Самый быстрый способ реструктуризации массива?
У меня есть массив, который может содержать несколько элементов, например:
Item 1
Item 2
Item 3
Item 4
Item 5
Item 6
etc
Мне нужен самый быстрый способ реструктурировать этот массив, чтобы он имел не более X элементов. Поэтому, если я говорю, что X равно 3, результирующий массив должен быть:
Item 1 , Item 2
Item 3, Item 4
Item 5, Item 6
etc
или если у него есть 7 элементов, это будет:
Item 1 , Item 2, Item 3,
Item 4, Item 5,
Item 6, Item 7
Какой самый простой способ сделать это?
Я начал с этого, но кажется, что действительно должен быть более простой способ:
foreach ($addressParts as $part)
{
if (empty($part)) continue;
if (empty($addressLines[$count])) $addressLines[$count] = '';
$addressLines[$count] .= $part;
$count++;
if ($count > 2) $count = 0;
}
Кроме того, это не сработает, потому что вы получите следующее:
item 1, item 4, item 7
item 2, item 5
item 3, item 6
... что неправильно. Любые мысли?
ОБНОВЛЕНИЕ
Если я начинаю с:
Array
(
[0] => item 1
[1] => item 2
[2] => item 3
[3] => item 4
[4] => item 5
[5] => item 6
[6] => item 7
)
Я хочу закончить:
Array
(
[0] => item 1, item 2, item 3
[1] => item 4, item 5
[2] => item 6, item 7
)
Имеют смысл?
Ответы
Ответ 1
Эта функция объединяет элементы в новый массив в соответствии с вашим примером. Он обрабатывает любое количество элементов ввода.
function ReduceArray($input, $length) {
$frac = $length / count($input);
$frac = $frac + 0.0001; // Offset for float calculations
$index = 0.0;
// Copy the elements, rolling over on $index
$temp = array();
foreach ($input as $part) {
$i= floor($index);
if (!isset($temp[$i])) {
$temp[$i] = array($part);
} else {
$temp[$i][] = $part;
}
$index += $frac;
}
// Combine the sub arrays
$output = array();
foreach ($temp as $line) {
$output[] = implode(', ', $line);
}
return $output;
}
$input = array('Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5', 'Item 6', 'Item 7');
$output = ReduceArray($input, 3);
print_r($output);
Выход
Array
(
[0] => Item 1, Item 2, Item 3
[1] => Item 4, Item 5
[2] => Item 6, Item 7
)
Изменить "фиксированный" выход в соответствии с данным выходом.
Редактировать См. комментарий для девяти элементов, проверенных на 12 элементов. Спасибо, секту
Ответ 2
Для каждой группы вычисляйте смещение первого элемента и длины группы, скопируйте этот срез из входного массива.
function array_group_elements($array, $groups) {
$result = array();
$count = count($array);
// minimum in each group
$limit = floor($count / $groups);
// balance, modulo
$overhead = $count % $groups;
// for each group
for ($i = 0; $i < $groups; ++$i) {
// group offset, add 1 for each group that got a balance element
$offset = ($i * $limit) + ($i < $overhead ? $i : $overhead);
// length, add 1 if it is a group with balance element
$length = $limit + ($i < $overhead ? 1 : 0);
// copy slice from original array
$result[] = array_slice($array, $offset, $length);
}
return $result;
}
$input = array('Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5', 'Item 6', 'Item 7');
$grouped = array_group_elements($input, 3);
var_dump(
array_map(
function($group) {
return implode(', ', $group);
},
$grouped
)
);
Вывод:
array(3) {
[0]=>
string(22) "Item 1, Item 2, Item 3"
[1]=>
string(14) "Item 4, Item 5"
[2]=>
string(14) "Item 6, Item 7"
}
Функция array_group_elements() выполняет цикл над $группами (3 раза), а не $array (7 раз).
Ответ 3
Для каждой группы вам необходимо вычислить максимальное количество элементов, которые будут вписываться в каждый сегмент, поэтому я использовал ceil(); функция всегда округляется.
Input:
Array
(
[0] => item1
[1] => item2
[2] => item3
[3] => item4
[4] => item5
[5] => item6
[6] => item7
)
Функции:
function segment_array($array, $segment = '3'){
// Count the items
$count = count($array);
// Create an array item for each segment
for($i=0;$i<$segment;$i++){
$offset += ($count - ($count - $chunk));
$chunk = ceil(($count - $offset)/($segment - $i));
$set[$i] = array_slice($array, $offset, $chunk);
$new_array[] = implode(', ', $set[$i]);
}
return($new_array);
}
$segmented = segment_array($array, '3');
Вывод:
Array
(
[0] => item1, item2, item3
[1] => item4, item5
[2] => item6, item7
)
Ответ 4
У меня есть две функции с разными подходами.
function restructureArray1($array, $x)
{
$size = sizeof($array);
if ($size < $x)
return array_chunk($array, 1) + array_fill(0, $x, array());
// chunk by 1 element and add missing empty elements
$big_row_length = (int) ($size / $x) + 1;
$big_rows_chunk = array_splice($array, 0, $size % $x * $big_row_length);
// $big_rows_chunk contains items with big rows
// $array now contains items with small rows
return array_merge(array_chunk($big_rows_chunk, $big_row_length), array_chunk($array, $big_row_length - 1));
// chunk and merge
}
function restructureArray2($array, $x)
{
$size = sizeof($array);
$small_row_length = (int) ($size / $x);
$big_row_count = $size % $x;
for ($i = 0; $i < $x; ++$i)
{
$length = $small_row_length + (int) ($i < $big_row_count); // type juggling
$return [] = array_splice($array, 0, $length);
// $return[] contains one row
// $array now contains rest of array
}
return $return;
}
Чтобы получить результат с массивом строк, вам нужно просто array_map it.
$x = 3;
$size = 7;
$array = range(1, $size);
$result1 = restructureArray1($array, $x);
$result2 = restructureArray2($array, $x);
var_dump(array_map(function($array)
{ return implode(', ', $array); }, $result2));
Демо
Относительные ссылки на документацию: array_splice, array_chunk, array_merge
P.S. Самое короткое решение
function restructureArray3($array, $x)
{
while($x)
$return [] = array_splice($array, 0, ceil(sizeof($array) / $x--));
return $return;
}
Демо
Ответ 5
<?php
$source_array = array(
'item 1',
'item 2',
'item 3',
'item 4',
'item 5',
'item 6',
'item 7',
'item 8',
'item 9',
'item 10',
);
$k = 4;
// allocating cells
$allocated_cells_sizes = array();
$ik = 0;
foreach ($source_array as $value){
if (! isset($allocated_cells_sizes[$ik])) $allocated_cells_sizes[$ik] = 0;
$allocated_cells_sizes[$ik] ++;
if (++$ik >= $k) $ik = 0;
}
// filling result array
$result = array();
foreach ($allocated_cells_sizes as $cells_sizes){
$result[] = implode(', ', array_slice($source_array, 0, $cells_sizes));
$source_array = array_slice($source_array, $cells_sizes, null);
}
print_r($result);
/**
* Output
* Array
(
[0] => item 1, item 2, item 3
[1] => item 4, item 5, item 6
[2] => item 7, item 8
[3] => item 9, item 10
)
*/
Ответ 6
работает для любого количества элементов. и изменить любое количество столбцов, просто измените значение $x.
<?php
$arr = array('Item 1','Item 2','Item 3','Item 4','Item 5','Item 6', 'Item 7');
$x = 3;
$newArr = array();
$j = 0;
foreach($arr as $key=>$val){
if($j == $x){
$j = 0;
}
$newArr[$j][] = $val;
$j++;
}
foreach($newArr as $key=>$val){
$tempVal = implode(',', $val);
$newArr[$key] = $tempVal;
}
print_r($newArr);
?>
Ответ 7
Я знаю, что там много ответов, но почему-то все они теряют array_chunk() функцию правильного использования для этого случая. В сочетании с правильным вычислением он может делать материал в 2-3 строках:
$data = range(1,20);
$limit = 6;
$point = count($data)-count($data)%$limit;
$result = array_chunk(array_slice($data, 0, $point), $point/$limit);
$result[$limit-1] = array_merge($result[$limit-1], array_slice($data, $point));
//var_dump($result);
-but, пожалуйста, обратите внимание, что в случае, когда ваш массив будет разделен, все его элементы также станут массивами. Я не думаю, что отличная идея сделать элементы результатов не-массивами, если они содержат только один элемент (например, если $limit равно 6, а массив имеет 7 элементов, только последний элемент будет содержать два элемента - и, следовательно, другие 5 будут массивы, содержащие один элемент) - но если это имеет значение, просто добавьте это:
$result = array_map(function($item)
{
return count($item)>1?$item:$item[0];
}, $result);
Также обновите. Там нет явного ограничения на элемент, который должен содержать "хвост". И в моем случае это будет последний элемент. Но если это действительно имеет значение, просто используйте начало массива как хвост, как это:
$point = count($data)-count($data)%$limit;
$result = array_chunk(array_slice($data, -$point), $point/$limit);
$result[0] = array_merge(array_slice($data, 0, count($data)-$point), $result[0]);
Ответ 8
Я придумал следующий алгоритм, который поддерживает правильное количество элементов в каждой строке; на каждой итерации мы округляем разделение количества оставшихся строк и остальных элементов:
$a = range(1,7);
$len = count($a);
$res = array();
$max = 3;
$i = 0;
while ($i < $len) {
// divide the remaining number of items by the maximum rows allowed
// this gives the width for the current row
$width = ceil(($len - $i) / $max);
$res[] = join(', ', array_slice($a, $i, $width));
// adjust pointer and reduce the maximum
$i += $width;
--$max;
}
print_r($res);
Демо
Ответ 9
Извините, это должен быть комментарий, но я не могу делать комментарии, возможно, из-за моей репутации...
Когда у вас есть массив с 7 элементами, знаете ли вы, что вы разделите массив на 3 или вам нужно найти делитель?
РЕДАКТИРОВАТЬ 1
Что-то вроде этого?:
$formatedAddress = array();
$divisor = 3;
$key = 0;
$counter =1;
foreach ($addressParts as $part)
{
if(!empty($part){
$formattedAddress[$key] = $part;
if($counter != $divisor){
$counter++;
}else{
$counter = 1;
$key++;
}
}
}
ИЗМЕНИТЬ 2:
Я обнаружил некоторые ошибки:
$formatedAddress = array();
$divisor = 3;
$key = 0;
$counter =1;
foreach ($addressParts as $part)
{
if(!empty($part)){
$formatedAddress[$key][] = $part;
if($counter != $divisor){
$counter++;
}else{
$counter = 1;
$key++;
}
}
}
Ответ 10
$source_array = array(
'item 1',
'item 2',
'item 3',
'item 4',
'item 5',
'item 6',
'item 7',
'item 8',
'item 9',
'item 10',
);
function reduce_array($input, $first_count = 3, $count = 2)
{
$array_slice = array(array_slice($input, 0, $first_count));
$array_chunk = array_chunk(array_slice($input, $first_count), $count);
return array_merge($array_slice, $array_chunk);
}
$reduce_array = reduce_array($source_array);
var_dump($reduce_array);
foreach($reduce_array as $array)
{
var_dump(implode(',', $array));
}
Output:
array(5) {
[0]=>
array(3) {
[0]=>
string(6) "item 1"
[1]=>
string(6) "item 2"
[2]=>
string(6) "item 3"
}
[1]=>
array(2) {
[0]=>
string(6) "item 4"
[1]=>
string(6) "item 5"
}
[2]=>
array(2) {
[0]=>
string(6) "item 6"
[1]=>
string(6) "item 7"
}
[3]=>
array(2) {
[0]=>
string(6) "item 8"
[1]=>
string(6) "item 9"
}
[4]=>
array(1) {
[0]=>
string(7) "item 10"
}
}
string(20) "item 1,item 2,item 3"
string(13) "item 4,item 5"
string(13) "item 6,item 7"
string(13) "item 8,item 9"
string(7) "item 10"
Ответ 11
<?php
$sample_array = array('item 1','item 2', 'itme 3','item 4', 'item 5','item 6','item 7', 'item 8','item 9','item 10',
'item 11','item 12','item 13','item 14','item 15','item 16');
restructure($sample_array,3);
function restructure($array ,$size)
{
$i=0;
while($i<= count($array))
{
$j=$i;
$count = 0;
while ($count<$size)
{
if($j<count($array))
{
echo $array[$j]. " ";
$j++;
}
$count++;
}
echo '<br>';
$i=$i+$size;
}
}
?>
<?php
Ответ 12
Попробуйте следующее:
function array_group($array, $X){
$extra = count($array)%$X;
$pre = array_splice($array, 0, $extra);
$post = array_chunk($array, count($array)/$X);
$post[0] = array_merge($pre, $post[0]);
foreach ($post as &$key) {
$key = implode(', ', $key);
}
return $post;
}
Ответ 13
Это нормально?
$items = array('item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7');
array_unshift($items, '');
$chunkitems = array_chunk($items, 2);
$newitems = array_map(function($v){return implode(', ', $v);}, $chunkitems);
$first = ltrim(implode(', ', array(array_shift($newitems), array_shift($newitems))),', ');
array_unshift($newitems, $first);
print_r($newitems);
Ответ 14
Код:
$input = array('Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5', 'Item 6', 'Item 7');
$height = 3;
$commonWidth = floor(count($input) / $height);
$remaining = count($input) % $height;
$i = 0;
for ($j = 0; $j < $height; $j++) {
$width = $commonWidth + (0 < $remaining--);
$output[] = implode(', ', array_slice($input, $i, $width));
$i += $width;
}
print_r($output);
Выход:
Array
(
[0] => Item 1, Item 2, Item 3
[1] => Item 4, Item 5
[2] => Item 6, Item 7
)
Интересно, является ли описание проблемы неправильным, и требуемый результат на самом деле является многомерным массивом, а не массивом конкатенированных строк. В этом случае просто удалите вызов для взлома:
$input = array('Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5', 'Item 6', 'Item 7');
$height = 3;
$commonWidth = floor(count($input) / $height);
$remaining = count($input) % $height;
$i = 0;
for ($j = 0; $j < $height; $j++) {
$width = $commonWidth + (0 < $remaining--);
$output[] = array_slice($input, $i, $width);
$i += $width;
}
print_r($output);
И результат:
Array
(
[0] => Array
(
[0] => Item 1
[1] => Item 2
[2] => Item 3
)
[1] => Array
(
[0] => Item 4
[1] => Item 5
)
[2] => Array
(
[0] => Item 6
[1] => Item 7
)
)
Ответ 15
Если вас устраивает двумерный массив, и вы счастливы, если последняя строка может быть намного меньше, чем все остальное, здесь однострочный:
function split_array1($orig_array, $parts = 1) {
return array_chunk($orig_array,ceil(count($orig_array)/$parts));
}
То же самое, слияние каждой части в строки:
function split_array2($orig_array, $parts = 1) {
$split = array_chunk($orig_array,ceil(count($orig_array)/$parts));
foreach ($split as &$row) $row = join($row, ', ');
return $split;
}
Вывод трех тестов с 7, 8 и 9 элементами:
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5, Item 6 [2] => Item 7 )
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5, Item 6 [2] => Item 7, Item 8 )
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5, Item 6 [2] => Item 7, Item 8, Item 9 )
Тест:
$input = array('Item 1', 'Item 2', 'Item 3', 'Item 4', 'Item 5', 'Item 6', 'Item 7', 'Item 8', 'Item 9');
for ($size=7; $size<=count($input); $size++){
$output = split_array2(array_slice($input, 0, $size), 3);
print_r($output);
echo '<br>';
}
Это будет точно соответствовать вашим примерам:
function split_array3($orig_array, $parts = 1) {
$count = count($orig_array);
for ($i=0, $index=0; $i<$parts; $i++) {
$size_of_sub = ceil(($count - $index) / ($parts-$i));
$split[$i] = join(array_slice($orig_array, $index, $size_of_sub), ', ');
$index += $size_of_sub;
}
return $split;
}
Результат:
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5 [2] => Item 6, Item 7 )
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5, Item 6 [2] => Item 7, Item 8 )
Array ( [0] => Item 1, Item 2, Item 3 [1] => Item 4, Item 5, Item 6 [2] => Item 7, Item 8, Item 9 )
Просто для удовольствия, здесь решение, которое использует рекурсию:
function recursive_split_array($orig_array, $num_sub_arrays = 1) {
$size_of_sub = ceil(count($orig_array) / $num_sub_arrays);
$split[0] = join(array_slice($orig_array, 0, $size_of_sub),', ');
$split = array_merge( $split,
split_array(array_slice($orig_array, $size_of_sub,
count($orig_array)-$size_of_sub),$num_sub_arrays - 1));
return $split;
}
Ответ 16
Это кажется довольно сжатым:
function ReduceArray($input,$length)
{
$count = count($input);
// fill new array with new number of empty elements
$newArray = array_fill(0,ceil($count/$length),"");
for( $i = $count; $i > 0; $i--)
{
// calculate index in new array to insert item
$index = ceil($i / $length)-1;
// we need a comma separator in this position if the array is empty
$sep = ($newArray[$index] != "" ? "," : "");
// insert into new array
$newArray[$index] = array_pop($input) . $sep . $newArray[$index] ;
}
return $newArray;
}
Ответ 17
Другой алгоритм, поскольку, как я понимаю, вопрос заключается в реструктуризации массива на месте, поэтому наилучшая эффективность может быть достигнута, когда временные массивы не создаются.
<?php
function group_array(&$array, $parts = 3)
{
$size = count($array);
$length = floor($size / $parts);
$remains = $size % $parts;
$done = 0;
for($i = 0; $i < $parts; ++$i)
{
$real_length = $length + ($i < $remains ? 1 : 0);
$array[$i] = $array[$done];
for($j = $done + 1; $j < min($done + $real_length, $size); ++$j)
$array[$i] .= ', ' . $array[$j];
$done += $real_length;
}
for($i = $size; $i >= $parts ; --$i)
unset($array[$i]);
}
?>
Тестовый пример № 1:
<?php
$array = array("item 1", "item 2", "item 3", "item 4", "item 5", "item 6", "item 7");
group_array($array);
echo '<pre>' . print_r($array, true) . '</pre>';
?>
Вывод:
Array
(
[0] => item 1, item 2, item 3
[1] => item 4, item 5
[2] => item 6, item 7
)
Тестовый пример № 2:
<?php
$array = array("item 1", "item 2", "item 3", "item 4", "item 5", "item 6",
"item 7", "item 8", "item 9", "item 10");
group_array($array);
echo '<pre>' . print_r($array, true) . '</pre>';
?>
Вывод:
Array
(
[0] => item 1, item 2, item 3, item 4
[1] => item 5, item 6, item 7
[2] => item 8, item 9, item 10
)
Ответ 18
Хорошо, я видел все ответы, но я хотел бы добавить мой:
используя array_chunck, array_splice и array_reduce приведет к очаровательному результату, например:
сначала, написав нашу основную функцию:
function custom_reduce($chunks,$array)
{
$result = [];
if(count($array)%2==0)
{
$muArray = array_chunk($array, $chunks);
foreach ($muArray as $key => $value) {
$result[]= array_reduce($value, "reduce");
}
return $result;
}
else{
$temp = array_splice($array, 0, $chunks+1);
$result[]= array_reduce($temp, "reduce");
$muArray = array_chunk($array, $chunks);
foreach ($muArray as $key => $value) {
$result[]= array_reduce($value, "reduce");
}
return $result;
}
}
now $chunks - это аргумент, который определит количество элементов, которые будут уменьшены позже. и для $array, очевидно, это будет ваш вклад.
array_reduce вызовет нашу функцию reduce, которая:
function reduce($reduced,$item)
{
if($reduced != '' OR !is_null($reduced))
$x = ' , ';
else
$x = '';
return $reduced.$x.$item;
}
который объединит входные индексы по мере необходимости.
концепция проста, и ее можно манипулировать по мере необходимости, и это легко, если вы не знаете размер вашего массива, который все время - 0,01: D
вы можете проверить это fiddle, чтобы поиграть.
Ответ 19
Возможно, еще один цент.: -)
<?php
function restructure($x,$slots)
{
$result=array();
$count=count($x);
$least=(int)($count/$slots);
$excess=$count-$least*$slots;
for($i=0;$i<$slots*$excess;$i+=$least+1)
array_push($result,implode(", ",array_slice($x,$i,$least+1)));
for(;$i<$count;$i+=$least)
array_push($result,implode(", ",array_slice($x,$i,$least)));
return $result;
}
if (PHP_SAPI==='cli') {
$x=array(
"item 1",
"item 2",
"item 3",
"item 4",
"item 5",
"item 6",
"item 7",
);
print_r(restructure($x,3));
}
Что делает:
Array
(
[0] => item 1, item 2, item 3
[1] => item 4, item 5
[2] => item 6, item 7
)
Ответ 20
Попробуйте это
$array_test = array('Item 1','Item 2','Item 3','Item 4','Item 5','Item 6','Item 7'); //,'Item 8','Item 9'
$x = 3;
$values_per_array = count($array_test) / $x;
if( count($array_test) % 2 == 0) {
$result_array = array_chunk($array_test, $values_per_array);
}
else {
$get_val = $array_test[$x-1];
unset($array_test[$x-1]);
$result_array = array_chunk($array_test, $values_per_array);
array_push($result_array[0], $get_val);
}
print_r($result_array);
Ответ 21
Отличный вопрос +1 для этого. Я создал решение более динамично, как.
- В качестве пользовательского ввода может быть любое число из 1..... n
- Минимальная группировка членов, которые будут описаны или изменены.
- Максимальная группировка членов, которые будут описаны или могут быть изменены в любое время
Это было бы краеугольным камнем для другого:
<?
//can n number of array items
$items = array('item1', 'item2', 'item3', 'item4', 'item5', 'item6', 'item7');
//counting of total number of items
$total_items = count($items);
//item to find in array
$find_item = "item7";
//first item found key number
$key = array_search($find_item, $items);
//Splitting into two
//array with last found as item
$temp_output1 = array_slice($items, 0, $key+1);
//items left
$temp_output2 = array_slice($items, $key+1, $total_items);
//minimum number items to group
$minimum_group=2;
//Maximum Number of Grouped items
$maximum_group=4;
if ( $temp_output1 ) {
//sending to group accordingly
$output1 = do_slicing($temp_output1, $minimum_group, $maximum_group);
print_r($output1);
}
if ( $temp_output2 ) {
//sending to group accordingly
$output2 = do_slicing($temp_output2, $minimum_group, $maximum_group);
print_r($output2);
}
function do_slicing($temp_output = array(), $minimum_group, $maximum_group){
$count = count($temp_output);
//array is equal to min grouping
if ( $count == $minimum_group){
//Group them and return
return by_grouping($temp_output, $minimum_group);
}elseif ($count == $maximum_group){
//if items equal to maximum then group them and return
return by_grouping($temp_output, $maximum_group);
}elseif ( ($count > $minimum_group) and ($count < $maximum_group)){
return by_grouping($temp_output, count($temp_output));
}elseif ($count == 1) {
//if item is 1 print error or return from here
return $temp_output;
}else{
//calculate the total number of groups available
$item_slice_count = intval($count/$maximum_group);
//Split them as grouped members
$temp_slice = array_slice($temp_output, 0,
($item_slice_count*$maximum_group));
//non group members
$temp_slice2 = array_slice($temp_output,
($item_slice_count*$maximum_group), $count);
//if there is no non group members
if ( !$temp_slice2 ) {
//combine them and return according to maximum grouping
return by_grouping($temp_slice, $maximum_group);
}else{
if (
(count($temp_slice2) === $minimum_group) or
(
(count($temp_slice2) > $minimum_group) and
(count($temp_slice2) <
$maximum_group)
)
){
//if count of slice2 equal to minimum group then
$a=by_grouping($temp_slice, $maximum_group);
if (
(count($temp_slice2) > $minimum_group) and
(count($temp_slice2) <
$maximum_group)
){
$b=by_grouping($temp_slice2, count($temp_slice2));
}else{
$b=by_grouping($temp_slice2, $minimum_group);
}
return array_merge($a, $b);
}elseif( count($temp_slice2) < $minimum_group ) {
//if less then minimum group then
//if total count is divisible with minimum group
if ( ($count % $minimum_group ) == 0 ){
//return after clubbing according minimum group
return by_grouping($temp_output, $minimum_group);
}else{
//Where last group is not equal to minimum group
//Minimum more needed to complete last slice
$minimum_needed = $minimum_group - count($temp_slice2);
//slice1 become
$slice1 = array_slice($temp_output, 0, (
($item_slice_count-1)*$maximum_group));
//slice2 would be
$slice2 = array_slice($temp_output, (
($item_slice_count-1)*$maximum_group),
($maximum_group-$minimum_needed));
//slice 3 then
$slice3 = array_slice($temp_output, (
(($item_slice_count-1)*$maximum_group) +
($maximum_group-$minimum_needed)),
$count);
//if slice2 is greater or equal to minimum group then
if ( $slice2>=$minimum_group) {
$a=by_grouping($slice1, $maximum_group);
$b=array_merge($a, by_grouping($slice2,
count($slice2)));
$c=by_grouping($slice3, $minimum_group);
return array_merge($b, $c);
}else{
die("This Situation doesn't reached any time");
}
}
}
}
}
}
//Grouping of members according to slices provided
function by_grouping($temp_slice, $group){
$return = array();
$temp = array_chunk($temp_slice, $group);
foreach($temp as $a){
$return[] = implode(', ', $a);
}
return $return;
}
?>
DEMO CODE
