Hace aproximadamente un año, el 31 de diciembre de 2015, tuve la idea de que:

Deberíamos hacer una cadena de cápsulas de tiempo. Todos pueden agregar un personaje y en los próximos años veremos quién puede hacer el mejor programa de todos los personajes con los esolangs que existen en ese momento.

Doorknob recogió gentilmente personajes de la comunidad PPCG y los mantuvo a salvo durante un año.

¡ Participaron 74 personas, por lo que tenemos 74 personajes ASCII imprimibles para jugar!

Aquí están los 74 caracteres de la cadena de la cápsula del tiempo 2016 en el orden en que fueron enviados:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Aquí están los 74 caracteres de la cadena de la cápsula del tiempo 2016 en orden ASCII (observe el espacio inicial):

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

No es mucho para trabajar, pero por aquí nos gusta un desafío.

El reto

Para determinar qué idioma es el "mejor" con la cadena de la cápsula del tiempo tendremos 6 (para 201 6 ) desafíos que aumentan en dificultad, donde en cada uno debe usar un subconjunto de los 74 caracteres de la cápsula del tiempo.

Tener 6 desafíos distintos ayuda a garantizar que más idiomas puedan competir, pero solo los mejores idiomas podrán responder a todos y obtener una puntuación alta.

Puntuación:

• Cada desafío se puntuará de 0 a 74 dependiendo de cuántos personajes se usen.
• Los puntajes más altos son mejores.
• Si su idioma no puede completar un desafío, su puntaje para ese desafío es 0.
• Se puede completar cualquier subconjunto no vacío de los desafíos.
• Su puntaje final es la suma de los puntajes de los 6 desafíos.
• El mejor puntaje final posible es 6 × 74 o 444 .

Los desafios

1. Ejecutar

Si el código de un idioma no puede ejecutarse en primer lugar, no podrá hacer nada en absoluto.

Escriba el programa completo más largo posible (usando solo los 74 caracteres de la cápsula del tiempo, recuerde) que se ejecuta / ejecuta sin errores de tiempo de compilación o tiempo de ejecución.

No importa lo que haga el programa, no importa si tiene entrada / salida o entra en un bucle infinito, solo importa que se ejecute sin errores. (Las advertencias están bien, al igual que los errores causados ​​por una entrada incorrecta del usuario).

Se permiten comentarios, por lo que esto podría ser tan simple como

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

en Python para un puntaje de 74.

(No tenga miedo de responder si este es el único desafío que su idioma puede completar, pero tampoco espere muchos votos).

Puntuación = duración del programa (un programa más largo es mejor)

2. E / S

Un lenguaje que no tiene forma de entrada o salida es casi tan inútil como uno que no se puede ejecutar.

Dado un carácter ASCII imprimible de !(0x33) a }(0x7D) inclusive, genera el carácter ASCII imprimible antes y después.

La salida puede ser una longitud de dos cadenas o listas, o los caracteres separados por un espacio o una nueva línea.

Por ejemplo, si la entrada es }la salida podría ser |~o ["|", "~"]o | ~o |\n~.

Del mismo modo, "es la salida para !y ACes la salida para B.

Puntuación = 74 - duración del programa (un programa más corto es mejor)

3. Branchability

Los condicionales son a menudo un requisito para la integridad de Turing , que a menudo es un requisito para que un idioma sea útil.

Dado un número entero positivo, si termina en los dígitos decimales 16a continuación, cambiar el 6a una 7y la salida el resultado; de lo contrario, envíe la entrada sin cambios. Puede usar cadenas para entrada / salida si lo prefiere.

Ejemplos:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Puntuación = 74 - duración del programa (un programa más corto es mejor)

4. Loopabilidad

Un lenguaje que no puede hacer bucles generará código repetitivo tan tedioso que necesitará tomar un descanso de programación por un tiempo.

Dado un número entero positivo, genera un cuadrado de arte ASCII de esa longitud lateral lleno de un patrón de cuadrados concéntricos más pequeños que alterna entre dos caracteres ASCII imprimibles distintos . No tienen que ser los mismos dos caracteres para diferentes entradas.

Por ejemplo:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Puntuación = 74 - duración del programa (un programa más corto es mejor)

5. Matemáticas

