Scinder un tableau en N tableaux - PHP
J'ai un tableau de 18 valeurs:
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r');
Je veux diviser ce tableau en 12 tableaux différents, il devrait donc ressembler à ceci:
array(
0 => array('a', 'b'),
1 => array('c', 'd'),
2 => array('e', 'f'),
3 => array('g', 'h'),
4 => array('i', 'j'),
5 => array('k', 'l'),
6 => array('m'),
7 => array('n'),
8 => array('o'),
9 => array('p'),
10 => array('q'),
11 => array('r')
)
Ma fonction ne semble pas fonctionner
function array_split($array, $parts){
return array_chunk($array, ceil(count($array) / $parts));
}
$result = array_split($array, 12);
parce que je reçois 9 tableaux différents au lieu de 12. Il reviendrait
array(
0 => array('a', 'b'),
1 => array('c', 'd'),
2 => array('e', 'f'),
3 => array('g', 'h'),
4 => array('i', 'j'),
5 => array('k', 'l'),
6 => array('m', 'n'),
7 => array('o', 'p'),
8 => array('q', 'r')
)
Comment pourrais-je m'y prendre? Merci.
Cette fonction simple fonctionnerait pour vous:
Utilisation
$array = range("a", "r"); // same as your array
print_r(alternate_chunck($array,12));
Sortie
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
[1] => f
)
[3] => Array
(
[0] => g
[1] => h
)
[4] => Array
(
[0] => i
[1] => j
)
[5] => Array
(
[0] => k
[1] => l
)
[6] => Array
(
[0] => m
)
[7] => Array
(
[0] => n
)
[8] => Array
(
[0] => o
)
[9] => Array
(
[0] => p
)
[10] => Array
(
[0] => q
)
[11] => Array
(
[0] => r
)
)
Mise à jour Ce qui précède pourrait ne pas être utile dans la plupart des cas ... voici un autre type de morceau
$array = range("a", "r"); // same as your array
print_r(fill_chunck($array, 5));
Sortie
Array
(
[0] => Array
(
[0] => a
[1] => b
[2] => c
[3] => d
)
[1] => Array
(
[0] => e
[1] => f
[2] => g
[3] => h
)
[2] => Array
(
[0] => i
[1] => j
[2] => k
[3] => l
)
[3] => Array
(
[0] => m
[1] => n
[2] => o
[3] => p
)
[4] => Array
(
[0] => q
[1] => r
)
)
Cela ferait en sorte que le groupe ne soit à aucun moment composé de plus de 5 éléments, l’autre étant sans limitation.
Fonction utilisée
function alternate_chunck($array, $parts) {
$t = 0;
$result = array();
$max = ceil(count($array) / $parts);
foreach(array_chunk($array, $max) as $v) {
if ($t < $parts) {
$result[] = $v;
} else {
foreach($v as $d) {
$result[] = array($d);
}
}
$t += count($v);
}
return $result;
}
function fill_chunck($array, $parts) {
$t = 0;
$result = array_fill(0, $parts - 1, array());
$max = ceil(count($array) / $parts);
foreach($array as $v) {
count($result[$t]) >= $max and $t ++;
$result[$t][] = $v;
}
return $result;
}
Tu as dit:
J'ai 13 catégories dans la base de données que je souhaite regrouper dans 12 tableaux . S'il y a plus de 12 catégories, s'il y en a, alors Insère les valeurs restantes à partir du premier tableau.
Cela fonctionne, mais quelle devrait être la sortie si vous avez plus d'éléments dans le tableau en entrée?
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm');
function s($array, $am) {
$r = array();
$d = count($array) - $am+1;
foreach ($array as $k => $v) {
if ($k < $d) {
if (!isset($r[0])) {
$r[0] = array($v);
} else {
$r[0] = array_merge($r[0], array($v));
}
} else {
$r[] = array($v);
}
}
return $r;
}
reviendra
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
)
[2] => Array
(
[0] => d
)
[3] => Array
(
[0] => e
)
[4] => Array
(
[0] => f
)
[5] => Array
(
[0] => g
)
[6] => Array
(
[0] => h
)
[7] => Array
(
[0] => i
)
[8] => Array
(
[0] => j
)
[9] => Array
(
[0] => k
)
[10] => Array
(
[0] => l
)
[11] => Array
(
[0] => m
)
)
Vous pouvez utiliser array_chunk et array_merge pour résoudre ce problème:
<?php
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r');
$chunked_arr = array_chunk($array,12);
$j = 0;
for($i = 0; $i < count($chunked_arr[0]); $i++){
if(!($i % 2 == 0)){
$first_combined[$j][$i % 2] = $chunked_arr[0][$i];
$j++;
} else {
$first_combined[$j][$i % 2] = $chunked_arr[0][$i];
}
}
$merged_array = array_merge($first_combined, $chunked_arr[1]);
echo '<pre>';
print_r($merged_array);
?>
Et vous obtiendrez le résultat comme ceci:
Array
(
[0] => Array
(
[0] => a
[1] => b
)
[1] => Array
(
[0] => c
[1] => d
)
[2] => Array
(
[0] => e
[1] => f
)
[3] => Array
(
[0] => g
[1] => h
)
[4] => Array
(
[0] => i
[1] => j
)
[5] => Array
(
[0] => k
[1] => l
)
[6] => m
[7] => n
[8] => o
[9] => p
[10] => q
[11] => r
)
C'est ce que vous voulez exactement.
Compilez cela et voyez si cela vous convient:
<?php
$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm');
$sliceA = 0;
$sliceB = 2;
$final = array(array_slice($array, $sliceA, $sliceB));
for ($i=$sliceB; $i<sizeof($array); $i++)
{
$final[$sliceB-1] = array($array[$i]);
$sliceB++;
}
var_dump($final);
<?php
$array = range('a','r');
$length = array(2=>6,1=>6); // 2=>6 means -- first six elements of new array will have 2 elements each and then, 1=>6 means -- next six elements of new array will have 1 element each
$target = array(); // or use [] in PHP 5.4
foreach($length as $i=>$times) {
while($times>0){
$target[] = array_splice($array, 0, $i);
$times--;
}
}
print_r($target);
?>
Cela le fera pour vous!
Ici, j’ai utilisé ma fonction smallify () pour diviser un tableau de 15 éléments en 3 tableaux de 5 éléments chacun.
<?php
$bigArray = array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15);
echo ("<pre>");
print_r (smallify($bigArray, 3));
echo ("<pre/>");
function smallify($arr, $numberOfSlices){
$sliceLength = sizeof($arr) /$numberOfSlices;
for($i=1; $i<=$numberOfSlices; $i++){
$arr1 = array_chunk($arr, $sliceLength*$i);
return $arr1;
unset($arr1);
}
}
?>
Résultat
Array
(
[0] => Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
[1] => Array
(
[0] => 6
[1] => 7
[2] => 8
[3] => 9
[4] => 10
)
[2] => Array
(
[0] => 11
[1] => 12
[2] => 13
[3] => 14
[4] => 15
)
)
ceil(count($array) / $parts) donnerait 2, donc chaque tableau est rempli de 2 éléments jusqu'à ce qu'il ne vous en reste plus 2. donc le dernier a 1 élément. Cela fonctionnera si vous avez une quantité énorme de données dans le tableau, mais pas autant lorsque vous avez une petite quantité de données.
Ce que vous décrivez n'est pas ce pour quoi array_chunk est fait. Vous devez utiliser array_slice () et calculer vous-même les parties du tableau que vous souhaitez transformer en nouveaux tableaux. (et utilisez une boucle for pour parcourir le tableau d'origine)
Mettre à jour:
Quelques calculs qui pourraient vous aider:
minimum_fill = floor(array_length / nr_buckets)
bigger_buckets_amount = array_length - (minimum_fill / nr_buckets)
Algorithme pour remplir les compartiments: Boucle sur le tableau, remplissez le premier nombre bigger_buckets_amount de compartiments avec (minimum_fill + 1), remplissez le reste des compartiments avec minimum_fill
Permettez-moi d'être le premier à proposer une solution sans boucle basée sur les mathématiques.
La magie dans le calcul consiste à déterminer quelle partie des éléments appartient au premier ensemble d'éléments où toutes les colonnes sont remplies dans chaque ligne par rapport aux éléments appartenant au deuxième ensemble (si cet ensemble devrait même exister), où toutes les colonnes à l'exception de l'extrême droite les colonnes sont remplies.
Laissez-moi dessiner ce dont je parle. Le > marque la division entre les deux tableaux fragmentés.
$size = 9; ------------- $size = 9; -------------
$maxrows = 4; 1 | A , B , C | $maxrow = 3; | A , B , C |
$columns = 3; > |-----------| $columns = 3; 1 | D , E , F |
$fullrows = 1; | D , E | $fullrows = 3; | G , H , I |
2 | F , G | > -------------
| H , I | 2 n/a
---------
$size = 18; --------- $size = 17; -------------------------------------
$maxrows = 12; | A , B | $maxrows = 2; 1 | A , B , C , D , E , F , G , H , I |
$columns = 2; | C , D | $columns = 9; > -------------------------------------
$fullrows = 6; | E , F | $fullrows = 1; 2 | J , K , L , M , N , O , P , Q |
1 | G , H | ---------------------------------
| I , J |
| K , L |
> ---------
| M |
| N |
| O |
2 | P |
| Q |
| R |
-----
Code: ( Démo )
function double_chunk($array, $maxrows) {
$size = sizeof($array);
$columns = ceil($size / $maxrows);
$fullrows = $size - ($columns - 1) * $maxrows;
if ($fullrows == $maxrows) {
return array_chunk($array, $fullrows); // all columns have full rows, don't splice
}
return array_merge(
array_chunk(
array_splice($array, 0, $columns * $fullrows), // extract first set to chunk
$columns
),
array_chunk($array, $columns - 1) // chunk the leftovers
);
}
var_export(double_chunk(range('a', 'i'), 3));
Si les appels array_splice() itérés ne vous dérangent pas, ceci est plus bref et peut-être plus facile à suivre (... peut-être pas):
Code: ( Démo )
function custom_chunk($array, $maxrows) {
$size = sizeof($array);
$columns = ceil($size / $maxrows);
$fullrows = $size - ($columns - 1) * $maxrows;
for ($i = 0; $i < $maxrows; ++$i) {
$result[] = array_splice($array, 0, ($i < $fullrows ? $columns : $columns - 1));
}
return $result;
}
var_export(custom_chunk(range('a', 'r'), 12));
Je crois que le problème est que vous utilisez une taille de 2 lorsque vous utilisez array_chunk. Cela garantit que chaque nouveau tableau créé contient deux éléments, si possible. La fonction sera alors à court de variables à mettre dans les nouveaux tableaux d’ici 10. Vous trouverez le manuel sur la fonction ici http://php.net/manual/fr/function.array- chunk.php J'espère que cela vous aidera