Mettre en place une machine à vérité

148

Une machine à vérité (c'est à ce type qu'il revient de l'avoir inventé) est un programme très simple conçu pour montrer le flux d'E / S et le contrôle du langage. Voici ce qu'une machine à vérité fait:

  • Obtient un numéro (0 ou 1) de STDIN.

  • Si ce nombre est 0, imprimez 0 et terminez.

  • Si ce nombre est 1, imprimez 1 pour toujours.

Défi

Écrivez une machine à vérité comme décrit ci-dessus dans la langue de votre choix. La machine à vérité doit être un programme complet qui suit ces règles:

  • prendre la contribution de STDIN ou une alternative acceptable
    • Si votre langue ne peut pas accepter la saisie de STDIN, elle peut également provenir d’une variable codée en dur ou d’un équivalent approprié dans le programme.
  • doit sortir vers STDOUT ou une alternative acceptable
    • Si votre langue est incapable de sortir les caractères 0ou 1, une entrée / sortie octet ou unaire est acceptable.
  • quand l'entrée est 1, il doit continuellement imprimer 1s et ne s'arrêter que si le programme est tué ou s'il manque de mémoire
  • la sortie ne doit être qu'un 0suivi d'un seul ou d'aucun caractère de nouvelle ligne ou d'un espace, ou un nombre infini de 1s 1suivi de chacun par un ou aucun nouveau caractère ou espace. Aucune autre sortie ne peut être générée, à l'exception d'une sortie constante de l'interprète de votre langue qui ne peut pas être supprimée (message d'accueil, codes de couleur ANSI ou indentation, par exemple). Votre utilisation des nouvelles lignes ou des espaces doit être cohérente: par exemple, si vous choisissez de générer 1une nouvelle ligne après tout, vous 1devez y insérer une nouvelle ligne.

  • si et seulement si votre langue ne peut pas se terminer sur une entrée de 0celle-ci, il est acceptable que le code entre dans une boucle infinie dans laquelle rien n'est sorti.

S'agissant d'un catalogue, les langues créées après ce défi sont autorisées à entrer en compétition. Notez qu'il doit y avoir un interprète pour que la soumission puisse être testée. Il est permis (et même encouragé) d’écrire cet interprète vous-même pour une langue non encore implémentée. En dehors de cela, toutes les règles standard du doivent être respectées. Les soumissions dans la plupart des langues seront notées en octets selon un codage préexistant approprié (généralement UTF-8).

Catalogue

L'extrait de pile au bas de cet article génère le catalogue à partir des réponses a) sous forme de liste des solutions les plus courtes par langue et b) sous forme de classement global.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores en les effaçant. Par exemple:

## Ruby, <s>104</s> <s>101</s> 96 bytes

Si vous souhaitez inclure plusieurs numéros dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou si vous souhaitez répertorier séparément les pénalités d'indicateur d'interprétation), assurez-vous que le score réel est le dernier numéro de l'en-tête:

## Perl, 43 + 2 (-p flag) = 45 bytes

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de code:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

un spaghetto
la source
Peut-on supposer que le programme s’arrête à la fin de l’exécution du code écrit par le processeur, pour une entrée de code machine?
lirtosiast
3
En supposant que tout comportement est correct pour toutes les entrées non valides?
Cruncher
3
@Cruncher Oui, les seules entrées que vous devriez obtenir sont 0 et 1.
un spaghetto
4
Le catalogue est bouché.
Addison Crump
2
Catalogue semble considérer Bfet bfêtre différentes langues.
Mooing Duck

Réponses:

189

Hexagonie , 6 octets

C'était étonnamment délicat, et je ne suis pas convaincu que ce soit optimal ...

<.@!$?

Après avoir rempli et déplié le code, cela représente la grille hexagonale suivante:

entrez la description de l'image ici

Cela utilise un flux de contrôle similaire à celui de mon récent programme de chat sans erreur , qui suit des anti-diagonales. Pour y parvenir, nous commençons par dévier le pointeur d’instruction (IP) vers la gauche, où le chemin violet s’enroule dans le coin inférieur gauche.

?lit l'entrée sous forme d'entier. !l'imprime en retour. .est juste un no-op. Maintenant le coin de la grille agit comme une branche:

Si l'entrée était 0, l'IP continuera le long du chemin rouge, qui termine simplement le programme avec @.

Si l'entrée était 1, l'IP continuera sur le chemin vert. Encore une fois, .c'est juste un non-op, mais $c'est l'équivalent du trampoline de Befunge: il saute l'instruction suivante. Après l’emballage, l’instruction suivante serait le ?, mais en raison de l’ $exécution, elle continue sur le chemin bleu, en commençant par !imprimer une autre copie du fichier 1. Cette boucle qui ne contient que !..$se répète maintenant indéfiniment.

Une étude du flux de contrôle en hexagone ...

Je crois que la solution ci-dessus est optimale. J'ai écrit un test forcé brutal, qui vérifie tous les programmes Hexagony de 6 octets, qui en contiennent au moins un ?!@(ce qui est nécessaire; j'ai également vérifié :et %au lieu de @terminer avec une erreur de division par zéro, mais cela n'a pas aidé non plus). Le chèque imprime tous les programmes qui a) produisent une 0entrée 0et se terminent et b) produisent au moins deux 1s (et rien d’autre) et ne se terminent pas dans les 60 premiers ticks du programme (200 ticks pour des solutions à 5 octets) . Je doute qu'une solution valable prenne plus de 200 ticks pour imprimer correctement la première 0ou la seconde 1sur une grille aussi petite. Je ne pense donc pas avoir manqué de solutions potentielles.

La recherche n'a donné aucun résultat pour 5 octets, mais 57 résultats pour 6 octets (en utilisant @; il n'est pas nécessaire de terminer par une erreur si nous pouvons résoudre ce problème proprement dans le même nombre d'octets). Sur ces 57, seuls 6 étaient des faux positifs qui n’imprimaient en réalité que deux 1secondes puis entraient dans une boucle infinie sans plus imprimer. Une solution a été répertoriée deux fois car elle contenait deux !commandes. Cela laisse exactement 50 solutions valables.

Il existe une certaine dégénérescence entre les solutions où un ou deux caractères ne sont pas substantiels, par exemple parce qu’ils sont de toute façon sans exception. Les solutions peuvent être regroupées en 23 ensembles de programmes véritablement distincts (dans certains cas, il n’ya qu’une différence de caractère entre deux ensembles, mais cela modifie considérablement le flux de contrôle, je les ai donc comptés séparément). Deux des groupes utilisent même plusieurs indicateurs d'instruction de manière très inattendue. Comme je n’aurais jamais trouvé la plupart de ces façons d’utiliser les branches et les miroirs, elles constituent une étude très intéressante sur les types de flux de contrôle possibles dans Hexagony, et j’ai définitivement appris de nouvelles astuces pour les futurs golfs.