Un lenguaje que no es bueno con los números y las matemáticas también podría ser para las carreras de humanidades.

No tome más datos que los 72 divisores enteros de 2016 , positivos y negativos, en cualquier orden. La salida se puede formatear como una cadena o lista de manera razonable.

Ejemplo:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Puntuación = 74 - duración del programa (un programa más corto es mejor)

6. Esoterismo

(No, eso no .) En PPCG nos gustan nuestras cosas esotéricas , y las quines son un buen ejemplo de eso.

Escriba la quine más larga que pueda, de acuerdo con las reglas habituales de quine . Un quine es un programa que no toma entrada y sale por sí mismo.

Puntuación = duración del programa (un programa más largo es mejor)

Reglas especificas

• En cada uno de los 6 desafíos, su programa debe ser un subconjunto de los 74 caracteres de la cápsula del tiempo reorganizados de la forma que desee. Puede ser un subconjunto vacío o un subconjunto incorrecto , por lo que cada uno de sus programas podría tener tan solo 0 y hasta 74 caracteres.
• Una nueva línea final al final de entrada / salida / código está bien en cualquier lugar ya que algunos idiomas requieren esto o no se puede evitar fácilmente.
• A menos que se especifique lo contrario, cada desafío se puede completar como una función o un programa completo de acuerdo con nuestros valores predeterminados .
• Todos los desafíos deben completarse en el mismo idioma.
• Debe usar un idioma (o versión de un idioma) creado antes de 2017 en cualquier lugar de la Tierra .
• Cualquiera puede responder, ya sea que haya agregado un personaje a la cápsula del tiempo o no.

_{Siéntase libre de usar los personajes de la cápsula del tiempo 2016 en sus propios desafíos.}

Glifo , 74 + ( 74-36 ) = 112

1. Ejecutar (74 bytes)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. IO (36 bytes)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

Explicación

Glypho parecía una opción bastante buena para este desafío, porque no le importan los personajes reales que se utilizan. En cambio, analiza grupos de cuatro caracteres y elige el comando en función del patrón de repetición en esos cuatro caracteres. Dado que hay muchos duplicados entre la cadena de la cápsula del tiempo, somos bastante flexibles en los programas que podemos escribir, excepto que estamos limitados a programas de 18 comandos (que no es mucho en Glypho). Si bien esto me permitió resolver los dos primeros problemas con bastante facilidad, dudo que Glypho pueda ejecutar a los demás con tan pocos personajes.

Los probé usando el intérprete de Java recuperado del 23/06/2006 en la máquina wayback , que usa una asignación ligeramente diferente de los comandos:

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

El programa Run se traduce en:

1d-+[...]

¿Dónde ...hay basura que no me molesté en traducir?

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

El programa IO se traduce en:

id1-+o1+o

Esto es lo que hace esto:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74 - 14) + (74 - 26) = puntaje 182

1. Ejecutar (74 bytes)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Pasar e#al frente comenta toda la línea.

2. E / S (14 bytes)

