Una máquina de la verdad (los créditos son para este tipo por haberlo inventado) es un programa muy simple diseñado para demostrar las E / S y controlar el flujo de un lenguaje. Esto es lo que hace una máquina de la verdad:

• Obtiene un número (0 o 1) de STDIN.

• Si ese número es 0, imprima 0 y termine.

• Si ese número es 1, imprima 1 para siempre.

Desafío

Escriba una máquina de la verdad como se describió anteriormente en su idioma de elección. La máquina de la verdad debe ser un programa completo que siga estas reglas:

• recibir información de STDIN o una alternativa aceptable
  • Si su idioma no puede recibir información de STDIN, puede recibir información de una variable codificada o equivalente adecuado en el programa
• debe salir a STDOUT o una alternativa aceptable
  • Si su idioma es incapaz de emitir los caracteres 0o 1, el byte o la E / S unaria es aceptable.
• cuando la entrada es 1, debe imprimir continuamente 1s y solo detenerse si el programa se cierra o se queda sin memoria

• la salida solo debe ser 0seguida por una o sin nueva línea o espacio, o infinitos 1con cada uno 1seguido de una o sin nueva línea o espacio. No se puede generar otra salida, excepto la salida constante del intérprete de su idioma que no se puede suprimir (como un saludo, códigos de color ANSI o sangría). El uso de nuevas líneas o espacios debe ser coherente: por ejemplo, si elige generar 1una nueva línea después de todo 1, debe tener una nueva línea después de ellos.

• si y solo si su idioma no puede terminar en una entrada de 0él, es aceptable que el código entre en un bucle infinito en el que no se emite nada.

Como se trata de un catálogo, los idiomas creados después de este desafío pueden competir. Tenga en cuenta que debe haber un intérprete para que se pueda probar el envío. Está permitido (e incluso alentado) escribir este intérprete usted mismo para un lenguaje previamente no implementado. Aparte de eso, se deben obedecer todas las reglas estándar del golf de código . Las presentaciones en la mayoría de los idiomas se puntuarán en bytes en una codificación preexistente apropiada (generalmente UTF-8).

Catalogar

El Fragmento de pila al final de esta publicación genera el catálogo a partir de las respuestas a) como una lista de la solución más corta por idioma yb) como una tabla de clasificación general.

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

## Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

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

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento:

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

<style>body { text-align: left !important} #answer-list { padding: 10px; width: 290px; float: left; } #language-list { padding: 10px; width: 320px; float: left; } table thead { font-weight: bold; } table td { padding: 5px; }</style><script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script> <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"> <div id="language-list"> <h2>Shortest Solution by Language</h2> <table class="language-list"> <thead> <tr><td>Language</td><td>User</td><td>Score</td></tr> </thead> <tbody id="languages"> </tbody> </table> </div> <div id="answer-list"> <h2>Leaderboard</h2> <table class="answer-list"> <thead> <tr><td></td><td>Author</td><td>Language</td><td>Size</td></tr> </thead> <tbody id="answers"> </tbody> </table> </div> <table style="display: none"> <tbody id="answer-template"> <tr><td>{{PLACE}}</td><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table> <table style="display: none"> <tbody id="language-template"> <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr> </tbody> </table><script>var QUESTION_ID = 62732; var ANSWER_FILTER = "!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe"; var COMMENT_FILTER = "!)Q2B_A2kjfAiU78X(md6BoYk"; var OVERRIDE_USER = 12012; var answers = [], answers_hash, answer_ids, answer_page = 1, more_answers = true, comment_page; function answersUrl(index) { return "https://api.stackexchange.com/2.2/questions/" + QUESTION_ID + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER; } function commentUrl(index, answers) { return "https://api.stackexchange.com/2.2/answers/" + answers.join(';') + "/comments?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + COMMENT_FILTER; } function getAnswers() { jQuery.ajax({ url: answersUrl(answer_page++), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { answers.push.apply(answers, data.items); answers_hash = []; answer_ids = []; data.items.forEach(function(a) { a.comments = []; var id = +a.share_link.match(/\d+/); answer_ids.push(id); answers_hash[id] = a; }); if (!data.has_more) more_answers = false; comment_page = 1; getComments(); } }); } function getComments() { jQuery.ajax({ url: commentUrl(comment_page++, answer_ids), method: "get", dataType: "jsonp", crossDomain: true, success: function (data) { data.items.forEach(function(c) { if (c.owner.user_id === OVERRIDE_USER) answers_hash[c.post_id].comments.push(c); }); if (data.has_more) getComments(); else if (more_answers) getAnswers(); else process(); } }); } getAnswers(); var SCORE_REG = /<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/; var OVERRIDE_REG = /^Override\s*header:\s*/i; function getAuthorName(a) { return a.owner.display_name; } function process() { var valid = []; answers.forEach(function(a) { var body = a.body; a.comments.forEach(function(c) { if(OVERRIDE_REG.test(c.body)) body = '<h1>' + c.body.replace(OVERRIDE_REG, '') + '</h1>'; }); var match = body.match(SCORE_REG); if (match) valid.push({ user: getAuthorName(a), size: +match[2], language: match[1], link: a.share_link, }); else console.log(body); }); valid.sort(function (a, b) { var aB = a.size, bB = b.size; return aB - bB }); var languages = {}; var place = 1; var lastSize = null; var lastPlace = 1; valid.forEach(function (a) { if (a.size != lastSize) lastPlace = place; lastSize = a.size; ++place; var answer = jQuery("#answer-template").html(); answer = answer.replace("{{PLACE}}", lastPlace + ".") .replace("{{NAME}}", a.user) .replace("{{LANGUAGE}}", a.language) .replace("{{SIZE}}", a.size) .replace("{{LINK}}", a.link); answer = jQuery(answer); jQuery("#answers").append(answer); var lang = a.language; lang = jQuery('<a>'+lang+'</a>').text(); languages[lang] = languages[lang] || {lang: a.language, lang_raw: lang.toLowerCase(), user: a.user, size: a.size, link: a.link}; }); var langs = []; for (var lang in languages) if (languages.hasOwnProperty(lang)) langs.push(languages[lang]); langs.sort(function (a, b) { if (a.lang_raw > b.lang_raw) return 1; if (a.lang_raw < b.lang_raw) return -1; return 0; }); for (var i = 0; i < langs.length; ++i) { var language = jQuery("#language-template").html(); var lang = langs[i]; language = language.replace("{{LANGUAGE}}", lang.lang) .replace("{{NAME}}", lang.user) .replace("{{SIZE}}", lang.size) .replace("{{LINK}}", lang.link); language = jQuery(language); jQuery("#languages").append(language); } }</script>

