правила, которым должен будет удовлетворять результат, перечисли.

KaFe
одно число первое, второе последнее и тд

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$len = count($array); // Лучше один раз высчитать длину массива, чем каждый раз в цикле
$max = $len - 1; // Тоже самое, фактически (сокращаем кол-во операций, выигрываем в скорости)
$result_array = array();
for($pos = 0; $pos < $len; $pos ++, $max --)
{
    if ($pos > $max) { break; }
    $result_array[] = $array[$pos];
    if ($pos == $max) { break; }
    $result_array[] = $array[$max];
}
print_r($result_array);

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10,11,12 );
$ar=count($array)-1;$ar;$arr=($ar/2);$v=-1;
for ($x=0;$x<$arr;$x++)
	{
	$v++;
	$g[$v]=$array[$x];
	$v++;
	$g[$v]=$array[$ar-$x];
	}
	if ($ar%2==0) {$v++;$g[$v]=$array[$arr];}
	print_r($g);

мда.....

всегда казалось, что мало кода - лучше
теперь убедился, что нет

за это вам спасибо и +1

Я считаю, что мой понятнее всех для новичка. Но у linker красиво выгладит, , и работает также по скорости как и у меня .

я завидую

До мне наконец дотюкала фраза

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$carr = count($array);
$j = $carr - 1;
for($i=0; $i<$carr; $i++, $j --)
{
  $array = array_reverse($array);
  $arr[$i] = $array[$j];
  unset($array[$j]);
}
print_r($arr);

qpayct лучше используй код linker'a .

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$c = count($array);
$j = $c - 1;
$c = $c / 2;
$arr = array();
for($i=0; $i<$c; $i++,$j-- )
{
  if($i == $j) break;
  $arr[] = $array[$i];
  $arr[] = $array[$j];
}
print_r($arr);

qpayct
Ну во-первых, array_reverse() жутко тормозит, а делается это при каждой итерации цикла. Во-вторых, unset в массиве, по которому идет цикл, не всегда кузяво.
Мой код, тоже не блещет идеалом, два брейка в цикле режут глаза таки.

p.s., кстати последний вариант не работает в случае если количество элементов в массиве нечетное количество.

может уже позно и я чего то не понимаю но помоему проще всего так

<?php
  $arr=array(1,2,3,4,5,6,7,8,9,0);
  $max=count ($arr);
  $len =$max/2;
	echo $max;
  $itog=array();
  for ($i=0;$i<$len;$i++)
  {
  $itog[]=$arr[$i];
  $itog[]=$arr[$max-$i-1];
  	}
  	print_r($itog);
?>

linker
опять накосячил не там бреак поставил

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
$c = count($array);
$j = $c - 1;
$c = $c / 2;
$arr = array();
for($i=0; $i<$c; $i++,$j-- )
{
  $arr[] = $array[$i];
  if($i == $j) break;
  $arr[] = $array[$j];
}
print_r($arr);

Basili4

А вот ишшо вариант... Сначала получаем все ключи массива в виде отдельного массива, а потом "тупо" вызываем по очереди нужные элементы и упаковываем их в новый массив. Вроде бы, нормально работает и с четным, и с нечетным количеством элементов. И пофиг , какие индексы у массива - числовые или символьные.

$array = array(0, 1, 2, 3, 4, 5, 6, 'new'=>7, 8, 9, 10);

$keys=array_keys( $array );

$c=count( $array );

$new_arr=array();
for( $i=0; $i<($c/2.); $i++)
{
  $new_arr[ $i*2 ] =$array[ $keys[$i] ];
	
  if( $i < $c-$i-1 )
    $new_arr[ $i*2+1 ]=$array[ $keys[$c-$i-1] ];
}

echo '<pre>'; var_dump( $new_arr ); echo '</pre>';

PS. После отправки немного скорректировал код, т.к. отправил сначала не самый последний вариант.

sergeiss

qpayct - а я тоже не понял Цитата чья-то, а вопрос ко мне

