第 81 题：打印出 1 - 10000 之间的所有对称数 例如 121、1331 等

Question

[...Array(10000).keys()].filter((x) => { 
  return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) 
})

Answer 1

function getSymmetricNum() {
  return [...Array(10000)].map((item, index) => index + 1 + '')
    .filter(item => item.length > 1 && item.split('').reverse().join('') === item)
}
getSymmetricNum()

Answer 2

function test() {
  return Array.from({length:100}).map((v,i)=>i).filter(m=> m>10 && m.toString().split('').reverse().join('') === m.toString())
}

Answer 3

for(let i = 10 ; i <10000;i++){
  let n = i+''
  if(n.length==2){
    if(n[0] == n[1]){
      console.log(parseInt(n))
    }
  }
  if(n.length==3){
    if(n[0] == n[2]){
      console.log(parseInt(n))
    }
  }
  if(n.length==4){
    if(n[0]+n[1] == n[3]+n[2]){
      console.log(parseInt(n))
    }
  }
}

Answer 4

// 打印出 1 - 10000 之间的所有对称数

// 例如：121、1331 等

const logSymmetry = () => {
  let result = [];
  for (let i = 0; i < 10000; i++) {
    let str = String(i);
    let reverse = str.split("").reverse().join("");
    if (str === reverse) {
      result.push(i);
    }
  }
  return result;
};

console.log(logSymmetry());

Answer 5

咋全是遍历所有数字的答案。

以10000 为例，列出所有位数的对称数，比如1位数的 对称数， 2位数的对称数...到5位数， 再判断是否小于10000。

对称数生成 ： 遍历最长位数（如5位）。 每个位置遍历 0 - 9，对称即可。

function symmetry(num) {
    let symmetrys = [];
    for (let i = 1; i < num; i++) {
        let iStr = i.toString();
        let n1 = iStr + iStr.slice(0,iStr.length-1).split('').reverse().join('');
        let n2 = iStr + iStr.split('').reverse().join('');
        if ( +n2 > num) {
            console.log(symmetrys.length)
            return symmetrys;
        } else {
            symmetrys.push(+n1);
            symmetrys.push(+n2);
        }
    }
    return symmetrys;
}
console.log(symmetry(100000000))

Answer 6

function a(start, end) {
let arr = []
const endloc = Math.floor(Math.log10(end))
const startloc = Math.floor(Math.log10(start))
const backTrack = function (val, weishu) {
if (val <= end && val >= start && weishu == 0) {
arr.push(val)
return
}else if (weishu == 0 &&( val > end || val < start)) return
if (weishu == 1) {
const number = (10 ** Math.ceil((Math.floor(Math.log10(val)) - 1) / 2))
for (let i = 0; i <= 9; i++) {
backTrack(val + number * i, weishu - 1)
}
} else if (weishu == 2) {
if (Math.floor(Math.log10(val)) == 1) {
for (let i = 0; i <= 9; i++) {
backTrack(11 * i, 0)
}
return
}
const number = (10 ** Math.ceil((Math.floor(Math.log10(val)) - 2) / 2)) * 11
for (let i = 0; i <= 9; i++) {
backTrack(val + number * i, weishu - 2)
}
} else {
let mid
if (Math.floor(Math.log10(val)) + 1 == weishu) {
mid = val + 1
for (let i = 0; i <= 9; i++) {

                backTrack( mid * i, weishu - 2)
            }
        } else {
            let left = 10 ** weishu
            let right = 10 ** (Math.floor(Math.log10(val)) - weishu)
            mid = left + right
            for (let i = 0; i <= 9; i++) {
                
                backTrack(val + mid * i, weishu - 2)
            }
        }

    }
}
for (let i = 10 ** endloc, j = endloc + 1; i >= 10 ** startloc; i = i / 10, j--) {
    console.log(i, j)
    backTrack(i, j)
}
console.log(arr)

}
a(22, 100)
回溯

Answer 7

[...Array(10000).keys()].filter(value => value > 10 && value.toString() === value.toString().split('').reverse().join(''))

Answer 8

一个比较原始的办法，但却是最好理解的：