Le flux de contrôle global est presque toujours le même: lisez un nombre, imprimez-le. Si c'est le 0moyen de trouver le @, sinon continuez en boucle !tout en conservant une valeur de bord de 1. Il y a quatre exceptions notables:

  • Une solution (celle avec deux !) imprime deux 1s par itération dans la grille, soit environ deux fois plus vite que la majorité des programmes. J'ai marqué celui-ci avec x2ci-dessous.
  • Quelques solutions (celles qui contiennent un o) remplacent le 1avec un 111(le code de caractère de o), de sorte qu’elles impriment trois 1 secondes par itération, leur permettant d’imprimer environ trois fois plus vite que la plupart des programmes. Je les ai marqués avec x3ci-dessous.
  • Deux solutions ajoutent un a 1la valeur du bord à chaque itération (donc 1-> 11-> 111-> ...). Ceux-ci impriment très vite, mais ils finiront par manquer de mémoire. Je les ai marqués avec OoMci-dessous.
  • Deux solutions entrent dans une boucle très serrée qui ne fait que rebondir par-dessus l’ !impression, imprimant tous les tics (au lieu de tous les 5 secondes environ), ce qui les rend légèrement plus rapides (et plus propres). Je les ai marqués avec ><ci-dessous.

Alors voici le zoo entier:

#1                #5                #12                #19
?!/$.@            ?$!>$@            .?!/$@             |!|?$@  # ><
?!/$1@  # OoM     ?$!|$@            =?!/$@
?!/$=@                                                 #20
?!/$\@            #6                #13                $@.?<!
?!/$o@  # x3      ?/!<|@            .?/!$@             $@1?<!  # OoM
?!/$!@  # x2                        =?/!$@             $@=?<!
                  #7                                   $@o?<!  # x3
#2                ?\!<|@            #14
?!>$)@                              \!?__@             #21
?!>$1@            #8                                   _>_!?@
?!>$o@  # x3      ?<!>$@  # ><      #15
?!|$)@                              \_?!$@             #22
?!|$1@            #9                                   <!@.$?
?!|$o@  # x3      ?\$!@$            #16                <!@/$?
                                    \_?!_@             <!@=$?
#3                #10                                  <$@!$?
?!|)$@            ?~#!@)            #17                <.@!$?
?!|1$@            ?~#!@1            $$?\@!             </@!$?
?!|o$@  # x3                                           <=@!$?
                  #11               #18
#4                ?$)\@!            \$?\@!             #23
?_!<@>            ?$1\@!                               <<@]!?
                  ?$o\@!  # x3

Ce qui suit est une courte présentation de quelques groupes plus représentatifs. Les groupes 10 et 23 sont particulièrement intéressants. Il existe de nombreux autres chemins intéressants et parfois compliqués dans les autres groupes, mais je pense que je vous ai assez ennuyé à la fin. Pour ceux qui veulent vraiment apprendre l’hexagone, il convient néanmoins de s’y intéresser, car ils présentent un nombre encore plus grand d’utilisations possibles des miroirs et $.

Groupe 1

Celui-ci n'est pas beaucoup plus élaboré que ma solution d'origine, mais les chemins vont dans des directions différentes. Il permet également le plus grand nombre de variations dans une seule cellule, car le no-op no-op le plus à droite peut être remplacé par 5 commandes différentes, ce qui permet de rendre cette opération valide sans modifier la structure:

entrez la description de l'image ici

Groupe 2

Celui-ci est très intéressant, car il ne se déplace que horizontalement. Après avoir enveloppé à la >, l'IP inverse immédiatement, en prenant la branche dans le coin. Ce n'est pas tout à fait visiblement pas le diagramme, mais dans le cas de la 1nous traversons à nouveau la première ligne, mais à l'envers cette fois. Cela signifie également que nous nous heurtons à ?nouveau, ce qui nous revient maintenant 0(EOF). Ceci est corrigé avec )(incrément) pour continuer à imprimer 1s. Cela a aussi 5 variations, comme cela )pourrait aussi être 1ou o, et >pourrait aussi être |:

entrez la description de l'image ici

Groupe 3

Celui-ci semble presque identique au précédent, mais c'est désordonné. Jusqu'à frapper |puis traverser la rangée du bas ou du haut, c'est la même chose. Mais dans le cas d'une boucle, le $passe maintenant ) sur le miroir. Nous suivons donc le chemin turquoise à droite, maintenant frappé l'incrément, sauter par- dessus l' @avant enrouler autour de la à | nouveau et puis remontons sur le chemin vert en haut.

entrez la description de l'image ici

Groupe 4

Je pensais que celui-ci était particulièrement chouette:

entrez la description de l'image ici

Le _miroir dans le coin supérieur droit est d’abord un no-op, nous imprimons avec !et appuyons sur le <. Le 0chemin frappe maintenant le miroir horizontal et se termine. Le 1chemin prend une trajectoire très intéressante cependant: il dévie vers le bas, enveloppements au !, est redirigé vers l'horizontale et enveloppe puis de nouveau à la ! fois . Il continue ensuite à avancer dans cette forme de losange, en imprimant deux fois par itération (tous les trois tics).

Groupe 8

C'est l'une des deux solutions avec une boucle d'impression très serrée:

entrez la description de l'image ici

Le <agit comme la branche. Après avoir emballé deux fois, 0frappe @. 1d'autre part, saute d'abord le ?, puis l' >envoie à $nouveau, donc saute le @. Ensuite, l’IP s’enroule dans le chemin turquoise, où il rebondit entre le >et <((entourant le bord entre les deux).

Groupe 10

L'un des deux groupes qui utilisent d'autres pointeurs d'instructions, et c'est absolument magnifique. Hexagony en a 6 - chacun part d'un coin différent le long du bord des aiguilles d'une montre, mais un seul d'entre eux est actif à la fois.

entrez la description de l'image ici

Comme d'habitude, on lit avec ?. La ~négation est maintenant unaire: elle transforme le 1en -1. Ensuite, nous avons frappé le #. C'est un moyen de basculer entre les adresses IP: il prend la valeur de front actuelle modulo 6 et bascule sur l'adresse IP correspondante (les adresses IP sont numérotées 0dans le sens des aiguilles d'une montre). Donc, si l’entrée était la suivante 0, l’adresse IP reste simplement la même et se déplace ennuyeusement droit devant elle !@. Mais si l'entrée était 1, alors la valeur actuelle est -1ce qui est 5 (mod 6). Nous passons donc à l’IP qui commence sur la même cellule (le chemin vert). Now #est un no-op et ?définit le bord de la mémoire à 0. )incrémente donc !imprime a 1. Maintenant, nous avons ~encore frappé pour nous assurer que#est toujours un no-op (par opposition à nous passer à IP 1 qui mettrait fin au programme). C'est incroyable de voir à quel point tout concorde dans ce petit programme.

