Scrivi un programma che includa un numero N da 1 a 9 incluso. Nella sua forma nativa, il tuo programma dovrebbe produrre N + NEg 2se N è 1, 4se N è 2, 6se N lo è 3e così via.

Quando ogni personaggio nel tuo programma è duplicato, allora dovrebbe essere un programma che accetta N (sempre da 1 a 9) e genera un output N × NEg 1se N è 1, 4se N lo è 2, 9se N lo è 3e così via.

Quando ogni carattere nel tuo programma è triplicato, allora dovrebbe essere un programma che accetta N (sempre da 1 a 9) e produce N ^ NEg 1se N è 1, 4se N è 2, 27se N è 3, 387420489se N è 9, eccetera.

I numeri sopra 9 non sono richiesti perché 10 ^ 10 è al di fuori dell'intervallo normale di molte lingue.

Esempio

Se il tuo programma iniziale era

My_Program!
Exit();

Quindi dovrebbe essere in grado di contenere N e produrre N + N.

Inoltre, il programma

MMyy__PPrrooggrraamm!!

EExxiitt(());;

dovrebbe contenere N e produrre N × N.

Finalmente il programma

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

dovrebbe contenere N e produrre N ^ N.

Non sono richiesti programmi con caratteri quadrupli e oltre.

Regole

• L'input e l'output devono essere numeri decimali normali, normalmente formattati. Puoi rispondere utilizzando una base diversa per mostrare il tuo codice ma la tua risposta non è competitiva.

• Gli utenti di Windows possono considerare \r\nun solo personaggio poiché cose come \r\r\n\nnon avrebbero senso o forse non funzionerebbero.

• Vince il programma nativo più breve (quello N + N) in byte.

Gelatina , 12 byte

N + N

“(ẹ+)‘FQṖṪỌv

Provalo online!

N × N

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

Provalo online!

N ^ N

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

Provalo online!

Come funziona

Jelly ha diversi tipi di letterali stringa; tutti iniziano con a “. Se il valore letterale ne contiene più di uno “, viene restituita una matrice di stringhe che “separa le stringhe l'una dall'altra.

Ad esempio, i “abc“def”rendimenti ['abc', 'def'].

A seconda dell'ultimo carattere del letterale (uno qualsiasi ”«»‘’, dove non «è attualmente implementato), si può scegliere tra i diversi tipi di letterali. Per ‘, otteniamo i punti di codice nella codepage di Jelly invece dei corrispondenti caratteri Unicode.

Ad esempio, i “abc“def‘rendimenti [[97, 98, 99], [100, 101, 102]].

I tre valori letterali nei programmi corrispondono alle seguenti matrici di punti di codice.

“(ẹ+)‘           -> [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.

Si noti che F, Q, Ṫe Ọnon altera array 1D, array senza duplicati, interi e caratteri (rispettivamente).

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 byte

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

Provalo in rete: N + N , N * N , N ^ N . Presuppone che l'ingresso STDIN sia esattamente un carattere.

> <> è un linguaggio 2D, quindi possiamo sfruttare il fatto che la semantica del codice è per lo più invariata se eseguiamo le istruzioni verso il basso: le righe vuote extra che ne conseguono sono semplicemente no-ops. L'eccezione a questo è il trampolino condizionale ?che fa apparire un valore e salta l'istruzione successiva se il valore era diverso da zero: le nuove linee extra potrebbero incasinare a ?causa delle no-op inserite, ma possiamo aggirare questo mettendo ?la fine una colonna e sfruttando il wrapping.

Per decidere quale operazione eseguire, la chiave è 40., che teletrasporta l'IP da posizionare (4, 0). A causa dell'espansione del codice, la x = 4colonna corrisponde a +per il programma di base, *per il programma raddoppiato e ^per il programma triplicato. Sfortunatamente> <> non ha esponentiation incorporato, il che rende la maggior parte del programma.

[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 mutazione del pollo ): 810147050 byte

Di seguito sono descritte due soluzioni suggerite: una soluzione completa alla domanda che richiede molti byte e una seconda soluzione parziale (risolvendo solo le parti N + N e N * N , che richiedono solo 484 byte), ognuna con un approccio diverso e una propria insieme di trucchi interessanti! :)

1. Soluzione completa (810147050 byte)

Usando TovTovTov(TOV='hi',SEP=','), gli TOVelementi sono immuni alla duplicazione dei personaggi in atto (entrambi "hihihi"e "hhiihhiihhii"hanno tre se "hi"in essi, e tutto ciò che TovTovTovimporta è quanti TOVs appaiono tra SEPi).

Se lo usassimo SEP=', ', l'intero programma sarebbe immune alla duplicazione dei personaggi (il che è interessante, ma non risolverà la domanda). Quindi usiamo SEP=','.

Quindi il programma "hihihi,hi", ad esempio, si compila nell'array ints [3,1], mentre si "hhiihhiihhii,,hhii"compila da [3,0,1]e "hhiihhiihhii,,hhii"verso [3,0,0,1]. Ciò significa che i comandi stessi non cambiano il loro significato dopo la duplicazione, ma la lunghezza complessiva cambia con la duplicazione dei caratteri. La soluzione qui di seguito interroga la durata del programma e la utilizza per decidere se stampare N+N, N*No N^N.

La soluzione completa suggerita, come ints array, è: [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]

Come stringa, è un programma piuttosto lungo, composto da 810147050 caratteri, che inizia con: hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. Risolvere solo le parti N + N e N * N della domanda (484 byte)

Usando TovTovTov(TOV='1',SEP=', '), questa volta le SEPs sono immuni alla duplicazione ( ",, "ne ha ancora solo una ", "), quindi la seguente soluzione suggerita avrà sempre 33 comandi, anche dopo la duplicazione dei caratteri:

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 matrice ints corrispondente (il numero di TOVs ( 1s) in ciascuno dei 33 comandi sopra) è la seguente:[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]

La duplicazione dei caratteri sul posto risulta in un elenco di 33 comandi totalmente diversi : [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]

L'array int originale (che calcola N + N ) creata con cura in modo che dopo i comandi cambiano il loro significato, il programma ha ancora senso, ma calcola N * N . Ad esempio, il primo 4(che TovTovTovcapisce come "tratta l'operazione successiva come un codice ASCII da convertire in un carattere") cambia dopo la duplicazione del carattere 8, che è un comando totalmente diverso ("cambia il Contatore del programma al primo valore spuntato dal stack, se il valore visualizzato immediatamente dopo è vero ").

Befunge-98 , 38 byte

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

Provalo online: N + N , N * N , N ^ N

Questo programma non funzionerà immediatamente poiché richiede che l'input sia nello stack all'inizio dell'esecuzione. Sostituendo la prima riga con il seguente codice (aggiungendo tre byte) ci vorrà l'input da stdin (anche se questo non funziona su tryitonline.net, purtroppo):

v
&x:k:2-

Spiegazione

Impostare

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