[英]Counting in binary ruby
我有兩個數組
[a0 b0 c0]
[a1 b1 c1]
我想計算兩者之間所有可能的和。 每個列插槽的可能總和僅包含1個元素。 例如,可能的總和是
a0 + b1 + c1
要么
a1 + b1 + c1
但不是a1 + a0 + b0 + c0
換句話說,示例中的總和將具有3個插槽,每個插槽只有兩個數組中的1個元素。 從我的角度來看,這似乎是二進制計數,其中每個插槽只能從兩個數字(0或1)中取1。 所以在這個例子中
000表示總和中的所有元素都來自第一個數組
sum(000) = a0 + b0 + c0.
sum(111) = a1 + b1 + c1
sum(010) = a0 + b1 + c0
你得到備忘錄。
我想知道如何在紅寶石中做到這一點。 我在考慮一個復雜的解決方案,我在二進制字符串中計數,並為每個計數從數組中“選擇”正確的元素。 由於我希望所有可能的組合(2 ^ n),我可以在一行中或接近一行的地方進行編碼嗎?
▶ a1 = [11,12,13]
#⇒ [11, 12, 13]
▶ b1 = [21,22,23]
#⇒ [21, 22, 23]
▶ a1.zip(b1).reduce(&:product).map(&:flatten)
#⇒ [[11, 12, 13], [11, 12, 23], [11, 22, 13], [11, 22, 23],
#⇒ [21, 12, 13], [21, 12, 23], [21, 22, 13], [21, 22, 23]]
▶ a1.zip(b1).reduce(&:product).map(&:flatten).map { |e| e.reduce &:+ }
#⇒ [36, 46, 46, 56, 46, 56, 56, 66]
UPD出於好奇,這是@pangpang用ruby編寫的解決方案:
[0,1].repeated_permutation([a1.length, a2.length].min).map do |bits|
bits.each_with_index.reduce(0) do |memo, (e, i)|
memo + (e.zero? ? a1[i] : a2[i])
end
end
arr1 = [0,0,0]
arr2 = [1,1,1]
(0..(2**arr1.length-1)).each do |i|
sum = 0
bina = "%0#{arr1.length}b" % i # convert int to binary
bina.split("").each_with_index do |e,i|
e.to_i == 0 ? sum += arr1[i] : sum += arr2[i]
end
puts "#{bina} and #{sum}"
end
輸出:
000 sum 0
001 sum 1
010 sum 1
011 sum 2
100 sum 1
101 sum 2
110 sum 2
111 sum 3
這是蠻力的方法。 我敢肯定,有一種方法可以用lambda做到這一點,但我的大腦在一天中的這個時候並不能這樣工作:
2.1.2 :003 > a=[1,2,3]
=> [1, 2, 3]
2.1.2 :005 > b=[4,5,6]
=> [4, 5, 6]
2.1.2 :006 > 1.downto(0) do |outer|
2.1.2 :007 > 1.downto(0) do |middle|
2.1.2 :008 > 1.downto(0) do |inner|
2.1.2 :009 > puts (outer==1 ? b[0] : a[0]) + (middle==1 ? b[1] : a[1]) + (inner==1 ? b[2] : a[2])
2.1.2 :010?> end
2.1.2 :011?> end
2.1.2 :012?> end
15
12
12
9
12
9
9
6
這是實現@pangpang答案的另一種方法。 我也試圖解釋這種方法的基本思想。
碼
def perm_sums(arr0, arr1)
sz = arr0.size
at = [arr0, arr1].transpose
(0...2**sz).map { |n| sz.times.reduce(0) { |t,i| t + at[i][n[i]] } }
end
例
arr0 = [1,2,3]
arr1 = [6,7,8]
perm_sums(arr0, arr1) #=> [6, 11, 11, 16, 11, 16, 16, 21]
說明
對於上面的示例:
sz = arr0.size #=> 3
at = [arr0, arr1].transpose #=> [[1, 6], [2, 7], [3, 8]]
當然,這與arr0.zip(arr1)
相同。
e0 = (0...2**sz).map #=> #<Enumerator: 0...8:map>
我們可以通過將此枚舉器轉換為數組來查看其元素:
e0.to_a #=> [0, 1, 2, 3, 4, 5, 6, 7]
e0
的第一個元素被傳遞到塊並分配給塊變量:
n = e0.next #=> 0
n=0
並不是那么有趣,因為它的二進制表示都是零位。 讓我們看一下n=3
:
n = e0.next #=> 1
n = e0.next #=> 2
n = e0.next #=> 3
e1 = sz.times #=> #<Enumerator: 3:times>
e1.to_a #=> [0, 1, 2]
塊計算使用Fixnum#[] 。 字符串顯示n=3
的二進制表示形式:
3.to_s(2).rjust(sz,'0') #=> "011"
3[i]
給出二進制值的第i個最高有效位:
3[0] #=> 1
3[1] #=> 1
3[2] #=> 0
塊計算按如下進行。 reduce
將塊變量t
設置為初始值0
,然后將e1
的三個元素分別傳遞給該塊:
t = 0
i = e1.next #=> 0
t + at[i][n[i]] #=> 0 + at[0][n[0]] => [1, 6][3[0]] => [1, 6][1] => 6
t = 6
i = e1.next #=> 1
t + at[i][n[i]] #=> 1 + at[1][3[1]] => 1 + [2,7][1] => 8
t = 8
i = e1.next #=> 2
t + at[i][n[i]] #=> 8 + at[2][n[2]] => 8 + [3,8][3[2]] => 8 + [3,8][0] => 11
i = e1.next
#=> StopIteration: iteration reached an end
因此,數字3
映射到11
。 其他計算類似地執行。
請注意,如果將at[i][n[i]]
替換at[i][n[sz-1-i]]
(即從高到低提取位),我們將得到相同的答案。
聲明:本站的技術帖子網頁,遵循CC BY-SA 4.0協議,如果您需要轉載,請注明本站網址或者原文地址。任何問題請咨詢:yoyou2525@163.com.