Groupe 22

Il est juste de noter que c’est le groupe dans lequel se trouve ma solution initiale. Il s’agit également du groupe le plus important, car le no-op peut se trouver à deux endroits différents et il existe plusieurs choix pour la commande réelle (no-op effective).

Groupe 23

C'est l'autre groupe qui utilise plusieurs adresses IP. En fait, celui-ci utilise 3 adresses IP différentes. Le coin en haut à droite est un peu en désordre, mais je vais essayer de vous expliquer:

entrez la description de l'image ici

Ainsi, le début que vous avez vu auparavant: <dévie le nord-est, ?lit les entrées. Il ]existe maintenant un autre moyen de changer d’adresse IP: il passe le contrôle à la prochaine adresse IP dans le sens des aiguilles d’une montre. Nous passons donc le contrôle sur le chemin turquoise qui (je sais que c'est difficile à voir) commence dans le coin nord-est en direction du sud-est. Cela se reflète immédiatement <dans le coin sud-est, en direction nord-ouest. Il frappe également le ]donc nous passons à la prochaine adresse IP. C'est le chemin gris qui commence dans le coin est et se dirige vers le sud-ouest. Il imprime l'entrée, puis passe au coin nord-est. <dévie le chemin dans l'horizontale, où il est reflété par l' autre < . Maintenant la main droite<agit comme une branche: si l’entrée était 0, l’IP se déplace vers le nord-est, et encapsule vers le @. Si l'entrée était 1, l'IP se déplace vers le !, enveloppe le le-thand <où il est reflété ... maintenant dans le coin, il retourne vers le !, est dévié par la droite <, reflété par la gauche <et les chemins commencent plus de...

Tout un gâchis, mais un beau gâchis. :)


Diagrammes générés avec l' étonnant HexagonyColorer de Timwi .

Martin Ender
la source
55
whoa. juste whoa.
Conor O'Brien
6
^ d'accord. Tellement cool ...
El'endia Starman
28
Tais-toi et prends mon vote positif!
Mego
7
@ThomasOltmann J'admets que cette réponse suppose des connaissances de base de la langue. Si vous souhaitez réellement en savoir plus à ce sujet, j'ai passé en revue les bases de cette réponse et de cette réponse , mais je ne vous blâmerai pas si vous ne l'êtes pas. ;)
Martin Ender
5
Ouais ... le modèle de mémoire a l'air un peu douloureux (mais toujours meilleur qu'une cassette 1D, je suppose)
John Dvorak
144

Motorola MC14500B Code machine, 2 octets

En hex:

58EC

Explication:

5  OR the register with input from the data bus
8  Write the register to the data bus
E  Skip next instruction if register is zero
C  Jump

Le Motorola MC14500B est un microcontrôleur 1 bit. il possède un registre 1 bit et un bus de données 1 bit. Étant donné que les codes d'opération sont de 4 bits chacun, il n'y en a que 16; la moitié d'entre eux effectuent une opération logique entre le registre et le bit sur le bus de données.

L'instruction de saut définit un drapeau de saut; lorsqu'aucune adresse n'est fournie, il est courant de régler le compteur de programme sur 0. Si le bit d'entrée était à zéro, le processeur ne sautera pas. Si le bit d'entrée était à 1, le processeur revient au début; Puisque nous avons ORune entrée, peu importe le signal d’entrée, le registre sera alors 1 pour toujours.

Comme il est classique, le registre est initialisé à 0.

Une liste des opcodes se trouve sur la fiche technique ou ici .

lirtosiast
la source
7
2 octets est certainement le minimum pour ce défi.
Conor O'Brien
23
@ CᴏɴᴏʀO'Bʀɪᴇɴ Cela fait plusieurs heures que je cherche dans les esolangs et les listes de processeurs 4 bits pour voir s'il existe un 1 ou un 1,5 et n'en ai pas trouvé.
lirtosiast
Certainement le bon outil pour le travail.
Hugo Zink
Link is borked atm ...
TheDoctor
@TheDoctor Les deux liens fonctionnent très bien pour moi
Mego
85

Arnold C, 296 octets

IT'S SHOWTIME
    HEY CHRISTMAS TREE i    
    YOU SET US UP @NO PROBLEMO
    BECAUSE I'M GOING TO SAY PLEASE i
        STICK AROUND i
            TALK TO THE HAND i
        CHILL
    BULLSHIT
        TALK TO THE HAND i
    YOU HAVE NO RESPECT FOR LOGIC
YOU HAVE BEEN TERMINATED

Pas vraiment compétitif, mais pour le plaisir. Ne supporte pas stdin, remplace par @NO PROBLEMOavec @I LIEDune valeur de zéro. @No Problemoest 1.

Exécuter avec (en supposant que le fichier est truthmachine.arnoldc):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine
Supprime moi
la source
46
Magnifique. J'ai pleuré 10/10
un spaghetto
10
BECAUSE I'M GOING TO SAY PLEASELOL
Eric Martinez
8
Cela ressemble if(i){while(i) print(i);} else {print(i);}sûrement à ce que ce serait sûrement plus court print(i);while(i) print(i);?
lirtosiast
16
Bien BULLSHITque contribue grandement à la valeur de divertissement du programme, techniquement, il n’est pas nécessaire. Vous pouvez factoriser toute la BULLSHITbranche en déplaçant TALK TO THE HAND iaprès YOU HAVE NO RESPECT FOR LOGIC.
Gaborsch
4
@GaborSch Il n'y a qu'une réponse appropriée à cela BULLSHIT
:;
65

Minecraft, 18 octets (version MC 15w45a)

esquisse minecraft

Comme vous pouvez le constater, un levier est dirigé vers le bloc de commandes répétitif, qui contient la commande say 1. Il y a une torche d'inversion de signal en plus de celle-ci, qui dirige l'alimentation dans le bloc de commandes à exécution unique contenant la commande say 0.

Chaque fois que le commutateur est orienté vers la vérité, le bloc répéteur utilise le code say 1pour produire une infinité de 1s. Lorsque le levier est redirigé sur false, il en émet un seul 0.

Notez que cela génère un [@]par défaut. Si vous voulez vraiment juste des 1 et des zéros, cela devient 34 octets, où le code dans les blocs de commande sont tellraw @a [1]et tellraw @a [0]. Ceci utilise le nombre d'octets suggéré par @ Cᴏɴᴏʀ O'Bʀɪᴇɴ pour MC, comme on peut le trouver dans Meta .

Addison Crump
la source
28
Vous avez utilisé un jeu vidéo pour le code golf. +1
RK.
11
@RK. C'est en fait une pratique assez standard pour des défis simples. Il y a au moins deux autres utilisateurs qui utilisent MC comme langue de golf - essayez la barre de recherche avec is:answer Minecraft. c:
Addison Crump
1
@FlagAsSpam lol bien fait. Merci également pour cette astuce de recherche des réponses de MC.
Ashwin Gupta
56

