Pengantar dan Kredit

Hari ini tanpa pembuka yang mewah: Harap laksanakan takewhile.

Variasi dari ini (pada struktur data non-sepele) adalah tugas di program pemrograman fungsional universitas saya. Tugas ini sekarang ditutup dan telah dibahas di kelas dan saya memiliki izin profesor saya untuk mempostingnya di sini (saya bertanya secara eksplisit).

Spesifikasi

Memasukkan

Masukan akan berupa daftar (atau konsep padanan bahasa Anda) dari bilangan bulat positif.

Keluaran

Outputnya harus berupa daftar (atau konsep padanan bahasa Anda) dari bilangan bulat positif.

Melakukan apa?

Tugas Anda adalah mengimplementasikan takewhile(bahasa built-in diizinkan) dengan predikat bahwa angka yang dipertimbangkan bahkan (untuk fokus pada takewhile).

Jadi Anda mengulangi daftar dari awal hingga akhir dan sementara kondisi (genap) berlaku, Anda menyalin ke daftar-output dan segera setelah Anda menekan elemen yang tidak membuat kondisi tersebut benar, Anda batalkan operasi dan output (contoh langkah demi langkah di bawah ini). Fungsionalitas tingkat tinggi ini juga disebut takeWhile ( takewhile).

Kasing sudut potensial

Urutan daftar output dibandingkan dengan daftar input mungkin tidak dapat diubah, misalnya [14,42,2]tidak menjadi [42,14].

Daftar kosong adalah input dan output yang valid.

Yang menang?

Ini adalah kode-golf sehingga jawaban tersingkat dalam byte menang!

Aturan standar berlaku tentu saja.

Vektor Uji

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

Contoh Langkah-demi-Langkah

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 byte

#~TakeWhile~EvenQ&

Lain bawaan built-in yang dikalahkan oleh faktor 3 oleh golf golf tanpa built-in ...

Haskell, 13 byte

fst.span even

spanmembagi daftar input menjadi sepasang daftar tepat sebelum elemen pertama di mana predikat (-> even) salah. fstmengambil elemen pertama dari pasangan.

Versi alternatif, 13 byte:

fst.break odd

breakadalah kebalikan dari span, yaitu membagi daftar pada elemen pertama di mana predikatnya benar.

Tentu saja ada juga

takeWhile even

tapi itu 14 byte.

MATL , 6 byte

toYs~)

Cobalah online!

Penjelasan

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

Hexagony , 19

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

Dapat dibaca:

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

Cobalah online!

Ini mungkin bisa di-golf dengan satu atau dua byte, tetapi itu mungkin memerlukan beberapa tata letak yang benar-benar cerdik, yang mungkin lebih mudah ditemukan melalui brute force (bahkan jika mungkin butuh waktu agak lama untuk menemukannya).

Penjelasan tingkat tinggi

Program ini sebagian besar mengikuti kodesemu ini:

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

Yang menyalahgunakan bagaimana Hexagony mencoba membaca angka begitu STDIN kosong (mengembalikan nol). Terima kasih banyak untuk Martin atas bantuannya dalam pendekatan ini.

Penjelasan Lengkap

Saya masih belum mengutak-atik Mono untuk menjalankan IDE esoterik fantastis Timwi , jadi saya mencondongkan tubuh ke Martin untuk memberi saya beberapa gambar cantik yang membantu!

Pertama, sedikit primer pada aliran kontrol dasar dalam Hexagony. Pointer instruksi pertama (IP), yang merupakan satu-satunya yang digunakan dalam program ini, dimulai di kiri atas kode sumber heksagonal, dan mulai bergerak ke arah kanan. Setiap kali IP meninggalkan tepi segi enam, itu bergerak side_length - 1baris menuju tengah segi enam. Karena program ini menggunakan panjang sisi tiga segi enam, IP akan selalu bergerak dua baris ketika ini terjadi. Satu-satunya pengecualian adalah jika bergerak dari baris tengah, di mana ia bergerak menuju bagian atas atau bawah hexagon, tergantung pada nilai dari tepi memori saat ini.

