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

[Davert]

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

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

[pixxxel]

А в чем говнокодость? echo вместо print чтоли?

[Davert]

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

[pixxxel]

Но если что можно дописать echo «echo «1-2-3-4-5-6-7», не?

[barker]

Надеюсь, вы шутите :)

[smind]

какая задача такое и решение :)

[pixxxel]

И, кстати, если задача изменится, и нужно будет вывести следующее, какой код будет проше изменить?
Напечатать на экране следующее:
1
2-1
7-2-3
4-545-6-3
7-26-3-0-45+7

[bohdan-shulha]

Ага. Что, если мы строим дом, а потом, вдруг, нам понадобилось изменить задачу и смастерить круиз-лайнер?

[Error_403_Forbidden]

>Предлагаю Вам переписать этот код для n=1000.
Ниже кто-то уже предложил изменить начальное условие задачи и решил смастерить круиз-лайнер.

[pixxxel]

Короче, я считаю что вы написали не говнокод, а очень даже правильный код человека, не страдающего ООП головного мозга.

[MainNika]

Предлагаю Вам переписать этот код для n=1000.

[kirik]

Сначала отправьте СМС

[lexazloy]

Ага, а ещё этот код не жмёт картинку и не ставит вотемар, хотя… Стоп. О чём это я? О чём это вы?

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

[pixxxel]

print "
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
1000-5-4-3-2-1
";

[MainNika]

И да! Я перечитал оговорку

(Естественно, вместо 6 может быть любое число).

И тут можно сказать, что Вы правы :)

[Error_403_Forbidden]

А ведь он, наверное, прав.
В задаче ведь не написано, что отобразить для любого n
Если в задаче сказано: напишите
1
1-2
то не имеет смысла тратить время, и всего двумя командами можно решить задачу.

[barker]

В задаче ведь не написано, что отобразить для любого n

Вообще-то сказано.

(Естественно, вместо 6 может быть любое число).

[Error_403_Forbidden]

Вот он — настоящий Капитан Говнокод!

[evlntnt]

Я отправил. Что дальше делать?

[Wo1fer]

Как вариант
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

[Wo1fer]

Упс… Первое лучше так:

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

[runcore]

// 1
$m=6;
for($i=0,$a=array(); $i<=$m; $a[]=++$i)
	echo join('-', $i%2 ? $a : array_reverse($a) )."<br />";

[runcore]

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

)

[Zona]

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

[Aldekein]

У меня холодок пробежал по пояснице в обе стороны! Ох.

[Davert]

Это задрот-код. Вам бы обфускатором работать )

[2xMax]

«Web-архитектор, программист»

[MainNika]

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

Вы же делали доклад по говнокоду? Я его с удовольствием смотрел.
Заготавливаете материалы для следующего?

[bitterman]

int main() без return [значение]

[MainNika]

В стандартах языка 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;

[bitterman]

хорошо, просто привык на таких языках к явному указанию происходящего :-)

[LeNsTR]

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

Извините, на говнокод меня уже не хватило (

[andoriyu]

Вот «говнокод»:
def makemess n
a = [1]
t = n/2
t.times do
puts a.join '-'
a

[andoriyu]

гребаные «елочки»…
def makemess
a = [1]
3.times do
puts a.join '-'
a << a.last + 1
puts a.reverse.join '-'
a << a.last + 1
end
end

[Kane]

Моя попытка говнокода:

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

[kirik]

Скажите, это говнокод (php)? (:

$n = 6;
for($i = 1; $i <= $n; print(join('-', $i % 2 ? range(1, $i++) : range($i++, 1)) . "\n"));

[Stalker_RED]

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

[kirik]

Если расписать его на несколько строчек

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

и забыть что это такое, то понятнее не становится :)

[ertaquo]

Тут я поспорю. Говнокод имхо — это код, который написан по-идиотски сам по себе. А тут код, который вполне грамотно написан и который просто слегка сложновато понять на первый взгляд. Тут даже можно еще сократить и не использовать переменную $nums :-)
Да и вообще не все говнокод, что может показаться им. Например:
if ($q == false) return false;
Вроде бы говнокод и можно написать просто «return $q;», правда? А на деле условие может сработать и на 0, и на пустую строку, а вернуть надо именно булевое значение. Программист просто или не знал, или поленился воспользоваться приведением типов: «return (bool)$q;», и имеет место быть не говнокод, а просто неумелость или лень :-)

[matiouchkine]

А зачем в двух разных местах $i++, если его можно запихнуть в одно ($i++ % 2)?

[kirik]

Нам нужно сначала получить число, и сделать range, а потом инкриментировать.
А если инкриментировать в условии, то вывод получается не верный (так как в range попадает уже увеличенное значение).

[kirik]

Хотя из такого положения можно выйти так:

$n = 6;
for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));

Спасибо за наводку! :)

[matiouchkine]

Ну да, ну да :-)

[matiouchkine]

Интервал цикла никто не обязывал быть равным [1…n]:

$n = 6;
for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));

Просто на мой вкус изменять счетчик цикла в разных местах тела цикла — как раз и есть частая потенциальная причина очень многих трудноотлавливаемых ошибок (e. g. «говнокод»).

[Arion]

(6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
на perl можно и не так отжечь думаю =)

[link0ln]

Обфускация скорее…

[gorinich]

немного опоздал :)

local $\="\n";
print join '-', $_%2?1..$_:reverse 1..$_ for 1..6;

[TheShock]

Просто плохое форматирование)

$n = 6;
for($i = 1; $i <= $n; $i++) {
    $array = $i % 2 ? range(1, $i) : range($i, 1);
    echo join('-', $array), PHP_EOL;
}

[kirik]

Ну да :) Я чут повыше примерно тоже самое писал.

[TheShock]

точно)

[AHDPEu]

Вложил все свои знания =)

//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

[AHDPEu]

Тег код не работает видать у низкокармщиков. Закинул на пастбин

[AHDPEu]

pastebin.com/a18tpmqr

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

[Mezomish]

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

Говнокод вездесущ ;)

[8bitjoey]

Без этого тега говнокод еще «наваристей» ))

[savostin]

Пля, похоже в сеть утекли сорсы моего проекта!

[Lerg]

Браво

