Interquine: dos programas que se generan entre sí en un bucle

29

El programa A emite el código del programa B cuando se ejecuta, y B emite la fuente de A.

Requisitos:

  • Solo un idioma en ambos programas
  • Los programas son diferentes. Un programa que se genera solo no califica.
  • Ambos programas no están vacíos o tienen al menos 1 byte de longitud. Las nuevas líneas finales tanto en la fuente como en la salida se ignoran
  • stdin está cerrado. No lea nada (por lo que no puede leer la fuente y manipularla). La salida va a stdout.
    Editar: stdin está conectado a /dev/null. Puede pedir que se cierre si se aclara.
  • No use randomfunciones.

Adicional:

  • Dar explicaciones si es posible

La puntuación es la longitud total . La nueva línea final no cuenta si no afecta el programa.

iBug
fuente
8
Relacionado.
Martin Ender
55
"No utilizar funciones aleatorias"? ¿Qué quieres decir? ¿Funciones que generan un número aleatorio?
Sr. Xcoder
Estoy bastante seguro de que realmente no quieres decir que stdin está cerrado. Esto explota algunos entornos a medida que stdin se convierte en un duplicado del primer archivo abierto. De todos modos, si no lo arreglas, lo abusaré.
Joshua

Respuestas:

18

CJam , 13 + 13 = 26 bytes

{sYZe\"_~"}_~

Pruébalo en línea!

Salidas

{sZYe\"_~"}_~

Explicación

{       e# Standard quine framework, leaves a copy of the block on the stack
        e# for the block itself to process.
  s     e# Stringify the block.
  YZe\  e# Swap the characters at indices 2 and 3, which are Y and Z themselves.
  "_~"  e# Push the "_~" to complete the quine.
}_~

Como e\es conmutativo en su segundo y tercer operando, el otro programa hace exactamente lo mismo, intercambiando Zy Yvolviendo a su orden original.

Martin Ender
fuente
17

CJam ,11 + 13 = 24 11 + 12 = 23 bytes

"N^_p"
N^_p

Pruébalo en línea!

Salidas:

"N^_p
"
N^_p

La salida tiene 13 bytes, pero:

La nueva línea final no cuenta si no afecta el programa.

Así que cambié el espacio a una nueva línea para aprovechar eso.

Se basa en la quine adecuada más corta de CJam:

"_p"
_p

Y N^consiste en xor la cadena con una nueva línea, que agrega una nueva línea si no hay una nueva línea, y elimínela si la hay, para una cadena en la que cada carácter es único.

Creo que he visto ese quine en la pregunta quine, pero no pude encontrarlo.

jimmy23013
fuente
+1 por tener dos programas de diferentes tamaños, a diferencia de todas las otras respuestas hasta ahora. Editar: tan pronto como pueda volver a votar ... alcanzó el límite última votación>.>
Kevin Cruijssen
Bueno por ser diferente en longitud.
iBug
"Creo que he visto esa quine en la pregunta quine, pero no pude encontrarla". Solo se menciona en la respuesta de GolfScript.
Martin Ender
12

RProgN 2 , 3 + 3 = 6 bytes

Primer programa:

0
1

Pruébalo en línea!

Segundo programa:

1
0

Pruébalo en línea!

-2 gracias a Martin Ender .

Erik el Outgolfer
fuente
77
Puede guardar dos bytes al cambiar de idioma: tio.run/##Kyooyk/P0zX6/9@Ay/D/fwA
Martin Ender
@MartinEnder Oh, sí, olvidé que RProgN 2 exhibe tal comportamiento ... por cierto, no sé si todavía es así de defectuoso.
Erik the Outgolfer
11
No sé nada sobre RProgN, excepto que este comportamiento existe.
Martin Ender
@MartinEnder Autor de RProgN aquí, solo pregunta si necesitas algo aclarado.
ATaco
@ATaco Bueno, te hubiera pedido que aclararas el voto negativo, pero no creo que puedas ...
Erik the Outgolfer
6

C, 95 + 95 = 190 bytes

¡Gracias a @immibis por guardar 16 * 2 bytes!

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}

Pruébalo en línea!

Salidas:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=0^1;printf(s,34,s,34,i);}

Pruébalo en línea!

Qué salidas:

char*s="char*s=%c%s%c;main(i){i=%d^1;printf(s,34,s,34,i);}";main(i){i=1^1;printf(s,34,s,34,i);}
Steadybox
fuente
1
¿Por qué no llamarlo siempre C y confiar en i change para que el programa sea diferente? C es más corto que% c
user253751
@immibis Sí, tienes razón, eso es perfecto.
Steadybox
5

Javascript, 67 + 67 = 134 bytes

1er programa:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=0))

2do programa:

alert(eval(c="`alert(eval(c=${JSON.stringify(c)},n=${+!n}))`",n=1))