Объясняю: точку я поставил на всякий случай, дабы не заморачиваться - целочисленное будет деление или вещественный результат. Посреди ночи не хотелось мозги нагружать особо-то
Самое главное - рабочий алгоритм или как?

Еще немного откорректировал код linker'а:

$array = array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 );
$array_size = count( $array );
$j = $array_size - 1;
$result_array = array();

for ( $i = 0; $i < $j; $i++, $j-- ) {
   $result_array[] = $array[$i];
   $result_array[] = $array[$j];
}
if ( $array_size % 2 ) {
   $result_array[] = $array[$j];
}

print_r($result_array);

И свой написал:

$array = array( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 );
$array_size = count( $array );
$i = 0;
$j = $array_size - 1;
$result_array = array();

for ( $k = 0; $k < $array_size; $k++ ) {
   if ( $k % 2 == 0 ) {
      $result_array[] = $array[$i];
      $i++;
   } else {
      $result_array[] = $array[$j];
      $j--;
   }
}

print_r($result_array);

$array1 =  array(0, 1, 2, 3, 4, 5, 6, 7, 8,9);
$cnt = count($array1);
for ($i = 0; $i < $cnt/2; $i++)
  {
      $array2[] = $array1[$i];
      $array2[] = $array1[$cnt - $i - 1];
  }
if ($cnt%2) array_pop($array2);

tomash
был такой вариант я писал недостаток не льзя использовать с массмвами с нечетным количество элементов как вариант доюовлять моссив до четности и и если был добавлен в конце сносить левые значения

Еще более быстрый вариант от меня

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$len = ceil(count($array)/2);
$max = count($array) - 1;
$result_array = array();
for($pos = 0; $pos < $len; $pos ++, $max --)
{
    $result_array[] = $array[$pos];
    if ($pos <> $max) $result_array[] = $array[$max];
}

sergeiss, ну такое условие было , вот вариант "ключе-независимый"

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 'sss' => 9);
$len = ceil(count($array)/2);
$max = count($array) - 1;
$keys = array_keys($array);
$result_array = array();
for($pos = 0; $pos < $len; $pos ++, $max --)
{
    $result_array[] = $array[$keys[$pos]];
    if ($pos <> $max) $result_array[] = $array[$keys[$max]];
}

linker - да, это лучше намного смотрится. Хотя, в конце ключик 'link_error' был бы более в тему

Я почему говорю насчет универсальности... Потому что много раз было уже тут на форуме: человек спросил что-то, частный случай. А ему надо, на самом деле, более универсальное решение. И он опять продолжает задавать тот же вопрос, но уже "с вариациями".

$array->arr_tmp = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$array->count = count($array->arr_tmp) - 1;
for($i=0, $j=$array->count; $i<$array->count; $i++, $j--)
{
  if($array->arr_tmp[$i] >= $array->arr_tmp[$j]) break;
  
  $array->arr[$i] = $array->arr_tmp[$i];
  $array->arr[$j] = $array->arr_tmp[$j];
}
var_dump($array->arr);

sergeiss
я не делаю замечаний, а просто интересно почему так. комментарии цитировал ибо их автор - Линкер и мне вот интересно может я чего то не понимаю или же он был прав и это относится к моему, а теперь и вашему коду?
по поводу универсальности согласен, хоть и не понимаю зачем перестраивать ассоциативный массив пирамидой? числовой для проверки кода, для парсинга и т.п. а ассоциативный разве чтобы ёлочку из стринга рисовать

linker
ceil() работает быстрее чем round() прикольно

Wird_34
всё это уже пробовали. работает, но можно и лучше

igovet
у вас прокрутка в цикле вдважды больше....

qpayct
Она останавливается тогда, когда нужно, это ничему не мешает.

igovet
ага, и всё что в цикле нужно умножить на 2, чтобы получить конечный итог выполняемых операций. мало того! ко всему ещё и классом зачем-то....
взяли мой "коктейль" и переименовали переменные да ещё и цикл увеличили вдважды. а толку?

