136 lines
4.3 KiB
Java
136 lines
4.3 KiB
Java
import java.util.ArrayList;
|
|
import java.util.List;
|
|
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) {
|
|
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 regex1 = "\\d{4}[-/](0[1-9]|1[0-2])[-/](0[1-9]|[12]\\d|3[01])";
|
|
String regex2 = "(0[1-9]|[12]\\d|3[01])/(0[1-9]|1[0-2])/\\d{4}";
|
|
|
|
Pattern pattern1 = Pattern.compile(regex1);
|
|
Pattern pattern2 = Pattern.compile(regex2);
|
|
Matcher matcher1 = pattern1.matcher(string);
|
|
Matcher matcher2 = pattern2.matcher(string);
|
|
|
|
if (matcher1.find()) {
|
|
return matcher1.group();
|
|
}
|
|
|
|
if (matcher2.find()) {
|
|
return matcher2.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) {
|
|
int count = 0;
|
|
String[] parts = string.split(" ");
|
|
|
|
for (String p : parts) {
|
|
if (p.length() < 8) {
|
|
continue;
|
|
}
|
|
boolean hasUpper = false;
|
|
boolean hasLower = false;
|
|
boolean hasNumber = false;
|
|
boolean hasSpecial = false;
|
|
boolean hasSpace = false;
|
|
|
|
for (int i = 0; i < p.length(); i++) {
|
|
char c = p.charAt(i);
|
|
if (Character.isUpperCase(c)) {
|
|
hasUpper = true;
|
|
}
|
|
else if (Character.isLowerCase(c)) {
|
|
hasLower = true;
|
|
}
|
|
else if (Character.isDigit(c)) {
|
|
hasNumber = true;
|
|
}
|
|
else if (Character.isWhitespace(c)) {
|
|
hasSpace = true;
|
|
}
|
|
else {
|
|
hasSpecial = true;
|
|
}
|
|
}
|
|
if (!hasSpace && hasUpper && hasLower && hasNumber && hasSpecial) {
|
|
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[] words = string.split(" ");
|
|
|
|
for (String w : words) {
|
|
String clean = w.replaceAll("[^A-Za-z]", "");
|
|
if (clean.length() >= 3) {
|
|
String lower = clean.toLowerCase() ;
|
|
String reversed = new StringBuilder(lower).reverse().toString();
|
|
if (lower.equals(reversed)) {
|
|
list.add(clean);
|
|
}
|
|
}
|
|
}
|
|
return list;
|
|
}
|
|
|
|
public static void main(String[] args) {
|
|
// you can test your code here
|
|
}
|
|
}
|