function print (min, max) {
    for(var i=min; i<max; i++) {
        let str = i.toString().split('')
        let num = Number(str.join(''))
        if(str.length==2 && str[0] == str[1]){
            console.log(num)
        } else if (str.length==3 && str[0] == str[2]) {
            console.log(num)
        } else if (str.length==4 && str[0] == str[3] && str[1] == str[2]) {
            console.log(num)
        }
    }
}
print(1, 10000)

Answer 9

function reverseCount(total) {
    for (let i = 10; i < total; i++) {
        if (+(i + '').split('').reverse().join('') === i) {
            console.log(i)
        }
    }
}
reverseCount(10000)

Answer 10

let data = []
for (let i = 0; i <= 9; i++) {
    let one = i + '' + i;
    if (i !== 0) {
        data.push(parseInt(one))
    }
    for (let j = 0; j <= 9; j++) {
        let two = i + '' + j + i;
        let three = i + '' + j + j + i;
        if (i !== 0 && i !== j) {
            data.push(parseInt(two));
            data.push(parseInt(three));
        }
    }
}

虽然不好看，但是遍历次数少些。

Answer 11

一、遍历所有数，判断是否是回文数

1、字符串反转后判断

function isPalindrome(n) {
  if (typeof n !== 'string') {
    n = n.toString()
  }
  return n.split('').reverse().join('') === n
}

2、双指针遍历

function isPalindrome(n) {
  if (typeof n !== 'string') {
    n = n.toString()
  }

  let l = 0, r = n.length - 1
  while(l <= r) {
    if (n[l] !== n[r]) {
      return false
    }
    l++
    r--
  }
  return true
}

function getPalindromeNumber(length) {
  return Array.from({ length }, (v, i) => i + 1).filter((n) => {
    return isPalindrome(n)
  })
}

getPalindromeNumber(10000)

二、不遍历所有数，直接找出规律，枚举所有对称数

function getPalindromeNumber() {
  let res = []
  for(let i = 1; i < 10; i++) {
    res.push(i)
    res.push(11 * i)
    for(let j = 0; j < 10; j++) {
      res.push(i * 101 + j * 10)
      res.push(i * 1001 + j * 110)
    }
  }
  return res
}

Answer 12

正则表达式，顺便对比一楼的耗时

//正则表达式
console.time('s')
var reg = /^(d)1$|^(d)d2$|(d)(d)43/g
var arr = [];
for(var i = 1; i <= 10000; i++){
    var v = reg.exec(String(i))
    if(v){
        arr.push(Number(v[0]))
    }
}
console.log(arr)
console.timeEnd('s')//s: 3.13916015625 ms

//
console.time('t')
var arr1 = Array(10000).keys();
console.log([...arr1].filter((x) => { 
  return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) 
}))
console.log(arr1)
console.timeEnd('t')//t: 6.968017578125 ms

Answer 13

function symNum(){
    let list = []
    for(var i = 1 ; i <= 10000; i++) {
        let str_i = i.toString()
        if(str_i.length > 1) {
            let sym_len = Math.floor(str_i.length / 2)
            let before_num = str_i.substr(0, sym_len)
            let after_num = str_i.substr(-sym_len)
            if(before_num === after_num.split("").reverse().join("")) list.push(str_i)
        }
    }
    return list
}

这个字符串反转比较应该是用的最多的了吧

Answer 14

// 最小循环次数。
// 里面的关键系数 100 和 10 和 1 都是可以计算出来的，懒得搞直接写死
// 10000 本身不对称，于是最大对称就变成 9999，从中劈开就是 99 次循环生成镜像
// 但镜像长度是复数，因此要对奇数长度做额外处理
var arr = [];
for (let i = 1; i<100; i++) {
  let reversedNum = String(i).split('').reverse().join('')
  arr.push(i + reversedNum);
  if ( i < 10 ) {
    for(let j=0; j<10; j++) {
      arr.push(i + '' + j + reversedNum);
    }
  }
};

/* 结果：
(189) ["11", "101", "111", "121", "131", "141", "151", "161", "171", "181", "191", "22", "202", "212", "222", "232", "242", "252", "262", "272", "282", "292", "33", "303", "313", "323", "333", "343", "353", "363", "373", "383", "393", "44", "404", "414", "424", "434", "444", "454", "464", "474", "484", "494", "55", "505", "515", "525", "535", "545", "555", "565", "575", "585", "595", "66", "606", "616", "626", "636", "646", "656", "666", "676", "686", "696", "77", "707", "717", "727", "737", "747", "757", "767", "777", "787", "797", "88", "808", "818", "828", "838", "848", "858", "868", "878", "888", "898", "99", "909", "919", "929", "939", "949", "959", "969", "979", "989", "999", "1001", …]
*/

