super katas

1-800-code-war.rb

PHONE_WORDS = [
  %w[A B C],
  %w[D E F],
  %w[G H I],
  %w[J K L],
  %w[M N O],
  %w[P Q R S],
  %w[T U V],
  %w[W X Y Z],
]

DICTIONARY = PHONE_WORDS.map do |set|
  group = set.join
  set.map { |letter| [letter, group] }
end.flatten(1).to_h


def check1800(s)
  result = {}
  letters = s.split("-").last(2).join()
  option_group = [letters[0..3], letters[4..], letters[0..2], letters[3..]]

  WORDS.each do |option|
    option_group.each do |part|
      result[part] ||= []
      if part.size == option.size && compare(part, option)
        result[part] << option
      end
    end
  end


  first_combination = result[letters[0..3]].product(result[letters[4..]])
  second_combination = result[letters[0..2]].product(result[letters[3..]])

  (first_combination + second_combination).map do |pair|
    option = pair.join("-")
    "1-800-#{option}"
  end
end

def compare(part, option)
  part.split('').each_with_index do |letter, index|
    return false unless DICTIONARY[letter].include?(option[index])
  end

  true
end

p check1800("1-800-CODE-WAR")

connect_four.rb

def who_is_winner(pieces_position_list)
  board = [*'A'..'G'].map { |letter| [letter, []] }.to_h

  pieces_position_list.each do |move|
    column, color = move.split('_')
    player = color.downcase.to_sym

    board[column].push(player)

    return color if check_winner(player, board)
  end

  'Draw'
end

def check_winner(player, board)
  full_board = transform_board(board)

  full_board.each do |row|
    return player if check_line(row, player)
  end

  full_board.transpose.each do |column|
    return player if check_line(column, player)
  end

  dig_left = [*3..6].map { |c| [0, c] }.concat([[5, 2], [6, 1]])

  dig_left.each do |start_row, start_column|
    line = diagonal_left(start_row, start_column, full_board)
    return player if check_line(line, player)
  end

  dig_right = [*3..6].map { |c| [5, c] }.concat([[3, 6], [4, 6]])

  dig_right.each do |start_row, start_column|
    line = diagonal_right(start_row, start_column, full_board)
    return player if check_line(line, player)
  end

  false
end

def diagonal_left(start_r, start_c, full_board)
  start_c.downto(start_r).map.with_index do |column, index|
    row = start_r + index
    full_board[row][column] if row < 6
  end
end

def diagonal_right(start_r, start_c, full_board)
  start_c.downto(0).map.with_index do |column, index|
    row = start_r - index
    full_board[row][column] if row >= 0
  end
end

def check_line(line, player)
  return false if line.count(player) < 4

  line.inject(0) do |acc, value|
    if value == player
      return player if acc + 1 == 4

      acc + 1
    else
      0
    end
  end

  false
end

def transform_board(board)
  board.values.map do |column|
    column + Array.new(6 - column.size)
  end.transpose
end

def nice_print(board)
  puts
  board.each do |row|
    row.each do |c|
      print((c || '-').to_s.ljust(10))
    end
    puts
  end
end