如何优化接受正整数并返回下一个较小正整数的函数？

Question

我正在尝试编写一个函数，它接受一个正整数并返回下一个包含相同数字的较小正整数，当没有包含相同数字的较小数字时返回-1。

For example:

nextSmaller(21) == 12
nextSmaller(531) == 513
nextSmaller(2071) == 2017

我写了一个代码来解决这个问题，但我真的不知道如何进一步优化它。请你帮助我好吗？它在 repl.it 上运行得相当快，但是当我提交它时，它说它需要超过 1200 毫秒，并且即使所有测试都通过了也不允许我提交它。

function nextSmaller(n) {
var nArray= n.toString().split("")
var minimumNum = 1 + Array(nArray.length).join('0')
for(var i=n-1; i >= minimumNum; i--) {
  var newNumArray = i.toString().split('');
  var counter = 0;
  for (var j=0; j<newNumArray.length; j++) {
    if (nArray.indexOf(newNumArray[j]) > -1) {
        counter++
        nArray.splice(nArray.indexOf(newNumArray[j]), 1)
        if (counter === n.toString().split("").length) {
        return i;
        }
     } 
  }
       nArray = n.toString().split("");
       if (i === Number(minimumNum)) return -1;
  }
}

Answer 1

您的代码可以稍微优化一下，例如，您可以在内部循环中使用 break 语句，在您知道当前的数字不起作用时立即转到下一个数字（这应该让它运行大约一半的时间，但对于像91234567 这样的n 来说仍然很慢，并且在循环中使用变量而不是n.toString().split("").length，因此您只需要将n 转换为数组一次。

function nextSmaller(n) {
  var nArray = n.toString().split("")
  var length = nArray.length;
  var minimumNum = 1 + Array(length).join('0')
  for(var i=n-1; i >= minimumNum; i--) {
    var newNumArray = i.toString().split('');
    var counter = 0;
    for (var j=0; j<newNumArray.length; j++) {
      if (nArray.indexOf(newNumArray[j]) < 0)
          break;
      counter++
      nArray.splice(nArray.indexOf(newNumArray[j]), 1)
      if (counter === length) {
          return i;
      }
    }
    nArray = n.toString().split("");
  }
  return -1;
}

有一种非常有效的算法可以计算下一个排列，可以很容易地改用前一个排列（如果结果排列以0 开头，则返回-1）。我调整了this algorithm 来做到这一点：

[21,531,2071,912345678,9123545678,915345678].forEach( x => console.log( nextSmaller( x ) ) );

function nextSmaller(n) {
  
    const arr = ( n + '' ).split( '' ).map( Number );
  
    // Find longest non-decreasing suffix
    let i, prev = 9;
    for ( i = arr.length; i--; ) {
        if ( arr[ i ] > prev )
            break;
        prev = arr[ i ];
    }
  
    // If whole sequence is non-decreasing,
    // it is already the smallest permutation
    if ( i < 0 )
        return -1;
  
    const pivot_i = i;
    const pivot = arr[ pivot_i ];
  
    for ( i = arr.length; i--; ) {
        if ( arr[ i ] < pivot )
            break;
    }
  
    arr[ pivot_i ] = arr[ i ];
    arr[ i ] = pivot;

    if ( arr[ 0 ] === 0 )
        return -1;
  
    return +arr.slice( 0, pivot_i + 1 ).concat( arr.slice( pivot_i + 1 ).reverse( ) ).join('');
}

Answer 2

算法可能如下：

1. 对于输入数字n，查找由same digits 和sort 中的一些permutations 组成的所有数字。例如，如果n=213，我们得到的排序列表为[123, 132, 213, 231, 312, 321]。 （例如，Permutations in JavaScript? 可以帮助您）。

2. 在排序列表中找到数字n 的index i。如果i>0 返回index i-1 处的数字，否则返回-1（如果它是出现在排序列表第一个位置的最小数字）。

另一种替代算法可能如下：

递减数字n，直到找到具有完全相同数字的数字（以不同的顺序，您可以对数字进行排序并检查是否相等）。

最有效的将类似于@Paulpro(https://www.nayuki.io/page/next-lexicographical-permutation-algorithm) 提到的那个

1. 从n 的十进制字符串表示中找到longest non-decreasing suffix。
2. 如果整个字符串 n 不递减，则返回 -1（不能更小）。
3. 否则选择紧靠后缀开头的数字为pivot，并将其与suffix中的（the leftmost和）the largest数字交换，即smaller而不是pivot。返回此号码。