diff --git a/.idea/misc.xml b/.idea/misc.xml index d2b5d0f..bada8b5 100644 --- a/.idea/misc.xml +++ b/.idea/misc.xml @@ -8,7 +8,7 @@ - + \ No newline at end of file diff --git a/pom.xml b/pom.xml index d469778..c09efef 100644 --- a/pom.xml +++ b/pom.xml @@ -9,8 +9,8 @@ 1.0-SNAPSHOT - 25 - 25 + 21 + 21 UTF-8 @@ -21,6 +21,13 @@ 5.11.4 test + + + org.junit.platform + junit-platform-launcher + 1.11.4 + test + diff --git a/src/main/java/BonusExercises.java b/src/main/java/BonusExercises.java index d02a746..2e3679e 100644 --- a/src/main/java/BonusExercises.java +++ b/src/main/java/BonusExercises.java @@ -5,71 +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 = ""; // todo + String regex = "^[a-zA-Z0-9]+[a-zA-Z0-9._]*@[a-zA-Z0-9]+[a-zA-Z0-9-]*(\\.[a-zA-Z]+)+$"; 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) { - // todo + if (string == null) {return null;} + String regex = "\\b(\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])|\\d{4}/(0[1-9]|1[0-2])/(0[1-9]|[12][0-9]|3[01])|(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\\d{4})\\b"; + 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) { - // todo - return -1; + String regex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\\d)(?=.*[^A-Za-z0-9])\\S{8,}$"; + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(string); + String[] passwords = string.split(" "); + int count = 0; + for (String pass: passwords){ + if (pattern.matcher(pass).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 findPalindromes(String string) { List list = new ArrayList<>(); - // todo + String regex = "\\b[a-zA-Z]{3,}\\b"; + Pattern pattern = Pattern.compile(regex); + Matcher matcher = pattern.matcher(string); + while (matcher.find()) { + if (CheckPalindrome(matcher.group())) { + list.add(matcher.group()); + } + } return list; } + private boolean CheckPalindrome(String str) { + str = str.toLowerCase(); + int i = 0; + int j = str.length() - 1; + while (i < str.length() / 2 ) { + if (str.charAt(i) != str.charAt(j)) { + return false; + } + i++; + j--; + + } + return true; + } + public static void main(String[] args) { // you can test your code here } diff --git a/src/main/java/MainExercises.java b/src/main/java/MainExercises.java index 21581ea..ea9aeb9 100644 --- a/src/main/java/MainExercises.java +++ b/src/main/java/MainExercises.java @@ -1,98 +1,75 @@ +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; public class MainExercises { - /* - you should create a triangle with "*" and return a two-dimensional array of characters based on that - the triangle's area is empty, which means some characters should be " " - example 1, input = 3: - * - ** - *** - - example 2, input = 5: - * - ** - * * - * * - ***** - - the output has to be a two-dimensional array of characters, so don't just print the triangle! - */ public char[][] generateTriangle(int n) { - - // todo - return null; - + char[][] triangle = new char[n][]; + for (int i = 0; i < n; i++) { + triangle[i] = new char[ i+1 ]; + for (int j = 0; j <= i; j++) { + if(j == 0 || j == i || i == n - 1) { + triangle[i][j] = '*'; + } + else { + triangle[i][j] = ' '; + } + } + } + return triangle; } - - - /* - SPIRAL TRAVERSAL OF A RECTANGULAR MATRIX - - Given a rectangular matrix (2D array) of integers, this method traverses - it in a spiral order (clockwise from outside to inside) and returns - the elements as a 1D array. - - EXAMPLE: - Input matrix: - 1 2 3 - 4 5 6 - 7 8 9 - - Spiral order: start at top-left (1), go right →, then down ↓, - then left ←, then up ↑, then repeat inward. - - Result: {1, 2, 3, 6, 9, 8, 7, 4, 5} - - so you should walk in that matrix in a curl and then add the numbers in order you've seen them in a 1D array - - RECTANGULAR MATRIX ASSUMPTION: - This method assumes the input matrix is RECTANGULAR (all rows have - the same number of columns). In Java, we can verify this because - 2D arrays might be jagged (rows of different lengths). - - IMPORTANT: In Java, we do NOT need to pass rows and cols! - The 2D array 'matrix' knows its own dimensions: - - Number of rows: matrix.length - - Number of columns: matrix[0].length (if rectangular) - */ public int[] spiralTraversal(int[][] matrix) { - // todo - return null; + int[] result = new int[matrix.length * matrix[0].length]; + int index = 0; + while (matrix.length > 0) { + for (int i = 0; i < matrix[0].length; i++) { + result[index++] = matrix[0][i]; + } + matrix = rotateMatrix(matrix); + + } + return result; } - /* - integer partitioning is a combinatorics problem in discreet maths - the problem is to generate sum numbers which their summation is the input number + private int[][] rotateMatrix(int[][] matrix) { + int m = matrix.length; + int n = matrix[0].length; + int[][] newMatrix = new int[n][m -1]; + for (int i = 0; i < n; i++) { + for (int j = 1; j < m; j++) { + newMatrix[i][j -1] = matrix[j][n -1 -i]; + } + } + return newMatrix; + } - e.g. 1 -> all partitions of integer 3 are: - 3 - 2, 1 - 1, 1, 1 - - e.g. 2 -> for number 4 goes as: - 4 - 3, 1 - 2, 2 - 2, 1, 1 - 1, 1, 1, 1 - - Note: As you can see in the examples, we want to generate distinct partitions, - which means 1,2 and 2,1 are not different — they count as the same combination. - - You should generate all partitions of the input number. - - Hint: You can determine the size and order of the arrays by finding the pattern - of partitions and their count. Trust me, this one's fun and easy :) - - If you're familiar with Lists and ArrayLists, you can also edit the method's - body to use them instead of arrays. - */ public int[][] intPartitions(int n) { - // todo - return null; + List result = new ArrayList<>(); + int[] partition = new int[n]; + int length = 0; + partition[length] = n; + while (true) { + result.add(Arrays.copyOf(partition, length+1)); + int rem = 0; + while (length >= 0 && partition[length] == 1){ + rem += partition[length]; + length--; + } + if ( length < 0 ) break; + partition[length]--; + rem++; + while (rem > partition[length]) { + partition[length+1] = partition[length]; + rem -= partition[length]; + length++; + } + partition[length+1] = rem; + length++; + } + return result.toArray(new int[0][]); }