checking for palindromes in js [duplicate] - javascript
I have the following:
function checkPalindrom(palindrom)
{
for( var i = palindrom.length; i > 0; i-- )
{
if( palindrom[i] = palindrom.charAt(palindrom.length)-1 )
{
document.write('the word is palindrome.');
}else{
document.write('the word is not palindrome!');
}
}
}
checkPalindrom('wordthatwillbechecked');
What is wrong with my code? I want to check if the word is a palindrome.
Maybe I will suggest alternative solution:
function checkPalindrom (str) {
return str == str.split('').reverse().join('');
}
UPD. Keep in mind however that this is pretty much "cheating" approach, a demonstration of smart usage of language features, but not the most practical algorithm (time O(n), space O(n)). For real life application or coding interview you should definitely use loop solution. The one posted by Jason Sebring in this thread is both simple and efficient (time O(n), space O(1)).
25x faster than the standard answer
function isPalindrome(s,i) {
return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i);
}
use like:
isPalindrome('racecar');
as it defines "i" itself
Fiddle: http://jsfiddle.net/namcx0yf/9/
This is ~25 times faster than the standard answer below.
function checkPalindrome(str) {
return str == str.split('').reverse().join('');
}
Fiddle: http://jsfiddle.net/t0zfjfab/2/
View console for performance results.
Although the solution is difficult to read and maintain, I would recommend understanding it to demonstrate non-branching with recursion and bit shifting to impress your next interviewer.
explained
The || and && are used for control flow like "if" "else". If something left of || is true, it just exits with true. If something is false left of || it must continue. If something left of && is false, it exits as false, if something left of a && is true, it must continue. This is considered "non-branching" as it does not need if-else interupts, rather its just evaluated.
1. Used an initializer not requiring "i" to be defined as an argument. Assigns "i" to itself if defined, otherwise initialize to 0. Always is false so next OR condition is always evaluated.
(i = i || 0) < 0
2. Checks if "i" went half way but skips checking middle odd char. Bit shifted here is like division by 2 but to lowest even neighbor division by 2 result. If true then assumes palindrome since its already done. If false evaluates next OR condition.
i >= s.length >> 1
3. Compares from beginning char and end char according to "i" eventually to meet as neighbors or neighbor to middle char. If false exits and assumes NOT palindrome. If true continues on to next AND condition.
s[i] == s[s.length-1-i]
4. Calls itself again for recursion passing the original string as "s". Since "i" is defined for sure at this point, it is pre-incremented to continue checking the string's position. Returns boolean value indicating if palindrome.
isPalindrome(s,++i)
BUT...
A simple for loop is still about twice as fast as my fancy answer (aka KISS principle)
function fastestIsPalindrome(str) {
var len = Math.floor(str.length / 2);
for (var i = 0; i < len; i++)
if (str[i] !== str[str.length - i - 1])
return false;
return true;
}
http://jsfiddle.net/6L953awz/1/
The logic here is not quite correct, you need to check every letter to determine if the word is a palindrome. Currently, you print multiple times. What about doing something like:
function checkPalindrome(word) {
var l = word.length;
for (var i = 0; i < l / 2; i++) {
if (word.charAt(i) !== word.charAt(l - 1 - i)) {
return false;
}
}
return true;
}
if (checkPalindrome("1122332211")) {
document.write("The word is a palindrome");
} else {
document.write("The word is NOT a palindrome");
}
Which should print that it IS indeed a palindrome.
First problem
= is assign
== is compare
Second problem, Your logic here is wrong
palindrom.charAt(palindrom.length)-1
You are subtracting one from the charAt and not the length.
Third problem, it still will be wrong since you are not reducing the length by i.
It works to me
function palindrome(str) {
/* remove special characters, spaces and make lowercase*/
var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase();
/* reverse removeChar for comparison*/
var checkPalindrome = removeChar.split('').reverse().join('');
/* Check to see if str is a Palindrome*/
return (removeChar === checkPalindrome);
}
As a much clearer recursive function: http://jsfiddle.net/dmz2x117/
function isPalindrome(letters) {
var characters = letters.split(''),
firstLetter = characters.shift(),
lastLetter = characters.pop();
if (firstLetter !== lastLetter) {
return false;
}
if (characters.length < 2) {
return true;
}
return isPalindrome(characters.join(''));
}
SHORTEST CODE (31 chars)(ES6):
p=s=>s==[...s].reverse().join``
p('racecar'); //true
Keep in mind short code isn't necessarily the best. Readability and efficiency can matter more.
At least three things:
You are trying to test for equality with =, which is used for setting. You need to test with == or ===. (Probably the latter, if you don't have a reason for the former.)
You are reporting results after checking each character. But you don't know the results until you've checked enough characters.
You double-check each character-pair, as you really only need to check if, say first === last and not also if last === first.
function checkPalindrom(palindrom)
{
var flag = true;
var j = 0;
for( var i = palindrom.length-1; i > palindrom.length / 2; i-- )
{
if( palindrom[i] != palindrom[j] )
{
flag = false;
break; // why this? It'll exit the loop at once when there is a mismatch.
}
j++;
}
if( flag ) {
document.write('the word is palindrome.');
}
else {
document.write('the word is not palindrome.');
}
}
checkPalindrom('wordthatwillbechecked');
Why am I printing the result outside the loop? Otherwise, for each match in the word, it'll print "is or is not pallindrome" rather than checking the whole word.
EDIT: Updated with changes and a fix suggested by Basemm.
I've added some more to the above functions, to check strings like, "Go hang a salami, I'm a lasagna hog".
function checkPalindrom(str) {
var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase();
return str == str.split('').reverse().join('');
}
Thanks
The most important thing to do when solving a Technical Test is Don't use shortcut methods -- they want to see how you think algorithmically! Not your use of methods.
Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume false and alter the logic if its looking to be true.
isPalindrome():
Basically, to make this run in O(N) (linear) complexity you want to have 2 iterators whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to break/return once they meet in the middle, but it may save some work to only give each iterator a half-length by default.
for loops seem to force the use of more checks, so I used while loops - which I'm less comfortable with.
Here's the code:
/**
* TODO: If func counts out, let it return 0
* * Assume !isPalindrome (invert logic)
*/
function isPalindrome(S){
var s = S
, len = s.length
, mid = len/2;
, i = 0, j = len-1;
while(i<mid){
var l = s.charAt(i);
while(j>=mid){
var r = s.charAt(j);
if(l === r){
console.log('#while *', i, l, '...', j, r);
--j;
break;
}
console.log('#while !', i, l, '...', j, r);
return 0;
}
++i;
}
return 1;
}
var nooe = solution('neveroddoreven'); // even char length
var kayak = solution('kayak'); // odd char length
var kayaks = solution('kayaks');
console.log('#isPalindrome', nooe, kayak, kayaks);
Notice that if the loops count out, it returns true. All the logic should be inverted so that it by default returns false. I also used one short cut method String.prototype.charAt(n), but I felt OK with this as every language natively supports this method.
function palindromCheck(str) {
var palinArr, i,
palindrom = [],
palinArr = str.split(/[\s!.?,;:'"-()]/ig);
for (i = 0; i < palinArr.length; i++) {
if (palinArr[i].toLowerCase() === palinArr[i].split('').reverse().join('').toLowerCase() &&
palinArr[i] !== '') {
palindrom.push(palinArr[i]);
}
}
return palindrom.join(', ');
}
console.log(palindromCheck('There is a man, his name! was Bob.')); //a, Bob
Finds and upper to lower case. Split string into array, I don't know why a few white spaces remain, but I wanted to catch and single letters.
= in palindrom[i] = palindrom.charAt(palindrom.length)-1 should be == or ===
palindrom.charAt(palindrom.length)-1 should be palindrom.charAt(palindrom.length - i)
Sharing my fast variant which also support spaces
function isPalindrom(str) {
var ia = 0;
var ib = str.length - 1;
do {
if (str[ia] === str[ib]) continue;
// if spaces skip & retry
if (str[ia] === ' ' && ib++) continue;
if (str[ib] === ' ' && ia--) continue;
return false;
} while (++ia < --ib);
return true;
}
var palindrom="never odd or even";
var res = isPalindrom(palindrom);
document.getElementById('check').innerHTML ='"'+ palindrom + '"'+" checked to be :" +res;
<span id="check" />
Some above short anwsers is good, but it's not easy for understand, I suggest one more way:
function checkPalindrome(inputString) {
if(inputString.length == 1){
return true;
}else{
var i = 0;
var j = inputString.length -1;
while(i < j){
if(inputString[i] != inputString[j]){
return false;
}
i++;
j--;
}
}
return true;
}
I compare each character, i start form left, j start from right, until their index is not valid (i<j).
It's also working in any languages
One more solution with ES6
isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);
You can try the following
function checkPalindrom (str) {
str = str.toLowerCase();
return str == str.split('').reverse().join('');
}
if(checkPalindrom('Racecar')) {
console.log('Palindrome');
} else {
console.log('Not Palindrome');
}
function checkPalindrom(palindrom)
{
palindrom= palindrom.toLowerCase();
var flag = true;
var j;
j = (palindrom.length) -1 ;
//console.log(j);
var cnt = j / 2;
//console.log(cnt);
for( i = 0; i < cnt+1 ; i++,j-- )
{
console.log("J is => "+j);
console.log(palindrom[i] + "<==>" + palindrom[j]);
if( palindrom[i] != palindrom[j] )
{
flag = false;
break;
}
}
if( flag ) {
console.log('the word is palindrome.');
}
else {
console.log('the word is not palindrome.');
}
}
checkPalindrom('Avid diva');
I'm wondering why nobody suggested this:
ES6:
// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
isPalindrom = (str = "") => {
if (str[0] === str[str.length - 1]) {
return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
}
return false;
}
alert(["aba", "acb", "aa", "abba", "s"].map((e, i) => isPalindrom(e)).join())
ES5:
// "aba" -> true
// "acb" -> false
// "aa" -> true
// "abba" -> true
// "s" -> true
function isPalindrom(str) => {
var str = typeof str !== "string" ? "" : str;
if (str[0] === str[str.length - 1]) {
return str.length <= 1 ? true : isPalindrom(str.slice(1, -1))
}
return false;
}
alert(["aba", "acb", "aa", "abba", "s"].map(function (e, i) {
return isPalindrom(e);
}).join());
Recursive Method:
var low;
var high;
var A = "abcdcba";
function palindrome(A , low, high){
A = A.split('');
if((low > high) || (low == high)){
return true;
}
if(A[low] === A[high]){
A = A.join('');
low = low + 1;
high = high - 1;
return palindrome(A , low, high);
}
else{
return "not a palindrome";
}
}
palindrome(A, 0, A.length-1);
I thought I'd share my own solution:
function palindrome(string){
var reverseString = '';
for(var k in string){
reverseString += string[(string.length - k) - 1];
}
if(string === reverseString){
console.log('Hey there palindrome');
}else{
console.log('You are not a palindrome');
}
}
palindrome('ana');
Hope will help someone.
I found this on an interview site:
Write an efficient function that checks whether any permutation of an
input string is a palindrome. You can ignore punctuation, we only care
about the characters.
Playing around with it I came up with this ugly piece of code :)
function checkIfPalindrome(text) {
var found = {};
var foundOne = 0;
text = text.replace(/[^a-z0-9]/gi, '').toLowerCase();
for (var i = 0; i < text.length; i++) {
if (found[text[i]]) {
found[text[i]]++;
} else {
found[text[i]] = 1;
}
}
for (var x in found) {
if (found[x] === 1) {
foundOne++;
if (foundOne > 1) {
return false;
}
}
}
for (var x in found) {
if (found[x] > 2 && found[x] % 2 && foundOne) {
return false;
}
}
return true;
}
Just leaving it here for posterity.
How about this, using a simple flag
function checkPalindrom(str){
var flag = true;
for( var i = 0; i <= str.length-1; i++){
if( str[i] !== str[str.length - i-1]){
flag = false;
}
}
if(flag == false){
console.log('the word is not a palindrome!');
}
else{
console.log('the word is a palindrome!');
}
}
checkPalindrom('abcdcba');
(JavaScript) Using regexp, this checks for alphanumeric palindrome and disregards space and punctuation.
function palindrome(str) {
str = str.match(/[A-Za-z0-9]/gi).join("").toLowerCase();
// (/[A-Za-z0-9]/gi) above makes str alphanumeric
for(var i = 0; i < Math.floor(str.length/2); i++) { //only need to run for half the string length
if(str.charAt(i) !== str.charAt(str.length-i-1)) { // uses !== to compare characters one-by-one from the beginning and end
return "Try again.";
}
}
return "Palindrome!";
}
palindrome("A man, a plan, a canal. Panama.");
//palindrome("4_2 (: /-\ :) 2-4"); // This solution would also work on something like this.
`
function checkPalindrome (str) {
var str = str.toLowerCase();
var original = str.split(' ').join('');
var reversed = original.split(' ').reverse().join('');
return (original === reversed);
}
`
This avoids regex while also dealing with strings that have spaces and uppercase...
function isPalindrome(str) {
str = str.split("");
var str2 = str.filter(function(x){
if(x !== ' ' && x !== ',') {
return x;
}
});
return console.log(str2.join('').toLowerCase()) == console.log(str2.reverse().join('').toLowerCase());
};
isPalindrome("A car, a man, a maraca"); //true
function myPolidrome(polidrome){
var string=polidrome.split('').join(',');
for(var i=0;i<string.length;i++){
if(string.length==1){
console.log("is polidrome");
}else if(string[i]!=string.charAt(string.length-1)){
console.log("is not polidrome");
break;
}else{
return myPolidrome(polidrome.substring(1,polidrome.length-1));
}
}
}
myPolidrome("asasdsdsa");
Thought I will share my solution using Array.prototype.filter(). filter()
filters the array based on boolean values the function returns.
var inputArray=["","a","ab","aba","abab","ababa"]
var outputArray=inputArray.filter(function isPalindrome(x){
if (x.length<2) return true;
var y=x.split("").reverse().join("");
return x==y;
})
console.log(outputArray);
This worked for me.
var number = 8008
number = number + "";
numberreverse = number.split("").reverse().join('');
console.log ("The number if reversed is: " +numberreverse);
if (number == numberreverse)
console.log("Yes, this is a palindrome");
else
console.log("Nope! It isnt a palindrome");
Here is a solution that works even if the string contains non-alphanumeric characters.
function isPalindrome(str) {
str = str.toLowerCase().replace(/\W+|_/g, '');
return str == str.split('').reverse().join('');
}
Related
How to check for valid braces in javascript, programming problem?
have been struggling for the last couple of days with the following problem from codewars: Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid. All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{} . What is considered Valid? A string of braces is considered valid if all braces are matched with the correct brace. Examples "(){}[]" => True "([{}])" => True "(}" => False "[(])" => False "[({})](]" => False So I'm really stuck with the code for this one, and this is what I have up to this point: function validBraces(braces){ let opening = [ '(', '[', '{'] let closing = [ ')', ']', '}'] let count = 0 const left = [] const right = [] // I generate left and right arrays, left w/the opening braces from the input, right w/ the closing for (let i = 0; i < braces.length; i++) { if (opening.includes(braces[i])) { left.push(braces[i]) } else if (closing.includes(braces[i])) { right.push(braces[i]) } } if (braces.length % 2 !== 0) { return false } // I know there's no point in doing this but at one point I thought I was finishing the program and thought I would 'optimize it' to exit early, probably this is dumb haha. if (left.length !== right.length) { return false } // The juicy (not juicy) part where I check if the braces make sense for (let i = 0; i < left.length; i++) { // If the list are made up of braces like ()[]{} add one to counter if (opening.indexOf(left[i]) === closing.indexOf(right[i])) { count += 1 } else // If left and right are mirrored add one to the counter if (opening.indexOf(left[i]) === closing.indexOf(right.reverse()[i])) { count += 1 } } //If the counter makes sense return true if (count === braces.length / 2) { return true } else { return false} } console.log(validBraces( "()" )) //true console.log(validBraces("([])")) //true console.log(validBraces( "[(])" )) //false console.log(validBraces( "[(})" )) //false console.log(validBraces( "[([[]])]" )) //true Some comments: I know I'm still not checking for this example ([])() but I thought of breaking this up into two smaller checks in some way. Thank you if you read up to this point. I would appreciate guidance in some way, though I don't want the problem solved for me. I'm probably overcomplicating this in some way since its a 6kyu problem, if so a tip on how to approach it more cleverly would be very much appreciated. Thank you in advance! :pray: :pray:
Hell yeah!! I'm very happy to finally reach to the solution myself using some of the hints given to me here: function validBraces(braces){ let opening = [ '(', '[', '{'] let closing = [ ')', ']', '}'] let arr = [] //console.log(closing.indexOf(braces[")"]) === opening.indexOf(arr[")"])) for (let i = 0; i < braces.length; i++) { if (opening.includes(braces[i])) { arr.push(braces[i]) } else if (closing.indexOf(braces[i]) === opening.indexOf(arr[arr.length - 1])) { arr.pop() } else return false } return arr.length === 0; } I was clearly overthinking it in the first place haha. Thanks for everyone that helped!
As Dave suggested, using a stack, I've wrote the code for it: var leftBraces="([{"; var rightBraces=")]}"; function checkBraces(braces) { var ok=true; var stack=[]; for(var i=0; i<braces.length && ok; i++) { var brace=braces[i]; if(leftBraces.includes(brace)) stack.push(brace); else { var leftBrace=stack.pop(); if(leftBrace==undefined) ok=false; else if(leftBraces.indexOf(leftBrace)!=rightBraces.indexOf(brace)) ok=false; } } if(stack.length) ok=false; return ok; } Code assumes only braces (no spaces or other characters). I'm using string.indexOf() that matches for leftBraces and rightBraces. Also, within the for loop, notice the termination part (2nd): i<braces.length && ok - doesn't "have to" use the iterator and, if I'm not mistaken, can even be empty...
var validBraces = (s) => { let objO = {'(': 0, '[': 1, '{': 2}; let objC = {')': 0, ']': 1, '}': 2}; let stack = []; for (let i=0; i<s.length; i++) { if (objO.hasOwnProperty(s[i])) { if (stack.length === 0 || stack[stack.length-1].idx!==objO[s[i]]) stack.push({idx: objO[s[i]], count: 1}); else stack[stack.length-1].count++; } else if (objC.hasOwnProperty(s[i])) { if (stack.length === 0 || stack[stack.length-1].idx!==objC[s[i]]) return false; else { stack[stack.length-1].count--; if (stack[stack.length-1].count===0) stack.pop(); } } } return stack.length === 0; }; console.log(validBraces("(){}[]")); console.log(validBraces("([{}])")); console.log(validBraces("(})")); console.log(validBraces("[(])")); console.log(validBraces("[({})](]"));
Here is a simplified solution: let isMatchingBraces = function(str) { let stack = []; let symbol = { '(': ')', '[': ']', '{': '}' }; for (let i = 0; i < str.length; i += 1) { // If character is an opening brace add it to a stack if (str[i] === '(' || str[i] === '{' || str[i] === '[') { stack.push(str[i]); } // If that character is a closing brace, pop from the stack, which will also reduce the length of the stack each time a closing bracket is encountered. else { let last = stack.pop(); //If the popped element from the stack, which is the last opening brace doesn’t match the corresponding closing brace in the symbol, then return false if (str[i] !== symbol[last]) { return false }; } } // After checking all the brackets of the str, at the end, the stack is not // empty then fail if (stack.length !== 0) { return false }; return true; }
function validBraces(braces){ let par =0; let bra =0; let cur =0; for(let i =0; i<braces.length; i++){ if(braces[i]==="("){ par++; } if(braces[i]===")"){ par--; } if(braces[i]==="["){ bra++; } if(braces[i]==="]"){ bra--; } if(braces[i]==="{"){ cur++; } if(braces[i]==="}"){ cur--; } } if(par<0 || bra<0 || cur<0){ return false; } return true; };
Here is my solution: var isValid = function (s) { let charMap = new Map(); for (let i = 0; i < s.length; i++) { charMap.set(s[i], i); } return Boolean( charMap.get("(") < charMap.get(")") && charMap.get("(") % 2 != charMap.get(")") % 2 && charMap.get("{") < charMap.get("}") && charMap.get("{") % 2 != charMap.get("}") % 2 && charMap.get("[") < charMap.get("]") && charMap.get("[") % 2 != charMap.get("]") % 2 ); }; Explanation: In order to achieve a quick and short solution, I have identified the common pattern of validity for opening/closing braces. The common pattern for opening and closing braces' validity is that if say the opening(closing) stands at the even index in the string, the other one should be odd and vice versa. Example {}, {[]}, {()[]}, {[()]}. Because we want to avoid a double loop for performance reasons, we are using a Hash Table via Map() to store the character and the index. An alternative for getting the character's index would be using Array's find or another method, but that would end up in a second loop over the values which we want to avoid. Finally, once the indexes of and the characters are stored in the charMap, we check whether or not the stored closing/opening characters' standing (odd/even) in the string is not equal, e.g. if '(' is odd the ')' should be even and vice versa. We check this via the remainder (%) operator, i.e. a number's remainder of 2 is 0 if even. Additionally, we need to check whether the order of braces is correct, e.g. if '(' is before '}'; The Boolean() function coerces the comparisons in the desired result.
Checking if a letter in a String is Upper Case
I am trying to complete the Caesar Cipher in JavaScript. I need a peice of code that checks to see if a letter in a string is upper case or lower case. const caesar = function(str) { for (i = 0; i < str.length; i++) { if (str[i] === str[i].toUpperCase) { console.log('YES'); } else { console.log('NO'); } } } caesar("HeLLO") Where am I going wrong? UPDATE: Additional Question Here is my full code - I swapped out my check for str[i] = str[i].toUpperCase() TO 64 < asciiNum < 91 but the check doesn't work. Any idea why using ASCII numbers to check for capital is not working in this instance? const caesar = function(str, shift) { var solved = ""; for (i=0; i < str.length; i++){ var asciiNum = str[i].charCodeAt(); console.log(asciiNum); if (64 < asciiNum < 91) { // check for upper cased newNum = asciiNum + shift; if(newNum > 90){ solved += String.fromCharCode(newNum - 26); } else { solved += String.fromCharCode(newNum); } } else if (96 < asciiNum < 123) { //check for lower case newNum = asciiNum + shift; if(newNum > 122){ solved += String.fromCharCode(newNum - 26); } else { solved += String.fromCharCode(newNum); } } } console.log(solved); } caesar("Hello, World!", 5);
Your issue was you weren't calling toUpperCase(). The computer saw it but didn't know it was supposed to run the function. To fix it, just put parentheses. However, to make it cleaner, I'd restructure this like so: // Gets a string from the user to test // Replace this with whatever string should be tested (probably a variable) var str = prompt("What string should be tested?"); const caesar = function(arg) { return arg.split("").every(function(e) { /* Makes an array of characters and tests to see if every character satisfies the conditions */ if (e === e.toUpperCase()) { // If the character is upper case return true; // Return true; the program should test the next character } else { console.log(`${e} was not uppercase`); return false; // Return false // The program should stop, because it detected a lowercase character } }); } console.log(`The result of running caesar() on string '${str}' was ${caesar(str)}`); /* Instead of using console.log inside the function Return the *result* of the function so that you can use it later */ This method is faster to run and a little cleaner. If you want to check if every letter is uppercase, leave it as it is. If you want to check if some letters are uppercase, change the every to some. If you want to reverse and check if all characters (or some) are lowercase, replace the e === e.toUpperCase() with e === e.toLowerCase() or e !== e.toUpperCase(). If a letter is not uppercase, it puts which one it was in the console and stops checking others. After it's finished, it puts whether all were uppercase in the string.
Only missing part in your code is a paranthesis () in toUpperCase.
You're missing parentheses after toUpperCase. if (str[i] === str[i].toUpperCase) { For JS you're trying to access a toUpperCase property instead call a function.
Check how many times a char appears in a string
Simply trying to find how many times a given character appears in a string but I can't solve it any other way then this simple for-loop. Is there a method that would solve this quicker or more eloquently other than using Regex? function countCharacter(str, char) { var count = 0; for(var i = 0; i < str.length; i++){ if(str.charAt(i) === char) count++; } return count; }
There are many possible ways are available in the market. I am adding a few of them. Method 1: str = "The man is as good as his word" str.split('a') output: (4) ["The m", "n is ", "s good ", "s his word"] str.split('a').length - 1 output: 3 Method 2: str = "The man is as good as his word" str.split('').map( function(char,i) { if(char === 'a') return i; } ).filter(Boolean) Output: (3) [5, 11, 19] str.split('').map( function(char,i) { if(char === 'a') return i; } ).filter(Boolean).length ouput: 3 Edit: As per comment we can also make use of filter(). str.split('').filter(function(char, i){ if(char == 'a'){ return i; } }) output: (3) ["a", "a", "a"] str.split('').filter(function(char, i){ if(char == 'a'){ return i; } }).length output: 3
----edited by adding more cases from answers---- there are several ways, you can use split/for/regex/reduce/indexOf like this: function countCharacter_reduce(str, ch) { return Array.prototype.reduce.call(str, (prev, cur) => cur === ch && ++prev && prev, 0); } function countCharacter_split(str, ch) { return str.split(ch).length - 1; } function countCharacter_for(str, ch) { for (var count = 0, ii = 0; ii < str.length; ii++) { if (str[ii] === ch) count++; } return count; } function countCharacter_regex(str, ch) { return str.length - str.replace(new RegExp(ch, 'g'), '').length; } function countCharacter_indexOf(str, char) { var start = 0; var count = 0; while ((start = str.indexOf(char, start) + 1) !== 0) { count++; } return count; } performance of them by running 1,000,000 times on counting '/' in a string. -- case1: running 1000000 times on ( 'this/is/a/path/with/extension', '/' ) countCharacter_reduce: 2389.880ms countCharacter_regex: 496.251ms countCharacter_split: 114.709ms countCharacter_for: 152.012ms countCharacter_indexOf: 90.330ms -- case2: running 1000000 times on ( '////////////', '/' ) countCharacter_reduce: 1138.051ms countCharacter_regex: 619.886ms countCharacter_split: 121.945ms countCharacter_for: 74.542ms countCharacter_indexOf: 204.242ms Conclusion ('>' means 'has better performance'): for|split|indexOf > regex > reduce. furthermore, if the string contains more searching characters (like case2), for>split>indexOf, otherwise (like case1) indexOf > split > for. BTW: you can change the for indexOf method to fit multi-characters search (example is single character)
using reduce: function countCharacter(str, char) { return str.split('').reduce((a, x) => x === char ? ++a : a, 0); }
I guess this involves regex which you wanted to avoid but it's pretty quick: function countCharacter(str, char) { return str.length - str.replace(new RegExp(char,"g"),"").length; } You can also try the str.split(char).length-1 approach suggested by Jaromanda. Or, go all out with some fun recursion (pass 0 to startingFrom): function countCharacter(str, char, startingFrom) { var idx = str.indexOf(char, startingFrom); return idx == -1 ? 0 : 1 + countCharacter(str, char, idx + 1); } You can get rid of the annoying extra argument at the cost of some efficiency: function countCharacter(str, char) { var idx = str.indexOf(char); return idx == -1 ? 0 : 1 + countCharacter(str.substr(idx+1), char); } And here's a version optimized for speed (this is about 3 times faster on my browser than your original and much faster than the regex versions, according to jsperf): function countCharacter(str, char) { var start = 0; var count = 0; while((start = str.indexOf(char, start)+1) !== 0) { count++; } return count; } Note that the indexOf approaches will generally be substantially faster than manually iterating through the string. See jsperf
Here you go. One line code "hello".match(new RegExp('l','g')).length replace 'l' with any char here, new RegExp('l','g'). that is str.match(new RegExp(char,'g')).length
Have you thought of using the split() method? How about this - function myFunction(str, char) { return string.split(char).length - 1 } Let me know what you think of this solution.
Failed test for JavaScript palindrome
I noticed when I literally type the word test or dabd, it fails by saying "test is a palindrome"; obviously these should fail. I test other words like racecar, madam, cat, they all pass. I check from the left most character and right most character and go down until we reach the middle. What could be the issue? function lengthChecker() { var str = document.getElementById("str").value; if (str.length > 10) { alert("Sorry. Your input surpasses the 10 characters maximum. Please try again.") return false; } else if (str.length == 0) { alert("Sorry. Your input is too short, and doesn't meet the 10 characters maximum. Please try again.") return false; } palindrome(str); } function palindrome(str) { var j = str.length; if (/\s/.test(str)) { alert("No spaces allowed.") return false; } for (i = 0; i < j / 2; i++) { if (str[i] == str[j - 1 - i]) { isPalindrome('', str); return true; } else { notPalindrome(str); return false; } } } function isPalindrome(e, str) { alert(str + " is a Palindrome."); } function notPalindrome(str) { alert(str + " isn't a Palindrome"); } document.addEventListener("DOMContentLoaded", function(e) { var el = document.getElementById("checkInput"); el.addEventListener("click", lengthChecker); });
In palindrome() you always only check the first character and immediately return. Fix the loop like this: for (var i = 0; i < j / 2; i++) { if (str[i] != str[j - 1 - i]) { notPalindrome(str); return false; } } isPalindrome('', str); return true;
For reference, you don't need to loop. You can simplify the palindrome test to just this: str === str.split('').reverse().join('') This splits the string into an array, which can then be reversed. It then joins it back into a string so you can compare it. I'd then put this in a ternary statement for modifying the message: var notp = (str === '' || str !== str.split('').reverse().join('').replace(" ", "")) ? 'is NOT':'IS'; I added "str === ''" to test for non-entries, and I added a remove spaces test as well. Now you've got a variable that you can push into a generic alert or whatever. You can change that to read "true:false;" instead is you want to control more than just the text of the message. The following gets rid of the leading and trailing spaces: str = str.trim(); There are more edits you can make, but this should help you along. Here's a jsfiddle: https://jsfiddle.net/mckinleymedia/fudLdx0r/
Palindrome check in Javascript
I have the following: function checkPalindrom(palindrom) { for( var i = palindrom.length; i > 0; i-- ) { if( palindrom[i] = palindrom.charAt(palindrom.length)-1 ) { document.write('the word is palindrome.'); }else{ document.write('the word is not palindrome!'); } } } checkPalindrom('wordthatwillbechecked'); What is wrong with my code? I want to check if the word is a palindrome.
Maybe I will suggest alternative solution: function checkPalindrom (str) { return str == str.split('').reverse().join(''); } UPD. Keep in mind however that this is pretty much "cheating" approach, a demonstration of smart usage of language features, but not the most practical algorithm (time O(n), space O(n)). For real life application or coding interview you should definitely use loop solution. The one posted by Jason Sebring in this thread is both simple and efficient (time O(n), space O(1)).
25x faster than the standard answer function isPalindrome(s,i) { return (i=i||0)<0||i>=s.length>>1||s[i]==s[s.length-1-i]&&isPalindrome(s,++i); } use like: isPalindrome('racecar'); as it defines "i" itself Fiddle: http://jsfiddle.net/namcx0yf/9/ This is ~25 times faster than the standard answer below. function checkPalindrome(str) { return str == str.split('').reverse().join(''); } Fiddle: http://jsfiddle.net/t0zfjfab/2/ View console for performance results. Although the solution is difficult to read and maintain, I would recommend understanding it to demonstrate non-branching with recursion and bit shifting to impress your next interviewer. explained The || and && are used for control flow like "if" "else". If something left of || is true, it just exits with true. If something is false left of || it must continue. If something left of && is false, it exits as false, if something left of a && is true, it must continue. This is considered "non-branching" as it does not need if-else interupts, rather its just evaluated. 1. Used an initializer not requiring "i" to be defined as an argument. Assigns "i" to itself if defined, otherwise initialize to 0. Always is false so next OR condition is always evaluated. (i = i || 0) < 0 2. Checks if "i" went half way but skips checking middle odd char. Bit shifted here is like division by 2 but to lowest even neighbor division by 2 result. If true then assumes palindrome since its already done. If false evaluates next OR condition. i >= s.length >> 1 3. Compares from beginning char and end char according to "i" eventually to meet as neighbors or neighbor to middle char. If false exits and assumes NOT palindrome. If true continues on to next AND condition. s[i] == s[s.length-1-i] 4. Calls itself again for recursion passing the original string as "s". Since "i" is defined for sure at this point, it is pre-incremented to continue checking the string's position. Returns boolean value indicating if palindrome. isPalindrome(s,++i) BUT... A simple for loop is still about twice as fast as my fancy answer (aka KISS principle) function fastestIsPalindrome(str) { var len = Math.floor(str.length / 2); for (var i = 0; i < len; i++) if (str[i] !== str[str.length - i - 1]) return false; return true; } http://jsfiddle.net/6L953awz/1/
The logic here is not quite correct, you need to check every letter to determine if the word is a palindrome. Currently, you print multiple times. What about doing something like: function checkPalindrome(word) { var l = word.length; for (var i = 0; i < l / 2; i++) { if (word.charAt(i) !== word.charAt(l - 1 - i)) { return false; } } return true; } if (checkPalindrome("1122332211")) { document.write("The word is a palindrome"); } else { document.write("The word is NOT a palindrome"); } Which should print that it IS indeed a palindrome.
First problem = is assign == is compare Second problem, Your logic here is wrong palindrom.charAt(palindrom.length)-1 You are subtracting one from the charAt and not the length. Third problem, it still will be wrong since you are not reducing the length by i.
It works to me function palindrome(str) { /* remove special characters, spaces and make lowercase*/ var removeChar = str.replace(/[^A-Z0-9]/ig, "").toLowerCase(); /* reverse removeChar for comparison*/ var checkPalindrome = removeChar.split('').reverse().join(''); /* Check to see if str is a Palindrome*/ return (removeChar === checkPalindrome); }
As a much clearer recursive function: http://jsfiddle.net/dmz2x117/ function isPalindrome(letters) { var characters = letters.split(''), firstLetter = characters.shift(), lastLetter = characters.pop(); if (firstLetter !== lastLetter) { return false; } if (characters.length < 2) { return true; } return isPalindrome(characters.join('')); }
SHORTEST CODE (31 chars)(ES6): p=s=>s==[...s].reverse().join`` p('racecar'); //true Keep in mind short code isn't necessarily the best. Readability and efficiency can matter more.
At least three things: You are trying to test for equality with =, which is used for setting. You need to test with == or ===. (Probably the latter, if you don't have a reason for the former.) You are reporting results after checking each character. But you don't know the results until you've checked enough characters. You double-check each character-pair, as you really only need to check if, say first === last and not also if last === first.
function checkPalindrom(palindrom) { var flag = true; var j = 0; for( var i = palindrom.length-1; i > palindrom.length / 2; i-- ) { if( palindrom[i] != palindrom[j] ) { flag = false; break; // why this? It'll exit the loop at once when there is a mismatch. } j++; } if( flag ) { document.write('the word is palindrome.'); } else { document.write('the word is not palindrome.'); } } checkPalindrom('wordthatwillbechecked'); Why am I printing the result outside the loop? Otherwise, for each match in the word, it'll print "is or is not pallindrome" rather than checking the whole word. EDIT: Updated with changes and a fix suggested by Basemm.
I've added some more to the above functions, to check strings like, "Go hang a salami, I'm a lasagna hog". function checkPalindrom(str) { var str = str.replace(/[^a-zA-Z0-9]+/gi, '').toLowerCase(); return str == str.split('').reverse().join(''); } Thanks
The most important thing to do when solving a Technical Test is Don't use shortcut methods -- they want to see how you think algorithmically! Not your use of methods. Here is one that I came up with (45 minutes after I blew the test). There are a couple optimizations to make though. When writing any algorithm, its best to assume false and alter the logic if its looking to be true. isPalindrome(): Basically, to make this run in O(N) (linear) complexity you want to have 2 iterators whose vectors point towards each other. Meaning, one iterator that starts at the beginning and one that starts at the end, each traveling inward. You could have the iterators traverse the whole array and use a condition to break/return once they meet in the middle, but it may save some work to only give each iterator a half-length by default. for loops seem to force the use of more checks, so I used while loops - which I'm less comfortable with. Here's the code: /** * TODO: If func counts out, let it return 0 * * Assume !isPalindrome (invert logic) */ function isPalindrome(S){ var s = S , len = s.length , mid = len/2; , i = 0, j = len-1; while(i<mid){ var l = s.charAt(i); while(j>=mid){ var r = s.charAt(j); if(l === r){ console.log('#while *', i, l, '...', j, r); --j; break; } console.log('#while !', i, l, '...', j, r); return 0; } ++i; } return 1; } var nooe = solution('neveroddoreven'); // even char length var kayak = solution('kayak'); // odd char length var kayaks = solution('kayaks'); console.log('#isPalindrome', nooe, kayak, kayaks); Notice that if the loops count out, it returns true. All the logic should be inverted so that it by default returns false. I also used one short cut method String.prototype.charAt(n), but I felt OK with this as every language natively supports this method.
function palindromCheck(str) { var palinArr, i, palindrom = [], palinArr = str.split(/[\s!.?,;:'"-()]/ig); for (i = 0; i < palinArr.length; i++) { if (palinArr[i].toLowerCase() === palinArr[i].split('').reverse().join('').toLowerCase() && palinArr[i] !== '') { palindrom.push(palinArr[i]); } } return palindrom.join(', '); } console.log(palindromCheck('There is a man, his name! was Bob.')); //a, Bob Finds and upper to lower case. Split string into array, I don't know why a few white spaces remain, but I wanted to catch and single letters.
= in palindrom[i] = palindrom.charAt(palindrom.length)-1 should be == or === palindrom.charAt(palindrom.length)-1 should be palindrom.charAt(palindrom.length - i)
Sharing my fast variant which also support spaces function isPalindrom(str) { var ia = 0; var ib = str.length - 1; do { if (str[ia] === str[ib]) continue; // if spaces skip & retry if (str[ia] === ' ' && ib++) continue; if (str[ib] === ' ' && ia--) continue; return false; } while (++ia < --ib); return true; } var palindrom="never odd or even"; var res = isPalindrom(palindrom); document.getElementById('check').innerHTML ='"'+ palindrom + '"'+" checked to be :" +res; <span id="check" />
Some above short anwsers is good, but it's not easy for understand, I suggest one more way: function checkPalindrome(inputString) { if(inputString.length == 1){ return true; }else{ var i = 0; var j = inputString.length -1; while(i < j){ if(inputString[i] != inputString[j]){ return false; } i++; j--; } } return true; } I compare each character, i start form left, j start from right, until their index is not valid (i<j). It's also working in any languages
One more solution with ES6 isPalin = str => [...str].every((c, i) => c === str[str.length-1-i]);
You can try the following function checkPalindrom (str) { str = str.toLowerCase(); return str == str.split('').reverse().join(''); } if(checkPalindrom('Racecar')) { console.log('Palindrome'); } else { console.log('Not Palindrome'); }
function checkPalindrom(palindrom) { palindrom= palindrom.toLowerCase(); var flag = true; var j; j = (palindrom.length) -1 ; //console.log(j); var cnt = j / 2; //console.log(cnt); for( i = 0; i < cnt+1 ; i++,j-- ) { console.log("J is => "+j); console.log(palindrom[i] + "<==>" + palindrom[j]); if( palindrom[i] != palindrom[j] ) { flag = false; break; } } if( flag ) { console.log('the word is palindrome.'); } else { console.log('the word is not palindrome.'); } } checkPalindrom('Avid diva');
I'm wondering why nobody suggested this: ES6: // "aba" -> true // "acb" -> false // "aa" -> true // "abba" -> true // "s" -> true isPalindrom = (str = "") => { if (str[0] === str[str.length - 1]) { return str.length <= 1 ? true : isPalindrom(str.slice(1, -1)) } return false; } alert(["aba", "acb", "aa", "abba", "s"].map((e, i) => isPalindrom(e)).join()) ES5: // "aba" -> true // "acb" -> false // "aa" -> true // "abba" -> true // "s" -> true function isPalindrom(str) => { var str = typeof str !== "string" ? "" : str; if (str[0] === str[str.length - 1]) { return str.length <= 1 ? true : isPalindrom(str.slice(1, -1)) } return false; } alert(["aba", "acb", "aa", "abba", "s"].map(function (e, i) { return isPalindrom(e); }).join());
Recursive Method: var low; var high; var A = "abcdcba"; function palindrome(A , low, high){ A = A.split(''); if((low > high) || (low == high)){ return true; } if(A[low] === A[high]){ A = A.join(''); low = low + 1; high = high - 1; return palindrome(A , low, high); } else{ return "not a palindrome"; } } palindrome(A, 0, A.length-1);
I thought I'd share my own solution: function palindrome(string){ var reverseString = ''; for(var k in string){ reverseString += string[(string.length - k) - 1]; } if(string === reverseString){ console.log('Hey there palindrome'); }else{ console.log('You are not a palindrome'); } } palindrome('ana'); Hope will help someone.
I found this on an interview site: Write an efficient function that checks whether any permutation of an input string is a palindrome. You can ignore punctuation, we only care about the characters. Playing around with it I came up with this ugly piece of code :) function checkIfPalindrome(text) { var found = {}; var foundOne = 0; text = text.replace(/[^a-z0-9]/gi, '').toLowerCase(); for (var i = 0; i < text.length; i++) { if (found[text[i]]) { found[text[i]]++; } else { found[text[i]] = 1; } } for (var x in found) { if (found[x] === 1) { foundOne++; if (foundOne > 1) { return false; } } } for (var x in found) { if (found[x] > 2 && found[x] % 2 && foundOne) { return false; } } return true; } Just leaving it here for posterity.
How about this, using a simple flag function checkPalindrom(str){ var flag = true; for( var i = 0; i <= str.length-1; i++){ if( str[i] !== str[str.length - i-1]){ flag = false; } } if(flag == false){ console.log('the word is not a palindrome!'); } else{ console.log('the word is a palindrome!'); } } checkPalindrom('abcdcba');
(JavaScript) Using regexp, this checks for alphanumeric palindrome and disregards space and punctuation. function palindrome(str) { str = str.match(/[A-Za-z0-9]/gi).join("").toLowerCase(); // (/[A-Za-z0-9]/gi) above makes str alphanumeric for(var i = 0; i < Math.floor(str.length/2); i++) { //only need to run for half the string length if(str.charAt(i) !== str.charAt(str.length-i-1)) { // uses !== to compare characters one-by-one from the beginning and end return "Try again."; } } return "Palindrome!"; } palindrome("A man, a plan, a canal. Panama."); //palindrome("4_2 (: /-\ :) 2-4"); // This solution would also work on something like this.
` function checkPalindrome (str) { var str = str.toLowerCase(); var original = str.split(' ').join(''); var reversed = original.split(' ').reverse().join(''); return (original === reversed); } `
This avoids regex while also dealing with strings that have spaces and uppercase... function isPalindrome(str) { str = str.split(""); var str2 = str.filter(function(x){ if(x !== ' ' && x !== ',') { return x; } }); return console.log(str2.join('').toLowerCase()) == console.log(str2.reverse().join('').toLowerCase()); }; isPalindrome("A car, a man, a maraca"); //true
function myPolidrome(polidrome){ var string=polidrome.split('').join(','); for(var i=0;i<string.length;i++){ if(string.length==1){ console.log("is polidrome"); }else if(string[i]!=string.charAt(string.length-1)){ console.log("is not polidrome"); break; }else{ return myPolidrome(polidrome.substring(1,polidrome.length-1)); } } } myPolidrome("asasdsdsa");
Thought I will share my solution using Array.prototype.filter(). filter() filters the array based on boolean values the function returns. var inputArray=["","a","ab","aba","abab","ababa"] var outputArray=inputArray.filter(function isPalindrome(x){ if (x.length<2) return true; var y=x.split("").reverse().join(""); return x==y; }) console.log(outputArray);
This worked for me. var number = 8008 number = number + ""; numberreverse = number.split("").reverse().join(''); console.log ("The number if reversed is: " +numberreverse); if (number == numberreverse) console.log("Yes, this is a palindrome"); else console.log("Nope! It isnt a palindrome");
Here is a solution that works even if the string contains non-alphanumeric characters. function isPalindrome(str) { str = str.toLowerCase().replace(/\W+|_/g, ''); return str == str.split('').reverse().join(''); }