在一个数字序列中，如何计算一个数字出现的次数，该数字的值恰好比前一个数字的值小 1？

如何解决在一个数字序列中，如何计算一个数字出现的次数，该数字的值恰好比前一个数字的值小 1？

代码：

function OneDecremented(num) { 
  num = num.toString()
  var count = 0

  for(i = 1; i < num.length; i++) {
    if(num[i - 1] - num[i] === 1){
      count++
    }
  }
  return count

}
console.log(OneDecremented(9876541110))

所以我很难理解两件事：

1. i 和 num[i] 有什么区别
2. 我不明白 if 语句中的计算是如何进行的，有人可以分解一下吗？

对不起，如果这些问题听起来太愚蠢了，我是 JS 新手，无法真正理解算术计算。谢谢你的时间。

解决方法

由于几个原因，该代码编写得不好，但最重要的是，它在全局范围内泄露了 i 引用，因此，让我们从更好的版本开始：

function OneDecremented(num) {
  var str = num.toString();
  var count = 0;
  for(var i = 1; i < str.length; i++) {
    if(str[i - 1] - str[i] === 1)
      count++;
  }
  return count;
}

字符串，在现代 JS 中，可以像数组一样访问，索引返回 index 位置的字符：

if(str[i - 1] - str[i] === 1)
// is the same as
if ((str.charAt(i - 1) - str.charAt(i)) === 1)

一旦检索到每个字符，代码就会执行一个隐式的“字符到数字”转换，这要归功于 - 运算符，但如果它是一个 +，它会将两个字符连接为字符串（所以，要小心）。

明确总是更好，但如果您知道 - 的工作原理，它就可以完成这项任务。

循环从 1 开始，并检查 i - 1 处的字符，即在第一次迭代中索引 0 处的字符减去当前字符后为 {{ 1}}，表示当前字符比前一个字符少一个。

如果是这种情况，计数器就会累加。

,

i 和 num[i] 有什么区别

i 是迭代键，即 0、1、2 等，因为字符串化数字中有多少字符。 num[i] 是字符串中索引 i 处的字符，即 num[i] 其中 i 是 0 == 9（字符串中索引 0 处的字符).

我不明白 if 语句中的计算是如何进行的，有人可以分解一下吗？

也就是说：如果计算字符串的索引 i-1 处的数字，减去正在考虑的当前数字（字符串中的索引 i 处）减去为 1，则递增 {{1 }}。

逐步了解实际使用的数量：

• 9 - 没有前一个字符；计算 (undefined - 9) 不等于 1
• 8 - 前一个字符是 9； (9 - 8) == 1;递增count
• 7 - 同上
• 6 - 同上
• 5 - 同上
• 4 - 同上
• 1 - 前一个字符是 4；计算 (4 - 1) 不等于 1
• 1 - 前一个字符是 1；计算 (1 - 1) 不等于 1
• 1 - 同上
• 0 - 前一个字符是 1； (1 - 0) == 1;递增count

,

Andrea 和 Mitya 已经成功了。

下一步可能是切换到基于 first class 的方法，例如使用特定的 Array 方法，例如 reduce。

这种方法如果正确实施，通常会提高代码的可读性/可维护性，并允许更好地重用代码。

对于OP提供的示例，可以编写两个函数，即获取计数的实际方法和上述第一类reducer功能。由于 reduce 是处理数组的标准方式，因此也很好地指定了减速器/回调的参数优先级...

[/* ... */].reduce(function(accumulator,currentValue,currentIndex,currentlyProcessedArray) {

  // implement reducer/aggregation/accumulator logic here.

  // the return value serves as the
  // new `accumulator` value within
  // the next iteration step.

  // thus,always return something! ... e.g ...

  return (accumulator + currentValue); 
});

function aggregatePrecursorAndDecrementedSuccessorCount(count,char,idx,arr) {

  const precursorValue = Number(arr[idx - 1]);
  const incrementedCurrentValue = (Number(char) + 1);
  const isValidCount = (precursorValue === incrementedCurrentValue);

  return (count + (isValidCount ? 1 : 0));
//return (count + Number(isValidCount)); // cast boolean value to either 1 or 0.
}

function getPrecursorAndDecrementedSuccessorCount(int) {
  return String(int) // - assure/typecast always a/into string value.
    .split('')       // - split string value into an array of single characters.
    .reduce(aggregatePrecursorAndDecrementedSuccessorCount,0);
}

console.log(getPrecursorAndDecrementedSuccessorCount(9876541110));

.as-console-wrapper { min-height: 100%!important; top: 0; }