delete - Escribe una matriz de cadenas numéricas radix-2 en un archivo binario en Ruby

size en ruby

Question

He escrito un código Huffman simple en Ruby. Como salida tengo una matriz, por ejemplo:

["010", "1111", "10", "10", "110", "1110", "001", "110", "000", "10", "011"]

Necesito escribir, y luego leerlo desde y hacia un archivo. Probé varios métodos:

IO.binwrite("out.cake", array)

Obtengo un archivo de texto simple y no binario.

O:

File.open("out.cake", ''wb'' ) do |output|
  array.each do | byte |
       output.print byte.chr
  end
end

Parece que funciona, pero luego no puedo leerlo en una matriz.

¿Qué codificación debo usar?

Answer 1

Creo que puedes usar Array#pack y String#unpack como el siguiente código:

# Writing
a = ["010", "1111", "10", "10", "110", "1110", "001", "110", "000", "10", "011"]
File.open("out.cake", ''wb'' ) do |output|
  output.write [a.join].pack("B*")
end

# Reading
s = File.binread("out.cake")
bits = s.unpack("B*")[0] # "01011111010110111000111000010011"

No conozco su formato preferido para el resultado de la lectura y sé que el método anterior es ineficiente. Pero de todos modos, puede tomar "0" o "1" secuencialmente del resultado de unpack para atravesar su árbol Huffman.

Answer 2

Si desea bits, debe empaquetar y desempaquetar manualmente. Ni Ruby ni ningún otro lenguaje de uso común lo harán por ti.

Su matriz contiene cadenas que son grupos de caracteres, pero necesita crear una matriz de bytes y escribir esos bytes en el archivo.

De esto: ["010", "1111", "10", "10", "110", "1110", "001", "110", "000", "10", "011"]

debes construir estos bytes: 01011111 01011011 10001110 00010011

Ya que solo tiene cuatro bytes, puede colocarlos en un solo número de 32 bits 01011111010110111000111000010011 que es el hex 5F5B8E13 .

Ambas muestras de tu código hacen cosas diferentes. El primero escribe en el archivo una representación de cadena de una matriz Ruby. El segundo escribe 32 bytes donde cada uno es 48 (''0'') o 49 (''1'').

Si desea bits, entonces el tamaño del archivo de salida debe ser de sólo cuatro bytes.

Lea acerca de las operaciones de bits para aprender cómo lograrlo.

Aquí hay un borrador. No lo probé. Algo puede estar mal.

a = ["010", "1111", "10", "10", "110", "1110", "001", "110", "000", "10", "011"]

# Join all the characters together. Add 7 zeros to the end.
bit_sequence = a.join + "0" * 7  # "010111110101101110001110000100110000000"

# Split into 8-digit chunks.
chunks = bit_sequence.scan(/.{8}/)  # ["01011111", "01011011", "10001110", "00010011"]

# Convert every chunk into character with the corresponding code.
bytes = chunks.map { |chunk| chunk.to_i(2).chr }  # ["_", "[", "/x8E", "/x13"]

File.open("my_huffman.bin", ''wb'' ) do |output|
  bytes.each { |b| output.write b }
end

Nota: se agregan siete ceros para manejar el caso cuando el número total de caracteres no es divisible por 8. Sin esos ceros, bit_sequence.scan(/.{8}/) eliminará los caracteres restantes.