function palindrome(str) {
  return str == str.split('').reverse().join('');
}

 function palindrome(s){
    let m = 0;
    for(let i = 0, j = 1; i < Math.ceil(s.length/2) || Math.ceil(j < s.length/2); i++, j++){
        if(s.charCodeAt(i) != s.charCodeAt(s.length-j)){
            return 0;
        }
        else m = 1;
    }
    return m;
}

 function palindrome(s) {
    for (let i = 0; i < s.length; i++)
        if (s[i] != s[s.length - (i + 1)])
            return 0;
    return 1;
}

 function palindrome(letter)
{
    return letter == letter.split('').reverse().join('');
}

 function palindrome(s) {
    let count = 1;
    for(let i = 1; i < s.length; i++){
        if(s[s.length - i] == s[i - 1])
        count++
        
    }
    if(count == s.length){
        return 1;
    }
    else {
        return 0;
    }
        
      

}

 function palindrome(s)
{
  let str = s.split('')
  let rev = []
  for(let i=0; i< str.length; i++)
  {
      rev[i]= str[str.length-i-1]
      if(str[i]!==rev[i])
      {
         return 0
      }
  }
  return 1
}

 function palindrome(s)
{
    if(s == rever(s))
        return 1;
    return 0;
}

function rever(str)
{
    var newStr = '';
    
    for(var i = 0; i < str.length; i++)
        newStr = str[i] + newStr;
    
    return newStr;
}

 function palindrome(s) {
    let a = parseInt(s.length / 2);
    let dl = s.length - 1;
    for (let i = 0; i < a; i++) {
        if (s[i] == s[dl - i])
            continue;

        else
            return 0;
    }
    return 1;
}

 function palindrome(i)
{
    let result = 0; 
    i == i.split('').reverse().join('')? result = 1 : result = 0;
    return result;  
}

 function palindrome(a) {
    let b = '';
    for (let i = a.length - 1; i >= 0; --i)
    {
        b += a[i];
    }
            if (a == b)
            return 1;
            else
            return 0;
}

 function palindrome(str){
    let res=1;
    for (i=0; i<(str.length/2); i++){
        if (str[i]!=str[str.length-1-i]){
            res=0;
            break;
        }
    }
    return (res);
}

 function palindrome(a) {
    let b = a.toUpperCase();
    let N = b.length; 
    for (let i = 0; i< N/2; i++)  
        if (b[i] != b[N-1-i]) return 0;
    return 1
}

 function palindrome(str){
    let result = 0;
    let newStr = '';
    for(let i = 0; i < str.length; i++){
        newStr = str[i] + newStr;
    }    
    if(str == newStr){
        result = 1;
        }
    else {result = 0}
    
    return result;
}

 function palindrome(s){
    let n="";
    let result=0;
    for (let i=0; i< s.length; i++){
        n+=s[(s.length-1)-i];
        if (n==s) {
          result=1;
        }
        else {
          result=0;
        }
    }
    return result;
}

 function palindrome ( i ) {
    if ( i == i.split("").reverse( ).join("") )
    return 1
    else 
    return 0
}

 function palindrome(s){
    let c = s;
    s = s.split("");
    s = s.reverse();
    s = s.join("");
    if (c == s){
        return 1;
    }else {
        return 0;
    }
}

 function palindrome(s) {
let a = s.split('').reverse().join('');
  if (a === s){ 
    return 1;
  } else {
    return 0;
  }
}

 function palindrome(i) {
  return i == i.split('').reverse().join('');
}

 function palindrome(str){
    let arr = str.split("");
    let rev = arr.reverse().join("");
    if(rev == str){
        return 1;
    }
    else{
        return 0;
    }
}

 function palindrome(i) {
  return i == i.split('').reverse().join('');
}

 function palindrome(s) {
    if (s.length === 1) return 1;
    let midIndex = Math.floor(s.length / 2);
    let left = s.slice(0, midIndex);
    let right = s.slice((s.length % 2 === 0 ? midIndex : midIndex + 1), s.length);
    return left === [...right].reverse().join('');
}

 function palindrome(s) {
    let n = 0;
    for(let i = 0; i < s.length; i++){
        if(s[i] == s[s.length-1-i]){
            ++n;
        } else{
            return 0;
        }
    }
    if(n == s.length){
        return 1;
    }
}

 function palindrome(s) {
    for(let i = 0; 2*i < s.length; ++i) {
        if(s.at(i) != s.at(s.length - i - 1))
            return false;
    }
    return true;
}

 function palindrome(str){
let a=0
str = str.toLowerCase()
if(str.length%2==1){
      for(i=(str.length-1)/2,j=(str.length-1)/2;i>=0;i--,j++){
         if(str[i]==str[j]){
             a++
          }
}
if(a==(str.length+1)/2){
return 1
    }
}
else{
for(i=str.length/2-1,j=str.length/2;i>=0;i--,j++){
         if(str[i]==str[j]){
             a++
          }
}
if(a==str.length/2){
return 1
    }
}
return 0
}

 function palindrome(str) {
    let counter = 0;
    for (let i = 0, j=str.length-1; i<=j; i++, j--) {
        if (str[i] == str[j])
        counter++
    }
    if (counter>=str.length/2)
    return 1
    else
    return 0
}

 function palindrome(string) {
  let result
  let string1 = string.split('').reverse().join('')
  if (string.toLowerCase() == string1.toLowerCase()) {
    result = 1
  } else {
    result = 0
  }
  return result
}

