Creating a hash where the keys are strings, values are numbers

Question

I have an array:

["Melanie", "149", "Joe", "2", "16", "216", "Sarah"]

I want to create a hash:

{"Melanie"=>[149], "Joe"=>[2, 16, 216] "Sarah"=>nil}

How would I accomplish this when the keys and values are in the same array?

All values would be integers (although they are in string form in the array.) All keys start and end with a letter.

Answer 1

Your expected hash is invalid. Therefore, it is impossible to get what you wrote that you want.

From your issue, it looks reasonable to expect the values to be array. In that case, you can do it like this:

["Melanie", "149", "Joe", "2", "16", "216", "Sarah"]
.slice_before(/[a-z]/i).map{|k, *v| [k, v.map(&:to_i)]}.to_h
# => {"Melanie"=>[149], "Joe"=>[2, 16, 216], "Sarah"=>[]}

With little modification, you can let the value be a number instead of an array when the array length is one, but that is not a good design; it would introduce exceptions.

Answer 2

Try this

def numeric?(x) 
 x.chars.all? { |y| ('0'..'9').include?(y) }
end

array = ["Melanie", "149", "Joe", "2", "16", "216", "Sarah"]
keys = array.select { |x| not numeric?(x) }

map = {}
keys.each do |k|
    from = array.index(k) + 1
    to = array.index( keys[keys.index(k) + 1] )
    map[k] = to ? array[from...to] : array[from..from]
end

p map

Output:

{"Melanie"=>["149"], "Joe"=>["2", "16", "216"], "Sarah"=>[]}
[Finished in 0.1s]

Answer 3

Here's another way:

arr = ["Melanie", "149", "Joe", "2", "16", "216", "Sarah"]

class String
  def integer?
    !!(self =~ /^-?\d+$/)
  end
end

Hash[*arr.each_with_object([]) { |s,a| s.integer? ? a[-1] << s.to_i : a<<s<<[] }].
  tap { |h| h.each_key { |k| h[k] = nil if h[k].empty? } }
  #=> {"Melanie"=>[149], "Joe"=>[2, 16, 216], "Sarah"=>nil}  

Answer 4

There are three components to your question, and I will try to answer them separately.

Regarding storing a multi-valued mapping, while there are specialized solutions available, the most common recommendation is just to store a hash whose values are arrays. That is, for your use case, your primary data structure is a hash whose keys are strings and whose values are arrays of integers. Depending on your desired behavior for duplicates etc., etc, you may wish to substitute a different data structure for the value structure, possibly a set.

Regarding identifying strings containing numbers and strings not containing numbers, well, that depends on exactly what your non-number-containing strings could instead contain, but a good starting point would be to perform a regular expression match for digits. You didn't specify whether your allowable numeric strings represented integers, floating points, etc. The particular answer to that may affect your overall strategy. Unfortunately, input parsing and validation is a complex and messy topic in the general case.

Regarding the actual conversion process, I would recommend the following strategy. Iterate through your input array. Check each string for whether it is numeric or non-numeric. If it is non-numeric, store that as the current key in a local. Also, in your hash, create a mapping from that key to a new empty array. If, instead, the string is numeric, convert it into a number, and add it to the array under the appropriate key.

Answer 5

I don't know if there's a pretty way to do it. I'd do something like this:

def numeric?(string)
  # `!!` converts parsed number to `true`
  !!Kernel.Float(string) 
rescue TypeError, ArgumentError
  false
end

def my_method(input_array)
  # associate values with proper key and stores result in output
  curr_key = nil
  output = {}
  input_array.each do |e|
    if !numeric?(e)
      output[e] = []
      curr_key = e
    else 
      # use Float if values may be floating-point
      output[curr_key] << Integer(e, 10)
    end
  end

  output.each do |k, v|
      output[k] = v.empty? ? nil : v
  end

  output
end

Source for numeric method.