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.

• Martin Ender: Does the program have to terminate?
• Calvin's Hobbies: @MartinBüttner Yes

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.

• Erik the Outgolfer: Can you add a link to TECO?

Answer 2

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 +..

• Brian J: You need to print N^2 characters, not N characters. I can't read BF code, so I don't know if your code is incorrect or if your description is incorrect.
• alephalpha: @BrianJ It prints N^2 characters. You can test it here: copy.sh/brainfuck Replace the plus with a minus if you can't see the output.
• Brian J: @alephalpha Oops, I now see that I misread the comment. The code does not do (N - 1) + 1 like I originally thought.

Answer 3

Brainfuck, (削除) 17 (削除ここまで) 16 bytes

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

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

• agweber: I can't believe I'm seeing BF at a competitive level of bytes!

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.

• xnor: Actually, is the final newline printed?
• Justin: no I don't think the final newline is printed. But simply removing the , after print a should work. print a prints a newline after each print.
• Sp3000: Are you talking about this post?

Answer 5

///, 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 6

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

• Peter Taylor: :L..1+ is the same idea in GolfScript.
• Martin Ender: @PeterTaylor I was thinking ..n+ in GolfScript, but that pesky trailing newline... :(
• Peter Taylor: Hah, you're right. No need for :L because it's not used.

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

• user32377: Don't you need a class to run anything?
• cygnusv: No, since OP asked for snippets of code. We can assume this is running inside a main, for example.
• user32377: Then I have a 59 or even 44 byte solution.
• cygnusv: Cool :) I prefer one-liners, but yours is indeed shorter!

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//__/;'
__
____
______

• Optimizer: flags are counted as 1 more byte per flag
• hmatt1: What about say?
• grc: @chilemagic I tried that, but I couldn't get it working on my versions of Perl.
• hmatt1: @grc it's version 5.10 and higher and you need -E instead.
• grc: @chilemagic hmm, that didn't seem to work for me on 5.16.

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)

• feersum: This wouldn't work in standard brainfuck, only if the cells are unlimited-size. Actually, it wouldn't totally make sense then either. How do you output character code 1 trillion?

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.

• FUZxxl: This solution is not written in C, but rather a C dialect. Please correct the language name.
• feersum: @FUZxxl Most code-golf answers are only designed to work in gcc, so I'm not sure why this would be an issue.
• FUZxxl: It isn't, but you should really declare that.
• corsiKa: I'm confused. Why declare a non-issue? O_o
• FUZxxl: @corsiKa It's only a non-issue if you declare it. The C gcc speaks is not standard C.

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.

• Xynariz: Kudos to you for an unusual language choice.

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.

• lyxal: I'm a little (a lot) late, but 5 bytes

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

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 25

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 26

GML, 27

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

Answer 27

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 28

Pyt, 10 bytes

0ǰąŁ−√+2(1)ǰ

Try it online!

0 pushes 0
 ǰ ǰoins stack with no delimiter
 ą convert to ąrray of characters
 Ł get the Łength
 − decrement
 √ square root
 + increment
 2 square
 (1) array of (top of stack) 1s
 ǰ ǰoin array with no delimiters (implicitly prints at end of code)

Answer 29

Forth (gforth), (削除) 31 (削除ここまで) 30 bytes

1 depth 2* 1 [do] 1. .r [loop]

Try it online!

Explanation

Inspired by Ben Jackson's Postscript answer, and uses effectively the same logic. Each copy leaves 1 extra item on the stack, then prints 2N-1 characters. This leads to the sum of odd-numbers trick causing us to output N^2 characters

Code Explanation

1 \ place the number 1 on the stack
depth \ get the count of items on the stack
2* \ duplicate the count of items
1 [do] \ start a loop from 1 to (2*count)-1
 1. .r \ output the char '1' right-aligned in a space of size 0 (trick to avoid a space afterwards)
[loop] \ end the counted loop 

Answer 30

Setanta, 26 bytes

a:=''
scriobh(a)a+='xx'>--

try-setanta.ie link