Self-optimizing Bloom filter

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

47% match

nlogn algorithm for n/2 matching numbers

This example visualizes the search for majority elements in an array, specifically highlighting matches for the number 4 in a test array of six integers. It demonstrates a divide-and-conquer algorithm that repeatedly halves the array length while logging matching indices and values to the console. The plain HTML page contains no visible graphical output; instead, the visualization is purely console-based, using JavaScript’s native `console.log` to display results from the custom `matchNo` function. The implementation relies on basic array indexing and arithmetic operations rather than external libraries, rendering the algorithm’s step-by-step progression through text output alone.

46% match

Mitchell’s Best-Candidate

This example visualizes Mitchell’s best-candidate algorithm, which approximates Poisson-disc sampling to generate a natural, blue-noise distribution of circles. Circles appear one at a time, growing from radius zero, and new candidates are chosen by maximizing distance from all previously placed circles, using a quadtree for efficient spatial lookup. The code uses the D3 v3 library, specifically `d3.select` and `d3.timer`, alongside the custom `bestCircleGenerator` function, which relies on the quadtree’s `visit` method to compute distances. As the number of circles increases, the algorithm gradually increases the candidate count while reducing circles per animation frame.

Mmbostock

46% match

Fork of Fork of nlogn algorithm for n/2 matching numbers : with function

This example demonstrates an algorithm that attempts to find matching numbers in an array by repeatedly halving the array length and checking for a target value. It shows a console-based visualization where loop iterations log both matched indices and the shrinking value of `n`. The code uses plain JavaScript array operations and `Math.floor` for integer division, with results printed to the browser console. The rendering approach is minimal, using only HTML and inline JavaScript without external libraries, while the page sets a large font size but displays no visible graphics.

Fork of Fork of nlogn algorithm for n/2 matching numbers : with psuedocode

This example demonstrates a brute-force algorithm that searches for matching numbers in an array by repeatedly halving the search range. The visualization shows a console output of the number `4` appearing in the array `[2, 4, 4, 4, 3, 6]`. The code uses plain JavaScript with a `while` loop and `Math.floor` to divide the array length, iterating through indices to log matches. No external libraries are used; the rendering relies entirely on the browser’s default console and HTML body styling with a large font size.

Fork of Fork of Fork of nlogn algorithm for n/2 matching numbers : with psuedocode

This example visualizes the process of finding majority elements in an array by scanning through indices and logging matches. It uses plain JavaScript with a `while` loop and `for` loop to iterate over the array, while an `if` conditional checks for equality with a target number. The page renders no graphics, only console output, and presents the looping logic separately as pseudocode in the README. The code relies on basic browser console APIs rather than visualization libraries.

Poisson-Disc II

This animation illustrates the Poisson-disc sampling algorithm, which generates a set of points with a minimum spacing. Red dots are active samples; one is selected randomly, and up to *k* candidate points (open black circles) are generated in an annulus around it. Candidates are rejected if too close to any existing sample, shown by a gray exclusion zone and black lines to the offending neighbor. Inactive samples turn black, and the process ends when none remain active. The code uses d3.svg.arc for the annulus and CSS transitions for animation.

Mmbostock

Ppmbhupathibalu@gmail.com

Fork of Buddha

Eleven colored circles emerge from zero and expand to a fixed radius over a black background, arranged according to static x/y coordinates from a CSV file. The animation uses D3 transitions with staggered delays to create a sequential bloom effect, while CSS mix-blend-mode screen blends overlapping circles into luminous composites. The data includes explicit fill colors and radius values, though the code overrides individual radii with a constant value during animation.