Free solved software for linux

JSokoApplet is a Java applet for playing the game of Sokoban. It features path finding, auto push, auto solving, undo/redo, deadlock detection, and more

JSokoApplet project is written in Java. You must have Java installed to start the game.

There are two ways of starting the program:

1. Starting the program as an applet:

Load the html-file in your browser (usually by doubleclicking the html-file). The applet should be loaded automatically with that html-file.

2. Starting the program as an application:

a) Start the batch-file "Start JSokoApplication.bat" (Windows users)
or
b) open a console window, go to the folder where the file "JSokoApplet.jar" is located and type: java -jar JSokoApplet.jar
or
c) Just double click the file "JSokoApplet.jar"

If the program doesnt start please check if you have Java installed.
If you have questions about how to start the program write to "x-brain@uni.de"

The game:

"Sokoban" is a puzzle game invented in Japan 1982 by Hiroyuki Imabayashi. The rules are very simple but the game itself is not.

The Rules

The object of the game is to push boxes to specially marked positions in a level. The boxes can only be pushed, never pulled, and only one can be pushed at a time. The player can only move on "free" (= no wall and no box) fields.

A level is solved if all boxes have been pushed to specially marked positions.
One field can just be occupied by only one of the following levelelements at a time: the player, a box, a wall

Just start the game. You easily will learn the rules by playing the game.

The computer will help you in positions where you lost the possibility to solve the level (for example, if you pushed a box in a corner) by showing you the message that the level isnt solvable anymore.

Note: Recognizing positions that are unsolvable is very difficult. Hence the computer just shows this message for some kinds of unsolvable positions.

How to Play

You can move the player by using the arrow keys or by using the mouse (or both)

Keyboard Functions

Move the player: Arrow keys

Undo last move: [Delete] or [Backspace]

Redo move from history: [Insert]

Restart level: [Enter]

Previous level: [Page up]

Next level: [Page down].

Mouse Functions

Left-click on a position to let the player automatically move to this position.
Left-click on a box to select it then left-click the target position. The player will automatically push the selected box to the specified position. Unselect a box by clicking on it again.

A click of the right mousebutton will undo the last done activity.

