添加到阵列的兄弟姐妹

Question

我有10个项目的数组：

| 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 | 0 |

每个阵列持有0

一个int我想要做的就是将值10添加到索引4 。然后让3个外部索引获得一半的值。这里有一个直观的例子：我选择了

| 0 | 1.25 | 2.5 | 5 | 10 | 5 | 2.5 | 1.25 | 0 |

所以，无论指数将收到的10。第一项到左边的值和右边将获得价值/ 2，进一步外的人将收到价值/ 4等

var indexesToCheck = 3; // Will check 3 before and 3 after the selected index 
var array = []; 
var arrayItems = 10; 

for(var i = 0; i < arrayItems.length; i++) { 
    array.push(0); 
} 

function setArrayValue(i, value) { 
    array[i] = value; 

    // How do I go about checking the next and previous 3 values and setting the halved value? 
} 

setArrayValue(4, 10); 

在正确的方向推动将不胜感激。

谢谢！

Answer 1

从你的例子的外观代码，它看起来像你想修改数组，而不是返回一个新的。下面是我的实现：

var indexesToCheck = 3; 
 
var array = new Array(10).fill(0); 
 

 
function setArrayValue(i, value) { 
 
    array[i] = value; 
 
    for (let j = 1; j <= indexesToCheck; j++) { 
 
    value /= 2; 
 
    array[i - j] = value; 
 
    array[i + j] = value; 
 
    } 
 
} 
 
setArrayValue(4, 10) 
 
console.log(array);

Answer 2

您可以使用两个指针，分别递增和递减它们，直到它们碰到数组边界。

var indexesToCheck = 3; //Will check 3 before and 3 after the selected index 
 

 
//you don't need that variable above 
 

 
var array = []; 
 
var arrayItems = 10; 
 

 
for (var i = 0; i < arrayItems; i++) { 
 
    array.push(0); 
 
} 
 

 
function setArrayValue(i, value) { 
 
    array[i] = value; 
 
    var originalVal = value; 
 

 
    var pointer1 = i - 1; 
 
    var pointer2 = i + 1; 
 

 
    while (pointer1 >= 0) { 
 
    array[pointer1] = value/2; 
 
    value = value/2; 
 
    pointer1--; 
 
    } 
 

 
    value = originalVal; 
 

 
    while (pointer2 < array.length) { 
 
    array[pointer2] = value/2; 
 
    value = value/2; 
 
    pointer2++; 
 
    } 
 
} 
 

 
setArrayValue(4, 10); 
 

 
console.log(array);

当然，这可能是更加精致和优化，但是这可以让你开始，因为我认为这是最简单，一种自我的记录，可以很容易理解的逻辑，试着想想如何用一个循环就干净地做到这一点，以及如何避免使用额外的变量。

Answer 3

你可以每次迭代和除以二对上号，那么你就写下一指数上行，下一指数下跌

var indexesToCheck = 3; // Will check 3 before and 3 after the selected index 
 
var array = []; 
 
var arrayItems = 10; 
 

 
for (var i = 0; i < arrayItems; i++) { 
 
    array.push(0); 
 
} 
 

 
function setArrayValue(start, value) { 
 
    array[start] = value; // set initial 
 
    var prev = value;  // keep previous 
 

 
    for (var i = 0; i < indexesToCheck; i++) { 
 
    var p = prev/2;   // divide by two 
 
    if ((start - i - 1) > -1)   array[start - i - 1] = p; 
 
    if ((start + i + 1) < array.length) array[start + i + 1] = p; 
 
    prev = p; 
 
    } 
 
} 
 

 
setArrayValue(4, 10); 
 

 
console.log(array);

Answer 4

你的逻辑就分成两个独立的回路。当你离开给定的索引时，人们会处理这些值的一半，而且一个会处理正确的值。例如：

function initializeArray(array, index, initialValue) { 
    array[index] = initialValue; 

    var i; 

    //Handles logic going left (decreasing indices) 
    var currentValue = initialValue; 
    for(i = index-1; i >= 0; i--) { 
     currentValue /= 2.0; 
     array[i] = currentValue; 
    } 

    //Handles logic going right (increasing indices) 
    currentValue = initialValue; 
    for(i = index+1; i < array.length; i++) { 
     currentValue /= 2.0; 
     array[i] = currentValue; 
    } 
} 

