Herausforderung

Schreiben Sie das kürzestmögliche Codefragment, sodass bei Verkettung von N Kopien N ² Zeichen ausgegeben werden . N wird eine positive ganze Zahl sein.

Wenn das Snippet zum Beispiel war soln();, soln();würde das Ausführen genau 1 Zeichen und das Ausführen soln();soln();genau 4 Zeichen und das Ausführen soln();soln();soln();genau 9 Zeichen usw. ausgeben.

Es können beliebige Zeichen ausgegeben werden, solange die Gesamtzahl der Zeichen korrekt ist. Um \r\nbetriebssystemübergreifende Verwechslungen zu vermeiden, werden Zeilenumbrüche als ein Zeichen gezählt.

Programme lesen möglicherweise nicht ihre eigene Quelle oder ihre Dateigröße oder verwenden andere solche Lücken. Behandle dies wie eine strenge Herausforderung für Quine .

Die Ausgabe kann an stdout oder eine Datei oder eine ähnliche Alternative gehen. Es erfolgt keine Eingabe.

Kommentare im Code sind in Ordnung, ebenso wie die Beendigung der Ausführung.

Beliebige Zeichen dürfen im Programm sein. Die kürzeste Übermittlung in Bytes gewinnt.

TECO, 4 Bytes

V1\V

Vdruckt den Inhalt der aktuellen Zeile im Textpuffer. 1\Fügt die Zeichenfolgendarstellung der Nummer 1 an der aktuellen Position ein.

Bei der N- ten Iteration des Programms werden also zuerst N - 1 Kopien des Zeichens Vausgegeben , dann ein weiteres zum Text hinzugefügt und dann N s ausgegeben .11 1

Brainfuck, 17 16 Bytes

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

Sie können es hier testen . Nutzen Sie einfach die Tatsache, dass .n2+2n+1=(n+1)2

Brainfuck, 11

Ich habe die erste Antwort von Brainfuck gesehen und fand sie viel zu lang :)

[.<]>[.>]+.

Die Ausgabe ist möglicherweise einfacher zu erkennen, wenn Sie das Pluszeichen durch viel mehr Pluszeichen ersetzen.

Bei der n-ten Iteration gibt jede Schleife N - 1 Kopien des Zeichens mit dem ASCII-Wert 1 und dann eine weitere mit aus +..

Python 2, 22

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

Druckt die leere Zeichenfolge, dann zwei x, dann xvier und so weiter. Mit dem Zeilenumbruch nach jeder Zeichenfolge werden die n*nZeichen ausgegeben .

Eine Kopie: "\n"(1 Zeichen )
Zwei Kopien: "\nxx\n"(4 Zeichen)
Drei Kopien: "\nxx\nxxxx\n"(9 Zeichen)

Um zu verhindern, dass die ursprüngliche Variable abei jedem Durchlauf erneut initialisiert wird, beende ich den Code mit einem ;a, das für sich genommen harmlos ist, aber mit der nächsten Schleife kombiniert wird, um den Sündenbock aazu erstellen, der stattdessen zugewiesen werden soll. Dieser Trick gehört mir nicht. Ich habe es in einer früheren Antwort gesehen. Ich würde mich freuen, wenn mir jemand einen Hinweis geben könnte, damit ich ihn würdigen kann.

CJam, 6 Bytes

LLS+:L

Nutzt die Tatsache, dass .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 Bytes

Ich bin mir sicher, dass es einen sehr kurzen und verdrehten Weg gibt, dies in /// zu lösen, aber ich konnte noch nichts finden, außer dem "einfachen" Weg:

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

Dies basiert auf dem Ansatz, fortlaufende ungerade Zahlen zu drucken. Das Snippet besteht aus einem 1zu Beginn gedruckten und zwei Ersetzungen, die 1dem ersten Teil jeder aufeinanderfolgenden Kopie des Snippets zwei weitere s hinzufügen . Lassen Sie uns das durchgehen N = 3. Das Folgende sollte in Gruppen von 3 oder mehr Zeilen gelesen werden: 1. der aktuelle Code, 2. das verarbeitete Token (s), 3. (und folgende) ein Kommentar, was das obige Token tut.

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

Interessanterweise funktioniert es genauso gut, wenn wir das 1zum Ende verschieben:

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

> <> , 14 Bytes

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

Verwendet die Idee "Summe aufeinanderfolgender ungerader Ganzzahlen ab 1". Es beginnt mit 1 und multipliziert es jedes Mal mit 100, wobei die Länge der Ausgabe schrittweise in Schritten von 2 erhöht wird.

Zum Beispiel gibt das Anhängen von 5 Kopien

1100100001000000100000000

Ich habe getestet, indem ich die Ausgabe in eine Datei umgeleitet habe, und keine nachgestellte Newline gesehen.

Nervenzusammenbruch

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 Bytes

],)_S*a*~

Dies druckt N ² Leerzeichen, wobei Ndie Anzahl der Kopien des Codes ist.

Code eexpansion :

],            "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";

Probieren Sie es hier online aus

