``` import java.util.HashSet; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Optional; import java.util.Set; import java.util.stream.Collectors; import java.util.stream.IntStream; import java.util.stream.Stream; class Solution { public java.util.List highlight_unique_substrings(java.util.List labels) { // Lowercase copies are used only for uniqueness checks. // Locale.ROOT keeps ASCII folding stable across environments. var lowers = labels.stream().map(label -> label.toLowerCase(Locale.ROOT)).toList(); // owners.get(sub) = set of label indices that contain substring `sub`. var owners = buildOwners(lowers); return IntStream.range(0, labels.size()) .mapToObj(i -> highlightOne(labels.get(i), lowers.get(i), i, owners)) .toList(); } /** Inclusive-exclusive character span inside a label. */ private record Span(int start, int length) { int end() { return start + length; } } /** * Builds a map from every distinct lowercase substring to the label indices * that contain it. A label is counted at most once even if a substring repeats. */ private static Map> buildOwners(List lowers) { return IntStream.range(0, lowers.size()) .boxed() .flatMap( i -> distinctSubstrings(lowers.get(i)) .map(sub -> Map.entry(sub, i))) .collect( Collectors.groupingBy( Map.Entry::getKey, Collectors.mapping(Map.Entry::getValue, Collectors.toCollection(HashSet::new)))); } /** All distinct substrings of {@code text}, shortest-first then left-to-right. */ private static Stream distinctSubstrings(String text) { var length = text.length(); return IntStream.rangeClosed(1, length) .boxed() .flatMap( subLen -> IntStream.range(0, length - subLen + 1) .mapToObj(start -> text.substring(start, start + subLen))) .distinct(); } /** * Picks the shortest earliest unique substring for one label and wraps it. * Stream order (length ↑, then start ↑) makes {@code findFirst} the right pick. */ private static String highlightOne( String original, String lower, int index, Map> owners) { return findUniqueSpan(lower, index, owners) .map(span -> wrap(original, span)) .orElse(original); // no unique substring — leave unchanged } private static Optional findUniqueSpan( String lower, int index, Map> owners) { var length = lower.length(); return IntStream.rangeClosed(1, length) .boxed() .flatMap( subLen -> IntStream.range(0, length - subLen + 1) .mapToObj(start -> new Span(start, subLen))) .filter(span -> isUniqueTo(lower, span, index, owners)) .findFirst(); } /** True iff {@code span} appears in this label only (case-insensitive via {@code lower}). */ private static boolean isUniqueTo( String lower, Span span, int index, Map> owners) { var sub = lower.substring(span.start(), span.end()); return owners.getOrDefault(sub, Set.of()).equals(Set.of(index)); } /** Wrap the original-cased slice; leave the rest untouched. */ private static String wrap(String original, Span span) { return "%s%s%s" .formatted( original.substring(0, span.start()), original.substring(span.start(), span.end()), original.substring(span.end())); } } ```

Visa Sponsors

H-1B Odds Calculator

Visa Bulletin

Quick Overview

Highlight the Shortest Unique Substring in Each Label