ஒரு கண்ட்ரோல் ஸ்ட்ரிங்கில் இருந்து வரிசை வார்த்தைகளுக்கு எழுத்துகளை பொருத்துதல்

சரம் பொருத்தத்தின் அடிப்படையில் வரிசை உறுப்புகளை வடிகட்டுதல் மற்றும் தொகுத்தல்

உள்ளமைக்கப்பட்ட சுழல்கள் மற்றும் மட்டு செயல்பாடுகளைப் பயன்படுத்தி ஜாவா அடிப்படையிலான தீர்வு

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

ஜாவாவில் ஸ்ட்ரீம்களைப் பயன்படுத்தி உகந்த தீர்வு

Java 8+ தீர்வு, வாசிப்புத்திறன் மற்றும் செயல்திறனுக்கான ஸ்ட்ரீம்களை மேம்படுத்துகிறது

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

இரண்டு தீர்வுகளுக்கான அலகு சோதனை

வெவ்வேறு சூழ்நிலைகளில் வெளியீடுகளைச் சரிபார்க்க ஜூனிட் அடிப்படையிலான சோதனை

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

சரம் பொருத்தம் மற்றும் உள்ளமைக்கப்பட்ட சுழல்கள் பற்றி பொதுவாகக் கேட்கப்படும் கேள்விகள்

1. இதன் நோக்கம் என்ன toCharArray() முறை?
2. தி toCharArray() முறை ஒரு சரத்தை ஒரு எழுத்து வரிசையாக மாற்றுகிறது, செயலாக்கத்திற்காக ஒவ்வொரு எழுத்துக்கும் மறு செய்கையை செயல்படுத்துகிறது.
3. எப்படி செய்கிறது removeDuplicates() செயல்பாடு வேலை?
4. தி removeDuplicates() செயல்பாடு உள்ளீட்டு சரத்திலிருந்து தனிப்பட்ட எழுத்துக்களை மட்டும் சேர்ப்பதன் மூலம் ஒரு புதிய சரத்தை உருவாக்குகிறது, மீண்டும் மீண்டும் செயலாக்கப்படாமல் இருப்பதை உறுதி செய்கிறது.
5. ஏன் உள்ளது startsWith() எழுத்துகளை கைமுறையாக சரிபார்ப்பதை விட விரும்புகிறீர்களா?
6. startsWith() ஒரு சரம் ஒரு குறிப்பிட்ட முன்னொட்டுடன் தொடங்குகிறதா என்பதை நேரடியாகச் சரிபார்ப்பதன் மூலம் குறியீட்டை எளிதாக்குகிறது, இதனால் பிழை குறைவாக இருக்கும்.
7. ஸ்ட்ரீம்களால் பெரிய தரவுத்தொகுப்புகளை திறமையாக கையாள முடியுமா?
8. ஆம், ஜாவா ஸ்ட்ரீம்கள், குறிப்பாக உடன் parallelStream(), இணையான கணக்கீட்டை மேம்படுத்துவதன் மூலம் பெரிய தரவுத்தொகுப்புகளை திறமையாக செயலாக்க முடியும்.
9. பயன்படுத்துவதால் என்ன நன்மை Collectors.joining() வெளியீட்டிற்காகவா?
10. Collectors.joining() ஒரு ஸ்ட்ரீமிலிருந்து தனிமங்களை விருப்பப் பிரிப்புகளுடன் ஒரு சரத்தில் ஒருங்கிணைக்கிறது, வாசிப்புத்திறன் மற்றும் வெளியீட்டு வடிவமைப்பை மேம்படுத்துகிறது.
11. அலகு சோதனைகள் எவ்வாறு நம்பகத்தன்மையை மேம்படுத்த முடியும்?
12. அலகு சோதனைகள் ஒவ்வொரு செயல்பாட்டையும் உறுதி செய்கின்றன print(), பல்வேறு சூழ்நிலைகளில் சரியாகச் செயல்படுகிறது, உற்பத்தியில் பிழைகளைக் குறைக்கிறது.
13. எப்படி செய்கிறது hash-based searching செயல்திறனை மேம்படுத்தவா?
14. ஹாஷ் வரைபடத்தில் தரவை முன்-இன்டெக்ஸ் செய்வதன் மூலம், நிலையான நேரத்தில் பொருத்தங்களைக் காணலாம், இது பெரிய வரிசைகளுக்கு செயல்முறையை துரிதப்படுத்தும்.
15. லோகேல் சென்சிடிவ் சரம் ஒப்பீடு என்றால் என்ன?
16. ஜாவா போன்ற கருவிகளைப் பயன்படுத்தி வெவ்வேறு மொழிகளில் அல்லது குறியாக்கங்களில் உள்ள சரங்களுக்கான துல்லியமான ஒப்பீடுகளை இது உறுதி செய்கிறது Collator.
17. இந்த ஸ்கிரிப்டை முன்-இறுதி பயன்பாடுகளுடன் ஒருங்கிணைக்க முடியுமா?
18. ஆம், தர்க்கத்தை ஜாவாஸ்கிரிப்ட் அல்லது ரியாக்ட் போன்ற கட்டமைப்புகளில் பயன்படுத்தி ஊடாடும் மற்றும் மாறும் வெளியீடுகளை உருவாக்கலாம்.
19. குறியீட்டை மட்டுப்படுத்துவதால் என்ன பயன்?
20. குறியீட்டை மீண்டும் பயன்படுத்தக்கூடிய முறைகளாக உடைத்தல் removeDuplicates() மற்றும் matchFirstWithLetter() பராமரிக்க மற்றும் விரிவாக்க எளிதாக்குகிறது.

திறமையான சரம் பொருத்தம் பற்றிய இறுதி எண்ணங்கள்

வரிசை வார்த்தைகளுடன் கட்டுப்பாட்டு சரம் எழுத்துக்களைப் பொருத்துவதில் உள்ள சிக்கலைத் தீர்ப்பதில், துப்பறிதல் மற்றும் குழுவாக்கம் போன்ற முக்கிய நுட்பங்கள் முன்னிலைப்படுத்தப்பட்டன. இவை துல்லியமான முடிவுகளையும் பெரிய தரவுத்தொகுப்புகளின் திறமையான கையாளுதலையும் உறுதி செய்கின்றன. தேடுபொறிகள் அல்லது தரவு வகைப்படுத்தல் போன்ற நிஜ-உலகப் பயன்பாடுகளுக்கு இத்தகைய தீர்வுகள் அவசியம்.

மட்டு நிரலாக்க அணுகுமுறைகள், மீண்டும் பயன்படுத்தக்கூடிய முறைகள் மூலம் நிரூபிக்கப்பட்டு, எளிதான பராமரிப்பு மற்றும் அளவிடுதல் ஆகியவற்றை அனுமதிக்கின்றன. சிறிய திட்டங்கள் அல்லது பெரிய அளவிலான அமைப்புகளுக்குப் பயன்படுத்தப்பட்டாலும், இந்தக் கருத்துக்கள் அடிப்படையாகவே இருக்கும். ஜாவாவின் சக்திவாய்ந்த கட்டளைகளை மேம்படுத்துவதன் மூலம், டெவலப்பர்கள் இதேபோன்ற சரம் பொருத்துதல் சவால்களை திறம்பட மற்றும் புதுமையான முறையில் தீர்க்க முடியும். 🧩