function palindrome(s) {
    s = s.toLowerCase()
    return s == s.split('').reverse().join('');
}

 function palindrome (ik) {
let arr1 = [];
let arr2 = []
for (let i = 0; i < ik.length; i++) {
arr1[i] = ik[i];
}
console.log(arr1);
let k = 0;
for (let i = ik.length - 1; i >= 0; i--) {
arr2[k] = ik[i];
k++;
}

console.log(arr2)
let count = 0;
for (let i = 0; i < arr1.length; i++) {
if (arr1[i] == arr2[i]) {
count++;
}
}
if (count == arr1.length) {
return 1;
}
return 0;
}

 function palindrome ( i ) {
    if ( i == i.split("").reverse( ).join("") )
    return 1
    else 
    return 0
}

 function palindrome(str) {
let restr = '';
    for(let i = str.length - 1; i >= 0; i--) {
        restr += str[i];
    }
    return str === restr;
}

 function palindrome(i){
  return i == i.split('').reverse().join('');
}

 function palindrome(str) {
    let reverseStr = str.split('').reverse().join('');
    if (reverseStr === str) {
        return 1;
    }
    else{ 
        return 0;
    }
}

 function palindrome(n){
    if(n.toString().split("").reverse().join("") == n.toString()){return 1}
    else {return 0};
}

 function palindrome(s) {
        s.toLowerCase()
        let t = 0;
        for (i = 0; i < Math.floor(s.length / 2); i++) {
            if (s[i] !== s[s.length - 1 - i]) t = 1
        }
        if (t == 1) {
            return "0"
        } else {
            return "1"
        }
    }

 function palindrome(text){
return text == text.split('').reverse().join('')
}

 function palindrome(s) {
    arr = s.split('');
    let count = 1;
    for(let i =0; i < arr.length && count != 0;i++){
        if(arr[i] == arr[arr.length - 1 - i]){
            continue;
        }else{
            count = 0;
        }
    }
    return count;
}

 function palindrome(str) {
  str = str.toLowerCase();
  for (let i = 0; i < str.length / 2; i++) {
    if (str[i] !== str[str.length - 1 - i]) return 0;
  }
  return 1;
}

 function palindrome(s) {
    s = s.toLowerCase();
    ar = [...s].reverse().join("");
    console.log(s, ar);

    if (ar == s) return 1;
    else return 0;
}

 function palindrome(string) {
    if (string.length === 1) return 1;
    let midIndex = Math.floor(string.length / 2);
    let left = string.slice(0, midIndex);
    let right = string.slice((string.length % 2 === 0 ? midIndex : midIndex + 1), string.length);
    return left === [...right].reverse().join('');
}

 function palindrome(i){
    i.toLowerCase()
    let poli = ""
    for (let j = i.length - 1; j >= 0; j--){
        poli += i.charAt(j)
    }
    if (i === poli)
        return 1
    else
        return 0
}

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

 function palindrome(i)
{
   return i == i.split('').reverse().join('');
}

 function palindrome(s)
{
    for(let i=0;i< s.length/2;i++)
        if(s[i]!=s[s.length-(i+1)])
            return 0;
    return 1;
}

 function palindrome(str)
{
    let rev = str.split("").reverse().join("");

    if(str == rev)
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

 function palindrome(string){
    return string == string.split("").reverse().join("");
}

 function palindrome(s)
{
  let check = '';
  for (let i = s.length - 1; i >= 0; --i) {
    check += s[i];
  }
  return s == check;
}

 function palindrome(s) {
    return s == s.split('').reverse().join('');
}

 function palindrome(i){
    let arr_I = [];
    for(let index = 0; index <= i.length; index++){
        arr_I.unshift(i[index]);
    }
    if (arr_I.join('') == i){
        return 1
    }
    else
    {
      return  0
    }
}

 function rev(s){
    a = s.split ("")
    a.reverse()
    a = a.join("")
    return a
}
function palindrome(s){
    s1 = rev (s)
    if (s1 == s){
        return 1
    }
    else{
        return 0
    }
}

 function palindrome(arr)
{
    for(let i = 0, j = arr.length - 1; i < arr.length && j >= 0; i ++, j --)
    {
        if(arr[i] != arr[j])
        {
            return 0;
        }
    }
    return 1;
}

 function palindrome(s) {
    s = s.toLowerCase().split("").join("")
    b = s.split("").reverse().join("")
        console.log(s)
        console.log(b)
    if(s == b){
        return 1
       
    }
   else{
    return 0
   }
}

 function palindrome(i) {
   return i == i.split("").reverse().join('')
}

 function palindrome(string) {
    if (string.length === 1) return 1;
    let midIndex = Math.floor(string.length / 2);
    let left = string.slice(0, midIndex);
    let right = string.slice((string.length % 2 === 0 ? midIndex : midIndex + 1), string.length);
    return left === [...right].reverse().join('');
}

 function palindrome(s) {
    
    for(let i=0;i    {
        if(s[i]==s[s.length-i-1])
        continue;
        else 
    return 0;
    }
    return 1;
}

 function palindrome(s) {
    let count =0;
    for(let i=0; i<=((s.length)/2); i++){
        if(s[i]==s[s.length-1-i]){
            count+=1;
        }
    }
    if(count >= ((s.length)/2)){
        return 1
    }else{
        return 0
    }
}

 function palindrome(str){
    if (str.split('').reverse().join('') == str) return 1;
    return 0;
}

 function palindrome(s){
    let f = true;
    for(let i = 0; i< s.length; i++){
        if(s[i]!=s[s.length-i-1]){
            f=false;
            break;
        }
    }
    return f;
}

 function palindrome(s) { 
    let l = s.length;
    let res = 0;
    for(let i = 0; i < l/2; i++){
        if(s[i] == s[(l-1)-i]){
            res++;
        }
    }
    if((res == l/2)||(res == ((l-l%2)/2)+1)){
        return 1;
    }else {
        return 0;
    }
}

 function palindrome(str) {
  let reversed = str.split('').reverse().join('');
  if (str === reversed) {
    return 1;
  } else {
    return 0;
  }
}

 function palindrome(s) {
        s.toLowerCase()
        let t = 0;
        for (i = 0; i < Math.floor(s.length / 2); i++) {
            if (s[i] !== s[s.length - 1 - i]) t = 1
        }
        if (t == 1) {
            return "0"
        } else {
            return "1"
        }
    }

 function palindrome(s)
{   
    s.toLowerCase()
    let t = 1
    let s1 = [] 
    let s2 = []
    for(let i = 0;i < s.length/2;i++)
    {   
        s1+=s[i]
    }
    ss=s.split('').reverse().join('')
    for(let j = 0;j < ss.length/2;j++)
    {
        s2+=ss[j]
    }
    for(let k = 0;k < s.length/2;k++)
    {
        if(s1.charCodeAt(k) != s2.charCodeAt(k)) t = 0
    }
    return(t)
}

 function palindrome(i){
    let reversed = i.split("").reverse().join('');
    if (reversed == i){
        return 1
    }
    else{
        return 0
    }
}

 function palindrome(s) {
    let arr1 = s.split('');
    let arr2 = s.split('').reverse();
    for(let i = 0; i < arr1.length; i++){
        if (arr1[i] !== arr2[i]) {
            return 0;
        }     
    }
    return 1;
}

 function palindrome(p){
    let c ='';
    for(let i =p.length-1;i >= 0;--i){
        c+=p[i];
    }
   if(p==c){
       return true;
   } 
   else{
       return false;
   }
}

 function palindrome(str) {
    
    let lastIndex = str.length - 1;
    for (let i = 0; i < str.length / 2; i++) {
        if (str[i] !== str[lastIndex - i]) {
            return 0;
        }
    }
    return 1;
}

 function palindrome(i) {
    let n = 0;
    for (let j = 0; j < (i.length/2); j++) {
        if (i[j]!=i[i.length - 1 - j]) n=1;
    }
    if (n == 0) return ('1');
    else return ('0');
}

 function palindrome(s){
    let r = "";
    for(let i =s.length-1;i>=0;i--)
    {
        r+=s[i];
    }
    if(r==s){return 1;}
    else{return 0;}
}

 function palindrome(string) {
    if (string.length === 1) return 1;
    let midIndex = Math.floor(string.length / 2);
    let left = string.slice(0, midIndex);
    let right = string.slice((string.length % 2 === 0 ? midIndex : midIndex + 1), string.length);
    return left === [...right].reverse().join('');
}

 function palindrome(s) {
    let count = 0;
    let arr = [...s];
    let arrRev = [...s];
    arrRev.reverse();
    for (let i = 0; i < arr.length; i++) {
        if (arr[i] === arrRev[i])
            count++;
    }
    if (count === arr.length)
        return 1;
    else 
        return 0;
}

 function palindrome(s) {
    let a = s.length
    let x = []
    let y = []
    let z = 1 
        for ( let i = a ; i > 0; i-- ){
            x.push(s[i-1])
        }
        console.log(x)
        for ( let j = 0; j < a; j ++ ){
            y.push(s[j])
        }
        console.log(y)
        for ( let u = 0; u < a; u ++ ){
            if ( y[u] == x[u]){
                z *= 1
            }
            if ( y[u] != x[u]){
                z *= 0
            }
        }
        return z
}

 function palindrome(str){
      var newString = "";
    for (var i = str.length - 1; i >= 0; i--) {
        newString += str[i];
    }
    if(str==newString){
        return 1
    }
    else{
        return 0
    }
}

 function palindrome(s)
{
let reverse = s.split('').reverse().join('');
if(s==reverse)
{
return 1
} 
return 0
}

 function palindrome(i){
    return i ==i.split('').reverse().join('');
    }

 function  palindrome (str) {
  return str == str.split('').reverse().join('');
}

 function palindrome(s) {
    for (let i = 0, j = s.length - 1; i < j; i++, j--) {
        if (s[i] != s[j]) return 0
    }
    return 1;
}

 function palindrome(text){return text == text.split('').reverse().join('')}

 function palindrome(s){
    let sr = s.split('');
    sr = sr.reverse()
    sr = sr.join('')
    return s == sr
}

 function palindrome(str){
    let revers='';
    for (let i=str.length-1; i>=0; --i) {
      revers+=str[i];
    }
    if (str==revers) {
      return 1;
    } 
    else {
      return 0;
    }
}

 function palindrome(string) {
    let number = 1;
    for(i = 0; i < string.length; i++) {
        if (string[i] == string[(string.length-i-1)]) {
            continue;
        } else {
            number = 0;
            break;
        }
    }
    return number;
}

 function palindrome(string) {
    if (string.length === 1) return 1;
    let midIndex = Math.floor(string.length / 2);
    let left = string.slice(0, midIndex);
    let right = string.slice((string.length % 2 === 0 ? midIndex : midIndex + 1), string.length);
    return left === [...right].reverse().join('');
}

 function palindrome(s)
{
  let a = '';
  for ( let i = s.length - 1; i >= 0; --i ) 
{
   
     a += s[i];
   }
  if ( s == a )
     return 1;
  else
     return 0;

}

 function palindrome(str){
    if (str === str.split("").reverse().join(""))
        return 1
    return 0
}

 function palindrome(str){
  if (str == str.split('').reverse().join('') ) {
      return 1
      
  } 
  else {
      return 0
  }
}

 function palindrome(word){
    for (let i = 0 ; i < word.length/2; i++){
        if (word[i] != word[(word.length - 1) - i]){
            return 0 ;
        }
    }
    return 1 ;
}

 function palindrome(string){
    if(string == string.split('').reverse().join('')){
        return 1;
    }
    else{
        return 0;
    }
}

 function palindrome(s)
{
    if(s == rever(s))
        return 1;
    return 0;
}

function rever(str)
{
    var newStr = '';
    
    for(var i = 0; i < str.length; i++)
        newStr = str[i] + newStr;
    
    return newStr;
}

 function palindrome(word) {
    let rev = '';
    for (let char in word){
        rev += word[word.length-char-1];
    }
    return rev == word
}

 function palindrome(s) {
    const len = s.length;
    for (let i = 0; i < len / 2; i++) {

        if (s[i] !== s[len - 1 - i]) {
            return 0;
        }
    }
    return 1;
}

 function palindrome(s){
    let arr = [...s];
    for(let i = 0; Math.floor(arr.length)>i;i++){
        if(arr[i] !== arr[arr.length-1-i]){
            return 0
        }
    }
    return 1
}

 function palindrome(str){
    let check = '';
    for (let i = str.length - 1; i >= 0; i--){
        check += str[i];
    }
    if (str == check){
        return 1;
    } else {
        return 0;
    }
}

 function palindrome(str){
    let reverse = str.split('').reverse().join('');
    
    if (reverse == str) {return 1;}
    else{return 0;} 
}

 function palindrome(s) {
    for (let i = 0; i < (s.length / 2); i++) {
        if (s.charCodeAt(i) != s.charCodeAt(s.length - 1 - i)) {
            return 0;
        }
    }
    return 1;
}

 function palindrome(s) {
     s = s.toLowerCase();
    let s2 = s.split('').reverse().join('');
    if( s == s2 ) {
        return 1;
    }
    else {
        return 0;
    }
}

 function palindrome(s){
    let c = 0;
    for (let i = 0; i < s.length / 2; i++)
        if (s[i] == s[s.length - i - 1])
            c++;
    if (s.length % 2 == 0) 
        if (c * 2 == s.length )
            return 1;
        else 
            return 0;
    else
        if ((c * 2) - 1 == s.length )
            return 1;
        else 
            return 0;
}

 function palindrome(s) {
  return  s==s.split("").reverse().join("")?true:false;
}

 function palindrome(string) {
    if (string.length === 1) return 1;
    let midIndex = Math.floor(string.length / 2);
    let left = string.slice(0, midIndex);
    let right = string.slice((string.length % 2 === 0 ? midIndex : midIndex + 1), string.length);
    return left === [...right].reverse().join('');
}

 function palindrome(s) {
    let sr = s.split('');
    sr = sr.reverse()
    sr = sr.join('')
    return s == sr
}

 function palindrome(s) {
  const arr = s.split('');
  const n = arr.reverse();

  if (n.join('') === s) 
  return 1;
  
  return 0;
}

 function palindrome(str) {
    str = str.toLowerCase()
    return str === str.split("").reverse().join("") ? 1 : 0;
}

 function palindrome(str) {
    let l = Math.floor(str.length / 2);
    for (let i = 0; i < l; i++)
        if (str[i] !== str[str.length - i - 1])
            return 0;
    return 1;
}

 function palindrome(b){
    let i = 0;
    for(let g = 0;g < b.length / 2;g++)
    {
        if(b[b.length - 1 - g] == b[g]){
            i = 1;
        } else {
            i = 0;
            break;
        }
    }
    return i;
}

 function palindrome(w){
    w = w.toLowerCase();
    ar = [...w].reverse().join("");
    console.log(w, ar);
    if (ar == w) return 1;
    else return 0;
}

 function palindrome(s) {
        for (let i = 0; i < s.length / 2; i++) {
            if (s[i] != s[s.length - i - 1])
                return 0
        }
        return 1;
    }

 function palindrome(i){
    if(i.toLowerCase() == i.split("").reverse().join("").toLowerCase()){
        return 1;
    }else{
        return 0;
    }
}

 function palindrome(s){
    if(s.split('').reverse().join('') == s){
        return 1
    }else{
        return 0
    }
}

 function palindrome(string){
if(string.split('').reverse().join('') == string){
    return 1
}else{
    return 0
}
}

 function palindrome(s) {
    let check = '';
    for (let i = s.length - 1; i >= 0; --i) {
    check += s[i];
  }
  if (s == check) {
    return (1);
  } else {
    return (0);
  }
}

 function palindrome(i) {
    let arr = [];
    for(let j = 0; j< i.length; j++) {
        arr.push(i[j]);
    }
    let t = [];
    t = arr.concat(t);
    t = t.join('');
    arr.reverse();
    arr = arr.join('');
    if(arr == t)
        return 1;
    else
        return 0;

}

 function palindrome(str){
    let arr = Array.from(str);
    let reversedArr = Array.from(str).reverse();
    let equals = arr.every((val, index) => val === reversedArr[index]);
    return equals;
}

 function palindrome(str){
    if (str === str.split("").reverse().join("")){
        return 1
    }else return 0
}

 function palindrome(s) {
    let k = 0;
    let ar = s.split("").reverse().join("");
    if (s === ar) k = 1;
    return k;
}

 function palindrome(str){
    let check = '';
    for (let i = str.length - 1; i >= 0; i--){
        check += str[i];
    }
    if (str == check){
        return 1;
    } else {
        return 0;
    }
}

 function palindrome(a){
   
    for (let i = 0, t = a.length -1; i< t; i++, t--){
        if (a[i] != a[t]){
            return 0
        }
    }
    return 1
}

console.log(palindrome("нажалкабаннабаклажан"))

 function rev(s){
    a =s.split("")
    a.reverse()
    a = a.join("")
    return a 
}
function palindrome(s){
    s1=rev(s)
    if (s1==s){
        return 1    
    }
    else{
        return 0
    }
}

 function palindrome(s){
    let c = s.split("").reverse().join("")
    if(s == c){
        return 1
    }
    else {
        return 0
    }
}

 function palindrome(blabla){
    if (blabla.split('').reverse().join('') === blabla)
        return 1;
    else 
        return 0;
}

 function palindrome(s){
    return s.slice(0,Math.ceil(s.length/2))==s.slice(Math.ceil(s.length/2)-s.length%2,s.length).split("").reverse().join("")?1:0
}

 function palindrome(str){
    let str2 = str
    let str1 = str.split("").reverse().join("")
    if (str2 == str1){
        return 1
    } else {
        return 0
    }
}

 function palindrome(i) {
    for (let j = 0; j < i.length/2; j++) 
        if (i[j] !== i[i.length - j - 1]) 
            return 0;
    return 1;
}

 function palindrome(str)
{
   
    for(i=0;i< str.length/2;i++)
    {
        if(str[i]!=str[str.length-(i+1)]) return 0;
    }
    return 1;
    
}

 function palindrome(s) {
    const arrayValues = s.split('');

    const reverseArrayValues = arrayValues.reverse();

    const reverseString = reverseArrayValues.join('');

    if(s == reverseString) {
        return 1;
    }
    else {
        return 0;
    }
}

 function palindrome(string) {
    return (string==string.split('').reverse().join(''))
}

 function palindrome(s){
    let a = s.split("")
    let b = a.reverse()
return s===b.join("") ? 1:0
}

 function palindrome(x){
    let strRev = x.split('').reverse().join('');
    return (x == strRev)? 1:0
}

 function palindrome(s) {
  const l = s.length;
  for (let i = 0; i < Math.floor(l / 2); i++) {
    if (s[i] !== s[l - i - 1]) return false;
  }
  return true;
}

 function palindrome(string){
    let revStr = string.split("").reverse().join("");;
     return (string == revStr)? true : false;
}

 function palindrome(str) {
    let count = 0;
    for (let i = 0, j = str.length - 1; i < j; i++, j--) {
         if(str[i] == str[j]) {
            count++;
         } else {
            return 0;
         }
    }
    if (count == Math.floor(str.length/2)) {
        return 1;
    }
}

 function palindrome(str){
    let pali = "";
    
    for (let i = str.length; i >= 0; i--)
        pali += str.charAt(i);
    
    
    if (pali == str) 
        return 1;
     
      
    return 0;
}

 function palindrome(str)
{
    let useless = [" ", ",", ".", "-","!","?"];
    for(let i = 0; i < useless.length; i++)
        str.replace(useless[i], "");
    str = str.toUpperCase();
    
    let str2 = str.split("").reverse().join("");
    if(str == str2)
        return true
    return false
}

 function palindrome(input){
    
    let arrayFromInput = Array.from(String(input).replace(/','|\s+/g,'').toLowerCase())
    let counter = 0;
    let switcher = 1;
    for (let i = 0; i < arrayFromInput.length; i++){
        counter++
        if (arrayFromInput[i] == arrayFromInput[arrayFromInput.length - counter]){
            switcher = 1
        }
        else{
            switcher = 0
            return switcher
        }
    }

    return switcher
    
 }

 function palindrome(string) {
  let start = 0;
  let end = string.length - 1;
  
  while (start < end) {
    if (string[start] !== string[end]) {
      return 0;
    }
    start++;
    end--;
  }
  
  return 1;
}

 function palindrome(s)
{
    return s == s.split('').reverse().join('');
}

 function palindrome(s){
    var y = s.split("").reverse().join("");
    var h = s.split("").join("");
    if (y == h){
        k = 1
    }
    else k = 0
    return k
}

 function palindrome(s) {
    let j = s.length-1;
    let number = 1;
    for(let i = 0; i< s.length; i++)
    {
        if(s[i]!=s[j])
        {
            number = 0;
        }
        j--;
    }
    return number;
}

 function palindrome(z){
    if(typeof(z)== "string"){
        if(z == (z.split("").reverse().join(""))){
      return 1;} else{return 0; }
    }
    else{
        if(z == (z.reverse())){
            return 1;} else{return 0; }
    }
  }
  console.log(palindrome("1010"));

 function palindrome(s){
    let r = 0;
    let n = s;
    s = s.split('').reverse().join('');
    if(s == n){
        r = 1;
    }
    else{
        r = 0;
    }
    return r;
}

 function palindrome(s){
let str = s.split("").reverse().join("")
if(s == str){
    return 1;
}else{
    return 0;
}

}