|
In this JavaScript article, we will see the solution to the problem of checking if a string follows the order of characters defined by a pattern or not. We have given a string and pattern as the input and our task is to develop a program that will check whether the input string follows the same pattern according to the pattern given.
Example:
To solve this problem, we have three different approaches which are mentioned below:
Using JavaScript Loops- In this apporach, we are using the looping in JavaScript, where we are comparing the order of the chatacter occurences between the input pattern and the input string.
- We are iterating thorugh them, and also having a track of max and min indexes of he chatacter occurences.
- If the patterm’s characters order is matched in the input string’s order then the true result is returned else the false result will be returned.
Examples:
JavaScript
function checkPattern(str, pattern) {
// lcmi -> Last char max index
// ccmi -> current char max index
// ccmin -> current char min index
let lcmi = -1, ccmi = -1, ccmin = -1;
let matchValue = true;
lcmi = lastOcc(str, pattern[0]);
for (i = 1; i < pattern.length; i++) {
ccmi = lastOcc(str, pattern[i]);
ccmin = firstOcc(str, pattern[i]);
if (lcmi < ccmi && lcmi < ccmin) {
matchValue = true;
}
else {
matchValue = false;
}
lcmi = ccmi;
if (matchValue == false)
break;
}
return matchValue;
}
function lastOcc(str, chr) {
let currentIdx = 99999999, maxIdx = -1;
for (j = 0; j < str.length; j++) {
if (chr == str[j]) {
currentIdx = j;
if (currentIdx > maxIdx)
maxIdx = currentIdx;
}
}
return maxIdx;
}
function firstOcc(str, chr) {
let currentIdx = 99999999, minIndex = 999999999;
for (k = 0; k < str.length; k++) {
if (chr == str[k]) {
currentIdx = k;
if (currentIdx < minIndex)
minIndex = currentIdx;
}
}
return minIndex;
}
console.log(checkPattern("engineers rock", "er"));
console.log(checkPattern("engineers rock", "egr"));
console.log(checkPattern("engineers rock", "gsr"));
Using JavaScript Map- In this apporch, we are using the Maps in JavaScript where we have used the two map objects (map1 and map2).
- This objects establish the connection between the chacraters in the input pattern and words in the input string, as well as the reverse mapping.
- This assures that the mappings are proper and returns true if the character and words are aligned correctly else false will be returned.
Examples:
JavaScript
function checkPattern(str, pattern) {
let words = str.split(' ')
if (pattern.length !== words.length) return false
let map1 = new Map();
let map2 = new Map();
for (let i = 0; i < pattern.length; i++) {
let key = pattern[i];
let value = words[i];
if (map1.has(key) || map2.has(value)) {
if (map1.get(key) !== value) return false;
if (map2.get(value) !== key) return false;
} else {
map1.set(key, value);
map2.set(value, key);
}
}
return true;
};
console.log(checkPattern("engineers rock", "er"));
console.log(checkPattern("engineers rock", "egr"));
console.log(checkPattern("engineers rock", "gsr"));
Using Builtin Functions ‘every‘, ‘reduce‘, and ‘split‘- In this apporach we are using inbuilt fucntions rather than using complex data structures.
- We firslty split the input string into words and then by using reduce funtion we create a mapping between pattern chatacters and the corresposnding words.
- Lastly, we check if all the mapped values are aligned properly witht he words in the input string using the every function.
- If they are aligned properly then true result will be returned else false result will be returned.
Example:
JavaScript
function checkPattern(str, pattern) {
let words = str.split(" ");
if (words.length !== pattern.length) {
return false;
}
let patternToWord = pattern.split("").reduce((map, character, index) => {
if (!map.has(character)) {
map.set(character, words[index]);
} else if (map.get(character) !== words[index]) {
return false;
}
return map;
}, new Map());
let values = [...patternToWord.values()];
let ans = values.every((value, index) => value === words[index]);
return ans;
}
console.log(checkPattern("engineers rock", "er"));
console.log(checkPattern("engineers rock", "egr"));
console.log(checkPattern("engineers rock", "gsr"));
Using Regular Expression:Using Regular Expression: Create a RegExp pattern by joining characters from the input pattern with ‘.*’, representing any character zero or more times. Test if the string matches the pattern anchored at both ends.
Example: In this example The function followsPattern utilizes a regular expression to match if the string str follows the character order defined by pattern, returning true for a match and false otherwise
JavaScript
function followsPattern(str, pattern) {
const regex = new RegExp('^' + pattern.split('').join('.*') + '$');
return regex.test(str);
}
const str1 = "abc";
const pattern1 = "abc";
console.log(followsPattern(str1, pattern1));
const str2 = "xyz";
const pattern2 = "xzy";
console.log(followsPattern(str2, pattern2));
|