[polyakstar]

последние 4 строки исполнил на пять!

[Ogra]

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

[youlose]

Perl:

use 5.012;

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

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


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

[abyrvalg]

Там же надо все комбинации вывести. Как-то так, наверное:

my $total = 6;

for $num ( 1 .. $total ) {
  say join( '-', $num % 2 ? 1..$num : reverse 1..$num );
}

[youlose]

Согласен, я ниже исправился.

[youlose]

Немного неверно я понял задание сначала потому:
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. подсветка не работает из-за низкой кармы

[youlose]

код с подсветкой на pastebin.com:

хороший — pastebin.com/eGXquCLs
плохой — pastebin.com/dgbH6qfn

[SnakeSolid]

Все на что хватило фантазии: pastebin.com/rdCtf2j5

[mihaild]

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

[sledopit]

#!/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
(:

[sledopit]

тьфу, 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

[SabMakc]

Нормальный вариант (ну более-менее):

// Инициализация
$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, но на С++ (про кривизну не забываем).

[SabMakc]

P.S. Для 3-4 подойдет любой высокоуровневый язык, такие как C#, PHP, Java и т.д.
C/C++ выделяю отдельно потому как только там мне удавалось без особых извращений объявить структуру, привести вещественное число к этой структуре и работать с экспонентой числа как заблагорассудится. Простор для говнокода просто неисчерпаемый (сразу скажу, что против C/C++ ни чего против не имею, прекрасный, гибкий язык).

[runcore]

ваш нормальный вариант — что вообще делает? )

[SabMakc]

Эм… Выводит
6-6-5-4-3-2-1
Согласен, криво (каюсь, не тестил. А кто говнокод еще и тестит? :-) ).

// Инициализация
$n=6;
// Вывод
echo $n;
for ($i = -1*$n+1; $i < 0; $i++)
  echo $i;

[SabMakc]

Проснулся.
Оказывается вывести надо все 6 строк, а не просто одну )))

[Arion]

(6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}

[pechlambda]

В тред врывается 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

[SidexQX]

После прочтения условия «Естественно, вместо 6 может быть любое число», появилось нездоровое желание вместо «6» влепить рандом))))) а остальное вывести принтом)

[dima_eam]

На APL будет одно выражение, но довольно говнокодистое:

[dima_eam]

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

[romeo_ordos]

Java:

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

Сомневаюсь что возможно короче. Данную задачу выполняет, масштабируется заменой константы «6» в цикле.
Самый говонокод, по моему мнению, написал Davert в первом комменте.

[TheShock]

У вас строка не разворачивается через одну

[romeo_ordos]

Упс, прошу прощения. Только проснулся, невнимательно прочитал условие.

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


[Ogra]

Без массивов это правильно, я тоже сделал без массивов. Но вот константы то зачем объявлять, да еще и писать их с учетом coding style?

[Yan169]

У Вас пока самый читабельный вариант из всех.

[asolntsev]

Интересно, почему вы это называете говнокодом?
По-моему, одно из лучших решений!

[nvbn]

Нечитаемый питоноговнокод:
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)])

[S2nek]

Коль такая пьянка:

#нормальный вариант
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))

[nvbn]

Придумал ещё хуже:
lambda x: "\n".join('-'.join(map(str,range(1, n+1))[::bool(n%2) or -1]) for n in range(1, x + 1))

[S2nek]

Итерация для джойна лишьняя

#нормальный вариант
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)

[IT_Tux_Droid]

питон pastie.org/1782311 :)

[IT_Tux_Droid]

или даже pastie.org/1782360 ;)

[liaren]

<?php

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


[liaren]

Version 2.0 :)

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

[Ogra]

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

[Ogra]

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

[ertaquo]

>+++++++>+++++++>+++++++>+++++++>+++++++>+++++++>+++++++<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<+++++++++[>+++++<-]++++++++++>
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
Ну а говнокодистое на один экран наверное не влезет :)

[pechlambda]

У Вас [ пропущена после восьмого символа (перед вторым >)

[link0ln]

По моему исходя из того, что браинфак вообще в принципе не читабельный язык, то довольно сложно или даже невозможно сделать что-либо «неговнокодистое». ( не в обиду любителям )

[zikher]

пара символов в начале проги пропущено.
PS: предлагаю посоревноваться на размер brainfuck-ового исходника (мой см. ниже) ;-)

[ertaquo]

Пропущена кавычка только одна, как и сказал pechlambda :)
Оптимизировал:
>+++++++[>+++++++<-]>[>+>+>+>+>+>+<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<<+++++++++[>+>+++++<<-]>+>
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<

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

[zikher]

++++++++++[>+++++>+<<-]>[>>+>+
>+>+>+>+>+<<<<<<<<-]>>----->->
>+>++>+++>++++<<<<<.<<.>>>.<<.
>.<<.>>.<.>>.<<.>>>.<<<<.>>>>>
.<<<<.>>>.<<<.>>.<<.>.<<.>>.<.
>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.
<<<<<<.>>>>>>>.<<<<<<.>>>>>.<<
<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.
<<.
243 вроде

[ertaquo]

+++++++[>+>+++++++>+++++++<<<-]>+++>.>----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
141 байт

[zikher]

++++++++++[>+>+++++>+++++<<<-]>>-.>-----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
на 2 меньше

[zikher]

даже вот так:
+++++[>++>++++++++++>+++++++++<<<-]>>-.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.

[ertaquo]

+++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
Еще на 2 меньше, 135 байт

[ertaquo]

+++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>>>++++[<<.+>.>-]<<.<.>++>>+++++[<<-.>.>-]<<-.
129 байт :-)

[tronix286]

Отец!

[ertaquo]

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

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

[Noboru]

Для любого четного m от 2 до 8, йоу! 120 байт!

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

[Noboru]

104 =)

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

[zikher]

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

[zikher]

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

96

[Noboru]

^^
Единственный минус такой оптимизации — теперь не очевидно, где же m задается)

[ertaquo]

+++++[>++>+++[>+++>+++<<-]<<-]+++>>>++++<<<[>>>.<[>>.>+<<+.<-]<.>>+.>>+[<.<-.<+>>>-]<<<+<.<-]
93

[ertaquo]