Нате вам.

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 'sss' => 9);
    $i = 0;
    while(count($array))
        $arr[] = !(++$i%2)?array_pop($array):array_shift($array);

print_r($arr);

qpayct
Зачем умножать на 2, ты код мой хоть понимаешь? Какая разница какое значение в цикле, пусть хоть 1 000 000, он выполниться с той же скоростью что и с цифрой 4, а знаешь почему? Потому что на цифре 4, мой цикл закончит работу.
if($array->arr_tmp[$i] >= $array->arr_tmp[$j]) break;
Чем плохо писать классом?

twin
а работает то в 10 раз медленее
пример лаконичности или как там?

igovet
твой код !?
насчёт брэйка это да. торможу

twin глупости какие 0,399 секунд за 10000 оборотов, когда у linker 0.220

Кстати, насчет скорости. "Мой" код как? Я его не сравнивал с другими, а автор темы, наверное, сравнил?

Ну я не мерял. Просто при решении задачи привык оперировать очевидными вещами. Впрочем, скорость тут падает из за цикла. Вот так к примеру будет быстрее:

$c = count($array);
  
    for($i = 0; $i < $c; ++$i)
        $arr[] = !($i%2)?array_pop($array):array_shift($array);

Можно еще помудрить, если так критично.

sergeiss
а как же? но сравнивать не буду у вас совсем по другим условиям код(ассоциативные массивы) а это конечно тормозит процесс

twin

$array=array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
$c = count($array);
    for($i = $c; $i > 0; --$i)
        $arr[] = !($i%2) ? array_pop($array) : array_shift($array);
print_r($arr);

вот так будет ваще прикольно

к слову о птичках - вайл быстрее фора

DedMorozzz
мои замерки в данном коде гооврят против вас....

twin
Я думаю что несовсем удачный вариант пробегать весь массив

может

лучше так

$c=count($array) ;
$f=$c%2;
$c=($c /2)-$f;

for($i = 0; $i < $c; ++$i)
{
 $arr[] = array_pop($array);
$arr[] =array_shift($array);
}

if ($f==1)  $arr[] = array_pop($array);

print_r($Array->reSet());

qpayct
дык возьми самое простое действие, к примеру инкримент. И пропусти через фор 10к раз. И пропусти через вайл. Измерь время и сравни. Вайл быстрее

DedMorozzz, в данном случае while или for не имеет значения, производительность гробят цикличные вызовы функций array_pop() и array_shift()

Вот еще пример, работает вдвое быстрее моего предыдущего

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 'sss' => 9);
$result_array = array();
$len = ceil(count($array)/2);
$max = count($array) - 1;
$keys = array_keys($array);
$pos = 0;
while($pos < $len)
{
    $result_array[] = $array[$keys[$pos]];
    if ($pos <> $max) $result_array[] = $array[$keys[$max]];
    $pos ++;
    $max --;
}

По вникал в суть дела, и вот так свой переделал

$array = array( 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10,11,12,'a'=>50);
$array=array_values ($array);
$ar=count($array)-1;$ar;$arr=($ar/2);
for ($x=0;$x<$arr;$x++)
	{
	$g[]=$array[$x];
	$g[]=$array[$ar-$x];
	}
	if ($ar%2==0) $g[]=$array[$arr];
}

А разве программист не должен стремиться к балансу между понятностью кода и его эффективностью. Одно дело предлагать разные варианты решения, но другое переписывать его в более непонятный, но при этом работающий на 5 наносекунд быстрее. Может другие задачи порешаем?

linker ваш последний код имеет показатели 0.240 сек., мой последний код 0.205 сек. за 10000 обращений:lol:

linker
Писать классом как написал я, это удобно для визуального восприятия, так как в большом коде когда пишешь, есть основной объект, а в нём уже хранится всё что тебе нужно, нет путаницы в переменных.
Необходимость класса бывает очень разной, узко мыслим.

Вот наверно самый лаконичный и читабельный код:

