Омельченко Никита ПрИ-201. Модуль 10

task01/src/com/example/task01/Task01Main.java

@@ -23,7 +23,11 @@ public static <T, U> Function<T, U> ternaryOperator(
             Function<? super T, ? extends U> ifTrue,
             Function<? super T, ? extends U> ifFalse) {
 
-        return null; // your implementation here
+        // Проверка на null аргументы
+        if (condition == null || ifTrue == null || ifFalse == null) {
+            throw new NullPointerException("All arguments must be non-null");
+        }
 
+        return t -> condition.test(t) ? ifTrue.apply(t) : ifFalse.apply(t);
     }
 }

task02/src/com/example/task02/Task02Main.java

@@ -5,19 +5,33 @@
 public class Task02Main {
 
     public static void main(String[] args) {
-
         /*
         cycleGrayCode(2)
                 .limit(10)
                 .forEach(System.out::println);
         */
-
     }
 
     public static IntStream cycleGrayCode(int n) {
-
-        return null; // your implementation here
-
+        // Проверка корректности входного параметра
+        if (n < 1 || n > 16) {
+            throw new IllegalArgumentException("n must be between 1 and 16");
+        }
+
+        // Вычисляем количество кодов Грея для n бит
+        int totalCodes = 1 << n; // 2^n
+
+        // Создаем массив для хранения всех кодов Грея
+        int[] grayCodes = new int[totalCodes];
+
+        // Заполняем массив кодами Грея
+        for (int i = 0; i < totalCodes; i++) {
+            // Формула преобразования двоичного числа в код Грея
+            grayCodes[i] = i ^ (i >> 1);
+        }
+
+        // Создаем бесконечный циклический поток
+        return IntStream.iterate(0, i -> (i + 1) % totalCodes)
+                .map(i -> grayCodes[i]);
     }
-
-}
+}

task03/src/com/example/task03/Task03Main.java

@@ -7,21 +7,79 @@
 public class Task03Main {
 
     public static void main(String[] args) {
-
         findMinMax(
                 Stream.of(2, 9, 5, 4, 8, 1, 3),
                 Integer::compareTo,
-                (min, max) ->
-                        System.out.println("min: " + min + " / max: " + max)
+                (min, max) -> System.out.println("min: " + min + " / max: " + max)
         );
-
     }
 
     public static <T> void findMinMax(
             Stream<? extends T> stream,
             Comparator<? super T> order,
             BiConsumer<? super T, ? super T> minMaxConsumer) {
 
-        // your implementation here
+        // Проверка на null аргументы
+        if (stream == null || order == null || minMaxConsumer == null) {
+            throw new NullPointerException("All arguments must be non-null");
+        }
+
+        // Внутренний класс для хранения пары min/max
+        class MinMaxHolder {
+            T min;
+            T max;
+            boolean hasElements = false;
+
+            // Метод для обновления min/max при обработке нового элемента
+            void update(T element) {
+                if (!hasElements) {
+                    // Первый элемент - инициализируем и min и max
+                    min = element;
+                    max = element;
+                    hasElements = true;
+                } else {
+                    // Сравниваем с текущим min и max
+                    if (order.compare(element, min) < 0) {
+                        min = element;
+                    }
+                    if (order.compare(element, max) > 0) {
+                        max = element;
+                    }
+                }
+            }
+
+            // Метод для объединения двух холдеров (полезно для параллельных потоков)
+            MinMaxHolder combine(MinMaxHolder other) {
+                if (!other.hasElements) {
+                    return this;
+                }
+                if (!this.hasElements) {
+                    return other;
+                }
+
+                MinMaxHolder result = new MinMaxHolder();
+                result.hasElements = true;
+                result.min = order.compare(this.min, other.min) <= 0 ? this.min : other.min;
+                result.max = order.compare(this.max, other.max) >= 0 ? this.max : other.max;
+                return result;
+            }
+        }
+
+        // Обрабатываем поток и собираем результаты
+        MinMaxHolder result = stream.reduce(
+                new MinMaxHolder(), // Начальное значение
+                (holder, element) -> {
+                    holder.update(element);
+                    return holder;
+                },
+                MinMaxHolder::combine // Комбинатор для параллельных потоков
+        );
+
+        // Вызываем consumer с результатами
+        if (result.hasElements) {
+            minMaxConsumer.accept(result.min, result.max);
+        } else {
+            minMaxConsumer.accept(null, null);
+        }
     }
-}
+}

