Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

Java i biblioteka apache commons - mam dwie listy tokenów typu string w javie i teraz…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Geminigemini-2.0-flash-001’s answer.
  1. User

    Java i biblioteka apache commons - mam dwie listy tokenów typu string w javie i teraz chce je porównać korzystając levenstheina, ale w taki sposób, że jeżeli dystans to 0 to score = 100, jeżeli długość pierwszego >2 i długość drugiego >2 i odległość levenshteina <= 2 to wyliczyć procentową zgodność dopasowania (nie wiem jaki tu wzór, chyba dzielić przez większą długość, ale jak to sensownie na procent zamienić by mi większe niż 100 nie wychodziły?). A w innym przypadku 0. Jeżeli procentowa zgodność jest większa niż poprzednio wyliczona to ją podmienić. Zgodność zapisuje w LinkedHashmapie. Szukam optymalizacji, chyba mógłbym nie wyliczać zgodności jeżeli jest 100 już obliczona oraz nie wiem czy jest sens robić to krzyżowo w podwójnej pętli.

  2. DeepSeek Assistant

    Oto optymalne rozwiązanie wykorzystujące odległość Levenshteina z Apache Commons Text, z implementacją sugerowanych optymalizacji:

    import org.apache.commons.text.similarity.LevenshteinDistance;
    import java.util.LinkedHashMap;
    import java.util.List;
    import java.util.Map;
    
    public class TokenComparator {
    
        public Map<String, Double> calculateSimilarity(List<String> list1, List<String> list2) {
            Map<String, Double> resultMap = new LinkedHashMap<>();
            LevenshteinDistance levenshtein = LevenshteinDistance.getDefaultInstance();
    
            for (String token1 : list1) {
                if (token1 == null) continue;
                
                double bestScore = 0;
                int len1 = token1.length();
                
                for (String token2 : list2) {
                    if (token2 == null) continue;
                    int len2 = token2.length();
                    
                    // Optymalizacja 1: Pomijaj gdy różnica długości > 2
                    if (Math.abs(len1 - len2) > 2) continue;
                    
                    // Optymalizacja 2: Przerwij pętlę jeśli znaleziono 100%
                    if (bestScore == 100) break;
                    
                    int distance = levenshtein.apply(token1, token2);
                    
                    if (distance == 0) {
                        bestScore = 100;
                    } else if (len1 > 2 && len2 > 2 && distance <= 2) {
                        // Oblicz procentową zgodność
                        int maxLength = Math.max(len1, len2);
                        double match = (1 - (double) distance / maxLength) * 100;
                        if (match > bestScore) {
                            bestScore = match;
                        }
                    }
                    // Dla pozostałych przypadków domyślnie 0 (nie zmienia bestScore)
                }
                
                resultMap.put(token1, bestScore);
            }
            
            return resultMap;
        }
    }
    

    Wyjaśnienie kluczowych elementów:

    1. Optymalizacje obliczeń:

      • Sprawdzanie różnicy długości tokenów przed obliczeniem odległości (gdy >2 - pomijaj)
      • Przerywanie wewnętrznej pętli po znalezieniu 100% dopasowania
      • Unikanie niepotrzebnych obliczeń dla tokenów krótszych niż 3 znaki
    2. Obliczanie procentowej zgodności:

      double match = (1 - (double) distance / maxLength) * 100;
      

      Gdzie:

      • distance - odległość Levenshteina
      • maxLength - dłuższy z porównywanych tokenów
      • Formuła gwarantuje wynik w zakresie 0-100%
    3. Warunki zgodności:

      • distance == 0 → 100%
      • len > 2 && distance <= 2 → oblicz procent
      • Inne przypadki → 0%
    4. Struktura danych:

      • LinkedHashMap zachowuje kolejność tokenów z wejściowej listy

    Dodatkowe optymalizacje (do rozważenia):

    1. Wstępne filtrowanie listy:

      List<String> filteredList2 = list2.stream()
          .filter(t -> t != null && t.length() >= len1 - 2 && t.length() <= len1 + 2)
          .collect(Collectors.toList());
      
    2. Mapa pomocnicza dla unikalnych tokenów:

      Map<String, Double> tokenCache = new HashMap<>();
      if (tokenCache.containsKey(token1)) {
          resultMap.put(token1, tokenCache.get(token1));
          continue;
      }
      
    3. Równoległe przetwarzanie (dla dużych zbiorów):

      list1.parallelStream().forEach(token1 -> { ... });
      

    Uwagi implementacyjne:

    • Wersja Apache Commons Text: 1.9+ (sprawdź aktualną wersję w Maven/Gradle)
    • Obsługa nulli: pomijanie nulli w listach wejściowych
    • Dokładność obliczeń: rzutowanie na double podczas dzielenia
    • Wydajność: Złożoność O(n*m) ale z znaczącymi optymalizacjami w praktyce

    To rozwiązanie zapewnia optymalne wykorzystanie zasobów przy zachowaniu czytelności kodu i poprawności obliczeń zgodności tokenów.

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.