1. Си / Говнокод #6973

    +142

    1. 1
    2. 2
    3. 3
    4. 4
    5. 5
    6. 6
    case 43: /* + */
        sum_up += sum_up > 1 ? 0 : 1;
        return 1;
    case 45: /* - */
        sum_up -= sum_up < 1 ? 0 : 1;
        return 1;

    Если выше/ниже лимита то добавляем/отнимаем ничего.

    ЗЫ sum_up это переменная контролирующая уровень вербозности (0,1,2) специальной мониторной проги. кнопками +/- можно интерактивно контролировать. К слову, сверху это уже правленый код. Оригинальный оригинал:

    if (c == 43) { sum_up = sum_up > 1 ? sum_up : ++sum_up; return 1; }
    if (c == 45) { sum_up = sum_up < 1 ? sum_up : --sum_up; return 1; }

    Запостил: Dummy00001, 16 Июня 2011

    Комментарии (41) RSS

    • > Оригинальный оригинал
      зачот!
      Ответить
    • Ох, на C я бы написал где-то так:
      case '+':
          sum_up = (sum_up >= 2) ? 2 : (sum_up + 1);
          sum_up = (sum_up < 0) ? 0 : sum_up;
          return 1;
      case '-':
          sum_up = (sum_up <= 0) ? 0 : (sum_up - 1);
          sum_up = (sum_up > 2) ? 2 : sum_up;
          return 1;

      Но это грустно, это не весело.
      Весело - это:
      (let ((verbosity 1)) (defun update_verbosity (in_char) (setf verbosity (min 2 (max 0 (funcall (case in_char (#\+ #'1+) (#\- #'1-) (otherwise #'identity)) verbosity))))))
      Ответить
      • я вас умоляю. код писаный по человечески:
        case '+':
            if (sum_up < 2) sum_up++;
            return 1;
        case '-':
            if (sum_up > 0) sum_up--;
            return 1;
        Ответить
        • А если '+' при sum_up = (-1) или '-' при sum_up = 10?
          Ответить
          • начальное значение 0. меняется только в этих двух строчках кода.
            Ответить
            • Хорошо если это так. И хорошо, если так будет всегда.
              Ответить
      • Пытался придумать структуру, в которой: car первого элемента списка указывает на первый элемент списка (и при этом равен 0) и cdr последнeго элемента списка указывает на последний элемент (и при этом равен 2) . В таком случае min / math не были бы нужны, попытавшись перейти на индекс "за границами" списка, мы бы просто остались на последнем элементе. Но чего-то уже поздно, и не соображу как такое сделать :)
        Ну, как циклический список, только переход не с "первого" на "последний" а с "первого" на "первый" и с "последнего" на "последний".
        Ответить
        • min / math -> min / max :)
          Ответить
        • У меня получилось что-то такое. Как раз для этого сайта.
          (defun new-chain (d) (let ((x (cons d nil))) (car (setf (cdr x) (cons x x)))))
          (defun find-leftmost-element (n) (do ((c n (cadr c))) ((eq c (cadr c)) c)))
          (defun find-rightmost-element (n) (do ((c n (cddr c))) ((eq c (cddr c)) c)))
          (defun merge-chains (p q) (let ((l (find-leftmost-element q)) (r (find-rightmost-element p))) (setf (cdar l) r) (setf (cddr r) l) p)
          (defun take-n-steps-left (v n) (let ((c v)) (dotimes (i n c) (setf c (cadr c)))))
          (defun take-n-steps-right (v n) (let ((c v)) (dotimes (i n c) (setf c (cddr c)))))
          (defun get-value-for (v n) (car (cond ((< (car v) n) (take-n-steps-right v (- n (car v)))) ((> (car v) n) (take-n-steps-left v (- (car v) n))) (t v))))
          (setf range_list (merge-chains (new-chain 0) (merge-chains (new-chain 1) (new-chain 2))))
          (get-value-for range_list 4)
          (get-value-for range_list -1)
          Ответить
          • Смотрю, здесь в комментах сегодня собралось много интересных кусков кода на самых разных языках. Хорошо, что хоть на ПХП нет. :)
            Ответить
      • Еще немного эзотерики :)
        -module(plus_minus).
        -export([log_level/1, spawn_logger/1]).
        
        spawn_logger(Proc) ->
            register(Proc, spawn(plus_minus, log_level, [0])).
        
        head_or_default([], Default, _Comparator) -> Default;
        
        head_or_default([Head | Tail], Default, Comparator) ->
            case erlang:apply(erlang, Comparator, [Head, Default]) of
        	true ->
        	    Head;
        	false ->
        	    head_or_default(Tail, Default, Comparator)
            end.
        
        log_level(Level) ->
            PrintAndRestart = 
        	fun(Comparator) ->
        		NewLevel = head_or_default([0, 1, 2], Level, Comparator),
        		io:format("New log level: ~p~n", [NewLevel]),
        		log_level(NewLevel)
        	end,
            receive
        	'+' -> PrintAndRestart('>');
        	'-' -> PrintAndRestart('<')
            end.

        Пользоватся:
        3> c(plus_minus).
        {ok,plus_minus}
        4> plus_minus:spawn_logger(logger).
        true
        5> logger ! '+'.
        New log level: 1
        '+'
        6> logger ! '+'.
        New log level: 2
        '+'
        7> logger ! '+'.
        New log level: 2
        '+'
        8>

        :)
        Ответить
        • -module(plus_minus).
          -export([log_level/1, spawn_logger/1]).
          
          spawn_logger(Proc) ->
              register(Proc, spawn(plus_minus, log_level, [0])).
          
          head_or_default([], Default, _Comparator) -> Default;
          
          head_or_default([Head | Tail], Default, Comparator) ->
              case Head - Default of
          	Comparator ->
          	    Head;
          	_ ->
          	    head_or_default(Tail, Default, Comparator)
              end.
          
          log_level(Level) ->
              PrintAndRestart = 
          	fun(Comparator) ->
          		NewLevel = head_or_default([0, 1, 2], Level, Comparator),
          		io:format("New log level: ~p~n", [NewLevel]),
          		log_level(NewLevel)
          	end,
              receive
          	'+' -> PrintAndRestart(1);
          	'-' -> PrintAndRestart(-1)
              end.
          Даже так...
          Ответить
          • Вы пробуждаете во мне Prolog...
            Ответить
            • Этож Эрланг.
              Ответить
              • Они очень похожи.
                Ответить
                • Это принципиально разные не сравнивые парадигмы.
                  Ответить
                  • Java / JavaScript - тоже разные парадигмы.
                    Ответить
                    • Java is to JavaScript as car is to carpet.
                      Ответить
                      • :) Но смысл был в том, что они синтаксически похожи.
                        Ответить
                        • это ни о чём не говорит, в то время все носились с явой и поэтому получилось похоже.
                          Ответить
                          • ещё раньше все носились на явах ...
                            Ответить
                          • language_syntactically_similar('JavaScript', 'Java').
                            language_syntactically_similar('Erlang', 'Prolog').
                            
                            is_similar_language(X, Y) :- language_syntactically_similar(X, Y).
                            
                            % | ?- is_similar_language('Erlang', 'Prolog').
                            % is_similar_language('Erlang', 'Prolog').
                            
                            % yes
                            %)
                            Ответить
                        • >смысл был в том, что они синтаксически похожи.
                          Зато не похожи симантически.
                          Ответить
                          • >симантически
                            джавамантически
                            Ответить
                          • Если симантика имеет что-то общее с браузером SeaMonkey - тогда я не знаю :) Если имеется в виду семантика, тогда ваше утверждение спорно. Область применения семантики - описание отношений между представлением и значением. Если вы сравните представление термов, списков и переменных в Erlang и Prolog, то увидите, что они очень похожи.
                            Но, как вы абсолютно правильно заметили, парадигмы отличаются, как отличаются и домены (сферы применения). Поэтому я не вижу причины спорить. Оба утверждения правильные и не противоречат друг другу.
                            Ответить
                          • > симантически
                            школатически, блеать
                            Ответить
                            • Тролль, по делу что есть?
                              Ответить
                              • да, в следующий раз перед употреблением умного слова читай хотя бы википедию
                                Ответить
                          • >симантически
                            symantически
                            Ответить
              • >
                case erlang:apply(erlang, Comparator, [Head, Default])

                Я заметил.
                Но тоска по логической парадигме наличествует. А функциональная достала чуть меньше объектно-ориентированной.
                Ответить
    • >sum_up = sum_up > 1 ? sum_up : ++sum_up;
      опасная это херня

      правленый код довольно неплох, а вот оригинальный оригинал 100% говно
      Ответить
      • Да, оригинальный вариант порождает неопределенное поведение из-за множественной модификации 'sum_up'.
        Ответить
    • показать все, что скрытоvanished
      Ответить

    Добавить комментарий