ಕಂಟ್ರೋಲ್ ಸ್ಟ್ರಿಂಗ್‌ನಿಂದ ಅರೇ ಪದಗಳಿಗೆ ಹೊಂದಾಣಿಕೆಯ ಅಕ್ಷರಗಳು

ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಾಣಿಕೆಯ ಆಧಾರದ ಮೇಲೆ ಅರೇ ಅಂಶಗಳನ್ನು ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಗುಂಪು ಮಾಡುವುದು

ನೆಸ್ಟೆಡ್ ಲೂಪ್‌ಗಳು ಮತ್ತು ಮಾಡ್ಯುಲರ್ ಫಂಕ್ಷನ್‌ಗಳನ್ನು ಬಳಸಿಕೊಂಡು ಜಾವಾ ಆಧಾರಿತ ಪರಿಹಾರ

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

ಎರಡೂ ಪರಿಹಾರಗಳಿಗಾಗಿ ಘಟಕ ಪರೀಕ್ಷೆ

ವಿಭಿನ್ನ ಸನ್ನಿವೇಶಗಳಲ್ಲಿ ಔಟ್‌ಪುಟ್‌ಗಳನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು ಜುನಿಟ್ ಆಧಾರಿತ ಪರೀಕ್ಷೆ

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() ನಿರ್ವಹಿಸಲು ಮತ್ತು ವಿಸ್ತರಿಸಲು ಸುಲಭವಾಗುತ್ತದೆ.

ಸಮರ್ಥ ಸ್ಟ್ರಿಂಗ್ ಹೊಂದಾಣಿಕೆಯ ಅಂತಿಮ ಆಲೋಚನೆಗಳು

ಅರೇ ಪದಗಳೊಂದಿಗೆ ಕಂಟ್ರೋಲ್ ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳನ್ನು ಹೊಂದಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸುವಲ್ಲಿ, ಡಿಡ್ಪ್ಲಿಕೇಶನ್ ಮತ್ತು ಗ್ರೂಪಿಂಗ್‌ನಂತಹ ಪ್ರಮುಖ ತಂತ್ರಗಳನ್ನು ಹೈಲೈಟ್ ಮಾಡಲಾಗಿದೆ. ಇವು ನಿಖರವಾದ ಫಲಿತಾಂಶಗಳನ್ನು ಮತ್ತು ದೊಡ್ಡ ಡೇಟಾಸೆಟ್‌ಗಳ ಸಮರ್ಥ ನಿರ್ವಹಣೆಯನ್ನು ಖಚಿತಪಡಿಸುತ್ತವೆ. ಸರ್ಚ್ ಇಂಜಿನ್‌ಗಳು ಅಥವಾ ಡೇಟಾ ವರ್ಗೀಕರಣದಂತಹ ನೈಜ-ಪ್ರಪಂಚದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಗೆ ಇಂತಹ ಪರಿಹಾರಗಳು ಅತ್ಯಗತ್ಯ.

ಮಾಡ್ಯುಲರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ವಿಧಾನಗಳು, ಮರುಬಳಕೆ ಮಾಡಬಹುದಾದ ವಿಧಾನಗಳ ಮೂಲಕ ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ, ಸುಲಭ ನಿರ್ವಹಣೆ ಮತ್ತು ಸ್ಕೇಲೆಬಿಲಿಟಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತದೆ. ಸಣ್ಣ ಯೋಜನೆಗಳಿಗೆ ಅಥವಾ ದೊಡ್ಡ-ಪ್ರಮಾಣದ ವ್ಯವಸ್ಥೆಗಳಿಗೆ ಅನ್ವಯಿಸಿದರೂ, ಈ ಪರಿಕಲ್ಪನೆಗಳು ಮೂಲಭೂತವಾಗಿ ಉಳಿಯುತ್ತವೆ. ಜಾವಾದ ಶಕ್ತಿಯುತ ಆಜ್ಞೆಗಳನ್ನು ಹತೋಟಿಗೆ ತರುವ ಮೂಲಕ, ಅಭಿವರ್ಧಕರು ಇದೇ ರೀತಿಯ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಸವಾಲುಗಳನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮತ್ತು ನವೀನವಾಗಿ ಪರಿಹರಿಸಬಹುದು. 🧩