14557657526

Committed 20 Apr 2025 08:22AM UTC coverage: 53.324% (+0.4%) from 52.924%

Build # 14557657526

Build Type

push

github

Committed by

ljacqu

Commit Message

Move dictionary test runners to dictionary pkg

Run Details

268 of 576 branches covered (46.53%)

2 of 2 new or added lines in 1 file covered. (100.0%)

18 existing lines in 2 files now uncovered.

730 of 1369 relevant lines covered (53.32%)

3.09 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

43.24

/src/main/java/ch/jalu/wordeval/evaluators/impl/Anagrams.java

package ch.jalu.wordeval.evaluators.impl;

import ch.jalu.wordeval.dictionary.Word;
import ch.jalu.wordeval.evaluators.AllWordsEvaluator;
import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
import ch.jalu.wordeval.util.StreamUtils;
import com.google.common.collect.HashMultimap;
import com.google.common.collect.ListMultimap;
import com.google.common.collect.Multimaps;
import com.google.common.collect.SetMultimap;
import lombok.Getter;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Collects anagram groups (e.g. "acre", "care", "race").
 */
public class Anagrams implements AllWordsEvaluator {

  @Getter
  private final List<WordGroupWithKey> results = new ArrayList<>();

  @Override
  public void evaluate(Collection<Word> words) {
    SetMultimap<String, Word> wordsBySortedChars = words.stream()
      .collect(Multimaps.toMultimap(this::sortLettersAlphabetically, Function.identity(), HashMultimap::create));

    Multimaps.asMap(wordsBySortedChars).forEach((sequence, groupedWords) -> {
      if (groupedWords.size() > 1) {
        // Note: IntelliJ claims the .sorted call has no effect, but it ensures that lowercase words will be processed
        // before their uppercase counterparts.
        Set<Word> uniqueWords = groupedWords.stream()
            .sorted(Comparator.comparing(w -> Character.isUpperCase(w.getRaw().charAt(0))))
            .filter(StreamUtils.distinctByKey(Word::getLowercase))
            .collect(Collectors.toSet());
        results.add(new WordGroupWithKey(uniqueWords, sequence));
      }
    });
  }

  @Override
  public String getId() {
    return "group.anagrams";
  }

  @Override
  public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
    Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.getWords().size())
        .thenComparing(group -> group.getKey().length())
        .reversed(); // todo: unit test

    List<WordGroupWithKey> sortedResult = results.stream()
        .sorted(comparator)
        .toList();

    Set<Integer> uniqueValues = new HashSet<>();
    ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();
    for (WordGroupWithKey wordGroup : sortedResult) {
      int score = wordGroup.getWords().size();
      if (uniqueValues.add(score) && uniqueValues.size() > topScores) {
        break;
      }
      List<String> wordList = wordGroup.getWords().stream()
          .map(Word::getRaw)
          .toList();
      filteredResults.put(score, wordList);
      if (filteredResults.size() >= maxLimit) {
        break;
      }
    }

    return filteredResults;
  }

  private String sortLettersAlphabetically(Word word) {
    char[] chars = word.getWithoutAccentsWordCharsOnly().toCharArray();
    Arrays.sort(chars);
    return new String(chars);
  }
}

1	package ch.jalu.wordeval.evaluators.impl;
2
3	import ch.jalu.wordeval.dictionary.Word;
4	import ch.jalu.wordeval.evaluators.AllWordsEvaluator;
5	import ch.jalu.wordeval.evaluators.export.EvaluatorExportUtil;
6	import ch.jalu.wordeval.evaluators.result.WordGroupWithKey;
7	import ch.jalu.wordeval.util.StreamUtils;
8	import com.google.common.collect.HashMultimap;
9	import com.google.common.collect.ListMultimap;
10	import com.google.common.collect.Multimaps;
11	import com.google.common.collect.SetMultimap;
12	import lombok.Getter;
13
14	import java.util.ArrayList;
15	import java.util.Arrays;
16	import java.util.Collection;
17	import java.util.Comparator;
18	import java.util.HashSet;
19	import java.util.List;
20	import java.util.Set;
21	import java.util.function.Function;
22	import java.util.stream.Collectors;
23
24	/**
25	* Collects anagram groups (e.g. "acre", "care", "race").
26	*/
27	public class Anagrams implements AllWordsEvaluator {	2✔
28
29	@Getter	6✔
30	private final List<WordGroupWithKey> results = new ArrayList<>();
31
32	@Override
33	public void evaluate(Collection<Word> words) {
34	SetMultimap<String, Word> wordsBySortedChars = words.stream()	4✔
35	.collect(Multimaps.toMultimap(this::sortLettersAlphabetically, Function.identity(), HashMultimap::create));	6✔
36
37	Multimaps.asMap(wordsBySortedChars).forEach((sequence, groupedWords) -> {	5✔
38	if (groupedWords.size() > 1) {	4✔
39	// Note: IntelliJ claims the .sorted call has no effect, but it ensures that lowercase words will be processed
40	// before their uppercase counterparts.
41	Set<Word> uniqueWords = groupedWords.stream()	3✔
42	.sorted(Comparator.comparing(w -> Character.isUpperCase(w.getRaw().charAt(0))))	10✔
43	.filter(StreamUtils.distinctByKey(Word::getLowercase))	2✔
44	.collect(Collectors.toSet());	4✔
45	results.add(new WordGroupWithKey(uniqueWords, sequence));	9✔
46	}
47	});	1✔
48	}	1✔
49
50	@Override
51	public String getId() {
UNCOV 52	return "group.anagrams";	×
53	}
54
55	@Override
56	public ListMultimap<Object, Object> getTopResults(int topScores, int maxLimit) {
57	Comparator<WordGroupWithKey> comparator = Comparator.comparingInt((WordGroupWithKey group) -> group.getWords().size())	×
58	.thenComparing(group -> group.getKey().length())	×
59	.reversed(); // todo: unit test	×
60
61	List<WordGroupWithKey> sortedResult = results.stream()	×
62	.sorted(comparator)	×
UNCOV 63	.toList();	×
64
65	Set<Integer> uniqueValues = new HashSet<>();	×
66	ListMultimap<Object, Object> filteredResults = EvaluatorExportUtil.newListMultimap();	×
67	for (WordGroupWithKey wordGroup : sortedResult) {	×
68	int score = wordGroup.getWords().size();	×
69	if (uniqueValues.add(score) && uniqueValues.size() > topScores) {	×
UNCOV 70	break;	×
71	}
UNCOV 72	List<String> wordList = wordGroup.getWords().stream()	×
73	.map(Word::getRaw)	×
UNCOV 74	.toList();	×
UNCOV 75	filteredResults.put(score, wordList);	×
UNCOV 76	if (filteredResults.size() >= maxLimit) {	×
UNCOV 77	break;	×
78	}
UNCOV 79	}	×
80
UNCOV 81	return filteredResults;	×
82	}
83
84	private String sortLettersAlphabetically(Word word) {
85	char[] chars = word.getWithoutAccentsWordCharsOnly().toCharArray();	4✔
86	Arrays.sort(chars);	2✔
87	return new String(chars);	5✔
88	}
89	}

ljacqu / wordeval / 14557657526

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous