¿Repite la matriz hasta cierta longitud?

Question

Estoy teniendo una matriz, por ejemplo, con 4 elementos array("a", "b", "c", d"); ¿cuál es la forma más rápida de repetir esta matriz para crear una nueva matriz con una cierta longitud, por ejemplo, 71 elementos?

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

probado y funciona.

Usted puede probar por sí mismo mediante la adición de esto:

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

Answer 4

Si tiene PHP 5.3 disponible, también puede probar esto:

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

Una solución sencilla utilizando each() y reset() y el puntero interno de la matriz:

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

solución utilizando 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'))); 

Los piratas informáticos SPL reales podría haber dejado caer el if (!$length--) break; y en su lugar se utiliza un iterador límite: new LimitIterator(new InfiniteIterator(new ArrayIterator($values)), 0, $length), pero pensé que para ser una exageración ...

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

con el fin de unirse a este club:

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

Pediste el más rápido así que hice un punto de referencia (Fuente: 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 es el más rápido pero sólo funciona para los valores de cadena con caracteres individuales (o la misma longitud si se utiliza segundo parámetro de str_split)

Answer 10

Creo que el usuario2469998 era el más cercano pero no tan agradable.

Para mi ejemplo, utilizo la tubería para implosionar y la función str_repeat para construir una cadena que cumpla con la longitud, explotarla y cortar la grasa.

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

$length = 6; 

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

Muchas formas de lograr esto, pero pensé en compartir el mío. La única restricción es que debe usar un personaje para implosionar y explotar en el que no forma parte de los elementos de la matriz o el explosor no funcionará correctamente.

:)