Rosetta Code Popular

ABC Problem

Determine whether a word can be formed from a fixed set of two-letter blocks without reusing a block.

Edit the source, then Run. Checks start after your first Run. Ctrl/⌘ + Enter runs; Tab indents. Preview services use sample data and never contact a real service.

Sourcerosettacode/popular/abc_problem.vibe
type RunResult = {
  a: bool,
  bark: bool,
  book: bool,
  common: bool,
  confuse: bool,
  squad: bool,
  treat: bool
}

def blocks -> array<string>
  [
    "BO", "XK", "DQ", "CP", "NA",
    "GT", "RE", "TG", "QD", "FS",
    "JW", "HU", "VI", "AN", "OB",
    "ER", "FS", "LY", "PC", "ZM"
  ]
end

def block_matches?(block: string, letter: string) -> bool
  block_chars = block.chars
  block.start_with?(letter) || block_chars.fetch(1) == letter
end

def can_make_from?(
  letters: array<string>,
  letter_index: int,
  available_blocks: array<string>
) -> bool
  if letter_index >= letters.length
    return true
  end

  letter = letters.fetch(letter_index)
  block_index = 0

  while block_index < available_blocks.length
    if block_matches?(available_blocks.fetch(block_index), letter)
      remaining = available_blocks.first(block_index) + available_blocks.drop(block_index + 1)
      if can_make_from?(letters, letter_index + 1, remaining)
        return true
      end
    end
    block_index = block_index + 1
  end

  false
end

def can_make?(word: string) -> bool
  can_make_from?(word.upcase.chars, 0, blocks)
end

def run -> RunResult
  {
    a: can_make?("A"),
    bark: can_make?("BARK"),
    book: can_make?("BOOK"),
    treat: can_make?("TREAT"),
    common: can_make?("COMMON"),
    squad: can_make?("SQUAD"),
    confuse: can_make?("CONFUSE")
  }
end

Output

Click Run example to see the result.

Code checks

Run once to load the checker. Your code stays in this browser.