Answer 15

function dd(num,list){
while(num>100){
if(num.toString().split('').reverse().join('')==num){
list.push(num)
}
num--
}
return list
}

Answer 16

let res = []
for(var i = 10; i <= 10000; i++) {
res.push(tt(i))
}
console.log('res===',res.filter(i => i))

function tt(str) {
str = str.toString();
var l = str.length;

let right = l - 1;
let left = 0;
while(left <= right) {
    let le = str.charAt(left)
    let re = str.charAt(right)
    if(le === re) {
        left++;
        right--;
    } else {
        break;
    }
}

if(left > right) {
    return str;
} else {
    return ''
}

}

Answer 17

function symmetry(base = 10000) {
        const res = []
        for (let i = 1; i <= base; i++) {
            const curReverse = (i + '').split('').reverse().join('')
            if (i == curReverse && curReverse.length != 1) {
                res.push(i)
            }
        }
        return res.join(',')
    }
    console.log(symmetry());

Answer 18

方法一

[...Array(10000).keys()].filter(x => x.toString().length > 1 && x === Number([...x.toString()].reverse().join('')))

方法二

for(let i=0; i<10000; i++){
	let str = i.toString()
	if(str.length>1 && str == [...str].reverse().join('')){
		console.log(Number(str))
	}
}

Answer 19

笨方法实现
*/
var str = '';
for (var i = 1; i < 10000; i++) {
var digit = Math.floor(i / 10);
if (digit === 0) {
str = str + i + '|';
} else if (digit >= 1 && digit <= 9) {
var ge = i % 10;
var shi = Math.floor(i / 10);
if (ge === shi) {
str = str + i + '|';
}
} else if (digit >= 10 && digit <= 99) {
var ge = i % 10;
var bai = Math.floor(i / 100);
if (ge === bai) {
str = str + i + '|';
}

		} else if (digit >= 100 &&　digit <= 999) {
			var ge = i % 10;
			var shi = Math.floor(i / 10) % 10;
			var bai = Math.floor(i / 100) % 10;
			var qian = Math.floor(i / 1000);
			if (qian === ge && shi === bai) {
				str = str + i + '|';
			}
		}
	}
	console.log(str)

Answer 20

大家的方法都差不多，ES6还是好用。

const isSymmetryNumber = (n) => n > 10 && `${n}` === [...`${n}`].reverse().join('');

const getSymmetryNumber = (num) => Array.from({ length: num }, (n, i) => i + 1).filter(isSymmetryNumber);

Answer 21

读这道题，我首先想到的是，最简单的方法是循环10000次，反转数字前后比较如果相等，则打印。可是循环10000次性能也太差了，怎么才能不循环怎么多次呢？利用对称数

一、循环1000次，笨方法

// 反转数字
function reverse {
	if (n < 0) {
        n = n.toString().split('-')[1]; // 负数提取数字
        n = '-' + [...n].reverse().join('');
        n = +n; // 转数字
    } else {
        n = n.toString(); // 转字符
        n = +[...n].reverse().join(''); // 转为数组 颠倒数组 再合字符 最后转数字
    }
    if (n >= Math.pow(2, 31) - 1 || n <= Math.pow(-2, 31) + 1) { // 判断溢出
        return 0;
    }
    return n;
}
 var arr=[];
for(var i = 0; i<10000; i++) {
   var num = reverse(i); // 反转数字
    if (i===num&&i>9) { // 判断数字和反转后的数字是否相等且不是一位数
      arr.push(i);
    }
}
console.log(arr);

二、利用对称数

以10000 为例，列出所有位数的对称数，比如1位数的 对称数， 2位数的对称数...到5位数， 再判断是否小于10000。
对称数生成 ： 遍历最长位数（如5位）。 每个位置遍历 0 - 9，对称即可。

var result = [];
for(let i=1;i<10;i++){  
    result.push(i*11); // 两位数的对称数
    for(let j=0;j<10;j++){
        result.push(i*101+j*10) //  三位数的对称数
        result.push(i*1001+j*110) // 四位数的对称数，当i和j均为9是值为9999
    }
}
console.log(result);

