[Question]
  [
# Challenge
Write the shortest snippet of code possible such that, when N copies of it are concatenated together, the number of characters output is N2. N will be a positive integer.
For example if the snippet was `soln();`, then running `soln();` would print exactly 1 character, and running `soln();soln();` would print exactly 4 characters, and running `soln();soln();soln();` would print exactly 9 characters, etc.
Any characters may be in the output as long as the total number of characters is correct. To avoid cross-OS confusion, `\r\n` newlines are counted as one character.
**Programs may not read their own source or read their file size or use other such loopholes.** Treat this like a strict [quine](/questions/tagged/quine "show questions tagged 'quine'") challenge.
The output may go to stdout or a file or a similar alternative. There is no input.
Comments in the code are fine, as is exiting mid-execution.
Any characters may be in the program. The shortest submission [in bytes](https://mothereff.in/byte-counter) wins.
  
[Answer]
# TECO, 4 bytes
```
V1\V
```
`V` prints the contents of the current line in the text buffer. `1\` inserts the string representation of the number 1 at the current position.
So on the *N*th iteration of the program, the first `V` will output *N - 1* copies of the character `1`, then add another `1` to the text, then output *N* `1`s.
[Answer]
# Brainfuck, ~~17~~ 16 bytes
```
[>+>-..+<<-]-.>+
```
You can test it [here](http://copy.sh/brainfuck/). Just use the fact that `n2+2n+1=(n+1)2`.
[Answer]
# Brainfuck, 11
I saw the first Brainfuck answer and thought it's way too long :)
```
[.<]>[.>]+.
```
The output may be easier to see if you replace the plus with a lot more pluses.
On the Nth iteration, each loop outputs N - 1 copies of the character with ASCII value 1, and then one more with `+.`.
[Answer]
# Python 2, 22
```
a='';print a;a+='xx';a
```
Prints the empty string, then two `x`'s, then `x`' four and so on. With the newline after each string, this comes out to `n*n` characters.
One copy: `"\n"` (1 char)  
Two copies: `"\nxx\n"` (4 chars)  
Three copies: `"\nxx\nxxxx\n"` (9 chars) 
In order to stop the initial variable `a` from being reinitialized each run, I end the code with a `;a`, which is benign on its own, but combined with the next loop to create the scapegoat `aa` to be assigned instead. This trick isn't mine; I saw it in a previous answer. I'd appreciate if someone could point me so I could give credit.
[Answer]
# CJam, 6 bytes
```
LLS+:L
```
Uses the fact that `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.";
```
[Answer]
# [///](http://esolangs.org/wiki////), 21 bytes
I'm sure there is a really short and twisted way to solve this in **///** but I couldn't find anything, beyond the "straightforward" way yet:
```
1/1\//112\///2\//1\//
```
This is based on the approach of printing consecutive odd numbers. The snippet consists of a `1` at the start which is printed, and two replacements which add two more `1`s to that first part of each consecutive copy of the snippet. Let's go through this for `N = 3`. The following should be read in groups of 3 or more lines: 1. the current code, 2. the processed token(s), 3. (and following) a comment what the above token does.
```
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
```
Interestingly, it works just as well if we move the `1` to the end:
```
/1\//112\///2\//1\//1
```
[Answer]
# [><>](http://esolangs.org/wiki/Fish), 14 bytes
```
1:na*a*';'10p!
```
Uses the "sum of consecutive odd integers starting from 1" idea. It starts off with 1 and multiplies it by 100 each time, increasing the length of the output progressively by increments of 2.
For example, appending 5 copies gives
```
1100100001000000100000000
```
I tested by piping the output to a file, and didn't see a trailing newline.
## Breakdown
```
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
```
[Answer]
# CJam, ~~10~~ 9 bytes
```
],)_S*a*~
```
This prints N2 spaces where `N` is the number of copies of the code.
**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";
```
[Try it online here](http://cjam.aditsu.net/)
[Answer]
# Python 2, 20 bytes
```
g=0
print'g'*g;g+=2#
```
[Answer]
# 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](https://codegolf.stackexchange.com/a/45381) in Python. It surely won't win, but it was fun :)
[Answer]
## 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//__/;'
__
____
______
```
[Answer]
# 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`)
[Answer]
# [Prelude](http://esolangs.org/wiki/Prelude), ~~18~~ 12 bytes
```
^1+(9!1-)#2+
```
This prints N2 tabs. It assumes a standard-compliant interpreter which prints characters instead of numbers, so if you use [the Python interpreter](https://web.archive.org/web/20060504072747/http://z3.ca/~lament/prelude.py) 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.
[Answer]
## 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";//
```
[Answer]
# 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.
[Answer]
# Dyalog APL, ~~20~~ 19 bytes
A matrix based solution.
```
{⍺≢⍵:⍵⍪⍵,⍺⋄∊⍺}⍨⍪'a'
```
[Try it here](http://tryapl.org/). Returns a string of `N2` repetitions of `a`. Explanation by explosion for `N = 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'.
```
[Answer]
## STATA 20
```
di _n($a)
gl a=$a+2
```
There is a trailing new line to make sure that the display (di) statement works.
First display the current number in $a newlines (and one additional from the default of display). Then add 2 to $a.
Uses the even numbers approach (i.e. odd numbers approach minus 1) with an extra newline every time.
[Answer]
## T-SQL 117
```
IF OBJECT_ID('tempdb..#')IS NULL CREATE TABLE #(A INT)INSERT INTO # VALUES(1)SELECT REPLICATE('a',COUNT(*)*2-1)FROM #
```
Note the trailing space to ensure that the if condition is properly checked every time.
Uses the odd numbers approach. Not sure if there's a newline on select statements.
Not sure if there's a shorter way to create a table if it doesn't exist.
[Answer]
# PostScript, 35 chars
```
count dup 2 mul 1 add string print
```
Each pass "leaks" one thing on the stack, so `count` goes up by 1 each time. Then it justs uses the sum of odd numbers trick.
The bytes output are all `\000` because that's the initial value of strings.
[Answer]
# Haskell, 72
```
putStr$let a="1";aputStr=(\n->take(n^2)$show n++cycle" ").(+1).read in a
```
## Explanation
The apply operator `$` acts as if you place surrounding parentheses around the rest of the line (there are exceptions to this, but it works in this case). `aputStr` is a function that takes a string with the format "abc ...", where "abc" is the square root of the length of the string, including abc. It will parse the string as an integer, and return a string starting with abc+1 and having that length squared. Because of the `$` operator, this will get called recursively on "1" N times.
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 4 bytes
```
:I,⇧
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCIiLCI6SSzih6ciLCIiLCIiXQ==)
-2 thanks to lyxal.
Note: output is in spaces + newlines.
[Answer]
# Pyth, 8 bytes
```
*d*2Z~Z1
```
This relies on the fact that N2 is equal to the sum of `N` odd numbers. Now Pyth auto prints an new line, so I have to just print `Z * 2` characters in each code where `Z` goes from `0` to `N - 1`.
**Code Expansion**:
```
*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";
```
[Try it online here](http://pyth.herokuapp.com/)
[Answer]
# Golflua, 23 bytes
```
X=2+(X|-2)w(S.t("&",X))
```
outputs a combination of `&` and `\n` characters.
### Equivalent Lua code
```
X = 2 + (X or -2)          -- initialize X to 0 the first time, add 2 ever other time
print(string.rep("&", X))
```
Each time the code snippet runs it produces 2 more characters of output than the last time, starting with 1 character. The `print` function appends a newline, so I initialize X to 0 instead of 1.
[Answer]
## ActionScript - 27 / 26 bytes
```
var n=""
trace(n);n+="11"//
```
or 
```
var n=1
trace(n);n+="11"//
```
How it works:
```
var n=""
trace(n);n+="11"//var n=""
trace(n);n+="11"//
```
It simply comments out the first line. Note: `trace` adds a newline. Or maybe all the IDE's I use do that automatically.
[Answer]
# GML, 27
```
a=''show_message(a)a+='xx'a
```
[Answer]
# [Nim](https://nim-lang.org/), 24 bytes
```
var s=""
echo s
s&="ss"#
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY7yhKLFIptlZS4UpMz8hWKuYrVbJWKi5WUIdJQVTDVAA)
[Attempt This Online!Attempt This Online!Attempt This Online!Attempt This Online!Attempt This Online!](https://ato.pxeger.com/run?1=m704LzN3wYKlpSVpuhY3K8oSixSKbZWUuFKTM_IVirmK1WyViouVlGktDrEf6gyYcwA)
[Answer]
# [Zsh](https://www.zsh.org/), 12 bytes
```
<<<$n
n+=..
```
[Try it online!](https://tio.run/##TY7BqsIwFET39ysGvZKEYrEuY/MV2QpSSvsMSNqXpG9h6LfXYhXe7nCGGeYZ74s1Yqnrmj35wpQlLYKs4Wx1pY/VTGNwPuEYsLPDFNpOg7P8LZSdd0T9EOAgc1WW59OsLpkAe3OFYbtS99c8IHqppODVCiVotcOUxikZlv0F7/EeWgF7sIRCTMGNESk07uH8D@LYtF38V8sb6NP7Hb4T4qNxiFff3psQNxTgLQHvN6B5eQE "Zsh – Try It Online")
Same \$ n^2 = \sum\_{k=1}^n 2k + 1 \$ as has been used elsewhere. The TIO test has to do some extra work because naively capturing the output in `$(f)` removes trailing newlines, and would output `0`, `3`, `8`, `15`, etc. Instead, we insert a `printf :` to add a character after the last newline, then `${output:0:-1}` to remove it.
[Answer]
# [Pyt](https://github.com/mudkip201/pyt), 10 bytes
```
0ǰąŁ⁻√⁺²⑴ǰ
```
[Try it online!](https://tio.run/##AR4A4f9weXT//zDHsMSFxYHigbviiJrigbrCsuKRtMew//8 "Pyt – Try It Online")
```
0              pushes 0
 ǰ             ǰoins stack with no delimiter
  ą            convert to ąrray of characters
   Ł           get the Łength
    ⁻          decrement
     √         square root
      ⁺        increment
       ²       square
        ⑴     array of (top of stack) 1s
          ǰ    ǰoin array with no delimiters (implicitly prints at end of code)
```
]