ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಕೋರ್ ಅನ್ನು ಆಪ್ಟಿಮೈಜ್ ಮಾಡುವುದು: ಒಂದು ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್ ಇಂಜಿನ್ ನಿರ್ಮಿಸುವುದು

ಸಾಫ್ಟ್‌ವೇರ್ ಅಭಿವೃದ್ಧಿಯ ವಿಶಾಲ ಜಗತ್ತಿನಲ್ಲಿ, ಸ್ಟ್ರಿಂಗ್ ಪ್ರೊಸೆಸಿಂಗ್ ಒಂದು ಮೂಲಭೂತ ಮತ್ತು ಸರ್ವವ್ಯಾಪಿ ಕಾರ್ಯವಾಗಿದೆ. ಟೆಕ್ಸ್ಟ್ ಎಡಿಟರ್‌ನಲ್ಲಿನ ಸರಳ 'ಫೈಂಡ್ ಅಂಡ್ ರಿಪ್ಲೇಸ್'ನಿಂದ ಹಿಡಿದು, ದುರುದ್ದೇಶಪೂರಿತ ಪೇಲೋಡ್‌ಗಳಿಗಾಗಿ ನೆಟ್‌ವರ್ಕ್ ಟ್ರಾಫಿಕ್ ಅನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುವ ಅತ್ಯಾಧುನಿಕ ಒಳನುಗ್ಗುವಿಕೆ ಪತ್ತೆ ವ್ಯವಸ್ಥೆಗಳವರೆಗೆ, ಪಠ್ಯದೊಳಗೆ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ಹುಡುಕುವ ಸಾಮರ್ಥ್ಯವು ಆಧುನಿಕ ಕಂಪ್ಯೂಟಿಂಗ್‌ನ ಅಡಿಗಲ್ಲು. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಕಾರ್ಯಕ್ಷಮತೆಯು ಬಳಕೆದಾರರ ಅನುಭವ ಮತ್ತು ಸರ್ವರ್ ವೆಚ್ಚಗಳ ಮೇಲೆ ನೇರವಾಗಿ ಪರಿಣಾಮ ಬೀರುವ ಪರಿಸರದಲ್ಲಿ ಕಾರ್ಯನಿರ್ವಹಿಸುವಾಗ, ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್‌ನ ಸೂಕ್ಷ್ಮ ವ್ಯತ್ಯಾಸಗಳನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಕೇವಲ ಶೈಕ್ಷಣಿಕ ವ್ಯಾಯಾಮವಲ್ಲ - ಇದು ಒಂದು ನಿರ್ಣಾಯಕ ವೃತ್ತಿಪರ ಕೌಶಲ್ಯವಾಗಿದೆ.

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಅಂತರ್ನಿರ್ಮಿತ ವಿಧಾನಗಳಾದ String.prototype.indexOf(), includes(), ಮತ್ತು ಶಕ್ತಿಯುತ RegExp ಇಂಜಿನ್ ದೈನಂದಿನ ಕಾರ್ಯಗಳಿಗೆ ಉತ್ತಮವಾಗಿ ಸೇವೆ ಸಲ್ಲಿಸುತ್ತವೆಯಾದರೂ, ಅಧಿಕ-ಥ್ರೋಪುಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ಇವು ಕಾರ್ಯಕ್ಷಮತೆಯ ಅಡಚಣೆಗಳಾಗಬಹುದು. ನೀವು ಒಂದು ಬೃಹತ್ ಡಾಕ್ಯುಮೆಂಟ್‌ನಲ್ಲಿ ಸಾವಿರಾರು ಕೀವರ್ಡ್‌ಗಳನ್ನು ಹುಡುಕಬೇಕಾದಾಗ, ಅಥವಾ ಲಕ್ಷಾಂತರ ಲಾಗ್ ನಮೂದುಗಳನ್ನು ನಿಯಮಗಳ ಗುಂಪಿನ ವಿರುದ್ಧ ಮೌಲ್ಯೀಕರಿಸಬೇಕಾದಾಗ, ಸರಳ ವಿಧಾನವು ಸಾಕಾಗುವುದಿಲ್ಲ. ಇಲ್ಲಿಯೇ ನಾವು ನಮ್ಮದೇ ಆದ ಆಪ್ಟಿಮೈಸ್ಡ್ ಸ್ಟ್ರಿಂಗ್ ಪ್ರೊಸೆಸಿಂಗ್ ಇಂಜಿನ್ ಅನ್ನು ನಿರ್ಮಿಸಲು ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಲೈಬ್ರರಿಯನ್ನು ಮೀರಿ, ಕಂಪ್ಯೂಟರ್ ಸೈನ್ಸ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಮತ್ತು ಡೇಟಾ ರಚನೆಗಳ ಜಗತ್ತನ್ನು ಆಳವಾಗಿ ನೋಡಬೇಕು.

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

ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್‌ನ ಸರ್ವವ್ಯಾಪಿ ಸ್ವರೂಪ

ಕೋಡ್‌ಗೆ ಧುಮುಕುವ ಮೊದಲು, ದಕ್ಷ ಸ್ಟ್ರಿಂಗ್ ಮ್ಯಾಚಿಂಗ್ ಅನ್ನು ಅವಲಂಬಿಸಿರುವ ಅಪ್ಲಿಕೇಶನ್‌ಗಳ ವಿಶಾಲ ವ್ಯಾಪ್ತಿಯನ್ನು ಪ್ರಶಂಸಿಸುವುದು ಅತ್ಯಗತ್ಯ. ಈ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಗುರುತಿಸುವುದು ಆಪ್ಟಿಮೈಸೇಶನ್‌ನ ಪ್ರಾಮುಖ್ಯತೆಯನ್ನು ಸಂದರ್ಭಕ್ಕೆ ತರಲು ಸಹಾಯ ಮಾಡುತ್ತದೆ.

• ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್ ಫೈರ್‌ವಾಲ್‌ಗಳು (WAFs): ಭದ್ರತಾ ವ್ಯವಸ್ಥೆಗಳು ಸಾವಿರಾರು ತಿಳಿದಿರುವ ದಾಳಿ ಸಿಗ್ನೇಚರ್‌ಗಳಿಗಾಗಿ (ಉದಾ., SQL ಇಂಜೆಕ್ಷನ್, ಕ್ರಾಸ್-ಸೈಟ್ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಪ್ಯಾಟರ್ನ್‌ಗಳು) ಒಳಬರುವ HTTP ವಿನಂತಿಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತವೆ. ಬಳಕೆದಾರರ ವಿನಂತಿಗಳನ್ನು ವಿಳಂಬಗೊಳಿಸುವುದನ್ನು ತಪ್ಪಿಸಲು ಇದು ಮೈಕ್ರೋಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ನಡೆಯಬೇಕು.
• ಟೆಕ್ಸ್ಟ್ ಎಡಿಟರ್‌ಗಳು ಮತ್ತು IDEಗಳು: ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೈಲೈಟಿಂಗ್, ಇಂಟೆಲಿಜೆಂಟ್ ಸರ್ಚ್, ಮತ್ತು 'ಎಲ್ಲಾ ಸಂಭವಗಳನ್ನು ಹುಡುಕಿ' ಮುಂತಾದ ವೈಶಿಷ್ಟ್ಯಗಳು ಸಂಭಾವ್ಯವಾಗಿ ದೊಡ್ಡ ಸೋರ್ಸ್ ಕೋಡ್ ಫೈಲ್‌ಗಳಲ್ಲಿ ಬಹು ಕೀವರ್ಡ್‌ಗಳು ಮತ್ತು ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ತ್ವರಿತವಾಗಿ ಗುರುತಿಸುವುದನ್ನು ಅವಲಂಬಿಸಿವೆ.
• ಕಂಟೆಂಟ್ ಫಿಲ್ಟರಿಂಗ್ ಮತ್ತು ಮಾಡರೇಶನ್: ಸಾಮಾಜಿಕ ಮಾಧ್ಯಮ ವೇದಿಕೆಗಳು ಮತ್ತು ಫೋರಮ್‌ಗಳು ಬಳಕೆದಾರರು ರಚಿಸಿದ ವಿಷಯವನ್ನು ನೈಜ ಸಮಯದಲ್ಲಿ ಅನುಚಿತ ಪದಗಳು ಅಥವಾ ನುಡಿಗಟ್ಟುಗಳ ದೊಡ್ಡ ನಿಘಂಟಿನ ವಿರುದ್ಧ ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತವೆ.
• ಬಯೋಇನ್ಫರ್ಮ್ಯಾಟಿಕ್ಸ್: ವಿಜ್ಞಾನಿಗಳು ಬೃಹತ್ DNA ಎಳೆಗಳಲ್ಲಿ (ಪಠ್ಯ) ನಿರ್ದಿಷ್ಟ ಜೀನ್ ಅನುಕ್ರಮಗಳನ್ನು (ಪ್ಯಾಟರ್ನ್‌ಗಳು) ಹುಡುಕುತ್ತಾರೆ. ಈ ಅಲ್ಗಾರಿದಮ್‌ಗಳ ದಕ್ಷತೆಯು ಜೀನೋಮಿಕ್ ಸಂಶೋಧನೆಗೆ ಅತಿಮುಖ್ಯವಾಗಿದೆ.
• ಡೇಟಾ ಲಾಸ್ ಪ್ರಿವೆನ್ಷನ್ (DLP) ಸಿಸ್ಟಮ್ಸ್: ಈ ಪರಿಕರಗಳು ಡೇಟಾ ಉಲ್ಲಂಘನೆಗಳನ್ನು ತಡೆಯಲು ಕ್ರೆಡಿಟ್ ಕಾರ್ಡ್ ಸಂಖ್ಯೆಗಳು ಅಥವಾ ಆಂತರಿಕ ಪ್ರಾಜೆಕ್ಟ್ ಕೋಡ್‌ನೇಮ್‌ಗಳಂತಹ ಸೂಕ್ಷ್ಮ ಮಾಹಿತಿ ಪ್ಯಾಟರ್ನ್‌ಗಳಿಗಾಗಿ ಹೊರಹೋಗುವ ಇಮೇಲ್‌ಗಳು ಮತ್ತು ಫೈಲ್‌ಗಳನ್ನು ಸ್ಕ್ಯಾನ್ ಮಾಡುತ್ತವೆ.
• ಸರ್ಚ್ ಇಂಜಿನ್‌ಗಳು: ತಮ್ಮ ಮೂಲದಲ್ಲಿ, ಸರ್ಚ್ ಇಂಜಿನ್‌ಗಳು ಅತ್ಯಾಧುನಿಕ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚರ್‌ಗಳಾಗಿದ್ದು, ವೆಬ್ ಅನ್ನು ಇಂಡೆಕ್ಸ್ ಮಾಡಿ ಬಳಕೆದಾರರು ಪ್ರಶ್ನಿಸಿದ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹೊಂದಿರುವ ಡಾಕ್ಯುಮೆಂಟ್‌ಗಳನ್ನು ಹುಡುಕುತ್ತವೆ.

ಈ ಪ್ರತಿಯೊಂದು ಸನ್ನಿವೇಶಗಳಲ್ಲಿ, ಕಾರ್ಯಕ್ಷಮತೆ ಒಂದು ಐಷಾರಾಮಿಯಾಗಿಲ್ಲ; ಇದು ಒಂದು ಪ್ರಮುಖ ಅವಶ್ಯಕತೆಯಾಗಿದೆ. ನಿಧಾನವಾದ ಅಲ್ಗಾರಿದಮ್ ಭದ್ರತಾ ದೋಷಗಳಿಗೆ, ಕಳಪೆ ಬಳಕೆದಾರ ಅನುಭವಕ್ಕೆ, ಅಥವಾ ನಿಷೇಧಿತ ಗಣನಾ ವೆಚ್ಚಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು.

ಸರಳ ವಿಧಾನ ಮತ್ತು ಅದರ ಅನಿವಾರ್ಯ ಅಡಚಣೆ

ಪಠ್ಯದಲ್ಲಿ ಒಂದು ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಹುಡುಕಲು ಅತ್ಯಂತ ನೇರವಾದ ಮಾರ್ಗದಿಂದ ಪ್ರಾರಂಭಿಸೋಣ: ಬ್ರೂಟ್-ಫೋರ್ಸ್ ವಿಧಾನ. ತರ್ಕ ಸರಳವಾಗಿದೆ: ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪಠ್ಯದ ಮೇಲೆ ಒಂದು ಸಮಯದಲ್ಲಿ ಒಂದು ಅಕ್ಷರದಂತೆ ಸ್ಲೈಡ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿ ಸ್ಥಾನದಲ್ಲಿ, ಪ್ಯಾಟರ್ನ್ ಅನುಗುಣವಾದ ಪಠ್ಯದ ಭಾಗಕ್ಕೆ ಹೊಂದಿಕೆಯಾಗುತ್ತದೆಯೇ ಎಂದು ಪರಿಶೀಲಿಸಿ.

ಬ್ರೂಟ್-ಫೋರ್ಸ್ ಇಂಪ್ಲಿಮೆಂಟೇಶನ್

