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