Sekarang sedikit tentang persyaratan. Satu-satunya persyaratan dalam Hexagony untuk aliran kontrol adalah >, <dan tepi tengah hexagon. Ini semua mengikuti aturan konstan: jika nilai pada tepi memori saat ini adalah nol atau aliran kontrol negatif bergerak ke kiri dan jika positif kontrol mengalir ke kanan. Lebih besar dari dan kurang dari tanda kurung mengarahkan IP pada sudut enam puluh derajat, sedangkan tepi segi enam mengontrol ke mana baris IP melompat.

Hexagony juga memiliki model memori khusus, di mana semua data disimpan di tepi grid heksagonal yang tak terbatas. Program ini hanya menggunakan tiga sisi: satu untuk menyimpan dua, satu untuk nomor yang sedang dibaca, dan satu untuk nomor modulo dua. Itu terlihat seperti:

Mod  \ / Input
      |
      2

Saya tidak akan menjelaskan dengan hati-hati di mana kita berada di memori pada setiap titik selama penjelasan program, jadi kembali ke sini jika Anda bingung dengan di mana kita berada dalam memori.

Dengan semua itu, penjelasan sebenarnya bisa dimulai. Pertama, kita mengisi tepi "2" dalam memori dengan angka 2, lalu kita jalankan perintah no-op dan pindahkan penunjuk memori ke kanan ( 2.}).

