Some little programming puzzle I found. Apparently Facebook asked this sometime. A message containing letters from A-Z is being encoded to numbers using the following mapping: a -> 1, b -> 2, ... etc. How many decodings of some given number. Takes an input of numeral characters.

100%

Some little programming puzzle I found. Apparently Facebook asked this sometime. A message containing letters from A-Z is being encoded to numbers using the following mapping: a -> 1, b -> 2, ... etc. How many decodings of some given number. Takes an input of numeral characters.

✓ Published0🌍 Public

Last edited Dec 6, 2013

Created on Dec 6, 2013

This example demonstrates a recursive solution to the classic Facebook interview puzzle of counting possible letter-to-number decodings for a given numeral string. It shows how the algorithm branches by treating each string as either a single digit or a two-digit pair, with base cases for lengths zero, one, and two. The code relies on Python’s `sys.argv` to read input from the command line and uses custom helper functions `howMany` and `isValid` to handle recursion and validate two-digit codes against the 1–26 mapping. The rendering approach is purely console-based, printing the final count directly.

AI-generated description

Similar vizzes

Loading thumbnail…

A solution to a codefights daily puzzle that was amusing and might be useful to reference

This example demonstrates a Python solution to a Codefights puzzle that decompresses a run-length encoded string, sorts its letters, and returns the kth character. The visualization shows how the algorithm groups identical letters using `itertools.groupby` and `sorted`, then aggregates their counts with `sum`. It uses `re.findall` to parse letter-number pairs and a pairwise iteration to handle adjacent matches. The code returns -1 for invalid inputs or when k exceeds the total character count, illustrating a compact approach to string compression challenges.

BBBischof

57% match

Loading thumbnail…

writing the numbers 1-100 in order and seeing the middle letter

This example examines the letters at the center of the concatenated text formed by writing the numbers 1 through 100 as words, with and without hyphens. It uses Python’s built-in string methods to join the number list, remove hyphens, and index the middle character by calculating half the total length. The visualization shows the resulting middle letter for four variations: with and without hyphen removal, and with spaces versus no spaces between numbers. The code relies solely on Python’s `list`, `join`, `replace`, and `len` functions, with no external libraries or graphical output.

BBBischof

52% match

Loading thumbnail…

Gist 718a9dfea4f5678607c3

This example shows the number of ways to reach a target integer (40) by adding fixed step sizes of 2, 3, 6, 7, or 8, where negative values contribute zero and zero contributes one. The code defines a recursive function `furtburl` and wraps it with a custom `memoize` decorator that caches results by argument tuple, avoiding redundant re-computation. It uses plain Python with a dictionary cache and function decoration, then calls `furtburl(40)` to compute the count. The visualization displays the resulting integer value, though no graphical library or rendering is involved.

BBBischof

49% match

Loading thumbnail…

FizzBuzz with simple mapping operator

This example demonstrates the FizzBuzz logic through a simple mapping operator, rendering the output sequence from 1 to 15 as a compact text visualization. The code uses the XQuery 3.0 `!` mapping operator to iterate over each number, applying a chain of conditional `mod` checks to classify values as “fizz,” “buzz,” or “fizz buzz.” The data source is the hardcoded range (1 to 15), and the rendering approach is direct string output, with no external libraries or graphical APIs involved. It shows how a classic programming puzzle can be expressed concisely using functional-style iteration and conditional logic in a single line.

CCliffordAnderson

48% match

Loading thumbnail…

Gist 95bc6a1fc08d5057b64b1b1dc24c211e

This example demonstrates a JavaScript array manipulation that generates all possible single-step neighbors for a four-digit lock combination. It creates two variations for each digit: one decrementing the value (with 0 wrapping to 9) and one incrementing it (with 9 wrapping to 0), storing all eight resulting arrays in a `neighbors` list. The code uses standard JavaScript array methods like `forEach` and `slice`, along with a ternary operator for edge-case wrapping, to construct the neighbor variations. The output, logged via `console.log`, shows a matrix of four-element arrays representing every adjacent combination state.

GGugaGongadze

48% match

Loading thumbnail…

Number Guesser

This interactive game challenges a player to guess a number between one and ten within three attempts. It shows the range and remaining guesses, then reveals the winning number if the player loses, and offers a play-again button. The interface is built with Skeleton CSS, while the game logic uses JavaScript and the DOM API for event handling. Random winning numbers are generated using the `Math.random` and `Math.floor` functions.

Bbukbukbukka

46% match

Loading thumbnail…

Number guessing

This visualization presents a classic number-guessing card trick. It displays a series of shuffled cards, each containing a subset of numbers from 1 to 60, generated by a mathematical algorithm. The user answers "Ja" (yes) or "Nein" (no) to whether their chosen number appears on a highlighted card. After all cards are shown, the program calculates and reveals the hidden number. Built with D3 v4, it uses SVG elements and `d3.transition` for smooth card movements and the final dramatic fade-in of the solution.

EEE2dev

45% match

Loading thumbnail…

Exercise: Implement FizzBuzz (Super Edition)

This example visualizes the transformation of an input array of integers through the FizzBuzz logic, displaying the resulting array where multiples of three are replaced with “Fizz,” multiples of five with “Buzz,” and multiples of both with “FizzBuzz.” The code, written in Ruby, implements two versions: an initial hash-based iteration that maps each index to its processed value, and a more concise solution using `Array#map!` to mutate the array in place. The visualization does not employ external libraries or rendering frameworks; instead, it relies solely on Ruby’s core array and hash methods to compute and output the final sequence, making the data flow explicit through the two algorithmic approaches.

EElaineYu

45% match