How to subtract value of array but still in position

Question

How can I subtract the value of an array if that value is greater than specific data?

For example:

I have an array of menu's position [0,3,10,5,6,9,2,7,1,4,8,11] I want to subtract all values that are greater than selectedDeletedNumbers and stay in their position.

Example: If I delete 3 and 5. I am using checkbox to delete

And the output should be like this.

[0,8,4,7,2,5,1,3,6,9]

Greater than 3 is subtract by 1, and greater than 5 is subtract by 2 since I selected 2 numbers.

HTML

@foreach ($columns as $key => $column)
    <div class="checkbox checkbox-danger col-xs-6 el{{ $column->Field  }}">
        <input type="checkbox" name="CheckboxDelete[]" id="check{{ $column->Field  }}" data-column="{{ $key }}" value="{{ $column->Field }}">
        <label for="check{{ $column->Field  }}"><b style="color: grey">{{ strtoupper($column->Field) }}</b></label>
    </div>
@endforeach

Here is my code, but it's only when deleted 1, and not in a position as well.

$searchArr = array_search( $selectedDeletedNumbers, $items);
unset($items[$searchArr]);
$numbers = [];
foreach ($items as $item) {
    if ($item > $col[1])
        $numbers[] = $item - 1;  
}

Thanks in advance.

Answer 1

For clarity and brevity, I'll refer to your input data as:

$array = [0, 3, 10, 5, 6, 9, 2, 7, 1, 4, 8, 11];
$deletes = [3, 5];

There is no sorting or preparation required for either of my snippets.

Output for both of the following are:

array (
  0 => 0,
  1 => 8,
  2 => 4,
  3 => 7,
  4 => 2,
  5 => 5,
  6 => 1,
  7 => 3,
  8 => 6,
  9 => 9,
)

Mostly function based approach: (Demo)

foreach (array_diff($array, $deletes) as $value) {
    $result[] = array_reduce(
        $deletes,
        function ($carry, $item) use ($value) {
            return $carry - ($value > $item);  
        },
        $value
    );
}
var_export($result);

*note: ($value > $item) will evaluated as true or false, when used in arithmetic, true = 1 and false = 0.

---

Language construct based approach: (Demo)

foreach ($array as $value) {
    foreach ($deletes as $delete) {
        if ($value == $delete) {
            continue 2;            // goto next value in outer loop without pushing
        }
        if ($value > $delete) {
            --$value;              // decrement value
        }
    }
    $result[] = $value;            // push adjusted value into result array
}
var_export($result);

The advantage in this snippet is that there are zero function calls and minimal variables declared.

Answer 2

One more solution is to optimize the checking of what to delete. This code makes sure the delete list is a 0 based array, so in the example it ensures it's

[ 0 => 3, 1 => 5 ]

Then it sorts it descending, but keeps the key, so

[ 1 => 5, 0 => 3 ]

Then when checking the numbers, if the number is greater than 5, it subtracts the key+1, so 1+1 = 2 (sorry for the basic maths). It can then stop and doesn't have to check any more.

$menu = [0,3,10,5,6,9,2,7,1,4,8,11];
$selectedDeletedNumbers = [3,5];
// In case array is not just 0 based index, can remove if it will be
$selectedDeletedNumbers = array_values($selectedDeletedNumbers);
// Sort so highest first, keep key (this is the offset)
arsort($selectedDeletedNumbers);

foreach ( $menu as $key => $menuItem )  {
    foreach ( $selectedDeletedNumbers as $deleteIndex => $delete )  {
        // Matching, just remove and carry on
        if ( $menuItem == $delete ) {
            unset($menu[$key]);
            break;
        }
        // Greater than item, so deduct index and move on
        if ( $menuItem > $delete )  {
            $menu[$key] -= ($deleteIndex+1);
            break;
        }
    }
}

print_r($menu);

If your selected array might come in any order, you can replace the

$selectedDeletedNumbers = array_values($selectedDeletedNumbers);

line with...

sort($selectedDeletedNumbers);

Answer 3

To delete numbers from array and to subtract a count from the current number in the original array with the number of numbers smaller than it in selectedDeletedNumbers, you can:

• Sort the selectedDeletedNumbers array.
• Iterate over the original array and use binary search to get the count of numbers smaller than the current number in the original array and subtract it later.
• If current number is present in selectedDeletedNumbers, then unset them.

Snippet:

<?php


$arr = [0,3,10,5,6,9,2,7,1,4,8,11];

$selectedDeletedNumbers = [3,5];

sort($selectedDeletedNumbers);

foreach($arr as $index => $val){
    $low = 0;$high = count($selectedDeletedNumbers) - 1;
    $equal_found = false;
    while($low <= $high){
        $mid = intval(($low + $high) / 2);
        if($selectedDeletedNumbers[$mid] > $val){
            $high = $mid - 1;
        }else if($selectedDeletedNumbers[$mid] < $val){
            $low = $mid + 1;
        }else{
            $equal_found = true;
            unset($arr[$index]);
            break;
        }
    }

    if(!$equal_found){
        $arr[$index] -= $low;
    }
}

print_r($arr);

Demo: http://sandbox.onlinephpfunctions.com/code/ca881fce6a27c216f24a1701190940a87132ab1c

This way, the time complexity will be max(O(m log(m)),O(n log(m))) where n is size of original array and m is the size of selectedDeletedNumbers and space complexity is O(1).

If you want to re-index the numbers sequentially, do an $arr = array_values($arr) in the end.

Answer 4

for ($i = 0; $i < count($menuPositions); $i++) {
        for ($j = 0; $j < count($selectedDeletedNumbers); $j++) {
            if ($menuPositions[$i] == $selectedDeletedNumbers[$j]) {
                unset($menuPositions[$i]); // remove the match value from array
                $menuPositions = array_values($menuPositions); // reorganize array keeping only the values are not null
                $i--; //include the new value of $menuPositions[$i] on interation
                break;
            }
            if ($menuPositions[$i] > $selectedDeletedNumbers[$j] ) {
                $menuPositions[$i]--;
            }
        }
    }