Hexagonía , 6 bytes.

Esto fue sorprendentemente complicado, y no estoy convencido de que sea óptimo ...

<.@!$?

Después de rellenar y desplegar el código, esto representa la siguiente cuadrícula hexadecimal:

Esto utiliza un flujo de control similar al de mi reciente programa de gato libre de errores , que se mueve a lo largo de antiagoniales. Para lograr eso, comenzamos desviando el puntero de instrucción (IP) hacia la izquierda, donde el camino púrpura se envuelve hacia la esquina inferior izquierda.

?lee la entrada como un entero. !lo imprime de nuevo. .es solo un no-op. Ahora la esquina de la cuadrícula actúa como una rama:

Si la entrada fue 0, la IP continuará a lo largo de la ruta roja, que simplemente termina el programa con @.

Si la entrada fue 1, la IP continuará en el camino verde. De nuevo, .es solo un no-op, pero $es el equivalente del trampolín de Befunge: omite la siguiente instrucción. Después del ajuste, la siguiente instrucción sería ?, pero debido a la $ejecución, en realidad continúa en la ruta azul, comenzando con la !impresión de otra copia del archivo 1. Este ciclo que solo contiene !..$ahora se repite indefinidamente.

Un estudio del flujo de control en Hexagony ...

Creo que la solución anterior es óptima. He escrito un forzador bruto, que verifica todos los programas de Hexagonía de 6 bytes, que contienen al menos uno de cada uno ?!@(que son necesarios; También he verificado :y %en lugar de @terminar con un error de división por cero, pero eso tampoco ayudó). La verificación imprime todos los programas que a) producen una 0entrada 0y terminan yb) producen al menos dos 1s (y nada más) y no terminan dentro de los primeros 60 ticks del programa (200 ticks para soluciones de 5 bytes) . Dudo que cualquier solución válida requiera más de 200 ticks para imprimir correctamente la primera 0o la segunda 1en una cuadrícula tan pequeña, así que no creo que me haya perdido ninguna solución potencial.

La búsqueda no arrojó ningún resultado para 5 bytes, pero 57 resultados para 6 bytes (usando @; no hay necesidad de terminar con un error si podemos resolver esto limpiamente en la misma cantidad de bytes). De esos 57, solo 6 eran falsos positivos que en realidad imprimieron solo dos 1sy luego entraron en un bucle infinito sin imprimir más. Una solución se enumeró dos veces porque contenía dos !comandos. Eso deja exactamente 50 soluciones válidas.

