Wprowadzenie i zaliczenie

Dzisiaj bez wymyślnego preludium: Proszę wdrożyć takewhile.

Odmianą tego (na nietrywialnej strukturze danych) było zadanie na moim uniwersyteckim kursie programowania funkcjonalnego. To zadanie jest teraz zamknięte i zostało omówione na zajęciach i mam pozwolenie mojego profesora na opublikowanie go tutaj (wyraźnie spytałem).

Specyfikacja

Wkład

Dane wejściowe będą listą (lub odpowiednikiem twojego języka) dodatnich liczb całkowitych.

Wydajność

Wynikiem powinna być lista (lub odpowiednik twojego języka) dodatnich liczb całkowitych.

Co robić?

Twoim zadaniem jest wdrożenie takewhile(dozwolone są wbudowane języki) z predykatem, że rozważana liczba jest parzysta (aby skupić się na czasie).

I tak iterujesz listę od początku do końca i dopóki warunek (jest parzysty) pozostaje, kopiujesz na listę wyników i jak tylko trafisz element, który nie spełnia warunku, przerywasz operację i wyjście (przykład krok po kroku znajduje się poniżej). Ta funkcja wyższego rzędu jest również nazywana takeWhile ( takewhile).

Potencjalne narożne skrzynki

Kolejność listy wyników w porównaniu do listy danych wejściowych nie może zostać zmieniona, np. [14,42,2]Może się nie zmienić [42,14].

Pusta lista jest prawidłowym wejściem i wyjściem.

Kto wygrywa?

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach!

Oczywiście obowiązują standardowe zasady.

Wektory testowe

[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]

Przykład krok po kroku

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 bajtów

#~TakeWhile~EvenQ&

Kolejny wspaniały wbudowany, który jest pokonany 3 razy przez języki gry w golfa bez wbudowanego ...

Haskell, 13 bajtów

fst.span even

spandzieli listę wejściową na parę list tuż przed pierwszym elementem, w którym predykat (-> even) ma wartość false. fstbierze pierwszy element z pary.

Alternatywna wersja, 13 bajtów:

fst.break odd

breakjest przeciwieństwem span, tzn. dzieli listę na pierwszy element, w którym predykat jest prawdziwy.

Oczywiście, że też

takeWhile even

ale to 14 bajtów.

MATL , 6 bajtów

toYs~)

Wypróbuj online!

Wyjaśnienie

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

Sześciokąt , 19

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

Czytelny:

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

Wypróbuj online!

Prawdopodobnie można go zagrać w bajt lub dwa bajty, ale może to wymagać naprawdę pomysłowego układu, który można łatwiej znaleźć za pomocą brutalnej siły (nawet jeśli znalezienie go może potrwać dość długo).

Wyjaśnienie na wysokim poziomie

Program przeważnie stosuje ten pseudokod:

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

Które nadużywają sposobu, w jaki Hexagony próbuje odczytać liczbę, gdy STDIN jest pusty (zwraca zero). Ogromne podziękowania dla Martina za pomoc w opracowaniu tego podejścia.

Pełne wyjaśnienie

Nadal nie majstrowałem przy Mono, żeby zdobyć Timwi fantastyczne ezoteryczne IDE , więc zaufałem Martinowi, aby dostarczył mi kilka pomocnych ładnych zdjęć!

Najpierw mały podkład na podstawowy przepływ kontrolny w Hexagony. Pierwszy wskaźnik instrukcji (IP), który jest jedynym używanym w tym programie, zaczyna się w lewym górnym rogu heksagonalnego kodu źródłowego i zaczyna przesuwać się w prawo. Ilekroć IP opuszcza krawędź sześciokąta, porusza sięside_length - 1 rzędy w kierunku środka sześciokąta. Ponieważ ten program używa sześciokąta o długości boku trzy, adres IP zawsze będzie się przesuwał o dwa rzędy, kiedy to nastąpi. Jedynym wyjątkiem jest sytuacja, gdy odsuwa się od środkowego rzędu, gdzie warunkowo przesuwa się w kierunku góry lub dołu sześciokąta, w zależności od wartości aktualnej krawędzi pamięci.