Answer 22

function getSemmetryNum() {
const semmetryNumList = []
for (let i = 0;i < 3;i++) {
for(let j = 1;j < 10;j++) {
if (i === 0) {
semmetryNumList.push(${j}${j} - 0)
} else {
for(let k = 0;k < 10; k++) {
let tempNum = new Array(i).fill(k).join('')
semmetryNumList.push(${j}${tempNum}${j} - 0)
}
}
}
}
return semmetryNumList
}

两头肯定是类似1**1 2*2之类的，中间的数有可能是0位，1位，2位

这个方法可以得到结果，但不够通用

Answer 23

暴力解法

for (let i = 1; i <= 10000; i++) {
      if (i == Number(i.toString().split('').reverse().join(''))) {
        console.log(i);
      }
    }   

Answer 24

第 81 题：打印出 1 - 10000 之间的所有对称数

例如：121、1331 等

[...Array(10000).keys()].filter((x) => { 
  return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) 
})

大佬，进行筛选的是下标（0 ~ 9999），不是（1 ~ 10000），如果题目要求时（1~9999）就有问题了，

Answer 25

强答：

[...Array(10000).keys()].filter(num => {
  const len = ('' + num).length
  if (len === 1) return true

  return (
    '' + num ===
    ('' + num)
      .split('')
      .reverse()
      .join('')
  )
})

Answer 26

//  the first solution

const symmetry0 = (min, max) => {

    let res = [];

    for(let i = min; i <= max; i ++) {

        if(i.toString().length > 1 && i.toString().split('').reverse().join('') === i.toString()) {

            res.push(i);
        }
    }

    return res;
}
console.log(symmetry0(1, 10000));

//  the second solution
const symmetry = (min, max) => {

    let arr = Array.from({length: max - min + 1}, (item, index) => index += min);

    return arr.filter(item => item.toString().split('').reverse().join('') === item.toString());
    
}
console.log(symmetry(1, 10000));

Answer 27

let result=[]
for(let i=1;i<10;i++){
    result.push(i)
    result.push(i*11)
    for(let j=0;j<10;j++){
        result.push(i*101+j*10)
        result.push(i*1001+j*110)
    }
}

1 - 9 应该不能算对称数吧

Answer 28

function a(n) {
    let go = true
    let i = 1;
    let num;

    while(go){            
        go = false
        num = `${i}${i.toString().split('').reverse().join('')}`

        if(num < n){
            go = true
            console.log(num)
        }

        if(i > 9){
            num = `${i}${i.toString().slice(0, -1).split('').reverse()}`

            if(num < n){
                go = true
                console.log(num)
            }
        }
        i++;
    }
}

a(10000)

Answer 29

for (let i = 0; i < 100000; i++) {
if (''.split.call(i, '').reverse().join('') == i) console.log(i)
}

Answer 30

;[...Array(10000).keys()].filter((v) => {
  return v === Number( (String(v).match(/(^d)(d)?2*1$/) || [])[0] )
})

精简一下
;[...Array(10000).keys()].filter(v => {
  return (String(v).match(/(^d)(d)?2*1$/) || [])[0]
})

再精简一下
;[...Array(1e4).keys()].filter(v => (v+'').match(/(^d)(d)?2*1$/))

Answer 31

Array.from({length: 10000}, (o, i) => i).filter(o => o + '' === (o + '').split('').reverse().join(''))

Answer 32

自己的以及上面各位总结：

// 方法一 笨方法
// 求 1到 10000的所有对称数
function getDuicheng(){
  let res = []
  var helpFunc = (num) => {
    let str = num + ''
    for (let i = 0, j = str.length-1; i++, j--; i < str.length, j >=0) {
      if (str[i] != str[j]){
        return false
      } 
    }
    return true
  }
  for (let i = 0; i <= 10000; i++) {
      if(helpFunc(i)) {
        res.push(i)
      }
  }

  return res
}

// 方法二 
// 对称的话肯定reverse一定相等
function getSymetry(){
return  [...Array(10000).keys()].filter(item => item> 10 && item.toString().split('').reverse().join('')== item.toString())
}


function getSymetry(){
  return [...Array(10000).keys()].filter(item => item >10 && [...item + ''].reverse().join('') == item)
}

// 方法三 求出所有的对称数【构造出来】
// ...