Esto se basa en la respuesta de Herman Lauenstein a Tri-interquine

Javascript (código fuente de lecturas no válidas), 75 + 75 = 150 61 + 61 = 122 58 + 58 = 116 50 + 50 = 100 bytes

ahorró 20 bytes gracias a Tushar, 6 bytes gracias a Craig Ayre, y guardó 16 bytes gracias a kamoroso94

1er programa:

f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f()

2do programa:

f=_=>alert(("f="+f).replace(1,a=>+!+a)+";f()");f()

Intercambia los 1 con los 0 y viceversa. Ambos hacen lo mismo, solo producen resultados diferentes debido a su código fuente.

SuperStormer
fuente
1
Guardemos algunos bytes. f.toString()=> (''+f), (0|1)=> 0|1, (a,b)=> aresultando enf=()=>("f="+(''+f).replace(/0|1/g,a=>a==0?1:0)+";f()");f()
Tushar
Puede usar un parámetro no utilizado para guardar un par de bytes f=_=>y eliminar los parens de la devolución de llamada de reemplazo como sugirió @Tushar:a=>+!+a
Craig Ayre
Reemplazar "f="+(f+"")con ("f="+f)para -3 bytes.
kamoroso94
Reemplace /0|1/gy /1|0/gcon 0y 1respectivamente para -5 bytes.
kamoroso94
¿Lo corriste? Funciona asi f=_=>alert(("f="+f).replace(0,a=>+!+a)+";f()");f().
kamoroso94
4

Python 2, 63 + 63 = 126 bytes

Pruébalo en línea

Primer programa:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]

salidas:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Segundo programa:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[29:35]

Salidas:

A='A=%r;print A[:23]%%A+A[29:35]23:29]';print A[:23]%A+A[23:29]
Zarigüeya muerta
fuente
4

JavaScript ( JsShell ), 35 + 34 = 69 bytes

1:

(f=x=>print(`(f=${f})(${-x})`))(-1)

2:

(f=x=>print(`(f=${f})(${-x})`))(1)
tsh
fuente
3

Mathematica, 43 + 44 = 87 bytes

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -1 1]

y

(Print[#1[#0[#1, -#2]]] & )[HoldForm, -(-1)]
alephalpha
fuente
Lo probé en mi computadora y la salida del segundo solo tiene -1al final, no -1 1.
numbermaniac
@numbermaniac Escribí estos códigos en la interfaz basada en texto. Parece que no funcionan en cuadernos.
alephalpha
3

asmutils sh, 16 + 16 bytes, abusando de la regla "stdin is closed".

#!/bin/sh
tr x y

Dado que stdin está cerrado y sh abrirá su script en el primer controlador disponible (en lugar de moverlo a un controlador con un número alto como lo hacen los shells modernos), tr termina leyendo una copia del script sin haberlo abierto nunca.

Este interquine es capaz de cargar, pero insertar una carga útil es complicado.

Además, esta versión original abusa de algunos errores locos en el núcleo antiguo que usaba en esos días. (No sé qué pasa con ese kernel, descubrí más tarde que también tenía diferentes números mayores y menores para los dispositivos). Si corrige los cambios de ABI que se rompieron como asmutils, la interquina aún no funcionará. Olvidé si asmutils sh tiene ejecutivo o no, pero si lo tiene, esta es una versión moderna:

exec dd skip=0 | tr x y

Esto abusa de un error deliberado en asmutils dd; tiene una optimización de rendimiento que llama a llseek para omitir si puede, pero para guardar un byte pasa SEEK_SET en lugar de SEEK_CUR. Esto da como resultado basura en stderr pero la interquina en stdout. Asmutils dd no tiene una opción para suprimir el correo basura más stderr.

Joshua
fuente
¿Funcionará si stdin está conectado a /dev/null? De todos modos, buen trabajo!
iBug
@iBug: No. Depende completamente de stdin cerrado y del hecho de que asmutils sh no esté vinculado contra libc y, por lo tanto, no herede el código de reparación automática en libc.
Joshua
¿Necesitas el #!/bin/sh?
CalculatorFeline
@CalculatorFeline: eso depende de la exactitud de su definición de otra cosa.
Joshua
En general, los shebangs no se cuentan, por lo que serían 6 bytes.
CalculatorFeline
1

Lisp común, 58 caracteres

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

... o 24 caracteres si no le importa suponer que *print-circle*está configurado globalmente en T:

#1=(print '(write '#1#))

La representación impresa del código se lee como una estructura cíclica, donde #1#apunta de nuevo a la siguiente celda de contras #1=. Cotizamos programas para que no se ejecuten. Como *print-circle*es T, el REPL se encarga de emitir tales variables de lectura durante la impresión; esto es lo que imprime el código anterior y devuelve:

#1=(write '(print '#1#)) 

Cuando evaluamos el código anterior, imprime:

#1=(print '(write '#1#))

Si desea mantener el valor predeterminado para *print-circle*, que es NIL en una implementación conforme, deberá volver a vincular la variable temporalmente:

#1=(let((*print-circle* t))(print'(write '#1# :circle t)))

Dentro del cuerpo del LET, imprimimos cosas con *print-circle*ser T. Entonces obtenemos:

#1=(write
    '(let ((*print-circle* t))
       (print '#1#))
    :circle t) 

Como puede ver, el nuevo programa no se vuelve a unir *print-circle*, pero como estamos utilizando write, que es la función de bajo nivel llamada por print, podemos pasar argumentos adicionales como :circle. El código entonces funciona como se esperaba:

#1=(let ((*print-circle* t))
     (print '(write '#1# :circle t)))

Sin embargo, debe ejecutar los programas anteriores como un script, no dentro de un REPL, porque a pesar de que imprime las cosas mientras se ocupa de las estructuras circulares, ambas writey printtambién devuelve el valor que se está imprimiendo; y en un REPL predeterminado, el valor también se imprime, pero fuera del contexto dinámico donde *print-circle*está T.

volcado de memoria
fuente
1

> <> , 16 + 16 = 32 bytes

":1-}80.r   !#o#

y

#o#!   r.08}-1:"

Pruébalo en línea!

Esto funciona mediante el uso de un salto en el programa, el primer salto de los programas omitirá el reverso de la pila (si revierte la pila, sería una quine). El segundo programa no omite el reverso, pero si ya está invertido por el flujo del programa, creará el original.

Este código terminará en un error.

Pelícano verde azulado
fuente
1

RProgN 2 , 7 + 7 = 14 bytes

Quería intentar mostrar un mejor uso de RProgN, en lugar de abusar de las órdenes de impresión ...

1
«\1\-

y...

0
«\1\-

Explicado

1   # Push the constant, 1. (Or 0, depending on the program)

«\1\-
«       # Define a function from this to the matching », in this case there isn't any, so define it from this to the end of the program, then continue processing.
 \      # Flip the defined function under the constant.
  1\-   # Get 1 - Constant.

Debido a que esto imprime la pila al revés, primero se imprime la nueva constante, luego se imprime la versión en cadena de la función.

Pruébalo en línea!

Un taco
fuente
1

LOGOTIPO , 65 + 66 = 131 bytes

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] 1]

y

apply [(pr ? ` [[,? ,-?2]] )] [[apply [(pr ? ` [[,? ,-?2]] )]] -1]
usuario202729
fuente
1

