• Write a better initial board/initial layout validation code for the online solver (at least initially]):

    • Exact number of playstacks. (requires introspection).

    • Number of Freecells not exceeded. (requires introspection).

    • missing/extra cards.

    • whitespace gaps.

    • invalid characters.

    • misformatting of the format.

  • Currently var_base*.h use many type casting and other minor inefficiencies. Refactor/optimize to avoid that.

  • Try different fcs_hash.c hash fill factors, and try to avoid unnecessary calculations to check if it should be rehashed.

  • Try to convert to an open addressing hash instead of chaining (for better memory localisation).

  • Find how well the solver performs with different permutations of the order of columns/freecells.

    • See if it’s possible to combine several scans on such different permutations.

  • Write a "simulator" for new flare-based runs to see how they improve on the existing runs. It will process the scans' command line based on their end results and performance and will generate the new estimated performance.

  • Write the split-dbm-solver which stores the results on the disk for every non-reversible-moves offset, and fully-connected-components.

  • Refer to expand-solitaire-multi-card-moves from the fc-solve process.

  • Create a displayer for fc-solve’s solutions which will allow seeing where a card was moved from (using a colored →) and where it was placed.

    • Create a GUI version.

  • If -opt is specified for the flare, then make sure that if the flares loop stop it when it’s doing the optimization scan, then the optimization scan goes on until it ends.

    • Not sure about it.

  • Investigate a way to have positions_by_rank also index according to the suit, and to traverse only the possible parents or children based on the suit.

  • In the states handling, there’s still some room for pointer arithmetics.

  • Implement more of Kevin Atkinson’s Common Lisp solver’s atomic move types, and try to construct good heuristics out of them.

  • Play with writing a memory-re-cycling Soft-DFS scan: if a sub-tree was marked as a dead-end, then its states might be able to be placed on a linked list of states that can be reused.

  • PySolFC Deal No. 48007594292403677907 :

shlomif:~$ -t -F 48007594292403677907 | fc-solve -l cpb -sam | grep ^Move | wc -l
shlomif:~$ -t -F 48007594292403677907 | fc-solve --method a-star -to 01234675 -asw 300,1500,0,2,50000 -sam | grep ^Move | wc -l
shlomif:~$ -t -F 48007594292403677907 | fc-solve --method a-star -to 01234675 -asw 40,2,40,0,40 -sam | grep ^Move | wc -l
shlomif:~$ -t -F 48007594292403677907 | fc-solve --method a-star -to 0123467589 -asw 300,1500,0,2,50000 -sam | grep ^Move | wc -l
shlomif:~$ -t -F 48007594292403677907 | fc-solve --method a-star -to 0123467589 -asw 300,1500,0,2,40000 -sam | grep ^Move | wc -l
shlomif:~$ -t -F 48007594292403677907 | fc-solve --method a-star -to 0123467589 -asw 300,1500,0,2,60000 -sam | grep ^Move | wc -l
shlomif:~$ -F -t 91151234961275807905 | ~/apps/test/fcs/bin/fc-solve  -p -t -sam --method a-star -to 0123467589 -asw 300,1000,0,2,90000 | grep ^Move | wc -l

However this scan generates takes too much time for most boards (over 100K iterations).

  • PySolFC deal No. 03620802041832966472:

shlomif[fcs]:$trunk/fc-solve/source$ -t -F 03620802041832966472  | ./scripts/summarize-fc-solve -- --method a-star -to 0123467589 -asw 300,1500,99,2,65000
Verdict: Solved ; Iters: 156 ; Length: 87
  • I solved it at length 87.

    • PySolFC deal No. 54369539487824719321:

shlomif[fcs]:$trunk/fc-solve/source$ -F -t 54369539487824719321 | ./scripts/summarize-fc-solve --method a-star -to 0123456789 -asw 3000,100,60,0,500
Verdict: Solved ; Iters: 1325 ; Length: 115
  • Shlomi Fish solved it in under 110 moves.

    • PySolFC deal 96166640969002647853:

shlomif[fcs]:$trunk/fc-solve/source$ -F -t 96166640969002647853 | ./scripts/summarize-fc-solve --method a-star -to 0123467589 -asw 370,0,0,2,90000
Verdict: Solved ; Iters: 615 ; Length: 77
  • Shlomi Fish solved it in 77 moves.

    • PySolFC deal 26892246862786948900:

shlomif[fcs]:$trunk/fc-solve/source$ -F -t 26892246862786948900 | perl scripts/summarize-fc-solve -l qsi --flares-choice fc_solve
Verdict: Solved ; Iters: 195331 ; Length: 98
shlomif[fcs]:$trunk/fc-solve/source$ -F -t 26892246862786948900 | perl scripts/summarize-fc-solve --method a-star -asw '1,0,4,0,4'   --flares-choice fc_solve
Verdict: Solved ; Iters: 111 ; Length: 92
  • Shlomi Fish solved it in 92 moves.

    • Add the new Freecell Solver-compatible game variants of PySolFC.

    • Convert magic rank constants such as 1 or 13 to FCS_MAX_RANK and FCS_RANK_ACE/etc.

    • Investigate:

$ -F -t 00682189035907813607 | perl ../scripts/summarize-fc-solve -l qsi
Verdict: Solved ; Iters: 157905 ; Length: 109
$ -F -t 00682189035907813607 | perl ../scripts/summarize-fc-solve --method a-star -to '01234567' -asw 1 -opt
Verdict: Solved ; Iters: 433 ; Length: 89


  • Integrate the patsolve’s prioritization and mixed BFS/DFS scan.

  • Update the architecture document.

  • Make a super-strict parsable-output without all the quirks of -p -t (see Games-Solitaire-Verify for why).

  • Write a multi-threaded version.

  • Port to Java (?)

  • Add a switch to ask the user if he wants to continue and enter a bigger iterations limit.

  • Check for unmalloced data and if so gracefully exit.

  • Experiment with a delta-based state storage.

  • Make the dbm_fc_solver not dependent on by implementing our own big ints.

  • Adapt the scans based on the parameters of the initial board.

    • Try to find a correlation between various parameters of the initial board (such as those calculated in the A* scan or the number of steps required to sort the cards in each column by rank), and the performance of various scans and then:

      1. Calculate the initial parameters on startup.

      2. See what would be a good meta-scan based on them.

      3. Use it.

  • Unit-test fc_solve_compare_lru_cache_keys in scans.c.

  • Interactive mode? Continue a scan that reached its limit.

  • Get the tests to run and pass on MS Windows (32-bit/64-bit) and implement AppVeyor Continuous Integration.

To be considered

  • Make the code splint-clean.

  • Write a multi-process client/server program.

  • Add a limit to stacks number (in the case of Indirect Stack States), number of states that are stored anywhere, etc.