Hay una cierta cantidad de degeneración entre las soluciones donde uno o dos caracteres no son sustanciales, por ejemplo, porque de todos modos son efectivamente no operativos. Las soluciones se pueden agrupar en 23 conjuntos de programas genuinamente distintos (en algunos casos, solo hay una única diferencia de caracteres entre dos conjuntos, pero cambia sustancialmente el flujo de control, por lo que los he contado por separado). Dos de los grupos incluso utilizan múltiples punteros de instrucción de una manera muy inesperada. Como nunca habría ideado la mayoría de estas formas de usar las ramas y los espejos, hacen un estudio muy interesante sobre qué tipos de flujo de control son posibles en Hexagony, y definitivamente he aprendido algunos trucos nuevos para futuros campos de golf.

El flujo de control general es casi siempre el mismo: lea un número, imprímalo. Si se trata de 0encontrar una forma de hacerlo @, si no, sigue recorriendo el !tiempo mientras mantienes un valor de borde de 1. Hay cuatro excepciones notables:

• Una solución (la que tiene dos !) imprime dos 1s por iteración a través de la cuadrícula, por lo tanto, imprime aproximadamente el doble de rápido que la mayoría de los programas. He marcado este con x2abajo.
• Algunas soluciones (las que contienen un o) reemplazan el 1con a 111(el código de carácter de o), por lo que imprimen tres 1 s por iteración, lo que hace que impriman aproximadamente tres veces más rápido que la mayoría de los programas. Los he marcado con x3abajo.
• Dos soluciones anexar una 1con el valor de punta en cada iteración (por lo que 1-> 11-> 111-> ...). Esos imprimen muy rápido, pero eventualmente se quedarán sin memoria. Los he marcado con OoMabajo.
• Dos soluciones entran en un bucle muy cerrado que simplemente rebota hacia adelante y hacia atrás !, imprimiendo en cada tictac (en lugar de cada 5 o más o menos), lo que las hace un poco más rápidas (y más ordenadas). Los he marcado con ><abajo.

Así que aquí está todo el zoológico:

#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

El siguiente es un breve recorrido para un puñado de los grupos más representativos. Especialmente los grupos 10 y 23 valen la pena echarle un vistazo. Hay muchos otros caminos interesantes y a veces complicados en los otros grupos, pero creo que ya te aburrí lo suficiente al final de esto. Para cualquiera que realmente quiera aprender Hexagony, definitivamente vale la pena investigarlos, ya que exhiben aún más usos posibles de los espejos y $.

Grupo 1

Esta no es mucho más elaborada que mi solución original, pero los caminos van en diferentes direcciones. También permite la mayor cantidad de variaciones en una sola celda, ya que el no-op más a la derecha se puede reemplazar con 5 comandos diferentes que aún lo hacen válido sin cambiar la estructura:

Grupo 2

Este es bastante interesante, porque solo se mueve horizontalmente. Después de ajustarse al >, la IP se invierte inmediatamente, tomando la rama en la esquina. No es del todo visible el diagrama, pero en el caso de 1que recorramos la primera fila de nuevo, pero esta vez hacia atrás. Esto también significa que nos encontramos ?nuevamente, que ahora regresa 0(EOF). Esto se arregla con )(incremento) para seguir imprimiendo 1s. Esto también tiene 5 variaciones, como )también podría ser 1o o, y >también podría ser |:

Grupo 3

Este parece casi idéntico al anterior, pero es desordenado como el infierno. Hasta golpear |y luego atravesar la fila inferior o superior es lo mismo. Pero en el caso de un bucle, el $ahora salta el ) en el espejo. Entonces seguimos el camino turquesa hacia la derecha, ahora tocamos el incremento, saltamos el @antes de pasar al de | nuevo y luego volvemos al camino verde en la parte superior.

Grupo 4

Pensé que este era particularmente ingenioso:

El _espejo en la esquina superior derecha es inicialmente no operativo, por lo que imprimimos con !y presionamos el botón <. El 0camino ahora golpea el espejo horizontal y termina. Sin 1embargo, el camino toma una trayectoria realmente interesante: se desvía hacia abajo, se envuelve !hacia la horizontal, se redirige hacia la horizontal y luego se envuelve hacia atrás ! nuevamente . Luego sigue moviéndose en esta forma de rombo, imprimiendo dos veces por iteración (cada tercer tic).

Grupo 8

Esta es una de las dos soluciones con un ciclo de impresión realmente ajustado:

Los <actos como la rama. Después de envolver dos veces, 0golpes @. 1por otro lado, primero omite el ?, luego lo >envía al de $nuevo, por lo que se omite el @. Luego, la IP se envuelve en el camino turquesa, donde rebota hacia adelante y hacia atrás entre >y <(envolviendo el borde en el medio).

Grupo 10

Uno de los dos grupos que utilizan otros punteros de instrucción, y es absolutamente hermoso. Hexagony tiene 6: cada uno comienza desde una esquina diferente a lo largo del borde en el sentido de las agujas del reloj, pero solo uno de ellos está activo a la vez.