+++++[>++>+++[>+++>+++<<-]>+<<<-]+++[>>>-.<[>>.>+<<+.<-]<.>>+.>>+[<.<-.<+>>>-]<<+<+<.<-]
88 байт

[zikher]

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

[ertaquo]

Самое смешное, что код на брейнфаке оказался гораздо меньше аналогичного кода на остальных языках :-)

[zikher]

вчера заснул, пытаясь реализовать то же самое :-)

[tokmakov]

тимати в записи c конференции для хохмы? :)

[asolntsev]

Почти.
Это не конференция, а devclub — клуб девелоперов. Поэтому песня нужна, чтобы подчеркнуть клубную атмосферу.

[sclv]

Думаю, что сама постановка задачи сформулирована неправильно. Она целенаправленна, что уже гарантирует по крайней мере на 50 % не г… Что бы точно вышло Г… надо говорить так. — Ну это не подходит! (без малейших объяснений), а сделайте так как у нас положено, принято и нам нравится.

[soomrack]

Меня всегда интересовал вопрос, почему появляется говнокод.
Что послужило причиной появления:

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(), чтобы типы данных остались прежними…

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

[youlose]

Абсолютно согласен и могу добавить ещё одну причину:
недостаточное знание языка программирования, то есть человек пишет совсем на другом, а с этим ему надо поработать эпизодически и оттуда тоже появляются шедевры. Я выше написал своё решение на Perl как написал бы опытный программист(1) и как мог бы написать неопытный(2).

[asolntsev]

Ну-ну, оптимизация сама по себе вещь хорошая, когда она нужна.
Думаю, правильнее было бы сказать так: отборный говнокод появляется в результате изменений кода. Но это, простите, КО.

[scorp_ca]

Ну как-то так:
<?
$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";
}
?>


[barker]

Вообще, задача такова, что любое решение будет похоже на гавнокод. Вот для 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();
		}
	}
}

[barker]

Вот решение покороче :)

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

Решение как решение, но всё равно гавнокод, потому что сложночитаемый, хотел сократить кол-во операторов и строк.

[Throwable]

Настоящий говнокод — это решение влоб, покрывающее строго фиксированный интервал значений.

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

[barker]

Да, в продолжение ещё хотел написать код с парой фабрик (на алгоритм рисования этой пирамиды и на рисование строк), но на середине бросил и подумал, что это уже слишком. Хотя получалось нечто 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();
	}
}

[sainnr]

Вот переписать подобное ООП-решение на PHP с использованием MVC-фреймворка (Yii тот же) ради вывода этих 6ти строчек — пожалуй, говнокодисто будет.

[silvansky]

А на brainfuck'е никто ещё не написал? Интересно, как будет говнокод от нормального кода на нём отличаться…

[silvansky]

а блин пока писал коммент уже написали =)

[sledopit]

Эх, у меня такая же проблема (:

[sledopit]

[Lemoor]

На тикле:
-в стиле каки:
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";}

[Lemoor]

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

[reinventer]

Достаточно говнокодисто получилось:

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

[soomrack]

Еще переменные надо переименовать. Например, Stroka в Naoborot, Noborot в Stroka, Stroka_array в hz_list_false_or_true.

[pixxxel]

Понравились ваши имена переменных!
Вчера заглядывал в БД PHPShop, повеселили названия полей в некоторых таблицах:
baseinputvaluta
odnotip
sklad_action
title_shablon
kurs
otsiv
otvet

[Aivean]

Я прошу прощения, но то, что большинство людей написало в комментариях, считая хорошим кодом, как раз и есть говнокод. Имхо, самое главное отрицательное качество говнокода — не большой размер, а нечитабельность. Хороший код должен читаться как хорошая книга. Если ваш язык программирования позволяет использовать высокоуровневые конструкции, зачем вы продолжаете пытаться писать на брейнфаке?

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

И извините за названия классов.

[Yan169]

Вы верно пишете про приоритет читабельности.
Только высокоуровневые конструкции != читабельность.

[Aivean]

Вы сильно категоричны. Я считаю, что хороший код должен показывать скорее что он делает, нежели как он это делает. Опять же, это скорее применимо к большим enterprise системам. Конечно, для низкоуровневых программ, где требуется прежде всего скорость, иногда нужно оптимизировать в ущерб читабельности.

[Yan169]

Никакой категоричности. Я как раз согласен, что по коду должна быть понятна задача, которую он выполняет. Только вот Ваш ООП-вариант несмотря на расширяемость (хотя вероятность того, что данный код потребует расширения минимальна), на мой взгляд описывает решаемую задачу хуже, чем пример без высокоуровневых конструкций выше.
Хотя по скорости Ваш вариант должен быть быстрее ввиду отсутствия работы со строками, но это в расчет не берём.

[Aivean]

Мой вариант не претендует на идеальность и он не объектно-ориентированный, поскольку используются статические методы класса.
По поводу примера по Вашей ссылке, я рассматривал подобную реализацию, согласен, она гораздо лучше читается, но не выдерживает совершенно никакой критики как по производительности, так и по используемой памяти (а что, если n будет равно 100000000?). Тут, мне кажется, уместнее всё же сохранять баланс между тривиальной оптимизацией и размером кода.

[Yan169]

На статические методы внимания не обратил, извиняюсь, на Java никогда не писал. В целом мы вроде пришли к единому мнению, что тот код несмотря на отсутствие высокоуровневых конструкций читается лучше. А читабельность приоритетна, и в этом был посыл Вашего сообщения, не так ли?

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

[Aivean]

Согласен.

[youlose]

В этом ничего удивительного нет. «Говнокод» очень широкое понятие, поэтому многие к нему относятся по разному. Опять же, читабельность кода также зависит и от глубины понимания языка программирования.

P.S. в Java не сильно разбираюсь, потому оценить ваш код не смогу никак.

[Shedal]

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

[typicalbaby]

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)

[typicalbaby]

Извиняюсь за форматирование. Здесь можно посмотреть в нормальном виде:
pastebin.com/GEreUx2j

[shiberz]

для говнокода как-то не очень говнисто, а для хорошего решения не очень чисто

[typicalbaby]

Да. Как минимум, можно было списковую сборку использовать вместо lambda. Действительно, в этот конкретном случае, lambda и map — излишество.

