Free rush hour puzzle solver software for linux

Mayze 0.0.1a will provide hours of entertainment for everyone. This is designed as a maze puzzle game written in Python and PyGame. It features a simple overhead adventure shooter. You move around, you shoot. You can also make your own levels using the level editor.

Requirements:

• Python >= 2.5
• Pygame >= 1.8
• PGU >= 0.10.6

Gecode/R is a Ruby interface to Gecode, allowing constraint programming in Ruby. The interface is intended for people with no previous experience of constraint programming, aiming to be easy to pick up and use in practice.
Constraint programming
Constraint programming is a declarative programming paradigm, you describe what kind of solution you want rather than how you want it computed. When using constraint programming you try to model the problem and then feed that model to the solver. The solver then searches for a solution by exploring the space of all possible assignments while using the constraints in the model to prune parts without having to visit them.
A popular example would be Soduko, to solve a Soduko with constraint programming you feed the rules (all numbers in each row must be distinct etc) to the solver, which then searches for a solution satisfying all the constraints.
Enhancements:
- A new Website has been launched, and a lot of documentation has been added (both code and user documentation).

PayVeX project works with PayPal IPN to sell files, this approach ensures you are paid for your digital content before a customer can download it.

For the customer using PayVeX, a purchase is quick, convenient, anonymous and simple.

In this day and age, asking for information can lead to lost sales. People are in a rush and arent interested in taking the time to fill out lengthy forms.

For the merchant, impulse buyers and people who would otherwise resist due to privacy or credit card concerns suddenly become buyers.

Taskjuggler is a project management tool for Linux and UNIX system-based operating systems. Whether you want to plan your colleges shifts for the next month or want to build a skyscraper - Taskjuggler is the tool for you.
Instead of clicking yourself painfully through hundreds of dialog boxes you specify your Taskjuggler project in a simple text format. You simply list all your tasks and their dependencies. The resulting schedule is then presented as GANTT chart, Table, HTML, XML or CSV report.
Taskjuggler does not only honor the task interdependencies but also takes resource constrains into account. Using Taskjugglers powerful filtering and reporting algorithms you can create task lists, resource usage tables, status reports, project calendars and project accounting statements.
Main features:
- Automatic scheduling of interdependent tasks with resource conflict solver.
- Powerful project description syntax with macro support.
- Flexible working hours and vacation handling.
- Support for shifts.
- Multiple time zone support.
- Flexible resource grouping.
- Project accounting support.
- Task may have initial costs, finishing costs.
- Resource may have running costs.
- Support for simple profit/loss analysis.
- HTML and XML report generation.
- Support for plan and actual scenario comparisons.
- Project tracking support.
- Groupware support by using a revision control system such as CVS or RCS on the project description files.
- Support for central resource allocation database.

JRicochet is a simple puzzle game. It consists of a 10x10 grid, which contains 5 invisible blocks. From each side a player can shoot probes into the grid. Goal is to find the blocks by the pattern of the ricochetting probes in as few shots as possible.

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.

Brikx is a puzzle game.

A small puzzle game in which your goal is to remove all tiles. You are held up by other tiles, gravity, walls, and other things, and you can even redesign the level while playing!