From 608454c19c797df081706c7be43dabbc00cb7a0a Mon Sep 17 00:00:00 2001 From: hlin Date: Fri, 20 Mar 2020 19:03:12 -0400 Subject: [PATCH 1/3] First commit --- .../quiz4/fundamentals/Calculator.java | 25 ++++++--- .../quiz4/fundamentals/StringUtils.java | 54 ++++++++++++++++--- 2 files changed, 65 insertions(+), 14 deletions(-) diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java index 02f2618..ddecebd 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java @@ -1,35 +1,46 @@ package rocks.zipcode.quiz4.fundamentals; +import java.util.stream.Stream; + /** * @author leon on 21/12/2018. */ public class Calculator { public static Double squareRoot(Double value) { - return null; + return Math.sqrt(value); } public static Double square(Double value) { - return null; + return value * value; } public static Double[] squareRoots(Double... value) { - return null; + Double[] result = (Double[]) Stream.of(value) + .map(root -> { + double square = root * root; + return square; + }) + .toArray(); + return result; + } public static Double[] squares(Double... values) { - return null; + Double[] result = new Double[values.length]; + Stream.of(result).forEach(Calculator::square); + return result; } public static Double add(Double value1, Double value2) { - return null; + return value1 + value2; } public static Double subtract(Double value1, Double value2) { - return null; + return value1 - value2; } public static Double divide(Double divisor, Double dividend) { - return null; + return divisor / dividend; } } diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java index 5ec61be..7f20f36 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java @@ -1,34 +1,74 @@ package rocks.zipcode.quiz4.fundamentals; +import java.util.Arrays; +import java.util.HashSet; +import java.util.LinkedHashSet; +import java.util.Set; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + /** * @author leon on 21/12/2018. */ public class StringUtils { public static Character getMiddleCharacter(String string) { - return null; + return string.charAt(string.length() / 2); } public static String capitalizeMiddleCharacter(String str) { - return null; + StringBuffer result = new StringBuffer(str); + for (int i = 0; i < str.length(); i++) { + int mid = str.length() / 2; + result.setCharAt(mid, Character.toUpperCase(str.charAt(mid))); + } + return result.toString(); } public static String lowerCaseMiddleCharacter(String str) { - return null; + StringBuffer result = new StringBuffer(str); + for (int i = 0; i < str.length(); i++) { + int mid = str.length() / 2; + result.setCharAt(mid, Character.toLowerCase(str.charAt(mid))); + } + return result.toString(); } public static Boolean isIsogram(String str) { - return null; + int length = str.length(); + char[] arr = str.toCharArray(); + Arrays.sort(arr); + for (int i = 0; i < length - 1; i++) { + if (arr[i] == arr[i + 1]) return false; + } + return true; } public static Boolean hasDuplicateConsecutiveCharacters(String str) { - return null; + return (str.matches(".*(.)\\1.*")); } public static String removeConsecutiveDuplicateCharacters(String str) { - return null; + for (int i = 1; i < str.length(); i++) { + if (str.charAt(i) == str.charAt(i-1)) { + str = str.substring(0, i - 1) + str.substring(i + 1); + i = 0; + } + } + return str; } public static String invertCasing(String str) { - return null; + char[] array = str.toCharArray(); + + for (int i = 0; i < array.length; i++) { + char c = array[i]; + if (Character.isUpperCase(c)) { + array[i] = Character.toLowerCase(c); + } + else if (Character.isLowerCase(c)) { + array[i] = Character.toUpperCase(c); + } + } + return new String(array); } } \ No newline at end of file From a9ba830e932e4c2b63d238cdace911395e71d9d0 Mon Sep 17 00:00:00 2001 From: hlin Date: Fri, 20 Mar 2020 19:57:43 -0400 Subject: [PATCH 2/3] it will compile --- .../zipcode/quiz4/arrays/ArrayUtils.java | 18 ++++++-- .../quiz4/fundamentals/Calculator.java | 1 - .../quiz4/fundamentals/StringUtils.java | 22 +++++----- .../objectorientation/account/Account.java | 10 +++-- .../quiz4/objectorientation/account/Bank.java | 14 +++++- .../account/BankAccount.java | 22 +++++++++- .../objectorientation/account/Employee.java | 43 ++++++++++++++++++- 7 files changed, 105 insertions(+), 25 deletions(-) diff --git a/src/main/java/rocks/zipcode/quiz4/arrays/ArrayUtils.java b/src/main/java/rocks/zipcode/quiz4/arrays/ArrayUtils.java index 6deaf61..51f512b 100644 --- a/src/main/java/rocks/zipcode/quiz4/arrays/ArrayUtils.java +++ b/src/main/java/rocks/zipcode/quiz4/arrays/ArrayUtils.java @@ -1,22 +1,32 @@ package rocks.zipcode.quiz4.arrays; +import java.util.Arrays; + /** * @author leon on 01/01/2019. */ public class ArrayUtils { public static String getMiddleElement(String[] values) { - return null; + int mid = values.length / 2; + return values[mid]; } public static String[] removeMiddleElement(String[] values) { - return null; + int middleStart = (values.length - 1) / 2; + int middleEnd = (values.length - 1) - middleStart; + int elementsToRemove = middleEnd - middleStart + 1; + + String[] result = new String[values.length - elementsToRemove]; + System.arraycopy(values, 0, result, 0, middleStart); + System.arraycopy(values, middleEnd + 1, result, middleStart, middleStart); + return result; } public static String getLastElement(String[] values) { - return null; + return values[values.length - 1]; } public static String[] removeLastElement(String[] values) { - return null; + return Arrays.copyOf(values, values.length - 1); } } \ No newline at end of file diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java index ddecebd..aea664d 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java @@ -22,7 +22,6 @@ public static Double[] squareRoots(Double... value) { }) .toArray(); return result; - } public static Double[] squares(Double... values) { diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java index 7f20f36..d7806ca 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java @@ -1,9 +1,6 @@ package rocks.zipcode.quiz4.fundamentals; -import java.util.Arrays; -import java.util.HashSet; -import java.util.LinkedHashSet; -import java.util.Set; +import java.util.*; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -47,16 +44,21 @@ public static Boolean hasDuplicateConsecutiveCharacters(String str) { return (str.matches(".*(.)\\1.*")); } + public static String removeConsecutiveDuplicateCharacters(String str) { - for (int i = 1; i < str.length(); i++) { - if (str.charAt(i) == str.charAt(i-1)) { - str = str.substring(0, i - 1) + str.substring(i + 1); - i = 0; - } + ArrayList dups = new ArrayList<>(); + String result = ""; + for (int i = 0; i < str.length()-1; i++) { + if(str.charAt(i) == str.charAt(i+1)) dups.add(str.charAt(i)); } - return str; + for (int i = 0; i < str.length()-1; i++) { + if(!dups.contains(str.charAt(i))) result += str.charAt(i); + } + result += str.charAt(str.length()-1); + return result; } + public static String invertCasing(String str) { char[] array = str.toCharArray(); diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Account.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Account.java index 40eb4a8..6eb6920 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Account.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Account.java @@ -3,11 +3,13 @@ /** * @author leon on 30/12/2018. */ -public class Account extends BankAccount { +public class Account { + + private Long id; + public Long getId() { - return null; + return this.id; } - public void setId(Long id) { - } + public void setId(Long id) { this.id = id; } } diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Bank.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Bank.java index 0dd4183..ae54d1c 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Bank.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Bank.java @@ -1,17 +1,27 @@ package rocks.zipcode.quiz4.objectorientation.account; +import java.util.ArrayList; + /** * @author leon on 27/12/2018. */ public class Bank { + + private ArrayList bankAccounts; + + public Bank() { + this.bankAccounts = new ArrayList<>(); + } + public BankAccount removeBankAccountByIndex(Integer indexNumber) { - return null; + return bankAccounts.remove((int)indexNumber); } public void addBankAccount(BankAccount bankAccount) { + bankAccounts.add(bankAccount); } public Boolean containsBankAccount(BankAccount bankAccount) { - throw new UnsupportedOperationException("Method not yet implemented"); + return bankAccounts.contains(bankAccount); } } diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java index 70ccb74..49acad0 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java @@ -3,7 +3,25 @@ /** * @author leon on 27/12/2018. */ -public class BankAccount { - public void setBalance(Double val) { +public class BankAccount extends Account implements Transactable{ + + private Double balance; + + public void setBalance(Double val) { this.balance = val; + } + + @Override + public void deposit(Double amountToIncreaseBy) { + + } + + @Override + public void withdrawal(Double amountToDecreaseBy) { + + } + + @Override + public Double getBalance() { + return this.balance; } } diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java index 8407f1a..37c4f65 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java @@ -3,18 +3,57 @@ /** * @author leon on 30/12/2018. */ -public class Employee { +public class Employee implements Worker, Transactable{ + + private BankAccount bankAccount; + private Double balance; + public Employee() { + this.balance = 0.0; } public Employee(BankAccount bankAccount) { + this.bankAccount = bankAccount; } public BankAccount getBankAccount() { + return this.bankAccount; + } + + public void setBankAccount(BankAccount bankAccount) { this.bankAccount = bankAccount; } + + @Override + public void deposit(Double amountToIncreaseBy) { + + } + + @Override + public void withdrawal(Double amountToDecreaseBy) { + + } + + @Override + public Double getBalance() { + return this.balance; + } + + @Override + public void increaseHoursWorked(Double numberOfHours) { + + } + + @Override + public Double getHoursWorked() { return null; } - public void setBankAccount(BankAccount bankAccount) { + @Override + public Double getHourlyWage() { + return null; + } + @Override + public Double getMoneyEarned() { + return null; } } From 62e956dfe1005c2d850e880a7e6efe013b766318 Mon Sep 17 00:00:00 2001 From: hlin Date: Sun, 22 Mar 2020 10:23:57 -0400 Subject: [PATCH 3/3] Finish quiz --- .../quiz4/collections/WordCounter.java | 12 ++++++++- .../quiz4/collections/culonary/Curry.java | 8 +++++- .../quiz4/collections/culonary/Food.java | 18 +++++++++++-- .../quiz4/collections/culonary/Ginger.java | 6 ++++- .../quiz4/collections/culonary/Pepper.java | 6 ++++- .../quiz4/collections/culonary/Spice.java | 1 + .../quiz4/fundamentals/Calculator.java | 14 +++-------- .../quiz4/fundamentals/StringUtils.java | 3 +-- .../account/BankAccount.java | 13 +++++++++- .../objectorientation/account/Employee.java | 25 +++++++++++-------- 10 files changed, 76 insertions(+), 30 deletions(-) diff --git a/src/main/java/rocks/zipcode/quiz4/collections/WordCounter.java b/src/main/java/rocks/zipcode/quiz4/collections/WordCounter.java index 2bf5ec2..1ed0678 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/WordCounter.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/WordCounter.java @@ -1,12 +1,22 @@ package rocks.zipcode.quiz4.collections; +import java.util.HashMap; import java.util.Map; public class WordCounter { + + String[] stringArray; + public WordCounter(String... strings) { + this.stringArray = strings; } public Map getWordCountMap() { - return null; + + Map map = new HashMap<>(); + for (String s : stringArray) { + map.compute(s, (k, v) -> (v == null) ? 1 : v+1); + } + return map; } } diff --git a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Curry.java b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Curry.java index 199cefc..fe81a16 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Curry.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Curry.java @@ -1,4 +1,10 @@ package rocks.zipcode.quiz4.collections.culonary; -public class Curry { +public class Curry implements Spice{ + + + @Override + public String getName() { + return "Curry"; + } } diff --git a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Food.java b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Food.java index e06abbc..a2b9d73 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Food.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Food.java @@ -1,5 +1,7 @@ package rocks.zipcode.quiz4.collections.culonary; +import java.util.ArrayList; +import java.util.HashMap; import java.util.List; import java.util.Map; @@ -7,14 +9,26 @@ * @author leon on 27/12/2018. */ public class Food { + + private List spices; + + public Food() { + this.spices = new ArrayList<>(); + } + public List getAllSpices() { - return null; + return this.spices; } public > Map getSpiceCount() { - return null; + Map map = new HashMap<>(); + for (Spice s : spices) { + map.compute((SpiceType) s.getClass(), (k, v) -> (v == null) ? 1 : v + 1); + } + return map; } public void applySpice(Spice spice) { + this.spices.add(spice); } } diff --git a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Ginger.java b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Ginger.java index 3c4e177..dca09ca 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Ginger.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Ginger.java @@ -3,5 +3,9 @@ /** * @author leon on 27/12/2018. */ -public class Ginger { +public class Ginger implements Spice { + @Override + public String getName() { + return "Ginger"; + } } diff --git a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Pepper.java b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Pepper.java index 4b771a8..d943f44 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Pepper.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Pepper.java @@ -3,5 +3,9 @@ /** * @author leon on 27/12/2018. */ -public class Pepper { +public class Pepper implements Spice { + @Override + public String getName() { + return "Pepper"; + } } diff --git a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Spice.java b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Spice.java index 9ab865b..ed6e324 100644 --- a/src/main/java/rocks/zipcode/quiz4/collections/culonary/Spice.java +++ b/src/main/java/rocks/zipcode/quiz4/collections/culonary/Spice.java @@ -4,4 +4,5 @@ * @author leon on 27/12/2018. */ public interface Spice { + public String getName(); } diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java index aea664d..92ac66d 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/Calculator.java @@ -1,6 +1,6 @@ package rocks.zipcode.quiz4.fundamentals; -import java.util.stream.Stream; +import java.util.Arrays; /** * @author leon on 21/12/2018. @@ -15,19 +15,11 @@ public static Double square(Double value) { } public static Double[] squareRoots(Double... value) { - Double[] result = (Double[]) Stream.of(value) - .map(root -> { - double square = root * root; - return square; - }) - .toArray(); - return result; + return Arrays.asList(value).stream().map(v -> squareRoot(v)).toArray(Double[]::new); } public static Double[] squares(Double... values) { - Double[] result = new Double[values.length]; - Stream.of(result).forEach(Calculator::square); - return result; + return Arrays.asList(values).stream().map(v -> square(v)).toArray(Double[]::new); } public static Double add(Double value1, Double value2) { diff --git a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java index d7806ca..f92c538 100644 --- a/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java +++ b/src/main/java/rocks/zipcode/quiz4/fundamentals/StringUtils.java @@ -1,8 +1,7 @@ package rocks.zipcode.quiz4.fundamentals; import java.util.*; -import java.util.regex.Matcher; -import java.util.regex.Pattern; + /** * @author leon on 21/12/2018. diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java index 49acad0..1f2be7e 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/BankAccount.java @@ -7,17 +7,28 @@ public class BankAccount extends Account implements Transactable{ private Double balance; + public BankAccount() { balance = 0.0; } + public void setBalance(Double val) { this.balance = val; } @Override public void deposit(Double amountToIncreaseBy) { + if (amountToIncreaseBy < 0.0){ + throw new IllegalArgumentException("Cannot deposit negative number!"); + } else { + balance += amountToIncreaseBy; + } } @Override public void withdrawal(Double amountToDecreaseBy) { - + if (amountToDecreaseBy > 0 && this.balance >= amountToDecreaseBy) { + this.balance -= amountToDecreaseBy; + } else { + throw new IllegalArgumentException("Cannot process transaction"); + } } @Override diff --git a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java index 37c4f65..85708af 100644 --- a/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java +++ b/src/main/java/rocks/zipcode/quiz4/objectorientation/account/Employee.java @@ -6,54 +6,59 @@ public class Employee implements Worker, Transactable{ private BankAccount bankAccount; - private Double balance; + private Double hoursWorked; + private Double hourlyWage; public Employee() { - this.balance = 0.0; + bankAccount = new BankAccount(); + this.hourlyWage = 35.0; + this.hoursWorked = 0.0; } public Employee(BankAccount bankAccount) { this.bankAccount = bankAccount; + this.hourlyWage = 35.0; + this.hoursWorked = 0.0; } public BankAccount getBankAccount() { - return this.bankAccount; + return bankAccount; } public void setBankAccount(BankAccount bankAccount) { this.bankAccount = bankAccount; } @Override public void deposit(Double amountToIncreaseBy) { - + this.bankAccount.deposit(amountToIncreaseBy); } @Override public void withdrawal(Double amountToDecreaseBy) { - + bankAccount.withdrawal(amountToDecreaseBy); } @Override public Double getBalance() { - return this.balance; + return bankAccount.getBalance(); } @Override public void increaseHoursWorked(Double numberOfHours) { - + this.hoursWorked += numberOfHours; } @Override public Double getHoursWorked() { - return null; + return this.hoursWorked; } @Override public Double getHourlyWage() { - return null; + return this.hourlyWage; } @Override public Double getMoneyEarned() { - return null; + return this.hoursWorked * this.hourlyWage; } }