$c = count($array); 
 
    while($c)
        $arr[] = (--$c % 2) ? array_shift($array) : array_pop($array);

хотя по скорости уступает последнему от linker

Вообще при разработке нужно учитывать все параметры. Если предполагается обработка больших массивов или их много, то стоит задуматься о скорости. А если такой, какой в примере, то выигрыш в пару десятитысячных секунды не стоит таких заморочек в ущерб прозрачности.

igovet

KaFe, ну не знаю, проверил у себя, ваше время:
5.79357147217E-5 сек.
против моего
1.31130218506E-5 сек.
у меня получается быстрее в 2.67 раза быстрее

igovet ......

linker входные данные одинаковые??? sergeiss да я учитывал данный факт.Результаты проверял на три раза, могу сказать одно.

While в два раза требовательнее for

P.S: На счет предупреждения! За что???

KaFe, абсолютно одинаковые и там и там

$array = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 'sss' => 9);

Я все еще раз перепроверил, у меня цифры правильные, покажите как вы проверяете

KaFe, да банально проверяю

$start = microtime(1);
... // Ваш код
$subtime1 = microtime(1) - $start;
$start = microtime(1);
... // Мой код
$subtime2 = microtime(1) - $start;
if ($subtime1 > $subtime2)
{
    echo "У меня быстрее в " . ($subtime1/$subtime2) . " раза";
}

KaFe удивительное рядом, поменяйте местами код (первый будет ваш, а второй мой).

Я поменял, выдало

$t = explode(" ",microtime());$start_t=$t[1]+$t[0];
//Здесь тестируем код, при том каждый код тестируется по отдельности, дабы ... 
$t = explode(" ",microtime());$end_t=$t[1]+$t[0];
echo ($end_t-$start_t);

дык ясный пень вариант линкера самый, что ненаесть оптимальный . Убираем асс.массивы и вообще просто чудо оптимизации. Ладно, думаю тема исчерпала себя.

З.Ы. Удивлюсь, если в конкурсе Твина в номинации 'самый оптимальный код' победит не Линкер

ещё одно важное разоблачение пхп5.

(за пример возьму код Линкера т.к. он самый шустрый)

    $array = array(0,1,2,3,4,5,6,7,8,9);
    $arr = array();
    $max = count($array) - 1;
    $len = $max/2;
    $pos = 0;
    //$keys = array_keys($array);
    while($pos < $len)
    {
        $arr[] = $array[$pos];
        if ($pos == $max) break;
        $arr[] = $array[$max];
        $pos ++;
        $max --;
    }
$arr[3] = 'ok';
print_r($array);

выведет

    $array = array(0,1,2,3,4,5,6,7,8,9);
    $arr = array();
    $max = count($array) - 1;
    $len = $max/2;
    $pos = 0;
    //$keys = array_keys($array);
    while($pos < $len)
    {
        $arr[] = &$array[$pos];
        if ($pos == $max) break;
        $arr[] = &$array[$max];
        $pos ++;
        $max --;
    }
$arr[3] = 'ok';
print_r($array);

самый быстрый(пока) вариант

$array = array(0,1,2,3,4,5,6,7,8,9);
$pos = 0;
$max = count($arr) - 1;
$len = $max / 2;
$arr = array();
while($pos < $len)
{
  $arr[] = &$array[$pos];
  if ($pos == $max) break;
  $arr[] = &$array[$max];
  $pos++;
  $max--;
}

Я бы порекомендовал не гоняться за скоростью, а делать так, как понятнее и логичнее
Вот подсчитай. Тут мелькали цифры типа 0.28 сек за 10 тыс циклов. Теперь делим и получаем 2.8е-6 сек на одну итерацию цикла. И пусть там будет даже в 10 раз дольше время, 2.8е-5 сек. Ты лично это заметишь?

sergeiss
нет конечно , но дело в другом я учусь изначально правильно строить. вот еслиб я не задался этим вопрсом разве узнал бы о таких тонкостях пхп5?