Como de costumbre, leemos con ?. Ahora ~es la negación unaria: convierte el 1a -1. A continuación, tocamos el #. Esta es una forma de cambiar entre IP: toma el valor de borde actual módulo 6 y cambia a la IP correspondiente (las IP están numeradas 0en el sentido de las agujas del reloj). Entonces, si la entrada fue 0, entonces la IP simplemente sigue siendo la misma, y ​​viaja aburridamente hacia adelante !@. Pero si la entrada fue 1, entonces el valor actual es -1cuál es 5 (mod 6). Entonces cambiamos a la IP que comienza en la misma celda (la ruta verde). Ahora #es un no-op y ?establece el borde de la memoria en 0. )incrementos para !imprimir a 1. Ahora golpeamos ~nuevamente para asegurarnos de que#sigue siendo un no-op (en lugar de cambiarnos a IP 1 que terminaría el programa). Es sorprendente lo bien que todo encaja en este pequeño programa.

Grupo 22

Solo para tener en cuenta, este es el grupo en el que se encuentra mi solución original. También es el grupo más grande, porque el no-op puede estar en dos lugares diferentes, y hay varias opciones para el comando real (no-op efectivo).

Grupo 23

Este es el otro grupo que usa múltiples IP. De hecho, este utiliza 3 IP diferentes. La esquina superior derecha es un poco desordenada, pero intentaré guiarte a través de esto:

Entonces, el comienzo que has visto antes: <desvía el noreste, ?lee la entrada. Ahora ]es otra forma de cambiar entre IP: le da el control a la siguiente IP en el sentido de las agujas del reloj. Así que cambiamos el control al camino turquesa que (sé que es difícil de ver) comienza en la esquina noreste que va hacia el sureste. Se refleja de inmediato en el <modo que se envuelve en la esquina sureste, en dirección noroeste. Es también golpea el ]por lo que cambiar a la siguiente IP. Este es el camino gris que comienza en la esquina este, hacia el suroeste. Imprime la entrada, luego se envuelve a la esquina noreste. <desvía el camino hacia la horizontal, donde es reflejado por el otro < . Ahora la mano derecha<actúa como una rama: si la entrada fue 0, la IP se mueve hacia el noreste y se ajusta al @. Si la entrada fue 1, la IP se mueve hacia el !, se envuelve hacia la izquierda y <donde se refleja ... ahora en la esquina, se devuelve al !, se desvía por la derecha <, se refleja por la izquierda <y comienza el camino terminado...

Todo un desastre, pero un desastre hermoso. :)

Diagramas generados con el sorprendente HexagonyColorer de Timwi .

Código de máquina Motorola MC14500B , 2 bytes

En hexadecimal:

58EC

Explicación:

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

El Motorola MC14500B es un microcontrolador de 1 bit; Tiene un registro de 1 bit y un bus de datos de 1 bit. Como los códigos de operación son de 4 bits cada uno, solo hay dieciséis; La mitad de ellos realiza una operación lógica entre el registro y el bit en el bus de datos.

La instrucción de salto establece una bandera de salto; cuando no se proporciona ninguna dirección, es común establecer el contador del programa en 0. Si el bit de entrada era cero, el procesador no saltará. Si el bit de entrada fue 1, el procesador vuelve al inicio; dado que estamos ORcon entrada, no importa cuál sea la señal de entrada después, el registro será 1 para siempre.

Como es convencional, el registro se inicializa a 0.

Puede encontrar una lista de los códigos de operación en la hoja de datos, o aquí .

Arnold C, 296 bytes

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

No es realmente competitivo, pero por diversión. No es compatible con stdin, reemplace @NO PROBLEMOcon @I LIEDun valor cero. @No Problemoes 1.

Ejecutar con (suponiendo que el archivo es truthmachine.arnoldc):

wget http://lhartikk.github.io/ArnoldC.jar
java -jar ArnoldC.jar truthmachine.arnoldc
java truthmachine

Minecraft, 18 Bytes (MC Versión 15w45a)

Como puede ver, hay una palanca dirigida hacia el bloque de comando de repetición, que tiene el comando say 1en él. Además de eso, hay una antorcha de inversión de señal que dirige la energía hacia el bloque de comando de una sola ejecución con el comando say 0en él.

Cada vez que el interruptor se dirige hacia la verdad, el bloque repetidor usa el código say 1para generar 1s infinitos . Cuando la palanca se redirige a falso, emite un solo 0.

Tenga en cuenta que esto genera un [@]valor predeterminado. Si realmente quiere solo 1s y ceros, esto se convierte en 34 bytes, donde están el código en los bloques de comandos tellraw @a [1]y tellraw @a [0]. Esto está utilizando el recuento de bytes sugerido de @ Cᴏɴᴏʀ O'Bʀɪᴇɴ para MC como se puede encontrar en Meta .

