第 99 题：编程算法题

Question

第 99 题：编程算法题

yygmind opened this issue 5 years ago · 174 comments

用 JavaScript 写一个函数，输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。

Answer 1 · 2019-07-04T16:39:12.000Z

function fun(num){
    let num1 = num / 10;
    let num2 = num % 10;
    if(num1<1){
        return num;
    }else{
        num1 = Math.floor(num1)
        return `${num2}${fun(num1)}`
    }
}
var a = fun(12345)
console.log(a)
console.log(typeof a)

Answer 2 · 2019-07-05T01:22:56.000Z

其实这种直接使用JavaScript的API更简单直观。

//  the first solution by recursion

const numToReverseStr = num => {

    if( 'number' !== typeof num ) throw '输入需为int型整数';

    if(!Math.floor(num / 10)) return num.toString();

    return (num % 10).toString() + numToReverseStr( Math.floor(num / 10) );
}

console.log(numToReverseStr(2169362));

//  the second solution not by recursion but JavaScript API

const numToReverseStr_0 = num => {

    return num.toString().split('').reverse().join('');
}

console.log(numToReverseStr_0(2169362));

Answer 3 · 2019-07-05T01:30:15.000Z

`function test(num) {
var str = num + "";
if(str.length > 1) {
var newStr = str.substring(str.length - 1);
var oldStr = str.substring(0, str.length - 1);
return newStr + test(oldStr)
} else {
return num
}

}

var s = test(1234);

console.log(s);`

Answer 4 · 2019-07-05T01:45:11.000Z

function test(num){
	num = typeof num === 'number' ? num.toString() : num
	if(num.length <= 1) return num
	else return num[num.length - 1] + test(num.substring(0, num.length - 1))
}

Answer 5 · 2019-07-05T01:45:48.000Z

function numberReverse(num) {
    const str = num.toString()
    return str.length === 1 ? str : numberReverse(str.substring(1)) + str.substring(0, 1)
}

这样行不,有错望指出

Answer 6 · 2019-07-05T01:52:33.000Z

function reverseNumber (num) {
if ((num / 10 >> 0) === 0) {
return (‘’ + num)
}
return ('' + num % 10 + reverseNumber(num / 10 >> 0) )
}
或者简化成三行代码
function reverseNumber (num) {
return (num / 10 >> 0) === 0 ? ('' + num) : ('' + num % 10 + reverseNumber(num / 10 >> 0) )
}

Answer 7 · 2019-07-05T02:01:33.000Z

function out(value){
  
 if(value.length===0) return '';
  
 value =  Array.isArray(value)?value:value.toString().split('');
 
  return value.pop() + out(value);

}

Answer 8 · 2019-07-05T02:07:44.000Z

function reverseInt(intNumber) {
if (!(intNumber%10)) {
return ''
}
return (intNumber%10).toString() + reverseInt(parseInt(intNumber/10))
}

Answer 9 · 2019-07-05T02:29:47.000Z

`var a = 1234;

function reverse(a){
var a = a.toString();
if(a.length==1){
return a
}else{
a = a.slice(-1)+reverse(a.slice(0,-1));
}
return a
}

reverse(a)`

Answer 10 · 2019-07-05T03:13:32.000Z

思路：先将传入的参数转为string,取该字符串的第二位至末尾作为下一次递归函数的参数，判断当前字符串长度是否大于1，大于1则递归调用，等于1就返回这个字符串

function myReverse(num){ 
  let str = num.toString()
  let num2 = parseInt(str.slice(1))
  
  if(str.length >1){
    return myReverse(num2) + str[0]
  }else {
    return str
  } 
}

console.log(myReverse(1234))

Answer 11 · 2019-07-05T03:17:50.000Z

function reverse(num) {
  const str = `${num}`
  return str ? `${str % 10}${reverse(str.slice(0, str.length - 1))}` : ''
}

Answer 12 · 2019-07-05T04:33:25.000Z

yaonote commented 5 years ago

👍2
👎7

Answer 13 · 2019-07-05T05:54:12.000Z

function renum(num) {
  num = num.toString()
  let rest = num.slice(0, -1),
    last = num.slice(-1);
  return last.length ? last + renum(rest) : ''
}

