Hacer una impresora entera versátil es agradable y todo, pero escribir un solo código que imprima muchos números diferentes es engorroso. ¿No sería más fácil crear un guión que genere un número, pero que también le proporcione un nuevo guión para obtener el siguiente número?

Reto:

Escriba un código que genere un único entero Ny un código ejecutable. El siguiente código debe salir N+1y un código que puede salir N+2. Continúa este camino hasta llegar N = 15. (El último número impreso debe ser 15).

Reglas:

• Sin entrada (suponga que la entrada está vacía).
• Se permite un programa o función completa u otros formatos convenientes.
• El primer código debería salir 1.
• No puede generar ceros a la izquierda. Es decir, no se puede imprimir 01para 1.
• La salida debe estar en el formato N, Code_for_N+1. Tenga en cuenta que la salida está separada por una coma y un solo espacio. El código para N+1no tiene comillas circundantes. N , Code_for_N+1no se acepta (espacio delante de la coma). Las nuevas líneas finales están bien.
• Los primeros caracteres de la salida deben ser el número. (Sin espacios iniciales, o ans = N).
• El número impreso no debe ser parte del siguiente código (el código puede contener este número, pero no puede tomar el número de salida como parte del código)
  • Ejemplo: La salida para N=2puede ser: 2, printer 2. En este caso, printer 2es el código para N=3. No puede usar toda la salida: 2, printer 2como código para N=3.
• Los guiones pueden estar en diferentes idiomas.
• Los tipos de datos son irrelevantes (el número puede ser una cadena), pero no puede estar rodeado de nada (comillas, paréntesis, etc.).
• Si se emite un código N=15, debe imprimirse STOP!(ver bonificación) o no imprimir nada (ni siquiera un espacio o una nueva línea).
  • El código para N=15no puede bloquearse (pero la salida a STDERR está bien).
  • Usted está descalificado si el código de salida para N=15impresiones 16o cualquier otra cosa (excepto el caso de bonificación).
• Los operadores de quine incorporados no están permitidos.
• No está permitido acceder al archivo fuente a través del sistema de archivos.

Prima:

-10 bytes si el código que imprime 15 también produce un código que imprime " STOP!"

Ejemplos que usan la sintaxis de Python: (obviamente, estos solo funcionarán para los enteros seleccionados, no del 1 al 15.)

N = 1
print "1, print 2"
1, print 2

---
N = 15
print 15
15

---
N = 15   (Qualifies for the -10 bytes bonus)
print "15, print 'STOP!'"
15, print 'STOP!'

print 'STOP!'
STOP!

----

N = 15   (Qualifies for the -10 bytes bonus)
print "15, disp('STOP!')"
15, disp('STOP!')        (disp('STOP!') outputs STOP! in MATLAB)

----
N = 15   (This one is not OK. The submission is disqualified)
print "15, print 16"
15, print 16

Se aplican las reglas estándar de golf. ¡El código más pequeño (para N = 1) en bytes gana!

Pyth + ///, 15 bytes - 10 = 5

