Giriş ve Kredi

Bugün süslü bir başlangıç ​​olmadan: Lütfen uygulayın takewhile.

Bunun bir çeşitliliği (önemsiz bir veri yapısında) üniversitedeki fonksiyonel programlama kursunda bir ödevdi. Bu ödev şimdi kapatıldı ve sınıfta tartışıldı ve profesörümün burada yayınlama iznine sahibim (açıkça sordum).

Şartname

Giriş

Girdi, pozitif tamsayıların bir listesi (veya dilinizin eşdeğer kavramı) olacaktır.

Çıktı

Çıktı, pozitif tamsayıların bir listesi (veya dilinizin eşdeğer kavramı) olmalıdır.

Ne yapalım?

Göreviniz, takewhilegöz önünde bulundurulacak sayının eşit olduğunu (beklemeye odaklanmak) öngörerek uygulamaktır (dil kurgularına izin verilir).

Böylece listeyi baştan sona yinelersiniz ve (hatta) koşul tutulurken, çıkış listesine kopyalarsınız ve koşulu doğru hale getirmeyen bir elemana çarptığınız anda işlemi ve çıkışı iptal edersiniz. (adım adım örnek aşağıdadır). Bu üst düzey işlevsellik ayrıca takeWhile ( takewhile) olarak da adlandırılır .

Potansiyel köşe kılıfları

Giriş listeye göre çıkış listesinin sırası örneğin değiştirilemez [14,42,2]hale olmayabilir [42,14].

Boş liste geçerli bir giriş ve çıkıştır.

Kim kazanır?

Bu kod-golf yani bayt cinsinden en kısa cevap kazanır!

Standart kurallar elbette geçerlidir.

Test vektörleri

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

Adım Adım Örnek

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 bayt

#~TakeWhile~EvenQ&

Yerleşik olmadan golf dilleri tarafından 3 faktörü ile dövülmüş bir başka görkemli ...

Haskell, 13 bayt

fst.span even

spanGiriş listesini, yüklemin (-> even) yanlış olduğu ilk öğeden hemen önce bir çift listeye böler . fstçiftin ilk elemanını alır.

Alternatif sürüm, 13 bayt:

fst.break odd

breakbunun tam tersi span, yani listeyi yüklemin doğru olduğu ilk öğede böler.

Tabii ki de var

takeWhile even

ama bu 14 bayt.

MATL , 6 bayt

toYs~)

Çevrimiçi deneyin!

açıklama

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

Altıgen , 19

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

Okunabilir:

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

Çevrimiçi deneyin!

Bu muhtemelen bir veya iki baytlık bir golfle oynanabilir, ancak kaba bir kuvvetle daha kolay bulunabilen bazı gerçekten ustaca bir düzen gerektirebilir (bulması oldukça uzun zaman alabilir).

Yüksek seviye açıklama

Program çoğunlukla bu sözde kodu izler:

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

Bu durum, Hexagony'in STDIN boşaldığında bir sayıyı okumaya nasıl istismarı vardır (sıfırı döndürür). Martin'e bu yaklaşımın ortaya çıkmasında yardımcı olduğu için teşekkür ederiz.

Tam açıklama

Timoi'nin harika ezoterik IDE'sini çalıştırmak için hala Mono'yla uğraşmadım , bu yüzden Martin'e bana bazı güzel resimler sağlamak için eğildim!

İlk olarak, Hexagony'deki temel kontrol akışı üzerine küçük bir astar. Bu programda kullanılan ilk komut göstericisi (IP), altıgen kaynak kodunun sol üstünden başlayarak sağa doğru hareket etmeye başlar. IP, altıgenin kenarından her ayrıldığında, side_length - 1satırları altıgenin ortasına doğru hareket ettirir . Bu program, yan uzunlukta üç altıgen kullandığından, bu olduğunda IP her zaman iki satır hareket edecektir. Bunun tek istisnası, geçerli bellek kenarının değerine bağlı olarak koşullu olarak altıgenin üst veya altına doğru hareket ettiği orta sıradan hareket etmesidir.

