Escriba un programa que incluya un número N del 1 al 9 inclusive. En su forma nativa, su programa debería generar N + NEg 2si N es 1, 4si N es 2, 6si N es 3, y así sucesivamente.

Cuando todos los caracteres de su programa se duplican en su lugar, debe ser un programa que incorpore N (aún del 1 al 9) y genere N × NEg de salida 1si N es 1, 4si N es 2, 9si N es 3, y así sucesivamente.

Cuando todos los caracteres de su programa se triplican en su lugar, debe ser un programa que incorpore N (aún del 1 al 9) y genere N ^ NEg de salida 1si N es 1, 4si N es 2, 27si N es 3, 387420489si N es 9, etc.

Los números superiores a 9 no son necesarios porque 10 ^ 10 está fuera del rango entero habitual de muchos idiomas.

Ejemplo

Si su programa inicial fue

My_Program!
Exit();

Entonces debería ser capaz de absorber N y generar N + N.

Además, el programa

MMyy__PPrrooggrraamm!!

EExxiitt(());;

debe tomar N y salir N × N.

Finalmente el programa

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

debería tomar N y generar N ^ N.

No se requieren programas de caracteres cuádruples y más.

Reglas

• La entrada y la salida deben ser números decimales simples, normalmente formateados. Puede responder utilizando una base diferente para mostrar su código, pero luego su respuesta no es competitiva.

• Los usuarios de Windows pueden tratar \r\ncomo un solo personaje, ya que cosas como \r\r\n\nno tendrían sentido o tal vez incluso funcionarían.

• El programa nativo más corto (el N + N) en bytes gana.

Jalea , 12 bytes

N + N

“(ẹ+)‘FQṖṪỌv

Pruébalo en línea!

N × N

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv

Pruébalo en línea!

N ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv

Pruébalo en línea!

Cómo funciona

Jelly tiene varios tipos diferentes de literales de cadena; todos comienzan con a “. Si el literal contiene más de uno “, se devuelve una matriz de cadenas y las “separa unas de otras.

Por ejemplo, “abc“def”rendimientos ['abc', 'def'].

Dependiendo del último carácter del literal (cualquiera de ”«»‘’, donde no «está implementado actualmente), uno puede elegir entre los diferentes tipos de literales. Para ‘, obtenemos los puntos de código en la página de códigos de Jelly en lugar de los caracteres Unicode correspondientes.

Por ejemplo, “abc“def‘rendimientos [[97, 98, 99], [100, 101, 102]].

Los tres literales en los programas corresponden a las siguientes matrices de puntos de código.

“(ẹ+)‘           -> [40, 214, 43, 41]
““((ẹẹ++))‘      -> [[], [40, 40, 214, 214, 43, 43, 41, 41]]
“““(((ẹẹẹ+++)))‘ -> [[], [], [40, 40, 40, 214, 214, 214, 43, 43, 43, 41, 41, 41]]

N + N

“(ẹ+)‘FQṖṪỌv                          Main link. Argument: n

“(ẹ+)‘                                As before.
      F                               Flatten the array. Yields an integer array.
       Q                              Unique; deduplicate the integers.
                                      This yields [40, 214, 43, 41].
        Ṗ                             Pop; remove the last element.
         Ṫ                            Tail; extract the last element. 
                                      This yields 43, the Unicode code point of +.
          Ọ                           Unordinal; cast to character.
           v                          Eval; execute the character as a Jelly
                                      program with argument n.

N × N

““((ẹẹ++))‘‘FFQQṖṖṪṪỌỌvv              Main link. Argument: n

““((ẹẹ++))‘                           As before.
           ‘                          Increment all integers.
            FF                        Flatten the array. Yields an integer array.
              QQ                      Unique; deduplicate the integers.
                                      This yields [41, 215, 44, 42].
                ṖṖ                    Pop twice; remove the last two elements.
                  ṪṪ                  Tail; extract the last element.
                                      This yields 215, the Unicode code point of ×.
                    ỌỌ                Unordinal; cast to character.
                      v               Eval; execute the character as a Jelly
                                      program with argument n.
                       v              Eval; convert the return value (n×n) to a
                                      string and execute that string as a Jelly
                                      program with argument n. Since the string
                                      consists of a single integer literal, that
                                      integer is returned, ignoring the argument.

