hw3, Daria Suvorova

src/main/java/edu/hw3/Task1.java

@@ -0,0 +1,29 @@
+package edu.hw3;
+
+public class Task1 {
+
+    private Task1() {
+    }
+
+    static final char UPPER_A = 'A';
+    static final char UPPER_Z = 'Z';
+
+    static final char LOWER_A = 'a';
+    static final char LOWER_Z = 'z';
+
+    public static String atbash(String string) {
+        int n = string.length();
+        StringBuilder answer = new StringBuilder();
+        for (int i = 0; i < n; i++) {
+            char currentChar = string.charAt(i);
+            if (currentChar >= UPPER_A && currentChar <= UPPER_Z) {
+                currentChar = (char) (UPPER_Z - (currentChar - UPPER_A));
+            } else if (currentChar >= LOWER_A && currentChar <= LOWER_Z) {
+                currentChar = (char) (LOWER_Z - (currentChar - LOWER_A));
+            }
+            answer.append(currentChar);
+        }
+        return answer.toString();
+    }
+
+}

src/main/java/edu/hw3/Task2.java

@@ -0,0 +1,29 @@
+package edu.hw3;
+
+import java.util.ArrayList;
+
+class Task2 {
+
+    private Task2() {}
+
+    static public ArrayList<String> clusterize(String string) {
+        ArrayList<String> answer = new ArrayList<>();
+        int currentOpenBrackets = 0;
+        int lastUsedIndex = 0;
+        for (int i = 0; i < string.length(); i++) {
+            if (string.charAt(i) == '(') {
+                currentOpenBrackets++;
+            } else if (string.charAt(i) == ')') {
+                currentOpenBrackets--;
+            }
+
+            if (currentOpenBrackets == 0) {
+                answer.add(string.substring(lastUsedIndex, i + 1));
+                lastUsedIndex = i + 1;
+            }
+        }
+
+        return answer;
+    }
+
+}

src/main/java/edu/hw3/Task3.java

@@ -0,0 +1,22 @@
+package edu.hw3;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+class Task3 {
+    private Task3() {}
+
+    public static <T> HashMap<T, Integer> freqDict(ArrayList<T> arrayList) {
+        HashMap<T, Integer> answer = new HashMap<>();
+        for (T elem : arrayList) {
+            if (answer.containsKey(elem)) {
+                answer.put(elem, answer.get(elem) + 1);
+            } else {
+                answer.put(elem, 1);
+            }
+        }
+        return answer;
+
+    }
+
+}

src/main/java/edu/hw3/Task4.java

@@ -0,0 +1,25 @@
+package edu.hw3;
+
+public class Task4 {
+
+    private Task4() {}
+
+    private final static String[] ROMAN_NUMBERS =
+        {"M", "CM", "D", "CD", "C", "XC", "L", "XL", "X", "IX", "V", "IV", "I"};
+    private final static int[] DECIMAL_NUMBERS = {1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1};
+
+    public static String convertToRoman(int number) {
+        var answer = new StringBuilder();
+        int remaining = number;
+        for (int i = 0; i < ROMAN_NUMBERS.length; i++) {
+            int decimalNumber = DECIMAL_NUMBERS[i];
+            String romanNumber = ROMAN_NUMBERS[i];
+            while (remaining >= decimalNumber) {
+                answer.append(romanNumber);
+                remaining -= decimalNumber;
+            }
+        }
+        return answer.toString();
+    }
+
+}

src/main/java/edu/hw3/task5/Contact.java

@@ -0,0 +1,41 @@
+package edu.hw3.task5;
+
+import java.util.Objects;
+
+public class Contact {
+
+    String name;
+    String surname;
+
+    public Contact(String name) {
+        String[] splittedName = name.split(" ");
+        if (splittedName.length > 0) {
+            this.name = splittedName[0];
+            if (splittedName.length == 2) {
+                this.surname = splittedName[1];
+            }
+        }
+    }
+
+    @Override
+    public String toString() {
+        return name + " " + surname;
+    }
+
+    @Override public boolean equals(Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (o == null || getClass() != o.getClass()) {
+            return false;
+        }
+        Contact contact = (Contact) o;
+        return Objects.equals(name, contact.name) && Objects.equals(surname, contact.surname);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, surname);
+    }
+}
+

src/main/java/edu/hw3/task5/ContactComparator.java

@@ -0,0 +1,27 @@
+package edu.hw3.task5;
+
+import java.util.Comparator;
+
+class ContactComparator implements Comparator<Contact> {
+
+    public int result(int value) {
+        return value;
+    }
+
+    public int compare(Contact a, Contact b) {
+        String aCompare;
+        String bCompare;
+        if (a.surname != null) {
+            aCompare = a.surname;
+        } else {
+            aCompare = a.name;
+        }
+        if (b.surname != null) {
+            bCompare = b.surname;
+        } else {
+            bCompare = b.name;
+        }
+        return result(aCompare.compareTo(bCompare));
+
+    }
+}

src/main/java/edu/hw3/task5/ContactComparatorDesc.java

@@ -0,0 +1,10 @@
+package edu.hw3.task5;
+
+class ContactComparatorDesc extends ContactComparator {
+
+    @Override
+    public int result(int value) {
+        return -1 * value;
+    }
+
+}

src/main/java/edu/hw3/task5/ParseContacts.java