Answer 33

循环10000次 效率在哪？
我的思路：
1、找对称数字 如 AA、ABA、ABBA 因为是10000以内，所以只有这三种情况
2、0不能当做首位

function fn() {
  let res = [];
  for (let i = 0; i < 10; i++) {
    if(i!==0) {
      // AA
      res.push(parseInt(i + '' + i));
      for (let j = 0; j < 10; j++) {
        // ABA
        res.push(parseInt(i + '' + j + i));
        // ABBA
        res.push(parseInt(i + '' + j + j + i));
      }
    }
  }
  return res;
}

欢迎交流

Answer 34

暴力方法
function find() {
let result = [];
for(let i=1;i<10000;i++){
let str = i.toString();
let isToAdd = true;
for(let j in str){
if(str[j] != str[str.length -1 -j]){
isToAdd = false;
}
}
if(isToAdd &&str.length>1){
result.push(i);
}
}
console.log(result);
return result;
}

find();

Answer 35

function f(num) {
return num.toString() === num.toString().split('').reverse().join('')
}

for (var i = 1; i <=10000 ; i++) {
if(f(i)){
console.log(i)
}
}

Answer 36

var result = ''
for (let i = 1; i <= 10000; i++) {
if (i.toString() === Array.from(i.toString()).reverse().join('')) {
result = result + ' ' + i
}
}
console.log(result)

Answer 37

[...Array(10001).keys()].forEach((index) => {
  if (index < 10 && index === parseInt(`${index}`.split('').reverse().join(''))) {
    console.log(index)
  }
})

Answer 38

function test(n) {
  let arr = [];
  for (let i = 10; i < n; i += 1) {
    let str = i.toString();
    if (str === str.split('').reverse().join('')) {
      arr.push(i)
    }
  }
  return arr;
}
test(10000)

Answer 39

来个好看懂的，话说1到9不算对称数吧
const symmetryFilter = () => {
let tempArr = [];
for (let index = 10; index < 10000; index++) {
if (String(index).split("").every((item, key, arr) => item === arr[arr.length - 1 - key]))
tempArr.push(index);
}
}
return tempArr;
};

Answer 40

Array.from({length: 10000}, (_, index) => index + 1).filter(item => item > 9 && item == String(item).split('').reverse().join(''))

Answer 41

function fn(number){
    let len = number < 10 ? 1 : ~~Math.log10(number);
    let arr = Array.from({ length: len });
    arr[0] = [''];
    arr[1] = [];
    for(let i = 0; i <= 9; i ++){
        arr[1].push(i + '');
    }
    let index = 2;
    while(index <= len){
        arr[index] = [];
        for(let i = 0; i <= 9; i ++){
            for(let j of arr[index-2]){
                arr[index].push(`${i}${j}${i}`);
            }
        }
        index ++;
    }
    arr = arr.flat(2).filter(item => {
        return item.length > 1 && item[0] !== '0';
    });

    return arr;
}

Answer 42

我们没有必要遍历所有数，只需遍历1-99就行了，
然后对1-99 的所有数进行对称一次，
分别找到对称后为奇数长度的和对称后为偶数长度的所有数

`
 function getPalind(){
    let res = []
    for (let i = 1; i <= 99; i++) {
        res.push(palind(i, false))
    }
    for (let i = 10; i <= 99; i++) {
        res.push(palind(i, true))
    }
    return res
 }

function palind(str, single){
    str = str + ''
    let res = '', end = str.length -  Number(single) - 1
    for (let i = end; i >= 0; i--) {
        str += str[i]
    }
    return +str
}

`

Answer 43

let result=[]
for(let i=1;i<10;i++){
    result.push(i)
    result.push(i*11)
    for(let j=0;j<10;j++){
        result.push(i*101+j*10)
        result.push(i*1001+j*110)
    }
}

没必要去遍历10000个数

呀，我们是黑白配。我第一眼的想法并不是循环数组而是去构造所有的对称数，大于10000的时候停止

Answer 44

let result=[]
for(let i=1;i<10;i++){
    result.push(i)
    result.push(i*11)
    for(let j=0;j<10;j++){
        result.push(i*101+j*10)
        result.push(i*1001+j*110)
    }
}

没必要去遍历10000个数

Answer 45

咋全是遍历所有数字的答案。