Bash + GNU utils, 13

grep 0||yes 1

Bash, 35 ans

read n;for((;n;));{ echo 1;};echo 0
Trauma numérique
la source
3
Vous savez, je me demandais si une solution bash avec oui serait possible ...
un spaghetto
2
Agréable! C'est assez malin
un spaghetto
38

Ruby, 20 ans

print while/1/||gets

Exécuter à partir de la ligne de commande pour éviter les avertissements, comme

ruby -e "print while/1/||gets" <<< 0
ruby -e "print while/1/||gets" <<< 1

Explication:

Moins joué au golf, c’est

while /1/ || gets
  print
end

Lorsqu'une expression rationnelle est utilisée dans une condition, elle est évaluée comme étant falsey sauf si la variable $_est renseignée et correspond au modèle. Lors du premier passage dans la boucle, il $_est vide et nous tombons sur gets, ce qui définit la valeur de $_sur une ligne lue à partir de STDIN. printsans argument imprime $_. Maintenant, nous évaluons à nouveau le conditionnel. Si nous lisons dans 1, nous court-circuitons et imprimons simplement 1 à nouveau, et ainsi de suite. Sinon, nous échouons gets, mais comme il n'y a pas de deuxième ligne d'entrée, getsretourne la valeur nil, la boucle se termine.

histocrate
la source
18
C'est bien quand des tâches triviales permettent toujours des solutions époustouflantes même dans des langages "normaux". :)
Martin Ender
La ||getspartie est cool et tout, mais ne pouvez-vous pas simplement gets;print while/1/sauvegarder et sauvegarder un octet?
daniero
Non, alors il n’imprime pas du tout le 0.
histocrat
37

Microscript, 3 octets

