private static int Generate(int size, SudokuDifficulty difficulty, String outfile)
{
SudokuPuzzle sudoku = SudokuGenerator.Generate(size, difficulty);
if (outfile is null)
{
Console.WriteLine(sudoku);
}
else
{
if (Program.WriteToFile(sudoku.ToString(), outfile))
{
Console.WriteLine($"Generated sudoku written to {outfile}");
}
else
{
Console.WriteLine(Program.FileOutputErrorMessage);
return(Program.FileOutputError);
}
}
return(0);
}
public ActionResult <SudokuPuzzleDTO> Generate(SudokuDifficulty difficulty, int?seed)
{
ISudokuGenerator generator = new SudokuGenerator();
ISudokuPuzzle puzzle = generator.Generate(difficulty, seed);
SudokuPuzzleDTO puzzleDTO = new SudokuPuzzleDTO()
{
Puzzle = puzzle.ToString(),
Seed = puzzle.Id
};
return(puzzleDTO);
}
internal static int Main(String[] args)
{
if (!Console.IsInputRedirected)
{
Console.Title = "Sudoku";
}
if (args.Length == 0)
{
if (Console.IsInputRedirected || Console.IsOutputRedirected)
{
Console.WriteLine(Program.IOErrorMessage);
return(Program.IOError);
}
Window window = new Window(SudokuGenerator.Generate(Program.DefaultSize, Program.DefaultDifficulty));
window.Init();
return(0);
}
if (!Program.ParseArguments(args, out int command, out int size, out SudokuDifficulty difficulty, out String filename, out String outfile))
{
Console.WriteLine(Program.UsageMessage);
return(Program.UsageMessageWarning);
}
switch (command)
{
case Program.CompareCommand:
return(Program.Compare(filename, outfile));
case Program.EnumerateCommand:
return(Program.Enumerate(filename));
case Program.GenerateCommand:
return(Program.Generate(size, difficulty, outfile));
case Program.InteractiveCommand:
return(Program.Interactive(size, filename));
case Program.PrintCommand:
return(Program.Print(filename));
case Program.SolveCommand:
return(Program.Solve(filename, outfile));
default:
Console.WriteLine(Program.UsageMessage);
return(Program.UsageMessageWarning);
}
}
/// <summary>
/// Run generation with ability to cancel
/// </summary>
private async Task Generate()
{
using (var generationTokenSource = new CancellationTokenSource())
{
var generationSettings = new GenerationSettings
{
Difficulty = _model.SudokuDifficulty,
Symmetry = _model.SudokuSymmetry,
DifficultyPoints = _model.DifficultyPoints
};
var generationTask = Task.Run(() =>
{
_model.CurrentSudoku = SudokuGenerator.Generate(generationSettings, generationTokenSource.Token);
}, generationTokenSource.Token);
while (true)
{
using (var delayToken = CancellationTokenSource.CreateLinkedTokenSource(generationTokenSource.Token))
{
var delayTask = Task.Delay(5_000, delayToken.Token);
var finishedTask = await Task.WhenAny(generationTask, delayTask);
if (finishedTask != generationTask)
{
if (AskToWait())
{
continue;
}
generationTokenSource.Cancel();
await generationTask.ContinueWith(task => Console.WriteLine(@"Generation task cancelled"),
TaskContinuationOptions.OnlyOnCanceled);
break;
}
delayToken.Cancel();
await delayTask.ContinueWith(task => Console.WriteLine(@"Delay task cancelled"),
TaskContinuationOptions.OnlyOnCanceled);
break;
}
}
}
}
public void GenerateSudokuTest(Enums.SudokuDifficulty diff, int threshold)
{
var sudoku = SudokuGenerator.GenerateFull();
sudoku.Transpose();
Assert.AreEqual(true, CheckSudoku(sudoku));
sudoku.SwapSmallRows(0, 0, 2);
Assert.AreEqual(true, CheckSudoku(sudoku));
sudoku.SwapBigRows(0, 2);
Assert.AreEqual(true, CheckSudoku(sudoku));
SudokuGenerator.RunShuffle(sudoku, 10, CancellationToken.None);
Assert.AreEqual(true, CheckSudoku(sudoku));
var settings = new GenerationSettings
{
Difficulty = Enums.SudokuDifficulty.Medium
};
sudoku = SudokuGenerator.Generate(settings, CancellationToken.None);
Assert.GreaterOrEqual(sudoku.DifficultyPoints, Domain.Sudoku.MediumThreshold);
}
public void Create(Difficult difficult)
{
SudokuGenerator.Generate(table, size, difficult);
}