Şimdi şartlamalar hakkında biraz. Kontrol akışı için Hexagony tek koşul vardır >, <ve altıgen, orta kenar. Bunların hepsi sabit bir kural izler: mevcut bellek kenarındaki değer sıfır ise veya negatif kontrol akışı sola hareket ederse ve pozitifse kontrol doğru akar. Köşeli ayraçlardan büyük ve küçük olanı IP'yi altmış derece açılarla yeniden yönlendirirken, altıgenin kenarı IP'nin hangi satırda sıçradığını kontrol eder.

Hexagony ayrıca, tüm verilerin sonsuz altıgen ızgarasının kenarlarında depolandığı özel bir bellek modeline sahiptir. Bu program sadece üç kenar kullanır: biri ikiyi saklamak için, diğeri halihazırda okunan numara için ve diğeri modulo iki numara için. Bir şeye benziyor:

Mod  \ / Input
      |
      2

Programın açıklanması sırasında her noktada nerede bellekte bulunduğumuzu dikkatlice açıklayamayacağım, bu yüzden bellekte bulunduğumuz yerle kafanız karışırsa buraya geri dönün.

Tüm bunların dışında, gerçek açıklama başlayabilir. İlk önce "2" kenarını 2 ile belleğe yerleştirdik, sonra no-op yürüttük ve bellek imlecini sağa hareket ettiriyoruz ( 2.}).

Daha sonra ana program döngüsüne başlarız. İlk sayıyı STDIN'den okuduk ve ardından bir koşullu ( ?<) isabet ediyoruz . STDIN'de hiç sayı kalmadıysa, bu mevcut bellek kenarına bir sıfır okur, bu nedenle @programı sonlandıran sola dönüyoruz . Aksi taktirde, bir aynadan sekeriz, hafıza işaretçisini geriye ve sola hareket ettiririz, girişi 2'ye bölüp kalanını hesaplamak için altıgenin etrafına sarılır ve sonra bir şartlı ( /"%>) düğmesine basarız .

Kalan bir tane ise (yani sayı tekse), no-op işlevini tekrar uygulayarak yukarıdaki mavi yolu takip ederek sağa döneriz, sonra altıgenin altına sarılır, geçerli kenarı 10 ile çarpıp sonra ekleriz. sekiz, birkaç aynadan sekerek, aynı çarpımı ve eklemeyi tekrar yapın, geçerli kenardan 188'i alıp, altıgenin üst kısmına geri sarın, no-op'u tekrar uygulayın ve son olarak programı sonlandırın ( .8/\8.@). Bu sarsılmış sonuç mutlu bir kazaydı, başlangıçta çok daha basit bir mantık yazmıştım, ancak daha fazla Hexagony ruhu içinde olduğunu düşündüğüm no-op'un lehine kaldırabileceğimi fark ettim.

