Ecrivez un programme qui prend un nombre N compris entre 1 et 9. Dans sa forme native, votre programme devrait générer une sortie N + NEg 2si N est 1, 4si N est 2, 6si N est 3, etc.

Lorsque chaque caractère de votre programme est dupliqué sur place, il devrait alors s'agir d'un programme qui prend N (toujours de 1 à 9) et génère N × NEg en sortie 1si N est 1, 4si N est 2, 9si N est 3, etc.

Lorsque chaque caractère de votre programme est triplé sur place, il doit s'agir d'un programme qui prend N (toujours de 1 à 9) et génère N ^ NEg en sortie 1si N est 1, 4si N est 2, 27si N est 3, 387420489si N est 9, etc.

Les nombres supérieurs à 9 ne sont pas obligatoires car 10 ^ 10 se situe en dehors de la plage entière de nombreuses langues.

Exemple

Si votre programme initial était

My_Program!
Exit();

Ensuite, il devrait être capable de prendre N et de sortir N + N.

De plus, le programme

MMyy__PPrrooggrraamm!!

EExxiitt(());;

devrait prendre N et sortir N × N.

Enfin, le programme

MMMyyy___PPPrrrooogggrrraaammm!!!


EEExxxiiittt((()));;;

devrait prendre N et sortir N ^ N.

Les programmes à quatre caractères et plus ne sont pas nécessaires.

Règles

• L'entrée et la sortie doivent être simples, des nombres décimaux normalement formatés. Vous pouvez répondre en utilisant une base différente pour afficher votre code, mais votre réponse est alors non compétitive.

• Les utilisateurs de Windows peuvent traiter \r\ncomme un seul personnage, car cela \r\r\n\nn'aurait pas de sens ou pourrait même fonctionner.

• Le programme natif le plus court (le N + N) en octets l'emporte.

Gelée , 12 octets

N + N

“(ẹ+)‘FQṖṪỌv

Essayez-le en ligne!

N × N

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

Essayez-le en ligne!

N ^ N

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

Essayez-le en ligne!

Comment ça fonctionne

Jelly a plusieurs types de littéraux de chaîne; tous commencent par un “. Si le littéral en contient plusieurs “, un tableau de chaînes est renvoyé et “sépare les chaînes les unes des autres.

Par exemple, les “abc“def”rendements ['abc', 'def'].

En fonction du dernier caractère du littéral (n'importe lequel des ”«»‘’, où «est actuellement non implémenté), on peut choisir entre les différents types de littéraux. En effet ‘, nous obtenons les points de code dans la page de code de Jelly au lieu des caractères Unicode correspondants.

Par exemple, les “abc“def‘rendements [[97, 98, 99], [100, 101, 102]].

Les trois littéraux des programmes correspondent aux tableaux de points de code suivants.

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

Notez que F, Q, ṪetỌ ne modifient pas les tableaux 1D, les tableaux sans doublons, les entiers et les caractères (respectivement).

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 octets

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

Essayez en ligne: N + N , N * N , N ^ N . Suppose que l’entrée STDIN a exactement un caractère.

> <> est un langage 2D, nous pouvons donc utiliser le fait que la sémantique du code reste la plupart du temps inchangée si nous exécutons les instructions vers le bas - les lignes vides supplémentaires qui en résultent ne sont que des no-ops. L'exception à cette règle est le trampoline conditionnel ?qui apparaît une valeur et passe à l'instruction suivante si la valeur était non nulle - les nouvelles lignes supplémentaires serait gâcher en ?raison de la non-ops inséré, mais nous pouvons contourner ce problème en mettant le ?à la fin de une colonne et en profitant de l'emballage.

Pour décider quelle opération à exécuter, la clé est 40., qui téléporte l’adresse IP en position (4, 0). En raison de l'extension du code, la x = 4colonne correspond au +programme de base, *au programme doublé et ^au programme triplé. Malheureusement, <> n'a pas d'exponentiation intégrée, ce qui en fait la majeure partie du programme.

[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 (une mutation de Poulet ): 810147050 octets

Vous trouverez ci-dessous deux solutions suggérées: une solution complète à la question nécessitant de nombreux octets et une seconde solution partielle (ne résolvant que les valeurs N + N et N * N). parties , ne nécessitant que 484 octets), chacune adoptant une approche différente et la sienne propre. ensemble d'astuces cool! :)

1. Solution complète (810147050 octets)

En utilisant TovTovTov(TOV='hi',SEP=','), les TOVéléments sont immunisés contre la duplication de caractères sur place (les deux "hihihi"et "hhiihhiihhii"ont trois "hi"s en eux, et tout ce qui TovTovTovimporte est le nombre de TOVs qui apparaissent entreSEP ).

Si nous l'utilisions SEP=', ', l'ensemble du programme serait à l'abri de la duplication de caractères (ce qui est cool, mais ne résoudra pas la question). Donc nous utilisonsSEP=',' .

Ainsi, le programme "hihihi,hi", par exemple, compile dans le tableau ints [3,1], pendant qu'il "hhiihhiihhii,,hhii"compile vers [3,0,1]et "hhiihhiihhii,,hhii"vers [3,0,0,1]. Cela signifie que les commandes elles-mêmes ne changent pas de signification après la duplication, mais que la longueur totale change avec la duplication de caractères. La solution ci-dessous demande la longueur du programme et l’utilise pour décider d’imprimer N+N, N*Nou deN^N .

La solution complète suggérée, en tant que tableau ints, est la suivante: [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]

En tant que chaîne, il s'agit d'un programme assez long, composé de 810147050 caractères, commençant par: hihihihihihi,hihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihi,hihihihihihihihihi,hihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihihih...

2. Résoudre uniquement les parties N + N et N * N de la question (484 octets)

En utilisant TovTovTov(TOV='1',SEP=', '), cette fois, les SEPs sont immunisés contre la duplication (il ",, "n'en reste qu'une ", "), de sorte que la solution suggérée suivante contiendra toujours 33 commandes, même après la duplication de caractères:

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

Le tableau ints correspondant (le nombre de TOVs (1 s) dans chacune des 33 commandes ci-dessus) est le suivant:[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 duplication des caractères sur place résulte en une liste de 33 commandes totalement différentes : [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]

Le tableau ints original (qui calcule N + N ) a été conçu avec soin afin que , après les commandes changent de sens, le programme a encore un sens, mais calcule N * N . Par exemple, le premier 4(qui TovTovTovcomprend comme "traite l'opération suivante comme un code ascii à convertir en caractère") change après la duplication de caractère 8, ce qui est une commande totalement différente ("change le compteur de programme en la première valeur pile, si la valeur affichée immédiatement après est vraie ").

Befunge-98 , 38 octets

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

Essayez-le en ligne: N + N , N * N , N ^ N

Ce programme ne fonctionnera pas immédiatement car il nécessite que les entrées soient sur la pile au début de l'exécution. En remplaçant la première ligne par le code suivant (en ajoutant trois octets), il prendra l’entrée de stdin (bien que cela ne fonctionne pas sur tryitonline.net, malheureusement):

v
&x:k:2-

Explication

Installer

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