Join N copies of a snippet to produce N^2 characters

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 N². 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 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 wins.

Answer 1

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 Nth 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 1s.

Answer 2

Brainfuck, 17 16 bytes

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

You can test it here. Just use the fact that n2+2n+1=(n+1)2.

Answer 3

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 4

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 5

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 6

///, 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 1s 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 7

><>, 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 8

CJam, 10 9 bytes

],)_S*a*~

This prints N² 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

Answer 9

Python 2, 20 bytes

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

Answer 10

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 :)

Answer 11

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 12

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 13

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.

Answer 14

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 15

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 16

Dyalog APL, 20 19 bytes

A matrix based solution.

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

Try it here. 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 17

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 18

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 19

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 20

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 21

Vyxal, 4 bytes

:I,⇧

Try it Online!

-2 thanks to lyxal.

Note: output is in spaces + newlines.

Answer 22

Pyth, 8 bytes

*d*2Z~Z1

This relies on the fact that N² 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

Answer 23

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 24

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 25

GML, 27

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

Answer 26

Nim, 24 bytes

var s=""
echo s
s&="ss"#

Attempt This Online!

Attempt This Online!Attempt This Online!Attempt This Online!Attempt This Online!Attempt This Online!

Answer 27

Zsh, 12 bytes

<<<$n
n+=..

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 28

Pyt, 10 bytes

0ǰąŁ⁻√⁺²⑴ǰ

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)