Python 3, 74 + 74 = 148 bytes

a='a=%r;b=%r;print(b%%(b,a))';b='b=%r;a=%r;print(a%%(a,b))';print(b%(b,a))

y

b='b=%r;a=%r;print(a%%(a,b))';a='a=%r;b=%r;print(b%%(b,a))';print(a%(a,b))

yo tampoco lo entiendo

aaay aaay
fuente
1

> <> , 12 + 12 = 24 bytes

'3d*!|o|!-c:

y

':c-!|o|!*d3

Pruébalo en línea!

Ambos programas usan un literal de cadena de ajuste para agregar el código a la pila, luego producen el 'comando a través de diferentes métodos. Al imprimir la pila, empuja el código hacia atrás, sin embargo, se 'queda al frente. Hay varias variaciones que producen el '; 3d*, d3*, 00g, :c-Cuando se combina con 3d*y:9- cuando se combina con00g .

Una solución demasiado similar para publicar, en Befunge-98 para 13 * 2 bytes

"2+ck, @,kc+2
Jo King
fuente
0

Javascript (ES6), 36 + 36 = 72 bytes

Programa 1:

f=n=>('f='+f).replace(/4|5/g,n=>n^1)

Programa 2:

f=n=>('f='+f).replace(/5|4/g,n=>n^1)

Estos programas funcionan clonándose y reemplazados 5por 4y 4con5

console.log((
    f=n=>('f='+f).replace(/4|5/g,n=>n^1)
)())
console.log((
    f=n=>('f='+f).replace(/5|4/g,n=>n^1)
)())

Herman L
fuente
2
Dado que esto se etiqueta quine , esto es lo que generalmente se consideraría una "quine trampa", ya que lee su propia fuente. No estoy seguro de cuál es la decisión de OP sobre eso, pero generalmente no están permitidos.
Stephen
0

Klein , 26 24 bytes

<:3+@+3<:"

Pruébalo en línea!

Explicación

Esto funciona igual que mi Klein Quine , donde imprime la fuente hacia atrás seguida de una ", la última se salio con la suya al ser palindrómica, por lo que todo lo que tenemos que hacer es hacerla no palindrómica sin dañar su funcionalidad. Al cambiar <y :pudimos hacer esto sin interferir con la funcionalidad.

Asistente de trigo
fuente