第 99 题：编程算法题

Question

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

Answer 1

如此简单!

function fn(val) { 
  return !val ? '' : val % 10 + fn(Math.floor(val / 10));
}

Answer 2

function a(n){

let _len = String(n).length
let str = String(n)
if(_len==1){
return str[0];
}
if(_len==2){
return str[1]+str[0];
}
return (str[_len-1] + a(Number(str.slice(0,_len-1))))
}

Answer 3

function reverse(num){

let datas = num.toString().split('');
let length = datas.length;
let result = '';

let change = (data, index = 0) => {

    // 判断中间点
    if(((length % 2 === 1) && (index === Math.floor(length/2)))
        || ((length % 2 !== 1) && (index + 1) === length/2)
    ) {
        result = data.join('');
        return ;
    }

    let temp =  data[index];
    data[index] = data[length-1-index];
    data[length-1-index] = temp

    index ++;
    change(data, index);
}

return result;

}

Answer 4

const reverseNum = num => {
    if (num === 0) {
        return '';
    }
    const mod = num % 10;
    return `${mod}` + reverseNum(Math.floor(num / 10));
}

Answer 5

what f***

Answer 6

function reserveStr(num) {
  const str = num.toString(), len = str.length;
  if (len === 1 || !len) return str;
  if (len === 2) return str[1] + str[0];
  let res = "";
  for (let i = 0; i < len; i += 2) {
    res = reserveStr(str.slice(i, i + 2)) + res;
  }
  return res;
}

Answer 7

function reverse(num){ return (num + "").length ? (reverse((num + "").slice(1)) + (num + "")[0]) : "" }

Answer 8

function reverse(num) {
    // 得到个位数
    var mod = num % 10
    // 剩余位数
    var n = Math.floor(num / 10)
    if(n <= 0) {
        return num
    } else {
        return '' + mod + reverse(n) 
    }
}

Answer 9

function toreverseString(int){
   if(!int&&int!==0) return ''
   var arr=int.toString().split('');
   var str = arr.pop()
   return str+toreverseString(arr.join(''))
}

Answer 10

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 的时候返回的是整形

小于10的时候toString()一下么

Answer 11

function core(input) {
  input = (input + "")
  let length = input.length
  let count = length - 1
  let result = ""
  return function f1() {
    result += input[count]
    if (count <= 0) {
      count = length - 1
      return result
    }
    count--
    return f1.call(null)
  }
}

core(123456789)()  // 987654321

Answer 12

这可能是不依赖任何API的最佳实践了吧
const reverseInt = num => (num/10 >> 0) ? `${num%10}${reverseInt(num/10 >> 0)}` : `${num}`

Answer 13

// 用递归。第一步 处理递归到底的条件 第二步 构建一个更小问题的解。 第三步 用更小问题的解构建出原问题的解
第一步 很明显
第二步 reverse这个函数的宏观语意就是题目的意思，输入一个整数 返回 这个整数的逆序字符串。 那么将原num % 10 后得到一个子整数即新的num reverse(num)就很明确的求出了原数字 除了 个位的逆序数
第三步 将个位数与 reverse(num) 加起来 构建原问题的解
const reverse = (num: number): string => {
if (num < 10) {
return num.toString()
}
const cur = (num % 10).toString()
num = Math.floor(num / 10)
return cur + reverse(num)
}

Answer 14

function numberToString(num) {
let a = num % 10
let b = Math.floor(num/10)
if(b === 0) return a
return a + '' + numberToString(b)
}

Answer 15

function numToString(num, res = []) {
	if (num == '') return;
		let temp = Number(num) % 10;
		res.push(temp);
		let str = num.toString();
		if (res.length !== 0) {
			numToString(str.slice(0, -1), res)
		}
	return res.join('');
}

Answer 16

function reverse(num){
   if(num < 10) return num
   let str = ''
   str = `${num%10}${reverse(Math.floor(num/10))}`
  return str
 }

