Arithmetic Billiards Racks

100%

Arithmetic Billiards Racks

✓ Published0🌍 Public

Last edited May 22, 2017

Created on May 19, 2017

This visualization shows the exhaustive search for arithmetic billiards racks, where each rack is a triangular arrangement of numbered balls where adjacent pairs combine via addition or absolute difference to produce the ball below. The code enumerates all possible starting configurations and recursively fills each row, displaying complete racks with remaining balls listed. It uses Python’s `copy.deepcopy` and custom `rack` and `row` classes to track and print valid arrangements, with the final output summarizing counts of racks by size.

AI-generated description

Similar vizzes

Loading thumbnail…

Gist 2bba23d8eda3ce767e87a6a491773372

The visualization is a scatterplot-style mosaic representing a 1000x1000 grid, plotting the positions and sizes of 234 rectangular claims from an Advent of Code puzzle. Overlapping rectangles accumulate, creating a dense heatmap-like field of colored blocks on a dark background. Built with Processing, the sketch loads the claim data from `aoc3_1.txt` and renders each rectangle using `rect()`, varying color intensity based on overlap count. The code uses `loadStrings()` to parse the input file and calls `noLoop()` to draw the static result once.

BBBischof

51% match

Loading thumbnail…

Gist b0f64c51570ca06b6602

This example demonstrates a recursive Boggle word-finding algorithm that visualizes its search process by printing the game board to the console at each step. The code uses Ruby’s `Array#each_with_index` to scan the 4x4 letter grid, and recursively calls the `checker` method to trace valid adjacent letter paths for a given word. A `draw` function outputs the board state, marking previously visited cells with the string `"NO"` to show the algorithm’s backtracking. The visualization relies on terminal text output rather than graphical rendering, using only the `p` method for display.

AAndrelton

49% match

Loading thumbnail…

Distribute lottery balls into 4 groups randomly

This visualization randomly distributes lottery balls, weighted by each team’s 2023 season results, into four groups. It shows the final, validated distribution after repeatedly shuffling until every group contains at least seven distinct teams. The R script samples the expanded list of team names using `sample()`, splits the reordered entries into four buckets with `split()`, and conditionally appends two extra balls to the first group. It then writes each group to a separate CSV file using `write.csv()`.

JJasonCabral

49% match

Loading thumbnail…

Advent of Code

This visualization demonstrates the redistribution of memory blocks in the "Advent of Code" Day 6 challenge, tracking how many redistribution cycles occur before a state repeats. The code uses XQuery 3.1 with recursive functions `local:zero-out-highest` and `local:add-blocks` to reallocate blocks from the highest-value bank across the array, while `local:calculate-state` records each state as a hyphen-separated string and stops when a duplicate state appears. The data source is a hardcoded sequence of 16 integers representing the initial memory banks, and the output is the integer count of iterations performed until repetition, rendered as plain text. No external visualization libraries are used; the example focuses purely on algorithmic state computation.

CCliffordAnderson

49% match

Loading thumbnail…

Staafjespuzzel code from Henk, tweaked. (36cube puzzle)

This visualization shows the solution search for the 36cube puzzle, a 6x6 grid where each row and column must contain each color exactly once. The code displays the board state in text form, with each cell colored and a numeric permutation showing the column order for each row. It tracks remaining colors per height level and uses a backtracking algorithm with placement statistics to explore solutions. The implementation uses C++ with the standard library, specifically the `set` container, and outputs progress markers and intermediate board states to standard output.

GGerHobbelt

48% match

Loading thumbnail…

advent-of-code-05

Each row of the visualization is a horizontal line representing an element in the puzzle's input array. As the algorithm jumps through the array, darker values indicate lower numbers, and the x-axis tracks progress over time. Purple vertical columns show the rate of visits each position receives per roughly 30,000 jumps. The code uses `d3.scaleLinear` for color encoding and draws rectangles to both a Canvas and an SVG layer via `d3.conventions`.

11wheel

48% match

Loading thumbnail…

custom chart v2.1

This example visualizes a cricket batting innings by mapping each batsman’s performance as a rectangular block. The chart shows the number of runs scored (rectangle height) against the sequence of balls faced, with each player’s block positioned according to their first ball and cumulative team runs. Using d3.csv, d3.scaleLinear, and SVG rectangles, the code computes scales from the parsed data to render the custom chart. The visualization relies on data.csv containing batting statistics and displays the progression of individual contributions across the innings.

PPabloEscargot

48% match

Loading thumbnail…

Gist 0d3ef677475862ba439fd5dacfd4a60d

The visualization maps the scoring patterns of five-letter words, showing how letter positions and letter values contribute to total word scores. It displays a grid or distribution of words, likely sorted or clustered by score, with each word’s score calculated from per-letter point values and a bonus for non-repeated letters. The implementation uses Python’s pandas to load and transform the word list, adding columns for each letter’s position and score, while the letter-to-value mapping follows standard Scrabble tile distributions. The final score sums individual letter scores and adds a two-point bonus when all letters are unique, as seen in the `duplicates` logic. The rendering itself is not shown in the code, but the data processing relies on pandas dataframes and string operations to derive the visualization’s underlying dataset.

CConorAspell

48% match