Répéter le tableau jusqu'à une certaine longueur?

Question

J'ai un tableau par exemple avec 4 éléments array("a", "b", "c", d"); quelle est la manière la plus rapide de répéter ce tableau pour créer un nouveau tableau avec une certaine longueur, par exemple 71 éléments?

Answer 1

// the variables 
$array = array("a", "b", "c", "d"); 
$desiredLength = 71; 
$newArray = array(); 
// create a new array with AT LEAST the desired number of elements by joining the array at the end of the new array 
while(count($newArray) <= $desiredLength){ 
    $newArray = array_merge($newArray, $array); 
} 
// reduce the new array to the desired length (as there might be too many elements in the new array 
$array = array_slice($newArray, 0, $desiredLength); 

Answer 2

$newarray = array(); 
$i = 0; 
$oldarrayvalues = array_values($oldarray); 
$oldarraysize = count($oldarrayvalues); 
if ($oldarraysize) { 
    while (count($newarray) < DESIRED_ARRAY_SIZE) { 
     $newarray[] = $oldarrayvalues[$i]; 
     $i++; 
     $i %= $oldarraysize; 
    } 
} 

Answer 3

<?php 
$array = array('a', 'b', 'c', 'd'); 
$end = 71; 

$new_array = array(); 

while(count($new_array) <= $end) 
{ 
    foreach($array as $key => $value) 
    { 
     $new_array[] = $value; 
    } 
} 

$new_array = array_slice($new_array, 0, $end); 

testé et fonctionne.

Vous pouvez tester par vous-même en ajoutant ceci:

echo '<pre>'; 
print_r($new_array); 
echo '</pre>'; 

Answer 4

Si vous avez PHP 5.3 disponible, vous pouvez aussi essayer ceci:

function fill(array $initalArray, $toCount) { 
    $initialArrayCount = count($initalArray); 

    $fillUp = function(array $filledUpArray, $missingCount) 
        use(&$fillUp, $initalArray, $initialArrayCount, $toCount) 
    { 
     if($missingCount <= 0) return array_slice($filledUpArray, 0, $toCount); 
     return $fillUp(array_merge($filledUpArray, $initalArray), $missingCount - $initialArrayCount); 
    }; 

    return $fillUp($initalArray, $toCount - $initialArrayCount); 
} 


$theArray = array("a", "b", "c", "d"); 
$toLength = 71; 

$filledArray = fill($theArray, $toLength); 

print_r($filledArray); 

Answer 5

$array = array("a", "b", "c", "d"); 
$merge = array(); 
$desiredLength = 71; 
while(2 * count($array) <= $desiredLength){ 
    $array = array_merge($array, $array); 
} 
if($desiredLength > count($array)) 
    $merge = array_slice($array, 0, $desiredLength - count($array)); 
$array = array_merge($array, $merge); 
$array = array_slice($array, 0, $desiredLength); 
print_r($array); 

Answer 6

Une solution simple à l'aide each() et reset() et le pointeur interne du tableau:

<?php 
$array = array('a', 'b', 'c', 'd'); 
$length = 71; 
$result = array(); 
while(count($result) < $length) 
{ 
    $current = each($array); 
    if($current == false) 
    { 
    reset($array); 
    continue; 
    } 
    $result[] = $current[1]; 
} 

echo count($result); // Output: 71 

Answer 7

Solution SPL en utilisant InfiniteIterator:

<?php 
function fillArray1($length, $values) { 
    foreach (new InfiniteIterator(new ArrayIterator($values)) as $element) { 
     if (!$length--) return $result; 
     $result[] = $element; 
    } 
    return $result; 
} 

var_dump(fillArray(71, array('a', 'b', 'c', 'd'))); 

Les vrais pirates SPL aurait laissé tomber le if (!$length--) break; et plutôt utilisé un itérateur limite: new LimitIterator(new InfiniteIterator(new ArrayIterator($values)), 0, $length), mais je pensais que pour être surpuissant ...

Answer 8

$arr = array("a", "b", "c", "d"); 
$len = 71; 
$a = array(); 
$a = str_split(substr(str_repeat(join($arr), ceil($len/count($arr))), 0, $len)); 
var_export($a); 

Answer 9

pour rejoindre ce club:

$result = call_user_func_array('array_merge', array_fill(0, ceil($size/count($array)), $array)); 
while(count($result) > $size) array_pop($result); 

Vous avez demandé le plus rapide, donc je l'ai fait référence (Source: http://pastebin.com/G5w7QJPU)

Kau-Boy: 5.40128803253 
Frxstrem: 5.00970411301 
NikiC: 4.12150001526 
user2469998: 0.561513900757 
Alexander: 1.92847204208 
Hammerite: 2.17130494118 
Max: 12.9516701698 
Evert: 1.9378361702 
Christoph: 1.6862449646 
Test took 35.7696909904s 

user2469998 est le plus rapide, mais il ne fonctionne que pour les valeurs de chaîne avec les caractères simples (ou la même longueur si vous utilisez second paramètre de str_split).

Answer 10

Je pense que l'utilisateur 2469998 était le plus proche mais pas si gentil. Pour mon exemple, j'utilise pipe pour imploser et la fonction str_repeat pour construire une chaîne qui rencontre la longueur, l'éclater et séparer la graisse.

$list = array('a','b','c','d'); 

$length = 6; 

$result = array_slice(explode('|', str_repeat(implode('|', $list).'|',ceil($length/count($list)))), 0, $length); 

De nombreuses façons d'y parvenir, mais pensé que je partagerais le mien. La seule restriction est que vous devez utiliser un caractère pour imploser et exploser sur lequel ne fait pas partie des éléments du tableau ou l'exploseur ne fonctionnera pas correctement.

:)