1. JavaScript / Говнокод #26387

    −1

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    (function(){
      const panel = document.querySelector('.pane-content > ul');
      function appendLink(text, href) {
        const li = document.createElement('li');
        const a = document.createElement('a');
        li.appendChild(a);
        a.setAttribute('href', href);
        a.innerText = text;
        panel.appendChild(li);
      }
      appendLink("Перелогиниться", 'https://govnokod.ru/user/exit/?url=https://govnokod.ru/user/login');
      appendLink("Регистрация", 'https://govnokod.ru/user/exit/?url=https://govnokod.ru/user/register');
    })();

    Кокококое у гк удобне апи )))

    Запостил: KpunoBblu_nemyx, 28 Января 2020

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

    • Какой "Javascript", ладно он в чистые функции не умеет, так ещё и с кавычками не определился.
      Ответить
      • https://github.com/timbl/standard
        > Single quotes for strings – when they are code eg 'color: blue'
        > Double quotes for strings – when they are natural language and need I18n, eg "Error you have run out of space"

        > чистые функции
        Приведи реальный пример чистой функции изменяющей DOM.
        Ответить
        • API для DOM вполне можно сделать на чистых функциях, это же обычное дерево. Возвращай результат с изменившимися нодами да и всё.
          Ответить
          • Ага, писать свой DOM ради маленького скрипта?

            Да и ГЦ заебётся чистить. Странички в интернетах довольно большие и постоянно жопоскриптами дрочатся.
            Ответить
            • Дык чистить только замененные ноды, это немного. Ну и я не предлагаю свой дом пилить, это весь браузер надо переделывать под иммутабельность.
              Ответить
            • А пусть компилятор как надо сразу скомпилирует и заменит на мо-дефекацию, если нужно. Ссылочная прозрачность и более корректный код в наш век дешёвых программистов - важнее мизерной просадки пирфоманса в тех местах, где компилятор не смог заменить на мо-дефекацию.
              Ответить
              • Хорошо, допустим алголоподобные языки убогие, а ФП-иммутабельно-ленивый подход такой божественный.

                То как найти в хацкеле среднее арифметическое списка за один проход по списку и О(1) памяти?
                Ответить
                • Не ебу как в хаскеле, но если мы не знаем длину списка, вот вариант для js
                  function avg(arr) {
                      return arr.reduce(([count, res], curr) => ([count + 1, count > 1 ? (count-1)/count * res + curr/count: curr] ), [1, 0])
                  }
                  Ответить
                  • var arr=[1,2,3,4,3,2,1,0]
                    
                    arr.reduce(([count, res], curr) => ([count + 1, count > 1 ? (count-1)/count * res + curr/count: curr] ), [1, 0])
                    
                    Array [ 9, 2.0000000000000004 ]

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

                        (1+2+3+4+3+2+1+0)/8
                        > 2

                        Высокоуровевный же язык, со сборщиком мусора. ФУНКЦИОНАЛЬНЫЙ.
                        Ответить
                        • Ну ты определись, тебе в один проход по списку и лениво-иммутабельно, или считать сумму и делить на длину
                          >А байтоёбы причём?
                          Ну а кто виноват в том что 5/6*2.6 +2/6 === 2.5000000000000004?
                          Ответить
                          • >лениво-иммутабельно, или считать сумму и делить на длину

                            Разве трудно считать сумму лениво-иммутабельно?
                            Можно передать в массиве сумму и count.
                            А в конце поделить.
                            Ответить
                            • >А в конце поделить.
                              Определять где конец - это уже какая-то императивная хуйня
                              Ответить
                              • Именно поэтому я за императивную хуйню.

                                var arr=[1,2,3,4,3,2,1,0]
                                
                                function avg(arr) 
                                {
                                    var r=arr.reduce(([count, res], curr) => ([count + 1, res+curr] ), [0, 0])
                                    return r[1]/r[0]
                                }
                                avg(arr)
                                >2

                                >Определять где конец
                                Зачем? Зачем?
                                Ответить
                                • >>Определять где конец
                                  >Зачем? Зачем?
                                  Ну вот представь, у тебя биржевая лента, в которой по 123456 котировок в секунду приходит и тебе надо считать в лайв-режиме среднюю котировку за день. Ты на каждое новое значение будешь постоянно растущий список пересчитывать?
                                  Ответить
                                  • В такой ситуации идеально подойдёт «естественный, простой и очевидный способ». Есть сумма, есть счётчик, приходит новое значение — увеличиваем сумму и счётчик, надо показать среднюю котировку — делим сумму на счётчик и течём.
                                    А в ФП реально питушня какая-то получится, либо тормозная, либо неидиоматическая.
                                    Ответить
                                  • >у тебя биржевая лента, в которой по 123456 котировок в секунду приходи
                                    >Ты на каждое новое значение будешь постоянно растущий список пересчитывать?

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

                                    Там на округлениях миллионы могут накапать.
                                    https://www.youtube.com/watch?v=N7JBXGkBoFc
                                    Ответить
                                    • в финансах используется фиксированный с 4 знаками
                                      Ответить
                                  • >Ты на каждое новое значение будешь постоянно растущий список пересчитывать?

                                    Хотя, в этом конечно есть свой резон.

                                    Числа тут примерно одного порядка.

                                    Если это среднее ни на что не влияет, и допустим нужно для вывода котировок на трейдерском сайте.

                                    Тогда это вполне приемлимая реализация.
                                    Ответить
                                    • Я ориентировался на потенциально бесконечные потоки данных, где вся ленивость и иммутабельность могут показать себя, но любимого тут "реального примера" привести не смогу
                                      Ответить
                                      • Идея понятна. Мы храним среднее и count.

                                        Потом нам приходит пачка чисел. Мы вычисляем ищем взвешенное среднее, а к count прибавляем размер пришедшего батча.

                                        >(count-1)/count * res + curr/count: curr
                                        Просто меня покоробило 2 деления и 1 умножение на каждой итерации.

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

                                            В жабе допустим для этого сделали Spliteratorы в Stream.

                                            Проблема в том что оверхед на создание потоков и синхронизацию, для таких простых задач съедает выгоду от многопоточности.

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

                                            Причём вычисление там было посложнее, чем «посчитай среднее N чисел».

                                            В итоге оно работало чуточку дольше, но при этом грузило 2-3 ядра вместо одного.
                                            Ответить
                                          • >В жабе допустим для этого сделали Spliteratorы
                                            https://docs.oracle.com/javase/8/docs/api/java/util/Spliterator.html

                                            Зацените как они по-байтоёбски среднее для сплита находят
                                            public Spliterator<T> trySplit() {
                                                   int lo = origin; // divide range in half
                                                   int mid = ((lo + fence) >>> 1) & ~1; // force midpoint to be even
                                                   if (lo < mid) { // split out left half
                                                     origin = mid; // reset this Spliterator's origin
                                                     return new TaggedArraySpliterator<>(array, lo, mid);
                                                   }
                                                   else       // too small to split
                                                     return null;
                                                 }


                                            >>> (unsigned right shift)
                                            Ответить
                                • > как найти в хацкеле среднее арифметическое списка за один проход по списку и О(1) памяти?
                                  Вот как раз как-то так, только в хаскеле. Думаю, стандартные функции свёртки должны оптимизнуться.
                                  А если нет, то стоит писать явную хвостовую рекурсию:
                                  avg arr = sum / len where
                                    (sum, len) = avg' arr (0, 0)
                                    avg' [] res =res
                                    avg' (x:xs) (sum, len) = avg' xs (sum+x, len+1)
                                  Ответить
                                  • Проложил:
                                    avg_([], Sum, Len, Avg) :- 
                                     Avg is Sum / Len.
                                    avg_(Arr, Sum, Len, Avg) :-
                                     append([Car], Cdr, Arr),
                                     Sum2 is Sum + Car,
                                     Len2 is Len + 1,
                                     avg_(Cdr, Sum2, Len2, Avg).
                                    avg(Arr, Avg) :-
                                     avg_(Arr, 0, 0, Avg).

                                    За один проход, хочу заметить.
                                    https://ideone.com/3JdsWI
                                    Ответить
                                    • Роман рассказал, что в свое время интервьюировал не меньше двух десятков хаскеллистов в Киеве.
                                      И практически никто не смог во время интервью решить такую задачку: есть длинный список чисел, надо найти их среднее арифметическое за один проход по списку и О(1) памяти.
                                      Ответить
                                      • Список оказался таким длинным, что программа на хаскеле не успела выполниться за время собеседования?
                                        Ответить
                                  • >ненужные частичные суммы некуда девать, и они забивают все пространство

                                    https://nponeccop.livejournal.com/449682.html?thread=3937170#t3937170
                                    Ответить
                                    • > я бы смог расписать последовательность редукций, обнаружить проблему и предложить методы решения, но времени бы на это ушло немеряно
                                      Бля, я к ФП отношусь уважительно, но это реально какой багор )))

                                      Кстати, нагуглил: https://wiki.haskell.org/Foldr_Foldl_Foldl'. Багор-с!..
                                      Ответить
                                      • >Бля, я к ФП отношусь уважительно, но это реально какой багор )))

                                        Ну и 5 императивных строк, которые в говне валяют эти потуги. Никаких оптимизаций тут нет, но они и не нужны.

                                        Ведь задача какая была?

                                        Показать, что хаскель-отребье обделалась и наврало.

                                        Версия на сишке компактней, быстрее, проще и выигрывает во всём.

                                        К тому же, нужно понимать, что никому никакие оптимизации в for сишке ненужны.

                                        А тем, кому они нужны - напишет себе то, что ему нужно.

                                        Поэтому хацкель-отребье так любит брать подобную херню и кого-то побеждать, правда оппонент как всегда не явился.

                                        Пойти и писать реальные программы, реальную логику - отребье не может.

                                        Соревноваться с лучшим - это не удел отребья.
                                        Ответить
                                        • Ну по императивным языкам можно тоже судить по C и PHP.
                                          * В ИП снизил уровень внимания ниже 100% - UB, которое будет ждать тебя в коде годы, и никакая хвалёная статическая питушня тебя не спасёт.
                                          * В ИП программа не может освободить память. Вся память освобождается только после завершения программы.
                                          * В ИП имена функций плохо сочетаются друг с другом, ИП - неконсистентное говно.
                                          * В ИП нельзя вернуть что-то сложнее числа или структуры, массив вернуть нельзя.
                                          Поэтому ИП - говно.
                                          Ответить
                                          • > В ИП нельзя вернуть что-то сложнее числа или структуры, массив вернуть нельзя.
                                            > массив вернуть нельзя

                                            Сомнительное утверждение.
                                            Особенно от человека, знающего js.
                                            Ответить
                                  • >стандартные функции свёртки должны оптимизнуться

                                    Cтандартное функцианальное кудахтанье: «оно должно питумизнуться», «хвостовая питушня», «заедушник не лолжен ни о чём думать».

                                    Есть стандартный fold, он должен быть tail-recursive.
                                    Tuple — он вообще-то, value-type, передаётся в стеке, а в heap ничего не аллоцируется.
                                    Ответить
                                    • Тьфу, а я думал «roman-kashitsyn».
                                      Ответить
                                      • А имелся в виду Роман Царёв — человек и царь-питух?
                                        Ответить
                                        • Не знаю, пи зачем-то потёр ссылку, а искать мне лень.
                                          Ответить
                                          • Ничего я не тёр.

                                            https://thedeemon.livejournal.com/101735.html
                                            Ответить
                                            • Потёр твои яйца, вызвал белёсого джинна, загадал 3 желания. Проверь.
                                              Ответить
                                            • В «PHP» никаких «фолдов» нет. Именно поэтому я за «PHP».
                                              Ответить
                                              • Haskell - довольно таки примитивное, но монстровое поделие, полное нелепых нагромождений.
                                                Человек, который хорошо в нем ориентируется - это хорошее зубрилко а не хороший программист.
                                                Умение героически преодолевать трудности, которые создает твой собственный инструмент, вместо того, чтобы решать непосредственно прикладную задачу, в современно мире ценится разве что только среди прыщавых сосок.
                                                Работодатель же это сомнительное умение не ценит, и совершенно справедливо.
                                                Потому производительность труда этих борщехлёбов настолько поганая, что больше платить им просто невозможно.
                                                Рантаймы же для нормальных платформ пишут обычно на голом Си, и они как правило очень компактны и минимальны.
                                                Ответить
                    • >>> def avg(arr):
                      ...     return sum(arr) / len(arr)
                      ...
                      >>> avg([1,2,3,4,3,2,1,0])
                      2.0

                      Именно поэтому я за «Python».
                      Ответить
                      • >... return sum(arr) / len(arr)

                        >среднее арифметическое списка за один проход по списку и О(1) памяти?

                        >> за один проход по списку

                        Мы вам перезвоним.
                        Ответить
                        • Всё верно, за один проход по списку. «Len()» для списков в «Python» выполняется за константу. Именно поэтому…
                          Ответить
                          • > «Len()» для списков в «Python» выполняется за константу

                            А мы передали кастомную реализацию связного списка.
                            bootcamp_dropout правильно сказал: длина неизвестна.
                            Ответить
                            • В «Python», несмотря на распространённую мантру про «one way to do it», «it» можно сделать охулиардом разных способов, и именно поэтому я за «Python».
                              >>> def avg(arr):
                              ...     s, l = 0, 0
                              ...     for x in arr:
                              ...             s += x
                              ...             l += 1
                              ...     return s / l
                              ...
                              >>> avg([1,2,3,4,3,2,1,0])
                              2.0
                              Ответить
                              • Ну. Самый естественный, простой и очевидный способ.

                                Причём я думал, что в этой задаче скриптухов подловить нереально.

                                Особенно питонистов с их длинными интами, но жсеров и пхпшников тоже.
                                Ответить
                    • Кстати, а в моём калькуляторе на шаблонах (https://govnokod.ru/26308, https://wandbox.org/permlink/vAHC5IpyIIyQhUjJ) никаких «плавающих питухов» нет, а дроби сокращаются только без потери точности. Именно поэтому я за «мой калькулятор на шаблонах».
                      using Result7 = Eval<Expr<
                          Div,
                          Expr<Add, Int<1>, Int<2>, Int<3>, Int<4>, Int<3>, Int<2>, Int<1>, Int<0>>,
                          Int<8>>>;
                      std::cout << ExprToString<Result7>::toString() << std::endl;  // 2
                      Ответить
                      • >никаких «плавающих питухов» нет

                        Это и плохо.
                        int не переполнится?
                        Ответить
                        • Переполнится. Но это проблемы заедушных анскиллябр, привыкших насиловать плавающего питуха как им вздумается. А тут думать надо, что на что делишь!
                          Ответить
                          • С интами как раз сложнее выходит. Там байтоебство нужно.

                            Даже 2 инта нетривиально посчитать.
                            ((a&b)>>1)+((a|b)>>1)
                            Ответить
                • С мобилы могу накосячить, да и хаскель я забыл, но что-то в духе


                  avg = (uncurry /) . fold (\(s, c) x -> (s + x, c + 1)) (0, 0)

                  З.Ы. На пустом поделит на 0, да. Но тут все участники специальной олимпиады на него делят.
                  Ответить
                  • >На пустом поделит на 0, да. Но тут все участники специальной олимпиады на него делят.

                    Ты так говоришь, будто делить на 0 это что-то плохое.

                    avg([]) = 0/0
                    NaN

                    На пустом будет NaN. Что логично: среднее арифметическое от пустоты — это не число.
                    Ответить
                    • Для пустого списка среднее арифметическое не определено, в условиях задачи результат для пустого списка не определён, а потому для пустого списка поведение не определено!
                      Ответить
                      • Граждане! При «copy-paste» эта сторона Стока наиболее опасна!
                        Ответить
                  • >fold
                    O(N)

                    https://nponeccop.livejournal.com/449682.html
                    Ответить
                    • Я в курсе.

                      Собственно из-за постоянной борьбы с ленивостью я и забросил хаски.
                      Ответить
                      • >из-за постоянной борьбы с ленивостью я и забросил хаски
                        Выздоровел.
                        Ответить
                • Перевёл на «C».
                  #include <stdlib.h>
                  #include <stdio.h>
                  
                  typedef struct ListNode_s {
                      int value;
                      struct ListNode_s *next;
                  } ListNode;
                  
                  ListNode *list_push(ListNode **root, int value)
                  {
                      ListNode *node = calloc(1, sizeof(ListNode));
                      node->value = value;
                      node->next = *root;
                      *root = node;
                      return node;
                  }
                  
                  ListNode *list_pop(ListNode **root)
                  {
                      if (!root || !*root) {
                          return NULL;
                      }
                      ListNode *node = *root;
                      *root = (*root)->next;
                      return node;
                  }
                  
                  void list_deleteNode(ListNode *node)
                  {
                      if (node) {
                          free(node);
                      }
                  }
                  
                  void list_deleteList(ListNode *list)
                  {
                      while (list) {
                          ListNode *toFree = list;
                          list = list->next;
                          list_deleteNode(toFree);
                      }
                  }
                  
                  float list_avg(ListNode *list)
                  {
                      int s = 0, l = 0;
                      while (list) {
                          s += list->value;
                          l += 1;
                          list = list->next;
                      }
                      return s / (float)l;
                  }
                  
                  int main()
                  {
                      ListNode *list = NULL;
                      list_push(&list, 0);
                      list_push(&list, 1);
                      list_push(&list, 2);
                      list_push(&list, 3);
                      list_push(&list, 4);
                      list_push(&list, 3);
                      list_push(&list, 2);
                      list_push(&list, 1);
                      printf("%f\n", list_avg(list));
                      list_deleteList(list);
                  
                      return 0;
                  }
                  Ответить
                  • Зачем делать list_deleteList?
                    Ответить
                    • Главное правило для любого, взявшего в руки «Си»: «насрал — убери за собой».
                      Ответить
                      • Но там сразу конец программы, смысла удалять нет.
                        Ответить
                        • Сейчас там конец программы, а завтра что-нибудь добавят. Ну и привыкнешь хуёвый код писать.

                          С такими "оптимизациями" иди на пхп ебашить.
                          Ответить
                    • Вот так можно не делать:
                      #define NODE(value, next) &(ListNode){value, next}
                      
                      ListNode *list = NODE(0, NODE(1, NODE(2, NODE(3, NODE(4, NODE(3, NODE(2, NODE(1, NULL))))))));
                      Ответить
                      • Укозатель на темповый объект?
                        Ответить
                      • Какой «LISP» )))
                        Ответить
                        • Я кстати когда-то пытался интерпретатор лишпа написать. Сейчас сорцы посмотрел, у меня там джвусвязные списки и сплошные рукурсии, ни одного цикла. У меня даже удаление списка и получение последнего елемента через рекурсию делалось.

                          Функцианальненько )))
                          Ответить
                  • Не сишник вы, дяденька.

                    Настоящий Сишник сделал бы null terminated array.

                    Только массивы, только хардкор!
                    Ответить
                    • Ну вы уж определитесь: вам или «null terminated array», или
                      >>> А мы передали кастомную реализацию связного списка.
                      .
                      Ответить
                  • >Перевёл на «C».

                    Моча какая-то
                    https://ideone.com/WneDbX

                    Я же говорю: переполнение.

                    Считать в рамках обычных интов нужно или изощрённое байтоёбство или длинная арифметика.
                    Ответить
                    • У вас UB: переполнение знакового int. В случае UB ответственности не несём!
                      Ответить
                    • > Считать в рамках обычных интов нужно или изощрённое байтоёбство или длинная арифметика.
                      А вот интересно, если длина списка заранее не известна — байтоёбство поможет? У меня такое ощущение, что не особо.
                      Ответить
                      • Битоёбство поможет если длина списка кратна степени двойки. Тогда даже делений не нужно.

                        Достаточно просто найти попарно находить среднее.
                        (a&b) + ((a^b)>>1)

                        И то, этот код неочевидно округляет отрицательные аргументы.

                        > если длина списка заранее не известна — байтоёбство поможет
                        При рандомной длине нужно или суммировать всё в более широком типе.
                        Или сохранять старшие биты в новую переменную. И потом делить их по частям.
                        Ответить
        • Можно сгенерить новый немутабельный DOM, заменив только ссылку на нужный кусок.
          Ответить
          • Ну да, а обработчики всяких кнопочек и таймеров просто принимают старый дом и возвращают новый.
            Ответить
        • > Single quotes for strings – when they are code eg 'color: blue'
          > Double quotes for strings – when they are natural language and need I18n, eg "Error you have run out of space"

          господи как же они заебали блядь

          то eslint, то standard, то ставь точку с запятой, то не ставь
          Ответить
          • То пристегнуть ремни, то расстегнуть ремни...
            Ответить
            • Сначала наденьте маску с PHP себе, потом помогите рёбенку.
              Ответить
          • Я поставил себе prettier, он мне и кавычки двойные ставит, и точки с запятой
            Выглядит уебищно и мне не нравится, но менять мне лень, а так хоть однородно
            Ответить
        • Какой уебанский конвеншон, на такое даже линтер не натравишь. Нужно самому на каждом ревью всматриваться в кавычки и классифицировать код внутри них.
          Ответить
          • Примени мышиное обучение.
            Ответить
          • Ты пишешь в бессознательном состоянии и не понимаешь что делаешь? За тобой нужно проверять даже такую примитивную вещь как кавычки?
            Ответить
            • Зачем он пишет в бессознательном состоянии и почему не понимает что делает?
              Зачем за ним нужно проверять даже такую примитивную вещь как кавычки?
              Ответить
            • Если отвлекаться на всю примитивную херню, времени на мысли не останется. Внимание так и рассеивается на мелочи.

              Как думаете, программист должен
              А. автоматизировать задачу заказчика
              Б. пердолиться с указателями в языке без ГЦ
              В. из кожи вон лезть, чтобы выполнить дебильный конвеншн, ничем не обоснованный?

              Разумный кодстайл позволяет исполнять себя автоматически. А значит его можно повесить на коммит, чтобы весь код был красивым, не важно, кто там у себя в кьюбикле насколько извращённо его написал.
              Ответить
        • это пыль, https://github.com/airbnb/javascript 92к звёзд
          Ответить
    • Учитывая твои познаниях в разных областях науки и техники, охарактеризовать тебя как личность можно вкратце: "онъ и швеъц, и жнецъ и хуйца сосѣцъ на дуде игрецъ"
      Ответить

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