Introduction et crédit

Aujourd'hui sans prélude sophistiqué: veuillez mettre en œuvre takewhile.

Une variation de ceci (sur une structure de données non triviale) était une affectation à mon cours de programmation fonctionnelle universitaire. Ce devoir est maintenant fermé et a été discuté en classe et j'ai la permission de mon professeur de le poster ici (j'ai demandé explicitement).

spécification

Contribution

L'entrée sera une liste (ou le concept équivalent de votre langue) d'entiers positifs.

Sortie

La sortie doit être une liste (ou le concept équivalent de votre langue) d'entiers positifs.

Que faire?

Votre tâche est d'implémenter takewhile(les langues intégrées sont autorisées) avec le prédicat que le nombre considéré est pair (pour se concentrer sur le temps).

Donc, vous parcourez la liste du début à la fin et pendant que la condition (est paire), vous copiez dans la liste de sortie et dès que vous frappez un élément qui ne rend pas la condition vraie, vous abandonnez l'opération et la sortie (un exemple étape par étape est ci-dessous). Cette fonctionnalité d'ordre supérieur est également appelée takeWhile ( takewhile).

Boîtes de coin potentielles

L'ordre de la liste de sortie par rapport à la liste d'entrée ne peut pas être modifié, par exemple [14,42,2]peut ne pas devenir [42,14].

La liste vide est une entrée et une sortie valides.

Qui gagne?

Il s'agit de code-golf, donc la réponse la plus courte en octets l'emporte!

Les règles standard s'appliquent bien sûr.

Vecteurs de test

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

Exemple pas à pas

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 octets

#~TakeWhile~EvenQ&

Un autre glorieux intégré qui est battu par un facteur de 3 par les langues de golf sans le ...

Haskell, 13 octets

fst.span even

spandivise la liste d'entrée en une paire de listes juste avant le premier élément où le prédicat (-> even) est faux. fstprend le premier élément de la paire.

Version alternative, 13 octets:

fst.break odd

breakest l'opposé de span, c'est-à-dire qu'il fractionne la liste au premier élément où le prédicat est vrai.

Bien sûr, il y a aussi

takeWhile even

mais cela fait 14 octets.

MATL , 6 octets

toYs~)

Essayez-le en ligne!

Explication

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

Hexagonie , 19

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

Lisible:

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

Essayez-le en ligne!

Cela peut probablement être joué par un octet ou deux, mais cela pourrait nécessiter une mise en page vraiment ingénieuse, qui pourrait être plus facilement trouvée via la force brute (même si cela peut prendre un certain temps pour le trouver).

Explication de haut niveau

Le programme suit principalement ce pseudocode:

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

Ce qui abuse de la façon dont Hexagony essaie de lire un nombre une fois que STDIN est vide (il renvoie un zéro). Un grand merci à Martin pour son aide dans l'élaboration de cette approche.

Explication complète

Je n'ai pas encore tripoté Mono pour faire tourner l' IDE ésotérique fantastique de Timwi , alors je me suis appuyé sur Martin pour me fournir de jolies photos utiles!

Tout d'abord, une petite introduction au flux de contrôle de base en hexagonie. Le premier pointeur d'instruction (IP), qui est le seul utilisé dans ce programme, commence en haut à gauche du code source hexagonal et commence à se déplacer vers la droite. Chaque fois que l'IP quitte le bord de l'hexagone, il déplace les side_length - 1rangées vers le milieu de l'hexagone. Étant donné que ce programme utilise un côté hexagonal de trois côtés, l'IP se déplacera toujours de deux lignes lorsque cela se produit. La seule exception est si elle se déplace hors de la ligne du milieu, où elle se déplace conditionnellement vers le haut ou le bas de l'hexagone, en fonction de la valeur du bord de mémoire actuel.

Maintenant, un peu sur les conditions. Les seules conditions dans les Hexagony de flux de commande sont >, <et le bord intermédiaire de l'hexagone. Ils suivent tous une règle constante: si la valeur sur le front de mémoire actuel est nulle ou si le flux de contrôle négatif se déplace vers la gauche et s'il est positif, le contrôle circule vers la droite. Les crochets supérieurs et inférieurs redirigent l'IP à des angles de soixante degrés, tandis que le bord de l'hexagone contrôle la ligne sur laquelle l'IP saute.

Hexagony a également un modèle de mémoire spécial, où toutes les données sont stockées sur les bords d'une grille hexagonale infinie. Ce programme n'utilise que trois arêtes: une pour stocker deux, une pour le nombre actuellement lu et une pour le nombre modulo deux. Cela ressemble à quelque chose comme:

Mod  \ / Input
      |
      2

Je ne vais pas expliquer avec soin où nous sommes en mémoire à chaque moment pendant l'explication du programme, alors revenez ici si vous êtes confus par où nous sommes en mémoire.