pPt`S15", STOP!

Esto imprime 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, STOP! en Pyth, quitando range(1,15+1)y quitando los corchetes de inicio y fin, e imprimiéndolo inmediatamente seguido de ", STOP!".

Los siguientes catorce programas están en ///, que genera directamente todos los programas que no contienen /o\ . Entonces el segundo programa

2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

da 2y el tercer programa 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15. El penúltimo programa, 15, STOP!imprime 15, STOP!, por lo que el último programa es justo STOP!.

JavaScript, 131238-10 = 131228 bytes

El enfoque ingenuo resultó peor de lo esperado. En retrospectiva, debería haberlo esperado. Pero pensé en compartirlo de todos modos. Código completo aquí.

Idea: escapar iterativamente y agregar el N-1, ...

alert("14,alert(\"15, alert(\\\"STOP!\\\")\")")

CJam, 26 25 24 bytes

1{", "2$)@"_~"](_F<@*}_~

Pruébalo en línea.

Los programas posteriores simplemente tienen el primer número incrementado. Esto ejecuta el programa 16 veces.

O con bonificación por el mismo puntaje:

1{", "\2$)_G<\@`+"_~"+"STOP!"`?}_~

Pruébalo en línea.

Los programas posteriores simplemente tienen el primer número incrementado. Esto ejecuta el programa 16 veces.

Solución alternativa para el bono:

1{", "\2$)Gmd@`+"_~"+"STOP!"`\?}_~

JavaScript (ES6), 62 61 bytes - 10 bonus = 51 puntaje

_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)

Explicación

Una solución que no lee su propio código fuente y tampoco es ridículamente larga.

El primer programa construye los otros 15 programas y los anida uno dentro del otro utilizando una función recursiva. Eludí el problema de la barra diagonal inversa al anidar las funciones mismas (que luego se convierten en cadenas durante la salida) en lugar de cadenas.

_=>
  "1, "                // print the first number
  +(f=n=>`_=>"`+(      // f = recursive function for printing program N
    n<16?              // for programs 2 - 15:
      n+`, "+(${       // add N to the output of the nested function
        f(n+1)         // nest the code of program N + 1
      })`
    :`STOP!"`          // program 16 just outputs "STOP!" for the bonus
  ))(2)                // start from program 2

Prueba

var nextProgram = '_=>"1, "+(f=n=>`_=>"`+(n<16?n+`, "+(${f(n+1)})`:`STOP!"`))(2)',
    n = 1;
while(nextProgram) {
  result.textContent += "Program " + n++ + ": " + nextProgram + "\n";
  var output = eval("(" + nextProgram + ")()");
  result.textContent += "   Output: " + output + "\n\n";
  var index = output.indexOf(",");
  nextProgram = index > 0 ? output.substr(index + 2) : null;
}

<pre id="result"></pre>

Matlab, 226122-10 = 202 bytes

Gracias a @StewieGriffin por unos pocos bytes =)

'awFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)

La primera parte es una cadena que representa la segunda línea (a continuación), el código real (solo desplazado por 9). En Matlab, las cadenas son matrices llenas de caracteres, por lo que puede realizar fácilmente los cambios simplemente agregando / restando un escalar. Entonces, el programa simplemente imprime la misma cadena * nuevamente, más la misma cadena pero desplazada, lo que da como resultado el código.

* No del todo: el primer byte es el contador que debe incrementarse en cada iteración.

El truco de quine con la cuerda fue robado descaradamente de aquí.

'awFjw|Dro)w1:26B?G:>DwF0\}xy*0Dnu|nDwFdw~v;|}{1w1:26B?2505)05<B5w1:24:5w1;Cnwm25<B5>B5w1;Cnwm26B500fDnwmDmr|y1w2';
n=ans;if n(1)-96>15;n='Stop!';else;n=[num2str(n(1)-96),', ',39,n(1)+1,n(2:end),39,59,n(2:end)-9,''];end;disp(n)

Aquí las últimas líneas de la secuencia copiadas de la consola:

>> 'mwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
13, 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'nwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
14, 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'owFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
15, 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
>> 'pwFjw|DWFw1:2DVFw1;Cnwm2Dro)WG:::DwF0\]XY*0Dnu|nDwFdw~v;|}{1W6B?2505)05<B5W4:5V5<B5>B5V6B500fDnwmDmr|y1w2';n=ans;N=n(1);M=n(2:end);if N>111;n='STOP!';else;n=[num2str(N-96),', ',39,N+1,M,39,59,M-9,''];end;disp(n)
STOP!

JavaScript, 50 47 44 42 44 ^* bytes

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1)

Es una función que extrae su propio cuerpo (solo a) y realiza reemplazos en él. Conseguir que el cuerpo de la función sea una característica incorporada de JavaScript, aunque no sea explícitamente un operador de quine (si no es válido, eliminará la respuesta).

a=_=>(x=1)+(x<15?", a="+a:"").replace(x,x+1);
alert(a());

