Random Question Generator Added

Author: Programmerryoki

README.md

@@ -5,5 +5,5 @@ Sudoku that is written in Java Swing
 To play the game, Open the SudokuApp.java and run it.
 
 ## To add Question
-Only add question to problems folder with the name "question #" where # is the number.
+Only add question to problems folder with the name "problem #" where # is the number.
 The question has to be added with space between each column and new line between each row.

src/backend/Answer.java

@@ -13,12 +13,40 @@ public class Answer {
 	 */
 	public static boolean solved(int[][] grid)
 	{
-		if (vertical(grid) && horizontal(grid) && gridWay(grid))
-			return true;
-		return false;
+		return strictVertical(grid) && strictHorizontal(grid) && strictGridWay(grid);
 	}
 
-	private static boolean vertical(int[][] grid)
+	protected static boolean canPut(int[][] grid, int row, int col, int val)
+	{
+		return vertical(grid,col, val) && horizontal(grid, row, val) && gridWay(grid, row, col, val);
+	}
+	
+	protected static boolean vertical(int[][] grid, int col, int val)
+	{
+		for (int row = 0; row < 9; row++)
+			if (grid[row][col] == val)
+				return false;
+		return true;
+	}
+	
+	protected static boolean horizontal(int[][] grid, int row, int val)
+	{
+		for (int col = 0; col < 9; col++)
+			if (grid[row][col] == val)
+				return false;
+		return true;
+	}
+	
+	protected static boolean gridWay(int[][] grid, int i, int j, int val)
+	{
+		for (int row = 0; row < 3; row++)
+			for (int col = 0; col < 3; col++)
+				if (grid[row + i/3 * 3][col + j/3 * 3] == val)
+					return false;
+		return true;
+	}
+	
+	private static boolean strictVertical(int[][] grid)
 	{
 		// Vertical Check
 		for (int col = 0; col < grid.length; col++)
@@ -36,7 +64,7 @@ private static boolean vertical(int[][] grid)
 		return true;
 	}
 
-	private static boolean horizontal(int[][] grid)
+	private static boolean strictHorizontal(int[][] grid)
 	{
 		// Horizontal Check
 		for (int row = 0; row < grid.length; row++)
@@ -54,7 +82,7 @@ private static boolean horizontal(int[][] grid)
 		return true;
 	}
 
-	private static boolean gridWay(int[][] grid)
+	private static boolean strictGridWay(int[][] grid)
 	{
 		// Grid way checking
 		for (int i = 0; i < 3; i++)

src/backend/SudokuGenerator.java

@@ -0,0 +1,165 @@
+/**
+ * 
+ */
+package backend;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+
+import model.Sudoku;
+
+/**
+ * @author Programmerryoki
+ *
+ */
+public class SudokuGenerator {
+	public static Sudoku generateSudoku()
+	{
+		int[][] generate = notEfficientGenerateAnswerGrid();
+		while (generate == null)
+			generate = notEfficientGenerateAnswerGrid();
+		int[][] question = new int[9][9];
+		String[] order = new String[81];
+		for (int i = 0; i < 9; i++)
+		{
+			for (int j = 0; j < 9; j++)
+			{
+				order[i*9+j] = i+""+j;
+				question[i][j] = generate[i][j];
+			}
+		}
+		List<String> strList = Arrays.asList(order);
+		Collections.shuffle(strList);
+		strList.toArray(order);
+		for (int i = 0; i < strList.size(); i++)
+		{
+			int row = strList.get(i).charAt(0) - '0';
+			int col = strList.get(i).charAt(1) - '0';
+			int val = question[row][col];
+			question[row][col] = 0;
+			int c = 0;
+			for (int j = 1; j < 10; j++)
+				if (Answer.canPut(question, row, col, j))
+					c++;
+			if (c != 1)
+				question[row][col] = val;
+		}
+		Sudoku answer = new Sudoku();
+		answer.setAnswer(generate);
+		answer.setOriginal(question);
+		return answer;
+	}
+	
+	private static int[] possibleList(int[][] grid, int i, int j)
+	{
+		int[] poss = new int[] {1,1,1,1,1,1,1,1,1};
+		for (int k = 0; k < 9; k++)
+			poss[grid[i][k] - 1] = 0;
+		for (int k = 0; k < 9; k++)
+			poss[grid[k][j] - 1] = 0;
+		i = i/3;
+		j = j/3;
+		for (int a = 0; a < 3; a++)
+			for (int b = 0; b < 3; b++)
+				poss[grid[i+a][j+b] - 1] = 0;
+		return poss;
+	}
+	
+	private static boolean isPossible(int[][] grid, int i, int j, int val)
+	{
+		for (int k = 0; k < 9; k++)
+			if (grid[i][k] == val)
+				return false;
+		for (int k = 0; k < 9; k++)
+			if (grid[k][j] == val)
+				return false;
+		for (int a = 0; a < 3; a++)
+			for (int b = 0; b < 3; b++)
+				if (grid[i+a][j+b] == val)
+					return false;
+		return true;
+	}
+	
+	private static int[][] notEfficientGenerateAnswerGrid()
+	{
+		int[][] ans = new int[9][9];
+//		return genAns(ans);
+		
+		for (int i = 0; i < 9; i++)
+		{
+			for (int j = 0; j < 9; j++)
+			{
+				int n = (int)(Math.random()*9 + 1);
+				HashSet<Integer> count = new HashSet<>();
+				while (!Answer.canPut(ans, i, j, n) && count.size() < 9)
+				{
+					n = (int)(Math.random()*9 + 1);
+					count.add(n);
+				}
+				if (count.size() == 9)
+				{
+					return null;
+				}
+				ans[i][j] = n;
+			}
+		}
+		return ans;
+	}
+	
+//	private static int[][] genAns(int[][] grid)
+//	{
+//		int[] randOrd = new int[] {1,2,3,4,5,6,7,8,9};
+//		List<Integer> intList = Arrays.asList(randOrd);
+//		Collections.shuffle(intList);
+//		intList.toArray(randOrd);
+//		
+//		boolean change = true;
+//		for (int i = 0; i < 9; i++)
+//		{
+//			for (int j = 0; j < 9; j++)
+//			{
+//				if (grid[i][j] == 0)
+//				{
+//					change = true;
+//					int val = (int)(Math.random()*9 + 1);
+//					if (isPossible(grid, i, j, val))
+//					{
+//						int[][] temp = new int[9][9];
+//						for (int row = 0; row < 9; row++)
+//							for (int col = 0; col < 9; col++)
+//								temp[i][j] = grid[i][j];
+//						temp[i][j] = val;
+//						genAns(grid);
+//					}
+//				}
+//			}
+//		}
+//		if (change)
+//			return 
+//	}
+	
+//	public static void main(String[] args)
+//	{
+//		
+//		int[][] grid = notEfficientGenerateAnswerGrid();
+//		int c = 0;
+//		while (grid == null)
+//		{
+//			grid = notEfficientGenerateAnswerGrid();
+//			c ++;
+//		}
+//		System.out.println(c);
+//		for (int[] i : grid)
+//		{
+//			for (int j : i)
+//			{
+//				System.out.print(j + " ");
+//			}
+//			System.out.println();
+//		}
+//		System.out.println(Answer.solved(grid));
+//	}
+}

src/problems/SudokuIO.java renamed to src/backend/SudokuIO.java

@@ -1,9 +1,14 @@
 
-package problems;
+package backend;
 
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileReader;
+import java.io.IOException;
+import java.nio.file.DirectoryStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 /**
  * The IO for the Sudoku
@@ -40,4 +45,22 @@ public static int[][] readFile(String fileName)
 
 		return input;
 	}
+	
+	public static int[][] getRandomGrid()
+	{
+		Path dir = Paths.get("src/problems/");
+		int i = 0;
+		try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir))
+		{
+			for (Path p : stream)
+				i++;
+		}
+		catch (IOException ex)
+		{
+			ex.printStackTrace();
+		}
+		
+		String fileName = "problem " + (int)(Math.random() * i + 1);
+		return readFile(fileName);
+	}
 }

src/controller/MasterController.java

@@ -5,8 +5,9 @@
 import javax.swing.JFrame;
 import javax.swing.JPanel;
 
+import backend.SudokuGenerator;
+import backend.SudokuIO;
 import model.Sudoku;
-import problems.SudokuIO;
 import view.MasterView;
 
 /**
@@ -21,7 +22,9 @@ public class MasterController {
 	public MasterController()
 	{
 		Sudoku example = new Sudoku();
-		example.setOriginal(SudokuIO.readFile("question 1"));
+		example = SudokuGenerator.generateSudoku();
+//		example.setOriginal(SudokuIO.getRandomGrid());
+//		example.setOriginal(SudokuIO.readFile("question 1"));
 		sudoku = new SudokuController(example, this);
 //		sudoku = new SudokuController(new Sudoku(), this);
 		mainView = new MasterView(sudoku.getView());

src/controller/SudokuController.java

@@ -7,6 +7,8 @@
 import javax.swing.JOptionPane;
 
 import backend.Answer;
+import backend.SudokuGenerator;
+import backend.SudokuIO;
 import model.Sudoku;
 import view.SudokuView;
 
@@ -56,9 +58,19 @@ else if (action.equals("Check"))
 		{
 			int[][] check = view.getGridNumbers();
 			if (Answer.solved(check))
+			{
 				JOptionPane.showMessageDialog(view, "It is Correct!");
+				int option = JOptionPane.showConfirmDialog(view, "Would you like to Continue?", "Continue?", JOptionPane.YES_NO_OPTION);
+				System.out.println(option);
+				if (option == 0)
+				{
+					model = SudokuGenerator.generateSudoku();
+					view.fixGridNumbers(model.getOriginal());
+					view.resetColor();
+				}
+			}
 			else
-				JOptionPane.showMessageDialog(null, "It is Wrong");
+				JOptionPane.showMessageDialog(view, "It is Wrong");
 		}
 		else if (action.substring(0, 5).equals("Radio"))
 		{

src/model/Sudoku.java

@@ -10,6 +10,11 @@ public Sudoku()
 	{
 	}
 
+	public Sudoku(int[][] original)
+	{
+		this.original = original;
+	}
+	
 	/**
 	 * Gets the grid
 	 * @return The grid
@@ -41,7 +46,45 @@ public int[][] getOriginal() {
 	public void setOriginal(int[][] original) {
 		this.original = original;
 	}
+	
+	/**
+	 * Gets the answer
+	 * @return The answer
+	 */
+	public int[][] getAnswer()
+	{
+		return answer;
+	}
+	
+	/**
+	 * Sets the answer
+	 * @param grid The answer to set
+	 */
+	public void setAnswer(int[][] grid)
+	{
+		this.answer = grid;
+	}
+	
+	/**
+	 * Checks if the answer given is correct or not
+	 * @param grid The grid to check
+	 * @return True if it is correct
+	 * @precondition answer cannot be null
+	 */
+	public boolean compareAnswer(int[][] grid)
+	{
+		for (int i = 0; i < 9; i++)
+		{
+			for (int j = 0; j < 9; j++)
+			{
+				if (grid[i][j] != answer[i][j])
+					return false;
+			}
+		}
+		return true;
+	}
 
 	private int[][] grid;
 	private int[][] original;
+	private int[][] answer;
 }

src/problems/question 1 renamed to src/problems/problem 1

@@ -0,0 +1,9 @@
+2 0 0 3 0 0 0 0 0
+8 0 4 0 6 2 0 0 3
+0 1 3 8 0 0 2 0 0
+0 0 0 0 2 0 3 9 0
+5 0 7 0 0 0 6 2 1
+0 3 2 0 0 6 0 0 0
+0 2 0 0 0 9 1 4 0
+6 0 1 2 5 0 8 0 9
+0 0 0 0 0 1 0 0 2