console.log(renum(12345678)); // 87654321

Answer 14 · 2019-07-05T06:52:33.000Z

如果能传两个参数的话，这个算法将会更好。
尾递归调用。性能上好不少。

function func(v, r = '') {
    v += ''
    if (v.length < 1) return r
    r += v.slice(v.length-1)
    v = v.slice(0, v.length-1)
    return func(v, r)

}
func(1234)
// "4321"

Answer 15 · 2019-07-05T07:27:18.000Z

如果能传两个参数的话，这个算法将会更好。
尾递归调用。性能上好不少。

function func(v, r = '') {
    v += ''
    if (v.length < 1) return r
    r += v.slice(v.length-1)
    v = v.slice(0, v.length-1)
    return func(v, r)

}
func(1234)
// "4321"

科里化一下就好了，在外面封装一层函数只接收参数v

Answer 16 · 2019-07-06T01:37:17.000Z

function fun(num){
    let num1 = num / 10;
    let num2 = num % 10;
    if(num1<1){
        return num;
    }else{
        num1 = Math.floor(num1)
        return `${num2}${fun(num1)}`
    }
}
var a = fun(12345)
console.log(a)
console.log(typeof a)

输入的数字小于 10 的时候返回的是整形

Answer 17 · 2019-07-06T08:46:14.000Z

const convert = num =>
   (num / 10) | 0
     ? String(num % 10) + convert((num / 10) | 0 )
     : String(num)

let res = convert(12345)
console.log(res) // 54321
console.log(typeof res)// string

Answer 18 · 2019-07-07T06:06:17.000Z

const calc = nums => nums.toString().split('').reduce((sum, num) => num + sum);

Answer 19 · 2019-07-07T07:47:53.000Z

贴上两种方法

// es6
const reverse1 = (num) => [...num.toString()].reverse().join('');

// no variable
var intReverseRecursive = function intReverseRecursive(num) {
    if (typeof num === 'number') {
        // add an anchor at the end
        return intReverseRecursive((num + '#').split(''));
    } else {
        // stop recursive
        if (num.indexOf('#') === 0) {
            num.shift();
            return num.join('');
        } else {
            num.splice(num.indexOf('#'), 0, num.shift());
            return intReverseRecursive(num);
        }
    }
};

Answer 20 · 2019-07-08T06:28:34.000Z

function reverseNumber (num) {
if ((num / 10 >> 0) === 0) {
return (‘’ + num)
}
return ('' + num % 10 + reverseNumber(num / 10 >> 0) )
}
或者简化成三行代码
function reverseNumber (num) {
return (num / 10 >> 0) === 0 ? ('' + num) : ('' + num % 10 + reverseNumber(num / 10 >> 0) )
}

你这个不行

Answer 21 · 2019-07-08T08:23:55.000Z

function intToString (int) {
	if (int >= 10) {
		return String(int % 10) + intToString(Math.floor(int / 10))
	}
	return String(int)
}

Answer 22 · 2019-07-08T09:07:52.000Z

function doo (num) {
    const str = `${num}`;
    const temp = str.length > 2 ? doo(str.slice(1)) : str.slice(1);

    return `${temp}${str[0]}`
}

先转成字符串，然后根据长度递归调用

Answer 23 · 2019-07-08T13:25:26.000Z

const reverse = num=>
    num!=0 ? `${num % 10}${reverse(num / 10 >> 0)}` : ''

参考了各位大佬的思路，用%10来取最后一位，用/10来减少位数，用>>0来去除小数点，最后用es6的模板字符串来返回字符串类型的结果

Answer 24 · 2019-07-08T13:42:39.000Z

用 JavaScript 写一个函数，输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。

int型整数也包含负数，发现大多数解法（包括我的）都只考虑传入数值为正数的情况，题干中也没有相关示例，求解 @yygmind

Answer 25 · 2019-07-08T15:37:25.000Z

function fn1(num){
  var str = num.toString();
   let i = 0,newStr="";
   while(i<str.length){
      newStr+=str.slice(str.length-(i+1),str.length-i);
     i++
   }
return newStr;
}
fn1(1234)

Answer 26 · 2019-07-09T03:12:17.000Z

