使用ruby在多维数组中找到最接近的值

Question

I need to find the closest values from a set multidimensional arrays, here is the example:

a = [[a,b,1,2,3],[a,b,5,6,7],[a,b,8,9,10],[c,d,1,2,9],[c,d,1,7,8]]

I want to search the value closest to 1.8 from the overall arrays that contain the same elements in the first 2 index. My expected result is this:

a = [[a,b,1,2,3],[c,d,1,2,9]]

Any ideas? Thanks!

Answer 1

a = [[:a, :b, 1, 2, 3], [:a, :b, 5, 6, 7], [:a, :b, 8, 9, 10], [:c, :d, 1, 2, 9], [:c, :d, 1, 7, 8]]

a.
  group_by {|a, b, *_| [a, b] }.
  map {|_k, v|
    v.min_by {|_, _, *nums|
      nums.map {|num| (1.8 - num).abs }.min }}
# => [[:a, :b, 1, 2, 3], [:c, :d, 1, 2, 9]]

1. Group the arrays by their first two elements
2. We are not interested in the keys, so we map to v
3. We want to find some sort of minimum
4. The criterion is: we want to find the array which contains the element which has the minimal absolute difference from 1.8 , so we only have to consider the minimal distance of the three

Answer 2

Assumption

In view of your comment, my understanding is that if:

a = [[:a, :b, 2], [:a, :b, 3], [:c, :d, 1], [:c, :d, 4]]

and the target value is 1.8 , the desired result is:

[[:a, :b, 2]]

and not:

[[:a, :b, 2], [:c, :d, 1]]

as the "closest value" is 2 and

[[:c, :d, 1], [:c, :d, 4]].flatten.include?(2) #=> false