9`)ZH*+~):Q(Q)

Dennis ahorró 8 bytes.

Explicación:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Branchability (26 bytes)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Explicación:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Veré a los otros más tarde. ( EDITAR : dudo que sean posibles, sin literales de bloque o cadena ... ¿tal vez el matemático?)

J, puntaje 71 + (74-19) = 126

Tarea 1, longitud 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Esto define un verbo AHILOpara ser el interior. No usado:

)))

No creo que haya forma de alargarse más que esto.

Tarea 3, longitud 19

+($#~$~4)=1e4|&%:*~

La forma de hacer esta tarea sin restricciones es la +16=100|]siguiente:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Tenemos +, =y varias copias o |a nuestra disposición, y es fácil moverse ], pero los números son más problemáticos. Aquí está la primera parte que calcula el módulo de entrada 100:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Una vez que hayamos terminado con eso, produzcamos el número 16. La manera fácil es con *~4(4 multiplicado consigo mismo), pero ya lo usamos, *así que está prohibido. En cambio, haremos alguna manipulación de matriz.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

Trabajo

2

Esto es definitivamente imposible. Las únicas formas de manipular los valores de los caracteres son a.y u:, y no tenemos acceso a ninguno.

Ahora, si pudiéramos usar en alugar de, digamos A, entonces, esta sería una solución:

Q{~(*^.4%9 1)+I.~&Q=:a.

La parte más difícil para que esto funcione fue producir el número -1.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4 4

(*.1:"|~@+.)

Esto genera la forma de la cáscara, pero parece que no puedo encontrar una manera de generar personajes. Pobre de mí.

5 5

Es cierto que esta parece ser la tarea más fácil de hacer en J. Sin embargo, sin i.esto, será bastante difícil.

6 6

Es probable que esto sea imposible sin un quine falso 449o algo así, porque la cadena de cápsulas no contiene comillas ni ninguna otra forma de producir cadenas J.

PowerShell - Puntuación total: 74

1. Carrera - Puntuación: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

Dado que esto es extremadamente difícil en PowerShell (por lo que puedo decir, todos los métodos posibles para obtener información son imposibles con los caracteres dados), al menos he decidido aleatorizar el primer desafío para que no todos estemos copiando el ejemplo directamente del post.

Así que aquí hay un desafío aleatorio 1 generador de respuestas (para idiomas donde #hay un comentario):

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Pruébalo en línea!

memes , puntuación de ( 62 65 + 70) 135

1: Ejecutar

Eliminé todos los backticks ( `) y operadores matemáticos. Entraron en conflicto porque no había suficientes números para satisfacer a todos los operadores unarios y binarios. Dejé algunos adentro, resultando en +3 bytes . Programa resultante:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

No tengo idea de por qué y cómo funcionó. Al menos no arroja ninguna excepción de tiempo de ejecución de C # y, por lo tanto, no se bloquea.

6: Quine

Sabes, si hubiera habido una -o minúscula qen algún lugar de esos 74 caracteres, esto sería demasiado fácil. Me alegro por el Ioperador, al menos.

1/4I

Este código no es exactamente obvio. Aquí hay una explicación:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Las cadenas de fracciones (p 1/4. Ej. ) Se muestran con una I al final, para indicar exactamente eso. El Ioperador suele ser inútil, lo agregué por otros medios, pero bueno, ¡funciona así!

El código anterior no es válido. Estúpido, no vi que los 74 caracteres no contienen un solo operador de división, forwardslash ( /). Sin embargo, se me ocurrió algo más:

True

