Valdymo eilutės simbolių suderinimas su masyvo žodžiais

Masyvo elementų filtravimas ir grupavimas pagal eilučių atitikimą

Java pagrįstas sprendimas, naudojant įdėtas kilpas ir modulines funkcijas

public class Main {
    public static void main(String[] args) {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        print(array, keyWord);
    }

    // Function to filter and print matching results
    static void print(String[] array, String keyWord) {
        String filteredKeyWord = removeDuplicates(keyWord.toLowerCase());
        for (char c : filteredKeyWord.toCharArray()) {
            StringBuilder matches = new StringBuilder();
            for (String word : array) {
                if (word.charAt(0) == c) {
                    if (matches.length() > 0) {
                        matches.append(", ");
                    }
                    matches.append(word);
                }
            }
            if (matches.length() > 0) {
                System.out.println(c + ": " + matches);
            }
        }
    }

    // Helper function to remove duplicate characters from a string
    static String removeDuplicates(String str) {
        StringBuilder result = new StringBuilder();
        for (char c : str.toCharArray()) {
            if (result.indexOf(String.valueOf(c)) == -1) {
                result.append(c);
            }
        }
        return result.toString();
    }
}

Optimizuotas sprendimas naudojant srautus Java

„Java 8“ ir naujesnės versijos sprendimas, kuriame naudojami srautai skaitomumui ir našumui užtikrinti

import java.util.*;
import java.util.stream.*;

public class Main {
    public static void main(String[] args) {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        printWithStreams(array, keyWord);
    }

    static void printWithStreams(String[] array, String keyWord) {
        String filteredKeyWord = keyWord.toLowerCase().chars()
                .distinct()
                .mapToObj(c -> (char) c)
                .map(String::valueOf)
                .collect(Collectors.joining());

        for (char c : filteredKeyWord.toCharArray()) {
            String matches = Arrays.stream(array)
                    .filter(word -> word.startsWith(String.valueOf(c)))
                    .collect(Collectors.joining(", "));

            if (!matches.isEmpty()) {
                System.out.println(c + ": " + matches);
            }
        }
    }
}

Abiejų sprendimų vieneto testas

JUnit pagrįstas testas, skirtas patvirtinti išvestis įvairiuose scenarijuose

import org.junit.jupiter.api.Test;
import java.io.ByteArrayOutputStream;
import java.io.PrintStream;
import static org.junit.jupiter.api.Assertions.assertEquals;

public class MainTest {
    @Test
    void testPrint() {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));

        Main.print(array, keyWord);
        String expectedOutput = "t: type\nr: reference, recursive\nc: class, constructor\n";
        assertEquals(expectedOutput, outContent.toString());
    }

    @Test
    void testPrintWithStreams() {
        String[] array = {"reference", "class", "method", "type", "constructor", "recursive"};
        String keyWord = "structure";
        ByteArrayOutputStream outContent = new ByteArrayOutputStream();
        System.setOut(new PrintStream(outContent));

        Main.printWithStreams(array, keyWord);
        String expectedOutput = "t: type\nr: reference, recursive\nc: class, constructor\n";
        assertEquals(expectedOutput, outContent.toString());
    }
}

Dažniausiai užduodami klausimai apie eilučių atitikimą ir įdėtas kilpas

1. Koks yra tikslas toCharArray() metodas?
2. The toCharArray() metodas konvertuoja eilutę į simbolių masyvą, įgalindamas kiekvieno simbolio iteraciją apdorojimui.
3. Kaip veikia removeDuplicates() funkcinis darbas?
4. The removeDuplicates() funkcija sukuria naują eilutę, pridedant tik unikalius simbolius iš įvesties eilutės, užtikrinant, kad nebūtų kartojamas apdorojimas.
5. Kodėl yra startsWith() teikia pirmenybę simbolių tikrinimui rankiniu būdu?
6. startsWith() supaprastina kodą tiesiogiai patikrindama, ar eilutė prasideda nurodytu priešdėliu, todėl joje mažiau klaidų.
7. Ar srautai gali efektyviai tvarkyti didelius duomenų rinkinius?
8. Taip, „Java“ srautai, ypač su parallelStream(), gali efektyviai apdoroti didelius duomenų rinkinius naudodamas lygiagretųjį skaičiavimą.
9. Koks yra naudojimo pranašumas Collectors.joining() dėl išėjimo?
10. Collectors.joining() sujungia elementus iš srauto į vieną eilutę su pasirenkamais skyrikliais, pagerina skaitomumą ir išvesties formatavimą.
11. Kaip vienetų testai gali pagerinti patikimumą?
12. Vienetų testai užtikrina kiekvieną funkciją, pvz print(), veikia tinkamai pagal įvairius scenarijus, sumažinant gamybos klaidas.
13. Kaip veikia hash-based searching pagerinti našumą?
14. Iš anksto indeksavus duomenis į maišos žemėlapį, atitikmenis galima rasti pastoviu laiku, o tai pagreitina didelių masyvų procesą.
15. Kas yra lokalei jautrių eilučių palyginimas?
16. Tai užtikrina tikslų eilučių palyginimą skirtingomis kalbomis arba kodavimą naudojant tokius įrankius kaip Java Collator.
17. Ar šis scenarijus gali būti integruotas su priekinėmis programomis?
18. Taip, logika gali būti pritaikyta naudoti „JavaScript“ arba tokiose sistemose kaip „React“, kad būtų galima sukurti interaktyvius ir dinamiškus išėjimus.
19. Kokia kodo moduliavimo nauda?
20. Kodo suskaidymas į daugkartinio naudojimo metodus, pvz removeDuplicates() ir matchFirstWithLetter() padeda lengviau prižiūrėti ir plėsti.

Paskutinės mintys apie efektyvų stygų derinimą

Sprendžiant valdymo eilutės simbolių suderinimo su masyvo žodžiais problemą, buvo išryškinti pagrindiniai metodai, tokie kaip deduplikacija ir grupavimas. Tai užtikrina tikslius rezultatus ir efektyvų didelių duomenų rinkinių tvarkymą. Tokie sprendimai yra būtini realaus pasaulio programoms, pvz., paieškos sistemoms ar duomenų klasifikavimui.

Moduliniai programavimo metodai, demonstruojami naudojant daugkartinio naudojimo metodus, leidžia lengviau prižiūrėti ir keisti mastelį. Nesvarbu, ar jos taikomos mažiems projektams, ar didelės apimties sistemoms, šios sąvokos išlieka pagrindinės. Naudodami galingas Java komandas, kūrėjai gali veiksmingai ir naujoviškai išspręsti panašias eilučių suderinimo problemas. 🧩