Skip to main content
100%

Eternity

✓ Published0🌍 Public
WWikunia
Last edited Apr 29, 2020
Created on Apr 29, 2020

A completed Eternity puzzle solution is displayed as a square grid of 49 tiles, each showing a piece ID and four colored triangular edge markers. The visualization uses Julia with Plots.jl to render the final arrangement after constraint solving with ConstraintSolver.jl and JuMP, where the puzzle pieces are matched by edge colors.

AI-generated description

Similar vizzes

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
60% match
Loading thumbnail…

Numoku solver: Solves i.e https://twitter.com/1to9puzzle/status/1255848687298740224

Numoku solver demonstrates how a constraint programming approach solves a 6x6 Numoku puzzle where row and column sums must total 30 with specific multiplicative split points. The visualization shows the solved grid with numbers 1-9 placed such that each 3x3 block, row, and column contains unique digits. Built with Julia using JuMP and the ConstraintSolver package, it employs `CS.AllDifferentSet` constraints for uniqueness and `CS.TableSet` constraints to enforce valid split patterns generated by `get_possible_splits`. The puzzle input includes fixed cells and split directions, solved via combinatorial permutation filtering.

WWikunia
59% 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
54% match
Loading thumbnail…

Sudoku

The visualization displays a Sudoku puzzle grid, where each cell contains a number from the provided data set. It shows the puzzle’s initial state with givens (nonzero digits) and empty cells (zeros) laid out in a 9x9 matrix. The grid is rendered using D3.js, with `d3.forceSimulation` positioning the cells and `d3.select` handling DOM updates. The numbers are drawn as text elements, while the grid lines are created via SVG rectangles and paths. The data originates from a plain text file (`sudoku.txt`) parsed into an array, and the code uses standard SVG attributes for styling and layout.

WWikunia
53% match
Loading thumbnail…

Sliding puzzle

This sliding puzzle divides a neon background image into a grid of tiles, with one tile removed to create a hole. An animation continuously swaps the hole with a random adjacent tile, creating a perpetually shuffling mosaic. The code uses D3 v4 to bind data to HTML `div` elements and positions them via absolute CSS, while `d3.shuffle` and `d3.transition` orchestrate the tile movement. Each tile’s background offset is calculated from its grid position, revealing the underlying image fragment.

TThanaporn-sk
53% match
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
52% match
Loading thumbnail…

Sudoku solver in rust

A Sudoku solver implemented in Rust displays a completed 9x9 puzzle grid as a console output, replacing empty cells with solved digits. The code models the board as a 2D array of characters and converts it to integers, then uses a backtracking algorithm with constraint propagation to find the solution. The `solve_step` function recursively tries candidate numbers, while `get_possible_numbers` checks row, column, and 3x3 subgrid constraints to filter valid options. The final result prints the solved board row by row using standard Rust formatting and I/O operations.

VValIlya
52% match
Loading thumbnail…

Invisible dots

Fifty black, rounded squares form a silent grid on a white background, each one a uniform tile with no visible variation. The piece demonstrates a simple HTML and JavaScript loop that creates the elements using `document.createElement` and `document.body.append`, with styling applied via CSS properties for size, margin, and border-radius. There is no interaction, animation, or data binding, only the static repetition of identical shapes. The title suggests an absence or a hidden pattern, but the code does not implement any such behavior, leaving the visual composition purely as a minimal exercise in layout generation.

Ggragors123@gmail.com
51% match