1. Haskell / Говнокод #25996

    0

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

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

    Запостил: bot, 26 Октября 2019

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

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


          Вообще, нестрогость типизации JS в случае map/reduce/filter очень круто использована. Там, где хаскелешки делают zip-unzip, жсофаги просто передают лишний аргумент.
          Ответить
          • Правильно. Хацкелистов нужно гнобить.
            Ответить
            • хвастаясь лямбдами перед хаскелистом, вы ничего, кроме демонстрации своей ущербности, не добьетесь
              Ответить
          • Именно поэтому я за «Python».
            xs[1::2]
            Ответить
            • то ли дело Ди
              xs.stride(2)
              Ответить
            • а что, сечения только в питоне есть?
              Ответить
              • помнится еще в Алгол 68 были
                Ответить
                • Ничоси у тебя память, дедушка!


                  А в фортран помнишь?
                  Ответить
                • >помнится еще в Алгол 68 были
                  да, давненько на нём проектов не было
                  Ответить
            • Какая выразительность. Хвала питонам!
              Ответить
              • Мне больше всего в слайс-нотации нравится толкование отрицательных значений.
                Так отрицательный шаг реверсит спис массив
                arr[::-1]

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

                Они не только обошли проблему out of range индексов, но и сделали дополнительный миллион полезных кейсов.
                Гениальная находка.
                Ответить
          • вот тебе статически типизированный коко
            тоже в одну строчку
            print(arrayOf("A", "B", "C", "D", "E").filterIndexed { index, _ -> index % 2 == 0 }) // [A, C, E]
            Ответить
            • > arrayOf
              Зачем? Зачем?
              Ответить
              • Потому что это единственно полезная структура.
                Ответить
              • В коко нету литералов для моссива
                Ответить
                • Какой багор (((
                  Ответить
                • Именно поэтому я за «PHP».
                  Ответить
                • М-да, можно вывезти девушку из жабы, но жабу из девушки никогда
                  Ответить
                  • а как это в свифте, кстати?
                    Ответить
                    • let array = ["A", "B", "C", "D"]
                      Ответить
                      • а как выбрать каждый четный-то?
                        Ответить
                        • 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 делать, чтобы пользователям языка не учить лишние правила и исключения.
                                            Ответить
                                  • Я не понял задачу. List comprehension или?
                                    Ответить
                                    • найди в функциональном стиле первые 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?
                                              Ответить
                                              • сделай на досуге

                                                зы: у пидона нету спеки, так что делать его трансляторы во что либо может быть не безопасно
                                                Ответить
                                                • Я не настолько поехал ещё
                                                  Ответить
                                                  • А на сколько ты поехал?

                                                    На планшете?
                                                    Ответить
                                                    • На 25%
                                                      Ответить
                                                      • 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.

                                              https://kotlinlang.org/docs/reference/sequences.html
                                              Ответить
                                              • Ну понятно, в общем.

                                                https://github.com/JetBrains/kotlin/blob/61ad32f012789ef95376ba30812c32e779c4806b/libraries/stdlib/src/kotlin/collections/Sequences.kt#L538

                                                Как я и догадывался, под капотом доморощенный генератор.

                                                Ну, его на Свифте, судя по всему, придётся писать руками (или надо ковырять стандартную библиотеку). В остальном подход схож:

                                                let array = Array([1, 2, 4, 7, 10, 14, 20, 21, 120, 140, 174, 210, 215, 217, 321].lazy.filter({ $0 % 7 == 0 }).prefix(10))
                                                
                                                print(array)
                                                Ответить
                                                • АЗАЗАЗАЗА

                                                  let array3 = Array((0...).lazy.filter({ $0 % 7 == 0 }).prefix(10))
                                                  Ответить
                                          • А, бля, Sequence это не коллекция, а генератор. В принципе, как и в Свифте.
                                            Ответить
                                            • И снова D всех уделывает:
                                              iota(1,100500).filter!"a%7==0".take(10)
                                              лямбды короче чем в плюсовом бусте
                                              Ответить
                                              • Ахах, у этих питушков тоже "иота". Интересно, автор заимствовал из APL или уже из крестов?
                                                Ответить
                                                • 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; }
                                                      Ответить
                                                      • Это что же получается, ГОМОИКОНЫ?!
                                                        Ответить
                                                        • мощь компайлтайма сопоставима со скриптовым языком. Есть упоротые, которые compile-time raytracer написали http://h3.gd/posts/ctrace/
                                                          Ответить
                                                      • Ой блядь, читаю "шаблон", пишу "макрос".

                                                        Давай ещё про 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летию Вождя - было чисто!

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

                  > Что за питушня, разберешься самостоятельно, если повезет.
                  "Ко-ко-ко, я сам не знаю, что высрал, но вставлю какую-нибудь хрень в стиле великого учителя Хуй-Цзы"
                  Технологию гиперссылок бесточечные цари в силу большой занятостью зачисткою мира от лямбд не осилили.
                  Ответить
                  • Гепа, у тебя лямбды скучные, тебе денег никто не даст
                    https://www.youtube.com/watch?v=3T3LZApQuSo
                    Ответить
    • Проложил:

      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' [] = []
      Ответить

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