Avec tout cela à l'écart, l'explication réelle peut commencer. D'abord, nous remplissons le bord "2" en mémoire avec un 2, puis nous exécutons un no-op et déplaçons le pointeur de mémoire vers la droite ( 2.}).

Ensuite, nous commençons la boucle du programme principal. Nous lisons le premier nombre de STDIN puis nous frappons un conditionnel ( ?<). S'il n'y a plus de chiffres dans STDIN, cela lit un zéro dans le bord de mémoire actuel, nous tournons donc à gauche sur le @, ce qui termine le programme. Sinon, nous rebondissons sur un miroir, déplaçons le pointeur de mémoire vers l'arrière et vers la gauche, enroulons autour de l'hexagone pour calculer le reste de la division de l'entrée par 2, puis frappons un autre conditionnel ( /"%>).

Si le reste était un (c.-à-d. Que le nombre était impair), nous tournons à droite en suivant le chemin bleu ci-dessus en commençant par exécuter à nouveau le no-op, puis nous enroulons autour du bas de l'hexagone, multiplions le bord actuel par 10, puis ajoutons huit, rebondissez sur quelques miroirs, effectuez la même multiplication et addition à nouveau, en obtenant 188 sur le bord actuel, en revenant au sommet de l'hexagone, en exécutant à nouveau le no-op et en terminant enfin le programme ( .8/\8.@). Ce résultat alambiqué était un heureux accident, j'avais à l'origine écrit un peu de logique beaucoup plus simple, mais j'ai remarqué que je pouvais le supprimer en faveur du no-op, ce que je pensais être plus dans l'esprit d'Hexagony.

