Powtórz tablicę do określonej długości?

Question

Mam tablicę na przykład z 4 elementami array("a", "b", "c", d"); jaki jest najszybszy sposób na powtórzenie tej tablicy, aby utworzyć nową tablicę o określonej długości, np. 71 elementów?

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

Przetestowane i działa.

można przetestować samemu, dodając w ten sposób:

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

Answer 4

Jeśli masz PHP 5.3 są dostępne, można również spróbować tego:

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

Prostym rozwiązaniem przy użyciu each() i reset() i wewnętrzny wskaźnik tablicy:

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

Rozwiązanie użyciu SPL 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'))); 

Prawdziwi hakerzy SPL mogło upuszczony if (!$length--) break; a zamiast tego użył iterator graniczną: new LimitIterator(new InfiniteIterator(new ArrayIterator($values)), 0, $length), ale myślałem, że będzie przesadą ...

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

Aby dołączyć do tego klubu:

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

Pytałeś o najszybszym tak zrobiłem benchmark (źródło: 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 jest najszybszy, ale to działa tylko dla wartości ciągów z pojedynczych znaków (lub taką samą długość, jeśli używasz drugi parametr str_split).

Answer 10

Myślę, że użytkownik user2469998 był najbliżej, ale po prostu niezbyt miły.

Dla mojego przykładu używam rurki do implodowania, a funkcja str_repeat do budowy ciągów, które odpowiadają długości, rozbijają je z powrotem i przycinają tłuszcz.

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

$length = 6; 

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

Wiele sposobów na osiągnięcie tego celu, ale pomyślałem, że podzielę się swoimi. Jedynym ograniczeniem jest to, że musisz użyć znaku, aby implodować i eksplodować, który nie jest częścią elementów tablicy, lub eksplozor nie będzie działał poprawnie.

:)