Tenga en cuenta que F, Q, Ṫ, y Ọno alteran las matrices, arrays 1D sin duplicados, enteros y caracteres (respectivamente).

N ^ N

“““(((ẹẹẹ+++)))‘‘‘FFFQQQṖṖṖṪṪṪỌỌỌvvv  Main link. Argument: n

“““(((ẹẹẹ+++)))‘                      As before.
                ‘‘                    Increment all integers twice.
                  FFF                 Flatten the array. Yields an integer array.
                     QQQ              Unique; deduplicate the integers.
                                      This yields [42, 216, 45, 43].
                        ṖṖṖ           Pop thrice; remove the last three elements.
                           ṪṪṪ        Tail; extract the last element.
                                      This yields 42, the Unicode code point of *.
                              ỌỌỌ     Unordinal; cast to character.
                                 v    Eval; execute the character as a Jelly
                                      program with argument n.
                                  vv  Eval twice. See N×N.

> <> , 41 bytes

\<
1:: :
&&* +
i*n n
c&
%:
4l
0(
.i
n}
&?

Pruébelo en línea: N + N , N * N , N ^ N . Asume que la entrada STDIN es exactamente un carácter.

> <> es un lenguaje 2D, por lo que podemos aprovechar el hecho de que la semántica de código no cambia en su mayoría si ejecutamos las instrucciones hacia abajo: las líneas vacías adicionales que se obtienen no son operaciones. La excepción a esto es el trampolín condicional ?que muestra un valor y omite la siguiente instrucción si el valor no es cero: las nuevas líneas adicionales se estropearían ?debido a las no-operaciones insertadas, pero podemos solucionar esto colocando el ?al final de una columna y aprovechando el envoltorio.

Para decidir qué operación ejecutar, la clave es 40., que teletransporta la IP a la posición (4, 0). Debido a la expansión del código, la x = 4columna corresponde al +programa base, *al programa duplicado y ^al programa triplicado. Desafortunadamente> <> no tiene exponenciación incorporada, lo que hace que la mayor parte del programa.

[Setup]
\         Mirror: reflect IP direction to downwards
1&        Put 1 into the register
ic%       Push a code point of input, then take it mod 12. This maps the char '1' to the
          number 1, and so forth for '2' to '9'.
40.       Jump to (4, 0), still heading downwards

[N+N version]
:+        Duplicate then add
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N*N version]
:*        Duplicate then multiply
n         Output as number
          (Stack is now empty, so the program errors out trying to do the above again)

[N^N version]
:&*&      Multiply register by N
:l(       Push (N < length of stack + 1)
i         Push input, but since we're now at EOF this pushes -1 (stack length += 1)
}         Move -1 to the back
?<        If (N < length + 1) was 1, execute the < to move leftward. Otherwise, skip it.
          (Continue loop)

\         Mirror: reflect IP direction upwards
&n        Output register
.         Jump to (-1, N), which is invalid so the program errors out

TovTovTov (una mutación de pollo ): 810147050 bytes

A continuación se describen dos soluciones sugeridas: una solución completa a la pregunta que requiere muchos bytes y una segunda solución parcial (que resuelve solo las partes N + N y N * N , que requieren solo 484 bytes), cada una con un enfoque diferente y su propio conjunto de trucos geniales! :)

1. Solución completa (810147050 bytes)

Usando TovTovTov(TOV='hi',SEP=','), los TOVelementos son inmunes a la duplicación de caracteres en su lugar (ambos "hihihi"y "hhiihhiihhii"tienen tres "hi"s en ellos, y lo único que TovTovTovimporta es cuántos TOVs aparecen entre SEPs).

Si lo usáramos SEP=', ', todo el programa sería inmune a la duplicación de caracteres (lo cual es genial, pero no resolverá la pregunta). Entonces lo usamos SEP=','.

Entonces, el programa "hihihi,hi", por ejemplo, compila a la matriz de ints [3,1], mientras que "hhiihhiihhii,,hhii"compila a [3,0,1]y "hhiihhiihhii,,hhii"hacia [3,0,0,1]. Esto significa que los comandos en sí mismos no cambian su significado después de la duplicación, pero la longitud total cambia con la duplicación de caracteres. La solución a continuación consulta la duración del programa y la utiliza para decidir si se debe imprimir N+N, N*No N^N.

