mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
Merge pull request #6 from kvedala/document/strings
Documentation of `strings` folder
This commit is contained in:
Krishna Vedala
GitHub
commit
12250c9f08
@ -1,7 +1,5 @@
|
||||
<!--# DO NOT REMOVE THIS LINE
|
||||
This is for Doxygen to recognize as the index file for the complete documentation
|
||||
{#mainpage} -->
|
||||
# The Algorithms - C++
|
||||
# The Algorithms - C++ # {#mainpage}
|
||||
|
||||
[](https://github.com/kvedala/C-Plus-Plus/blob/master/CONTRIBUTION.md)
|
||||
|
||||
|
||||
|
||||
@ -1,52 +1,53 @@
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
using std::string;
|
||||
|
||||
int brute_force(string text, string pattern);
|
||||
std::vector<std::vector<string>> test_set = {
|
||||
// {text, pattern, expected output}
|
||||
{"a", "aa", "-1"},
|
||||
{"a", "a", "0"},
|
||||
{"ba", "b", "0"},
|
||||
{"bba", "bb", "0"},
|
||||
{"bbca", "c", "2"},
|
||||
{"ab", "b", "1"}
|
||||
};
|
||||
|
||||
int main() {
|
||||
for (size_t i = 0 ; i < test_set.size(); i++) {
|
||||
int output = brute_force(test_set[i][0], test_set[i][1]);
|
||||
if (std::to_string(output) == test_set[i][2])
|
||||
std::cout << "success\n";
|
||||
else
|
||||
std::cout << "failure\n";
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
*@description Find a pattern in a string by comparing the pattern
|
||||
* to every substring.
|
||||
*@param text Any string that might contain the pattern.
|
||||
*@param pattern String that we are searching for.
|
||||
*@return Index where the pattern starts in the text or
|
||||
* -1 if the pattern was not found.
|
||||
/**
|
||||
* @file
|
||||
* @brief String pattern search - brute force
|
||||
*/
|
||||
#include <iostream>
|
||||
#ifdef _MSC_VER
|
||||
#include <string> // use this for MS Visucal C++
|
||||
#else
|
||||
#include <cstring>
|
||||
#endif
|
||||
#include <vector>
|
||||
|
||||
int brute_force(string text, string pattern) {
|
||||
size_t pat_l = pattern.length();
|
||||
size_t txt_l = text.length();
|
||||
int index = -1;
|
||||
if (pat_l <= txt_l) {
|
||||
for (size_t i = 0; i < txt_l-pat_l+1; i++) {
|
||||
string s = text.substr(i, pat_l);
|
||||
if (s == pattern) {
|
||||
index = i;
|
||||
/**
|
||||
* Find a pattern in a string by comparing the pattern to every substring.
|
||||
* @param text Any string that might contain the pattern.
|
||||
* @param pattern String that we are searching for.
|
||||
* @return Index where the pattern starts in the text
|
||||
* @return -1 if the pattern was not found.
|
||||
*/
|
||||
int brute_force(const std::string &text, const std::string &pattern) {
|
||||
size_t pat_l = pattern.length();
|
||||
size_t txt_l = text.length();
|
||||
int index = -1;
|
||||
if (pat_l <= txt_l) {
|
||||
for (size_t i = 0; i < txt_l - pat_l + 1; i++) {
|
||||
std::string s = text.substr(i, pat_l);
|
||||
if (s == pattern) {
|
||||
index = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return index;
|
||||
}
|
||||
|
||||
/** set of test cases */
|
||||
const std::vector<std::vector<std::string>> test_set = {
|
||||
// {text, pattern, expected output}
|
||||
{"a", "aa", "-1"}, {"a", "a", "0"}, {"ba", "b", "0"},
|
||||
{"bba", "bb", "0"}, {"bbca", "c", "2"}, {"ab", "b", "1"}};
|
||||
|
||||
/** Main function */
|
||||
int main() {
|
||||
for (size_t i = 0; i < test_set.size(); i++) {
|
||||
int output = brute_force(test_set[i][0], test_set[i][1]);
|
||||
|
||||
if (std::to_string(output) == test_set[i][2])
|
||||
std::cout << "success\n";
|
||||
else
|
||||
std::cout << "failure\n";
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,64 +1,88 @@
|
||||
/*
|
||||
The Knuth-Morris-Pratt Algorithm for finding a pattern within a piece of text
|
||||
with complexity O(n + m)
|
||||
1) Preprocess pattern to identify any suffixes that are identical to prefixes
|
||||
This tells us where to continue from if we get a mismatch between a character in our pattern
|
||||
and the text.
|
||||
2) Step through the text one character at a time and compare it to a character in the pattern
|
||||
updating our location within the pattern if necessary
|
||||
*/
|
||||
/**
|
||||
* \file
|
||||
* \brief The [Knuth-Morris-Pratt
|
||||
* Algorithm](https://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm) for
|
||||
* finding a pattern within a piece of text with complexity O(n + m)
|
||||
*
|
||||
* 1. Preprocess pattern to identify any suffixes that are identical to
|
||||
* prefixes. This tells us where to continue from if we get a mismatch between a
|
||||
* character in our pattern and the text.
|
||||
* 2. Step through the text one character at a time and compare it to a
|
||||
* character in the pattern updating our location within the pattern if
|
||||
* necessary
|
||||
*/
|
||||
|
||||
#include<iostream>
|
||||
#include<vector>
|
||||
#include<string>
|
||||
using namespace std;
|
||||
vector<int> getFailureArray(string pattern){
|
||||
int pattern_length=pattern.size();
|
||||
vector<int>failure(pattern_length+1);
|
||||
failure[0]=-1;
|
||||
int j=-1;
|
||||
for(int i=0; i<pattern_length; i++){
|
||||
while(j!=-1&&pattern[j]!=pattern[i]){
|
||||
j=failure[j];
|
||||
#include <iostream>
|
||||
#ifdef _MSC_VER
|
||||
#include <string> // use this for MS Visucal C++
|
||||
#else
|
||||
#include <cstring>
|
||||
#endif
|
||||
#include <vector>
|
||||
|
||||
/**
|
||||
* Generate the partial match table aka failure function for a pattern to
|
||||
* search.
|
||||
* \param[in] pattern text for which to create the partial match table
|
||||
* \returns the partial match table as a vector array
|
||||
*/
|
||||
std::vector<int> getFailureArray(const std::string &pattern) {
|
||||
int pattern_length = pattern.size();
|
||||
std::vector<int> failure(pattern_length + 1);
|
||||
failure[0] = -1;
|
||||
int j = -1;
|
||||
|
||||
for (int i = 0; i < pattern_length; i++) {
|
||||
while (j != -1 && pattern[j] != pattern[i]) {
|
||||
j = failure[j];
|
||||
}
|
||||
j++;
|
||||
failure[i+1]=j;
|
||||
failure[i + 1] = j;
|
||||
}
|
||||
return failure;
|
||||
}
|
||||
bool kmp(string pattern,string text){
|
||||
int text_length=text.size(),pattern_length=pattern.size();
|
||||
vector<int>failure=getFailureArray(pattern);
|
||||
int k=0;
|
||||
for(int j=0; j<text_length; j++){
|
||||
while(k!=-1&&pattern[k]!=text[j]){
|
||||
k=failure[k];
|
||||
|
||||
/**
|
||||
* KMP algorithm to find a pattern in a text
|
||||
* \param[in] pattern string pattern to search
|
||||
* \param[in] text text in which to search
|
||||
* \returns `true` if pattern was found
|
||||
* \returns `false` if pattern was not found
|
||||
*/
|
||||
bool kmp(const std::string &pattern, const std::string &text) {
|
||||
int text_length = text.size(), pattern_length = pattern.size();
|
||||
std::vector<int> failure = getFailureArray(pattern);
|
||||
|
||||
int k = 0;
|
||||
for (int j = 0; j < text_length; j++) {
|
||||
while (k != -1 && pattern[k] != text[j]) {
|
||||
k = failure[k];
|
||||
}
|
||||
k++;
|
||||
if(k==pattern_length)return true;
|
||||
if (k == pattern_length)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
/** Main function */
|
||||
int main() {
|
||||
std::string text = "alskfjaldsabc1abc1abc12k23adsfabcabc";
|
||||
std::string pattern = "abc1abc12l";
|
||||
|
||||
string text="alskfjaldsabc1abc1abc12k23adsfabcabc";
|
||||
string pattern="abc1abc12l";
|
||||
if(kmp(pattern,text)==true){
|
||||
cout<<"Found"<<endl;
|
||||
if (kmp(pattern, text) == true) {
|
||||
std::cout << "Found" << std::endl;
|
||||
} else {
|
||||
std::cout << "Not Found" << std::endl;
|
||||
}
|
||||
else{
|
||||
cout<<"Not Found"<<endl;
|
||||
}
|
||||
text="abcabc";
|
||||
pattern="bca";
|
||||
if(kmp(pattern,text)==true){
|
||||
cout<<"Found"<<endl;
|
||||
}
|
||||
else{
|
||||
cout<<"Not Found"<<endl;
|
||||
|
||||
text = "abcabc";
|
||||
pattern = "bca";
|
||||
if (kmp(pattern, text) == true) {
|
||||
std::cout << "Found" << std::endl;
|
||||
} else {
|
||||
std::cout << "Not Found" << std::endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
@ -1,39 +1,64 @@
|
||||
/*
|
||||
* file name : rabin_karp.cpp
|
||||
* author : Amit Kumar
|
||||
* Copyright : 2020 , Amit Kumar
|
||||
* version : 1.0
|
||||
/**
|
||||
* \file
|
||||
* \brief The [Rabin-Karp
|
||||
* Algorithm](https://en.wikipedia.org/wiki/Rabin–Karp_algorithm) for finding a
|
||||
* pattern within a piece of text with complexity O(n + m)
|
||||
*/
|
||||
#include<cassert>
|
||||
#include<cmath>
|
||||
#include<iostream>
|
||||
#include<string>
|
||||
#include <cassert>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#ifdef _MSC_VER
|
||||
#include <string> // use this for MS Visucal C++
|
||||
#else
|
||||
#include <cstring>
|
||||
#endif
|
||||
|
||||
using std::string;
|
||||
using std::pow;
|
||||
#define PRIME 5 ///< Prime modulus for hash functions
|
||||
|
||||
#define PRIME 5
|
||||
|
||||
int64_t create_hash(string s , int n) {
|
||||
/**
|
||||
* convert a string to an intger - called as hashing function
|
||||
* \param[in] s source of string to hash
|
||||
* \param[in] n length of substring to hash
|
||||
* \returns hash integer
|
||||
*/
|
||||
int64_t create_hash(const std::string& s, int n) {
|
||||
int64_t result = 0;
|
||||
for ( int i = 0; i < n; ++i ) {
|
||||
result += (int64_t)(s[i] * (int64_t)pow(PRIME , i));
|
||||
for (int i = 0; i < n; ++i) {
|
||||
result += (int64_t)(s[i] * (int64_t)pow(PRIME, i));
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
int64_t recalculate_hash(string s , int old_index ,
|
||||
int new_index , int64_t old_hash , int patLength) {
|
||||
/**
|
||||
* re-hash a string using known existing hash
|
||||
* \param[in] s source of string to hash
|
||||
* \param[in] old_index previous index of string
|
||||
* \param[in] new_index new index of string
|
||||
* \param[in] old_hash previous hash of substring
|
||||
* \param[in] patLength length of substring to hash
|
||||
* \returns new hash integer
|
||||
*/
|
||||
int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
|
||||
int64_t old_hash, int patLength) {
|
||||
int64_t new_hash = old_hash - s[old_index];
|
||||
new_hash /= PRIME;
|
||||
new_hash += (int64_t)(s[new_index]*(int64_t)pow(PRIME, patLength-1));
|
||||
new_hash += (int64_t)(s[new_index] * (int64_t)pow(PRIME, patLength - 1));
|
||||
return new_hash;
|
||||
}
|
||||
|
||||
bool check_if_equal(string str1 , string str2 ,
|
||||
int start1 , int end1 ,
|
||||
int start2 , int end2) {
|
||||
if (end1-start1 != end2-start2) {
|
||||
/**
|
||||
* compare if two sub-strings are equal
|
||||
* \param[in] str1 string pattern to search
|
||||
* \param[in] str2 text in which to search
|
||||
* \param[in] start1,end1 start and end indices for substring in str1
|
||||
* \param[in] start2,end2 start and end indices for substring in str2
|
||||
* \returns `true` if pattern was found
|
||||
* \returns `false` if pattern was not found
|
||||
* @note can this be replaced by std::string::compare?
|
||||
*/
|
||||
bool check_if_equal(const std::string& str1, const std::string& str2,
|
||||
int start1, int end1, int start2, int end2) {
|
||||
if (end1 - start1 != end2 - start2) {
|
||||
return false;
|
||||
}
|
||||
while (start1 <= end1 && start2 <= end2) {
|
||||
@ -46,33 +71,36 @@ bool check_if_equal(string str1 , string str2 ,
|
||||
return true;
|
||||
}
|
||||
|
||||
/*
|
||||
* @description : search pattern in the given text
|
||||
* @param : string str
|
||||
* @param : string pat
|
||||
* @return index of first occurrence of pattern or -1 if pattern not found
|
||||
/**
|
||||
* Perform string pattern search using Rabin-Karp algorithm
|
||||
* @param[in] str string to search in
|
||||
* @param[in] pat pattern to search for
|
||||
* @return index of first occurrence of pattern
|
||||
* @return -1 if pattern not found
|
||||
*/
|
||||
|
||||
int rabin_karp(const string &str , const string& pat) {
|
||||
int64_t pat_hash = create_hash(pat , pat.size());
|
||||
int64_t str_hash = create_hash(str , pat.size());
|
||||
for (int i=0; i <= str.size()-pat.size(); ++i) {
|
||||
int rabin_karp(const std::string& str, const std::string& pat) {
|
||||
int64_t pat_hash = create_hash(pat, pat.size());
|
||||
int64_t str_hash = create_hash(str, pat.size());
|
||||
for (int i = 0; i <= str.size() - pat.size(); ++i) {
|
||||
if (pat_hash == str_hash &&
|
||||
check_if_equal(str , pat , i , i+pat.size()-1 , 0 , pat.size()-1)) {
|
||||
return i;
|
||||
check_if_equal(str, pat, i, i + pat.size() - 1, 0,
|
||||
pat.size() - 1)) {
|
||||
return i;
|
||||
}
|
||||
if (i < str.size()-pat.size()) {
|
||||
if (i < str.size() - pat.size()) {
|
||||
str_hash =
|
||||
recalculate_hash(str, i, i+pat.size(), str_hash, pat.size());
|
||||
recalculate_hash(str, i, i + pat.size(), str_hash, pat.size());
|
||||
}
|
||||
}
|
||||
return -1; // return -1 if given pattern not found
|
||||
}
|
||||
|
||||
/** Main function */
|
||||
int main(void) {
|
||||
assert(rabin_karp("helloWorld", "world") == -1);
|
||||
assert(rabin_karp("helloWorld", "World") == 5);
|
||||
assert(rabin_karp("this_is_c++" , "c++") == 8);
|
||||
assert(rabin_karp("happy_coding", "happy") == 0);
|
||||
assert(rabin_karp("helloWorld", "world") == -1);
|
||||
assert(rabin_karp("helloWorld", "World") == 5);
|
||||
assert(rabin_karp("this_is_c++", "c++") == 8);
|
||||
assert(rabin_karp("happy_coding", "happy") == 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user