Come convertire una stringa o un numero intero in binario in Ruby?

Come si creano gli interi 0..9 e gli operatori matematici + - * / in nelle stringhe binarie. Per esempio:

 0 = 0000,
 1 = 0001, 
 ...
 9 = 1001

C'è un modo per farlo con Ruby 1.8.6 senza usare una libreria?

Hai Integer#to_s(base)e String#to_i(base)disponibile per te.

Integer#to_s(base) converte un numero decimale in una stringa che rappresenta il numero nella base specificata:

9.to_s(2) #=> "1001"

mentre il contrario si ottiene con String#to_i(base):

"1001".to_i(2) #=> 9

Ho fatto una domanda simile . Basato sulla risposta di @sawa , il modo più breve per rappresentare un numero intero in una stringa in formato binario è usare il formattatore di stringhe:

"%b" % 245
=> "11110101"

Puoi anche scegliere la lunghezza della rappresentazione della stringa, che potrebbe essere utile se desideri confrontare numeri binari a larghezza fissa:

1.upto(10).each { |n| puts "%04b" % n }
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010

Raccogliendo l'idea della tabella di ricerca di bta, puoi creare la tabella di ricerca con un blocco. I valori vengono generati al primo accesso e memorizzati per dopo:

>> lookup_table = Hash.new { |h, i| h[i] = i.to_s(2) }
=> {}
>> lookup_table[1]
=> "1"
>> lookup_table[2]
=> "10"
>> lookup_table[20]
=> "10100"
>> lookup_table[200]
=> "11001000"
>> lookup_table
=> {1=>"1", 200=>"11001000", 2=>"10", 20=>"10100"}

Utilizzeresti naturalmente Integer#to_s(2), String#to_i(2)o "%b"in un vero programma, ma, se sei interessato a come funziona la traduzione, questo metodo calcola la rappresentazione binaria di un dato intero usando operatori di base:

def int_to_binary(x)
  p = 0
  two_p = 0
  output = ""

  while two_p * 2 <= x do
    two_p = 2 ** p
    output << ((two_p & x == two_p) ? "1" : "0")
    p += 1
  end

  #Reverse output to match the endianness of %b
  output.reverse
end

Per verificare che funzioni:

1.upto(1000) do |n|
  built_in, custom = ("%b" % n), int_to_binary(n)
  if built_in != custom
    puts "I expected #{built_in} but got #{custom}!"
    exit 1
  end
  puts custom
end

Se lavori solo con le singole cifre 0-9, è probabilmente più veloce creare una tabella di ricerca in modo da non dover chiamare le funzioni di conversione ogni volta.

lookup_table = Hash.new
(0..9).each {|x|
    lookup_table[x] = x.to_s(2)
    lookup_table[x.to_s] = x.to_s(2)
}
lookup_table[5]
=> "101"
lookup_table["8"]
=> "1000"

L'indicizzazione in questa tabella hash usando la rappresentazione di numeri interi o di stringhe di un numero produrrà la sua rappresentazione binaria come stringa.

Se si richiede che le stringhe binarie siano lunghe un determinato numero di cifre (mantenere gli zero iniziali), passare x.to_s(2)a sprintf "%04b", x(dove 4è il numero minimo di cifre da utilizzare).

Se stai cercando un metodo / classe Ruby, ho usato questo e ho incluso anche i test:

class Binary
  def self.binary_to_decimal(binary)
    binary_array = binary.to_s.chars.map(&:to_i)
    total = 0

    binary_array.each_with_index do |n, i|
      total += 2 ** (binary_array.length-i-1) * n
    end
    total
   end
end

class BinaryTest < Test::Unit::TestCase
  def test_1
   test1 = Binary.binary_to_decimal(0001)
   assert_equal 1, test1
  end

 def test_8
    test8 = Binary.binary_to_decimal(1000)
    assert_equal 8, test8
 end

 def test_15
    test15 = Binary.binary_to_decimal(1111)
    assert_equal 15, test15
 end

 def test_12341
    test12341 = Binary.binary_to_decimal(11000000110101)
    assert_equal 12341, test12341
 end
end