[antivir]

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

[imwode]

я кроме Вас серьезных людей тут не встречал.

[antivir]

Забыл добавить — взрослых. Надо же так ошибиться в Хабре…

[imwode]

ничего страшного, это очень распространенная ошибка.

[antivir]

Спасибо Вам за Ваши минусы!

[imwode]

серьезный человек заслуживает серьезного подхода.

[soomrack]

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

[Paul]

А в меньшинстве своём, но всё-таки заходят, дети. Им такие слова уж и подавно нельзя показывать!

[asolntsev]

«Подобной» лексики — это какой?
Вы имеете в виду «говнокод»? Согласен, лучше было бы использовать что-нибудь поприличней, но человечество не придумало ещё такого термина, который бы так же точно отражал суть предмета.

[antivir]

Именно такой. Да и еще на главной странице. Не знаю, известно ли вам, но некоторые слова в приличном обществе не употребляют. А все оправдания — дешевые отмазки.

[asolntsev]

Зато, как видно, в приличном обществе принято использовать слэнговые слова, пришедшие из криминального жаргона.

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

Кстати, надо бы еще обратиться к администрации хабра, чтобы он переименовали блог code_wtf в что-нибудь более приличное, ведь «wtf» переводится на русский язык еще неприличнее.

[SCINER]

$a = array();
for($i=1;$i<7;$i++)
{
$a[]=$i;
echo implode('-', $i%2 ? $a : array_reverse($a)), '
';
}

[runcore]

function my($v) {
	static $s='';
	$s .= $v.'-';
	echo trim($v%2 ? $s : strrev($s), '-').'<br />';
}
array_map('my', range(1,6));

строки лучше? ))

[SCINER]

а как в этом случае без использования второй переменной перевернуть строку вида:
1-2-3-...15-16-17-18
чтобы 15 при этом не превратилась в 51?

[mgyk]

puts (1..6).map{|n| (1..n).to_a.reverse.join("-")}.join("\n")

[toxicmt]

У Вас всегда реверс. Так работает:

puts (1..6).map{|n| (1..n).to_a.tap{|a| a.reverse! if n%2==0}.join("-")}.join("\n")

[imwode]

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

А че, я всегда так пишу…

[imwode]

тьфу, копипаст подвел. но идея, думаю, понятна.
Так, пойду подумаю как это написать в говнокоде.

[Voenniy]

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

[Voenniy]

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

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;

[imwode]

QString string = «6-5-4-3-2-1»;

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

[cybergrind]


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


[Jumanji]

Говно код — он бывает разные, бывает говно по форме, а бывает говно по сути, вот второе это код из первого камента, а первое — это то чтонаписал krink.
По сути все верно, но записано так что ни кто кроме автора тут ничерта не поймет.

[kirik]

Как уже писали где-то: задача такая, что тут впринципе ничего вменяемо-понятного написать нельзя. Однозначно чёрт ногу сломит.

[puffofsmoke]

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


[sledopit]

странно, что никто еще не написал проверок в духе if (true=true || 1=1) (:

[Valery4]

Тогда уже true!=false или 1!=false

[BeeZONE]

Немножко индийской мудрости тогда не помешает :)

if Lenght(BoolToStr(true)) = 4

[zikher]

+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++.>

и

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

[Vokabre]

Длиннокод

[soomrack]

#!/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");
}


[soomrack]

С отступами:

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

[soomrack]

А вот ровно тоже код, но попорченный:

my @a=(1);for(my $b=(print(@a,"\n"),2);$b<7;$b++){
     @a=(@a,'-',$b);print($b%2?@a:reverse(@a),"\n");}

[evgenyk]

А я бы написал так, не знаю только говнокод это или нет. 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)

[evgenyk]

Извиняюсь, продублирую с отступами, а то непонятно:

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)

[asolntsev]

Для Питона это однозначно говнокод, ведь там в одну-две строчки можно написать, и ничуть не менее читабельно.
Вот на Яве по-другому нельзя.

[evgenyk]

Очень не люблю, когда много написано в одну строку.
Часто приходится разбираться с чужим кодом. Поубивал бы.
Хуже всего:
— Несколько вызовов функций в одной строке
— Невозврат из функций, переход в другое мест по исключению.
Предпочитаю писать так:

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

чем:

return func2(func1(x,y))

[dprojex]

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

[dprojex]

Использования 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.

[stroncium]

Есть источник вдохновения, но лень писать, потому делаем на ПХП так:
генерим массивы через рэйндж и джоиним их.
Нечетные строки реверсим.
Обнаруживаем, что не работает для двузначных чисел, потому для каждой такой подстроки находим числа по регекспу(естественно, извратному), реверсим и возвращаем в строку.

[apkawa]

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

[vorbiz]

1.upto(6) {|i| p (1..i).to_a.tap{|a| a.reverse! if i.even?}.join('-')}

Пост превосходства руби над другими жалкими языками. Говнокод попозже придумаю. Даже на руби можно говнокодить (

[soomrack]

Имена переменных должны быть осмысленные. Мне мой код нравится больше (см. выше) мой код на perl

[vorbiz]

Ну в таком случае ничем, ничем не могу помочь. Конечно, давайте самые незначительные счётчики в итерация называть осмысленно. Вот уже где говнокод так говнокод.

[Shedal]

Если счетчик можно назвать осмысленно, то почему бы этого не сделать? :)

[vorbiz]

Чтобы код выглядел легче. В первую очередь. Во вторую — потому что так принято. И какой бы ты код ни читал тебе не придётся запоминать, что переменная lineNumber — это сраный счётчик в цикле. Если глаз видит i — мозг уже знает, что к чему.

[soomrack]

Глядя на i я вижу мнимую единицу. Может быть потому, что я слишком много писал реализацию алгоритмов для моделирования динамики систем описываемых уравнением Шредингера?

[vorbiz]

Вот я даже не знаю, что ответить на этот бред. Мне срать, что ты там видишь, ок? Я тебе говорю о том, как принято делать и писать код. Это не моё личное мнение.

[Shedal]

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

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.

[evgenyk]

Очень много комментариев. ИМХО, нужно стремиться к тому, чтобы комментариев было бы поменьше, а сам код читался бы как комментарии.