Explicación:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Salidas True(debido a la forma en que C # maneja Boolean.ToString()mayúsculas y no minúsculas). No estoy seguro de si se trata de una quine adecuada, mientras tanto todavía me estoy rompiendo la cabeza por una válida, realmente adecuada e intuitiva.

Tal vez también podría resolver el desafío de E / S y matemáticas, pero me faltan tokens (caracteres) específicos que no están incluidos en los 74 caracteres.

Brainfuck, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Solo tenía que hacerlo.

Explicación:

Cualquier personaje que no sea un personaje válido de Brainfuck se trata como un comentario. El único código que realmente se ejecuta es este:

.+..

Esto no produce resultados imprimibles, ya que ni 0 ni 1 son caracteres imprimibles en ASCII. Sin embargo, no causa un error, por lo que completamos con éxito el primer desafío.

Mathematica, puntaje de 62

Me sorprendería si alguien puede hacer que los desafíos 2-6 funcionen en Mathematica. Aquí está lo mejor que hice con el desafío 1:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

Define una función bastante estúpida Acon un valor constante. Los 12 caracteres no utilizados son:

)))\\`````{~

Octava, puntaje 74

1. Ejecutar

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

50 de estos caracteres son parte de la función, mientras que los 24 restantes no lo son.

Que hace:

x =@(AHILOQQQTTZeefmpy)crea una función xque puede tomar una variable AHILOQQQTTZeefmpycomo entrada.

Para entender el resto:

a||bllama a la función all()en ambos ay b. Si uno o ambos devuelven verdadero, el ||operador devolverá verdadero.

!ay ~asignifica lo mismo aquí, son ambos not(a).

a.^b es un poder de elemento sabio (a(1)^b(1), a(2)^b(2) ...)

Explicación continua

Acortaré cada uno de los pasos a medida que avance:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

Y:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

Hay un número par de not, por lo que es equivalente a not(not(4))cuál es trueo 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

El resto está comentado.

*> <> , puntaje total = 74

1. Corre, anota 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Pruébalo aquí!

Esto fue extremadamente difícil de hacer sin el ;personaje. De hecho, pensé que iba a ser imposible por un par de momentos, hasta que vi el %, básicamente me di por vencido.

Este también es un programa válido> <>.

Explicado (partes irrelevantes omitidas)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Desafíos enfrentados

Podría intentar los otros desafíos ... serían extremadamente difíciles y podrían involucrar doblar las reglas de maneras extrañas, pero el uso liberal de los |espejos y los !trampolines debería hacer posible al menos un desafío más.

Estos desafíos son particularmente difíciles porque no se nos permite ninguna salida con *> <> ( oy n), o incluso llamadas a funciones ( C), retornos de funciones ( R) o terminadores de programa ( ;). Aunque también nos faltan ientradas, todavía podemos tener entradas colocadas en la pila, lo cual es una ventaja. Otra ventaja es que obtenemos una sola pinstrucción, que nos permite reemplazar una instrucción en el cuadro de código. Esto podría usarse varias veces (aún no he descubierto una forma práctica), lo que comenzaría a hacer que los otros programas parezcan más posibles (ya que podríamos generar dos o más instrucciones).

Haskell, puntaje 63

1. Ejecutar:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

No se utilizan son )))```````{. Los comentarios en Haskell son --o {- ... -}, por lo que no hay una versión fácil de todos los comentarios.

Este código define un operador infijo !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~que toma dos argumentos:

1. fmpxyAHILOQQQTTZ que se ignora y, por lo tanto, puede ser de tipo arbitrario
2. e, que debe ser una función que tome dos números

En la función, el cuerpo ese aplica a 14 y 49, usando la `notación de inserción.

Ejemplo de uso:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

El operador se aplica a ()la tupla vacía y (*)al operador de multiplicación, por lo que 14*49 = 686se calcula.

Pruébalo en línea!

Otros desafíos

Dudo que alguno de los otros desafíos sean posibles, especialmente debido a la falta de posibles nombres de variables que pueden aparecer dos veces, que es solo e(o algo así eQT), porque los nombres de variables no pueden comenzar con una letra mayúscula. Por supuesto, tener solo uno =tampoco ayuda.

Pyth, 131 por ahora (2 desafíos completos)

1. Run, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Este programa no tiene entrada y no crea salida.

Este programa utiliza $$, lo que permite la ejecución de código arbitrario, por lo que está prohibido en línea, por lo que este programa en línea se ejecuta sin conexión. Aquí está su salida de compilación, para que pueda ver lo que realmente se ejecuta:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

Es bastante complicado escribir un programa con caracteres arbitrarios que no produzca errores en Pyth. Me planteé el desafío adicional de exigir que el programa se ejecute sin requerir también la intervención del usuario.

El primer paso es usar #para comer todos los errores. A continuación, debemos evitar los errores causados ​​por ~, Iy L, cada uno con sus propios detalles. Esto se logra colocándolos dentro del $$, que los incrusta dentro de la compilación de salida, y por lo tanto los somete a las reglas de compilación de Python, no a Pyth. Finalmente, para evitar tomar la entrada del usuario, los diversos tokens de arity 0 (Variables y similares) se colocan al final, y los Qs se mueven dentro del $$bloque.

2. IO

Esto será increíblemente difícil, si es posible. Ninguna de las funciones de Pyth que crean cadenas o caracteres arbitrarios están presentes .f, excepto , y eso hace un trabajo realmente pobre de crear caracteres arbitrarios.

3. Branchabilidad: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Pruébalo en línea

Un programa Pyth equivalente sería:

?n%Q100 16Q+1

Este código toma el mod de entrada 100, lo compara con 16, y luego usa un ternario para elegir entre la entrada y la entrada más uno. Debido a restricciones de caracteres, hice algunas sustituciones:

• En lugar del ?ternario que utilicé |&, orentonces and, que tiene la misma funcionalidad, excepto que se rompe si la entrada es cero, pero como se nos garantiza una entrada entera positiva, está bien. (Esto podría haberse solucionado sin caracteres adicionales, pero es más simple de esta manera).

• En lugar de comparar directamente los dos números, tomo su XOR con x, que es cero si y solo si son iguales, según lo deseado.

• En lugar de escribir 100directamente, lo genero con *TT, ya que Tse inicializa en 10.

• En lugar de escribir 16directamente, lo genero con ye|LZ9. |LZesencialmente funciona como la función de rango, por lo que |LZ9da [0, 1, 2, 3, 4, 5, 6, 7, 8]. etoma el elemento final de una lista, dando 8. ylo dobla, dando lo 16que desee. Con un extra +o un extra *, podría guardar un personaje, pero ambos son más útiles en otros lugares.

¡Más por venir!

Rubí - Puntuación: 74

1. Ejecutar

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Agarrado del desafío.

JavaScript (ES6), puntuación = 74

1. Ejecutar, 74 bytes

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Esoterismo (inválido)

Para el registro, mi quine sugerido fue:

1.4e+49

que resultó no ser válido, como se analiza en los comentarios a continuación.

Retina, puntaje 74

1. Corre, anota 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

Moví los parens adicionales a la configuración para que se equilibren en la expresión regular. También me moví a la `derecha después de eso, y cambié +.a .+.

Pruébalo en línea

Los otros son probablemente imposibles, ya que no hay nuevas líneas. Tampoco hay -para la transliteración o dpara una clase de caracteres de dígitos.

Pip, puntaje 74 + (74-19) = 129

¡Tantos backticks sin una cita para ver, simple o doble!

Tarea 1, puntaje 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Básicamente solo una serie de literales de patrón (regex) en backticks, el último de los cuales se imprime. Como hay un número impar de backticks, tenemos que hacer una barra invertida para escapar de uno de ellos ( `\``). Pruébelo en línea , con la -wbandera agregada para demostrar que no se generan advertencias.

Tarea 3, puntaje 55 (longitud 19)

e+!!e%(1.#x.!9)=4*4

Usando un método de entrada bastante extraño, el quinto argumento de la línea de comandos, esto es posible. Pruébalo en línea!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Otras tareas

Es posible obtener información para la tarea 2 , por el mismo método que la tarea 3 anterior. El problema es convertir a código ASCII y volver a un carácter. Se puede hacer lo primero A, pero lo último requiere C, o posiblemente indexar en la PAvariable. La construcción y evaluación del código no se puede hacer sin V. No creo que la tarea sea posible.

La tarea 4 es desafiante incluso sin un conjunto de caracteres restringido. Supongo que requeriría listas (sin usar los []delimitadores o RL(lista de repetición) y solo tener una oportunidad de usar AL(agregar lista) - no es probable) o posiblemente algo con CG(cuadrícula de coordenadas) o MC( coordenadas de mapa), ambos no permitidos .

La tarea 5 está al borde de la posibilidad. Los bucles serían difíciles, ya que Fo y Map no son posibles, y no se pueden construir rangos ,. Puede haber algo que hacer con Tenfermedad. El incremento podría ser de la x:x+1variedad (obviamente con una variable distinta de x). Se pueden usar controles de divisibilidad %. Aún así, no creo que haya suficientes caracteres, especialmente letras repetidas, para hacer todo lo que debe suceder.

La tarea 6 parece completamente imposible. Todos los Pip quines conocidos tienen "en ellos. También usan R(reemplazar), RP(repr) o V(eval), ninguno de los cuales está disponible.

En realidad, puntaje (74 + 0 + 0 + 0 + 0 + 0 ) = 74

Sí, la cadena de la cápsula funcionará con Actually como lo es para Run, ya que en realidad descarta cualquier error y cada error se convierte en un NOP.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%(¡ Pruébelo en línea! )

Sin embargo, generará un desastre de cosas (pero también su fuente una vez: 3).

Sin embargo, trabajaré en otros desafíos.

05AB1E - Puntuación total: 74

1. Ejecutar, 74 bytes

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

05AB1E omite todo lo que causa un error. Toda esta línea de código es un NOP.

Pruébalo en línea!

(abusado) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

El intérprete de PHP simplemente volca el código fuente hasta que encuentra una, <?ya que nos falta <cada permutación de esos caracteres es una quine en ejecución. Supongo que esto no es peor que usar un comando quine incorporado: P

Mathematica, puntaje 68

`A: = .1% *. 44y # +. 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | f | m | p | x) !!!!! & \

Observe la nueva línea final. No creo que ninguno de los otros desafíos se pueda lograr con Mathematica.

Laberinto, puntaje 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Estoy bastante seguro de que cualquier variedad de estos personajes produce un programa Labyrinth válido, pero para hacerlo al menos un poco más interesante, esto se imprime 2016dígito a dígito. (En resumen: presione 2 2's en la pila, pop / print uno, mueva el otro a la pila auxiliar, imprima 0, presione 2 1' s en la pila, pop / print 1, incremente, bit a bit no, niegue (eso último 1es a 3en este punto), suma con el 2de la pila auxiliar, 5 * 10 + 4 = 54, imprime como valor ASCII, termina)

La mayor parte de la línea larga simplemente se ignora, ya que @termina el programa.

Los desafíos 2, 3 y 4 son imposibles ya que ninguno de los comandos de entrada de Labyrinth están disponibles ( ,o ?), y no se me ocurrió nada para 5 o 6.

SmileBASIC, 48 puntos

desafío 1:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

explicación:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

otros:

No hay comandos de entrada / salida disponibles, por lo que el resto no es posible.

Aún así, no está mal para un idioma real sin usar comentarios.

MATL , puntaje total 74

1. Corre, anota 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Todo depende del %código real. %es un símbolo de comentario, por lo que los caracteres a su derecha se ignoran.

El programa sale 1sin errores.

Pruébalo en línea!

golpe, puntaje 74

1: correr. Podemos correr los 74

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Esoterismo:

El programa vacío es una quine en bash.

Sin ningún espacio en blanco, no se puede lograr nada más en la lista. Ergo, tengo la entrada ganadora de bash.

Perl 6 , puntaje total 74

1. Corre, anota 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Sin comentarios.
(Solo poner el #frente para hacer todo un comentario también funciona, pero esto es más divertido).

Trabajo

Este es el subconjunto del lenguaje Perl 6 que solo usa los caracteres permitidos:

Constantes: e

Escriba los nombres: IO

Funciones: exp

Métodos:
    en tipo IO: .e .f .x
    (... probablemente más).

Operadores: | infijo: | prefijo:
    ----------- + ----------------------- + ---------
    numérico: | + * + ^ + | + &% | + + ^
    cadena: | ~ x ~ ^ ~ | ~ & | ~
    booleano: | || ~~ | !
    cruces: | El | & ^ |  
    misceláneo: | =: = Z .. ... |  

sintaxis:
    literales numéricos: 1 4 9
    literales de cadena: Q``Q! ! etc.
    comandos de shell: Q: x``P: x! ! etc.
    Cualquier estrella: *
    variables: my \ $ @ &
    agrupación: ()
    comentarios: # # `()
    unspace: \

El obstáculo inmediato para evitar los desafíos 2-6 es que no parece haber una manera de hacer E / S:

• Si suponemos que hay un archivo llamado f, podríamos usarlo Q`f`.IO.epara verificar si existe o Q`f`.IO.xpara verificar si es ejecutable. Pero no podemos leerlo ni escribir desde él.

• Podríamos usar Q:x` `para ejecutar un comando de shell (suponiendo que encontremos los caracteres para uno). Pero no podemos interpolar nada, por lo que solo sería bueno para leer, no para escribir.

• Como no hay llave de cierre, no podemos hacer un bloque lambda (por ejemplo {1 + $_}) que devuelva automáticamente el valor de su última instrucción.

• Nosotros podríamos utilizar el asterisco para hacer una expresión lambda (por ejemplo 1+*), pero entonces sólo podemos tener un argumento, se refieren a este argumento sólo una vez, y son aún más limitadas en la sintaxis / operadores que podemos utilizar.

Lua, puntaje 31

1. Carrera (31 de 74 puntos)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Gelatina , puntaje 74

1. Run , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

No estoy seguro de cómo hacer cualquiera de los otros.

/// , Puntuación: 146

1. Correr, Puntuación: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Puntuación: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Yay, cuando no hay ninguna barra diagonal hacia adelante o hacia atrás en el código, solo se imprime.