Python 2, 20 Bytes

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

Java - 91 Bytes

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

This solution is equivalent to this other one in Python. It surely won't win, but it was fun :)

Perl, 14 bytes

print;s//__/;

This needs to be run with Perl's -l command switch, which causes print to append new lines.

It prints the default variable $_, then prepends two underscores via substitution.

Example:

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

__
____
______

Brainfuck, 10 chars

Both previous Brainfuck solutions were waaay too long (16 and 11 chars) so here is a shorter one:

+[.->+<]>+

In the n-th block it prints out 2*n-1 characters (with codepoints from 2*n-1 to 1)

Prelude, 18 12 bytes

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

This prints N² tabs. It assumes a standard-compliant interpreter which prints characters instead of numbers, so if you use the Python interpreter you'll need to set NUMERIC_OUTPUT to False.

The idea is simply to use the top of the stack (which is initially 0) as 2(N-1), and print 2N-1 tabs, then increment the top of the stack by 2. Hence each repetition prints the next odd number of tabs.

Java - 59 / 44 (depending on requirements)

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

Apparently we're allowed to assume code runs in a class.

If it can go inside a main method:

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

C, 87 bytes

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

This uses two magic macros. __COUNTER__ is a macro that expands to 0 the first time it is used, 1 the second, etc. It is a compiler extension, but is available in both gcc, clang, and Visual Studio at least. __FILE__ is the name of the source file. Including a file in C/C++ is literally the same as pasting it directly into your source code, so it was a little tricky to make use of.

It would still be possible to use this technique without __COUNTER__. In that case, the standard guard against using code twice could be used for the #if statement, and __LINE__ could be used to count the number of characters needed.

Dyalog APL, 20 bis 19 Bytes

Eine matrixbasierte Lösung.

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

Probieren Sie es hier aus . Gibt eine Folge von Wiederholungen von zurück . Erklärung durch Explosion für :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

Es wird eine neue Zeile nachgestellt, um sicherzustellen, dass die display (di) -Anweisung funktioniert. Zeigen Sie zuerst die aktuelle Zahl in Zeilenumbrüchen an (und eine weitere in der Standardeinstellung der Anzeige). Dann addiere 2 zu $ ​​a.

Verwendet die Annäherung an gerade Zahlen (dh Annäherung an ungerade Zahlen minus 1) mit jeder neuen Zeile.

T-SQL 117

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

Beachten Sie das nachstehende Leerzeichen, um sicherzustellen, dass die if-Bedingung jedes Mal ordnungsgemäß überprüft wird.

Verwendet den Ansatz mit ungeraden Zahlen. Ich bin nicht sicher, ob in ausgewählten Anweisungen ein Zeilenumbruch steht.

Ich bin mir nicht sicher, ob es eine kürzere Möglichkeit gibt, eine Tabelle zu erstellen, wenn sie nicht existiert.

PostScript, 35 Zeichen

count dup 2 mul 1 add string print

Jeder Durchgang "leckt" eine Sache auf dem Stapel, so count erhöht sich jedes Mal um 1. Dann wird nur der Trick mit der Summe der ungeraden Zahlen verwendet.

Die Bytes werden alle ausgegeben, \000da dies der Anfangswert von Zeichenfolgen ist.

Haskell, 72

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

Erläuterung

Der Apply-Operator $verhält sich so, als würden Sie umgebende Klammern um den Rest der Zeile setzen (es gibt Ausnahmen, aber in diesem Fall funktioniert dies). aputStrist eine Funktion, die einen String mit dem Format "abc ..." annimmt, wobei "abc" die Quadratwurzel der Länge des Strings ist, einschließlich abc. Die Zeichenfolge wird als Ganzzahl analysiert und es wird eine Zeichenfolge zurückgegeben, die mit abc + 1 beginnt und deren Länge zum Quadrat passt. Aufgrund des $Operators wird dies bei "1" N-mal rekursiv aufgerufen.

Pyth, 8 Bytes

*d*2Z~Z1

Dies beruht auf der Tatsache, dass N ² gleich der Summe von Nungeraden Zahlen ist. Jetzt druckt Pyth automatisch eine neue Zeile, sodass ich Z * 2in jedem Code nur noch Zeichen ausgeben mussZ aus 0nach N - 1.

Code-Erweiterung :

*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";

Probieren Sie es hier online aus

Golflua, 23 Bytes

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

gibt eine Kombination von &und aus\n .

Äquivalenter Lua-Code

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

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

Jedes Mal, wenn das Code-Snippet ausgeführt wird, werden 2 Zeichen mehr ausgegeben als beim letzten Mal, beginnend mit 1 Zeichen. Die printFunktion hängt eine neue Zeile an, also initialisiere ich X auf 0 anstatt auf 1.

ActionScript - 27/26 Byte

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

oder

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

Wie es funktioniert:

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

Es kommentiert einfach die erste Zeile aus. Hinweis: traceFügt eine neue Zeile hinzu. Oder vielleicht machen das alle IDEs, die ich benutze, automatisch.

GML, 27

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