Вступ та кредит

Сьогодні без фантазійної прелюдії: Будь ласка, реалізуйте 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]

Математика, 18 байт

#~TakeWhile~EvenQ&

Ще одна славна вбудована, яка побита в 3 рази за допомогою мов для гольфу без вбудованого ...

Haskell, 13 байт

fst.span even

spanрозбиває список введення на пару списків безпосередньо перед першим елементом, де предикат (-> even) помилковий. fstприймає перший елемент пари.

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

fst.break odd

breakє протилежною span, тобто розбиває список на перший елемент, де предикат є істинним.

Звичайно, є також

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;
} 

Що зловживає тим, як Гексагоні намагається прочитати число, коли STDIN порожній (він повертає нуль). Велика подяка Мартіну за допомогу в розробці такого підходу.

Повне пояснення

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

По-перше, трохи грунтовки на базовий контрольний потік у Гексагонії. Перший вказівник інструкції (IP), який є єдиним, що використовується в цій програмі, починається вгорі ліворуч від шестигранного вихідного коду і починає рухатися вправо. Щоразу, коли IP залишає край шестикутника, він рухаєтьсяside_length - 1 рядки до середини шестикутника. Оскільки ця програма використовує бічну довжину три шестикутника, IP завжди буде рухатись у два ряди, коли це станеться. Єдиний виняток - якщо він переміщується із середнього ряду, де умовно рухається до верхнього або нижнього шестикутника, залежно від значення краю поточної пам’яті.

Тепер трохи про умовні умови. Єдиними умовами гексагонії для контрольного потоку є >:< а середній край шестикутника. Усі вони відповідають постійному правилу: якщо значення поточного краю пам'яті дорівнює нулю або негативний потік керування переміщується ліворуч, а якщо додатний - управління тече вправо. Більші та менші дужки перенаправляють IP під кутом шістдесяти градусів, тоді як край шестикутника контролює, до якого ряду переходить IP-адреса.

У шестикутника також є спеціальна модель пам'яті, де всі дані зберігаються на краях нескінченної шестикутної сітки. Ця програма використовує лише три ребра: один для зберігання двох, один для числа, що читається в даний час, і один для модуля два. Це виглядає приблизно так:

Mod  \ / Input
      |
      2

Я не збираюся ретельно пояснювати, де ми знаходимося в пам'яті в кожній точці під час пояснення програми, тому повертайтеся сюди, якщо ви заплутаєтесь у тому, де ми в пам’яті.

Коли все це не вийде, власне пояснення може початися. По-перше, ми заповнюємо край "2" в пам'яті двома, потім виконуємо безапеляційний режим і переміщуємо вказівник пам'яті вправо ( 2.}).

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

Якщо залишок був один (тобто число було непарним), повертаємо право, слідуючи за синім контуром вище, починаючи, знову виконуючи неоперацію, потім загортаємо до нижньої частини шестикутника, множимо поточний край на 10 і потім додаємо вісім, відмовтеся від декількох дзеркал, повторіть те саме множення та додавання ще раз, отримавши 188 на поточному краю, загорнувшись до вершини шестикутника, знову виконавши но-оп і нарешті закінчивши програму ( .8/\8.@). Цей згорнутий результат був щасливою випадковістю, я спочатку написав набагато простішу логіку, але помітив, що можу зняти це на користь но-оп, що, на мою думку, було більше в дусі Гексагонії.

Якщо залишок дорівнював нулю, ми замість цього повертаємо ліворуч, слідуючи червоною стежкою вгорі. Це змушує пересунути вказівник пам'яті ліворуч, а потім надрукувати там значення (вхідне значення) як число. Дзеркало, з яким ми стикаємось, діє як неоперативний через напрямок, в якому рухаємось ( {/!). Тоді ми натискаємо на край шестикутника, який є умовним лише з одним результатом, оскільки вхідне значення раніше було перевірене як позитивне, тому ми завжди рухаємося вправо (якщо ви уявляєте себе, зверненим у напрямку IP) . Потім ми множимо введення на 10 і додаємо два, тільки щоб змінити напрямок, обернемось і перезапишемо нове значення зі значенням ascii з великої літери М, 77. Потім натиснемо кілька дзеркал і вийдемо через край середини шестикутник з батутом (2<M\>$ ). Оскільки 77 є позитивним, ми рухаємось праворуч у нижній частині шестикутника і через батут пропускаємо першу інструкцію ( !). Потім множимо поточний край пам'яті на 10 і додаємо 8, отримуючи 778. Потім виводимо це значення мод 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

Пітона, 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?))

The λСимвол вважається як 2 байта.

Я ніколи не бачив Ракетки, яку раніше використовували в жодному з відповідей на кодекс, який я бачив, тому мені довелося це зробити хоча б раз!

Лабіринт , 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 байт

hH: 2% 0,? b & ~ 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

Пітон, 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.*

Подача підводного каналу є значною. Введення та вихід - це розділені пробілами списки.

Спробуйте в Інтернеті!

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

Як вказує Leaky Nun, беручи список у двійковій формі, ми можемо зберегти 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.

Зручно, що той самий код працює для перевірки всіх тестових випадків одночасно.

Діалог APL , 11 байт

{⍵/⍨∧\~2|⍵}

2| поділ, що залишився від ділення на 2

~ заперечувати

∧\ AND-сканування (вимикається з першого 0)

/⍨ виберіть, де

Рубін, 25 байт

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

Я думаю, що програю ...

Пайк, 8 байт

0+2L%fhO

Перекладач виправлений, використовуйте інші посилання

Використовує метод Денніса, крім моєї функції split_at включає зміни - можливо, помилка

Або з виправленням, 7 байт

2L%1R@<

Спробуйте тут!

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

Або після другого виправлення, 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 ;

Спробуйте в Інтернеті

Безголовка, з коментарями:

: 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 - це досить рефлексивна мова