i{p

Le plus court que je connaisse.

Explication:

i  Takes numeric input and puts it in register 1
{  while register 1 is truthy
  p  Print the contents of register 1

Microscript imprime implicitement le registre 1 à la fin, raison pour laquelle une entrée 0est imprimée une fois.

un spaghetto
la source
@quartata je vous ai correspondus: D
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ: O
un spaghetto
2
Je me demande sérieusement si vous avez écrit la question en premier ou la réponse ...
John Dvorak
1
La question. Je voulais juste poster ceci car c'était le plus court que j'ai trouvé en écrivant la question. C'est un catalogue donc il n'y a pas de vrais gagnants.
un spaghetto
36

Code machine de Turing, 32 octets

Utilisation de la syntaxe de la table de règles trouvée ici.

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1
SuperJedi224
la source
J'aime vraiment ça. +1
un spaghetto
Je savais que quelqu'un l'aurait déjà posté!
Mai
25

JavaScript, 28 octets

Les boucles sont souvent plus courtes que les boucles while.

alert(x)renvoie undefined, ce qui est faux, ainsi le bitwise ou l'opérateur |, le jette sur 0. Ainsi, si xest "0", alerte une fois, sinon continuez à boucler. Utilise alertpour STDOUT comme cette réponse .

for(x=prompt();alert(x)|x;);
intrépide
la source
Shoot, vous m'avez battu à ça. J'étais sur le point de poster exactement cela! :) GG
Domino
Wow, c'est un peu plus intelligent que le mien :) Ayez un +1!
ETHproductions
Vous n'avez pas besoin du dernier point-virgule.
Conor O'Brien
@ CᴏɴᴏʀO'Bʀɪᴇɴ Quel navigateur avez-vous utilisé? Je l'ai testé sur Firefox et Chrome et j'obtiens un SyntaxErrorsans.
Intrepidcoder
@intrepidcoder Oh, désolé, mon mauvais. Mon esprit était en mode "les points-virgules sont inutiles". ^^ "
Conor O'Brien
24

Python 2, 29 octets

a=input()
while 1:print a;1/a

Cela se termine par une erreur de division activée 0, autorisée par défaut .

Xnor
la source
La sortie de STDERR est correcte. La réponse> <> l'utilise également.
Un spaghetto
C'est brillant ^ _ ^
ABcDexter
Est-ce que tout en imprimant une œuvre? Désolé, je ne connais pas le python.
Rohan Jhunjhunwala
1
@RohanJhunjhunwala Pour 0, cela n'imprimera rien, mais il devrait l'imprimer une fois.
xnor
1
@xnor oh, mon mauvais.
Rohan Jhunjhunwala
20

Brainfuck, 41 36 31 30 octets

Réduit en imprimant une fois juste après la saisie et avec l'aide d'Ethan et de user46915.

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

Version précédente: Soustrayez 48 de l’entrée, et si elle n’est pas nulle, ajoutez 1 à la 48 pour imprimer ASCII 1définitivement, sinon imprimez 0.

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

Je l'ai exécuté ici , mais en raison d'une sortie en mémoire tampon, vous ne pouvez voir aucune sortie car le programme ne se termine jamais 1.

Edit: j'avais oublié d'imprimer 0en entrée 0. Correction maintenant. J'aime les >.<visages à la fin.

mbomb007
la source
1
@ThomasKwa Je suppose que non, mais je ne suis pas sûr, car je ne vois pas d'algorithme spécifique à Modulo 2. L' algorithme divmod est un peu long.
mbomb007
2
Vous pouvez le raccourcir un peu plus en fusionnant un peu mieux les éléments de code et en utilisant directement votre registre d'entrée au lieu d'avoir un registre "48" séparé:,.[>+>+<<-]-[>-<-----]>+++[>.<]
Ethan
Tentative de solution avec le mod 2. Absolument, la soustraction de 48 est la meilleure solution. ,.[->+>+<<]>>[->[>-<[-]]>+[<+>-]<<]>[<<.>>]
cardboard_box
1
@Ray C'est la valeur par défaut et est généralement assumée. Si j'avais utilisé une autre implémentation, je l'aurais dit.
mbomb007
1
Vous pouvez obtenir un octet supplémentaire en combinant la soustraction et la copie:,.+++[->>+<-----<]>>---<-[>.<]
user46915
19

Piet, 27 18 16 codels

(Codel est un nom sophistiqué pour le pixel utilisé pour éviter la confusion quand une image est étirée pour être visionnée. J'ai compté les codels au lieu d'octets car les scripts de pixels sont sauvegardés en tant qu'images, donc la taille physique peut varier. Je pense qu'un format de fichier idéal qui permettrait d'économiser ce piet aussi efficacement que possible prendrait 11 octets. En pratique, mon petit fichier gif est de 62 octets, avec des données de palette optimales. Dites-moi si je devrais utiliser ceci comme taille de mon entrée au lieu de la quantité de code.)

Image originale: version minuscule

Agrandie: version agrandie

En piet, la différence entre deux couleurs est ce qui détermine la commande exécutée. Voir deux fois la même couleur ne signifie donc pas qu’il fait la même action. L'exécution commence dans le code en haut à gauche. Ensuite, il se déplace horizontalement, en effectuant les opérations suivantes:

  1. Lire un nombre et le mettre sur la pile
  2. Dupliquer le haut de la pile
  3. Pop et sortie en haut de la pile
  4. Pop le haut de la pile et tournez dans le sens des aiguilles d'une montre ce nombre de fois.

Si la valeur est 1, le curseur descend dans le code de chaux, ce qui pousse 1 sur la pile. Ensuite, l'exécution continue en allant à gauche. Lorsque le curseur passe d'une couleur à un blanc et d'un blanc à une couleur, rien ne se produit. Etant donné que le noir est également considéré comme un mur, le curseur revient au code de la chaux sur la ligne supérieure et répète le tout à partir de l'étape 2.

Si, toutefois, l’entrée était 0, le curseur ne descendra jamais et se retrouvera dans le J bleu à droite (jeu de mots voulu, cela en valait la peine), s’il restera bloqué (parce que le haut, droite, gauche et les côtés inférieurs de ce bloc en forme de J sont à côté des codes noirs ou du bord de l’image). Puisque le curseur est pris au piège, l'exécution se termine.

Valeurs inattendues:
si l'utilisateur écrit un autre numéro, il sera toujours imprimé, puis le curseur pivotera plus ou moins de fois en fonction de la valeur.

  • Multiple de 4 ou 0: l'exécution se poursuit horizontalement et se termine.
  • Multiple de 3: Comme il est impossible de monter, le curseur tourne immédiatement dans le sens des aiguilles d'une montre et continue horizontalement, puis se termine.
  • Multiple de 2 et non un multiple de 4: le curseur pivote et commence à se déplacer vers la gauche. Heureusement, cela ne fait que réaliser un tas d'opérations qui n'affectent pas le déroulement du programme et finissent par vider la pile. Lorsqu'une opération ne peut pas être effectuée car la pile est vide, elle est simplement ignorée. Quand il frappe le coin en haut à gauche, le curseur n'a nulle part où aller, mais à nouveau à droite, ce qui redémarre effectivement le programme.
  • Autres valeurs: Le curseur s'abaisse comme s'il le ferait avec 1, ce qui lui fait imprimer 1 pour toujours. Si l’entrée est 5, la sortie sera5111111111111...

Toute valeur non entière terminera le programme. L'exécution continuera normalement, mais toutes les opérations seront ignorées car il n'y a rien dans la pile. D'une certaine manière, le programme ne se bloque jamais - il s'arrête normalement ou tourne en boucle pour toujours.


PietDev version conviviale

PietDev (un Piet IDE en ligne très basique) semble avoir des problèmes avec les codes blancs, j'ai donc créé une nouvelle version qui effectue une rotation manuelle, au lieu de compter sur une rotation automatique des codes blancs appropriée. Et je n'ai même pas eu besoin d'utiliser une nouvelle couleur! Si vous souhaitez tester, veillez à dessiner une bordure noire autour du code, car PietDev ne prend pas en charge les tailles de programme personnalisées.

version minuscule

version agrandie


Versions plus anciennes

La première version n'a pas repoussé 1 sur la pile et a été rebouclée sur une instruction de duplication antérieure. Il y avait aussi des codels décoratifs inutiles.

Petit motif qui est en fait un code piet

Version agrandie

Ensuite, j'ai eu l'idée d'appuyer sur 1 sur la pile pour supprimer la ligne blanche. C'est marrant comme j'y ai pensé grâce à mes codels décoratifs.

version minuscule

grande version

Ensuite, j'ai réalisé que j'avais une duper superflue dont je n'avais plus besoin, et j'ai réduit le nombre de couleurs pour sauvegarder les données de palette dans l'image. Je me suis également débarrassé du code unique décoratif parce que je ne sais pas.

Domino
la source
7
Je n'ai jamais vu une réponse de Piet enregistrée dans autre chose que des codels, mais je pense que le nombre optimal d'octets est également intéressant à inclure :)
undergroundmonorail
1
Il existe 20 valeurs de codel différentes, ce qui signifie que vous devriez pouvoir conditionner trois codels en 13 bits, puis huit triplets en 13 octets pour une densité de stockage de 2,6 codels par octet. Mais quelqu'un doit d'abord définir cette langue. Je suggère le nom DPPi = pied dense.
John Dvorak
1
@ JanDvorak J'ai compté 21 valeurs pour en ajouter une spéciale pour le saut de ligne, et une fois que vous avez le premier saut de ligne, l'analyseur peut deviner où devraient se trouver les autres. Mais je ne suis pas allé aussi loin que la combinaison de codes dans des triplets, ce qui est beaucoup plus logique que de perdre 5 bits par code. Intelligent.
Domino
1
Ajoutez simplement les dimensions en tant que premiers octets. Vous n'avez pas besoin d'un symbole supplémentaire.
John Dvorak
1
@ Tous ceux qui veulent l'essayer: n'essayez pas cette solution avec PietDev, car PietDev n'imprime qu'un seul 1 et se termine. Mais la solution fonctionne correctement avec npiet.
ML
19

Pyth, 4 3 2

Wp

Il y a un non! espace de fuite (merci isaac :)). Auparavant, l'espace requis pour compiler la boucle while était compilé, mais Pyth a depuis été mis à jour. Normalement, cela disqualifierait son utilisation, mais puisqu'il s'agit d'un catalogue, il devrait être valide.

Explication:

Wp        : implicit Q = eval(input)
W         : while
 p        : print and return the value of Q, to be evaluated as the while condition
          : Functions without enough arguments automatically use Q now
          : do nothing in the body of the while loop