Answer 5

一个简单的解决方案可以是

var leftIndex = 6; //Index of value 
var rightIndex = 6; //Index of value 
var val = 10; //Value at Index 
var arr=[]; 
arr[leftIndex]=val; 
while(leftIndex>0) { 
    leftIndex--; 
    arr[leftIndex] = arr[leftIndex+1]/2; 
} 
while(rightIndex<9) { 
    rightIndex++; 
    arr[rightIndex] = arr[rightIndex-1]/2; 
} 

Answer 6

你可以计算数组项的值。

var length = 9, 
 
    center = 10, 
 
    border = 0, 
 
    array = Array.apply(null, { length: length }).map(function (a, i, aa) { 
 
     return i === 0 || i + 1 === aa.length ? 
 
      border : 
 
      center/(1 << Math.abs(Math.floor(aa.length/2) - i)); 
 
    }); 
 

 
console.log(array);

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

Answer 7

这应该做的伎俩。例如，我不确定元素是否包含要保留的值或是否应该全部用零覆盖，但这是一个简单的更改。

var arr = [0,0,0,0,0,0,0,0,0,0,0]; 
 

 
var changed = doThing(arr, 4, 10, 3); // add 10 to array el 4 and affect elements within 3 
 

 
function doThing(arr, index, value, spread) { 
 
    return arr.map(function(el, i) { 
 
    var d = Math.abs(index - i); 
 
    if (d <= spread) { 
 
     return value * Math.pow(0.5, d); 
 
    } 
 
    return 0; 
 
    }); 
 
} 
 
     
 
console.log(changed); 
 

 

Answer 8

// We need to loop over the offset from the original index 
for (var offset=1; offset <= indexToCheck; offset++) { 
    // We want to handle moving offset to the left 
    if(start - offset >= 0){ // Ensure we're still in bounds 
     array[start-offset] += value/(2 * offset); // Add value divided by 2 for each offset 
    } 
    // We want to handle moving offset to the right 
    if (start + offset < array.length) { // Ensure we're still in bounds 
     array[start+offset] += value/(2 * offset); 
    } 
} 

Answer 9

const arr = Array(10).fill(0); 
 

 
const setNum = (pos, num, arr) => { // position, initial number, and array 
 
    const a = arr.slice(); 
 
    a[pos] = num; 
 
    for (let i = (pos - 1); i >= 0; i--) { a[i] = a[i+1]/2 } 
 
    for (let i = (pos + 1); i < a.length; i++) { a[i] = a[i-1]/2 } 
 
    return a; 
 
} 
 

 
console.log(setNum(5, 10, arr))

Answer 10

通用的解决问题的方法是：

1. 让枢轴（在这种情况下枢轴= 4）是被指定为阈值（在该情况下阈值= 10）值和indexBoundary（在这种情况下，indexBoundary = 3）的索引是检查的索引。
2. 现在leftStartIndex = MAX（0，枢轴indexBoundary）和rightEndIndex =分钟（array.size（） - 1，+枢轴indexBoundary）。这也将处理边界案件。
3. 从i-> pivot-1到leftStartIndex（包括）do array [i] = threshold/2 ^（pivot-i）。
4. 类似地从i-> pivot + 1到rightEndIndex（包括）do array [i] = threshold/2 ^（i-pivot）。

对于您的情况：

pivot=4 
threshold=10 
indexBoundary=3 

for i->3 to 1, do 
    array[i] = threshold/2^(pivot-i) 
i=3, array[3] = 10/2^(4-3) = 10/2 = 5 
i=2, array[2] = 10/2^(4-2) = 10/4 = 2.5 
i=1, array[1] = 10/2^(4-1) = 10/8 = 1.25 


for i->5 to 7, do 
    array[i] = threshold/2^(i-pivot) 
i=3, array[3] = 10/2^(5-4) = 10/2 = 5 
i=2, array[2] = 10/2^(6-4) = 10/4 = 2.5 
i=1, array[1] = 10/2^(7-4) = 10/8 = 1.25 

让我知道，如果有什么不明确。