ਇੱਕ ਨਿਯੰਤਰਣ ਸਤਰ ਤੋਂ ਐਰੇ ਸ਼ਬਦਾਂ ਤੱਕ ਅੱਖਰਾਂ ਦਾ ਮੇਲ ਕਰਨਾ

ਸਟ੍ਰਿੰਗ ਮੈਚਿੰਗ ਦੇ ਆਧਾਰ 'ਤੇ ਐਰੇ ਐਲੀਮੈਂਟਸ ਨੂੰ ਫਿਲਟਰ ਕਰਨਾ ਅਤੇ ਗਰੁੱਪ ਕਰਨਾ

ਨੇਸਟਡ ਲੂਪਸ ਅਤੇ ਮਾਡਿਊਲਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ Java-ਅਧਾਰਿਤ ਹੱਲ

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

ਦੋਵਾਂ ਹੱਲਾਂ ਲਈ ਯੂਨਿਟ ਟੈਸਟ

ਵੱਖ-ਵੱਖ ਸਥਿਤੀਆਂ ਵਿੱਚ ਆਉਟਪੁੱਟ ਨੂੰ ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ 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. ਇਹ Java's ਵਰਗੇ ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਵੱਖ-ਵੱਖ ਭਾਸ਼ਾਵਾਂ ਜਾਂ ਏਨਕੋਡਿੰਗਾਂ ਵਿੱਚ ਸਤਰ ਲਈ ਸਹੀ ਤੁਲਨਾ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ Collator.
17. ਕੀ ਇਸ ਸਕ੍ਰਿਪਟ ਨੂੰ ਫਰੰਟ-ਐਂਡ ਐਪਲੀਕੇਸ਼ਨਾਂ ਨਾਲ ਜੋੜਿਆ ਜਾ ਸਕਦਾ ਹੈ?
18. ਹਾਂ, ਤਰਕ ਨੂੰ JavaScript ਜਾਂ ਫਰੇਮਵਰਕ ਜਿਵੇਂ ਕਿ ਪਰਸਪਰ ਅਤੇ ਗਤੀਸ਼ੀਲ ਆਉਟਪੁੱਟ ਬਣਾਉਣ ਲਈ React ਵਿੱਚ ਵਰਤਣ ਲਈ ਅਨੁਕੂਲਿਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
19. ਕੋਡ ਨੂੰ ਮਾਡਿਊਲਰ ਕਰਨ ਦਾ ਕੀ ਫਾਇਦਾ ਹੈ?
20. ਕੋਡ ਨੂੰ ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਤਰੀਕਿਆਂ ਵਿੱਚ ਤੋੜਨਾ ਜਿਵੇਂ ਕਿ removeDuplicates() ਅਤੇ matchFirstWithLetter() ਇਸਨੂੰ ਬਰਕਰਾਰ ਰੱਖਣਾ ਅਤੇ ਫੈਲਾਉਣਾ ਆਸਾਨ ਬਣਾਉਂਦਾ ਹੈ।

ਕੁਸ਼ਲ ਸਟ੍ਰਿੰਗ ਮੈਚਿੰਗ 'ਤੇ ਅੰਤਿਮ ਵਿਚਾਰ

ਐਰੇ ਸ਼ਬਦਾਂ ਦੇ ਨਾਲ ਨਿਯੰਤਰਣ ਸਤਰ ਦੇ ਅੱਖਰਾਂ ਨੂੰ ਮਿਲਾਨ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਵਿੱਚ, ਮੁੱਖ ਤਕਨੀਕਾਂ ਜਿਵੇਂ ਕਿ ਡੀਡੁਪਲੀਕੇਸ਼ਨ ਅਤੇ ਗਰੁੱਪਿੰਗ ਨੂੰ ਉਜਾਗਰ ਕੀਤਾ ਗਿਆ ਸੀ। ਇਹ ਵੱਡੇ ਡੇਟਾਸੈਟਾਂ ਦੇ ਸਹੀ ਨਤੀਜੇ ਅਤੇ ਕੁਸ਼ਲ ਪ੍ਰਬੰਧਨ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦੇ ਹਨ। ਅਜਿਹੇ ਹੱਲ ਅਸਲ-ਸੰਸਾਰ ਐਪਲੀਕੇਸ਼ਨਾਂ ਲਈ ਜ਼ਰੂਰੀ ਹਨ, ਜਿਵੇਂ ਕਿ ਖੋਜ ਇੰਜਣ ਜਾਂ ਡੇਟਾ ਵਰਗੀਕਰਨ।

ਮਾਡਯੂਲਰ ਪ੍ਰੋਗਰਾਮਿੰਗ ਪਹੁੰਚ, ਮੁੜ ਵਰਤੋਂ ਯੋਗ ਤਰੀਕਿਆਂ ਦੁਆਰਾ ਪ੍ਰਦਰਸ਼ਿਤ, ਆਸਾਨ ਰੱਖ-ਰਖਾਅ ਅਤੇ ਸਕੇਲੇਬਿਲਟੀ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ। ਭਾਵੇਂ ਛੋਟੇ ਪ੍ਰੋਜੈਕਟਾਂ ਜਾਂ ਵੱਡੇ ਪੈਮਾਨੇ ਦੀਆਂ ਪ੍ਰਣਾਲੀਆਂ 'ਤੇ ਲਾਗੂ ਕੀਤੇ ਜਾਣ, ਇਹ ਧਾਰਨਾਵਾਂ ਬੁਨਿਆਦੀ ਬਣੀਆਂ ਰਹਿੰਦੀਆਂ ਹਨ। Java ਦੀਆਂ ਸ਼ਕਤੀਸ਼ਾਲੀ ਕਮਾਂਡਾਂ ਦਾ ਲਾਭ ਉਠਾ ਕੇ, ਡਿਵੈਲਪਰ ਸਮਾਨ ਸਟ੍ਰਿੰਗ ਮੈਚਿੰਗ ਚੁਣੌਤੀਆਂ ਨੂੰ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਅਤੇ ਨਵੀਨਤਾਕਾਰੀ ਢੰਗ ਨਾਲ ਹੱਲ ਕਰ ਸਕਦੇ ਹਨ। 🧩