var str = '12345';
function revert(str){
return str.length > 0 ? revert(str.slice(1)) + str[0] : str;
}

Answer 27 · 2019-07-09T04:23:27.000Z

function fun(num){
    let num1 = num / 10;
    let num2 = num % 10;
    if(num1<1){
        return num;
    }else{
        num1 = Math.floor(num1)
        return `${num2}${fun(num1)}`
    }
}
var a = fun(12345)
console.log(a)
console.log(typeof a)

我觉着这个还是得加一些异常case，比如1000，或者负数

/**
 * @case 1234 => '4321'
 * @case 1000 => '1'
 * @case -1000 => '-1'
 * @case -1234 => '-4321'
 *
 * @param {number} number 传入的数值
 */
function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}

const assert = require('assert').strict;

assert.strictEqual(solution(1234), '4321');
assert.strictEqual(solution(1000), '1');
assert.strictEqual(solution(-1234), '-4321');
assert.strictEqual(solution(-1000), '-1');

Answer 28 · 2019-07-09T06:13:23.000Z

function reverseNum(x){
if(x<0){
return '-'+reverseNum(Math.abs(x))
}else if(typeof x === 'number'){
return reverseNum(String(x))
}
return x.length===0?x:reverseNum(x.slice(1)) + x[0]
}
reverseNum(1234560)
reverseNum(-1234560)

Answer 29 · 2019-07-09T07:15:54.000Z

	function main(num){
		let [n, str] = ('' + num / 10).split(".");
                 return n > 0 ? str + main(n) : str;
	}

Answer 30 · 2019-07-09T08:01:02.000Z

题目很简单，增加一些异常判断好了

const reverse = (num) => {
  let type = num || undefined;
  if(Object.prototype.toString.call(type) !== '[object Number]') {
    return;
  }
  if(num < 0) {
    return '-' + reverse(num * -1)
  }
  let s = num + '';
  if(s.length > 1){
    let temp = s.substring(0,1);
    num = s.substring(1,s.length) - '';
    return reverse(num) + temp;
  }else {
    return num + '';
  }
}

Answer 31 · 2019-07-09T08:36:42.000Z

function reverse (num) {
	
  num = typeof num  === 'number' ? num.toString() : num;
  
  if (num.length <= 1) return num;
  
  return `${num[num.length-1]}${reverse(num.slice(0, -1))}`

}

Answer 32 · 2019-07-09T09:42:34.000Z

var reverse = function(n) {
n = n + '';
return Array.from(n).reduce((str, a) => {
return a + str;
})
}

Answer 33 · 2019-07-09T11:56:15.000Z

恕我直言

function print(n) {
  if (!n) return '0';
  let num2Str = n => {
    if (!n) return '';
    return `${n % 10}` + num2Str(~~(n / 10));
  }
  return num2Str(n);
}

Answer 34 · 2019-07-09T16:33:18.000Z

INT范围内不会有问题😊

function revNum(num){
  if(num < 10){
    return '' + num
  } else return '' + num%10 + revNum(num/10>>0)
}

Answer 35 · 2019-07-09T17:33:14.000Z

function reverseStr(num) {
if (num < 10) {
return num;
}

let res = (num % 10) + "" + reverseStr(Math.floor(num / 10));
return res;
}

Answer 36 · 2019-07-10T05:47:58.000Z

function foo(num){
if(typeof(num) == 'number'){
var a = num.toString();
var b = [];
for (var i = a.length - 1; i >= 0; i--){
b.push(a[i]);
}
return foo(b);
}
return num.join('');
}

Answer 37 · 2019-07-10T06:21:46.000Z

function sortNum2String(num){
let arr = (num+'').split('');
arr.sort((a,b)=>{
return b-a
})
return arr.join('')
}

Answer 38 · 2019-07-10T08:06:51.000Z

function sortNum2String(num){
let arr = (num+'').split('');
arr.sort((a,b)=>{
return b-a
})
return arr.join('')
}

???

Answer 39 · 2019-07-10T08:32:46.000Z

// 使用递归，只使用一个参数（利用柯里化）
function reverse(index) {
    return function (num) {
        num=num+'';
        if(index>=num.length/2||(index>=num.length/2-1&&num.length%2===1))return num;
        return reverse(index+1)(num.slice(0,index)+num[num.length-1-index]+num.slice(index+1,-index-1)+num[index]+(index!==0?num.slice(-index):''))
    }
}
reverse(0)(123456);