Bash + GNU utils, 13

grep 0||yes 1

Bash, 35

read n;for((;n;));{ echo 1;};echo 0

Rubí, 20

print while/1/||gets

Ejecute desde la línea de comando para evitar advertencias, ya que

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

Explicación:

Menos golf, esto es

while /1/ || gets
  print
end

Cuando se usa un Regexp en un condicional, se evalúa como falsey a menos que la variable $_se complete y coincida con el patrón. La primera vez a través del bucle, $_está vacío, por lo que caemos en gets, lo que establece el valor de $_una línea leída desde STDIN. printsin argumentos impresos $_. Ahora evaluamos el condicional nuevamente. Si leemos en 1, cortocircuitamos y solo imprimimos 1 nuevamente, y así sucesivamente para siempre. De lo contrario, caemos en gets, pero como no hay una segunda línea de entrada, getsdevuelve nil, por lo que el ciclo termina.

Microscript, 3 bytes

i{p

El más corto que conozco.

Explicación:

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

Microscript tiene una impresión implícita del registro 1 al finalizar, que es la razón por la cual una entrada de 0se imprime una vez.

Código de máquina de Turing, 32 bytes

Usando la sintaxis de la tabla de reglas que se encuentra aquí.

0 0 0 * halt
0 1 1 r 1
1 _ 1 r 1

JavaScript, 28 bytes

Los bucles For suelen ser más cortos que los bucles while.

alert(x)devuelve undefined, que es falso, por lo que el operador u bit a bit |, lo emite 0. Por lo tanto, si xes así "0", alerta una vez, de lo contrario, sigue en bucle. Utiliza alertpara STDOUT como esta respuesta .

for(x=prompt();alert(x)|x;);

Python 2, 29 bytes

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

Esto termina con un error de división 0, que está permitido por defecto .

Brainfuck, 41 36 31 30 bytes

Se acortó imprimiendo una vez justo después de la entrada y con la ayuda de Ethan y user46915.

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

Versión anterior: reste 48 de la entrada, y si no es cero, agregue 1 a 48 para imprimir ASCII 1para siempre, de lo contrario imprima 0.

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

Lo ejecuté aquí , pero debido a la salida almacenada en búfer, no puede ver ninguna salida ya que el programa nunca termina 1.

Editar: se me había olvidado imprimir 0en la entrada 0. Corregido ahora. Me gustan las >.<caras al final.

Piet, 27 18 16 codeles

(Codel es un nombre elegante para píxeles que se usa para evitar confusiones cuando una imagen se estira para verla. Conté los codeles en lugar de los bytes porque los scripts piet se guardan como imágenes, por lo que el tamaño físico puede variar. Creo que un formato de archivo ideal guardaría este piet lo más eficientemente posible tomaría 11 bytes. En la práctica, mi pequeño archivo gif es de 62 bytes, con datos de paleta óptimos. Dígame si debo usar esto como el tamaño de mi entrada en lugar de la cantidad de codeles).

Imagen original:

Engrandecido:

En piet, la diferencia entre dos colores es lo que determina qué comando se ejecuta, por lo que ver el mismo color dos veces no significa que realice la misma acción. La ejecución comienza en el códec superior izquierdo. Luego se mueve horizontalmente, realizando lo siguiente:

1. Lee un número y ponlo en la pila
2. Duplicar la parte superior de la pila.
3. Pop y salida de la parte superior de la pila
4. Haga estallar la parte superior de la pila y gire en sentido horario esa cantidad de veces.

Si la entrada era 1, el cursor se mueve hacia abajo al códel de lima, que empuja 1 en la pila. Luego la ejecución continúa yendo a la izquierda. Cuando el cursor pasa de un color a blanco y de blanco a un color, no pasa nada. Dado que el negro también se considera como paredes, el cursor termina volviendo al codel de cal en la línea superior y repite todo desde el paso 2.

Sin embargo, si la entrada fue 0, el cursor nunca bajará y terminará en la J azul a la derecha (juego de palabras previsto, valió la pena), si permanecerá atrapado (porque la parte superior, derecha, izquierda y los lados inferiores de este bloque en forma de J están al lado de los codeles negros o el borde de la imagen). Como el cursor está atrapado, la ejecución finaliza.

Valores inesperados:
si el usuario escribe otro número, todavía se imprimirá, luego el cursor rotará más o menos veces según el valor.

• Múltiple de 4 o 0: la ejecución continúa horizontalmente y finaliza.
• Múltiple de 3: dado que subir es imposible, el cursor gira inmediatamente en sentido horario y continúa horizontalmente, luego termina.
• Múltiple de 2 y no múltiplo de 4: el cursor gira y comienza a moverse hacia la izquierda. Afortunadamente, todo lo que hace es realizar un montón de operaciones que no afectan el flujo del programa y terminan vaciando la pila. Cuando no se puede realizar una operación porque la pila está vacía, simplemente se ignora. Cuando toca la esquina superior izquierda, el cursor no tiene otro lugar a donde ir sino a la derecha nuevamente, reiniciando efectivamente el programa.
• Otros valores: el cursor baja como si fuera 1, lo que hace que imprima 1 para siempre. Si la entrada es 5, la salida será5111111111111...

Cualquier valor no entero terminará el programa. La ejecución continuará normalmente, pero todas las operaciones serán ignoradas ya que no hay nada en la pila. Entonces, en cierto modo, el programa nunca se bloquea: se detiene normalmente o se repite para siempre.

Versión amigable de PietDev

PietDev (un IDE de Piet en línea muy básico) parece tener problemas con los códeles blancos, así que hice una nueva versión que gira manualmente hacia atrás en lugar de depender de la rotación automática del codel blanco adecuado. ¡Y ni siquiera necesitaba usar un nuevo color! Si desea probarlo, asegúrese de dibujar un borde negro alrededor del código porque PietDev no admite tamaños de programa personalizados.

versiones mas antiguas

La primera versión no hizo retroceder 1 en la pila y en su lugar volvió a una instrucción de duplicación anterior. También tenía codeles decorativos inútiles.

Entonces tuve la idea de presionar 1 en la pila para eliminar la línea en blanco. Es curioso cómo lo pensé gracias a mis codeles decorativos.

Luego me di cuenta de que tenía un duplicado extraño que ya no era necesario, y reduje la cantidad de colores para guardar los datos de la paleta en la imagen. También me deshice del codel decorativo único porque no lo sé.

Pyth 4 4 3 2

Wp

Hay un no! espacio final (gracias isaac :)). El espacio solía ser necesario para hacer la compilación del bucle while, pero Pyth se ha actualizado desde entonces. Normalmente eso descalificaría su uso, pero como se trata de un catálogo, debería ser válido.

