需要基于同等的增值答案

【问题标题】：Need to equally add value based需要基于同等的增值
【发布时间】：2020-08-23 13:36:22
【问题描述】：

我必须关注数组：

var collections=[
    {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false}
];

使用以下迭代，我可以计算出next 和prev：

for(i = 0; i < collections.length; i++) {
    collections[i].next = (i+1) % collections.length;
  collections[i].prev = i > 0 ? i-1 : collections.length-1;
}

结果如下：

var collections=[
    {value:20, next:"1", prev: "3", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"2", prev: "0", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"3", prev: "1", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"4", prev: "2", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"0", prev: "3", lastUpdated: false, isLoaked: false, pointer: false}
];

基于新的集合，如果指针是increased或decreased，我需要计算每个值

示例：第 3 项的值已增加到 25

var collections=[
    {value:20, next:"1", prev: "3", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"2", prev: "0", lastUpdated: false, isLoaked: false, pointer: false},
  {value:25, next:"3", prev: "1", lastUpdated: false, isLoaked: false, pointer: true},
  {value:20, next:"4", prev: "2", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"0", prev: "3", lastUpdated: false, isLoaked: false, pointer: false}
];

预期结果：

0: {value: 19, next: 1, prev: 4, lastUpdated: true, isLoaked: false, pointer: false}
1: {value: 19, next: 2, prev: 0, lastUpdated: true, isLoaked: false, pointer: false}
2: {value: 25, next: 3, prev: 1, lastUpdated: true, isLoaked: false, pointer: true}
3: {value: 18, next: 4, prev: 2, lastUpdated: true, isLoaked: false, pointer: false}
4: {value: 19, next: 0, prev: 3, lastUpdated: true, isLoaked: false, pointer: false}

示例 2：如果同一指针的值减小到 2。

var collections=[
    {value:19, next:"1", prev: "3", lastUpdated: false, isLoaked: false, pointer: false},
  {value:19, next:"2", prev: "0", lastUpdated: false, isLoaked: false, pointer: false},
  {value:23, next:"3", prev: "1", lastUpdated: false, isLoaked: false, pointer: true},
  {value:18, next:"4", prev: "2", lastUpdated: false, isLoaked: false, pointer: false},
  {value:19, next:"0", prev: "3", lastUpdated: false, isLoaked: false, pointer: false}
];

以下结果应遵循prev:

0: {value: 20, next: 1, prev: 4, lastUpdated: true, isLoaked: false, pointer: false}
1: {value: 20, next: 2, prev: 0, lastUpdated: true, isLoaked: false, pointer: false}
2: {value: 23, next: 3, prev: 1, lastUpdated: false, isLoaked: false, pointer: true}
3: {value: 18, next: 4, prev: 2, lastUpdated: false, isLoaked: false, pointer: false}
4: {value: 19, next: 0, prev: 3, lastUpdated: false, isLoaked: false, pointer: false}

到目前为止，我有以下代码：

var collections=[
    {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false}
];
var maxValue = 100;
var totalValue = 0;
var toBeDistributedNext = 0;
var toBeDistributedPrev = 0;

for(i = 0; i < collections.length; i++) {
    collections[i].next = (i+1) % collections.length;
  collections[i].prev = i > 0 ? i-1 : collections.length-1;
}

collections[2].value = 25;
collections[2].pointer = true;

collections.forEach(function (collection) {
  totalValue += parseInt(collection.value);
});

if (totalValue > maxValue) {
    toBeDistributedNext = totalValue - maxValue;
} else {
    toBeDistributedPrev = maxValue - totalValue;
}
var currentPointer = collections.find(item => item.pointer === true);
for (let i = 0; i < toBeDistributedNext; i++) {
  var nextIndex = currentPointer.next;
  if (!collections[i%collections.length].pointer) {
    collections[i%collections.length].value--;
    collections[i%collections.length].lastUpdated = true;
    console.log(collections[i%collections.length])
    //currentPointer = collections[i%collections.length].next;
  }
}