ನಾವು ಒಂದು ದೊಡ್ಡ ಪಠ್ಯದಲ್ಲಿ ಒಂದೇ ಪ್ಯಾಟರ್ನ್‌ನ ಎಲ್ಲಾ ಸಂಭವಗಳನ್ನು ಹುಡುಕಬೇಕೆಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ.

            
function naiveSearch(text, pattern) {
    const textLength = text.length;
    const patternLength = pattern.length;
    const occurrences = [];

    if (patternLength === 0) return [];

    for (let i = 0; i <= textLength - patternLength; i++) {
        let match = true;
        for (let j = 0; j < patternLength; j++) {
            if (text[i + j] !== pattern[j]) {
                match = false;
                break;
            }
        }
        if (match) {
            occurrences.push(i);
        }
    }

    return occurrences;
}

const text = "abracadabra";
const pattern = "abra";
console.log(naiveSearch(text, pattern)); // Output: [0, 7]

            

              
                Copy
              
            
          

ಅದು ಏಕೆ ವಿಫಲವಾಗುತ್ತದೆ: ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿ ವಿಶ್ಲೇಷಣೆ

ಹೊರಗಿನ ಲೂಪ್ ಸುಮಾರು N ಬಾರಿ (ಇಲ್ಲಿ N ಪಠ್ಯದ ಉದ್ದ) ಮತ್ತು ಒಳಗಿನ ಲೂಪ್ M ಬಾರಿ (ಇಲ್ಲಿ M ಪ್ಯಾಟರ್ನ್‌ನ ಉದ್ದ) ಚಲಿಸುತ್ತದೆ. ಇದು ಅಲ್ಗಾರಿದಮ್‌ಗೆ O(N * M) ನ ಟೈಮ್ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿಯನ್ನು ನೀಡುತ್ತದೆ. ಸಣ್ಣ ಸ್ಟ್ರಿಂಗ್‌ಗಳಿಗೆ, ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಸರಿಯಾಗಿದೆ. ಆದರೆ 10MB ಪಠ್ಯ (≈10,000,000 ಅಕ್ಷರಗಳು) ಮತ್ತು 100-ಅಕ್ಷರದ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಪರಿಗಣಿಸಿ. ಹೋಲಿಕೆಗಳ ಸಂಖ್ಯೆ ಶತಕೋಟಿಗಳಲ್ಲಿರಬಹುದು.

ಈಗ, ನಾವು K ವಿಭಿನ್ನ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹುಡುಕಬೇಕಾದರೆ ಏನು? ಸರಳ ವಿಸ್ತರಣೆಯು ನಮ್ಮ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿಯೊಂದಕ್ಕೂ ನೇರ ಹುಡುಕಾಟವನ್ನು ನಡೆಸುವುದು, ಇದು O(K * N * M) ನ ಭಯಾನಕ ಕಾಂಪ್ಲೆಕ್ಸಿಟಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ. ಯಾವುದೇ ಗಂಭೀರ ಅಪ್ಲಿಕೇಶನ್‌ಗೆ ಈ ವಿಧಾನವು ಸಂಪೂರ್ಣವಾಗಿ ವಿಫಲಗೊಳ್ಳುವ ಸ್ಥಳ ಇದಾಗಿದೆ.

ಬ್ರೂಟ್-ಫೋರ್ಸ್ ವಿಧಾನದ ಪ್ರಮುಖ ಅಸಮರ್ಥತೆಯೆಂದರೆ ಅದು ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದಾಗ (mismatch) ಏನನ್ನೂ ಕಲಿಯುವುದಿಲ್ಲ. ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದಾಗ, ಅದು ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಕೇವಲ ಒಂದು ಸ್ಥಾನದಿಂದ ಬದಲಾಯಿಸುತ್ತದೆ ಮತ್ತು ಹೋಲಿಕೆಯನ್ನು ಮತ್ತೆ ಮೊದಲಿನಿಂದ ಪ್ರಾರಂಭಿಸುತ್ತದೆ, ಹೊಂದಾಣಿಕೆಯಾಗದ ಮಾಹಿತಿಯು ನಮಗೆ ಹೆಚ್ಚು ದೂರಕ್ಕೆ ಬದಲಾಯಿಸಲು ಹೇಳಬಹುದಾಗಿದ್ದರೂ ಸಹ.

ಮೂಲಭೂತ ಆಪ್ಟಿಮೈಸೇಶನ್ ತಂತ್ರಗಳು: ಕಷ್ಟಪಟ್ಟು ಯೋಚಿಸುವುದಕ್ಕಿಂತ, ಚಾಣಾಕ್ಷತನದಿಂದ ಯೋಚಿಸುವುದು

ಸರಳ ವಿಧಾನದ ಮಿತಿಗಳನ್ನು ಮೀರಿಸಲು, ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನಿಗಳು ಹುಡುಕಾಟದ ಹಂತವನ್ನು ನಂಬಲಾಗದಷ್ಟು ವೇಗಗೊಳಿಸಲು ಪೂರ್ವ-ಗಣನೆಯನ್ನು ಬಳಸುವ ಅದ್ಭುತ ಅಲ್ಗಾರಿದಮ್‌ಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿದ್ದಾರೆ. ಅವರು ಮೊದಲು ಪ್ಯಾಟರ್ನ್(ಗಳ) ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಸಂಗ್ರಹಿಸುತ್ತಾರೆ, ನಂತರ ಆ ಮಾಹಿತಿಯನ್ನು ಹುಡುಕಾಟದ ಸಮಯದಲ್ಲಿ ಪಠ್ಯದ ದೊಡ್ಡ ಭಾಗಗಳನ್ನು ಬಿಟ್ಟುಬಿಡಲು ಬಳಸುತ್ತಾರೆ.

ಏಕ ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್: ಬೋಯರ್-ಮೂರ್ ಮತ್ತು ಕೆಎಂಪಿ

ಒಂದೇ ಪ್ಯಾಟರ್ನ್‌ಗಾಗಿ ಹುಡುಕುವಾಗ, ಎರಡು ಕ್ಲಾಸಿಕ್ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ಪ್ರಾಬಲ್ಯ ಹೊಂದಿವೆ: ಬೋಯರ್-ಮೂರ್ ಮತ್ತು ನುಥ್-ಮೋರಿಸ್-ಪ್ರಾಟ್ (KMP).

• ಬೋಯರ್-ಮೂರ್ ಅಲ್ಗಾರಿದಮ್: ಇದು ಪ್ರಾಯೋಗಿಕ ಸ್ಟ್ರಿಂಗ್ ಹುಡುಕಾಟಕ್ಕೆ ಮಾನದಂಡವಾಗಿದೆ. ಇದರ ಪ್ರತಿಭೆ ಎರಡು ಹ್ಯೂರಿಸ್ಟಿಕ್‌ಗಳಲ್ಲಿದೆ. ಮೊದಲನೆಯದಾಗಿ, ಇದು ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಎಡದಿಂದ ಬಲಕ್ಕೆ ಬದಲಾಗಿ ಬಲದಿಂದ ಎಡಕ್ಕೆ ಹೊಂದಿಸುತ್ತದೆ. ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದಾಗ, ಗರಿಷ್ಠ ಸುರಕ್ಷಿತ ಮುಂದಿನ ಶಿಫ್ಟ್ ಅನ್ನು ನಿರ್ಧರಿಸಲು ಇದು ಪೂರ್ವ-ಗಣನೆ ಮಾಡಿದ 'ಬ್ಯಾಡ್ ಕ್ಯಾರೆಕ್ಟರ್ ಟೇಬಲ್' ಅನ್ನು ಬಳಸುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ನಾವು "EXAMPLE" ಅನ್ನು ಪಠ್ಯದ ವಿರುದ್ಧ ಹೊಂದಿಸುತ್ತಿದ್ದರೆ ಮತ್ತು ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದರೆ, ಮತ್ತು ಪಠ್ಯದಲ್ಲಿನ ಅಕ್ಷರ 'Z' ಆಗಿದ್ದರೆ, 'Z' "EXAMPLE" ನಲ್ಲಿ ಕಾಣಿಸುವುದಿಲ್ಲ ಎಂದು ನಮಗೆ ತಿಳಿದಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಸಂಪೂರ್ಣ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಈ ಬಿಂದುವನ್ನು ದಾಟಿ ಶಿಫ್ಟ್ ಮಾಡಬಹುದು. ಇದು ಪ್ರಾಯೋಗಿಕವಾಗಿ ಉಪ-ರೇಖೀಯ ಕಾರ್ಯಕ್ಷಮತೆಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
• ನುಥ್-ಮೋರಿಸ್-ಪ್ರಾಟ್ (KMP) ಅಲ್ಗಾರಿದಮ್: KMP ಯ ನಾವೀನ್ಯತೆಯು ಪೂರ್ವ-ಗಣನೆ ಮಾಡಿದ 'ಪ್ರಿಫಿಕ್ಸ್ ಫಂಕ್ಷನ್' ಅಥವಾ ಲಾಂಗೆಸ್ಟ್ ಪ್ರಾಪರ್ ಪ್ರಿಫಿಕ್ಸ್ ಸಫಿಕ್ಸ್ (LPS) ಅರೇ ಆಗಿದೆ. ಈ ಅರೇಯು ಪ್ಯಾಟರ್ನ್‌ನ ಯಾವುದೇ ಪ್ರಿಫಿಕ್ಸ್‌ಗೆ, ಅತಿ ಉದ್ದದ ಸರಿಯಾದ ಪ್ರಿಫಿಕ್ಸ್‌ನ ಉದ್ದವನ್ನು ಹೇಳುತ್ತದೆ ಅದು ಸಫಿಕ್ಸ್ ಕೂಡ ಆಗಿದೆ. ಈ ಮಾಹಿತಿಯು ಅಲ್ಗಾರಿದಮ್‌ಗೆ ಹೊಂದಾಣಿಕೆಯಾಗದ ನಂತರ ಅನಗತ್ಯ ಹೋಲಿಕೆಗಳನ್ನು ತಪ್ಪಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ. ಹೊಂದಾಣಿಕೆಯಾಗದಿದ್ದಾಗ, ಒಂದರಿಂದ ಶಿಫ್ಟ್ ಮಾಡುವ ಬದಲು, ಅದು LPS ಮೌಲ್ಯವನ್ನು ಆಧರಿಸಿ ಪ್ಯಾಟರ್ನ್ ಅನ್ನು ಶಿಫ್ಟ್ ಮಾಡುತ್ತದೆ, ಹಿಂದೆ ಹೊಂದಾಣಿಕೆಯಾದ ಭಾಗದಿಂದ ಮಾಹಿತಿಯನ್ನು ಪರಿಣಾಮಕಾರಿಯಾಗಿ ಮರುಬಳಕೆ ಮಾಡುತ್ತದೆ.

ಇವು ಏಕ-ಪ್ಯಾಟರ್ನ್ ಹುಡುಕಾಟಗಳಿಗೆ ಆಕರ್ಷಕ ಮತ್ತು ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ನಮ್ಮ ಗುರಿಯು ಗರಿಷ್ಠ ದಕ್ಷತೆಯೊಂದಿಗೆ ಬಹು ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸುವ ಇಂಜಿನ್ ಅನ್ನು ನಿರ್ಮಿಸುವುದಾಗಿದೆ. ಅದಕ್ಕಾಗಿ, ನಮಗೆ ವಿಭಿನ್ನ ರೀತಿಯ ಪ್ರಾಣಿಯ ಅಗತ್ಯವಿದೆ.

ಬಹು-ಪ್ಯಾಟರ್ನ್ ಮ್ಯಾಚಿಂಗ್: ಅಹೋ-ಕೊರಾಸಿಕ್ ಅಲ್ಗಾರಿದಮ್

ಆಲ್ಫ್ರೆಡ್ ಅಹೋ ಮತ್ತು ಮಾರ್ಗರೆಟ್ ಕೊರಾಸಿಕ್ ಅವರಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲ್ಪಟ್ಟ ಅಹೋ-ಕೊರಾಸಿಕ್ ಅಲ್ಗಾರಿದಮ್, ಪಠ್ಯದಲ್ಲಿ ಬಹು ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು ಹುಡುಕಲು ನಿರ್ವಿವಾದ ಚಾಂಪಿಯನ್ ಆಗಿದೆ. ಇದು ಯುನಿಕ್ಸ್ ಕಮಾಂಡ್ `fgrep` ನಂತಹ ಸಾಧನಗಳಿಗೆ ಆಧಾರವಾಗಿರುವ ಅಲ್ಗಾರಿದಮ್ ಆಗಿದೆ. ಇದರ ಮ್ಯಾಜಿಕ್ ಏನೆಂದರೆ, ಅದರ ಹುಡುಕಾಟದ ಸಮಯ O(N + L + Z), ಇಲ್ಲಿ N ಪಠ್ಯದ ಉದ್ದ, L ಎಲ್ಲಾ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಒಟ್ಟು ಉದ್ದ, ಮತ್ತು Z ಹೊಂದಾಣಿಕೆಗಳ ಸಂಖ್ಯೆ. ಗಮನಿಸಿ, ಪ್ಯಾಟರ್ನ್‌ಗಳ ಸಂಖ್ಯೆ (K) ಹುಡುಕಾಟದ ಸಂಕೀರ್ಣತೆಯಲ್ಲಿ ಗುಣಕವಲ್ಲ! ಇದೊಂದು ಸ್ಮಾರಕ ಸುಧಾರಣೆಯಾಗಿದೆ.

