Free puzzle solver software for linux

Sudoku solver application was created for solving a Sudoku with a backtracking algorithm. Instead of using a 9 x 9 matrix, it extends the matrix to 10 x 36 (10 rows, 36 columns), storing information in the extra cells.

The last row is used for keeping track of how many cells, for the current column, are still available.

The columns 9-17 (0-based) are used for storing the numbers which are still available in rows 0-8.

The columns 18-26 are used for storing the numbers which are still available in columns 0-8.

The columns 27-35 are used for storing the numbers which are still available in each square (counting from left to right and from top to bottom).

The GLPK (GNU Linear Programming Kit) package is intended for solving large-scale linear programming (LP), mixed integer programming (MIP), and other related problems. It is a set of routines written in ANSI C and organized in the form of a callable library.
GLPK supports the GNU MathProg language, which is a subset of the AMPL language.
The GLPK package includes the following main modules:
- Revised simplex method.
- Primal-dual interior point method.
- Branch-and-bound method.
- Translator for GNU MathProg.
- Application program interface (API).
- Stand-alone LP/MIP solver.

PipeWalker is a puzzle game where you must connect all hosts to network!

You need to merge all workstations on map to one network and connect server. This game is a clone of NetWalk.

YasSS is a command line C++ program that solves given Sudokus.
The actual work is done in a class the encapsulates all the functionality, so it should be easy to set up another GUI for it.
How It Works
YasSS stores the Sudoku field in a two-dimensional array. For each cell there is stored which numbers can be entered there.
The actual solver is discussed below.
Header File of Class Sudoku
If a cell contains a zero, it is empty.
#ifndef _MORITZ_FIELD_
#define _MORITZ_FIELD_
#include < iostream >
// a Sudoku playing field implemented as a 2d fixed size array
// contains consistency checks and a solver.
class sudoku {
public:
sudoku();
// creates a field with in ital data. 0 means "not set".
// Note that the first coordinate is considered as x, so if
// you create an array char f= {{1 ,2 ...}, {..}} you will get
// the transposed sudoku field. but dont worry, sudoku is
// invariant under transposition
sudoku(char init_data[9][9]);
sudoku(char* init_data);
// creates a field with initial data. 0 means "not set".
// Note that the first coordinate is considered as x, so if
// you create an array char f= {{1 ,2 ...}, {..}} you will get
// the transposed sudoku field. but dont worry, sudoku is
// invariant under transposition
sudoku(int init_data[9][9]);
// generates a rather simplistic output to the given stream
// call as pretty_print(cout) or something like that...
void pretty_print(std::ostream &handle);
// just print all chars in one row
void print(std::ostream &handle);
// sets item (x, y) to val
// assumes that it is doesnt lead to an intermediate
// conflict with sudoku rules
// which is equivalent to saying it requires
// allowed_set(val, x, y) to be true
void set_item(char val, int x, int y);
// get entry at position (x, y)
// 0 means "unset"
int get_item(int x, int y);
// returns true if it doesnt lead to a direct error if you
// set (x, y) to val
// If data[x][y] != 0 the return value is
// true if val == data[x][y]
bool allowed_set(char val, int x, int y);
// try to solve the puzzle. Returns true on success.
bool solve();
// returns true if there is no zero entry left, e.g. the
// problem is solved correctly.
bool is_solved();
// returns true if there is no possibility to continue without
// violating rule
bool is_stuck();
protected:
// contains 0 for unset values and the corresponding value
// if the value is set
char data[9][9];
// allowed[x][y][i] is true if and only if it is possible to
// set data[x][y] to i+1 without conjuring an immediate
// collision.
// If data[x][y] == i != 0 then allowed[x][y][i] is true,
// allowed[x][y][j] = false for j != i
bool allowed[9][9][9];
bool simple_solve();
bool simple_solve1();
bool simple_solve2();
// returns either an is_solved or a stuck() version of *this
bool backtrack();
void null_init();
int recursion_depth;
void set_recursion_depth(int rd) {recursion_depth = rd;};
};
Enhancements:
- This release adds an option to generate Sudokus with a random number of initial clues.

Automagical Sudoku Solver project is an attempt to solve Sudoku puzzles using a computer. It can solve rather tough puzzles, but not all of them.

Installation:

The source code should compile flawlessly using the make utility. Then, simply run "ass < foo", where foo is a sudoku puzzle in text format like the ones in the puzzles/ directory.

Arguments

-s show progress using an ncurses interface
-v show version number
-d [2-4] show debug info (4 is highest level)

MazeRunner project is a very extensible puzzle game that is also meant to be (somewhat) a Mario clone, featuring good music, graphics (2D), and other features.

malkriz is solver for the Japanese puzzle, Griddlers.

malkriz project is written as a set of simple, portable C++ classes, and supports a range of GUI front-ends.