编写一个矩形的文本块，当该文本块布置在Sierpinski地毯中时，使用相同大小的空白区域作为空白部分，以创建一个输出地毯迭代次数的程序。

例如，如果您的文本块是

TXT
BLK

然后运行程序

TXTTXTTXT
BLKBLKBLK
TXT   TXT
BLK   BLK
TXTTXTTXT
BLKBLKBLK

应该输出，1因为程序的形状代表了Sierpinski地毯的第一次迭代。

同样，正在运行

TXTTXTTXTTXTTXTTXTTXTTXTTXT
BLKBLKBLKBLKBLKBLKBLKBLKBLK
TXT   TXTTXT   TXTTXT   TXT
BLK   BLKBLK   BLKBLK   BLK
TXTTXTTXTTXTTXTTXTTXTTXTTXT
BLKBLKBLKBLKBLKBLKBLKBLKBLK
TXTTXTTXT         TXTTXTTXT
BLKBLKBLK         BLKBLKBLK
TXT   TXT         TXT   TXT
BLK   BLK         BLK   BLK
TXTTXTTXT         TXTTXTTXT
BLKBLKBLK         BLKBLKBLK
TXTTXTTXTTXTTXTTXTTXTTXTTXT
BLKBLKBLKBLKBLKBLKBLKBLKBLK
TXT   TXTTXT   TXTTXT   TXT
BLK   BLKBLK   BLKBLK   BLK
TXTTXTTXTTXTTXTTXTTXTTXTTXT
BLKBLKBLKBLKBLKBLKBLKBLKBLK

应该输出2，因为这是第二次Sierpinski地毯迭代的形状。

按原样运行文本块

TXT
BLK

应该输出，0因为它可以视为第零次迭代。

这应该适用于所有进一步的迭代。（至少从理论上讲，假设计算机具有内存和所有内存。）

细节

• 程序可能无法读取或访问有关其源代码的信息。将此视为严格的奎因挑战。
• 输出到stdout或类似的替代品。仅输出数字和可选的尾随换行符。没有输入。
• 文本块可以包含任何不视为行终止符的字符。文本块可能包含空格。
• 地毯上的“空空间”必须完全由空间字符组成。
• 您可以选择假设所有程序的末尾都有换行符。

您可以在任何迭代中使用此堆栈片段为给定的文本块生成覆盖区：

<style>#o,#i{font-family:monospace;}</style><script>function c(e){e=e.split("\n");for(var n=new Array(3*e.length),t=0;t<n.length;t++){var l=t%e.length;n[t]=e[l]+(t>=e.length&&t<2*e.length?e[l].replace(/./g," "):e[l])+e[l]}return n.join("\n")}function f(){for(i=document.getElementById("i").value,n=parseInt(document.getElementById("n").value);n>0;)i=c(i),n--;document.getElementById("o").value=i}</script><textarea id='i'placeholder='code block...'rows='8'cols='32'></textarea><br>Iterations <input id='n'type='text' value='1'><br><br><button type='button'onclick='f()'>Generate</button><br><br><textarea id='o'placeholder='output...'rows='8'cols='32'style='background-color:#eee'readonly></textarea>

计分

初始文本块的面积（宽度乘以高度）最小的提交者为获胜者。该TXT\nBLK示例是3 x 2，得分为6。（基本上，最短的代码获胜，因此是代码高尔夫球标记。）

Tiebreaker进入使用其文本块中最少的不同字符的提交。如果仍然并列，则答案发布为第一获胜者。

CJam，9个字节

我认为这可以改善，但是现在就让它去吧...

];U):U8mL

运作方式：

];             "Wrap everything on stack in an array and discard it";
               "Before this point, the only thing on array can be the log 8 result of";
               "last updated value of U, or nothing, if its the first code";
  U):U         "Increment by 1 and update the value of U (which is pre initialized to 0)";
      8mL      "Take log base 8 of U. This is the property of Sierpinski carpet that";
               "the occurrence of the code is 8 to the power iteration count, indexed 0";

在这里在线尝试

piet-32 * 6 = 192

我用检查器模式填充了空白空间。我认为这使Sierpinski有点虚张声势。

这是第二次迭代：

原始尺寸：32 * 7

> <>，11 * 2 = 22

";n"00pbi1v
+$3*:@3-0.>

在这里，我们通过使用> <>的跳转/传送功能采用不同的方法。

该程序仅执行最上面一行的块，依次运行第1/2个块，第3/4个块，第9/10个块，第27/28个块等（以3的幂递增）。由于顶部行具有3^n块，n因此在程序回绕到开始，输出栈顶并暂停之前（由于nvia放置的指令p），仅执行块。

该程序利用规则“没有输入。”，因为i如果满足EOF ，命令会将-1压入堆栈。因此，要对此进行测试，您需要通过管道传递一个空文件。

先前提交的内容，7 * 4 = 28

