koralines - ¿Cómo convertir una cadena o un entero a binario en Ruby?

ruby encode

Question

¿Cómo se crean los enteros 0..9 y los operadores matemáticos + - * / in en cadenas binarias? Por ejemplo:

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

¿Hay alguna manera de hacer esto con Ruby 1.8.6 sin usar una biblioteca?

Answer 1

Hice una pregunta similar . En base a la respuesta de @sawa , la manera más sucinta de representar un entero en una cadena en formato binario es usar el formateador de cadenas:

"%b" % 245
=> "11110101"

También puede elegir la duración de la representación de cadena, que podría ser útil si desea comparar números binarios de ancho fijo:

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

Answer 2

Naturalmente, utilizaría Integer#to_s(2) , String#to_i(2) o "%b" en un programa real, pero, si le interesa cómo funciona la traducción, este método calcula la representación binaria de un entero dado. utilizando operadores básicos:

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

Para verificarlo funciona:

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

Answer 3

Si está buscando una clase / método de Ruby lo usé, y también he incluido las pruebas:

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

Answer 4

Si solo está trabajando con los dígitos únicos 0-9, es probable que sea más rápido crear una tabla de búsqueda para que no tenga que llamar a las funciones de conversión todo el tiempo.

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"

La indexación en esta tabla hash que usa la representación entera o de cadena de un número producirá su representación binaria como una cadena.

Si necesita que las cadenas binarias tengan un cierto número de dígitos (mantenga los ceros a la izquierda), cambie x.to_s(2) a sprintf "%04b", x (donde 4 es el número mínimo de dígitos para usar).

Answer 5

Tiene Integer#to_s(base) y String#to_i(base) disponibles para usted.

Integer#to_s(base) convierte un número decimal en una cadena que representa el número en la base especificada:

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

mientras que el reverso se obtiene con String#to_i(base) :

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

Answer 6

Tomando como punto de partida la idea de la tabla de búsqueda de bta, puede crear la tabla de búsqueda con un bloque. Los valores se generan cuando se acceden por primera vez y se almacenan para más adelante:

>> 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"}