Selanjutnya, kita mulai loop program utama. Kami membaca angka pertama dari STDIN dan kemudian kami menekan conditional ( ?<). Jika tidak ada angka yang tersisa di STDIN, ini membaca nol ke tepi memori saat ini, jadi kami belok kiri ke @, yang mengakhiri program. Kalau tidak, kita pantulkan cermin, pindahkan penunjuk memori ke belakang dan ke kiri, bungkus sekitar segi enam untuk menghitung sisa membagi input dengan 2 dan kemudian tekan kondisional lain ( /"%>).

Jika sisanya adalah satu (yaitu angkanya ganjil), kita belok kanan mengikuti jalur biru di atas dimulai dengan mengeksekusi no-op lagi, lalu kita lilitkan ke bagian bawah segi enam, kalikan tepi saat ini dengan 10 dan kemudian tambahkan delapan, bangkit dari beberapa mirror, lakukan penggandaan dan penambahan yang sama lagi, dapatkan 188 di tepi saat ini, membungkus kembali ke atas segi enam, menjalankan no-op lagi, dan akhirnya mengakhiri program ( .8/\8.@). Hasil berbelit-belit ini adalah kecelakaan yang membahagiakan, saya awalnya telah menulis sedikit logika yang lebih sederhana, tetapi memperhatikan bahwa saya dapat menghapusnya demi no-op, yang saya pikir lebih sesuai dengan semangat Hexagony.

Jika sisanya nol kita sebaliknya belok kiri mengikuti jalan merah, di atas. Ini menyebabkan kita untuk memindahkan penunjuk memori ke kiri, dan kemudian mencetak nilai di sana (nilai input) sebagai angka. Cermin yang kita temui bertindak sebagai no-op karena arah yang kita bergerak ( {/!). Lalu kami mencapai ujung hexagon yang bertindak bersyarat dengan hanya satu hasil, karena nilai input dari sebelumnya sudah diuji menjadi positif, jadi kami selalu bergerak ke kanan (jika Anda membayangkan diri Anda menghadap ke arah IP) . Kami kemudian mengalikan input dengan 10 dan menambahkan dua, hanya untuk mengubah arah, membungkus dan menimpa nilai baru dengan nilai ascii dari huruf kapital M, 77. Kemudian kami menekan beberapa mirror, dan keluar melewati tepi tengah segi enam dengan trampolin (2<M\>$). Karena 77 positif, kita bergerak ke arah bagian bawah segi enam dan karena trampolin lewati instruksi pertama ( !). Kami kemudian mengalikan tepi memori saat ini dengan 10 dan menambahkan 8, mendapatkan 778. Kami kemudian menampilkan nilai ini mod 256 (10) sebagai karakter ASCII, yang kebetulan merupakan baris baru. Akhirnya kita keluar dari segi enam dan membungkus kembali ke yang pertama ?yang menimpa 778 dengan nilai input berikutnya.

Pyth, 13 9 7 byte

uPWs%R2

Kredit ke @FryAmTheEggman untuk 2 (cukup rumit) byte!

Penjelasan:

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

Uji di sini .

Jelly , 5 byte

Ḃœp⁸Ḣ

Cobalah online! atau verifikasi semua kasus uji .

Bagaimana itu bekerja

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

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

Fungsi memodifikasi argumennya di tempat .

Terima kasih kepada @xnor karena bermain golf dari byte dengan cara yang sangat cerdas!

Uji di Ideone .

ed, 13

/[13579]$/,$d

Karena programmer nyata menggunakan The Standard Text Editor .

Mengambil input sebagai satu bilangan bulat di setiap baris; output dalam format yang sama.

Ini hanya menemukan angka ganjil pertama (angka yang berakhir dengan angka ganjil) dan menghapus dari baris itu sampai akhir file.

Clojure, 21 byte

#(take-while even? %)

Clojure akhirnya hampir bersaing! (terima kasih untuk tugasnya menjadi built-in) Lihat secara online https://ideone.com/BEKmez

Python, 45 44 byte

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

Uji di Ideone .

R, 25 byte

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

Atau sederajat

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

05AB1E, 8 7 byte

[DÉO_#¨

Penjelasan

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

Cobalah online

Solusi 8 byte sebelumnya

vyÈiyˆëq

Penjelasan

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

Cobalah online

Brainf ***, 263 byte

Saya mengambil sedikit cuplikan dari sini

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

Saya akan memberikan penjelasan tetapi bahkan saya tidak tahu bagaimana ini bekerja lagi.

Mengharapkan input sebagai angka yang dipisahkan oleh spasi (mis. 2 432 1)

Pyth, 7 byte

<x%R2Q1

Coba di sini!

Apa yang saya coba lakukan di Pyke tetapi indeks rusak di atm itu

Racket, 22 byte

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

The λkarakter dihitung sebagai 2 byte.

Saya belum pernah melihat Racket digunakan sebelumnya dalam salah satu jawaban kode golf yang pernah saya lihat, jadi saya harus melakukannya setidaknya sekali!

Labirin , 14 byte

?:
"`#
"@%
\!;

Input dan output adalah daftar yang dipisahkan oleh linefeed (meskipun pada prinsipnya, input dapat menggunakan pemisah non-digit).

Cobalah online!

Ini mungkin adalah program Labirin paling ringkas yang pernah saya tulis.

Menariknya, takewhile(odd)jauh lebih sederhana:

?:#
" %
\!/

Penjelasan

Primer Labirin biasa:

• Model memori adalah tumpukan (sebenarnya ada dua, tetapi kita hanya perlu satu untuk program ini), yang memegang bilangan bulat presisi sewenang-wenang dan awalnya memegang jumlah nol tak terbatas (implisit).
• Tidak ada instruksi aliran kendali. Sebaliknya, pergerakan penunjuk instruksi (IP) ditentukan oleh tata letak kode (spasi dianggap "dinding" dan tidak dapat dilalui oleh IP). Biasanya , kode tersebut menyerupai labirin, di mana IP mengikuti koridor lurus dan belokan, tetapi setiap kali mencapai persimpangan, ini bertindak sebagai kondisi di mana arah baru IP ditentukan berdasarkan kondisi saat ini. Aturan untuk memilih arah bermuara pada hal ini: jika bagian atas tumpukan adalah nol, IP terus bergerak maju; jika bagian atas positif, IP berbelok ke kanan; jika bagian atas negatif IP membelok ke kiri. Jika salah satu dari arah ini diblokir oleh dinding, IP akan mengambil arah sebaliknya. Ini berarti program itu tanpaKoridor yang jelas biasanya sangat sulit untuk dikerjakan, karena setiap perintah akan bertindak sebagai persimpangan. Fakta bahwa ini berhasil dalam kasus ini adalah sedikit keajaiban.
• IP dimulai pada karakter non-spasi pertama dalam urutan membaca ( ?dalam hal ini), bergerak ke timur.

Aliran utama melalui program ini adalah satu loop di sekeliling:

>v
^>v
^@v
^<<

Seperti yang terjadi, kita tahu bahwa bagian atas tumpukan adalah nol setelahnya !dan "agar IP dijamin tidak berbalik ke tengah. `dan %di sisi lain digunakan sebagai kondisi di mana IP mungkin bergerak ke arah tengah sehingga @menghentikan program, atau mungkin terus bergerak di sekeliling.

Mari kita lihat kode di loop:

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

Dan kemudian loop dimulai kembali.

Itu menimbulkan pertanyaan mengapa takewhile(odd)jauh lebih sederhana. Ada dua alasan:

• Karena EOF dikembalikan sebagai 0(yang genap), kami tidak memerlukan pemeriksaan EOF terpisah. Lagipula daftar itu akan terpotong pada saat itu.
• Sekarang kita ingin mengakhiri saat N % 2ini 0(sebagai lawan 1), yang berarti bukan kontrol kondisional mengalir kita hanya bisa membagi salinan lain Noleh N % 2: jika input aneh, yang hanya daun Ndan bahkan kami mendapat menyingkirkan N % 2(sehingga kita don' t need ;), tetapi jika inputnya genap, itu akan menghentikan program dengan kesalahan (diam) pembagian demi nol.

Oleh karena itu, kode lainnya adalah loop sederhana yang tidak memungkinkan untuk bercabang sama sekali.

Brachylog , 19 16 byte

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

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

Penjelasan

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

Hari ini saya mempelajari trik yang rapi (yang digunakan dalam jawaban 19 byte): ~b.hHlebih pendek daripada :[H]rc.menambahkan elemen pada awal daftar. Yang pertama berarti "Output adalah hasil dengan item tambahan di awal, dan item pertama dari Output adalah H" , sedangkan yang lainnya langsung "Output adalah gabungan dari [[H], Result]".

J, 10 byte

{.~2&|i.1:

Penjelasan

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

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

Memotong lhingga indeks kemunculan pertama nomor ganjil. Indeks ditemukan dengan mencari 1dalam modulo nilai-nilai 2. Untuk menjaga agar tidak ada nomor ganjil yang ditemukan, a 1diletakkan di ujung.

C #, 50 byte

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

CJam , 11 byte

Berkat @ Dennis untuk dua koreksi dan satu byte off!

{1+_2f%1#<}

Ini adalah blok kode (setara dengan fungsi; diizinkan secara default) yang mengharapkan array input pada stack, dan meninggalkan array output pada stack.

Cobalah online!

Penjelasan

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

 ?\d*[13579]\b.*

Linefeed tambahan sangat penting. Input dan output adalah daftar yang dipisahkan oleh ruang.

Cobalah online!

Ini adalah penggantian regex sederhana, cocok dengan angka ganjil pertama (yaitu angka yang berakhir dengan digit ganjil), dan jika mungkin ruang yang mendahuluinya serta semuanya setelahnya dan menggantinya dengan string kosong, yaitu semua elemen dari sana selanjutnya dihapus dari input.

Seperti yang Leaky Nun tunjukkan, dengan mengambil daftar dalam biner, kita dapat menyimpan 6 byte, tetapi tampaknya sedikit curang, jadi saya mungkin akan terus menghitung versi desimal:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 byte

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

V , 13 byte

íä*[13579]¾.*

Cobalah online!

Penjelasan:

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

Dengan mudah, kode yang sama berfungsi untuk memverifikasi semua kasus uji secara bersamaan.

Dyalog APL , 11 byte

{⍵/⍨∧\~2|⍵}

2| sisa pembagian dari pembagian dengan 2

~ meniadakan

∧\ AND-scan (mati dari 0 pertama)

/⍨ pilih dimana

Ruby, 25 byte

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

Saya pikir saya kehilangan ...

Pyke, 8 byte

0+2L%fhO

Interpreter diperbaiki, gunakan tautan lain

Menggunakan metode Dennis 'kecuali fungsi split_at saya termasuk perubahan - mungkin bug

Atau dengan perbaikan bug, 7 byte

2L%1R@<

Coba di sini!

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

Atau setelah perbaikan bug ke-2, 6 byte

2L%fhO

Coba di sini!

Penjelasan:

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

GolfScript, 11 byte

Ini adalah program GolfScript lengkap yang membaca literal array GolfScript string (misalnya [28 14 7 0]) dan mencetak array yang sama dengan elemen aneh pertama dan semuanya setelah dihapus:

~1\{~&.},p;

Cobalah online. (Juga: Versi diperpanjang dengan test harness. )

Versi de-golf dengan komentar:

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

Solusi ini didasarkan pada { },operator filter GolfScript , yang menjalankan konten blok kode pada setiap elemen array, dan memilih elemen-elemen array yang kode di blok mengembalikan nilai yang benar (yaitu bukan nol) pada atas tumpukan.

Jadi, misalnya, {1&},akan memilih semua angka ganjil dalam array, dan {~1&},akan memilih semua angka genap. Maka tantangannya adalah membuat filter yang memilih angka genap sampai menemukan angka ganjil pertama , dan setelah itu tidak memilih angka sama sekali.

Solusi yang saya gunakan adalah mengganti bit-mask konstan 1(digunakan untuk mengekstrak bit terendah dari setiap nomor input) dengan variabel pada stack yang menyimpan hasil (0 atau 1) dari iterasi loop filter sebelumnya (dan diinisialisasi ke 1 sebelum loop). Jadi, segera setelah filter mengembalikan 0 sekali, bitmask juga diatur ke 0, mencegah filter untuk kembali lagi 1.

Keempat, 114 byte

Keempat tidak benar-benar memiliki daftar. Parameter harus didorong ke tumpukan dalam urutan terbalik, seperti yang tipikal dalam Keempat. Hasilnya akan ditinggalkan di tumpukan dalam urutan yang sama. Ini tidak berfungsi pada Ideone karena alasan tertentu, tetapi bekerja pada repl. Baris baru diperlukan untuk menghapus semacam ambiguitas?

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

Cobalah online

Tidak disatukan, dengan komentar:

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

Program ini (usaha saya sebelumnya) mencetak hasilnya hingga mencapai angka ganjil. Semua yang tersisa (tidak diambil) akan ditinggalkan di tumpukan.

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

Gagal jika hanya bilangan bulat

Befunge, 35 Bytes

Kode ini menangani angka antara 0 dan 65535

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

Masukkan format :

number_of_values    values(separated by a space)

Berikut adalah versi yang menampilkan nilai di akhir proses:

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

Anda dapat menguji kode di sini , tetapi Anda harus menambahkan garis trailing dengan spasi tambahan, karena ini menafsirkan:

«Kode torus hanya sebesar program awal. Masukkan lebih banyak garis atau spasi tambahan jika data akan diletakkan di luar akhir kode. »

Saya tidak tahu apakah ini dapat diterima, karena saya tidak menghitung jejak ini dalam byte byte
nb: tampaknya karena saya menyimpan nomor dalam kode, penerjemah tidak akan membiarkan program ini berjalan dua kali dengan benar cara. Anda harus memuatnya kembali.

Bagaimana cara kerjanya: Penerjemah mengikuti panah dan melewatkan instruksi ketika melewati '#'

Titik abu-abu adalah tes, dan garis merah menghapus variabel yang tidak dibutuhkan dari tumpukan

Dengan menggunakan interpreter di atas, nilai yang disimpan ditampilkan dalam kode menggunakan representasi mereka (saya tidak tahu formatnya). Ya, Befunge adalah bahasa yang cukup reflektif