C# palindrome number

// Given a string, return true or false depending if the string
// is a palindrome.  Palindromes are words that read the same backwards
// and forwards. Make sure it is case insensitive!
// --- Examples:
//   palindrome("Madam") === true
//   palindrome("love") === false

function palindrome(str) {
  return (str.toLowerCase().split("").reverse().join("") === str.toLowerCase())
}

const isPalindrome = (str) => {
    
    const preprocessing_regex = /[^a-zA-Z0-9]/g,
    processed_string = str.toLowerCase().replace(preprocessing_regex , ""),
    integrity_check = processed_string.split("").reverse().join("");
    if(processed_string === integrity_check) return true
    else return false
         
        }

//if you find this answer is useful ,
//upvote ⇑⇑ , so can the others benefit also . @mohammad alshraideh ( ͡~ ͜ʖ ͡°)

function isPalindrome(num) {
   const temp = num.toString().split('').reverse().join('') * 1;
   return (result = num === parseInt(temp) ? true : false);
}

console.log(isPalindrome(121));
console.log(isPalindrome(320));

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

class Solution {
public:
    bool isPalindrome(int x) {
        
    }
};

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()

def pal(word):
    isPal = 1
    first = 0
    last = len(word)-1;
    for x in range(last):
        if(word[first]!=word[last]):
            isPal = 0
        first += 1
        last -=1
    return isPal
        

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");
}   

def is_palindrome(s):
    string = s
    if (string==string[::-1]):
        print("The string IS a palindrome")
    else:
        print("The string is NOT a palindrome")
    return

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}


}

 while(n>0){    
   r=n%10;  //getting remainder  
   sum=(sum*10)+r;    
   n=n/10;    
  }    

# 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.")

function palindrome(str) {
	if (str.toLowerCase() === str.toString().toLowerCase().split('').reverse().join('')) {
		return true;
	} else {
		return false;
	}
}

//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
}

function Palindrome(str) { 

  str = str.replace(/ /g,"").toLowerCase();
  var compareStr = str.split("").reverse().join("");

  if (compareStr === str) {
    return true;
  } 
  else {
    return false;
  } 

}

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)}')

class Solution {
    func isPalindrome(_ x: Int) -> Bool {
        
    }
}

Input: s = "race a car"
Output: false
Explanation: "raceacar" is not a palindrome.

Input: s = "race a car"
Output: false
Explanation: "raceacar" is not a palindrome.

anything

Input: x = 121
Output: true
Explanation: 121 reads as 121 from left to right and from right to left.

class Solution {

    /**
     * @param Integer $x
     * @return Boolean
     */
    function isPalindrome($x) {
        
    }
}

# @param {Integer} x
# @return {Boolean}
def is_palindrome(x)
    
end

/**
 * @param {number} x
 * @return {boolean}
 */
var isPalindrome = function(x) {
    
};

public class Solution {
    public bool IsPalindrome(int x) {
        
    }
}

class Solution {
    public boolean isPalindrome(int x) {
        
    }
}

import java.util.Scanner;
class Palindrome {
    public static void main(String args[]) {
        String original, reverse = "";
        Scanner s1 = new Scanner(System.in);
        System.out.println("Enter a word");
        original = "cat";
        int length = original.length();
        for ( int i = length - 1; i >= 0; i-- )
            reverse = reverse + original.charAt(i);
        if (original.equals(reverse))
            System.out.println("true");
        else
            System.out.println("false");
    }
}

const palindrome = str => {
  // turn the string to lowercase
  str = str.toLowerCase()
  // reverse input string and return the result of the
  // comparisong
  return str === str.split('').reverse().join('')
}

function isPalindrome(text) {
  return [...text].reverse().join('') === text;
}

isPalindrome = text => {
	return [...text].reverse().join('') === text;
}

isPalindrome = text => [...text].reverse().join('') === text;

171, 181, 191, 202

#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;
}

function isPalindrome(x: number): boolean {

};

bool isPalindrome(int x){

}