Défi

Écrivez l'extrait de code le plus court possible de sorte que, lorsque N copies de celui-ci sont concaténées ensemble, le nombre de caractères sortis soit N ² . N sera un entier positif.

Par exemple, si l'extrait était soln();, alors l'exécution soln();afficherait exactement 1 caractère, et l'exécution soln();soln();imprimerait exactement 4 caractères, et l'exécution soln();soln();soln();imprimerait exactement 9 caractères, etc.

Tous les caractères peuvent être dans la sortie tant que le nombre total de caractères est correct. Pour éviter toute confusion entre les systèmes d'exploitation, les \r\nsauts de ligne sont comptés comme un seul caractère.

Les programmes ne peuvent pas lire leur propre source, lire la taille de leur fichier ou utiliser d'autres failles de ce type. Traitez cela comme un défi de quine strict .

La sortie peut aller vers stdout ou un fichier ou une alternative similaire. Il n'y a aucune entrée.

Les commentaires dans le code sont corrects, tout comme la sortie en cours d'exécution.

Tous les caractères peuvent être dans le programme. La soumission la plus courte en octets l' emporte.

TECO, 4 octets

V1\V

Vimprime le contenu de la ligne actuelle dans le tampon de texte. 1\insère la représentation sous forme de chaîne du numéro 1 à la position actuelle.

Ainsi, à la N ème itération du programme, le premier Vaffichera N - 1 copies du caractère 1, puis en ajoutera un autre 1au texte, puis affichera N 1 s.

Brainfuck, 17 16 octets

[>+>-..+<<-]-.>+

Vous pouvez le tester ici . Utilisez simplement le fait que .n2+2n+1=(n+1)2

Brainfuck, 11

J'ai vu la première réponse de Brainfuck et j'ai pensé que c'était beaucoup trop long :)

[.<]>[.>]+.

La sortie peut être plus facile à voir si vous remplacez le plus par beaucoup plus de plus.

À la Nième itération, chaque boucle génère N - 1 copies du caractère avec la valeur ASCII 1, puis une de plus avec +..

Python 2, 22

a='';print a;a+='xx';a

Imprime la chaîne vide, puis deux x, puis xquatre et ainsi de suite. Avec la nouvelle ligne après chaque chaîne, cela ressort des n*ncaractères.

Un exemplaire: "\n"(1 caractère)
Deux exemplaires: "\nxx\n"(4 caractères)
Trois exemplaires: "\nxx\nxxxx\n"(9 caractères)

Afin d'empêcher la aréinitialisation de la variable initiale à chaque exécution, je termine le code par un ;a, qui est bénin en soi, mais combiné avec la boucle suivante pour créer le bouc émissaire aaà affecter à la place. Cette astuce n'est pas la mienne; Je l'ai vu dans une réponse précédente. J'apprécierais si quelqu'un pouvait me pointer pour que je puisse donner du crédit.

CJam, 6 octets

LLS+:L

Utilise le fait que .n2 + n + (n+1) = (n+1)2

L      "Push L. Initially this is an empty string, but its length increases by 1 with each copy
        of the snippet.";
 L     "Push another L.";
  S+   "Add a space to the second copy.";
    :L "Store the lengthened string in L for the next copy of the snippet.";

/// , 21 octets

Je suis sûr qu'il existe un moyen très court et tordu de résoudre ce problème dans /// mais je n'ai encore rien trouvé, au-delà de la méthode "simple":

1/1\//112\///2\//1\//

Ceci est basé sur l'approche consistant à imprimer des nombres impairs consécutifs. L'extrait se compose d'un 1au début qui est imprimé et de deux remplacements qui ajoutent deux 1s supplémentaires à cette première partie de chaque copie consécutive de l'extrait. Passons par là pour N = 3. Les éléments suivants doivent être lus par groupes de 3 lignes ou plus: 1. le code actuel, 2. le (s) jeton (s) traité (s), 3. (et les suivants) un commentaire sur ce que fait le jeton ci-dessus.