[Shedal]

Да, может быть, я немного переборщил с комментариями в самом коде. Но шапку с summary я бы точно оставил как есть.

[Aivean]

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

[Shedal]

Я думаю о производительности, когда стоит такая задача :) В данном случае я стремился сделать код как можно более читабельным. Если он будет работать медленно, то его можно переписать, но это, скорее всего, ухудшит читаемость.
Однако, как показывает практика, до проблем со скоростью дело доходит крайне редко, и намного большие проблемы возникают из-за трудностей в поддержке кода.

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

[Aivean]

Вы молодец :)

[slider]

«Premature optimization is the root of all evil.»
Угадайте кто ;)

[asolntsev]

Ваше решение — конечно, не говнокод. Но на мой взгляд, оно избыточное. Слишком много строк и текста для такой простой задачи. Шапка хороша, я бы оставил из неё только первую половину. Остальные комментарии не несут никакой полезной информации. Например, «Finally, print the line to screen.» — это и так понятно из кода. Комментарии должны содержать только ту информацию, которую трудно/невозможно вычитать из кода.

[Shedal]

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

[2xMax]

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

[Wyrd]

Неплохая разминка для утра: :)

#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 *m = (int*)new int[k];
 
    memset( m, 0, k*4 );
 
    for( int i = 0; i < n; ++i ) for( int j = 1; j <= n; ++j ) for( k = 0; ( k & 0x80000000 ? -k : k ) < j; k -= (j/2*2==j)*2-1 )
    {
        int *p(&k[m]+(j*j-j)/2+(j/2*2==j)*(j-1));
 
        if( !*p ){ *p = -1*(i+1)*((k!=(j/2*2==j)*(-j+1))*2-1); break; }
    }
 
    for( int i = 1; i <= n; ++i ) for( int j = 0; j < i; ++j )
    {
        cout << *(m+(i*i-i)/2+j);
 
        if( j + 1 == i ) cout << endl;
    }
 
    delete [] (int*)m;
 
    return 0;
}

[azproduction]

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

[kirilloid]

Хороший код такой хороший =)

[vkramskikh]

$ 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

[voidus]

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

[santa]

можете немного сократить код используя range(1, i)[::(-1) ** i]

[javamain]

я тоже напрогал… яху…
#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.

[Shedal]

Советую: source.virtser.net/

[barker]

Советую: тег <source></source>

[lmlm]

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.

[Ku6ep]

Однострочник на 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"}

[vitaly_KF]

У меня вот код всегда избыточен, но говно ли он… не знаю, решайте сами =)

  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++

[Volshebnyi]

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]

[dem0n3d]

Странно, что ещё никто про /dev/urandom не вспомнил)

[Next_Alex]

А можно еще вот так извратиться…

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.  

[jauseg]

Отмечусь.

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.

[zikher]

main(t,x,k){for(x=49,k=0;k<13;k+=2,t=0)while(t<k)putchar(t%2?++t==k?'\n':'-':x+(k/2%2?t++:k-++t)/2);return;}

[ByTheWay]

Как же без LINQ :)

var arr = new List<int> { 1, 2, 3, 4, 5, 6 };
for (var i = 1; i < arr.Count + 1; i++)
{
  foreach (var j in (i % 2 != 0) ? arr.Select(n => n.ToString()).Take(i).Aggregate((a, b) =>
                    a + "-" + b) : arr.Select(n => n.ToString()).Take(i).Reverse().Aggregate((a, b) =>
                    a + "-" + b))
  {
    Console.Write(j);
  }

  Console.WriteLine();
}

* This source code was highlighted with Source Code Highlighter.

[AlexanderYastrebov]

Говнокод в стиле явы. Можно было еще дальше развивать, но надоело

package ru.nullpointer.shitty;

import java.io.PrintStream;
import java.util.Iterator;

public class Main {

    public static void main(String[] args) {
        int n = 6;

        IteratorStrategy<Integer> pis = new PrintIteratorStrategy(System.out);
        IteratorFactory sif = IteratorFactory.getInstance();

        IteratorStrategy<Integer> fis = new ForeachStartegy(sif, pis);

        Iterator<Integer> it = new ForwardIterator(n);

        fis.execute(it);
    }

    static public class ForwardIterator implements Iterator<Integer> {

        private int capacity;
        private int counter;

        public ForwardIterator(int capacity) {
            if (capacity < 1) {
                throw new IllegalArgumentException("Capacity must be positive");
            }
            this.capacity = capacity;
            this.counter = 1;
        }

        @Override
        public boolean hasNext() {
            return counter <= capacity;
        }

        @Override
        public Integer next() {
            return counter++;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }

    static public class BackwardIterator implements Iterator<Integer> {

        private int counter;

        public BackwardIterator(int capacity) {
            if (capacity < 1) {
                throw new IllegalArgumentException("Capacity must be positive");
            }
            this.counter = capacity;
        }

        @Override
        public boolean hasNext() {
            return counter > 0;
        }

        @Override
        public Integer next() {
            return counter--;
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException("Not supported yet.");
        }
    }

    static public interface IteratorStrategy<E> {

        void execute(Iterator<E> it);
    }

    static public class PrintIteratorStrategy implements IteratorStrategy<Integer> {

        private PrintStream ps;

        public PrintIteratorStrategy(PrintStream ps) {
            if (ps == null) {
                throw new IllegalArgumentException("Print stream can't be null");
            }
            this.ps = ps;
        }

        @Override
        public void execute(Iterator<Integer> it) {
            while (it.hasNext()) {
                ps.print(it.next());
                if (it.hasNext()) {
                    ps.print('-');
                }
            }
            ps.println();
        }
    }

    static public class ForeachStartegy implements IteratorStrategy<Integer> {

        private IteratorFactory sif;
        private IteratorStrategy<Integer> is;

        public ForeachStartegy(IteratorFactory sif, IteratorStrategy<Integer> is) {
            if (sif == null) {
                throw new IllegalArgumentException("Iterator factory can't be null");
            }
            if (is == null) {
                throw new IllegalArgumentException("Iterator strategy can't be null");
            }
            this.sif = sif;
            this.is = is;
        }