ಇದು ಇದನ್ನು ಹೇಗೆ ಸಾಧಿಸುತ್ತದೆ? ಎರಡು ಪ್ರಮುಖ ಡೇಟಾ ರಚನೆಗಳನ್ನು ಸಂಯೋಜಿಸುವ ಮೂಲಕ:

1. ಒಂದು ಟ್ರೈ (ಪ್ರಿಫಿಕ್ಸ್ ಟ್ರೀ): ಇದು ಮೊದಲು ಎಲ್ಲಾ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು (ನಮ್ಮ ಕೀವರ್ಡ್‌ಗಳ ನಿಘಂಟು) ಹೊಂದಿರುವ ಟ್ರೈ ಅನ್ನು ನಿರ್ಮಿಸುತ್ತದೆ.
2. ಫೇಲ್ಯೂರ್ ಲಿಂಕ್‌ಗಳು: ನಂತರ ಇದು ಟ್ರೈ ಅನ್ನು 'ಫೇಲ್ಯೂರ್ ಲಿಂಕ್‌ಗಳೊಂದಿಗೆ' ವೃದ್ಧಿಸುತ್ತದೆ. ಒಂದು ನೋಡ್‌ಗಾಗಿ ಫೇಲ್ಯೂರ್ ಲಿಂಕ್, ಆ ನೋಡ್‌ನಿಂದ ಪ್ರತಿನಿಧಿಸುವ ಸ್ಟ್ರಿಂಗ್‌ನ ಅತಿ ಉದ್ದದ ಸರಿಯಾದ ಸಫಿಕ್ಸ್‌ಗೆ ಸೂಚಿಸುತ್ತದೆ, ಅದು ಟ್ರೈನಲ್ಲಿನ ಕೆಲವು ಪ್ಯಾಟರ್ನ್‌ನ ಪ್ರಿಫಿಕ್ಸ್ ಕೂಡ ಆಗಿರುತ್ತದೆ.

ಈ ಸಂಯೋಜಿತ ರಚನೆಯು ಒಂದು ಸೀಮಿತ ಆಟೋಮ್ಯಾಟನ್ ಅನ್ನು ರೂಪಿಸುತ್ತದೆ. ಹುಡುಕಾಟದ ಸಮಯದಲ್ಲಿ, ನಾವು ಪಠ್ಯವನ್ನು ಒಂದೊಂದೇ ಅಕ್ಷರವಾಗಿ ಪ್ರಕ್ರಿಯೆಗೊಳಿಸುತ್ತೇವೆ, ಆಟೋಮ್ಯಾಟನ್ ಮೂಲಕ ಚಲಿಸುತ್ತೇವೆ. ನಾವು ಅಕ್ಷರ ಲಿಂಕ್ ಅನ್ನು ಅನುಸರಿಸಲು ಸಾಧ್ಯವಾಗದಿದ್ದರೆ, ನಾವು ಫೇಲ್ಯೂರ್ ಲಿಂಕ್ ಅನ್ನು ಅನುಸರಿಸುತ್ತೇವೆ. ಇದು ಇನ್‌ಪುಟ್ ಪಠ್ಯದಲ್ಲಿನ ಅಕ್ಷರಗಳನ್ನು ಮರು-ಸ್ಕ್ಯಾನ್ ಮಾಡದೆಯೇ ಹುಡುಕಾಟವನ್ನು ಮುಂದುವರಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ.

ರೆಗ್ಯುಲರ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್‌ಗಳ ಬಗ್ಗೆ ಒಂದು ಟಿಪ್ಪಣಿ

ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ `RegExp` ಇಂಜಿನ್ ನಂಬಲಾಗದಷ್ಟು ಶಕ್ತಿಯುತ ಮತ್ತು ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಲ್ಪಟ್ಟಿದೆ, ಇದನ್ನು ಹೆಚ್ಚಾಗಿ ನೇಟಿವ್ C++ ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ. ಅನೇಕ ಕಾರ್ಯಗಳಿಗೆ, ಉತ್ತಮವಾಗಿ ಬರೆಯಲಾದ ರೆಜೆಕ್ಸ್ ಅತ್ಯುತ್ತಮ ಸಾಧನವಾಗಿದೆ. ಆದಾಗ್ಯೂ, ಇದು ಕಾರ್ಯಕ್ಷಮತೆಯ ಬಲೆಯೂ ಆಗಿರಬಹುದು.

• ಕ್ಯಾಟಾಸ್ಟ್ರೋಫಿಕ್ ಬ್ಯಾಕ್‌ಟ್ರ್ಯಾಕಿಂಗ್: ನೆಸ್ಟೆಡ್ ಕ್ವಾಂಟಿಫೈಯರ್‌ಗಳು ಮತ್ತು ಪರ್ಯಾಯಗಳೊಂದಿಗೆ (ಉದಾ., (a|b|c*)*) ಕಳಪೆಯಾಗಿ ನಿರ್ಮಿಸಲಾದ ರೆಜೆಕ್ಸ್‌ಗಳು ಕೆಲವು ಇನ್‌ಪುಟ್‌ಗಳಲ್ಲಿ ಘಾತೀಯ ರನ್‌ಟೈಮ್‌ಗಳಿಗೆ ಕಾರಣವಾಗಬಹುದು. ಇದು ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಅಥವಾ ಸರ್ವರ್ ಅನ್ನು ಫ್ರೀಜ್ ಮಾಡಬಹುದು.
• ಓವರ್‌ಹೆಡ್: ಸಂಕೀರ್ಣ ರೆಜೆಕ್ಸ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುವುದಕ್ಕೆ ಆರಂಭಿಕ ವೆಚ್ಚವಿದೆ. ದೊಡ್ಡ ಗುಂಪಿನ ಸರಳ, ಸ್ಥಿರ ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ಹುಡುಕಲು, ರೆಜೆಕ್ಸ್ ಇಂಜಿನ್‌ನ ಓವರ್‌ಹೆಡ್ ಅಹೋ-ಕೊರಾಸಿಕ್‌ನಂತಹ ವಿಶೇಷ ಅಲ್ಗಾರಿದಮ್‌ಗಿಂತ ಹೆಚ್ಚಾಗಿರಬಹುದು.

ಆಪ್ಟಿಮೈಸೇಶನ್ ಸಲಹೆ: ಬಹು ಕೀವರ್ಡ್‌ಗಳಿಗಾಗಿ ರೆಜೆಕ್ಸ್ ಬಳಸುವಾಗ, ಅವುಗಳನ್ನು ಸಮರ್ಥವಾಗಿ ಸಂಯೋಜಿಸಿ. str.match(/cat|)|str.match(/dog/)|str.match(/bird/) ಬದಲಿಗೆ, ಒಂದೇ ರೆಜೆಕ್ಸ್ ಬಳಸಿ: str.match(/cat|dog|bird/g). ಇಂಜಿನ್ ಈ ಒಂದೇ ಪಾಸ್ ಅನ್ನು ಹೆಚ್ಚು ಉತ್ತಮವಾಗಿ ಆಪ್ಟಿಮೈಜ್ ಮಾಡಬಹುದು.