Teraz trochę o warunkach. Jedynymi warunkami w Hexagony dla przepływu kontrolnego są >:< a środkowa krawędź sześciokąta. Wszystkie one działają zgodnie ze stałą zasadą: jeśli wartość na bieżącym zboczu pamięci wynosi zero lub ujemny przepływ sterowania przesuwa się w lewo, a jeśli jest dodatni, sterowanie płynie w prawo. Większe niż i mniejsze niż nawiasy przekierowują IP pod kątem sześćdziesięciu stopni, podczas gdy krawędź sześciokąta określa, do którego rzędu skacze IP.

Heksagonia ma również specjalny model pamięci, w którym wszystkie dane są przechowywane na krawędziach nieskończonej sześciokątnej siatki. Ten program używa tylko trzech krawędzi: jednej do przechowywania dwóch, jednej dla aktualnie odczytywanego numeru i jednej dla liczby dwóch modułów. Wygląda mniej więcej tak:

Mod  \ / Input
      |
      2

Nie zamierzam dokładnie wyjaśniać, gdzie jesteśmy w pamięci w każdym punkcie podczas wyjaśniania programu, więc wróć tutaj, jeśli się zdezorientujesz, gdzie jesteśmy w pamięci.

Po tym wszystkim, prawdziwe wyjaśnienie może się rozpocząć. Najpierw wypełniamy krawędź „2” pamięcią 2, a następnie wykonujemy brak operacji i przesuwamy wskaźnik pamięci w prawo ( 2.}).