A Sudoku Solver in C is a console-based Linux program, written in C language, that solves Su Doku puzzles using deductive logic. It will only resort to trial-and-error and backtracking approaches upon exhausting its deductive moves.
Puzzles must be of the standard 9x9 variety using the (ASCII) characters 1 through 9 for the puzzle symbols. Puzzles should be submitted as 81 character strings which, when read left-to-right will fill a 9x9 Sudoku grid from left-to-right and top-to-bottom. In the puzzle specification, the characters 1 - 9 represent the puzzle givens or clues. Any other non-blank character represents an unsolved cell.
The puzzle solving algorithm is home grown. I did not borrow any of the usual techniques from the literature, e.g. Donald Knuths "Dancing Links." Instead I rolled my own from scratch as a personal challenge. As such, its performance can only be blamed on yours truly. Still, I feel it is quite fast. On a 333 MHz Pentium II Linux box it solves typical medium force puzzles in approximately 800 microseconds or about 1,200 puzzles per second, give or take. On an Athlon XP 3000 it solves about 6,600 puzzles per sec. (Solving time is dependent upon degree of difficulty, so YMMV.)
Description of Algorithm:
The puzzle algorithm initially assumes every unsolved cell can assume every possible value. It then uses the placement of the givens to refine the choices available to each cell. I call this the markup phase.
After markup completes, the algorithm then looks for singleton cells with values that, due to constraints imposed by the row, column, or 3x3 region, may only assume one possible value. Once these cells are assigned values, the algorithm returns to the markup phase to apply these changes to the remaining candidate solutions. The markup/singleton phases alternate until either no more changes occur, or the puzzle is solved. I call the markup/singleton elimination loop the Simple Solver because in a large percentage of cases it solves the puzzle.
If the simple solver portion of the algorithm doesnt produce a solution, then more advanced deductive rules are applied.
Ive implemented two additional rules as part of the deductive puzzle solver. The first is subset elimination wherein a row/column/region is scanned for X number of cells with X number of matching candidate solutions. If such subsets (or tuples) are found in the row, column, or region, then the candidates values from the subset may be eliminated from all other unsolved cells within the row, column, or region, respectively.
The next deductive rule examines each region looking for candidate values that exclusively align themselves along a single row or column, i.e. a vector. If such candidate values are found, then they may be eliminated from the cells outside of the region that are part of the aligned row or column.
Note that each of the advanced deductive rules calls all preceeding rules, in order, if that advanced rule has effected a change in puzzle markup.
Finally, if no solution is found after iteratively applying all deductive rules, then we begin trial-and-error using recursion for backtracking. A working copy is created from our puzzle, and using this copy the first cell with the smallest number of candidate solutions is chosen. One of the solutions values is assigned to that cell, and the solver algorithm is called using this working copy as its starting point. Eventually, either a solution, or an impasse is reached.
If we reach an impasse, the recursion unwinds and the next trial solution is attempted. If a solution is found (at any point) the values for the solution are added to a list. Again, so long as we are examining all possibilities, the recursion unwinds so that the next trial may be attempted. It is in this manner that we enumerate puzzles with multiple solutions.
Note that it is certainly possible to add to the list of applied deductive rules. The techniques known as "X-Wing" and "Swordfish" come to mind. On the other hand, adding these additional rules will, in all likelihood, slow the solver down by adding to the computational burden while producing very few results. Ive seen the law of diminishing returns even in some of the existing rules, e.g. in subset elimination I only look at two and three valued subsets because taking it any further than that degraded performance.
Enhancements:
- Code optimization has resulted in a 30% increase in speed.

nss-ldapd project is a fork of the nss_ldap package by PADL Software Pty Ltd.. This fork was done to implement some structural design changes. These changes were needed because there are some issues with the original design. See the documentation section for more details.
These problems are solved by splitting the library in two parts: a daemon that connects to the LDAP server and does all the requests and a thin NSS connector that passes requests to the daemon through a socket. The nss-ldapd implementation has a number of (some theoretical) advantages:
- lighter NSS library
- simpler internal semantics
- clear separation between NSS and LDAP code (the server part could easily be implemented in another language)
- less connections to the LDAP server
The implementation is also a major code overhaul of the code having a number of simplifications and removal of old compatibility code. Compatibility will be re-added with later releases of nss-ldapd for those platforms that need it.
Enhancements:
- This is a quick update to the earlier 0.2 release. It fixes a problem with the permissions with the server socket and pthread related build problems.

Sepp is a version of the classic sliding puzzle game in which the properly ordered tiles form a picture.
Sepp, the Sliding Evil-Piece Puzzle, implements a computer version of the classic moving puzzle game, which has 15 sliding tiles in a 4-by-4 matrix and is also known as the 15 puzzle, in which the properly ordered tiles would form a picture.
Variants like Loyds would be unsuitable for this version of the game because a picture in which two contiguous tiles were swapped (and which, therefore, could not be recomposed) might annoy users and likely be perceived as a bug in the program; therefore, Sepp does not perform arbitrary tile swapping when scrambling the tiles, and the original image can always be obtained given enough tile pushes.
On the other hand, Sepp implements its own innovative kind of player aggravation: based on a user-configurable degree of evil, ranging from Not at all evil to beyond Very Evil, Sepp decides, during each animation frame, whether it will disturb a tile while the game is in progress. For better or worse, this feature, which can be disabled by setting the evilness to Not at all evil, sets Sepp apart from other, similar games.
Main features:
- Sepp allows the player to select the tile that will be used as the empty slot by simply clicking on it before scrambling the tiles; this setting is remembered by Sepp for as long as the players session stays in the puzzle in which the tile was chosen, and is dismissed when the user chooses a different picture or different grid geometry.
- Sepp keeps track of time spent by the player in solving the puzzle, but displays it only if and when the puzzle is solved; in this regard, Sepp implements the same behavior as the casual game Frozen Bubble and avoids distracting and terrorizing the user during gameplay.
- The terror that Sepp does cause its players comes in four levels, and can be set using an options menu that is available with a single click immediately after startup; in consideration of the elderly, the children, and small household appliances, "evilness" is disabled by default.
- The Sepp player can enjoy endless hours the aggravation using the input device of his choice, whether it be the keyboard or the mouse: except for empty slot selection, all operations can be performed with either; additionally, Sepp does not require dragging of the tiles but instead supports single-click action.

