Хламидомонада / Говнокод #25996 Ссылка на оригинал

0

  1. 1
  2. 2
  3. 3
  4. 4
f :: [Int] -> [Int]
f [] = []
f [a] = []
f (a:b:lst) = b: f lst

Как вытащить каждый второй элемент из массива.

Запостил: bot bot, (Updated )

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

  • Я напишу это на жабаскрипте за полторы строчки кода.
    Ответить
      • Что за маловыразительная питушня? То ли дело JS:
        var f = xs => xs.filter((_,i) => i % 2);


        Вообще, нестрогость типизации JS в случае map/reduce/filter очень круто использована. Там, где хаскелешки делают zip-unzip, жсофаги просто передают лишний аргумент.
        Ответить
          • хвастаясь лямбдами перед хаскелистом, вы ничего, кроме демонстрации своей ущербности, не добьетесь
            Ответить
              • >помнится еще в Алгол 68 были
                да, давненько на нём проектов не было
                Ответить
            • Мне больше всего в слайс-нотации нравится толкование отрицательных значений.
              Так отрицательный шаг реверсит спис массив
              arr[::-1]

              А отрицательные индексы начинают работать с конца.

              Они не только обошли проблему out of range индексов, но и сделали дополнительный миллион полезных кейсов.
              Гениальная находка.
              Ответить
        • вот тебе статически типизированный коко
          тоже в одну строчку
          print(arrayOf("A", "B", "C", "D", "E").filterIndexed { index, _ -> index % 2 == 0 }) // [A, C, E]
          Ответить
            • В коко нету литералов для моссива
              Ответить
              • М-да, можно вывезти девушку из жабы, но жабу из девушки никогда
                Ответить
                    • а как выбрать каждый четный-то?
                      Ответить
                      • let array = ["A", "B", "C", "D"]
                        array.enumerated().filter({ $0.offset % 2 == 0 }).map({$0.element})


                        Красивее пока не придумалось
                        Ответить
                      • О, вот так ещё можно:

                        array.enumerated().compactMap { $0.0 % 2 == 0 ? $0.1 : nil }
                        Ответить
                        • Ну примерно так же как в коко, только литерал хороший есть.

                          Кстати, редки момент, где очень сильно соснул рубин.
                          В рубине получить индекс можно только у Enumerable, причем только получить, а фильтрнуть нельзя.

                          Получается так
                          p %w[a b c d].collect.with_index { |s, i| s if i % 2 == 0 }.compact

                          collect конвертит в enumerable, with_index мапит в объкт или nil, compact выпиливает нилы.

                          А груви воспользовался случаем, и тоже соснул
                          print(['a', 'b', 'c', 'd', 'e'].withIndex().grep { s, i -> i % 2 == 0 }.collect { s, _ -> s })


                          пушо grep (это как filter) и collect (map) это отдельные функции
                          Ответить
                          • По-моему, вообще ни разу не как в Котлине, а ближе к тому, что есть в Руби, только compactMap сам одновременно мапит и выпиливает.

                            А что, в Котлине нет сахара для аргументов замыкания? Типа $0, $1, вот это всё. Вроде ж был
                            Ответить
                            • ну так в котлине тоже "filterIndexed" одновременно и фильтрует, и индексирует.

                              Сахар есть только для единственного аргумента (it). Если их два, то надо явно..

                              С руби стрижа роднит явное переключение в енумербл (collect): в коко этот метод есть и у Array, и у Iterable, то-есть практически у всех. Даже у sequence
                              Ответить
                              • compactMap сам по себе ничего не индексирует, обрати внимание на enumerated().

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

                                let array = ["A", "B", "C", "D"]
                                     
                                for (index, element) in array.enumerated() where index % 2 == 0 {
                                    print(element)
                                }
                                Ответить
                              • Кстати, о ленивых бесконечных секвенсах.
                                Берем первые 10 чисел, делящихся на 7.

                                коко
                                print(generateSequence(0) { it + 1 }.filter { it % 7 == 0 }.take(10).toList())


                                руби
                                p (0..Float::INFINITY).lazy.select { |i| i % 7 == 0 }.first(10)


                                в свифте можно?
                                Ответить
                                • Идея красивая, но выглядит как-то по-питушарски.
                                  Кобенация скобок для вызова с их отсутствием - говно.
                                  Так же, как необязатяльность точки с запятой в JS - говно.

                                  Круглые скобки, отсутствие скобок, ...
                                  То ли дело Haskell совсем без скобок или C совсем со скобками.
                                  Ответить
                                  • Можно и со скобками.
                                    Просто руби, груви и ко имеют такой сахар: если последний аргумент функции есть лямбда, то скобки можно не писать.

                                    generateSequence(0) { it + 1 }
                                    generateSequence((0, { it + 1 })
                                    Ответить
                                    • Ох, это ещё и один и тот же список аргументов. Какой багор )))

                                      Я думал, это эквивалентно generateSequence(0)({ it + 1 })

                                      В такой нотации код становится неподдерживаемым. Было где-то f(x) + 1 и g { it+1 }. "f(x)" решили подставить вместо g. Вышло f(x) { it + 1 }, в f передали 2 аргумента.

                                      Вообще, для языка, который предполагает использование отдельных конструкций ФП, язык сильно дубовый. Какие-то лямбды, какие-то proc, непродуманность касательно работы с каррированными функциями (f(0) { it + 1 } != f(0) ({ it + 1 })).

                                      Как будто автор начал читать учебник по ФП, сделал так, чтобы работали примеры с рисунков 1, 2, 4, 7, и закрыл учебник. Или как будто хотел написать этот язык на другом (как я писал JS на C++, и у меня console.log и console["log"] работает, можно сделать console["xxx"] = 1, но если сделать console.xxx = 1, то не скомпилируется.
                                      Ответить
                                      • >Какой багор )
                                        сделано для питушни вроде

                                        коко
                                        addFuckingListener {
                                         print("$it fucked")
                                        }


                                        руби
                                        add_fucking_listener |n|
                                          puts "#{n} fucked"
                                        end
                                        Ответить
                                        • Эх, надо было тогда совсем как в Haskell делать, чтобы пользователям языка не учить лишние правила и исключения.
                                          Ответить
                                  • найди в функциональном стиле первые 10 чисел, делящихся на 7.
                                    Ответить
                                    • А бесуонечные послоедовательности обязательно пользовать? Или без них уже не функциАнально?

                                      NB. язык пргораммирования "жуй"
                                      7*>:i.10
                                      Ответить
                                        • В J нет бесконечных, есть только массивы.

                                          Значит бесконечные последовательности не нужны.
                                          Ответить
                                            • Мне кажется, если у прошраммиста что-то не в память, то бесконечные здесь не пичём.
                                              Ответить
                                              • попробую абяснить.

                                                Чтобы написить эту задачу функционально, нужна функция, которая при каждом вызове будет отдавать n+1, пока ты не наберешь нужное количество значений.

                                                Есть два способа:
                                                * получить итератор по массиву от ноля до охулиона
                                                * написать функцию, которая выдает такие значения

                                                Ленивость позволяет получить такую функцию из коробки. А если написать такой массив, то он не влезет в мапять.

                                                Смотри:
                                                Вот это работает
                                                p (0..Float::INFINITY).lazy.select { |i| i % 7 == 0 }.first(10)

                                                а если убрать lazy, то пизданеца, потому что сначала он попытается создать массив от 0 до инфинити
                                                Ответить
                                                • Но здесь совсем не нужны бесконечные.

                                                  Приведи реальный пример где нужны.
                                                  Ответить
                                                  • напиши тоже самое без бесконечности тогда, только вместо 7 пусть будет 1005001
                                                    Ответить
                                                    • Представил пунктик в ТЗ:

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

                                                      Реальный пример.
                                                      Ответить
                                                    • Императоры смотрят на возню функциушков и снисходительно улыбаются.

                                                      for (let i = 0; i < 10 * 1005001; i += 1005001) {
                                                          console.log(i);
                                                      }
                                                      Ответить
                                                      • > 10 *
                                                        Какая-то питушня для ма-те-ма-ти-ков из раш-ки.

                                                        Ма-те-ма-ти-ка пригодится, если понадобится найти
                                                        1. 10 чисел, у которых i % 7 == 2
                                                        2. 10 чисел, у которых (i % 7) + (i % 10 / 2) == 6
                                                        Ответить
                                                        • Ну 1 это легко, любая пидоращка справиится:
                                                          2 + 7 * i.10


                                                          А со вторым сложнее, там думать надо, а я не умею.
                                                          Ответить
                                                          • У 1024-- всё же на JS, скорее всего плавки.

                                                            Хотя как жс-питушок он бы написал "===", может это какой-то "Си", тагда целый.

                                                            Хуй ево знаит.
                                                            Ответить
                                                            • В «JS» ещё есть прикол, связанный с отсутствие целого питуха: когда биты в мантиссе заканчиваются, он начинает считать с ошибками...

                                                              Пусть питух плавающий. Тогда:
                                                              2*(i % 7) + (i % 10) == 12.

                                                              (i % 7) принимает 7 значений, (i % 10) принимает 10 значений.

                                                              Поскольку 2*(i % 7) чётное, то и (i % 10) должно быть чётным, иначе 12 не получим. Значит, для (i % 10) остаются 6 значений.

                                                              Получаем:
                                                              (x | x in {0, 2, 4, 6, 8, 10, 12}) + (y | y in {0, 2, 4, 6, 8}) = 12.
                                                              Из этих кобенаций 12 получим в таких случаях: 4 + 8; 6 + 6; 8 + 4; 10 + 2; 12 + 0. Итого пять вариантов:

                                                              1) i % 7 == 2; i % 10 == 8.
                                                              2) i % 7 == 3; i % 10 == 6.
                                                              3) i % 7 == 4; i % 10 == 4.
                                                              4) i % 7 == 5; i % 10 == 2.
                                                              5) i % 7 == 6; i % 10 == 0.

                                                              Каждое из таких чисел можно представить как 70*k плюс хвост, который меньше 70. Осталось найти значения таких хвостов.

                                                              Для первого варианта: 7*m + 2 == 10*n + 8; 7*m - 10*n = 6. Очевидное решение 7*8 + 2 = 10*5 + 8. Хвост равен 58.
                                                              Следующее решение (7*18 + 2 = 10*12 + 8) оказывается больше 70.

                                                              Для второго варианта: 7*m + 3 == 10*n + 6; 7*m - 10*n = 3.
                                                              Очевидное решение 7*9 + 3 = 10*6 + 6. Хвост равен 66.

                                                              Для третьего варианта: 7*m + 4 == 10*n + 4; 7*m - 10*n = 0.
                                                              Очевидное решение 7*0 = 0*7. Хвост равен 0.

                                                              Для четвёртого варианта: 7*m + 5 == 10*n + 2; 7*m - 10*n = -3.
                                                              Очевидное решение 7*1 + 5 = 10*1 + 2. Хвост равен 12.

                                                              Для пятого варианта: 7*m + 6 == 10*n ; 7*m - 10*n = -6.
                                                              Очевидное решение 7*2 + 6 = 10*2. Хвост равен 20.

                                                              Итого: окончательным решением будет последовательность чисел вида 70*k + числа из набора {58; 66; 0; 12; 20}.
                                                              Ответить
                                                            • Жс-питушки пишут "==".
                                                              "===" пишут сишники под прикрытием!
                                                              Ответить
                                                              • Вебмакаки пишут "==" до первого взлома. Или до непервого...

                                                                Какой-то форумный движок принимал неправильные пароли из-за «слабого» сравнения.
                                                                Ответить
                                                                • Больше похоже на PHP с его "0kakoj" == "0bagor"

                                                                  null и undefined равны только между собой и больше не с чем. Если null пришёл из базы и его кастанули к String, всё равно имеем сравнение hash(received_password) == String(null).
                                                                  Если каст и сравнение с null сработали, то проблема не в "==", а в хранении паролей в БД.

                                                                  Ну хотя не знаю, как ещё в JS можно сравнить плохие пароли.
                                                                  Ответить
                                                                  • То есть в «JS» такого багра, как в «PHP», связанного с жадным преобразованием строк в числа, нет?
                                                                    Ответить
                                                                    • В JS строки сами по себе не рассматриваются как числа.

                                                                      https://www.ecma-international.org/ecma-262/10.0/index.html#sec-abstract-equality-comparison

                                                                      Если число является одним из операндов, то второй операнд скастуется в число. Но это не будет как scanf(s, "%f", постфикс не откидывается и зананивает число.
                                                                      * если число зананено, то оно ни с чем не сравнится. Разве что если автор - питушок и использует !(received != send) для сравнения.
                                                                      * если число не зананено, то возможна питушня вроде 1 == '1', 1 == '1.0', 1 == '1.00e+00' но не 1 == '1bagor'

                                                                      Однако, ещё где-то надо достать число. От пользователя по умолчанию приходит строка, какая-нибудь SQLушня типизирована, там тоже должна быть строка.
                                                                      Ответить
                                                          • Честно говоря, не задумывался. Различия важны только для императоров математики.

                                                            Но если надо определиться, то пусть будет целочисленное. "%" и "/" с плавающими питухами в одном выражении - какая-то мерзкая опасная питушня.
                                                            Ответить
                                                            • Если целочисленное, то решений может получиться раза в два больше.

                                                              При плавающем делении 2/2 == 1; 3/2 == 1.5, тройка оказывается недопустимым значением (i % 10), потому что 6 не получим.

                                                              При целочисленным делении 2/2 == 1 и 3/2 тоже равно 1, поэтому тройка в качестве возможного значения (i % 10) не отсекается.
                                                              Ответить
                                                              • Ма-те-ма-тик из раш-ки!

                                                                Вот зачем Вы эти решения случайной кобенации чисел и опереций нагенерировали?
                                                                > 1) i % 7 == 2; i % 10 == 8.
                                                                > 2) i % 7 == 3; i % 10 == 6.
                                                                > 3) i % 7 == 4; i % 10 == 4.
                                                                > 4) i % 7 == 5; i % 10 == 2.
                                                                > 5) i % 7 == 6; i % 10 == 0.
                                                                Ответить
                                                                • Зато теперь император может генерировать миллионы подходящих чисел в секунду. А функциушки будут печально смотреть на свой перебирающий весь натуральный ряд filter и плакать.
                                                                  Ответить
                                                                  • Заказчику нужно было всего десять таких чисел. С большей вероятностью окажется, что с критериями налажали, и надо выбирать числя чуть-чуть по-другому.

                                                                    Вот когда программу обкатают и на практике будут вычислять хотя бы сотни тысяч таких чисел - тогда и вызывайте своих императоров из царских палат шестых.
                                                                    Ответить
                                                                    • Тогда император просто выпишет их в отдельную константу. Чем меньше кода — тем лучше, а отсутствующий код — идеальный.
                                                                      Ответить
                                                                      • а если код выполнится в complie-time и на асме почти ничего не останется?
                                                                        Ответить
                                                                          • А для компайл-питухайма как считать будете - как имперанцы или как функцилябры?
                                                                            Ответить
                                                                            • по-наполеоновски, императорскими указами. Фукциклябров вздернем не рее.
                                                                              Ответить
                                                                              • но вообще почти вся стандартная либа доступна в компайлтайме, так что можно и по функциклировать
                                                                                Ответить
                                                            • > Различия важны только для императоров математики.
                                                              >>> Если целочисленное, то решений может получиться раза в два больше
                                                              Именно поэтому я за «Раш-ку» и её «ма-те-ма-ти-ков».
                                                              Ответить
                                          • В чём проблема сделать транслятор питона в J?
                                            Ответить
                                            • сделай на досуге

                                              зы: у пидона нету спеки, так что делать его трансляторы во что либо может быть не безопасно
                                              Ответить
                                                    • 27 = 128 printable характера который могут быть представлены различными Кодами 7-BIT ASCII. Другой комплект характеров нет для представления HTML но они изобретены для того чтобы контролировать оборудование.

                                                      Следование ставит список на обсуждение вниз с всех Кодов 7-BIT ASCII и их соответствующих Кодов реальности HTML.

                                                      Если вы хотите увидеть соответствующий НАГОВОР, то ОКТЯБРЬ и расширенный комплект Кодов ASCII тогда проверяют следующую главу.
                                                      https://www.tutorialspoint.com/ru/html/html_ascii_codes.htm
                                                      Ответить
                                                      • Асции или юникоде - разница невелика для гробовщика, который будет лупить тупым зубилом твою надгробную плиту.
                                                        Ответить
                                    • Без понятия, аналога функции generateSequence я не знаю. Написать самому разве что.

                                      Только я не понимаю, как работает твой пример. Дока говорит, что

                                      Returns a sequence which invokes the function to calculate the next value on each iteration until the function returns null.


                                      У тебя функция никогда не вернёт null. Когда же тогда вообще в принципе вызовется filter?
                                      Ответить
                                      • последовательность считается лениво, то-есть только когда она нужна. А нужна она только take(10).

                                        take(10) дергает фильтр
                                        фильтр дергаетgenerateSequence, пока та не вернет ему 10 значений, которые фильтр устроят

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

                                        провреь
                                        https://play.kotlinlang.org/
                                        Ответить
                                        • Скажу честно, не хочу никого обидеть, но выглядит, как хуета. Хорошо, что в Свифте такого нет. Плохо, если есть, а я не знаю просто.

                                          Как фильтр может дёргать generateSequence? Фильтр должен работать по коллекции. generateSequence работает как reduce и на каждом шаге пересоздаёт коллекцию с +1 элементом? В какой код под капотом это всё в итоге разворачивается?
                                          Ответить
                                        • А, бля, Sequence это не коллекция, а генератор. В принципе, как и в Свифте.
                                          Ответить
                                          • И снова D всех уделывает:
                                            iota(1,100500).filter!"a%7==0".take(10)
                                            лямбды короче чем в плюсовом бусте
                                            Ответить
                                            • Ахах, у этих питушков тоже "иота". Интересно, автор заимствовал из APL или уже из крестов?
                                              Ответить
                                            • Это строка там?
                                              Она преобразуется в какой-то код вида LamEq(LamMod(LamVar(1),7),0) (вроде как пользовательских литералов в крестах)?
                                              Она интерпретируется?
                                              Ответить
                                              • > интерпретируется

                                                В ди хитро сделано. Там вместо макросов и шаблонов ты просто отдаёшь строку конпелятору. И он её конпелирует как обычный код, как-будто бы он на этом месте и был написан.
                                                Ответить
                                                • Интересно. А зачем тогда строка, если это всё равно код?
                                                  Ответить
                                                • Вообще filter! это как раз макрос.

                                                  https://dlang.org/phobos/std_algorithm_iteration.html#.filter

                                                  Если посмотреть на примеры в доке, то строка ему, в общем-то, и не нужна. Без глубокого знания D сложно понять, зачем использовать строковый литерал в примере хохахона.
                                                  Ответить
                                                  • filter это шаблонная функция. С помощью кодогенерации из строки строится лямбда,которую в компактной форме можно описать a => a%7==0, в полной function (int a) { return a%7==0; }
                                                    Ответить
                                                    • Ой блядь, читаю "шаблон", пишу "макрос".

                                                      Давай ещё про D. Например, про template mixins.
                                                      Ответить
                                    • take 10 [0, 7...]

                                      З.Ы. Вы там упоролись фильтровать числа, делящиеся на 7?
                                      Ответить
                            • Лично мне идея отсутствия капитанства с аргументами нравится. И подход boost::lambda с формулированием лямб за счёт питуширования с системой типов - например, _2 % 2 == 0 - выглядит очень круто.

                              Но как работать с замыканиями в $0-питушне? Как доставать питушню из внешних скоупов?

                              Например, как достали "a" в λa.λb.a+b

                              Для этого делают удобный сахарок?
                              Ответить
                              • Я не въехал, о чём ты спрашиваешь если честно.

                                Как во внутреннем замыкании захватить что-то из внешнего?
                                Ответить
                                • Что-то из этого.

                                  Когда лямбда внутри лямбды, её $0, $1 скрывают внешние $0, $1. Неясно, как достать внешние.

                                  Насколько я понимаю, λa.λb.a+b должно выглядеть как {{$0+$0}} 🙂
                                  Ответить
                              • Наверное, понял.

                                Если ты про то, можно ли как-то захватить сахарок в коде типа

                                array.forEach { $0.forEach { print($0) } }
                                ,

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

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

            > зачем перебирать все элементы массива, если он не рекурсивный тип данных
            Что за питушня? Если речь про ленивость, то причём тут рекурсивные типы? Если не про ленивость, то не перебрать все элементы нельзя.
            Ответить
            • оговорился, не неявный, лишний. Другое слово.
              Лямбды это мейнстрим, скучный и посредственный.
              Равно как и мой пример, я его привел в ответ к комменту про полторы строчки.
              Но зачем всюду пихать свой жээс? Тебе он нравится, хорошо, сядь, выдохни, успокойся и расслабься. Продолжай называть костыли в его устройстве крутой реализацией полезных фич.

              Что за питушня, разберешься самостоятельно, если повезет. Ты, судя по всему, организм юный и особыми знаниями не обремененный, так что есть куда расти.
              Ответить
              • Лямбды скучные. Ну охренеть теперь.

                Скучные, слышите? Бесточечному царю не нравятся лямбды. Ребята, чистим код от лямбд. Чтоб сука к 12 сентября - к 120летию Вождя - было чисто!

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

                > Что за питушня, разберешься самостоятельно, если повезет.
                "Ко-ко-ко, я сам не знаю, что высрал, но вставлю какую-нибудь хрень в стиле великого учителя Хуй-Цзы"
                Технологию гиперссылок бесточечные цари в силу большой занятостью зачисткою мира от лямбд не осилили.
                Ответить
  • Проложил:

    f([], []) :- true.
    f([A], []) :- true.
    f(Lst, Rez) :-
        append([A, B], Cdr, Lst),
        f(Cdr, FCdr),
        append([B ], FCdr, Rez).
    Ответить
  • <?php
    
    function make_regexp($x) {
         $keys = explode(':', $x);
         $last = "(?P<" . array_pop($keys) . ">.+)";
         array_walk($keys, function(&$v, $k) { $v = "(?P<$v>[^:]+)";});
         array_push($keys, $last);
         return '#^' . implode(':', $keys) . '$#';
    }
    
    function slice($a, $key) {
        return array_filter($a, function($k)use($key) {return in_array($k, explode(':', $key));}, ARRAY_FILTER_USE_KEY);
    }
    
    function f($a) {
        $keys = implode(':', array_keys($a));
        if(preg_match(make_regexp('a:b:lst'), $keys, $matches)) {
            return array_merge(slice($a, $matches['b']), f(slice($a, $matches['lst'])));
        }
    
        if(preg_match(make_regexp('a:b'), $keys, $matches)) {
            return [$a[$matches['b']]];
        }
    
        return [];
    }
    
    echo implode(' ', f(['Хорошо','живёт','на свете','Винни-пух']));


    https://ideone.com/D3cVIA
    Ответить
  • вам паттерн матчинга не много?
    f (a:b:lst) = b: f lst
    f _ = []
    Ответить
  • можно еще так. Нужны четные элементы - вызываешь f, нечетные - f'
    f (x:xs) = f' xs
    f [] = []
    f' (x:xs) = x : f xs
    f' [] = []
    Ответить

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

Семь раз отмерь — один отрежь, guest!

    А не использовать ли нам bbcode?


    8