上面的代码给出了以下结果：这是错误的

0: {value: 19, next: 1, prev: 4, lastUpdated: true, isLoaked: false, …}
1: {value: 19, next: 2, prev: 0, lastUpdated: true, isLoaked: false, …}
2: {value: 25, next: 3, prev: 1, lastUpdated: false, isLoaked: false, …}
3: {value: 19, next: 4, prev: 2, lastUpdated: true, isLoaked: false, …}
4: {value: 19, next: 0, prev: 3, lastUpdated: true, isLoaked: false, …}

最后没有计算，请任何人帮忙。 总数必须为 100。

我有 JsFiddle：https://jsfiddle.net/tanvir_alam_shawn/zm21pLen/144/

【问题讨论】：

为什么在索引3 上有18？为什么不在另一个地方，然后为什么不先增加这个值呢？
@NinaScholz 它必须遵循next 和prev 的顺序，因为索引2 已经是指向next 的指针
我不明白为什么当你实际上有数组索引时你有 prev/next。直接寻址有什么问题？
@trincot 请给我一个例子
您已经接受了一个答案。但是你肯定可以通过增加“当前”索引来访问“下一个”元素。

标签： javascript arrays iteration

【解决方案1】：

您可以使用一个函数来更新值并检查分布的增量。

function update(array, index, value) {
    function go(index, direction) {
        do {
            if (!array[index].isLocked) { // check for locked items
                array[index].value += increment;
                if (!(delta -= increment)) return;
            }
            index = array[index][direction];
        } while (!array[index].pointer)
    }
    
    let delta = array[index].value - value,
        increment = Math.sign(delta);

    array[index].value = value;
    array[index].pointer = true;

    while (delta) {
        go(array[index].prev, 'prev');
        if (!delta) break;
        go(array[index].next, 'next');
    }

    array[index].pointer = false;
}

var collections = [
        { value: 20, next: 1, prev: 4, lastUpdated: false, isLocked: false, pointer: false },
        { value: 20, next: 2, prev: 0, lastUpdated: false, isLocked: false, pointer: false },
        { value: 20, next: 3, prev: 1, lastUpdated: false, isLocked: false, pointer: false },
        { value: 20, next: 4, prev: 2, lastUpdated: false, isLocked: false, pointer: false },
        { value: 20, next: 0, prev: 3, lastUpdated: false, isLocked: false, pointer: false }
    ];

update(collections, 2, 25);
console.log(...collections.map(({ value }) => value));
update(collections, 2, 23);
console.log(...collections.map(({ value }) => value));

【讨论】：

这仅在数量均匀分布时才有效，如果因非偶数而失败
如果你能帮我解决这个问题将不胜感激
你有例子吗？
如何锁定一个并将其余部分分配给未锁定的其他人？如果它的锁定，可用数量（100 - 锁定）和剩余的分配给其他未锁定的？ isLocked
只检查属性和continue循环。

【解决方案2】：

您非常接近，但您的代码中有一些奇怪的东西。

首先，您小心地为当前指针分配：

var currentPointer = collections.find(item => item.pointer === true);

在你的循环中你分配下一个指针

