twentyseven alternatives and similar packages
Based on the "Algorithms" category.
Alternatively, view twentyseven alternatives based on common mentions on social networks and blogs.

arithmoi
Number theory: primes, arithmetic functions, modular computations, special sequences 
presburger
Decision procedures for Presburger arithmetic in Haskell 
imjanimation
Monorepo for a multiplayer game engine, and game examples 
textmetrics
Calculate various string metrics efficiently in Haskell 
searchalgorithms
Haskell library containing common graph search algorithms 
lca
Improves the known complexity of online lowest common ancestor search to O(log h) persistently, and without preprocessing 
integerlogarithms
Integer logarithms, originally split from arithmoi package 
incrementalsatsolver
Simple, Incremental SAT Solving as a Haskell Library 
treeviz
Haskell library for visualizing algorithmic decomposition of computations. 
nonlinearoptimizationad
Wrapper of nonlinearoptimization package for using with ad and backprop packages 
GraphSCC
Tarjan's algorithm for computing strongly connected components 
infinitesearch
An implementation of Martin Escardo's exhaustively searchable sets in Haskell. 
editdistancevector
Calculate edit scripts and distances between Vectors. 
primesieve
A collection of packages related to math, algorithms and science, in Haskell. 
adpmulti
Prototype of ADP for MCFL (multiple contextfree languages) 
graphgenerators
A Haskell library for creating random Data.Graph instances using several pop 
editdistancelinear
Levenshtein edit distance in linear memory (also turns out to be faster than C++) 
epanethaskell
Call the EPANET toolkit via Haskell's Foreign Function Interface 
bordacount
Haskell implementation of the Borda count election method
Clean code begins in your IDE with SonarLint
* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of twentyseven or a related project?
README
Twentyseven
Rubik's cube solver in Haskell.
Inspired by Herbert Kociemba's Cube Explorer.
The main idea is to precompute, for every configuration, the number of moves required to put certain subsets of the 27 cubies composing the 3x3 Rubik's cube in their right place and/or in the right orientation. This gives lower bounds used for an A⋆like search in the graph of scrambled cubes.
By default, a suboptimal "twophase" solver is used, as it runs rather quickly. It currently solves 1000 random cubes (uniformly distributed) in about one minute. The optimal solver is quite slow however, taking between five minutes and two hours to solve a random cube (18 moves in average).
The solver must precompute a certain number of lookup tables, which can be stored in files. These tables take fifteen seconds to compute and weigh 13MB for the twophase solver, compare that to about 8 hours and 2GB for the optimal one!
You may check the produced files with the checksums in tstables.sha256
.
A compressed archive tstables.zip
(723MB) of all precomputed tables is
available in the branch fetchtables
via gitlfs
. Unzip it in $HOME/.27/
,
or wherever (see usage below).
Usage summary
twentyseven [p] [strict] [d DIR] [optimal]
 For the first invocation, use
p
to precompute nonexistent lookup tables, otherwise an error is thrown whentwentyseven
tries to load them; strict
loads tables immediately, otherwise they are loaded "by need" (so you can also send it a cube to solve);d DIR
specifies the directory where the tables should be read and written (default:$HOME/.27/
).
The input is read line by line.
Input format
A line can be one of:
 A string of 54 characters (ignoring spaces) from a set of (almost any) 6 characters. Each character then corresponds to the color of one facelet, in the order illustrated below.
Output: a sequence of moves to unscramble it.
Facelets are numbered in base 9. Faces 0,1,2,3,4,5
correspond to U,L,F,R,B,D
.
00 01 02
03 04 05
06 07 08
10 11 12 20 21 22 30 31 32 40 41 42
13 14 15 23 24 25 33 34 35 43 44 45
16 17 18 26 27 28 36 37 38 46 47 48
50 51 52
53 54 55
56 57 58
 A dot
.
followed by a sequence of moves to scramble the cube.
The basic moves are given by a letter in [ULFRBD]
, or their lowercase
counterparts. Each letter corresponds to a clockwise quarter turn of the
given face (up, left, front, right, back, down). The orientation is
determined when looking directly at the turning face.
For every basic move, an optional suffix [23']
allows to specify a half
turn (e.g., U2
), equivalent to a sequence of two quarter turns (UU
), or a
counterclockwise quarter turn (e.g., U3
or U'
) equivalent to a sequence
of three clockwise (UUU
).
Output: a description of the resulting cube if the moves are applied starting
from the solved cube (in the format above, with letters ULFRBD
as
colors).
 The keyword
random
.
Output: a random solvable cube with uniform distribution.
 The keyword
quit
(or an endoffile) terminates the interactive session.
Example
Initialization
$ echo quittwentyseven p strict
Example
examples.txt
:
qwqwqwqwq erererere tytytytyt rerererer ytytytyty wqwqwqwqw
qwqwqwqwq erqrerere tytytytyt rerererer ytytytyty wqwqwqwqw
BBBBUBBBB UUUULUUUU RRRRFRRRR DDDDRDDDD LLLLBLLLL FFFFDFFFF
DDDFUDLRB FUFDLLLRR UBLBFDFUD ULBFRULLB RRRLBBRUB UBFFDFDRU
111121111 333313333 222232222 444454444 666646666 555565555
111111214 223222222 131333333 344444444 555555555 666666666
.udddlrrrbfffuddd
random
The output then looks like this:
$ twentyseven < examples.txt
U2 D2 L2 R2 F2 B2
Facelets [6,18,11] ("qtq") do not match any regular cubie.
U D F B L R U2 R2 F2 R2 U2 L2 B2 U' D' B2
U L B' L R2 D R U2 F U2 L2 B2 U B2 D' B2 U' R2 U L2 R2 U
U D L R F B U2 B2 L2 F2 D2 B2 R2 U' D' L2
L U' F2 U F2 U L U' L2 D F2 D' F2
BBBBUBBBB UUUULUUUU RRRRFRRRR DDDDRDDDD LLLLBLLLL FFFFDFFFF
BDLLUFBUD LBUBLURFL RLBFFBFRU RLFURULRR UBDRBRDDU DFBDDDFLF
Detail of current heuristics
The distance estimations are based on cosets corresponding to the following elements.
Twophase
Phase 1
 Corner Orientation × UD Slice
 Edge Orientation × UD Slice
It is possible to store the actual distances to the goal set in phase 1 but the current speed seems good enough for now.
Phase 2
 Corner Permutation × UD Slice Permutation (Phase 2)
 UD Edge Permutation (Phase 2) × UD SlicePermutation (Phase 2)
Optimal
 Corner Orientation × Edge Orientation × XY Slice Permutation, for XY in {UD, LR, FB}
 Corner Orientation × Corner Permutation