1/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
1
is printed
/1\//112\///2\//1\//1/1\//112\///2\//1\//1/1\//112\///2\//1\//
/1\//112\//
replaces all occurrences of 1/ with 112/. This affects the starts of all further snippets
but not the substitution commands, because the slashes in those are always escaped.
It is necessary to put a 2 in there, because otherwise the interpreter goes into an infinite
loop replacing the resulting 1/ again and again.
/2\//1\//112/1\//112\///2\//1\//112/1\//112\///2\//1\//
/2\//1\//
Replace all occurrences of 2/ with 1/, so the the next snippets substitution works again.
111/1\//112\///2\//1\//111/1\//112\///2\//1\//
111
is printed
/1\//112\///2\//1\//111/1\//112\///2\//1\//
/1\//112\//
add two 1s again
/2\//1\//11112/1\//112\///2\//1\//
/2\//1\//
turn the 2 into a 1 again
11111/1\//112\///2\//1\//
11111
print 11111
/1\//112\///2\//1\//
the last two substitutions have nothing to substitute so they do nothing

Fait intéressant, cela fonctionne aussi bien si nous passons 1à la fin:

/1\//112\///2\//1\//1

> <> , 14 octets

1:na*a*';'10p!

Utilise la "somme d'entiers impairs consécutifs à partir de 1". Il commence par 1 et le multiplie par 100 à chaque fois, augmentant progressivement la longueur de la sortie par incréments de 2.

Par exemple, ajouter 5 copies donne

1100100001000000100000000

J'ai testé en redirigeant la sortie vers un fichier et je n'ai pas vu de nouvelle ligne de fin.

Panne

1                   Push 1, skipped by ! every time except the first
 :n                 Copy top of stack and output as num                  
   a*a*             Multiply by 10 twice
       ';'10p       Modify the source code so that the first : becomes a ; for termination
             !      Skip the next 1

CJam, 10 9 octets

],)_S*a*~

Cela imprime N ² espaces où Nest le nombre de copies du code.

Extension du code :

],            "Wrap everything on stack and take length";
  )_          "Increment and take copy";
    S*        "Get that length space string";
      a*      "Wrap that space string in an array and create that many copies";
        ~     "Unwrap so that next code can use to get length";

Essayez-le en ligne ici

Python 2, 20 octets

g=0
print'g'*g;g+=2#

Java - 91 octets

{String s=System.getProperty("a","");System.out.println(s);System.setProperty("a","xx"+s);}

Cette solution est équivalente à cette autre en Python. Ça ne gagnera sûrement pas, mais c'était amusant :)

Perl, 14 octets

print;s//__/;

Cela doit être exécuté avec le -lcommutateur de commande de Perl , ce qui provoque l' printajout de nouvelles lignes.

Il imprime la variable par défaut $_, puis ajoute deux traits de soulignement par substitution.

Exemple:

$ perl -le 'print;s//__/;print;s//__/;print;s//__/;print;s//__/;'

__
____
______

Brainfuck, 10 caractères

Les deux solutions précédentes étaient Brainfuck waaay trop long (16 et 11 caractères) voici donc une plus courte:

+[.->+<]>+

Dans le n-ième bloc, il imprime les 2*n-1caractères (avec les points de code de 2*n-1à 1)

Prélude , 18 12 octets

^1+(9!1-)#2+

Cela imprime N ² onglets. Il suppose un interprète conforme aux normes qui imprime des caractères au lieu de chiffres, donc si vous utilisez Python interprète vous aurez besoin de mettre NUMERIC_OUTPUTà False.

L'idée est simplement d'utiliser le haut de la pile (qui est initialement 0) comme 2(N-1), et d'imprimer les 2N-1onglets, puis d'incrémenter le haut de la pile de 2. Par conséquent, chaque répétition imprime le nombre impair suivant d'onglets.

Java - 59/44 (selon les besoins)

static String n="1";
static{System.out.print(n);n+="11";}//

Apparemment, nous sommes autorisés à supposer que le code s'exécute dans une classe.

S'il peut entrer dans une méthode principale:

String n="1";
System.out.print(n);n+="11";//

C, 87 octets

#if!__COUNTER__
#include __FILE__
main(a){a=__COUNTER__-1;printf("%*d",a*a,0);}
#endif

Cela utilise deux macros magiques. __COUNTER__est une macro qui se développe jusqu'à 0la première utilisation, 1la seconde, etc. C'est une extension de compilateur, mais elle est disponible dans gcc, clang et Visual Studio au moins. __FILE__est le nom du fichier source. Inclure un fichier en C / C ++ équivaut littéralement à le coller directement dans votre code source, il était donc un peu difficile à utiliser.