Answer 40 · 2019-07-10T09:07:37.000Z

function bili(int){
if(int.toString().length <= 1){ return int }
return (int/10).toString().slice(-1) + bili(parseInt(int/10))
}

Answer 41 · 2019-07-10T09:50:04.000Z

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}

我觉得这样才是正解，不考虑负数和倒过来是0就像耍流氓

Answer 42 · 2019-07-10T10:07:24.000Z

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}

测试了下，跟我的bug一样。1001的中间0都被Number化时去除了

Answer 43 · 2019-07-10T10:23:34.000Z

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}

测试了下，跟我的bug一样。1001的中间0都被Number化时去除了

单参就比较难了，双参的话就比较好写，用一个参数带初始number的位数信息，在去掉0的时候判断一下就行

Answer 44 · 2019-07-10T10:26:09.000Z

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}
测试了下，跟我的bug一样。1001的中间0都被Number化时去除了
单参就比较难了，双参的话就比较好写，用一个参数带初始number的位数信息，在去掉0的时候判断一下就行

我觉得这才是这道题的难点，要不然不考虑这些真的是在耍流氓。。

Answer 45 · 2019-07-10T10:32:12.000Z

function reverse(num){
  num = num + ''
  var len = num.length
  if(len == 1) return num
  return num[len - 1] + reverse(num.slice(0,-1))
}

console.log(reverse(1234))

Answer 46 · 2019-07-10T11:06:49.000Z

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

Answer 47 · 2019-07-10T11:49:42.000Z

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  if (number < 10) {
    return `${number}`;
  }

  return `${number % 10 || ''}${solution(~~(number / 10))}`;
}
测试了下，跟我的bug一样。1001的中间0都被Number化时去除了
单参就比较难了，双参的话就比较好写，用一个参数带初始number的位数信息，在去掉0的时候判断一下就行
我觉得这才是这道题的难点，要不然不考虑这些真的是在耍流氓。。

用小数位来标示是否舍0，写的很复杂，暂时符合条件了。。

function solution(number) {
  if (number < 0) {
    return `-${solution(Math.abs(number))}`;
  }

  let integerPart = Math.floor(number);
  let decimal = `${number}`.split('.')[1];

  let numberSize = `${integerPart}`.length;

  if (number < 10) {
    return `${integerPart}`;
  }

  if (integerPart % 10 === 0) {
    let initialNumberSize = decimal || 0;
    // initialNumberSize === 0 => 初始number以0为结尾
    // +initialNumberSize === numberSize => 以2个以上0为结尾
    if (initialNumberSize === 0 || +initialNumberSize === numberSize) {
      return solution(parseFloat(`${~~(integerPart / 10)}.${numberSize - 1}`));
    }
    return `0${solution(
      parseFloat(`${~~(integerPart / 10)}.${initialNumberSize}`)
    )}`;
  }

  // 以小数标示从首位到最后一位非0位置的个数
  return `${integerPart % 10}${solution(
    parseFloat(`${~~(integerPart / 10)}.${decimal || numberSize}`)
  )}`;
}

const assert = require('assert').strict;

assert.strictEqual(solution(1234), '4321');
assert.strictEqual(solution(1000), '1');
assert.strictEqual(solution(-1234), '-4321');
assert.strictEqual(solution(-1000), '-1');
assert.strictEqual(solution(1011), '1101');
assert.strictEqual(solution(-1001), '-1001');

Answer 48 · 2019-07-11T02:41:07.000Z

function transformwrap(n){
  var sum=""
  function transform(n){
    if(n<=0){
      return sum
    }
    var left=n%10
    sum+=left
    n=(n-left)/10
    transform(n)
  }
  transform(n)
  return sum
}

Answer 49 · 2019-07-11T08:40:05.000Z

function reverse(num) {
  if (num < 0) {
    return `-${reverse(Math.abs(num))}`
  }
  if (num < 10) {
    return num;
  }
  return `${num % 10}${reverse(Math.floor(num / 10))}`
}

