Escreva um programa que inclua um número N de 1 a 9, inclusive. Em sua forma nativa, seu programa deve gerar N + NEg 2se N for 1, 4se N for 2, 6se N for 3, e assim por diante.

Quando todos os caracteres do seu programa são duplicados no local, deve ser um programa que absorva N (ainda de 1 a 9) e emita N × NEg 1se N for 1, 4se N for 2, 9se N for 3, e assim por diante.

Quando cada caractere em seu programa é triplicado, deve ser um programa que recebe N (ainda de 1 a 9) e gera saída N ^ NEg 1se N for 1, 4se N for 2, 27se N for 3, 387420489se N for 9, etc.

Números acima de 9 não são necessários porque 10 ^ 10 está fora do intervalo inteiro usual de muitos idiomas.

Exemplo

Se o seu programa inicial foi

My_Program!
Exit();

Então deve ser capaz de receber N e emitir N + N.

Além disso, o programa

MMyy__PPrrooggrraamm!!

EExxiitt(());;

deve receber N e gerar N × N.

Finalmente, o programa

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

deve receber N e gerar N ^ N.

Programas de caracteres quádruplos e além não são necessários.

Regras

• A entrada e a saída devem ser simples, números decimais normalmente formatados. Você pode responder usando uma base diferente para exibir seu código, mas sua resposta não é competitiva.

• Os usuários do Windows podem tratar \r\ncomo um caractere, pois coisas como \r\r\n\nnão faria sentido ou talvez até funcionassem.

• O programa nativo mais curto (o N + N) em bytes vence.

Gelatina , 12 bytes

N + N

“(ẹ+)‘FQṖṪỌv

Experimente online!

N × N

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

Experimente online!

N ^ N

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

Experimente online!

Como funciona

A geléia tem vários tipos diferentes de literais de string; todos eles começam com a “. Se o literal contiver mais de um “, uma matriz de strings será retornada e “separará as strings umas das outras.

Por exemplo, “abc“def”rendimentos ['abc', 'def'].

Dependendo do último caractere do literal (qualquer um dos ”«»‘’, onde «atualmente não está implementado), é possível escolher entre os diferentes tipos de literais. Pois ‘, obtemos os pontos de código na página de códigos do Jelly em vez dos caracteres Unicode correspondentes.

Por exemplo, “abc“def‘rendimentos [[97, 98, 99], [100, 101, 102]].

Os três literais nos programas correspondem às seguintes matrizes de pontos 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.

Note-se que F, Q, Ṫ, e Ọnão alteram matrizes 1D, matrizes sem duplicados, números inteiros, e 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}
&?

Experimente on-line: N + N , N * N , N ^ N . Supõe que a entrada STDIN seja exatamente um caractere.

> <> é uma linguagem 2D, para que possamos usar o fato de que a semântica de código é praticamente inalterada se executarmos as instruções para baixo - as linhas vazias extras que se seguem são apenas não operacionais. A exceção a isso é o trampolim condicional ?que gera um valor e ignora a próxima instrução se o valor for diferente de zero - as novas linhas extras atrapalhariam ?devido às no-ops inseridas, mas podemos contornar isso colocando o ?no final de uma coluna e aproveitando a quebra.

Para decidir qual operação executar, é a chave 40.que teleporta o IP para a posição (4, 0). Devido à expansão do código, a x = 4coluna corresponde ao +programa base, *ao programa duplicado e ^ao programa triplicado. Infelizmente, o <<> não possui exponenciação incorporada, tornando-o a maior parte do 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 (uma mutação de Chicken ): 810147050 bytes

A seguir, são descritas duas soluções sugeridas: uma solução completa para a questão que requer muitos bytes e uma segunda solução parcial (resolvendo apenas as partes N + N e N * N , exigindo apenas 484 bytes), cada uma adotando uma abordagem diferente e própria conjunto de truques legais! :)

1. Solução completa (810147050 bytes)

Usando TovTovTov(TOV='hi',SEP=','), os TOVelementos são imunes à duplicação de caracteres no lugar (ambos "hihihi"e "hhiihhiihhii"têm três "hi"s neles, e tudo se TovTovTovpreocupa é com quantos TOVs aparecem entre SEPs).

Se usássemos SEP=', ', o programa inteiro seria imune à duplicação de caracteres (o que é legal, mas não resolve a questão). Então nós usamos SEP=','.

Portanto, o programa "hihihi,hi", por exemplo, compila na matriz ints [3,1], enquanto "hhiihhiihhii,,hhii"compila para [3,0,1]e "hhiihhiihhii,,hhii"para [3,0,0,1]. Isso significa que os próprios comandos não mudam de significado após a duplicação, mas o comprimento geral muda com a duplicação de caracteres. A solução abaixo consulta a duração do programa e usa isso para decidir se quer imprimir N+N, N*Nou N^N.

A solução completa sugerida, como matriz ints, é: [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 uma sequência, é um programa bastante longo, composto por 810147050 caracteres, começando com: hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. Resolvendo apenas as partes N + N e N * N da pergunta (484 bytes)

Usando TovTovTov(TOV='1',SEP=', '), desta vez, os SEPs são imunes à duplicação ( ",, "ainda tem apenas um ", "), portanto, a seguinte solução sugerida sempre terá 33 comandos, mesmo após a duplicação 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

A matriz ints correspondente (o número de TOVs ( 1s) em cada um dos 33 comandos acima) é a seguinte:[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 os caracteres no local resulta em uma 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]

A matriz original é ints (que calcula N + N ) foi concebido com cuidado de modo que depois os comandos alterar o seu sentido, o programa ainda faz sentido, mas calcula N * N . Por exemplo, o primeiro 4(que TovTovToventende como "tratar a próxima operação como um código ASCII para converter em um caractere") muda após a duplicação de caracteres para 8, que é um comando totalmente diferente ("altere o contador de programa para o primeiro valor populado do pilha, se o valor exibido imediatamente após for verdadeiro ").

Befunge-98 , 38 bytes

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

Experimente online: N + N , N * N , N ^ N

Este programa não funciona imediatamente, pois requer entrada na pilha no início da execução. Substituindo a primeira linha pelo código a seguir (adicionando três bytes), será recebida a entrada do stdin (embora isso não funcione no tryitonline.net, infelizmente):

v
&x:k:2-

Explicação

Configuração

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