ನಮ್ಮ ಅಹೋ-ಕೊರಾಸಿಕ್ ಇಂಜಿನ್ ನಿರ್ಮಾಣ: ಹಂತ-ಹಂತದ ಮಾರ್ಗದರ್ಶಿ

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

ಹಂತ 1: ಟ್ರೈ ಡೇಟಾ ರಚನೆಯ ಅಡಿಪಾಯ

ಟ್ರೈ ಎಂಬುದು ಒಂದು ಮರದಂತಹ ಡೇಟಾ ರಚನೆಯಾಗಿದ್ದು, ಪ್ರತಿ ನೋಡ್ ಒಂದು ಅಕ್ಷರವನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ರೂಟ್‌ನಿಂದ ಒಂದು ನೋಡ್‌ಗೆ ಹೋಗುವ ಮಾರ್ಗಗಳು ಪ್ರಿಫಿಕ್ಸ್‌ಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತವೆ. ಪೂರ್ಣಗೊಂಡ ಪ್ಯಾಟರ್ನ್‌ನ ಅಂತ್ಯವನ್ನು ಸೂಚಿಸುವ ನೋಡ್‌ಗಳಿಗೆ ನಾವು `output` ಅರೇ ಅನ್ನು ಸೇರಿಸುತ್ತೇವೆ.

            
class TrieNode {
    constructor() {
        this.children = {}; // Maps characters to other TrieNodes
        this.isEndOfWord = false;
        this.output = []; // Stores patterns that end at this node
        this.failureLink = null; // To be added later
    }
}

class AhoCorasickEngine {
    constructor(patterns) {
        this.root = new TrieNode();
        this.buildTrie(patterns);
        this.buildFailureLinks();
    }

    /**
     * Builds the basic Trie from a list of patterns.
     */
    buildTrie(patterns) {
        for (const pattern of patterns) {
            if (typeof pattern !== 'string' || pattern.length === 0) continue;
            let currentNode = this.root;
            for (const char of pattern) {
                if (!currentNode.children[char]) {
                    currentNode.children[char] = new TrieNode();
                }
                currentNode = currentNode.children[char];
            }
            currentNode.isEndOfWord = true;
            currentNode.output.push(pattern);
        }
    }

    // ... buildFailureLinks and search methods to come
}

            

              
                Copy
              
            
          

ಹಂತ 2: ಫೇಲ್ಯೂರ್ ಲಿಂಕ್‌ಗಳ ಜಾಲವನ್ನು ಹೆಣೆಯುವುದು

ಇದು ಅತ್ಯಂತ ನಿರ್ಣಾಯಕ ಮತ್ತು ಪರಿಕಲ್ಪನಾತ್ಮಕವಾಗಿ ಸಂಕೀರ್ಣವಾದ ಭಾಗವಾಗಿದೆ. ನಾವು ಪ್ರತಿ ನೋಡ್‌ಗೆ ಫೇಲ್ಯೂರ್ ಲಿಂಕ್‌ಗಳನ್ನು ನಿರ್ಮಿಸಲು ರೂಟ್‌ನಿಂದ ಪ್ರಾರಂಭವಾಗುವ ಬ್ರೆಡ್ತ್-ಫಸ್ಟ್ ಸರ್ಚ್ (BFS) ಅನ್ನು ಬಳಸುತ್ತೇವೆ. ರೂಟ್‌ನ ಫೇಲ್ಯೂರ್ ಲಿಂಕ್ ತನ್ನನ್ನೇ ಸೂಚಿಸುತ್ತದೆ. ಯಾವುದೇ ಇತರ ನೋಡ್‌ಗೆ, ಅದರ ಫೇಲ್ಯೂರ್ ಲಿಂಕ್ ಅನ್ನು ಅದರ ಪೋಷಕರ ಫೇಲ್ಯೂರ್ ಲಿಂಕ್ ಅನ್ನು ದಾಟುವ ಮೂಲಕ ಮತ್ತು ಪ್ರಸ್ತುತ ನೋಡ್‌ನ ಅಕ್ಷರಕ್ಕೆ ಒಂದು ಮಾರ್ಗ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆಯೇ ಎಂದು ನೋಡುವ ಮೂಲಕ ಕಂಡುಹಿಡಿಯಲಾಗುತ್ತದೆ.

            
// Add this method inside the AhoCorasickEngine class

buildFailureLinks() {
    const queue = [];
    this.root.failureLink = this.root; // The root's failure link points to itself

    // Start BFS with the children of the root
    for (const char in this.root.children) {
        const node = this.root.children[char];
        node.failureLink = this.root;
        queue.push(node);
    }

    while (queue.length > 0) {
        const currentNode = queue.shift();

        for (const char in currentNode.children) {
            const nextNode = currentNode.children[char];
            let failureNode = currentNode.failureLink;

            // Traverse failure links until we find a node with a transition for the current character,
            // or we reach the root.
            while (failureNode.children[char] === undefined && failureNode !== this.root) {
                failureNode = failureNode.failureLink;
            }

            if (failureNode.children[char]) {
                nextNode.failureLink = failureNode.children[char];
            } else {
                nextNode.failureLink = this.root;
            }

            // Also, merge the output of the failure link node with the current node's output.
            // This ensures we find patterns that are suffixes of other patterns (e.g., finding "he" in "she").
            nextNode.output.push(...nextNode.failureLink.output);

            queue.push(nextNode);
        }
    }
}

            

              
                Copy
              
            
          

ಹಂತ 3: ಅಧಿಕ-ವೇಗದ ಸರ್ಚ್ ಫಂಕ್ಷನ್

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

            
// Add this method inside the AhoCorasickEngine class

search(text) {
    let currentNode = this.root;
    const results = [];

    for (let i = 0; i < text.length; i++) {
        const char = text[i];

        while (currentNode.children[char] === undefined && currentNode !== this.root) {
            currentNode = currentNode.failureLink;
        }

        if (currentNode.children[char]) {
            currentNode = currentNode.children[char];
        } 
        // If we are at the root and there's no path for the current char, we stay at the root.

        if (currentNode.output.length > 0) {
            for (const pattern of currentNode.output) {
                results.push({
                    pattern: pattern,
                    index: i - pattern.length + 1
                });
            }
        }
    }

    return results;
}

            

              
                Copy
              
            
          

