Array auf eine bestimmte Länge wiederholen?

Question

Ich habe ein Array zum Beispiel mit 4 Elementen array("a", "b", "c", d"); Was ist der schnellste Weg, um dieses Array zu wiederholen, um ein neues Array mit einer bestimmten Länge, z. B. 71 Elemente zu erstellen?

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); 

getestet und funktioniert.

Sie können selbst testen dies durch Hinzufügen:

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

Answer 4

Wenn Sie PHP 5.3 zur Verfügung haben, können Sie auch versuchen, diese:

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

Eine einfache Lösung mit each() und reset() und der interne Zeiger des Arrays:

<?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

Lösung SPL mit 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'))); 

Die wirklichen SPL Hacker könnte die if (!$length--) break; fallen gelassen haben und stattdessen eine Grenze Iterator verwendet: new LimitIterator(new InfiniteIterator(new ArrayIterator($values)), 0, $length), aber ich dachte, dass sein viel des Guten ...

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

um diesem Club beizutreten:

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

Sie bat um die schnellsten, so habe ich eine Benchmark (Quelle: 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 ist die schnellste, aber es funktioniert nur für String-Werte mit einzelnen Zeichen (oder die gleiche Länge, wenn Sie zweiten Parameter von str_split verwenden).

Answer 10

Ich denke, dass user2469998 am nächsten war, aber einfach nicht so nett.

Für mein Beispiel verwende ich Rohr zu implodieren und die str_repeat Funktion, um eine Schnur zu bauen, die die Länge trifft, es auseinander auseinander bricht und das Fett trimmt.

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

$length = 6; 

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

Viele Möglichkeiten, dies zu erreichen, dachte aber, ich würde meine teilen. Die einzige Einschränkung besteht darin, dass Sie ein Zeichen verwenden müssen, das implodiert und explodiert, das nicht Teil der Array-Elemente ist, oder der Exploder wird nicht ordnungsgemäß funktionieren.

:)