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

zpzxgcr · 2019-05-24T00:53:02Z

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

例如：121、1331 等

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

SilvaYH · 2019-05-24T01:30:03Z

是下标

…

------------------ 原始邮件 ------------------ 发件人: "robbie"<notifications@github.com>; 发送时间: 2019年5月24日(星期五) 上午9:17 收件人: "Advanced-Frontend/Daily-Interview-Question"<Daily-Interview-Question@noreply.github.com>; 抄送: "Subscribed"<subscribed@noreply.github.com>; 主题: Re: [Advanced-Frontend/Daily-Interview-Question] 第 81 题：打印出 1 - 10000 之间的所有对称数例如：121、1331 等 (#131) 第 81 题：打印出 1 - 10000 之间的所有对称数例如：121、1331 等 [...Array(10000).keys()].filter((x) => { return x.toString().length > 1 && x === Number(x.toString().split('').reverse().join('')) }) 为什么控制台会有一个[0,99]，一个[100,188]两个数组？ — You are receiving this because you are subscribed to this thread. Reply to this email directly, view it on GitHub, or mute the thread.

sgzhm4444 · 2019-05-24T01:31:03Z

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

ning-chen · 2019-05-24T01:39:14Z

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

LiJiahaoCoder · 2019-05-24T01:54:03Z

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

xiaofengqqcom123 · 2019-05-24T02:02:31Z


 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
  }

GuoYuFu123 · 2019-05-24T02:49:42Z

//第 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,....]

jerrychane · 2019-05-24T03:13:25Z

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

fxss5201 · 2019-05-24T03:20:58Z

@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。

Robbie-Han · 2019-05-24T04:41:58Z

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

poozhu · 2019-05-24T04:50:09Z

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

benzhemin · 2019-05-24T05:58:40Z

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

Tsionhe · 2019-05-24T07:21:11Z

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

Nolaaaaa · 2019-05-24T07:43:16Z

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

// 方法一
[...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(''))

mydaoyuan · 2019-05-24T09:47:45Z

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

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

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

liangmuren · 2019-05-24T13:03:00Z

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个数

wwwjun · 2019-05-24T14:14:17Z

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的时候停止

lerte · 2019-05-25T05:52:54Z

方法一

[...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))
	}
}

liuchao2019 · 2019-05-26T03:25:54Z

笨方法实现
*/
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)

pengcc · 2019-05-26T08:40:37Z

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

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

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

luohong123 · 2019-05-27T08:55:13Z

读这道题，我首先想到的是，最简单的方法是循环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);

chouzhenyi · 2019-05-27T11:48:28Z

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

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

sohoorc · 2019-05-28T06:45:00Z

暴力解法

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

ckjie · 2019-06-24T13:10:49Z

第 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）就有问题了，

chen86860 · 2019-06-26T08:36:06Z

强答：

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

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

dorseysen · 2019-06-27T08:41:56Z

//  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));

CasoMemory · 2019-07-03T11:37:12Z

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 应该不能算对称数吧

pndllxzzy · 2019-07-09T11:24:11Z

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)

chphaeton · 2019-07-10T10:12:53Z

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

vizoy · 2019-07-10T14:44:45Z

;[...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$/))

jackYouth · 2019-07-11T07:11:59Z

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

lanOrage · 2019-12-02T14:09:37Z

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

weely · 2019-12-17T03:40:53Z

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

zjiang121143210 · 2020-01-10T07:11:44Z

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)

zaixia-damao · 2020-04-08T03:13:47Z

来个好看懂的，话说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;
};

zh-lc · 2020-05-09T08:51:11Z

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

hycript · 2020-05-30T11:43:13Z

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

zhengybo · 2020-06-18T15:29:56Z

我们没有必要遍历所有数，只需遍历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
}