Il serait toujours possible d'utiliser cette technique sans __COUNTER__. Dans ce cas, la protection standard contre l'utilisation de code deux fois peut être utilisée pour l' #ifinstruction et __LINE__peut être utilisée pour compter le nombre de caractères nécessaires.

Dyalog APL, 20 19 octets

Une solution basée sur une matrice.

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'

Essayez-le ici . Renvoie une chaîne de répétitions de . Explication par explosion pour :N2aN = 2

{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
                                  ⍪'a'  Wrap 'a' into a 1x1 matrix.
                'a'{            }⍨      Binary function: bind 'a' to ⍵ and the matrix to ⍺.
                    ⍺≢⍵:                The arguments are not identical,
                        ⍵⍪⍵,⍺           so add to the matrix 1 column and 1 row of 'a's.
               ⍪                        Identity function for a matrix.
{            }⍨                         Unary function: bind the matrix to both ⍵ and ⍺.
 ⍺≢⍵:                                   The arguments are identical,
           ∊⍺                           so flatten the matrix into the string 'aaaa'.

STATA 20

di _n($a)
gl a=$a+2

Il y a une nouvelle ligne de fin pour vous assurer que l'instruction display (di) fonctionne. Affichez d'abord le numéro actuel dans $ a sauts de ligne (et un supplémentaire par rapport à l'affichage par défaut). Ajoutez ensuite 2 à $ a.

Utilise l'approche des nombres pairs (c'est-à-dire l'approche des nombres impairs moins 1) avec une nouvelle ligne supplémentaire à chaque fois.

T-SQL 117

IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #

Notez l'espace de fin pour vous assurer que la condition if est correctement vérifiée à chaque fois.

Utilise l'approche des nombres impairs. Je ne sais pas s'il y a une nouvelle ligne sur certaines instructions.

Je ne sais pas s'il existe un moyen plus court de créer une table si elle n'existe pas.

PostScript, 35 caractères

count dup 2 mul 1 add string print

Chaque passage "fuit" une chose sur la pile, countaugmente donc de 1 à chaque fois. Ensuite, il utilise la somme des nombres impairs.

Les octets en sortie sont tous \000parce que c'est la valeur initiale des chaînes.

Haskell, 72

putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a

Explication

L'opérateur d'application $agit comme si vous placez des parenthèses autour du reste de la ligne (il existe des exceptions, mais cela fonctionne dans ce cas). aputStrest une fonction qui prend une chaîne au format "abc ...", où "abc" est la racine carrée de la longueur de la chaîne, y compris abc. Il analysera la chaîne comme un entier et retournera une chaîne commençant par abc + 1 et ayant cette longueur au carré. En raison de l' $opérateur, cela sera appelé récursivement sur "1" N fois.

Pyth, 8 octets

*d*2Z~Z1

Cela repose sur le fait que N ² est égal à la somme des Nnombres impairs. Maintenant, Pyth imprime automatiquement une nouvelle ligne, donc je dois simplement imprimer des Z * 2caractères dans chaque code où Zva de 0à N - 1.

Expansion du code :

*d               "Print d whose value is a space character"
  *2Z            "2 * Z times where Z's initial value is 0"
     ~Z1         "Increment the value of Z";

Essayez-le en ligne ici

Golflua, 23 octets

X=2+(X|-2)w(S.t("&",X))

affiche une combinaison de caractères &et \n.

Code Lua équivalent

X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time

print(string.rep("&", X))

Chaque fois que l'extrait de code s'exécute, il produit 2 caractères de sortie de plus que la dernière fois, en commençant par 1 caractère. La printfonction ajoute une nouvelle ligne, donc j'initialise X à 0 au lieu de 1.

ActionScript - 27/26 octets

var n=""
trace(n);n+="11"//

ou

var n=1
trace(n);n+="11"//

Comment ça marche:

var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//

Il commente simplement la première ligne. Remarque: traceajoute une nouvelle ligne. Ou peut-être que tous les IDE que j'utilise le font automatiquement.

GML, 27

a=''show_message(a)a+='xx'a