test:
reverse(123349495)
"594943321"
reverse(-123455)
"-554321"
reverse(-1234000055)
"-5500004321"
reverse(-12340000500005)
"-50000500004321"

Answer 50 · 2019-07-13T14:48:00.000Z

function itoa (num) { return (num % 10 === 0 ? "" : num % 10) + (num >= 10 ? itoa(parseInt(num / 10)) : ""); }

Answer 51 · 2019-07-17T07:11:08.000Z

`function convert(num){
if(!num){
return '';
}
return num % 10 + convert((num / 10) | 0);
}

var int = 12345;
console.log(typeof convert(int));`

Answer 52 · 2019-07-18T04:07:16.000Z

let a = 2341
function b(num) {
    return num.toString().split('').sort((x,y) => {return y - x}).join('')
}
let str = b(a)
console.log(str)

Answer 53 · 2019-07-18T04:14:54.000Z

function rotate(nums) {
let str = ''
let current = nums%10
str = str+current
if (Math.floor(nums/10) > 0 ) {
return str+ rotate(Math.floor(nums/10))
} else {
return str
}

}

Answer 54 · 2019-07-18T10:21:28.000Z

function f(num) {
    let a = num%10
    if(num<10) return num+''
    return a + '' + f((num-a)/10)
}

Answer 55 · 2019-07-22T03:40:46.000Z

function reverse(n) {
    return n<0?'-'+reverse(Math.abs(n)):((n<10)?String(n): (n%10+''+reverse(Math.floor(n/10))));
}

Answer 56 · 2019-07-22T07:02:07.000Z

function test(num){
num=num.toString();
if(num.length==1){
return num
}else{
return num.substring(num.length-1)+test(num.substring(0,num.length-1))
}
}

Answer 57 · 2019-07-23T03:19:11.000Z

function print(num) {
let yu = num%10;
let shang = (num-yu)/10;
return shang ? ${yu}${print2(shang)} : yu;
}

Answer 58 · 2019-07-24T07:48:53.000Z

function sub(str){
    let out
     if(str.length>1){
       out=sub(str.substring(1))+str[0]
     }else{
       return str
     }
     return out
  }

Answer 59 · 2019-07-25T11:39:49.000Z

function f2(number){
	const str = number.toString();
	if(number < 10){
		return number.toString()
	}else {
		return str.slice(str.length-1, str.length)+ f2(str.slice(0, str.length-1));
	}
}

Answer 60 · 2019-07-26T03:03:09.000Z

考虑转化规则为：
1000逆序结果为'1' 而不是'0001'
-1000逆序结果为'-1' 而不是'-0001'

function calc(num) {
  if (num < 0) {
    return `-${+calc(Math.abs(num) + '')}`;
  }
  if (num < 10) {
    return num;
  }
  let n = Math.floor(num / 10);
  let m = num % 10;
  let ans = `${m}${calc(n + '')}`;
  return (typeof num === 'string') ? ans : `${+ans}`;
}

Answer 61 · 2019-07-27T06:36:46.000Z

function helper(number) {
  if (number === 0) return "";
  return String(number % 10) + helper((number / 10) >> 0);
}

function reverseNumber(number) {
  if (number === 0) return "0";
  if (number < 0) return String(`-${helper(-1 * number)}`);
  return helper(number);
}

如果大家对算法感兴趣可以关注我的leetcode题解

Answer 62 · 2019-07-31T00:24:38.000Z

用 JavaScript 写一个函数，输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。

function reverse(data) {
        let arr = [];
        let val = data % 10;
        arr.push(val);
        if (val) {
            return arr.concat(reverse(parseInt(data / 10))).join("");
        };
    }

Answer 63 · 2019-08-07T09:20:47.000Z

