Говнокод: врага надо знать в лицо



    Все примерно представляют, что такое говнокод. На этом замечательном сайте собрана целая коллекция.

    Что делает код говнокодом — никто точно не знает. Точного определения нет. Часто то, что одни считают очевидным говнокодом, другим кажется лаконичным и эффективным решением.

    Примеры


    Примеры говнокода варьируются от избыточных до откровенного хардкода. Самые любмые примеры — такие, говнокодистость которых очевидна для всех:
    Boolean b = new Boolean( is_admin );
    if( b.toString().length() == 4 ) {
       // something...
    }
    // something
    


    Но знаете, что я скажу? Осуждать говнокод легко, но написать его не так-то легко!
    Не верите? Давайте попробуем!

    UPD Ниже добавлен анализ поступивших решений.


    Задание


    Вот простое задание: Напечатать на экране следующее:
    1
    2-1
    1-2-3
    4-3-2-1
    1-2-3-4-5
    6-5-4-3-2-1
    (Естественно, вместо 6 может быть любое число).

    Попробуйте написать два решения на любом языке:
    1. Максимально лаконичное/красивое/читабельное
    2. Максимально говнокодистое (но не слишком много. Скажем, ограничение в один экран. И конечно, решение должно работать!)

    Можете писать свои варианты в комментарии (для длинных кусков рекомендуется pastebin). Помимо развлекательной составляющей, это может оказаться и полезным упражнением, потому что возможно, оно приблизит вас к понимаю, как получается плохой код и как с ним бороться.

    Дайте волю своей фантазии!

    UPDATE: Анализ решений


    Спасибо всем, кто прислал свои варианты. Так много комментариев я ещё не видел. Стало быть, тема актуальна.

    Попробуем проанализировать поступившие решения.

    Хорошие решения


    «Хорошие» решения, как и полагается, все однотипные, то есть примерно такие:
    $n = 6;
    for($i = 1; $i <= $n; $i++) {
        $array = $i % 2 ? range(1, $i) : range($i, 1);
        echo join('-', $array), PHP_EOL;
    }
    


    Среди них выделяются два решения на Руби и Хаскеле, которые, на мой взгляд, хороши тем, что они написаны в одну строчку, но при этом сохраняют читабельность. Достигается это, очевидно, засчёт языка.

    Руби от Arion:
    (6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
    


    Хаскель от pechlambda:
    main = mapM_ (putStrLn . foo) [1..6]
    foo n = concat $ intersperse "-" $ (if odd n then id else reverse) $ take n $ map show [1..]
    

    Что ещё раз доказывает, что Руби рулит!

    Если говорить серьёзно, то у всех этих решений есть один недостаток: они жрут много ресурсов при больших N (создают много временных массивов и строк). Следующее решение от rPman отчасти решает эту проблему (интересно, что сам автор представил его как говнокод):
    <?php
    define('LENGTH',6);
    define('nl',"\n");
    
    $right='1';
    $left='1';
    echo '1'.nl; // <== это он
    for($i=2;$i<=LENGTH;$i++)
    {
        $left=$i.'-'.$left;
        $right=$right.'-'.$i;
        echo ($i%2?$right:$left).nl;
    }
    ?>
    


    Плохие решения



    Меня изначально интересовали, конечно, именно «плохие» решения. Надо сказать, что хабровчане смогли-таки меня удивить и придумал больше говновариантов, чем я ожидал.

    Добротный треш

    Решение от runcore пытается в одной строчке совместить цикл 1..N и N..1, что надёжно обфускирует изначальное предназначение этого кода:
    $is_reverse = false;
    for($i=1; $i<=6; ++$i) {
    	for($is_reverse?$j=$i:$j=1; $is_reverse?$j>=1:$j<=$i; $is_reverse?--$j:++$j) {
    		echo (($is_reverse)?($j.($j>1?'-':'')):($j.($j<$i?'-':'')));
    	}
    	$is_reverse = (($is_reverse) ? false : true);
    	if (in_array($is_reverse, array(true,false))) {
    		echo '<br />';
    	}
    }
    


    Комментарии рулят

    AHDPEu в своём решении активно использует комментарии. Получилось классно. Что ещё раз доказывает, что комментирование кода — от лукавого.

    Premature optimization

    Говнокод на Perl у youlose получается засчёт попыток чего-то там оптимизировать. Что ещё раз доказывает, что преждевременная оптимизация — зло.

    Обработка ошибок

    Решение на JavaScript от azproduction, хоть и несколько преувеличенно, показывает, к чему приводит чрезмерная забота об ошибках и нестандартных ситуациях.

    Говноязыки

    • Доставило решение sledopit на языке bash:
      #!/bin/bash
      i=1;m=7;while [ $i -lt $m ];do seq 1 $(($i%$m))|tr '\n' ' '|sed 's/ /-/g;s/-$//';((i++));echo;done|while read line; do [ $((${line/*-/}%2)) -eq 1 ]&&echo $line||echo $line|rev;done
      

      Думаю, все согласятся с тем, что оно ни разу не читабельное. Похоже, это тот случай, когда сам язык обязывает программиста писать говнокод. То же подтверждает и целая череда решений на brainfuck.
    • Решение pechlambda на Хаскеле: codepad.org/NQUSqcjc доказывает, что каким бы хорошим язык ни был, на нём всегда можно добротно наговнокодить.
    • Спасибо огромное Next_Alex за то, что напомнил нам про старые добрые goto.
    • А вот Levsha100, совершенно зря наговаривает на своё решение на ассемблере. По-моему, ничего читабельнее я тут не встречал. :)
    • Решения на Лиспе, по-моему, оба нечитабельные. Впрочем, позже S2nek исправился.


    Школы говнокода



    Классика

    Но самый классический говнокод, похоже, вышел у SnakeSolid: pastebin.com/rdCtf2j5
    Вроде бы ничего особенно лишнего: комментарии, и парочка лишних проверок — да, это всё немножко лишнее, но без криминала. Начнёшь придираться — автор наверняка сможет всё это защитить. Но кода получилось на целую страницу вместо пары строчек. Именно так оно в жизни и бывает.

    Подводя итоги


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

    Всем спасибо!

    Пишите чисто!

    Share post

    Comments 290

      +199
      Буду капитаном говнокодом.

      <?php
      echo «1
      »;
      echo «2-1
      »;
      echo «1-2-3
      »;
      echo «4-3-2-1
      »;
      echo «1-2-3-4-5
      »;
      echo «6-5-4-3-2-1
      »;
      if ($n > 6) echo 'Чтобы увидеть дальнейшие результат отправьте смс на номер 5555555';
        –45
        А в чем говнокодость? echo вместо print чтоли?
          +13
          Ну, наверное, в том, что типичный говнокод решает только видимую часть проблемы. И проявляется только когда его нужно допилить.
            +13
            Но если что можно дописать echo «echo «1-2-3-4-5-6-7», не?
              +7
              Надеюсь, вы шутите :)
                +5
                какая задача такое и решение :)
              +4
              И, кстати, если задача изменится, и нужно будет вывести следующее, какой код будет проше изменить?
              Напечатать на экране следующее:
              1
              2-1
              7-2-3
              4-545-6-3
              7-26-3-0-45+7
                +17
                Ага. Что, если мы строим дом, а потом, вдруг, нам понадобилось изменить задачу и смастерить круиз-лайнер?
                  0
                  >Предлагаю Вам переписать этот код для n=1000.
                  Ниже кто-то уже предложил изменить начальное условие задачи и решил смастерить круиз-лайнер.
                –23
                Короче, я считаю что вы написали не говнокод, а очень даже правильный код человека, не страдающего ООП головного мозга.
                  +24
                  Предлагаю Вам переписать этот код для n=1000.
                    +95
                    Сначала отправьте СМС
                      +2
                      Ага, а ещё этот код не жмёт картинку и не ставит вотемар, хотя… Стоп. О чём это я? О чём это вы?

                      Не надо менять условие задачи, если никто об этом не просил.
                        +10
                        print "
                        1
                        2-1
                        1-2-3
                        4-3-2-1
                        1-2-3-4-5
                        1000-5-4-3-2-1
                        ";
                          +7
                          И да! Я перечитал оговорку
                          (Естественно, вместо 6 может быть любое число).


                          И тут можно сказать, что Вы правы :)
                          0
                          А ведь он, наверное, прав.
                          В задаче ведь не написано, что отобразить для любого n
                          Если в задаче сказано: напишите
                          1
                          1-2
                          то не имеет смысла тратить время, и всего двумя командами можно решить задачу.
                            –2
                            В задаче ведь не написано, что отобразить для любого n
                            Вообще-то сказано.
                            (Естественно, вместо 6 может быть любое число).
                          +9
                          Вот он — настоящий Капитан Говнокод!
                      +2
                      Я отправил. Что дальше делать?
                      –1
                      Как вариант
                      1:
                      <?php
                      $n=6;
                      for($i=1;$i<=$n;$i++){
                          if($i%2)
                              $arr=range(1,$i);
                          else
                              $arr=range($i,1,-1);
                          echo implode('-',$arr).'<br>';
                      }
                      ?>

                      2:
                      http://pastebin.com/EaDt0Qbj
                        –1
                        Упс… Первое лучше так:
                        <?php
                        $n=6;
                        for($i=1; $i<=$n; $i++){
                            $arr=($i%2) ? range(1,$i) : range($i,1,-1);
                            echo implode('-',$arr).'<br>';
                        }
                        ?>
                          +15
                          // 1
                          $m=6;
                          for($i=0,$a=array(); $i<=$m; $a[]=++$i)
                          	echo join('-', $i%2 ? $a : array_reverse($a) )."<br />";
                          

                            +15
                            // 2 - govno
                            $is_reverse = false;
                            for($i=1; $i<=6; ++$i) {
                            	for($is_reverse?$j=$i:$j=1; $is_reverse?$j>=1:$j<=$i; $is_reverse?--$j:++$j) {
                            		echo (($is_reverse)?($j.($j>1?'-':'')):($j.($j<$i?'-':'')));
                            	}
                            	$is_reverse = (($is_reverse) ? false : true);
                            	if (in_array($is_reverse, array(true,false))) {
                            		echo '<br />';
                            	}
                            }
                            

                            )
                              +2
                              Добротный треш)
                                +1
                                У меня холодок пробежал по пояснице в обе стороны! Ох.
                                  +1
                                  Это задрот-код. Вам бы обфускатором работать )
                                    0
                                    «Web-архитектор, программист»
                                +5
                                #include <iostream>
                                
                                int main(){
                                
                                	int n=6;
                                
                                	for (int i=0;i++<=n;std::cout<<std::endl)
                                		for (int j=i;--j>0;i%2==0?std::cout<<i-j:std::cout<<j);
                                }
                                


                                Вы же делали доклад по говнокоду? Я его с удовольствием смотрел.
                                Заготавливаете материалы для следующего?
                                  0
                                  int main() без return [значение]
                                    +4
                                    В стандартах языка C++,
                                    www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1905.pdf
                                    Раздел 3.6.1, пункт 5, написано:
                                    A return statement in main has the effect of leaving the main function (destroying any objects with automatic storage duration) and calling std::exit with the return value as the argument. If control reaches the end of main without encountering a return statement, the effect is that of executing «return 0;»
                                    Т.е. если функция main у Вас ничего не возвращает, то автоматически выполняется return 0;

                                      0
                                      хорошо, просто привык на таких языках к явному указанию происходящего :-)
                                  0
                                  def foo n
                                    numbers = [1]
                                    while numbers.last <= n
                                      puts (numbers.last.even? ? numbers.reverse : numbers).join '-'
                                      numbers << numbers.last.next
                                    end
                                  end
                                  
                                  foo 6
                                  


                                  Извините, на говнокод меня уже не хватило (
                                    0
                                    Вот «говнокод»:
                                    def makemess n
                                    a = [1]
                                    t = n/2
                                    t.times do
                                    puts a.join '-'
                                    a
                                      +1
                                      гребаные «елочки»…
                                      def makemess
                                      a = [1]
                                      3.times do
                                      puts a.join '-'
                                      a << a.last + 1
                                      puts a.reverse.join '-'
                                      a << a.last + 1
                                      end
                                      end

                                      0
                                      Моя попытка говнокода:
                                      def shit_code n
                                        (1..n).inject([]) do |line, element|
                                          puts line.reverse!.tap{ |l|
                                            l.send(l.size.even? ? :push : :unshift, element)
                                          }.join("-")
                                          line
                                        end
                                      end
                                      shit_code 6
                                      
                                      0
                                      Скажите, это говнокод (php)? (:
                                      $n = 6;
                                      for($i = 1; $i <= $n; print(join('-', $i % 2 ? range(1, $i++) : range($i++, 1)) . "\n"));
                                        +6
                                        по крайней мере прочесть его тяжело.
                                        дайте его любому человеку незнакомому с этой задачей, и засеките за сколько времени он поймет что делает эта ваша одна строчка кода.
                                          0
                                          Если расписать его на несколько строчек
                                          $n = 6;
                                          for($i = 1; $i <= $n; $i++) {
                                               $nums = $i % 2 ? range(1, $i) : range($i, 1);
                                               print(join('-', $nums) . "\n");
                                          }

                                          и забыть что это такое, то понятнее не становится :)
                                            +1
                                            Тут я поспорю. Говнокод имхо — это код, который написан по-идиотски сам по себе. А тут код, который вполне грамотно написан и который просто слегка сложновато понять на первый взгляд. Тут даже можно еще сократить и не использовать переменную $nums :-)
                                            Да и вообще не все говнокод, что может показаться им. Например:
                                            if ($q == false) return false;
                                            Вроде бы говнокод и можно написать просто «return $q;», правда? А на деле условие может сработать и на 0, и на пустую строку, а вернуть надо именно булевое значение. Программист просто или не знал, или поленился воспользоваться приведением типов: «return (bool)$q;», и имеет место быть не говнокод, а просто неумелость или лень :-)
                                            0
                                            А зачем в двух разных местах $i++, если его можно запихнуть в одно ($i++ % 2)?
                                              0
                                              Нам нужно сначала получить число, и сделать range, а потом инкриментировать.
                                              А если инкриментировать в условии, то вывод получается не верный (так как в range попадает уже увеличенное значение).
                                                0
                                                Хотя из такого положения можно выйти так:
                                                $n = 6;
                                                for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));

                                                Спасибо за наводку! :)
                                                0
                                                Интервал цикла никто не обязывал быть равным [1…n]:
                                                $n = 6;
                                                for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));
                                                


                                                Просто на мой вкус изменять счетчик цикла в разных местах тела цикла — как раз и есть частая потенциальная причина очень многих трудноотлавливаемых ошибок (e. g. «говнокод»).
                                              +1
                                              (6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
                                              на perl можно и не так отжечь думаю =)
                                                +1
                                                Обфускация скорее…
                                                  0
                                                  немного опоздал :)

                                                  local $\="\n";
                                                  print join '-', $_%2?1..$_:reverse 1..$_ for 1..6;
                                                  0
                                                  Просто плохое форматирование)
                                                  $n = 6;
                                                  for($i = 1; $i <= $n; $i++) {
                                                      $array = $i % 2 ? range(1, $i) : range($i, 1);
                                                      echo join('-', $array), PHP_EOL;
                                                  }
                                                  
                                                    0
                                                    Ну да :) Я чут повыше примерно тоже самое писал.
                                                      0
                                                      точно)
                                                  +59
                                                  Вложил все свои знания =)

                                                  //ToDo: ОбЕзательно комЯнтрАвать код!
                                                  var arr = [1,2,3,4,5,6]
                                                  var i = arr.length
                                                  //rerurn зарезервированное имя, вот черт :(
                                                  //Теперь мой код будет не красивым(((((
                                                  var return2 = [];
                                                  while(i--){
                                                  //Даёшь больше бинарных операций!
                                                  var i2 = i | 1;
                                                  //Ифы отстой! Свич правит логикой!
                                                  switch(i == i2){
                                                  case true:
                                                  console.log('true');
                                                  //Больше вложеных циклов!
                                                  var str = '';
                                                  for (v in arr){
                                                  if (v == i) break;
                                                  str += arr[v] + ' — '
                                                  }
                                                  return2[i] = str.substr(0,str.length-2).trim();
                                                  break
                                                  case false:
                                                  console.log('false');
                                                  var str = '';
                                                  //Обратные циклы быстрые! Я читал на хабре!
                                                  var i3 = i;
                                                  while (i3--){
                                                  str += arr[i3] + ' — '
                                                  }
                                                  return2[i] = str.substr(0,str.length-2).trim();
                                                  break
                                                  //Самое главное добавить дефолт!
                                                  default:
                                                  alert('Ашипко!!!!!');
                                                  }
                                                  }
                                                  //Почему то не сработал мой чудо алгоритм на последнюю строчку
                                                  //Потом посмотрю, щас ваще некогда, обедать надо
                                                  str = «6 — 5 — 4 — 3 — 2 — 1»
                                                  return2 = return2.slice(1).join("\n") + "\n" + str
                                                    +1
                                                    Тег код не работает видать у низкокармщиков. Закинул на пастбин
                                                      +32
                                                      pastebin.com/a18tpmqr

                                                      вот зачем мне надпись «можно использовать html-теги» если их нельзя использовать?
                                                        +5
                                                        >вот зачем мне надпись «можно использовать html-теги» если их нельзя использовать?

                                                        Говнокод вездесущ ;)
                                                        +6
                                                        Без этого тега говнокод еще «наваристей» ))
                                                        +15
                                                        Пля, похоже в сеть утекли сорсы моего проекта!
                                                          0
                                                          Браво
                                                            +1
                                                            последние 4 строки исполнил на пять!
                                                            0
                                                            echo '1<br>';
                                                            $x = 2;
                                                            $d = -1;
                                                            $i = 2;
                                                            while ($i < 10){
                                                              echo $x;
                                                              $x += $d;
                                                              if ($x == 1) {echo '-' . $x . '<br>'; $d = -$d; $i++;}
                                                              if ($x == $i) {echo '-' . $x++ . '<br/>'; $d = -$d; $i++;}
                                                              if ($x != 1 && $x != $i) echo '-';
                                                            }
                                                            
                                                              +1
                                                              Perl:

                                                              use 5.012;

                                                              my $num = $ARGV[0] // 6;
                                                              my @num_arr = 1..$num;

                                                              say join '-',$num % 2 ? @num_arr : reverse @num_arr;


                                                              Говнокод изложу чуть позже комментарием, надо подумать… =)

                                                                0
                                                                Там же надо все комбинации вывести. Как-то так, наверное:
                                                                my $total = 6;
                                                                
                                                                for $num ( 1 .. $total ) {
                                                                  say join( '-', $num % 2 ? 1..$num : reverse 1..$num );
                                                                }
                                                                
                                                                  0
                                                                  Согласен, я ниже исправился.
                                                                  +1
                                                                  Немного неверно я понял задание сначала потому:
                                                                  1 вариант:

                                                                  use 5.012;

                                                                  sub smart_join {
                                                                  my $num = shift;
                                                                  my @num_arr = 1..$num;
                                                                  join '-',$num % 2 ? @num_arr : reverse @num_arr;
                                                                  }

                                                                  my $num_in = $ARGV[0] // 6;

                                                                  say smart_join( $_ ) for 1..$num_in;


                                                                  2 вариант:

                                                                  $n = shift @ARGV;
                                                                  if ($n == 0) { $n = 6 };

                                                                  for ($i = 1; $i<$n+1; $i++) {
                                                                  # дополнительная оптимизация для скорости
                                                                  if (length $current > 0) { $current = $current . '-'; }
                                                                  $current = $current . $i;
                                                                  $output = "";
                                                                  $direction = (($i/2) == int ($i/2));
                                                                  if ($direction) {
                                                                  @chars = split //,$current;
                                                                  for ($k = $#chars ; $k > -1; $k--) {
                                                                  $output = $output . $chars[$k];
                                                                  }
                                                                  }
                                                                  if (not $direction) {
                                                                  $output = $current;
                                                                  }
                                                                  print "$output\n";
                                                                  }


                                                                  Во втором варианте ещё и логическую ошибку допустил, если кому интересно — находите.

                                                                  P.S. подсветка не работает из-за низкой кармы
                                                                0
                                                                Все на что хватило фантазии: pastebin.com/rdCtf2j5
                                                                  0
                                                                  def str_reversed(s):
                                                                    tmp = list(s)
                                                                    tmp.reverse()
                                                                    return "".join(tmp)
                                                                  def get_line(n):
                                                                    if n == 1:
                                                                      return "1"
                                                                    elif n % 2 == 0:
                                                                      return str(n)+"-"+str_reversed(get_line(n-1))
                                                                    else:
                                                                      return str_reversed(str(n)+"-"+get_line(n-1))
                                                                  print "\n".join(map(get_line, range(1, 7)))
                                                                  
                                                                    +1
                                                                    #!/bin/bash
                                                                    i=1;m=7;while [ $i -lt $m ];do seq 1 $(($i%$max))|tr '\n' ' '|sed 's/ /-/g;s/-$//';((i++));echo;done|while read line; do [ $((${line/*-/}%2)) -eq 1 ]&&echo $line||echo $line|rev;done

                                                                    (:
                                                                      +1
                                                                      тьфу, s/max/m/g
                                                                      #!/bin/bash
                                                                      i=1;m=7;while [ $i -lt $m ];do seq 1 $(($i%$m))|tr '\n' ' '|sed 's/ /-/g;s/-$//';((i++));echo;done|while read line; do [ $((${line/*-/}%2)) -eq 1 ]&&echo $line||echo $line|rev;done
                                                                      –5
                                                                      Нормальный вариант (ну более-менее):
                                                                      // Инициализация
                                                                      $n=6;
                                                                      // Вывод
                                                                      echo $n;
                                                                      for ($i = -1*$n; $i < 0; $i++)
                                                                        echo $i;
                                                                      

                                                                      Говно-способ (применим рекурсию о_О):
                                                                      func($n)
                                                                      {
                                                                        if($n==1)
                                                                          return "1";
                                                                        else
                                                                        {
                                                                          $str = func($n-1);
                                                                          $str2 = '-'.$str;
                                                                          $str3 = $n . $str2;
                                                                          return $str3;
                                                                        }
                                                                      }
                                                                      echo func(6);

                                                                      Что сделать для возрастания говнистости:
                                                                      1) Не следить за форматированием кода.
                                                                      2) Переписать на C, реализуя все готовые функции самостоятельно (и, разумеется, криво).
                                                                      3) Переписать на ООП, реализовав свой класс строк.
                                                                      4) Переписать на ООП, реализовав иерархию классов на 5 уровней, с интерфейсам, наследованием и т.д. Вспомнить про паттерны. Применить по максимуму.
                                                                      5) Аналогично 4, но на С++ (про кривизну не забываем).
                                                                        0
                                                                        P.S. Для 3-4 подойдет любой высокоуровневый язык, такие как C#, PHP, Java и т.д.
                                                                        C/C++ выделяю отдельно потому как только там мне удавалось без особых извращений объявить структуру, привести вещественное число к этой структуре и работать с экспонентой числа как заблагорассудится. Простор для говнокода просто неисчерпаемый (сразу скажу, что против C/C++ ни чего против не имею, прекрасный, гибкий язык).
                                                                          +2
                                                                          ваш нормальный вариант — что вообще делает? )
                                                                            +1
                                                                            Эм… Выводит
                                                                            6-6-5-4-3-2-1
                                                                            Согласен, криво (каюсь, не тестил. А кто говнокод еще и тестит? :-) ).
                                                                            // Инициализация
                                                                            $n=6;
                                                                            // Вывод
                                                                            echo $n;
                                                                            for ($i = -1*$n+1; $i < 0; $i++)
                                                                              echo $i;
                                                                              +3
                                                                              Проснулся.
                                                                              Оказывается вывести надо все 6 строк, а не просто одну )))
                                                                            +3
                                                                            (6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
                                                                              –2
                                                                              Си.

                                                                              int i,j;

                                                                              for (i = 1; i <= 6; i++)
                                                                              for (j = i; j > 0; j--)
                                                                              printf("%d%c", j, j>1?'-':'\n');
                                                                                0
                                                                                а, их еще разворачивать надо — не заметил
                                                                                  +1
                                                                                  Ну, кстати, пусть так тогда будет (чтобы выглядело не очень скучно):

                                                                                  for (i = 1; i <= 6; i++) for (j = 1; j <= i; j++) printf("%d%c", i%2?j:i-j+1, "-\n"[j==i]);

                                                                                  Прекрасный образчик, по-моему…
                                                                                +3
                                                                                В тред врывается Haskell.

                                                                                1)
                                                                                import Data.List

                                                                                main = mapM_ (putStrLn . foo) [1..6]
                                                                                foo n = concat $ intersperse "-" $ (if odd n then id else reverse) $ take n $ map show [1..]


                                                                                2) (Я сильно вспотел, когда писал это)
                                                                                codepad.org/NQUSqcjc
                                                                                  +1
                                                                                  После прочтения условия «Естественно, вместо 6 может быть любое число», появилось нездоровое желание вместо «6» влепить рандом))))) а остальное вывести принтом)
                                                                                    0
                                                                                    На APL будет одно выражение, но довольно говнокодистое:

                                                                                    image
                                                                                      +2
                                                                                      Блин, пропустил первые строки, предится через цикл:


                                                                                      –3
                                                                                      Java:

                                                                                      String s = "1";
                                                                                      for(int i = 2; i <= 6; i++)
                                                                                         System.out.println(s = i + "-" + s);
                                                                                      


                                                                                      Сомневаюсь что возможно короче. Данную задачу выполняет, масштабируется заменой константы «6» в цикле.
                                                                                      Самый говонокод, по моему мнению, написал Davert в первом комменте.
                                                                                        +3
                                                                                        У вас строка не разворачивается через одну
                                                                                          –1
                                                                                          Упс, прошу прощения. Только проснулся, невнимательно прочитал условие.
                                                                                        +4
                                                                                        Однако смотрю в коде народ активно использует массивы, вот вам + немного говнокода :)
                                                                                        <?php
                                                                                        define('LENGTH',6);
                                                                                        define('nl',"\n");

                                                                                        $right='1';
                                                                                        $left='1';
                                                                                        echo '1'.nl; // <== это он
                                                                                        for($i=2;$i<=LENGTH;$i++)
                                                                                        {
                                                                                            $left=$i.'-'.$left;
                                                                                            $right=$right.'-'.$i;
                                                                                            echo ($i%2?$right:$left).nl;
                                                                                        }
                                                                                        ?>
                                                                                          0
                                                                                          Без массивов это правильно, я тоже сделал без массивов. Но вот константы то зачем объявлять, да еще и писать их с учетом coding style?
                                                                                            0
                                                                                            У Вас пока самый читабельный вариант из всех.
                                                                                              0
                                                                                              А что, PHP_EOL уже запретили?
                                                                                                0
                                                                                                Интересно, почему вы это называете говнокодом?
                                                                                                По-моему, одно из лучших решений!
                                                                                                +1
                                                                                                Нечитаемый питоноговнокод:
                                                                                                print "\n".join(['-'.join([str(i) for i in n%2 and range(1, n+1) or range(n, 0, -1)]) for n in range(1, int(raw_input()) + 1)])
                                                                                                  +1
                                                                                                  Коль такая пьянка:

                                                                                                  #нормальный вариант
                                                                                                  def gen(n):
                                                                                                      for line in xrange(1, n+1):
                                                                                                          res = [item for item in xrange(1, line+1)]
                                                                                                          res = sorted(res, reverse= not line%2)
                                                                                                          print("-".join((str(i) for i in res)))
                                                                                                              
                                                                                                  gen(6)
                                                                                                  
                                                                                                  #однострочник
                                                                                                  def gen(n):
                                                                                                      return "\n".join(
                                                                                                          ("-".join(
                                                                                                              sorted((str(x) for x in xrange(1, b+1)), reverse=(b+1)%2)) 
                                                                                                             for b in xrange(1, n+1)
                                                                                                           )
                                                                                                          )
                                                                                                  
                                                                                                  print(gen(6))
                                                                                                  
                                                                                                    +3
                                                                                                    Придумал ещё хуже:
                                                                                                    lambda x: "\n".join('-'.join(map(str,range(1, n+1))[::bool(n%2) or -1]) for n in range(1, x + 1))
                                                                                                      0
                                                                                                      Итерация для джойна лишьняя
                                                                                                      #нормальный вариант
                                                                                                      def gen(n):
                                                                                                          for line in xrange(1, n+1):
                                                                                                              res = [str(item) for item in xrange(1, line+1)]
                                                                                                              res = sorted(res, reverse= not line%2)
                                                                                                              print("-".join(res))
                                                                                                                  
                                                                                                      gen(6)
                                                                                                      
                                                                                                        0
                                                                                                        питон pastie.org/1782311 :)
                                                                                                    0
                                                                                                    <?php

                                                                                                    $sign = true;
                                                                                                    for($i=1; $i <=6; $i++) {
                                                                                                    echo implode('-', $sign ? range(1, $i) : range($i, 1)) . "\n";
                                                                                                    $sign = !$sign;
                                                                                                    }
                                                                                                      0
                                                                                                      Version 2.0 :)

                                                                                                      for($i=1; $i <=6; $i++) {
                                                                                                      echo implode('-', $i % 2 ? range(1, $i) : range($i, 1)) . "\n";
                                                                                                      }

                                                                                                        0
                                                                                                        Это можно даже свести к вот такому:

                                                                                                          0
                                                                                                          for($i=1; $i <=6; $i++) {echo implode('-', ($sign = !$sign)? range(1, $i): range($i, 1)). "
                                                                                                          ";}
                                                                                                        +12
                                                                                                        >+++++++>+++++++>+++++++>+++++++>+++++++>+++++++>+++++++<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<+++++++++[>+++++<-]++++++++++>
                                                                                                        >.< <.>
                                                                                                        >>.<<.>.< <.>
                                                                                                        >.<.>>.<<.>>>.<<< <.>
                                                                                                        >>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
                                                                                                        >.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
                                                                                                        >>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
                                                                                                        Ну а говнокодистое на один экран наверное не влезет :)
                                                                                                          +19
                                                                                                          У Вас [ пропущена после восьмого символа (перед вторым >)
                                                                                                            –1
                                                                                                            По моему исходя из того, что браинфак вообще в принципе не читабельный язык, то довольно сложно или даже невозможно сделать что-либо «неговнокодистое». ( не в обиду любителям )
                                                                                                              0
                                                                                                              пара символов в начале проги пропущено.
                                                                                                              PS: предлагаю посоревноваться на размер brainfuck-ового исходника (мой см. ниже) ;-)
                                                                                                                +3
                                                                                                                Пропущена кавычка только одна, как и сказал pechlambda :)
                                                                                                                Оптимизировал:
                                                                                                                >+++++++[>+++++++<-]>[>+>+>+>+>+>+<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<<+++++++++[>+>+++++<<-]>+>
                                                                                                                >.< <.>
                                                                                                                >>.<<.>.< <.>
                                                                                                                >.<.>>.<<.>>>.<<< <.>
                                                                                                                >>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
                                                                                                                >.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
                                                                                                                >>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<

                                                                                                                Итого без лишних пробелов и переносов строк мой вариант получился в 261 байт, твой в 279 :-)
                                                                                                                  +3
                                                                                                                  ++++++++++[>+++++>+<<-]>[>>+>+
                                                                                                                  >+>+>+>+>+<<<<<<<<-]>>----->->
                                                                                                                  >+>++>+++>++++<<<<<.<<.>>>.<<.
                                                                                                                  >.<<.>>.<.>>.<<.>>>.<<<<.>>>>>
                                                                                                                  .<<<<.>>>.<<<.>>.<<.>.<<.>>.<.
                                                                                                                  >>.<<.>>>.<<<.>>>>.<<<<.>>>>>.
                                                                                                                  <<<<<<.>>>>>>>.<<<<<<.>>>>>.<<
                                                                                                                  <<<.>>>>.<<<<.>>>.<<<.>>.<<.>.
                                                                                                                  <<.

                                                                                                                  243 вроде
                                                                                                                    +2
                                                                                                                    +++++++[>+>+++++++>+++++++<<<-]>+++>.>----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
                                                                                                                    141 байт
                                                                                                                      +2
                                                                                                                      ++++++++++[>+>+++++>+++++<<<-]>>-.>-----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
                                                                                                                      на 2 меньше
                                                                                                                        +1
                                                                                                                        даже вот так:
                                                                                                                        +++++[>++>++++++++++>+++++++++<<<-]>>-.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
                                                                                                                          +2
                                                                                                                          +++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
                                                                                                                          Еще на 2 меньше, 135 байт
                                                                                                                            +4
                                                                                                                            +++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>>>++++[<<.+>.>-]<<.<.>++>>+++++[<<-.>.>-]<<-.
                                                                                                                            129 байт :-)
                                                                                                                              +3
                                                                                                                              Отец!
                                                                                                                                +4
                                                                                                                                +++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>>>++++[<<.+>.>-]<<.<.>+.>>+++++[<.<-.>>-]

                                                                                                                                125 байт. Где чего еще можно соптимизировать — уже не знаю :-) Циклы помогают только для двух последних строк (для четвертой можно, получится байт-в-байт), но уменьшить их хоть на байт вроде уже нельзя. Подозреваю, что можно уменьшить самое начало, где записываются коды символов, но как — тоже не знаю.
                                                                                                                                Я таки победил? :-)
                                                                                                                                  +1
                                                                                                                                  Для любого четного m от 2 до 8, йоу! 120 байт!

                                                                                                                                  ++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>>>+>[<+>-]<<<+.>>[<.<-.>>->+<]>[<+>-]<+<<<.<<--]
                                                                                                                                    +2
                                                                                                                                    104 =)

                                                                                                                                    ++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>+.>>>+[<<.<-.>>>-<+>]<+<<<.<<--]
                                                                                                                                      0
                                                                                                                                      +++++[>+>++>++++++++
                                                                                                                                      ++>+++++++++<<<<-]>+
                                                                                                                                      >>-<<[>>.>>[<.<+.>>-
                                                                                                                                      >+<]<<<.>+.>>>+[<<.<
                                                                                                                                      -.>>>-<+>]<+<<<.<--]

                                                                                                                                      ровно 100
                                                                                                                                        0
                                                                                                                                        +++++[>+>++>+++[>+++
                                                                                                                                        >+++<<-]<<<-]>>>>+++
                                                                                                                                        +<<<+[>>>.<[>>.>+<<+
                                                                                                                                        .<-]<.>>+.>>+[<.<-.<
                                                                                                                                        +>>>-]<<<+<.<--]

                                                                                                                                        96
                                                                                                                                          0
                                                                                                                                          ^^
                                                                                                                                          Единственный минус такой оптимизации — теперь не очевидно, где же m задается)
                                                                                                                                            +2
                                                                                                                                            +++++[>++>+++[>+++>+++<<-]<<-]+++>>>++++<<<[>>>.<[>>.>+<<+.<-]<.>>+.>>+[<.<-.<+>>>-]<<<+<.<-]
                                                                                                                                            93
                                                                                                                                              +2
                                                                                                                                              +++++[>++>+++[>+++>+++<<-]>+<<<-]+++[>>>-.<[>>.>+<<+.<-]<.>>+.>>+[<.<-.<+>>>-]<<+<+<.<-]
                                                                                                                                              88 байт
                                                                                                                                                0
                                                                                                                                                да, тут похоже уже ничего не оптимизируешь. еще два варианта с такой же длиной нашел.
                                                                                                                                                  +1
                                                                                                                                                  Самое смешное, что код на брейнфаке оказался гораздо меньше аналогичного кода на остальных языках :-)
                                                                                                                                        0
                                                                                                                                        вчера заснул, пытаясь реализовать то же самое :-)
                                                                                                                      0
                                                                                                                      тимати в записи c конференции для хохмы? :)
                                                                                                                        0
                                                                                                                        Почти.
                                                                                                                        Это не конференция, а devclub — клуб девелоперов. Поэтому песня нужна, чтобы подчеркнуть клубную атмосферу.
                                                                                                                        0
                                                                                                                        Думаю, что сама постановка задачи сформулирована неправильно. Она целенаправленна, что уже гарантирует по крайней мере на 50 % не г… Что бы точно вышло Г… надо говорить так. — Ну это не подходит! (без малейших объяснений), а сделайте так как у нас положено, принято и нам нравится.
                                                                                                                          +1
                                                                                                                          Меня всегда интересовал вопрос, почему появляется говнокод.
                                                                                                                          Что послужило причиной появления:
                                                                                                                          Boolean b = new Boolean( is_admin );
                                                                                                                          if( b.toString().length() == 4 ) {
                                                                                                                          }

                                                                                                                          Если честно, то очень хотелось бы комментариев от его авторов.

                                                                                                                          Я могу представить только вариант постепенной доработки кода разными программистами в условиях жуткого аврала:
                                                                                                                          1. вначале был относительно нормальный код, в переменной int exit_code хранился код ошибки (4 — плохо, произошло то-то и то-то)
                                                                                                                          2. а потом бабах и для упрощения (оптимизации) решили объединить обработку этой ошибки с еще несколькими, ввели переменую boolean b.
                                                                                                                          3. заменили регекспом везде exit_code на b.toString().length(), чтобы типы данных остались прежними…

                                                                                                                          Короче, моя мысль такая: отборный говнокод появляется в результате оптимизации.
                                                                                                                            +3
                                                                                                                            Абсолютно согласен и могу добавить ещё одну причину:
                                                                                                                            недостаточное знание языка программирования, то есть человек пишет совсем на другом, а с этим ему надо поработать эпизодически и оттуда тоже появляются шедевры. Я выше написал своё решение на Perl как написал бы опытный программист(1) и как мог бы написать неопытный(2).
                                                                                                                              0
                                                                                                                              Ну-ну, оптимизация сама по себе вещь хорошая, когда она нужна.
                                                                                                                              Думаю, правильнее было бы сказать так: отборный говнокод появляется в результате изменений кода. Но это, простите, КО.
                                                                                                                              –1
                                                                                                                              Ну как-то так:
                                                                                                                              <?
                                                                                                                              $max = 6;
                                                                                                                              $arr = array();
                                                                                                                              for ($i = 1; $i <= $max; $i++)
                                                                                                                              {
                                                                                                                              $arr[] = $i;
                                                                                                                              if (ceil($i / 2) == $i / 2)
                                                                                                                              rsort($arr);
                                                                                                                              else
                                                                                                                              sort($arr);
                                                                                                                              print implode("-", $arr) . "\n";
                                                                                                                              }
                                                                                                                              ?>

                                                                                                                                +1
                                                                                                                                Вообще, задача такова, что любое решение будет похоже на гавнокод. Вот для Java, решение в самый лоб. Вроде чисто под задачу «вывести в столбик», без выдумок, а всё же гавнокод. Дальше я его сокращу.

                                                                                                                                public class Gavnokod1
                                                                                                                                {
                                                                                                                                	final static int N = 6;
                                                                                                                                	
                                                                                                                                	public static void main( String[] args ) {
                                                                                                                                		for( int row=1; row<=N; row++ )	 {
                                                                                                                                			if( row%2 == 1 ) {
                                                                                                                                				for( int pos=1; pos<=row; pos++ ) {
                                                                                                                                					System.out.print(pos);
                                                                                                                                					if(pos!=row)System.out.print("-");
                                                                                                                                				}
                                                                                                                                			}
                                                                                                                                			else
                                                                                                                                			{
                                                                                                                                				for( int pos=row; pos>=1; pos-- ) {
                                                                                                                                					System.out.print(pos);
                                                                                                                                					if(pos!=1)System.out.print("-");
                                                                                                                                				}
                                                                                                                                			}			
                                                                                                                                			System.out.println();
                                                                                                                                		}
                                                                                                                                	}
                                                                                                                                }
                                                                                                                                  +1
                                                                                                                                  Вот решение покороче :)
                                                                                                                                  public class Gavnokod2 {
                                                                                                                                  	final static int N = 6;
                                                                                                                                  	public static void main( String[] args ) {
                                                                                                                                  		for (int row=1;row<=N;row++)
                                                                                                                                  			for (int pos=row%2==1?1:row;row%2==1?pos<=row:pos>=1;pos+=row%2==1?1:-1)
                                                                                                                                  				System.out.print(pos+(pos!=(row%2==1?row:1)?"-":"\n"));
                                                                                                                                  	}
                                                                                                                                  }
                                                                                                                                  Решение как решение, но всё равно гавнокод, потому что сложночитаемый, хотел сократить кол-во операторов и строк.
                                                                                                                                    –2
                                                                                                                                    Настоящий говнокод — это решение влоб, покрывающее строго фиксированный интервал значений.

                                                                                                                                    if ( n >= 1 )
                                                                                                                                    System.out.println( «1» );
                                                                                                                                    if ( n >= 2 )
                                                                                                                                    System.out.println( «2-1» );
                                                                                                                                    if ( n >= 3 )
                                                                                                                                    System.out.println( «1-2-3» );
                                                                                                                                    if ( n >= 4 )
                                                                                                                                    Ыystem.out.println( «4-3-2-1» );
                                                                                                                                    if ( n >= 5 )
                                                                                                                                    System.out.println( «1-2-3-4-5» );
                                                                                                                                    if ( n >= 6 )
                                                                                                                                    System.out.println( «6-5-4-3-2-1» );
                                                                                                                                      +4
                                                                                                                                      Да, в продолжение ещё хотел написать код с парой фабрик (на алгоритм рисования этой пирамиды и на рисование строк), но на середине бросил и подумал, что это уже слишком. Хотя получалось нечто java-красивое :)) Вот остановился на другом упрощённом варианте с листенерами, пока хватит.

                                                                                                                                      /**
                                                                                                                                       * Обработчик печати.
                                                                                                                                       * ... тут куча описания ...
                                                                                                                                       */
                                                                                                                                      interface PrintListener {
                                                                                                                                      	/**
                                                                                                                                      	 * Печать объекта последовательности. 
                                                                                                                                      	 * @param num номер объекта в последовательности.
                                                                                                                                      	 * @return true, если объект не последний, false - в обратном случае.
                                                                                                                                      	 */
                                                                                                                                      	 boolean print( int num );
                                                                                                                                      }
                                                                                                                                      
                                                                                                                                      /**
                                                                                                                                       * Реализация печати последовательности объектов.
                                                                                                                                       */
                                                                                                                                      class Printer {
                                                                                                                                      	private PrintListener printListener;	
                                                                                                                                      	public Printer( PrintListener printListener ) {
                                                                                                                                      		this.printListener = printListener;
                                                                                                                                      	}	
                                                                                                                                      	public void print() {
                                                                                                                                      		int num = 1;
                                                                                                                                      		while ( printListener.print( num++ ) );
                                                                                                                                      	}
                                                                                                                                      }
                                                                                                                                      
                                                                                                                                      public class Gavnokod4 {
                                                                                                                                      	final static int N = 6;
                                                                                                                                      	public static void main( String[] args ) {
                                                                                                                                      		// запускаем печаталку строк
                                                                                                                                      		new Printer( new PrintListener() {
                                                                                                                                      			@Override
                                                                                                                                      			public boolean print( final int row )
                                                                                                                                      			{
                                                                                                                                      				// запускаем печаталку столбцов в каждой строке
                                                                                                                                      				new Printer( new PrintListener() {
                                                                                                                                      					@Override
                                                                                                                                      					public boolean print( final int col )
                                                                                                                                      					{
                                                                                                                                      						System.out.print( row%2==1 ? col : row-col+1 );
                                                                                                                                      						System.out.print( col < row ? "-" : "\n" );
                                                                                                                                      						// печатаем пока столбцов меньше строк
                                                                                                                                      						// (у нас же половинка матрицы)
                                                                                                                                      						return col<row;
                                                                                                                                      					}
                                                                                                                                      				}).print();
                                                                                                                                      				// печатаем пока не напечатано нужное кол-во строк
                                                                                                                                      				return row<N; 
                                                                                                                                      			}
                                                                                                                                      		}).print();
                                                                                                                                      	}
                                                                                                                                      }
                                                                                                                                        0
                                                                                                                                        Вот переписать подобное ООП-решение на PHP с использованием MVC-фреймворка (Yii тот же) ради вывода этих 6ти строчек — пожалуй, говнокодисто будет.
                                                                                                                                        –2
                                                                                                                                        А на brainfuck'е никто ещё не написал? Интересно, как будет говнокод от нормального кода на нём отличаться…
                                                                                                                                          +2
                                                                                                                                          а блин пока писал коммент уже написали =)
                                                                                                                                            –1
                                                                                                                                            Эх, у меня такая же проблема (:
                                                                                                                                            +7
                                                                                                                                            image
                                                                                                                                            0
                                                                                                                                            На тикле:
                                                                                                                                            -в стиле каки:
                                                                                                                                            puts "1\n2-1\n1-2-3\n4-3-2-1\n1-2-3-4-5\n6-5-4-3-2-1\n"
                                                                                                                                            -со списками, самый простой:
                                                                                                                                            set x [split 1/2-1/1-2-3/4-3-2-1/1-2-3-4-5/6-5-4-3-2-1 "/"];
                                                                                                                                            foreach j $x{ puts "$j\n";}

                                                                                                                                              0
                                                                                                                                              Хотя можно запихать в цикл, но сейчас нет времени писать. Мейби к вечеру напишу)
                                                                                                                                              +6
                                                                                                                                              Достаточно говнокодисто получилось:

                                                                                                                                              <?php
                                                                                                                                              $Tsyfry=array(
                                                                                                                                                  'error',
                                                                                                                                                  '1',
                                                                                                                                                  '1-2',
                                                                                                                                                  '1-2-3',
                                                                                                                                                  '1-2-3-4',
                                                                                                                                                  '1-2-3-4-5',
                                                                                                                                                  '1-2-3-4-5-6',
                                                                                                                                              );
                                                                                                                                              
                                                                                                                                              $Naoborot=false;
                                                                                                                                              
                                                                                                                                              for($i=0;$i<=6;$i++) {
                                                                                                                                                  if (!$i) continue;
                                                                                                                                                  if ($i==1) $Stroka=$Tsyfry[1];
                                                                                                                                                  if ($i==2) $Stroka=$Tsyfry[2];
                                                                                                                                                  if ($i==3) $Stroka=$Tsyfry[3];
                                                                                                                                                  if ($i==4) $Stroka=$Tsyfry[4];
                                                                                                                                                  if ($i==5) $Stroka=$Tsyfry[5];
                                                                                                                                                  if ($i==6) $Stroka=$Tsyfry[6];
                                                                                                                                                  if ($i==7) $Stroka=$Tsyfry[7];
                                                                                                                                              
                                                                                                                                                  if ($Naoborot==false) {
                                                                                                                                                      echo $Stroka;
                                                                                                                                                      echo "\n";
                                                                                                                                                  }
                                                                                                                                                  if ($Naoborot==true) {
                                                                                                                                                      $Stroka_array=preg_split('//',$Stroka);
                                                                                                                                                      $Stroka_array=array_reverse($Stroka_array);
                                                                                                                                                      $Stroka=implode($Stroka_array);
                                                                                                                                                      echo $Stroka;
                                                                                                                                                      echo "\n";
                                                                                                                                                  }
                                                                                                                                              
                                                                                                                                                  if ($Naoborot==false) $Naoborot=true;
                                                                                                                                                  else $Naoborot=false;
                                                                                                                                              }
                                                                                                                                              ?>
                                                                                                                                              
                                                                                                                                              
                                                                                                                                                +1
                                                                                                                                                Еще переменные надо переименовать. Например, Stroka в Naoborot, Noborot в Stroka, Stroka_array в hz_list_false_or_true.
                                                                                                                                                  +1
                                                                                                                                                  Понравились ваши имена переменных!
                                                                                                                                                  Вчера заглядывал в БД PHPShop, повеселили названия полей в некоторых таблицах:
                                                                                                                                                  baseinputvaluta
                                                                                                                                                  odnotip
                                                                                                                                                  sklad_action
                                                                                                                                                  title_shablon
                                                                                                                                                  kurs
                                                                                                                                                  otsiv
                                                                                                                                                  otvet
                                                                                                                                                  +9
                                                                                                                                                  Я прошу прощения, но то, что большинство людей написало в комментариях, считая хорошим кодом, как раз и есть говнокод. Имхо, самое главное отрицательное качество говнокода — не большой размер, а нечитабельность. Хороший код должен читаться как хорошая книга. Если ваш язык программирования позволяет использовать высокоуровневые конструкции, зачем вы продолжаете пытаться писать на брейнфаке?

                                                                                                                                                  Я написал два примера кода, оба считаю далеко не идеальными. Уверен, каждый сможет найти более десятка замечаний. Первый больше приспособлен к дальнейшему изменению и расширению. Второй
                                                                                                                                                  «в одну строчку». Лично я считаю примером говнокода скорее второй вариант. Готов обсудить.

                                                                                                                                                  И извините за названия классов.
                                                                                                                                                    0
                                                                                                                                                    Вы верно пишете про приоритет читабельности.
                                                                                                                                                    Только высокоуровневые конструкции != читабельность.
                                                                                                                                                      0
                                                                                                                                                      Вы сильно категоричны. Я считаю, что хороший код должен показывать скорее что он делает, нежели как он это делает. Опять же, это скорее применимо к большим enterprise системам. Конечно, для низкоуровневых программ, где требуется прежде всего скорость, иногда нужно оптимизировать в ущерб читабельности.
                                                                                                                                                        +1
                                                                                                                                                        Никакой категоричности. Я как раз согласен, что по коду должна быть понятна задача, которую он выполняет. Только вот Ваш ООП-вариант несмотря на расширяемость (хотя вероятность того, что данный код потребует расширения минимальна), на мой взгляд описывает решаемую задачу хуже, чем пример без высокоуровневых конструкций выше.
                                                                                                                                                        Хотя по скорости Ваш вариант должен быть быстрее ввиду отсутствия работы со строками, но это в расчет не берём.
                                                                                                                                                          0
                                                                                                                                                          Мой вариант не претендует на идеальность и он не объектно-ориентированный, поскольку используются статические методы класса.
                                                                                                                                                          По поводу примера по Вашей ссылке, я рассматривал подобную реализацию, согласен, она гораздо лучше читается, но не выдерживает совершенно никакой критики как по производительности, так и по используемой памяти (а что, если n будет равно 100000000?). Тут, мне кажется, уместнее всё же сохранять баланс между тривиальной оптимизацией и размером кода.
                                                                                                                                                            +1
                                                                                                                                                            На статические методы внимания не обратил, извиняюсь, на Java никогда не писал. В целом мы вроде пришли к единому мнению, что тот код несмотря на отсутствие высокоуровневых конструкций читается лучше. А читабельность приоритетна, и в этом был посыл Вашего сообщения, не так ли?

                                                                                                                                                            И n=10^8 конечно интересно, но уже из области преждевременной оптимизации. Всё таки наиболее вероятно, что выводить на экран строку, превышающую по длине ширину экрана не потребуется, и потому тот код вряд ли будет являться узким местом в системе. Т.е. можно осознанно его выбрать как более читабельный, но менее производительный.
                                                                                                                                                              0
                                                                                                                                                              Согласен.
                                                                                                                                                      0
                                                                                                                                                      В этом ничего удивительного нет. «Говнокод» очень широкое понятие, поэтому многие к нему относятся по разному. Опять же, читабельность кода также зависит и от глубины понимания языка программирования.

                                                                                                                                                      P.S. в Java не сильно разбираюсь, потому оценить ваш код не смогу никак.
                                                                                                                                                        0
                                                                                                                                                        Поддерживаю! Читабельность, на мой взгляд, — один из главных критериев хорошего кода.
                                                                                                                                                        Естественно, сам код с точки зрения алгоритма должен быть верен и оптимален, но это должно подразумеваться само собой :)
                                                                                                                                                        Ниже в комментариях я оставил свой пример того, что считаю хорошим примером кода.
                                                                                                                                                        +1
                                                                                                                                                        Python:

                                                                                                                                                        def foo(n):
                                                                                                                                                        for i in range(1,n+1):
                                                                                                                                                        seq = map(lambda n: str(n), range(1,i+1))
                                                                                                                                                        if i%2 == 0:
                                                                                                                                                        seq = reversed(seq)
                                                                                                                                                        print '-'.join(seq)

                                                                                                                                                        foo(6)
                                                                                                                                                          0
                                                                                                                                                          Извиняюсь за форматирование. Здесь можно посмотреть в нормальном виде:
                                                                                                                                                          pastebin.com/GEreUx2j
                                                                                                                                                            0
                                                                                                                                                            для говнокода как-то не очень говнисто, а для хорошего решения не очень чисто
                                                                                                                                                              0
                                                                                                                                                              Да. Как минимум, можно было списковую сборку использовать вместо lambda. Действительно, в этот конкретном случае, lambda и map — излишество.
                                                                                                                                                          –6
                                                                                                                                                          На мой взгляд, использование подобной лексики в постах недопустимо на ресурсах вроде Хабра, на который заходят в большинстве своем, по-моему мнению, серьезные люди.
                                                                                                                                                            +4
                                                                                                                                                            я кроме Вас серьезных людей тут не встречал.
                                                                                                                                                              –5
                                                                                                                                                              Забыл добавить — взрослых. Надо же так ошибиться в Хабре…
                                                                                                                                                                +2
                                                                                                                                                                ничего страшного, это очень распространенная ошибка.
                                                                                                                                                                  –5
                                                                                                                                                                  Спасибо Вам за Ваши минусы!
                                                                                                                                                                    +5
                                                                                                                                                                    серьезный человек заслуживает серьезного подхода.
                                                                                                                                                              0
                                                                                                                                                              Мысль нужно озвучивать в должной форме, дабы исключить ее двоякое толкование.
                                                                                                                                                                0
                                                                                                                                                                А в меньшинстве своём, но всё-таки заходят, дети. Им такие слова уж и подавно нельзя показывать!
                                                                                                                                                                  0
                                                                                                                                                                  «Подобной» лексики — это какой?
                                                                                                                                                                  Вы имеете в виду «говнокод»? Согласен, лучше было бы использовать что-нибудь поприличней, но человечество не придумало ещё такого термина, который бы так же точно отражал суть предмета.
                                                                                                                                                                    0
                                                                                                                                                                    Именно такой. Да и еще на главной странице. Не знаю, известно ли вам, но некоторые слова в приличном обществе не употребляют. А все оправдания — дешевые отмазки.
                                                                                                                                                                      +1
                                                                                                                                                                      Зато, как видно, в приличном обществе принято использовать слэнговые слова, пришедшие из криминального жаргона.

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

                                                                                                                                                                      Кстати, надо бы еще обратиться к администрации хабра, чтобы он переименовали блог code_wtf в что-нибудь более приличное, ведь «wtf» переводится на русский язык еще неприличнее.
                                                                                                                                                                  0
                                                                                                                                                                  $a = array();
                                                                                                                                                                  for($i=1;$i<7;$i++)
                                                                                                                                                                  {
                                                                                                                                                                  $a[]=$i;
                                                                                                                                                                  echo implode('-', $i%2 ? $a : array_reverse($a)), '
                                                                                                                                                                  ';
                                                                                                                                                                  }
                                                                                                                                                                    0
                                                                                                                                                                    А почему все используют массивы как само собой разумеющееся?

                                                                                                                                                                    Циклы же эффективнее — и читаемы не хуже.
                                                                                                                                                                      0
                                                                                                                                                                      function my($v) {
                                                                                                                                                                      	static $s='';
                                                                                                                                                                      	$s .= $v.'-';
                                                                                                                                                                      	echo trim($v%2 ? $s : strrev($s), '-').'<br />';
                                                                                                                                                                      }
                                                                                                                                                                      array_map('my', range(1,6));
                                                                                                                                                                      

                                                                                                                                                                      строки лучше? ))
                                                                                                                                                                        0
                                                                                                                                                                        а как в этом случае без использования второй переменной перевернуть строку вида:
                                                                                                                                                                        1-2-3-...15-16-17-18
                                                                                                                                                                        чтобы 15 при этом не превратилась в 51?
                                                                                                                                                                      +2
                                                                                                                                                                      puts (1..6).map{|n| (1..n).to_a.reverse.join("-")}.join("\n")
                                                                                                                                                                        +1
                                                                                                                                                                        У Вас всегда реверс. Так работает:

                                                                                                                                                                        puts (1..6).map{|n| (1..n).to_a.tap{|a| a.reverse! if n%2==0}.join("-")}.join("\n")
                                                                                                                                                                        0
                                                                                                                                                                        struct ds
                                                                                                                                                                        {
                                                                                                                                                                        unsigned char string[15];
                                                                                                                                                                        unsigned char symbols;
                                                                                                                                                                        unsigned char string number;
                                                                                                                                                                        } ds_one {{'1', '\r', '\n'}, 3, 1} \
                                                                                                                                                                        ds_two {{'2', '-', '1' '\r', '\n'}, 3, 1} \
                                                                                                                                                                        .......

                                                                                                                                                                        ds * xs = {&ds_one, &ds_two, ....};

                                                                                                                                                                        for (unsigned char i = 0, i < sizeof(xs), i++)
                                                                                                                                                                        {
                                                                                                                                                                        for (unsigned char j = 0, j<xs[i]->symbols, j++)
                                                                                                                                                                        {
                                                                                                                                                                        putch(xs[i]->string[j]);
                                                                                                                                                                        }
                                                                                                                                                                        }


                                                                                                                                                                        А че, я всегда так пишу…
                                                                                                                                                                          0
                                                                                                                                                                          тьфу, копипаст подвел. но идея, думаю, понятна.
                                                                                                                                                                          Так, пойду подумаю как это написать в говнокоде.
                                                                                                                                                                          0
                                                                                                                                                                          В Mysql уже говнокодили?

                                                                                                                                                                          SET @r = 0;
                                                                                                                                                                          select
                                                                                                                                                                          ELT(@r:= ROUND(@r+1), '1', '2-1', '1-2-3', '4-3-2-1', '1-2-3-4-5','6-5-4-3-2-1')
                                                                                                                                                                          from information_schema.columns
                                                                                                                                                                          limit 6;

                                                                                                                                                                            0
                                                                                                                                                                            Кстати, а вот получилось более универсальное решение (в третьей колонке)

                                                                                                                                                                            SET @i = 0;
                                                                                                                                                                            SET @s = '';

                                                                                                                                                                            select
                                                                                                                                                                            @i:= ROUND(@i+1),@s := TRIM('-' FROM CONCAT(@s, "-", @i)), IF(@i%2=1, @s, REVERSE(@s)) 'Решение тут'
                                                                                                                                                                            from information_schema.columns
                                                                                                                                                                            limit 6;
                                                                                                                                                                            +1
                                                                                                                                                                            QString string = «6-5-4-3-2-1»;

                                                                                                                                                                            for (int i = 2; i < 12; i+=2) puts(string.right(i));
                                                                                                                                                                              0

                                                                                                                                                                              def f(n):
                                                                                                                                                                              print '-'.join(map(str, xrange(1, n+1))[::-1 if (n+1)%2 else 1])

                                                                                                                                                                                0
                                                                                                                                                                                Говно код — он бывает разные, бывает говно по форме, а бывает говно по сути, вот второе это код из первого камента, а первое — это то чтонаписал krink.
                                                                                                                                                                                По сути все верно, но записано так что ни кто кроме автора тут ничерта не поймет.
                                                                                                                                                                                  0
                                                                                                                                                                                  Как уже писали где-то: задача такая, что тут впринципе ничего вменяемо-понятного написать нельзя. Однозначно чёрт ногу сломит.
                                                                                                                                                                                  +1
                                                                                                                                                                                  <?php echo '<pre>'?>
                                                                                                                                                                                  1
                                                                                                                                                                                  2-1
                                                                                                                                                                                  1-2-3
                                                                                                                                                                                  4-3-2-1
                                                                                                                                                                                  1-2-3-4-5
                                                                                                                                                                                  6-5-4-3-2-1
                                                                                                                                                                                  <?php echo '</pre>'?>
                                                                                                                                                                                    +1
                                                                                                                                                                                    странно, что никто еще не написал проверок в духе if (true=true || 1=1) (:
                                                                                                                                                                                      +1
                                                                                                                                                                                      Тогда уже true!=false или 1!=false
                                                                                                                                                                                        +2
                                                                                                                                                                                        Немножко индийской мудрости тогда не помешает :)

                                                                                                                                                                                        if Lenght(BoolToStr(true)) = 4
                                                                                                                                                                                      +5
                                                                                                                                                                                      +++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

                                                                                                                                                                                      и

                                                                                                                                                                                      ++++++++++++[->++++>+>+<<<]>[->>>+>+>+>+>+>+>+<<<<<<<<<]>+>-->--->+>++>+++>++++>+++++>++++++<<<<<.<<<.>.>>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<<<.>.
                                                                                                                                                                                      >>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<<<<.>.>>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.
                                                                                                                                                                                        0
                                                                                                                                                                                        Длиннокод
                                                                                                                                                                                        0
                                                                                                                                                                                        #!/usr/bin/perl
                                                                                                                                                                                        ...

                                                                                                                                                                                        my @line = ( 1 );
                                                                                                                                                                                        print( @line, "\n" );
                                                                                                                                                                                        for( my $line_number = 2; $line_number <= 6; ++$line_number ) {
                                                                                                                                                                                        @line = ( @line, '-', $line_number );
                                                                                                                                                                                        print( $line_number % 2 ? @line : reverse( @line ), "\n");
                                                                                                                                                                                        }
                                                                                                                                                                                          +1
                                                                                                                                                                                          С отступами:
                                                                                                                                                                                          my @line = ( 1 );
                                                                                                                                                                                          print( @line, "\n" );
                                                                                                                                                                                          for( my $line_number = 2; $line_number <= 6; ++$line_number ) {
                                                                                                                                                                                              @line = ( @line, '-', $line_number );
                                                                                                                                                                                              print( $line_number % 2 ? @line : reverse( @line ), "\n");
                                                                                                                                                                                          }
                                                                                                                                                                                          
                                                                                                                                                                                            0
                                                                                                                                                                                            А вот ровно тоже код, но попорченный:
                                                                                                                                                                                            my @a=(1);for(my $b=(print(@a,"\n"),2);$b<7;$b++){
                                                                                                                                                                                                 @a=(@a,'-',$b);print($b%2?@a:reverse(@a),"\n");}
                                                                                                                                                                                            
                                                                                                                                                                                          0
                                                                                                                                                                                          А я бы написал так, не знаю только говнокод это или нет. Python

                                                                                                                                                                                          def get_arr(n):
                                                                                                                                                                                          out = []
                                                                                                                                                                                          for i in range(1,n+1):
                                                                                                                                                                                          out.append(i)
                                                                                                                                                                                          return out

                                                                                                                                                                                          def print_arr(arr):
                                                                                                                                                                                          out = ""
                                                                                                                                                                                          for i in arr:
                                                                                                                                                                                          out += "%s-" % i
                                                                                                                                                                                          out = out.rstrip('-')
                                                                                                                                                                                          print out

                                                                                                                                                                                          def print_result(n):
                                                                                                                                                                                          to_be_reversed = False
                                                                                                                                                                                          for i in range(1,n+1):
                                                                                                                                                                                          arr = get_arr(i)
                                                                                                                                                                                          if to_be_reversed:
                                                                                                                                                                                          arr.reverse()
                                                                                                                                                                                          print_arr(arr)
                                                                                                                                                                                          to_be_reversed = not to_be_reversed

                                                                                                                                                                                          print_result(6)

                                                                                                                                                                                            0
                                                                                                                                                                                            Извиняюсь, продублирую с отступами, а то непонятно:
                                                                                                                                                                                            def get_arr(n):
                                                                                                                                                                                                out = []
                                                                                                                                                                                                for i in range(1,n+1):
                                                                                                                                                                                                    out.append(i)
                                                                                                                                                                                                return out
                                                                                                                                                                                            
                                                                                                                                                                                            def print_arr(arr):
                                                                                                                                                                                                out = ""
                                                                                                                                                                                                for i in arr:
                                                                                                                                                                                                    out += "%s-" % i
                                                                                                                                                                                                out = out.rstrip('-')
                                                                                                                                                                                                print out
                                                                                                                                                                                            
                                                                                                                                                                                            def print_result(n):
                                                                                                                                                                                                to_be_reversed = False
                                                                                                                                                                                                for i in range(1,n+1):
                                                                                                                                                                                                    arr = get_arr(i)
                                                                                                                                                                                                    if to_be_reversed:
                                                                                                                                                                                                        arr.reverse()
                                                                                                                                                                                                    print_arr(arr)
                                                                                                                                                                                                    to_be_reversed = not to_be_reversed
                                                                                                                                                                                            
                                                                                                                                                                                            
                                                                                                                                                                                            print_result(6)
                                                                                                                                                                                            
                                                                                                                                                                                              0
                                                                                                                                                                                              Для Питона это однозначно говнокод, ведь там в одну-две строчки можно написать, и ничуть не менее читабельно.
                                                                                                                                                                                              Вот на Яве по-другому нельзя.
                                                                                                                                                                                                0
                                                                                                                                                                                                Очень не люблю, когда много написано в одну строку.
                                                                                                                                                                                                Часто приходится разбираться с чужим кодом. Поубивал бы.
                                                                                                                                                                                                Хуже всего:
                                                                                                                                                                                                — Несколько вызовов функций в одной строке
                                                                                                                                                                                                — Невозврат из функций, переход в другое мест по исключению.
                                                                                                                                                                                                Предпочитаю писать так:

                                                                                                                                                                                                result = func1(x,y)
                                                                                                                                                                                                result2 = func2(result)
                                                                                                                                                                                                return result2

                                                                                                                                                                                                чем:

                                                                                                                                                                                                return func2(func1(x,y))
                                                                                                                                                                                            0
                                                                                                                                                                                                    static void Main(string[] args)
                                                                                                                                                                                                    {
                                                                                                                                                                                                        int n = 20;
                                                                                                                                                                                                        bool inv = false;
                                                                                                                                                                                                        StringBuilder sb = new StringBuilder();
                                                                                                                                                                                            
                                                                                                                                                                                                        for (int i = 1; i < n + 1; i++)
                                                                                                                                                                                                        {
                                                                                                                                                                                                            sb.Clear();
                                                                                                                                                                                                            if (!inv)
                                                                                                                                                                                                            {
                                                                                                                                                                                                                for (int z = 1; z < i + 1; z++)
                                                                                                                                                                                                                    sb.Append(z.ToString() + "-");
                                                                                                                                                                                                                inv = true;
                                                                                                                                                                                                            }
                                                                                                                                                                                                            else
                                                                                                                                                                                                            {
                                                                                                                                                                                                                for (int z = i; z > 0; z--)
                                                                                                                                                                                                                    sb.Append(z.ToString() + "-");
                                                                                                                                                                                                                inv = false;
                                                                                                                                                                                                            }
                                                                                                                                                                                                            Console.WriteLine(sb.ToString());
                                                                                                                                                                                                        }
                                                                                                                                                                                            
                                                                                                                                                                                                        Console.ReadKey();
                                                                                                                                                                                                    }
                                                                                                                                                                                              +1
                                                                                                                                                                                              Использования modulo вместо булочной переменной

                                                                                                                                                                                              class Program
                                                                                                                                                                                                {
                                                                                                                                                                                                  static void Main(string[] args)
                                                                                                                                                                                                  {
                                                                                                                                                                                                    int n = 20;
                                                                                                                                                                                                    //bool inv = false;
                                                                                                                                                                                                    StringBuilder sb = new StringBuilder();

                                                                                                                                                                                                    for (int i = 1; i < n + 1; i++)
                                                                                                                                                                                                    {
                                                                                                                                                                                                      sb.Clear();
                                                                                                                                                                                                      if ((i%2)>0)
                                                                                                                                                                                                      {
                                                                                                                                                                                                        for (int z = 1; z < i + 1; z++)
                                                                                                                                                                                                          sb.Append(z.ToString() + "-");
                                                                                                                                                                                                      }
                                                                                                                                                                                                      else
                                                                                                                                                                                                      {
                                                                                                                                                                                                        for (int z = i; z > 0; z--)
                                                                                                                                                                                                          sb.Append(z.ToString() + "-");
                                                                                                                                                                                                      }
                                                                                                                                                                                                      Console.WriteLine(sb.ToString());
                                                                                                                                                                                                    }

                                                                                                                                                                                                    Console.ReadKey();
                                                                                                                                                                                                  }
                                                                                                                                                                                                }


                                                                                                                                                                                              * This source code was highlighted with Source Code Highlighter.
                                                                                                                                                                                              0
                                                                                                                                                                                              Есть источник вдохновения, но лень писать, потому делаем на ПХП так:
                                                                                                                                                                                              генерим массивы через рэйндж и джоиним их.
                                                                                                                                                                                              Нечетные строки реверсим.
                                                                                                                                                                                              Обнаруживаем, что не работает для двузначных чисел, потому для каждой такой подстроки находим числа по регекспу(естественно, извратному), реверсим и возвращаем в строку.
                                                                                                                                                                                                0
                                                                                                                                                                                                >>> n = 6
                                                                                                                                                                                                >>> print '\n'.join(map(lambda l: ' '.join(map(str, len(l)%2 and l or (reversed(l)))), [[k for k in range(1, i+1)] for i in range(1, n+1)]))
                                                                                                                                                                                                1
                                                                                                                                                                                                2 1
                                                                                                                                                                                                1 2 3
                                                                                                                                                                                                4 3 2 1
                                                                                                                                                                                                1 2 3 4 5
                                                                                                                                                                                                6 5 4 3 2 1
                                                                                                                                                                                                  –1
                                                                                                                                                                                                  1.upto(6) {|i| p (1..i).to_a.tap{|a| a.reverse! if i.even?}.join('-')}

                                                                                                                                                                                                  Пост превосходства руби над другими жалкими языками. Говнокод попозже придумаю. Даже на руби можно говнокодить (
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Имена переменных должны быть осмысленные. Мне мой код нравится больше (см. выше) мой код на perl
                                                                                                                                                                                                      0
                                                                                                                                                                                                      Ну в таком случае ничем, ничем не могу помочь. Конечно, давайте самые незначительные счётчики в итерация называть осмысленно. Вот уже где говнокод так говнокод.
                                                                                                                                                                                                        +2
                                                                                                                                                                                                        Если счетчик можно назвать осмысленно, то почему бы этого не сделать? :)
                                                                                                                                                                                                          –1
                                                                                                                                                                                                          Чтобы код выглядел легче. В первую очередь. Во вторую — потому что так принято. И какой бы ты код ни читал тебе не придётся запоминать, что переменная lineNumber — это сраный счётчик в цикле. Если глаз видит i — мозг уже знает, что к чему.
                                                                                                                                                                                                            +1
                                                                                                                                                                                                            Глядя на i я вижу мнимую единицу. Может быть потому, что я слишком много писал реализацию алгоритмов для моделирования динамики систем описываемых уравнением Шредингера?
                                                                                                                                                                                                              –4
                                                                                                                                                                                                              Вот я даже не знаю, что ответить на этот бред. Мне срать, что ты там видишь, ок? Я тебе говорю о том, как принято делать и писать код. Это не моё личное мнение.

                                                                                                                                                                                                    +1
                                                                                                                                                                                                    Позволю себе продемонстрировать, что я считаю не говнокодом. Документация и хорошая читаемость кода, на мой взгляд, — очень важные вещи.

                                                                                                                                                                                                    1.  /// <summary>
                                                                                                                                                                                                    2.  /// Prints <paramref name="lines"/> number of lines in the
                                                                                                                                                                                                    3.  /// following format:
                                                                                                                                                                                                    4.  /// <example>
                                                                                                                                                                                                    5.  ///  1
                                                                                                                                                                                                    6.  ///  2-1
                                                                                                                                                                                                    7.  ///  1-2-3
                                                                                                                                                                                                    8.  ///  4-3-2-1
                                                                                                                                                                                                    9.  /// </example>
                                                                                                                                                                                                    10. ///
                                                                                                                                                                                                    11. /// Each line represents a sequence which consists of <c>n</c>
                                                                                                                                                                                                    12. /// numbers, <c>n</c> being the 1-based sequence number of the
                                                                                                                                                                                                    13. /// line. In every second line the order of numbers is reverted.
                                                                                                                                                                                                    14. /// </summary>
                                                                                                                                                                                                    15. /// <param name="lines">The number of lines to display.</param>
                                                                                                                                                                                                    16. public void PrintSequence(int lines)
                                                                                                                                                                                                    17. {
                                                                                                                                                                                                    18.     //
                                                                                                                                                                                                    19.     // On each iteration, this list stores the sequence of
                                                                                                                                                                                                    20.     // numbers corresponding to the current line.
                                                                                                                                                                                                    21.     //
                                                                                                                                                                                                    22.     List<int> currentNumbers = new List<int>();
                                                                                                                                                                                                    23.  
                                                                                                                                                                                                    24.     for(int n = 1; n <= lines; n++)
                                                                                                                                                                                                    25.     {
                                                                                                                                                                                                    26.         currentNumbers.Add(n + 1);
                                                                                                                                                                                                    27.  
                                                                                                                                                                                                    28.         //
                                                                                                                                                                                                    29.         // This temporary array will contain the actual sequence
                                                                                                                                                                                                    30.         // of numbers to display.
                                                                                                                                                                                                    31.         //
                                                                                                                                                                                                    32.         int[] tempArray = currentNumbers.ToArray();
                                                                                                                                                                                                    33.  
                                                                                                                                                                                                    34.         //
                                                                                                                                                                                                    35.         // If the line number is even, reverse the order.
                                                                                                                                                                                                    36.         //
                                                                                                                                                                                                    37.         if(n % 2 == 0)
                                                                                                                                                                                                    38.         {
                                                                                                                                                                                                    39.             Array.Reverse(tempArray);
                                                                                                                                                                                                    40.         }
                                                                                                                                                                                                    41.  
                                                                                                                                                                                                    42.         //
                                                                                                                                                                                                    43.         // Concatenate the sequence into resulting string.
                                                                                                                                                                                                    44.         //
                                                                                                                                                                                                    45.         string outputLine =
                                                                                                                                                                                                    46.             String.Join(
                                                                                                                                                                                                    47.                 @"-",
                                                                                                                                                                                                    48.                 Array.ConvertAll(tempArray, v => v.ToString()));
                                                                                                                                                                                                    49.  
                                                                                                                                                                                                    50.         //
                                                                                                                                                                                                    51.         // Finally, print the line to screen.
                                                                                                                                                                                                    52.         //
                                                                                                                                                                                                    53.         Console.WriteLine(outputLine);
                                                                                                                                                                                                    54.     }
                                                                                                                                                                                                    55. }
                                                                                                                                                                                                    * This source code was highlighted with Source Code Highlighter.
                                                                                                                                                                                                      +1
                                                                                                                                                                                                      Очень много комментариев. ИМХО, нужно стремиться к тому, чтобы комментариев было бы поменьше, а сам код читался бы как комментарии.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        Да, может быть, я немного переборщил с комментариями в самом коде. Но шапку с summary я бы точно оставил как есть.
                                                                                                                                                                                                        0
                                                                                                                                                                                                        Ваш код хорошо читаем. Комментарии — это тоже очень правильно. Выше уже написали, что в данном примере комментариев избыточно много. Но, имхо, лучше, когда комментариев много, чем когда их нет. К сожалению, Вы совершенно не думаете о производительности.
                                                                                                                                                                                                          +3
                                                                                                                                                                                                          Я думаю о производительности, когда стоит такая задача :) В данном случае я стремился сделать код как можно более читабельным. Если он будет работать медленно, то его можно переписать, но это, скорее всего, ухудшит читаемость.
                                                                                                                                                                                                          Однако, как показывает практика, до проблем со скоростью дело доходит крайне редко, и намного большие проблемы возникают из-за трудностей в поддержке кода.

                                                                                                                                                                                                          Впрочем, когда передо мной стоит задача что-то реализовать, я сначала выясняю все подробности о том, в каких условиях будет работать решение, и тогда уже принимаю тактические решения по балансу производительности/краткости/читаемости кода. В данном же случае про производительность в задаче ничего не сказано, поэтому я просто продемонстрировал читаемость.
                                                                                                                                                                                                            +1
                                                                                                                                                                                                            Вы молодец :)
                                                                                                                                                                                                            +3
                                                                                                                                                                                                            «Premature optimization is the root of all evil.»
                                                                                                                                                                                                            Угадайте кто ;)
                                                                                                                                                                                                            +1
                                                                                                                                                                                                            Ваше решение — конечно, не говнокод. Но на мой взгляд, оно избыточное. Слишком много строк и текста для такой простой задачи. Шапка хороша, я бы оставил из неё только первую половину. Остальные комментарии не несут никакой полезной информации. Например, «Finally, print the line to screen.» — это и так понятно из кода. Комментарии должны содержать только ту информацию, которую трудно/невозможно вычитать из кода.
                                                                                                                                                                                                              0
                                                                                                                                                                                                              Вы правы, конечно. И чуть выше я уже признал, что погорячился. Не все комментарии в моем примере полезны, а следовательно, часть нужно удалить.
                                                                                                                                                                                                              0
                                                                                                                                                                                                              class Program
                                                                                                                                                                                                              {
                                                                                                                                                                                                              static int Main(string[] args)
                                                                                                                                                                                                              {
                                                                                                                                                                                                              // at this point the program really should be outputting text to the
                                                                                                                                                                                                              // console. we must take into account 78 character maximum line length
                                                                                                                                                                                                              // and ensure that we use Environment.NewLine for line endings.
                                                                                                                                                                                                              // ideally should provide multi-region language support and UTF-8 /
                                                                                                                                                                                                              // UTF-16 encoding.
                                                                                                                                                                                                              Console.WriteLine("Hello World");
                                                                                                                                                                                                              }
                                                                                                                                                                                                              }
                                                                                                                                                                                                              +3
                                                                                                                                                                                                              Неплохая разминка для утра: :)

                                                                                                                                                                                                              #include "stdafx.h"
                                                                                                                                                                                                               
                                                                                                                                                                                                              #include <iostream>
                                                                                                                                                                                                               
                                                                                                                                                                                                              using namespace std;
                                                                                                                                                                                                               
                                                                                                                                                                                                              int _tmain( int, _TCHAR*[] )
                                                                                                                                                                                                              {
                                                                                                                                                                                                                  int n = 0;
                                                                                                                                                                                                               
                                                                                                                                                                                                                  cout << "n? ";
                                                                                                                                                                                                                  cin >> n;
                                                                                                                                                                                                               
                                                                                                                                                                                                                  int k = n+(n*n-n)/2;
                                                                                                                                                                                                               
                                                                                                                                                                                                                  int *= (int*)new int[k];
                                                                                                                                                                                                               
                                                                                                                                                                                                                  memset( m, 0, k*4 );
                                                                                                                                                                                                               
                                                                                                                                                                                                                  for( int i = 0; i < n; ++) for( int j = 1; j <= n; ++) for( k = 0; ( k & 0x80000000 ? -: k ) < j; k -= (j/2*2==j)*2-1 )
                                                                                                                                                                                                                  {
                                                                                                                                                                                                                      int *p(&k[m]+(j*j-j)/2+(j/2*2==j)*(j-1));
                                                                                                                                                                                                               
                                                                                                                                                                                                                      if( !*){ *= -1*(i+1)*((k!=(j/2*2==j)*(-j+1))*2-1); break; }
                                                                                                                                                                                                                  }
                                                                                                                                                                                                               
                                                                                                                                                                                                                  for( int i = 1; i <= n; ++) for( int j = 0; j < i; ++)
                                                                                                                                                                                                                  {
                                                                                                                                                                                                                      cout << *(m+(i*i-i)/2+j);
                                                                                                                                                                                                               
                                                                                                                                                                                                                      if( j + 1 == i ) cout << endl;
                                                                                                                                                                                                                  }
                                                                                                                                                                                                               
                                                                                                                                                                                                                  delete [] (int*)m;
                                                                                                                                                                                                               
                                                                                                                                                                                                                  return 0;
                                                                                                                                                                                                              }
                                                                                                                                                                                                                +5
                                                                                                                                                                                                                JavaScript ;)
                                                                                                                                                                                                                // Хороший код
                                                                                                                                                                                                                for (var i = 2, a = ['1', '1']; i <= 6 + 1; i++) { 
                                                                                                                                                                                                                    console.log(a[i & 1]);
                                                                                                                                                                                                                    a[1] = i + '-' + a[1];
                                                                                                                                                                                                                    a[0] = a[0] + '-' + i;
                                                                                                                                                                                                                }
                                                                                                                                                                                                                
                                                                                                                                                                                                                // Хороший код 2
                                                                                                                                                                                                                for (var i = 1, a = [[], []]; i <= 6; i++) { 
                                                                                                                                                                                                                    a[0].unshift(i);
                                                                                                                                                                                                                    a[1].push(i);
                                                                                                                                                                                                                    console.log(a[i & 1].join('-'));
                                                                                                                                                                                                                }
                                                                                                                                                                                                                
                                                                                                                                                                                                                // Г код
                                                                                                                                                                                                                // Форматирование оставил
                                                                                                                                                                                                                
                                                                                                                                                                                                                function S_Prnt_Str (options) {
                                                                                                                                                                                                                    if (options.stroka.length >= 0) {
                                                                                                                                                                                                                        if (typeof options.stroka == typeof 'string') {
                                                                                                                                                                                                                            if (console) {
                                                                                                                                                                                                                                if ('console' in window) {
                                                                                                                                                                                                                                    if ('log' in window.console) {
                                                                                                                                                                                                                                        try {
                                                                                                                                                                                                                                            console.log(options.stroka);
                                                                                                                                                                                                                                        } catch (owibka) {
                                                                                                                                                                                                                                            throw owibka;
                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                    } else {
                                                                                                                                                                                                                                        throw new Error('Net funccii log');
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                    throw new Error('Konsoli net v window');
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            } else {
                                                                                                                                                                                                                                throw new Error('Konsoli net');
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                            throw new Error('Eto ne stroka');
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    } else {
                                                                                                                                                                                                                        throw new Error('U stroki net length');
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                                
                                                                                                                                                                                                                cho = true;
                                                                                                                                                                                                                
                                                                                                                                                                                                                try {
                                                                                                                                                                                                                
                                                                                                                                                                                                                    for (i = 1; i <= 6; i++) {
                                                                                                                                                                                                                        if (cho == true) {
                                                                                                                                                                                                                            try {
                                                                                                                                                                                                                                stroka = '';
                                                                                                                                                                                                                                for (j = 1; j <= i; j++) {
                                                                                                                                                                                                                                    if (stroka == '') {
                                                                                                                                                                                                                                        stroka = stroka + j;
                                                                                                                                                                                                                                    } else {
                                                                                                                                                                                                                                        stroka = stroka + '-' + j;
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                S_Prnt_Str({stroka: stroka});
                                                                                                                                                                                                                                cho = false;
                                                                                                                                                                                                                            } catch  (owibka) {
                                                                                                                                                                                                                                if (owibka instanceof Error) {
                                                                                                                                                                                                                                    throw new Error(owibka.message);
                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                    throw new Error('Owibka ne owibka');
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        } else if (cho == false) {
                                                                                                                                                                                                                            try {
                                                                                                                                                                                                                                stroka = '';
                                                                                                                                                                                                                                for (j = 1; j <= i; j++) {
                                                                                                                                                                                                                                    if (stroka == '') {
                                                                                                                                                                                                                                        stroka = stroka + j;
                                                                                                                                                                                                                                    } else {
                                                                                                                                                                                                                                        stroka = j + '-' + stroka;
                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                S_Prnt_Str({stroka: stroka});
                                                                                                                                                                                                                                cho = true;
                                                                                                                                                                                                                            } catch  (owibka) {
                                                                                                                                                                                                                                if (owibka instanceof Error) {
                                                                                                                                                                                                                                    throw new Error(owibka.message);
                                                                                                                                                                                                                                } else {
                                                                                                                                                                                                                                    throw new Error('Owibka ne owibka');
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                            }
                                                                                                                                                                                                                        } else {
                                                                                                                                                                                                                            throw new Error('Owibka!!!');
                                                                                                                                                                                                                        }
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                
                                                                                                                                                                                                                } catch  (owibka) {
                                                                                                                                                                                                                    if (owibka instanceof Error) {
                                                                                                                                                                                                                         throw new Error(owibka.message);
                                                                                                                                                                                                                    } else {
                                                                                                                                                                                                                         throw new Error('Owibka ne owibka');
                                                                                                                                                                                                                    }
                                                                                                                                                                                                                }
                                                                                                                                                                                                                  +1
                                                                                                                                                                                                                  Так вот кто кодит эти «Ошибка: ошибок не было»…
                                                                                                                                                                                                                    +1
                                                                                                                                                                                                                    Хороший код такой хороший =)
                                                                                                                                                                                                                    +2
                                                                                                                                                                                                                    $ perl -E 'map{say(join"-",@$_%2?@$_:reverse@$_)}map{[1..$_]}1..$ARGV[0]' 6
                                                                                                                                                                                                                    1
                                                                                                                                                                                                                    2-1
                                                                                                                                                                                                                    1-2-3
                                                                                                                                                                                                                    4-3-2-1
                                                                                                                                                                                                                    1-2-3-4-5
                                                                                                                                                                                                                    6-5-4-3-2-1
                                                                                                                                                                                                                      0
                                                                                                                                                                                                                      (lambda z: '\n'.join(['-'.join(str(j) for j in (range(1,i) if i%2==0 else reversed(range(1,i)) )) for i in xrange(1,z+2)]))(6)
                                                                                                                                                                                                                        0
                                                                                                                                                                                                                        можете немного сократить код используя range(1, i)[::(-1) ** i]
                                                                                                                                                                                                                        0
                                                                                                                                                                                                                        я тоже напрогал… яху…
                                                                                                                                                                                                                        #include <QtCore/QCoreApplication>#include <iostream>QString GetString(int n);int main(int argc, char *argv[]){  QCoreApplication a(argc, argv);   const int N=6;  int i=1;  while(i<=N)  {    std::cout << GetString( i).toStdString() << std::endl;    i++;  }  return a.exec();} using namespace std; QString GetString(int n){  int i=1;  QString s;  while( i <= n )  {    if( n % 2 )    {      s=s+(s.size()?"-":"")+QString::number(i);    }    else    {      s=QString::number(i)+(s.size()?"-":"")+s;    }    i++;  }  return s;}* This source code was highlighted with Source Code Highlighter.
                                                                                                                                                                                                                        0
                                                                                                                                                                                                                        int maxrow = 6;
                                                                                                                                                                                                                        for (int row = 1; row<=maxrow; row++) {     //row iterator
                                                                                                                                                                                                                          for (int num = 1; num<=row; num++) {     // 1..row number
                                                                                                                                                                                                                            row&1 ? cout << num : cout << row-num+1;   // if parity 1..n else n..1
                                                                                                                                                                                                                            if (row!=num) cout << "-";
                                                                                                                                                                                                                          }
                                                                                                                                                                                                                          cout << "\n";
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                        * This source code was highlighted with Source Code Highlighter.
                                                                                                                                                                                                                          0
                                                                                                                                                                                                                          Однострочник на perl.
                                                                                                                                                                                                                          print join("-", $_%2 ? (1..$_) : reverse(1..$_))."\n" for (1..6)
                                                                                                                                                                                                                          И ухудшенный :)
                                                                                                                                                                                                                          for (1..6) {if ($_ == 1) {print "$_\n";next};if ($_%2 > 0){for ($n=$_;$n>0;$n--) {print $n; print $n==1?"":"-"}} else {for $m(1..$_){print "$m";print $m==$_?"":"-"}}print "\n"}
                                                                                                                                                                                                                            0
                                                                                                                                                                                                                            У меня вот код всегда избыточен, но говно ли он… не знаю, решайте сами =)
                                                                                                                                                                                                                              int c = 8;
                                                                                                                                                                                                                              bool reverse = false;
                                                                                                                                                                                                                              QList<int> numbers;
                                                                                                                                                                                                                              for(int i= 1; i <= c; i++) { numbers.append (i);}
                                                                                                                                                                                                                              for(int i= 1; i <= c; i++){
                                                                                                                                                                                                                                QList<int> list = numbers.mid (0,i);
                                                                                                                                                                                                                                if (reverse){
                                                                                                                                                                                                                                  QListIterator<int> i(list);
                                                                                                                                                                                                                                  while (i.hasNext()) { list.prepend (i.next()); }
                                                                                                                                                                                                                                  list = list.mid (0, list.count ()/2);
                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                qDebug() << list;
                                                                                                                                                                                                                                reverse = !reverse;
                                                                                                                                                                                                                              }


                                                                                                                                                                                                                            * This source code was highlighted with Source Code Highlighter.


                                                                                                                                                                                                                            Вывод:
                                                                                                                                                                                                                            (1)
                                                                                                                                                                                                                            (2, 1)
                                                                                                                                                                                                                            (1, 2, 3)
                                                                                                                                                                                                                            (4, 3, 2, 1)
                                                                                                                                                                                                                            (1, 2, 3, 4, 5)
                                                                                                                                                                                                                            (6, 5, 4, 3, 2, 1)
                                                                                                                                                                                                                            (1, 2, 3, 4, 5, 6, 7)
                                                                                                                                                                                                                            (8, 7, 6, 5, 4, 3, 2, 1)


                                                                                                                                                                                                                            * This source code was highlighted with Source Code Highlighter.


                                                                                                                                                                                                                            Qt/C++
                                                                                                                                                                                                                              0
                                                                                                                                                                                                                              print (("%s\n"*6) % tuple([("%s"*j % tuple([str(-i-1) for i in j%2 and range(j) or range(j-1,-1,-1)]))
                                                                                                                                                                                                                              [int(bool((',',))):] for j in range(1,7)]))[:int()-1]
                                                                                                                                                                                                                                0
                                                                                                                                                                                                                                Странно, что ещё никто про /dev/urandom не вспомнил)
                                                                                                                                                                                                                                  +1
                                                                                                                                                                                                                                  А можно еще вот так извратиться…
                                                                                                                                                                                                                                  1. int n = 1;
                                                                                                                                                                                                                                  2. int m = 1;
                                                                                                                                                                                                                                  3. int n_max = 6;
                                                                                                                                                                                                                                  4.  
                                                                                                                                                                                                                                  5. for ( n = 1; n <= n_max; n++ )
                                                                                                                                                                                                                                  6. {
                                                                                                                                                                                                                                  7.     if ( ( n % 2 ) ==  0 )
                                                                                                                                                                                                                                  8.     {
                                                                                                                                                                                                                                  9.         m = n;
                                                                                                                                                                                                                                  10.         goto even;
                                                                                                                                                                                                                                  11.     }
                                                                                                                                                                                                                                  12.     else
                                                                                                                                                                                                                                  13.     {
                                                                                                                                                                                                                                  14.         m = n;
                                                                                                                                                                                                                                  15.         goto odd;
                                                                                                                                                                                                                                  16.     }
                                                                                                                                                                                                                                  17. back:;
                                                                                                                                                                                                                                  18. }
                                                                                                                                                                                                                                  19.  
                                                                                                                                                                                                                                  20. even:
                                                                                                                                                                                                                                  21.     for ( int i = m; i >= 1; i-- )
                                                                                                                                                                                                                                  22.     {
                                                                                                                                                                                                                                  23.         char buffer[1024];
                                                                                                                                                                                                                                  24.         printf( "%i", i );
                                                                                                                                                                                                                                  25.         if ( i > 1 ) printf( "-" );
                                                                                                                                                                                                                                  26.     }
                                                                                                                                                                                                                                  27.     printf( "\n" );
                                                                                                                                                                                                                                  28.     if ( m >= n_max ) goto exit_label; else goto back;
                                                                                                                                                                                                                                  29. odd:
                                                                                                                                                                                                                                  30.     for ( int i = 1; i <= m; i++ )
                                                                                                                                                                                                                                  31.     {
                                                                                                                                                                                                                                  32.         char buffer[1024];
                                                                                                                                                                                                                                  33.         printf( "%i", i );
                                                                                                                                                                                                                                  34.         if ( i < m ) printf( "-" );
                                                                                                                                                                                                                                  35.     }
                                                                                                                                                                                                                                  36.     printf( "\n" );
                                                                                                                                                                                                                                  37.     if ( m >= n_max ) goto exit_label; else goto back;
                                                                                                                                                                                                                                  38.  
                                                                                                                                                                                                                                  39. exit_label:
                                                                                                                                                                                                                                  40.  
                                                                                                                                                                                                                                    +1
                                                                                                                                                                                                                                    Отмечусь.

                                                                                                                                                                                                                                    int _tmain(int argc, _TCHAR* argv[])
                                                                                                                                                                                                                                    {
                                                                                                                                                                                                                                      int delta = 1; // направление счета

                                                                                                                                                                                                                                      int maxValue = 1; // максимальное значение счета

                                                                                                                                                                                                                                      int rows = 6; // количество выводимых строк

                                                                                                                                                                                                                                      int value = 1; // текущее значение

                                                                                                                                                                                                                                      for(int i = 0; i < rows; i++)
                                                                                                                                                                                                                                      {
                                                                                                                                                                                                                                        for(;(delta > 0) ? (value <= maxValue) : (value > 0); value += delta)
                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                          printf("%d-", value);
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        maxValue++;

                                                                                                                                                                                                                                        if(value == 0)
                                                                                                                                                                                                                                        {
                                                                                                                                                                                                                                          value = 1;
                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                        delta = -delta;

                                                                                                                                                                                                                                        printf("\b \r\n");
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                      return 0;
                                                                                                                                                                                                                                    }


                                                                                                                                                                                                                                    * This source code was highlighted with Source Code Highlighter.