Następnie rozpoczynamy główną pętlę programu. Czytamy pierwszy numer ze STDIN, a następnie trafiamy na warunkowy ( ?<). Jeśli w STDIN nie ma żadnych liczb, to odczytuje zero w bieżącym zboczu pamięci, więc skręcamy w lewo na @, co kończy program. W przeciwnym razie odbijamy się od lustra, przesuwamy wskaźnik pamięci do tyłu i w lewo, owijamy sześciokąt, aby obliczyć pozostałą część dzielenia danych wejściowych przez 2, a następnie uderzamy w inną funkcję warunkową ( /"%>).

Jeśli reszta to jeden (tzn. Liczba była nieparzysta), skręcamy w prawo, podążając niebieską ścieżką powyżej, zaczynając od ponownego wykonania operacji no-op, a następnie zawijamy się do dolnej części sześciokąta, mnożymy bieżącą krawędź przez 10, a następnie dodajemy ósemka, odbij się od kilku luster, wykonaj to samo mnożenie i dodawanie jeszcze raz, otrzymując 188 na bieżącej krawędzi, owijając się z powrotem na górę sześciokąta, ponownie wykonując brak operacji i na końcu kończąc program ( .8/\8.@). Ten zawiły wynik był szczęśliwym wypadkiem, pierwotnie napisałem dużo prostszą logikę, ale zauważyłem, że mogę go usunąć na korzyść braku operacji, który, jak myślałem, był bardziej w duchu Sześciokąta.

Jeśli reszta to zero, skręcamy w lewo, podążając czerwoną ścieżką powyżej. Powoduje to przesunięcie wskaźnika pamięci w lewo, a następnie wydrukowanie tam wartości (wartości wejściowej) jako liczby. Zwierciadło, które napotykamy, działa jako brak działania ze względu na kierunek, w którym się poruszamy ( ). Ponieważ wartość 77 jest dodatnia, poruszamy się w kierunku dolnej części sześciokąta iz powodu trampoliny pomiń pierwszą instrukcję ( ). Następnie mnożymy bieżącą krawędź pamięci przez 10 i dodajemy 8, otrzymując 778. Następnie wyprowadzamy tę wartość mod 256 (10) jako znak ASCII, który okazuje się być nowym znakiem. Na koniec wychodzimy z sześciokąta i wracamy do pierwszej, która zastępuje 778 następną wartością wejściową.{/! ). Następnie uderzamy o krawędź sześciokąta, który działa warunkowo z tylko jednym wynikiem, ponieważ wcześniej wprowadzona wartość została już przetestowana pod kątem dodatniej, więc zawsze poruszamy się w prawo (jeśli wyobrażasz sobie, że patrzysz w kierunku IP) . Następnie mnożymy dane wejściowe przez 10 i dodajemy dwa, tylko w celu zmiany kierunku, zawinięcia i zastąpienia nowej wartości wartością ascii wielkiej litery M, 77. Następnie uderzamy w lustra i wychodzimy poza krawędź środka sześciokąt z trampoliną (2<M\>$!?

Pyth, 13 9 7 bajtów

uPWs%R2

Kredyty dla @FryAmTheEggman za 2 (dość trudne) bajty!

Wyjaśnienie:

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

Sprawdź to tutaj .

Galaretka , 5 bajtów

Ḃœp⁸Ḣ

Wypróbuj online! lub zweryfikuj wszystkie przypadki testowe .

Jak to działa

Ḃœ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 bajty

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

Funkcja modyfikuje argument na swoim miejscu .

Dzięki @xnor za grę w bajt w naprawdę sprytny sposób!

Przetestuj na Ideone .

ed, 13

/[13579]$/,$d

Ponieważ prawdziwi programiści używają Standardowego edytora tekstu .

Pobiera dane wejściowe jako jedną liczbę całkowitą w każdym wierszu; wyjścia w tym samym formacie.

To po prostu znajduje pierwszą nieparzystą liczbę (liczbę kończącą się nieparzystą cyfrą) i usuwa z tego wiersza do końca pliku.

Clojure, 21 bajtów

#(take-while even? %)

Clojure w końcu prawie konkuruje! (dzięki temu, że zadanie jest wbudowane) Zobacz online https://ideone.com/BEKmez

Python, 45 44 bajtów

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

Przetestuj na Ideone .

R, 25 bajtów

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

Lub równoważnie

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

05AB1E, 8 7 bajtów

[DÉO_#¨

Wyjaśnienie

[        # 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

Wypróbuj online

Poprzednie 8 bajtowe rozwiązanie

vyÈiyˆëq

Wyjaśnienie

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

Wypróbuj online

Brainf ***, 263 bajty

Wziąłem stąd mały fragment

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

Dałbym wyjaśnienie, ale nawet nie mam pojęcia, jak to działa.

Oczekuje wprowadzania jako liczby oddzielone spacjami (np. 2 432 1)

Pyth, 7 bajtów

<x%R2Q1

Wypróbuj tutaj!

To, co próbowałem zrobić w Pyke, ale indeks jest zepsuty w tym bankomacie

Rakieta, 22 bajty

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

λZnak jest liczony jako 2 bajty.

Nie widziałem Rakieta używanego wcześniej w żadnej z odpowiedzi na pytania dotyczące gry w golfa, więc musiałem to zrobić przynajmniej raz!

Labirynt , 14 bajtów

?:
"`#
"@%
\!;

Dane wejściowe i wyjściowe są listami oddzielonymi od linii (chociaż w zasadzie dane wejściowe mogą wykorzystywać dowolny separator inny niż cyfrowy).

Wypróbuj online!

Jest to prawdopodobnie najbardziej kompaktowy program Labiryntu, jaki kiedykolwiek napisałem.

Co ciekawe, takewhile(odd)jest o wiele prostsze:

?:#
" %
\!/

Wyjaśnienie

Zwykły podkład do labiryntu:

• Model pamięci to stos (w rzeczywistości są dwa, ale potrzebujemy tylko jednego dla tego programu), który zawiera liczby całkowite o dowolnej dokładności i początkowo zawiera (niejawną) nieskończoną liczbę zer.
• Brak instrukcji sterowania przepływem. Zamiast tego ruch wskaźnika instrukcji (IP) jest determinowany przez układ kodu (spacje są uważane za „ściany” i nie mogą być przemieszczane przez IP). Zwykle kod ma przypominać labirynt, w którym IP biegnie prostymi korytarzami i zakrętami, ale ilekroć dotrze do skrzyżowania, działa to jako warunek, w którym nowy kierunek IP jest określany na podstawie bieżącego stanu. Zasady wyboru kierunku sprowadzają się do tego: jeśli górna część stosu jest równa zero, IP przesuwa się do przodu; jeśli góra jest dodatnia, adres IP skręca w prawo; jeśli góra jest ujemna, IP skręca w lewo. Jeśli jeden z tych kierunków jest zablokowany przez ścianę, adres IP przyjmuje przeciwny kierunek. Oznacza to, że programy bez czyste korytarze są zazwyczaj niezwykle trudne w obsłudze, ponieważ każde polecenie działałoby jako skrzyżowanie. Fakt, że udało się to w tym przypadku, jest trochę cudem.
• IP zaczyna się od pierwszego znaku spacji w kolejności czytania ( ?w tym przypadku), przesuwając się na wschód.

Główny przepływ przez program jest pojedynczą pętlą wokół obwodu:

>v
^>v
^@v
^<<

Tak się składa, że ​​wiemy, że górna część stosu ma zero !i "dlatego gwarantuje się, że IP nie skręci w kierunku centrum. `a %z drugiej strony są używane jako warunki warunkowe, w których adres IP może przesuwać się w kierunku centrum, co @kończy program lub może przesuwać się po obwodzie.

Spójrzmy na kod w pętli:

?   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.

A potem pętla zaczyna się od nowa.

Rodzi to pytanie, dlaczego takewhile(odd)jest o wiele prostsze. Są dwa powody:

• Ponieważ EOF jest zwracany jako 0(który jest parzysty), nie potrzebujemy osobnego sprawdzania EOF. W każdym razie lista zostanie skrócona.
• Teraz chcemy zakończyć, kiedy N % 2jest 0(w przeciwieństwie do 1), co oznacza, że ​​zamiast przepływu kontroli warunkowej możemy po prostu podzielić drugą kopię Nprzez N % 2: jeśli dane wejściowe są nieparzyste, to po prostu wychodzi, Na nawet pozbyliśmy się N % 2(więc nie potrzeba ;), ale jeśli wejście jest parzyste, to po prostu kończy program z (cichym) błędem dzielenia przez zero.

Dlatego drugi kod jest prostą pętlą, która w ogóle nie pozwala na rozgałęzienia.

Brachylog , 19 16 bajtów

hH: 2% 0, b b & b.hH; [].

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

Wyjaśnienie

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

Dzisiaj nauczyłem się zgrabnej sztuczki (która została użyta w odpowiedzi na 19 bajtów): ~b.hHjest krótsza niż :[H]rc.dodanie elementu na początku listy. Pierwszy oznacza „Wyjście to wynik z dodatkową pozycją na początku, a pierwszym elementem Wyjście jest H” , podczas gdy drugi jest wprost „Wyjście to konkatenacja [[H], Result]”.

J, 10 bajtów

{.~2&|i.1:

Wyjaśnienie

{.~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 bajtów

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

Obcina ldo indeksu pierwszego wystąpienia liczby nieparzystej. Indeks można znaleźć, szukając 1w wartości modulo 2. Aby uniknąć znalezienia nieparzystej liczby, 1na końcu znajduje się a.

C #, 50 bajtów

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

CJam , 11 bajtów

Dzięki @Dennis za dwie poprawki i jeden bajt off!

{1+_2f%1#<}

Jest to blok kodu (równoważny funkcji; domyślnie dozwolony), który oczekuje tablicy wejściowej na stosie i pozostawia tablicę wyjściową na stosie.

Wypróbuj online!

Wyjaśnienie

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

Siatkówka , 17 bajtów

 ?\d*[13579]\b.*

Końcowe podawanie linii jest znaczące. Dane wejściowe i wyjściowe są listami rozdzielonymi spacjami.

Wypróbuj online!

Jest to proste podstawienie wyrażenia regularnego, dopasowuje pierwszą liczbę nieparzystą (tj. Liczbę kończącą się cyfrą nieparzystą) i, jeśli to możliwe, poprzedzającą ją spację, a także wszystko po niej i zastępuje ją pustym ciągiem, tzn. Wszystkimi elementami stamtąd i później są usuwane z wejścia.

Jak wskazuje Leaky Nun, biorąc listę w formie binarnej, możemy zapisać 6 bajtów, ale wydaje się to nieco podstępne, więc prawdopodobnie nadal liczę wersję dziesiętną:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 bajtów

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

V , 13 bajtów

íä*[13579]¾.*

Wypróbuj online!

Wyjaśnienie:

í              "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.

Dogodnie ten sam kod działa jednocześnie w celu weryfikacji wszystkich przypadków testowych.

Dyalog APL , 11 bajtów

{⍵/⍨∧\~2|⍵}

2| podział pozostały z dzielenia za pomocą 2

~ negować

∧\ AND-scan (wyłącza się od pierwszego 0)

/⍨ wybierz gdzie

Rubin, 25 bajtów

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

Myślę, że przegrywam ...

Pyke, 8 bajtów

0+2L%fhO

Naprawiono interpreter, użyj innych linków

Używa metody Dennisa, z wyjątkiem tego, że moja funkcja split_at obejmuje zmianę - prawdopodobnie błąd

Lub z poprawką, 7 bajtów

2L%1R@<

Wypróbuj tutaj!

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

Lub po 2. poprawce błędu, 6 bajtów

2L%fhO

Wypróbuj tutaj!

Wyjaśnienie:

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

GolfScript, 11 bajtów

Jest to pełny program GolfScript, który odczytuje dosłownie literę tablicy GolfScript (np. [28 14 7 0]) I drukuje tę samą tablicę z pierwszym nieparzystym elementem i wszystkim, co zostanie usunięte:

~1\{~&.},p;

Wypróbuj online. (Również: Wersja rozszerzona z wiązką testową. )

Wersja bez golfa z komentarzami:

~     # 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

To rozwiązanie jest oparte na języku GolfScript { }, operatorze filtru , który uruchamia zawartość bloku kodu na każdym elemencie tablicy i wybiera elementy tablicy, dla których kod w bloku zwraca wartość true (tj. Niezerową) dla szczyt stosu.

Na przykład {1&},wybrałby wszystkie liczby nieparzyste w tablicy i{~1&}, wybrałby wszystkie liczby parzyste. Wyzwaniem jest więc stworzenie filtra, który wybiera liczby parzyste, aż znajdzie pierwszy nieparzysty , a następnie nie wybierze żadnych liczb.

Rozwiązaniem, które zastosowałem, jest zastąpienie stałej maski bitowej 1(używanej do wyodrębnienia najniższego bitu każdej liczby wejściowej) zmienną na stosie, która przechowuje wynik (0 lub 1) poprzedniej iteracji pętli filtra (i jest inicjowany 1 przed pętlą). Zatem, gdy tylko filtr zwróci 0 raz, maska ​​bitowa również zostaje ustawiona na 0, co zapobiega ponownemu zwróceniu przez filtr 1.

Dalej, 114 bajtów

Forth tak naprawdę nie ma list. Parametry należy wcisnąć na stos w odwrotnej kolejności, jak to jest typowo w Forth. Wynik pozostanie na stosie w tej samej kolejności. Z jakiegoś powodu to nie działa na Ideone, ale działa na repl. Nowa linia jest wymagana do usunięcia niejasności?

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

Wypróbuj online

Niegolfowany, z komentarzami:

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

Ten program (moja poprzednia próba) drukuje wyniki, aż osiągnie nieparzystą liczbę. Wszystkie pozostałe (nie zabrane) pozostaną na stosie.

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

Nie powiedzie się, jeśli tylko liczby całkowite

Befunge, 35 bajtów

Ten kod obsługuje liczby od 0 do 65535

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

Format wejściowy:

number_of_values    values(separated by a space)

Oto wersja, która wyświetla wartości na końcu procesu:

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

Możesz przetestować kod tutaj , ale będziesz musiał dodać linię końcową ze spacjami końcowymi, ponieważ ta interpretacja określa:

«Kod torus jest tak duży, jak program początkowy. Wstaw więcej wierszy lub końcowe spacje, jeśli dane będą umieszczane poza końcem kodu. »

Nie wiem, czy jest to dopuszczalne, ponieważ nie policzyłem tego końcowego w liczbie bajtów
nb: wygląda na to, że ponieważ przechowuję liczbę w kodzie, interpreter nie pozwoli, aby ten program uruchomił się dwukrotnie we właściwym droga. Będziesz musiał go ponownie załadować.

Jak to działa: Tłumacz postępuje zgodnie ze strzałkami i pomija instrukcje podczas przekraczania „#”

Szare kropki są testowane, a czerwona linia usuwa niepotrzebne zmienne ze stosu

Korzystając z powyższego interpretera, zapisane wartości są wyświetlane w kodzie przy użyciu ich reprezentacji (nie znam formatu). Tak, Befunge jest dość refleksyjnym językiem