这样算不算玩文字游戏(😁

const convert = (number) => {
  let num = number
  while (num % 10 === 0) {
      num = num / 10
  }
  const _reverse = (str) => {
      return str.length <= 0 ? '' :`${_reverse(str.slice(1))}${str.slice(0,1)}`
  }
  return _reverse(`${num}`) 
}
convert(1234)
convert(1230)

Answer 64 · 2019-08-07T15:49:57.000Z

完了，难到我了，不能用爱发电了

Answer 65 · 2019-08-10T12:32:24.000Z

function reverse(num) {
  const str = num.toString();
  if(str.length === 1) return str; // 如果切分成一个数就返回
  const lastNum = str.slice(str.length -1); //  获取最后一个数
  return lastNum + reverse(str.slice(0, str.length -1));   // 递归相加
}

Answer 66 · 2019-08-13T08:55:18.000Z

入参数判断一下类型

const reverseNum = (num) => {
  //let str_arr = num.toString().split('')
  if (typeof num === 'number') {
    return reverseNum(num.toString().split('').reverse())
  } else if (Array.isArray(num)){
    return num.join('')
  } else {
    throw '输入需为int型整数'
  }
}

Answer 67 · 2019-08-13T10:07:43.000Z

function reverse(nums){
	const str = nums.toString()
	if(str.length===0){
		return str
	}
	return str.slice(-1) + reverse(str.slice(0,-1))
}
console.log(reverse(123456789))

Answer 68 · 2019-08-14T13:13:23.000Z

function reverse(num) {
    if(num.toString().length === 1){
        return num
    }
    return reverse(num.toString().slice(1)) + num.toString()[0];
}

Answer 69 · 2019-08-15T09:23:32.000Z

yangxinSamsara commented 5 years ago

Answer 70 · 2019-08-15T10:41:54.000Z

function convert(number) {
	let s = number % 10
	let num = parseInt(number / 10)
	if(num <= 0) {
		return s
	}
	return `${s}${convert(num)}`
}
convert(1234)

Answer 71 · 2019-08-23T08:46:03.000Z

function convert(str) {
    str = (str).toString()
    if (str)
        return convert(str.substr(1)) + str.substr(0, 1)
    return ''
}
convert(12345)

Answer 72 · 2019-08-29T12:45:48.000Z

const numToReverseStr = (num) => {
  let result = num % 10;
  if (num === 0) {
    return ''
  }
  const newNum = Number(String(num).slice(0 ,-1));
  return String(result) + numToReverseStr(newNum);
}

Answer 73 · 2019-08-30T08:16:19.000Z

function getRerviseString(num) {
    if (num < 10) return num;
    return (num % 10) + '' + getRerviseString(((num - (num % 10)) / 10))

}

console.log(getRerviseString(4576567567))

考递归相关的知识

Answer 74 · 2019-09-02T07:34:49.000Z

function reverse(num) {
  return String(num).split('').reverse().join('');
}

function reverse2(num) {
  if (num < 10) {
    return String(num);
  } else {
    return String(num % 10) + reverse2(Math.floor(num / 10));
  }
}

function reverse3(num) {
  let result = '';
  while(num) {
    result += String(num % 10);
    num = Math.floor(num / 10);
  }
  return result;
}

console.log(reverse(1234567));
console.log(reverse2(1234567));
console.log(reverse3(1234567));

Answer 75 · 2019-09-02T07:53:29.000Z

function fun(num){
    let num1 = num / 10;
    let num2 = num % 10;
    if(num1<1){
        return num;
    }else{
        num1 = Math.floor(num1)
        return `${num2}${fun(num1)}`
    }
}
var a = fun(12345)
console.log(a)
console.log(typeof a)

Answer 76 · 2019-09-11T06:34:21.000Z

!function(num){
    let span='';
    while(Math.floor(num)>=1){
        const temp = num%10;
        num/=10;
        span+=temp|0;
    }
    console.log(span)//4321
}(num=1234)

Answer 77 · 2019-09-20T10:01:05.000Z

/**
 * 用 JavaScript 写一个函数，输入 int 型，返回整数逆序后的字符串。如：输入整型 1234，返回字符串“4321”。要求必须使用递归函数调用，不能用全局变量，输入函数必须只有一个参数传入，必须返回字符串。
 * @param {Number} num
 * @returns {String}
 */
function reverse(num) {
  let arr = Number.isInteger(num) ? ['', num.toString()] : num;
  if (arr[1].length > 0) {
    let copyArr = [...arr[1]];
    return reverse([(arr[0] += copyArr.pop()), copyArr.join('')]);
  }
  return arr[0];
}
console.log(reverse(1234));

function reverse(num) {
  if (num) return reverse(num.toString().substring(1)) + num.toString().substring(0, 1);
  return '';
}
console.log(reverse(1234));

Answer 78 · 2019-10-14T09:03:06.000Z

function ints(num) {
var str = String(num),i=str.length;
if(i>1) {
var newNum = Number(str.substring(0,i-1));
var d = str.substring(i-1);
return d+ints(newNum);
}else {
return num;
}
}
ints(1234);

Answer 79 · 2019-10-19T14:46:20.000Z

// 当前仅考虑非负整数
function intReverse(num) {
	if(!/^[1-9]\d*|0$/.test(num)) {throw new Error('请传入非负整数')};

	strNumber = num + '';
	if(strNumber.length === 1) {return strNumber};

	let tail = strNumber.slice(-1);
	let rest = parseInt(strNumber.slice(0,-1));
	return  tail + intReverse(rest)
}

Answer 80 · 2019-11-04T12:36:52.000Z

function test(num){
	num = typeof num === 'number' ? num.toString() : num
	if(num.length <= 1) return num
	else return num[num.length - 1] + test(num.substring(0, num.length - 1))
}

test的输入必须为整数，输出必须为字符串

Answer 81 · 2019-11-06T14:12:53.000Z

function intToStringReverse(num){
  if(num <= 0) return ""
  return "" + num % 10 + intToStringReverse(parseInt(num / 10))
}

Answer 82 · 2019-11-11T16:40:16.000Z

如果能传两个参数的话，这个算法将会更好。
尾递归调用。性能上好不少。

function func(v, r = '') {
    v += ''
    if (v.length < 1) return r
    r += v.slice(v.length-1)
    v = v.slice(0, v.length-1)
    return func(v, r)

}
func(1234)
// "4321"

function func(v) {
    var r = [...arguments][1] || ''
    v += ''
    if (v.length < 1) return r * 1
    r += v.slice(v.length-1)
    v = v.slice(0, v.length-1)
    return func(v, r)
}

在您代码上加了俩点：1、省去第二个参数，2、输出数字格式

Answer 83 · 2019-11-14T01:41:16.000Z

function reverse(num) {
const input = new String(num)

if (input.length <= 1) return input;

return input[input.length - 1] + reverse(input.slice(1, input.length - 1)) + input[0];
}

Answer 84 · 2019-11-21T02:13:40.000Z

function bilibili(num) {
if (num.toString().length < 2) {
return num.toString()
}
let a = Math.floor(num / 10)
let b = num % 10
return ${b}${bilibili(a)}
}

Answer 85 · 2019-11-28T01:06:27.000Z

function fun(num){
    let num1 = num / 10;
    let num2 = num % 10;
    if(num1<1){
        return num;
    }else{
        num1 = Math.floor(num1)
        return `${num2}${fun(num1)}`
    }
}
var a = fun(12345)
console.log(a)
console.log(typeof a)

思路也太巧妙了

Answer 86 · 2019-12-02T11:24:54.000Z

function reverse(num) {
    if (!num) return '';
    return '' + num % 10 + reverse(parseInt(num / 10));
}

Answer 87 · 2019-12-17T10:07:59.000Z

const num = 1234;
function func(number) {
    return number > 9 ? String(number % 10) + func(Math.floor(number / 10)) : String(number);
}
console.log(func(1234), typeof func(1234))

Answer 88 · 2019-12-26T02:37:08.000Z

`
function reverseInt(int) {
if(!Number.isInteger(int) || arguments.length !== 1) {
return new Error('only one params was required and must be a interger number')
}
int += ''
const cut = int.slice(-1)
if(int.length == 1) {
return int
} else {
int = int.substr(0,int.length - 1)
return cut + reverseInt(int)
}

}
console.log(typeof reverseInt(23645583)) // 'string'
console.log(reverseInt(23645583)) // 38556432
console.log(reverseInt(23645583.123)) // 报错
console.log(reverseInt(123,23645583)) // 报错
`

Answer 89 · 2020-01-01T14:32:11.000Z

function formatNumber(num) {
  let str = num.toString();
  const length = str.length;
  let value = '';
  if (length > 1) {    
    let subStr = str.substr(0, length - 1)
    let next = parseInt(subStr)
    value = str.substr(length - 1, 1)  + formatNumber(next)             
  } else {
    value = str.substr(length - 1, 1) 
  }
  return value
}

let value = formatNumber(2020)
console.log(value)
// "0202"

Answer 90 · 2020-01-16T08:57:42.000Z



function reserve(num) {
    let str = num.toString();
    let len = str.length
    let first = str[len - 1]
    if (str.length > 1) {
        return first + reserve(str.substring(0, len-1))
    } else {
        return first
    }
}
console.log(reserve(423456777));
console.log(typeof(reserve(423456777)));

Answer 91 · 2020-01-17T02:28:55.000Z

function reverseInt(num) {
return num < 10
? num
: ${num % 10}${reverseInt(parseInt(num / 10))}
}
这样它不香么

Answer 92 · 2020-01-17T02:36:33.000Z

香但是差一点。必须返回字符串。reverseInt(1) number function reverseInt(num) { if(num < 10) return num+''; return `${num % 10}${reverseInt(parseInt(num / 10))}` }

…

------------------ 原始邮件 ------------------ 发件人: "fasign"<notifications@github.com>; 发送时间: 2020年1月17日(星期五) 上午10:29 收件人: "Advanced-Frontend/Daily-Interview-Question"<Daily-Interview-Question@noreply.github.com>; 抄送: "杭州电子科技大学-胡大昌"<707555326@qq.com>; "Comment"<comment@noreply.github.com>; 主题: Re: [Advanced-Frontend/Daily-Interview-Question] 第 99 题：编程算法题 (#153) function reverseInt(num) { if(num < 10) return num return ${num % 10}${reverseInt(parseInt(num / 10))} } 这样它不香么 — You are receiving this because you commented. Reply to this email directly, view it on GitHub, or unsubscribe.

Answer 93 · 2020-01-20T06:47:39.000Z

function r (n) {
    if (n.length <= 1) {
        return n
    }
    const first = n[0]
    const rest = n.slice(1)
    return r(rest) + first
}

Answer 94 · 2020-02-05T07:08:26.000Z

function reverse(num) {
    if (num===0) return '';
    return parseInt(num%10) + '' + reverse(parseInt(num/10))
}

Answer 95 · 2020-02-09T02:45:11.000Z

function outerFn(num){
var count=0
var str=num+""
var l=str.length
var result=""
function innerFn(){
if(count==l) return console.log(result)
result+=str.slice(-count-1)[0]
count++
innerFn()
}
return innerFn()
}
outerFn(31234)//43213

Answer 96 · 2020-02-12T10:58:04.000Z

负数+尾递归

function reverseNumber(number) {
  const flag = number < 0 ? -1 : 1;
  number = Math.abs(number);

  const pre = [...arguments][1] || '';

  if (number < 10) {
    return pre + String(number);
  }
  return reverseNumber(Math.floor(number / 10), pre + flag * (number % 10));
}

Answer 97 · 2020-02-17T07:33:00.000Z

代码如下，支持负数

function reverseNum(num) {
  if(num < 0) return '-' + reverseNum(Math.abs(num));
  let str = num.toString();
  return str.length === 1 ? str : str.slice(-1) + reverseNum(str.slice(0,-1));
}

Answer 98 · 2020-02-22T07:00:14.000Z

function reverse(num, i = 0, acc = '') {
    if (typeof num == 'number') {
        num += '';
        i = num.length - 1;
    }

    if (i < 0) {
        return acc;
    }

    acc += num[i];

    return reverse(num.substring(0, i--), i, acc);
}
reverse(1234); // 4321
// 符合ES6尾调用优化规则

Answer 99 · 2020-02-26T12:33:40.000Z

function reverse(num) {
   if(num > 10) {
      let a = num / 10
      let b = num % 10
      return b + reverse((num - b) / 10)
   }else if(num < 0) {
      return reverse(-num) + '-'
   }else {
      return num + ''
   }
}

Answer 100 · 2020-03-10T03:50:08.000Z

function reverseNum(num){
  if(num<10){
    return String(num)
  }
  let min1 = Math.floor(num/10);
  let min2 = num%10;
  if(min1<10){
    return `${min2}${min1}`;
  }
  return `${min2}${reverseNum(min1)}`
}