`

523451928 · 2020-07-10T09:36:46Z

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

littlepurple · 2020-07-23T06:36:17Z

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

fengfan0409 · 2020-08-24T08:27:27Z

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

promotion-xu · 2020-08-31T08:27:30Z

// 打印出 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());

chaserstrong · 2020-09-11T09:08:22Z

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

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

q774221810 · 2020-10-24T13:55:57Z

                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)
回溯

blank1u · 2020-12-09T10:02:25Z

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

JeremyChenn · 2021-01-08T07:33:33Z

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

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)

jiangmingwen · 2021-02-03T08:28:21Z

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

lianglei777 · 2021-03-04T13:51:32Z

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

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

MrLeihe · 2021-05-09T15:28:45Z

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

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
}

zhuyuzhu · 2021-05-16T06:47:37Z

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

//正则表达式
console.time('s')
var reg = /^(\d)\1$|^(\d)\d\2$|(\d)(\d)\4\3/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

p992202933 · 2021-06-28T06:54:04Z

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
}

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

3fatty · 2021-06-30T08:55:19Z

// 最小循环次数。
// 里面的关键系数 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", …]
*/

haiyangzhishengs · 2021-07-07T07:38:56Z

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

tianfengbiao · 2021-07-30T08:27:05Z

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

}

SnailOwO · 2021-12-22T09:27:04Z

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

xuxin666666 · 2022-10-26T14:29:53Z

普适解法，非暴力，求出1到任意数之间的对称数

function symmetry(max) {
    let arr = []

    out: for (let i = 1, len = Math.ceil(max.toString().length / 2); i <= len; i++) {
        let start = Math.pow(10, i - 1)
        // 奇数构造
        for (let j = start; j < start * 10; j++) {
            let s = j.toString(), // 左半边
                reve = s.split('').reverse().slice(1).join(''), // 右半边
                sy = parseInt(s + reve) // 合起来
            if (sy > max) break out

            arr.push(sy)
        }
        // 偶数构造
        for (let j = start; j < start * 10; j++) {
            let s = j.toString(), reve = s.split('').reverse().join(''), sy = parseInt(s + reve)
            if (sy > max) break out

            arr.push(sy)
        }
    }

    return arr
}

benzhemin · 2023-02-25T01:45:47Z

const isSymmetry = num =>
    num > 10 && `${num}` === [...`${num}`].reverse().join('')


const printSymmetry = num => {
    const symmetryList = []
    Array.from({length: num }).forEach((_, index) => {
        isSymmetry(index) && symmetryList.push(index);
    });

    console.log(symmetryList.join(','));
}

printSymmetry(10000);

chenzhengduan · 2024-05-30T08:51:42Z

function isPalindrome(num) {
const str = num.toString();
const reversedStr = str.split('').reverse().join('');
return str === reversedStr;
}

function printPalindromes(range) {
for (let i = 1; i <= range; i++) {
if (isPalindrome(i)) {
console.log(i);
}
}
}

// 打印1到10000之间的所有对称数
printPalindromes(10000);

yuewanxinghui · 2024-10-21T08:43:02Z

const fn = (num) => {
const res = []
let i = 1
const temp = Math.ceil(num.toString().split('').length / 2)
let maxNum = Number(1${[...Array(temp).keys()].map(i => '0').join('')})
const reverseFn = (n) => n.toString().split('').reverse().join('')
const tempArr = [...Array(10).keys()]
while (i < maxNum) {
if (i < 10) {
res.push(Number(${i}${i}))
} else {
const reNum = Number(${i}${reverseFn(i)})
if (reNum < num) {
res.push(reNum)
}
}
for(let j = 0; j < 10; j++) {
const reNum = Number(${i}${j}${reverseFn(i)})
if (reNum < num) {
res.push(reNum)
}
}
i++
}
return res
}

yygmind added the 编程题 label Dec 16, 2019

yygmind changed the title ~~第 81 题：打印出 1 - 10000 之间的所有对称数例如：121、1331 等~~ 第 81 题：打印出 1 - 10000 之间的所有对称数例如 121、1331 等 Dec 31, 2019

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

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

Comments

zpzxgcr commented May 24, 2019 • edited Loading

SilvaYH commented May 24, 2019 via email

sgzhm4444 commented May 24, 2019

ning-chen commented May 24, 2019

LiJiahaoCoder commented May 24, 2019

xiaofengqqcom123 commented May 24, 2019 • edited Loading

GuoYuFu123 commented May 24, 2019 • edited Loading

jerrychane commented May 24, 2019

fxss5201 commented May 24, 2019

Robbie-Han commented May 24, 2019

poozhu commented May 24, 2019

benzhemin commented May 24, 2019

Tsionhe commented May 24, 2019

Nolaaaaa commented May 24, 2019 • edited Loading

mydaoyuan commented May 24, 2019 • edited Loading

liangmuren commented May 24, 2019

wwwjun commented May 24, 2019

lerte commented May 25, 2019

方法一

方法二

liuchao2019 commented May 26, 2019

pengcc commented May 26, 2019

luohong123 commented May 27, 2019 • edited Loading

一、循环1000次，笨方法

二、利用对称数

chouzhenyi commented May 27, 2019 • edited Loading

sohoorc commented May 28, 2019

暴力解法

ckjie commented Jun 24, 2019

chen86860 commented Jun 26, 2019

dorseysen commented Jun 27, 2019 • edited Loading

CasoMemory commented Jul 3, 2019

pndllxzzy commented Jul 9, 2019 • edited Loading

chphaeton commented Jul 10, 2019

vizoy commented Jul 10, 2019

jackYouth commented Jul 11, 2019

lanOrage commented Dec 2, 2019

weely commented Dec 17, 2019

zjiang121143210 commented Jan 10, 2020

zaixia-damao commented Apr 8, 2020

zh-lc commented May 9, 2020

hycript commented May 30, 2020 • edited Loading

zhengybo commented Jun 18, 2020 • edited Loading

523451928 commented Jul 10, 2020

littlepurple commented Jul 23, 2020 • edited Loading

fengfan0409 commented Aug 24, 2020

promotion-xu commented Aug 31, 2020

chaserstrong commented Sep 11, 2020 • edited Loading

q774221810 commented Oct 24, 2020 • edited Loading

blank1u commented Dec 9, 2020

JeremyChenn commented Jan 8, 2021 • edited Loading

jiangmingwen commented Feb 3, 2021 • edited Loading

lianglei777 commented Mar 4, 2021 • edited Loading

MrLeihe commented May 9, 2021

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

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

zhuyuzhu commented May 16, 2021

p992202933 commented Jun 28, 2021

3fatty commented Jun 30, 2021 • edited Loading

haiyangzhishengs commented Jul 7, 2021

tianfengbiao commented Jul 30, 2021

SnailOwO commented Dec 22, 2021

xuxin666666 commented Oct 26, 2022

benzhemin commented Feb 25, 2023

chenzhengduan commented May 30, 2024

yuewanxinghui commented Oct 21, 2024

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

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

zpzxgcr commented May 24, 2019 •

edited

Loading

xiaofengqqcom123 commented May 24, 2019 •

edited

Loading

GuoYuFu123 commented May 24, 2019 •

edited

Loading

Nolaaaaa commented May 24, 2019 •

edited

Loading

mydaoyuan commented May 24, 2019 •

edited

Loading

luohong123 commented May 27, 2019 •

edited

Loading

chouzhenyi commented May 27, 2019 •

edited

Loading

dorseysen commented Jun 27, 2019 •

edited

Loading

pndllxzzy commented Jul 9, 2019 •

edited

Loading

hycript commented May 30, 2020 •

edited

Loading

zhengybo commented Jun 18, 2020 •

edited

Loading

littlepurple commented Jul 23, 2020 •

edited

Loading

chaserstrong commented Sep 11, 2020 •

edited

Loading

q774221810 commented Oct 24, 2020 •

edited

Loading

JeremyChenn commented Jan 8, 2021 •

edited

Loading

jiangmingwen commented Feb 3, 2021 •

edited

Loading

lianglei777 commented Mar 4, 2021 •

edited

Loading

3fatty commented Jun 30, 2021 •

edited

Loading