@@ -0,0 +1,26 @@
+package edu.hw3.task5;
+
+import java.util.Objects;
+import static java.util.Arrays.sort;
+
+public class ParseContacts {
+
+    private ParseContacts() {
+    }
+
+    public static Contact[] parseContacts(String[] names, String order) {
+        int n = names.length;
+        Contact[] answer = new Contact[n];
+        for (int i = 0; i < n; i++) {
+            answer[i] = new Contact(names[i]);
+        }
+
+        if (Objects.equals(order, "ASC")) {
+            sort(answer, new ContactComparator());
+        } else {
+            sort(answer, new ContactComparatorDesc());
+        }
+        return answer;
+    }
+
+}

src/main/java/edu/hw3/task6/Stock.java

@@ -0,0 +1,11 @@
+package edu.hw3.task6;
+
+public class Stock {
+
+    int value;
+
+    public Stock(int value) {
+        this.value = value;
+    }
+
+}

src/main/java/edu/hw3/task6/StockComparator.java

@@ -0,0 +1,11 @@
+package edu.hw3.task6;
+
+import java.util.Comparator;
+
+public class StockComparator implements Comparator<Stock> {
+
+    @Override
+    public int compare(Stock s1, Stock s2) {
+        return -Integer.compare(s1.value, s2.value);
+    }
+}

src/main/java/edu/hw3/task6/StockMarket.java

@@ -0,0 +1,24 @@
+package edu.hw3.task6;
+
+import java.util.PriorityQueue;
+
+public class StockMarket {
+
+    public StockMarket() {
+    }
+
+    PriorityQueue<Stock> stockQueue = new PriorityQueue<>(new StockComparator());
+
+    public void add(Stock stock) {
+        stockQueue.add(stock);
+    }
+
+    public void remove(Stock stock) {
+        stockQueue.remove(stock);
+    }
+
+    public Stock mostValuableStock() {
+        return stockQueue.peek();
+    }
+
+}

src/main/java/edu/hw3/task7/MyComparator.java

@@ -0,0 +1,23 @@
+package edu.hw3.task7;
+
+import java.util.Comparator;
+
+public class MyComparator<T extends Comparable> implements Comparator<T> {
+
+    public MyComparator() {
+    }
+
+    @Override
+    public int compare(T o1, T o2) {
+        if (o1 == null && o2 == null) {
+            return 0;
+        }
+
+        if (o1 == null || o2 == null) {
+            return -1;
+        }
+
+        return o1.compareTo(o2);
+    }
+
+}

src/main/java/edu/hw3/task8/BackwardIterator.java

@@ -0,0 +1,32 @@
+package edu.hw3.task8;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+
+public class BackwardIterator<E> implements Iterator<E> {
+
+    int cursor;
+    E[] myCollection;
+
+    public BackwardIterator(Collection<E> collection) {
+        this.cursor = collection.size();
+        this.myCollection = (E[]) collection.toArray();
+    }
+
+    @Override
+    public boolean hasNext() {
+        return cursor != 0;
+
+    }
+
+    @Override
+    public E next() {
+        if (hasNext()) {
+            cursor--;
+            return myCollection[cursor];
+        }
+        throw new NoSuchElementException();
+    }
+}
+

src/test/java/edu/hw3/Task1Test.java

@@ -0,0 +1,50 @@
+package edu.hw3;
+
+import org.junit.jupiter.api.Test;
+import static edu.hw3.Task1.atbash;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+public class Task1Test {
+
+    @Test
+    void atbashSmallLettersTest() {
+        assertEquals("svooldliow", atbash("helloworld"));
+        assertEquals("vmerilmnvmg", atbash("environment"));
+        assertEquals("qzez", atbash("java"));
+        assertEquals("sld ziv blf", atbash("how are you"));
+    }
+
+    @Test
+    void atbashCapitalLettersTest() {
+        assertEquals("TLLWNLIMRMT", atbash("GOODMORNING"));
+        assertEquals("XBKIFH", atbash("CYPRUS"));
+        assertEquals("VMTRMVVIRMT", atbash("ENGINEERING"));
+    }
+
+    @Test
+    void atbashNotLettersTest() {
+        assertEquals("1234)&)%_#+)(&(", atbash("1234)&)%_#+)(&("));
+        assertEquals("   ", atbash("   "));
+        assertEquals("", atbash(""));
+    }
+
+    @Test
+    void atbashMixedTest() {
+        assertEquals("Hello world!", atbash("Svool dliow!"));
+        assertEquals(
+            "Any fool can write code that a computer can understand. Good programmers " +
+                "write code that humans can understand. ― Martin Fowler",
+            atbash(
+                "Zmb ullo xzm dirgv xlwv gszg z xlnkfgvi xzm fmwvihgzmw. Tllw kiltiznnvih dirgv " +
+                    "xlwv gszg sfnzmh xzm fmwvihgzmw. ― Nzigrm Uldovi")
+        );
+        assertEquals(
+            "Olivn rkhfn wloli hrg znvg, xlmhvxgvgfi zwrkrhxrmt vorg, hvw wl vrfhnlw gvnkli rmxrwrwfmg " +
+                "fg ozyliv vg wloliv nztmz zorjfz.",
+            atbash(
+                "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt " +
+                    "ut labore et dolore magna aliqua.")
+        );
+
+    }
+}