Explicación:

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

Chip de 6 bytes

e*faAs

Chip es un lenguaje 2D que se comporta un poco como un circuito integrado. Toma entrada, un byte a la vez, y divide los bits en elementos de entrada individuales. La salida vuelve a unir los valores de los elementos de salida en bytes.

Analicemos esto:

*es una señal fuente, enviará un valor verdadero a todos los elementos adyacentes. ey fcorresponden al quinto y sexto bit de la salida. Entonces, e*fproduce binario 00110000, que es ASCII char "0".

Ahora, Aes el primer bit de entrada y aes el primer bit de salida, por lo aAque copia ese bit de entrada a salida. Entonces, cuando se combina con e*f, una entrada de ASCII "0" produce "0" y "1" produce "1". (No hay interacción entre fy a, ya que ninguno produce ninguna señal).

Al sfinal, cuando se activa mediante una señal verdadera, evitará que la entrada avance al siguiente byte, lo que significa que todo volverá a funcionar con la misma entrada.

Como el primer byte de "0" es cero, no activará este elemento y el programa imprimirá "0" y, por lo tanto, agotará su entrada, lo que le permite terminar. Sin embargo, "1" activa este elemento, lo que significa que se emite "1", pero no se consume en la entrada, lo que permite que el ciclo se repita indefinidamente.

Si los valores 0x0 y 0x1 se utilizan para la salida, en lugar de ASCII, podemos eliminar la e*fparte, lo que resulta en solo 3 bytes :

aAs

Si el cero debe terminar por sí mismo, en lugar de esperar que stdin se cierre, obtenemos lo siguiente, que invierte el primer byte ~y pasa el resultado a t, que termina el programa ( 10 bytes ):

aA~te*f
 s

( ttampoco produce señal, por lo que no hay interacción entre ty e.)

Brainbool , 5 bytes

,.[.]

Brainbool es Brainfuck, pero sólo opera en los bits, y hace I / O a través de 0y 1caracteres.

LOLCODE, 119 bytes

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

Sin golf:

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

C, 37 bytes

Una opinión diferente sobre cómo hacerlo en C.

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

cel valor predeterminado es un intvalor 1. gets(&c)obtiene una cadena de stdin, aquí golpeando el valor de c, hackishly ya cque no es un char*. putchar(c)imprime el valor de cto stdouty devuelve c. Como '0'es 48 y '1'49 en ASCII, podemos usar el último bit ( &1) para determinar cuál es. Si es así '0', el bucle se rompe. De lo contrario, se va para siempre.

Compila (con una advertencia sobre gets) y se ejecuta gcc-4.8en Linux.

Laberinto , 7 bytes

 ?+
@!:

