Question

数组A = [1,0,1,1,1,1,0,1,1]]; 结果将是B B = [1,0,4,3,2,1,0,2,1]; 给出A的元素，结果为B. A中的元素只能是0和1。我们需要从A中的最后一个元素向后计数，如果有连续的1，则A和B中的元素将为1但是对于A中的第二个连续1，它将是2并且对于第3个在A中，元素将在B中为3 但对于0，它将为0.我尝试了以下方法，但我没有得到输出。

<script>

var A= [1,0,1,1,1,1,0,1,1]];
var B =[];
//var B= A.length;

var lastValueOne;
var consecutiveOnes = 0;

for (i = A.Length - 1; i >= 0; i--)
    {
        if ( lastValueOne== false) 
        {
                consecutiveOnes = 0; 
                B[i] = 0;
        }
        else 
        { 
            consecutiveOnes++; 
            B[i] = consecutiveOnes; 
        }

        if (A[i] == 1) 
        { 
            lastValueOne = true; 
        }

        else 
        { 
            lastValueOne = false; 
        }
    }

  //console.log(B[i]);
 document.getElementById("demo").innerHTML = B;

Answer 1

如果在实际索引处给出了真值，则可以迭代给定数组并映射计数值。然后迭代直到找到一个假值并返回计数。

var array = [1, 0, 1, 1, 1, 1, 0, 1, 1],
    result = array.map(function (_, i, a) { // take only index and array as parameter
        var count = 0;                      // declare and initialize counter with zero
        while(a[i++]) {                     // check value at actual index and inc index
            count++;                        // increment counter while true/truthy
        }
        return count;                       // return count
    });

console.log(result);

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

在不使用sum变量并使用结果数组r[0]的第一个元素来保持累积总和的情况下，提前le_m的answer的想法

var array = [1, 0, 1, 1, 1, 1, 0, 1, 1],
    result = array.reduceRight(function (r, a) {
        return [a && (r[0] || 0) + a].concat(r);
    }, []);

console.log(result);

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

Answer 2

更具描述性的Array.reduceRight非常适合从右到左计算累积金额的任务。

＆＃13;

// Return cumulative sums from right, reset on zero:
function cumSumRight(array, sum = 0) {
  return array.reduceRight((result, a) => {
    sum = a > 0 ? sum + a : 0;
    result.unshift(sum);
    return result;
  }, []);
}

// Example:
console.log(cumSumRight([1,0,1,1,1,1,0,1,1])); // [1,0,4,3,2,1,0,2,1]

＆＃13;

要修复当前解决方案，请写下A.length而不是A.Length。然后，您可以简化为：

let sum = 0;
for (let i = A.length - 1; i >= 0; i--) {
  sum += A[i];
  if (A[i] === 0) {
    sum = 0; 
  }
  B.unshift(sum);
}

Answer 3

如果最后一个值为1且当前值也为1，则只应递增consecutiveOnes。但逻辑可以更简单，因为当最后一个值为false时，您的连续值也应为0。

var A= [1,0,1,1,1,1,0,1,1];
var B = [];
var consecutiveOnes = 0;

for (i = A.length - 1; i >= 0; i--)
    {
        if (A[i] == 1) 
        {
            consecutiveOnes += 1;
        }
        else 
        { 
            consecutiveOnes = 0; 
        }
        B[i] = consecutiveOnes;
    }

console.log(B);

什么应该是从阵列A获取阵列B的正确算法

3 个答案: