Push static value into another array at every nth position

Question

I have an array:

$names = [
    "Ayush" , "Vaibhav", "Shivam",
    "Hacker", "Topper", "ABCD",
    "NameR", "Tammi", "Colgate",
    "Britney", "Bra", "Kisser"
];

And I have another variable

$addthis = "ADDTHIS";

How to make an array from these two so that after every three items in $names, the value of $addthis is added. So, I want this array as result from these two.

$result = [
    "Ayush", "Vaibhav", "Shivam", "ADDTHIS",
    "Hacker", "Topper", "ABCD", "ADDTHIS",
    "NameR", "Tammi", "Colgate", "ADDTHIS",
    "Britney", "Bra", "Kisser"
];

zerkms · Accepted Answer · 2012-12-16T12:29:50.823

4

"Oneliner", just for fun:

$new = array_reduce(
    array_map(
        function($i) use($addthis) { return count($i) == 3 ? array_merge($i, array($addthis)) : $i; },
        array_chunk($names, 3)
    ),
    function($r, $i) { return array_merge($r, $i); },
    array()
);

edited Dec 16 '12 at 12:29

answered Dec 16 '12 at 12:00

zerkms

249,484
69
436
539

iRaS · Answer 2 · 2018-10-15T09:27:39.793

2

Maybe an easier to understand solution:

// the parameters
$names = array( "Ayush" , "Vaibhav", "Shivam", "Hacker", "Topper",
            "ABCD",  "NameR", "Tammi", "Colgate", "Britney",
            "Bra", "Kisser");
$addThis = 'ADDTHIS';
$every = 3;

// how often we need to add this
$count = ceil(count($names) / $every) - 1;
for ($i = 0; $i < $count; $i++) {
    array_splice($names, $i * ($every + 1) + $every, 0, $addThis);
}

array_splice is exactly for modifying arrays (removing or adding items), preserves existing keys and is not doing any other operation on the array.

While other answers are for sure valid as well this should be the fastest and cleanest solution.

edited Oct 15 '18 at 09:27

answered Oct 15 '18 at 06:26

iRaS

1,958
1
16
29

