static void Main(string[] args)
{
string line;
List<long> times = new List<long>();
StreamReader file = new StreamReader(args[0]);
while ((line = file.ReadLine()) != null)
{
Solver solver = new Solver(line);
Console.WriteLine("Solving: \n" + solver.ToString());
Stopwatch sw = new Stopwatch();
sw.Restart();
solver.Solve();
sw.Stop();
times.Add(sw.ElapsedMilliseconds);
Console.WriteLine("Solved: \n" + solver.ToString() + "\nin " + sw.ElapsedMilliseconds + " miliseconds\n");
}
file.Close();
Console.WriteLine("");
Console.WriteLine("Times:");
foreach (long time in times.OrderBy(x => x))
{
Console.WriteLine(time);
}
Console.WriteLine("Medium: " + times.Sum(x => x) / times.Count);
Console.ReadKey();
}
public void TestSolve()
{
// int[][] input = new int[4][]{new int[4]{1,0,0,0}, new int[4]{0,0,0,3}, new int[4]{4,0,0,0}, new int[4]{0,2,0,0}};
int[][] input = new int[9][] {new int[9]{ 9,0,0,1,3,0,4,0,0}, new int[9]{ 0,5,0,8,9,6,3,7,0}, new int[9]{ 0,2,6,0,0,4,0,0,0},
new int[9]{ 0,0,1,6,4,7,0,0,0}, new int[9]{ 8,6,7,5,0,9,0,0,0}, new int[9]{0,0,0,2,0,3,0,0,0} ,
new int[9]{6,0,0,3,0,0,9,4,0}, new int[9]{0,1,3,9,2,5,0,6,0}, new int[9]{0,0,5,4,0,0,1,0,3}};
int[][] input2 = new int[9][]{ new int[9]{5,2,0,0,0,4,0,0,0}, new int[9]{8,0,7,0,0,1,0,0,0} , new int[9]{0,1,3,5,0,0,2,0,8},
new int[9]{0,8,0,1,6,0,0,0,4},new int[9]{6,9,0,0,0,0,0,8,2} , new int[9]{3,0,0,0,5,8,0,1,0},
new int[9]{2,0,6,7,0,5,8,4,0}, new int[9]{0,0,0,4,0,0,3,0,0}, new int[9]{1,0,0,8,0,0,0,0,5}};
//2 star puzzle in hindu -- SOLVED IN 0.09 Secs !!
int[][] input3 = new int[9][]{ new int[9]{6,0,9,0,0,0,7,3,0} , new int[9]{0,3,7,0,1,9,0,0,0}, new int[9]{0,1,0,4,0,0,0,9,0} , new int[9]{0,2,0,0,0,0,0,0,0}, new int[9]{0,0,0,3,5,2,0,0,0}, new int[9]{0,0,0,0,0,0,0,6,0},
new int[9]{0,8,0,0,0,1,0,7,0}, new int[9]{0,0,0,9,7,0,2,5,0} , new int[9]{0,7,5,0,0,0,3,0,4} };
//5 star from hindu - SOLVED IN 0.08 secs !
int[][] input4 = new int[9][]{ new int[9]{0,4,0,5,0,0,0,0,0} , new int[9]{0,0,3,0,0,2,0,1,4}, new int[9]{0,0,8,0,0,7,0,5,0},
new int[9]{2,0,0,0,0,0,4,6,0}, new int[9]{3,0,0,0,0,0,0,0,1}, new int[9]{0,1,4,0,0,0,0,0,7}, new int[9]{0,2,0,9,0,0,3,0,0},
new int[9]{7,8,0,2,0,0,6,0,0} , new int[9]{0,0,0,0,0,4,0,9,0}};
Solver s = new Solver();
// Display2x2(input);
int[][] output = s.Solve(input4);
// Console.WriteLine(output[0][2]);
Display2x2(output);
}
private void checkSudokuButton_Click(object sender, RoutedEventArgs e)
{
string sudoku = sudokuTextBox.Text;
if (sudoku == "test")
{
sudoku = exampleSudoku;
}
checker = new Checker(sudoku);
outputTextBlock.Text = checker.FormatSudoku();
Solver solver = new Solver(sudoku);
outputTextBlock.Text = String.Join(",", solver.GetEmptyPlacesPerSquare());
}
public Vm()
{
Board = new SudokuBoard();
this.PropertyChanged += (sender, args) =>
{
if (args.PropertyName =="Board")
{
if(_notNewBoard)
return;
_solver = new Solver(Board);
}
};
_solver = new Solver(Board);
SaveCommand = new RelayCommand(o => Save());
SaveAsCommand = new RelayCommand(o=> SaveAs());
OpenCommand = new RelayCommand(o => Open());
NewCommand = new RelayCommand(o => New());
NextCommand = new RelayCommand(o=>Next(),o=>!_solver.IsDone);
}
public static void Main()
{
Console.WriteLine("Enter Suduko here:");
var input = Console.ReadLine();
var sudoku = new Sudoku(input);
var displayer = new Displayer();
displayer.Show(sudoku);
Console.WriteLine();
Console.WriteLine("Show solve? (y/n)");
var showSolve = Console.ReadLine() == "y";
var solver = new Solver(sudoku, showSolve);
Console.WriteLine();
Console.WriteLine("***SOLVING***");
Console.WriteLine();
solver.Solve();
Console.WriteLine("SOLUTION:");
Console.WriteLine();
displayer.Show(sudoku);
Console.ReadLine();
}
static void Main(string[] args)
{
// Initialise board
Board b = new Board();
b.set(new int[,] {
{ 0,1,4, 2,0,0, 0,9,0},
{ 0,2,0, 0,0,0, 0,0,3},
{ 0,6,5, 0,8,0, 0,4,0},
{ 0,0,8, 0,3,0, 0,0,0},
{ 2,0,0, 5,0,7, 0,0,8},
{ 0,0,0, 0,4,0, 6,0,0},
{ 0,8,0, 0,2,0, 1,6,0},
{ 4,0,0, 0,0,0, 0,5,0},
{ 0,7,0, 0,0,5, 9,8,0} });
//b.set(new int[,] {
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0},
// { 0,0,0, 0,0,0, 0,0,0} });
//b.set(new int[,]
//{
// { 0,6,1, 2,0,8, 3,0,9},
// { 0,0,0, 0,0,1, 4,0,2},
// { 0,0,2, 0,0,0, 6,0,0},
// { 6,2,0, 0,5,3, 0,0,4},
// { 5,0,0, 0,8,0, 0,0,6},
// { 1,0,0, 6,2,0, 0,7,3},
// { 0,0,4, 0,0,0, 7,0,0},
// { 8,0,6, 3,0,0, 0,0,0},
// { 3,0,5, 7,0,2, 9,6,0}
//});
// Ask user for input
string input = "";
int x = 0, y = 0, value = 0;
string[] split;
while (true)
{
Console.Clear();
b.render();
Console.WriteLine("Enter data in the format [x y value], or enter 0 to solve: ");
input = Console.ReadLine();
split = input.Split(' ');
if (split.Length == 3)
{
x = Int32.Parse(split[0]);
y = Int32.Parse(split[1]);
value = Int32.Parse(split[2]);
b.set(x, y, value);
} else if (input == "0")
{
break;
}
}
// Attempt to solve sudoku
Solver s = new Solver(b.copy());
Stopwatch watch = new Stopwatch();
watch.Start();
Board result = s.solve();
watch.Stop();
// Check complete
if (result == null || !result.checkComplete())
{
Console.WriteLine(":( Unable to solve.");
}
else
{
Console.Clear();
b.render();
Console.WriteLine("Solved! Time used " + watch.Elapsed.TotalMilliseconds + "ms. Here it is: ");
result.render();
}
}
private void Next()
{
_solver = _solver.Next();
_notNewBoard = true;
Board= _solver.Board;
_notNewBoard = false;
}
public void Then_the_sudoku_solver_enters_the_correct_value_for_me()
{
var singleGridValue = new Solver().Solve(1);
Assert.AreEqual(1, singleGridValue.Single().Value);
}
static void Main(string[] args)
{
string pathSudokuFolder = Environment.CurrentDirectory + "/Sudoku/";
DirectoryInfo di = new DirectoryInfo(pathSudokuFolder);
if (!di.Exists)
{
di.Create();
}
Solver solver;
Reader reader = new Reader();
string question;
List <string> menu;
int selected;
int selectedSudoku;
int[,] sudoku;
while (true)
{
reader.ListSudoku();
reader.Read();
question = "What would you like to do ?";
menu = new List <string>(new string[] { "Solve", "Generate", "Import", "Remove", "Quit" });
selected = GenerateMenu(question, menu);
switch (selected)
{
case 0:
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--< Solver >--");
Console.WriteLine();
Console.ResetColor();
menu = reader.getListSudokuName();
if (menu.Count == 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The sudoku folder is empty ! Please generate or import one grid.");
Console.ResetColor();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
}
question = "Which sudoku do you want to solve ?";
selectedSudoku = GenerateMenu(question, menu);
sudoku = reader.getListSudoku()[selectedSudoku];
question = "Do you want to display the resolution animation ?";
menu = new List <string>(new string[] { "Yes", "No" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("PrintGrid", "true");
}
else
{
ConfigurationManager.AppSettings.Set("PrintGrid", "false");
}
question = "Do you want to use AC-3 ?";
menu = new List <string>(new string[] { "Yes", "No" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("AC3", "true");
}
else
{
ConfigurationManager.AppSettings.Set("AC3", "false");
}
question = "Which algorithm do you want to use to decide which box is the best to fill ?";
menu = new List <string>(new string[] { "MRV", "Degree Heuristics", "Random" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("VarChoose", "MRV");
}
else if (selected == 1)
{
ConfigurationManager.AppSettings.Set("VarChoose", "DH");
}
else
{
ConfigurationManager.AppSettings.Set("VarChoose", "null");
}
question = "Which algorithm do you want to use to decide which number is the best to write ? (when multiple number are possible for a box)";
menu = new List <string>(new string[] { "LCV", "Random" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("LCV", "true");
}
else
{
ConfigurationManager.AppSettings.Set("LCV", "false");
}
string name = reader.getListSudokuName()[selectedSudoku];
solver = new Solver(sudoku);
solver.PrintGrid();
question = "Do you want to start the solver for this grid and with parameters configure just before?";
menu = new List <string>(new string[] { "Yes", "No" });
selected = GenerateMenu(question, menu);
if (selected == 1)
{
break;
}
Console.Clear();
Console.WriteLine("\t\tSolving sudoku : {0}", name);
Stopwatch stopwatch = new Stopwatch();
stopwatch.Start();
int res = solver.Run();
Console.WriteLine();
if (res == 0)
{
Console.WriteLine("Solve !");
}
else
{
Console.WriteLine("Can't be solve ! Please check if your grid is correct.");
}
stopwatch.Stop();
TimeSpan elapsed_time = stopwatch.Elapsed;
solver.PrintGridEvolution();
Console.WriteLine("Time to solve (hh:mm:ss) : {0}", elapsed_time);
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
case 1:
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--< Generator >--");
Console.WriteLine();
Console.ResetColor();
question = "Do you want to display the resolution animation ?";
menu = new List <string>(new string[] { "Yes", "No" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("PrintGrid", "true");
}
else
{
ConfigurationManager.AppSettings.Set("PrintGrid", "false");
}
question = "Choose a difficulty for the generate sudoku :";
menu = new List <string>(new string[] { "Easy", "Medium", "Hard" });
selected = GenerateMenu(question, menu);
if (selected == 0)
{
ConfigurationManager.AppSettings.Set("Generate", "easy");
}
else if (selected == 1)
{
ConfigurationManager.AppSettings.Set("Generate", "medium");
}
else
{
ConfigurationManager.AppSettings.Set("Generate", "hard");
}
Console.Write("Choose a name for the sudoku : ");
string sudokuName = Console.ReadLine();
Console.Clear();
Generator generate;
generate = new Generator(sudokuName);
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
case 2:
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--< Import >--");
Console.WriteLine();
Console.ResetColor();
Console.ForegroundColor = ConsoleColor.DarkYellow;
Console.WriteLine("To import a sudoku, please indicate the path of the file");
Console.WriteLine("The grid has to be a matrix of 9x9 size which values correspond to the number of the sudoku and empty box are equals to 0");
Console.WriteLine("The file has to be in .txt format");
Console.WriteLine();
Console.ResetColor();
Console.WriteLine("Example :");
Console.WriteLine("040000179\n" +
"002008054\n" +
"006005008\n" +
"080070910\n" +
"050090030\n" +
"019060040\n" +
"300400700\n" +
"570100200\n" +
"928000060\n");
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Cyan;
Console.Write("Path : ");
Console.ResetColor();
string path = Console.ReadLine();
if (File.Exists(path))
{
string filename = Path.GetFileName(path);
string ext = filename.Split('.')[1];
if (ext == "txt")
{
try
{
int [,] mySudoku = reader.FileToArray(path);
File.Copy(path, pathSudokuFolder + filename);
}
catch
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Wrong sudoku grid format ! Please check if it's the same format at the example");
Console.ResetColor();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("Wrong file extension ! Please provide a .txt file");
Console.ResetColor();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
}
}
else
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The path is Wrong ! Couldn't find the file");
Console.ResetColor();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
}
break;
case 3:
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--< Remove >--");
Console.WriteLine();
Console.ResetColor();
menu = reader.getListSudokuName();
if (menu.Count == 0)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine("The sudoku folder is empty !");
Console.ResetColor();
Console.WriteLine("Press any key to continue");
Console.ReadKey();
break;
}
question = "Which sudoku do you want to remove ?";
selectedSudoku = GenerateMenu(question, menu);
string gridRemoveName = reader.getListSudokuName()[selectedSudoku];
File.Delete(pathSudokuFolder + gridRemoveName);
break;
case 4:
Console.ForegroundColor = ConsoleColor.Blue;
Console.WriteLine("--< Quit >--");
Console.WriteLine();
Console.ResetColor();
question = "Do you want to clean the sudoku folder ?";
menu = new List <string>(new string[] { "No", "Yes" });
selected = GenerateMenu(question, menu);
if (selected == 1)
{
di.Delete(true);
}
System.Environment.Exit(1);
break;
}
Console.Clear();
}
}
// Submit button - run the Solver and write the results to the text boxes
private void button1_Click(object sender, EventArgs e)
{
Solver solver = new Solver(grabUserInput());
int[,] results = solver.solve();
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
textBoxes[i, j].Text = results[i, j].ToString();
}
}
}
private void SetApplication(Solver.Status appStatus)
{
switch (appStatus)
{
case (Solver.Status.Start):
toolStripStatusLabel1.Text = "Searching...";
panelSudokuTable.Enabled = false;
solveToolStripMenuItem.Enabled = false;
buttonStart.Enabled = false;
break;
case(Solver.Status.Solved):
toolStripStatusLabel1.Text = "Solved!";
panelSudokuTable.Enabled = true;
solveToolStripMenuItem.Enabled = true;
break;
case(Solver.Status.Error):
toolStripStatusLabel1.Text = "Error!";
panelSudokuTable.Enabled = true;
solveToolStripMenuItem.Enabled = true;
buttonStart.Enabled = true;
break;
}
}
private void EndCallback(Solver.Status appStatus)
{
this.BeginInvoke(new SetApplicationDlg(SetApplication), appStatus);
}
private static void Main(string[] args)
{
Solver.Solve(Grid.Load(SudokuMedium));
Console.ReadKey();
}
public IOHandler()
{
solver = new Solver();
}
public void SolveStep()
{
if (FindSimple())
{
_innerResults.Add(SolverResult.FoundOne);
return;
}
if (FindIntersect())
{
_innerResults.Add(SolverResult.FoundOne);
return;
}
if (Board.AllCells.Any(c => !c.HasValue && !c.PossibleValues.Any()))
{
_innerResults.Add(SolverResult.Error);
return;
}
var remainingCells = Board.AllCells.Where(c => !c.HasValue).ToArray();
if (!remainingCells.Any())
{
_innerResults.Add(SolverResult.Done);
return;
}
int min = remainingCells.Min(x => x.PossibleValues.Count);
SudokuCell guessCell = remainingCells.First(x => x.PossibleValues.Count == min);
for (int index = 0; index < guessCell.PossibleValues.Count; index++)
{
SudokuBoard sudokuBoard = Board.Clone();
sudokuBoard.Cells[guessCell.RowIndex, guessCell.ColumnIndex].GuessValue =
guessCell.PossibleValues[index];
var solver = new Solver(this, sudokuBoard);
_guessSolvers.Add(solver);
_solverCount++;
}
_innerResults.Add(SolverResult.Guessed);
return;
}
static void Main(string[] args)
{
if (args.Length == 0 || args.Length == 1 && args[0] == "-h")
{
printHelp();
return;
}
Board sudokuBoard;
try
{
sudokuBoard = FileInterface.readFromFile(args[0]);
}
catch (Exception e)
{
if (File.Exists(args[0]))
{
string[] allLines = File.ReadAllLines(args[0]);
foreach (string l in allLines)
{
Console.WriteLine(l);
}
}
Console.WriteLine();
Console.WriteLine(e.Message);
return;
}
Board initialBoard = new Board(sudokuBoard);
Tracker tracker = new Tracker(sudokuBoard);
Solver solver = new Solver(tracker);
tracker = solver.run();
if (!tracker.valid)
{
Console.WriteLine("ERROR: Invalid puzzle.");
return;
}
if (tracker.solutionCnt > 1)
{
Console.WriteLine("WARNING: More than one solution found. One is shown.");
}
if (args.Length > 1)
{
using (var writer = new StreamWriter(args[1]))
{
Console.SetOut(writer);
FileInterface.writeToFile(initialBoard, tracker.board, solver, solver.totalTimeElapsed);
}
}
else
{
FileInterface.writeToFile(initialBoard, tracker.board, solver, solver.totalTimeElapsed);
}
Console.SetOut(new StreamWriter(Console.OpenStandardOutput()));
}
public Solver(Solver antecedent, SudokuBoard board)
{
_antecedent = antecedent;
Board = board;
}
public Solver(Solver antecedent, SudokuBoard board)
{
this.antecedent = antecedent;
this.Board = board;
}
private void bgWorker_DoWork(object sender, DoWorkEventArgs e)
{
List<object> param = (List<object>)e.Argument;
bool demo = (bool)param[1];
int[,] seed = new int[9, 9];
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
seed[i, j] = -1;
}
}
Random rand = new Random();
for (int i = 1; i <= 9; i++)
{
int r = rand.Next(0, 8);
int c = rand.Next(0, 8);
//textBoxes[r, c].Text = i + ""; //bleh
seed[r, c] = i;
}
Solver solver = new Solver(seed);
int[,] solution = solver.solve();
int[,] puzzle = new int[9, 9];
Array.Copy(solution, puzzle, solution.Length);
if (demo)
{
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
//textBoxes[i, j].Text = puzzle[i, j] + "";
//updateBoard(i, j, puzzle[i, j]);
bgWorker.ReportProgress(puzzle[i, j], new Point(i, j));
}
}
}
//this.Refresh();
// remove random values...
//puzzle[0, 0] = -1;
Solver uniqueCheck = new Solver();
// uniqueCheck.
List<TreeNode> children = new List<TreeNode>();
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
children.Add(new TreeNode(i, j, puzzle[i, j]));
}
}
TreeNode node = children[rand.Next(0, children.Count - 1)];
children.Remove(node);
node.setChildren(children);
int n = 0;
//int limit = slider.Value;
//int limit = 50;
int limit = 81 - (int)param[0];
Console.WriteLine("Starting algorithm with limit: " + limit);
while (n < limit)
{
// Clear out current square
puzzle[node.r, node.c] = -1;
// Increment n every time we set something to -1
n++;
uniqueCheck.setInput(puzzle);
// If it not uniquely solvable, back up
if (uniqueCheck.isUnique(solution))
{
//textBoxes[node.r, node.c].Text = "";
if (demo)
{
bgWorker.ReportProgress(-1, new Point(node.r, node.c));
}
//this.Refresh();
}
else
{
// Decrement n every time we undo an operation
puzzle[node.r, node.c] = node.lastValue;
//textBoxes[node.r, node.c].Text = node.lastValue + "";
if (demo)
{
bgWorker.ReportProgress(node.lastValue, new Point(node.r, node.c));
}
//this.Refresh();
n--;
node = node.getParent();
}
// Make sure we haven't reached the top
if (node == null)
break;
// Randomly pick the next node
// If the current node has no more children, back up
TreeNode nextNode = node.getNextNode();
while (nextNode == null && node != null)
{
puzzle[node.r, node.c] = node.lastValue;
//textBoxes[node.r, node.c].Text = node.lastValue + "";
if (demo)
{
bgWorker.ReportProgress(node.lastValue, new Point(node.r, node.c));
}
//this.Refresh();
n--;
node = node.getParent();
nextNode = node.getNextNode();
}
// Make sure we haven't reached the top
if (node == null)
break;
node = nextNode;
// return the current count;
bgWorker.ReportProgress(100, 81 - n);
}
for (int i = 0; i < 9; i++)
{
for (int j = 0; j < 9; j++)
{
if (puzzle[i, j] != -1)
//textBoxes[i, j].Text = puzzle[i, j] + "";
bgWorker.ReportProgress(puzzle[i, j], new Point(i, j));
else
{
//textBoxes[i, j].Text = "";
bgWorker.ReportProgress(-1, new Point(i, j));
}
}
}
}
/// <summary>
/// 24通りから任意のロジック組み合わせを取得
/// </summary>
/// <param name="solver"></param>
/// <returns></returns>
public LogicDelegates[] GetLogicCombination(Solver solver)
{
LogicDelegates[] logics = new LogicDelegates[4];
logics[0] = solver.ShareCandLogic;
logics[1] = solver.PairLogic;
logics[2] = solver.CrossLogic;
logics[3] = solver.TripleLogic;
switch (combinationNo)
{
case 1:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.CrossLogic; //対角
break;
case 2:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.TripleLogic; //三つ子
break;
case 3:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.CrossLogic; //対角
break;
case 4:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.ShareCandLogic; //共有
break;
case 5:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.TripleLogic; //三つ子
break;
case 6:
logics[0] = solver.PairLogic; //双子
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.ShareCandLogic; //共有
break;
case 7:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.PairLogic; //双子
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.CrossLogic; //対角
break;
case 8:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.PairLogic; //双子
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.TripleLogic; //三つ子
break;
case 9:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.PairLogic; //双子
logics[3] = solver.CrossLogic; //対角
break;
case 10:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.PairLogic; //双子
break;
case 11:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.PairLogic; //双子
logics[3] = solver.TripleLogic; //三つ子
break;
case 12:
logics[0] = solver.ShareCandLogic; //共有
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.PairLogic; //双子
break;
case 13:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.PairLogic; //双子
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.CrossLogic; //対角
break;
case 14:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.PairLogic; //双子
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.ShareCandLogic; //共有
break;
case 15:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.PairLogic; //双子
logics[3] = solver.CrossLogic; //対角
break;
case 16:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.CrossLogic; //対角
logics[3] = solver.PairLogic; //双子
break;
case 17:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.PairLogic; //双子
logics[3] = solver.ShareCandLogic; //共有
break;
case 18:
logics[0] = solver.TripleLogic; //三つ子
logics[1] = solver.CrossLogic; //対角
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.PairLogic; //双子
break;
case 19:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.PairLogic; //双子
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.TripleLogic; //三つ子
break;
case 20:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.PairLogic; //双子
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.ShareCandLogic; //共有
break;
case 21:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.PairLogic; //双子
logics[3] = solver.TripleLogic; //三つ子
break;
case 22:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.ShareCandLogic; //共有
logics[2] = solver.TripleLogic; //三つ子
logics[3] = solver.PairLogic; //双子
break;
case 23:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.PairLogic; //双子
logics[3] = solver.ShareCandLogic; //共有
break;
case 24:
logics[0] = solver.CrossLogic; //対角
logics[1] = solver.TripleLogic; //三つ子
logics[2] = solver.ShareCandLogic; //共有
logics[3] = solver.PairLogic; //双子
break;
}
return(logics);
}
