Chia một mảng vào N Mảng - PHP

Question

Tôi có một mảng của 18 giá trị:

$array = array('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r'); 

Tôi muốn chia mảng này thành 12 mảng khác nhau vì vậy nó sẽ giống như thế này:

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

Chức năng của tôi dường như không hoạt động

function array_split($array, $parts){ 
    return array_chunk($array, ceil(count($array)/$parts)); 
} 

$result = array_split($array, 12); 

vì tôi nhận được 9 mảng khác nhau thay vì 12. Nó sẽ trả về

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

Tôi làm cách nào để thực hiện việc này? Cảm ơn.

Answer 1

chức năng đơn giản này sẽ làm việc cho bạn:

Cách sử dụng

$array = range("a", "r"); // same as your array 
print_r(alternate_chunck($array,12)); 

Output

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 
     ) 

) 

Cập nhật Trên đây có thể không phải hữu ích cho hầu hết các trường hợp ... đây là một loại đoạn

$array = range("a", "r"); // same as your array 
print_r(fill_chunck($array, 5)); 

Output

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 
     ) 

) 

Điều này sẽ đảm bảo rằng các nhóm không lúc nào là hơn 5 yếu tố mà một trong những khác không có giới hạn

Chức năng sử dụng

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

Answer 2

ceil(count($array)/$parts) sẽ cung cấp 2, vì vậy mỗi mảng được lấp đầy với 2 mục cho đến khi bạn không còn 2 mục. do đó người cuối cùng có 1 mục. điều này sẽ làm việc khi bạn có một lượng lớn dữ liệu trong mảng, nhưng không nhiều khi bạn có một lượng nhỏ dữ liệu.

Answer 3

Điều bạn mô tả không phải là những gì array_chunk được tạo ra. Bạn nên sử dụng array_slice() và tự tính toán phần nào của mảng mà bạn muốn kết thúc dưới dạng mảng mới. (Và sử dụng một vòng lặp for để lặp qua mảng ban đầu của bạn)

Cập nhật:

Một số tính toán có thể giúp bạn:

minimum_fill = floor(array_length/nr_buckets) 
bigger_buckets_amount = array_length - (minimum_fill/nr_buckets) 

Thuật toán để điền vào xô: Vòng qua mảng, điền vào đầu tiên bigger_buckets_amount lượng xô với (minimum_fill + 1), điền vào phần còn lại của thùng với minimum_fill

Answer 4

Bạn nói:

Tôi có 13 danh mục trong DB mà tôi muốn nhóm chúng thành 12 mảng. Nếu có hơn 12 danh mục, trong đó có chèn các giá trị còn lại bắt đầu từ mảng đầu tiên.

Công trình này, nhưng đầu ra sẽ ra sao nếu bạn có nhiều phần tử hơn trong mảng đầu vào?

$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; 
} 

sẽ trở lại

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 
     ) 

) 

Answer 5

Biên dịch đó và xem nếu nó làm cho bạn:

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

Answer 6

Bạn có thể sử dụng array_chunk và array_merge cho vấn đề này:

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

Và bạn sẽ nhận được kết quả như sau:

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 
) 

Đây chính xác là những gì bạn muốn.

Live Demo Here>>

Answer 7

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

Answer 8

Tôi tin rằng vấn đề là bạn đang sử dụng một kích thước của 2 khi sử dụng array_chunk. Điều này đảm bảo rằng mỗi mảng mới được tạo có hai mục trong đó nếu có thể. Điều này làm cho chức năng chạy ra khỏi các biến để đưa vào mảng mới theo thời gian bạn nhận được đến 10. Bạn có thể tìm hướng dẫn sử dụng chức năng tại đây http://php.net/manual/en/function.array-chunk.php Hy vọng điều này sẽ giúp

Answer 9

Điều này sẽ làm điều đó cho bạn!
Ở đây, tôi đã sử dụng hàm smallify() để chia mảng 15 thành phần thành 3 mảng gồm 5 phần tử.

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

    } 

} 
?> 

quả

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 
    ) 

)