---
Backtracking/NQueens.java | 136 ++++++++++++++++++++++++++++++++++++++
1 file changed, 136 insertions(+)
create mode 100644 Backtracking/NQueens.java
diff --git a/Backtracking/NQueens.java b/Backtracking/NQueens.java
new file mode 100644
index 000000000000..597e35a2fe36
--- /dev/null
+++ b/Backtracking/NQueens.java
@@ -0,0 +1,136 @@
+package Backtracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Problem statement:
+ * Given a N x N chess board. Return all arrangements in which N queens can be placed on the board such no two queens attack
+ * each other.
+ * Ex. N = 6
+ * Solution= There are 4 possible ways
+ * Arrangement: 1
+ * ".Q....",
+ * "...Q..",
+ * ".....Q",
+ * "Q.....",
+ * "..Q...",
+ * "....Q."
+ *
+ * Arrangement: 2
+ * "..Q...",
+ * ".....Q",
+ * ".Q....",
+ * "....Q.",
+ * "Q.....",
+ * "...Q.."
+ *
+ * Arrangement: 3
+ * "...Q..",
+ * "Q.....",
+ * "....Q.",
+ * ".Q....",
+ * ".....Q",
+ * "..Q..."
+ *
+ * Arrangement: 4
+ * "....Q.",
+ * "..Q...",
+ * "Q.....",
+ * ".....Q",
+ * "...Q..",
+ * ".Q...."
+ *
+ * Solution:
+ * Brute Force approach:
+ *
+ * Generate all possible arrangement to place N queens on N*N board.
+ * Check each board if queens are placed safely.
+ * If it is safe, include arrangement in solution set. Otherwise ignore it
+ *
+ * Optimized solution:
+ * This can be solved using backtracking in below steps
+ *
+ * Start with first column and place queen on first row
+ * Try placing queen in a row on second column
+ * If placing second queen in second column attacks any of the previous queens, change the row in second column
+ * otherwise move to next column and try to place next queen
+ * In case if there is no rows where a queen can be placed such that it doesn't attack previous queens, then go back to previous column and change row of previous queen.
+ * Keep doing this until last queen is not placed safely.
+ * If there is no such way then return an empty list as solution
+ */
+public class NQueens {
+
+ public static void main(String[] args) {
+ placeQueens(1);
+ placeQueens(2);
+ placeQueens(3);
+ placeQueens(4);
+ placeQueens(5);
+ placeQueens(6);
+ }
+
+ public static void placeQueens(final int queens) {
+ List> arrangements = new ArrayList>();
+ getSolution(queens, arrangements, new int[queens], 0);
+ if (arrangements.isEmpty()) {
+ System.out.println("There is no way to place " + queens + " queens on board of size " + queens + "x" + queens);
+ } else {
+ System.out.println("Arrangement for placing " + queens + " queens");
+ }
+ arrangements.forEach(arrangement -> {
+ arrangement.forEach(row -> System.out.println(row));
+ System.out.println();
+ });
+ }
+
+ /**
+ * This is backtracking function which tries to place queen recursively
+ * @param boardSize: size of chess board
+ * @param solutions: this holds all possible arrangements
+ * @param columns: columns[i] = rowId where queen is placed in ith column.
+ * @param columnIndex: This is the column in which queen is being placed
+ */
+ private static void getSolution(int boardSize, List> solutions, int[] columns, int columnIndex) {
+ if (columnIndex == boardSize) {
+ // this means that all queens have been placed
+ List sol = new ArrayList();
+ for (int i = 0; i < boardSize; i++) {
+ StringBuilder sb = new StringBuilder();
+ for (int j = 0; j < boardSize; j++) {
+ sb.append(j == columns[i] ? "Q" : ".");
+ }
+ sol.add(sb.toString());
+ }
+ solutions.add(sol);
+ return;
+ }
+
+ // This loop tries to place queen in a row one by one
+ for (int rowIndex = 0; rowIndex < boardSize; rowIndex++) {
+ columns[columnIndex] = rowIndex;
+ if (isPlacedCorrectly(columns, rowIndex, columnIndex)) {
+ // If queen is placed successfully at rowIndex in column=columnIndex then try placing queen in next column
+ getSolution(boardSize, solutions, columns, columnIndex + 1);
+ }
+ }
+ }
+
+ /**
+ * This function checks if queen can be placed at row = rowIndex in column = columnIndex safely
+ * @param columns: columns[i] = rowId where queen is placed in ith column.
+ * @param rowIndex: row in which queen has to be placed
+ * @param columnIndex: column in which queen is being placed
+ * @return true: if queen can be placed safely
+ * false: otherwise
+ */
+ private static boolean isPlacedCorrectly(int[] columns, int rowIndex, int columnIndex) {
+ for (int i = 0; i < columnIndex; i++) {
+ int diff = Math.abs(columns[i] - rowIndex);
+ if (diff == 0 || columnIndex - i == diff) {
+ return false;
+ }
+ }
+ return true;
+ }
+}
From 71a735f9e0dc462c9e98faf3a383dad995ef1f9b Mon Sep 17 00:00:00 2001
From: Parundeep Singh <52928589+ParundeepSingh@users.noreply.github.com>
Date: Thu, 14 Oct 2021 16:36:06 +0530
Subject: [PATCH 0008/1552] Add Word Ladder (#2556)
---
Strings/WordLadder.java | 97 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 97 insertions(+)
create mode 100644 Strings/WordLadder.java
diff --git a/Strings/WordLadder.java b/Strings/WordLadder.java
new file mode 100644
index 000000000000..4f461e76dc6a
--- /dev/null
+++ b/Strings/WordLadder.java
@@ -0,0 +1,97 @@
+package Strings;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.Queue;
+import java.util.HashSet;
+
+/*
+ **Problem Statement:**
+ A transformation sequence from word beginWord to word endWord using a dictionary wordList is a sequence of words beginWord -> s1 -> s2 -> ... -> sk such that:
+
+ Every adjacent pair of words differs by a single letter.
+ Every si for 1 <= i <= k is in wordList. Note that beginWord does not need to be in wordList.
+ sk == endWord
+ Given two words, beginWord and endWord, and a dictionary wordList, return the number of words in the shortest transformation sequence from beginWord to endWord, or 0 if no such sequence exists.
+
+ **Example 1:**
+ Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log","cog"]
+ Output: 5
+ Explanation: One shortest transformation sequence is "hit" -> "hot" -> "dot" -> "dog" -> cog", which is 5 words long.
+
+ **Example 2:**
+ Input: beginWord = "hit", endWord = "cog", wordList = ["hot","dot","dog","lot","log"]
+ Output: 0
+ Explanation: The endWord "cog" is not in wordList, therefore there is no valid transformation sequence.
+
+ **Constraints:**
+ 1 <= beginWord.length <= 10
+ endWord.length == beginWord.length
+ 1 <= wordList.length <= 5000
+ wordList[i].length == beginWord.length
+ beginWord, endWord, and wordList[i] consist of lowercase English letters.
+ beginWord != endWord
+ All the words in wordList are unique.
+*/
+
+class WordLadder {
+
+ /** Driver Code */
+ public static void main(String []args){
+
+ String beginWord = "hit";
+ String endWord = "cog";
+ String words[] = {"hot","dot","dog","lot","log","cog"};
+ List wordList = Arrays.asList(words);
+
+ System.out.println("Ladder Length: " + ladderLength(beginWord,endWord,wordList));
+ }
+
+ /**
+ * This function finds the ladderLength
+ * @param beginWord: Starting word of the ladder
+ * @param endWord: Ending word of the ladder
+ * @param wordList: This list contains the words which needs to be included in ladder.
+ * @return ladderLength: This function will return the ladderLength(level) if the endword is there.
+ * Otherwise, will return the length as 0.
+ */
+
+ public static int ladderLength(String beginWord, String endWord, List wordList) {
+ HashSet set = new HashSet();
+ for(String word : wordList){
+ set.add(word);
+ }
+
+ if(!set.contains(endWord)) return 0;
+
+ Queue queue = new LinkedList();
+ queue.offer(beginWord);
+ int level = 1;
+
+ while(!queue.isEmpty()){
+ int size = queue.size();
+ for(int i = 0; i < size; i++){
+ String curr = queue.poll();
+ char[] words_chars = curr.toCharArray();
+ for(int j = 0; j < words_chars.length; j++){
+ char original_chars = words_chars[j];
+ for(char c = 'a'; c <= 'z'; c++){
+ if(words_chars[j] == c) continue;
+ words_chars[j] = c;
+ String new_word = String.valueOf(words_chars);
+ if(new_word.equals(endWord)) return level+1;
+ if(set.contains(new_word)){
+ set.remove(new_word);
+ queue.offer(new_word);
+ }
+ }
+ words_chars[j] = original_chars;
+ }
+ }
+ level++;
+ }
+ return 0;
+ }
+}
\ No newline at end of file
From bb9e8654b51fcac1b342b74d59a73a7c7a6146ab Mon Sep 17 00:00:00 2001
From: 921vikram
Date: Thu, 14 Oct 2021 16:43:45 +0530
Subject: [PATCH 0009/1552] Add Memoization solution for knapsack (#2560)
Co-authored-by: Vikram Prakash
---
DynamicProgramming/KnapsackMemoization.java | 53 +++++++++++++++++++++
1 file changed, 53 insertions(+)
create mode 100644 DynamicProgramming/KnapsackMemoization.java
diff --git a/DynamicProgramming/KnapsackMemoization.java b/DynamicProgramming/KnapsackMemoization.java
new file mode 100644
index 000000000000..fb4c49d58fd5
--- /dev/null
+++ b/DynamicProgramming/KnapsackMemoization.java
@@ -0,0 +1,53 @@
+package DynamicProgramming;
+
+
+import java.util.Arrays;
+
+/**
+ * Recursive Solution for 0-1 knapsack with memoization
+ */
+public class KnapsackMemoization {
+
+ private static int[][] t;
+
+
+ // Returns the maximum value that can
+ // be put in a knapsack of capacity W
+ public static int knapsack(int[] wt, int[] value, int W, int n) {
+ if(t[n][W] != -1) {
+ return t[n][W];
+ }
+ if (n == 0 || W == 0) {
+ return 0;
+ }
+ if (wt[n - 1] <= W) {
+ t[n-1][W-wt[n-1]] = knapsack(wt, value, W - wt[n - 1], n - 1);
+ // Include item in the bag. In that case add the value of the item and call for the remaining items
+ int tmp1 = value[n - 1] + t[n-1][W-wt[n-1]];
+ // Don't include the nth item in the bag anl call for remaining item without reducing the weight
+ int tmp2 = knapsack(wt, value, W, n - 1);
+ t[n-1][W] = tmp2;
+ // include the larger one
+ int tmp = tmp1 > tmp2 ? tmp1 : tmp2;
+ t[n][W] = tmp;
+ return tmp;
+ // If Weight for the item is more than the desired weight then don't include it
+ // Call for rest of the n-1 items
+ } else if (wt[n - 1] > W) {
+ t[n][W] = knapsack(wt, value, W, n - 1);
+ return t[n][W];
+ }
+ return -1;
+ }
+
+ // Driver code
+ public static void main(String args[]) {
+ int[] wt = {1, 3, 4, 5};
+ int[] value = {1, 4, 5, 7};
+ int W = 10;
+ t = new int[wt.length+1][W+1];
+ Arrays.stream(t).forEach(a -> Arrays.fill(a, -1));
+ int res = knapsack(wt, value, W, wt.length);
+ System.out.println("Maximum knapsack value " + res);
+ }
+}
From 99362e2646bbfcd5fb0e45b856c93e2a9105c9a9 Mon Sep 17 00:00:00 2001
From: Pramil <75042864+Pramil01@users.noreply.github.com>
Date: Thu, 14 Oct 2021 20:03:51 +0530
Subject: [PATCH 0010/1552] Add Vertical Order Traversal (#2585)
---
.../Trees/VerticalOrderTraversal.java | 106 ++++++++++++++++++
1 file changed, 106 insertions(+)
create mode 100644 DataStructures/Trees/VerticalOrderTraversal.java
diff --git a/DataStructures/Trees/VerticalOrderTraversal.java b/DataStructures/Trees/VerticalOrderTraversal.java
new file mode 100644
index 000000000000..bfbd36caabdb
--- /dev/null
+++ b/DataStructures/Trees/VerticalOrderTraversal.java
@@ -0,0 +1,106 @@
+package DataStructures.Trees;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Map;
+import java.util.Queue;
+
+/* The following class implements a vertical order traversal
+in a tree from top to bottom and left to right, so for a tree :
+ 1
+ / \
+ 2 3
+ / \ \
+ 4 5 6
+ \ / \
+ 7 8 10
+ \
+ 9
+ the sequence will be :
+ 4 2 7 1 5 9 3 8 6 10
+ */
+public class VerticalOrderTraversal{
+
+
+ public static void main(String[] args) {
+ BinaryTree tree = new BinaryTree();
+ tree.put(5);
+ tree.put(6);
+ tree.put(3);
+ tree.put(1);
+ tree.put(4);
+ BinaryTree.Node root = tree.getRoot();
+ ArrayList ans = verticalTraversal(root);
+ for(int i : ans) {
+ System.out.print(i+" ");
+ }
+ }
+
+ /*Function that receives a root Node and prints the tree
+ in Vertical Order.*/
+ private static ArrayList verticalTraversal(BinaryTree.Node root) {
+ /*Queue to store the Nodes.*/
+ Queue queue= new LinkedList<>();
+
+ /*Queue to store the index of particular vertical
+ column of a tree , with root at 0, Nodes on left
+ with negative index and Nodes on right with positive
+ index. */
+ Queue index = new LinkedList<>();
+
+ /*Map of Integer and ArrayList to store all the
+ elements in a particular index in a single arrayList
+ that will have a key equal to the index itself. */
+ Map> map = new HashMap<>();
+
+ /* min and max stores leftmost and right most index to
+ later print the tree in vertical fashion.*/
+ int max =0, min =0;
+ queue.offer(root);
+ index.offer(0);
+
+ while(!queue.isEmpty()) {
+
+ if(queue.peek().left!=null) {
+ /*Adding the left Node if it is not null
+ and its index by subtracting 1 from it's
+ parent's index*/
+ queue.offer(queue.peek().left);
+ index.offer(index.peek()-1);
+ }
+ if(queue.peek().right!=null) {
+ /*Adding the right Node if it is not null
+ and its index by adding 1 from it's
+ parent's index*/
+ queue.offer(queue.peek().right);
+ index.offer(index.peek()+1);
+ }
+ /*If the map does not contains the index a new
+ ArrayList is created with the index as key.*/
+ if(!map.containsKey(index.peek())) {
+ ArrayList a = new ArrayList<>();
+ map.put(index.peek(), a);
+ }
+ /*For a index, corresponding Node data is added
+ to the respective ArrayList present at that
+ index. */
+ map.get(index.peek()).add(queue.peek().data);
+ max = (int)Math.max(max,index.peek());
+ min = (int)Math.min(min,index.peek());
+ /*The Node and its index are removed
+ from their respective queues.*/
+ index.poll();queue.poll();
+ }
+ /*Finally map data is printed here which has keys
+ from min to max. Each ArrayList represents a
+ vertical column that is added in ans ArrayList.*/
+ ArrayList ans= new ArrayList<>();
+ for(int i =min ; i<= max ; i++) {
+ for(int j = 0 ; j
Date: Fri, 15 Oct 2021 11:47:51 +0530
Subject: [PATCH 0011/1552] Add Ugly Numbers (#2615)
---
Maths/NthUglyNumber.java | 59 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 59 insertions(+)
create mode 100644 Maths/NthUglyNumber.java
diff --git a/Maths/NthUglyNumber.java b/Maths/NthUglyNumber.java
new file mode 100644
index 000000000000..cd7674e903a3
--- /dev/null
+++ b/Maths/NthUglyNumber.java
@@ -0,0 +1,59 @@
+// Ugly numbers are numbers whose only prime factors are 2, 3 or 5. The sequence 1, 2, 3, 4, 5, 6, 8, 9, 10, 12, 15, … shows the first 11 ugly numbers.
+// By convention, 1 is included.
+// A program to find the nth Ugly number
+
+// Algorithm :
+// Initialize three-pointers two, three, and five pointing to zero.
+// Take 3 variables nm2, nm3, and nm5 to keep track of next multiple of 2,3 and 5.
+// Make an array of size n to store the ugly numbers with 1 at 0th index.
+// Initialize a variable next which stores the value of the last element in the array.
+// Run a loop n-1 times and perform steps 6,7 and 8.
+// Update the values of nm2, nm3, nm5 as ugly[two]*2, ugly[three]*3, ugly[5]*5 respectively.
+// Select the minimum value from nm2, nm3, and nm5 and increment the pointer related to it.
+// Store the minimum value in variable next and array.
+// Return next.
+
+
+
+package Maths;
+import java.util.*;
+class NthUglyNumber {
+ /* Function to get the nth ugly number*/
+ public long getNthUglyNo(int n) {
+ long[] ugly = new long[n];
+ int two=0, three=0, five=0;
+ long nm2=2, nm3=3, nm5=5;
+ long next = 1;
+
+ ugly[0] = 1;
+
+ for(int i=1; i
Date: Fri, 15 Oct 2021 08:23:43 +0200
Subject: [PATCH 0012/1552] Add MiniMax algorithm (#2563)
Co-authored-by: aitorfi
---
Others/MiniMaxAlgorithm.java | 128 +++++++++++++++++++++++++++++++++++
1 file changed, 128 insertions(+)
create mode 100644 Others/MiniMaxAlgorithm.java
diff --git a/Others/MiniMaxAlgorithm.java b/Others/MiniMaxAlgorithm.java
new file mode 100644
index 000000000000..06bfa732c281
--- /dev/null
+++ b/Others/MiniMaxAlgorithm.java
@@ -0,0 +1,128 @@
+package Others;
+
+import java.util.Arrays;
+import java.util.Random;
+
+/**
+ * MiniMax is an algorithm used int artificial intelligence and game theory for
+ * minimizing the possible loss for the worst case scenario.
+ *
+ * See more (https://en.wikipedia.org/wiki/Minimax,
+ * https://www.geeksforgeeks.org/minimax-algorithm-in-game-theory-set-1-introduction/).
+ *
+ * @author aitofi (https://github.com/aitorfi)
+ */
+public class MiniMaxAlgorithm {
+ /**
+ * Game tree represented as an int array containing scores. Each array element
+ * is a leaf node.
+ */
+ private int[] scores;
+ private int height;
+
+ /**
+ * Initializes the scores with 8 random leaf nodes
+ */
+ public MiniMaxAlgorithm() {
+ scores = getRandomScores(3, 99);
+ height = log2(scores.length);
+ }
+
+ public static void main(String[] args) {
+ MiniMaxAlgorithm miniMaxAlgorith = new MiniMaxAlgorithm();
+ boolean isMaximizer = true; // Specifies the player that goes first.
+ boolean verbose = true; // True to show each players choices.
+ int bestScore;
+
+ bestScore = miniMaxAlgorith.miniMax(0, isMaximizer, 0, verbose);
+
+ if (verbose) {
+ System.out.println();
+ }
+
+ System.out.println(Arrays.toString(miniMaxAlgorith.getScores()));
+ System.out.println(
+ "The best score for " + (isMaximizer ? "Maximizer" : "Minimizer") + " is " + String.valueOf(bestScore));
+ }
+
+ /**
+ * Returns the optimal score assuming that both players play their best.
+ *
+ * @param depth Indicates how deep we are into the game tree.
+ * @param isMaximizer True if it is maximizers turn; otherwise false.
+ * @param index Index of the leaf node that is being evaluated.
+ * @param verbose True to show each players choices.
+ * @return The optimal score for the player that made the first move.
+ */
+ public int miniMax(int depth, boolean isMaximizer, int index, boolean verbose) {
+ int bestScore, score1, score2;
+
+ if (depth == height) { // Leaf node reached.
+ return scores[index];
+ }
+
+ score1 = miniMax(depth + 1, !isMaximizer, index * 2, verbose);
+ score2 = miniMax(depth + 1, !isMaximizer, (index * 2) + 1, verbose);
+
+ if (isMaximizer) {
+ // Maximizer player wants to get the maximum possible score.
+ bestScore = Math.max(score1, score2);
+ } else {
+ // Minimizer player wants to get the minimum possible score.
+ bestScore = Math.min(score1, score2);
+ }
+
+ // Leaf nodes can be sequentially inspected by
+ // recurssively multiplying (0 * 2) and ((0 * 2) + 1):
+ // (0 x 2) = 0; ((0 x 2) + 1) = 1
+ // (1 x 2) = 2; ((1 x 2) + 1) = 3
+ // (2 x 2) = 4; ((2 x 2) + 1) = 5 ...
+
+ if (verbose) {
+ System.out.println(String.format("From %02d and %02d, %s chooses %02d", score1, score2,
+ (isMaximizer ? "Maximizer" : "Minimizer"), bestScore));
+ }
+
+ return bestScore;
+ }
+
+ /**
+ * Returns an array of random numbers which lenght is a power of 2.
+ *
+ * @param size The power of 2 that will determine the lenght of the array.
+ * @param maxScore The maximum possible score.
+ * @return An array of random numbers.
+ */
+ public static int[] getRandomScores(int size, int maxScore) {
+ int[] randomScores = new int[(int) Math.pow(2, size)];
+ Random rand = new Random();
+
+ for (int a : randomScores) {
+ a = rand.nextInt(maxScore) + 1;
+ }
+
+ return randomScores;
+ }
+
+ // A utility function to find Log n in base 2
+ private int log2(int n) {
+ return (n == 1) ? 0 : log2(n / 2) + 1;
+ }
+
+ public void setScores(int[] scores) {
+ if (scores.length % 1 == 0) {
+ this.scores = scores;
+ height = log2(this.scores.length);
+ } else {
+ System.out.println("The number of scores must be a power of 2.");
+ }
+ }
+
+ public int[] getScores() {
+ return scores;
+ }
+
+ public int getHeight() {
+ return height;
+ }
+}
\ No newline at end of file
From 7635dace6213d9c646ca2aca761015f0beb4edd3 Mon Sep 17 00:00:00 2001
From: Sahil Tagala <60920150+sahiltagala@users.noreply.github.com>
Date: Fri, 15 Oct 2021 11:55:39 +0530
Subject: [PATCH 0013/1552] Add Dice Throw (#2565)
---
DynamicProgramming/DiceThrow.java | 66 +++++++++++++++++++++++++++++++
1 file changed, 66 insertions(+)
create mode 100644 DynamicProgramming/DiceThrow.java
diff --git a/DynamicProgramming/DiceThrow.java b/DynamicProgramming/DiceThrow.java
new file mode 100644
index 000000000000..1bf1a715e127
--- /dev/null
+++ b/DynamicProgramming/DiceThrow.java
@@ -0,0 +1,66 @@
+// Given N dice each with M faces, numbered from 1 to M, find the number of ways to get sum X.
+// X is the summation of values on each face when all the dice are thrown.
+
+/* The Naive approach is to find all the possible combinations of values from n dice and
+keep on counting the results that sum to X. This can be done using recursion. */
+
+// The above recursion solution exhibits overlapping subproblems.
+
+/* Hence, storing the results of the solved sub-problems saves time.
+And it can be done using Dynamic Programming(DP).
+Following is implementation of Dynamic Programming approach. */
+
+
+// Code ---->
+// Java program to find number of ways to get sum 'x' with 'n'
+// dice where every dice has 'm' faces
+import java.util.*;
+import java.lang.*;
+import java.io.*;
+
+class DP {
+ /* The main function that returns the number of ways to get sum 'x' with 'n' dice and 'm' with m faces. */
+ public static long findWays(int m, int n, int x){
+
+ /* Create a table to store the results of subproblems.
+ One extra row and column are used for simplicity
+ (Number of dice is directly used as row index and sum is directly used as column index).
+ The entries in 0th row and 0th column are never used. */
+ long[][] table = new long[n+1][x+1];
+
+ /* Table entries for only one dice */
+ for(int j = 1; j <= m && j <= x; j++)
+ table[1][j] = 1;
+
+ /* Fill rest of the entries in table using recursive relation
+ i: number of dice, j: sum */
+ for(int i = 2; i <= n;i ++){
+ for(int j = 1; j <= x; j++){
+ for(int k = 1; k < j && k <= m; k++)
+ table[i][j] += table[i-1][j-k];
+ }
+ }
+
+ return table[n][x];
+ }
+
+ public static void main (String[] args) {
+ System.out.println(findWays(4, 2, 1));
+ System.out.println(findWays(2, 2, 3));
+ System.out.println(findWays(6, 3, 8));
+ System.out.println(findWays(4, 2, 5));
+ System.out.println(findWays(4, 3, 5));
+ }
+}
+
+/*
+OUTPUT:
+0
+2
+21
+4
+6
+*/
+
+// Time Complexity: O(m * n * x) where m is number of faces, n is number of dice and x is given sum.
+
From f30ec189bae31847c5ba35a647e117ac40327666 Mon Sep 17 00:00:00 2001
From: Sneha B <57147597+Sneha421@users.noreply.github.com>
Date: Fri, 15 Oct 2021 12:10:47 +0530
Subject: [PATCH 0014/1552] Add Two Sum Problem (#2572)
---
Misc/TwoSumProblem.java | 113 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 113 insertions(+)
create mode 100644 Misc/TwoSumProblem.java
diff --git a/Misc/TwoSumProblem.java b/Misc/TwoSumProblem.java
new file mode 100644
index 000000000000..33bfbf4d2173
--- /dev/null
+++ b/Misc/TwoSumProblem.java
@@ -0,0 +1,113 @@
+import java.util.*;
+import java.util.stream.Collectors;
+public class TwoSumProblem {
+ public static void main(String args[])
+ {
+ Scanner scan = new Scanner(System.in);
+ System.out.print("Enter the target sum ");
+ int ts= scan.nextInt();
+ System.out.print("Enter the number of elements in the array ");
+ int n = scan.nextInt();
+ System.out.println("Enter all your array elements:");
+ int arr[]= new int[n];
+ for(int i=0;i hm=new HashMap();
+ for(int i =0;i temp
+ = hm.entrySet()
+ .stream()
+ .sorted((i1, i2)
+ -> i1.getValue().compareTo(
+ i2.getValue()))
+ .collect(Collectors.toMap(
+ Map.Entry::getKey,
+ Map.Entry::getValue,
+ (e1, e2) -> e1, LinkedHashMap::new));
+
+ int start = 0;
+ int end = nums.length - 1;
+ while (starttarget)
+ end-=1;
+ else if(currSum hm=new HashMap();
+ for(int i=0;i
Date: Sat, 16 Oct 2021 08:14:46 +0300
Subject: [PATCH 0015/1552] Fix random number generation in MiniMax Algorithm
(#2636)
Co-authored-by: aitorfi
---
Others/MiniMaxAlgorithm.java | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/Others/MiniMaxAlgorithm.java b/Others/MiniMaxAlgorithm.java
index 06bfa732c281..7d0dd0537f6f 100644
--- a/Others/MiniMaxAlgorithm.java
+++ b/Others/MiniMaxAlgorithm.java
@@ -97,8 +97,8 @@ public static int[] getRandomScores(int size, int maxScore) {
int[] randomScores = new int[(int) Math.pow(2, size)];
Random rand = new Random();
- for (int a : randomScores) {
- a = rand.nextInt(maxScore) + 1;
+ for (int i = 0; i < randomScores.length; i++) {
+ randomScores[i] = rand.nextInt(maxScore) + 1;
}
return randomScores;
From b6dc9617f6c5395d28b0e507a5b52ba0fc7fc411 Mon Sep 17 00:00:00 2001
From: Ojasva Jain <44553464+ojasva@users.noreply.github.com>
Date: Sat, 16 Oct 2021 18:53:33 +0530
Subject: [PATCH 0016/1552] Inverse Of a Square Matrix [Hacktoberfest] (#2582)
Co-authored-by: Andrii Siriak
---
Misc/InverseOfMatrix.java | 131 ++++++++++++++++++++++++++++++++++++++
1 file changed, 131 insertions(+)
create mode 100644 Misc/InverseOfMatrix.java
diff --git a/Misc/InverseOfMatrix.java b/Misc/InverseOfMatrix.java
new file mode 100644
index 000000000000..ed11d77ed205
--- /dev/null
+++ b/Misc/InverseOfMatrix.java
@@ -0,0 +1,131 @@
+package Misc;
+import java.util.Scanner;
+
+/*
+* Wikipedia link : https://en.wikipedia.org/wiki/Invertible_matrix
+*
+* Here we use gauss elimination method to find the inverse of a given matrix.
+* To understand gauss elimination method to find inverse of a matrix: https://www.sangakoo.com/en/unit/inverse-matrix-method-of-gaussian-elimination
+*
+* We can also find the inverse of a matrix
+*/
+public class InverseOfMatrix
+{
+ public static void main(String argv[])
+ {
+ Scanner input = new Scanner(System.in);
+ System.out.println("Enter the matrix size (Square matrix only): ");
+ int n = input.nextInt();
+ double a[][]= new double[n][n];
+ System.out.println("Enter the elements of matrix: ");
+ for(int i=0; i=0; --j)
+ {
+ x[j][i] = b[index[j]][i];
+ for (int k=j+1; k c1) c1 = c0;
+ }
+ c[i] = c1;
+ }
+
+ // Search the pivoting element from each column
+ int k = 0;
+ for (int j=0; j pi1)
+ {
+ pi1 = pi0;
+ k = i;
+ }
+ }
+ // Interchange rows according to the pivoting order
+ int itmp = index[j];
+ index[j] = index[k];
+ index[k] = itmp;
+ for (int i=j+1; i
Date: Sat, 16 Oct 2021 19:01:24 +0530
Subject: [PATCH 0017/1552] Fix Circular linked list (#2598)
---
DataStructures/Lists/CircleLinkedList.java | 40 +++++++++++++++++++++-
1 file changed, 39 insertions(+), 1 deletion(-)
diff --git a/DataStructures/Lists/CircleLinkedList.java b/DataStructures/Lists/CircleLinkedList.java
index b1f9ec77d738..de264ddc845f 100644
--- a/DataStructures/Lists/CircleLinkedList.java
+++ b/DataStructures/Lists/CircleLinkedList.java
@@ -15,12 +15,14 @@ private Node(E value, Node next) {
private int size;
// this will point to dummy node;
private Node head = null;
+ private Node tail = null; // keeping a tail pointer to keep track of the end of list
// constructer for class.. here we will make a dummy node for circly linked list implementation
// with reduced error catching as our list will never be empty;
public CircleLinkedList() {
// creation of the dummy node
head = new Node(null, head);
+ tail = head;
size = 0;
}
@@ -37,10 +39,43 @@ public void append(E value) {
throw new NullPointerException("Cannot add null element to the list");
}
// head.next points to the last element;
- head.next = new Node(value, head);
+ if (tail == null){
+ tail = new Node(value, head);
+ head.next = tail;
+ }
+ else{
+ tail.next = new Node(value, head);
+ tail = tail.next;
+ }
size++;
}
+ // utility function for teraversing the list
+ public String toString(){
+ Node p = head.next;
+ String s = "[ ";
+ while(p!=head){
+ s += p.value;
+ s += " , ";
+ p = p.next;
+ }
+ return s + " ]";
+ }
+
+ public static void main(String args[]){
+ CircleLinkedList cl = new CircleLinkedList();
+ cl.append(12);
+ System.out.println(cl);
+ cl.append(23);
+ System.out.println(cl);
+ cl.append(34);
+ System.out.println(cl);
+ cl.append(56);
+ System.out.println(cl);
+ cl.remove(3);
+ System.out.println(cl);
+ }
+
public E remove(int pos) {
if (pos > size || pos < 0) {
// catching errors
@@ -58,6 +93,9 @@ public E remove(int pos) {
// the last element will be assigned to the head.
before.next = before.next.next;
// scrubbing
+ if(destroy == tail){
+ tail = before;
+ }
destroy = null;
size--;
return saved;
From 2b7a977cc8a5e075d2036ad38d6fa37072026242 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aitor=20Fidalgo=20S=C3=A1nchez?=
<64830228+aitorfi@users.noreply.github.com>
Date: Sat, 16 Oct 2021 16:43:51 +0300
Subject: [PATCH 0018/1552] Fix package declarations (#2576)
---
DataStructures/Graphs/A_Star.java | 3 +--
DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java | 3 ---
DataStructures/Graphs/KahnsAlgorithm.java | 3 +--
DataStructures/Graphs/Kruskal.java | 2 ++
DataStructures/Lists/RemoveDuplicateNodes.java | 2 --
DataStructures/Queues/CircularQueue.java | 2 ++
DataStructures/Trees/BSTIterative.java | 2 ++
DataStructures/Trees/BSTRecursive.java | 2 ++
DataStructures/Trees/LCA.java | 2 +-
DivideAndConquer/BinaryExponentiation.java | 2 ++
DivideAndConquer/ClosestPair.java | 2 --
DivideAndConquer/StrassenMatrixMultiplication.java | 2 ++
DynamicProgramming/DiceThrow.java | 5 ++---
.../LongestPalindromicSubsequence.java | 5 +----
DynamicProgramming/LongestPalindromicSubstring.java | 5 +----
DynamicProgramming/MinimumSumPartition.java | 3 ---
DynamicProgramming/PalindromicPartitioning.java | 8 ++++----
.../ShortestCommonSupersequenceLength.java | 2 ++
DynamicProgramming/Sum_Of_Subset.java | 2 ++
Maths/AutomorphicNumber.java | 2 ++
Maths/CircularConvolutionFFT.java | 2 +-
Maths/Convolution.java | 2 +-
Maths/ConvolutionFFT.java | 2 +-
Maths/FFT.java | 2 +-
Maths/FFTBluestein.java | 2 +-
Maths/GenericRoot.java | 2 ++
Maths/KeithNumber.java | 5 ++++-
Maths/KrishnamurthyNumber.java | 2 +-
Maths/MagicSquare.java | 3 +++
Maths/RomanNumeralUtil.java | 2 ++
Misc/TwoSumProblem.java | 3 +++
Misc/WordBoggle.java | 2 ++
...menting_auto_completing_features_using_trie.java | 6 ------
Others/RabinKarp.java | 2 ++
Others/RestrictedTowerOfHanoi/Main/Hanoi.java | 2 ++
Others/StringMatchFiniteAutomata.java | 2 ++
...nyTimesRotated.java => HowManyTimesRotated.java} | 13 +++++++------
Searches/PerfectBinarySearch.java | 2 --
Sorts/MergeSortRecursive.java | 2 ++
.../List_all_Possible_Words_From_Phone_Digits.java | 2 --
Strings/LongestPalindromicSubstring.java | 3 ++-
Strings/WordLadder.java | 1 -
42 files changed, 68 insertions(+), 55 deletions(-)
rename Searches/{howManyTimesRotated.java => HowManyTimesRotated.java} (96%)
diff --git a/DataStructures/Graphs/A_Star.java b/DataStructures/Graphs/A_Star.java
index 0141610255ca..4116fce89a0c 100644
--- a/DataStructures/Graphs/A_Star.java
+++ b/DataStructures/Graphs/A_Star.java
@@ -2,9 +2,8 @@
Time Complexity = O(E), where E is equal to the number of edges
*/
-package Graphs;
+package DataStructures.Graphs;
-import java.lang.reflect.Array;
import java.util.*;
public class A_Star {
diff --git a/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java b/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java
index d04a855e90c9..928281602765 100644
--- a/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java
+++ b/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java
@@ -4,9 +4,6 @@
*/
package DataStructures.Graphs;
-import java.util.*;
-import java.io.*;
-
class dijkstras{
int k=9;
diff --git a/DataStructures/Graphs/KahnsAlgorithm.java b/DataStructures/Graphs/KahnsAlgorithm.java
index 0dfd2f8b387f..eac840340a58 100644
--- a/DataStructures/Graphs/KahnsAlgorithm.java
+++ b/DataStructures/Graphs/KahnsAlgorithm.java
@@ -1,4 +1,4 @@
-package Graphs;
+package DataStructures.Graphs;
import java.util.ArrayList;
import java.util.Map;
@@ -104,7 +104,6 @@ void calculateInDegree(){
*/
ArrayList topSortOrder(){
calculateInDegree();
- int count = 0;
Queue q = new LinkedList();
for(E vertex: inDegree.keySet()){
diff --git a/DataStructures/Graphs/Kruskal.java b/DataStructures/Graphs/Kruskal.java
index 941f30593ad9..3c8f6e44c01e 100644
--- a/DataStructures/Graphs/Kruskal.java
+++ b/DataStructures/Graphs/Kruskal.java
@@ -1,3 +1,5 @@
+package DataStructures.Graphs;
+
// Problem -> Connect all the edges with the minimum cost.
// Possible Solution -> Kruskal Algorithm (KA), KA finds the minimum-spanning-tree, which means, the
// group of edges with the minimum sum of their weights that connect the whole graph.
diff --git a/DataStructures/Lists/RemoveDuplicateNodes.java b/DataStructures/Lists/RemoveDuplicateNodes.java
index 4eb12de2956d..944f7b1746e0 100644
--- a/DataStructures/Lists/RemoveDuplicateNodes.java
+++ b/DataStructures/Lists/RemoveDuplicateNodes.java
@@ -1,7 +1,5 @@
package DataStructures.Lists;
-import DataStructures.Lists.Node;
-
public class RemoveDuplicateNodes {
public Node deleteDuplicates(Node head) {
diff --git a/DataStructures/Queues/CircularQueue.java b/DataStructures/Queues/CircularQueue.java
index 5e9bbe088fb4..355cd8724c1d 100644
--- a/DataStructures/Queues/CircularQueue.java
+++ b/DataStructures/Queues/CircularQueue.java
@@ -1,3 +1,5 @@
+package DataStructures.Queues;
+
//This program implements the concept of CircularQueue in Java
//Link to the concept: (https://en.wikipedia.org/wiki/Circular_buffer)
diff --git a/DataStructures/Trees/BSTIterative.java b/DataStructures/Trees/BSTIterative.java
index 8c8e254be727..7cf283db95bb 100644
--- a/DataStructures/Trees/BSTIterative.java
+++ b/DataStructures/Trees/BSTIterative.java
@@ -1,3 +1,5 @@
+package DataStructures.Trees;
+
/**
*
*
diff --git a/DataStructures/Trees/BSTRecursive.java b/DataStructures/Trees/BSTRecursive.java
index a228326b4762..b6536a7b82f6 100644
--- a/DataStructures/Trees/BSTRecursive.java
+++ b/DataStructures/Trees/BSTRecursive.java
@@ -1,3 +1,5 @@
+package DataStructures.Trees;
+
/**
*
*
diff --git a/DataStructures/Trees/LCA.java b/DataStructures/Trees/LCA.java
index 0f3d63de351b..ffadd6a97f15 100644
--- a/DataStructures/Trees/LCA.java
+++ b/DataStructures/Trees/LCA.java
@@ -1,4 +1,4 @@
-package Trees;
+package DataStructures.Trees;
import java.util.ArrayList;
import java.util.Scanner;
diff --git a/DivideAndConquer/BinaryExponentiation.java b/DivideAndConquer/BinaryExponentiation.java
index b5844b8d9b40..623a30aebe73 100644
--- a/DivideAndConquer/BinaryExponentiation.java
+++ b/DivideAndConquer/BinaryExponentiation.java
@@ -1,3 +1,5 @@
+package DivideAndConquer;
+
public class BinaryExponentiation {
public static void main(String args[]) {
diff --git a/DivideAndConquer/ClosestPair.java b/DivideAndConquer/ClosestPair.java
index 48cbfc58af0e..48a2950e8a46 100644
--- a/DivideAndConquer/ClosestPair.java
+++ b/DivideAndConquer/ClosestPair.java
@@ -1,7 +1,5 @@
package DivideAndConquer;
-import java.io.IOException;
-
/**
* For a set of points in a coordinates system (10000 maximum), ClosestPair class calculates the two
* closest points.
diff --git a/DivideAndConquer/StrassenMatrixMultiplication.java b/DivideAndConquer/StrassenMatrixMultiplication.java
index 2608d5a3bbf2..6bd48b524a1a 100644
--- a/DivideAndConquer/StrassenMatrixMultiplication.java
+++ b/DivideAndConquer/StrassenMatrixMultiplication.java
@@ -1,3 +1,5 @@
+package DivideAndConquer;
+
// Java Program to Implement Strassen Algorithm
// Class Strassen matrix multiplication
diff --git a/DynamicProgramming/DiceThrow.java b/DynamicProgramming/DiceThrow.java
index 1bf1a715e127..415f4a63c9cc 100644
--- a/DynamicProgramming/DiceThrow.java
+++ b/DynamicProgramming/DiceThrow.java
@@ -1,3 +1,5 @@
+package DynamicProgramming;
+
// Given N dice each with M faces, numbered from 1 to M, find the number of ways to get sum X.
// X is the summation of values on each face when all the dice are thrown.
@@ -14,9 +16,6 @@ And it can be done using Dynamic Programming(DP).
// Code ---->
// Java program to find number of ways to get sum 'x' with 'n'
// dice where every dice has 'm' faces
-import java.util.*;
-import java.lang.*;
-import java.io.*;
class DP {
/* The main function that returns the number of ways to get sum 'x' with 'n' dice and 'm' with m faces. */
diff --git a/DynamicProgramming/LongestPalindromicSubsequence.java b/DynamicProgramming/LongestPalindromicSubsequence.java
index a7a62891cf54..0626c208bdd7 100644
--- a/DynamicProgramming/LongestPalindromicSubsequence.java
+++ b/DynamicProgramming/LongestPalindromicSubsequence.java
@@ -1,7 +1,4 @@
-package test;
-
-import java.io.*;
-import java.util.*;
+package DynamicProgramming;
/**
* Algorithm explanation https://www.educative.io/edpresso/longest-palindromic-subsequence-algorithm
diff --git a/DynamicProgramming/LongestPalindromicSubstring.java b/DynamicProgramming/LongestPalindromicSubstring.java
index 5bef01eb17b9..1652567676fb 100644
--- a/DynamicProgramming/LongestPalindromicSubstring.java
+++ b/DynamicProgramming/LongestPalindromicSubstring.java
@@ -1,7 +1,4 @@
-package test;
-
-import java.io.*;
-import java.util.*;
+package DynamicProgramming;
/*
* Algorithm explanation https://leetcode.com/problems/longest-palindromic-substring/
diff --git a/DynamicProgramming/MinimumSumPartition.java b/DynamicProgramming/MinimumSumPartition.java
index 745d22a1b5cf..c47984dbc941 100644
--- a/DynamicProgramming/MinimumSumPartition.java
+++ b/DynamicProgramming/MinimumSumPartition.java
@@ -15,9 +15,6 @@
Subset2 = {36, 40} ; sum of Subset2 = 76
*/
-import java.io.*;
-import java.util.*;
-
public class MinimumSumPartition {
public static int subSet(int[] arr) {
int n = arr.length;
diff --git a/DynamicProgramming/PalindromicPartitioning.java b/DynamicProgramming/PalindromicPartitioning.java
index c46616469f8b..e11837622597 100644
--- a/DynamicProgramming/PalindromicPartitioning.java
+++ b/DynamicProgramming/PalindromicPartitioning.java
@@ -1,4 +1,7 @@
package DynamicProgramming;
+
+import java.util.Scanner;
+
/**
* @file
* @brief Implements [Palindrome
@@ -16,9 +19,6 @@
* "aba | b | bbabb | ababa"
* @author [Syed] (https://github.com/roeticvampire)
*/
-
-import java.util.Scanner;
-
public class PalindromicPartitioning {
public static int minimalpartitions(String word){
@@ -31,7 +31,7 @@ public static int minimalpartitions(String word){
int[] minCuts = new int[len];
boolean[][] isPalindrome = new boolean[len][len];
- int i, j, k, L; // different looping variables
+ int i, j, L; // different looping variables
// Every substring of length 1 is a palindrome
for (i = 0; i < len; i++) {
diff --git a/DynamicProgramming/ShortestCommonSupersequenceLength.java b/DynamicProgramming/ShortestCommonSupersequenceLength.java
index bca31746bcb8..8948bde5025c 100644
--- a/DynamicProgramming/ShortestCommonSupersequenceLength.java
+++ b/DynamicProgramming/ShortestCommonSupersequenceLength.java
@@ -1,3 +1,5 @@
+package DynamicProgramming;
+
// Java program to find length of the shortest supersequence
class ShortestSuperSequence {
diff --git a/DynamicProgramming/Sum_Of_Subset.java b/DynamicProgramming/Sum_Of_Subset.java
index a1dc24b34a01..7faa116006d5 100644
--- a/DynamicProgramming/Sum_Of_Subset.java
+++ b/DynamicProgramming/Sum_Of_Subset.java
@@ -1,3 +1,5 @@
+package DynamicProgramming;
+
public class Sum_Of_Subset {
public static void main(String[] args){
diff --git a/Maths/AutomorphicNumber.java b/Maths/AutomorphicNumber.java
index 9308073cb218..c0fac2a53b2d 100644
--- a/Maths/AutomorphicNumber.java
+++ b/Maths/AutomorphicNumber.java
@@ -1,3 +1,5 @@
+package Maths;
+
/**
* A number is said to be an Automorphic, if it is present in the last digit(s) of its square.
* Example- Let the number be 25, its square is 625.
diff --git a/Maths/CircularConvolutionFFT.java b/Maths/CircularConvolutionFFT.java
index 6c7c2c7e1277..dc207489e4a8 100644
--- a/Maths/CircularConvolutionFFT.java
+++ b/Maths/CircularConvolutionFFT.java
@@ -1,4 +1,4 @@
-package com.maths;
+package Maths;
import java.util.ArrayList;
diff --git a/Maths/Convolution.java b/Maths/Convolution.java
index 42757dbb5338..f96811735a2a 100644
--- a/Maths/Convolution.java
+++ b/Maths/Convolution.java
@@ -1,4 +1,4 @@
-package com.maths;
+package Maths;
/**
* Class for linear convolution of two discrete signals
diff --git a/Maths/ConvolutionFFT.java b/Maths/ConvolutionFFT.java
index f1d595087142..e43db72affc8 100644
--- a/Maths/ConvolutionFFT.java
+++ b/Maths/ConvolutionFFT.java
@@ -1,4 +1,4 @@
-package com.maths;
+package Maths;
import java.util.ArrayList;
diff --git a/Maths/FFT.java b/Maths/FFT.java
index bdf8444e73ee..30c8cfbdf7bf 100644
--- a/Maths/FFT.java
+++ b/Maths/FFT.java
@@ -1,4 +1,4 @@
-package com.maths;
+package Maths;
import java.util.ArrayList;
import java.util.Collections;
diff --git a/Maths/FFTBluestein.java b/Maths/FFTBluestein.java
index 4a571916db9a..06e87b15bce6 100644
--- a/Maths/FFTBluestein.java
+++ b/Maths/FFTBluestein.java
@@ -1,4 +1,4 @@
-package com.maths;
+package Maths;
import java.util.ArrayList;
diff --git a/Maths/GenericRoot.java b/Maths/GenericRoot.java
index 0909220346db..67074177be4b 100644
--- a/Maths/GenericRoot.java
+++ b/Maths/GenericRoot.java
@@ -1,3 +1,5 @@
+package Maths;
+
/*
* Algorithm explanation: https://technotip.com/6774/c-program-to-find-generic-root-of-a-number/#:~:text=Generic%20Root%3A%20of%20a%20number,get%20a%20single%2Ddigit%20output.&text=For%20Example%3A%20If%20user%20input,%2B%204%20%2B%205%20%3D%2015.
*/
diff --git a/Maths/KeithNumber.java b/Maths/KeithNumber.java
index e0d2ec89654c..d4a3e83c8fd0 100644
--- a/Maths/KeithNumber.java
+++ b/Maths/KeithNumber.java
@@ -1,4 +1,7 @@
-import java.util.*;
+package Maths;
+
+import java.util.*;
+
class KeithNumber
{
//user-defined function that checks if the given number is Keith or not
diff --git a/Maths/KrishnamurthyNumber.java b/Maths/KrishnamurthyNumber.java
index 4d3d48aadc71..130914226ee2 100644
--- a/Maths/KrishnamurthyNumber.java
+++ b/Maths/KrishnamurthyNumber.java
@@ -1,4 +1,4 @@
-//package Maths;
+package Maths;
/* This is a program to check if a number is a Krishnamurthy number or not.
A number is a Krishnamurthy number if the sum of the factorials of the digits of the number is equal to the number itself.
diff --git a/Maths/MagicSquare.java b/Maths/MagicSquare.java
index 70cbaf060eb1..289e8e7b83c4 100644
--- a/Maths/MagicSquare.java
+++ b/Maths/MagicSquare.java
@@ -1,4 +1,7 @@
+package Maths;
+
import java.util.*;
+
/*A magic square of order n is an arrangement of distinct n^2 integers,in a square, such that the n numbers in all
rows, all columns, and both diagonals sum to the same constant. A magic square contains the integers from 1 to n^2.*/
public class MagicSquare {
diff --git a/Maths/RomanNumeralUtil.java b/Maths/RomanNumeralUtil.java
index 661a2878b722..77a8c2965932 100644
--- a/Maths/RomanNumeralUtil.java
+++ b/Maths/RomanNumeralUtil.java
@@ -1,3 +1,5 @@
+package Maths;
+
/**
* Translates numbers into the Roman Numeral System.
*
diff --git a/Misc/TwoSumProblem.java b/Misc/TwoSumProblem.java
index 33bfbf4d2173..0bea06f3901f 100644
--- a/Misc/TwoSumProblem.java
+++ b/Misc/TwoSumProblem.java
@@ -1,5 +1,8 @@
+package Misc;
+
import java.util.*;
import java.util.stream.Collectors;
+
public class TwoSumProblem {
public static void main(String args[])
{
diff --git a/Misc/WordBoggle.java b/Misc/WordBoggle.java
index 2a87b0d6e8cc..85f70d21f91e 100644
--- a/Misc/WordBoggle.java
+++ b/Misc/WordBoggle.java
@@ -1,3 +1,5 @@
+package Misc;
+
import java.util.*;
public class WordBoggle {
diff --git a/Others/Implementing_auto_completing_features_using_trie.java b/Others/Implementing_auto_completing_features_using_trie.java
index 32d443b8ad34..e33c6438678e 100644
--- a/Others/Implementing_auto_completing_features_using_trie.java
+++ b/Others/Implementing_auto_completing_features_using_trie.java
@@ -1,13 +1,7 @@
package Others;
-
// Java Program to implement Auto-Complete
// Feature using Trie
-
-import java.util.*;
-import java.io.*;
-import java.lang.*;
-
class Trieac {
// Alphabet size (# of symbols)
diff --git a/Others/RabinKarp.java b/Others/RabinKarp.java
index 7dafa00c7874..6f9adf8a25f9 100644
--- a/Others/RabinKarp.java
+++ b/Others/RabinKarp.java
@@ -1,3 +1,5 @@
+package Others;
+
/** @author Prateek Kumar Oraon (https://github.com/prateekKrOraon) */
import java.util.Scanner;
diff --git a/Others/RestrictedTowerOfHanoi/Main/Hanoi.java b/Others/RestrictedTowerOfHanoi/Main/Hanoi.java
index 585649276c21..ab9e5b415d92 100644
--- a/Others/RestrictedTowerOfHanoi/Main/Hanoi.java
+++ b/Others/RestrictedTowerOfHanoi/Main/Hanoi.java
@@ -1,3 +1,5 @@
+package Others.RestrictedTowerOfHanoi.Main;
+
import java.awt.*;
import java.awt.event.*;
import java.util.*;
diff --git a/Others/StringMatchFiniteAutomata.java b/Others/StringMatchFiniteAutomata.java
index a6d3fbab4d62..f534fa812bf8 100644
--- a/Others/StringMatchFiniteAutomata.java
+++ b/Others/StringMatchFiniteAutomata.java
@@ -1,3 +1,5 @@
+package Others;
+
/** @author Prateek Kumar Oraon (https://github.com/prateekKrOraon) */
import java.util.Scanner;
diff --git a/Searches/howManyTimesRotated.java b/Searches/HowManyTimesRotated.java
similarity index 96%
rename from Searches/howManyTimesRotated.java
rename to Searches/HowManyTimesRotated.java
index 487df2e51d99..2efe50174338 100644
--- a/Searches/howManyTimesRotated.java
+++ b/Searches/HowManyTimesRotated.java
@@ -1,3 +1,7 @@
+package Searches;
+
+import java.util.*;
+
/*
Problem Statement:
Given an array, find out how many times it has to been rotated
@@ -19,10 +23,7 @@ If we look at the rotated array, to identify the minimum element (say a[i]), we
1. [1,2,3,4] Number of rotations: 0 or 4(Both valid)
2. [15,17,2,3,5] Number of rotations: 3
*/
-
-import java.util.*;
-
-class howManyTimesRotated
+class HowManyTimesRotated
{
public static void main(String[] args)
{
@@ -42,11 +43,11 @@ public static int rotated(int[] a)
int low = 0;
int high = a.length-1;
int mid=0; // low + (high-low)/2 = (low + high)/2
- int i=0;
+
while(low<=high)
{
mid = low + (high-low)/2;
- i++;
+
if(a[mid]
Date: Sat, 16 Oct 2021 17:12:33 +0300
Subject: [PATCH 0019/1552] Add Monte Carlo Tree Search Algorithm (#2588)
---
Searches/MonteCarloTreeSearch.java | 179 +++++++++++++++++++++++++++++
1 file changed, 179 insertions(+)
create mode 100644 Searches/MonteCarloTreeSearch.java
diff --git a/Searches/MonteCarloTreeSearch.java b/Searches/MonteCarloTreeSearch.java
new file mode 100644
index 000000000000..f6909b63a5e7
--- /dev/null
+++ b/Searches/MonteCarloTreeSearch.java
@@ -0,0 +1,179 @@
+package Searches;
+
+import java.util.Collections;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Random;
+
+/**
+ * Monte Carlo Tree Search (MCTS) is a heuristic search algorithm
+ * used in decition taking problems especially games.
+ *
+ * See more: https://en.wikipedia.org/wiki/Monte_Carlo_tree_search,
+ * https://www.baeldung.com/java-monte-carlo-tree-search
+ */
+public class MonteCarloTreeSearch {
+ public class Node {
+ Node parent;
+ ArrayList childNodes;
+ boolean isPlayersTurn; // True if it is the player's turn.
+ boolean playerWon; // True if the player won; false if the opponent won.
+ int score;
+ int visitCount;
+
+ public Node() {}
+
+ public Node(Node parent, boolean isPlayersTurn) {
+ this.parent = parent;
+ childNodes = new ArrayList<>();
+ this.isPlayersTurn = isPlayersTurn;
+ playerWon = false;
+ score = 0;
+ visitCount = 0;
+ }
+ }
+
+ static final int WIN_SCORE = 10;
+ static final int TIME_LIMIT = 500; // Time the algorithm will be running for (in milliseconds).
+
+ public static void main(String[] args) {
+ MonteCarloTreeSearch mcts = new MonteCarloTreeSearch();
+
+ mcts.monteCarloTreeSearch(mcts.new Node(null, true));
+ }
+
+ /**
+ * Explores a game tree using Monte Carlo Tree Search (MCTS)
+ * and returns the most promising node.
+ *
+ * @param rootNode Root node of the game tree.
+ * @return The most promising child of the root node.
+ */
+ public Node monteCarloTreeSearch(Node rootNode) {
+ Node winnerNode;
+ double timeLimit;
+
+ // Expand the root node.
+ addChildNodes(rootNode, 10);
+
+ timeLimit = System.currentTimeMillis() + TIME_LIMIT;
+
+ // Explore the tree until the time limit is reached.
+ while (System.currentTimeMillis() < timeLimit) {
+ Node promisingNode;
+
+ // Get a promising node using UCT.
+ promisingNode = getPromisingNode(rootNode);
+
+ // Expand the promising node.
+ if (promisingNode.childNodes.size() == 0) {
+ addChildNodes(promisingNode, 10);
+ }
+
+ simulateRandomPlay(promisingNode);
+ }
+
+ winnerNode = getWinnerNode(rootNode);
+ printScores(rootNode);
+ System.out.format("\nThe optimal node is: %02d\n", rootNode.childNodes.indexOf(winnerNode) + 1);
+
+ return winnerNode;
+ }
+
+ public void addChildNodes(Node node, int childCount) {
+ for (int i = 0; i < childCount; i++) {
+ node.childNodes.add(new Node(node, !node.isPlayersTurn));
+ }
+ }
+
+ /**
+ * Uses UCT to find a promising child node to be explored.
+ *
+ * UCT: Upper Confidence bounds applied to Trees.
+ *
+ * @param rootNode Root node of the tree.
+ * @return The most promising node according to UCT.
+ */
+ public Node getPromisingNode(Node rootNode) {
+ Node promisingNode = rootNode;
+
+ // Iterate until a node that hasn't been expanded is found.
+ while (promisingNode.childNodes.size() != 0) {
+ double uctIndex = Double.MIN_VALUE;
+ int nodeIndex = 0;
+
+ // Iterate through child nodes and pick the most promising one
+ // using UCT (Upper Confidence bounds applied to Trees).
+ for (int i = 0; i < promisingNode.childNodes.size(); i++) {
+ Node childNode = promisingNode.childNodes.get(i);
+ double uctTemp;
+
+ // If child node has never been visited
+ // it will have the highest uct value.
+ if (childNode.visitCount == 0) {
+ nodeIndex = i;
+ break;
+ }
+
+ uctTemp = ((double) childNode.score / childNode.visitCount)
+ + 1.41 * Math.sqrt(Math.log(promisingNode.visitCount) / (double) childNode.visitCount);
+
+ if (uctTemp > uctIndex) {
+ uctIndex = uctTemp;
+ nodeIndex = i;
+ }
+ }
+
+ promisingNode = promisingNode.childNodes.get(nodeIndex);
+ }
+
+ return promisingNode;
+ }
+
+ /**
+ * Simulates a random play from a nodes current state
+ * and back propagates the result.
+ *
+ * @param promisingNode Node that will be simulated.
+ */
+ public void simulateRandomPlay(Node promisingNode) {
+ Random rand = new Random();
+ Node tempNode = promisingNode;
+ boolean isPlayerWinner;
+
+ // The following line randomly determines whether the simulated play is a win or loss.
+ // To use the MCTS algorithm correctly this should be a simulation of the nodes' current
+ // state of the game until it finishes (if possible) and use an evaluation function to
+ // determine how good or bad the play was.
+ // e.g. Play tic tac toe choosing random squares until the game ends.
+ promisingNode.playerWon = (rand.nextInt(6) == 0);
+
+ isPlayerWinner = promisingNode.playerWon;
+
+ // Back propagation of the random play.
+ while (tempNode != null) {
+ tempNode.visitCount++;
+
+ // Add wining scores to bouth player and opponent depending on the turn.
+ if ((tempNode.isPlayersTurn && isPlayerWinner) ||
+ (!tempNode.isPlayersTurn && !isPlayerWinner)) {
+ tempNode.score += WIN_SCORE;
+ }
+
+ tempNode = tempNode.parent;
+ }
+ }
+
+ public Node getWinnerNode(Node rootNode) {
+ return Collections.max(rootNode.childNodes, Comparator.comparing(c -> c.score));
+ }
+
+ public void printScores(Node rootNode) {
+ System.out.println("N.\tScore\t\tVisits");
+
+ for (int i = 0; i < rootNode.childNodes.size(); i++) {
+ System.out.println(String.format("%02d\t%d\t\t%d", i + 1,
+ rootNode.childNodes.get(i).score, rootNode.childNodes.get(i).visitCount));
+ }
+ }
+}
From fa3c1f5e6a3b2b29c4961679bbaebd0d2c090af0 Mon Sep 17 00:00:00 2001
From: patrick-steve <75305373+patrick-steve@users.noreply.github.com>
Date: Mon, 18 Oct 2021 10:32:28 +0530
Subject: [PATCH 0020/1552] Add Affine Cipher #hacktoberfest (#2587)
---
Ciphers/affineCipher.java | 83 +++++++++++++++++++++++++++++++++++++++
1 file changed, 83 insertions(+)
create mode 100644 Ciphers/affineCipher.java
diff --git a/Ciphers/affineCipher.java b/Ciphers/affineCipher.java
new file mode 100644
index 000000000000..8542884c8b5f
--- /dev/null
+++ b/Ciphers/affineCipher.java
@@ -0,0 +1,83 @@
+package Ciphers;
+class affineCipher
+{
+
+ // Key values of a and b
+ static int a = 17;
+ static int b = 20;
+
+ static String encryptMessage(char[] msg)
+ {
+ /// Cipher Text initially empty
+ String cipher = "";
+ for (int i = 0; i < msg.length; i++)
+ {
+ // Avoid space to be encrypted
+ /* applying encryption formula ( a x + b ) mod m
+ {here x is msg[i] and m is 26} and added 'A' to
+ bring it in range of ascii alphabet[ 65-90 | A-Z ] */
+ if (msg[i] != ' ')
+ {
+ cipher = cipher
+ + (char) ((((a * (msg[i] - 'A')) + b) % 26) + 'A');
+ } else // else simply append space character
+ {
+ cipher += msg[i];
+ }
+ }
+ return cipher;
+ }
+
+ static String decryptCipher(String cipher)
+ {
+ String msg = "";
+ int a_inv = 0;
+ int flag = 0;
+
+ //Find a^-1 (the multiplicative inverse of a
+ //in the group of integers modulo m.)
+ for (int i = 0; i < 26; i++)
+ {
+ flag = (a * i) % 26;
+
+ // Check if (a*i)%26 == 1,
+ // then i will be the multiplicative inverse of a
+ if (flag == 1)
+ {
+ a_inv = i;
+ }
+ }
+ for (int i = 0; i < cipher.length(); i++)
+ {
+ /*Applying decryption formula a^-1 ( x - b ) mod m
+ {here x is cipher[i] and m is 26} and added 'A'
+ to bring it in range of ASCII alphabet[ 65-90 | A-Z ] */
+ if (cipher.charAt(i) != ' ')
+ {
+ msg = msg + (char) (((a_inv *
+ ((cipher.charAt(i) + 'A' - b)) % 26)) + 'A');
+ }
+ else //else simply append space character
+ {
+ msg += cipher.charAt(i);
+ }
+ }
+
+ return msg;
+ }
+
+ // Driver code
+ public static void main(String[] args)
+ {
+ String msg = "AFFINE CIPHER";
+
+ // Calling encryption function
+ String cipherText = encryptMessage(msg.toCharArray());
+ System.out.println("Encrypted Message is : " + cipherText);
+
+ // Calling Decryption function
+ System.out.println("Decrypted Message is: " + decryptCipher(cipherText));
+
+ }
+}
+
From e04ba756fd276f8b06ae97bc8386a523b643b478 Mon Sep 17 00:00:00 2001
From: Vatsal Patel <75309827+vatsal-dp@users.noreply.github.com>
Date: Mon, 18 Oct 2021 11:13:38 +0530
Subject: [PATCH 0021/1552] Add Affine Cipher (#2668)
---
Ciphers/AffineCipher.java | 98 +++++++++++++++++++++++++++++++++++++++
1 file changed, 98 insertions(+)
create mode 100644 Ciphers/AffineCipher.java
diff --git a/Ciphers/AffineCipher.java b/Ciphers/AffineCipher.java
new file mode 100644
index 000000000000..679f742c5d23
--- /dev/null
+++ b/Ciphers/AffineCipher.java
@@ -0,0 +1,98 @@
+//The ‘key’ for the Affine cipher consists of 2 numbers, we’ll call them a and b.
+// The following discussion assumes the use of a 26 character alphabet (m = 26).
+// a should be chosen to be relatively prime to m (i.e. a should have no factors in common with m).
+
+package Ciphers;
+
+import java.util.Scanner;
+
+class AffineCipher
+{
+ static Scanner in = new Scanner(System.in);
+
+ static String encryptMessage(char[] msg)
+ {
+ System.out.println("Enter key value a for encryption : ");
+ int a = in.nextInt();
+
+ System.out.println("Enter key value b for encryption : ");
+ int b = in.nextInt();
+
+ /// Initially empty cipher String
+ String cipher = "";
+ for (int i = 0; i < msg.length; i++)
+ {
+ // Avoid space to be encrypted
+ /* applying encryption formula ( a x + b ) mod m
+ {here x is msg[i] and m is 26} and added 'A' to
+ bring it in range of ascii alphabet[ 65-90 | A-Z ] */
+ if (msg[i] != ' ')
+ {
+ cipher = cipher
+ + (char) ((((a * (msg[i] - 'A')) + b) % 26) + 'A');
+ } else // append space character
+ {
+ cipher += msg[i];
+ }
+ }
+ return cipher;
+ }
+
+ static String decryptCipher(String cipher)
+ {
+ System.out.println("Enter key value a for decryption : ");
+ int a = in.nextInt();
+
+ System.out.println("Enter key value b for decryption : ");
+ int b = in.nextInt();
+
+ String msg = "";
+ int a_inv = 0;
+ int flag = 0;
+
+ //Find a^-1 (the multiplicative inverse of a
+ //in the group of integers modulo m.)
+ for (int i = 0; i < 26; i++)
+ {
+ flag = (a * i) % 26;
+
+ // Check if (a*i)%26 == 1,
+ // if so, then i will be the multiplicative inverse of a
+ if (flag == 1)
+ {
+ a_inv = i;
+ }
+ }
+ for (int i = 0; i < cipher.length(); i++)
+ {
+ /*Applying decryption formula a^-1 ( x - b ) mod m
+ {here x is cipher[i] and m is 26} and added 'A'
+ to bring it in range of ASCII alphabet[ 65-90 | A-Z ] */
+ if (cipher.charAt(i) != ' ')
+ {
+ msg = msg + (char) (((a_inv *
+ ((cipher.charAt(i) + 'A' - b)) % 26)) + 'A');
+ }
+ else // append space character
+ {
+ msg += cipher.charAt(i);
+ }
+ }
+
+ return msg;
+ }
+
+ // Main method
+ public static void main(String[] args)
+ {
+ String msg = "AFFINE CIPHER";
+
+ // Encrypting message
+ String cipherText = encryptMessage(msg.toCharArray());
+ System.out.println("Encrypted Message is : " + cipherText);
+
+ // Decrypting message
+ System.out.println("Decrypted Message is: " + decryptCipher(cipherText));
+
+ }
+}
From 68d6a9419be675347bfbb0f2a7e374ebf4b51332 Mon Sep 17 00:00:00 2001
From: Suraj Kumar Modi <76468931+skmodi649@users.noreply.github.com>
Date: Tue, 19 Oct 2021 09:58:55 +0530
Subject: [PATCH 0022/1552] Add Digital Root (#2637)
---
Maths/DigitalRoot.java | 92 ++++++++++++++++++++++++++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 Maths/DigitalRoot.java
diff --git a/Maths/DigitalRoot.java b/Maths/DigitalRoot.java
new file mode 100644
index 000000000000..a94a1e8f4aa5
--- /dev/null
+++ b/Maths/DigitalRoot.java
@@ -0,0 +1,92 @@
+/** Author : Suraj Kumar Modi
+ * https://github.com/skmodi649
+ */
+
+
+/** You are given a number n. You need to find the digital root of n.
+ * DigitalRoot of a number is the recursive sum of its digits until we get a single digit number.
+ *
+ * Test Case 1:
+ * Input:
+ * n = 1
+ * Output: 1
+ * Explanation: Digital root of 1 is 1
+ *
+ * Test Case 2:
+ * Input:
+ * n = 99999
+ * Output: 9
+ * Explanation: Sum of digits of 99999 is 45
+ * which is not a single digit number, hence
+ * sum of digit of 45 is 9 which is a single
+ * digit number.
+ */
+
+
+
+/** Algorithm :
+ * Step 1 : Define a method digitalRoot(int n)
+ * Step 2 : Define another method single(int n)
+ * Step 3 : digitalRoot(int n) method takes output of single(int n) as input
+ if(single(int n) <= 9)
+ return single(n)
+ else
+ return digitalRoot(single(n))
+ * Step 4 : single(int n) calculates the sum of digits of number n recursively
+ if(n<=9)
+ return n;
+ else
+ return (n%10) + (n/10)
+ * Step 5 : In main method simply take n as input and then call digitalRoot(int n) function and print the result
+ */
+
+
+
+
+
+package Maths;
+
+import java.util.*;
+import java.io.*;
+import java.lang.*;
+
+class DigitalRoot
+{
+
+ public static int digitalRoot(int n)
+ {
+ if(single(n) <= 9) // If n is already single digit than simply call single method and return the value
+ return single(n);
+ else
+ return digitalRoot(single(n));
+ }
+
+
+
+ // This function is used for finding the sum of digits of number
+ public static int single(int n)
+ {
+ if(n<=9) // if n becomes less than 10 than return n
+ return n;
+ else
+ return (n % 10) + single(n / 10); // n % 10 for extracting digits one by one
+ } // n / 10 is the number obtainded after removing the digit one by one
+ // Sum of digits is stored in the Stack memory and then finally returned
+
+
+
+ public static void main(String[] args)
+ {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter the number : ");
+ int n = sc.nextInt(); // Taking a number as input from the user
+ System.out.println("Digital Root : "+digitalRoot(n)); // Printing the value returned by digitalRoot() method
+ }
+}
+
+
+/**
+ * Time Complexity : O((Number of Digits)^2)
+ * Auxiliary Space Complexity : O(Number of Digits)
+ * Constraints : 1 <= n <= 10^7
+ */
From 4a2b19016068c1be5040647194e89445aadeb199 Mon Sep 17 00:00:00 2001
From: KanakalathaVemuru <46847239+KanakalathaVemuru@users.noreply.github.com>
Date: Wed, 20 Oct 2021 13:49:30 +0530
Subject: [PATCH 0023/1552] Add Fenwick Tree (#2570)
---
DataStructures/Trees/FenwickTree.java | 34 +++++++++++++++++++++++++++
1 file changed, 34 insertions(+)
create mode 100644 DataStructures/Trees/FenwickTree.java
diff --git a/DataStructures/Trees/FenwickTree.java b/DataStructures/Trees/FenwickTree.java
new file mode 100644
index 000000000000..65b6eb07f920
--- /dev/null
+++ b/DataStructures/Trees/FenwickTree.java
@@ -0,0 +1,34 @@
+package DataStructures.Trees;
+
+public class FenwickTree {
+ private int n;
+ private int fen_t[];
+
+ /* Constructor which takes the size of the array as a parameter */
+ public FenwickTree(int n) {
+ this.n = n;
+ this.fen_t = new int[n + 1];
+ }
+
+ /* A function which will add the element val at index i*/
+ public void update(int i, int val) {
+ // As index starts from 0, increment the index by 1
+ i += 1;
+ while (i <= n) {
+ fen_t[i] += val;
+ i += i & (-i);
+ }
+ }
+
+ /* A function which will return the cumulative sum from index 1 to index i*/
+ public int query(int i) {
+ // As index starts from 0, increment the index by 1
+ i += 1;
+ int cumSum = 0;
+ while (i > 0) {
+ cumSum += fen_t[i];
+ i -= i & (-i);
+ }
+ return cumSum;
+ }
+}
\ No newline at end of file
From 3028cf58d81b7383d3ae23f2c5d078d89f752cfd Mon Sep 17 00:00:00 2001
From: Amit Kumar
Date: Wed, 20 Oct 2021 13:52:32 +0530
Subject: [PATCH 0024/1552] Fix: 2618: [Enhancement] Combinations (#2625)
Co-authored-by: Amit Kumar
---
Maths/Combinations.java | 39 +++++++++++++++++++++++++++++++++++++++
1 file changed, 39 insertions(+)
diff --git a/Maths/Combinations.java b/Maths/Combinations.java
index 0fb2437c21f3..cc19ee9088be 100644
--- a/Maths/Combinations.java
+++ b/Maths/Combinations.java
@@ -7,6 +7,17 @@ public static void main(String[] args) {
assert combinations(10, 5) == 252;
assert combinations(6, 3) == 20;
assert combinations(20, 5) == 15504;
+
+ // Since, 200 is a big number its factorial will go beyond limits of long even when 200C5 can be saved in a long
+ // variable. So below will fail
+ // assert combinations(200, 5) == 2535650040l;
+
+ assert combinationsOptimized(100, 0) == 1;
+ assert combinationsOptimized(1, 1) == 1;
+ assert combinationsOptimized(10, 5) == 252;
+ assert combinationsOptimized(6, 3) == 20;
+ assert combinationsOptimized(20, 5) == 15504;
+ assert combinationsOptimized(200, 5) == 2535650040l;
}
/**
@@ -32,4 +43,32 @@ public static long factorial(int n) {
public static long combinations(int n, int k) {
return factorial(n) / (factorial(k) * factorial(n - k));
}
+
+ /**
+ * The above method can exceed limit of long (overflow) when factorial(n) is larger than limits of long variable.
+ * Thus even if nCk is within range of long variable above reason can lead to incorrect result.
+ * This is an optimized version of computing combinations.
+ * Observations:
+ * nC(k + 1) = (n - k) * nCk / (k + 1)
+ * We know the value of nCk when k = 1 which is nCk = n
+ * Using this base value and above formula we can compute the next term nC(k+1)
+ * @param n
+ * @param k
+ * @return nCk
+ */
+ public static long combinationsOptimized(int n, int k) {
+ if (n < 0 || k < 0) {
+ throw new IllegalArgumentException("n or k can't be negative");
+ }
+ if (n < k) {
+ throw new IllegalArgumentException("n can't be smaller than k");
+ }
+ // nC0 is always 1
+ long solution = 1;
+ for(int i = 0; i < k; i++) {
+ long next = (n - i) * solution / (i + 1);
+ solution = next;
+ }
+ return solution;
+ }
}
From ce53fee92fd6def93e81150e14a9445a492ec79b Mon Sep 17 00:00:00 2001
From: Madhur Panwar <39766613+mdrpanwar@users.noreply.github.com>
Date: Wed, 20 Oct 2021 21:08:21 +0530
Subject: [PATCH 0025/1552] Add Implementation of Tree Sort and Generic Type
BST (#2638)
---
DataStructures/Trees/BSTRecursive.java | 2 +-
DataStructures/Trees/BSTRecursiveGeneric.java | 296 ++++++++++++++++++
Sorts/TreeSort.java | 113 +++++++
3 files changed, 410 insertions(+), 1 deletion(-)
create mode 100644 DataStructures/Trees/BSTRecursiveGeneric.java
create mode 100644 Sorts/TreeSort.java
diff --git a/DataStructures/Trees/BSTRecursive.java b/DataStructures/Trees/BSTRecursive.java
index b6536a7b82f6..3802ceb4285e 100644
--- a/DataStructures/Trees/BSTRecursive.java
+++ b/DataStructures/Trees/BSTRecursive.java
@@ -26,7 +26,7 @@ public class BSTRecursive {
/** main function for tests */
public static void main(String[] args) {
- BSTIterative tree = new BSTIterative();
+ BSTRecursive tree = new BSTRecursive();
tree.add(5);
tree.add(10);
tree.add(9);
diff --git a/DataStructures/Trees/BSTRecursiveGeneric.java b/DataStructures/Trees/BSTRecursiveGeneric.java
new file mode 100644
index 000000000000..a3b117a6fc46
--- /dev/null
+++ b/DataStructures/Trees/BSTRecursiveGeneric.java
@@ -0,0 +1,296 @@
+package DataStructures.Trees;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Binary Search Tree (Recursive) Generic Type Implementation
+ *
+ *
+ * A recursive implementation of generic type BST.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Binary_search_tree
+ *
+ *
+ * @author [Madhur Panwar](https://github.com/mdrpanwar)
+ */
+public class BSTRecursiveGeneric> {
+ /** only data member is root of BST */
+ private Node root;
+
+ /** Constructor use to initialize node as null */
+ public BSTRecursiveGeneric() {
+ root = null;
+ }
+
+ /** main function for testing */
+ public static void main(String[] args) {
+ System.out.println("Testing for integer data...");
+ // Integer
+ DataStructures.Trees.BSTRecursiveGeneric integerTree = new DataStructures.Trees.BSTRecursiveGeneric();
+
+ integerTree.add(5);
+ integerTree.add(10);
+ integerTree.add(9);
+ assert !integerTree.find(4) : "4 is not yet present in BST";
+ assert integerTree.find(10) : "10 should be present in BST";
+ integerTree.remove(9);
+ assert !integerTree.find(9) : "9 was just deleted from BST";
+ integerTree.remove(1);
+ assert !integerTree.find(1) : "Since 1 was not present so find deleting would do no change";
+ integerTree.add(20);
+ integerTree.add(70);
+ assert integerTree.find(70) : "70 was inserted but not found";
+ /*
+ Will print in following order
+ 5 10 20 70
+ */
+ integerTree.inorder();
+ System.out.println();
+ System.out.println("Testing for string data...");
+ // String
+ DataStructures.Trees.BSTRecursiveGeneric stringTree = new DataStructures.Trees.BSTRecursiveGeneric();
+
+ stringTree.add("banana");
+ stringTree.add("pineapple");
+ stringTree.add("date");
+ assert !stringTree.find("girl") : "girl is not yet present in BST";
+ assert stringTree.find("pineapple") : "10 should be present in BST";
+ stringTree.remove("date");
+ assert !stringTree.find("date") : "date was just deleted from BST";
+ stringTree.remove("boy");
+ assert !stringTree.find("boy") : "Since boy was not present so deleting would do no change";
+ stringTree.add("india");
+ stringTree.add("hills");
+ assert stringTree.find("hills") : "hills was inserted but not found";
+ /*
+ Will print in following order
+ banana hills india pineapple
+ */
+ stringTree.inorder();
+
+ }
+
+ /**
+ * Recursive method to delete a data if present in BST.
+ *
+ * @param node the node under which to (recursively) search for data
+ * @param data the value to be deleted
+ * @return Node the updated value of root parameter after delete operation
+ */
+ private Node delete(Node node, T data) {
+ if (node == null) {
+ System.out.println("No such data present in BST.");
+ } else if (node.data.compareTo(data) > 0) {
+ node.left = delete(node.left, data);
+ } else if (node.data.compareTo(data) < 0) {
+ node.right = delete(node.right, data);
+ } else {
+ if (node.right == null && node.left == null) { // If it is leaf node
+ node = null;
+ } else if (node.left == null) { // If only right node is present
+ Node temp = node.right;
+ node.right = null;
+ node = temp;
+ } else if (node.right == null) { // Only left node is present
+ Node temp = node.left;
+ node.left = null;
+ node = temp;
+ } else { // both child are present
+ Node temp = node.right;
+ // Find leftmost child of right subtree
+ while (temp.left != null) {
+ temp = temp.left;
+ }
+ node.data = temp.data;
+ node.right = delete(node.right, temp.data);
+ }
+ }
+ return node;
+ }
+
+ /**
+ * Recursive insertion of value in BST.
+ *
+ * @param node to check if the data can be inserted in current node or its subtree
+ * @param data the value to be inserted
+ * @return the modified value of the root parameter after insertion
+ */
+ private Node insert(Node node, T data) {
+ if (node == null) {
+ node = new Node<>(data);
+ } else if (node.data.compareTo(data) > 0) {
+ node.left = insert(node.left, data);
+ } else if (node.data.compareTo(data) < 0) {
+ node.right = insert(node.right, data);
+ }
+ return node;
+ }
+
+ /**
+ * Recursively print Preorder traversal of the BST
+ *
+ * @param node the root node
+ */
+ private void preOrder(Node node) {
+ if (node == null) {
+ return;
+ }
+ System.out.print(node.data + " ");
+ if (node.left != null) {
+ preOrder(node.left);
+ }
+ if (node.right != null) {
+ preOrder(node.right);
+ }
+ }
+
+ /**
+ * Recursively print Postorder traversal of BST.
+ *
+ * @param node the root node
+ */
+ private void postOrder(Node node) {
+ if (node == null) {
+ return;
+ }
+ if (node.left != null) {
+ postOrder(node.left);
+ }
+ if (node.right != null) {
+ postOrder(node.right);
+ }
+ System.out.print(node.data + " ");
+ }
+
+ /**
+ * Recursively print Inorder traversal of BST.
+ *
+ * @param node the root node
+ */
+ private void inOrder(Node node) {
+ if (node == null) {
+ return;
+ }
+ if (node.left != null) {
+ inOrder(node.left);
+ }
+ System.out.print(node.data + " ");
+ if (node.right != null) {
+ inOrder(node.right);
+ }
+ }
+
+ /**
+ * Recursively traverse the tree using inorder traversal
+ * and keep adding elements to argument list.
+ *
+ * @param node the root node
+ * @param sortedList the list to add the srted elements into
+ */
+ private void inOrderSort(Node node, List sortedList) {
+ if (node == null) {
+ return;
+ }
+ if (node.left != null) {
+ inOrderSort(node.left, sortedList);
+ }
+ sortedList.add(node.data);
+ if (node.right != null) {
+ inOrderSort(node.right, sortedList);
+ }
+ }
+
+ /**
+ * Serach recursively if the given value is present in BST or not.
+ *
+ * @param node the node under which to check
+ * @param data the value to be checked
+ * @return boolean if data is present or not
+ */
+ private boolean search(Node node, T data) {
+ if (node == null) {
+ return false;
+ } else if (node.data.compareTo(data) == 0) {
+ return true;
+ } else if (node.data.compareTo(data) > 0) {
+ return search(node.left, data);
+ } else {
+ return search(node.right, data);
+ }
+ }
+
+ /**
+ * add in BST. if the value is not already present it is inserted or else no change takes place.
+ *
+ * @param data the value to be inserted
+ */
+ public void add(T data) {
+ this.root = insert(this.root, data);
+ }
+
+ /**
+ * If data is present in BST delete it else do nothing.
+ *
+ * @param data the value to be removed
+ */
+ public void remove(T data) {
+ this.root = delete(this.root, data);
+ }
+
+ /** To call inorder traversal on tree */
+ public void inorder() {
+ System.out.println("Inorder traversal of this tree is:");
+ inOrder(this.root);
+ System.out.println(); // for next line
+ }
+
+ /** return a sorted list by traversing the tree elements using inorder traversal */
+ public List inorderSort() {
+ List sortedList = new ArrayList<>();
+ inOrderSort(this.root, sortedList);
+ return sortedList;
+ }
+
+ /** To call postorder traversal on tree */
+ public void postorder() {
+ System.out.println("Postorder traversal of this tree is:");
+ postOrder(this.root);
+ System.out.println(); // for next line
+ }
+
+ /** To call preorder traversal on tree. */
+ public void preorder() {
+ System.out.println("Preorder traversal of this tree is:");
+ preOrder(this.root);
+ System.out.println(); // for next line
+ }
+
+ /**
+ * To check if given value is present in tree or not.
+ *
+ * @param data the data to be found for
+ */
+ public boolean find(T data) {
+ if (search(this.root, data)) {
+ System.out.println(data + " is present in given BST.");
+ return true;
+ }
+ System.out.println(data + " not found.");
+ return false;
+ }
+
+ /** The generic Node class used for building binary search tree */
+ private static class Node {
+ T data;
+ Node left;
+ Node right;
+
+ /** Constructor with data as parameter */
+ Node(T d) {
+ data = d;
+ left = null;
+ right = null;
+ }
+ }
+}
diff --git a/Sorts/TreeSort.java b/Sorts/TreeSort.java
new file mode 100644
index 000000000000..126625db8fe3
--- /dev/null
+++ b/Sorts/TreeSort.java
@@ -0,0 +1,113 @@
+package Sorts;
+
+import static Sorts.SortUtils.print;
+
+import java.util.List;
+
+/**
+ * Implementation of the Tree Sort algorithm
+ *
+ *
+ * Tree Sort: A sorting algorithm which constructs a Binary Search Tree
+ * using the unsorted data and then outputs the data by inorder traversal
+ * of the tree.
+ *
+ * Reference: https://en.wikipedia.org/wiki/Tree_sort
+ *
+ *
+ * @author Madhur Panwar (https://github.com/mdrpanwar)
+ */
+public class TreeSort implements SortAlgorithm {
+
+ @Override
+ public > T[] sort(T[] unsortedArray) {
+ return doTreeSortArray(unsortedArray);
+ }
+
+ @Override
+ public > List sort(List unsortedList) {
+ return doTreeSortList(unsortedList);
+ }
+
+ private > T[] doTreeSortArray(T[] unsortedArray) {
+ // create a generic BST tree
+ DataStructures.Trees.BSTRecursiveGeneric tree = new DataStructures.Trees.BSTRecursiveGeneric();
+
+ // add all elements to the tree
+ for(T element: unsortedArray) {
+ tree.add(element);
+ }
+
+ // get the sorted list by inorder traversal of the tree
+ List sortedList = tree.inorderSort();
+
+ // add the elements back to the initial array
+ int i = 0;
+ for(T element: sortedList) {
+ unsortedArray[i++] = element;
+ }
+
+ // return the array
+ return unsortedArray;
+ }
+
+ private > List doTreeSortList(List unsortedList) {
+ // create a generic BST tree
+ DataStructures.Trees.BSTRecursiveGeneric tree = new DataStructures.Trees.BSTRecursiveGeneric();
+
+ // add all elements to the tree
+ for(T element: unsortedList) {
+ tree.add(element);
+ }
+
+ // get the sorted list by inorder traversal of the tree and return it
+ return tree.inorderSort();
+ }
+
+ public static void main(String[] args) {
+ TreeSort treeSort = new TreeSort();
+
+ // ==== Integer Array =======
+ System.out.println("Testing for Integer Array....");
+ Integer[] a = { 3, -7, 45, 1, 343, -5, 2, 9 };
+ System.out.print(String.format("%-10s", "unsorted: "));
+ print(a);
+ a = treeSort.sort(a);
+ System.out.print(String.format("%-10s", "sorted: "));
+ print(a);
+ System.out.println();
+
+ // ==== Integer List =======
+ System.out.println("Testing for Integer List....");
+ List intList = List.of(3, -7, 45, 1, 343, -5, 2, 9);
+ System.out.print(String.format("%-10s", "unsorted: "));
+ print(intList);
+ intList = treeSort.sort(intList);
+ System.out.print(String.format("%-10s", "sorted: "));
+ print(intList);
+ System.out.println();
+
+
+ // ==== String Array =======
+ System.out.println("Testing for String Array....");
+ String[] b = { "banana", "berry", "orange", "grape", "peach", "cherry", "apple", "pineapple" };
+ System.out.print(String.format("%-10s", "unsorted: "));
+ print(b);
+ b = treeSort.sort(b);
+ System.out.print(String.format("%-10s", "sorted: "));
+ print(b);
+ System.out.println();
+
+ // ==== String List =======
+ System.out.println("Testing for String List....");
+ List stringList = List.of("banana", "berry", "orange", "grape", "peach", "cherry", "apple", "pineapple");
+ System.out.print(String.format("%-10s", "unsorted: "));
+ print(stringList);
+ stringList = treeSort.sort(stringList);
+ System.out.print(String.format("%-10s", "sorted: "));
+ print(stringList);
+
+ }
+
+}
+
From 340a323c8785c8b84bbf167803aa3896bbf33f11 Mon Sep 17 00:00:00 2001
From: Anirudh Buvanesh <39529765+anirudhb11@users.noreply.github.com>
Date: Thu, 21 Oct 2021 10:36:30 +0530
Subject: [PATCH 0026/1552] Add matrix exponentiation based Fibonacci numbers
(#2616)
---
MatrixExponentiation/Fibonacci.java | 74 +++++++++++++++++++++++++++++
1 file changed, 74 insertions(+)
create mode 100644 MatrixExponentiation/Fibonacci.java
diff --git a/MatrixExponentiation/Fibonacci.java b/MatrixExponentiation/Fibonacci.java
new file mode 100644
index 000000000000..bdcc06816db8
--- /dev/null
+++ b/MatrixExponentiation/Fibonacci.java
@@ -0,0 +1,74 @@
+package MatrixExponentiation;
+
+import java.util.Scanner;
+
+/** @author Anirudh Buvanesh (https://github.com/anirudhb11)
+ * For more information see https://www.geeksforgeeks.org/matrix-exponentiation/
+ * */
+public class Fibonacci {
+ // Exponentiation matrix for Fibonacci sequence
+ private static final int [][] fibMatrix = {{1,1}, {1,0}};
+ private static final int [][] identityMatrix = {{1,0}, {0,1}};
+ //First 2 fibonacci numbers
+ private static final int [][] baseFibNumbers = {{1}, {0}};
+
+ /**
+ * Performs multiplication of 2 matrices
+ * @param matrix1
+ * @param matrix2
+ * @return The product of matrix1 and matrix2
+ */
+
+ private static int[][] matrixMultiplication(int[][] matrix1, int[][] matrix2){
+ //Check if matrices passed can be multiplied
+ int rowsInMatrix1 = matrix1.length;
+ int columnsInMatrix1 = matrix1[0].length;
+
+ int rowsInMatrix2 = matrix2.length;
+ int columnsInMatrix2 = matrix2[0].length;
+
+ assert columnsInMatrix1 == rowsInMatrix2;
+ int [][] product = new int[rowsInMatrix1][columnsInMatrix2];
+ for (int rowIndex = 0; rowIndex < rowsInMatrix1; rowIndex ++){
+ for(int colIndex = 0; colIndex < columnsInMatrix2; colIndex++){
+ int matrixEntry = 0;
+ for(int intermediateIndex = 0; intermediateIndex < columnsInMatrix1; intermediateIndex++){
+ matrixEntry += matrix1[rowIndex][intermediateIndex] * matrix2[intermediateIndex][colIndex];
+ }
+ product[rowIndex][colIndex] = matrixEntry;
+ }
+ }
+ return product;
+ }
+
+ /**
+ * Calculates the fibonacci number using matrix exponentiaition technique
+ * @param n The input n for which we have to determine the fibonacci number Outputs the nth
+ * * fibonacci number
+ * @return a 2 X 1 array as { {F_n+1}, {F_n} }
+ */
+ public static int[][] fib(int n){
+ if(n == 0){
+ return Fibonacci.identityMatrix;
+ }
+ else{
+ int [][] cachedResult = fib(n/2);
+ int [][] matrixExpResult = matrixMultiplication(cachedResult, cachedResult);
+ if(n%2 == 0){
+ return matrixExpResult;
+ }
+ else{
+ return matrixMultiplication(Fibonacci.fibMatrix, matrixExpResult);
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ // Returns [0, 1, 1, 2, 3, 5 ..] for n = [0, 1, 2, 3, 4, 5.. ]
+ Scanner sc = new Scanner(System.in);
+ int n = sc.nextInt();
+ int [][] result = matrixMultiplication(fib(n), baseFibNumbers);
+ System.out.println("Fib(" + n + ") = "+ result[1][0] );
+ sc.close();
+ }
+}
From 7ca58d6f8c9a52b7bf449b7a049091e37fdb68e8 Mon Sep 17 00:00:00 2001
From: patrick-steve <75305373+patrick-steve@users.noreply.github.com>
Date: Thu, 21 Oct 2021 21:33:28 +0530
Subject: [PATCH 0027/1552] Add Substitution Cipher (#2694)
---
Ciphers/simpleSubCipher.java | 92 ++++++++++++++++++++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 Ciphers/simpleSubCipher.java
diff --git a/Ciphers/simpleSubCipher.java b/Ciphers/simpleSubCipher.java
new file mode 100644
index 000000000000..779ca9b3aab8
--- /dev/null
+++ b/Ciphers/simpleSubCipher.java
@@ -0,0 +1,92 @@
+package ciphers;
+
+import java.util.*;
+
+/**
+ *
+ * The simple substitution cipher is a cipher that has been in use for many hundreds of years
+ * (an excellent history is given in Simon Singhs 'the Code Book').
+ * It basically consists of substituting every plaintext character for a different ciphertext character.
+ * It differs from the Caesar cipher in that the cipher alphabet is not simply the alphabet shifted,
+ * it is completely jumbled.
+ *
+ */
+
+public class simpleSubCipher {
+
+ /**
+ * Encrypt text by replacing each element with its opposite character.
+ *
+ * @param message
+ * @param cipherSmall
+ * @return Encrypted message
+ */
+ public static String encode(String message, String cipherSmall) {
+ String encoded = "";
+
+ // This map is used to encode
+ Map cipherMap = new HashMap();
+
+ char beginSmallLetter = 'a';
+ char beginCapitalLetter = 'A';
+
+ cipherSmall = cipherSmall.toLowerCase();
+ String cipherCapital = cipherSmall.toUpperCase();
+
+ // To handle Small and Capital letters
+ for(int i = 0; i < cipherSmall.length(); i++){
+ cipherMap.put(beginSmallLetter++,cipherSmall.charAt(i));
+ cipherMap.put(beginCapitalLetter++,cipherCapital.charAt(i));
+ }
+
+ for(int i = 0; i < message.length(); i++){
+ if(Character.isAlphabetic(message.charAt(i)))
+ encoded += cipherMap.get(message.charAt(i));
+ else
+ encoded += message.charAt(i);
+ }
+
+ return encoded;
+ }
+
+ /**
+ * Decrypt message by replacing each element with its opposite character in cipher.
+ *
+ * @param encryptedMessage
+ * @param cipherSmall
+ * @return message
+ */
+ public static String decode(String encryptedMessage, String cipherSmall) {
+ String decoded = "";
+
+
+ Map cipherMap = new HashMap();
+
+ char beginSmallLetter = 'a';
+ char beginCapitalLetter = 'A';
+
+ cipherSmall = cipherSmall.toLowerCase();
+ String cipherCapital = cipherSmall.toUpperCase();
+
+ for(int i = 0; i < cipherSmall.length(); i++){
+ cipherMap.put(cipherSmall.charAt(i),beginSmallLetter++);
+ cipherMap.put(cipherCapital.charAt(i),beginCapitalLetter++);
+ }
+
+ for(int i = 0; i < encryptedMessage.length(); i++){
+ if(Character.isAlphabetic(encryptedMessage.charAt(i)))
+ decoded += cipherMap.get(encryptedMessage.charAt(i));
+ else
+ decoded += encryptedMessage.charAt(i);
+ }
+
+ return decoded;
+ }
+
+ public static void main(String[] args) {
+ String a = encode("defend the east wall of the castle","phqgiumeaylnofdxjkrcvstzwb");
+ String b = decode(a,"phqgiumeaylnofdxjkrcvstzwb");
+ System.out.println(b);
+ }
+
+}
From 2eb6d5c1413fa2edb55a6723ab2bea6f608afb2e Mon Sep 17 00:00:00 2001
From: Dilrose Reji <70878223+dilroseR@users.noreply.github.com>
Date: Fri, 22 Oct 2021 09:53:21 +0530
Subject: [PATCH 0028/1552] Add Page Rank (#2614)
---
Others/PageRank.java | 94 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 94 insertions(+)
create mode 100644 Others/PageRank.java
diff --git a/Others/PageRank.java b/Others/PageRank.java
new file mode 100644
index 000000000000..fc4fed0fcae3
--- /dev/null
+++ b/Others/PageRank.java
@@ -0,0 +1,94 @@
+package Others;
+
+import java.util.*;
+
+class PageRank {
+ public static void main(String args[]) {
+ int nodes, i, j;
+ Scanner in = new Scanner(System.in);
+ System.out.print("Enter the Number of WebPages: ");
+ nodes = in.nextInt();
+ PageRank p = new PageRank();
+ System.out.println("Enter the Adjacency Matrix with 1->PATH & 0->NO PATH Between two WebPages: ");
+ for (i = 1; i <= nodes; i++)
+ for (j = 1; j <= nodes; j++) {
+ p.path[i][j] = in.nextInt();
+ if (j == i)
+ p.path[i][j] = 0;
+ }
+ p.calc(nodes);
+ }
+
+ public int path[][] = new int[10][10];
+ public double pagerank[] = new double[10];
+
+ public void calc(double totalNodes) {
+
+ double InitialPageRank;
+ double OutgoingLinks = 0;
+ double DampingFactor = 0.85;
+ double TempPageRank[] = new double[10];
+ int ExternalNodeNumber;
+ int InternalNodeNumber;
+ int k = 1; // For Traversing
+ int ITERATION_STEP = 1;
+ InitialPageRank = 1 / totalNodes;
+ System.out.printf(
+ " Total Number of Nodes :" + totalNodes + "\t Initial PageRank of All Nodes :" + InitialPageRank + "\n");
+
+ // 0th ITERATION _ OR _ INITIALIZATION PHASE //
+
+ for (k = 1; k <= totalNodes; k++) {
+ this.pagerank[k] = InitialPageRank;
+ }
+ System.out.printf("\n Initial PageRank Values , 0th Step \n");
+
+ for (k = 1; k <= totalNodes; k++) {
+ System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
+ }
+
+ while (ITERATION_STEP <= 2) // Iterations
+ {
+ // Store the PageRank for All Nodes in Temporary Array
+ for (k = 1; k <= totalNodes; k++) {
+ TempPageRank[k] = this.pagerank[k];
+ this.pagerank[k] = 0;
+ }
+
+ for (InternalNodeNumber = 1; InternalNodeNumber <= totalNodes; InternalNodeNumber++) {
+ for (ExternalNodeNumber = 1; ExternalNodeNumber <= totalNodes; ExternalNodeNumber++) {
+ if (this.path[ExternalNodeNumber][InternalNodeNumber] == 1) {
+ k = 1;
+ OutgoingLinks = 0; // Count the Number of Outgoing Links for each ExternalNodeNumber
+ while (k <= totalNodes) {
+ if (this.path[ExternalNodeNumber][k] == 1) {
+ OutgoingLinks = OutgoingLinks + 1; // Counter for Outgoing Links
+ }
+ k = k + 1;
+ }
+ // Calculate PageRank
+ this.pagerank[InternalNodeNumber] += TempPageRank[ExternalNodeNumber] * (1 / OutgoingLinks);
+ }
+ }
+ System.out.printf("\n After " + ITERATION_STEP + "th Step \n");
+
+ for (k = 1; k <= totalNodes; k++)
+ System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
+
+ ITERATION_STEP = ITERATION_STEP + 1;
+ }
+
+ // Add the Damping Factor to PageRank
+ for (k = 1; k <= totalNodes; k++) {
+ this.pagerank[k] = (1 - DampingFactor) + DampingFactor * this.pagerank[k];
+ }
+
+ // Display PageRank
+ System.out.printf("\n Final Page Rank : \n");
+ for (k = 1; k <= totalNodes; k++) {
+ System.out.printf(" Page Rank of " + k + " is :\t" + this.pagerank[k] + "\n");
+ }
+
+ }
+ }
+}
From 87e10d66fa58998ca59f9e875163cf1a3a9e5eb0 Mon Sep 17 00:00:00 2001
From: Pramil <75042864+Pramil01@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:08:01 +0530
Subject: [PATCH 0029/1552] Add Power Sum (fixes #2634) (#2645)
---
Backtracking/PowerSum.java | 52 ++++++++++++++++++++++++++++++++++++++
1 file changed, 52 insertions(+)
create mode 100644 Backtracking/PowerSum.java
diff --git a/Backtracking/PowerSum.java b/Backtracking/PowerSum.java
new file mode 100644
index 000000000000..c06fa4439197
--- /dev/null
+++ b/Backtracking/PowerSum.java
@@ -0,0 +1,52 @@
+package Backtracking;
+
+import java.util.Scanner;
+/*
+ * Problem Statement :
+ * Find the number of ways that a given integer, N , can be expressed as the sum of the Xth powers of unique, natural numbers.
+ * For example, if N=100 and X=3, we have to find all combinations of unique cubes adding up to 100. The only solution is 1^3+2^3+3^3+4^3.
+ * Therefore output will be 1.
+*/
+public class PowerSum {
+
+ public static void main(String[] args) {
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter the number and the power");
+ int N = sc.nextInt();
+ int X = sc.nextInt();
+ PowerSum ps = new PowerSum();
+ int count = ps.powSum(N,X);
+ //printing the answer.
+ System.out.println("Number of combinations of different natural number's raised to "+X+" having sum "+N+" are : ");
+ System.out.println(count);
+ sc.close();
+ }
+ private int count = 0,sum=0;
+ public int powSum(int N, int X) {
+ Sum(N,X,1);
+ return count;
+ }
+ //here i is the natural number which will be raised by X and added in sum.
+ public void Sum(int N, int X,int i) {
+ //if sum is equal to N that is one of our answer and count is increased.
+ if(sum == N) {
+ count++;
+ return;
+ }
+ //we will be adding next natural number raised to X only if on adding it in sum the result is less than N.
+ else if(sum+power(i,X)<=N) {
+ sum+=power(i,X);
+ Sum(N,X,i+1);
+ //backtracking and removing the number added last since no possible combination is there with it.
+ sum-=power(i,X);
+ }
+ if(power(i,X)
Date: Fri, 22 Oct 2021 06:46:00 +0200
Subject: [PATCH 0030/1552] Add Union Find (fixes #2692) (#2693)
---
Searches/UnionFind.java | 77 +++++++++++++++++++++++++++++++++++++++++
1 file changed, 77 insertions(+)
create mode 100644 Searches/UnionFind.java
diff --git a/Searches/UnionFind.java b/Searches/UnionFind.java
new file mode 100644
index 000000000000..0aba6f876a23
--- /dev/null
+++ b/Searches/UnionFind.java
@@ -0,0 +1,77 @@
+package Searches;
+
+import java.util.*;
+
+public class UnionFind {
+ private int[] p;
+ private int[] r;
+
+ public UnionFind(int n) {
+ p = new int[n];
+ r = new int[n];
+
+ for (int i = 0; i < n; i++) {
+ p[i] = i;
+ }
+ }
+
+ public int find(int i) {
+ int parent = p[i];
+
+ if (i == parent) return i;
+
+ return p[i] = find(parent);
+ }
+
+ public void union(int x, int y) {
+ int r0 = find(x);
+ int r1 = find(y);
+
+ if (r1 == r0) return;
+
+ if (r[r0] > r[r1]) {
+ p[r1] = r0;
+ } else if (r[r1] > r[r0]) {
+ p[r0] = r1;
+ } else {
+ p[r1] = r0;
+ r[r0]++;
+ }
+ }
+
+ public int count() {
+ List parents = new ArrayList();
+ for(int i = 0; i < p.length; i++) {
+ if(!parents.contains(find(i))) {
+ parents.add(find(i));
+ }
+ }
+ return parents.size();
+ }
+
+ public String toString() {
+ return "p " + Arrays.toString(p) + " r " + Arrays.toString(r) + "\n";
+ }
+
+ // Tests
+ public static void main(String[] args) {
+ UnionFind uf = new UnionFind(5);
+ System.out.println("init /w 5 (should print 'p [0, 1, 2, 3, 4] r [0, 0, 0, 0, 0]'):");
+ System.out.println(uf);
+
+ uf.union(1,2);
+ System.out.println("union 1 2 (should print 'p [0, 1, 1, 3, 4] r [0, 1, 0, 0, 0]'):");
+ System.out.println(uf);
+
+ uf.union(3,4);
+ System.out.println("union 3 4 (should print 'p [0, 1, 1, 3, 3] r [0, 1, 0, 1, 0]'):");
+ System.out.println(uf);
+
+ uf.find(4);
+ System.out.println("find 4 (should print 'p [0, 1, 1, 3, 3] r [0, 1, 0, 1, 0]'):");
+ System.out.println(uf);
+
+ System.out.println("count (should print '3'):");
+ System.out.println(uf.count());
+ }
+}
From f7bf18ae9b3688a69219606cb548f9a77561bc3d Mon Sep 17 00:00:00 2001
From: Ashutosh Sharma <77958573+ashutosh-buku@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:22:21 +0530
Subject: [PATCH 0031/1552] Add Exponential Search (#2627)
---
Searches/ExponentalSearch.java | 59 ++++++++++++++++++++++++++++++++++
1 file changed, 59 insertions(+)
create mode 100644 Searches/ExponentalSearch.java
diff --git a/Searches/ExponentalSearch.java b/Searches/ExponentalSearch.java
new file mode 100644
index 000000000000..4b8e7afcacf5
--- /dev/null
+++ b/Searches/ExponentalSearch.java
@@ -0,0 +1,59 @@
+package Searches;
+
+import java.util.Arrays;
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.IntStream;
+
+import static java.lang.String.format;
+
+class ExponentialSearch implements SearchAlgorithm {
+
+ public static void main(String [] args) {
+ Random r = ThreadLocalRandom.current();
+
+ int size = 100;
+ int maxElement = 100000;
+
+ Integer[] integers =
+ IntStream.generate(() -> r.nextInt(maxElement))
+ .limit(size)
+ .sorted()
+ .boxed()
+ .toArray(Integer[]::new);
+
+ // The element that should be found
+ int shouldBeFound = integers[r.nextInt(size - 1)];
+
+ ExponentialSearch search = new ExponentialSearch();
+ int atIndex = search.find(integers, shouldBeFound);
+
+ System.out.println(
+ format(
+ "Should be found: %d. Found %d at index %d. An array length %d",
+ shouldBeFound, integers[atIndex], atIndex, size));
+
+ int toCheck = Arrays.binarySearch(integers, shouldBeFound);
+ System.out.println(
+ format(
+ "Found by system method at an index: %d. Is equal: %b", toCheck, toCheck == atIndex));
+
+ }
+
+ @Override
+ public > int find(T[] array, T key) {
+ if (array[0] == key)
+ return 0;
+ if (array[array.length - 1] == key)
+ return array.length;
+
+ int range = 1;
+
+
+ while (range < array.length && array[range].compareTo(key) <= -1) {
+ range = range * 2;
+ }
+
+ return Arrays.binarySearch(array, range / 2, Math.min(range, array.length), key);
+ }
+}
From 3bec562a1dc651295b343d5994f24e33fcec9b7e Mon Sep 17 00:00:00 2001
From: uttarabahad <34717612+uttarabahad@users.noreply.github.com>
Date: Fri, 22 Oct 2021 10:50:06 +0530
Subject: [PATCH 0032/1552] Add Dudeney Number (#2629)
---
Maths/DudeneyNumber.java | 65 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 65 insertions(+)
create mode 100644 Maths/DudeneyNumber.java
diff --git a/Maths/DudeneyNumber.java b/Maths/DudeneyNumber.java
new file mode 100644
index 000000000000..e10b003cd683
--- /dev/null
+++ b/Maths/DudeneyNumber.java
@@ -0,0 +1,65 @@
+/**
+ * A number is said to be Dudeney if the sum of the digits, is the cube root of the entered number.
+ * Example- Let the number be 512, its sum of digits is 5+1+2=8. The cube root of 512 is also 8.
+ * Since, the sum of the digits is equal to the cube root of the entered number;
+ * it is a Dudeney Number.
+ */
+package Maths;
+
+import java.io.*;
+
+
+public class DudeneyNumber
+{
+ //returns True if the number is a Dudeney number and False if it is not a Dudeney number.
+ public static boolean isDudeney(int n)
+ {
+ // Calculating Cube Root
+ int cube_root = (int)(Math.round((Math.pow(n, 1.0 / 3.0))));
+ // If the number is not a perfect cube the method returns false.
+ if (cube_root * cube_root * cube_root != n)
+ return false;
+ int sum_of_digits = 0;// Stores the sums of the digit of the entered number
+ int temp = n;//A temporary variable to store the entered number
+ // Loop to calculate sum of the digits.
+ while (temp > 0)
+ {
+
+ // Extracting Last digit of the number
+ int rem = temp % 10;
+
+ // Calculating sum of digits.
+ sum_of_digits += rem;
+
+ // Removing the last digit
+ temp /= 10;
+ }
+
+ //If the cube root of the number is not equal to the sum of its digits we return false.
+ if (cube_root != sum_of_digits)
+ return false;
+
+ return true;
+ }
+
+ /** Method to check if number is Dudeney Number or Not
+ * 1) Input - Enter a Number: 512
+ * Output - It is a Dudeney Number.
+ * 2) Input - Enter a Number: 125
+ * Output - It is not a Dudeney Number.
+ */
+ public static void main(String args[]) throws IOException
+ {
+ BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+ System.out.println("Enter a Number: ");
+ int n=Integer.parseInt(br.readLine());
+ if(isDudeney(n))
+ {
+ System.out.println("It is a Dudeney Number.");
+ }
+ else
+ {
+ System.out.println("It is not a Dudeney Number.");
+ }
+ }
+}
\ No newline at end of file
From bc7a3fc3fc90aa6781a3fe988ccc90ab9ac81b10 Mon Sep 17 00:00:00 2001
From: Florian <38241786+Flonator3000@users.noreply.github.com>
Date: Fri, 22 Oct 2021 07:50:59 +0200
Subject: [PATCH 0033/1552] Add Leonardo Number (#2649) (#2650)
---
Maths/LeonardoNumber.java | 20 ++++++++++++++++++++
1 file changed, 20 insertions(+)
create mode 100644 Maths/LeonardoNumber.java
diff --git a/Maths/LeonardoNumber.java b/Maths/LeonardoNumber.java
new file mode 100644
index 000000000000..d666cab221b9
--- /dev/null
+++ b/Maths/LeonardoNumber.java
@@ -0,0 +1,20 @@
+package Maths;
+
+public class LeonardoNumber {
+ public static int leonardoNumber(int n) {
+ if (n < 0) {
+ return 0;
+ }
+ if (n == 0 || n == 1) {
+ return 1;
+ }
+ return (leonardoNumber(n - 1) + leonardoNumber(n - 2) + 1);
+ }
+
+ public static void main(String args[]) {
+ for (int i = 0; i < 20; i++) {
+ System.out.print(leonardoNumber(i) + " ");
+ }
+
+ }
+}
From 4e40e67aaef84cb3a65a65b270f7e2a0b8191c5d Mon Sep 17 00:00:00 2001
From: Subramani
Date: Sat, 23 Oct 2021 04:29:54 -0400
Subject: [PATCH 0034/1552] Correct grammatical errors in CONTRIBUTING.md
(#2687)
---
CONTRIBUTING.md | 4 ++--
1 file changed, 2 insertions(+), 2 deletions(-)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3d30db617484..d439684a4e14 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -10,7 +10,7 @@
#### **Do you want to contribute to the documentation?**
-- Please read the documentation in here [Contributing to the Documentation](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md) ,[open a new issue](https://github.com/TheAlgorithms/Java/issues/new), make changes and then create a pull request, it will be put under review and accepted if it is appropriate.
+- Please read the documentation here [Contributing to the Documentation](https://github.com/TheAlgorithms/Java/blob/master/CONTRIBUTING.md), [open a new issue](https://github.com/TheAlgorithms/Java/issues/new), make changes, and then create a pull request, it will be put under review and accepted if it is appropriate.
#### **Do you want to add a new feature?**
@@ -18,7 +18,7 @@
#### **Do you want to fix a bug?**
-- [Open a new issue](https://github.com/TheAlgorithms/Java/issues/new).Be sure to include a **title and a clear description** and a **test case** demonstrating the expected behaviour that is not occurring.
+- [Open a new issue](https://github.com/TheAlgorithms/Java/issues/new).Be sure to include a **title and a clear description** and a **test case** demonstrating the expected behavior that is not occurring.
#### **Do you have questions about the source code?**
From 2a74d6a34fc509e30f9d7d19f1643b2b6daf8193 Mon Sep 17 00:00:00 2001
From: Thisaru Dilshan <49381898+ThisaruD@users.noreply.github.com>
Date: Sat, 23 Oct 2021 14:14:49 +0530
Subject: [PATCH 0035/1552] Add ADT Fraction calculation (fixes #2453) (#2550)
---
DIRECTORY.md | 74 +++++++++++++++++++++++++++-
Maths/ADTFraction.java | 106 +++++++++++++++++++++++++++++++++++++++++
2 files changed, 179 insertions(+), 1 deletion(-)
create mode 100644 Maths/ADTFraction.java
diff --git a/DIRECTORY.md b/DIRECTORY.md
index 33266c52a956..c7eb2b2322e2 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,10 +1,19 @@
+## Backtracking
+ * [NQueens](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/NQueens.java)
+ * [PowerSum](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/PowerSum.java)
+
## Ciphers
* [AES](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/AES.java)
* [AESEncryption](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/AESEncryption.java)
+ * [affineCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/affineCipher.java)
+ * [AffineCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/AffineCipher.java)
* [Caesar](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/Caesar.java)
* [ColumnarTranspositionCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/ColumnarTranspositionCipher.java)
+ * [HillCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/HillCipher.java)
+ * [ProductCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/ProductCipher.java)
* [RSA](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/RSA.java)
+ * [simpleSubCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/simpleSubCipher.java)
* [SimpleSubstitutionCipher](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/SimpleSubstitutionCipher.java)
* [Vigenere](https://github.com/TheAlgorithms/Java/blob/master/Ciphers/Vigenere.java)
@@ -41,8 +50,10 @@
* [BellmanFord](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/BellmanFord.java)
* [ConnectedComponent](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/ConnectedComponent.java)
* [Cycles](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Cycles.java)
+ * [DIJSKSTRAS ALGORITHM](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java)
* [FloydWarshall](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/FloydWarshall.java)
* [Graphs](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Graphs.java)
+ * [KahnsAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/KahnsAlgorithm.java)
* [Kruskal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Kruskal.java)
* [MatrixGraphs](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/MatrixGraphs.java)
* [PrimMST](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/PrimMST.java)
@@ -67,9 +78,11 @@
* [Merge K SortedLinkedlist](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/Merge_K_SortedLinkedlist.java)
* [MergeSortedArrayList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/MergeSortedArrayList.java)
* [MergeSortedSinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/MergeSortedSinglyLinkedList.java)
+ * [RemoveDuplicateNodes](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/RemoveDuplicateNodes.java)
* [SearchSinglyLinkedListRecursion](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/SearchSinglyLinkedListRecursion.java)
* [SinglyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/SinglyLinkedList.java)
* Queues
+ * [CircularQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Queues/CircularQueue.java)
* [GenericArrayListQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Queues/GenericArrayListQueue.java)
* [LinkedQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Queues/LinkedQueue.java)
* [PriorityQueues](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Queues/PriorityQueues.java)
@@ -78,6 +91,7 @@
* [BalancedBrackets](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/BalancedBrackets.java)
* [DecimalToAnyUsingStack](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/DecimalToAnyUsingStack.java)
* [InfixToPostfix](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/InfixToPostfix.java)
+ * [MaximumMinimumWindow](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/MaximumMinimumWindow.java)
* [NodeStack](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/NodeStack.java)
* [StackArray](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/StackArray.java)
* [StackArrayList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/StackArrayList.java)
@@ -87,7 +101,11 @@
* [BinaryTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BinaryTree.java)
* [BSTIterative](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BSTIterative.java)
* [BSTRecursive](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BSTRecursive.java)
+ * [BSTRecursiveGeneric](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BSTRecursiveGeneric.java)
+ * [CeilInBinarySearchTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/CeilInBinarySearchTree.java)
+ * [FenwickTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/FenwickTree.java)
* [GenericTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/GenericTree.java)
+ * [LCA](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LCA.java)
* [LevelOrderTraversal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LevelOrderTraversal.java)
* [LevelOrderTraversalQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LevelOrderTraversalQueue.java)
* [PrintTopViewofTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/PrintTopViewofTree.java)
@@ -95,15 +113,20 @@
* [TreeTraversal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/TreeTraversal.java)
* [TrieImp](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/TrieImp.java)
* [ValidBSTOrNot](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/ValidBSTOrNot.java)
+ * [VerticalOrderTraversal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/VerticalOrderTraversal.java)
## DivideAndConquer
+ * [BinaryExponentiation](https://github.com/TheAlgorithms/Java/blob/master/DivideAndConquer/BinaryExponentiation.java)
* [ClosestPair](https://github.com/TheAlgorithms/Java/blob/master/DivideAndConquer/ClosestPair.java)
* [SkylineAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/DivideAndConquer/SkylineAlgorithm.java)
+ * [StrassenMatrixMultiplication](https://github.com/TheAlgorithms/Java/blob/master/DivideAndConquer/StrassenMatrixMultiplication.java)
## DynamicProgramming
* [BoardPath](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/BoardPath.java)
* [BruteForceKnapsack](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/BruteForceKnapsack.java)
+ * [CatalanNumber](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/CatalanNumber.java)
* [CoinChange](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/CoinChange.java)
+ * [DiceThrow](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/DiceThrow.java)
* [DyanamicProgrammingKnapsack](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/DyanamicProgrammingKnapsack.java)
* [EditDistance](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/EditDistance.java)
* [EggDropping](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/EggDropping.java)
@@ -111,26 +134,35 @@
* [FordFulkerson](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/FordFulkerson.java)
* [KadaneAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/KadaneAlgorithm.java)
* [Knapsack](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/Knapsack.java)
+ * [KnapsackMemoization](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/KnapsackMemoization.java)
* [LevenshteinDistance](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LevenshteinDistance.java)
* [LongestCommonSubsequence](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestCommonSubsequence.java)
* [LongestIncreasingSubsequence](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestIncreasingSubsequence.java)
* [LongestPalindromicSubsequence](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestPalindromicSubsequence.java)
+ * [LongestPalindromicSubstring](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestPalindromicSubstring.java)
* [LongestValidParentheses](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestValidParentheses.java)
* [MatrixChainMultiplication](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MatrixChainMultiplication.java)
* [MemoizationTechniqueKnapsack](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MemoizationTechniqueKnapsack.java)
* [MinimumPathSum](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MinimumPathSum.java)
* [MinimumSumPartition](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MinimumSumPartition.java)
+ * [PalindromicPartitioning](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/PalindromicPartitioning.java)
+ * [RegexMatching](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/RegexMatching.java)
* [RodCutting](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/RodCutting.java)
+ * [ShortestCommonSupersequenceLength](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/ShortestCommonSupersequenceLength.java)
* [SubsetSum](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/SubsetSum.java)
+ * [Sum Of Subset](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/Sum_Of_Subset.java)
+ * [WineProblem](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/WineProblem.java)
## Maths
* [AbsoluteMax](https://github.com/TheAlgorithms/Java/blob/master/Maths/AbsoluteMax.java)
* [AbsoluteMin](https://github.com/TheAlgorithms/Java/blob/master/Maths/AbsoluteMin.java)
* [AbsoluteValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/AbsoluteValue.java)
+ * [ADTFraction](https://github.com/TheAlgorithms/Java/blob/master/Maths/ADTFraction.java)
* [AliquotSum](https://github.com/TheAlgorithms/Java/blob/master/Maths/AliquotSum.java)
* [AmicableNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/AmicableNumber.java)
* [Area](https://github.com/TheAlgorithms/Java/blob/master/Maths/Area.java)
* [Armstrong](https://github.com/TheAlgorithms/Java/blob/master/Maths/Armstrong.java)
+ * [AutomorphicNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/AutomorphicNumber.java)
* [Average](https://github.com/TheAlgorithms/Java/blob/master/Maths/Average.java)
* [BinaryPow](https://github.com/TheAlgorithms/Java/blob/master/Maths/BinaryPow.java)
* [Ceil](https://github.com/TheAlgorithms/Java/blob/master/Maths/Ceil.java)
@@ -138,6 +170,9 @@
* [Combinations](https://github.com/TheAlgorithms/Java/blob/master/Maths/Combinations.java)
* [Convolution](https://github.com/TheAlgorithms/Java/blob/master/Maths/Convolution.java)
* [ConvolutionFFT](https://github.com/TheAlgorithms/Java/blob/master/Maths/ConvolutionFFT.java)
+ * [DeterminantOfMatrix](https://github.com/TheAlgorithms/Java/blob/master/Maths/DeterminantOfMatrix.java)
+ * [DigitalRoot](https://github.com/TheAlgorithms/Java/blob/master/Maths/DigitalRoot.java)
+ * [DudeneyNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/DudeneyNumber.java)
* [EulerMethod](https://github.com/TheAlgorithms/Java/blob/master/Maths/EulerMethod.java)
* [Factorial](https://github.com/TheAlgorithms/Java/blob/master/Maths/Factorial.java)
* [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FactorialRecursion.java)
@@ -151,11 +186,19 @@
* [Floor](https://github.com/TheAlgorithms/Java/blob/master/Maths/Floor.java)
* [GCD](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCD.java)
* [GCDRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/GCDRecursion.java)
+ * [GenericRoot](https://github.com/TheAlgorithms/Java/blob/master/Maths/GenericRoot.java)
+ * [HarshadNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/HarshadNumber.java)
+ * [KeithNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/KeithNumber.java)
+ * [KrishnamurthyNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/KrishnamurthyNumber.java)
+ * [LeonardoNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/LeonardoNumber.java)
* [LucasSeries](https://github.com/TheAlgorithms/Java/blob/master/Maths/LucasSeries.java)
+ * [MagicSquare](https://github.com/TheAlgorithms/Java/blob/master/Maths/MagicSquare.java)
* [MaxValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MaxValue.java)
* [Median](https://github.com/TheAlgorithms/Java/blob/master/Maths/Median.java)
* [MinValue](https://github.com/TheAlgorithms/Java/blob/master/Maths/MinValue.java)
* [Mode](https://github.com/TheAlgorithms/Java/blob/master/Maths/Mode.java)
+ * [NonRepeatingElement](https://github.com/TheAlgorithms/Java/blob/master/Maths/NonRepeatingElement.java)
+ * [NthUglyNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/NthUglyNumber.java)
* [NumberOfDigits](https://github.com/TheAlgorithms/Java/blob/master/Maths/NumberOfDigits.java)
* [PalindromeNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/PalindromeNumber.java)
* [ParseInteger](https://github.com/TheAlgorithms/Java/blob/master/Maths/ParseInteger.java)
@@ -169,23 +212,31 @@
* [PrimeCheck](https://github.com/TheAlgorithms/Java/blob/master/Maths/PrimeCheck.java)
* [PrimeFactorization](https://github.com/TheAlgorithms/Java/blob/master/Maths/PrimeFactorization.java)
* [PythagoreanTriple](https://github.com/TheAlgorithms/Java/blob/master/Maths/PythagoreanTriple.java)
+ * [RomanNumeralUtil](https://github.com/TheAlgorithms/Java/blob/master/Maths/RomanNumeralUtil.java)
* [SumOfArithmeticSeries](https://github.com/TheAlgorithms/Java/blob/master/Maths/SumOfArithmeticSeries.java)
* [SumOfDigits](https://github.com/TheAlgorithms/Java/blob/master/Maths/SumOfDigits.java)
* [VampireNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/VampireNumber.java)
+ * [VectorCrossProduct](https://github.com/TheAlgorithms/Java/blob/master/Maths/VectorCrossProduct.java)
+
+## MatrixExponentiation
+ * [Fibonacci](https://github.com/TheAlgorithms/Java/blob/master/MatrixExponentiation/Fibonacci.java)
## MinimizingLateness
* [MinimizingLateness](https://github.com/TheAlgorithms/Java/blob/master/MinimizingLateness/MinimizingLateness.java)
## Misc
* [ColorContrastRatio](https://github.com/TheAlgorithms/Java/blob/master/Misc/ColorContrastRatio.java)
+ * [InverseOfMatrix](https://github.com/TheAlgorithms/Java/blob/master/Misc/InverseOfMatrix.java)
* [matrixTranspose](https://github.com/TheAlgorithms/Java/blob/master/Misc/matrixTranspose.java)
* [MedianOfRunningArray](https://github.com/TheAlgorithms/Java/blob/master/Misc/MedianOfRunningArray.java)
* [PalindromePrime](https://github.com/TheAlgorithms/Java/blob/master/Misc/PalindromePrime.java)
* [RangeInSortedArray](https://github.com/TheAlgorithms/Java/blob/master/Misc/RangeInSortedArray.java)
+ * [TwoSumProblem](https://github.com/TheAlgorithms/Java/blob/master/Misc/TwoSumProblem.java)
* [WordBoggle](https://github.com/TheAlgorithms/Java/blob/master/Misc/WordBoggle.java)
## Others
* [BestFit](https://github.com/TheAlgorithms/Java/blob/master/Others/BestFit.java)
+ * [BFPRT](https://github.com/TheAlgorithms/Java/blob/master/Others/BFPRT.java)
* [BrianKernighanAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Others/BrianKernighanAlgorithm.java)
* [CountChar](https://github.com/TheAlgorithms/Java/blob/master/Others/CountChar.java)
* [CountWords](https://github.com/TheAlgorithms/Java/blob/master/Others/CountWords.java)
@@ -193,17 +244,21 @@
* [CRCAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Others/CRCAlgorithm.java)
* [Dijkstra](https://github.com/TheAlgorithms/Java/blob/master/Others/Dijkstra.java)
* [EulersFunction](https://github.com/TheAlgorithms/Java/blob/master/Others/EulersFunction.java)
- * [FibToN](https://github.com/TheAlgorithms/Java/blob/master/Others/FibToN.java)
+ * [FibbonaciSeries](https://github.com/TheAlgorithms/Java/blob/master/Others/FibbonaciSeries.java)
* [FirstFit](https://github.com/TheAlgorithms/Java/blob/master/Others/FirstFit.java)
* [FloydTriangle](https://github.com/TheAlgorithms/Java/blob/master/Others/FloydTriangle.java)
* [GuassLegendre](https://github.com/TheAlgorithms/Java/blob/master/Others/GuassLegendre.java)
+ * [Implementing auto completing features using trie](https://github.com/TheAlgorithms/Java/blob/master/Others/Implementing_auto_completing_features_using_trie.java)
* [InsertDeleteInArray](https://github.com/TheAlgorithms/Java/blob/master/Others/InsertDeleteInArray.java)
* [KMP](https://github.com/TheAlgorithms/Java/blob/master/Others/KMP.java)
* [KochSnowflake](https://github.com/TheAlgorithms/Java/blob/master/Others/KochSnowflake.java)
* [Krishnamurthy](https://github.com/TheAlgorithms/Java/blob/master/Others/Krishnamurthy.java)
* [LinearCongruentialGenerator](https://github.com/TheAlgorithms/Java/blob/master/Others/LinearCongruentialGenerator.java)
* [LowestBasePalindrome](https://github.com/TheAlgorithms/Java/blob/master/Others/LowestBasePalindrome.java)
+ * [Luhn](https://github.com/TheAlgorithms/Java/blob/master/Others/Luhn.java)
* [Mandelbrot](https://github.com/TheAlgorithms/Java/blob/master/Others/Mandelbrot.java)
+ * [MiniMaxAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Others/MiniMaxAlgorithm.java)
+ * [PageRank](https://github.com/TheAlgorithms/Java/blob/master/Others/PageRank.java)
* [PasswordGen](https://github.com/TheAlgorithms/Java/blob/master/Others/PasswordGen.java)
* [PerlinNoise](https://github.com/TheAlgorithms/Java/blob/master/Others/PerlinNoise.java)
* [QueueUsingTwoStacks](https://github.com/TheAlgorithms/Java/blob/master/Others/QueueUsingTwoStacks.java)
@@ -221,6 +276,7 @@
* [SkylineProblem](https://github.com/TheAlgorithms/Java/blob/master/Others/SkylineProblem.java)
* [StackPostfixNotation](https://github.com/TheAlgorithms/Java/blob/master/Others/StackPostfixNotation.java)
* [StringMatchFiniteAutomata](https://github.com/TheAlgorithms/Java/blob/master/Others/StringMatchFiniteAutomata.java)
+ * [Sudoku](https://github.com/TheAlgorithms/Java/blob/master/Others/Sudoku.java)
* [ThreeSum](https://github.com/TheAlgorithms/Java/blob/master/Others/ThreeSum.java)
* [TopKWords](https://github.com/TheAlgorithms/Java/blob/master/Others/TopKWords.java)
* [TowerOfHanoi](https://github.com/TheAlgorithms/Java/blob/master/Others/TowerOfHanoi.java)
@@ -229,15 +285,21 @@
## Searches
* [BinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/BinarySearch.java)
+ * [ExponentalSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/ExponentalSearch.java)
+ * [HowManyTimesRotated](https://github.com/TheAlgorithms/Java/blob/master/Searches/HowManyTimesRotated.java)
* [InterpolationSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/InterpolationSearch.java)
* [IterativeBinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/IterativeBinarySearch.java)
* [IterativeTernarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/IterativeTernarySearch.java)
* [JumpSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/JumpSearch.java)
* [LinearSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/LinearSearch.java)
+ * [LowerBound](https://github.com/TheAlgorithms/Java/blob/master/Searches/LowerBound.java)
+ * [MonteCarloTreeSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/MonteCarloTreeSearch.java)
* [PerfectBinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/PerfectBinarySearch.java)
* [SaddlebackSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/SaddlebackSearch.java)
* [SearchAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Searches/SearchAlgorithm.java)
+ * [SquareRootBinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/SquareRootBinarySearch.java)
* [TernarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/TernarySearch.java)
+ * [UnionFind](https://github.com/TheAlgorithms/Java/blob/master/Searches/UnionFind.java)
## Sorts
* [BitonicSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BitonicSort.java)
@@ -249,18 +311,25 @@
* [CombSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CombSort.java)
* [CountingSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CountingSort.java)
* [CycleSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CycleSort.java)
+ * [DNFSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/DNFSort.java)
* [GnomeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/GnomeSort.java)
* [HeapSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/HeapSort.java)
* [InsertionSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/InsertionSort.java)
* [MergeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSort.java)
+ * [MergeSortRecursive](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSortRecursive.java)
* [PancakeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/PancakeSort.java)
* [QuickSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/QuickSort.java)
* [RadixSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/RadixSort.java)
* [SelectionSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SelectionSort.java)
* [ShellSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/ShellSort.java)
+ * [SimpleSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SimpleSort.java)
+ * [SlowSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SlowSort.java)
* [SortAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SortAlgorithm.java)
* [SortUtils](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SortUtils.java)
+ * [StoogeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/StoogeSort.java)
+ * [SwapSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/SwapSort.java)
* [TimSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/TimSort.java)
+ * [TreeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/TreeSort.java)
## Strings
* [Alphabetical](https://github.com/TheAlgorithms/Java/blob/master/Strings/Alphabetical.java)
@@ -268,9 +337,12 @@
* [CheckAnagrams](https://github.com/TheAlgorithms/Java/blob/master/Strings/CheckAnagrams.java)
* [CheckVowels](https://github.com/TheAlgorithms/Java/blob/master/Strings/CheckVowels.java)
* [HorspoolSearch](https://github.com/TheAlgorithms/Java/blob/master/Strings/HorspoolSearch.java)
+ * [List all Possible Words From Phone Digits](https://github.com/TheAlgorithms/Java/blob/master/Strings/List_all_Possible_Words_From_Phone_Digits.java)
+ * [LongestPalindromicSubstring](https://github.com/TheAlgorithms/Java/blob/master/Strings/LongestPalindromicSubstring.java)
* [Lower](https://github.com/TheAlgorithms/Java/blob/master/Strings/Lower.java)
* [Palindrome](https://github.com/TheAlgorithms/Java/blob/master/Strings/Palindrome.java)
* [Pangram](https://github.com/TheAlgorithms/Java/blob/master/Strings/Pangram.java)
* [ReverseString](https://github.com/TheAlgorithms/Java/blob/master/Strings/ReverseString.java)
* [Rotation](https://github.com/TheAlgorithms/Java/blob/master/Strings/Rotation.java)
* [Upper](https://github.com/TheAlgorithms/Java/blob/master/Strings/Upper.java)
+ * [WordLadder](https://github.com/TheAlgorithms/Java/blob/master/Strings/WordLadder.java)
diff --git a/Maths/ADTFraction.java b/Maths/ADTFraction.java
new file mode 100644
index 000000000000..bb69f0326a9d
--- /dev/null
+++ b/Maths/ADTFraction.java
@@ -0,0 +1,106 @@
+
+package Maths;
+
+
+public class ADTFraction {
+
+
+ public static void main(String[] args) {
+ // TODO code application logic here
+
+ ADTFraction f1 = new ADTFraction(3, 5);
+ f1.display();
+ ADTFraction f2 = new ADTFraction(7, 8);
+ f2.display();
+ ADTFraction f3 = f1.plus(f2);
+ f3.display();
+ ADTFraction f4 = f1.times(f2);
+ f4.display();
+ ADTFraction f5 = f1.times(4);
+ f5.display();
+
+ }
+
+}
+
+class ADTFraction {
+ private int n; //numerator
+ private int d; //denomenator
+
+ public ADTFraction() {
+ this.n = 0;
+ this.d = 1;
+ }
+
+ public ADTFraction(int a, int b) {//parameter constructor
+
+ if (b != 0) {
+ this.n = a;
+ this.d = b;
+ } else {
+ this.n = 0;
+ this.d = 1;
+ System.out.println("denomerator cannot be 0,default values assinged");
+ }
+ }
+
+ public void set(int a, int b) {//set numerator and denomenator
+
+ if (b != 0) {
+ this.n = a;
+ this.d = b;
+ } else {
+ this.n = 0;
+ this.d = 1;
+ System.out.println("denomerator cannot be 0,default values assinged");
+ }
+
+ }
+
+ //add two fractions
+ public ADTFraction plus(ADTFraction x) {
+
+ int num, den;
+ num = this.d * x.n + this.n * x.d;
+ den = this.d * x.d;
+ ADTFraction f = new ADTFraction(num, den);
+ return f;
+
+ }
+
+ public ADTFraction times(int a) {//multiply fraction by a number
+
+ int num, den;
+ num = this.n * a;
+ den = this.d;
+ ADTFraction f1 = new ADTFraction(num, den);
+ return f1;
+
+ }
+
+ public ADTFraction times(ADTFraction x) {//multiply two fractions
+
+ int num, dem;
+ num = this.n * x.n;
+ dem = this.d * x.d;
+ ADTFraction f3 = new ADTFraction(num, dem);
+ return f3;
+
+ }
+
+ //reciprocal of a fraction
+ public ADTFraction reciprocal() {
+ ADTFraction f1 = new ADTFraction(this.d, this.n);
+ return f1;
+ }
+
+ //numerical value of a fraction
+ public float value() {
+ return (float) this.n / this.d;
+ }
+
+ //display the fraction in the format n/d
+ public void display() {
+ System.out.println(this.n + "/" + this.d);
+ }
+}
From 77f138077be3004fa6c0df5aa530dbc95384826f Mon Sep 17 00:00:00 2001
From: Shubhojeet Banerjee <50337427+Shubhojeetban@users.noreply.github.com>
Date: Sat, 23 Oct 2021 15:04:56 +0530
Subject: [PATCH 0036/1552] Add Check Bipartite in Graph (#2708)
---
DataStructures/Graphs/BipartiteGrapfDFS.java | 80 ++++++++++++++++++++
1 file changed, 80 insertions(+)
create mode 100644 DataStructures/Graphs/BipartiteGrapfDFS.java
diff --git a/DataStructures/Graphs/BipartiteGrapfDFS.java b/DataStructures/Graphs/BipartiteGrapfDFS.java
new file mode 100644
index 000000000000..472f20f10fdc
--- /dev/null
+++ b/DataStructures/Graphs/BipartiteGrapfDFS.java
@@ -0,0 +1,80 @@
+package DataStructures.Graphs;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Arrays;
+
+/**
+ * Given an adjacency list of a graph adj of V no.
+ * of vertices having 0 based index.
+ * Check whether the graph is bipartite or not.
+ *
+ * Input :
+ * {{0, 1, 0, 1},
+ * {1, 0, 1, 0},
+ * {0, 1, 0, 1},
+ * {1, 0, 1, 0}}
+ *
+ * Output : YES
+ */
+public class BipartiteGrapfDFS {
+ private static boolean bipartite(int V, ArrayList>adj, int[] color, int node){
+ if(color[node] == -1){
+ color[node] = 1;
+ }
+ for(Integer it : adj.get(node)){
+ if(color[it] == -1){
+ color[it] = 1-color[node];
+ if(bipartite(V, adj, color, it)== false) return false;
+ }
+ else if(color[it] == color[node]){
+ return false;
+ }
+ }
+ return true;
+ }
+ public static boolean isBipartite(int V, ArrayList> adj)
+ {
+ // Code here
+ int[] color = new int[V+1];
+ Arrays.fill(color, -1);
+
+ for(int i =0; i< V; i++){
+ if(color[i] == -1){
+ if(!bipartite(V, adj, color, i)){
+ return false;
+ }
+ }
+ }
+ return true;
+ }
+ public static void main(String[] args) throws IOException {
+ BufferedReader read = new BufferedReader(new InputStreamReader(System.in));
+ int t = Integer.parseInt(read.readLine().trim());
+ while(t-- > 0) {
+ String[] S = read.readLine().trim().split(" ");
+ int V = Integer.parseInt(S[0]);
+ int E = Integer.parseInt(S[1]);
+
+ ArrayList> adj = new ArrayList<>();
+ for(int i =0;i < V; i++) {
+ adj.add(new ArrayList<>());
+ }
+ for(int i = 0; i < E; i++) {
+ String[] s = read.readLine().trim().split(" ");
+ int u = Integer.parseInt(s[0]);
+ int v = Integer.parseInt(s[1]);
+ adj.get(u).add(v);
+ adj.get(v).add(u);
+ }
+
+ boolean ans = isBipartite(V, adj);
+ if(ans)
+ System.out.println("YES");
+ else
+ System.out.println("NO");
+ }
+ }
+}
From 831a0a4bd048d1806819090570a3c317658d9201 Mon Sep 17 00:00:00 2001
From: caos321 <36530240+caos321@users.noreply.github.com>
Date: Sat, 23 Oct 2021 12:56:08 +0200
Subject: [PATCH 0037/1552] Add Java Streams for Fibonacci computation (#2623)
Co-authored-by: xzero
---
Maths/FibonacciJavaStreams.java | 114 ++++++++++++++++++++++++++++++++
1 file changed, 114 insertions(+)
create mode 100644 Maths/FibonacciJavaStreams.java
diff --git a/Maths/FibonacciJavaStreams.java b/Maths/FibonacciJavaStreams.java
new file mode 100644
index 000000000000..e11365613920
--- /dev/null
+++ b/Maths/FibonacciJavaStreams.java
@@ -0,0 +1,114 @@
+package Maths;
+
+import java.math.BigDecimal;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.stream.Stream;
+
+/**
+ * @author: caos321
+ * @date: 14 October 2021 (Thursday)
+ */
+public class FibonacciJavaStreams {
+
+ public static Optional calculate(final BigDecimal index) {
+ if (index == null || index.compareTo(BigDecimal.ZERO) < 0) {
+ return Optional.empty();
+ }
+
+ if (index.compareTo(BigDecimal.ONE) < 0) {
+ return Optional.of(BigDecimal.ZERO);
+ }
+
+ if (index.compareTo(new BigDecimal(2)) < 0) {
+ return Optional.of(BigDecimal.ONE);
+ }
+
+ final List results = Stream.iterate(
+ index,
+ x -> x.compareTo(BigDecimal.ZERO) > 0,
+ x -> x.subtract(BigDecimal.ONE)
+ )
+ .reduce(
+ List.of(),
+ (list, current) ->
+ list.isEmpty() || list.size() < 2
+ ? List.of(BigDecimal.ZERO, BigDecimal.ONE)
+ : List.of(list.get(1), list.get(0).add(list.get(1))),
+ (list1, list2) -> list1
+ );
+
+ return results.isEmpty()
+ ? Optional.empty()
+ : Optional.of(results.get(results.size() - 1));
+ }
+
+ public static void assertThat(final Object actual, final Object expected) {
+ if (!Objects.equals(actual, expected)) {
+ throw new AssertionError(String.format("expected=%s but was actual=%s", expected, actual));
+ }
+ }
+
+ public static void main(final String[] args) {
+ {
+ final Optional result = calculate(new BigDecimal(-1));
+ assertThat(result.isEmpty(), true);
+ }
+ {
+ final Optional result = calculate(BigDecimal.ZERO);
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, BigDecimal.ZERO));
+ }
+ {
+ final Optional result = calculate(BigDecimal.ONE);
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(2));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, BigDecimal.ONE));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(3));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(2)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(10));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(55)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(20));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(6765)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(30));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(832040)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(40));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(102334155)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(50));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal(12586269025L)));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(100));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal("354224848179261915075")));
+ }
+ {
+ final Optional result = calculate(new BigDecimal(200));
+ assertThat(result.isPresent(), true);
+ result.ifPresent(value -> assertThat(value, new BigDecimal("280571172992510140037611932413038677189525")));
+ }
+ }
+}
From 5855983fe59d347e5f5e5a053cc1dbb9cac1bb40 Mon Sep 17 00:00:00 2001
From: Florian <38241786+Flonator3000@users.noreply.github.com>
Date: Sat, 23 Oct 2021 12:58:33 +0200
Subject: [PATCH 0038/1552] Add Trinomial triangle #2651 (#2652)
---
Maths/TrinomialTriangle.java | 47 ++++++++++++++++++++++++++++++++++++
1 file changed, 47 insertions(+)
create mode 100644 Maths/TrinomialTriangle.java
diff --git a/Maths/TrinomialTriangle.java b/Maths/TrinomialTriangle.java
new file mode 100644
index 000000000000..40723d54e93d
--- /dev/null
+++ b/Maths/TrinomialTriangle.java
@@ -0,0 +1,47 @@
+package Maths;
+
+/**
+ * The trinomial triangle is a variation of Pascal’s triangle. The difference
+ * between the two is that an entry in the trinomial triangle is the sum of the
+ * three (rather than the two in Pasacal’s triangle) entries above it
+ *
+ * Example Input: n = 4
+ * Output
+ * 1
+ * 1 1 1
+ * 1 2 3 2 1
+ * 1 3 6 7 6 3 1
+ */
+public class TrinomialTriangle {
+
+ public static int TrinomialValue(int n, int k) {
+ if (n == 0 && k == 0) {
+ return 1;
+ }
+
+ if (k < -n || k > n) {
+ return 0;
+ }
+
+ return TrinomialValue(n - 1, k - 1) + TrinomialValue(n - 1, k) + TrinomialValue(n - 1, k + 1);
+ }
+
+ public static void printTrinomial(int n) {
+ for (int i = 0; i < n; i++) {
+ for (int j = -i; j <= 0; j++) {
+ System.out.print(TrinomialValue(i, j) + " ");
+ }
+
+ for (int j = 1; j <= i; j++) {
+ System.out.print(TrinomialValue(i, j) + " ");
+ }
+
+ System.out.println();
+ }
+ }
+
+ public static void main(String argc[]) {
+ int n = 6;
+ printTrinomial(n);
+ }
+}
From 089ac333f2eacbf6bb96f2002ab34f70a2fa6ecd Mon Sep 17 00:00:00 2001
From: ishika22
Date: Sat, 23 Oct 2021 17:50:26 +0530
Subject: [PATCH 0039/1552] Add Reverse Stack (#2653)
---
DataStructures/Stacks/ReverseStack.java | 70 +++++++++++++++++++++++++
1 file changed, 70 insertions(+)
create mode 100644 DataStructures/Stacks/ReverseStack.java
diff --git a/DataStructures/Stacks/ReverseStack.java b/DataStructures/Stacks/ReverseStack.java
new file mode 100644
index 000000000000..8db3fb7c3ac1
--- /dev/null
+++ b/DataStructures/Stacks/ReverseStack.java
@@ -0,0 +1,70 @@
+package DataStructures.Stacks;
+
+import java.util.Scanner;
+import java.util.Stack;
+
+/**
+ * Reversal of a stack using recursion.
+ *
+ * @author Ishika Agarwal, 2021
+ */
+
+public class ReverseStack {
+
+ public static void main(String args[]){
+
+ Scanner sc = new Scanner(System.in);
+ System.out.println("Enter the number of elements you wish to insert in the stack");
+ int n = sc.nextInt();
+ int i;
+ Stack stack = new Stack();
+ System.out.println("Enter the stack elements");
+ for(i = 0; i < n ; i++)
+ stack.push(sc.nextInt());
+ sc.close();
+ reverseStack(stack);
+ System.out.println("The reversed stack is:");
+ while(!stack.isEmpty()){
+ System.out.print(stack.peek()+",");
+ stack.pop();
+ }
+
+ }
+
+ private static void reverseStack(Stack stack) {
+ if(stack.isEmpty()){
+ return;
+ }
+
+ //Store the topmost element
+ int element = stack.peek();
+ //Remove the topmost element
+ stack.pop();
+
+ //Reverse the stack for the leftover elements
+ reverseStack(stack);
+
+ //Insert the topmost element to the bottom of the stack
+ insertAtBottom(stack,element);
+
+ }
+
+ private static void insertAtBottom(Stack stack, int element) {
+
+ if(stack.isEmpty()){
+ //When stack is empty, insert the element so it will be present at the bottom of the stack
+ stack.push(element);
+ return;
+ }
+
+ int ele = stack.peek();
+ /*Keep popping elements till stack becomes empty. Push the elements once the topmost element has
+ moved to the bottom of the stack.
+ */
+ stack.pop();
+ insertAtBottom(stack, element);
+
+ stack.push(ele);
+ }
+
+}
From a9b242016575f509043ebe4cd23d7db0456a86a6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Aitor=20Fidalgo=20S=C3=A1nchez?=
<64830228+aitorfi@users.noreply.github.com>
Date: Sat, 23 Oct 2021 16:07:39 +0300
Subject: [PATCH 0040/1552] Fix build issue in ADTFraction.java (#2712)
---
Maths/ADTFraction.java | 7 -------
1 file changed, 7 deletions(-)
diff --git a/Maths/ADTFraction.java b/Maths/ADTFraction.java
index bb69f0326a9d..f585a81f2bc8 100644
--- a/Maths/ADTFraction.java
+++ b/Maths/ADTFraction.java
@@ -1,10 +1,6 @@
-
package Maths;
-
public class ADTFraction {
-
-
public static void main(String[] args) {
// TODO code application logic here
@@ -21,9 +17,6 @@ public static void main(String[] args) {
}
-}
-
-class ADTFraction {
private int n; //numerator
private int d; //denomenator
From 83ecf56d942842cf4a3ae66928e93ee8662d58a0 Mon Sep 17 00:00:00 2001
From: Shraddha <42699578+shraddhavp@users.noreply.github.com>
Date: Sun, 24 Oct 2021 12:36:59 +0530
Subject: [PATCH 0041/1552] Add merge sort with O(1) space (#2672)
---
Sorts/MergeSortNoExtraSpace.java | 75 ++++++++++++++++++++++++++++++++
1 file changed, 75 insertions(+)
create mode 100644 Sorts/MergeSortNoExtraSpace.java
diff --git a/Sorts/MergeSortNoExtraSpace.java b/Sorts/MergeSortNoExtraSpace.java
new file mode 100644
index 000000000000..282082ece03b
--- /dev/null
+++ b/Sorts/MergeSortNoExtraSpace.java
@@ -0,0 +1,75 @@
+package Sorts;
+import java.util.Arrays;
+import java.util.*;
+
+/*This code implements the mergeSort algorithm without extra space
+For understanding about mergesort visit :https://www.geeksforgeeks.org/merge-sort/
+ */
+public class MergeSortNoExtraSpace {
+ public static void call_merge_sort(int a[],int n)
+ {
+ int maxele = Arrays.stream(a).max().getAsInt() + 1;
+ merge_sort(a,0,n-1,maxele);
+ }
+ public static void merge_sort(int a[],int start , int end,int maxele){ //this function divides the array into 2 halves
+
+ if(start
Date: Sun, 24 Oct 2021 12:48:49 +0530
Subject: [PATCH 0042/1552] Update README.md of stack (#2671)
---
DataStructures/Stacks/README.md | 23 ++++++++++++-----------
1 file changed, 12 insertions(+), 11 deletions(-)
diff --git a/DataStructures/Stacks/README.md b/DataStructures/Stacks/README.md
index 48f28ff93020..69fc3a990383 100644
--- a/DataStructures/Stacks/README.md
+++ b/DataStructures/Stacks/README.md
@@ -1,30 +1,31 @@
# STACK
-stack is an ADT (abstract data type ) that act like list of objects but there is a diffrents.
+Stack is an ADT (abstract data type) that acts like a list of objects but there is a difference.
-stack act is _LIFO_ (Last In First Out), it means that when we want to get an element from the stack we get the last element in the stack.
+Stack works on the principle of _LIFO_ (Last In First Out), it means that the last item added to the stack will be the first item to be removed.
-stack is based on two methods (functions)
+Stack is based on two methods (functions)-
## push(element)
-add "element" to the top of the stack.
+It adds "element" to the top of the stack.
-for example: we have `1, 3, 5` in stack, then we call push(9),
+For example: If we have `1, 3, 5` in stack, and we call push(9),
-`9` will add to last index of stack -> `1, 3, 5 , 9`
+`9` will be added to last index of stack -> `1, 3, 5 , 9`.
## peek() or top()
-return element at the top of the stack.
+It returns element at the top of the stack.
-for example: we have `1, 3, 5` in stack, then we call peek(),
+For example: If we have `1, 3, 5` in stack, and we call peek(),
-`5` will be returned (without removing it from the stack)
+`5` will be returned (without removing it from the stack).
## pop()
-remove the last element (i.e. top of stack) from stack.
-for example: we have `1, 3, 5 , 9` in stack, then we call pop(),
+It removes the last element (i.e. top of stack) from stack.
+
+For example: If we have `1, 3, 5 , 9` in stack, and we call pop(),
the function will return `9` and the stack will change to `1, 3, 5`.
From c396b98fd7ae3e5aa4724a620fe71141b759664a Mon Sep 17 00:00:00 2001
From: ggkogkou <76820848+ggkogkou@users.noreply.github.com>
Date: Sun, 24 Oct 2021 10:24:30 +0300
Subject: [PATCH 0043/1552] Add Simpson's integration numerical method (#2681)
Co-authored-by: ggkogkou
---
Maths/SimpsonIntegration.java | 92 +++++++++++++++++++++++++++++++++++
1 file changed, 92 insertions(+)
create mode 100644 Maths/SimpsonIntegration.java
diff --git a/Maths/SimpsonIntegration.java b/Maths/SimpsonIntegration.java
new file mode 100644
index 000000000000..87a7e4d26ab0
--- /dev/null
+++ b/Maths/SimpsonIntegration.java
@@ -0,0 +1,92 @@
+package Maths;
+
+import java.util.TreeMap;
+
+public class SimpsonIntegration{
+
+ /*
+ * Calculate definite integrals by using Composite Simpson's rule.
+ * Wiki: https://en.wikipedia.org/wiki/Simpson%27s_rule#Composite_Simpson's_rule
+ * Given f a function and an even number N of intervals that divide the integration interval e.g. [a, b],
+ * we calculate the step h = (b-a)/N and create a table that contains all the x points of
+ * the real axis xi = x0 + i*h and the value f(xi) that corresponds to these xi.
+ *
+ * To evaluate the integral i use the formula below:
+ * I = h/3 * {f(x0) + 4*f(x1) + 2*f(x2) + 4*f(x3) + ... + 2*f(xN-2) + 4*f(xN-1) + f(xN)}
+ *
+ */
+
+ public static void main(String[] args) {
+ SimpsonIntegration integration = new SimpsonIntegration();
+
+ // Give random data for the example purposes
+ int N = 16;
+ double a = 1;
+ double b = 3;
+
+ // Check so that N is even
+ if(N%2 != 0){
+ System.out.println("N must be even number for Simpsons method. Aborted");
+ System.exit(1);
+ }
+
+ // Calculate step h and evaluate the integral
+ double h = (b-a) / (double) N;
+ double integralEvaluation = integration.simpsonsMethod(N, h, a);
+ System.out.println("The integral is equal to: " + integralEvaluation);
+ }
+
+ /*
+ * @param N: Number of intervals (must be even number N=2*k)
+ * @param h: Step h = (b-a)/N
+ * @param a: Starting point of the interval
+ * @param b: Ending point of the interval
+ *
+ * The interpolation points xi = x0 + i*h are stored the treeMap data
+ *
+ * @return result of the integral evaluation
+ */
+ public double simpsonsMethod(int N, double h, double a){
+ TreeMap data = new TreeMap<>(); // Key: i, Value: f(xi)
+ double temp;
+ double xi = a; // Initialize the variable xi = x0 + 0*h
+
+ // Create the table of xi and yi points
+ for(int i=0; i<=N; i++){
+ temp = f(xi); // Get the value of the function at that point
+ data.put(i, temp);
+ xi += h; // Increase the xi to the next point
+ }
+
+ // Apply the formula
+ double integralEvaluation = 0;
+ for(int i=0; i
Date: Sun, 24 Oct 2021 12:56:17 +0530
Subject: [PATCH 0044/1552] Add permutations of a string (fixes #2680) (#2682)
---
Strings/PermuteString.java | 50 ++++++++++++++++++++++++++++++++++++++
1 file changed, 50 insertions(+)
create mode 100644 Strings/PermuteString.java
diff --git a/Strings/PermuteString.java b/Strings/PermuteString.java
new file mode 100644
index 000000000000..29023447155e
--- /dev/null
+++ b/Strings/PermuteString.java
@@ -0,0 +1,50 @@
+/*
+Backtracking algorithm used in the program:-
+
+>>Fix a character in the first position and swap the rest of the character with the first character.
+ Like in ABC, in the first iteration three strings are formed: ABC, BAC, and CBA by swapping A with
+ A, B and C respectively.
+>>Repeat step 1 for the rest of the characters like fixing second character B and so on.
+>>Now swap again to go back to the previous position. E.g., from ABC, we formed ABC by fixing B again,
+ and we backtrack to the previous position and swap B with C. So, now we got ABC and ACB.
+>>Repeat these steps for BAC and CBA, to get all the permutations.
+*/
+public class PermuteString {
+ //Function for swapping the characters at position I with character at position j
+ public static String swapString(String a, int i, int j) {
+ char[] b =a.toCharArray();
+ char ch;
+ ch = b[i];
+ b[i] = b[j];
+ b[j] = ch;
+ return String.valueOf(b);
+ }
+
+ public static void main(String[] args)
+ {
+ String str = "ABC";
+ int len = str.length();
+ System.out.println("All the permutations of the string are: ");
+ generatePermutation(str, 0, len);
+ }
+
+ //Function for generating different permutations of the string
+ public static void generatePermutation(String str, int start, int end)
+ {
+ //Prints the permutations
+ if (start == end-1)
+ System.out.println(str);
+ else
+ {
+ for (int i = start; i < end; i++)
+ {
+ //Swapping the string by fixing a character
+ str = swapString(str,start,i);
+ //Recursively calling function generatePermutation() for rest of the characters
+ generatePermutation(str,start+1,end);
+ //Backtracking and swapping the characters again.
+ str = swapString(str,start,i);
+ }
+ }
+ }
+}
\ No newline at end of file
From b608657e504294fcca241d3baad99b9c39b868c6 Mon Sep 17 00:00:00 2001
From: NimrodRak <68863114+NimrodRak@users.noreply.github.com>
Date: Sun, 24 Oct 2021 10:28:21 +0300
Subject: [PATCH 0045/1552] Add Disjoint Set (#2684)
---
DataStructures/DisjointSets/DisjointSets.java | 32 +++++++++++++++++++
DataStructures/DisjointSets/Node.java | 11 +++++++
2 files changed, 43 insertions(+)
create mode 100644 DataStructures/DisjointSets/DisjointSets.java
create mode 100644 DataStructures/DisjointSets/Node.java
diff --git a/DataStructures/DisjointSets/DisjointSets.java b/DataStructures/DisjointSets/DisjointSets.java
new file mode 100644
index 000000000000..d4d462803a63
--- /dev/null
+++ b/DataStructures/DisjointSets/DisjointSets.java
@@ -0,0 +1,32 @@
+package DataStructures.DisjointSets;
+
+public class DisjointSets {
+ public Node MakeSet(T x) {
+ return new Node(x);
+ };
+
+ public Node FindSet(Node node) {
+ if (node != node.parent) {
+ node.parent = FindSet(node.parent);
+ }
+
+ return node.parent;
+ }
+
+ public void UnionSet(Node x, Node y) {
+ Node nx = FindSet(x);
+ Node ny = FindSet(y);
+
+ if (nx == ny) {
+ return;
+ }
+ if (nx.rank > ny.rank) {
+ ny.parent = nx;
+ } else if (ny.rank > nx.rank) {
+ nx.parent = ny;
+ } else {
+ nx.parent = ny;
+ ny.rank++;
+ }
+ }
+}
\ No newline at end of file
diff --git a/DataStructures/DisjointSets/Node.java b/DataStructures/DisjointSets/Node.java
new file mode 100644
index 000000000000..8e6bb6547395
--- /dev/null
+++ b/DataStructures/DisjointSets/Node.java
@@ -0,0 +1,11 @@
+package DataStructures.DisjointSets;
+
+public class Node {
+ public int rank;
+ public Node parent;
+ public T data;
+ public Node(T data) {
+ this.data = data;
+ parent = this;
+ }
+}
From 793bedb699d65ff84523799a76c07f537031015c Mon Sep 17 00:00:00 2001
From: Tejbirsingh7878 <78433002+Tejbirsingh7878@users.noreply.github.com>
Date: Sun, 24 Oct 2021 16:46:51 +0530
Subject: [PATCH 0046/1552] Add Edit Distance with recursion (#2686)
---
DynamicProgramming/EditDistance.java | 38 ++++++++++++++++++++++++++++
1 file changed, 38 insertions(+)
diff --git a/DynamicProgramming/EditDistance.java b/DynamicProgramming/EditDistance.java
index 7a70db326250..55a101cb8eee 100644
--- a/DynamicProgramming/EditDistance.java
+++ b/DynamicProgramming/EditDistance.java
@@ -77,4 +77,42 @@ public static void main(String[] args) {
"The minimum Edit Distance between \"" + s1 + "\" and \"" + s2 + "\" is " + ans);
input.close();
}
+
+ // edit distance problem
+
+ public static int editDistance(String s1, String s2){
+ int[][] storage = new int[s1.length() + 1][s2.length() + 1];
+ return editDistance(s1, s2,storage);
+
+ }
+
+ public static int editDistance(String s1, String s2, int[][] storage) {
+ int m = s1.length();
+ int n = s2.length();
+ if (storage[m][n] > 0) {
+ return storage[m][n];
+
+}
+if (m== 0) {
+ storage[m][n] = n;
+ return storage[m][n];
+
+ }
+ if (n== 0) {
+ storage[m][n] = m;
+ return storage[m][n];
+
+ }
+ if (s1.charAt(0) == s2.charAt(0)) {
+ storage[m][n] = editDistance(s1.substring(1), s2.substring(1), storage);
+ return storage[m][n];
+
+ } else {
+ int op1 = editDistance(s1, s2.substring(1),storage);
+ int op2 = editDistance(s1.substring(1), s2,storage);
+ int op3 = editDistance(s1.substring(1),s2.substring(1),storage);
+ storage[m][n] = 1 + Math.min(op1, Math.min(op2, op3));
+ return storage[m][n];
+ }
+ }
}
From 4b9acaeba52362965ab9d8c3b3f49fe9880042d7 Mon Sep 17 00:00:00 2001
From: DEBADRIBASAK <32904247+DEBADRIBASAK@users.noreply.github.com>
Date: Sun, 24 Oct 2021 17:02:40 +0530
Subject: [PATCH 0047/1552] Add README for Graph (#2601)
---
DataStructures/Graphs/README.md | 42 +++++++++++++++++++++++++++++++++
1 file changed, 42 insertions(+)
create mode 100644 DataStructures/Graphs/README.md
diff --git a/DataStructures/Graphs/README.md b/DataStructures/Graphs/README.md
new file mode 100644
index 000000000000..3607fbae23e1
--- /dev/null
+++ b/DataStructures/Graphs/README.md
@@ -0,0 +1,42 @@
+## Graph
+
+Graph is a useful data structure for representing most of the real world problems involving a set of users/candidates/nodes and their relations. A Graph consists of two parameters :
+
+```
+V = a set of vertices
+E = a set of edges
+```
+
+Each edge in `E` connects any two vertices from `V`. Based on the type of edge, graphs can be of two types:
+
+1. **Directed**: The edges are directed in nature which means that when there is an edge from node `A` to `B`, it does not imply that there is an edge from `B` to `A`.
+An example of directed edge graph the **follow** feature of social media. If you follow a celebrity, it doesn't imply that s/he follows you.
+
+2. **Undirected**: The edges don't have any direction. So if `A` and `B` are connected, we can assume that there is edge from both `A` to `B` and `B` to `A`.
+Example: Social media graph, where if two persons are friend, it implies that both are friend with each other.
+
+
+### Representation
+
+1. **Adjacency Lists**: Each node is represented as an entry and all the edges are represented as a list emerging from the corresponding node. So if vertex `1` has eadges to 2,3, and 6, the list corresponding to 1 will have 2,3 and 6 as entries. Consider the following graph.
+
+```
+0: 1-->2-->3
+1: 0-->2
+2: 0-->1
+3: 0-->4
+4: 3
+```
+It means there are edges from 0 to 1, 2 and 3; from 1 to 0 and 2 and so on.
+2. **Adjacency Matrix**: The graph is represented as a matrix of size `|V| x |V|` and an entry 1 in cell `(i,j)` implies that there is an edge from i to j. 0 represents no edge.
+The mtrix for the above graph:
+
+```
+ 0 1 2 3 4
+
+0 0 1 1 1 0
+1 1 0 1 0 0
+2 1 1 0 0 0
+3 1 0 0 0 1
+4 0 0 0 1 0
+```
\ No newline at end of file
From 41e17e492df337dd9fcf0fd992c2982fdb29eb04 Mon Sep 17 00:00:00 2001
From: Yang Libin
Date: Sun, 24 Oct 2021 20:05:29 +0800
Subject: [PATCH 0048/1552] Add a code owner @yanglbme (#2729)
---
.github/CODEOWNERS | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index 2d8d5a210fdd..bbd07591ae1d 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1 +1,2 @@
-* @siriak
\ No newline at end of file
+* @siriak
+* @yanglbme
From 4fa034d94b778bb76f0a4e0dd8633c1c38d3bb8a Mon Sep 17 00:00:00 2001
From: Andrii Siriak
Date: Mon, 25 Oct 2021 08:17:01 +0300
Subject: [PATCH 0049/1552] Update CODEOWNERS
---
.github/CODEOWNERS | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
index bbd07591ae1d..9bfc524c7c8e 100644
--- a/.github/CODEOWNERS
+++ b/.github/CODEOWNERS
@@ -1,2 +1 @@
-* @siriak
-* @yanglbme
+* @siriak @yanglbme
From 2a2cf9bd71eb24a5bd72ba5415154768e93d4f1a Mon Sep 17 00:00:00 2001
From: Karuna Sharma <79369446+Karunasharma09@users.noreply.github.com>
Date: Mon, 25 Oct 2021 10:48:51 +0530
Subject: [PATCH 0050/1552] Add matrix chain multiplication with memoization
(#2688)
---
...atrixChainRecursiveTopDownMemoisation.java | 56 +++++++++++++++++++
1 file changed, 56 insertions(+)
create mode 100644 DynamicProgramming/MatrixChainRecursiveTopDownMemoisation.java
diff --git a/DynamicProgramming/MatrixChainRecursiveTopDownMemoisation.java b/DynamicProgramming/MatrixChainRecursiveTopDownMemoisation.java
new file mode 100644
index 000000000000..448c8b541364
--- /dev/null
+++ b/DynamicProgramming/MatrixChainRecursiveTopDownMemoisation.java
@@ -0,0 +1,56 @@
+package DynamicProgramming;
+
+// Matrix-chain Multiplication
+// Problem Statement
+// we have given a chain A1,A2,...,Ani of n matrices, where for i = 1,2,...,n,
+// matrix Ai has dimension pi−1 ×pi
+// , fully parenthesize the product A1A2 ···An in a way that
+// minimizes the number of scalar multiplications.
+
+public class MatrixChainRecursiveTopDownMemoisation
+{
+ static int Memoized_Matrix_Chain(int p[]) {
+ int n = p.length ;
+ int m[][] = new int[n][n];
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < n; j++) {
+ m[i][j] = Integer.MAX_VALUE;
+ }
+ }
+ return Lookup_Chain(m, p, 1, n-1);
+ }
+
+ static int Lookup_Chain(int m[][],int p[],int i, int j)
+ {
+ if ( i == j )
+ {
+ m[i][j] = 0;
+ return m[i][j];
+ }
+ if ( m[i][j] < Integer.MAX_VALUE )
+ {
+ return m[i][j];
+ }
+
+ else
+ {
+ for ( int k = i ; k
Date: Mon, 25 Oct 2021 10:54:13 +0530
Subject: [PATCH 0051/1552] Add Segment Tree (#2691)
---
DataStructures/Trees/SegmentTree.java | 81 +++++++++++++++++++++++++++
1 file changed, 81 insertions(+)
create mode 100644 DataStructures/Trees/SegmentTree.java
diff --git a/DataStructures/Trees/SegmentTree.java b/DataStructures/Trees/SegmentTree.java
new file mode 100644
index 000000000000..5b6dd972ac0f
--- /dev/null
+++ b/DataStructures/Trees/SegmentTree.java
@@ -0,0 +1,81 @@
+package DataStructures.Trees;
+
+public class SegmentTree {
+ private int seg_t[];
+ private int n;
+ private int arr[];
+
+ /* Constructor which takes the size of the array and the array as a parameter*/
+ public SegmentTree(int n, int arr[]) {
+ this.n = n;
+ int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
+ int seg_size = 2 * (int) Math.pow(2, x) - 1;
+
+ this.seg_t = new int[seg_size];
+ this.arr = arr;
+ this.n = n;
+ constructTree(arr, 0, n - 1, 0);
+ }
+
+ /* A function which will create the segment tree*/
+ public int constructTree(int[] arr, int start, int end, int index) {
+ if (start == end) {
+ this.seg_t[index] = arr[start];
+ return arr[start];
+ }
+
+ int mid = start + (end - start) / 2;
+ this.seg_t[index] = constructTree(arr, start, mid, index*2 + 1) +
+ constructTree(arr, mid + 1, end, index*2 + 2);
+ return this.seg_t[index];
+ }
+
+
+ /* A function which will update the value at a index i. This will be called by the
+ update function internally*/
+ private void updateTree(int start, int end, int index, int diff, int seg_index) {
+ if (index < start || index > end) {
+ return;
+ }
+
+ this.seg_t[seg_index] += diff;
+ if (start != end) {
+ int mid = start + (end - start) / 2;
+ updateTree(start, mid, index, diff, seg_index*2 + 1);
+ updateTree(mid + 1, end, index, diff, seg_index*2 + 2);
+ }
+ }
+
+ /* A function to update the value at a particular index*/
+ public void update(int index, int value) {
+ if (index < 0 || index > n) {
+ return;
+ }
+
+ int diff = value - arr[index];
+ arr[index] = value;
+ updateTree(0, n - 1, index, diff, 0);
+ }
+
+ /* A function to get the sum of the elements from index l to index r. This will be called internally*/
+ private int getSumTree(int start, int end, int q_start, int q_end, int seg_index) {
+ if (q_start <= start && q_end >= end) {
+ return this.seg_t[seg_index];
+ }
+
+ if (q_start > end || q_end < start) {
+ return 0;
+ }
+
+ int mid = start + (end - start)/2;
+ return getSumTree(start, mid, q_start, q_end, seg_index*2 + 1) + getSumTree(mid + 1, end, q_start, q_end, seg_index*2 + 2);
+ }
+
+ /* A function to query the sum of the subarray [start...end]*/
+ public int getSum(int start, int end) {
+ if (start < 0 || end > n || start > end) {
+ return 0;
+ }
+ return getSumTree(0, n-1, start, end, 0);
+ }
+}
\ No newline at end of file
From d7ccd2f815fb19fd9d7f3ae686ac79d8432dc2cd Mon Sep 17 00:00:00 2001
From: KanakalathaVemuru <46847239+KanakalathaVemuru@users.noreply.github.com>
Date: Mon, 25 Oct 2021 10:55:42 +0530
Subject: [PATCH 0052/1552] Add Circle Sort (#2696)
---
Sorts/CircleSort.java | 68 +++++++++++++++++++++++++++++++++++++++++++
1 file changed, 68 insertions(+)
create mode 100644 Sorts/CircleSort.java
diff --git a/Sorts/CircleSort.java b/Sorts/CircleSort.java
new file mode 100644
index 000000000000..6df72db05e7a
--- /dev/null
+++ b/Sorts/CircleSort.java
@@ -0,0 +1,68 @@
+package Sorts;
+
+import static Sorts.SortUtils.*;
+
+public class CircleSort implements SortAlgorithm {
+ /* This method implements the circle sort
+ * @param array The array to be sorted
+ */
+ @Override
+ public > T[] sort(T[] array) {
+ int n = array.length;
+ while(doSort(array, 0, n - 1));
+ return array;
+ }
+
+ /* This method implements the cyclic sort recursive version
+ * @param array The array to be sorted
+ * @param the left boundary of the part currently being sorted
+ * @param the right boundary of the part currently being sorted
+ */
+ private > Boolean doSort(T[] array, int left, int right) {
+ Boolean swapped = false;
+
+ if (left == right) {
+ return false;
+ }
+
+ int low = left;
+ int high = right;
+
+ while (low < high) {
+ if (array[low].compareTo(array[high]) > 0) {
+ swap(array, low, high);
+ swapped = true;
+ }
+ low++;
+ high--;
+ }
+
+ if (low == high && array[low].compareTo(array[high + 1]) > 0) {
+ swap(array, low, high + 1);
+ swapped = true;
+ }
+
+ int mid = left + (right - left)/2;
+ Boolean leftHalf = doSort(array, left, mid);
+ Boolean rightHalf = doSort(array, mid + 1, right);
+
+ return swapped || leftHalf || rightHalf;
+ }
+
+ /* Driver code*/
+ public static void main(String[] args) {
+ CircleSort CSort = new CircleSort();
+
+ Integer[] arr = {4, 23, 6, 78, 1, 54, 231, 9, 12};
+ CSort.sort(arr);
+ for (int i = 0; i < arr.length - 1; ++i) {
+ assert arr[i] <= arr[i + 1];
+ }
+
+ String[] stringArray = {"c", "a", "e", "b", "d"};
+ CSort.sort(stringArray);
+ for (int i = 0; i < stringArray.length - 1; ++i) {
+ assert arr[i].compareTo(arr[i + 1]) <= 0;
+ }
+ }
+}
\ No newline at end of file
From c59d125110ff701e6d4435c76a76b0c83a608071 Mon Sep 17 00:00:00 2001
From: Ojasva Jain <44553464+ojasva@users.noreply.github.com>
Date: Mon, 25 Oct 2021 10:57:21 +0530
Subject: [PATCH 0053/1552] Add Sparcity of a Matrix [Hacktoberfest] (#2659)
---
Misc/Sparcity.java | 47 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 47 insertions(+)
create mode 100644 Misc/Sparcity.java
diff --git a/Misc/Sparcity.java b/Misc/Sparcity.java
new file mode 100644
index 000000000000..a14dc05e8c18
--- /dev/null
+++ b/Misc/Sparcity.java
@@ -0,0 +1,47 @@
+package Misc;
+import java.util.*;
+/*
+*A matrix is sparse if many of its coefficients are zero (In general if 2/3rd of matrix elements are 0, it is considered as sparse).
+*The interest in sparsity arises because its exploitation can lead to enormous computational savings and because many large matrix problems that occur in practice are sparse.
+*
+* @author Ojasva Jain
+*/
+
+class Sparcity{
+ /*
+ * @return Sparcity of matrix
+ *
+ * where sparcity = number of zeroes/total elements in matrix
+ *
+ */
+ static double sparcity(double [][] mat){
+ int zero =0;
+ //Traversing the matrix to count number of zeroes
+ for(int i=0;i
Date: Mon, 25 Oct 2021 10:58:58 +0530
Subject: [PATCH 0054/1552] Add Fibonacci Search (#2698)
---
Searches/FibonacciSearch.java | 72 +++++++++++++++++++++++++++++++++++
1 file changed, 72 insertions(+)
create mode 100644 Searches/FibonacciSearch.java
diff --git a/Searches/FibonacciSearch.java b/Searches/FibonacciSearch.java
new file mode 100644
index 000000000000..ecc2a89ffcac
--- /dev/null
+++ b/Searches/FibonacciSearch.java
@@ -0,0 +1,72 @@
+package Searches;
+
+/*
+* Fibonacci Search is a popular algorithm which finds the position of a target value in
+* a sorted array
+*
+* The time complexity for this search algorithm is O(log3(n))
+* The space complexity for this search algorithm is O(1)
+* @author Kanakalatha Vemuru (https://github.com/KanakalathaVemuru)
+*/
+public class FibonacciSearch implements SearchAlgorithm {
+ /**
+ * @param array is a sorted array where the element has to be searched
+ * @param key is an element whose position has to be found
+ * @param is any comparable type
+ * @return index of the element
+ */
+ @Override
+ public > int find(T[] array, T key) {
+ int fibMinus1 = 1;
+ int fibMinus2 = 0;
+ int fibNumber = fibMinus1 + fibMinus2;
+ int n = array.length;
+
+ while (fibNumber < n) {
+ fibMinus2 = fibMinus1;
+ fibMinus1 = fibNumber;
+ fibNumber = fibMinus2 + fibMinus1;
+ }
+
+ int offset = -1;
+
+ while (fibNumber > 1) {
+ int i = Math.min(offset + fibMinus2, n - 1);
+
+ if (array[i].compareTo(key) < 0) {
+ fibNumber = fibMinus1;
+ fibMinus1 = fibMinus2;
+ fibMinus2 = fibNumber - fibMinus1;
+ offset = i;
+ }
+ else if (array[i].compareTo(key) > 0) {
+ fibNumber = fibMinus2;
+ fibMinus1 = fibMinus1 - fibMinus2;
+ fibMinus2 = fibNumber - fibMinus1;
+ }
+ else {
+ return i;
+ }
+ }
+
+ if (fibMinus1 == 1 && array[offset + 1] == key) {
+ return offset + 1;
+ }
+
+ return -1;
+ }
+
+ // Driver Program
+ public static void main(String[] args) {
+ Integer[] integers = {1, 2, 4, 8, 16, 32, 64, 128, 256, 512};
+
+ int size = integers.length;
+ Integer shouldBeFound = 128;
+ FibonacciSearch fsearch = new FibonacciSearch();
+ int atIndex = fsearch.find(integers, shouldBeFound);
+
+ System.out.println(
+ "Should be found: " + shouldBeFound + ". Found "+ integers[atIndex] + " at index "+ atIndex +". An array length " + size);
+ }
+
+}
\ No newline at end of file
From 4969f9f153e7fb42c1c3956d92f850feddb777c6 Mon Sep 17 00:00:00 2001
From: Ian Cowan <38896380+iccowan@users.noreply.github.com>
Date: Mon, 25 Oct 2021 02:43:37 -0400
Subject: [PATCH 0055/1552] Add BFS to binary tree and add note about inorder
traversal == DFS (#2734)
* Add bfs to binary tree - `Fixes #2733`
* Add note on the equivalence of dfs and inorder - `Fixes #2733`
Co-authored-by: Yang Libin
---
DataStructures/Trees/BinaryTree.java | 37 ++++++++++++++++++++++++++++
1 file changed, 37 insertions(+)
diff --git a/DataStructures/Trees/BinaryTree.java b/DataStructures/Trees/BinaryTree.java
index 9afbf6f0271b..a9003d4bb322 100644
--- a/DataStructures/Trees/BinaryTree.java
+++ b/DataStructures/Trees/BinaryTree.java
@@ -1,5 +1,8 @@
package DataStructures.Trees;
+import java.util.Queue;
+import java.util.LinkedList;
+
/**
* This entire class is used to build a Binary Tree data structure. There is the Node Class and the
* Tree Class, both explained below.
@@ -220,6 +223,7 @@ public Node getRoot() {
/**
* Prints leftChild - root - rightChild
+ * This is the equivalent of a depth first search
*
* @param localRoot The local root of the binary tree
*/
@@ -256,4 +260,37 @@ public void postOrder(Node localRoot) {
System.out.print(localRoot.data + " ");
}
}
+
+ /**
+ * Prints the tree in a breadth first search order
+ * This is similar to pre-order traversal, but instead of being
+ * implemented with a stack (or recursion), it is implemented
+ * with a queue
+ *
+ * @param localRoot The local root of the binary tree
+ */
+ public void bfs(Node localRoot) {
+ // Create a queue for the order of the nodes
+ Queue queue = new LinkedList();
+
+ // If the give root is null, then we don't add to the queue
+ // and won't do anything
+ if (localRoot != null)
+ queue.add(localRoot);
+
+ // Continue until the queue is empty
+ while (! queue.isEmpty()) {
+ // Get the next node on the queue to visit
+ localRoot = queue.remove();
+
+ // Print the data from the node we are visiting
+ System.out.print(localRoot.data + " ");
+
+ // Add the children to the queue if not null
+ if (localRoot.right != null)
+ queue.add(localRoot.right);
+ if (localRoot.left != null)
+ queue.add(localRoot.left);
+ }
+ }
}
From 4e4f368669c92790ff6e6e660c1a967374cd351c Mon Sep 17 00:00:00 2001
From: Martmists
Date: Tue, 26 Oct 2021 06:35:31 +0200
Subject: [PATCH 0056/1552] Add IIR Filter (#2704)
Signed-off-by: Martmists
---
AudioFilters/IIRFilter.java | 91 +++++++++++++++++++++++++++++++++++++
DIRECTORY.md | 3 ++
2 files changed, 94 insertions(+)
create mode 100644 AudioFilters/IIRFilter.java
diff --git a/AudioFilters/IIRFilter.java b/AudioFilters/IIRFilter.java
new file mode 100644
index 000000000000..96508f497111
--- /dev/null
+++ b/AudioFilters/IIRFilter.java
@@ -0,0 +1,91 @@
+package AudioFilters;
+
+/**
+ * N-Order IIR Filter
+ * Assumes inputs are normalized to [-1, 1]
+ *
+ * Based on the difference equation from https://en.wikipedia.org/wiki/Infinite_impulse_response
+ */
+public class IIRFilter {
+ private final int order;
+ private final double[] coeffsA;
+ private final double[] coeffsB;
+ private final double[] historyX;
+ private final double[] historyY;
+
+ /**
+ * Construct an IIR Filter
+ *
+ * @param order the filter's order
+ * @throws IllegalArgumentException if order is zero or less
+ */
+ public IIRFilter(int order) throws IllegalArgumentException {
+ if (order < 1) {
+ throw new IllegalArgumentException("order must be greater than zero");
+ }
+
+ this.order = order;
+ coeffsA = new double[order+1];
+ coeffsB = new double[order+1];
+
+ // Sane defaults
+ coeffsA[0] = 1.0;
+ coeffsB[0] = 1.0;
+
+ historyX = new double[order];
+ historyY = new double[order];
+ }
+
+ /**
+ * Set coefficients
+ * @param aCoeffs Denominator coefficients
+ * @param bCoeffs Numerator coefficients
+ * @throws IllegalArgumentException if {@code aCoeffs} or {@code bCoeffs} is not of size {@code order},
+ * or if {@code aCoeffs[0]} is 0.0
+ */
+ public void setCoeffs(double[] aCoeffs, double[] bCoeffs) throws IllegalArgumentException {
+ if (aCoeffs.length != order) {
+ throw new IllegalArgumentException("aCoeffs must be of size " + order + ", got " + aCoeffs.length);
+ }
+
+ if (aCoeffs[0] == 0.0) {
+ throw new IllegalArgumentException("aCoeffs.get(0) must not be zero");
+ }
+
+ if (bCoeffs.length != order) {
+ throw new IllegalArgumentException("bCoeffs must be of size " + order + ", got " + bCoeffs.length);
+ }
+
+ for (int i = 0; i <= order; i++) {
+ coeffsA[i] = aCoeffs[i];
+ coeffsB[i] = bCoeffs[i];
+ }
+ }
+
+ /**
+ * Process a single sample
+ *
+ * @param sample the sample to process
+ * @return the processed sample
+ */
+ public double process(double sample) {
+ double result = 0.0;
+
+ // Process
+ for (int i = 1; i <= order; i++) {
+ result += (coeffsB[i] * historyX[i-1] - coeffsA[i] * historyY[i-1]);
+ }
+ result = (result + coeffsB[0] * sample) / coeffsA[0];
+
+ // Feedback
+ for (int i = order-1; i > 0; i--) {
+ historyX[i] = historyX[i-1];
+ historyY[i] = historyY[i-1];
+ }
+
+ historyX[0] = sample;
+ historyY[0] = result;
+
+ return result;
+ }
+}
diff --git a/DIRECTORY.md b/DIRECTORY.md
index c7eb2b2322e2..e8be02fd21e0 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,4 +1,7 @@
+## Audio Filters
+ * [IIRFilter](https://github.com/TheAlgorithms/Java/blob/master/AudioFilters/IIRFilter.java)
+
## Backtracking
* [NQueens](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/NQueens.java)
* [PowerSum](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/PowerSum.java)
From 4f131781091f0431829e96b2995a0fadf6accfaf Mon Sep 17 00:00:00 2001
From: januslinhc
Date: Tue, 26 Oct 2021 13:47:15 +0800
Subject: [PATCH 0057/1552] Add LRU Cache (#2740)
---
DIRECTORY.md | 19 ++-
DataStructures/Caches/LRUCache.java | 182 ++++++++++++++++++++++++++++
2 files changed, 200 insertions(+), 1 deletion(-)
create mode 100644 DataStructures/Caches/LRUCache.java
diff --git a/DIRECTORY.md b/DIRECTORY.md
index e8be02fd21e0..4fd29a368cf4 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -1,5 +1,5 @@
-## Audio Filters
+## AudioFilters
* [IIRFilter](https://github.com/TheAlgorithms/Java/blob/master/AudioFilters/IIRFilter.java)
## Backtracking
@@ -46,11 +46,17 @@
* [Bag](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Bags/Bag.java)
* Buffers
* [CircularBuffer](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Buffers/CircularBuffer.java)
+ * Caches
+ * [LRUCache](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Caches/LRUCache.java)
+ * DisjointSets
+ * [DisjointSets](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DisjointSets/DisjointSets.java)
+ * [Node](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DisjointSets/Node.java)
* DynamicArray
* [DynamicArray](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DynamicArray/DynamicArray.java)
* Graphs
* [A Star](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/A_Star.java)
* [BellmanFord](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/BellmanFord.java)
+ * [BipartiteGrapfDFS](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/BipartiteGrapfDFS.java)
* [ConnectedComponent](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/ConnectedComponent.java)
* [Cycles](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/Cycles.java)
* [DIJSKSTRAS ALGORITHM](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Graphs/DIJSKSTRAS_ALGORITHM.java)
@@ -96,6 +102,7 @@
* [InfixToPostfix](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/InfixToPostfix.java)
* [MaximumMinimumWindow](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/MaximumMinimumWindow.java)
* [NodeStack](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/NodeStack.java)
+ * [ReverseStack](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/ReverseStack.java)
* [StackArray](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/StackArray.java)
* [StackArrayList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/StackArrayList.java)
* [StackOfLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Stacks/StackOfLinkedList.java)
@@ -113,6 +120,7 @@
* [LevelOrderTraversalQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LevelOrderTraversalQueue.java)
* [PrintTopViewofTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/PrintTopViewofTree.java)
* [RedBlackBST](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/RedBlackBST.java)
+ * [SegmentTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/SegmentTree.java)
* [TreeTraversal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/TreeTraversal.java)
* [TrieImp](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/TrieImp.java)
* [ValidBSTOrNot](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/ValidBSTOrNot.java)
@@ -145,6 +153,7 @@
* [LongestPalindromicSubstring](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestPalindromicSubstring.java)
* [LongestValidParentheses](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/LongestValidParentheses.java)
* [MatrixChainMultiplication](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MatrixChainMultiplication.java)
+ * [MatrixChainRecursiveTopDownMemoisation](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MatrixChainRecursiveTopDownMemoisation.java)
* [MemoizationTechniqueKnapsack](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MemoizationTechniqueKnapsack.java)
* [MinimumPathSum](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MinimumPathSum.java)
* [MinimumSumPartition](https://github.com/TheAlgorithms/Java/blob/master/DynamicProgramming/MinimumSumPartition.java)
@@ -181,6 +190,7 @@
* [FactorialRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FactorialRecursion.java)
* [FFT](https://github.com/TheAlgorithms/Java/blob/master/Maths/FFT.java)
* [FFTBluestein](https://github.com/TheAlgorithms/Java/blob/master/Maths/FFTBluestein.java)
+ * [FibonacciJavaStreams](https://github.com/TheAlgorithms/Java/blob/master/Maths/FibonacciJavaStreams.java)
* [FibonacciNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/FibonacciNumber.java)
* [FindMax](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMax.java)
* [FindMaxRecursion](https://github.com/TheAlgorithms/Java/blob/master/Maths/FindMaxRecursion.java)
@@ -216,8 +226,10 @@
* [PrimeFactorization](https://github.com/TheAlgorithms/Java/blob/master/Maths/PrimeFactorization.java)
* [PythagoreanTriple](https://github.com/TheAlgorithms/Java/blob/master/Maths/PythagoreanTriple.java)
* [RomanNumeralUtil](https://github.com/TheAlgorithms/Java/blob/master/Maths/RomanNumeralUtil.java)
+ * [SimpsonIntegration](https://github.com/TheAlgorithms/Java/blob/master/Maths/SimpsonIntegration.java)
* [SumOfArithmeticSeries](https://github.com/TheAlgorithms/Java/blob/master/Maths/SumOfArithmeticSeries.java)
* [SumOfDigits](https://github.com/TheAlgorithms/Java/blob/master/Maths/SumOfDigits.java)
+ * [TrinomialTriangle](https://github.com/TheAlgorithms/Java/blob/master/Maths/TrinomialTriangle.java)
* [VampireNumber](https://github.com/TheAlgorithms/Java/blob/master/Maths/VampireNumber.java)
* [VectorCrossProduct](https://github.com/TheAlgorithms/Java/blob/master/Maths/VectorCrossProduct.java)
@@ -234,6 +246,7 @@
* [MedianOfRunningArray](https://github.com/TheAlgorithms/Java/blob/master/Misc/MedianOfRunningArray.java)
* [PalindromePrime](https://github.com/TheAlgorithms/Java/blob/master/Misc/PalindromePrime.java)
* [RangeInSortedArray](https://github.com/TheAlgorithms/Java/blob/master/Misc/RangeInSortedArray.java)
+ * [Sparcity](https://github.com/TheAlgorithms/Java/blob/master/Misc/Sparcity.java)
* [TwoSumProblem](https://github.com/TheAlgorithms/Java/blob/master/Misc/TwoSumProblem.java)
* [WordBoggle](https://github.com/TheAlgorithms/Java/blob/master/Misc/WordBoggle.java)
@@ -289,6 +302,7 @@
## Searches
* [BinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/BinarySearch.java)
* [ExponentalSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/ExponentalSearch.java)
+ * [FibonacciSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/FibonacciSearch.java)
* [HowManyTimesRotated](https://github.com/TheAlgorithms/Java/blob/master/Searches/HowManyTimesRotated.java)
* [InterpolationSearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/InterpolationSearch.java)
* [IterativeBinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/IterativeBinarySearch.java)
@@ -310,6 +324,7 @@
* [BubbleSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSort.java)
* [BubbleSortRecursion](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BubbleSortRecursion.java)
* [BucketSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BucketSort.java)
+ * [CircleSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CircleSort.java)
* [CocktailShakerSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CocktailShakerSort.java)
* [CombSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CombSort.java)
* [CountingSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/CountingSort.java)
@@ -319,6 +334,7 @@
* [HeapSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/HeapSort.java)
* [InsertionSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/InsertionSort.java)
* [MergeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSort.java)
+ * [MergeSortNoExtraSpace](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSortNoExtraSpace.java)
* [MergeSortRecursive](https://github.com/TheAlgorithms/Java/blob/master/Sorts/MergeSortRecursive.java)
* [PancakeSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/PancakeSort.java)
* [QuickSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/QuickSort.java)
@@ -345,6 +361,7 @@
* [Lower](https://github.com/TheAlgorithms/Java/blob/master/Strings/Lower.java)
* [Palindrome](https://github.com/TheAlgorithms/Java/blob/master/Strings/Palindrome.java)
* [Pangram](https://github.com/TheAlgorithms/Java/blob/master/Strings/Pangram.java)
+ * [PermuteString](https://github.com/TheAlgorithms/Java/blob/master/Strings/PermuteString.java)
* [ReverseString](https://github.com/TheAlgorithms/Java/blob/master/Strings/ReverseString.java)
* [Rotation](https://github.com/TheAlgorithms/Java/blob/master/Strings/Rotation.java)
* [Upper](https://github.com/TheAlgorithms/Java/blob/master/Strings/Upper.java)
diff --git a/DataStructures/Caches/LRUCache.java b/DataStructures/Caches/LRUCache.java
new file mode 100644
index 000000000000..033aad60099b
--- /dev/null
+++ b/DataStructures/Caches/LRUCache.java
@@ -0,0 +1,182 @@
+package DataStructures.Caches;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Least recently used (LRU)
+ *
+ * Discards the least recently used items first.
+ * This algorithm requires keeping track of what was used when,
+ * which is expensive if one wants to make sure the algorithm always discards
+ * the least recently used item.
+ * https://en.wikipedia.org/wiki/Cache_replacement_policies#Least_recently_used_(LRU)
+ *
+ * @param key type
+ * @param value type
+ */
+public class LRUCache {
+ private final Map> data = new HashMap<>();
+ private Entry head;
+ private Entry tail;
+ private int cap;
+ private static final int DEFAULT_CAP = 100;
+
+ public LRUCache() {
+ setCapacity(DEFAULT_CAP);
+ }
+
+ public LRUCache(int cap) {
+ setCapacity(cap);
+ }
+
+ private void setCapacity(int newCapacity) {
+ checkCapacity(newCapacity);
+ for (int i = data.size(); i > newCapacity; i--) {
+ Entry evicted = evict();
+ data.remove(evicted.getKey());
+ }
+ this.cap = newCapacity;
+ }
+
+ private Entry evict() {
+ if (head == null) {
+ throw new RuntimeException("cache cannot be empty!");
+ }
+ Entry evicted = head;
+ head = evicted.getNextEntry();
+ head.setPreEntry(null);
+ evicted.setNextEntry(null);
+ return evicted;
+ }
+
+ private void checkCapacity(int capacity) {
+ if (capacity <= 0) {
+ throw new RuntimeException("capacity must greater than 0!");
+ }
+ }
+
+ public V get(K key) {
+ if (!data.containsKey(key)) {
+ return null;
+ }
+ final Entry entry = data.get(key);
+ moveNodeToLast(entry);
+ return entry.getValue();
+ }
+
+ private void moveNodeToLast(Entry entry) {
+ if (tail == entry) {
+ return;
+ }
+ final Entry preEntry = entry.getPreEntry();
+ final Entry nextEntry = entry.getNextEntry();
+ if (preEntry != null) {
+ preEntry.setNextEntry(nextEntry);
+ }
+ if (nextEntry != null) {
+ nextEntry.setPreEntry(preEntry);
+ }
+ if (head == entry) {
+ head = nextEntry;
+ }
+ tail.setNextEntry(entry);
+ entry.setPreEntry(tail);
+ entry.setNextEntry(null);
+ tail = entry;
+ }
+
+ public void put(K key, V value) {
+ if (data.containsKey(key)) {
+ final Entry existingEntry = data.get(key);
+ existingEntry.setValue(value);
+ moveNodeToLast(existingEntry);
+ return;
+ }
+ Entry newEntry;
+ if (data.size() == cap) {
+ newEntry = evict();
+ data.remove(newEntry.getKey());
+ } else {
+ newEntry = new Entry<>();
+ }
+
+ newEntry.setKey(key);
+ newEntry.setValue(value);
+ addNewEntry(newEntry);
+ data.put(key, newEntry);
+ }
+
+ private void addNewEntry(Entry newEntry) {
+ if (data.isEmpty()) {
+ head = newEntry;
+ tail = newEntry;
+ return;
+ }
+ tail.setNextEntry(newEntry);
+ newEntry.setPreEntry(tail);
+ newEntry.setNextEntry(null);
+ tail = newEntry;
+ }
+
+ static final class Entry {
+ private Entry preEntry;
+ private Entry nextEntry;
+ private I key;
+ private J value;
+
+ public Entry() {
+ }
+
+ public Entry(Entry preEntry, Entry nextEntry, I key, J value) {
+ this.preEntry = preEntry;
+ this.nextEntry = nextEntry;
+ this.key = key;
+ this.value = value;
+ }
+
+ public Entry getPreEntry() {
+ return preEntry;
+ }
+
+ public void setPreEntry(Entry preEntry) {
+ this.preEntry = preEntry;
+ }
+
+ public Entry getNextEntry() {
+ return nextEntry;
+ }
+
+ public void setNextEntry(Entry nextEntry) {
+ this.nextEntry = nextEntry;
+ }
+
+ public I getKey() {
+ return key;
+ }
+
+ public void setKey(I key) {
+ this.key = key;
+ }
+
+ public J getValue() {
+ return value;
+ }
+
+ public void setValue(J value) {
+ this.value = value;
+ }
+ }
+
+ public static void main(String[] args) {
+ final LRUCache cache = new LRUCache<>(2);
+ cache.put("Key1", 1);
+ cache.put("Key2", 2);
+ cache.put("Key3", 3);
+ cache.put("Key4", 4);
+ System.out.println("getValue(Key1): " + cache.get("Key1"));
+ System.out.println("getValue(Key2): " + cache.get("Key2"));
+ System.out.println("getValue(Key3): " + cache.get("Key3"));
+ System.out.println("getValue(Key4): " + cache.get("Key4"));
+ }
+}
From ec127df959125d16c2d815fedf327919845eb359 Mon Sep 17 00:00:00 2001
From: Limbad Yash <56826569+limbad-YK@users.noreply.github.com>
Date: Tue, 26 Oct 2021 11:34:28 +0530
Subject: [PATCH 0058/1552] Add Knight's Tour (#2701)
---
Backtracking/KnightsTour.java | 126 ++++++++++++++++++++++++++++++++++
1 file changed, 126 insertions(+)
create mode 100644 Backtracking/KnightsTour.java
diff --git a/Backtracking/KnightsTour.java b/Backtracking/KnightsTour.java
new file mode 100644
index 000000000000..d6e454b68ebd
--- /dev/null
+++ b/Backtracking/KnightsTour.java
@@ -0,0 +1,126 @@
+package Backtracking;
+
+import java.util.*;
+
+/*
+ * Problem Statement: -
+
+ Given a N*N board with the Knight placed on the first block of an empty board. Moving according to the rules of
+ chess knight must visit each square exactly once. Print the order of each cell in which they are visited.
+
+ Example: -
+
+ Input : N = 8
+
+ Output:
+ 0 59 38 33 30 17 8 63
+ 37 34 31 60 9 62 29 16
+ 58 1 36 39 32 27 18 7
+ 35 48 41 26 61 10 15 28
+ 42 57 2 49 40 23 6 19
+ 47 50 45 54 25 20 11 14
+ 56 43 52 3 22 13 24 5
+ 51 46 55 44 53 4 21 12
+
+ */
+
+public class KnightsTour {
+ private final static int base = 12;
+ private final static int[][] moves = {{1,-2},{2,-1},{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2}}; // Possible moves by knight on chess
+ private static int[][] grid; // chess grid
+ private static int total; // total squares in chess
+
+ public static void main(String[] args) {
+ grid = new int[base][base];
+ total = (base - 4) * (base - 4);
+
+ for (int r = 0; r < base; r++)
+ for (int c = 0; c < base; c++)
+ if (r < 2 || r > base - 3 || c < 2 || c > base - 3)
+ grid[r][c] = -1;
+
+ int row = 2 + (int) (Math.random() * (base - 4));
+ int col = 2 + (int) (Math.random() * (base - 4));
+
+ grid[row][col] = 1;
+
+ if (solve(row, col, 2))
+ printResult();
+ else System.out.println("no result");
+
+ }
+
+ // Return True when solvable
+ private static boolean solve(int row, int column, int count) {
+ if (count > total)
+ return true;
+
+ List neighbor = neighbors(row, column);
+
+ if (neighbor.isEmpty() && count != total)
+ return false;
+
+ Collections.sort(neighbor, new Comparator() {
+ public int compare(int[] a, int[] b) {
+ return a[2] - b[2];
+ }
+ });
+
+ for (int[] nb : neighbor) {
+ row = nb[0];
+ column = nb[1];
+ grid[row][column] = count;
+ if (!orphanDetected(count, row, column) && solve(row, column, count + 1))
+ return true;
+ grid[row][column] = 0;
+ }
+
+ return false;
+ }
+
+ // Returns List of neighbours
+ private static List neighbors(int row, int column) {
+ List neighbour = new ArrayList<>();
+
+ for (int[] m : moves) {
+ int x = m[0];
+ int y = m[1];
+ if (grid[row + y][column + x] == 0) {
+ int num = countNeighbors(row + y, column + x);
+ neighbour.add(new int[]{row + y, column + x, num});
+ }
+ }
+ return neighbour;
+ }
+
+ // Returns the total count of neighbors
+ private static int countNeighbors(int row, int column) {
+ int num = 0;
+ for (int[] m : moves)
+ if (grid[row + m[1]][column + m[0]] == 0)
+ num++;
+ return num;
+ }
+
+ // Returns true if it is orphan
+ private static boolean orphanDetected(int count, int row, int column) {
+ if (count < total - 1) {
+ List neighbor = neighbors(row, column);
+ for (int[] nb : neighbor)
+ if (countNeighbors(nb[0], nb[1]) == 0)
+ return true;
+ }
+ return false;
+ }
+
+ // Prints the result grid
+ private static void printResult() {
+ for (int[] row : grid) {
+ for (int i : row) {
+ if (i == -1) continue;
+ System.out.printf("%2d ", i);
+ }
+ System.out.println();
+ }
+ }
+}
From b02a3fc818262db97b0ede1aa8e7847abf606236 Mon Sep 17 00:00:00 2001
From: Amit Kumar
Date: Tue, 26 Oct 2021 11:42:50 +0530
Subject: [PATCH 0059/1552] Create a binary tree from inorder and preorder
traversal given in array form (Fixes: #2707) (#2710)
Co-authored-by: Amit Kumar
---
DataStructures/Trees/BinaryTree.java | 7 +-
.../CreateBinaryTreeFromInorderPreorder.java | 95 +++++++++++++++++++
2 files changed, 101 insertions(+), 1 deletion(-)
create mode 100644 DataStructures/Trees/CreateBinaryTreeFromInorderPreorder.java
diff --git a/DataStructures/Trees/BinaryTree.java b/DataStructures/Trees/BinaryTree.java
index a9003d4bb322..0669f80fd8c3 100644
--- a/DataStructures/Trees/BinaryTree.java
+++ b/DataStructures/Trees/BinaryTree.java
@@ -22,7 +22,7 @@ public class BinaryTree {
*
* @author Unknown
*/
- class Node {
+ static class Node {
/** Data for the node */
public int data;
/** The Node to the left of this one */
@@ -53,6 +53,11 @@ public BinaryTree() {
root = null;
}
+ /** Parameterized Constructor */
+ public BinaryTree(Node root) {
+ this.root = root;
+ }
+
/**
* Method to find a Node with a certain value
*
diff --git a/DataStructures/Trees/CreateBinaryTreeFromInorderPreorder.java b/DataStructures/Trees/CreateBinaryTreeFromInorderPreorder.java
new file mode 100644
index 000000000000..ea9583bb3f94
--- /dev/null
+++ b/DataStructures/Trees/CreateBinaryTreeFromInorderPreorder.java
@@ -0,0 +1,95 @@
+package DataStructures.Trees;
+
+import java.util.HashMap;
+import java.util.Map;
+import DataStructures.Trees.BinaryTree.Node;
+
+/**
+ * Approach: Naive Solution: Create root node from first value present in
+ * preorder traversal. Look for the index of root node's value in inorder
+ * traversal. That will tell total nodes present in left subtree and right
+ * subtree. Based on that index create left and right subtree.
+ * Complexity:
+ * Time: O(n^2) for each node there is iteration to find index in inorder array
+ * Space: Stack size = O(height) = O(lg(n))
+ *
+ * Optimized Solution: Instead of iterating over inorder array to find index of
+ * root value, create a hashmap and find out the index of root value.
+ * Complexity:
+ * Time: O(n) hashmap reduced iteration to find index in inorder array
+ * Space: O(n) space taken by hashmap
+ *
+ */
+public class CreateBinaryTreeFromInorderPreorder {
+ public static void main(String[] args) {
+ test(new Integer[] {}, new Integer[] {}); // empty tree
+ test(new Integer[] { 1 }, new Integer[] { 1 }); // single node tree
+ test(new Integer[] { 1, 2, 3, 4 }, new Integer[] { 1, 2, 3, 4 }); // right skewed tree
+ test(new Integer[] { 1, 2, 3, 4 }, new Integer[] { 4, 3, 2, 1 }); // left skewed tree
+ test(new Integer[] { 3, 9, 20, 15, 7 }, new Integer[] { 9, 3, 15, 20, 7 }); // normal tree
+ }
+
+ private static void test(final Integer[] preorder, final Integer[] inorder) {
+ System.out.println("\n====================================================");
+ System.out.println("Naive Solution...");
+ BinaryTree root = new BinaryTree(createTree(preorder, inorder, 0, 0, inorder.length));
+ System.out.println("Preorder Traversal: ");
+ root.preOrder(root.getRoot());
+ System.out.println("\nInorder Traversal: ");
+ root.inOrder(root.getRoot());
+ System.out.println("\nPostOrder Traversal: ");
+ root.postOrder(root.getRoot());
+
+ Map map = new HashMap<>();
+ for (int i = 0; i < inorder.length; i++) {
+ map.put(inorder[i], i);
+ }
+ BinaryTree optimizedRoot = new BinaryTree(createTreeOptimized(preorder, inorder, 0, 0, inorder.length, map));
+ System.out.println("\n\nOptimized solution...");
+ System.out.println("Preorder Traversal: ");
+ optimizedRoot.preOrder(root.getRoot());
+ System.out.println("\nInorder Traversal: ");
+ optimizedRoot.inOrder(root.getRoot());
+ System.out.println("\nPostOrder Traversal: ");
+ optimizedRoot.postOrder(root.getRoot());
+ }
+
+ private static Node createTree(final Integer[] preorder, final Integer[] inorder,
+ final int preStart, final int inStart, final int size) {
+ if (size == 0) {
+ return null;
+ }
+
+ Node root = new Node(preorder[preStart]);
+ int i = inStart;
+ while (preorder[preStart] != inorder[i]) {
+ i++;
+ }
+ int leftNodesCount = i - inStart;
+ int rightNodesCount = size - leftNodesCount - 1;
+ root.left = createTree(preorder, inorder, preStart + 1, inStart, leftNodesCount);
+ root.right = createTree(preorder, inorder, preStart + leftNodesCount + 1, i + 1,
+ rightNodesCount);
+ return root;
+
+ }
+
+ private static Node createTreeOptimized(final Integer[] preorder, final Integer[] inorder,
+ final int preStart, final int inStart, final int size,
+ final Map inorderMap) {
+ if (size == 0) {
+ return null;
+ }
+
+ Node root = new Node(preorder[preStart]);
+ int i = inorderMap.get(preorder[preStart]);
+ int leftNodesCount = i - inStart;
+ int rightNodesCount = size - leftNodesCount - 1;
+ root.left = createTreeOptimized(preorder, inorder, preStart + 1, inStart,
+ leftNodesCount, inorderMap);
+ root.right = createTreeOptimized(preorder, inorder, preStart + leftNodesCount + 1,
+ i + 1, rightNodesCount, inorderMap);
+ return root;
+ }
+
+}
From 64513ff53e4ae91191a088dd7c9d734489a25d9b Mon Sep 17 00:00:00 2001
From: Amit Kumar
Date: Tue, 26 Oct 2021 11:44:26 +0530
Subject: [PATCH 0060/1552] Create a balanced binary search tree from a sorted
array (Fixes: #2706) (#2711)
Co-authored-by: Amit Kumar
---
.../Trees/CreateBSTFromSortedArray.java | 45 +++++++++++++++++++
1 file changed, 45 insertions(+)
create mode 100644 DataStructures/Trees/CreateBSTFromSortedArray.java
diff --git a/DataStructures/Trees/CreateBSTFromSortedArray.java b/DataStructures/Trees/CreateBSTFromSortedArray.java
new file mode 100644
index 000000000000..f31e7928c6b1
--- /dev/null
+++ b/DataStructures/Trees/CreateBSTFromSortedArray.java
@@ -0,0 +1,45 @@
+package DataStructures.Trees;
+
+import DataStructures.Trees.BinaryTree.Node;
+
+/**
+ * Given a sorted array. Create a balanced binary search tree from it.
+ *
+ * Steps:
+ * 1. Find the middle element of array. This will act as root
+ * 2. Use the left half recursively to create left subtree
+ * 3. Use the right half recursively to create right subtree
+ */
+public class CreateBSTFromSortedArray {
+
+ public static void main(String[] args) {
+ test(new int[]{});
+ test(new int[]{1, 2, 3});
+ test(new int[]{1, 2, 3, 4, 5});
+ test(new int[]{1, 2, 3, 4, 5, 6, 7});
+ }
+
+ private static void test(int[] array) {
+ BinaryTree root = new BinaryTree(createBst(array, 0, array.length - 1));
+ System.out.println("\n\nPreorder Traversal: ");
+ root.preOrder(root.getRoot());
+ System.out.println("\nInorder Traversal: ");
+ root.inOrder(root.getRoot());
+ System.out.println("\nPostOrder Traversal: ");
+ root.postOrder(root.getRoot());
+ }
+
+ private static Node createBst(int[] array, int start, int end) {
+ // No element left.
+ if (start > end) {
+ return null;
+ }
+ int mid = start + (end - start) / 2;
+
+ // middle element will be the root
+ Node root = new Node(array[mid]);
+ root.left = createBst(array, start, mid - 1);
+ root.right = createBst(array, mid + 1, end);
+ return root;
+ }
+}
From 9b90628a89d2c2eff2bcf907d73a8d7ef3c31959 Mon Sep 17 00:00:00 2001
From: Shivam Shrey <31056227+shivamshrey@users.noreply.github.com>
Date: Thu, 28 Oct 2021 00:26:00 +0530
Subject: [PATCH 0061/1552] Fix incorrect file extension (Fixes: #2716) (#2717)
---
DataStructures/Lists/CreateAndDetectLoop.java | 95 ++++++++++++++++
DataStructures/Lists/README.md | 2 +-
.../Lists/detect_and_create_loop.jav | 107 ------------------
3 files changed, 96 insertions(+), 108 deletions(-)
create mode 100644 DataStructures/Lists/CreateAndDetectLoop.java
delete mode 100644 DataStructures/Lists/detect_and_create_loop.jav
diff --git a/DataStructures/Lists/CreateAndDetectLoop.java b/DataStructures/Lists/CreateAndDetectLoop.java
new file mode 100644
index 000000000000..149bf51df700
--- /dev/null
+++ b/DataStructures/Lists/CreateAndDetectLoop.java
@@ -0,0 +1,95 @@
+package DataStructures.Lists;
+
+import java.util.Scanner;
+
+public class CreateAndDetectLoop {
+
+ /**
+ * Prints the linked list.
+ *
+ * @param head head node of the linked list
+ */
+ static void printList(Node head) {
+ Node cur = head;
+
+ while (cur != null) {
+ System.out.print(cur.value + " ");
+ cur = cur.next;
+ }
+ }
+
+ /**
+ * Creates a loop in the linked list.
+ * @see
+ * GeeksForGeeks: Make a loop at K-th position
+ * @param head head node of the linked list
+ * @param k position of node where loop is to be created
+ */
+ static void createLoop(Node head, int k) {
+ if (head == null)
+ return;
+ Node temp = head;
+ int count = 1;
+ while (count < k) { // Traverse the list till the kth node
+ temp = temp.next;
+ count++;
+ }
+
+ Node connectedPoint = temp;
+
+ while (temp.next != null) // Traverse remaining nodes
+ temp = temp.next;
+
+ temp.next = connectedPoint; // Connect last node to k-th element
+ }
+
+ /**
+ * Detects the presence of a loop in the linked list.
+ * @see
+ * Floyd's Cycle Detection Algorithm
+ *
+ * @param head the head node of the linked list
+ *
+ * @return true if loop exists else false
+ */
+ static boolean detectLoop(Node head) {
+ Node sptr = head;
+ Node fptr = head;
+
+ while (fptr != null && fptr.next != null) {
+ sptr = sptr.next;
+ fptr = fptr.next.next;
+ if (fptr == sptr)
+ return true;
+ }
+
+ return false;
+ }
+
+ public static void main(String[] args) {
+ SinglyLinkedList singlyLinkedList = new SinglyLinkedList();
+ Scanner sc = new Scanner(System.in);
+
+ System.out.println("Enter the number of elements to be inserted: ");
+ int n = sc.nextInt();
+ System.out.printf("Enter the %d elements: \n", n);
+ while (n-- > 0)
+ singlyLinkedList.insert(sc.nextInt());
+
+ System.out.print("Given list: ");
+ printList(singlyLinkedList.getHead());
+ System.out.println();
+
+ System.out.println("Enter the location to generate loop: ");
+ int k = sc.nextInt();
+
+ createLoop(singlyLinkedList.getHead(), k);
+
+ if (detectLoop(singlyLinkedList.getHead()))
+ System.out.println("Loop found");
+ else
+ System.out.println("No loop found");
+
+ sc.close();
+ }
+}
diff --git a/DataStructures/Lists/README.md b/DataStructures/Lists/README.md
index 544d22277667..813e1a5f84c0 100644
--- a/DataStructures/Lists/README.md
+++ b/DataStructures/Lists/README.md
@@ -25,6 +25,6 @@ The `next` variable points to the next node in the data structure and value stor
1. `CircleLinkedList.java` : A circular linked list where next pointer of last node points to first nide of linked list.
2. `SinglyLinkedList.java` : The classic case of single links.
3. `CountSinglyLinkedListRecursion.java`: Recursively counts the size of a list.
-4. `detect_and_create_loop.java` : Detect a loop in linked list
+4. `CreateAndDetectLoop.java` : Create and detect a loop in a linked list.
5. `DoublyLinkedList.java` : A modification of singly linked list which has a `prev` pointer to point to the previous node.
6. `Merge_K_SortedLinkedlist.java` : Merges K sorted linked list with mergesort (mergesort is also the most efficient sorting algorithm for linked list).
\ No newline at end of file
diff --git a/DataStructures/Lists/detect_and_create_loop.jav b/DataStructures/Lists/detect_and_create_loop.jav
deleted file mode 100644
index a4f391457d13..000000000000
--- a/DataStructures/Lists/detect_and_create_loop.jav
+++ /dev/null
@@ -1,107 +0,0 @@
-import java.util.*;
-import java.util.Scanner;
-public class LinkedList {
-
- static Node head; // head of list
-
- static class Node // Linked list Node
- {
- int data; //to store value
- Node next; //pointer
- Node(int d) {
- data = d;
- next = null;
- }
- }
-
- static int countNodes(Node ptr) //Function to count the number of nodes present
- {
- int count = 0;
- while (ptr != null) {
- ptr = ptr.next;
- count++;
- }
- return count;
- }
-
- static public void push(int new_data) // Function to inserts a new Node at front of the list
- {
-
- Node new_node = new Node(new_data); //Allocate a pointer/node and store the data
-
- new_node.next = head; // make next of new Node as head
-
- head = new_node; // Move the head to point to new Node.
- }
-
- static void printList(Node head, int total_nodes) //function to traverse through the list and print all data values
- {
- Node curr = head;
- int count = 0;
- while (count < total_nodes) {
- count++;
- System.out.print(curr.data + " ");
- curr = curr.next;
- }
- }
-
- static Node makeloop(Node head_ref, int k) {
- Node temp = head_ref;
- int count = 1;
- while (count < k) //traverrse the list till point is found
- {
- temp = temp.next;
- count++;
- }
-
- Node connected_point = temp;
-
- while (temp.next != null) // traverse remaining nodes
- temp = temp.next;
-
- temp.next = connected_point; //connect last node to k-th element
- return head_ref;
- }
-
- static boolean detectLoop(Node h) //Function to detect loop, retuens true if loop is in linked list else returns false.
- {
- HashSet < Node > traverse = new HashSet < Node > ();
- while (n != null) {
-
- if (traverse.contains(n)) //if the hash a;ready contains a record of the node encountered true is returned as a loop isdetected
- return true;
-
- traverse.add(n);
- n = n.next;
- }
- return false;
- }
-
- public static void main(String[] args) {
- LinkedList l = new LinkedList();
-
- Scanner sc = new Scanner(System.in);
-
- print("Enter elements in the list, to stop entering press any alphabetical key");
- while (true) {
- try {
- i = sc.nextInt();
- l.push(i);
- } catch (Exception e) {
- System.out.println("Creating loop for run");
- }
- }
- System.out.println("Enter the location to generate loop");
- int k = sc.nextInt()
- System.out.print("Given list");
- printList(head, total_nodes);
- head = makeloop(head, k);
- System.out.print("Modified list with loop");
- printList(head, total_nodes);
-
- if (detectLoop(head))
- System.out.println("Loop found");
- else
- System.out.println("No Loop");
- }
-}
From 1899d2a43992d24bf41ca88f03c6b97ae1b887e0 Mon Sep 17 00:00:00 2001
From: Pratik Padalia
Date: Thu, 28 Oct 2021 00:29:23 +0530
Subject: [PATCH 0062/1552] Add Upper Bound Search Algorithm (#2722)
Co-authored-by: Pratik
---
Searches/UpperBound.java | 95 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 95 insertions(+)
create mode 100644 Searches/UpperBound.java
diff --git a/Searches/UpperBound.java b/Searches/UpperBound.java
new file mode 100644
index 000000000000..6f895fcafde0
--- /dev/null
+++ b/Searches/UpperBound.java
@@ -0,0 +1,95 @@
+package Searches;
+
+import static java.lang.String.format;
+
+import java.util.Random;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.stream.IntStream;
+
+/**
+ * The UpperBound method is used to return an index pointing to the first element in the range
+ * [first, last) which has a value greater than val, or the last index if no such element exists
+ * i.e. the index of the next smallest number just greater than that number. If there are multiple
+ * values that are equal to val it returns the index of the first such value.
+ *
+ * This is an extension of BinarySearch.
+ *
+ *
Worst-case performance O(log n) Best-case performance O(1) Average performance O(log n)
+ * Worst-case space complexity O(1)
+ *
+ * @author Pratik Padalia (https://github.com/15pratik)
+ * @see SearchAlgorithm
+ * @see BinarySearch
+ */
+class UpperBound implements SearchAlgorithm {
+
+ // Driver Program
+ public static void main(String[] args) {
+ // Just generate data
+ Random r = ThreadLocalRandom.current();
+
+ int size = 100;
+ int maxElement = 100000;
+
+ Integer[] integers =
+ IntStream.generate(() -> r.nextInt(maxElement))
+ .limit(size)
+ .sorted()
+ .boxed()
+ .toArray(Integer[]::new);
+
+ // The element for which the upper bound is to be found
+ int val = integers[r.nextInt(size - 1)] + 1;
+
+ UpperBound search = new UpperBound();
+ int atIndex = search.find(integers, val);
+
+ System.out.println(
+ format(
+ "Val: %d. Upper Bound Found %d at index %d. An array length %d",
+ val, integers[atIndex], atIndex, size));
+
+ boolean toCheck = integers[atIndex] > val || integers[size - 1] < val;
+ System.out.println(
+ format(
+ "Upper Bound found at an index: %d. Is greater or max element: %b", atIndex, toCheck));
+ }
+
+ /**
+ * @param array is an array where the UpperBound value is to be found
+ * @param key is an element for which the UpperBound is to be found
+ * @param is any comparable type
+ * @return index of the UpperBound element
+ */
+ @Override
+ public > int find(T[] array, T key) {
+ return search(array, key, 0, array.length - 1);
+ }
+
+ /**
+ * This method implements the Generic Binary Search
+ *
+ * @param array The array to make the binary search
+ * @param key The number you are looking for
+ * @param left The lower bound
+ * @param right The upper bound
+ * @return the location of the key
+ */
+ private > int search(T[] array, T key, int left, int right) {
+ if (right <= left) {
+ return left;
+ }
+
+ // find median
+ int median = (left + right) >>> 1;
+ int comp = key.compareTo(array[median]);
+
+ if (comp < 0) {
+ // key is smaller, median position can be a possible solution
+ return search(array, key, left, median);
+ } else {
+ // key we are looking is greater, so we must look on the right of median position
+ return search(array, key, median + 1, right);
+ }
+ }
+}
From b2de5c7f1eda5ab1e48749dfba41acb001cc328a Mon Sep 17 00:00:00 2001
From: Artem Boiarshinov <54187376+Boiarshinov@users.noreply.github.com>
Date: Wed, 27 Oct 2021 22:01:53 +0300
Subject: [PATCH 0063/1552] Add description for Sieve of Eratosthenes algorithm
(Fixes: #2724) (#2725)
---
Others/SieveOfEratosthenes.java | 74 +++++++++++++++++++++++----------
1 file changed, 53 insertions(+), 21 deletions(-)
diff --git a/Others/SieveOfEratosthenes.java b/Others/SieveOfEratosthenes.java
index f3759d2fdb56..a4293cc3439b 100644
--- a/Others/SieveOfEratosthenes.java
+++ b/Others/SieveOfEratosthenes.java
@@ -1,44 +1,76 @@
package Others;
-/** @author Varun Upadhyay (https://github.com/varunu28) */
+import java.util.Arrays;
+
+/**
+ * Sieve of Eratosthenes is an ancient algorithm for finding all prime numbers up to any given limit.
+ * It does so by iteratively marking as composite (i.e., not prime) the multiples of each prime,
+ * starting with the first prime number, 2.
+ * The multiples of a given prime are generated as a sequence of numbers starting from that prime,
+ * with constant difference between them that is equal to that prime.
+ * This is the sieve's key distinction from using trial division to sequentially test each
+ * candidate number for divisibility by each prime.
+ * Once all the multiples of each discovered prime have been marked as composites, the remaining
+ * unmarked numbers are primes.
+ *
+ * Poetry about Sieve of Eratosthenes:
+ *
Sift the Two's and Sift the Three's:
+ * The Sieve of Eratosthenes.
+ * When the multiples sublime,
+ * The numbers that remain are Prime.
+ *
+ * @see Wiki
+ */
public class SieveOfEratosthenes {
/**
- * This method implements the Sieve of Eratosthenes Algorithm
- *
- * @param n The number till which we have to check for prime Prints all the prime numbers till n
+ * @param n The number till which we have to check for prime Prints all the prime numbers till n.
+ * Should be more than 1.
+ * @return array of all prime numbers between 0 to n
*/
- public static void findPrimesTillN(int n) {
- int[] arr = new int[n + 1];
-
- for (int i = 0; i <= n; i++) {
- arr[i] = 1;
- }
+ public static int[] findPrimesTill(int n) {
+ // Create array where index is number and value is flag - is that number a prime or not.
+ // size of array is n + 1 cause in Java array indexes starts with 0
+ Type[] numbers = new Type[n + 1];
- arr[0] = arr[1] = 0;
+ // Start with assumption that all numbers except 0 and 1 are primes.
+ Arrays.fill(numbers, Type.PRIME);
+ numbers[0] = numbers[1] = Type.NOT_PRIME;
- for (int i = 2; i <= Math.sqrt(n); i++) {
- if (arr[i] == 1) {
+ double cap = Math.sqrt(n);
+ // Main algorithm: mark all numbers which are multiples of some other values as not prime
+ for (int i = 2; i <= cap; i++) {
+ if (numbers[i] == Type.PRIME) {
for (int j = 2; i * j <= n; j++) {
- arr[i * j] = 0;
+ numbers[i * j] = Type.NOT_PRIME;
}
}
}
+ //Write all primes to result array
+ int primesCount = (int) Arrays.stream(numbers)
+ .filter(element -> element == Type.PRIME)
+ .count();
+ int[] primes = new int[primesCount];
+
+ int primeIndex = 0;
for (int i = 0; i < n + 1; i++) {
- if (arr[i] == 1) {
- System.out.print(i + " ");
+ if(numbers[i] == Type.PRIME) {
+ primes[primeIndex++] = i;
}
}
- System.out.println();
+ return primes;
+ }
+
+ private enum Type {
+ PRIME, NOT_PRIME
}
- // Driver Program
public static void main(String[] args) {
int n = 100;
-
- // Prints 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
- findPrimesTillN(n);
+ System.out.println("Searching for all primes from zero to " + n);
+ int[] primes = findPrimesTill(n);
+ System.out.println("Found: " + Arrays.toString(primes));
}
}
From ad380dcaa4721e5bad5ba4517d380dec2b697ec9 Mon Sep 17 00:00:00 2001
From: Shraddha <42699578+shraddhavp@users.noreply.github.com>
Date: Thu, 28 Oct 2021 00:33:51 +0530
Subject: [PATCH 0064/1552] Add Boyer moore voting algo (#2726)
---
Others/BoyerMoore.java | 40 ++++++++++++++++++++++++++++++++++++++++
1 file changed, 40 insertions(+)
create mode 100644 Others/BoyerMoore.java
diff --git a/Others/BoyerMoore.java b/Others/BoyerMoore.java
new file mode 100644
index 000000000000..68f6aa6fde9d
--- /dev/null
+++ b/Others/BoyerMoore.java
@@ -0,0 +1,40 @@
+/* this Code is the illustration of Boyer moore's voting algorithm to
+find the majority element is an array that appears more than n/2 times in an array
+where "n" is the length of the array.
+For more information on the algorithm refer https://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_majority_vote_algorithm
+ */
+package Others;
+import java.util.*;
+
+public class BoyerMoore {
+ public static int findmajor(int [] a){
+int count=0; int cand=-1;
+for(int i=0;i (a.length / 2))
+ return cand;
+ return -1;
+}
+ public static void main(String args[]){
+ Scanner input=new Scanner(System.in);
+ int n=input.nextInt();
+ int a[]=new int[n];
+ for(int i=0;i
Date: Wed, 27 Oct 2021 22:19:09 +0300
Subject: [PATCH 0065/1552] Add nearest right neighbor (#2574)
---
DataStructures/Trees/nearestRightKey.java | 84 +++++++++++++++++++++++
1 file changed, 84 insertions(+)
create mode 100644 DataStructures/Trees/nearestRightKey.java
diff --git a/DataStructures/Trees/nearestRightKey.java b/DataStructures/Trees/nearestRightKey.java
new file mode 100644
index 000000000000..228bf470d809
--- /dev/null
+++ b/DataStructures/Trees/nearestRightKey.java
@@ -0,0 +1,84 @@
+package DataStructures.NRKTrees;
+
+import java.util.Scanner;
+import java.util.concurrent.ThreadLocalRandom;
+
+class Main {
+
+ public static void main(String[] args) {
+ NRKTree root = BuildTree();
+ Scanner sc = new Scanner(System.in);
+ System.out.print("Enter first number: ");
+ int inputX0 = sc.nextInt();
+ int toPrint = nearestRightKey(root, inputX0);
+ System.out.println("Key: " + toPrint);
+ }
+
+ public static NRKTree BuildTree() {
+ int randomX = ThreadLocalRandom.current().nextInt(0, 100 + 1);
+ NRKTree root = new NRKTree(null, null, randomX);
+
+ for (int i = 0; i < 1000; i++) {
+ randomX = ThreadLocalRandom.current().nextInt(0, 100 + 1);
+ root = root.insertKey(root, randomX);
+ }
+
+ return root;
+ }
+
+ public static int nearestRightKey(NRKTree root, int x0) {
+ //Check whether tree is empty
+ if(root == null){
+ return 0;
+ }
+ else {
+ if(root.data - x0 > 0){
+ // Go left
+ int temp = nearestRightKey(root.left, x0);
+ if(temp == 0){
+ return root.data;
+ }
+ return temp;
+ } else {
+ // Go right
+ return nearestRightKey(root.right, x0);
+ }
+
+ }
+ }
+
+}
+
+
+class NRKTree {
+
+ public NRKTree left;
+ public NRKTree right;
+ public int data;
+
+ public NRKTree(int x) {
+ this.left = null;
+ this.right = null;
+ this.data = x;
+ }
+
+ public NRKTree(NRKTree right, NRKTree left, int x) {
+ this.left = left;
+ this.right = right;
+ this.data = x;
+ }
+
+ public NRKTree insertKey(NRKTree current, int value) {
+ if (current == null) {
+ return new NRKTree(value);
+ }
+
+ if (value < current.data) {
+ current.left = insertKey(current.left, value);
+ } else if (value > current.data) {
+ current.right = insertKey(current.right, value);
+ }
+
+ return current;
+ }
+}
From 6934c53c0400e1d3158014dfeb984e629c0bc8fb Mon Sep 17 00:00:00 2001
From: januslinhc
Date: Fri, 29 Oct 2021 00:58:58 +0800
Subject: [PATCH 0066/1552] Add MRU Cache (#2738)
---
DIRECTORY.md | 8 ++
DataStructures/Caches/MRUCache.java | 179 ++++++++++++++++++++++++++++
2 files changed, 187 insertions(+)
create mode 100644 DataStructures/Caches/MRUCache.java
diff --git a/DIRECTORY.md b/DIRECTORY.md
index 4fd29a368cf4..3a2ee7bd7668 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -3,6 +3,7 @@
* [IIRFilter](https://github.com/TheAlgorithms/Java/blob/master/AudioFilters/IIRFilter.java)
## Backtracking
+ * [KnightsTour](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/KnightsTour.java)
* [NQueens](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/NQueens.java)
* [PowerSum](https://github.com/TheAlgorithms/Java/blob/master/Backtracking/PowerSum.java)
@@ -48,6 +49,7 @@
* [CircularBuffer](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Buffers/CircularBuffer.java)
* Caches
* [LRUCache](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Caches/LRUCache.java)
+ * [MRUCache](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Caches/MRUCache.java)
* DisjointSets
* [DisjointSets](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DisjointSets/DisjointSets.java)
* [Node](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/DisjointSets/Node.java)
@@ -82,6 +84,7 @@
* Lists
* [CircleLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/CircleLinkedList.java)
* [CountSinglyLinkedListRecursion](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/CountSinglyLinkedListRecursion.java)
+ * [CreateAndDetectLoop](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/CreateAndDetectLoop.java)
* [CursorLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/CursorLinkedList.java)
* [DoublyLinkedList](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/DoublyLinkedList.java)
* [Merge K SortedLinkedlist](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Lists/Merge_K_SortedLinkedlist.java)
@@ -113,11 +116,14 @@
* [BSTRecursive](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BSTRecursive.java)
* [BSTRecursiveGeneric](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/BSTRecursiveGeneric.java)
* [CeilInBinarySearchTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/CeilInBinarySearchTree.java)
+ * [CreateBinaryTreeFromInorderPreorder](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/CreateBinaryTreeFromInorderPreorder.java)
+ * [CreateBSTFromSortedArray](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/CreateBSTFromSortedArray.java)
* [FenwickTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/FenwickTree.java)
* [GenericTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/GenericTree.java)
* [LCA](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LCA.java)
* [LevelOrderTraversal](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LevelOrderTraversal.java)
* [LevelOrderTraversalQueue](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/LevelOrderTraversalQueue.java)
+ * [nearestRightKey](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/nearestRightKey.java)
* [PrintTopViewofTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/PrintTopViewofTree.java)
* [RedBlackBST](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/RedBlackBST.java)
* [SegmentTree](https://github.com/TheAlgorithms/Java/blob/master/DataStructures/Trees/SegmentTree.java)
@@ -253,6 +259,7 @@
## Others
* [BestFit](https://github.com/TheAlgorithms/Java/blob/master/Others/BestFit.java)
* [BFPRT](https://github.com/TheAlgorithms/Java/blob/master/Others/BFPRT.java)
+ * [BoyerMoore](https://github.com/TheAlgorithms/Java/blob/master/Others/BoyerMoore.java)
* [BrianKernighanAlgorithm](https://github.com/TheAlgorithms/Java/blob/master/Others/BrianKernighanAlgorithm.java)
* [CountChar](https://github.com/TheAlgorithms/Java/blob/master/Others/CountChar.java)
* [CountWords](https://github.com/TheAlgorithms/Java/blob/master/Others/CountWords.java)
@@ -317,6 +324,7 @@
* [SquareRootBinarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/SquareRootBinarySearch.java)
* [TernarySearch](https://github.com/TheAlgorithms/Java/blob/master/Searches/TernarySearch.java)
* [UnionFind](https://github.com/TheAlgorithms/Java/blob/master/Searches/UnionFind.java)
+ * [UpperBound](https://github.com/TheAlgorithms/Java/blob/master/Searches/UpperBound.java)
## Sorts
* [BitonicSort](https://github.com/TheAlgorithms/Java/blob/master/Sorts/BitonicSort.java)
diff --git a/DataStructures/Caches/MRUCache.java b/DataStructures/Caches/MRUCache.java
new file mode 100644
index 000000000000..e31564775a3f
--- /dev/null
+++ b/DataStructures/Caches/MRUCache.java
@@ -0,0 +1,179 @@
+package DataStructures.Caches;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Most recently used (MRU)
+ *
+ * In contrast to Least Recently Used (LRU), MRU discards the most recently used items first.
+ * https://en.wikipedia.org/wiki/Cache_replacement_policies#Most_recently_used_(MRU)
+ *
+ * @param key type
+ * @param value type
+ */
+public class MRUCache {
+ private final Map> data = new HashMap<>();
+ private Entry head;
+ private Entry tail;
+ private int cap;
+ private static final int DEFAULT_CAP = 100;
+
+ public MRUCache() {
+ setCapacity(DEFAULT_CAP);
+ }
+
+ private void setCapacity(int newCapacity) {
+ checkCapacity(newCapacity);
+ for (int i = data.size(); i > newCapacity; i--) {
+ Entry evicted = evict();
+ data.remove(evicted.getKey());
+ }
+ this.cap = newCapacity;
+ }
+
+
+ private void checkCapacity(int capacity) {
+ if (capacity <= 0) {
+ throw new RuntimeException("capacity must greater than 0!");
+ }
+ }
+
+ private Entry evict() {
+ if (head == null) {
+ throw new RuntimeException("cache cannot be empty!");
+ }
+ final Entry evicted = this.tail;
+ tail = evicted.getPreEntry();
+ tail.setNextEntry(null);
+ evicted.setNextEntry(null);
+ return evicted;
+ }
+
+ public MRUCache(int cap) {
+ setCapacity(cap);
+ }
+
+ public V get(K key) {
+ if (!data.containsKey(key)) {
+ return null;
+ }
+ final Entry entry = data.get(key);
+ moveEntryToLast(entry);
+ return entry.getValue();
+ }
+
+ public void put(K key, V value) {
+ if (data.containsKey(key)) {
+ final Entry exitingEntry = data.get(key);
+ exitingEntry.setValue(value);
+ moveEntryToLast(exitingEntry);
+ return;
+ }
+ Entry newEntry;
+ if (data.size() == cap) {
+ newEntry = evict();
+ data.remove(newEntry.getKey());
+ } else {
+ newEntry = new Entry<>();
+ }
+ newEntry.setKey(key);
+ newEntry.setValue(value);
+ addNewEntry(newEntry);
+ data.put(key, newEntry);
+ }
+
+ private void addNewEntry(Entry newEntry) {
+ if (data.isEmpty()) {
+ head = newEntry;
+ tail = newEntry;
+ return;
+ }
+ tail.setNextEntry(newEntry);
+ newEntry.setPreEntry(tail);
+ newEntry.setNextEntry(null);
+ tail = newEntry;
+ }
+
+ private void moveEntryToLast(Entry entry) {
+ if (tail == entry) {
+ return;
+ }
+ final Entry preEntry = entry.getPreEntry();
+ final Entry nextEntry = entry.getNextEntry();
+ if (preEntry != null) {
+ preEntry.setNextEntry(nextEntry);
+ }
+ if (nextEntry != null) {
+ nextEntry.setPreEntry(preEntry);
+ }
+ if (head == entry) {
+ head = nextEntry;
+ }
+ tail.setNextEntry(entry);
+ entry.setPreEntry(tail);
+ entry.setNextEntry(null);
+ tail = entry;
+ }
+
+ static final class Entry {
+ private Entry preEntry;
+ private Entry nextEntry;
+ private I key;
+ private J value;
+
+ public Entry() {
+ }
+
+ public Entry(Entry preEntry, Entry nextEntry, I key, J value) {
+ this.preEntry = preEntry;
+ this.nextEntry = nextEntry;
+ this.key = key;
+ this.value = value;
+ }
+
+ public Entry getPreEntry() {
+ return preEntry;
+ }
+
+ public void setPreEntry(Entry preEntry) {
+ this.preEntry = preEntry;
+ }
+
+ public Entry getNextEntry() {
+ return nextEntry;
+ }
+
+ public void setNextEntry(Entry nextEntry) {
+ this.nextEntry = nextEntry;
+ }
+
+ public I getKey() {
+ return key;
+ }
+
+ public void setKey(I key) {
+ this.key = key;
+ }
+
+ public J getValue() {
+ return value;
+ }
+
+ public void setValue(J value) {
+ this.value = value;
+ }
+ }
+
+ public static void main(String[] args) {
+ final MRUCache cache = new MRUCache<>(2);
+ cache.put("Key1", 1);
+ cache.put("Key2", 2);
+ cache.put("Key3", 3);
+ cache.put("Key4", 4);
+ System.out.println("getValue(Key1): " + cache.get("Key1"));
+ System.out.println("getValue(Key2): " + cache.get("Key2"));
+ System.out.println("getValue(Key3): " + cache.get("Key3"));
+ System.out.println("getValue(Key4): " + cache.get("Key4"));
+ }
+}
From 9ff553e0a35ac2e4a80f5fe8e2dd96d8c8988cb8 Mon Sep 17 00:00:00 2001
From: Sneha B <57147597+Sneha421@users.noreply.github.com>
Date: Thu, 28 Oct 2021 22:31:59 +0530
Subject: [PATCH 0067/1552] Add Three Sum Problem (#2741)
---
Misc/ThreeSumProblem.java | 109 ++++++++++++++++++++++++++++++++++++++
Misc/TwoSumProblem.java | 1 -
2 files changed, 109 insertions(+), 1 deletion(-)
create mode 100644 Misc/ThreeSumProblem.java
diff --git a/Misc/ThreeSumProblem.java b/Misc/ThreeSumProblem.java
new file mode 100644
index 000000000000..a5ccae862ddc
--- /dev/null
+++ b/Misc/ThreeSumProblem.java
@@ -0,0 +1,109 @@
+import java.util.*;
+public class ThreeSumProblem {
+ public static void main(String args[])
+ {
+ Scanner scan = new Scanner(System.in);
+ System.out.print("Enter the target sum ");
+ int ts= scan.nextInt();
+ System.out.print("Enter the number of elements in the array ");
+ int n = scan.nextInt();
+ System.out.println("Enter all your array elements:");
+ int arr[]= new int[n];
+ for(int i=0;i> BruteForce(int[] nums,int target) {
+ List> arr = new ArrayList>();
+
+ for(int i=0;i temp = new ArrayList<>();
+ temp.add(nums[i]);
+ temp.add(nums[j]);
+ temp.add(nums[k]);
+ Collections.sort(temp);
+ arr.add(temp);
+ }
+
+
+ }
+ }
+ }
+ arr = new ArrayList>(new LinkedHashSet>(arr));
+ return arr;
+ }
+ public List> TwoPointer(int[] nums, int target) {
+ Arrays.sort(nums);
+ List> arr = new ArrayList>();
+ int start=0;
+ int end=0;
+ int i = 0;
+ while(i temp = new ArrayList<>();
+ temp.add(nums[i]);
+ temp.add(nums[start]);
+ temp.add(nums[end]);
+ arr.add(temp);
+ start++;
+ end--;
+ }
+ else if (nums[start]+nums[end]+nums[i]> set = new LinkedHashSet>(arr);
+ return new ArrayList>(set);
+ }
+ public List> Hashmap(int[] nums, int target) {
+ Arrays.sort(nums);
+ Set> ts = new HashSet();
+ HashMap hm = new HashMap<>();
+
+ for(int i=0;ij)
+ {
+ List temp = new ArrayList<>();
+ temp.add(nums[i]);
+ temp.add(nums[j]);
+ temp.add(t);
+ ts.add(temp);
+ }
+ }
+ }
+ return new ArrayList(ts);
+ }
+
+}
+
diff --git a/Misc/TwoSumProblem.java b/Misc/TwoSumProblem.java
index 0bea06f3901f..620f5d883c07 100644
--- a/Misc/TwoSumProblem.java
+++ b/Misc/TwoSumProblem.java
@@ -1,5 +1,4 @@
package Misc;
-
import java.util.*;
import java.util.stream.Collectors;
From 447c5fa578a98b0af85bf63969b48993f8ddf38e Mon Sep 17 00:00:00 2001
From: Limbad Yash <56826569+limbad-YK@users.noreply.github.com>
Date: Thu, 28 Oct 2021 22:33:31 +0530
Subject: [PATCH 0068/1552] Add Longest Alternating Subsequence (#2743)
---
.../LongestAlternatingSubsequence.java | 68 +++++++++++++++++++
1 file changed, 68 insertions(+)
create mode 100644 DynamicProgramming/LongestAlternatingSubsequence.java
diff --git a/DynamicProgramming/LongestAlternatingSubsequence.java b/DynamicProgramming/LongestAlternatingSubsequence.java
new file mode 100644
index 000000000000..3551edf0262e
--- /dev/null
+++ b/DynamicProgramming/LongestAlternatingSubsequence.java
@@ -0,0 +1,68 @@
+/*
+
+ * Problem Statement: -
+ * Find Longest Alternating Subsequence
+
+ * A sequence {x1, x2, .. xn} is alternating sequence if its elements satisfy one of the following relations :
+
+ x1 < x2 > x3 < x4 > x5 < …. xn or
+ x1 > x2 < x3 > x4 < x5 > …. xn
+*/
+
+import java.io.*;
+
+public class LongestAlternatingSubsequence {
+
+ /* Function to return longest alternating subsequence length*/
+ static int AlternatingLength(int arr[], int n){
+ /*
+
+ las[i][0] = Length of the longest
+ alternating subsequence ending at
+ index i and last element is
+ greater than its previous element
+
+ las[i][1] = Length of the longest
+ alternating subsequence ending at
+ index i and last element is
+ smaller than its previous
+ element
+
+ */
+ int las[][] = new int[n][2]; // las = LongestAlternatingSubsequence
+
+ for (int i = 0; i < n; i++)
+ las[i][0] = las[i][1] = 1;
+
+ int result = 1; // Initialize result
+
+ /* Compute values in bottom up manner */
+ for (int i = 1; i < n; i++){
+
+ /* Consider all elements as previous of arr[i]*/
+ for (int j = 0; j < i; j++){
+
+ /* If arr[i] is greater, then check with las[j][1] */
+ if (arr[j] < arr[i] && las[i][0] < las[j][1] + 1)
+ las[i][0] = las[j][1] + 1;
+
+ /* If arr[i] is smaller, then check with las[j][0]*/
+ if( arr[j] > arr[i] && las[i][1] < las[j][0] + 1)
+ las[i][1] = las[j][0] + 1;
+ }
+
+ /* Pick maximum of both values at index i */
+ if (result < Math.max(las[i][0], las[i][1]))
+ result = Math.max(las[i][0], las[i][1]);
+ }
+
+ return result;
+ }
+
+ public static void main(String[] args)
+ {
+ int arr[] = { 10, 22, 9, 33, 49,50, 31, 60 };
+ int n = arr.length;
+ System.out.println("Length of Longest "+"alternating subsequence is " +AlternatingLength(arr, n));
+ }
+}
From 7858187d59c7189c05b5833162fda8a2c64b5bb4 Mon Sep 17 00:00:00 2001
From: Rahul Chhabra
Date: Thu, 28 Oct 2021 22:35:44 +0530
Subject: [PATCH 0069/1552] Add Solver For Linear Diophantine Equations (#2744)
---
Maths/LinearDiophantineEquationsSolver.java | 143 ++++++++++++++++++++
1 file changed, 143 insertions(+)
create mode 100644 Maths/LinearDiophantineEquationsSolver.java
diff --git a/Maths/LinearDiophantineEquationsSolver.java b/Maths/LinearDiophantineEquationsSolver.java
new file mode 100644
index 000000000000..09837cc9037c
--- /dev/null
+++ b/Maths/LinearDiophantineEquationsSolver.java
@@ -0,0 +1,143 @@
+package Maths;
+
+import java.util.Objects;
+
+public final class LinearDiophantineEquationsSolver {
+
+ public static void main(String[] args) {
+ // 3x + 4y = 7
+ final var toSolve = new Equation(3, 4, 7);
+ System.out.println(findAnySolution(toSolve));
+ }
+
+ public static Solution findAnySolution(final Equation equation) {
+ if (equation.a() == 0 && equation.b() == 0 && equation.c() == 0) {
+ return Solution.INFINITE_SOLUTIONS;
+ }
+ final var stub = new GcdSolutionWrapper(0, new Solution(0, 0));
+ final var gcdSolution = gcd(equation.a(), equation.b(), stub);
+ if (equation.c() % gcdSolution.getGcd() != 0) {
+ return Solution.NO_SOLUTION;
+ }
+ final var toReturn = new Solution(0, 0);
+ var xToSet = stub.getSolution().getX() * (equation.c() / stub.getGcd());
+ var yToSet = stub.getSolution().getY() * (equation.c() / stub.getGcd());
+ toReturn.setX(xToSet);
+ toReturn.setY(yToSet);
+ return toReturn;
+ }
+
+ private static GcdSolutionWrapper gcd(final int a, final int b, final GcdSolutionWrapper previous) {
+ if (b == 0) {
+ return new GcdSolutionWrapper(a, new Solution(1, 0));
+ }
+ // stub wrapper becomes the `previous` of the next recursive call
+ final var stubWrapper = new GcdSolutionWrapper(0, new Solution(0, 0));
+ final var next = /* recursive call */ gcd(b, a % b, stubWrapper);
+ previous.getSolution().setX(next.getSolution().getY());
+ previous.getSolution().setY(next.getSolution().getX() - (a / b) * (next.getSolution().getY()));
+ previous.setGcd(next.getGcd());
+ return new GcdSolutionWrapper(next.getGcd(), previous.getSolution());
+ }
+
+ public static final class Solution {
+ public static final Solution NO_SOLUTION = new Solution(Integer.MAX_VALUE, Integer.MAX_VALUE);
+ public static final Solution INFINITE_SOLUTIONS = new Solution(Integer.MIN_VALUE, Integer.MIN_VALUE);
+ private int x;
+ private int y;
+
+ public Solution(int x, int y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ public int getX() {
+ return x;
+ }
+
+ public int getY() {
+ return y;
+ }
+
+ public void setX(int x) {
+ this.x = x;
+ }
+
+ public void setY(int y) {
+ this.y = y;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) return true;
+ if (obj == null || obj.getClass() != this.getClass()) return false;
+ var that = (Solution) obj;
+ return this.x == that.x &&
+ this.y == that.y;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(x, y);
+ }
+
+ @Override
+ public String toString() {
+ return "Solution[" +
+ "x=" + x + ", " +
+ "y=" + y + ']';
+ }
+
+ }
+
+ public record Equation(int a, int b, int c) {
+ }
+
+ public static final class GcdSolutionWrapper {
+ private int gcd;
+ private Solution solution;
+
+ public GcdSolutionWrapper(int gcd, Solution solution) {
+ this.gcd = gcd;
+ this.solution = solution;
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (obj == this) return true;
+ if (obj == null || obj.getClass() != this.getClass()) return false;
+ var that = (GcdSolutionWrapper) obj;
+ return this.gcd == that.gcd &&
+ Objects.equals(this.solution, that.solution);
+ }
+
+ public int getGcd() {
+ return gcd;
+ }
+
+ public void setGcd(int gcd) {
+ this.gcd = gcd;
+ }
+
+ public Solution getSolution() {
+ return solution;
+ }
+
+ public void setSolution(Solution solution) {
+ this.solution = solution;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hash(gcd, solution);
+ }
+
+ @Override
+ public String toString() {
+ return "GcdSolutionWrapper[" +
+ "gcd=" + gcd + ", " +
+ "solution=" + solution + ']';
+ }
+
+ }
+}
From 4db7a0c77e77378849fd2715842805c4b3c86c99 Mon Sep 17 00:00:00 2001
From: Shraddha <42699578+shraddhavp@users.noreply.github.com>
Date: Fri, 29 Oct 2021 10:24:11 +0530
Subject: [PATCH 0070/1552] Adde Dutch National Flag Algorithm (#2728)
---
Misc/Sort012D.java | 53 ++++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 53 insertions(+)
create mode 100644 Misc/Sort012D.java
diff --git a/Misc/Sort012D.java b/Misc/Sort012D.java
new file mode 100644
index 000000000000..3d9785bad673
--- /dev/null
+++ b/Misc/Sort012D.java
@@ -0,0 +1,53 @@
+package Misc;
+import java.util.*;
+/**
+The array is divided into four sections:
+a[1..Lo-1] zeroes
+a[Lo..Mid-1] ones
+a[Mid..Hi] unknown
+a[Hi+1..N] twos
+If array [mid] =0, then swap array [mid] with array [low] and increment both pointers once.
+If array [mid] = 1, then no swapping is required. Increment mid pointer once.
+If array [mid] = 2, then we swap array [mid] with array [high] and decrement the high pointer once.
+For more information on the Dutch national flag algorithm refer https://en.wikipedia.org/wiki/Dutch_national_flag_problem
+*/
+public class Sort012D {
+ public static void main(String args[]) {
+ Scanner np = new Scanner(System.in);
+ int n = np.nextInt();
+ int a[] = new int[n];
+ for (int i = 0; i < n; i++) {
+ a[i] = np.nextInt();
+ }
+ sort012(a);}
+
+ public static void sort012(int[]a){
+ int l = 0;
+ int h = a.length - 1;
+ int mid = 0;
+ int temp ;
+ while (mid <= h) {
+ switch (a[mid]) {
+ case 0: {
+ temp = a[l];
+ a[l] = a[mid];
+ a[mid] = temp;
+ l++;
+ mid++;
+ break;}
+ case 1:
+ mid++;
+ break;
+ case 2: {
+ temp = a[mid];
+ a[mid] = a[h];
+ a[h] = temp;
+ h--;
+ break;
+ }
+ }
+ }
+ System.out.println("the Sorted array is ");
+ for (int i = 0; i < a.length; i++)
+ System.out.print(+a[i] + " "); }
+}
From 0503c466800673c21a4a61553db5f443d8421963 Mon Sep 17 00:00:00 2001
From: Shikhar Chandra <47221817+SHIKHAR-CHANDRA@users.noreply.github.com>
Date: Fri, 29 Oct 2021 10:46:26 +0530
Subject: [PATCH 0071/1552] Add Huffman Compression (#2753)
---
Others/Huffman.java | 135 ++++++++++++++++++++++++++++++++++++++++++++
1 file changed, 135 insertions(+)
create mode 100644 Others/Huffman.java
diff --git a/Others/Huffman.java b/Others/Huffman.java
new file mode 100644
index 000000000000..43366046bdd4
--- /dev/null
+++ b/Others/Huffman.java
@@ -0,0 +1,135 @@
+import java.util.PriorityQueue;
+import java.util.Scanner;
+import java.util.Comparator;
+
+// node class is the basic structure
+// of each node present in the Huffman - tree.
+class HuffmanNode {
+
+ int data;
+ char c;
+
+ HuffmanNode left;
+ HuffmanNode right;
+}
+
+// comparator class helps to compare the node
+// on the basis of one of its attribute.
+// Here we will be compared
+// on the basis of data values of the nodes.
+class MyComparator implements Comparator {
+ public int compare(HuffmanNode x, HuffmanNode y)
+ {
+
+ return x.data - y.data;
+ }
+}
+
+public class Huffman {
+
+ // recursive function to print the
+ // huffman-code through the tree traversal.
+ // Here s is the huffman - code generated.
+ public static void printCode(HuffmanNode root, String s)
+ {
+
+ // base case; if the left and right are null
+ // then its a leaf node and we print
+ // the code s generated by traversing the tree.
+ if (root.left
+ == null
+ && root.right
+ == null
+ && Character.isLetter(root.c)) {
+
+ // c is the character in the node
+ System.out.println(root.c + ":" + s);
+
+ return;
+ }
+
+ // if we go to left then add "0" to the code.
+ // if we go to the right add"1" to the code.
+
+ // recursive calls for left and
+ // right sub-tree of the generated tree.
+ printCode(root.left, s + "0");
+ printCode(root.right, s + "1");
+ }
+
+ // main function
+ public static void main(String[] args)
+ {
+
+ Scanner s = new Scanner(System.in);
+
+ // number of characters.
+ int n = 6;
+ char[] charArray = { 'a', 'b', 'c', 'd', 'e', 'f' };
+ int[] charfreq = { 5, 9, 12, 13, 16, 45 };
+
+ // creating a priority queue q.
+ // makes a min-priority queue(min-heap).
+ PriorityQueue q
+ = new PriorityQueue(n, new MyComparator());
+
+ for (int i = 0; i < n; i++) {
+
+ // creating a Huffman node object
+ // and add it to the priority queue.
+ HuffmanNode hn = new HuffmanNode();
+
+ hn.c = charArray[i];
+ hn.data = charfreq[i];
+
+ hn.left = null;
+ hn.right = null;
+
+ // add functions adds
+ // the huffman node to the queue.
+ q.add(hn);
+ }
+
+ // create a root node
+ HuffmanNode root = null;
+
+ // Here we will extract the two minimum value
+ // from the heap each time until
+ // its size reduces to 1, extract until
+ // all the nodes are extracted.
+ while (q.size() > 1) {
+
+ // first min extract.
+ HuffmanNode x = q.peek();
+ q.poll();
+
+ // second min extarct.
+ HuffmanNode y = q.peek();
+ q.poll();
+
+ // new node f which is equal
+ HuffmanNode f = new HuffmanNode();
+
+ // to the sum of the frequency of the two nodes
+ // assigning values to the f node.
+ f.data = x.data + y.data;
+ f.c = '-';
+
+ // first extracted node as left child.
+ f.left = x;
+
+ // second extracted node as the right child.
+ f.right = y;
+
+ // marking the f node as the root node.
+ root = f;
+
+ // add this node to the priority-queue.
+ q.add(f);
+ }
+
+ // print the codes by traversing the tree
+ printCode(root, "");
+ }
+}
+
From 794719c773645a2872ac7c6a3c5a4c17435d1fa4 Mon Sep 17 00:00:00 2001
From: Yang Libin