Similar techniques ([one more rigid](https://stackoverflow.com/a/12520664/2943403), [one more dynamic](https://stackoverflow.com/a/73568281/2943403)) can be found at [Insert elements from one array (one-at-a-time) after every second element of another array (un-even zippering)](https://stackoverflow.com/q/12520272/2943403) – mickmackusa Sep 01 '22 at 23:20
An important point of distinction: The above answer [does not insert a new element AFTER every 3 elements](https://3v4l.org/X0drs), if it did, there would be another inserted element after the 12th/last element. It doesn't mean that it is wrong, in fact, it provides the asker's desired output. This comes down to ambiguity in the plain English expression of the task. – mickmackusa Sep 01 '22 at 23:43

score 1 · Answer 3 · answered Dec 16 '12 at 12:06

1

Another oneliner ;)

$result = call_user_func_array(
    'array_merge', array_map(function($v) use ($addthis) {
        return $v + [4 => $addthis];
    }, array_chunk($names, 3))
); array_pop($result);

Demo

answered Dec 16 '12 at 12:06

hakre

193,403
52
435
836

Wow, I see the 5.4 arrays syntax for the first time irl. PS: good catch on `array_merge` – zerkms Dec 16 '12 at 12:07
Ha, not "oneliner" anymore! ;-) – zerkms Dec 16 '12 at 12:08
well could wrap in array_slice or similar. I mean it's only for the fun after I saw yours ;) array_chunk came to mind at first, too. – hakre Dec 16 '12 at 12:09
Or use `[0]` for the whole expression may be? – zerkms Dec 16 '12 at 12:10
@zerkms: Nope, last element from the merged result array needs to be removed. – hakre Dec 16 '12 at 12:21
btw, our solutions fail in the tail and if there are < 3 elements in the source array – zerkms Dec 16 '12 at 12:28
1

yeah, popididu :D. what about a `array_chunk_implode` function? – hakre Dec 16 '12 at 12:34
This answer is missing its educational explanation. "Failing in the tail" -- if there are less than 4 elements, [no new element is inserted](https://3v4l.org/7rmCQ). – mickmackusa Sep 01 '22 at 23:50

mickmackusa · Answer 4 · 2022-09-02T00:51:50.320

I concur with @iRaS's answer that it will be more direct/efficient to make iterated element insertions in a loop. I interpret the question as requiring an element to be inserted after every 10 elements -- in other words, if the array has exactly 20 elements, then 2 elements should be inserted. One after the 10nth element, then one after the 20th element.

By iterating from the back of the array, you can avoid keeping track of previously injected elements (which effectively push out the desired position of subsequently injected elements). I didn't use this approach while crafting a dynamic approach for a similar question.

Use a modulus-based calculation to determine the last insertion position, then decrement the position variable by the $every variable.

To test the accuracy of my snippet, just add and remove elements in the input array.

Code: (Demo)

$names = [
    "Ayush" , "Vaibhav", "Shivam",
    "Hacker", "Topper", "ABCD",
    "NameR", "Tammi", "Colgate",
    "Britney"//, "Bra"//, "Kisser"
];
$addThis = 'ADDTHIS';
$every = 3;

for (
    $count = count($names), $pos = $count - ($count % $every);
    $pos > 0;
    $pos -= $every
) {
    array_splice($names, $pos, 0, $addThis);
}
var_export($names);

Output:

array (
  0 => 'Ayush',
  1 => 'Vaibhav',
  2 => 'Shivam',
  3 => 'ADDTHIS',
  4 => 'Hacker',
  5 => 'Topper',
  6 => 'ABCD',
  7 => 'ADDTHIS',
  8 => 'NameR',
  9 => 'Tammi',
  10 => 'Colgate',
  11 => 'ADDTHIS',
  12 => 'Britney',
)

P.S. If you don't want to add the extra tail element (the array shouldn't end with an "ADDTHIS" element), then use this code as the first parameter of the for():

$count = count($names), $pos = $count - (($count % $every) ?: $every);

score 0 · Answer 5 · answered May 13 '20 at 22:52

I have the ANSWER for anyone curious, I've just done a function that randomizes an array.

function randomize($array){
    $randomized=array(); //start a new array
    foreach ($array as $key=>$val){ ///loop thru the array we randomize
        if($key % 2 == 0){   ////if the key is even
            array_push($randomized,$val);///push to back
        }else{ ////if the key is odd
            array_unshift($randomized,$val); ///push to front
        }
    }
    return $randomized;
}///randomize

Basically what we are doing is creating a new randomized array, looping through the array we pass, tracking an interator and as we loop thru if the key is even we send that array value to the back, if its odd we send that to the front.

This late answer [does not appear to work as required](https://3v4l.org/OfpE1). — mickmackusa, Sep 02 '22 at 00:00

score -1 · Answer 6 · answered Dec 16 '12 at 11:57

-1

$result = array();
$cnt = 0;
foreach ($names AS $val) {
    $result[] = $val;
    if ($cnt >=3) {
        $result[] = $addthis;
        $cnt = 0;
    }
    $cnt++;
}

answered Dec 16 '12 at 11:57

newman

2,689
15
23

This unexplained answer [does not provide the desired result](https://3v4l.org/9ASpg). – mickmackusa Sep 02 '22 at 00:40

score -1 · Answer 7 · answered Dec 16 '12 at 11:58

-1

Loop through and use modulo for checking for 3. element: After that use splice to insert an element between two element

    foreach($result as $k=>$value){
 if(($k+1)%3==0){
   array_splice($arrayvariable, $k+1, 0, "ADDTHIS");
 }
}

answered Dec 16 '12 at 11:58

Dávid Szabó

2,235
2
14
26

This answer [does not provide the desired result](https://3v4l.org/kPdhu) because it doesn't account for previously inserted elements – mickmackusa Sep 02 '22 at 00:43

Sherif · Answer 8 · 2012-12-16T12:27:55.377

One thing you do not want to do is assume that every key in your array is numeric and that it accurately represents the offset of each element. This is wrong, because PHP arrays are not like traditional arrays. The array key is not the offset of the element (i.e. it does not determine the order of elements) and it does not have to be a number.

Unfortunately, PHP arrays are ordered hashmaps, not traditional arrays, so the only way to insert a new element in the middle of the map is to create a brand new map.

You can do this by using PHP's array_chunk() function, which will create a new array of elements, each containing up to a designated number of elements, form your input array. Thus we create an array of arrays or chunks of elements. This way you can iterate over the chunks and append them to a new array, getting your desired effect.

$names = array( "Ayush" , "Vaibhav", "Shivam", "Hacker", "Topper",
                "ABCD",  "NameR", "Tammi", "Colgate", "Britney",
                "Bra", "Kisser");

$addthis = "ADDTHIS";

$result = array();

foreach (array_chunk($names, 3) as $chunk) { // iterate over each chunk
    foreach ($chunk as $element) {
        $result[] = $element;
    }
    // Now push your extra element at the end of the 3 elements' set
    $result[] = $addthis;
}

If you wanted to preserve keys as well you can do this....

$names = array( "Ayush" , "Vaibhav", "Shivam", "Hacker", "Topper",
                "ABCD",  "NameR", "Tammi", "Colgate", "Britney",
                "Bra", "Kisser");

$addthis = "ADDTHIS";

$result = array();

foreach (array_chunk($names, 3, true) as $chunk) { // iterate over each chunk
    foreach ($chunk as $key => $element) {
        $result[$key] = $element;
    }
    // Now push your extra element at the end of the 3 elements' set
    $result[] = $addthis;
}

This perserves both order of the elements as well as keys of each element. However, if you don't care about the keys you can simply use the first example. Just be careful that numeric keys in order will cause you a problem with the second approach since the appended element in this example is assuming the next available numeric key (thus overwritten on the next iteration).

in the question there was no word about assoc array and php also has indexed arrays. on the other hand: this would create a new array and array_chunks that are bascially wasted memory - and my version will also preserve the existing keys. — iRaS, Oct 15 '18 at 09:21
This answer [does not provide the desired output](https://3v4l.org/QdqvP). — mickmackusa, Sep 02 '22 at 00:46

Push static value into another array at every nth position

8 Answers8

Linked

Related