Введение и кредит

Сегодня без фантазии прелюдии: Пожалуйста реализации takewhile.

Вариант этого (нетривиальной структуры данных) был заданием на моем курсе функционального программирования в университете. Это задание теперь закрыто и обсуждалось в классе, и у меня есть разрешение моего профессора опубликовать его здесь (я спросил явно).

Спецификация

вход

Входными данными будет список (или эквивалентная концепция вашего языка) положительных чисел.

Выход

Выходными данными должен быть список (или эквивалентная концепция вашего языка) положительных целых чисел.

Что делать?

Ваша задача - реализовать takewhile(встроенные языковые модули допустимы) с предикатом, что рассматриваемое число является четным (сосредоточиться на takewhile).

Таким образом, вы перебираете список от начала до конца, и пока условие (четное) выполняется, вы копируете в выходной список и, как только вы нажимаете элемент, который не выполняет условие, вы прерываете операцию и вывод (пошаговый пример ниже). Эта функциональность более высокого порядка также называется takeWhile ( takewhile).

Потенциальные угловые случаи

Порядок списка вывода по сравнению со списком ввода не может быть изменен, например, [14,42,2]может не стать [42,14].

Пустой список является допустимым входом и выходом.

Кто выигрывает?

Это код-гольф, поэтому выигрывает самый короткий ответ в байтах!

Стандартные правила применяются конечно.

Тестовые векторы

[14, 42, 2324, 97090, 4080622, 171480372] -> [14, 42, 2324, 97090, 4080622, 171480372]
[42, 14, 42, 2324] -> [42, 14, 42, 2324]
[7,14,42] -> []
[] -> []
[171480372, 13, 14, 42] -> [171480372]
[42, 14, 42, 43, 41, 4080622, 171480372] -> [42, 14, 42]

Пошаговый пример

Example Input: [42, 14, 42, 43, 41, 4080622, 171480372]

Consider first element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42]

Consider second element: 14
14 is even (7*2)
Put 14 into output list, output list is now [42,14]

Consider third element: 42
42 is even (21*2)
Put 42 into output list, output list is now [42,14,42]

Consider fourth element: 43
43 is not even (2*21+1)
Drop 43 and return the current output list

return [42,14,42]

Mathematica, 18 байт

#~TakeWhile~EvenQ&

Еще одно великолепное встроенное устройство, которое в 3 раза превосходит языки игры в гольф без встроенного ...

Haskell, 13 байт

fst.span even

spanразбивает входной список на пару списков непосредственно перед первым элементом, где предикат (-> even) равен false. fstзанимает первый элемент пары.

Альтернативная версия, 13 байт:

fst.break odd

breakявляется противоположностью span, т. е. разделяет список на первый элемент, где предикат имеет значение true.

Конечно, есть также

takeWhile even

но это 14 байтов.

MATL , 6 байтов

toYs~)

Попробуйте онлайн!

объяснение

t    % Input array implicitly. Duplicate
o    % Parity of each entry. Gives 0 for even entries, 1 for odd
Ys   % Cumulative sum
~    % Logical negate. Gives true for the first run of even entries, and then false
)    % Use this as logical index into the original array. Implicitly display

Гексагония , 19

2.}<@>%?<{>$"/\M!8;

Удобочитаемый:

  2 . }
 < @ > %