        @Override
        public void execute(Iterator<Integer> it) {
            while (it.hasNext()) {
                Integer capacity = it.next();
                is.execute(sif.getIterator(capacity));
            }
        }
    }

    static public class IteratorFactory {

        private static IteratorFactory instance = null;

        private IteratorFactory() {
        }

        public static IteratorFactory getInstance() {
            if (instance == null) {
                instance = new IteratorFactory();
            }
            return instance;
        }

        public Iterator<Integer> getIterator(int capacity) {
            if (capacity % 2 == 0) {
                return new BackwardIterator(capacity);
            } else {
                return new ForwardIterator(capacity);
            }
        }
    }
}

[AlexanderYastrebov]

И читабельный вариант

package ru.nullpointer.nonshitty;

public class Main {

    public static void main(String[] args) {
        int n = 6;

        for (int i = 1; i <= n; i++) {
            if (i % 2 == 0) {
                for (int j = i; j > 1; j--) {
                    System.out.print(j);
                    System.out.print('-');
                }
                System.out.print(1);
            } else {
                for (int j = 1; j < i; j++) {
                    System.out.print(j);
                    System.out.print('-');
                }
                System.out.print(i);
            }
            System.out.println();
        }
    }
}

[dprojex]

а мысли у нас одинаковы, хоть и языки разные habrahabr.ru/blogs/code_wtf/116842/#comment_3794924

[AlexanderYastrebov]

И еще говно-вариант, зато с одним циклом

package ru.nullpointer.shitty2;

public class Main {

    public static void main(String[] args) {
        int n = 6;

        int total = (1 + n) * n / 2;
        boolean forward = true;
        int width = 1;

        for (int i = 1; i <= total; i++) {
            int index = (1 + width) * width / 2;
            int value = forward ? width + i - index : index - i + 1;

            System.out.print(value);

            if (i == index) {
                width++;
                forward = !forward;
                System.out.println();
            } else {
                System.out.print('-');
            }
        }
    }
}

[Wildy]

… и большинство комментариев — загадка: говнокод это или нет.

[oWeRQ]

$n = 6;

$odd = '';
$even = '';

for ($i = 1; $i < $n+1; $i++) {
$odd = "$odd-$i";
$even = "$i-$even";

if (is_float($i / 2))
echo substr($odd, 1, $i*2-1)."\n";
else
echo substr($even, 0, $i*2-1)."\n";
}


[dprojex]

слоган: нет денег на обфускатор — пиши говнокод!

[megahertz]

Лаконичный говнокод:
<?php
$max = 6;
while (@count($r) < $max) {
    @$r[] = count($r) + 1;
    echo implode('-', count($r) % 2 ? $r : array_reverse($r)) . PHP_EOL;
}

[AndryX]

Зайдёт какой-нить иностранец без знания русского на хабр… Так и начнётся история, что в русские программисты — говнокодеры.

[BeeZONE]

В таком случае, наверное, стоит внести в шапку дискламер на английском, а то ведь действительно увидит кто :)

[kirilloid]

Мораль — не хрен судить о сайте только по коду.

[zimorodok]

Javascript