ಎಲ್ಲವನ್ನೂ ಒಟ್ಟಿಗೆ ಸೇರಿಸುವುದು: ಒಂದು ಸಂಪೂರ್ಣ ಉದಾಹರಣೆ

            
// (Include the full TrieNode and AhoCorasickEngine class definitions from above)

const patterns = ["he", "she", "his", "hers"];
const text = "ushers";

const engine = new AhoCorasickEngine(patterns);
const matches = engine.search(text);

console.log(matches);
// Expected Output:
// [
//   { pattern: 'he', index: 2 },
//   { pattern: 'she', index: 1 },
//   { pattern: 'hers', index: 2 }
// ]

            

              
                Copy
              
            
          

ನಮ್ಮ ಇಂಜಿನ್ "ushers" ನ ಇಂಡೆಕ್ಸ್ 5 ರಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ "he" ಮತ್ತು "hers" ಅನ್ನು ಮತ್ತು ಇಂಡೆಕ್ಸ್ 3 ರಲ್ಲಿ ಕೊನೆಗೊಳ್ಳುವ "she" ಅನ್ನು ಹೇಗೆ ಸರಿಯಾಗಿ ಕಂಡುಹಿಡಿದಿದೆ ಎಂಬುದನ್ನು ಗಮನಿಸಿ. ಇದು ಫೇಲ್ಯೂರ್ ಲಿಂಕ್‌ಗಳು ಮತ್ತು ವಿಲೀನಗೊಂಡ ಔಟ್‌ಪುಟ್‌ಗಳ ಶಕ್ತಿಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

ಅಲ್ಗಾರಿದಮ್‌ನ್ನು ಮೀರಿ: ಇಂಜಿನ್-ಮಟ್ಟದ ಮತ್ತು ಪರಿಸರಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳು

ಒಂದು ಉತ್ತಮ ಅಲ್ಗಾರಿದಮ್ ನಮ್ಮ ಇಂಜಿನ್‌ನ ಹೃದಯವಾಗಿದೆ, ಆದರೆ V8 (Chrome ಮತ್ತು Node.js ನಲ್ಲಿ) ನಂತಹ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರದಲ್ಲಿ ಗರಿಷ್ಠ ಕಾರ್ಯಕ್ಷಮತೆಗಾಗಿ, ನಾವು ಮತ್ತಷ್ಟು ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಪರಿಗಣಿಸಬಹುದು.

• ಪೂರ್ವ-ಗಣನೆಯೇ ಪ್ರಮುಖ: ಅಹೋ-ಕೊರಾಸಿಕ್ ಆಟೋಮ್ಯಾಟನ್ ಅನ್ನು ನಿರ್ಮಿಸುವ ವೆಚ್ಚವನ್ನು ಒಮ್ಮೆ ಮಾತ್ರ ಪಾವತಿಸಲಾಗುತ್ತದೆ. ನಿಮ್ಮ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಸೆಟ್ ಸ್ಥಿರವಾಗಿದ್ದರೆ (WAF ನಿಯಮಗಳ ಸೆಟ್ ಅಥವಾ ಅಶ್ಲೀಲತೆಯ ಫಿಲ್ಟರ್‌ನಂತೆ), ಇಂಜಿನ್ ಅನ್ನು ಒಮ್ಮೆ ನಿರ್ಮಿಸಿ ಮತ್ತು ಲಕ್ಷಾಂತರ ಹುಡುಕಾಟಗಳಿಗೆ ಅದನ್ನು ಮರುಬಳಕೆ ಮಾಡಿ. ಇದು ಸೆಟಪ್ ವೆಚ್ಚವನ್ನು ಶೂನ್ಯಕ್ಕೆ ಹತ್ತಿರವಾಗಿಸುತ್ತದೆ.
• ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯ: ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್‌ಗಳು ಹೆಚ್ಚು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಆಂತರಿಕ ಸ್ಟ್ರಿಂಗ್ ಪ್ರಾತಿನಿಧ್ಯಗಳನ್ನು ಹೊಂದಿವೆ. ಒಂದು ಟೈಟ್ ಲೂಪ್‌ನಲ್ಲಿ ಅನೇಕ ಸಣ್ಣ ಸಬ್‌ಸ್ಟ್ರಿಂಗ್‌ಗಳನ್ನು ರಚಿಸುವುದನ್ನು ತಪ್ಪಿಸಿ (ಉದಾ., `text.substring()` ಅನ್ನು ಪದೇ ಪದೇ ಬಳಸುವುದು). ಇಂಡೆಕ್ಸ್ ಮೂಲಕ ಅಕ್ಷರಗಳನ್ನು ಪ್ರವೇಶಿಸುವುದು (`text[i]`) ಸಾಮಾನ್ಯವಾಗಿ ಬಹಳ ವೇಗವಾಗಿರುತ್ತದೆ.
• ಮೆಮೊರಿ ನಿರ್ವಹಣೆ: ಅತ್ಯಂತ ದೊಡ್ಡ ಪ್ಯಾಟರ್ನ್‌ಗಳ ಸೆಟ್‌ಗಾಗಿ, ಟ್ರೈ ಗಮನಾರ್ಹ ಪ್ರಮಾಣದ ಮೆಮೊರಿಯನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. ಇದರ ಬಗ್ಗೆ ಗಮನವಿರಲಿ. ಅಂತಹ ಸಂದರ್ಭಗಳಲ್ಲಿ, ರೋಲಿಂಗ್ ಹ್ಯಾಶ್‌ಗಳೊಂದಿಗೆ ರಾಬಿನ್-ಕಾರ್ಪ್‌ನಂತಹ ಇತರ ಅಲ್ಗಾರಿದಮ್‌ಗಳು ವೇಗ ಮತ್ತು ಮೆಮೊರಿ ನಡುವೆ ವಿಭಿನ್ನ ವಿನಿಮಯವನ್ನು ನೀಡಬಹುದು.
• ವೆಬ್‌ಅಸೆಂಬ್ಲಿ (WASM): ಅತ್ಯಂತ ಬೇಡಿಕೆಯ, ಕಾರ್ಯಕ್ಷಮತೆ-ನಿರ್ಣಾಯಕ ಕಾರ್ಯಗಳಿಗಾಗಿ, ನೀವು ಕೋರ್ ಮ್ಯಾಚಿಂಗ್ ಲಾಜಿಕ್ ಅನ್ನು ರಸ್ಟ್ ಅಥವಾ C++ ನಂತಹ ಭಾಷೆಯಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು ಮತ್ತು ಅದನ್ನು ವೆಬ್‌ಅಸೆಂಬ್ಲಿಗೆ ಕಂಪೈಲ್ ಮಾಡಬಹುದು. ಇದು ನಿಮಗೆ ನೇಟಿವ್-ಗೆ ಹತ್ತಿರದ ಕಾರ್ಯಕ್ಷಮತೆಯನ್ನು ನೀಡುತ್ತದೆ, ನಿಮ್ಮ ಕೋಡ್‌ನ ಹಾಟ್ ಪಾತ್‌ಗಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಮತ್ತು JIT ಕಂಪೈಲರ್ ಅನ್ನು ಬೈಪಾಸ್ ಮಾಡುತ್ತದೆ. ಇದು ಒಂದು ಸುಧಾರಿತ ತಂತ್ರವಾಗಿದೆ ಆದರೆ ಅಂತಿಮ ವೇಗವನ್ನು ನೀಡುತ್ತದೆ.

