ruby - ビット配列-すべての可能な組み合わせ

Question

0と1の配列があります。そして、「次の」配列を返す関数が必要です。このようなもの：

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

Ruby には、2 進数と 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

これは、2 つの nbit 数を加算する方法です。

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

(タイトルが示すように) 可能なすべての組み合わせを生成したい場合、それらは実際には順列 (繰り返しあり) です。

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]

Answer 3

私は退屈だったので、配列を文字列化することを含まないソリューションがあります

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 4

ビット配列を数値に変換するのは非常に簡単です。

[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 5

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]