Комментарии 290
Буду капитаном говнокодом.
<?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';
<?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';
А в чем говнокодость? echo вместо print чтоли?
Ну, наверное, в том, что типичный говнокод решает только видимую часть проблемы. И проявляется только когда его нужно допилить.
Но если что можно дописать echo «echo «1-2-3-4-5-6-7», не?
И, кстати, если задача изменится, и нужно будет вывести следующее, какой код будет проше изменить?
Напечатать на экране следующее:
1
2-1
7-2-3
4-545-6-3
7-26-3-0-45+7
Напечатать на экране следующее:
1
2-1
7-2-3
4-545-6-3
7-26-3-0-45+7
Короче, я считаю что вы написали не говнокод, а очень даже правильный код человека, не страдающего ООП головного мозга.
Предлагаю Вам переписать этот код для n=1000.
Сначала отправьте СМС
Ага, а ещё этот код не жмёт картинку и не ставит вотемар, хотя… Стоп. О чём это я? О чём это вы?
Не надо менять условие задачи, если никто об этом не просил.
Не надо менять условие задачи, если никто об этом не просил.
print "
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
1000-5-4-3-2-1
";
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
1000-5-4-3-2-1
";
А ведь он, наверное, прав.
В задаче ведь не написано, что отобразить для любого n
Если в задаче сказано: напишите
1
1-2
то не имеет смысла тратить время, и всего двумя командами можно решить задачу.
В задаче ведь не написано, что отобразить для любого n
Если в задаче сказано: напишите
1
1-2
то не имеет смысла тратить время, и всего двумя командами можно решить задачу.
Вот он — настоящий Капитан Говнокод!
Я отправил. Что дальше делать?
Как вариант
1:
2:
http://pastebin.com/EaDt0Qbj
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
Упс… Первое лучше так:
<?php
$n=6;
for($i=1; $i<=$n; $i++){
$arr=($i%2) ? range(1,$i) : range($i,1,-1);
echo implode('-',$arr).'<br>';
}
?>
// 1
$m=6;
for($i=0,$a=array(); $i<=$m; $a[]=++$i)
echo join('-', $i%2 ? $a : array_reverse($a) )."<br />";
// 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 />';
}
}
)
#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);
}
Вы же делали доклад по говнокоду? Я его с удовольствием смотрел.
Заготавливаете материалы для следующего?
int main() без return [значение]
В стандартах языка C++,
www.open-std.org/jtc1/sc22/wg21/docs/papers/2005/n1905.pdf
Раздел 3.6.1, пункт 5, написано:
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;
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
Извините, на говнокод меня уже не хватило (
Скажите, это говнокод (php)? (:
$n = 6;
for($i = 1; $i <= $n; print(join('-', $i % 2 ? range(1, $i++) : range($i++, 1)) . "\n"));
по крайней мере прочесть его тяжело.
дайте его любому человеку незнакомому с этой задачей, и засеките за сколько времени он поймет что делает эта ваша одна строчка кода.
дайте его любому человеку незнакомому с этой задачей, и засеките за сколько времени он поймет что делает эта ваша одна строчка кода.
Если расписать его на несколько строчек
и забыть что это такое, то понятнее не становится :)
$n = 6;
for($i = 1; $i <= $n; $i++) {
$nums = $i % 2 ? range(1, $i) : range($i, 1);
print(join('-', $nums) . "\n");
}и забыть что это такое, то понятнее не становится :)
Тут я поспорю. Говнокод имхо — это код, который написан по-идиотски сам по себе. А тут код, который вполне грамотно написан и который просто слегка сложновато понять на первый взгляд. Тут даже можно еще сократить и не использовать переменную $nums :-)
Да и вообще не все говнокод, что может показаться им. Например:
if ($q == false) return false;
Вроде бы говнокод и можно написать просто «return $q;», правда? А на деле условие может сработать и на 0, и на пустую строку, а вернуть надо именно булевое значение. Программист просто или не знал, или поленился воспользоваться приведением типов: «return (bool)$q;», и имеет место быть не говнокод, а просто неумелость или лень :-)
Да и вообще не все говнокод, что может показаться им. Например:
if ($q == false) return false;
Вроде бы говнокод и можно написать просто «return $q;», правда? А на деле условие может сработать и на 0, и на пустую строку, а вернуть надо именно булевое значение. Программист просто или не знал, или поленился воспользоваться приведением типов: «return (bool)$q;», и имеет место быть не говнокод, а просто неумелость или лень :-)
А зачем в двух разных местах
$i++, если его можно запихнуть в одно ($i++ % 2)?Нам нужно сначала получить число, и сделать range, а потом инкриментировать.
А если инкриментировать в условии, то вывод получается не верный (так как в range попадает уже увеличенное значение).
А если инкриментировать в условии, то вывод получается не верный (так как в range попадает уже увеличенное значение).
Хотя из такого положения можно выйти так:
Спасибо за наводку! :)
$n = 6;
for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));Спасибо за наводку! :)
Интервал цикла никто не обязывал быть равным [1…n]:
Просто на мой вкус изменять счетчик цикла в разных местах тела цикла — как раз и есть частая потенциальная причина очень многих трудноотлавливаемых ошибок (e. g. «говнокод»).
$n = 6;
for($i = 0; $i < $n; print(join('-', ++$i % 2 ? range(1, $i) : range($i, 1)) . "\n"));
Просто на мой вкус изменять счетчик цикла в разных местах тела цикла — как раз и есть частая потенциальная причина очень многих трудноотлавливаемых ошибок (e. g. «говнокод»).
(6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
на perl можно и не так отжечь думаю =)
на perl можно и не так отжечь думаю =)
Просто плохое форматирование)
$n = 6;
for($i = 1; $i <= $n; $i++) {
$array = $i % 2 ? range(1, $i) : range($i, 1);
echo join('-', $array), PHP_EOL;
}
Ну да :) Я чут повыше примерно тоже самое писал.
Вложил все свои знания =)
//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
//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
Тег код не работает видать у низкокармщиков. Закинул на пастбин
pastebin.com/a18tpmqr
вот зачем мне надпись «можно использовать html-теги» если их нельзя использовать?
вот зачем мне надпись «можно использовать html-теги» если их нельзя использовать?
Без этого тега говнокод еще «наваристей» ))
Пля, похоже в сеть утекли сорсы моего проекта!
Браво
последние 4 строки исполнил на пять!
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 '-';
}
Perl:
Говнокод изложу чуть позже комментарием, надо подумать… =)
use 5.012;
my $num = $ARGV[0] // 6;
my @num_arr = 1..$num;
say join '-',$num % 2 ? @num_arr : reverse @num_arr;
Говнокод изложу чуть позже комментарием, надо подумать… =)
Там же надо все комбинации вывести. Как-то так, наверное:
my $total = 6;
for $num ( 1 .. $total ) {
say join( '-', $num % 2 ? 1..$num : reverse 1..$num );
}
Немного неверно я понял задание сначала потому:
1 вариант:
2 вариант:
Во втором варианте ещё и логическую ошибку допустил, если кому интересно — находите.
P.S. подсветка не работает из-за низкой кармы
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. подсветка не работает из-за низкой кармы
Все на что хватило фантазии: pastebin.com/rdCtf2j5
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)))
#!/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) Не следить за форматированием кода.
2) Переписать на C, реализуя все готовые функции самостоятельно (и, разумеется, криво).
3) Переписать на ООП, реализовав свой класс строк.
4) Переписать на ООП, реализовав иерархию классов на 5 уровней, с интерфейсам, наследованием и т.д. Вспомнить про паттерны. Применить по максимуму.
5) Аналогично 4, но на С++ (про кривизну не забываем).
// Инициализация
$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, но на С++ (про кривизну не забываем).
P.S. Для 3-4 подойдет любой высокоуровневый язык, такие как C#, PHP, Java и т.д.
C/C++ выделяю отдельно потому как только там мне удавалось без особых извращений объявить структуру, привести вещественное число к этой структуре и работать с экспонентой числа как заблагорассудится. Простор для говнокода просто неисчерпаемый (сразу скажу, что против C/C++ ни чего против не имею, прекрасный, гибкий язык).
C/C++ выделяю отдельно потому как только там мне удавалось без особых извращений объявить структуру, привести вещественное число к этой структуре и работать с экспонентой числа как заблагорассудится. Простор для говнокода просто неисчерпаемый (сразу скажу, что против C/C++ ни чего против не имею, прекрасный, гибкий язык).
ваш нормальный вариант — что вообще делает? )
(6 + 1).times{|i| p (1..i).to_a.send((i%2 == 0)? :to_a: :reverse).join('-')}
НЛО прилетело и опубликовало эту надпись здесь
В тред врывается Haskell.
1)
2) (Я сильно вспотел, когда писал это)
codepad.org/NQUSqcjc
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
После прочтения условия «Естественно, вместо 6 может быть любое число», появилось нездоровое желание вместо «6» влепить рандом))))) а остальное вывести принтом)
На APL будет одно выражение, но довольно говнокодистое:
Java:
Сомневаюсь что возможно короче. Данную задачу выполняет, масштабируется заменой константы «6» в цикле.
Самый говонокод, по моему мнению, написал Davert в первом комменте.
String s = "1";
for(int i = 2; i <= 6; i++)
System.out.println(s = i + "-" + s);
Сомневаюсь что возможно короче. Данную задачу выполняет, масштабируется заменой константы «6» в цикле.
Самый говонокод, по моему мнению, написал Davert в первом комменте.
Однако смотрю в коде народ активно использует массивы, вот вам + немного говнокода :)
<?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;
}
?>
Без массивов это правильно, я тоже сделал без массивов. Но вот константы то зачем объявлять, да еще и писать их с учетом coding style?
У Вас пока самый читабельный вариант из всех.
НЛО прилетело и опубликовало эту надпись здесь
Интересно, почему вы это называете говнокодом?
По-моему, одно из лучших решений!
По-моему, одно из лучших решений!
Нечитаемый питоноговнокод:
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)])
Коль такая пьянка:
#нормальный вариант
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))
Придумал ещё хуже:
lambda x: "\n".join('-'.join(map(str,range(1, n+1))[::bool(n%2) or -1]) for n in range(1, x + 1))Итерация для джойна лишьняя
#нормальный вариант
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)
питон pastie.org/1782311 :)
или даже pastie.org/1782360 ;)
<?php
$sign = true;
for($i=1; $i <=6; $i++) {
echo implode('-', $sign ? range(1, $i) : range($i, 1)) . "\n";
$sign = !$sign;
}
>+++++++>+++++++>+++++++>+++++++>+++++++>+++++++>+++++++<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<+++++++++[>+++++<-]++++++++++>
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
Ну а говнокодистое на один экран наверное не влезет :)
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
Ну а говнокодистое на один экран наверное не влезет :)
У Вас
[ пропущена после восьмого символа (перед вторым >)
По моему исходя из того, что браинфак вообще в принципе не читабельный язык, то довольно сложно или даже невозможно сделать что-либо «неговнокодистое». ( не в обиду любителям )
пара символов в начале проги пропущено.
PS: предлагаю посоревноваться на размер brainfuck-ового исходника (мой см. ниже) ;-)
PS: предлагаю посоревноваться на размер brainfuck-ового исходника (мой см. ниже) ;-)
Пропущена кавычка только одна, как и сказал pechlambda :)
Оптимизировал:
>+++++++[>+++++++<-]>[>+>+>+>+>+>+<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<<+++++++++[>+>+++++<<-]>+>
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
Итого без лишних пробелов и переносов строк мой вариант получился в 261 байт, твой в 279 :-)
Оптимизировал:
>+++++++[>+++++++<-]>[>+>+>+>+>+>+<<<<<<-]>>+>++>+++>++++>+++++<<<<<<<<+++++++++[>+>+++++<<-]>+>
>.< <.>
>>.<<.>.< <.>
>.<.>>.<<.>>>.<<< <.>
>>>>.<<<<.>>>.<<<.>>.<<.>.< <.>
>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<< <.>
>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<
Итого без лишних пробелов и переносов строк мой вариант получился в 261 байт, твой в 279 :-)
++++++++++[>+++++>+<<-]>[>>+>+
>+>+>+>+>+<<<<<<<<-]>>----->->
>+>++>+++>++++<<<<<.<<.>>>.<<.
>.<<.>>.<.>>.<<.>>>.<<<<.>>>>>
.<<<<.>>>.<<<.>>.<<.>.<<.>>.<.
>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.
<<<<<<.>>>>>>>.<<<<<<.>>>>>.<<
<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.
<<.243 вроде
+++++++[>+>+++++++>+++++++<<<-]>+++>.>----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
141 байт
141 байт
++++++++++[>+>+++++>+++++<<<-]>>-.>-----<<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
на 2 меньше
на 2 меньше
даже вот так:
+++++[>++>++++++++++>+++++++++<<<-]>>-.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
+++++[>++>++++++++++>+++++++++<<<-]>>-.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
+++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>.>.<+.>.<+.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.>.<-.>.<-.
Еще на 2 меньше, 135 байт
Еще на 2 меньше, 135 байт
+++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>>>++++[<<.+>.>-]<<.<.>++>>+++++[<<-.>.>-]<<-.
129 байт :-)
129 байт :-)
Отец!
+++++++++[>+>+++++>+++++<<<-]>+>++++.<.>+.>.<-.<.>.>.<+.>.<+.<.>+.>.<-.>.<-.>.<-.<.>>>++++[<<.+>.>-]<<.<.>+.>>+++++[<.<-.>>-]
125 байт. Где чего еще можно соптимизировать — уже не знаю :-) Циклы помогают только для двух последних строк (для четвертой можно, получится байт-в-байт), но уменьшить их хоть на байт вроде уже нельзя. Подозреваю, что можно уменьшить самое начало, где записываются коды символов, но как — тоже не знаю.
Я таки победил? :-)
125 байт. Где чего еще можно соптимизировать — уже не знаю :-) Циклы помогают только для двух последних строк (для четвертой можно, получится байт-в-байт), но уменьшить их хоть на байт вроде уже нельзя. Подозреваю, что можно уменьшить самое начало, где записываются коды символов, но как — тоже не знаю.
Я таки победил? :-)
Для любого четного m от 2 до 8, йоу! 120 байт!
++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>>>+>[<+>-]<<<+.>>[<.<-.>>->+<]>[<+>-]<+<<<.<<--]
++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>>>+>[<+>-]<<<+.>>[<.<-.>>->+<]>[<+>-]<+<<<.<<--]
104 =)
++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>+.>>>+[<<.<-.>>>-<+>]<+<<<.<<--]
++++++>+++++++++[>+>+++++>+++++<<<-]>+>++++<<<[>>>.>>[<.<+.>>->+<]<<<.>+.>>>+[<<.<-.>>>-<+>]<+<<<.<<--]
+++++[>+>++>++++++++
++>+++++++++<<<<-]>+
>>-<<[>>.>>[<.<+.>>-
>+<]<<<.>+.>>>+[<<.<
-.>>>-<+>]<+<<<.<--]ровно 100
вчера заснул, пытаясь реализовать то же самое :-)
тимати в записи c конференции для хохмы? :)
Думаю, что сама постановка задачи сформулирована неправильно. Она целенаправленна, что уже гарантирует по крайней мере на 50 % не г… Что бы точно вышло Г… надо говорить так. — Ну это не подходит! (без малейших объяснений), а сделайте так как у нас положено, принято и нам нравится.
Меня всегда интересовал вопрос, почему появляется говнокод.
Что послужило причиной появления:
Если честно, то очень хотелось бы комментариев от его авторов.
Я могу представить только вариант постепенной доработки кода разными программистами в условиях жуткого аврала:
1. вначале был относительно нормальный код, в переменной int exit_code хранился код ошибки (4 — плохо, произошло то-то и то-то)
2. а потом бабах и для упрощения (оптимизации) решили объединить обработку этой ошибки с еще несколькими, ввели переменую boolean b.
3. заменили регекспом везде exit_code на b.toString().length(), чтобы типы данных остались прежними…
Короче, моя мысль такая: отборный говнокод появляется в результате оптимизации.
Что послужило причиной появления:
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(), чтобы типы данных остались прежними…
Короче, моя мысль такая: отборный говнокод появляется в результате оптимизации.
Абсолютно согласен и могу добавить ещё одну причину:
недостаточное знание языка программирования, то есть человек пишет совсем на другом, а с этим ему надо поработать эпизодически и оттуда тоже появляются шедевры. Я выше написал своё решение на Perl как написал бы опытный программист(1) и как мог бы написать неопытный(2).
недостаточное знание языка программирования, то есть человек пишет совсем на другом, а с этим ему надо поработать эпизодически и оттуда тоже появляются шедевры. Я выше написал своё решение на Perl как написал бы опытный программист(1) и как мог бы написать неопытный(2).
Ну-ну, оптимизация сама по себе вещь хорошая, когда она нужна.
Думаю, правильнее было бы сказать так: отборный говнокод появляется в результате изменений кода. Но это, простите, КО.
Думаю, правильнее было бы сказать так: отборный говнокод появляется в результате изменений кода. Но это, простите, КО.
Ну как-то так:
<?
$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";
}
?>
Вообще, задача такова, что любое решение будет похоже на гавнокод. Вот для 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();
}
}
}Вот решение покороче :)
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"));
}
}
Настоящий говнокод — это решение влоб, покрывающее строго фиксированный интервал значений.
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» );
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» );
Да, в продолжение ещё хотел написать код с парой фабрик (на алгоритм рисования этой пирамиды и на рисование строк), но на середине бросил и подумал, что это уже слишком. Хотя получалось нечто 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();
}
}
Вот переписать подобное ООП-решение на PHP с использованием MVC-фреймворка (Yii тот же) ради вывода этих 6ти строчек — пожалуй, говнокодисто будет.
А на brainfuck'е никто ещё не написал? Интересно, как будет говнокод от нормального кода на нём отличаться…
На тикле:
-в стиле каки:
-со списками, самый простой:
-в стиле каки:
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";}
Достаточно говнокодисто получилось:
<?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;
}
?>
Еще переменные надо переименовать. Например, Stroka в Naoborot, Noborot в Stroka, Stroka_array в hz_list_false_or_true.
Понравились ваши имена переменных!
Вчера заглядывал в БД PHPShop, повеселили названия полей в некоторых таблицах:
baseinputvaluta
odnotip
sklad_action
title_shablon
kurs
otsiv
otvet
Вчера заглядывал в БД PHPShop, повеселили названия полей в некоторых таблицах:
baseinputvaluta
odnotip
sklad_action
title_shablon
kurs
otsiv
otvet
Я прошу прощения, но то, что большинство людей написало в комментариях, считая хорошим кодом, как раз и есть говнокод. Имхо, самое главное отрицательное качество говнокода — не большой размер, а нечитабельность. Хороший код должен читаться как хорошая книга. Если ваш язык программирования позволяет использовать высокоуровневые конструкции, зачем вы продолжаете пытаться писать на брейнфаке?
Я написал два примера кода, оба считаю далеко не идеальными. Уверен, каждый сможет найти более десятка замечаний. Первый больше приспособлен к дальнейшему изменению и расширению. Второй
«в одну строчку». Лично я считаю примером говнокода скорее второй вариант. Готов обсудить.
И извините за названия классов.
Я написал два примера кода, оба считаю далеко не идеальными. Уверен, каждый сможет найти более десятка замечаний. Первый больше приспособлен к дальнейшему изменению и расширению. Второй
«в одну строчку». Лично я считаю примером говнокода скорее второй вариант. Готов обсудить.
И извините за названия классов.
Вы верно пишете про приоритет читабельности.
Только высокоуровневые конструкции != читабельность.
Только высокоуровневые конструкции != читабельность.
Вы сильно категоричны. Я считаю, что хороший код должен показывать скорее что он делает, нежели как он это делает. Опять же, это скорее применимо к большим enterprise системам. Конечно, для низкоуровневых программ, где требуется прежде всего скорость, иногда нужно оптимизировать в ущерб читабельности.
Никакой категоричности. Я как раз согласен, что по коду должна быть понятна задача, которую он выполняет. Только вот Ваш ООП-вариант несмотря на расширяемость (хотя вероятность того, что данный код потребует расширения минимальна), на мой взгляд описывает решаемую задачу хуже, чем пример без высокоуровневых конструкций выше.
Хотя по скорости Ваш вариант должен быть быстрее ввиду отсутствия работы со строками, но это в расчет не берём.
Хотя по скорости Ваш вариант должен быть быстрее ввиду отсутствия работы со строками, но это в расчет не берём.
Мой вариант не претендует на идеальность и он не объектно-ориентированный, поскольку используются статические методы класса.
По поводу примера по Вашей ссылке, я рассматривал подобную реализацию, согласен, она гораздо лучше читается, но не выдерживает совершенно никакой критики как по производительности, так и по используемой памяти (а что, если n будет равно 100000000?). Тут, мне кажется, уместнее всё же сохранять баланс между тривиальной оптимизацией и размером кода.
По поводу примера по Вашей ссылке, я рассматривал подобную реализацию, согласен, она гораздо лучше читается, но не выдерживает совершенно никакой критики как по производительности, так и по используемой памяти (а что, если n будет равно 100000000?). Тут, мне кажется, уместнее всё же сохранять баланс между тривиальной оптимизацией и размером кода.
На статические методы внимания не обратил, извиняюсь, на Java никогда не писал. В целом мы вроде пришли к единому мнению, что тот код несмотря на отсутствие высокоуровневых конструкций читается лучше. А читабельность приоритетна, и в этом был посыл Вашего сообщения, не так ли?
И n=10^8 конечно интересно, но уже из области преждевременной оптимизации. Всё таки наиболее вероятно, что выводить на экран строку, превышающую по длине ширину экрана не потребуется, и потому тот код вряд ли будет являться узким местом в системе. Т.е. можно осознанно его выбрать как более читабельный, но менее производительный.
И n=10^8 конечно интересно, но уже из области преждевременной оптимизации. Всё таки наиболее вероятно, что выводить на экран строку, превышающую по длине ширину экрана не потребуется, и потому тот код вряд ли будет являться узким местом в системе. Т.е. можно осознанно его выбрать как более читабельный, но менее производительный.
В этом ничего удивительного нет. «Говнокод» очень широкое понятие, поэтому многие к нему относятся по разному. Опять же, читабельность кода также зависит и от глубины понимания языка программирования.
P.S. в Java не сильно разбираюсь, потому оценить ваш код не смогу никак.
P.S. в Java не сильно разбираюсь, потому оценить ваш код не смогу никак.
Поддерживаю! Читабельность, на мой взгляд, — один из главных критериев хорошего кода.
Естественно, сам код с точки зрения алгоритма должен быть верен и оптимален, но это должно подразумеваться само собой :)
Ниже в комментариях я оставил свой пример того, что считаю хорошим примером кода.
Естественно, сам код с точки зрения алгоритма должен быть верен и оптимален, но это должно подразумеваться само собой :)
Ниже в комментариях я оставил свой пример того, что считаю хорошим примером кода.
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)
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)
Извиняюсь за форматирование. Здесь можно посмотреть в нормальном виде:
pastebin.com/GEreUx2j
pastebin.com/GEreUx2j
На мой взгляд, использование подобной лексики в постах недопустимо на ресурсах вроде Хабра, на который заходят в большинстве своем, по-моему мнению, серьезные люди.
я кроме Вас серьезных людей тут не встречал.
Мысль нужно озвучивать в должной форме, дабы исключить ее двоякое толкование.
А в меньшинстве своём, но всё-таки заходят, дети. Им такие слова уж и подавно нельзя показывать!
«Подобной» лексики — это какой?
Вы имеете в виду «говнокод»? Согласен, лучше было бы использовать что-нибудь поприличней, но человечество не придумало ещё такого термина, который бы так же точно отражал суть предмета.
Вы имеете в виду «говнокод»? Согласен, лучше было бы использовать что-нибудь поприличней, но человечество не придумало ещё такого термина, который бы так же точно отражал суть предмета.
Именно такой. Да и еще на главной странице. Не знаю, известно ли вам, но некоторые слова в приличном обществе не употребляют. А все оправдания — дешевые отмазки.
Зато, как видно, в приличном обществе принято использовать слэнговые слова, пришедшие из криминального жаргона.
Ну ладно, давайте конструктивно: предложите достойный приличный термин, и я впредь буду использовать только его. И переименую топик.
Кстати, надо бы еще обратиться к администрации хабра, чтобы он переименовали блог code_wtf в что-нибудь более приличное, ведь «wtf» переводится на русский язык еще неприличнее.
Ну ладно, давайте конструктивно: предложите достойный приличный термин, и я впредь буду использовать только его. И переименую топик.
Кстати, надо бы еще обратиться к администрации хабра, чтобы он переименовали блог code_wtf в что-нибудь более приличное, ведь «wtf» переводится на русский язык еще неприличнее.
$a = array();
for($i=1;$i<7;$i++)
{
$a[]=$i;
echo implode('-', $i%2 ? $a : array_reverse($a)), '
';
}
puts (1..6).map{|n| (1..n).to_a.reverse.join("-")}.join("\n")
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]);
}
}А че, я всегда так пишу…
В 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;
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;
QString string = «6-5-4-3-2-1»;
for (int i = 2; i < 12; i+=2) puts(string.right(i));
for (int i = 2; i < 12; i+=2) puts(string.right(i));
def f(n):
print '-'.join(map(str, xrange(1, n+1))[::-1 if (n+1)%2 else 1])
Говно код — он бывает разные, бывает говно по форме, а бывает говно по сути, вот второе это код из первого камента, а первое — это то чтонаписал krink.
По сути все верно, но записано так что ни кто кроме автора тут ничерта не поймет.
По сути все верно, но записано так что ни кто кроме автора тут ничерта не поймет.
<?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>'?>
странно, что никто еще не написал проверок в духе if (true=true || 1=1) (:
+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++.>++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++.>
и
++++++++++++[->++++>+>+<<<]>[->>>+>+>+>+>+>+>+<<<<<<<<<]>+>-->--->+>++>+++>++++>+++++>++++++<<<<<.<<<.>.>>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<<<.>.
>>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<<<<.>.>>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.
и
++++++++++++[->++++>+>+<<<]>[->>>+>+>+>+>+>+>+<<<<<<<<<]>+>-->--->+>++>+++>++++>+++++>++++++<<<<<.<<<.>.>>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<<<.>.
>>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.>>.<.>>.<<.>>>.<<<.>>>>.<<<<.>>>>>.<<<<<<<.>.>>>>>>>.<<<<<<.>>>>>.<<<<<.>>>>.<<<<.>>>.<<<.>>.<<.>.<<<.>.
#!/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");
}
А я бы написал так, не знаю только говнокод это или нет. 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)
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)
Извиняюсь, продублирую с отступами, а то непонятно:
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)
Для Питона это однозначно говнокод, ведь там в одну-две строчки можно написать, и ничуть не менее читабельно.
Вот на Яве по-другому нельзя.
Вот на Яве по-другому нельзя.
Очень не люблю, когда много написано в одну строку.
Часто приходится разбираться с чужим кодом. Поубивал бы.
Хуже всего:
— Несколько вызовов функций в одной строке
— Невозврат из функций, переход в другое мест по исключению.
Предпочитаю писать так:
result = func1(x,y)
result2 = func2(result)
return result2
чем:
return func2(func1(x,y))
Часто приходится разбираться с чужим кодом. Поубивал бы.
Хуже всего:
— Несколько вызовов функций в одной строке
— Невозврат из функций, переход в другое мест по исключению.
Предпочитаю писать так:
result = func1(x,y)
result2 = func2(result)
return result2
чем:
return func2(func1(x,y))
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();
}Использования 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.
Есть источник вдохновения, но лень писать, потому делаем на ПХП так:
генерим массивы через рэйндж и джоиним их.
Нечетные строки реверсим.
Обнаруживаем, что не работает для двузначных чисел, потому для каждой такой подстроки находим числа по регекспу(естественно, извратному), реверсим и возвращаем в строку.
генерим массивы через рэйндж и джоиним их.
Нечетные строки реверсим.
Обнаруживаем, что не работает для двузначных чисел, потому для каждой такой подстроки находим числа по регекспу(естественно, извратному), реверсим и возвращаем в строку.
>>> 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
>>> 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.upto(6) {|i| p (1..i).to_a.tap{|a| a.reverse! if i.even?}.join('-')}
Пост превосходства руби над другими жалкими языками. Говнокод попозже придумаю. Даже на руби можно говнокодить (
Пост превосходства руби над другими жалкими языками. Говнокод попозже придумаю. Даже на руби можно говнокодить (
Имена переменных должны быть осмысленные. Мне мой код нравится больше (см. выше) мой код на perl
Ну в таком случае ничем, ничем не могу помочь. Конечно, давайте самые незначительные счётчики в итерация называть осмысленно. Вот уже где говнокод так говнокод.
Если счетчик можно назвать осмысленно, то почему бы этого не сделать? :)
Чтобы код выглядел легче. В первую очередь. Во вторую — потому что так принято. И какой бы ты код ни читал тебе не придётся запоминать, что переменная lineNumber — это сраный счётчик в цикле. Если глаз видит i — мозг уже знает, что к чему.
Позволю себе продемонстрировать, что я считаю не говнокодом. Документация и хорошая читаемость кода, на мой взгляд, — очень важные вещи.
- /// <summary>
- /// Prints <paramref name="lines"/> number of lines in the
- /// following format:
- /// <example>
- /// 1
- /// 2-1
- /// 1-2-3
- /// 4-3-2-1
- /// </example>
- ///
- /// Each line represents a sequence which consists of <c>n</c>
- /// numbers, <c>n</c> being the 1-based sequence number of the
- /// line. In every second line the order of numbers is reverted.
- /// </summary>
- /// <param name="lines">The number of lines to display.</param>
- public void PrintSequence(int lines)
- {
- //
- // On each iteration, this list stores the sequence of
- // numbers corresponding to the current line.
- //
- List<int> currentNumbers = new List<int>();
-
- for(int n = 1; n <= lines; n++)
- {
- currentNumbers.Add(n + 1);
-
- //
- // This temporary array will contain the actual sequence
- // of numbers to display.
- //
- int[] tempArray = currentNumbers.ToArray();
-
- //
- // If the line number is even, reverse the order.
- //
- if(n % 2 == 0)
- {
- Array.Reverse(tempArray);
- }
-
- //
- // Concatenate the sequence into resulting string.
- //
- string outputLine =
- String.Join(
- @"-",
- Array.ConvertAll(tempArray, v => v.ToString()));
-
- //
- // Finally, print the line to screen.
- //
- Console.WriteLine(outputLine);
- }
- }
* This source code was highlighted with Source Code Highlighter.Очень много комментариев. ИМХО, нужно стремиться к тому, чтобы комментариев было бы поменьше, а сам код читался бы как комментарии.
Ваш код хорошо читаем. Комментарии — это тоже очень правильно. Выше уже написали, что в данном примере комментариев избыточно много. Но, имхо, лучше, когда комментариев много, чем когда их нет. К сожалению, Вы совершенно не думаете о производительности.
Я думаю о производительности, когда стоит такая задача :) В данном случае я стремился сделать код как можно более читабельным. Если он будет работать медленно, то его можно переписать, но это, скорее всего, ухудшит читаемость.
Однако, как показывает практика, до проблем со скоростью дело доходит крайне редко, и намного большие проблемы возникают из-за трудностей в поддержке кода.
Впрочем, когда передо мной стоит задача что-то реализовать, я сначала выясняю все подробности о том, в каких условиях будет работать решение, и тогда уже принимаю тактические решения по балансу производительности/краткости/читаемости кода. В данном же случае про производительность в задаче ничего не сказано, поэтому я просто продемонстрировал читаемость.
Однако, как показывает практика, до проблем со скоростью дело доходит крайне редко, и намного большие проблемы возникают из-за трудностей в поддержке кода.
Впрочем, когда передо мной стоит задача что-то реализовать, я сначала выясняю все подробности о том, в каких условиях будет работать решение, и тогда уже принимаю тактические решения по балансу производительности/краткости/читаемости кода. В данном же случае про производительность в задаче ничего не сказано, поэтому я просто продемонстрировал читаемость.
«Premature optimization is the root of all evil.»
Угадайте кто ;)
Угадайте кто ;)
Ваше решение — конечно, не говнокод. Но на мой взгляд, оно избыточное. Слишком много строк и текста для такой простой задачи. Шапка хороша, я бы оставил из неё только первую половину. Остальные комментарии не несут никакой полезной информации. Например, «Finally, print the line to screen.» — это и так понятно из кода. Комментарии должны содержать только ту информацию, которую трудно/невозможно вычитать из кода.
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");
}
}
Неплохая разминка для утра: :)
#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;
}
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');
}
}
$ 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
1
2-1
1-2-3
4-3-2-1
1-2-3-4-5
6-5-4-3-2-1
(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)
я тоже напрогал… яху…
#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.
#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.
Советую: source.virtser.net/
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.
Однострочник на 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"}
У меня вот код всегда избыточен, но говно ли он… не знаю, решайте сами =)
Вывод:
Qt/C++
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++
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]
Странно, что ещё никто про /dev/urandom не вспомнил)
А можно еще вот так извратиться…
- int n = 1;
- int m = 1;
- int n_max = 6;
-
- for ( n = 1; n <= n_max; n++ )
- {
- if ( ( n % 2 ) == 0 )
- {
- m = n;
- goto even;
- }
- else
- {
- m = n;
- goto odd;
- }
- back:;
- }
-
- even:
- for ( int i = m; i >= 1; i-- )
- {
- char buffer[1024];
- printf( "%i", i );
- if ( i > 1 ) printf( "-" );
- }
- printf( "\n" );
- if ( m >= n_max ) goto exit_label; else goto back;
- odd:
- for ( int i = 1; i <= m; i++ )
- {
- char buffer[1024];
- printf( "%i", i );
- if ( i < m ) printf( "-" );
- }
- printf( "\n" );
- if ( m >= n_max ) goto exit_label; else goto back;
-
- exit_label:
-
Отмечусь.
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.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;}
Как же без 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.
Говнокод в стиле явы. Можно было еще дальше развивать, но надоело
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);
}
}
}
}
И читабельный вариант
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();
}
}
}
а мысли у нас одинаковы, хоть и языки разные habrahabr.ru/blogs/code_wtf/116842/#comment_3794924
И еще говно-вариант, зато с одним циклом
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('-');
}
}
}
}
… и большинство комментариев — загадка: говнокод это или нет.
$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";
}
слоган: нет денег на обфускатор — пиши говнокод!
НЛО прилетело и опубликовало эту надпись здесь
Лаконичный говнокод:
<?php
$max = 6;
while (@count($r) < $max) {
@$r[] = count($r) + 1;
echo implode('-', count($r) % 2 ? $r : array_reverse($r)) . PHP_EOL;
}
Зайдёт какой-нить иностранец без знания русского на хабр… Так и начнётся история, что в русские программисты — говнокодеры.
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);
}
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)));
Налажу и я свой кусочек:
Заставить его работать было сложнее, чем нормальным методом.
<?
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);Заставить его работать было сложнее, чем нормальным методом.
Нечетные строки должны начинаться с 1, а четные должны быть в обратном порядке. Да и в место OB можно было с таким же успехом использовать переменную, это не сильно врияет на читабиность.
Я как обычно просмотрел, спасибо. Но зато в итоге говнокод получился еще говнокодистее!
С переменной оно конечно проще, но не так интересно. Как по мне, один из признаков говнокода использование неадекватных потребностям инструментов.
<?
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);
С переменной оно конечно проще, но не так интересно. Как по мне, один из признаков говнокода использование неадекватных потребностям инструментов.
#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;
}
python-говнокод от меня:
[(lambda l:print(*((l)if(i%2)else(list(reversed(l)))),sep='-'))(range(1,i+1))for(i)in(range(1,7))]
Говнокодик на асме(не проверял):
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Что-то меня поперло сегодня на говнокод:
#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" расстрелять
готово
готово
фух ноль расстрелять
готово
Шедеврально, чо
Шедеврально — это class ПОЕЗДДД. А тут просто куча дефайнов.
Странно что ассемблер уже есть, а лиспа еще нет:
;нечитабельный вариант
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
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.Как-то так.
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));
Вот мои два решения в одном: и лаконично и говнокод :)
for i in range(7): print '-'.join(map(str, range(1,i+1)))[::i%2*2-1]
Javascript. А этот код к какому роду относится? (Рекурсия, поэтому не сразу понятно, что делает.)
А так переписать? (arguments.callee — это обращение функции к себе, ==«thisFunction»)
<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>
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('-'));
}
Я написал.
$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++);
Говноерланг:
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).
js+css
а вот на голом 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 пока не получается :(
Лаконичный говно 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
Да что же такое! И не одной реализации визитора!
Привет всем. Наверно мой комментарий уже никто не прочтет (я болел пару дней и было не до кода). Да, действительно такое количество интересных примеров я не видел давно. Решения были просто супер. Есть оптимизированные, короткие, есть решения даже в одну строчку. Но что меня опечалило, люди стремятся показать крутизну кода. И это печально. Я считаю, лучше написать плохой код, который легко читается, чем супер-крутой код, в котором тяжело разобраться с первого взгляда. Я сам в этом не мастак, но попытаюсь привести пример:
Код не совершенство, но это попытка сделать читабельный код.
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;
}
}
Код не совершенство, но это попытка сделать читабельный код.
Кто-нибудь уже давал ссылку на govnokod.ru?
и снова 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);
быдлкодеры ололо
//*******************************************
Процедура ЧитабельныйКод()
n = 1000;
Направление = -1;
Для ТекущийН = 1 по n цикл
Направление = Направление*(-1);
стр = ""+?(Направление = 1,1, ТекущийН);
Для Цикл2 = 2 по ТекущийН Цикл
Стр = стр +"-"+ ?(Направление = 1, Цикл2, ТекущийН+1-Цикл2);
КонецЦикла;
Сообщить(Стр);
// Дальше уже проверка :)
Если ц = 152 Тогда
Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например в контроле на форме»);
Прервать;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
Процедура ЧитабельныйКод()
n = 1000;
Направление = -1;
Для ТекущийН = 1 по n цикл
Направление = Направление*(-1);
стр = ""+?(Направление = 1,1, ТекущийН);
Для Цикл2 = 2 по ТекущийН Цикл
Стр = стр +"-"+ ?(Направление = 1, Цикл2, ТекущийН+1-Цикл2);
КонецЦикла;
Сообщить(Стр);
// Дальше уже проверка :)
Если ц = 152 Тогда
Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например в контроле на форме»);
Прервать;
КонецЕсли;
КонецЦикла;
КонецПроцедуры
Оптимизированный гкод, каждая нечетная операция — только одно сложение строк
//*******************************************
Процедура Сформировать()
n = 1000;
Направление = -1;
Стр1 = «1»;
для ТекущийН = 1 по n цикл
Направление = Направление*(-1);
Если Направление = -1 Тогда
стр = ""+ТекущийН;
Для Цикл2 = 2 по ТекущийН Цикл
Стр = стр +"-"+ (ТекущийН+1-Цикл2);
КонецЦикла;
иначе
Стр1 = Стр1+"-" + ТекущийН;
Стр = Стр1;
КонецЕсли;
Сообщить(Стр);
// Дальше уже проверка
Если ТекущийН = 151 Тогда
Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например текстареа на форме „);
Прервать;
КонецЕсли;
конецЦикла;
КонецПроцедуры
//*******************************************
Процедура Сформировать()
n = 1000;
Направление = -1;
Стр1 = «1»;
для ТекущийН = 1 по n цикл
Направление = Направление*(-1);
Если Направление = -1 Тогда
стр = ""+ТекущийН;
Для Цикл2 = 2 по ТекущийН Цикл
Стр = стр +"-"+ (ТекущийН+1-Цикл2);
КонецЦикла;
иначе
Стр1 = Стр1+"-" + ТекущийН;
Стр = Стр1;
КонецЕсли;
Сообщить(Стр);
// Дальше уже проверка
Если ТекущийН = 151 Тогда
Сообщить(«Все классно, но для N >152 нужна неограниченная строка, например текстареа на форме „);
Прервать;
КонецЕсли;
конецЦикла;
КонецПроцедуры
НЛО прилетело и опубликовало эту надпись здесь
Yo- с опозданиемм но всеже…
#include
int main()
{
int n=1;
int y, s;
char v=1;
scanf("%i",&s);
while(n
#include
int main()
{
int n=1;
int y, s;
char v=1;
scanf("%i",&s);
while(n
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)])
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)) + ['']);
echo implode(PHP_EOL, array_map(function ($i) use (&$a, &$odd) {
return implode('-', ($a[] = $i) && ($odd = !$odd)? $a: array_reverse($a));
}, range(1, N)) + ['']);
Зарегистрируйтесь на Хабре, чтобы оставить комментарий
Говнокод: врага надо знать в лицо