Change algorithm of intPartitions method (recursive solution)

src/main/java/BonusExercises.java

@@ -20,7 +20,7 @@ public class BonusExercises {
             - Each segment (between dots) must follow same hyphen rules
      */
     public boolean validateEmail(String email) {
-        String regex = "^[a-zA-z0-9_+-]+(?:\\.[a-zA-Z0-9_+-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z0-9-]+$"; // todo
+        String regex = "^[a-zA-z0-9_+-]+(?:\\.[a-zA-Z0-9_+-]+)*@(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z0-9-]+$";
         Pattern pattern = Pattern.compile(regex);
         Matcher matcher = pattern.matcher(email);
 
@@ -39,7 +39,15 @@ public class BonusExercises {
         If no match for a date is found in the string, return null.
     */
     public String findDate(String string) {
-        // todo
+        String regex1 = "(0[1-9]|1[0-2])\\/(0[1-9]|[12][0-9]|30)\\/\\d{4}|(0[1-9]|[12][0-9]|30)\\/(0[1-9]|1[0-2])\\/\\d{4}";
+        String regex2 = "(\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|30))";
+        String regex3 = "(\\d{4}\\/(0[1-9]|1[0-2])\\/(0[1-9]|[12][0-9]|30))";
+        Pattern pattern = Pattern.compile(regex1 + "|" + regex2 + "|" + regex3);
+        Matcher matcher = pattern.matcher(string);
+
+        if(matcher.find()){
+            return matcher.group();
+        }
         return null;
     }
 
@@ -54,8 +62,18 @@ public class BonusExercises {
         - has no white-space in it
      */
     public int findValidPasswords(String string) {
-        // todo
-        return -1;
+        String regex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[!@#$%^&*]).{8,}$";
+        Pattern pattern = Pattern.compile(regex);
+
+        String[] parts = string.split("\\s+");
+        int counter = 0;
+        for(String part : parts){
+            Matcher matcher = pattern.matcher(part);
+            if(matcher.matches()){
+                counter++;
+            }
+        }
+        return counter;
     }
 
     /*
@@ -66,10 +84,32 @@ public class BonusExercises {
      */
     public List<String> findPalindromes(String string) {
         List<String> list = new ArrayList<>();
-        // todo
+
+        String[] words = string.split("\\s+|,");
+        for(String word : words){
+            if(word.length() >= 3 && isPalindrome(word)){
+                list.add(word);
+            }
+        }
+
         return list;
     }
 
+    private boolean isPalindrome(String string){
+        boolean result = true;
+        int counter = 0;
+        while(counter + 1 <= string.length() / 2){
+            char ch1 = string.charAt(counter);
+            char ch2 = string.charAt(string.length() - 1 - counter);
+            if(Character.toLowerCase(ch1) != Character.toLowerCase(ch2)){
+                result = false;
+                break;
+            }
+            counter++;
+        }
+        return result;
+    }
+
     public static void main(String[] args) {
         // you can test your code here
     }

src/main/java/MainExercises.java

@@ -1,4 +1,5 @@
 import java.util.ArrayList;
+import java.util.List;
 
 public class MainExercises
 {
@@ -150,64 +151,39 @@ public class MainExercises
 
     public int[][] intPartitions(int n) {
 
-        if(n == 1){
-            return new int[][]{{1}};
-        }
+        List<List<Integer>> allPartitions = new ArrayList<>();
+        ArrayList<Integer> current = new ArrayList<>();
+        generatePartition(n, n, current, allPartitions);
 
-        ArrayList<int[]> result = new ArrayList<>();
-        int[] current = new int[n]; // current partition, to be built
-
-        // we use stack arrays to have the situation saved.
-        int[] remainingStack = new int[n*n]; // remaining value, to be added
-//        int[] maxValueStack = new int[n*n]; // maximum number we can use, to prevent repeating partitions
-        int[] nextTryStack = new int[n*n]; // the next number we try
-        int[] lenStack = new int[n*n]; // length of current partition, gives us the next index in current
-        int head = 0; // works like a pointer, it makes stack arrays make sense.
-
-        remainingStack[0] = n;
-//        maxValueStack[0] = n;
-        nextTryStack[0] = n;
-        lenStack[0] = 0;
-
-        while(head >= 0){
-            int remaining = remainingStack[head];
-//            int maxValue = maxValueStack[head];
-            int nextTry = nextTryStack[head];
-            int partitionLen = lenStack[head];
-
-            if(remaining == 0){ // partition has been completed
-                //
-                int[] partition = new int[partitionLen];
-                System.arraycopy(current, 0, partition, 0, partitionLen);
-                result.add(partition);
-                head--;
-                continue;
+        // converting ArrayList of ArrayLists into a 2d array
+        int[][] result = new int[allPartitions.size()][];
+        for (int i = 0; i < allPartitions.size(); i++) {
+            List<Integer> sublist = allPartitions.get(i);
+            result[i] = new int[sublist.size()];
+            for (int j = 0; j < sublist.size(); j++) {
+                result[i][j] = sublist.get(j);
             }
-
-            if(nextTry <= 0){ // no choices left
-                head--;
-                continue;
-            }
-
-            int chosen = nextTry;
-            nextTryStack[head] = chosen - 1; // next value to be tried
-            current[partitionLen] = chosen; // adding selected number
-
-            // generating next number for the partition
-            head++;
-            remainingStack[head] = remaining - chosen;
-//            maxValueStack[head] = chosen;
-            nextTryStack[head] = Math.min(chosen, remaining - chosen);
-            lenStack[head] = partitionLen + 1;
-
         }
         
-        int[][] output = new int[result.size()][];
-        for(int i = 0; i < result.size(); i++){
-            output[i] = result.get(i);
+        return result;
+
+    }
+
+    private void generatePartition(int remaining, int maxValue, List<Integer> currentPartition, List<List<Integer>> allPartitions){
+        if(remaining == 0){
+            allPartitions.add(new ArrayList<>(currentPartition));
+            return ;
         }
 
-        return output;
+        for (int i = Math.min(maxValue, remaining); i >= 1; i--){ // preventing choosing the bigger number between maxValue and remaining, this way repeating partitions
+            currentPartition.add(i);
+            generatePartition(remaining - i, i, currentPartition, allPartitions);
+
+            currentPartition.removeLast(); /*
+                                                after the recursive call returns. we need to undo adding i.
+                                                this way we can try adding i again. ( remaining may not be 0 yet)
+                                            */
+        }
 
     }