implement intPartitions method in MainExercises

src/main/java/BonusExercises.java

@@ -5,84 +5,68 @@ import java.util.regex.Pattern;
 
 public class BonusExercises {
 
+    /*
+        complete the method below, so it will validate an email address
+        1. Must have exactly one @ (no more, no less)
+        2. Split into local-part and domain (before @ and after @)
+        3. Local-part rules:
+            - Can't be empty
+            - Can't start or end with dot
+            - Can't have two dots in a row
+        4. Domain rules:
+            - Can't be empty
+            - Can't start or end with hyphen
+            - Can't have underscores
+            - Each segment (between dots) must follow same hyphen rules
+     */
     public boolean validateEmail(String email) {
-        String regex = "^(?!\\.)(?!.*\\.\\..*)([0-9A-Za-z._]+)(?<!\\.)@(?!-)([0-9A-Za-z.\\-]+)(?<!-)$";
+        String regex = ""; // todo
-
         Pattern pattern = Pattern.compile(regex);
         Matcher matcher = pattern.matcher(email);
 
         return matcher.matches();
     }
 
+    /*
+        This method should find and return the first date in a string.
 
+        Supported formats:
+        - American:   MM/DD/YYYY   (e.g., 12/09/2023)
+        - British:    DD/MM/YYYY   (e.g., 12/09/2023 — same pattern, context matters)
+        - ISO:        YYYY-MM-DD   (e.g., 2024-07-15)
+        - Slash variant: YYYY/MM/DD (e.g., 2025/01/01)
+
+        If no match for a date is found in the string, return null.
+    */
     public String findDate(String string) {
-        String regex = "(\\b((1[0-2])|(0[1-9]))\\b/\\b((0[1-9])|([12][0-9])|(3[01]))\\b/\\b(\\d{4})\\b)|(\\b((0[1-9])|([12][0-9])|(3[01]))\\b/\\b((1[0-2])|(0[1-9]))\\b/\\b(\\d{4})\\b)|(\\b(\\d{4})\\b-\\b((1[0-2])|(0[1-9]))\\b-\\b((0[1-9])|([12][0-9])|(3[01]))\\b)|(\\b(\\d{4})\\b/\\b((1[0-2])|(0[1-9]))\\b/\\b((0[1-9])|([12][0-9])|(3[01]))\\b)";
+        // todo
-
-        Pattern pattern = Pattern.compile(regex);
-        Matcher matcher = pattern.matcher(string);
-
-        if (matcher.find()) {
-            return matcher.group();
-        }
-
         return null;
     }
 
+    /*
+        given a string, implement the method to detect all valid passwords
+        then, it should return the count of them
 
+        a valid password has the following properties:
+        - at least 8 characters
+        - has to include at least one uppercase letter, and at least a lowercase
+        - at least one number and at least a special char "!@#$%^&*"
+        - has no white-space in it
+     */
     public int findValidPasswords(String string) {
-        String passwordRegex = "(?=.*[A-Z])(?=.*[a-z])(?=.*\\d)(?=.*\\W).{8,}";
+        // todo
-        String tokenRegex = "(?<!\\S)[A-Za-z0-9!@#$%^&*_]{8,}(?!\\S)";
+        return -1;
-
-        Pattern tokenPattern = Pattern.compile(tokenRegex);
-        Pattern passwordPattern = Pattern.compile(passwordRegex);
-        Matcher matcher = tokenPattern.matcher(string);
-
-        int count = 0;
-        while (matcher.find()) {
-            String token = matcher.group();
-
-            Matcher passwordMatcher = passwordPattern.matcher(token);
-            if (passwordMatcher.matches()){
-                count++;
-            }
     }
 
-        return count;
+    /*
-    }
+        you should return a list of *words* which are palindromic
+        by word we mean at least 3 letters with no whitespace in it
 
+        note: your implementation should be case-insensitive, e.g. Aba -> is palindrome
+     */
     public List<String> findPalindromes(String string) {
         List<String> list = new ArrayList<>();
-        String[] inputList = string.split("\\W+");
+        // todo
-
-        for (String word : inputList)
-        {
-            String regex = "";
-            int wordLength = word.length();
-
-            if (wordLength < 3) continue;
-
-            for (int i = 0; i < wordLength/2; i++) {
-                regex += "(.)";
-            }
-
-            if (wordLength % 2 != 0)
-            {
-                regex += ".";
-            }
-
-            for (int i = wordLength/2; i > 0; i--) {
-                regex += "\\" + i;
-            }
-
-            Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
-            Matcher matcher = pattern.matcher(word);
-
-            if (matcher.matches())
-            {
-                list.add(word);
-            }
-        }
-
         return list;
     }
 

src/main/java/MainExercises.java

@@ -8,28 +8,23 @@ public class MainExercises
         
         for (int i = 0; i < n; i++)
         {
-            char[] line = new char[i+1];
+            result[i] = new char[i+1];
-
+            if (i == n-1)
-            if (i == n-1 || i == 0)
             {
                 for (int j = 0; j <= i; j++)
                 {
-                    line[j] = '*';
+                    result[i][j] = '*';
                 }
             }
             else 
             {
-                line[0] = '*';
+                result[i][0] = '*';
-                line[i] = '*';
+                result[i][i] = '*';
 
-                for (int j = i - 1; j > 0; j--) {
+                for (int j = 1; j < i; j++) result[i][j] = ' ';
-                    line[j] = ' ';
             }
         }
 
-            result[i] = line;
-        }
-
         return result;
     }
 
@@ -69,37 +64,61 @@ public class MainExercises
     }
 
     public int[][] intPartitions(int n) {
-        ArrayList<int[]> result = new ArrayList<>();
+        int[][] result;
-        ArrayList<Integer> curPartition = new ArrayList<>();
+        ArrayList<ArrayList<Integer>> mainArray = new ArrayList<>();
 
-        fillPartition(n, n, curPartition, result);
+        ArrayList<Integer> start = new ArrayList<>();
+        start.add(n);
+        mainArray.add(start);
         
-        return result.toArray(new int[result.size()][]);
+        while (true) { 
+            ArrayList<Integer> latestArray = mainArray.get(mainArray.size() - 1);
+
+            Integer numberOfInterest = 0;
+            for (Integer number : latestArray)
+            {
+                if (number > 1) {
+                    numberOfInterest = number;
+                    break;
+                }
             }   
 
-    private void fillPartition(int max, int remaining, ArrayList<Integer> curPartition, ArrayList<int[]> result) {
+            if (numberOfInterest == 0) break;
-        if (remaining == 0) {
-            int size = curPartition.size();
-            int[] savingArr = new int[size];
 
-            for (int i = 0; i < size; i++) {
+            numberOfInterest--;
-                savingArr[i] = curPartition.get(i);
+            Integer remain = n - numberOfInterest;
+            ArrayList<Integer> newArray = new ArrayList<>();
+            newArray.add(numberOfInterest);
+
+            for (Integer number = numberOfInterest;;) {
+                if (number >= remain) {
+                    newArray.add(remain);
+                    break;
+                }
+                else {
+                    newArray.add(number);
+                    remain -= number;
+                }
             }
 
-            result.add(savingArr);
+            mainArray.add(newArray);
-            return;
         }
 
-        for (int i = Math.min(max, remaining); i >= 1; i--) {
+        result = new int[mainArray.size()][];
-            curPartition.add(i);
-            int newRemaining = remaining - i;
 
-            fillPartition(i, newRemaining, curPartition, result);
+        for (int i = 0; i < mainArray.size(); i++) {
+            ArrayList<Integer> array = mainArray.get(i);
 
-            curPartition.removeLast();
+            result[i] = new int[array.size()];
+
+            for (int j = 0; j < array.size(); j++) {
+                result[i][j] = array.get(j);
             }
         }
 
+        return result;
+    }
+
 
     public static void main()
     {