task04/src/com/example/task04/Task04Main.java

@@ -1,11 +1,34 @@
 package com.example.task04;
 
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
 public class Task04Main {
 
     public static void main(String[] args) {
-
-        // your implementation here
-
+        // Читаем из System.in, обязательно указывая кодировку UTF-8
+        new BufferedReader(new InputStreamReader(System.in, StandardCharsets.UTF_8))
+                .lines() // Превращаем текст в поток строк
+                // Разбиваем каждую строку на слова по разделителю (все, что не буквы и не цифры)
+                .flatMap(line -> Arrays.stream(line.split("[^\\p{L}\\p{N}]+")))
+                // Убираем пустые строки, которые могут возникнуть из-за split (например, если строка начинается с пробела)
+                .filter(word -> !word.isEmpty())
+                // Переводим в нижний регистр
+                .map(String::toLowerCase)
+                // Собираем в Map<String, Long>, где ключ - слово, значение - количество
+                .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
+                .entrySet().stream() // Превращаем карту обратно в стрим пар (Слово=Количество)
+                // Сортируем: сначала по количеству (убывание), затем по слову (алфавитный порядок)
+                .sorted(Map.Entry.<String, Long>comparingByValue().reversed()
+                        .thenComparing(Map.Entry.comparingByKey()))
+                .limit(10) // Берем только топ-10
+                .forEach(entry -> System.out.print(entry.getKey() + '\n')); // Выводим слова
     }
 
-}
+}

task05/src/com/example/task05/MailContent.java

@@ -0,0 +1,8 @@
+// MailContent.java
+package com.example.task05;
+
+public interface MailContent<T> {
+    String getFrom();
+    String getTo();
+    T getContent();
+}

task05/src/com/example/task05/MailMessage.java

@@ -0,0 +1,29 @@
+// MailMessage.java
+package com.example.task05;
+
+public class MailMessage implements MailContent<String> {
+    private final String from;
+    private final String to;
+    private final String content;
+
+    public MailMessage(String from, String to, String content) {
+        this.from = from;
+        this.to = to;
+        this.content = content;
+    }
+
+    @Override
+    public String getFrom() {
+        return from;
+    }
+
+    @Override
+    public String getTo() {
+        return to;
+    }
+
+    @Override
+    public String getContent() {
+        return content;
+    }
+}

task05/src/com/example/task05/MailService.java

@@ -0,0 +1,33 @@
+// MailService.java
+package com.example.task05;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class MailService<T> implements Consumer<MailContent<T>> {
+    private final Map<String, List<T>> mailBox = new HashMap<>();
+
+    @Override
+    public void accept(MailContent<T> mailContent) {
+        String to = mailContent.getTo();
+        T content = mailContent.getContent();
+
+        mailBox.computeIfAbsent(to, k -> new ArrayList<>()).add(content);
+    }
+
+    public Map<String, List<T>> getMailBox() {
+        // Возвращаем "безопасную" версию Map, которая для отсутствующих ключей возвращает пустой список
+        return new AbstractMap<String, List<T>>() {
+            @Override
+            public Set<Entry<String, List<T>>> entrySet() {
+                return mailBox.entrySet();
+            }
+
+            @Override
+            public List<T> get(Object key) {
+                List<T> result = mailBox.get(key);
+                return result != null ? result : Collections.emptyList();
+            }
+        };
+    }
+}

task05/src/com/example/task05/Salary.java

@@ -0,0 +1,29 @@
+// Salary.java
+package com.example.task05;
+
+public class Salary implements MailContent<Integer> {
+    private final String from;
+    private final String to;
+    private final int salary;
+
+    public Salary(String from, String to, int salary) {
+        this.from = from;
+        this.to = to;
+        this.salary = salary;
+    }
+
+    @Override
+    public String getFrom() {
+        return from;
+    }
+
+    @Override
+    public String getTo() {
+        return to;
+    }
+
+    @Override
+    public Integer getContent() {
+        return salary;
+    }
+}

task05/src/com/example/task05/Task05Main.java

@@ -9,7 +9,6 @@ public class Task05Main {
 
     public static void main(String[] args) {
 
-        /*
 
         // Random variables
         String randomFrom = "..."; // Некоторая случайная строка. Можете выбрать ее самостоятельно.
@@ -88,7 +87,6 @@ public static void main(String[] args) {
         assert salaries.get(randomTo).equals(Arrays.asList(randomSalary)) : "wrong salaries mailbox content (3)";
 
 
-        */
 
     }