挑战

编写尽可能短的代码段，以便将N个副本串联在一起时，输出的字符数为N ²。N将为正整数。

例如，如果代码段为soln();，则运行soln();将仅打印1个字符，运行soln();soln();将仅打印4个字符，运行soln();soln();soln();将仅打印9个字符，依此类推。

只要字符总数正确，输出中就可以包含任何字符。为了避免跨OS的混淆，\r\n换行符被视为一个字符。

程序可能无法读取其自身的源代码或读取其文件大小或使用其他此类漏洞。将此视为严格的奎因挑战。

输出可能会转到stdout或文件或类似的替代文件。没有输入。

代码中的注释很好，退出执行过程中也是如此。

程序中可能包含任何字符。以字节为单位的最短提交获胜。

TECO，4个字节

V1\V

V在文本缓冲区中打印当前行的内容。1\在当前位置插入数字1的字符串表示形式。

因此，在程序的第N次迭代中，第一个V将输出N-1个字符副本1，然后将另一个副本添加1到文本中，然后输出N 1 s。

Brainfuck，17 16字节

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

您可以在这里进行测试。只需使用事实。n2+2n+1=(n+1)2

Brainfuck，11岁

我看到了Brainfuck的第一个答案，并认为它太长了:)

[.<]>[.>]+.

如果用更多的正号替换正号，则输出可能更容易看清。

在第N次迭代中，每个循环输出ASCII值为1的N-1个字符副本，然后再输出+.。

Python 2、22

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

打印空字符串，然后是两个x'，然后是x'四个，依此类推。每个字符串后都有换行符，这是n*n字符。

一份："\n"（1个字符）
两份："\nxx\n"（4个字符）
三份： "\nxx\nxxxx\n"（9个字符）

为了防止a每次运行都重新初始化初始变量，我以结束代码，;a它本身是良性的，但与下一个循环结合使用以创建aa要分配的替罪羊。这不是我的把戏。我在先前的答案中看到了。如果有人可以指出我的身份，我将不胜感激。

CJam，6个字节

LLS+:L

使用以下事实 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字节

我敢肯定有一种非常短而曲折的方法可以解决///，但是除了“简单”的方法外，我什么也找不到：

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

这是基于打印连续奇数的方法。该代码段1在开始时由a组成，并包含两个替换项，这两个替换项1在该代码段的每个连续副本的第一部分中增加了两个s。让我们来看看N = 3。应该以3行或更多行为一组阅读以下内容：1.当前代码，2.处理过的令牌，3.（及之后）注释上述令牌的作用。

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

有趣的是，如果我们将其1移至末尾，它也同样有效：

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

> <>，14个字节

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

使用“从1开始的连续奇数整数之和”的想法。它以1开头，每次乘以100，以2为增量逐渐增加输出的长度。

例如，附加5个副本即可

1100100001000000100000000

我通过将输出管道传输到文件进行了测试，但没有看到尾随换行符。

分解

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个字节

],)_S*a*~

这将打印N ^2个空格，其中N是代码的副本数。

代码扩展：

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

在这里在线尝试

Python 2，20个字节

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

Java-91字节

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

此解决方案与Python中的另一个解决方案等效。它肯定不会赢，但是很有趣:)

Perl，14个字节

print;s//__/;

这需要使用Perl的-l命令开关来运行，这会导致print添加新行。

它打印默认变量$_，然后通过替换在两个下划线之间加前缀。

例：

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

__
____
______

Brainfuck，10个字符

前两次Brainfuck解决方案是waaay太长（16和11个字符），所以这里是一个较短：

+[.->+<]>+

在n-th块中，它打印出2*n-1字符（代码点从2*n-1到1）

前奏，18 12字节

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

打印N ^2个标签。它假定使用一个符合标准的解释器，该解释器将输出字符而不是数字，因此，如果您使用Python解释器，则需要将其设置NUMERIC_OUTPUT为False。

这个想法只是将栈顶（最初为0）用作2(N-1)，并打印2N-1制表符，然后将栈顶增加2。因此，每次重复都打印下一个奇数个制表符。

Java-59/44（取决于要求）

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

显然，我们被允许假定代码在类中运行。

如果可以进入主要方法中：

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

C，87字节

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

这使用了两个魔术宏。__COUNTER__是一个宏，0它在第一次使用时会扩展，1在第二次使用时会扩展。等等。它是编译器扩展，但至少在gcc，clang和Visual Studio中都可用。__FILE__是源文件的名称。从本质上讲，在C / C ++中包含文件与将其直接粘贴到源代码中是一样的，因此使用它有点棘手。

如果不使用，仍然可以使用此技术__COUNTER__。在这种情况下，可以将防止两次使用代码的标准防护措施用于该#if语句，并__LINE__可以用于计算所需的字符数。

Dyalog APL，20岁 19字节

基于矩阵的解决方案。

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

在这里尝试。返回重复的字符串。爆炸式解释：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

后面有一行新行，以确保显示（di）语句有效。首先在$ a换行符中显示当前数字（从显示的默认值起再显示一个）。然后将2加到$ a。

每次使用偶数方法（即，奇数方法减去-1），并使用额外的换行符。

T-SQL 117

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

注意尾随空格，以确保每次都正确检查if条件。

使用奇数方法。不确定select语句上是否有换行符。

如果表不存在，则不确定是否可以使用较短的方法来创建表。

PostScript，35个字符

count dup 2 mul 1 add string print

每次通过都会在堆栈上“泄漏”一件事，因此 count每次增加1。然后，它使用奇数和的把戏。

输出的字节全都\000是因为这是字符串的初始值。

哈斯克尔，72岁

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

说明

apply运算符的$作用就好像您将括号放在行的其余部分周围一样（这是例外，但在这种情况下可以使用）。aputStr是一个采用格式为“ abc ...”的字符串的函数，其中“ abc”是字符串长度的平方根，包括abc。它将字符串解析为整数，并返回以abc + 1开头且长度为平方的字符串。由于$操作员的缘故，它将在N次“ 1”上递归调用。

Pyth，8个字节

*d*2Z~Z1

这取决于N ²等于N奇数之和的事实。现在，Pyth自动打印新行，因此我只需要Z * 2在每个代码中打印字符，Z从0到的N - 1。

代码扩展：

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

在这里在线尝试

Golflua，23个字节

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

输出的组合&和\n字符。

等效的Lua码

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

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

每次运行该代码段时，它都会比上一次生成2个字符更多的输出字符，从1个字符开始。该print函数追加了换行符，因此我将X初始化为0而不是1。

ActionScript-27/26字节

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

要么

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

怎么运行的：

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

它只是注释掉第一行。注意：trace添加换行符。也许我使用的所有IDE都会自动执行此操作。

GML，27

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