नियंत्रण स्ट्रिंग से शब्दों की सारणी में वर्णों का मिलान

स्ट्रिंग मिलान के आधार पर सरणी तत्वों को फ़िल्टर करना और समूहीकृत करना

नेस्टेड लूप और मॉड्यूलर फ़ंक्शंस का उपयोग करके जावा-आधारित समाधान

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

जावा में स्ट्रीम का उपयोग करके अनुकूलित समाधान

जावा 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);
            }
        }
    }
}

दोनों समाधानों के लिए यूनिट टेस्ट

विभिन्न परिदृश्यों में आउटपुट को मान्य करने के लिए JUnit-आधारित परीक्षण

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() इसे बनाए रखना और विस्तार करना आसान बनाता है।

कुशल स्ट्रिंग मिलान पर अंतिम विचार

सरणी शब्दों के साथ नियंत्रण स्ट्रिंग वर्णों के मिलान की समस्या को हल करने में, डिडुप्लीकेशन और ग्रुपिंग जैसी प्रमुख तकनीकों पर प्रकाश डाला गया। ये सटीक परिणाम और बड़े डेटासेट का कुशल संचालन सुनिश्चित करते हैं। ऐसे समाधान वास्तविक दुनिया के अनुप्रयोगों, जैसे खोज इंजन या डेटा वर्गीकरण, के लिए आवश्यक हैं।

मॉड्यूलर प्रोग्रामिंग दृष्टिकोण, पुन: प्रयोज्य तरीकों के माध्यम से प्रदर्शित, आसान रखरखाव और स्केलेबिलिटी की अनुमति देता है। चाहे छोटी परियोजनाओं पर लागू किया जाए या बड़े पैमाने की प्रणालियों पर, ये अवधारणाएँ मौलिक बनी हुई हैं। जावा के शक्तिशाली कमांड का लाभ उठाकर, डेवलपर्स समान स्ट्रिंग मिलान चुनौतियों को प्रभावी ढंग से और नवीन रूप से हल कर सकते हैं। 🧩