Skip to main content
100%

Acht Königinnen

✓ Published0🌍 Public
Aadewes
Last edited Feb 22, 2014
Created on Feb 22, 2014

This visualization solves the eight queens puzzle by generating all 64 single-queen board states, encoding each as a string of characters, and computing pairwise compatibility between states. It then recursively narrows down combinations of queens that do not attack each other, printing each valid solution as a grid of "Q" (queen), "O" (free), and "X" (attacked) cells. The code uses Python’s `reduce` for flattening state lists and standard list comprehensions to filter compatible states, with no external visualization libraries. The final output lists all 92 solutions, counting them via a simple loop.

AI-generated description

Similar vizzes

Loading thumbnail…

Eight Queens Problem Solved using Common Table Expressions

A SQL query using recursive Common Table Expressions solves the Eight Queens puzzle, enumerating all 92 valid board configurations. The recursive `solutions` CTE incrementally places queens, checking row, column, and diagonal conflicts via arithmetic on board positions. A separate `positions` CTE generates the 64 board cells. A Python script executes the SQL against an in-memory SQLite database, iterating over the result rows and printing each 8×8 board as a text grid with asterisks marking queen placements.

Aadewes
77% 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
58% 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
53% 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
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…

Eternity

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.

WWikunia
51% match
Loading thumbnail…

Sudoku solver

This example shows a Python implementation of a Sudoku solver that finds a complete solution for a given 9x9 puzzle. The code defines a `Solution` class with a recursive backtracking algorithm in `solve_step`, which selects the cell with the fewest possible candidates and tries each valid number until the board is filled. It uses a `get_possible_numbers` method to compute remaining digits by checking row, column, and 3x3 square constraints. The solver modifies the board in place and is verified against an expected solution using test functions.

VValIlya
51% match
Loading thumbnail…

Gist a89d7fc0f8e78309dd5959f6df960e0a

A Connect-4 game simulation renders a 6-by-7 ASCII board where two players, X and O, alternate placing pieces. The code demonstrates game state management with functions to drop a piece into a column and check for a four-in-a-row win condition across horizontal, vertical, and diagonal directions. After each move, a `printBoard` function outputs the current grid, initially showing empty slots as asterisks and updating to display player tokens. The implementation uses plain JavaScript with no external libraries, running via the `npm run start` command, and relies on standard array operations and nested loops for board traversal.

Aamazingandyyy
51% match