function palindrome(str) {
var re = /[W_]/g;// representing Non-alphanumetic characters
var lowRegStr = str.toLowerCase().replace(re, '');
var reverseStr = lowRegStr.split('').reverse().join('');
return reverseStr === lowRegStr;
}
palindrome("A man, a plan, a canal. Panama");
function isPalindrome(sometext) {
var replace = /[.,'!?- "]/g; //regex for what chars to ignore when determining if palindrome
var text = sometext.replace(replace, '').toUpperCase(); //remove toUpperCase() for case-sensitive
for (var i = 0; i < Math.floor(text.length/2) - 1; i++) {
if(text.charAt(i) == text.charAt(text.length - 1 - i)) {
continue;
} else {
return false;
}
}
return true;
}
//EDIT: found this on https://medium.com/@jeanpan/javascript-splice-slice-split-745b1c1c05d2
//, it is much more elegant:
function isPalindrome(str) {
return str === str.split('').reverse().join('');
}
//you can still add the regex and toUpperCase() if you don't want case sensitive
#palindrome program in python
n=int(input('Enter a number :'))
num=n
rev=0
while n>0:
r=n%10
rev=rev*10+r
n//=10
print('Reverse of',num,'=',rev)
if rev==num:
print(num,'is a palindrome number')
else :
print(num,'is not a palindrome number')
#output
Enter a number :132
Reverse of 132 = 231
132 is not a palindrome numbe
________________________________________________________________________________
Enter a number :451
Reverse of 451 = 154
451 is not a palindrome number
________________________________________________________________________________
Enter a number :12321
Reverse of 12321 = 12321
12321 is a palindrome number
let data = 12421
const dataOne = data.toString().split("").reverse().join("");
data = data.toString();
dataOne === data ? console.log("Palindrom")
: console.log("Not Palindorm");
# Note: A palindrome is a string that reads the same forwards and backwards.
def palindrome_function(original_list, user_string):
# reversing the list
reversed_list = original_list[::-1]
# comparing reversed_list to original_list to
# determine if the original_list is a palindrome
if reversed_list == original_list:
print("'" + user_string.lower() + "' is a palindrome.")
else:
print("'" + user_string.lower() + "' is not a palindrome!")
def main():
# promting user to input a word or phrase
user_string = input("Enter string: ")
user_list = list(user_string.lower())
# putting our palindrome_function() to use
palindrome_function(user_list, user_string)
if __name__ == "__main__":
main()
var letters = [];
var word = "racecar" //bob
var rword = "";
//put letters of word into stack
for (var i = 0; i < word.length; i++) {
letters.push(word[i]);
}
//pop off the stack in reverse order
for (var i = 0; i < word.length; i++) {
rword += letters.pop();
}
if (rword === word) {
console.log("The word is a palindrome");
}
else {
console.log("The word is not a palindrome");
}
function isPalindrome(word) {
// Step 1- Put a pointer at each extreme of the word
// Step 2 - Iterate the string "inwards"
// Step 3 - At each iteration, check if the pointers represent equal values
// If this condition isn't accomplished, the word isn't a palindrome
let left = 0
let right = word.length-1
while (left < right) {
if (word[left] !== word[right]) return false
left++
right--
}
return true
}
isPalindrome("neuquen") // true
isPalindrome("Buenos Aires") // false
// Should Check if the argument passed is a string
function isPalindrome(str){
return typeof str === "string"
? str.split("").reverse().join("") === str
: "Value is not a type string";
}
var isPalindrome = function(x) {
let y = x
let r = y.toString().split('').reverse().join('')
let t = Number(r)
if(t ===x){
return true
}
else{
return false}
}
<script>
// function that check str is palindrome or not
function check_palindrome( str )
{
let j = str.length -1;
for( let i = 0 ; i < j/2 ;i++)
{
let x = str[i] ;//forward character
let y = str[j-i];//backward character
if( x != y)
{
// return false if string not match
return false;
}
}
/// return true if string is palindrome
return true;
}
//function that print output is string is palindrome
function is_palindrome( str )
{
// variable that is true if string is palindrome
let ans = check_palindrome(str);
//condition checking ans is true or not
if( ans == true )
{
console.log("passed string is palindrome ");
}
else
{
console.log("passed string not a palindrome");
}
}
// test variable
let test = "racecar";
is_palindrome(test);
</script>
# Program to check if a string is palindrome or not
my_str = 'aIbohPhoBiA'
# make it suitable for caseless comparison
my_str = my_str.casefold()
# reverse the string
rev_str = reversed(my_str)
# check if the string is equal to its reverse
if list(my_str) == list(rev_str):
print("The string is a palindrome.")
else:
print("The string is not a palindrome.")
//Reverses every character in the string
func Reverse(s string) (result string){
for _,v := range s {
result = string(v) + result
}
return
}
//Check if the string is same as it is reversed
func Check(s string) (b bool){
a := Reverse(s)
if s == a{
b = true
}else {
b = false
}
return
}
class Solution :
def isPalindrome(self, string: str ) :
'''
A function to check if a string is Palindrome or not!
:param string: string to be checked
:return: True if it is palindrome else False
'''
string = string.lower()
s_stripped = ''.join(list( filter ( lambda x : x.isalnum () == True , string)))
return s_stripped == s_stripped[::-1]
if __name__ == '__main__' :
string = 'Was it a car or a cat I saw!!'
print (f'Is "{string}" a palindrome? : {Solution ().isPalindrome (string)}')
string2 = 'A man, a plan,'
print (f'Is "{string2}" a palindrome? : {Solution ().isPalindrome (string2)}')
#include <iostream>
#include <deque>
bool is_palindrome(const std::string &s){
if(s.size() == 1 ) return true;
std::deque<char> d ;
for(char i : s){
if(std::isalpha(i)){
d.emplace_back( toupper(i) );
}
}
auto front = d.begin();
auto back = d.rbegin();
while( (front != d.end()) || (back != d.rend())){
bool ans = (*front == *back);
if(!ans){
return ans;
}
++front;++back;
}
return true;
}
int main() {
std::string s = "A man, a plan, a cat, a ham, a yak, a yam, a hat, a canal-Panama!";
std::cout << std::boolalpha << is_palindrome(s) << std::endl;
return 0;
}
// can we generate palindrome string by suffling
// the character of the string s
public bool CanBePalindrome(string s)
{
var dict = new Dictionary<char, int>();
for (int j =0; j < s.Length; j++)
{
var item = s[j];
if (dict.ContainsKey(item))
{
dict[item]++;
if (dict[item] == 2)
{
dict.Remove(item);
}
}
else
{
dict.Add(item, 1);
}
}
return dict.Count <= 1;
}