for (var i = 1, a = []; i < 8; i += 1) {
    i % 2 ? ( document.write(a.reverse().join('-') + '<br>\) , a.reverse()) : document.write(a.join('-') + '<br>');
    a.push(i);
}

[teh13th]

C#-говнокод в одну строку:

for (int i = 1; i <= MAX; i++) Console.WriteLine(string.Join<int>(@"-", (i % 2 == 0) ? Enumerable.Range(1, i).Reverse() : Enumerable.Range(1, i)));

[teh13th]

Где MAX = 6

[leonard]

Налажу и я свой кусочек:

<?
define(N,6);
ob_start();
$s='';
for ($i=0; $i<N; $i++) {
  for ($j=$i+1; $j>0; $j--) {
    echo $s.$j.'-';
  }
  echo "\n";
}
$s=ob_get_contents();
ob_clean();
echo str_replace("-\n","\n",$s);

Заставить его работать было сложнее, чем нормальным методом.

[oWeRQ]

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

[leonard]

Я как обычно просмотрел, спасибо. Но зато в итоге говнокод получился еще говнокодистее!

<?
define(N,6);
ob_start();

for ($i=0; $i<N; $i++) {
  for ($j=$i+1; $j>0; $j--) {
    if (($i/2==round($i/2))==false) {
      echo $j.'-';
    } else {
      echo -$j+2+$i.'-';
    }
  }
  echo "\n";
}
$s=ob_get_contents();
ob_clean();
echo str_replace("-\n","\n",$s);

С переменной оно конечно проще, но не так интересно. Как по мне, один из признаков говнокода использование неадекватных потребностям инструментов.

[shaeng]

#include <stdio.h>
int main(int argc, char** argv) {
    int max = atoi(argv[1]);
    int k;
    int i;
    for(k = 1; k <= max;k++){
        if(k % 2 == 1){
            for(i = 1; i < k;i++){
                printf("%d-", i);
            }
            printf("%d\n", k);
        }else{
            for(i = k; i > 1;i--){
                printf("%d-", i);
            }
            printf("1\n");
        }
    }
    return 0;
}

[Amper]

python-говнокод от меня:

[(lambda l:print(*((l)if(i%2)else(list(reversed(l)))),sep='-'))(range(1,i+1))for(i)in(range(1,7))]

[Amper]

можно даже ещё страшнее:

(lambda x:[(lambda l:print(*((l)if(i%2)else(list(reversed(l)))),sep='-'))(range(i)[1:])for(i)in(range(x+2)[2:])])(6)

[S2nek]

Мало того что говнокод, так еще и не рабочий :-)

[Amper]

Наглая ложь, мой говнокод всегда работает (проверено Py3.2 и Py2.7 with print_function). Пруф:

[Levsha100]

Говнокодик на асме(не проверял):
get a
ldi b 0x2d
ldi d 0x1
ldi h 0x1e
dec a h
main_loop:
inc c
tst c a
jc exit
mov e c
and e d
tst e z
jc 4etnoe
jmp ne4etnoe
jmp main_loop
exit:
halt
4etnoe:
mov g c
inc g
ldi f 0
4etnoe_loop:
inc f
mov k f
add k h
put k
tst f g
jnc 4etnoe_loop
jmp main_loop
ne4etnoe
mov g c
ne4etnoe_loop:
mov k g
add k h
put k
dec g
tst g z
jnc ne4etnoe_loop
jmp main_loop

[Levsha100]

Что-то меня поперло сегодня на говнокод:
#include #define using использовать
#define namespace стиль
#define std стандарт
#define ; расстрелять
#define int цельное
#define cin слушать
#define туда >>
#define сюда <<
#define плюсануть ++
#define минусануть --
#define сделать for
#define что (
#define ага )
#define прировнять =
#define одын 1
#define два 2
#define плюс +
#define минус -
#define процентъ %
#define равно ==
#define чаво if
#define а_если else
#define меньше_равно <=
#define меньше <
#define больше >
#define не_равно !=
#define молвитъ cout
#define { начнемс
#define } готово
#define 0 ноль
#define return фух
#define main тут_и_начнем

использовать стиль стандарт расстрелять

цельное тут_и_начнем что ага
начнемс
цельное н расстрелять
слушать туда н расстрелять
н плюсануть расстрелять
сделать что цельное И прировнять одын расстрелять И меньше_равно н расстрелять И плюсануть ага
начнемс
чаво что И процентъ два равно ноль ага
начнемс
сделать чтоцельное Ы прировнять одын расстрелять Ы меньше И расстрелять Ы плюсануть ага
начнемс
молвитъ сюда Ы расстрелять
чаво что И два Ы плюс одын ага начнемс молвитъ сюда "минус" расстрелять готово
готово
молвитъ сюда "\n" расстрелять
готово а_если
начнемс
сделать что цельное Ы прировнять И расстрелять Ы больше одын расстрелять Ы минусануть ага
начнемс
молвитъ сюда Ы минус одын расстрелять
чаво что Ы не_равно два ага начнемс молвитъ сюда "минус" расстрелять готово
готово
молвитъ сюда "\n" расстрелять
готово

готово
фух ноль расстрелять
готово



[vorbiz]

Шедеврально, чо

[Paul]

Шедеврально — это class ПОЕЗДДД. А тут просто куча дефайнов.

[S2nek]

Странно что ассемблер уже есть, а лиспа еще нет:

;нечитабельный вариант
CL-USER> (defun gen (x) (loop for i from 1 below (+ x 1) do (format t "~{~a~^-~}~%" (if (= (rem i 2) 0)	(reverse (loop for b from 1 below (+ i 1) append (list b)))	(loop for b from 1 below (+ i 1) append (list b))))))

;читабельный вариант
CL-USER> (defun gen (x) 
		   (loop for i from 1 below (+ x 1) do 
				(format t "~{~a~^-~}~%" (if (= (rem i 2) 0)
					(reverse (loop for b from 1 below (+ i 1) append (list b)))
						(loop for b from 1 below (+ i 1) append (list b))))))
GEN
CL-USER> (gen 6)

1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
6-5-4-3-2-1
NIL

[S2nek]

Чуть-чуть лучше вариант

(defun gen (x) 
  (loop for i from 1 below (+ x 1) do 
     (format t "~{~a~^-~}~%"
       (if (evenp i)
	(loop for b from i downto 1 collect b)
	(loop for b from 1 to i collect b)))))

Да, и не считаю это говнокодом.

[asolntsev]

Да не, это классное решение.
А вот предыдущие два варианта на Лиспе были плохонькие.

[root_sashok]

const n=100;
var a: array [1..n] of string;
i: byte;

begin

writeln ('Enter following data:');
writeln ('1');
writeln ('2-1');
writeln ('1-2-3');
writeln ('4-3-2-1');
writeln ('1-2-3-4-5');
writeln ('6-5-4-3-2-1');
writeln ('Until n');

for i:=1 to n do
readln (a[i]);

for i:=1 to n do
writeln (a[i]);

end.

Как-то так.

[orionll]

LINQ:

int[] array = { 1, 2, 3, 4, 5, 6 };
foreach (int i in array)
  Console.WriteLine(array.Take(i).OrderBy(x => i % 2 == 0 ? -x : x).Select(x => x.ToString()).Aggregate((x, y) => x + "-" + y));

[susl]

Вот мои два решения в одном: и лаконично и говнокод :)

for i in range(7): print '-'.join(map(str, range(1,i+1)))[::i%2*2-1]

[spmbt]

Javascript. А этот код к какому роду относится? (Рекурсия, поэтому не сразу понятно, что делает.)

<script>
onload = function(){
    document.body.innerHTML += (function(i){
        var b = function(j){
            return j ==1 ? 1
                : (i %2 ? b(j -1) : j) +'-'+ (i %2 ? j : b(j -1));
        }
        return i ==1 ? 1 : arguments.callee(i -1) +'<br/>'+ b(i);
    })(6)
}
</script>

А так переписать? (arguments.callee — это обращение функции к себе, ==«thisFunction»)

<script>
onload = function(){
    document.body.innerHTML += (function(i){
        return i ==1 ? 1 : arguments.callee(i -1) +'<br/>'
            + (function(j){    	
                return j ==1 ? 1
                    : (i %2 ? arguments.callee(j -1) : j)
                        +'-'+ (i %2 ? j : arguments.callee(j -1));
            
            })(i);
    })(6)
}
</script>

[olexandr17]

var i:int,j:int;
var _len:int = 6;
var _arr:Array;

for (i = 1; i <= _len; i++) {
_arr = [];

for (j = 0; j < i; j++)
_arr[j] = j + 1;

trace(i % 2 ? _arr.join('-') : _arr.reverse().join('-'));
}

[olexandr17]

[sectus]

Я написал.

$n = 6;
$array = array(($i = 2) - 1);
do
    echo implode('-', $array = array_reverse($array)) . PHP_EOL;
while (call_user_func($i % 2 ? 'array_unshift' : 'array_push', &$array, $i) && $n >= $i++);

[slider]