Solving Constraint Integer Programs is a framework for constraint integer programming. For solving Integer Programs and Constraint Programs, a very similar technique is used: the problem is successively divided into smaller subproblems (branching) that are solved recursively.
On the other hand, Integer Programming and Constraint Programming have different strengths: Integer Programming uses LP relaxations and cutting planes to provide strong dual bounds, while Constraint Programming can handle arbitrary (non-linear) constraints and uses propagation to tighten the variables domains.
SCIP is a framework for Constraint Integer Programming oriented towards the needs of Mathematical Programming experts who want to have total control of the solution process and access detailed information down to the guts of the solver. SCIP can also be used as pure MIP solver or as framework for branch-cut-and-price.
Main features:
- It is a framework for branching, cutting, pricing, and propagation.
- It is highly flexible through many possible user plugins:
- constraint handlers to implement arbitrary constraints,
- variable pricers to dynamically create problem variables,
- domain propagators to apply constraint independent propagations on the variables domains,
- cut separators to apply cutting planes on the LP relaxation,
- relaxators to provide relaxations and dual bounds in addition to the LP relaxation,
- primal heuristics to search for feasible solutions with specific support for probing and diving,
- node selectors to guide the search,
- branching rules to split the problem into subproblems,
- presolvers to simplify the solved problem,
- file readers to parse different input file formats,
- event handlers to be informed on specific events, e.g., when a node was solved, a specific variable changed its bounds, or a new primal solution was found,
- display handlers to create additional columns in the solvers output.
- dialog handlers to extend the included command shell.
- Every existing unit is implemented as a plugin, leading to an interface flexible enough to meet the needs of most additional user extensions.
- A dynamic cut pool management is included.
- The user may mix preprocessed and active problem variables in expressions: they are automatically transformed to corresponding active problem variables.
- Arbitrarily many children per node can be created, and the different children can be arbitrarily defined.
- It has an open LP solver support (currently supporting ILOG CPLEX, Dash XPress-MP, SoPlex, and CLP.
- The LP relaxation need not to be solved at every single node (it can even be turned off completely, mimicing a pure constraint solver).
- Additional relaxations (e.g., semidefinite relaxations or Lagrangian relaxations) can be included, working in parallel or interleaved.
- Conflict analysis can be applied to learn from infeasible subproblems.
- Dynamic memory management reduces the number of operation system calls with automatic memory leakage detection in debug mode.
Enhancements:
- The new heuristics "RENS", "mutation", "veclendiving", and "intshifting", were included.
- The existing ones were improved.
- Presolving and c-MIR cut generation were improved.
- A few bugs were fixed.

Somatic project is a generic 3D puzzle solver for soma and pentomino-like puzzles.

Somatic is a generic 3D puzzle solver for soma and pentomino-like puzzles. For an arbitrary set of pieces and a figure with not more than 64 cubes, it can check whether this figure can be built using these pieces and return one or more solutions.

It can also solve split figures that are not connected and partial figures, which do not need all pieces to be built.

Piece sets that can be solved include but are not limited to the soma cube, the somaplus set, the doublesoma set, the bedlam cube, and the pentomino set.