Si le reste était nul, nous tournerons à gauche en suivant le chemin rouge ci-dessus. Cela nous amène à déplacer le pointeur de mémoire vers la gauche, puis à y imprimer la valeur (la valeur d'entrée) sous forme de nombre. Le miroir que nous rencontrons agit comme un no-op en raison de la direction dans laquelle nous nous déplaçons ( {/!). Ensuite, nous frappons le bord de l'hexagone qui agit comme un conditionnel avec un seul résultat, car la valeur d'entrée d'avant a déjà été testée pour être positive, nous nous déplaçons donc toujours vers la droite (si vous vous imaginez face à la direction de l'IP) . Nous multiplions ensuite l'entrée par 10 et en ajoutons deux, seulement pour changer de direction, envelopper et écraser la nouvelle valeur avec la valeur ascii de la lettre majuscule M, 77. Ensuite, nous frappons quelques miroirs et sortons sur le bord du milieu de l'hexagone avec un trampoline (2<M\>$). Puisque 77 est positif, nous nous déplaçons à droite vers le bas de l'hexagone et à cause du trampoline sautez la première instruction ( !). Nous multiplions ensuite le bord de mémoire actuel par 10 et ajoutons 8, obtenant 778. Nous sortons ensuite cette valeur mod 256 (10) sous forme de caractère ASCII, qui se trouve être une nouvelle ligne. Enfin, nous quittons l'hexagone et revenons au premier ?qui remplace le 778 avec la prochaine valeur d'entrée.

Pyth, 13 9 7 octets

uPWs%R2

Crédits à @FryAmTheEggman pour 2 octets (assez délicats)!

Explication:

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

Testez-le ici .

Gelée , 5 octets

Ḃœp⁸Ḣ

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

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

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

La fonction modifie son argument en place .

Merci à @xnor d'avoir joué un octet de manière vraiment intelligente!

Testez-le sur Ideone .

ed, 13

/[13579]$/,$d

Parce que les vrais programmeurs utilisent l' éditeur de texte standard .

Prend l'entrée comme un entier sur chaque ligne; sorties dans le même format.

Cela trouve simplement le premier nombre impair (nombre se terminant par un chiffre impair) et supprime de cette ligne jusqu'à la fin du fichier.

Clojure, 21 octets

#(take-while even? %)

Clojure est enfin un peu en compétition! (grâce à la tâche étant intégrée) Voir en ligne https://ideone.com/BEKmez

Python, 45 44 octets

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

Testez-le sur Ideone .

R, 25 octets

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

Ou équivalent

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

05AB1E, 8 7 octets

[DÉO_#¨

Explication

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

Essayez-le en ligne

Solution précédente de 8 octets

vyÈiyˆëq

Explication

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

Essayez-le en ligne

Brainf ***, 263 octets

J'ai pris un petit extrait d' ici

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

Je donnerais une explication mais même moi, je ne sais plus comment cela fonctionne.

Attend l'entrée en tant que nombres séparés par l'espace (par exemple 2 432 1)

Pyth, 7 octets

<x%R2Q1

Essayez-le ici!

Ce que j'ai essayé de faire à Pyke mais l'index est cassé dans cette atmosphère

Raquette, 22 octets

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

Le λcaractère compte pour 2 octets.

Je n'ai jamais vu Racket utilisé auparavant dans aucune des réponses de golf que j'ai vues, j'ai donc dû le faire au moins une fois!

Labyrinthe , 14 octets

?:
"`#
"@%
\!;

L'entrée et la sortie sont des listes séparées par des sauts de ligne (bien qu'en principe, l'entrée puisse utiliser n'importe quel séparateur non numérique).

Essayez-le en ligne!

C'est probablement le programme Labyrinthe le plus compact que j'aie jamais écrit.

Fait intéressant, takewhile(odd)c'est beaucoup plus simple:

?:#
" %
\!/

Explication

Le primaire Labyrinth habituel:

• Le modèle de mémoire est une pile (il y en a en fait deux, mais nous n'en aurons besoin que d'un pour ce programme), qui contient des entiers de précision arbitraire et contient initialement un nombre infini (implicite) de zéros.
• Il n'y a pas d'instructions de flux de contrôle. Au lieu de cela, le mouvement du pointeur d'instruction (IP) est déterminé par la disposition du code (les espaces sont considérés comme des "murs" et ne peuvent pas être traversés par l'IP). Normalement , le code est censé ressembler à un labyrinthe, où l'IP suit des couloirs droits et des virages, mais chaque fois qu'il atteint une jonction, cela agit comme une condition où la nouvelle direction de l'IP est déterminée en fonction de l'état actuel. Les règles pour choisir une direction se résument à ceci: si le haut de la pile est nul, l'IP continue d'avancer; si le sommet est positif, l'IP tourne à droite; si le haut est négatif, l'IP tourne à gauche. Si l'une de ces directions est bloquée par un mur, l'IP prend la direction opposée à la place. Cela signifie que les programmes sansles couloirs clairs sont généralement incroyablement difficiles à travailler, car chaque commande unique ferait office de jonction. Le fait que cela ait fonctionné dans ce cas est un peu un miracle.
• L'IP commence au premier caractère non spatial dans l'ordre de lecture ( ?dans ce cas), se déplaçant vers l'est.

Le flux principal dans le programme est une boucle unique autour du périmètre:

>v
^>v
^@v
^<<

En l'occurrence, nous savons que le haut de la pile est zéro après !et "que l'IP est garanti de ne pas se tourner vers le centre. `et %d'autre part sont utilisés comme conditions où l'IP peut se déplacer vers le centre de telle sorte que @le programme se termine, ou il peut continuer à se déplacer dans le périmètre.

Regardons le code dans la boucle:

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

Et puis la boucle recommence.

Cela soulève la question de savoir pourquoi takewhile(odd)c'est tellement plus simple. Il y a deux raisons:

• Étant donné que EOF est retourné comme 0(ce qui est pair), nous n'avons pas besoin d'un contrôle EOF séparé. La liste serait alors coupée de toute façon.
• Maintenant, nous voulons terminer quand N % 2is 0(par opposition à 1), ce qui signifie qu'au lieu du flux de contrôle conditionnel, nous pouvons simplement diviser l'autre copie Npar N % 2: si l'entrée est impaire, cela part juste Net nous nous sommes même débarrassés de N % 2(donc nous ne faisons pas '' t besoin ;), mais si l'entrée est paire, cela termine simplement le programme avec une erreur de division par zéro (silencieuse).

Par conséquent, l'autre code est une simple boucle qui ne permet aucune ramification.

Brachylog , 19 16 octets

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

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

Explication

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

Aujourd'hui, j'ai appris une astuce intéressante (qui a été utilisée dans la réponse de 19 octets): ~b.hHest plus courte que :[H]rc.d'ajouter un élément au début d'une liste. Le premier signifie "La sortie est le résultat avec un élément supplémentaire au début, et le premier élément de la sortie est H" , tandis que l'autre est simple "La sortie est la concaténation de [[H], Result]".

J, 10 octets

{.~2&|i.1:

Explication

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

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

Tronque ljusqu'à l'index de la première occurrence d'un nombre impair. L'index est trouvé en recherchant un 1dans les valeurs modulo 2. Pour éviter qu'aucun nombre impair ne soit trouvé, un 1est placé à la fin.

C #, 50 octets

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

CJam , 11 octets

Merci à @Dennis pour deux corrections et un octet!

{1+_2f%1#<}

Il s'agit d'un bloc de code (équivalent à une fonction; autorisé par défaut) qui attend le tableau d'entrée sur la pile et laisse le tableau de sortie sur la pile.

Essayez-le en ligne!

Explication

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

Rétine , 17 octets

 ?\d*[13579]\b.*

Le saut de ligne arrière est important. L'entrée et la sortie sont des listes séparées par des espaces.

Essayez-le en ligne!

Il s'agit d'une simple substitution d'expression régulière, elle correspond au premier nombre impair (c'est-à-dire un nombre se terminant par un chiffre impair), et si possible l'espace qui le précède ainsi que tout ce qui le suit et le remplace par une chaîne vide, c'est-à-dire tous les éléments de là partir de l'entrée.

Comme le souligne Leaky Nun, en prenant la liste en binaire, nous pouvons économiser 6 octets, mais cela semble un peu tricheur, donc je continuerai probablement à compter la version décimale:

 ?\d*1\b.*

JavaScript (Firefox 30-57), 30 octets

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

V , 13 octets

íä*[13579]¾.*

Essayez-le en ligne!

Explication:

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

Idéalement, le même code fonctionne pour vérifier tous les cas de test simultanément.

Dyalog APL , 11 octets

{⍵/⍨∧\~2|⍵}

2| division reste de la division avec 2

~ nier

∧\ AND-scan (s'éteint à partir du premier 0)

/⍨ sélectionner où

Rubis, 25 octets

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

Je pense que je perds ...

Pyke, 8 octets

0+2L%fhO

Interprète corrigé, utilisez d'autres liens

Utilise la méthode de Dennis sauf que ma fonction split_at inclut le changement - probablement un bogue

Ou avec correction de bug, 7 octets

2L%1R@<

Essayez-le ici!

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

Ou après le 2ème bugfix, 6 octets

2L%fhO

Essayez-le ici!

Explication:

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

GolfScript, 11 octets

Il s'agit d'un programme GolfScript complet qui lit un littéral de tableau GolfScript stratifié (par exemple [28 14 7 0]) et imprime le même tableau avec le premier élément impair et tout ce qu'il a supprimé:

~1\{~&.},p;

Essayez-le en ligne. (Aussi: version étendue avec faisceau de test. )

Version dé-golfée avec commentaires:

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

Cette solution est basée sur l' { },opérateur de filtre GolfScript , qui exécute le contenu du bloc de code sur chaque élément d'un tableau et sélectionne les éléments du tableau pour lesquels le code du bloc renvoie une valeur vraie (c'est-à-dire non nulle) sur haut de la pile.

Ainsi, par exemple, {1&},sélectionnerait tous les nombres impairs dans un tableau et {~1&},sélectionnerait tous les nombres pairs. Le défi consiste donc à créer un filtre qui sélectionne les nombres pairs jusqu'à ce qu'il trouve le premier impair , puis ne sélectionne aucun nombre.

La solution que j'ai utilisée est de remplacer le masque de bits constant 1(utilisé pour extraire le bit le plus bas de chaque numéro d'entrée) par une variable sur la pile qui stocke le résultat (0 ou 1) de l'itération de boucle de filtre précédente (et est initialisée à 1 avant la boucle). Ainsi, dès que le filtre renvoie 0 une fois, le masque binaire est également défini sur 0, ce qui empêche le filtre de retourner à nouveau 1.

Forth, 114 octets

Forth n'a pas vraiment de listes. Les paramètres doivent être poussés sur la pile dans l'ordre inverse, comme c'est généralement le cas dans Forth. Le résultat sera laissé sur la pile dans le même ordre. Cela ne fonctionne pas sur Ideone pour une raison quelconque, mais cela fonctionne sur repl. La nouvelle ligne est nécessaire pour lever toute ambiguïté?

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

Essayez-le en ligne

Non golfé, avec commentaires:

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

Ce programme (ma tentative précédente) imprime les résultats jusqu'à ce qu'il atteigne un nombre impair. Tout ce qui reste (non pris) sera laissé sur la pile.

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

Échoue si seulement des entiers pairs

Befunge, 35 octets

Ce code gère les nombres compris entre 0 et 65535

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

Format d'entrée:

number_of_values    values(separated by a space)

Voici une version qui affiche les valeurs à la fin du processus:

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

Vous pouvez tester le code ici , mais vous devrez ajouter une ligne de fin avec des espaces de fin, comme l'indique cette interprétation:

«Le code torus est aussi grand que le programme initial. Insérez plus de lignes ou d'espace de fin si les données seront placées au-delà de la fin du code. »

Je ne sais pas si cela est acceptable, car je n'ai pas compté cette fin dans le nombre d'octets
nb: il semble que parce que je stocke le numéro dans le code, l'interpréteur ne laissera pas ce programme s'exécuter deux fois dans le bon façon. Vous devrez le recharger.

Comment ça marche: L'interprète suit les flèches et saute une instruction lors du passage de '#'

Les points gris sont testés et la ligne rouge supprime les variables inutiles de la pile

En utilisant ici dans l'interpréteur ci-dessus, les valeurs enregistrées sont affichées dans le code en utilisant leurs représentations (je ne connais pas le format). Oui, Befunge est un langage assez réfléchissant