for (let i = 0; i < toBeDistributedNext; i++) {
    var nextIndex = currentPointer.next;

但是在下一行中，您忽略了所有出色的工作：

if (!collections[i%collections.length].pointer)

collections[i%collections.length] 没有指向您当前的指针，请注意在循环开始时 i 等于 0。不要使用 i 访问指针，您应该使用您已经计算过的 nextIndex 值出去。

此外，当您的示例集合数组中有五个项目时，您使用的示例增加了 5 的值，这对您没有任何帮助。无论如何，看看你的循环，看看问题：

for (let i = 0; i < toBeDistributedNext; i++) {
  var nextIndex = currentPointer.next;
  if (!collections[i%collections.length].pointer) {
    collections[i%collections.length].value--;
    collections[i%collections.length].lastUpdated = true;
    console.log(collections[i%collections.length])
    //currentPointer = collections[i%collections.length].next;
  }
}

pointer 设置为 true 时会怎样？好吧，没有值被改变，但 i 无论如何都会增加，因此实际上只进行了 4 次更改。因此，要修复您的代码，您需要使用已计算的实际索引，并在当前集合项的指针设置为 true 时执行某些操作（例如，递增 toBeDistributedNext）。您还想更新 currenntPointer 的值，以便正确计算下一个索引。所以循环看起来像这样：

var currentPointer = collections.find(item => item.pointer === true);
for (let i = 0; i < toBeDistributedNext; i++) {
  var nextIndex = currentPointer.next;
  if (!collections[nextIndex].pointer) {
    collections[nextIndex].value--;
    collections[nextIndex].lastUpdated = true;
  } else {
    toBeDistributedNext++;
  }

  currentPointer = collections[nextIndex];
}

这是一个运行代码的 sn-p：

var collections=[
    {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false},
  {value:20, next:"", prev: "", lastUpdated: false, isLoaked: false, pointer: false}
];
var maxValue = 100;
var totalValue = 0;
var toBeDistributedNext = 0;
var toBeDistributedPrev = 0;

for(i = 0; i < collections.length; i++) {
    collections[i].next = (i+1) % collections.length;
  collections[i].prev = i > 0 ? i-1 : collections.length-1;
}

collections[2].value = 25;
collections[2].pointer = true;

collections.forEach(function (collection) {
  totalValue += parseInt(collection.value);
});

if (totalValue > maxValue) {
    toBeDistributedNext = totalValue - maxValue;
} else {
    toBeDistributedPrev = maxValue - totalValue;
}
console.log('BEFORE', collections);
var currentPointer = collections.find(item => item.pointer === true);
for (let i = 0; i < toBeDistributedNext; i++) {
  var nextIndex = currentPointer.next;
  if (!collections[nextIndex].pointer) {
    collections[nextIndex].value--;
    collections[nextIndex].lastUpdated = true;
  } else {
    toBeDistributedNext++;
  }
  
  currentPointer = collections[nextIndex];
}

console.log("AFTER", collections)

    /*if (collections[i%collections.length].pointer && !collections[i%collections.length].lastUpdated) {
    collections[collections[i%collections.length].next%collections.length].value++;
    collections[collections[i%collections.length].next%collections.length].lastUpdated = true;
  } else {
    //????Need help, So it moves to next item and add one as you see the expected result
  }*/
/**Expected Result: with NEXT
0: {value: 19, next: 1, prev: 4, lastUpdated: true, isLoaked: false, pointer: false}
1: {value: 19, next: 2, prev: 0, lastUpdated: true, isLoaked: false, pointer: false}
2: {value: 25, next: 3, prev: 1, lastUpdated: true, isLoaked: false, pointer: true}
3: {value: 18, next: 4, prev: 2, lastUpdated: true, isLoaked: false, pointer: false}
4: {value: 19, next: 0, prev: 3, lastUpdated: true, isLoaked: false, pointer: false}
*/

/**Expected Result: with PREV
0: {value: 20, next: 1, prev: 4, lastUpdated: true, isLoaked: false, pointer: false}
1: {value: 20, next: 2, prev: 0, lastUpdated: true, isLoaked: false, pointer: false}
2: {value: 23, next: 3, prev: 1, lastUpdated: false, isLoaked: false, pointer: true}
3: {value: 18, next: 4, prev: 2, lastUpdated: false, isLoaked: false, pointer: false}
4: {value: 19, next: 0, prev: 3, lastUpdated: false, isLoaked: false, pointer: false}
*/

//So if its LOCKED, it will (100 - totalLocaked) and what ever is left will be distributed similary with next and prev.

【讨论】：