From 2be5b888234cf42dd50c91d7c0dfbd6301bc5c31 Mon Sep 17 00:00:00 2001 From: Matthew Date: Fri, 18 Oct 2019 17:47:44 -0400 Subject: [PATCH 1/2] Fixed invalid package names --- .../CoinChange.java | 0 .../CuttingARod.java | 0 .../EggDroppingPuzzle.java | 0 .../Fibonacci.java | 0 .../Knapsack.java | 0 .../LongestCommonSubSequence.java | 0 .../UglyNumbers.java | 0 .../BFS.java | 0 .../Bipartite.java | 0 .../DFS.java | 0 .../DetectCycleDisjointSet.java | 0 .../TopologicalSort.java | 0 .../Activity_Selection_Problem}/Activity.java | 0 .../ActivitySelectionProblem.java | 0 .../Job_Sequencing_Problem}/Job.java | 0 .../JobSequencingProblem.java | 0 .../dijkstra shortest path.java | 0 .../Bankers.java | 0 .../BogoSort.java | 0 .../HeapSort.java | 0 .../QuickSort.java | 0 .../RadixSort.java | 0 .../Recursive Insertion Sort.java | 0 .../ShellSort.java | 0 .../ShuffleSort.java | 0 .../bubble_sort.java | 58 +++++++------- .../insertion_sort.java | 76 +++++++++---------- .../merge_sort.java | 0 .../selection_sort.java | 58 +++++++------- {String Reversal => String_Reversal}/GFG.java | 0 30 files changed, 96 insertions(+), 96 deletions(-) rename {Dynamic Programming => Dynamic_Programming}/CoinChange.java (100%) rename {Dynamic Programming => Dynamic_Programming}/CuttingARod.java (100%) rename {Dynamic Programming => Dynamic_Programming}/EggDroppingPuzzle.java (100%) rename {Dynamic Programming => Dynamic_Programming}/Fibonacci.java (100%) rename {Dynamic Programming => Dynamic_Programming}/Knapsack.java (100%) rename {Dynamic Programming => Dynamic_Programming}/LongestCommonSubSequence.java (100%) rename {Dynamic Programming => Dynamic_Programming}/UglyNumbers.java (100%) rename {Graph Algorithms => Graph_Algorithms}/BFS.java (100%) rename {Graph Algorithms => Graph_Algorithms}/Bipartite.java (100%) rename {Graph Algorithms => Graph_Algorithms}/DFS.java (100%) rename {Graph Algorithms => Graph_Algorithms}/DetectCycleDisjointSet.java (100%) rename {Graph Algorithms => Graph_Algorithms}/TopologicalSort.java (100%) rename {Greedy Algorithms/Activity Selection Problem => Greedy_Algorithms/Activity_Selection_Problem}/Activity.java (100%) rename {Greedy Algorithms/Activity Selection Problem => Greedy_Algorithms/Activity_Selection_Problem}/ActivitySelectionProblem.java (100%) rename {Greedy Algorithms/Job Sequencing Problem => Greedy_Algorithms/Job_Sequencing_Problem}/Job.java (100%) rename {Greedy Algorithms/Job Sequencing Problem => Greedy_Algorithms/Job_Sequencing_Problem}/JobSequencingProblem.java (100%) rename {Greedy Algorithms => Greedy_Algorithms}/dijkstra shortest path.java (100%) rename {Operating Systems => Operating_Systems}/Bankers.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/BogoSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/HeapSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/QuickSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/RadixSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/Recursive Insertion Sort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/ShellSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/ShuffleSort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/bubble_sort.java (96%) rename {Sorting Algorithms => Sorting_Algorithms}/insertion_sort.java (96%) rename {Sorting Algorithms => Sorting_Algorithms}/merge_sort.java (100%) rename {Sorting Algorithms => Sorting_Algorithms}/selection_sort.java (96%) rename {String Reversal => String_Reversal}/GFG.java (100%) diff --git a/Dynamic Programming/CoinChange.java b/Dynamic_Programming/CoinChange.java similarity index 100% rename from Dynamic Programming/CoinChange.java rename to Dynamic_Programming/CoinChange.java diff --git a/Dynamic Programming/CuttingARod.java b/Dynamic_Programming/CuttingARod.java similarity index 100% rename from Dynamic Programming/CuttingARod.java rename to Dynamic_Programming/CuttingARod.java diff --git a/Dynamic Programming/EggDroppingPuzzle.java b/Dynamic_Programming/EggDroppingPuzzle.java similarity index 100% rename from Dynamic Programming/EggDroppingPuzzle.java rename to Dynamic_Programming/EggDroppingPuzzle.java diff --git a/Dynamic Programming/Fibonacci.java b/Dynamic_Programming/Fibonacci.java similarity index 100% rename from Dynamic Programming/Fibonacci.java rename to Dynamic_Programming/Fibonacci.java diff --git a/Dynamic Programming/Knapsack.java b/Dynamic_Programming/Knapsack.java similarity index 100% rename from Dynamic Programming/Knapsack.java rename to Dynamic_Programming/Knapsack.java diff --git a/Dynamic Programming/LongestCommonSubSequence.java b/Dynamic_Programming/LongestCommonSubSequence.java similarity index 100% rename from Dynamic Programming/LongestCommonSubSequence.java rename to Dynamic_Programming/LongestCommonSubSequence.java diff --git a/Dynamic Programming/UglyNumbers.java b/Dynamic_Programming/UglyNumbers.java similarity index 100% rename from Dynamic Programming/UglyNumbers.java rename to Dynamic_Programming/UglyNumbers.java diff --git a/Graph Algorithms/BFS.java b/Graph_Algorithms/BFS.java similarity index 100% rename from Graph Algorithms/BFS.java rename to Graph_Algorithms/BFS.java diff --git a/Graph Algorithms/Bipartite.java b/Graph_Algorithms/Bipartite.java similarity index 100% rename from Graph Algorithms/Bipartite.java rename to Graph_Algorithms/Bipartite.java diff --git a/Graph Algorithms/DFS.java b/Graph_Algorithms/DFS.java similarity index 100% rename from Graph Algorithms/DFS.java rename to Graph_Algorithms/DFS.java diff --git a/Graph Algorithms/DetectCycleDisjointSet.java b/Graph_Algorithms/DetectCycleDisjointSet.java similarity index 100% rename from Graph Algorithms/DetectCycleDisjointSet.java rename to Graph_Algorithms/DetectCycleDisjointSet.java diff --git a/Graph Algorithms/TopologicalSort.java b/Graph_Algorithms/TopologicalSort.java similarity index 100% rename from Graph Algorithms/TopologicalSort.java rename to Graph_Algorithms/TopologicalSort.java diff --git a/Greedy Algorithms/Activity Selection Problem/Activity.java b/Greedy_Algorithms/Activity_Selection_Problem/Activity.java similarity index 100% rename from Greedy Algorithms/Activity Selection Problem/Activity.java rename to Greedy_Algorithms/Activity_Selection_Problem/Activity.java diff --git a/Greedy Algorithms/Activity Selection Problem/ActivitySelectionProblem.java b/Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java similarity index 100% rename from Greedy Algorithms/Activity Selection Problem/ActivitySelectionProblem.java rename to Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java diff --git a/Greedy Algorithms/Job Sequencing Problem/Job.java b/Greedy_Algorithms/Job_Sequencing_Problem/Job.java similarity index 100% rename from Greedy Algorithms/Job Sequencing Problem/Job.java rename to Greedy_Algorithms/Job_Sequencing_Problem/Job.java diff --git a/Greedy Algorithms/Job Sequencing Problem/JobSequencingProblem.java b/Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java similarity index 100% rename from Greedy Algorithms/Job Sequencing Problem/JobSequencingProblem.java rename to Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java diff --git a/Greedy Algorithms/dijkstra shortest path.java b/Greedy_Algorithms/dijkstra shortest path.java similarity index 100% rename from Greedy Algorithms/dijkstra shortest path.java rename to Greedy_Algorithms/dijkstra shortest path.java diff --git a/Operating Systems/Bankers.java b/Operating_Systems/Bankers.java similarity index 100% rename from Operating Systems/Bankers.java rename to Operating_Systems/Bankers.java diff --git a/Sorting Algorithms/BogoSort.java b/Sorting_Algorithms/BogoSort.java similarity index 100% rename from Sorting Algorithms/BogoSort.java rename to Sorting_Algorithms/BogoSort.java diff --git a/Sorting Algorithms/HeapSort.java b/Sorting_Algorithms/HeapSort.java similarity index 100% rename from Sorting Algorithms/HeapSort.java rename to Sorting_Algorithms/HeapSort.java diff --git a/Sorting Algorithms/QuickSort.java b/Sorting_Algorithms/QuickSort.java similarity index 100% rename from Sorting Algorithms/QuickSort.java rename to Sorting_Algorithms/QuickSort.java diff --git a/Sorting Algorithms/RadixSort.java b/Sorting_Algorithms/RadixSort.java similarity index 100% rename from Sorting Algorithms/RadixSort.java rename to Sorting_Algorithms/RadixSort.java diff --git a/Sorting Algorithms/Recursive Insertion Sort.java b/Sorting_Algorithms/Recursive Insertion Sort.java similarity index 100% rename from Sorting Algorithms/Recursive Insertion Sort.java rename to Sorting_Algorithms/Recursive Insertion Sort.java diff --git a/Sorting Algorithms/ShellSort.java b/Sorting_Algorithms/ShellSort.java similarity index 100% rename from Sorting Algorithms/ShellSort.java rename to Sorting_Algorithms/ShellSort.java diff --git a/Sorting Algorithms/ShuffleSort.java b/Sorting_Algorithms/ShuffleSort.java similarity index 100% rename from Sorting Algorithms/ShuffleSort.java rename to Sorting_Algorithms/ShuffleSort.java diff --git a/Sorting Algorithms/bubble_sort.java b/Sorting_Algorithms/bubble_sort.java similarity index 96% rename from Sorting Algorithms/bubble_sort.java rename to Sorting_Algorithms/bubble_sort.java index a982458..f4740b8 100644 --- a/Sorting Algorithms/bubble_sort.java +++ b/Sorting_Algorithms/bubble_sort.java @@ -1,30 +1,30 @@ -import java.io.*; -class Bubble -{ - public static void main()throws IOException - { - BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); - int i,j,t,n; - System.out.println("Enter the size of the array"); - n=Integer.parseInt(br.readLine()); - int a[]=new int[n]; - System.out.println("Enter the array elements"); - for(i=0;ia[j+1]) - { - t=a[j]; - a[j]=a[j+1]; - a[j+1]=t; - } - System.out.println("SORTED ARRAY"); - for(i=0;ia[j+1]) + { + t=a[j]; + a[j]=a[j+1]; + a[j+1]=t; + } + System.out.println("SORTED ARRAY"); + for(i=0;i= 0 && a[j] > key) - { - a[j + 1] = a[j]; - j = j - 1; - } - a[j+1]=key; - - } - //Displaying the array - System.out.println("SORTED ARRAY : "); - for(i=0;i= 0 && a[j] > key) + { + a[j + 1] = a[j]; + j = j - 1; + } + a[j+1]=key; + + } + //Displaying the array + System.out.println("SORTED ARRAY : "); + for(i=0;ia[j]) - { - t=a[i]; - a[i]=a[j]; - a[j]=t; - } - System.out.println("SORTED ARRAY"); - for(i=0;ia[j]) + { + t=a[i]; + a[i]=a[j]; + a[j]=t; + } + System.out.println("SORTED ARRAY"); + for(i=0;i Date: Fri, 18 Oct 2019 18:31:58 -0400 Subject: [PATCH 2/2] Added missing package statements --- Backtracking/AllPermutationsOfAString.java | 1 + Backtracking/FlightItinerary.java | 2 +- Backtracking/GraphColoring.java | 2 + Backtracking/HamiltonianPath.java | 2 + Backtracking/MatPathDFS.java | 2 + Backtracking/NQueen.java | 2 + Backtracking/SudokuSolver.java | 442 +++++++++--------- .../DuplicateElimination.java | 2 + Dynamic_Programming/CoinChange.java | 1 + Dynamic_Programming/CuttingARod.java | 1 + Dynamic_Programming/EggDroppingPuzzle.java | 1 + Dynamic_Programming/Fibonacci.java | 1 + Dynamic_Programming/Knapsack.java | 1 + .../LongestCommonSubSequence.java | 1 + Dynamic_Programming/UglyNumbers.java | 1 + Graph_Algorithms/BFS.java | 1 + Graph_Algorithms/Bipartite.java | 1 + Graph_Algorithms/DFS.java | 1 + Graph_Algorithms/DetectCycleDisjointSet.java | 2 +- Graph_Algorithms/TopologicalSort.java | 1 + .../Activity_Selection_Problem/Activity.java | 2 + .../ActivitySelectionProblem.java | 1 + .../Job_Sequencing_Problem/Job.java | 2 + .../JobSequencingProblem.java | 1 + Greedy_Algorithms/dijkstra shortest path.java | 3 +- Miscellaneous/ArmstrongNumber.java | 1 + Miscellaneous/CountVowelsAndConsonants.java | 2 + Miscellaneous/FloydCycleDetector.java | 2 +- Miscellaneous/NthFibonacci.java | 2 + Miscellaneous/Palindrome.java | 4 +- .../ReplaceAll0with5InInputInteger.java | 1 + Miscellaneous/factorial.java | 2 + Operating_Systems/Bankers.java | 1 + Searching/BinarySearch.java | 4 +- Searching/FibonacciSearch.java | 4 +- Searching/InterpolationSearch.java | 2 + Searching/JumpSearch.java | 4 +- Searching/LinearSearch.java | 2 + Searching/TernaySearch.java | 2 + Sorting_Algorithms/BogoSort.java | 2 + Sorting_Algorithms/HeapSort.java | 4 +- Sorting_Algorithms/QuickSort.java | 4 +- Sorting_Algorithms/RadixSort.java | 4 +- .../Recursive Insertion Sort.java | 6 +- Sorting_Algorithms/ShellSort.java | 4 +- Sorting_Algorithms/ShuffleSort.java | 2 + Sorting_Algorithms/bubble_sort.java | 2 + Sorting_Algorithms/insertion_sort.java | 2 + Sorting_Algorithms/merge_sort.java | 4 +- Sorting_Algorithms/selection_sort.java | 2 + String_Reversal/GFG.java | 2 + 51 files changed, 313 insertions(+), 235 deletions(-) diff --git a/Backtracking/AllPermutationsOfAString.java b/Backtracking/AllPermutationsOfAString.java index c67536f..0c0349a 100644 --- a/Backtracking/AllPermutationsOfAString.java +++ b/Backtracking/AllPermutationsOfAString.java @@ -1,3 +1,4 @@ +package Backtracking; /** * A string of length n has n! permutation. */ diff --git a/Backtracking/FlightItinerary.java b/Backtracking/FlightItinerary.java index 83109ab..9690da3 100644 --- a/Backtracking/FlightItinerary.java +++ b/Backtracking/FlightItinerary.java @@ -1,4 +1,4 @@ -package backtracking; +package Backtracking; import java.util.HashSet; import java.util.Stack; diff --git a/Backtracking/GraphColoring.java b/Backtracking/GraphColoring.java index f056298..cfaeec2 100644 --- a/Backtracking/GraphColoring.java +++ b/Backtracking/GraphColoring.java @@ -1,3 +1,5 @@ +package Backtracking; + import java.util.ArrayList; import java.util.List; import java.util.Scanner; diff --git a/Backtracking/HamiltonianPath.java b/Backtracking/HamiltonianPath.java index 6b00a84..ee0ddef 100644 --- a/Backtracking/HamiltonianPath.java +++ b/Backtracking/HamiltonianPath.java @@ -1,3 +1,5 @@ +package Backtracking; + import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; diff --git a/Backtracking/MatPathDFS.java b/Backtracking/MatPathDFS.java index 22978e7..53e8a09 100644 --- a/Backtracking/MatPathDFS.java +++ b/Backtracking/MatPathDFS.java @@ -1,3 +1,5 @@ +package Backtracking; + /** Given a MxN matrix where each element can either be 0 or 1. We need to find the shortest path between a given source cell to a destination cell. diff --git a/Backtracking/NQueen.java b/Backtracking/NQueen.java index 49b7805..811b78d 100644 --- a/Backtracking/NQueen.java +++ b/Backtracking/NQueen.java @@ -1,3 +1,5 @@ +package Backtracking; + import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; diff --git a/Backtracking/SudokuSolver.java b/Backtracking/SudokuSolver.java index e91b276..e8a796c 100644 --- a/Backtracking/SudokuSolver.java +++ b/Backtracking/SudokuSolver.java @@ -1,220 +1,222 @@ -//Solves Sudokus with the approach of backtracking - -public class SudokuSolver{ - - static int[][] grid; //= new int[9][9]; - static int recursionDepth = 0; - static int changes = 0; - - //Driver method - public static void main(String[] args){ - grid = new int[][] {{7, 0, 9, 3, 0, 0, 0, 0, 0}, - {0, 1, 0, 5, 0, 0, 6, 0, 0}, - {5, 0, 3, 0, 1, 0, 2, 4, 9}, - - {0, 3, 0, 9, 5, 0, 7, 0, 0}, - {4, 0, 0, 1, 0, 0, 0, 0, 8}, - {0, 0, 0, 0, 3, 8, 0, 6, 0}, - - {3, 0, 1, 0, 6, 0, 4, 0, 2}, - {0, 0, 2, 0, 0, 1, 0, 7, 0}, - {0, 0, 0, 0, 0, 3, 9, 0, 0}}; - - boolean[][] boolGrid = fillBoolGrid(grid); - - System.out.println("\nTo solve: \n"); - draw(grid); - - //start at the top left - int rowCurrent=0, columnCurrent=0, rowNext, columnNext, numberLast=0; - - if(boolGrid[0][0]){ - rowNext = 0; - columnNext = 0; - } else{ - int nextFieldReturn = nextField(boolGrid, rowCurrent, columnCurrent); - rowNext = nextFieldReturn/10; - columnNext = nextFieldReturn%10; - } - - boolean solvable = false; - - try{ - solvable = solve(grid, boolGrid, rowNext, columnNext); - } catch(Exception e){ - e.printStackTrace(); - } - - if(solvable){ - System.out.println("\n\nSolution: \n"); - draw(grid); - System.out.println("\nMaximum depth of recursion: " + recursionDepth); - System.out.println("Number of changes: " + changes); - } else { - System.out.println("Not solvable!"); - } - } - - //checks if the number fits at the given position - static boolean check(int[][] grid, int row, int column, int number){ - - for(int indexRow=0; indexRow<9; indexRow++){ - if(number == grid[indexRow][column]){ - return false; - } - } - - for(int indexColumn=0; indexColumn<9; indexColumn++){ - if(number == grid[row][indexColumn]){ - return false; - } - } - - int borderColumn = column/3*3; - int borderRow = row/3*3; - for(int indexBlockColumn = borderColumn; indexBlockColumn < borderColumn+3; indexBlockColumn++){ - for(int indexBlockRow = borderRow; indexBlockRow < borderRow+3; indexBlockRow++){ - if(number == grid[indexBlockRow][indexBlockColumn]){ - return false; - } - } - } - return true; - } - - - //returns 10*nextRow + nextColumn so that nextRow = nextField/10 and nextColumn = nextField%10 - static int nextField(boolean[][] boolGrid, int rowCurrent, int columnCurrent){ - - int rowNext, columnNext; - //at the end of a row - if(columnCurrent >= 8){ - columnNext = 0; - rowNext = rowCurrent+1; - } else { - columnNext = columnCurrent+1; - rowNext = rowCurrent; - } - - for(int row=rowNext; row<9; row++){ - for(int column=columnNext; column<9; column++){ - if(boolGrid[row][column]){ //true if the field is changeable - return (int) 10*row + column; //for conersion back: row=return/10, column=return%10 - } - } - columnNext = 0; - } - return -1; //if there are no more fields - } - - //creates a boolean-grid to safe which field is changeable - static boolean[][] fillBoolGrid(int[][] grid){ - boolean[][] boolGrid = new boolean[9][9]; - for(int row=0; row<9; row++){ - for(int column=0; column<9; column++){ - if(grid[row][column] == 0){ //erfüllt wenn wir ein bearbeitbares Feld kontrollieren - boolGrid[row][column] = true; - } - } - } - return boolGrid; - } - - //returns the previously changed Field encoded with 10*previousRow + previousColumn - static int lastField(boolean[][] boolGrid, int rowCurrent, int columnCurrent){ - - int columnLast, rowLast; - - if(columnCurrent == 0){ - columnLast = 8; - rowLast = rowCurrent-1; - } else { - columnLast = columnCurrent-1; - rowLast = rowCurrent; - } - - for(int row=rowLast; row>=0; row--){ - for(int column=columnLast; column>=0; column--){ - if(boolGrid[row][column]){ - return (int) 10*row + column; //for conversion back: row=return/10, column=return%10 - } - } - columnLast = 8; - } - return -1; //if there is no previous field - - } - - //coordinated the process - //returns true if a number was placed and false if no number has been placed - static boolean solve(int[][] grid, boolean[][] boolGrid, int rowCurrent, int columnCurrent){ - - recursionDepth++; - - //System.out.println("recursionDepth Current: " + recursionDepth); - - int testnumber = 1; - boolean alreadyChanged = false; - - do{ - //System.out.println("testnumber " + testnumber); - if(check(grid, rowCurrent, columnCurrent, testnumber)){ - grid[rowCurrent][columnCurrent] = testnumber; - - alreadyChanged = true; //indicates if the number has already been changed - - int nextFieldReturn = nextField(boolGrid, rowCurrent, columnCurrent); - - if(nextFieldReturn == -1){ //if finished - return true; - } - - int rowNext = nextFieldReturn/10; - int columnNext = nextFieldReturn%10; - - if(solve(grid, boolGrid, rowNext, columnNext)){ - return true; //if no changes are necessary - } else { - grid[rowCurrent][columnCurrent] = 0; //step backwards - alreadyChanged = false; - changes++; - } - - } - testnumber++; - - }while(testnumber<10); - - if(!alreadyChanged){ //if no number has been changed - grid[rowCurrent][columnCurrent] = 0; - recursionDepth--; - return false; - } - return false; - } - - //draws the grid - static void draw(int[][] feld){ - for(int a = 0; a < feld[1].length; a++){ - String row = ""; - - if (a % 3 == 0) { - for (int i = 0; i < feld.length; i++) { - row += "--"; - } - row += "-----\n"; - } - - row += "|"; - - for(int b = 0; b < feld.length; b++){ - row = row + feld[a][b] + ((b+1) % 3 == 0 && b < feld.length - 1 ? " | " : "|"); - } - - row += "\n"; - - System.out.print(row); - } - } - -} +package Backtracking; + +//Solves Sudokus with the approach of backtracking + +public class SudokuSolver{ + + static int[][] grid; //= new int[9][9]; + static int recursionDepth = 0; + static int changes = 0; + + //Driver method + public static void main(String[] args){ + grid = new int[][] {{7, 0, 9, 3, 0, 0, 0, 0, 0}, + {0, 1, 0, 5, 0, 0, 6, 0, 0}, + {5, 0, 3, 0, 1, 0, 2, 4, 9}, + + {0, 3, 0, 9, 5, 0, 7, 0, 0}, + {4, 0, 0, 1, 0, 0, 0, 0, 8}, + {0, 0, 0, 0, 3, 8, 0, 6, 0}, + + {3, 0, 1, 0, 6, 0, 4, 0, 2}, + {0, 0, 2, 0, 0, 1, 0, 7, 0}, + {0, 0, 0, 0, 0, 3, 9, 0, 0}}; + + boolean[][] boolGrid = fillBoolGrid(grid); + + System.out.println("\nTo solve: \n"); + draw(grid); + + //start at the top left + int rowCurrent=0, columnCurrent=0, rowNext, columnNext, numberLast=0; + + if(boolGrid[0][0]){ + rowNext = 0; + columnNext = 0; + } else{ + int nextFieldReturn = nextField(boolGrid, rowCurrent, columnCurrent); + rowNext = nextFieldReturn/10; + columnNext = nextFieldReturn%10; + } + + boolean solvable = false; + + try{ + solvable = solve(grid, boolGrid, rowNext, columnNext); + } catch(Exception e){ + e.printStackTrace(); + } + + if(solvable){ + System.out.println("\n\nSolution: \n"); + draw(grid); + System.out.println("\nMaximum depth of recursion: " + recursionDepth); + System.out.println("Number of changes: " + changes); + } else { + System.out.println("Not solvable!"); + } + } + + //checks if the number fits at the given position + static boolean check(int[][] grid, int row, int column, int number){ + + for(int indexRow=0; indexRow<9; indexRow++){ + if(number == grid[indexRow][column]){ + return false; + } + } + + for(int indexColumn=0; indexColumn<9; indexColumn++){ + if(number == grid[row][indexColumn]){ + return false; + } + } + + int borderColumn = column/3*3; + int borderRow = row/3*3; + for(int indexBlockColumn = borderColumn; indexBlockColumn < borderColumn+3; indexBlockColumn++){ + for(int indexBlockRow = borderRow; indexBlockRow < borderRow+3; indexBlockRow++){ + if(number == grid[indexBlockRow][indexBlockColumn]){ + return false; + } + } + } + return true; + } + + + //returns 10*nextRow + nextColumn so that nextRow = nextField/10 and nextColumn = nextField%10 + static int nextField(boolean[][] boolGrid, int rowCurrent, int columnCurrent){ + + int rowNext, columnNext; + //at the end of a row + if(columnCurrent >= 8){ + columnNext = 0; + rowNext = rowCurrent+1; + } else { + columnNext = columnCurrent+1; + rowNext = rowCurrent; + } + + for(int row=rowNext; row<9; row++){ + for(int column=columnNext; column<9; column++){ + if(boolGrid[row][column]){ //true if the field is changeable + return (int) 10*row + column; //for conersion back: row=return/10, column=return%10 + } + } + columnNext = 0; + } + return -1; //if there are no more fields + } + + //creates a boolean-grid to safe which field is changeable + static boolean[][] fillBoolGrid(int[][] grid){ + boolean[][] boolGrid = new boolean[9][9]; + for(int row=0; row<9; row++){ + for(int column=0; column<9; column++){ + if(grid[row][column] == 0){ //erfüllt wenn wir ein bearbeitbares Feld kontrollieren + boolGrid[row][column] = true; + } + } + } + return boolGrid; + } + + //returns the previously changed Field encoded with 10*previousRow + previousColumn + static int lastField(boolean[][] boolGrid, int rowCurrent, int columnCurrent){ + + int columnLast, rowLast; + + if(columnCurrent == 0){ + columnLast = 8; + rowLast = rowCurrent-1; + } else { + columnLast = columnCurrent-1; + rowLast = rowCurrent; + } + + for(int row=rowLast; row>=0; row--){ + for(int column=columnLast; column>=0; column--){ + if(boolGrid[row][column]){ + return (int) 10*row + column; //for conversion back: row=return/10, column=return%10 + } + } + columnLast = 8; + } + return -1; //if there is no previous field + + } + + //coordinated the process + //returns true if a number was placed and false if no number has been placed + static boolean solve(int[][] grid, boolean[][] boolGrid, int rowCurrent, int columnCurrent){ + + recursionDepth++; + + //System.out.println("recursionDepth Current: " + recursionDepth); + + int testnumber = 1; + boolean alreadyChanged = false; + + do{ + //System.out.println("testnumber " + testnumber); + if(check(grid, rowCurrent, columnCurrent, testnumber)){ + grid[rowCurrent][columnCurrent] = testnumber; + + alreadyChanged = true; //indicates if the number has already been changed + + int nextFieldReturn = nextField(boolGrid, rowCurrent, columnCurrent); + + if(nextFieldReturn == -1){ //if finished + return true; + } + + int rowNext = nextFieldReturn/10; + int columnNext = nextFieldReturn%10; + + if(solve(grid, boolGrid, rowNext, columnNext)){ + return true; //if no changes are necessary + } else { + grid[rowCurrent][columnCurrent] = 0; //step backwards + alreadyChanged = false; + changes++; + } + + } + testnumber++; + + }while(testnumber<10); + + if(!alreadyChanged){ //if no number has been changed + grid[rowCurrent][columnCurrent] = 0; + recursionDepth--; + return false; + } + return false; + } + + //draws the grid + static void draw(int[][] feld){ + for(int a = 0; a < feld[1].length; a++){ + String row = ""; + + if (a % 3 == 0) { + for (int i = 0; i < feld.length; i++) { + row += "--"; + } + row += "-----\n"; + } + + row += "|"; + + for(int b = 0; b < feld.length; b++){ + row = row + feld[a][b] + ((b+1) % 3 == 0 && b < feld.length - 1 ? " | " : "|"); + } + + row += "\n"; + + System.out.print(row); + } + } + +} diff --git a/DuplicateLinesElimination/DuplicateElimination.java b/DuplicateLinesElimination/DuplicateElimination.java index fd4bf5f..d4f4aa4 100644 --- a/DuplicateLinesElimination/DuplicateElimination.java +++ b/DuplicateLinesElimination/DuplicateElimination.java @@ -1,3 +1,5 @@ +package DuplicateLinesElimination; + import java.io.*; class DuplicateElimination { diff --git a/Dynamic_Programming/CoinChange.java b/Dynamic_Programming/CoinChange.java index af39a78..7dd35ae 100644 --- a/Dynamic_Programming/CoinChange.java +++ b/Dynamic_Programming/CoinChange.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamReader; diff --git a/Dynamic_Programming/CuttingARod.java b/Dynamic_Programming/CuttingARod.java index 70040cc..4abc233 100644 --- a/Dynamic_Programming/CuttingARod.java +++ b/Dynamic_Programming/CuttingARod.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; /** * Given a rod of length n inches and an array of prices * that contains prices of all pieces of size smaller than n. diff --git a/Dynamic_Programming/EggDroppingPuzzle.java b/Dynamic_Programming/EggDroppingPuzzle.java index 88a5707..7ed98db 100644 --- a/Dynamic_Programming/EggDroppingPuzzle.java +++ b/Dynamic_Programming/EggDroppingPuzzle.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; /** * Time Complexity: O(nk^2) * Auxiliary Space: O(nk) diff --git a/Dynamic_Programming/Fibonacci.java b/Dynamic_Programming/Fibonacci.java index 3f94d5e..5ae2e8a 100644 --- a/Dynamic_Programming/Fibonacci.java +++ b/Dynamic_Programming/Fibonacci.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; /** * This is a algorithm to implement the Fibonacci Nth element problem * using dynamic programming paradigm. This version I am using the memoization diff --git a/Dynamic_Programming/Knapsack.java b/Dynamic_Programming/Knapsack.java index 85673d3..b6c67c0 100644 --- a/Dynamic_Programming/Knapsack.java +++ b/Dynamic_Programming/Knapsack.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; import java.util.HashMap; import java.util.Map; diff --git a/Dynamic_Programming/LongestCommonSubSequence.java b/Dynamic_Programming/LongestCommonSubSequence.java index f8ba10f..0a76da9 100644 --- a/Dynamic_Programming/LongestCommonSubSequence.java +++ b/Dynamic_Programming/LongestCommonSubSequence.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; import java.util.*; public class LongestCommonSubSequence { diff --git a/Dynamic_Programming/UglyNumbers.java b/Dynamic_Programming/UglyNumbers.java index e0f2c6b..a9c51ef 100644 --- a/Dynamic_Programming/UglyNumbers.java +++ b/Dynamic_Programming/UglyNumbers.java @@ -1,3 +1,4 @@ +package Dynamic_Programming; /** * Ugly numbers are numbers whose only prime factors are 2, 3 or 5. */ diff --git a/Graph_Algorithms/BFS.java b/Graph_Algorithms/BFS.java index a4b4a70..2393a8c 100644 --- a/Graph_Algorithms/BFS.java +++ b/Graph_Algorithms/BFS.java @@ -1,3 +1,4 @@ +package Graph_Algorithms; /** * Time Complexity: O(V+E) where V is number of vertices in the graph and * E is number of edges in the graph. diff --git a/Graph_Algorithms/Bipartite.java b/Graph_Algorithms/Bipartite.java index cf7d63d..21f66d8 100644 --- a/Graph_Algorithms/Bipartite.java +++ b/Graph_Algorithms/Bipartite.java @@ -1,3 +1,4 @@ +package Graph_Algorithms; /** * A Bipartite Graph is a graph whose vertices can be divided into two independent sets, U and V * such that every edge (u, v) either connects a vertex from U to V or a vertex from V to U. diff --git a/Graph_Algorithms/DFS.java b/Graph_Algorithms/DFS.java index af578ed..ba9964e 100644 --- a/Graph_Algorithms/DFS.java +++ b/Graph_Algorithms/DFS.java @@ -1,3 +1,4 @@ +package Graph_Algorithms; /** * Time Complexity: O(V+E) where V is number of vertices in the graph and * E is number of edges in the graph. diff --git a/Graph_Algorithms/DetectCycleDisjointSet.java b/Graph_Algorithms/DetectCycleDisjointSet.java index ffa8eeb..62ca673 100644 --- a/Graph_Algorithms/DetectCycleDisjointSet.java +++ b/Graph_Algorithms/DetectCycleDisjointSet.java @@ -1,4 +1,4 @@ - +package Graph_Algorithms; /** * A disjoint-set data structure is a data structure that * keeps track of a set of elements partitioned into a number of disjoint (non-overlapping) subsets. diff --git a/Graph_Algorithms/TopologicalSort.java b/Graph_Algorithms/TopologicalSort.java index 4b98156..4a471c1 100644 --- a/Graph_Algorithms/TopologicalSort.java +++ b/Graph_Algorithms/TopologicalSort.java @@ -1,3 +1,4 @@ +package Graph_Algorithms; /** * Topological sorting for Directed Acyclic Graph (DAG) is a linear ordering of vertices * such that for every directed edge uv, vertex u comes before v in the ordering. diff --git a/Greedy_Algorithms/Activity_Selection_Problem/Activity.java b/Greedy_Algorithms/Activity_Selection_Problem/Activity.java index 87f2a37..e091107 100644 --- a/Greedy_Algorithms/Activity_Selection_Problem/Activity.java +++ b/Greedy_Algorithms/Activity_Selection_Problem/Activity.java @@ -1,3 +1,5 @@ +package Greedy_Algorithms.Activity_Selection_Problem; + class Activity implements Comparable { Integer startTime = 0; diff --git a/Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java b/Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java index c0a78dd..aa94497 100644 --- a/Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java +++ b/Greedy_Algorithms/Activity_Selection_Problem/ActivitySelectionProblem.java @@ -1,3 +1,4 @@ +package Greedy_Algorithms.Activity_Selection_Problem; /** * You are given n activities with their start and finish times. * Select the maximum number of activities that can be performed by a single person, diff --git a/Greedy_Algorithms/Job_Sequencing_Problem/Job.java b/Greedy_Algorithms/Job_Sequencing_Problem/Job.java index eb257fb..7e44ac4 100644 --- a/Greedy_Algorithms/Job_Sequencing_Problem/Job.java +++ b/Greedy_Algorithms/Job_Sequencing_Problem/Job.java @@ -1,3 +1,5 @@ +package Greedy_Algorithms.Job_Sequencing_Problem; + class Job implements Comparable { Character id = 'a'; diff --git a/Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java b/Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java index 8b50373..94566a1 100644 --- a/Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java +++ b/Greedy_Algorithms/Job_Sequencing_Problem/JobSequencingProblem.java @@ -1,3 +1,4 @@ +package Greedy_Algorithms.Job_Sequencing_Problem; /** * Given an array of jobs where every job has a deadline and * associated profit if the job is finished before the deadline. diff --git a/Greedy_Algorithms/dijkstra shortest path.java b/Greedy_Algorithms/dijkstra shortest path.java index c6a6dfe..6eb920b 100644 --- a/Greedy_Algorithms/dijkstra shortest path.java +++ b/Greedy_Algorithms/dijkstra shortest path.java @@ -1,4 +1,5 @@ -// A Java program for Dijkstra's single source shortest path algorithm. +package Greedy_Algorithms; +// A Java program for Dijkstra's single source shortest path algorithm. // The program is for adjacency matrix representation of the graph import java.util.*; import java.lang.*; diff --git a/Miscellaneous/ArmstrongNumber.java b/Miscellaneous/ArmstrongNumber.java index 3ac5038..fff72bd 100644 --- a/Miscellaneous/ArmstrongNumber.java +++ b/Miscellaneous/ArmstrongNumber.java @@ -1,3 +1,4 @@ +package Miscellaneous; /** * Created with IntelliJ IDEA. * User: ngupta diff --git a/Miscellaneous/CountVowelsAndConsonants.java b/Miscellaneous/CountVowelsAndConsonants.java index 4a9a6ca..b8bb102 100644 --- a/Miscellaneous/CountVowelsAndConsonants.java +++ b/Miscellaneous/CountVowelsAndConsonants.java @@ -1,3 +1,5 @@ +package Miscellaneous; + import java.util.Scanner; class VowelCon { diff --git a/Miscellaneous/FloydCycleDetector.java b/Miscellaneous/FloydCycleDetector.java index 6b7068a..3013d27 100644 --- a/Miscellaneous/FloydCycleDetector.java +++ b/Miscellaneous/FloydCycleDetector.java @@ -1,4 +1,4 @@ -package FloydsCycleDetection; +package Miscellaneous; public class FloydCycleDetector { diff --git a/Miscellaneous/NthFibonacci.java b/Miscellaneous/NthFibonacci.java index c74d51d..1c1edd5 100644 --- a/Miscellaneous/NthFibonacci.java +++ b/Miscellaneous/NthFibonacci.java @@ -1,3 +1,5 @@ +package Miscellaneous; + class NthFibonacci { /* diff --git a/Miscellaneous/Palindrome.java b/Miscellaneous/Palindrome.java index 1dcf2a9..fc1066b 100644 --- a/Miscellaneous/Palindrome.java +++ b/Miscellaneous/Palindrome.java @@ -1,5 +1,7 @@ +package Miscellaneous; + import java.util.Scanner; -public class main +class Main { public static void main(String args[]) { diff --git a/Miscellaneous/ReplaceAll0with5InInputInteger.java b/Miscellaneous/ReplaceAll0with5InInputInteger.java index 4cb71af..3b4bff8 100644 --- a/Miscellaneous/ReplaceAll0with5InInputInteger.java +++ b/Miscellaneous/ReplaceAll0with5InInputInteger.java @@ -1,3 +1,4 @@ +package Miscellaneous; /** * Given a integer as a input and replace all the ‘0’ with ‘5’ in the integer. * Use of array to store all digits is not allowed. diff --git a/Miscellaneous/factorial.java b/Miscellaneous/factorial.java index bc42969..f1e871b 100644 --- a/Miscellaneous/factorial.java +++ b/Miscellaneous/factorial.java @@ -1,3 +1,5 @@ +package Miscellaneous; + import java.math.BigInteger; public class factorial{ diff --git a/Operating_Systems/Bankers.java b/Operating_Systems/Bankers.java index 4ad7704..cf64cc4 100644 --- a/Operating_Systems/Bankers.java +++ b/Operating_Systems/Bankers.java @@ -1,3 +1,4 @@ +package Operating_Systems; /* PROGRAM : BANKER'S ALGORITHM Author : Yukta peswani diff --git a/Searching/BinarySearch.java b/Searching/BinarySearch.java index 2dc881c..1c1af0f 100644 --- a/Searching/BinarySearch.java +++ b/Searching/BinarySearch.java @@ -1,4 +1,6 @@ -class BinarySearch { +package Searching; + +class BinarySearch { int Search(int arr[], int l, int r, int search_element) { if (r >= l) { diff --git a/Searching/FibonacciSearch.java b/Searching/FibonacciSearch.java index f57bb30..948d100 100644 --- a/Searching/FibonacciSearch.java +++ b/Searching/FibonacciSearch.java @@ -1,4 +1,6 @@ -//Fibonacci Search +package Searching; + +//Fibonacci Search import java.util.*; class FibonacciSearch diff --git a/Searching/InterpolationSearch.java b/Searching/InterpolationSearch.java index fbd71e3..d66328f 100644 --- a/Searching/InterpolationSearch.java +++ b/Searching/InterpolationSearch.java @@ -1,3 +1,5 @@ +package Searching; + //Java program to implement interpolation search public class InterpolationSearch { diff --git a/Searching/JumpSearch.java b/Searching/JumpSearch.java index ffa25e4..99c8749 100644 --- a/Searching/JumpSearch.java +++ b/Searching/JumpSearch.java @@ -1,4 +1,6 @@ -class JumpSearch { +package Searching; + +class JumpSearch { public static int jumpSearch(int[] arr, int x){ int n = arr.length; diff --git a/Searching/LinearSearch.java b/Searching/LinearSearch.java index 0805509..62a032a 100644 --- a/Searching/LinearSearch.java +++ b/Searching/LinearSearch.java @@ -1,3 +1,5 @@ +package Searching; + import java.util.Scanner; public class LinearSearch diff --git a/Searching/TernaySearch.java b/Searching/TernaySearch.java index 1058330..13a963d 100644 --- a/Searching/TernaySearch.java +++ b/Searching/TernaySearch.java @@ -1,3 +1,5 @@ +package Searching; + import java.util.*; import java.io.*; class ternarysearch { diff --git a/Sorting_Algorithms/BogoSort.java b/Sorting_Algorithms/BogoSort.java index d044a6a..fdfa692 100644 --- a/Sorting_Algorithms/BogoSort.java +++ b/Sorting_Algorithms/BogoSort.java @@ -1,3 +1,5 @@ +package Sorting_Algorithms; + import java.util.Arrays; import java.util.Random; diff --git a/Sorting_Algorithms/HeapSort.java b/Sorting_Algorithms/HeapSort.java index 5482a6e..b19c0a2 100644 --- a/Sorting_Algorithms/HeapSort.java +++ b/Sorting_Algorithms/HeapSort.java @@ -1,4 +1,6 @@ -// Java program for implementation of Heap Sort +package Sorting_Algorithms; + +// Java program for implementation of Heap Sort public class HeapSort { public void sort(int arr[]) diff --git a/Sorting_Algorithms/QuickSort.java b/Sorting_Algorithms/QuickSort.java index 3c3547f..04025cd 100644 --- a/Sorting_Algorithms/QuickSort.java +++ b/Sorting_Algorithms/QuickSort.java @@ -1,4 +1,6 @@ -// Java program for implementation of QuickSort +package Sorting_Algorithms; + +// Java program for implementation of QuickSort class QuickSort { /* This function takes last element as pivot, diff --git a/Sorting_Algorithms/RadixSort.java b/Sorting_Algorithms/RadixSort.java index b348b95..e2c35c9 100644 --- a/Sorting_Algorithms/RadixSort.java +++ b/Sorting_Algorithms/RadixSort.java @@ -1,4 +1,6 @@ -// Radix sort Java implementation +package Sorting_Algorithms; + +// Radix sort Java implementation import java.io.*; import java.util.*; diff --git a/Sorting_Algorithms/Recursive Insertion Sort.java b/Sorting_Algorithms/Recursive Insertion Sort.java index 18ccc6e..2b98c4e 100644 --- a/Sorting_Algorithms/Recursive Insertion Sort.java +++ b/Sorting_Algorithms/Recursive Insertion Sort.java @@ -1,8 +1,10 @@ -// Recursive Java program for insertion sort +package Sorting_Algorithms; + +// Recursive Java program for insertion sort import java.util.Arrays; -public class GFG +class GFG { // Recursive function to sort an array using // insertion sort diff --git a/Sorting_Algorithms/ShellSort.java b/Sorting_Algorithms/ShellSort.java index 2300908..d3ab8b5 100644 --- a/Sorting_Algorithms/ShellSort.java +++ b/Sorting_Algorithms/ShellSort.java @@ -1,4 +1,6 @@ -// Java implementation of ShellSort +package Sorting_Algorithms; + +// Java implementation of ShellSort class ShellSort { /* An utility function to print array of size n*/ diff --git a/Sorting_Algorithms/ShuffleSort.java b/Sorting_Algorithms/ShuffleSort.java index 8d4a4dc..98c965e 100644 --- a/Sorting_Algorithms/ShuffleSort.java +++ b/Sorting_Algorithms/ShuffleSort.java @@ -1,3 +1,5 @@ +package Sorting_Algorithms; + import java.util.Arrays; import java.util.Random; diff --git a/Sorting_Algorithms/bubble_sort.java b/Sorting_Algorithms/bubble_sort.java index f4740b8..ba373f3 100644 --- a/Sorting_Algorithms/bubble_sort.java +++ b/Sorting_Algorithms/bubble_sort.java @@ -1,3 +1,5 @@ +package Sorting_Algorithms; + import java.io.*; class Bubble { diff --git a/Sorting_Algorithms/insertion_sort.java b/Sorting_Algorithms/insertion_sort.java index 03f6ca4..b3254c6 100644 --- a/Sorting_Algorithms/insertion_sort.java +++ b/Sorting_Algorithms/insertion_sort.java @@ -1,3 +1,5 @@ +package Sorting_Algorithms; + import java.io.*; class Insertion { diff --git a/Sorting_Algorithms/merge_sort.java b/Sorting_Algorithms/merge_sort.java index 78dcfb5..45ff3aa 100644 --- a/Sorting_Algorithms/merge_sort.java +++ b/Sorting_Algorithms/merge_sort.java @@ -1,4 +1,6 @@ -class MergeSort +package Sorting_Algorithms; + +class MergeSort { // Merges two subarrays of arr[]. // First subarray is arr[l..m] diff --git a/Sorting_Algorithms/selection_sort.java b/Sorting_Algorithms/selection_sort.java index f826afa..35b84f3 100644 --- a/Sorting_Algorithms/selection_sort.java +++ b/Sorting_Algorithms/selection_sort.java @@ -1,3 +1,5 @@ +package Sorting_Algorithms; + import java.io.*; class Selection { diff --git a/String_Reversal/GFG.java b/String_Reversal/GFG.java index e6df8d3..cdea54b 100644 --- a/String_Reversal/GFG.java +++ b/String_Reversal/GFG.java @@ -1,3 +1,5 @@ +package String_Reversal; + //Reverse an array without affecting special characters class GFG {