Factorial in Scala

100%

Factorial in Scala

✓ Published0🌍 Public

Last edited Apr 10, 2019

Created on Apr 10, 2019

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.

AI-generated description

Similar vizzes

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

74% match

Loading thumbnail…

Factorial

This example demonstrates the computation of the factorial of 10 using XQuery 3.1. It shows two distinct implementation approaches: a recursive function `local:fac` and a higher-order function `local:hFac` that uses `fn:fold-right` with an anonymous function. The program executes `local:hFac(10)`, which iteratively multiplies values from 1 to 10. The data is not visualized graphically; instead, the output is the numeric result of the calculation. The code relies on XQuery’s built-in type annotations (`xs:int`) and function library, with no external visualization libraries involved.

CCliffordAnderson

73% match

Loading thumbnail…

Recursion factorial exa

This example demonstrates a recursive factorial calculation using plain JavaScript, displaying the result of factorialize(4)—the value 24—in large, centered text on the page. The code defines a recursive function that multiplies a number by the factorial of its decremented value until reaching zero, logging the answer to the console and rendering it directly in the DOM. It uses D3 v7 only to load the library via a script tag, while the visualization itself relies on standard HTML, CSS, and JavaScript recursion rather than any D3-specific API or data binding.

NNita

67% match

Loading thumbnail…

countChange

This example visualizes the recursive computation of `countChange`, a Scala function that counts the number of ways to make change for a given amount using a list of coin denominations. It shows the branching call tree, where each node represents a recursive invocation, and the paths highlight how the algorithm explores combinations of coins. The visualization uses d3.forceSimulation to layout the nodes and edges, with the code from gistfile1.scala driving the structure. The rendering approach maps each recursive call to a visual node, revealing the exponential growth of subproblems.

CColinEberhardt

63% match

Loading thumbnail…

Fibonacci Sequence in Elm

This example presents an interactive Fibonacci sequence calculator built in Elm, starting with a simple recursive function and progressing through increasingly feature-rich versions. The code demonstrates Elm’s model-update-view architecture using `beginnerProgram`, with buttons firing `Increment` and `Decrement` messages that adjust a numeric counter. A text display shows the current model value and the corresponding Fibonacci number computed via a naive recursive definition. The visualization uses no external graphics library, instead relying on core Elm `Html` elements like `h2`, `button`, and `p` to render the interface and results.

CCliffordAnderson

58% match

Loading thumbnail…

FizzBuzz in Scala

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.

PP7h

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

58% match

Loading thumbnail…

XQuery Fibonacci

This example computes the 30th Fibonacci number using a recursive XQuery function defined in a separate module. It demonstrates XQuery 3.1’s switch expression and integer arithmetic through the `local:fib` function, which calls itself until it reaches the base cases of 0 and 1. The final result is returned directly without any visualization, showing a pure server-side computation. The source code is stored as a gist by CliffordAnderson.

CCliffordAnderson

57% match