Vadības virknes rakstzīmju atbilstība masīva vārdiem

Masīva elementu filtrēšana un grupēšana, pamatojoties uz virkņu saskaņošanu

Uz Java balstīts risinājums, izmantojot ligzdotas cilpas un modulāras 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();
    }
}

Optimizēts risinājums, izmantojot straumes Java

Java 8+ risinājums, kas izmanto straumes lasāmībai un veiktspējai

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);
            }
        }
    }
}

Vienības tests abiem risinājumiem

Uz JUnit balstīts tests, lai apstiprinātu rezultātus dažādos scenārijos

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());
    }
}

Bieži uzdotie jautājumi par virkņu saskaņošanu un ligzdotajām cilpām

1. Kāds ir mērķis toCharArray() metode?
2. The toCharArray() metode pārveido virkni rakstzīmju masīvā, ļaujot veikt katras rakstzīmes iterāciju apstrādei.
3. Kā darbojas removeDuplicates() funkciju darbs?
4. The removeDuplicates() funkcija izveido jaunu virkni, pievienojot tikai unikālas rakstzīmes no ievades virknes, nodrošinot atkārtotu apstrādi.
5. Kāpēc ir startsWith() dod priekšroku nevis manuālai rakstzīmju pārbaudei?
6. startsWith() vienkāršo kodu, tieši pārbaudot, vai virkne sākas ar noteiktu prefiksu, tādējādi samazinot kļūdu iespējamību.
7. Vai straumes var efektīvi apstrādāt lielas datu kopas?
8. Jā, Java straumes, īpaši ar parallelStream(), var efektīvi apstrādāt lielas datu kopas, izmantojot paralēlo aprēķinu.
9. Kāda ir izmantošanas priekšrocība Collectors.joining() izlaidei?
10. Collectors.joining() apkopo elementus no straumes vienā virknē ar izvēles norobežotājiem, uzlabojot lasāmību un izvades formatējumu.
11. Kā vienību testi var uzlabot uzticamību?
12. Vienību testi nodrošina katru funkciju, piemēram print(), darbojas pareizi dažādos scenārijos, samazinot kļūdas ražošanā.
13. Kā dara hash-based searching uzlabot veiktspēju?
14. Iepriekš indeksējot datus hash kartē, atbilstības var atrast nemainīgā laikā, padarot procesu ātrāku lieliem masīviem.
15. Kas ir lokāli jutīgu virkņu salīdzinājums?
16. Tas nodrošina precīzus virkņu salīdzinājumus dažādās valodās vai kodējumu, izmantojot tādus rīkus kā Java Collator.
17. Vai šo skriptu var integrēt ar priekšgala lietojumprogrammām?
18. Jā, loģiku var pielāgot lietošanai JavaScript vai sistēmās, piemēram, React, lai izveidotu interaktīvas un dinamiskas izvades.
19. Kāds ir koda modularizācijas ieguvums?
20. Koda sadalīšana atkārtoti izmantojamās metodēs, piemēram removeDuplicates() un matchFirstWithLetter() atvieglo uzturēšanu un paplašināšanu.

Pēdējās domas par efektīvu stīgu saskaņošanu

Risinot kontroles virknes rakstzīmju saskaņošanas problēmu ar masīva vārdiem, tika izceltas tādas galvenās metodes kā dedublikācija un grupēšana. Tie nodrošina precīzus rezultātus un efektīvu lielu datu kopu apstrādi. Šādi risinājumi ir būtiski reālās pasaules lietojumprogrammām, piemēram, meklētājprogrammām vai datu kategorizēšanai.

Modulārās programmēšanas pieejas, kas demonstrētas ar atkārtoti lietojamām metodēm, nodrošina vieglāku apkopi un mērogojamību. Neatkarīgi no tā, vai tos izmanto maziem projektiem vai liela mēroga sistēmām, šīs koncepcijas joprojām ir būtiskas. Izmantojot Java jaudīgās komandas, izstrādātāji var efektīvi un inovatīvi atrisināt līdzīgas virkņu saskaņošanas problēmas. 🧩