Find the closest value in multidimensional arrays with ruby - arrays

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]]
Group the arrays by their first two elements
We are not interested in the keys, so we map to v
We want to find some sort of minimum
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.