? < { > $
 " / \ M
  ! 8 ;

Попробуйте онлайн!

Вероятно, это может быть игра в гольф одним или двумя байтами, но это может потребовать некоторой действительно изобретательной компоновки, которую можно было бы легче найти с помощью грубой силы (даже если это может занять довольно много времени).

Объяснение высокого уровня

Программа в основном следует этому псевдокоду:

while (read number is not zero) 
{
    if (number is even) 
        print number;
} 

Который злоупотребляет тем, как Hexagony пытается прочитать число, когда STDIN пуст (возвращает ноль). Большое спасибо Мартину за помощь в разработке этого подхода.

Полное объяснение

Я до сих пор не возился с Моно, чтобы запустить фантастическую эзотерическую IDE Тимви , поэтому я опирался на Мартина, чтобы предоставить мне несколько полезных симпатичных картинок!

Сначала немного о базовом контроле потока в гексагоне. Первый указатель инструкций (IP), который является единственным используемым в этой программе, начинается в верхнем левом углу гексагонального исходного кода и начинает двигаться вправо. Всякий раз, когда ИП покидает край шестиугольника, он перемещается side_length - 1рядами к середине шестиугольника. Поскольку эта программа использует шестиугольник с длиной стороны три, IP всегда будет перемещаться на две строки, когда это происходит. Единственное исключение - если он перемещается за пределы среднего ряда, где он условно перемещается к вершине или низу шестиугольника, в зависимости от значения текущего края памяти.

Теперь немного об условностях. Только в условном Hexagony для потока управления является >, <а средний край шестиугольника. Все они следуют постоянному правилу: если значение на текущем фронте памяти равно нулю или отрицательный поток управления перемещается влево, а если положителен, управление течет вправо. Квадратные скобки больше и меньше перенаправляют IP под углом шестьдесят градусов, в то время как край шестиугольника определяет, к какой строке переходит IP.

Гексагония также имеет специальную модель памяти, где все данные хранятся по краям бесконечной гексагональной сетки. Эта программа использует только три ребра: одно для хранения двух, одно для текущего читаемого числа и одно для числа по модулю два. Это выглядит примерно так:

Mod  \ / Input
      |
      2

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

После всего этого фактическое объяснение может начаться. Сначала мы заполняем ребро «2» в памяти цифрой 2, затем выполняем no-op и перемещаем указатель памяти вправо ( 2.}).

