HW-02-git-and-java-practice/src/main/java/BonusExercises.java

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.regex.Matcher;
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) {
        if (email == null) return false;

        String regex =
                "^[A-Za-z0-9_+&*-]+(?:\\.[A-Za-z0-9_+&*-]+)*@" +
                        "(?:[A-Za-z0-9](?:[A-Za-z0-9-]*[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);

        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) {
        if (string == null) {
            return null;
        }

        Pattern pattern = Pattern.compile("\\b\\d{2,4}[/-]\\d{1,2}[/-]\\d{1,4}\\b");
        Matcher matcher = pattern.matcher(string);

        Map<String, DateTimeFormatter> formattersMap = new LinkedHashMap<>();

        formattersMap.put("yyyy-MM-dd", DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        formattersMap.put("yyyy/M/d", DateTimeFormatter.ofPattern("yyyy/M/d"));
        formattersMap.put("M/d/yyyy", DateTimeFormatter.ofPattern("M/d/yyyy"));
        formattersMap.put("d/M/yyyy", DateTimeFormatter.ofPattern("d/M/yyyy"));

        while (matcher.find()) {
            String candidate = matcher.group();
            for (Map.Entry<String, DateTimeFormatter> entry : formattersMap.entrySet()) {
                String patternStr = entry.getKey();
                DateTimeFormatter formatter = entry.getValue();

                try {
                    LocalDate.parse(candidate, formatter);
                    return candidate;

                } catch (DateTimeParseException ignored) {
                }
            }
        }
        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) {
        if(string == null || string.isEmpty()){
            return 0;
        }
        int validPasswordCount = 0;
        Pattern pattern = Pattern.compile("[A-Za-z0-9!@#$%^&*]+");
        Matcher matcher = pattern.matcher(string);

        while (matcher.find()){
            String candidate = matcher.group();
            if(isValidPassword(candidate)){
                validPasswordCount ++;
            }
        }

        return validPasswordCount;
    }

    public boolean isValidPassword(String password){
        if(password.length()<8){
            return false;
        }

        boolean hasUpperCase = false;
        boolean hasLowerCase = false;
        boolean hasDigit = false;
        boolean hasSpecialChar = false;
        String sepecialChras = "!@#$%^&*";

        for( char c : password.toCharArray()){
            if(Character.isUpperCase(c)){
                hasUpperCase = true;
            }
            else if(Character.isLowerCase(c)){
                hasLowerCase = true;
            }
            else if(Character.isDigit(c)){
                hasDigit = true;
            }
            else if(sepecialChras.indexOf(c) != -1){
                hasSpecialChar = true;
            }
            else if (Character.isSpaceChar(c)){
                return false;
            }
        }
        return hasUpperCase && hasLowerCase && hasDigit && hasSpecialChar;
    }

    /*
        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<>();

        if (string == null || string.isEmpty()) {
            return list;
        }

        String[] words = string.split("\\s+");

        for(String word : words){
            word = word.replaceAll("^[^a-zA-Z0-9]+|[^a-zA-Z0-9]+$" , "");

            if(word.length() >= 3 && isPalindrome(word)){
                list.add(word);
            }
        }
        return list;
    }

    private boolean isPalindrome(String word){
        String lower = word.toLowerCase();
        int left = 0 ,right = lower.length()-1;

        while(left < right) {
            if (lower.charAt(left) != lower.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }

    public static void main(String[] args) {
    }
}