以10000 为例，列出所有位数的对称数，比如1位数的 对称数， 2位数的对称数...到5位数， 再判断是否小于10000。

对称数生成 ： 遍历最长位数（如5位）。 每个位置遍历 0 - 9，对称即可。

Answer 46

返回一个数组，其值为所有符合条件的数字。

// 方法一
[...Array(10000).keys()].filter(i => i.toString().length > 1 && i == i.toString().split('').reverse().join(''))

// 方法二
[...Array(10000).keys()].filter(i => i > 10 && i == [...i + ''].reverse().join(''))

Answer 47

[...Array(10000).keys()].filter((x) => {
    return x > 10 && x.toString() === x.toString().split('').reverse().join('');
})

Answer 48

function printSymmetry(begin: number, end: number) {
  const isSymmetry = (str: string) => str === Array.from(str).reverse().join('');

  Array.from({length:end}, (_, index) => index)
    .filter(v => v>begin && isSymmetry(String(v)))
    .forEach(v => console.log(v));
}

printSymmetry(1, 10000);

Answer 49

function test(num) {
    let str = num + '';
    var l = str.length;
    for (let i = 0; i < Math.ceil(l / 2); i++) {
        if (str.charAt(i) !== str.charAt(l - i - 1)) {
            return false;
        }
        if ((i === (l - i - 1)) || i === l - i - 2) {
            console.log(str);
        }
    }
}

for (let i = 0; i < 10000; i++) {
    if (i > 10 && i % 10 !== 0) {
        test(i);
    }
}

Answer 50

Array.from({length:10000},(v,i) => i+1).slice(9).filter(item => (item+'').split('').reverse().join('') === (item+''));

Answer 51

@zpzxgcr
[...Array(10000).keys()] 取的是 0 - 9999 的数，并不是 1 - 10000 ，如果是 1 - 10000 ：

[...Array(10000).keys()].map(x => x + 1).filter(x => { 
  return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) 
})

假如说现在改为 1 - 9999的话，不加map可以取到188个，加map可以取到189个，9999也应该算是对数，所以应该加map。

Answer 52

[...Array(10000).keys()].filter(function(x){ return x.toString().length>1&&x===Number(x.toString().split('').reverse().join('')) })

Answer 53

//第 81 题：打印出 1 - 10000 之间的所有对称数 例如：121、1331 等 
    class Test{
        constructor() {
            this.arr = [];
        }
        symmetry() {
            for(var i = 1; i<=1000;i++) {    
                let flag = true;            
                i = String(i);
                let integer = parseInt(i.length/2);
                for(let j = 0; j < integer; j++) {
                    if(i[j] != i[i.length - j -1]) {
                        flag = false
                    }
                }
                if(flag) {
                    this.arr.push(Number(i))
                }
            }
            return this.arr;
        }
    }
    let test = new Test();
    console.log(test.symmetry()) //[1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 22, 33, 44, 55, 66, 77, 88, 99, 101, 111, 121, 131, 141, 151, 161, 171, 181, 191, 202, 212, 222, 232, 242, 252, 262, 272, 282, 292, 303, 313, 323, 333, 343, 353, 363, 373, 383, 393, 404, 414, 424, 434, 444,....]

Answer 54

 getSame(num) {
    const res = []
    for (let i = 0; i < num; i++) {
        const str = i.toString()
        const reserveStr = str.split('').reverse().join('')
        if (str === reserveStr) {
         res.push(Number(str))
        }
    }
    return res
  }

Answer 55

for(let i = 1; i <= 10000; i++)
    if(isPalindrome(i))
        console.log(i);
var isPalindrome = function(x) {
    if((x < 0) || (x !== 0 && x % 10 === 0))
      return false;
    let tmp = 0;
    while(x > tmp) {
      tmp = tmp * 10 + x % 10;
      x = Math.floor(x / 10);
    }
    return x === tmp || x === Math.floor(tmp / 10);
};

Answer 56

let result = [];
for (let i = 1; i <= 10000; i++) {
    let reverse = Number(i.toString().split('').reverse().join(''));
    if (i === reverse) {
        result.push(i);
    }
}

Answer 57

var result = [];
for (let i = 1; i <= 10000; i++) {
	let origin = '' + i;
	let reverse = origin.split('').reverse().join('');
	if(origin === reverse) {
		result.push(i);
	}
}