位陣列 - 所有可能的組合

Question

我有0和1的數組。我需要一個返回'next'數組的函數。這樣的事情：

f([0,0,0,0]) -> [0,0,0,1] 
f([0,0,0,1]) -> [0,0,1,0] 
f([0,1,1,1]) -> [1,0,0,0] 

是否有任何庫函數或我需要自己編碼它？

Answer 1

紅寶石包括一個簡單的方法來二進制和底座之間轉換10

"0010".to_i(2) 
=> 2 

13.to_s(2) 
=> "1101" 

因此，一個簡單的方法做你需要的是

def f(a) 
    (a.join.to_i(2) + 1).to_s(2).split("").map{ |v| v.to_i } 
end 

這裏是添加兩個n位數字的方式。

def nbit_addition(a, b) 
    bit1 = toBits(a) 
    bit2 = toBits(b) 
    bitLength = bit1.length > bit2.length ? bit1.length : bit2.length 
    bit3 = [] 
    for i in 0...bitLength 
    bit1[i] = 0 if bit1[i].nil? 
    bit2[i] = 0 if bit2[i].nil? 
    bit3[i] = 0 if bit3[i].nil? 
    bit3[i] += (bit1[i] + bit2[i]) 
    if bit3[i] > 1 
     bit3[i + 1] = 0 if bit3[i + 1].nil? 
     bit3[i] %= 2 
     bit3[i + 1] += 1 
    end 
    end 
    bit3.join.to_s.reverse.to_i(2) 
end 

def toBits(value) 
    bit = [] 
    value.to_s(2).reverse.split(//).each { |b| bit << b.to_i } 
    return bit 
end 

Answer 2

這是相當簡單的一組位之間轉換爲數字：

[0,1,1,1].inject(0) { |number,bit| number * 2 + bit } 
=> 7 

這當然容易得到下一個數字：

7.succ 
=> 8 

...和它的容易將其變回位陣列：

8.to_s(2).chars.map(&:to_i) 
=> [1, 0, 0, 0] 

也就是說，如果你必須這樣做，你應該重新思考爲什麼你首先要有一些位。 8是一個比[1, 0, 0, 0]更合理的數字表示。

Answer 3

class Array 
    def binary_succ(lindex=nil) 
    lindex ||= size - 1  
    if lindex >= 0 
     if self[lindex] == 0 then self[lindex] = 1 
     else self[lindex] = 0; binary_succ(lindex-1) end 
    end 
    self 
    end 
end 

[0,1,1,1].binary_sucC#=> [1,0,0,0] 

Answer 4

我很無聊，所以這裏的。如果你想生成所有可能的組合（如標題所說），不涉及字符串化的陣列

def succ arr 
    overflow = false 
    rev = arr.reverse 
    rev[0] += 1 
    rev.map do |el| 
    el += 1 if overflow 
    case el 
    when 0, 1 
     overflow = false 
     el 
    when 2 
     overflow = true 
     0 
    end 
    end.reverse 
end 

succ [0,0,0,0] # => [0, 0, 0, 1] 
succ [0,0,0,1] # => [0, 0, 1, 0] 
succ [0,1,1,1] # => [1, 0, 0, 0] 

Answer 5

的解決方案，以及它們實際上是排列（重複）。

f = [0,1].repeated_permutation(4) 
16.times {p f.next} 

輸出：

[0, 0, 0, 0] 
[0, 0, 0, 1] 
[0, 0, 1, 0] 
[0, 0, 1, 1] 
[0, 1, 0, 0] 
[0, 1, 0, 1] 
[0, 1, 1, 0] 
[0, 1, 1, 1] 
[1, 0, 0, 0] 
[1, 0, 0, 1] 
[1, 0, 1, 0] 
[1, 0, 1, 1] 
[1, 1, 0, 0] 
[1, 1, 0, 1] 
[1, 1, 1, 0] 
[1, 1, 1, 1]