Answer 17

function reverse(val) {
if (!val) return ''
let str = val + ''
return reverse(+str.slice(1)) + str.charAt(0)
}

Answer 18

function reverse(num){
    var str=String(num)
    if(str.length===1){
        return str
    }

    return  reverse(str.slice(-1))+reverse(str.slice(0,-1))

}

Answer 19

function fun(int, x = int.toString().split(""), y = "") {
  if (x.length == 0) return y;
  else y = fun(undefined, x, x.shift()) + y;
  return y;
}
console.time("my");
console.log(fun(123212312312312313212312123321231231231));
console.timeEnd("my");

console.time("sys");
console.log(
  (123212312312312313212312123321231231231)
    .toString()
    .split("")
    .reverse()
    .join("")
);
console.timeEnd("sys");

Answer 20

function getRevString(num){
let numString= typeof num == 'string' ? num : num.toString();
if(numString<=1){
return numString
}else{
return ${numString.slice(numString.length- 1)}${getRevString(numString.slice(0,numString.length-1))}
}

}
console.log(getRevString(1234))

Answer 21

function reverseN2S(num) {
  let str = num + '';
  let index = str.length - 1;
  return str[index] + (index > 0 ? reverseN2S(str.substring(0, index)) : '');
}

console.log(reverseN2S(1234));    // '4321'
console.log(reverseN2S(-1000));   // '0001-'

Answer 22

function input(num){
    const str = num.toString();
    function reverser(pos){
        if(pos<0){
            return '';
        }
        return str.charAt(pos)+reverser(--pos);
    }
    return reverser(str.length-1);
}

Answer 23

function reverse(num) {
    if(num == undefined) {
        return
    }
    var str = num + ''
    if(str.length == 0) {
        return str
    }
    var s = str.charAt(str.length - 1)
    return s + reverse(str.substr(0, str.length - 1))
}

Answer 24

function reverse(num) {
    num = typeof num === 'number' ? '' + num : num;
    if (!num.length) return '';
    
    return num.slice(-1) + reverse(num.slice(0, -1));
}

Answer 25

function input(num) {
	const strNum = String(num)
    
	if (strNum.length === 1) return strNum

	const d = Math.pow(10, strNum.length - 1)
	const res = Math.floor(num / d)
	const left = num % d
    
    console.log('res', res)
    console.log('d', d)
	return input(left) + res + ''
}

console.log(input(1234)) // '4321'

Answer 26

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

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 27

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 28

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 29

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

Answer 30

贴上两种方法

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

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 32

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

Answer 33

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

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

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

Answer 34

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

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

Answer 35

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

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

Answer 36

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 37

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

Answer 38

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 39

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 40

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

Answer 41

function reverseString(str) {
    // 转换整型
    var str = str.toString()
    if (str.length === 1) return str;
    return reverseString(str.slice(1)) + str[0];
  }

Answer 42

function abc(n){
if(n>0){
return abc(Math.floor(n/10)) + n %10 + ''
}else {
return n
}
}

Answer 43

const reverseNum=(num)=>{
let str=num.toString();
let len=str.length;
return len === 1 ? str: str.substring(len-1)+reverseNum(str.substring(0,len-1));
}

Answer 44

function reverse(num) {
  let numArr = num.toString().split("");
  return recuision(numArr);
}
function recuision(arr) {
  if (arr.length === 1) return arr.pop() + "";
  return arr.pop() + recuision(arr);
}
console.log(reverse(1234)); // "4321"
console.log(typeof reverse(1234)); // string

Answer 45

function reverse (v) {
    if (!v) return ''
    
    return foo(String(v).slice(1)) + String(v)[0]
}

Answer 46

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 47

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

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 48

Answer 49

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

Answer 50

思路：先将传入的参数转为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 51

`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 52

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

Answer 53

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

}

Answer 54

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 55

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

这样行不,有错望指出

Answer 56

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 57

`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 58

其实这种直接使用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 59

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)