La solución completa sugerida, como matriz de ints, es: [6, 12, 9, 18, 9, 142, 11, 38, 8, 9, 260, 11, 73, 8, 22, 75, 7, 10, 14, 3, 1, 22, 24, 18, 15, 8, 10, 16, 3, 1, 22, 24, 18, 15, 8, 10, 45, 16, 7, 22, 3, 1, 22, 24, 18, 15, 8, 22, 3, 1, 22, 24, 18, 15, 8, 25, 3, 1, 22, 24, 18, 15, 8, 48, 3, 1, 22, 24, 18, 15, 8, 277, 3, 1, 22, 24, 18, 15, 8, 3146, 3, 1, 22, 24, 18, 15, 8, 46677, 3, 1, 22, 24, 18, 15, 8, 823564, 3, 1, 22, 24, 18, 15, 8, 16777237, 3, 1, 22, 24, 18, 15, 8, 387420510, 3, 1, 22, 24, 18, 15, 8]

Como una cadena, es un programa bastante largo, que consta de 810147050 caracteres, comenzando con: hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. Resolver solo las partes N + N y N * N de la pregunta (484 bytes)

Utilizando TovTovTov(TOV='1',SEP=', '), esta vez los SEPs son inmunes a la duplicación ( ",, "todavía tiene solo uno ", "), por lo que la siguiente solución sugerida siempre tendrá 33 comandos, incluso después de la duplicación de caracteres:

1111, 111111111111111111111111111111111111111111111111, 1111111111, 1111111111, 1111111111, 111111, 111111111111, 111111111, 11111111111111, 111, 1, 1111111111111111111111, 111111111111111111111111, 111111111111111111, 111111111111111, 11111111, 111111111111, 1111111111111111, 111111111111111, 1111111111111111111111, 111111111111111111111111111111111111, 11, 1111111111111111111111111111, 111111, 111, 111111, 11111111111, 111111111111111111111111111, 1111, 1, 11111111, 1, 11111111

La matriz de ints correspondiente (el número de TOVs ( 1s) en cada uno de los 33 comandos anteriores) es la siguiente:[4,48,10,10,10,6,12,9,14,3,1,22,24,18,15,8,12,16,15,22,36,2,28,6,3,6,11,27,4,1,8,1,8]

Duplicar los caracteres en el lugar da como resultado una lista de 33 comandos totalmente diferentes : [8,96,20,20,20,12,24,18,28,6,2,44,48,36,30,16,24,32,30,44,72,4,56,12,6,12,22,54,8,2,16,2,16]

La matriz de enteros originales (que calcula N + N ) fue diseñado cuidadosamente para que después de los comandos cambian su significado, el programa todavía tiene sentido, pero calcula N * N . Por ejemplo, el primero 4(que se TovTovToventiende como "tratar la siguiente operación como un código ASCII para convertir a un carácter") cambia después de la duplicación de caracteres 8, que es un comando totalmente diferente ("cambiar el contador del programa al primer valor emergente del pila, si el valor aparecido inmediatamente después es verdadero ").

Befunge-98 , 38 bytes

vx:k:2-k*.@
20@
j3.
>^*
>:^
>:+.@

Pruébelo en línea: N + N , N * N , N ^ N

Este programa no funcionará de inmediato, ya que requiere que la entrada esté en la pila al comienzo de la ejecución. Al reemplazar la primera línea con el siguiente código (agregando tres bytes) tomará la entrada de stdin (aunque esto no funciona en tryitonline.net, lamentablemente):

v
&x:k:2-

Explicación

Preparar

v       Redirect motion downward
02j     Jump over two instructions/spaces, executing the third
        If N=1, it will skip to the 6th line
        If N=2, it will skip to the 5th line
        If N=3, it will skip to the 4th line

N = 1

>       Move right
:+.@    Duplicate, add, print and exit

N = 2

>>::^^  Move right, duplicate twice, move up
*.@     Multiply, print and exit

N = 3

>>>^^^  Redirect motion
30x     Set instruction pointer delta to (3, 0), causing it to
        move right, executing every third instruction
:k:     Duplicate the number (we'll call it M) M+1 times
        The stack is now [M]*(M+2)
2-k*    Multiply things M-1 times (`k' is a quirky instruction)
.@      Print and exit