FryAmTheEggman
la source
5
Cette réponse m'a inspiré pour ajouter implicite passà Pyth. L'espace est maintenant inutile. pyth.herokuapp.com/?code=WpQ&input=0&debug=0
isaacg
52
Le croisement de quatre ressemble toujours à un quatre.
Conor O'Brien
1
Euh, je commence à en avoir tellement marre de voir pyth dominer tout le temps :(. LOL.
Ashwin Gupta
1
@AshwinGupta, ma langue a battu techniquement, donc ce n'est pas complètement dominant :)
Cyoce
@ Cyoce ouais! Bon travail! Je suis assuré que quelque chose peut battre pyth lol.
Ashwin Gupta
16

Puce , 6 octets

e*faAs

Chip est un langage 2D qui se comporte un peu comme un circuit intégré. Il prend en entrée, un octet à la fois, et sépare les bits en éléments d’entrée individuels. Output coud les valeurs des éléments de sortie en octets.

Décomposons ceci:

*est un signal source, il enverra une valeur vraie à tous les éléments adjacents. eet fcorrespondent aux cinquième et sixième bits de la sortie. Donc, e*fproduit binaire 00110000, qui est le caractère ASCII "0".

Maintenant, Aest le premier bit d'entrée et ale premier bit de sortie, donc aAcopie ce bit d'entrée à sortie. Ainsi, lorsque combiné avec e*f, une entrée ASCII "0" produit "0" et "1" produit "1". (Il n'y a pas d'interaction entre fet a, car aucun ne produit de signal.)

A sla fin, lorsqu'il est activé par un signal vrai, empêchera l'entrée de passer à l'octet suivant, ce qui signifie que tout fonctionnera à nouveau avec la même entrée.

Étant donné que le premier octet de "0" est zéro, il n'active pas cet élément et le programme imprimera "0", épuisant ainsi son entrée, ce qui lui permet de se terminer. "1", cependant, active cet élément, ce qui signifie que "1" est sorti, mais pas consommé sur l'entrée, permettant ainsi au cycle de se répéter indéfiniment.

Si les valeurs 0x0 et 0x1 sont utilisées pour la sortie plutôt qu'ASCII, nous pouvons éliminer la e*fpartie, ce qui donne seulement 3 octets :

aAs

Si le zéro doit se terminer lui-même, plutôt que de s'attendre à la fermeture de stdin, nous obtenons ce qui suit, qui inverse le premier octet avec ~et transmet le résultat à tqui termine le programme ( 10 octets ):

aA~te*f
 s

( tne produit également aucun signal, il n'y a donc pas d'interaction entre tet e.)

Phlarx
la source
2
Bonne réponse! Comme il s’agit d’un défi de catalogue, il n’est pas nécessaire de le marquer comme non compétitif, j’ai donc supprimé ce bit pour vous. Bienvenue chez PPCG!
Mego
4
J'ai pris la liberté d'ajouter Chip à TIO. Essayez-le en ligne!
Dennis
@Dennis, question pour vous: comment pourrais-je obliger TIO à mettre à jour son source? La semaine dernière, j'ai corrigé un bogue dans l'interpréteur Chip, mais celui-ci n'a pas propagé le changement dans TIO. Est-ce quelque chose que je dois demander à quelqu'un de faire pour moi?
Phlarx
J'ai tiré Chip. Si vous avez besoin d’une mise à jour, laissez un message sur talk.tryitonline.net .
Dennis
14

Brainbool , 5 octets

,.[.]

Brainbool est Brainfuck, mais il ne fonctionne que sur les bits, et effectue les entrées / sorties 0et les 1caractères.

lirtosiast
la source
3
Je savais qu'il devait y avoir un dérivé de BF où cela pourrait être fait de manière pratique.
Un spaghetto
14
Je pense que "Boolfuck" pourrait être un meilleur nom, mais bien joué quand même.
James Murphy
2
@JamesMurphy il semble que cela existe déjà: esolangs.org/wiki/Boolfuck
DLeh
13

LOLCODE, 119 octets

GIMMEH n
n R SUM OF n AN 0
BOTH SAEM n AN 0, O RLY?
YA RLY
 VISIBLE 0
NO WAI
 IM IN UR l
  VISIBLE 1
 IM OUTTA UR l
OIC

Ungolfed:

HAI

BTW, Read n as a string from STDIN and convert to an integer
GIMMEH n
n R SUM OF n AN 0

BTW, Test n for equality with 0
BOTH SAEM n AN 0, O RLY?
YA RLY
    BTW, Write 0 to STDOUT and exit
    VISIBLE 0
NO WAI
    BTW, Loop forever, printing 1
    IM IN YR l
        VISIBLE 1
    IM OUTTA YR l
OIC

KTHXBYE
Alex A.
la source
1. Quel interprète utilisez-vous? 2. Pouvez-vous MAEK n A NUMBRlancer? 3. Pouvez-vous utiliser DIFFRINTau lieu de BOTH SAEMet changer les conditionnels?
lirtosiast
@ThomasKwa J'utilisais LOLCOFFEE, celui sur repl.it. (Ce qui semble être en panne pour le moment, je vais donc tester vos suggestions une fois qu'elle sera rétablie.)
Alex A.
Ne O RLY?jette pas au booléen?
Leaky Nun
@ LeakyNun Non ...? O RLY?est comme un postfixe if.
Alex A.
12

C, 37 octets

Une autre façon de procéder en C.

main(c){for(gets(&c);putchar(c)&1;);}

cLa valeur par défaut est un intde valeur 1. gets(&c)obtient une chaîne de stdin, ici engloutissant la valeur de c, de façon hackishly puisque cn'est pas un char*. putchar(c)imprime la valeur cà stdout, et retourne c. Comme '0'est 48 et '1'49 en ASCII, nous pouvons utiliser le dernier bit ( &1) pour déterminer lequel il s’agit. Si c'est le cas '0', la boucle se rompt. Sinon, ça va pour toujours.

Compile (avec un avertissement à propos de gets) et fonctionne sous gcc-4.8Linux.

cbojar
la source
2
Vraisemblablement, cela ne fonctionne que sur les architectures little-endian.
Neil
@ Neil je suppose donc.
cbojar
@Neil Endianness n'affecte que l'ordre des octets dans les valeurs multi-octets.
LegionMammal978
1
@ LegionMammal978 utilise par cdéfaut une intvaleur représentant une valeur multi-octets. Sur une architecture big-endian, getsle mauvais octet est défini.
Neil
11

Labyrinthe , 7 octets

 ?+
@!:

Labyrinth est un langage basé sur la pile 2D où le contrôle dépend du signe de l’élément supérieur de la pile, vérifié après chaque instruction. L'exécution commence à se déplacer vers la droite à partir de la première instruction valide de la rangée supérieure, qui est la suivante ?.

Les instructions pertinentes sont:

?      Input integer
+      Add top two elements (Labyrinth's stack has infinite 0s on the bottom)
:      Duplicate top element
!      Output as number
@      Terminate program

Si l'entrée est 0, l'adresse IP lit avec ?, ajoute les deux premiers de la pile ( 0 + 0 = 0), puis duplique :et génère !un 0. Ici, nous rencontrons l'unique jonction du programme et nous devons vérifier le haut de la pile pour déterminer où aller. Puisque le sommet est 0, on avance et on termine avec @.

Par contre, si l’entrée est 1, on fait la même instruction qu’auparavant (mais on émet un 1) avant d’atteindre la jonction au !. Maintenant, le sommet de la pile est positif, nous obligeant à tourner à droite dans le ?. Sur EOF Labyrinth pousse 0, nous faisons donc 0 + 1 = 1à la +duplication :et à la sortie !. Encore une fois, nous avons un 1 en haut de la pile et la boucle continue.

Pour un bonus, voici la solution à 7 octets de @ MartinBüttner, qui fonctionne de la même manière:

?+!@
1!

Notez que, contrairement à la plupart des langues, 1apparaît en fait nla pile et pousse n*10 + 1, ce qui rend l'édification d' un grand nombre facile. Cependant, comme le haut de la pile est vide à ce stade, il n’ya pas de différence en poussant 1.

Sp3000
la source
10

> <> , 7 octets

i2%:n:,

Ceci utilise le fait que> <> pousse -1 sur EOF, ce qui correspond à 1 mod 2. Il utilise également la division par 0 pour la terminaison (ce qui est apparemment correct puisque le consensus est que la sortie de STDERR est ignorée).

Juste pour référence, quitter proprement sans erreurs est un octet supplémentaire:

i2%:n?!;
Sp3000
la source
10

APL, 6 octets

→⎕←⍣⍲⎕

Explication:

     ⎕ Read the input, then
 ⎕←    write it out
   ⍣   repeatedly
    ⍲  until NAND of it with itself becomes true.
→      Branch to zero to avoid printing the result again.
utilisateur46915
la source
1
Les deuxième et dernier personnages sont-ils supposés être différents? Parce qu'ils ne le font pas pour moi.
John Dvorak
@ JanDvorak Nope, ils sont les mêmes.
Alex A.
1
OK, maintenant je le regarde sur mobile et tout sauf les deux flèches me ressemble :-D
John Dvorak
10

Brian & Chuck , 21 octets

,}<-{-?<SOH>_{+?
_>+{?<.p

Ici, <SOH>doit être remplacé par le caractère de contrôle correspondant (0x01).

Explication

L'idée de base est de soustraire le code de caractère de l'entrée (48 ou 49) de la pfin de Chuck, ce qui donnera soit un ?(qui est une commande valide), soit @un non-op.

,lit le caractère saisi dans la première cellule de Chuck (marqué d'un _). Nous voulons décrémenter cette valeur 0dans une boucle, tout en apportant d'autres modifications:

}<se déplace vers le pet le -décrémente. Ensuite , {se déplace à la cellule d'entrée -décrémente aussi. Tant que ce n'est pas encore zéro, ?donne le contrôle à Chuck. Déplace maintenant >la tête de bande de Brian d'une cellule à droite (qui est initialisée à 1) et l' +incrémente. Ensuite, nous réinitialisons la boucle avec {?.

Au moment où la première cellule sur Chuck arrive 0, la <SOH>cellule aura été incrémentée dans le caractère que nous avons lu à partir de STDIN et psera utilisée ?pour la saisie 1ou @pour la saisie 0.

Maintenant ?ne change plus de contrôle. Le 0ou 1après c'est un no-op, tout comme le null-byte (représenté par _). {revient à la première cellule de Chuck et +s'incrémente pour s'assurer qu'elle est positive, de sorte que les ?mains contrôlent Chuck.

Cette fois, >+la cellule est incrémentée après la fin de la bande initiale de Brian. Cette cellule est une poubelle, mais nous ne l'utilisons jamais. Maintenant {ne numérise pas tout le chemin à l'avant de la bande de Brian, mais seulement à la _. C'est ?donc un non-fonctionnement car la cellule actuelle est à zéro. Puis <.déplace un vers la gauche (la copie du caractère saisi) et l’imprime.

Enfin, nous rencontrons le ?ou @. Si l'entrée était 0et que cette cellule est, @c'est un no-op et le programme se termine. Mais si l’entrée était 1et que cette cellule était, ?nous passions à Brian {+?qui réinitialiserait la boucle sur Chuck, et maintenant nous imprimons à 1jamais (jusqu’à ce que le nombre entier dans la cellule à la fin de la bande de Brian ne tienne dans la mémoire) plus, je suppose ...).

Prime

Sp3000 et moi jouons au golf depuis plusieurs jours. Nous avons commencé à environ 40 octets et sommes arrivés à deux solutions complètement différentes, mais liées à 26 octets. Ce n'est que lorsque j'ai commencé à rédiger l'explication pour la mienne que la solution à 21 octets ci-dessus m'est apparue. Un grand merci à Sp pour avoir échangé des idées et appris les uns des autres certaines astuces de golf dans B & C. :)

Voici sa solution à 26 octets:

>,----{?{>1?0
#I<?_}<.<<<?

Et voici le mien:

,{>-<-?_0+?_1{<?
_®{?_{>.?

®est un octet de valeur 174 (par exemple, enregistrez simplement le fichier en tant que ISO 8859-1).

À la mine principale fonctionne de la même manière que la solution à 21 octets, en ce sens que cela ®devient }une entrée 1et ~(sans opération) une entrée 0, mais l’exécution est beaucoup moins élégante.

Sa solution est tout à fait intéressante en ce sens que le code source est uniquement ASCII et qu’il ne nécessite pas de boucle pour traiter l’entrée. Au lieu de cela, se ----transforme 1en -et 0en ,(une non-opération pour Chuck). Cela -transformera ensuite le premier ?contenu sur la bande de Brian en un >flux de contrôle différent pour le cas 1.

Martin Ender
la source
10

Balise cyclique binaire , 3 bits ou <1 octet

Bitwise Cyclic Tag est l’un des langages les plus simples de Turing-complete. Cela fonctionne avec deux chaînes de bits, le programme et les données . Les bits du programme sont lus cycliquement et interprétés comme suit:

  • 0: Supprimer le premier bit de données (et le sortir, dans les implémentations qui ont une sortie).
  • 1x: Si le premier bit de données est 1, ajoutez x(représentant un 0ou ou 1) à la fin des données. (Si le premier bit de données est 0, ne faites rien.)

Le programme s'exécute jusqu'à ce que la chaîne de données soit vide.

Machine à vérité

110

Lorsque la chaîne de données est définie sur 0:

  • 11n’ajoute rien car le premier bit de données n’est pas 1.
  • 0supprime / affiche 0.
  • La chaîne de données est maintenant vide et le programme s’arrête.

Lorsque la chaîne de données est définie sur 1:

  • 11ajoute a 1.
  • 0supprime / affiche 1.
  • La chaîne de données est revenue à un seul fichier 1et le programme est revenu à son point de départ.
DLosc
la source
9

GNU sed, 10

:;/1/{p;b}

Explication

  • : définir une étiquette sans nom
  • /1/Si l'entrée correspond à l'expression régulière 1, alors
  • p imprimer l'espace motif (c.-à-d. 1)
  • b et revenir à l'étiquette sans nom (pour toujours)
  • Si l'entrée n'était pas 1 (c'est-à-dire 0), l'espace du motif est imprimé sans modification et le programme se termine.
Trauma numérique
la source
Supprimez 1 caractère en utilisant :;p;/1/bet le drapeau n , pour un total de 9 octets. Puisque sed -fest utilisé de toute façon pour exécuter le fichier de script, l'ajout de cet indicateur supplémentaire ne nécessite pas 2 octets.
Seshoumara
9

Sérieusement , 4 3 octets

4 barré est toujours 4 :(

,W■

,lit une valeur de STDIN. Wdémarre une boucle qui s'exécute alors que la valeur au sommet de la pile est vérité, avec le corps . imprime l’élément de pile supérieur sans éclater. La boucle est implicitement fermée à EOF.

A l'entrée de 0, la boucle ne s'exécute jamais (car 0is falsey), et le programme se termine à EOF, sautant et imprimant automatiquement toutes les valeurs de la pile. En entrée de la 1(ou toute valeur qui ne soit pas 0, ""ou []), la boucle fonctionne en continu.

En réalité , l'interlignage ,n'est pas nécessaire (grâce à la saisie implicite), ce qui ramène le score à 2 octets.

Mego
la source
8

Jeudi, 34 octets

1::=12
2::=~1
0::=~0
@::=:::
::=
@

Explication:

1::=12 Les instances de la sous-chaîne "1" peuvent devenir "12"

2::=~1 Les instances de la sous-chaîne "2" peuvent être supprimées, en imprimant "1"

0::=~0 Les instances de la sous-chaîne "0" peuvent être supprimées, en affichant "0"

@::=::: Les instances de la sous-chaîne "@" peuvent être remplacées par des chaînes de l'entrée

::= Fin de la liste des règles de substitution

@ La chaîne initiale est "@"

SuperJedi224
la source
8

Arnold C, 134 octets

IT'S SHOWTIME
HEY CHRISTMAS TREE i
YOU SET US UP 0         //or 1
STICK AROUND i
TALK TO THE HAND 1
CHILL
TALK TO THE HAND 0
YOU HAVE BEEN TERMINATED

Bien que ce ne soit pas aussi divertissant que l’autre réponse d’ ArnoldC , il joue au golf . Par exemple, l'indentation n'est pas nécessaire, de même que les macros @NO PROBLEMOet @I LIED.

Testé avec cette version du langage , qui ne peut pas prendre en entrée.

lirtosiast
la source
8

Cubix , 5 à 6 octets

Cubix est le nouveau langage bidimensionnel @ETHproductions dans lequel les commandes sont encapsulées autour des faces d’un cube. Interprète en ligne Merci à @ETHproductions pour les économies réalisées.

!I\@O

Cela finit par s'étendre au cube

  !
I \ @ O
  .

Cela commence par la Icommande. Entrez un entier sur la pile.
\, redirige le pointeur d’instruction vers le bas sur le no op.
O, affiche la valeur numérique top of stack.
!, ignore la commande suivante ( @) si top of stack true. Cela fera sauter la \redirection si 1
\, redirige le pointeur d'instruction vers le @programme d'exit.

Cela tire parti du fait que la pile n’éclate pas la pile O ? !.

MickyT
la source
Agréable. Je suis vraiment content de voir quelqu'un d'autre utiliser mon langage :) J'ai une autre solution de 6 octets qui utilise seulement 5 instructions (plus une instruction non-op), alors je vais peut-être poster ça.
ETHproductions
@ETHproductions l'affiche à coup sûr. Je pense que vous avez une langue prometteuse ici :)
MickyT
Vous pouvez sauvegarder un octet en supprimant le ?et en utilisant simplement !:!I\@O
ETHproductions
@ETHproductions very nice
MickyT
1
J'ai écrit une brute-forceur pour cela (avertissement: gèle votre navigateur pendant une minute ou deux), qui vient avec exactement cinq solutions 5 octets: @IOw!, @I?Ov, @!IOw, !IOW@,!I\@O
ETHproductions
7

Foo , 6 octets

&1($i)

Le deuxième caractère est codé en dur car Foo n’a pas d’entrée STDIN. Ne sommes-nous pas d'accord pour dire que Foo est génial maintenant? :)

Explication

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int
Sp3000
la source
2
J'ai toujours aimé Foo.
un spaghetto
7

Perl, 18 + 1 = 19 13 + 1 = 14 octets

print while$_

Courez comme ça:

echo -n NUM | perl -p truth.pl

Merci à ThisSuitIsBlackNot (qui est bien meilleur que moi au golf Perl) pour avoir joué au golf cinq octets.

un spaghetto
la source
2
Les modificateurs de déclaration sont vos amis! De plus, si vous vous assurez que l'entrée n'a pas de fin de nouvelle ligne, vous pouvez supprimer +0: echo -n 0 | perl -pe'print while$_'(13 octets + 1 pour -p). perl -M5.010 -pe'say while$_'serait encore plus court, mais cela aboutit à des sauts de lignes incohérents entre 0 et 1.
ThisSuitIsBlackNot
@ThisSuitIsBlackNot Ah-ha! J'ai essayé d'imprimer avec $ _ mais je ne pouvais pas comprendre pourquoi cela ne fonctionnait pas. Je n'avais pas réalisé que vous ne pouviez pas avoir la fin de ligne sur l'entrée.
un spaghetto
Oui, la chaîne 0est false mais 0+ newline est true. Voir perldoc perlsyn.
ThisSuitIsBlackNot
2
sayest plus court, même si vous comptez -Ecomme un octet supplémentaire.
Dennis
2
@Dennis ... que je viens de réaliser peut être corrigé avec -l: perl -lpE 'say while$_'(11 octets + 2 pour -lp).
ThisSuitIsBlackNot
7

> <> , 6 octets

::n?!;

Pousse l'entrée sur la pile pour commencer

:        copy top element on stack
 :       copy top element on stack again
  n      pop and outputs top element
   ?     condition trampoline - pops top element, if it is zero skips next instruction
    !    trampoline skips next instruction
     ;   finish execution
Blake Lockley
la source
1
Chez PPCG, nous aimons nos explications. +1
un spaghetto
3
Je suis presque sûr que cela ne fonctionne qu'avec les entrées littérales 0 et 1, alors que c'est supposé fonctionner avec 48 ( '0') et 49 ( '1'). Est-ce que je me trompe?
undergroundmonorail
@quartata Si c'était moi, je dirais que, pour être juste envers toutes les réponses qui utilisent des méthodes plus traditionnelles pour obtenir des entrées, vous devriez avoir à mettre 48 ou 49 sur la pile. C'est votre défi cependant et ce n'est pas une affaire énorme de toute façon alors ¯ \ _ (ツ) _ / ¯
undergroundmonorail
2
Cela pose un autre problème: si la pile est pré-remplie, vous devez ajouter 3 octets pour le -vdrapeau.
El'endia Starman
1
@Aaron: Pour ce que ça vaut, j'ai aussi pensé que c'était 2 octets -v, alors j'ai été corrigé. Donc, vous n'êtes pas le seul. :)
El'endia Starman