Monochrome Bitmaps

Краен срок
15.12.2012 12:00

Срокът за предаване на решения е отминал

Monochrome Bitmaps

Нека упражним малко елементарна битова аритметика.

Ще дефинираме монохромна битова карта като правоъгълна двоична матрица. Ще считаме, че където в матрицата стои цифрата едно, имаме запълнено квадратче (например черно), докато на мястото на нулите ще считаме, че стои празно квадратче (например бяло). Като допълнително ограничение ще имаме изискването броя колони на въпросната матрица да е число, кратно на осем.

Ще дефинираме текстуално представяне на въпросните битови карти, като заместим единиците със символа диез (#), а нулите с точка (.). Така например, следната монохромна битова карта:

10010000
00101000

Ще има следното представяне в текстов вид:

#..#....
..#.#...

За числово представяне на монохромна битова карта ще считаме списък от числа между 0 и 255 (байтове), опционално асоцииран с още едно число, указващо броя байтове в един ред от битовата карта. Например, списъкът [1, 10, 100], асоцииран с числото 3, представлява валидна битова карта с три байта на ред. Тъй като всеки байт съдържа осем бита, това означава, че битовата карта ще има 3 * 8 = 24 бита (квадратчета) на ред и ще бъде фактически едноредова. Нейното текстуално представяне можем да получим като обърнем всеки от байтовете в списъка в неговото битово представяне и заменим единиците и нулите от това побитово представяне според правилата по-горе. За конкретния пример, то ще изглежда така:

.......#....#.#..##..#..

От вас се иска да напишете клас Bitmap, чиито конструктор приема един задължителен аргумент — списъка с байтове и един опционален аргумент — броя байтове на ред. Ако опционалният аргумент не бъде подаден, ще се подразбира, че матрицата е едноредова, тоест, че на един ред имаме толкова байта, колкото са подадени в списъка.

Класът Bitmap трябва да има един метод to_s, който да връща текстуалното представяне на въпросната матрица. "Квадратчетата" са залепени едно за друго, както в примерите, а редовете са съединени със символ за нов ред ("\n"). След последния ред няма символ за нов ред.

За примера по-горе ще имаме:

bitmap = Bitmap.new [1, 10, 100], 3
bitmap.to_s # => ".......#....#.#..##..#.."

Считайте, че в списъка с числа ще са ви подадени винаги валидни байтове (между 0 и 255) и че броят елементи в него ще е винаги кратен на опционалния аргумент, когато такъв е подаден. Тоест, няма да ви подадем списък с три елемента и да искаме да рендерирате битова карта с по два байта на ред.

Решения

Димитър Димитров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Димитър Димитров
class Bitmap
def initialize(bytes, bytes_per_row = bytes.size)
@bytes, @bytes_per_row = bytes, bytes_per_row
end
def to_s
@bytes.each_slice(@bytes_per_row).map do |bytes|
bytes.map { |byte| render_byte(byte) }.join('')
end.join("\n")
end
private
def render_byte(byte)
7.downto(0).map { |bit| byte[bit] == 1 ? '#' : '.' }.join('')
end
end
Станислав Гатев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Станислав Гатев
class Bitmap
def initialize(numbers, bytes_per_line=numbers.length)
@bytes, @bytes_per_line = numbers.map { |n| "%08b" % n }, bytes_per_line
@bitmap = { '0' => '.', '1' => '#' }
end
def to_s
@bytes.each_slice(@bytes_per_line).map { |n| n.join.gsub(/[01]/, @bitmap) }.join "\n"
end
end
Николай Димитров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Николай Димитров
class Bitmap
def initialize(list, bytes = 0)
@list, @bytes = list, bytes
@bytes = @list.length if @bytes == 0
end
def to_s
@list.map { |byte| byte.to_s(2).rjust( 8, '0') }.
map { |byte| byte.gsub(/./, '0' => '.', '1' => '#') }.
each_slice(@bytes).map { |slice| slice.join('') }.join("\n")
end
end
Мартин Попов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мартин Попов
class Bitmap
def initialize bytes, bytes_in_a_row = bytes.count
@byte_table = bytes.map {|byte| byte.to_s(2).rjust(8,'0')}.
each_slice(bytes_in_a_row).
map{|row| row.join}.
join("\n")
end
def to_s
@byte_table.gsub(/[01]/, {'1' => '#', '0' => '.'} )
end
end
Йордан Петров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йордан Петров
class Bitmap
def initialize(list, number = list.size)
@list = list.map do |integer|
'0' * (8 - integer.to_s(2).length) + integer.to_s(2)
end
@number = number
end
def to_s
@list.each_slice(@number).to_a.map do |line|
line.join.gsub(/0/, '.').gsub(/1/, '#')
end.join("\n")
end
end
Филарета Йорданова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Филарета Йорданова
class Bitmap
attr_accessor :array, :count
def initialize(array,count = array.size)
@array = array.each_slice(count)
@count = count
end
def to_bitmap(item)
bitmap = []
1.upto(8) do |i|
item % 2 == 0 ? bitmap << '.' : bitmap << '#'
item /= 2
end
bitmap.reverse
end
def to_s
array.map { |item| item.map { |i| to_bitmap i }.join }.join("\n")
end
end
Стоян Стоянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Стоянов
class Integer
def to_hash_and_dot
string_length = to_s(2).length
if string_length < 8
("0" * (8 - string_length) + to_s(2)).gsub(/1/,'#').gsub(/0/,'.')
else
to_s(2).gsub(/1/,'#').gsub(/0/,'.')
end
end
end
class Bitmap
def initialize(number_list, bytes_on_row = 1)
@number_list = number_list
@bytes_on_row = bytes_on_row
end
def to_s
to_hash_and_dot.each_slice(@bytes_on_row) { |s| p s.join}
end
private
def to_hash_and_dot
@number_list.map { |e| e.to_hash_and_dot }
end
end
Кирчо Кирев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Кирчо Кирев
class Bitmap
def initialize(bytes, bytes_per_row = 0)
@bytes = bytes
@bits_per_row = bytes_per_row * 8
end
def to_s
result = @bytes.inject("") do |string, byte|
bits = byte.to_s(2).gsub /./, '1' => '#', '0' => '.'
bits.insert 0, '.' * (8 - bits.length)
string << bits
end
@bits_per_row != 0 ? format_table(result) : result
end
private
def format_table(string)
result = string[0, @bits_per_row]
string.chars.drop(@bits_per_row).each_slice(@bits_per_row) do |row|
result << "\n" << row.join
end
result
end
end
Милан Миланов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Милан Миланов
class Bitmap
def initialize(bytes, bytes_per_row = bytes.size)
@bytes, @bytes_per_row = bytes, bytes_per_row
end
def to_s
@bytes.map { |number| number.to_s(2).rjust(8, "0").tr("01", ".#") }.each_slice(@bytes_per_row).map { |row| row.join }.join("\n")
end
end
Тихомир Янев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Тихомир Янев
class Bitmap
MAX_SIZE = 8
PATTERN = { '0' => '.', '1' => '#' }
def initialize (list, bits_per_row = 1)
@bits_per_row = bits_per_row
@array_bitmap = list.map { |item| to_binary(item) }
end
def to_s
output = ''
@array_bitmap.each_slice(@bits_per_row) { |line| output << "#{line.join.gsub(/[01]/, PATTERN)}\n"}
output[0..-2]
end
private
def to_binary(number)
bin_number = number.to_s(2)
(MAX_SIZE - bin_number.size).times { bin_number.prepend '0' }
bin_number
end
end
Александър Иванов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов
class Bitmap
def initialize(values, bytes_on_row = values.length)
@values = values.each_slice(bytes_on_row).to_a
end
def to_s
@values.map do |row|
row.map { |byte| byte_to_s(byte) }.join
end.join("\n")
end
private
def byte_to_s(byte)
byte.to_s(2).rjust(8, '0').gsub('1', '#').gsub('0', '.')
end
end
Иван Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Иван Георгиев
class Bitmap
def initialize(bytes, bytes_per_row = bytes.size)
@bytes = bytes
@bytes_per_row = bytes_per_row
end
def replace(letter)
case letter
when "0" then "."
when "1" then "#"
else letter
end
end
def to_s
table = ""
@bytes.map { |byte| byte.to_s(2).rjust(8, "0") }.join("").split("").each_slice(8 * @bytes_per_row) do |row|
table = table + row.join("") + "\n"
end
table.split("").map { |letter| replace(letter) }.join("").chomp
end
end
Орлин Христов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Орлин Христов
class Bitmap
def initialize(words, width=1)
@words = words.map { |word| ('%08b' % word).tr '01', '.#' }
@width = width
end
def to_s
@words.each_slice(@width).map { |line| line.join }.join '\n'
end
end
Ангел Николов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Ангел Николов
class Bitmap
def initialize(bytes, bytes_per_line = bytes.count)
@bitmap = bytes.map { |byte| byte.to_s(2).rjust(8, '0') }.
each_slice(bytes_per_line).map &:join
end
def to_s
@bitmap.join("\n").gsub /[01]/, '0' => '.', '1' => '#'
end
end
Цвета Гергичанова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Цвета Гергичанова
class Bitmap
def initialize(array, size = array.size)
@array, @line = array.map { |item| "0"*(8-(item.to_s(2)).size) + item.to_s(2) }, size
end
def to_s
array = @array.map do |item|
0.upto(7).each { |index| item[index] = item[index] == "0" ? "." : "#" }
item
end
string = array.inject(:+)
index = 0
result = ""
while index < string.size
result += string[index...(index + @line*8)] + "\n"
index = index + @line*8
end
result.chomp
end
end
Михаил Жеков
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Михаил Жеков
class Bitmap
def initialize bytearray, bpr = nil
@bytearray = bytearray
if bpr
@bpr = bpr
else
@bpr = @bytearray.length
end
end
def to_s
x = @bytearray.inject(""){ |acc, number| acc+("%08d" % number.to_s(2)).split('').map{ |e| e.to_i }.join("").gsub('0', '.').gsub('1', '#') }
puts x.scan(/.{#{(@bpr * 8)}}|.+/).join("\n")
end
end
Виктория Христова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Виктория Христова
class Bitmap
attr_accessor :bytes, :number
def initialize(bytes, number)
@bytes, @number = bytes, number
end
def convert(num)
(0..7).map { |n| num[7-n] == 1 ? "#" : "." }.join
end
def to_s
bytes.each_slice(number).map do |array|
array.map { |num| convert(num) }.join
end.join("\n")
end
end
Явор Лилянов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Явор Лилянов
class Bitmap
def initialize(list, bytes_each_row = 1)
@bitmap = []
list.map { |number| number.to_s(2) }.map do |byte|
while byte.size < 8
byte.insert(0, "0")
end
byte
end.each_slice(bytes_each_row).each { |row| @bitmap << row.inject(:+) }
end
def to_s
text = ""
@bitmap.each do |row|
text += row.gsub(/1/) { "#" }.gsub(/0/) { "." } + "\n"
end
text.chop
end
end
Даяна Беркова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Даяна Беркова
class Bitmap
def initialize(byte_list, bytes_per_row = byte_list.count)
@byte_list, @bytes_per_row = byte_list, bytes_per_row
end
def to_s
@byte_list.map! do |byte|
byte = byte.to_s(2).rjust(8, '0')
byte.gsub!(/[01]/, '0' => '.', '1' => '#')
end
@byte_list = @byte_list.each_slice(@bytes_per_row)
@byte_list.map { |byte| byte.join }.join("\n")
end
end
Христо Хърсев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Христо Хърсев
class Bitmap
attr_accessor :bit_map, :bytes_per_row
def initialize bit_map, bytes_per_row = 1
@bytes_per_row = bytes_per_row
@bit_map = []
bit_map.each { |x| @bit_map << x.to_s(2) }
@bit_map.each { |x| x[0,0] = "0" * (8-x.size) }
end
def to_s
result = @bit_map.join.to_s
result.gsub!("0", "."); result.gsub!("1", "#")
result.chars.each_slice(8*@bytes_per_row).map(&:join).join("\n")
end
end
Чанита Иванова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Чанита Иванова
class Bitmap
attr_accessor :array, :size
def initialize(array,size=array.length)
@array = []
array.map{|x| @array << x.to_s(2)}
@size = size * 8
end
def element_to_s(element)
result = ""
1.upto(8 - element.length){ result<<"."}
element.each_char{ |c|
if(c == '0') then result << "."
else result << "#"
end
}
result
end
def to_s
result = ""
length = size
array.map{ |x|
if(length == 0)then
result << "\n"
length = size
end
current_string = element_to_s(x)
result << current_string
length -= current_string.length
}
result
end
end
Нели Хатева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Нели Хатева
class Bitmap
def initialize(array_of_bytes, bytes_in_row = 1)
@array_of_bytes, @bytes_in_row = array_of_bytes, bytes_in_row
@bit_representation, @text_representation = "", ""
end
def to_s
to_bit_representation
to_text_representation
insert_new_lines
@text_representation
end
def to_bit_representation
@array_of_bytes.each do |byte|
@bit_representation << "0" * ( 8 - byte.to_s(2).length) + byte.to_s(2)
end
end
def to_text_representation
@bit_representation.each_char do |character|
if character == "1" then @text_representation << "#"
else @text_representation << "."
end
end
end
def insert_new_lines
(1...@array_of_bytes.length / @bytes_in_row).each do |position|
@text_representation.insert(position * 8 * @bytes_in_row + position - 1, "\n")
end
end
end
Елена Денева
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Елена Денева
class Bitmap
attr_accessor :bytes, :lines
def initialize bytes, lines = bytes.length
@lines = lines
@bytes = bytes.map {|x| bits(x)}
end
def to_s
arr = ""
bytes.each_slice(lines) { |slice| arr << (slice.join() + "\n") }
arr
end
private
def bits num
arr = []
0.upto(7) do |i|
num & 1 << 7-i == 0 ? arr << '.' : arr << '#'
end
arr
end
end
Свилен Андонов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Свилен Андонов
class Bitmap
attr_accessor :value , :row
def initialize value, row = 1
@value = value
@row = row
end
def to_s
result = ""
@value.each_with_index do |val,pos|
temp = ""
(0..7).each do |i|
temp << "#" if (1<<i) & val != 0
temp << "." if (1<<i) & val == 0
end
result << temp.reverse
result << "\n" if (pos+1) % @row == 0 && pos + 1 < @value.length
end
result
end
end
Пламен Тотев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Пламен Тотев
class Bitmap
def initialize(bits_list, bytes_per_line = nil)
@bitmap = bits_list
@line_length = bytes_per_line ||= bits_list.size
end
def to_s
bitmap_string = @bitmap.each_slice(@line_length).reduce('') { |bitmap, line| bitmap += line_to_string(line) }
bitmap_string.chomp "\n"
end
private
def line_to_string(line)
line_as_string = line.reduce('') { |string, byte| string += byte_as_string(byte) }
line_as_string + "\n";
end
def byte_as_string(byte)
7.downto(0).reduce('') { |string, n| string += byte[n] == 1 ? '#' : '.' }
end
end
Георги Гърдев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Гърдев
class Bitmap
def initialize(bytes, rows = 1)
@bytes, @rows = bytes, rows
end
def to_s
@bytes.map{ |x| to_bits x }.each_slice(@rows).map(&:join).join("\n")
end
private
def to_bits(byte)
result = byte.to_s(2).chars.map{ |x| x == "1" ? "#" : "." }.join
result.prepend "." * (8 - result.length)
end
end
Атанас Пройчев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Атанас Пройчев
class Bitmap
def initialize(bytes, bytes_per_line = 1)
@bytes = bytes.map{ |b| "%08d" % b.to_s(2) }
@bytes_per_line = bytes_per_line
end
def to_s
result = ""
@bytes.take(@bytes_per_line).each do |item|
#@bytes.each do |item|
result += item.gsub(/[01]/, '0' => '.', '1' => '#') + "\n"
end
result.chomp
end
end
Никола Таушанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Никола Таушанов
class Bitmap
def initialize(numbers, columns)
@numbers, @columns = numbers, columns
end
def to_s
@numbers.each_slice(@columns).map { |x| arr_to_bitmap(x) }.join "\n"
end
def arr_to_bitmap(arr)
arr.map { |x| x.to_s(2).rjust(8, '.').gsub('1', '#').gsub('0', '.') }.join
end
end
Стоян Найденов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Стоян Найденов
class Bitmap
def initialize(list, line_size = list.length)
@list, @line_size = list, line_size
end
def to_s
monochrome_list = @list.map { |number| number.to_s(2).gsub('0', '.').gsub('1','#').rjust(8,'.') }
monochrome_list.each_slice(@line_size).map{ |slice| slice.join() }.join("\n")
end
end
Петър Костов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Петър Костов
class Bitmap
def initialize(bytes, row_length = bytes.length)
@bytes = bytes.map { |byte| byte.to_s(2).rjust(8, '0') }.join
@row_length = row_length * 8
end
def to_s
@bytes.gsub('0', '.').gsub('1', '#').scan(Regexp.new '.' * @row_length).join "\n"
end
end
Румен Палетов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Румен Палетов
class Bitmap
def initialize(array, row_length = array.size)
@array = array
@row_length = row_length * 8
end
def to_s
to_rows(@array.map { |i| to_byte(i).chars.map { |b| to_symbol(b) }.join }.join)
end
private
def to_rows(string)
string.chars.each_slice(@row_length).map(&:join).join("\n")
end
def to_byte(number)
(number + (1 << 8)).to_s(2)[1, 8]
end
def to_symbol(bit)
if bit == '1' then '#'
else '.'
end
end
end
Александър Иванов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Александър Иванов
class Bitmap
def initialize(integers, rows = 1)
binaries = integers.map { |int| '%08d' % int.to_s(2) }
columns = binaries.size / rows
@matrix = []
0.upto(rows - 1) { |row| @matrix[row] = binaries.shift(columns) }
end
def to_s
@matrix.map { |row| row.join.tr('10', '#.') }.join("\n")
end
end
Светлана Величкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Светлана Величкова
class Bitmap
attr_accessor :array, :count, :bitmap
def initialize(array, count = 1)
@array = array
@count = count
@bitmap = ''
end
def to_s
array.each do |x|
@bitmap << x.to_s(2).rjust(8, '.').gsub('1','#').gsub('0','.')
end
1.upto(array.length / count) { |i| bitmap.insert(i * 8 + i - 1, "\n") }
bitmap.chomp!
end
end
Илиян Бобев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Илиян Бобев
class Bitmap
def initialize (bytelist, row_size = nil)
@bytelist = bytelist
row_size ||= bytelist.size
@row_size = row_size
end
def to_s
string_map = ['.','#'].repeated_permutation(8).collect { |byte| byte.join }
z = @bytelist.each_slice(@row_size).collect { |line| line.collect { |byte| string_map[byte] }.join }.join("\n")
end
end
Кирил Владимиров
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Кирил Владимиров
class Bitmap
def initialize(bytes, bytes_per_row=false)
@bytes = bytes
@bytes_per_row = bytes_per_row ? bytes_per_row : bytes.length
end
def to_s
bits = @bytes.map do |byte|
byte.to_s(2).rjust(8, '.').gsub('0', '.').gsub('1', '#')
end
result = []
bits.each_slice(@bytes_per_row) { |row| result.push row.join }
result.join("\n")
end
end
Йордан Стефанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Йордан Стефанов
class Bitmap
def initialize byte_array, row_length = nil
@row_length = row_length ? row_length : byte_array.length
@data = byte_array
end
def to_s
@data.map { |byte| byte.to_s( 2 ).rjust( 8, '0' ).gsub( /./, {'1' => '#', '0' => '.'} ) }
.each_slice( @row_length )
.reduce('') { |data_as_string, row| data_as_string + row.reduce( &:+ ) + "\n" }
.rstrip
end
end
Изабела Недялкова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Изабела Недялкова
class Bitmap
def initialize(bytes, bytes_in_row = bytes.size)
@bits_in_row = bytes_in_row * 8
@bytes = bytes.map { |byte| byte.to_s(2).rjust(8, '0') }
end
def to_s
@bytes.join.gsub(/[10]/, '1' => '#', '0' => '.').scan(/.{1,#{@bits_in_row}}/).join("\n")
end
end
Емил Гоцев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Емил Гоцев
class Bitmap
def initialize(array, bytes_per_row = nil)
@bytes_per_row = bytes_per_row || array.length
@array_of_numbers = array.map { |number| number.to_s(2).rjust(8, "0") }
end
def to_s
@bitmap ||= construct
@bitmap.join "\n"
end
private
def construct
bitmap = []
@array_of_numbers.each_slice(@bytes_per_row) do |slice|
bitmap << slice.join.gsub(/[01]/, '1' => '#', '0' => '.')
end
bitmap
end
end
Радослав Върбанов
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Радослав Върбанов
class Bitmap
def initialize(bytelist, bytes_per_row = -1)
@bytelist = bytelist
@bytes_per_row = bytes_per_row
end
def to_s
byte_counter, result_string = 0, ""
@bytelist.each do |byte|
if @bytes_per_row == -1 || byte_counter < @bytes_per_row
result_string += complete_byte(convert_to_bitmap(byte))
byte_counter += 1
else
result_string += "\n" + complete_byte(convert_to_bitmap(byte))
byte_counter = 1
end
end
puts result_string
end
private
def convert_to_bitmap(byte)
bitmap = ""
while byte >= 1
bitmap = (byte.remainder(2) == 1 ? "#" : ".") + bitmap
byte = byte / 2
end
bitmap
end
def complete_byte(half_byte)
while half_byte.length < 8
half_byte = "." + half_byte
end
half_byte
end
end
Георги Георгиев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Георги Георгиев
class Bitmap
def initialize(byte_list, row_size = byte_list.size)
@matrix = Bitmap.binarize byte_list.each_slice(row_size).to_a
end
def to_s
@matrix.map { |row| row.join }.join("\n").gsub(/./, '1' => '#', '0' => '.')
end
def self.binarize(matrix)
matrix.map { |row| row.map { |number| number.to_s(2).rjust(8, '0').split('') } }
end
end
Мирослав Крамолински
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Мирослав Крамолински
class Bitmap
def initialize(bitmap, bytes_per_line = -1)
bytes_per_line = bitmap.length if bytes_per_line == -1
@bitmap = bitmap
@bytes_per_line = bytes_per_line
end
def dec_to_bin(dec_num)
return "" if dec_num <= 0
(dec_num % 2).to_s + dec_to_bin(dec_num / 2)
end
def byte_parse(byte)
byte_string = dec_to_bin(byte).reverse
"." * (8- byte_string.length) + byte_string.gsub(/./) { |bit| bit == '1' ? "#" : "." }
end
def to_s
bitmap = @bitmap.map { |byte| byte_parse(byte) }
bitmap_grouped = []
bitmap.each_slice(@bytes_per_line) { |slice| bitmap_grouped << slice.join }
bitmap_grouped.join("\n")
end
end
Валентин Ейткен
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Валентин Ейткен
#!/usr/bin/env ruby
class Bitmap
def initialize(bytes, per_row = 0)
bits = bytes.map do |element|
("0" * (8 - element.to_s(2).length)) + element.to_s(2)
end
@bitmap = bits.each_slice(per_row == 0? bytes.length: per_row)
end
def to_s
lines = @bitmap.map do |line|
(line.join.gsub "0", ".").gsub "1", "#"
end
lines.join("\n")
end
end
Христо Владев
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Христо Владев
class Bitmap
def initialize(bytes_list, bytes_per_line = bytes_list.length)
@bitmap = bytes_list.each_slice(bytes_per_line).map(&bit_representation)
end
def to_s
@bitmap.map do |row|
row.chars.map(&binary_to_s).join
end.join("\n")
end
private
RULES = {'0' => '.', '1' => '#'}
def bit_representation
Proc.new { |bytes| bytes.map { |byte| byte.to_s(2).rjust(8, '0') }.join }
end
def binary_to_s
Proc.new do |char|
if char == '0' or char == '1'
RULES[char]
else
char
end
end
end
end
Гергана Петрова
  • Непроверено
  • 0 успешни тест(а)
  • 0 неуспешни тест(а)
Гергана Петрова
class Bitmap
attr_reader :list, :bytes_per_line
def initialize(list_of_bytes, bytes_per_line = 1 )
@list = list_of_bytes
@bytes_per_line = bytes_per_line
end
def to_s
list.map.each_slice(bytes_per_line).map do |byte_line|
byte_line.map { |byte| ("%08b" % byte).tr "10", "#." }.join ''
end.join "\n"
end
end