C++లో స్ట్రింగ్ శోధన (String Search) అల్గోరిథం- వివరణ, ఉదాహరణ మరియు కోడ్

స్ట్రింగ్ శోధన అల్గోరిథం ఒక పెద్ద టెక్స్ట్(స్ట్రింగ్) లోపల నిర్దిష్ట నమూనా(సబ్‌స్ట్రింగ్) యొక్క సంఘటనలను కనుగొనడానికి ఉపయోగించబడుతుంది. ఈ అల్గోరిథం టెక్స్ట్ ప్రాసెసింగ్, సెర్చింగ్ మరియు మానిప్యులేషన్ టాస్క్‌లలో కీలక పాత్ర పోషిస్తుంది.

అది ఎలా పని చేస్తుంది

1. శోధించడానికి టెక్స్ట్(స్ట్రింగ్) మరియు నమూనా(సబ్‌స్ట్రింగ్)తో ప్రారంభించండి.
2. ఒక సమయంలో ఒక అక్షరం వచనం ద్వారా పునరావృతం చేయండి.
3. వచనంలోని ప్రతి అక్షరానికి, నమూనాలోని మొదటి అక్షరంతో పోల్చండి.
4. సరిపోలిక ఉన్నట్లయితే, తదుపరి అక్షరాలు కూడా నమూనాతో సరిపోలుతున్నాయో లేదో తనిఖీ చేయండి.
5. నమూనా పూర్తిగా సరిపోలినట్లయితే, మ్యాచ్ యొక్క ప్రారంభ స్థానాన్ని రికార్డ్ చేయండి.
6. టెక్స్ట్‌లోని నమూనా కోసం శోధించడం కొనసాగించండి.

ఉదాహరణ

ఒక వచనాన్ని పరిగణించండి: "ababcababcabcabc" మరియు ఒక నమూనా: "abc"

1. స్థానం 0 వద్ద ప్రారంభించండి. నమూనాలోని మొదటి అక్షరం "a"తో "a"ని సరిపోల్చండి.
2. సరిపోలిక కనుగొనబడింది, తదుపరి అక్షరాలకు తరలించండి: "b"తో "b" మరియు "a"తో "c".
3. సరిపోలికను కొనసాగించండి: "a"తో "b", "b"తో "a" మరియు "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" నమూనా యొక్క సంఘటనలను కనుగొనడానికి ఫంక్షన్ ఉపయోగించబడుతుంది. ఫలితం మ్యాచ్‌ల ప్రారంభ స్థానాలను కలిగి ఉన్న వెక్టర్ అవుతుంది.