En caso de que no funcione correctamente incrustado allí (porque para mí no lo hace), puede ver un ejemplo allí .

^{*: parece que el fragmento produce el resultado sin a=hacerlo, lo que hace que sea imposible realizar más llamadas}

Python 2.7.10, 196 92-10 = 82 bytes

Whee !!! Esto fue divertido. Mucho más corto ahora. :PAGS

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Explicación:

Empecé con esto:

a='a=%r;print a%%a';print a%a

Eso es solo una quine simple. Esto es que con un contador agregado:

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)';print n,a%(n+1,a)

nes una variable de contador que se imprime al principio. Luego, cuando imprime la n=pieza, sustituye n+1la %d. Entonces desde aquí contará infinitamente.

Y aquí está la versión final. Agrega una cláusula if para detenerse en 15, e imprime "STOP!" también.

n=1;a='n=%d;a=%r;print n,a%%(n+1,a)if n!=15else"STOP!"';print n,a%(n+1,a)if n!=15else"STOP!"

Código antiguo

a= ['if num==15:print"STOP!!!";exit()','print num','print"a=",a','print"num=",num+1', 'for s in a:print s']
num= 1
print num
if num==15:print"STOP!!!";exit()
print"a=",a
print"num=",num+1
for s in a:print s

Nunca va a ganar, pero es divertido. : P Mucho más corto ahora, aunque todavía no tengo ninguna posibilidad. :PAGS

PowerShell, (215-10) = 205 197 167 106 104 103 bytes

$d='$c=(,1*{2}).count;$d={0}{1}{0};(("$c, $d"-f[char]39,$d,($c+1)),$c)[$c-eq15]';"1, $d"-f[char]39,$d,2

_{(Si su única herramienta es PowerShell, cada problema parece un clavo. Espere ...)}

En esencia, se comienza con la configuración $digual a una cadena de grandes ole-largo de un casi- quine del código original. Genera 1y luego $dcon el operador de formato -fpara rellenar correctamente el {0}, {1}, {2}ins-pie, incrementando el{2} número de la ,1*{2}sección en uno cada vez.

La ,x*yoperación en PowerShell crea una nueva matriz de yelementos, cada uno de los cuales es igual a x. Por ejemplo,,2*3 es equivalente a@(2,2,2) .

Esto significa que la primera salida será 1, $c=(,1*2).length;$d=(etc...), por lo tanto, cuando se ejecute el segundo código, $cserá igual al recuento de la matriz@(1,1) , o 2etc. Tenga en cuenta que$c no se utiliza como una variable en el código original, justo en carreras subsiguientes.

Se detiene cuando imprime 15 simplemente calculando si $ces igual 15y luego indexando en una matriz, el elemento 0 es $c, $dcomo se describió anteriormente, el otro es justo 15. Por lo tanto, cuando $csea ​​15, generará15 y nada más. No califica para la bonificación, porque "15, {0}STOP!{0}"son 5 caracteres demasiado largos para que valga la pena el -10.

Requiere un terminal PowerShell de ancho> ~ 150. O para que elimine manualmente el salto de línea adicional (que la terminal ayude inserta ajuste de salida) al copiar y pegar el código. O para que capture la salida en una variable y luego vuelva a ejecutar esa variable. Etc.

_{Edición 1: guardado algunos bytes al eliminar "¡DETENER!" fraseología.
Edición 2: Durr, no uses .length cada vez, solo llámalo una vez
Edición 3: no es necesario que sea una quine, por lo que la ejecución inicial puede ser mucho más corta
Edición 4: cambió de usar cadenas a matrices para calcular $c, lo que ahorró dos bytes. Estoy bastante seguro de que esto es casi óptimo para este enfoque.
Edición 5: guardado otro byte contando directamente la igualdad en lugar de modificar}

JavaScript, 79-10 = 69 bytes

