Add WordFrequencyImpl

src/main/java/ru/ilug/c10_word_frequency/MainTest.java

@@ -9,7 +9,7 @@ import java.util.Map;
 public class MainTest {
 
     public static void main(String[] args) {
-        WordFrequency wordFrequency = null;
+        WordFrequency wordFrequency = new WordFrequencyImpl();
 
         List<String> words1 = List.of("list", "map", "class", "public", "list", "set", "word", "class", "list", "public", "main", "string", "map");
         List<String> words2 = List.of("long", "string", "list", "public", "import", "double", "word", "map", "class", "package", "void", "long");

src/main/java/ru/ilug/c10_word_frequency/WordFrequencyImpl.java

@@ -0,0 +1,30 @@
+package ru.ilug.c10_word_frequency;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Slf4j
+public class WordFrequencyImpl implements WordFrequency {
+
+    /**
+     * Ищет слова, которые встречаются в обоих списках, считает суммарную частоту каждого
+     * @param list1 Первый список слов
+     * @param list2 Второй список слов
+     * @return Частота слов, которые есть в обоих списках
+     */
+    @Override
+    public Map<String, Integer> getWordFrequency(List<String> list1, List<String> list2) {
+        Set<String> retainedSet = new HashSet<>(list1);
+        retainedSet.retainAll(list2);
+
+        return Stream.concat(list1.stream(), list2.stream())
+                .filter(retainedSet::contains)
+                .collect(Collectors.groupingBy(w -> w, Collectors.collectingAndThen(
+                        Collectors.toList(),
+                        List::size
+                )));
+    }
+}

src/main/java/ru/ilug/c1_word_counter/MainTest.java

@@ -8,7 +8,7 @@ import java.util.Map;
 public class MainTest {
 
     public static void main(String[] args) {
-        WordCounter wordCounter = null;
+        WordCounter wordCounter = new WordCounterImpl();
 
         String text = "Внутри Map данные хранятся в формате ключ значение, то есть по парам. И в качестве ключей, и в качестве значений могут выступать любые объекты числа, строки или объекты других классов.";
         Map<String, Integer> wordsCountMap = wordCounter.countWords(text);

src/main/java/ru/ilug/c1_word_counter/WordCounterImpl.java

@@ -0,0 +1,21 @@
+package ru.ilug.c1_word_counter;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class WordCounterImpl implements WordCounter {
+    @Override
+    public Map<String, Integer> countWords(String text) {
+        String[] words = text.split(" ");
+
+        Map<String, Integer> wordsCount = new HashMap<>();
+
+        for(String word : words) {
+            word = word.toLowerCase();
+            int wordCount = wordsCount.getOrDefault(word, 0);
+            wordsCount.put(word, wordCount + 1);
+        }
+
+        return wordsCount;
+    }
+}

src/main/java/ru/ilug/c2_phone_book/MainTest.java

@@ -6,7 +6,7 @@ import lombok.extern.slf4j.Slf4j;
 public class MainTest {
 
     public static void main(String[] args) {
-        PhoneBook phoneBook = null;
+        PhoneBook phoneBook = new PhoneBookImpl();
 
         phoneBook.addContact("Ivan", "+1 (234) 567 89 10");
         phoneBook.addContact("Dima", "+3 (456) 789 10 11");

src/main/java/ru/ilug/c2_phone_book/PhoneBookImpl.java

@@ -0,0 +1,24 @@
+package ru.ilug.c2_phone_book;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class PhoneBookImpl implements PhoneBook {
+
+    private final Map<String, String> contacts = new HashMap<>();
+
+    @Override
+    public void addContact(String name, String phone) {
+        contacts.put(name, phone);
+    }
+
+    @Override
+    public String findPhoneByName(String name) {
+        return contacts.get(name);
+    }
+
+    @Override
+    public void removeContactByName(String name) {
+        contacts.remove(name);
+    }
+}

src/main/java/ru/ilug/c3_simple_translator/MainTest.java

@@ -6,7 +6,7 @@ import lombok.extern.slf4j.Slf4j;
 public class MainTest {
 
     public static void main(String[] args) {
-        SimpleTranslator simpleTranslator = null;
+        SimpleTranslator simpleTranslator = new SimpleTranslatorImpl();
 
         simpleTranslator.addWordTranslate("подборка", "selection");
         simpleTranslator.addWordTranslate("практических", "practical");

src/main/java/ru/ilug/c3_simple_translator/SimpleTranslatorImpl.java

@@ -0,0 +1,24 @@
+package ru.ilug.c3_simple_translator;
+
+import java.util.Arrays;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class SimpleTranslatorImpl implements SimpleTranslator {
+
+    private final Map<String, String> wordsTranslate = new HashMap<>();
+
+    @Override
+    public void addWordTranslate(String word, String translate) {
+        wordsTranslate.put(word.toLowerCase(), translate.toLowerCase());
+    }
+
+    @Override
+    public String translate(String text) {
+        return Arrays.stream(text.split(" "))
+                .map(w -> wordsTranslate.getOrDefault(w.toLowerCase(), w))
+                .collect(Collectors.joining(" "));
+    }
+
+}

src/main/java/ru/ilug/c4_school_journal/MainTest.java

@@ -9,7 +9,7 @@ import java.util.Map;
 public class MainTest {
 
     public static void main(String[] args) {
-        SchoolJournal schoolJournal = null;
+        SchoolJournal schoolJournal = new SchoolJournalImpl();
 
         schoolJournal.addScore("Ivan", 4);
         schoolJournal.addScore("Ivan", 5);

src/main/java/ru/ilug/c4_school_journal/SchoolJournalImpl.java

@@ -0,0 +1,37 @@
+package ru.ilug.c4_school_journal;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+public class SchoolJournalImpl implements SchoolJournal {
+
+    private final Map<String, List<Integer>> studentsScores = new HashMap<>();
+
+    @Override
+    public void addScore(String name, int score) {
+        studentsScores.computeIfAbsent(name, k -> new LinkedList<>()).add(score);
+    }
+
+    @Override
+    public void addScores(String name, Collection<Integer> scores) {
+        studentsScores.computeIfAbsent(name, k -> new LinkedList<>()).addAll(scores);
+    }
+
+    @Override
+    public Map<String, Float> getAverageScorePerStudent() {
+        return studentsScores.entrySet().stream()
+                .collect(Collectors.toMap(Map.Entry::getKey, e -> {
+                    List<Integer> scores = e.getValue();
+                    int scoresSum = scores.stream().mapToInt(s -> s).sum();
+                    return (float) scoresSum / scores.size();
+                }));
+    }
+
+    @Override
+    public List<String> studentsWithAverageScoreHighThen(float averageScore) {
+        return getAverageScorePerStudent().entrySet().stream()
+                .filter(e -> e.getValue() >= averageScore)
+                .map(Map.Entry::getKey)
+                .toList();
+    }
+}

src/main/java/ru/ilug/c5_char_frequency/CharFrequencyImpl.java

@@ -0,0 +1,19 @@
+package ru.ilug.c5_char_frequency;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class CharFrequencyImpl implements CharFrequency {
+
+    @Override
+    public Map<Character, Integer> getCharFrequency(String text) {
+        return text.chars()
+                .mapToObj(c -> (char) c)
+                .collect(
+                        Collectors.groupingBy(c -> c,
+                                Collectors.collectingAndThen(Collectors.toList(), List::size)
+                        )
+                );
+    }
+}

src/main/java/ru/ilug/c5_char_frequency/MainTest.java

@@ -6,7 +6,7 @@ import lombok.extern.slf4j.Slf4j;
 public class MainTest {
 
     public static void main(String[] args) {
-        CharFrequency charFrequency = null;
+        CharFrequency charFrequency = new CharFrequencyImpl();
 
         String text1 = "Мама мыла Милку мылом";
         String text2 = "Карл у Клары украл рекламу, а Клара у Карла украла бюджет.";

src/main/java/ru/ilug/c6_word_group/MainTest.java

@@ -6,7 +6,7 @@ import lombok.extern.slf4j.Slf4j;
 public class MainTest {
 
     public static void main(String[] args) {
-        WordGroup wordGroup = null;
+        WordGroup wordGroup = new WordGroupImpl();
 
         String text1 = "Карл у Клары украл рекламу, а Клара у Карла украла бюджет.";
         String text2 = "Из кузова в кузов шла перегрузка арбузов. В грозу, в грязи от груза арбузов развалился кузов.";

src/main/java/ru/ilug/c6_word_group/WordGroupImpl.java

@@ -0,0 +1,16 @@
+package ru.ilug.c6_word_group;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class WordGroupImpl implements WordGroup {
+
+    @Override
+    public Map<Integer, List<String>> groupWordsByLength(String text) {
+        text = text.replaceAll("[.,]", "");
+        return Arrays.stream(text.split(" "))
+                .collect(Collectors.groupingBy(String::length));
+    }
+}

src/main/java/ru/ilug/c7_factorial_calculator/FactorialCalculatorImpl.java

@@ -0,0 +1,18 @@
+package ru.ilug.c7_factorial_calculator;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class FactorialCalculatorImpl implements FactorialCalculator {
+
+    private final Map<Integer, Integer> cache = new ConcurrentHashMap<>();
+
+    @Override
+    public int calculate(int num) {
+        if (num <= 1) {
+            return 1;
+        }
+        return cache.computeIfAbsent(num, n -> calculate(n - 1) * n);
+    }
+
+}

src/main/java/ru/ilug/c7_factorial_calculator/MainTest.java

@@ -6,7 +6,7 @@ import lombok.extern.slf4j.Slf4j;
 public class MainTest {
 
     public static void main(String[] args) {
-        FactorialCalculator factorialCalculator = null;
+        FactorialCalculator factorialCalculator = new FactorialCalculatorImpl();
 
         log.info("Factorial 3 = {}", factorialCalculator.calculate(3));
         log.info("Factorial 4 = {}", factorialCalculator.calculate(4));

src/main/java/ru/ilug/c8_anagram_group/AnagramGroupImpl.java

@@ -0,0 +1,34 @@
+package ru.ilug.c8_anagram_group;
+
+import lombok.extern.slf4j.Slf4j;
+
+import java.nio.CharBuffer;
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Slf4j
+public class AnagramGroupImpl implements AnagramGroup {
+
+    /**
+     * Группирует слова в группы анаграммы (слова, составленные из одних букв). Ключ — отсортированные буквы слова, значение — список анаграмм.
+     *
+     * @param words Слова
+     * @return Группы
+     */
+    @Override
+    public Map<String, List<String>> group(String... words) {
+        Map<String, List<String>> anagrams = new HashMap<>();
+
+        for (String word : words) {
+            String key = CharBuffer.wrap(word.toCharArray()).chars().boxed()
+                    .distinct()
+                    .sorted()
+                    .map(c -> String.valueOf((char) c.intValue()))
+                    .collect(Collectors.joining());
+            anagrams.computeIfAbsent(key, k -> new LinkedList<>()).add(word);
+        }
+
+        return anagrams;
+    }
+
+}

src/main/java/ru/ilug/c8_anagram_group/MainTest.java

@@ -2,17 +2,21 @@ package ru.ilug.c8_anagram_group;
 
 import lombok.extern.slf4j.Slf4j;
 
+import java.util.List;
+import java.util.Map;
+
 @Slf4j
 public class MainTest {
 
     public static void main(String[] args) {
-        AnagramGroup anagramGroup = null;
+        AnagramGroup anagramGroup = new AnagramGroupImpl();
 
         String[] words = new String[]{
-                "кабан", "соринка", "кукла", "мышка", "приказ", "шнурок",
-                "кулак", "банка", "коршун", "росинка", "каприз", "камыш"
+                "кабан", "соринка", "кукла", "мышка", "приказ", "шнурок", // кабан -> кабн -> абкн
+                "кулак", "банка", "коршун", "росинка", "каприз", "камыш"  // банка -> банк -> абкн
         };
-        log.info("Anagram groups: {}", words);
+        Map<String, List<String>> result = anagramGroup.group(words);
+        log.info("Anagram groups: {}", result);
     }
 
 }

src/main/java/ru/ilug/c9_most_frequent_words/MainTest.java

@@ -8,7 +8,7 @@ import java.util.Map;
 public class MainTest {
 
     public static void main(String[] args) {
-        MostFrequentWords mostFrequentWords = null;
+        MostFrequentWords mostFrequentWords = new MostFrequentWordsImpl();
 
         Map<String, Integer> result = mostFrequentWords.getNWords("На дворе трава, на траве дрова. Не руби дрова на траве двора!", 3);
         log.info("3 most frequent words: {}", result);

src/main/java/ru/ilug/c9_most_frequent_words/MostFrequentWordsImpl.java

@@ -0,0 +1,24 @@
+package ru.ilug.c9_most_frequent_words;
+
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+public class MostFrequentWordsImpl implements MostFrequentWords {
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public Map<String, Integer> getNWords(String text, int count) {
+        return Arrays.stream(text.replaceAll("[.,!]", "").split(" "))
+                .collect(
+                        Collectors.groupingBy(c -> c,
+                                Collectors.collectingAndThen(Collectors.toList(), List::size)
+                        )
+                ).entrySet().stream()
+                .sorted(Comparator.comparingInt(e -> ((Map.Entry<String, Integer>)e).getValue()).reversed())
+                .limit(count)
+                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
+    }
+}