Kalan sıfır ise, yukarıdaki kırmızı yoldan sonra sola döneriz. Bu, bellek işaretçisini sola hareket ettirmemize ve ardından değeri oradaki (giriş değeri) sayı olarak basmamıza neden olur. Karşılaştığımız ayna, hareket ettiğimiz yönden dolayı no-op görevi görür ( {/!). Ardından, daha önce gelen girdi değeri pozitif olarak test edildiğinden, tek bir sonuçla koşullu olan altıgen kenarına çarptık, bu yüzden her zaman sağa doğru hareket ediyoruz (kendinizi IP yönüne doğru bakacaksanız) . Daha sonra girişi 10 ile çarptık ve sadece iki yön ekliyoruz, sadece yönünü değiştirmek, sarmak ve yeni değeri M, 77 büyük harfinin ascii değeriyle değiştirmek. bir trambolin ile altıgen (2<M\>$). 77 pozitif olduğundan, altıgenin altına doğru hareket ediyoruz ve trambolin nedeniyle ilk talimatı atlıyoruz ( !). Daha sonra mevcut bellek kenarını 10 ile çarpıp 8 ekleyerek 778 alıyoruz. Daha sonra bu değeri mod 256 (10) olarak ASCII karakteri olarak çıkardık, bu da yeni satır olur. Sonunda altıgenden çıktık ?ve bir sonraki giriş değeriyle 778'i geçersiz kılan ilkine geri döndük .

Pyth, 13 9 7 bayt

uPWs%R2

@FryAmTheEggman'e 2 (oldukça zorlu) bayt için kredi!

Açıklama:

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

Burada test et .

Jöle , 5 bayt

Ḃœp⁸Ḣ

Çevrimiçi deneyin! veya tüm test durumlarını doğrulayın .

Nasıl çalışır

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

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

İşlev argümanını yerinde değiştirir .

Gerçekten akıllı bir şekilde bir bayt kapalı golf için @xnor için teşekkürler!

İdeone üzerinde test et .

ed, 13

/[13579]$/,$d

Çünkü gerçek programcılar kullanmak Standart Metin Düzenleyici .

Her satırda bir tam sayı olarak girdi alır; aynı formatta çıktılar.

Bu sadece ilk tek sayıyı bulur (tek sayı ile biten sayı) ve bu satırdan dosyanın sonuna kadar siler.

Clojure, 21 bayt

#(take-while even? %)

Clojure sonunda neredeyse yarışıyor! (yerleşik olduğu görev sayesinde) Çevrimiçi görün https://ideone.com/BEKmez

Python, 45 44 bayt

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

İdeone üzerinde test et .

R, 25 bayt

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

Veya eşdeğer olarak

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

05AB1E, 8 7 bayt

[DÉO_#¨

açıklama

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

Çevrimiçi deneyin

Önceki 8 byte çözüm

vyÈiyˆëq

açıklama

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

Çevrimiçi deneyin

Brainf ***, 263 bayt

Buradan küçük bir snippet aldım

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

Bir açıklama yapardım ama bunun nasıl çalıştığı hakkında hiçbir fikrim bile yok.

Girişi boşlukla ayrılmış sayılar olarak bekler (örn. 2 432 1)

Pyth, 7 bayt

<x%R2Q1

Burada dene!

Pyke'de ne yapmaya çalıştım ama endeks o atmda bozuldu

Raket, 22 bayt

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

λKarakter 2 bayt olarak sayılır.

Racket’i daha önce gördüğüm kod golfü cevaplarında kullandığımı görmedim, bu yüzden en az bir kere yapmak zorunda kaldım!

Labirent , 14 bayt

?:
"`#
"@%
\!;

Girdi ve çıktılar satır beslemeli ayrılmış listelerdir (ilke olarak, girdi herhangi bir rakam olmayan ayırıcı kullanabilir).

Çevrimiçi deneyin!

Bu muhtemelen şimdiye kadar yazdığım en kompakt Labirent programı.

İlginçtir, takewhile(odd)çok daha basittir:

?:#
" %
\!/

açıklama

Her zamanki Labyrinth primer:

• Hafıza modeli bir istektir (aslında iki tane var, ancak keyfi bir tamsayıya sahip olan ve başlangıçta (kapalı) sonsuz sayıda sıfır içeren, bu program için bir taneye ihtiyacımız var.
• Kontrol akışı talimatı yoktur. Bunun yerine, komut göstergesinin (IP) hareketi, kodun düzeni ile belirlenir (boşluklar "duvarlar" olarak kabul edilir ve IP tarafından geçilemez). Normalde , kodun, IP'nin düz koridorları ve virajları takip ettiği bir labirente benzemesi beklenir, ancak bir kavşağa ulaştığında, bu, IP'nin yeni yönünün mevcut duruma göre belirlendiği koşullu olarak hareket eder. Bir yön seçmek için kurallar bu noktaya kadar kaynamaktadır: eğer yığının tepesi sıfır ise, IP ilerlemeye devam eder; üst pozitif ise, IP sağa döner; Eğer üst negatifse, IP sola döner. Bu yönlerden biri duvar tarafından engellenirse, IP bunun ters yönünü alır. Bu olmadan programlar anlamına gelirAçık koridorlar genellikle çalışmak için inanılmaz derecede zordur, çünkü her komut bir kavşak görevi görür. Bunun bu durumda çözülmüş olması bir mucizedir.
• IP ?, doğu yönünde hareket eden ( bu durumda) okuma sırasındaki ilk boşluk olmayan karakterden başlar .

Programdan geçen ana akış, çevre etrafındaki tek bir döngüdür:

>v
^>v
^@v
^<<

Böyle olduğundan, biz yığınının üst sonra sıfır olduğunu biliyoruz !ve "IP merkezine doğru çevirmek için garanti böylece. `ve %diğer taraftan, IP'nin @programı sonlandıracak şekilde merkeze doğru hareket edebileceği veya çevre çevresinde hareket etmeye devam edebileceği koşullamalar olarak kullanılır .

Döngüdeki koda bakalım:

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

Ve sonra döngü baştan başlar.

Bu neden takewhile(odd)bu kadar basit olduğu sorusunu gündeme getiriyor . İki sebep var:

• EOF 0(olduğu gibi) olarak iade edildiğinden , ayrı bir EOF kontrolüne ihtiyacımız yoktur. Liste zaten o noktada kesiliyor.
• Şimdi ne zaman sona istiyoruz N % 2olan 0(karşıt olarak 1yerine şartlı denetim araçları biz sadece diğer kopyayı bölebilirsiniz akış, hangi) Ntarafından N % 2giriş tekse, sadece yapraklar o: Nve hatta kurtulmak var N % 2'biz don (böylece t ;)), ancak giriş eşitse, bu programı (sessiz) sıfır-sıfıra bölme hatasıyla sonlandırır.

Bu nedenle, diğer kod hiçbir dallamaya izin vermeyen basit bir döngüdür.

Brachylog , 19 16 bayt

hH:% 2 0, B & ~ b.hH [].

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

açıklama

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

Bugün (19 baytlık cevabında kullanılan) düzgün bir numara öğrendim: bir listenin başında bir element eklemek ~b.hHdaha kısa :[H]rc.. İlki, "Çıktı, başında ek bir öğe olan sonuçtur ve Çıktının ilk öğesi H" anlamına gelir , diğeri ise doğrudandır. "Çıktı, birleştirmedir [[H], Result]".

J, 10 bayt

{.~2&|i.1:

açıklama

{.~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 bayt

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

lTek sayıdaki ilk oluşumun dizinine kadar keser . İndeks, bir 1modulo değerinde aranarak bulunur 2. Bulunmayan tek bir numaraya karşı korunmak için a 1konulur.

C #, 50 bayt

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

CJam , 11 bayt

İki düzeltme ve bir bayt için @Dennis'e teşekkürler!

{1+_2f%1#<}

Bu, giriş dizisini yığın üzerinde bekleyen ve çıkış dizisini yığın üzerinde bırakan bir kod bloğudur (bir işleve eşdeğer; varsayılan olarak izin verilir).

Çevrimiçi deneyin!

açıklama

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

Retina , 17 bayt

 ?\d*[13579]\b.*

Sondaki satır besleme kayda değerdir. Giriş ve çıkış boşlukla ayrılmış listelerdir.

Çevrimiçi deneyin!

Bu, basit bir regex ikamesidir, ilk tek sayı ile eşleşir (yani tek bir rakam ile biten bir sayı) ve mümkünse, kendisinden önceki boşluğun yanı sıra ondan sonraki her şeyin yanı sıra boş bir dize ile değiştirir, yani oradaki tüm öğeler ileriye girişden kaldırılır.

Leaky Nun'un işaret ettiği gibi, listeyi ikili olarak alarak 6 bayt kaydedebiliriz, ancak biraz aldatıcı görünüyor, bu yüzden muhtemelen ondalık sürümü saymaya devam edeceğim:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 bayt

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

V , 13 bayt

íä*[13579]¾.*

Çevrimiçi deneyin!

Açıklama:

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

Uygun şekilde, aynı kod tüm test durumlarını aynı anda doğrulamak için çalışır.

Dyalog APL , 11 bayt

{⍵/⍨∧\~2|⍵}

2| kalanları 2 ile bölmek

~ negate

∧\ AND-taraması (ilk 0'dan kapanıyor)

/⍨ nerede seç

Yakut, 25 bayt

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

Sanırım kaybettim ...

Pyke, 8 bayt

0+2L%fhO

Tercüman düzeltildi, diğer bağlantıları kullanın

Split_at işlevim dışındaki Dennis yöntemini kullanır, değişimi de içerir - muhtemelen bir hata

Veya bugfix ile 7 bayt

2L%1R@<

Burada dene!

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

Veya 2. hata düzeltmesinden sonra, 6 bayt

2L%fhO

Burada dene!

Açıklama:

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

GolfScript, 11 bayt

Bu, dizili bir GolfScript dizisi değişmezi (örn. [28 14 7 0]) Okuyan ve aynı diziyi ilk tek öğeyle ve çıkarıldıktan sonraki her şeyi basan tam bir GolfScript programıdır :

~1\{~&.},p;

Çevrimiçi deneyin. (Ayrıca: Test kablo demeti ile genişletilmiş versiyon. )

De-golfed yorum ile yorum:

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

Bu çözüm, { },bir dizinin her birindeki kod bloğunun içeriğini çalıştıran ve bloktaki kodun gerçek (sıfır olmayan) bir değer döndürdüğü dizinin öğelerini seçen GolfScript filtre işlecine dayanır . yığının en üstünde.

Böylece, örneğin, {1&},bir dizideki tüm tek sayıları seçer ve tüm çift sayıları {~1&},seçerdi. Öyleyse, zorluk, ilk tek olanı bulana kadar çiftleri seçen ve daha sonra hiç sayı seçmeyen bir filtre oluşturmaktır .

Kullandığım çözüm, sabit bit maskesini 1(her giriş numarasının en düşük bitini çıkartmak için kullanılan) önceki filtre döngüsü yinelemesinin sonucunu (0 veya 1) depolayan (ve başlangıç ​​durumuna getirilen) yığındaki bir değişkenle değiştirmek. Döngüden önce 1). Böylece, filtre bir kez 0 değerini döndürdüğü anda, bit maskesi aynı zamanda 0 olarak da ayarlanır ve böylece filtrenin bir daha geri dönmesini önler.

İleri, 114 bayt

Dördüncü gerçekten listeleri yok. Parametreler, Forth'da tipik olarak olduğu gibi, yığına ters sırayla basılmalıdır. Sonuç aynı sıra ile yığında bırakılacaktır. Bu bir nedenden dolayı İdeone üzerinde çalışmıyor, ancak repl üzerinde çalışıyor. Bir çeşit belirsizliği gidermek için yeni hat gerekli midir?

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

Çevrimiçi deneyin

Ungolfed, yorumlarla:

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

Bu program (önceki denemem) sonuçları tek bir sayıya ulaşana kadar yazdırır. Kalan her şey (alınmamış) yığında bırakılacaktır.

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

Yalnızca tam sayı bile olsa başarısız olur

Befunge, 35 Bayt

Bu kod 0 ile 65535 arasındaki sayıları yönetir.

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

Giriş formatı:

number_of_values    values(separated by a space)

İşlemin sonunda değerleri görüntüleyen bir sürüm:

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

Kodu burada test edebilirsiniz , ancak bu yorumlamanın belirttiği gibi takip boşluklarıyla bir takip satırı eklemeniz gerekir:

«Kod torus sadece ilk program kadar büyük. Veriler kodun sonunun üstüne çıkarılacaksa daha fazla satır veya sondaki boşluk ekleyin. »

Bu kabul edilebilir olup olmadığını bilmiyorum, bu sondaki bayt sayısı
nb'de sayılmadığı için: kodda numara sakladığım için, tercüman bu programın iki kez doğru çalışmasına izin vermiyor yol. Yeniden yüklemeniz gerekecek.

Bu nasıl çalışır: Tercüman okları takip eder ve '#' işaretini okurken bir talimat atlar.

Gri noktalar test edilmiştir ve kırmızı çizgi gereksiz değişkenleri yığından kaldırır.

Burada, yukarıdaki yorumlayıcıda kullanıldığında, kaydedilen değerler temsilleri kullanılarak kodda görüntülenir (formatı bilmiyorum). Evet, Befunge oldukça yansıtıcı bir dil