(At the end, however, I offer a solution for the case where "closest "value" is to be obtained for every group of elements having the same first two elements.)

Code

If my assumption is correct, obtaining the desired result is simple:

def extract_closest(a, target)
  closest = a.flatten.
              select { |e| e.respond_to?(:abs) }.
              min_by { |e| (e.to_f-target).abs }
  a.select { |e| e.include?(closest) }.uniq { |e| e[0,2] }
end

Examples

target = 1.8

a1 = [[:a, :b, 1, 2, 3], [:a, :b, 5, 6, 7], [:a, :b, 8, 9, 2],
      [:c, :d, 1, 2, 9], [:c, :d, 1, 7, 8]]

(Notice that I've changed the last element of a1[2] from the example.)

extract_closest(a1, target)
  #=> [[:a, :b, 1, 2, 3], [:c, :d, 1, 2, 9]]

a2 = [[:a, :b, 1, 2, 3], [:a, :b, 5, 6, 7], [:a, :b, 8, 9, 2],
      [:c, :d, 1, 3, 9], [:c, :d, 1, 7, 8]]

extract_closest(a2, target)
  #=> [[:a, :b, 1, 2, 3]]

Explanation

For the first example above, the steps are as follows:

b = a1.flatten
  #=> [:a, :b, 1, 2, 3, :a, :b, 5, 6, 7, :a, :b, 8, 9, 10,
  #    :c, :d, 1, 2, 9, :c, :d, 1, 7, 8]
c = b.select { |e| e.respond_to?(:-) }
  #=> [1, 2, 3, 5, 6, 7, 8, 9, 10, 1, 2, 9, 1, 7, 8] 
closest = c.min_by { |e| (e.to_f-target).abs }
  #=> 2 

enum = a.select
  #=> #<Enumerator: [[:a, :b, 1, 2, 3], [:a, :b, 5, 6, 7],
  #     [:a, :b, 8, 9, 10], [:c, :d, 1, 2, 9], [:c, :d, 1, 7, 8]]
  #     :select> 
e = enum.next
  #=> [:a, :b, 1, 2, 3] 
e.include?(closest) 
  #=>   [:a, :b, 1, 2, 3].include?(2) => true

so [:a, :b, 1, 2, 3] is selected.

e = enum.next
  #=> [:a, :b, 5, 6, 7] 
e.include?(closest) 
  #=>   [:a, :b, 5, 6, 7].include?(2) #=> false

so [:a, :b, 5, 6, 7] is not select. The remaining elements of enum are processed similarly, resulting in a return value of:

f = [[:a, :b, 1, 2, 3], [:a, :b, 8, 9, 2], [:c, :d, 1, 2, 9]]

Lastly, we need only one of the first two elements of f , so:

f.uniq { |e| e[0,2] }
  #=> [[:a, :b, 1, 2, 3], [:c, :d, 1, 2, 9]] 

Alternative assumption

If a "closest "value" is to be obtained for every group of elements having the same first two elements. In addition, to respond to your comment, I'll permit any of the elements of each array to be any object:

def extract_closest(a, target)
  a.each_with_object({}) do |e,h|
    min_diff = e[2..-1].select { |n| n.respond_to?(:abs) }.
                        map { |n| (n.to_f-target).abs }.min
    h.update(e[0,2]=>[min_diff, e]) do |_,(omin,oe),(nmin,ne)|
      (nmin < omin) ? [nmin, ne] : [omin, oe]
    end
  end.values.map(&:last)
end

target = 1.8

a3 = [[:a, :b, 1, 2, :c], [:a, :b, 5, "c", 7], [:a, :b, 8, 9, [1,2]],
      [:c, :d, 1, 3, {e: 1.8}], [:c, :d, 1, 7, "8"]]

extract_closest(a3, target)
  #=> [[:a, :b, 1, 2, :c], [:c, :d, 1, 3, {:e=>1.8}]]

This uses the form of Hash#update (aka merge! ) that uses a block to determine the value of keys that are present in both hashes being merged.

Explanation for alternative assumption

For the example given:

enum0 = a3.each_with_object({})
  #=> #<Enumerator: [[:a, :b, 1, 2, :c], [:a, :b, 5, "c", 7],
  #     [:a, :b, 8, 9, [1, 2]], [:c, :d, 1, 3, {:e=>1.8}],
  #     [:c, :d, 1, 7, "8"]]:each_with_object({})> 
e,h = enum0.next
  #=> [[:a, :b, 1, 2, :c], {}] 
e #=> [:a, :b, 1, 2, :c] 
h #=> {} 
b = e[2..-1].select { |n| n.respond_to?(:abs) }
  #=> [1, 2] 
c = b.map { |n| (n.to_f-target).abs }
  #=> [0.8, 0.2]
min_diff = c.min
  #=> 0.2
h.update(e[0,2]=>[min_diff, e]) do |_,(omin,oe),(nmin,ne)|
  (nmin < omin) ? [nmin, ne] : [omin, oe]
end
  #=> {}.update([:a, :b]=>[0.2, [:a, :b, 1, 2, :c]])
  #=> {[:a, :b]=>[0.2, [:a, :b, 1, 2, :c]]}

as {} does not contain the key [:a, :b] , update 's block is not called upon. Note that update returns the updated value of h .

e,h = enum0.next
  #=> [[:a, :b, 5, "c", 7],
  #    {[:a, :b]=>[0.2, [:a, :b, 1, 2, :c]]}] 
b = e[2..-1].select { |n| n.respond_to?(:abs) }
  #=> [5, 7] 
c = b.map { |n| (n.to_f-target).abs }
  #=> [3.2, 5.2] 
min_diff = c.min
  #=> 3.2 
h.update(e[0,2]=>[min_diff, e]) do |_,(omin,oe),(nmin,ne)|
  (nmin < omin) ? [nmin, ne] : [omin, oe]
end

update first considers:

h.update(e[0,2]=>[min_diff, e])
  #=> {[:a, :b]=>[0.2, [:a, :b, 1, 2, :c]]}.
  #     update([:a, :b]=> [3.2, [:a, :b, 5, "c", 7]])

As both hashes being merged are found to have the key [:a, :b] , update 's block is called upon to determine the value of that key in the merged hash:

  # do |_,(0.2, [:a, :b, 1, 2, :c]), (3.2, [:a, :b, 5, "c", 7])|
  #    (3.2 < 0.2) ? [3.2, [:a, :b, 5, "c", 7]] : [0.2, [:a, :b, 1, 2, :c]]
  # end

As 3.2 < 0.2 #=> false , the block returns:

[0.2, [:a, :b, 1, 2, :c]]

for the value of the key [:a, :b] ; that is, the value is unchanged.

The remaining calculations are similar.