l"v"10p
v>:1=?v
3  ;n{<
<^}+1{,

第一行连续增加每个块的堆栈长度，并使用put命令将第一"引号更改为向下箭头。当第一行结束时，堆栈看起来像vp

[0, 1, 2, .., 3^n]

（请注意，缩写l使用两次。）

然后，最后三行计算在达到1之前需要除以3的次数（因为> <>没有对数函数）。底部的零用于跟踪计数。

Perl，26岁

$_+=.91/++$n;
die int."\n";

这使用谐波序列来近似以3为底的对数。我认为它可行，但是我只尝试了少量使用。感谢ososifrage的使用技巧die。

旧版本（34）：

$n--or$n=3**$s++;
print$s-1if!$o++;

Perl，30（15×2）

首先，我要声明10次迭代是一个合理的限制，而不是2 ³²。经过10次迭代后，由N个字节组成的程序将扩展为（N ×3 ²⁰）个字节（加上换行符），即使N = 1 ，也超过3 GB 。32位体系结构将完全无法处理11个迭代。（显然，宇宙中没有足够的粒子进行2 ³²次迭代）。

所以这是我的解决方案：

$n++; $_=log$n;
print int;exit;

通过增加$n第一行中的变量并在每一步中计算其对数来工作。第二行显示此对数的整数部分并退出。

以e为底的简单对数（2.718 ..）足够接近，可以为前10次迭代提供正确的结果。

Golfscript，9 * 2 = 18

0+       
,3base,(}

（请注意，第一行具有尾随空格以使其变为矩形）

我找不到Golfscript的日志功能，所以base必须这样做。

Golfscript以空字符串开始，因此0+只需将字符串的长度增加1（通过强制）即可。在第一行结束时，堆栈将具有一个length的字符串3^n，在超级注释之前，该字符串的对数为3。n然后自动打印。

C，12x8 = 96

受@ciamej的启发，我将其减少了。它使用了三分法，再加上地毯有效地将if转换为while循环的认识。

该代码已在gcc / Ubuntu上进行了测试，最多可迭代3次。

#ifndef A //
#define A //
x;main(a){//
a++;/*    */
if(a/=3)x++;
printf(   //
"%d",x);} //
#endif    //

先前的解决方案：C，11x12

不是大小赢家，但是嘿，是C。

它通过移位找到块计数的log2，然后使用一些幻数和整数截断来估计log3。数学运算最多可以进行26次迭代（42位数字）。

#ifndef A//
#define A//
int n=0;//_
int main//_
(v,c){//___
n+=1;/*..*/
while(n//__
>>=1)v++;//
n=.3+.62*v;
printf(//__
"%d",n);}//
#endif//__

CJam，9个字节

使用的想法]来自Optimizer，但它使用一种非常不同的方法进行计数。

X~]:X,8mL

在线尝试

这个怎么运作：

X~          "push X and dump its contents.  On the zeroth iteration, X is a single number, but later is it an array.";
  ]         "wrap everything into an array.  The stack would contain the contents of X plus the result of the previous instance of the code";
   :X       "store this array back into X.  X is now 1 element longer";
     ,      "take the length of X";
      8mL   "do a base-8 logarithm of it";

其他两个9字节解决方案

]X+:X,8mL

],X+:X8mL

Python 2、15 * 3 = 45

m=n=0;E=exit  ;
m+=1;n+=m>3**n;
print n;E()   ;

计数先行然后记录三再退出的想法的另一种实现方式。也许还能打更多的高尔夫球。

公元前2 * 16 + 1 = 33

分数中额外的+1是因为-l需要bc选项：

a+=1;          
l(a)/l(3);halt;

Golfscript，7 * 2 = 14

1+~abs(
3base,}

这是受Sp3000的回答启发的，尤其是对优化长第二行的渴望。3base,与GS中以3为底的对数一样短，并且超注释}显然是最佳的。

第一行需要将空字符串''从初始stdin映射到0，然后将每个非负整数映射到其后继。这样，我们3^n - 1在堆栈上以第一行结束，并且3base,不需要任何递减。

C，13x8

#ifndef A//__
#define A//__
x;a;main(){//
a++;;;;;;;;;;
while(a/=3)//
x++;printf(//
"%d",x);}//__
#endif//_____

佩尔（76）

我知道发布此消息可能没有多大意义，因为它已经被彻底击败了，但是无论如何这是我当前的解决方案。

$_++;                                 
if(not$_&$_-1){print log()/log 8;$_--}

> <>（鱼），12 * 3 = 36

一个更直接的> <>解决方案：

'v'00p0l1+  
>  :2-?v$1+v
^$+1$,3< ;n<

我们首先运行顶部块的第一行。'v'00p放在v整个程序的第一位置，在到达行尾后返回到开始时将程序指针向下。在此之前，每个块都将0和堆栈长度+ 1压入到其上。（堆栈将为0 2 0 4 0 6 ...）

在第二个和第三个的前半部分，我们计算在获得2之前可以将顶部堆栈元素划分多少次（我们将其存储在第二个到顶部元素中）。

最后，我们输出堆栈的第二个到顶部元素。

Lua，3 * 17 = 51

与大多数人相同的策略：

x=(x or 0)+1;    
y=math.log(x,3)  
print(y)os.exit()

PHP，22×2 = 44 27×2 = 54

<?php $i++          ?>
<?php die(log($i,3))?>

关于count-log3-out的另一种说法。不是很小，但是我第一次打高尔夫球;）