C++ માં સ્ટ્રિંગ સર્ચ (String Search) અલ્ગોરિધમ- સમજૂતી, ઉદાહરણ અને કોડ

સ્ટ્રિંગ સર્ચ અલ્ગોરિધમનો ઉપયોગ મોટા ટેક્સ્ટ(સ્ટ્રિંગ) ની અંદર ચોક્કસ પેટર્ન(સબસ્ટ્રિંગ) ની ઘટનાઓ શોધવા માટે થાય છે. આ અલ્ગોરિધમ ટેક્સ્ટ પ્રોસેસિંગ, સર્ચિંગ અને મેનીપ્યુલેશન કાર્યોમાં નિર્ણાયક ભૂમિકા ભજવે છે.

તે કેવી રીતે કામ કરે છે

1. શોધવા માટે ટેક્સ્ટ(સ્ટ્રિંગ) અને પેટર્ન(સબસ્ટ્રિંગ) થી પ્રારંભ કરો.
2. ટેક્સ્ટ દ્વારા એક સમયે એક અક્ષર પુનરાવર્તિત કરો.
3. ટેક્સ્ટમાં દરેક અક્ષર માટે, તેને પેટર્નના પ્રથમ અક્ષર સાથે સરખાવો.
4. જો ત્યાં મેચ હોય, તો તપાસો કે પછીના અક્ષરો પણ પેટર્ન સાથે મેળ ખાય છે.
5. જો પેટર્ન સંપૂર્ણપણે મેળ ખાતી હોય, તો મેચની શરૂઆતની સ્થિતિ રેકોર્ડ કરો.
6. ટેક્સ્ટમાં પેટર્ન શોધવાનું ચાલુ રાખો.

ઉદાહરણ

એક ટેક્સ્ટનો વિચાર કરો: "ababcababcabcabc" અને એક પેટર્ન: "abc"

1. સ્થિતિ 0 થી પ્રારંભ કરો. પેટર્નમાં પ્રથમ અક્ષર "a" સાથે "a" ની તુલના કરો.
2. મેળ મળ્યો, આગલા અક્ષરો પર જાઓ: "b" સાથે "b" અને "c" સાથે "a".
3. મેચ કરવાનું ચાલુ રાખો: "a" સાથે "b", "b" સાથે "b" અને "c" સાથે "b"
4. પોઝિશન 2 પર મેચ નિષ્ફળ ગઈ.
5. પોઝિશન 3 પર ફરીથી પ્રારંભ કરો. પેટર્નમાં પ્રથમ અક્ષર "a" સાથે "a" ની તુલના કરો.
6. સફળ મેચ: "a" સાથે "a", "b" સાથે "b" અને "c" સાથે "c"
7. રેકોર્ડ પોઝિશન 3.

પેટર્ન "abc" સ્થિતિ 0, 6 અને 9 પર જોવા મળે છે.

C++ માં ઉદાહરણ કોડ

#include <iostream>  
#include <string>  
#include <vector>  
  
std::vector<int> stringSearch(const std::string& text, const std::string& pattern) {  
    std::vector<int> positions;  
  
    for(int i = 0; i <= text.length()- pattern.length(); ++i) {  
        int j = 0;  
        while(j < pattern.length() && text[i + j] == pattern[j]) {  
            ++j;  
        }  
        if(j == pattern.length()) {  
            positions.push_back(i);  
        }  
    }  
  
    return positions;  
}  
  
int main() {  
    std::string text = "ababcababcabcabc";  
    std::string pattern = "abc";  
  
    std::vector<int> result = stringSearch(text, pattern);  
  
    std::cout << "Pattern found at positions: ";  
    for(int pos: result) {  
        std::cout << pos << ";  
    }  
    std::cout << std::endl;  
  
    return 0;  
}  

આ ઉદાહરણમાં, stringSearch ફંક્શનનો ઉપયોગ "ababcababcabcabc" ટેક્સ્ટની અંદર પેટર્ન "abc" ની ઘટનાઓ શોધવા માટે થાય છે. પરિણામ મેચોની પ્રારંભિક સ્થિતિ ધરાવતું વેક્ટર હશે.