Labyrinth es un lenguaje basado en la pila 2D donde el flujo de control depende del signo del elemento superior de la pila, verificado después de cada instrucción. La ejecución comienza a moverse hacia la derecha desde la primera instrucción válida en la fila superior, que aquí está ?.

Las instrucciones relevantes son:

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

Si la entrada es 0, el IP lee la entrada con ?, agrega los dos primeros de la pila ( 0 + 0 = 0), luego duplica :y genera !un 0. Aquí encontramos la única unión en el programa, y ​​tenemos que verificar la parte superior de la pila para determinar dónde ir. Como la parte superior es 0, avanzamos y terminamos con @.

Por otro lado, si la entrada es 1, hacemos la misma instrucción que antes (pero sacando un 1) antes de llegar a la unión en el !. Ahora la parte superior de la pila es positiva, lo que nos hace girar a la derecha hacia el ?. En EOF Labyrinth empuja 0, así que lo hacemos 0 + 1 = 1en +, duplicar :y salida !. Una vez más tenemos un 1 en la parte superior de la pila y el ciclo continúa.

Para obtener una bonificación, aquí está la solución de 7 bytes de @ MartinBüttner, que funciona de manera similar:

?+!@
1!

Tenga en cuenta que, a diferencia de la mayoría de los idiomas, en 1realidad sale nde la pila y empuja n*10 + 1, lo que facilita la creación de grandes números. Sin embargo, dado que la parte superior de la pila está vacía en ese punto, no es diferente de simplemente presionar 1.

> <> , 7 bytes

i2%:n:,

Esto usa el hecho de que> <> empuja -1 en EOF, que es 1 mod 2. También usa dividir por 0 para la terminación (lo cual aparentemente está bien ya que el consenso es que la salida STDERR se ignora).

Solo como referencia, salir limpiamente sin errores es un byte adicional:

i2%:n?!;

APL, 6 bytes

→⎕←⍣⍲⎕

Explicación:

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

Brian y Chuck , 21 bytes

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

Aquí, <SOH>debe reemplazarse con el carácter de control correspondiente (0x01).

Explicación

La idea básica es restar el código de caracteres de la entrada (48 o 49) pal final de Chuck, que dará un ?(que es un comando válido) o @un no operativo.

