Do...While 循环后无法获得价值

Question

问题：创建一个函数，它接受一个正整数并返回下一个更大的数字，该数字可以通过重新排列其数字来形成。例如：

12 ==> 21
513 ==> 531
2017 ==> 2071
//nextBigger(num: 12)   // returns 21
//nextBigger(num: 513)  // returns 531
//nextBigger(num: 2017) // returns 2071

---

我正在尝试比较两个数组并获得正确的数组作为答案。在 do...while 循环中，我通过将第二个数组加一来比较两个数组。

function nextBigger(n){
  let nStrg = n.toString();
  
  let nArr = nStrg.split('');
 
  function compareArr(Ar1,Ar2){
    if(Ar2.length>Ar1.length){
      return false;
    }
    for(let i=0; i<Ar1.length; i++){
      let num = Ar1[i];
      for(let j=0; j<Ar2.length; j++){
        if(Ar2.lastIndexOf(num) !== -1){
          Ar2.splice(Ar2.lastIndexOf(num), 1);
          break;
        }
        else{
          return false;
          break;
        }
      }
    }
    return true;
  }
  
  let nextNumArr;
  let m = n;
  
  do{
    let nextNum = m+1
    m=nextNum
    
    let nextNumStrg = nextNum.toString();
    
    nextNumArr = nextNumStrg.split('')
    
    
    console.log(compareArr(nArr, nextNumArr))
  }
  while(compareArr(nArr, nextNumArr) == false)
    
  console.log(nextNumArr)
  
  return parseInt(nextNumArr.join())
}

nextBigger(12);

这最后给了我一个空数组；

Answer 1

[2,0,1,7].join() 会给你'2,0,1,7'，可以使用[2,0,1,7].join('') 得到'2017'

Answer 2

一切看起来有点复杂。怎么样：

const nextLarger = num => {
  const numX = `${num}`.split(``).map(Number).reverse();
  
  for (let i = 0; i < numX.length; i += 1) {
    if ( numX[i] > numX[i + 1] ) {
      numX.splice(i, 2, ...[numX[i+1], numX[i]]);
      return +(numX.reverse().join(``));
    }
  }
  
  return num;
};

const test = [...Array(100)].map(v => {
    const someNr = Math.floor(10 + Math.random() * 100000);
    const next = nextLarger(someNr);
    return `${someNr} => ${
      next === someNr ? `not possible` : next}`;
  }).join('\n');

document.querySelector(`pre`).textContent = test;

<pre></pre>

See also

Answer 3

function nextbig(number) {
  let nums = []
  number.toString().split('').forEach((num) => {
    nums.push(parseInt(num))
  })
  number = nums
  n = number.length
  for (var i = n - 1; i >= 0; i--) {
    if (number[i] > number[i - 1])
      break;
  }

  if (i == 1 && number[i] <= number[i - 1]) {
    return 'No greater possible'
  }

  let x = number[i - 1];
  let smallest = i;

  for (let j = i + 1; j < n; j++) {
    if (number[j] > x &&
      number[j] < number[smallest])
      smallest = j;
  }

  let temp = number[smallest];
  number[smallest] = number[i - 1];
  number[i - 1] = temp;

  x = 0

  for (let j = 0; j < i; j++)
    x = x * 10 + number[j];

  number = number.slice(i, number.length + 1);
  number.sort()

  for (let j = 0; j < n - i; j++)
    x = x * 10 + number[j];

  return x

}
console.log(nextbig(12))
console.log(nextbig(513))
console.log(nextbig(2017))

Answer 4

在compareArr 中，您正在删除找到的元素，这样做是正确的，以确保重复实际发生两次等。但是，这也会在调用上下文中从nextNumArr 中删除元素，因为数组通过引用而不是值传递。您需要手动复制它，例如：compareArr(nArr, [...nextNumArr])。

Answer 5

我使用了另一种方法，首先我使用置换函数搜索给定数字的所有可能组合。此函数返回一个可能的数字数组。

然后我对这个组合数组进行排序，并在主函数中查找给定数字的索引。

一旦我有了这个索引，我就会返回给定数字之前的位置。

function nextbig(num){
    function permutator(inputArr){
        let result = [];     
        const permute = (arr, m = []) => {
          if (arr.length === 0) {
            result.push(m)
          } else {
            for (let i = 0; i < arr.length; i++) {
              let curr = arr.slice();
              let next = curr.splice(i, 1);
              permute(curr.slice(), m.concat(next))
           }
         }
       }      
       permute(inputArr)
       return result;
    }


    let arrNums = num.toString().split('')
    let combinations = permutator(arrNums).map(elem => parseInt(elem.join("")))

    combinations.sort((a, b) => {
      return b - a
    })
    let indexOfNum = combinations.findIndex(elem => elem === num) 
    let nextBigIndex = indexOfNum <= 0 ? 0 : indexOfNum - 1 
    return (combinations[nextBigIndex])
}

console.log(nextbig(12))
console.log(nextbig(517))
console.log(nextbig(2017))