Далее мы начинаем основной цикл программы. Мы читаем первое число из STDIN, а затем нажимаем на условное выражение ( ?<). Если в STDIN не осталось чисел, это читает ноль в текущем крае памяти, поэтому мы поворачиваем налево на то @, что завершает программу. В противном случае мы отскакиваем от зеркала, перемещаем указатель памяти назад и влево, оборачиваем вокруг шестиугольника, чтобы вычислить остаток от деления ввода на 2, а затем нажимаем на другое условие ( /"%>).

Если остаток равен единице (т. Е. Число было нечетным), мы поворачиваем направо, следуя синему пути выше, начиная с повторного выполнения no-op, затем переходим к нижней части шестиугольника, умножаем текущее ребро на 10 и затем добавляем восьмой, отскочив от пары зеркал, сделайте то же самое умножение и сложение снова, получив 188 на текущем ребре, вернувшись к вершине шестиугольника, снова выполнив no-op и, наконец, завершив программу ( .8/\8.@). Этот запутанный результат был счастливой случайностью, я изначально написал гораздо более простую логику, но заметил, что могу убрать ее в пользу запрета, который, как мне показалось, больше соответствует духу гексагонии.

Если остаток был равен нулю, мы вместо этого поворачиваем налево, следуя красному пути выше. Это заставляет нас переместить указатель памяти влево, а затем распечатать значение (входное значение) в виде числа. Зеркало, с которым мы сталкиваемся, действует как no-op из-за направления, в котором мы движемся ( {/!). Затем мы достигаем края шестиугольника, который действует условно только с одним результатом, так как входное значение, которое было до этого, уже было проверено на положительное значение, поэтому мы всегда движемся вправо (если вы представляете себя лицом в направлении IP) , Затем мы умножаем ввод на 10 и добавляем два, только чтобы изменить направление, обернуть вокруг и перезаписать новое значение на значение ascii заглавной буквы M, 77. Затем мы нажимаем на некоторые зеркала и выходим через край середины шестигранник с батутом (2<M\>$). Так как 77 положительно, мы двигаемся вправо к нижней части шестиугольника и из-за батута пропускаем первую инструкцию ( !). Затем мы умножаем текущий край памяти на 10 и добавляем 8, получая 778. Затем мы выводим это значение mod 256 (10) в виде символа ASCII, который оказывается символом новой строки. Наконец, мы выходим из шестиугольника и возвращаемся к первому, ?который переопределяет 778 следующим входным значением.

Pyth, 13 9 7 байтов

uPWs%R2

Кредиты @FryAmTheEggman за 2 (довольно хитрых) байта!

Объяснение:

u       Q    keep applying to input until invariant:
 PW          drop last element if...
   s%R2G     ...any one is odd, G is the argument originally given the value of input

Проверьте это здесь .

Желе , 5 байт

Ḃœp⁸Ḣ

Попробуйте онлайн! или проверьте все контрольные примеры .

Как это работает

Ḃœp⁸Ḣ  Main link. Argument: A (array)

Ḃ      Bit; yield 1 for odd integers, 0 for even ones.
   ⁸   Yield A.
 œp    Partition A, splitting at 1's in the bit array.
       This yields a 2D array of runs of even integers.
    Ḣ  Head; extract the first chunk.

Python 2, 43 42 байта

def f(x):
 while"1'"in`map(bin,x)`:x.pop()

Функция изменяет свой аргумент на месте .

Спасибо @xnor за умный способ сыграть в байт!

Проверьте это на Ideone .

Эд, 13

/[13579]$/,$d

Потому что настоящие программисты используют стандартный текстовый редактор .

Принимает ввод как одно целое число в каждой строке; выходы в том же формате.

Он просто находит первое нечетное число (число, заканчивающееся нечетной цифрой) и удаляет из этой строки до конца файла.

Clojure, 21 байт

#(take-while even? %)

Наконец, Clojure почти конкурирует! (благодаря встроенной задаче) Смотрите его на сайте https://ideone.com/BEKmez

Python, 45 44 байта

f=lambda x:x and~x[0]%2*x and x[:1]+f(x[1:])

Проверьте это на Ideone .

R, 25 байт

x=scan()
x[!cumsum(x%%2)]

Или эквивалентно

(y=scan())[!cumsum(y%%2)]

05AB1E, 8 7 байт

[DÉO_#¨

объяснение

[        # infinite loop start
 DÉO     # count odd numbers
    _    # push negative bool (turning 0->1, X->0)
     #   # if true (no odd numbers exist), break out of loop and implicitly print
      ¨  # else, remove last element from list

Попробуйте онлайн

Предыдущее 8-байтовое решение

vyÈiyˆëq

объяснение

v         # for each y in input
 yÈi      # if y is even
    yˆ    # push y to global array
      ëq  # else terminate program
          # implicitly print global array

Попробуйте онлайн

Brainf ***, 263 байта

Я взял небольшой фрагмент отсюда

>>>>>>,[>>>>>>,]>++++[<++++++++>-]>>>>>+>>>>>>>++++[<++++++++>-]<<<<<<<[<<<<<<]>>>>>>[[>>>>>>>++++[<-------->-]<]<<<<<<[->>>+<<<]>>>[-<+<<+>>>]<>>+>+<<<[-[->]<]+>>>[>]<[-<]<[-]<-[<[<<<<<<]>>>>>>.>>>>>>[>[-]++++[<++++++++>-]<.>>>>>>]>++++[-<++++++++>]<.[-]]>>>>>>]

Я бы дал объяснение, но даже я понятия не имею, как это работает больше.

Ожидается ввод в виде разделенных пробелами чисел (например 2 432 1)

Pyth, 7 байт

<x%R2Q1

Попробуй это здесь!

То, что я пытался сделать в Pyke, но индекс в этом банкомате не работает

Ракетка, 22 байта

(λ(n)(takef n even?))

Символ λсчитается как 2 байта.

Я никогда не видел, чтобы Racket использовался ранее ни в одном из кодовых ответов, которые я видел, поэтому мне пришлось сделать это хотя бы один раз!

Лабиринт , 14 байт

?:
"`#
"@%
\!;

Вход и выход представляют собой списки, разделенные переводом строки (хотя в принципе вход может использовать любой нецифровый разделитель).

Попробуйте онлайн!

Это, наверное, самая компактная программа Лабиринт, которую я когда-либо писал.

Интересно, takewhile(odd)что намного проще:

?:#
" %
\!/

объяснение

Обычный лабиринтный праймер:

• Модель памяти - это стек (на самом деле их два, но нам понадобится только один для этой программы), который содержит целые числа произвольной точности и изначально содержит (неявное) бесконечное число нулей.
• Там нет инструкции потока управления. Вместо этого перемещение указателя инструкций (IP) определяется компоновкой кода (пробелы считаются "стенами" и не могут быть пройдены IP). Обычно предполагается, что код напоминает лабиринт, где IP следует по прямым коридорам и изгибается, но всякий раз, когда он достигает перекрестка, это действует как условие, где новое направление IP определяется на основе текущего состояния. Правила выбора направления сводятся к следующему: если вершина стека равна нулю, IP продолжает двигаться вперед; если вершина положительна, IP поворачивается направо; если вершина отрицательна, IP поворачивается налево. Если одно из этих направлений заблокировано стеной, IP-адрес принимает противоположное направление. Это означает, что программы безС чистыми коридорами, как правило, невероятно сложно работать, потому что каждая отдельная команда будет действовать как соединение. Тот факт, что это сработало в данном случае, является чудом.
• IP начинается с первого непробельного символа в порядке чтения ( ?в данном случае), двигаясь на восток.

Основной поток через программу представляет собой один цикл по периметру:

>v
^>v
^@v
^<<

Как это происходит, мы знаем, что вершина стека равна нулю после этого, !и "поэтому гарантированно, что IP не повернет к центру. `и %с другой стороны, используются в качестве условных выражений, когда IP-адрес может двигаться к центру, так что @он может завершить программу, или он может продолжать двигаться по периметру.

Давайте посмотрим на код в цикле:

?   Read decimal integer N from STDIN, or 0 at EOF.
:   Duplicate. Since this is just a corner, the IP always turns south.
`   Negate the copy of the input (i.e. multiply by 1). At EOF, the result
    is still zero and the IP keeps moving south into the @. Otherwise, the
    top of the stack is now negative, and the IP turns east.
#   Push the stack depth (i.e. 2). Again, this is a corner, and the IP
    is forced to turn south.
%   Computer (-N % 2), which is identical to (N % 2) to determine the
    parity of the input. If input was odd, this gives 1, and the IP turns
    west into the @. Otherwise, the result is 0 and the IP keeps moving
    south, continuing the loop.
;   Discard the 0. This is a corner, so the IP is forced to turn west.
!   Print (and discard) N. The top of the stack is now one of the implicit
    zeros at the bottom, so the IP keeps moving west.
\   Print a linefeed. The IP is forced to turn north in the corner.
""  Two no-ops. The top of the stack is still zero, so the IP keeps moving north.

И тогда цикл начинается заново.

Это поднимает вопрос, почему takewhile(odd)так проще. Есть две причины:

• Поскольку EOF возвращается как 0(что является четным), нам не нужна отдельная проверка EOF. В любом случае, список будет отрезан в этот момент.
• Теперь мы хотим завершить, когда N % 2есть 0(в отличие от 1), что означает, что вместо условного потока управления мы можем просто разделить другую копию Nна N % 2: если ввод нечетный, он просто уходит, Nи мы даже избавились от N % 2(так что мы не t ;), но если ввод четный, это просто завершает программу с (тихой) ошибкой деления на ноль.

Следовательно, другой код представляет собой простой цикл, который вообще не допускает никакого ветвления.

Брахилог , 19 16 байт

ЧЧ:? 2% 0, б & ~ b.hH; [].

s.:Mc?,.:{:2%0}a

объяснение

s.                 Output is an ordered subset of Input
  :Mc?,            The concatenation of Output with a list M is Input
       .:{:2%0}a   All elements of Output are even

Сегодня я выучил изящный трюк (который был использован в ответе из 19 байтов): ~b.hHон короче, чем :[H]rc.добавление элемента в начале списка. Первый означает «Выход - это результат с дополнительным элементом в начале, а первый элемент - это H« » , тогда как другой является прямым «Выход - это конкатенация [[H], Result]».

J, 10 байт

{.~2&|i.1:

объяснение

{.~2&|i.1:  Input: s
   2&|      Take each value in s mod 2
      i.1:  Find the index of the first 1
{.~         Take that many values from s and return

Python, 41 байт

lambda l:l[:[x%2for x in l+[1]].index(1)]

Усекает lдо индекса первого появления нечетного числа. Индекс можно найти, выполнив поиск по 1значениям по модулю 2. Чтобы избежать обнаружения нечетного числа, 1ставится конец.

C #, 50 байтов

int[]f(int[]a)=>(a.TakeWhile(x=>x%2<1).ToArray());

CJam , 11 байт

Спасибо @Dennis за два исправления и один байт!

{1+_2f%1#<}

Это блок кода (эквивалент функции; разрешен по умолчанию), который ожидает входной массив в стеке и оставляет выходной массив в стеке.

Попробуйте онлайн!

объяснение

{         }    e# define code block
 1+            e# attach 1 at the end of the array
   _           e# duplicate
    2f%        e# modulo 2 of each entry
       1#      e# find index of first occurrence of 1
         <     e# slice before

Сетчатка , 17 байт

 ?\d*[13579]\b.*

Конечный перевод строки является значительным. Вход и выход - разделенные пробелами списки.

Попробуйте онлайн!

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

Как указывает Лики Нун, взяв список в двоичном виде, мы можем сохранить 6 байтов, но это кажется немного обманчивым, поэтому я, вероятно, продолжу считать десятичную версию:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 байт

a=>[for(x of a)if(!(a|=x&1))x]

V , 13 байт

íä*[13579]¾.*

Попробуйте онлайн!

Объяснение:

í              "search for, on every line
 ä*            "Any number of digits
   [13579]     "Followed by an odd digit
          ¾    "Then the end of a word,
           .*  "Followed by anything
               "(implicit) and replace it with nothing.

Удобно, что один и тот же код работает для проверки всех тестовых случаев одновременно.

Дьялог АПЛ , 11 байт

{⍵/⍨∧\~2|⍵}

2| деление остатка от деления на 2

~ NEGATE

∧\ И-сканирование (отключается с первого 0)

/⍨ выберите где

Рубин, 25 байт

->a{a.take_while &:even?}

Я думаю, что проиграл ...

Пайк, 8 байт

0+2L%fhO

Исправлен переводчик, используйте другие ссылки

Использует метод Денниса, за исключением того, что моя функция split_at включает изменение - возможно, ошибка

Или с исправлением 7 байтов

2L%1R@<

Попробуй это здесь!

2L%     -   map(%2, input)
   1R@  -  ^.index(1)
      < - input[:^]

Или после 2-го исправления, 6 байтов

2L%fhO

Попробуй это здесь!

Объяснение:

2L%    -   map(%2, input)
   f   -  split_at(input, ^)
    hO - ^[0][:-1]

GolfScript, 11 байт

Это полная программа GolfScript, которая считывает строковый литерал массива GolfScript (например, [28 14 7 0]) и распечатывает тот же массив с первым нечетным элементом и всем, что после него удалено:

~1\{~&.},p;

Попробуйте онлайн. (Также: расширенная версия с тестовым комплектом. )

Де-гольф версия с комментариями:

~     # evaluate input
1\    # push the number 1 onto the stack and move it under then input array
{     # start of loop body
  ~   #  bitwise negate the input number (making odd numbers even and vice versa)
  &   #  take bitwise AND of input and the saved number (0 or 1) on stack 
  .   #  duplicate result; filter loop will pop off the duplicate
},    # run loop above over input array, select elements for which it returns true
p     # stringify and print filtered array
;     # pop the number 0/1 off the stack

Это решение основано на операторе { },фильтра GolfScript , который запускает содержимое блока кода для каждого элемента массива и выбирает элементы массива, для которых код в блоке возвращает истинное (то есть ненулевое) значение в вершина стека.

Таким образом, например, {1&},выбрал бы все нечетные числа в массиве и {~1&},выбрал бы все четные числа. Задача состоит в том, чтобы создать фильтр, который выбирает четные числа, пока не найдет первое нечетное число. , а затем вообще не выбирает числа.

Решение, которое я использовал, состоит в том, чтобы заменить постоянную битовую маску 1(используемую для извлечения младшего бита каждого входного числа) переменной в стеке, которая хранит результат (0 или 1) предыдущей итерации цикла фильтра (и инициализируется как 1 перед циклом). Таким образом, как только фильтр возвращает 0 один раз, битовая маска также устанавливается в 0, предотвращая когда-либо фильтр снова возвращать 1.

Далее 114 байтов

У Forth действительно нет списков. Параметры должны быть помещены в стек в обратном порядке, как это типично для Forth. Результат будет оставлен в стеке в том же порядке. По некоторым причинам это не работает на Ideone, но работает на repl. Новая строка требуется, чтобы устранить какую-то двусмысленность?

: D DEPTH ;
: f D IF 1 D 1 DO D 1- ROLL LOOP D 0 DO I PICK 2 MOD IF D I LEAVE THEN LOOP
DO I ROLL DROP LOOP THEN ;

Попробуйте онлайн

Ungolfed, с комментариями:

: f DEPTH IF                                ( if stack not empty )
        1 DEPTH 1 DO DEPTH 1- ROLL LOOP     ( put 1 on bottom of stack )
        DEPTH 0 DO                          ( loop over entire stack )
            I PICK 2 MOD IF                 ( if stack[i] is odd )
                DEPTH I LEAVE               ( put range and exit loop )
            THEN
        LOOP
        DO I ROLL                           ( roll eyes )
            DROP
        LOOP                                ( iterate that range and remove )
    THEN
;

Эта программа (моя предыдущая попытка) печатает результаты, пока не достигнет нечетного числа. Все остальное (не взятое) останется в стеке.

: f DEPTH IF BEGIN DUP 2 MOD DUP 1- IF SWAP . THEN UNTIL THEN ;

Сбой, если только целые числа

Befunge, 35 байт

Этот код обрабатывает числа от 0 до 65535

1&:v
v-1_@#:@#<
>\:&:2%|
 \+1p4\< ^

Формат ввода:

number_of_values    values(separated by a space)

Вот версия, которая отображает значения в конце процесса:

1&:v>::   v                >00g1+:4g.v
v-1_^#:>#<>$$\$1-:10p000p0-| -g01p00:<
>\:&:2%|                   @
 \+1p4\< ^

Вы можете проверить код здесь , но вам нужно будет добавить завершающую строку с конечными пробелами, так как это интерпретация указывает:

«Код кода то же, что и исходная программа. Вставьте больше строк или завершающего пробела, если данные будут помещены после конца кода. »

Я не знаю, является ли это приемлемым, так как я не учел этот трейлинг в подсчете байтов
nb: кажется, что, поскольку я храню число в коде, интерпретатор не позволит этой программе работать дважды в правильном путь. Вам придется перезагрузить его.

Как это работает: переводчик следует за стрелками и пропускает инструкцию при пересечении '#'

Серые точки проверены, а красная линия удаляет ненужные переменные из стека

Используя здесь в приведенном выше интерпретаторе, сохраненные значения отображаются в коде, используя их представления (я не знаю формат). Да, Befunge - довольно рефлексивный язык