,lee el carácter de entrada en la primera celda de Chuck (marcada con _). Queremos disminuir este valor 0en un bucle, mientras hacemos otros cambios:

}<se mueve hacia py lo -decrementa. Luego {vuelve a la celda de entrada -que también disminuye. Mientras esto todavía no sea cero, ?le da el control a Chuck. Ahora >mueve el cabezal de cinta de Brian una celda hacia la derecha (que se inicializa 1) e +incrementa eso. Luego reiniciamos el ciclo con {?.

Para cuando llegue la primera celda de Chuck 0, la <SOH>celda se habrá incrementado al carácter que hemos leído de STDIN y pserá ?para entrada 1o @para entrada 0.

Ahora ?ya no cambia el control. El 0o 1después es un no-op, como lo es el byte nulo (representado por _). {regresa a la primera celda de Chuck e +incrementa para asegurarse de que sea positivo, de modo que las ?manos controlen a Chuck.

Este tiempo >+incrementa la celda después del final de la cinta inicial de Brian. Esa celda es basura pero nunca la usaremos. Ahora {no se escanea hasta el frente de la cinta de Brian, sino solo hacia el _. Por ?lo tanto, es un no-op porque la celda actual es cero. Luego <.mueve uno a la izquierda (la copia del carácter de entrada) y lo imprime.

Finalmente, nos encontramos con el ?o @. Si la entrada fue 0y esta celda es @no operativa, el programa finaliza. Pero si la entrada fue 1y esta celda es ?entregada a Brian, quien {+?restablecerá el bucle en Chuck, y ahora estamos imprimiendo 1s para siempre (hasta que el número entero en la celda al final de la cinta de Brian no cabe en la memoria) más, supongo ...).

Prima

Sp3000 y yo hemos estado jugando golf en esto durante varios días. Comenzamos alrededor de 40 bytes y llegamos a dos soluciones completamente diferentes, pero vinculadas a 26 bytes. Solo cuando comencé a escribir la explicación para la mía, se me ocurrió la solución de 21 bytes anterior. Muchas gracias a Sp por lanzar ideas y enseñarnos unos a otros trucos de golf en B&C. :)

Esta es su solución de 26 bytes:

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

Y esto es mío:

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

Donde ®es un byte con valor 174 (por ejemplo, solo guarde el archivo como ISO 8859-1).

En el núcleo, la mina funciona de manera similar a la solución de 21 bytes, ya que se ®convierte }en entrada 1y ~(no-op) para entrada 0, pero la ejecución es mucho menos elegante.

Su solución es bastante clara, ya que el código fuente es solo ASCII y no requiere un bucle para procesar la entrada. En cambio, se ----convierte 1en -y 0en ,(un no-op para Chuck). Eso -cambiará el primero ?de la cinta de Brian en a >, creando así un flujo de control diferente para el 1caso.

Etiqueta cíclica bit a bit, 3 bits o <1 byte

Bitwise Cyclic Tag es uno de los lenguajes más completos de Turing. Funciona con dos cadenas de bits, el programa y los datos . Los bits del programa se leen cíclicamente y se interpretan de la siguiente manera:

• 0: Eliminar el primer bit de datos (y generarlo, en implementaciones que tengan salida).
• 1x: Si el primer bit de datos es 1, agregue x(representando cualquiera 0o 1) al final de los datos. (Si el primer bit de datos es 0, no haga nada).

El programa se ejecuta hasta que la cadena de datos esté vacía.

Máquina de la verdad

110

Cuando la cadena de datos se establece en 0:

• 11no agrega nada porque el primer bit de datos no lo es 1.
• 0elimina / salidas 0.
• La cadena de datos ahora está vacía y el programa se detiene.

Cuando la cadena de datos se establece en 1:

• 11anexa a 1.
• 0elimina / salidas 1.
• La cadena de datos vuelve a un solo 1y el programa vuelve a donde comenzó, por lo que hacemos un bucle para siempre.

GNU sed, 10

:;/1/{p;b}

Explicación

• : definir una etiqueta sin nombre
• /1/Si la entrada coincide con la expresión regular 1, entonces
• p imprimir el espacio del patrón (es decir, 1)
• b y volver a la etiqueta sin nombre (para siempre)
• Si la entrada no fue 1 (es decir, 0), el espacio del patrón se imprime sin modificaciones y el programa finaliza.

En serio , 4 3 bytes

_{Tachado 4 sigue siendo 4 :(}

,W■

,lee un valor de STDIN. Wcomienza un ciclo que se ejecuta mientras el valor en la parte superior de la pila es verdadero, con el cuerpo ■. ■imprime el elemento de la pila superior sin reventar. El ciclo está implícitamente cerrado en EOF.

Al ingresar 0, el ciclo nunca se ejecuta (ya que 0es falsey), y el programa termina en EOF, apareciendo e imprimiendo automáticamente cada valor en la pila. En la entrada de 1(o cualquier valor que no es 0, ""o []), el bucle se ejecuta infinitamente.

En realidad , el inicio ,no es necesario (gracias a la entrada implícita), lo que reduce la puntuación a 2 bytes.

Jue, 34 bytes

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

Explicación:

1::=12 Las instancias de la subcadena "1" pueden convertirse en "12"

2::=~1 Las instancias de la subcadena "2" se pueden eliminar, imprimiendo "1"

0::=~0 Las instancias de la subcadena "0" se pueden eliminar, imprimiendo "0"

@::=::: Las instancias de la subcadena "@" se pueden reemplazar con cadenas de la entrada

::= Lista final de reglas de sustitución

@ La cadena inicial es "@"

Arnold C, 134 bytes

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

Si bien esto no es tan entretenido como la otra respuesta de ArnoldC , es un juego de golf. Por ejemplo, la sangría es innecesaria, al igual que las macros @NO PROBLEMOy @I LIED.

Probado con esta versión del lenguaje , que no puede recibir información.

Cubix , 5 6 bytes

Cubix es el nuevo lenguaje bidimensional de @ETHproductions donde los comandos se envuelven alrededor de las caras de un cubo. Intérprete en línea Gracias a @ETHproductions por el ahorro.

!I\@O

Esto termina expandido al cubo

  !
I \ @ O
  .

Esto comienza con el Icomando. Ingrese un número entero en la pila.
\, redirige el puntero de instrucciones hacia abajo sobre el no op.
O, genera el valor numérico de la parte superior de la pila.
!, omita el siguiente comando ( @) si la parte superior de la pila es verdadera. Esto saltará la \redirección si 1
\, redirige el puntero de instrucción al @programa de salida.

Esto aprovecha el hecho de que los O ? !comandos no revelan la pila .

Foo , 6 bytes

&1($i)

La entrada está codificada como el segundo carácter, ya que Foo no tiene entrada STDIN. ¿No estamos de acuerdo en que Foo es increíble ahora? :)

Explicación

&1          Set current cell to 1
  (  )      Do-while loop (or, at least according to the interpreter)
   $i       Print current cell as int

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

print while$_

Corre así:

echo -n NUM | perl -p truth.pl

Gracias a ThisSuitIsBlackNot (que es mucho mejor en Perl golf que yo) por jugar golf de cinco bytes.

> <> , 6 bytes

::n?!;

Empuja la entrada en la pila para comenzar

:        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