Skip to main content
100%

Eight Queens Problem Solved using Common Table Expressions

✓ Published0🌍 Public
Aadewes
Last edited Feb 1, 2015
Created on Feb 1, 2015

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.

AI-generated description

Similar vizzes

Loading thumbnail…

Acht Königinnen

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.

Aadewes
77% 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
58% 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
57% 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
56% 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
53% 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
50% 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
50% match
Loading thumbnail…

Arithmetic Billiards Racks

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.

BBBischof
50% match