ಬೆಂಚ್‌ಮಾರ್ಕಿಂಗ್: ಊಹಿಸಬೇಡಿ, ಸಾಬೀತುಪಡಿಸಿ

ನೀವು ಅಳೆಯಲು ಸಾಧ್ಯವಾಗದ್ದನ್ನು ನೀವು ಆಪ್ಟಿಮೈಜ್ ಮಾಡಲು ಸಾಧ್ಯವಿಲ್ಲ. ನಮ್ಮ ಕಸ್ಟಮ್ ಇಂಜಿನ್ ಸರಳ ಪರ್ಯಾಯಗಳಿಗಿಂತ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿದೆ ಎಂದು ಮೌಲ್ಯೀಕರಿಸಲು ಸರಿಯಾದ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಅನ್ನು ಸ್ಥಾಪಿಸುವುದು ನಿರ್ಣಾಯಕವಾಗಿದೆ.

ನಾವು ಒಂದು ಕಾಲ್ಪನಿಕ ಪರೀಕ್ಷಾ ಪ್ರಕರಣವನ್ನು ವಿನ್ಯಾಸಿಸೋಣ:

• ಪಠ್ಯ: 5MB ಪಠ್ಯ ಫೈಲ್ (ಉದಾ., ಒಂದು ಕಾದಂಬರಿ).
• ಪ್ಯಾಟರ್ನ್‌ಗಳು: 500 ಸಾಮಾನ್ಯ ಇಂಗ್ಲಿಷ್ ಪದಗಳ ಒಂದು ಅರೇ.

ನಾವು ನಾಲ್ಕು ವಿಧಾನಗಳನ್ನು ಹೋಲಿಸುತ್ತೇವೆ:

1. `indexOf` ನೊಂದಿಗೆ ಸರಳ ಲೂಪ್: ಎಲ್ಲಾ 500 ಪ್ಯಾಟರ್ನ್‌ಗಳ ಮೂಲಕ ಲೂಪ್ ಮಾಡಿ ಮತ್ತು ಪ್ರತಿಯೊಂದಕ್ಕೂ `text.indexOf(pattern)` ಅನ್ನು ಕಾಲ್ ಮಾಡಿ.
2. ಏಕ ಕಂಪೈಲ್ಡ್ RegExp: ಎಲ್ಲಾ ಪ್ಯಾಟರ್ನ್‌ಗಳನ್ನು `/word1|word2|...|word500/g` ನಂತಹ ಒಂದೇ ರೆಜೆಕ್ಸ್‌ಗೆ ಸಂಯೋಜಿಸಿ ಮತ್ತು `text.match()` ಅನ್ನು ರನ್ ಮಾಡಿ.
3. ನಮ್ಮ ಅಹೋ-ಕೊರಾಸಿಕ್ ಇಂಜಿನ್: ಇಂಜಿನ್ ಅನ್ನು ಒಮ್ಮೆ ನಿರ್ಮಿಸಿ, ನಂತರ ಹುಡುಕಾಟವನ್ನು ರನ್ ಮಾಡಿ.
4. ನೇರ ಬ್ರೂಟ್-ಫೋರ್ಸ್: O(K * N * M) ವಿಧಾನ.

ಒಂದು ಸರಳ ಬೆಂಚ್‌ಮಾರ್ಕ್ ಸ್ಕ್ರಿಪ್ಟ್ ಈ ರೀತಿ ಕಾಣಿಸಬಹುದು:

            
console.time("Aho-Corasick Search");
const matches = engine.search(largeText);
console.timeEnd("Aho-Corasick Search");

// Repeat for other methods...

            

              
                Copy
              
            
          

ನಿರೀಕ್ಷಿತ ಫಲಿತಾಂಶಗಳು (ವಿವರಣಾತ್ಮಕ):

• ನೇರ ಬ್ರೂಟ್-ಫೋರ್ಸ್: > 10,000 ms (ಅಥವಾ ಅಳೆಯಲು ತುಂಬಾ ನಿಧಾನ)
• `indexOf` ನೊಂದಿಗೆ ಸರಳ ಲೂಪ್: ~1500 ms
• ಏಕ ಕಂಪೈಲ್ಡ್ RegExp: ~300 ms
• ಅಹೋ-ಕೊರಾಸಿಕ್ ಇಂಜಿನ್: ~50 ms

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

ತೀರ್ಮಾನ: ಕೆಲಸಕ್ಕೆ ಸರಿಯಾದ ಸಾಧನವನ್ನು ಆರಿಸುವುದು

ಸ್ಟ್ರಿಂಗ್ ಪ್ಯಾಟರ್ನ್ ಆಪ್ಟಿಮೈಸೇಶನ್‌ನ ಪ್ರಯಾಣವು ಸಾಫ್ಟ್‌ವೇರ್ ಇಂಜಿನಿಯರಿಂಗ್‌ನ ಒಂದು ಮೂಲಭೂತ ಸತ್ಯವನ್ನು ಬಹಿರಂಗಪಡಿಸುತ್ತದೆ: ಉತ್ಪಾದಕತೆಗಾಗಿ ಉನ್ನತ-ಮಟ್ಟದ ಅಮೂರ್ತತೆಗಳು ಮತ್ತು ಅಂತರ್ನಿರ್ಮಿತ ಫಂಕ್ಷನ್‌ಗಳು ಅಮೂಲ್ಯವಾಗಿದ್ದರೂ, ಆಧಾರವಾಗಿರುವ ತತ್ವಗಳ ಆಳವಾದ ತಿಳುವಳಿಕೆಯು ನಾವು ನಿಜವಾಗಿಯೂ ಉನ್ನತ-ಕಾರ್ಯಕ್ಷಮತೆಯ ವ್ಯವಸ್ಥೆಗಳನ್ನು ನಿರ್ಮಿಸಲು ಸಾಧ್ಯವಾಗುವಂತೆ ಮಾಡುತ್ತದೆ.

ನಾವು ಕಲಿತಿದ್ದೇವೆ:

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

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