public void Init()
{
maze = new Maze(mazeWidth, mazeHeight);
rng = new Random(1001);
generator = new PrimsAlgorithm(rng);
generator.Generate(maze);
solver = new RecursiveSolver(maze);
}
static void BashThroughSudokus(string path, int number, int start = 0)
{
Shape shape = Shape.SquareGrid(3);
string [] lines = File.ReadAllLines(path);
ISolver solver = new RecursiveSolver();
SolverArgs args = new SolverArgs()
{
use_set_elimination = false
};
Stopwatch stopwatch = Stopwatch.StartNew();
for (int i = start; i < number + start; i++)
{
int [] grid = lines [i].Select(x => int.Parse(x.ToString())).ToArray();
int [] [] solution = solver.Solve(shape, grid, args, out int diff, out int [] [] fill_orders);
if (solution.Length != 1)
{
Console.WriteLine("!");
}
if ((i + 1) % 100 == 0)
{
Console.Write(".");
}
if ((i + 1) % 500 == 0)
{
Console.Write(" ");
}
if ((i + 1) % 1000 == 0)
{
Console.Write("\n");
}
if ((i + 1) % 5000 == 0)
{
Console.Write("\n");
}
}
double n = stopwatch.Elapsed.TotalSeconds / number;
Console.WriteLine("\n" + n * 1000 + "ms per sudoku.");
Console.WriteLine(1 / n + " sudoku per second.");
}
public static void Main(string[] args)
{
int limit = 20000;
int numIterations = 1000;
var recursiveSolver = new RecursiveSolver();
var iterativeSolver = new IterativeSolver();
Console.Write("Testing iterative approach... ");
GetAverageResults(numIterations, limit, iterativeSolver);
Console.Write("Testing recursive approach... ");
GetAverageResults(numIterations, limit, recursiveSolver);
Console.WriteLine("Complete!");
Console.ReadKey();
}
private void Button_Click(object sender, RoutedEventArgs e)
{
// Get a CurrencyHolder holding notations made from dataGrid data in notationsList
var holder = new CurrencyHolder(notationsList.Select(f => f.GetNotation()).ToList());
var value = inputTextBox.Text;
IChangeRounder rounder = null;
if (NoroundRadioButton.IsChecked.GetValueOrDefault(false))
{
rounder = new NoRounding();
}
if (NaiveroundingRadioButton.IsChecked.GetValueOrDefault(false))
{
rounder = new NaiveRounder();
}
IChangeSolver solver = null;
if (recursiveRadioButton.IsChecked.GetValueOrDefault(false))
{
solver = new RecursiveSolver(rounder);
}
if (iterativeRadioButton.IsChecked.GetValueOrDefault(false))
{
solver = new IterativeSolver(rounder);
}
if (solver != null && decimal.TryParse(value, out decimal amount))
{
solver.FindReturnFor(holder, amount);
// Update dataGrid with result
notationsList.ForEach(f => f.Update());
dataGrid.Items.Refresh();
changeLabel.Content = $"Amount left: {amount - holder.SumTaken()}";
}
else
{
changeLabel.Content = "Input is not a valid number";
inputTextBox.Text = "111.55";
}
}
static void SolveSome3x3Puzzle()
{
// Solve something
Shape shape3x3 = Shape.SquareGrid(3);
int [] clues = RecursiveSolver.Get3x3Grid(base_path + @"3x3 Puzzles\hard.txt");
int [] [] solutions = new RecursiveSolver().Solve(shape3x3, clues, new SolverArgs()
{
max_solutions = 2
}, out int difficulty, out int [] [] cell_orders);
shape3x3.Print(clues);
Console.WriteLine(difficulty);
foreach (int [] sol in solutions)
{
shape3x3.Print(sol);
}
}
private void MakeNonograms(bool createHandlers)
{
DrawDelayed(() => _solvedNonogram, 0, true);
DrawDelayed(() =>
{
var clone = _solvedNonogram.Clone() as Nonogram;
clone.Clear();
var solver = new ContradictionSolver();
solver.Solve(clone);
return(clone);
}, 1, createHandlers);
DrawDelayed(() =>
{
var clone = _solvedNonogram.Clone() as Nonogram;
var solver = new ContradictionSolver();
solver.SolveWithOneGuess(clone);
return(clone);
}, 2, createHandlers);
DrawDelayed(() =>
{
var clone = _solvedNonogram.Clone() as Nonogram;
var solver = new ArcConsistencySolver();
solver.Solve(clone);
return(clone);
}, 3, createHandlers);
DrawDelayed(() =>
{
var clone = _solvedNonogram.Clone() as Nonogram;
var solver = new RecursiveSolver();
solver.Solve(clone);
return(clone);
}, 4, createHandlers);
}
static void Main(string[] args)
{
Console.CursorVisible = false;
r = new Random((int)DateTime.Now.Ticks);
maze = new Maze(mazeWidth, mazeHeight);
display = new char[mazeWidth * offset, mazeHeight *offset];
Console.WriteLine("Choose a type of maze to generate:\n");
Console.WriteLine("1: Recursive Backtracker");
Console.WriteLine("2: Randomised Prim's Algorithm");
var mazeOption = Console.ReadKey().Key;
IMazeGenerator generator;
switch (mazeOption)
{
case ConsoleKey.D2:
generator = new PrimsAlgorithm(r);
break;
case ConsoleKey.D1:
default:
generator = new RecursiveBacktracker(r);
break;
}
Console.Clear();
Console.WriteLine("Choose a type of solver, if any:\n");
Console.WriteLine("0: No solver");
Console.WriteLine("1: Recursive Solver");
Console.Write("2: A* Solver");
var solverOption = Console.ReadKey().Key;
ISolver solver;
switch (solverOption)
{
case ConsoleKey.D1:
solver = new RecursiveSolver(maze);
break;
case ConsoleKey.D2:
solver = new AStar(maze);
break;
default:
solver = null;
break;
}
while (true)
{
maze.InitialiseNodes();
generator.Generate(maze);
Console.Clear();
for (int h = 0; h < mazeHeight; h++)
{
for (int w = 0; w < mazeWidth; w++)
{
WriteNodeChar(w, h, maze[(uint)w, (uint)h].Walls);
}
}
if (solver != null)
{
Random r = new Random();
NodePtr startPoint = new NodePtr((uint)maze.Width + 1, (uint)maze.Height + 1); // Purposefully not valid
NodePtr endPoint = new NodePtr((uint)maze.Width + 1, (uint)maze.Height + 1);
while (true)
{
//TODO: Probably refactor
var startPointIsValid = maze.IsPointValid(startPoint);
var endPointIsValid = maze.IsPointValid(endPoint);
if (startPointIsValid && endPointIsValid)
{
break;
}
if (!startPointIsValid)
{
startPoint = new NodePtr((uint)r.Next(maze.Width), (uint)r.Next(maze.Height));
}
if (!endPointIsValid)
{
endPoint = new NodePtr((uint)r.Next(maze.Width), (uint)r.Next(maze.Height));
}
}
var solution = solver.Solve(startPoint, endPoint);
if (solution != null)
{
WriteSolution(startPoint, endPoint, solution);
Console.WriteLine(string.Format("Solving for: Start - {0}x, {1}y; End - {2}x, {3}y",
startPoint.x, startPoint.y,
endPoint.x, endPoint.y));
}
else
{
Console.WriteLine("Cannot find a Solution.....");
}
}
DrawDisplay();
Console.WriteLine();
Console.WriteLine("Press any key to regenerate, or Escape to exit....");
if (Console.ReadKey().Key == ConsoleKey.Escape)
{
break;
}
}
}
public void TestCustomNotationsWithLeftover()
{
IChangeSolver solver = new RecursiveSolver(_rounder);
SolverTestsCommon.TestCustomNotationsWithLeftover(solver);
}
public void TestComplicatedNumber()
{
IChangeSolver solver = new RecursiveSolver(_rounder);
SolverTestsCommon.TestComplicatedNumber(solver);
}
public static int [] GeneratePuzzle(Shape shape, int [] solution, int seed = 0, int min_clues = 0)
{
int [] initial_board = (int [])solution.Clone();
Random rng = new Random(seed);
int iterations = 0;
int best_score = 0;
int [] best_board = null;
try {
RecursiveRemove(initial_board, 0, 0);
} catch (GetMeOutOfHereException) {
return(best_board);
}
throw new Exception("This code should never be executed.");
void RecursiveRemove(int [] board, int groups_gone, int squares_gone)
{
int [] class_order = Utils.RandomPermutation(rng, shape.symmetry.cells_by_class.Length, 0);
// Request that higlighted groups are removed first
if (false && shape.highlight != null && shape.highlight.Any())
{
int i = class_order.Length - 1;
int j = 0;
while (i >= j)
{
if (shape.symmetry.cells_by_class [class_order [i]]
.Select(x => shape.highlight [x])
.Any()
)
{
int temp = class_order [i];
class_order [i] = class_order [j];
class_order [j] = temp;
j += 1;
}
else
{
i -= 1;
}
}
}
// Console.WriteLine (string.Join (",", class_order.Select (x => x.ToString ())));
for (int i = 0; i < class_order.Length; i++)
{
// Check if this has already been removed
if (board [shape.symmetry.cells_by_class [class_order [i]] [0]] == 0)
{
continue;
}
// Buck out after too many iterations (so this function doesn't hang forever)
iterations++;
if (iterations > 100)
{
throw new GetMeOutOfHereException(board);
}
// Construct new board
int [] points = shape.symmetry.cells_by_class [class_order [i]];
// Check if too few clues are left
if (shape.num_cells - points.Length - squares_gone < min_clues)
{
continue;
}
int [] new_board = (int [])board.Clone();
for (int j = 0; j < points.Length; j++)
{
new_board [points [j]] = 0;
}
// Check that every letter in the alphabet appears once
bool [] has_been_used = new bool [shape.group_size];
for (int b = 0; b < shape.num_cells; b++)
{
if (new_board [b] > 0)
{
has_been_used [new_board [b] - 1] = true;
}
}
bool any_missing = false;
for (int v = 0; v < shape.group_size; v++)
{
if (!has_been_used [v])
{
any_missing = true;
break;
}
}
if (any_missing)
{
continue;
}
// Check for solutions
try {
int [] [] solutions = new RecursiveSolver().Solve(
shape,
new_board,
new SolverArgs()
{
max_solutions = 2, iteration_limit = 50000
},
out int diff,
out int [] [] cell_fill_orders
);
if (solutions.Length == 1)
{
int score = squares_gone + diff;
if (score > best_score)
{
best_score = score;
best_board = new_board;
}
RecursiveRemove(new_board, groups_gone + 1, squares_gone + points.Length);
}
} catch (RecursiveSolver.TooManyIterationsException) {
}
}
}
}
public int [] PopulateGrid(Shape shape, PopulatorArgs args, int [] grid = null)
{
// Fill in the first group
int [] full_grid = new int [shape.num_cells];
Random rng = new Random(args.random_seed);
if (grid == null)
{
int [] perm = Utils.RandomPermutation(rng, shape.group_size);
for (int i = 0; i < shape.group_size; i++)
{
full_grid [shape.cells_by_group [0, i]] = perm [i];
}
}
else
{
Array.Copy(grid, full_grid, grid.Length);
for (int i = 0; i < shape.num_groups; i++)
{
bool [] has_been_found = new bool [shape.group_size];
for (int j = 0; j < shape.group_size; j++)
{
int v = full_grid [shape.cells_by_group [i, j]];
if (v > 0)
{
if (has_been_found [v - 1])
{
throw new DuplicateElementInGroupException("Duplicate element in a group.", v - 1);
}
has_been_found [v - 1] = true;
}
}
}
}
try {
int [] [] solutions = new RecursiveSolver().Solve(
shape,
full_grid,
new SolverArgs(args)
{
rng = rng, max_solutions = args.print_fixed_cells ? 10 : 1, iteration_limit = 10_000_000
},
out int difficulty,
out int [] [] cell_fill_orders
);
if (args.print_fixed_cells)
{
int [] fixed_cells = (int [])solutions [0].Clone();
Console.WriteLine(solutions.Length);
for (int i = 1; i < solutions.Length; i++)
{
for (int j = 0; j < shape.num_cells; j++)
{
if (fixed_cells [j] != 0 && solutions [i] [j] != fixed_cells [j])
{
fixed_cells [j] = 0;
}
}
}
shape.Print(fixed_cells, args.alphabet);
}
if (solutions.Length == 0)
{
throw new GridNotSolubleException("Grid could not be completed.");
}
return(solutions [0]);
} catch (RecursiveSolver.TooManyIterationsException) {
public SolveResult Solve(IProblemDefinition gridToSolve)
{
var iterativeSolver = new RecursiveSolver(gridToSolve.PossibilitiesSquareGrid);
return iterativeSolver.Solve(gridToSolve.StartingKnownSquares);
}