Skip to main content
SimilarExport ZIP
100%

FizzBuzz in Scala

✓ Published0🌍 Public
PP7h
Last edited Feb 4, 2017
Created on Feb 4, 2017

This example demonstrates a functional implementation of FizzBuzz for numbers 1 through 30, using Scala’s pattern matching with custom extractors. The code defines a `MultipleOf` case class whose `unapply` method returns `Some(x/n)` when the input is divisible by `n`, enabling concise matching against `multipleOfThree`, `multipleOfFive`, and `multipleOfFifteen`. Each number is mapped through a `fizzbuzz` function that returns the appropriate string or the original integer, then printed sequentially via `map println`. The example highlights Scala’s case classes, partial functions, and the map-collect-print idiom.

AI-generated description

Similar vizzes

Loading thumbnail…

FizzBuzz in Haskell

This example demonstrates the classic FizzBuzz algorithm implemented in Haskell, printing results for numbers 1 through 100 to the console. The code defines three pure functions—`fizzbuzz`, `fizz`, and `buzz`—which use Haskell’s `mod` operator for divisibility checks and string concatenation to build each output line. The `main` function leverages the `mapM_` function with `putStrLn` to sequentially output each line, using a list comprehension to generate the input range. No external libraries are used; the example relies solely on Haskell’s standard Prelude, and it is compiled with GHC as shown in the comments.

PP7h
76% 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
75% match
Loading thumbnail…

Fizz Buzz in XQuery

This example demonstrates the classic Fizz Buzz logic, where numbers divisible by 3 and 5 are replaced with the word "fizzbuzz", those divisible by only 3 with "fizz", and those divisible by only 5 with "buzz". The code iterates over a fixed range of integers from 1 to 30 using an XQuery `for` loop. It applies nested `if`/`else` expressions to evaluate the modulo conditions (`$i mod 3` and `$i mod 5`) and returns the appropriate string or the original number. The entire computation is performed entirely within XQuery 3.0, with no external libraries or data sources involved.

CCliffordAnderson
73% 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
71% match
Loading thumbnail…

Fibonacci in Scala

This example demonstrates a functional definition of the Fibonacci sequence in Scala, highlighting two equivalent recursive implementations: one using nested conditionals and another using pattern matching with a match expression. The visualization shows how the recursive calls unfold, with the second implementation (fib2) called for inputs 10 and 200 to illustrate growth. The code relies on Scala’s standard library, including the Int type and the match keyword, but does not use external visualization libraries. The rendering approach is minimal, focusing on the source code itself as the primary visual artifact, with no graphical output or data source beyond the hardcoded integers passed to the functions.

CCliffordAnderson
62% match
Loading thumbnail…

Factorial in Scala

This visualization demonstrates the recursive computation of factorial values in Scala, tracing the call stack from `fac(10)` down to the base case. The code defines a function `fac(num: Int): Int` that multiplies each number by the factorial of its predecessor, halting at 1. The example renders this execution as a branching tree, where each node represents a function call and its return value. The visualization uses Scala’s standard recursion mechanism, with no external libraries; the data is generated directly from the source gist by CliffordAnderson. The rendering approach likely relies on a custom drawing routine, though the code snippet itself only shows the pure function logic, not the display layer.

CCliffordAnderson
58% match
Loading thumbnail…

I like this example of grabbing elements from a List until you reach your desired sum.

This example demonstrates a functional approach to accumulating values from a numeric sequence, stopping once the running total exceeds 100. The code constructs a range of integers from 1 to 10,000 using Scala’s `1 to 10000` collection, then applies `takeWhile` with a closure that mutates an external `var sum`. The predicate adds each element to `sum` and tests the condition `sum <= 100`, effectively yielding the shortest prefix whose cumulative sum is just under the target. The visualization likely shows the resulting list and the final sum, highlighting how `takeWhile` short-circuits iteration without materializing the full sequence.

BBBischof
56% match
Loading thumbnail…

Fibonacci with pattern matching in Julia

This example demonstrates a pattern-matching–based implementation of the Fibonacci sequence in Julia, showing how the `Match.jl` library's `@match` macro can express recursive function cases inline. The code defines a `fib` function that dispatches on the integer argument, with explicit base cases for 0 and 1 and a recursive fallback case for larger numbers. The example relies on Julia's `typeof` check to constrain inputs to non-negative `Int64` values, then uses `Match.jl`'s pattern syntax (e.g., `0 => 0`, `_ => fib(num-1) + fib(num-2)`) to handle each branch. The rendering is purely computational, with no external data sources or graphical output.

CCliffordAnderson
52% match