s='STOP!';for(i=15;i;){s=i--+',alert("'+s.replace(/[\\"]/g,"\\$&")+'")'};alert(s)

Sin usar Function.prototype.toStringde ninguna manera.

Befunge, 57-10 = 47 bytes

1:'!`'#*j:.',,1+:9`''*'0++,1#;:0g:48*`j@,1+;"!POTS",,,,,@

Este es asombroso. Probarlo aquí .

Lote, 73 + 5 - 10 = 68 bytes

@set a=STOP!
@for /l %%a in (15,-1,1)do @set a=%%a, @echo !a!
@echo %a%

Requiere, CMD /V:ONasí que agregué 5 bytes para eso.

Python 2.7, 107 caracteres

Al usar la recursividad y no escribir un quine, pensé que podría ahorrar mucho, lo cual es cierto, pero no lo suficientemente bueno. Aunque no es un ganador, creo que el enfoque es divertido de compartir.

Comencé haciendo una cadena para N = 4, escapando de los caracteres \y ".

print "1, print \"2, print \\\"3, print \\\\\\\"4, print \\\\\\\\\\\\\\\"STOP!\\\\\\\\\\\\\\\"\\\\\\\"\\\"\""

Luego creé una función lambda que crea esta cadena, basada en un índice de inicio y un índice de detención, utilizando la recursividad. Eso es todo:

l=lambda n,m:str(n)+", print "+"\\"*(2**(n-1)-1)+"\""+l(n+1,m)+"\\"*(2**(n-1)-1)+"\"" if n<m else "STOP!"

Úselo así:

print l(1,15)

Salida: [32902 caracteres, demasiado largos para manejar]

Entonces, parece que mi enfoque de complejidad kolmogorov no es tan exitoso ;-)

SMBF , 28 bytes

\x10representa un byte literal (valor decimal 16). El entero se emite como un entero (byte). Entonces la salida del primer carácter es \x01. El programa luego imprime ",". Al imprimir su propia fuente, imprime un extra +al principio.

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

Explicación:

+.                                  Increment number and print
  <-                                Pre-decrement loop counter
    <<.>.>                          Print comma and space from own source
          [             ]           Only execute if loop counter != 0
           [<]>.                    Move to left of source, then print `+`
                [.>]                Print entire source.
                    <[-]            Zero out the loop counter so this program halts.
                         , \x10     The comma, space, and loop counter used earlier.
                                    Input is empty, so `,` doesn't do anything.

Tenga en cuenta que no puede ejecutar esto en un intérprete estándar porque requiere un literal hexadecimal en la entrada. También necesita un terminal especial para que la salida hexadecimal funcione correctamente.

Bash, 78 74 73-10 = 63 bytes (Ejemplo, no puede ganar)

p='if(($((++a>15))));then unset a p;fi;echo ${a-STOP\!}${p+, $p}';eval $p

Llegué tarde, pero vi que bash no había sido probado, así que probé. Primer desafío del golfo y rompecabezas tipo quine. ¡Ellos son divertidos!

Explicación:

Esto funciona porque los apasos del 1 al 15 y luego es unsetjunto con p. El script (almacenado en p) los imprime a ambos si están sety "¡DETÉNGASE!" de otra manera. Inicialmente unset aes set0 porque aparece en una expansión aritmética.

𝔼𝕊𝕄𝕚𝕟, 30 caracteres / 47 bytes (no competitivo)

⟮a=1)+(a<ḏ?⬬+ⒸⅩ222+ᶈ0:⬯)ē(a,⧺a

Try it here (Firefox only).

Finalmente encontré una buena quine verdadera para 𝔼𝕊𝕄𝕚𝕟.

Explicación

Aquí está la verdadera quine que usé: ⟮ⒸⅩ222+ᶈ0

¿Lo ves en mi respuesta? Con suerte, ustedes podrán expandirse desde allí.

Barrilete + PHP, 19-10 = 10 bytes

ï_(. \,,,)\!POTS(,

Cuenta de 1 a 15 y luego se detiene. TIO

Barril, 13 bytes

ï_(. \,,,).