Говноерланг:
print_num(1) -> io:format("1\r\n");
print_num(NUM) when is_number(NUM),
NUM < 0 -> "error";
print_num(NUM) when is_number(NUM),
NUM rem 2 == 0
-> print_num(NUM-1),io:format(print_even(NUM) ++ "\r\n");
print_num(NUM) when is_number(NUM)
-> print_num(NUM-1),io:format(print_odd(NUM) ++ "\r\n").
print_even(1) -> "1";
print_even(NUM) ->
erlang:integer_to_list(NUM) ++ " - " ++ print_even(NUM-1).
print_odd(1) -> "1";
print_odd(NUM) ->
print_odd(NUM-1) ++ " - " ++ erlang:integer_to_list(NUM).


[slider]

js+css

<style type="text/css">
	p:nth-child(odd) 
	{
		text-align: left;
	    direction: rtl; 
		unicode-bidi: bidi-override;
	}
</style>

<script type="text/javascript">
		var text = "1";
		for(var i=1; i<=6; i++)
		{
			document.write("<p>"+text+"</p>");
			text+=" - "+(i+1)
		}	
</script>

а вот на голом css пока не получается :(

[slider]

«document.write» — ну вы понимаете ;)

[Hoorsh]

Лаконичный говно PHP-код:

<?$n=6;for($i=1;$i<=$n;$i++){$s='';for($j=1;$j<=$i;$j++){$s.=$j;
if($j!=$i){$s.="-";}}if($j%2){$r='';$z=strlen($s);for($k=$z-1;$k>=0;$k--)
$r.=$s[$k];}else$r=$s;echo($r.'
');}?>

Вывод:

1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
6-5-4-3-2-1

[veitmen]

Да что же такое! И не одной реализации визитора!

[Regul777]

Привет всем. Наверно мой комментарий уже никто не прочтет (я болел пару дней и было не до кода). Да, действительно такое количество интересных примеров я не видел давно. Решения были просто супер. Есть оптимизированные, короткие, есть решения даже в одну строчку. Но что меня опечалило, люди стремятся показать крутизну кода. И это печально. Я считаю, лучше написать плохой код, который легко читается, чем супер-крутой код, в котором тяжело разобраться с первого взгляда. Я сам в этом не мастак, но попытаюсь привести пример:

	public class PrintSequenceClass extends Sprite {

		private static const FROM_NUMBER:int = 1;
		private var _toNumber:int;

		public function printSequence(toNumber:int):void {
			trace(createSequenceString(toNumber));
		}

		public function createSequenceString(toNumber:int):String {
			_toNumber = toNumber;
			if (_toNumber % 2) {
				return createForwardSequence();
			} else {
				return createBackwardSequence();
			}
		}

		private function createBackwardSequence():String {
			var result:String = String(FROM_NUMBER);
			for (var i:int = FROM_NUMBER + 1; i <= _toNumber; i++) {
				result = result + "-" + String(i);
			}
			return result;
		}

		private function createForwardSequence():String {
			var result:String = String(FROM_NUMBER);
			for (var i:int = FROM_NUMBER + 1; i <= _toNumber; i++) {
				result = String(i) + "-" + result;
			}
			return result;
		}

	}

Код не совершенство, но это попытка сделать читабельный код.

[Hoorsh]

Кто-нибудь уже давал ссылку на govnokod.ru?

[asolntsev]

Если присмотреться внимательнее, статья прямо с неё и начинается: «На этом замечательном сайте собрана целая коллекция. „

[DenisNikolayev]

и снова LINQ (в одну строку)

Enumerable.Range(1, 6)
     .Select(i => new { forward = i % 2 == 1, nums = Enumerable.Range(1, i).Select(k => k.ToString()) })
     .Select(a => a.nums.Aggregate((n, s) => a.forward ? n + " - " + s : s + " - " + n))
     .ToList().ForEach(Console.WriteLine);

[orionll]

Блин! Круто! А про Enumerable.Range и анонимные классы я то и забыл…

[Ennki]

быдлкодеры ололо

[lazyone]

//*******************************************
Процедура ЧитабельныйКод()

      n = 1000;
      Направление = -1;
      Для ТекущийН = 1 по n цикл
            Направление = Направление*(-1);
            стр = ""+?(Направление = 1,1, ТекущийН);
            Для Цикл2 = 2 по ТекущийН Цикл
                        Стр = стр +"-"+ ?(Направление = 1, Цикл2, ТекущийН+1-Цикл2);
            КонецЦикла;
            Сообщить(Стр);
// Дальше уже проверка :)
            Если ц = 152 Тогда
                        Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например в контроле на форме»);
                        Прервать;
            КонецЕсли;
      КонецЦикла;

КонецПроцедуры

[lazyone]

Оптимизированный гкод, каждая нечетная операция — только одно сложение строк

//*******************************************
Процедура Сформировать()

    n = 1000;
    Направление = -1;
    Стр1 = «1»;    
    для ТекущийН = 1 по n цикл
        
        Направление = Направление*(-1);
        
        Если Направление = -1 Тогда
            стр = ""+ТекущийН;
            Для Цикл2 = 2 по ТекущийН Цикл
                Стр = стр +"-"+ (ТекущийН+1-Цикл2);
            КонецЦикла;
        иначе
            Стр1 = Стр1+"-" + ТекущийН;
            Стр = Стр1;
        КонецЕсли;
        
        Сообщить(Стр);
        
        // Дальше уже проверка
        Если ТекущийН = 151 Тогда
            Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например текстареа на форме „);
            Прервать;
        КонецЕсли;
        
    конецЦикла;

КонецПроцедуры

[Psionic]

Yo- с опозданиемм но всеже…
#include
int main()
{
int n=1;
int y, s;
char v=1;
scanf("%i",&s);
while(n

[Psionic]

Что-то сверху не так :(
#include
int main()
{
int n=1;
int y, s;
char v=1;
scanf("%i",&s);
while(n

[ashuha]

print '\n'.join(['-'.join(map(str, range(1, n)) if not n % 2 else map(str, reversed(range(1, n)))) for n in range(2, 10)])

[gavaez]

define('N', 6);

echo implode(PHP_EOL, array_map(function ($i) use (&$a, &$odd) {
return implode('-', ($a[] = $i) && ($odd = !$odd)? $a: array_reverse($a));
}, range(1, N)) + ['']);

[DjPhoeniX]

NodeJS. Вроде бы и ГК, а вроде бы и нет. Зато однострочник и проходит standard.