Viết một khối văn bản hình chữ nhật mà khi được sắp xếp vào một tấm thảm Sierpinki , sử dụng các khối không gian có cùng kích thước cho các phần trống, sẽ tạo ra một chương trình tạo ra số lần lặp của tấm thảm.

Ví dụ: nếu khối văn bản của bạn là

TXT
BLK

sau đó chạy chương trình

TXTTXTTXT
BLKBLKBLK
TXT   TXT
BLK   BLK
TXTTXTTXT
BLKBLKBLK

nên xuất ra 1vì hình dạng của chương trình đại diện cho lần lặp đầu tiên của thảm Sierpinki.

Tương tự, chạy

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

nên xuất 2 vì đây là hình dạng của lần lặp thảm Sierpinki thứ hai.

Chạy khối văn bản như là

TXT
BLK

nên xuất ra 0bởi vì nó có thể được coi là lặp zeroth.

Điều này sẽ làm việc cho tất cả các lần lặp tiếp theo. (Ít nhất là về mặt lý thuyết, giả sử máy tính có bộ nhớ và tất cả.)

Chi tiết

• Các chương trình có thể không đọc hoặc truy cập thông tin về mã nguồn của họ. Đối xử với điều này giống như một thách thức nghiêm ngặt.
• Đầu ra đi đến thiết bị xuất chuẩn hoặc thay thế tương tự. Chỉ xuất số và một dòng mới tùy chọn. Không có đầu vào.
• Khối văn bản có thể chứa bất kỳ ký tự nào không được coi là dấu kết thúc dòng . Khối văn bản có thể chứa khoảng trắng.
• "Không gian trống" trong thảm phải bao gồm toàn bộ các ký tự không gian .
• Bạn có thể tùy ý giả sử tất cả các chương trình có một dòng mới.

Bạn có thể sử dụng đoạn mã ngăn xếp này để tạo một tấm thảm cho một khối văn bản nhất định tại bất kỳ lần lặp nào:

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

Chấm điểm

Bài nộp có khối văn bản ban đầu nhỏ nhất theo khu vực (chiều rộng lần chiều cao) là người chiến thắng. Các TXT\nBLKví dụ là 3 bởi 2 cho điểm của 6. (Về cơ bản thắng mã ngắn nhất, vì thế mà thẻ mã golf.)

Tiebreaker đi đến trình đệ trình sử dụng ít ký tự riêng biệt nhất trong khối văn bản của họ. Nếu vẫn bị ràng buộc, câu trả lời được đăng đầu tiên chiến thắng.

CJam, 9 byte

Tôi nghĩ rằng điều này có thể được cải thiện, nhưng bây giờ, hãy đi với nó ...

];U):U8mL

Cách thức hoạt động :

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

Dùng thử trực tuyến tại đây

piet - 32 * 6 = 192

Tôi lấp đầy không gian trống với mẫu kiểm tra. Tôi nghĩ rằng nó làm cho Sierpinki một chút trippier.

Đây là lần lặp thứ hai:

bản gốc: 32 * 7

> <> , 11 * 2 = 22

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

Ở đây chúng tôi thực hiện một cách tiếp cận khác bằng cách sử dụng chức năng nhảy / dịch chuyển tức thời của> <>.

Chương trình chỉ thực hiện các khối ở hàng trên cùng, chạy khối 1/2, sau đó là khối thứ 3/4, khối 9/10, khối 27/28, v.v. (đi lên theo cấp độ 3). Vì hàng trên cùng có 3^ncác khối, chỉ ncác khối được thực thi trước khi chương trình kết thúc trở lại bắt đầu, xuất ra đỉnh của ngăn xếp và tạm dừng (do nlệnh được đặt qua p).

Chương trình khai thác quy tắc "Không có đầu vào.", Vì ilệnh sẽ đẩy -1 lên ngăn xếp nếu EOF được đáp ứng. Vì vậy, để kiểm tra điều này, bạn sẽ cần đặt một tệp trống.

Gửi trước, 7 * 4 = 28

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

Dòng đầu tiên liên tục đẩy chiều dài của ngăn xếp cho mỗi khối và thay đổi "trích dẫn đầu tiên thành mũi tên xuống vbằng plệnh put. Khi dòng đầu tiên kết thúc, ngăn xếp trông giống như

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

(Lưu ý rằng chữ cái đầu lđược sử dụng hai lần.)

Ba dòng cuối cùng sau đó đếm số lần chúng ta cần chia cho 3 lần trước khi chúng ta nhấn 1 (vì> <> không có chức năng ghi nhật ký). Số không dưới cùng được sử dụng để theo dõi số đếm.

Perl, 26

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

Điều này sử dụng chuỗi điều hòa để xấp xỉ logarit cơ sở 3. Tôi nghĩ rằng nó hoạt động, nhưng tôi chỉ thử nó với số lượng nhỏ. Cảm ơn squossish ossifrage cho ý tưởng sử dụng die.

Phiên bản cũ (34):

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

Perl, 30 (15 × 2)

Trước hết, tôi sẽ tuyên bố rằng 10 lần lặp là giới hạn hợp lý, không phải là 2 ³² . Sau 10 lần lặp, một chương trình bao gồm N byte sẽ được mở rộng thành ( N × 3 ²⁰ ) byte (cộng dòng ngắt), vượt quá 3 gigabyte ngay cả với N = 1. Một kiến ​​trúc 32 bit sẽ hoàn toàn không thể xử lý 11 lần lặp. (Và rõ ràng là không có đủ các hạt trong vũ trụ cho 2 ³² lần lặp).

Vì vậy, đây là giải pháp của tôi:

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

Điều này hoạt động bằng cách tăng biến $ntrong dòng đầu tiên và tính toán logarit của nó ở mỗi bước. Dòng thứ hai in phần nguyên của logarit này và thoát.

Một logarit đơn giản cho cơ sở e (2.718 ..) đủ gần để đưa ra kết quả chính xác cho 10 lần lặp đầu tiên.

Golf, 9 * 2 = 18

0+       
,3base,(}

(Lưu ý rằng dòng đầu tiên có dấu cách để làm cho hình chữ nhật)

Tôi không thể tìm thấy một chức năng đăng nhập cho Golfscript, vì vậy basephải làm.

Golfscript bắt đầu với một chuỗi trống, vì vậy 0+chỉ cần tăng độ dài của chuỗi lên 1 (bằng cách ghép). Vào thời điểm dòng đầu tiên kết thúc, ngăn xếp sẽ có một chuỗi độ dài 3^n, chúng ta lấy cơ sở nhật ký 3 trước khi chúng ta siêu bình luận. nsau đó được in tự động.

C, 12x8 = 96

Lấy cảm hứng từ @ciamej, tôi đã giảm nó. Nó sử dụng phép chia đó cho 3 mẹo, cộng với việc nhận ra rằng thảm có hiệu quả chuyển đổi một if thành một vòng lặp while.

Mã đã được thử nghiệm trên gcc / Ubuntu cho số lần lặp lên đến 3.

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

Giải pháp trước: C, 11x12

Không phải là một người chiến thắng kích thước, nhưng hey, đó là C.

Nó tìm thấy log2 của blockcount bằng cách bẻ khóa, sau đó sử dụng một số số ma thuật và cắt ngắn để ước tính log3. Toán học nên hoạt động tối đa 26 lần lặp (số 42 bit).

#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 byte

Ý tưởng sử dụng ]là từ Trình tối ưu hóa, nhưng nó sử dụng một phương pháp rất khác để đếm.

X~]:X,8mL

Dùng thử trực tuyến

Làm thế nào nó hoạt động:

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

Hai giải pháp 9 byte khác

]X+:X,8mL

],X+:X8mL

Con trăn 2, 15 * 3 = 45

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

Một cách thực hiện khác của ý tưởng đếm-hàng-đầu-sau-sau-ba-và-thoát. Có lẽ vẫn có thể được chơi golf một chút công bằng hơn.

bc, 2 * 16 + 1 = 33

+1 thêm trong điểm số là do -ltùy chọn bc là bắt buộc:

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

Golf, 7 * 2 = 14

1+~abs(
3base,}

Điều này được lấy cảm hứng từ câu trả lời của Sp3000 và đặc biệt là mong muốn tối ưu hóa dòng thứ hai dài. 3base,ngắn như logarit cơ sở 3 sẽ nhận được trong GS và siêu nhận xét }rõ ràng là tối ưu.

Những gì cần thiết cho dòng đầu tiên là ánh xạ chuỗi trống ''từ stdin ban đầu thành 0, sau đó ánh xạ từng số nguyên không âm sang kế tiếp của nó. Theo cách này, chúng tôi kết thúc dòng đầu tiên với 3^n - 1ngăn xếp và 3base,không yêu cầu bất kỳ sự giảm giá nào.

C, 13x8

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

Perl, 76

Tôi biết có lẽ không có nhiều điểm trong việc đăng bài này vì nó đã bị đánh bại hoàn toàn, nhưng dù sao đây cũng là giải pháp hiện tại của tôi.

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

> <> (Cá), 12 * 3 = 36

Một giải pháp đơn giản hơn> <>:

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

Đầu tiên chúng tôi chạy hàng trên cùng của các khối hàng đầu. 'v'00pđặt vở vị trí đầu tiên của toàn bộ chương trình hướng con trỏ chương trình xuống dưới khi nó quay trở lại điểm bắt đầu sau khi đến cuối dòng. Trước đó, mỗi khối đẩy 0 và chiều dài của ngăn xếp + 1 lên nó. (ngăn xếp sẽ là0 2 0 4 0 6 ... )

Trong nửa đầu của giây thứ hai và thứ ba, chúng tôi đếm số lần chúng tôi có thể chia phần tử ngăn xếp trên cùng trước khi chúng tôi nhận được 2 (chúng tôi lưu trữ phần tử này trong phần tử thứ hai đến đầu).

Cuối cùng, chúng ta xuất phần tử thứ hai lên trên cùng của ngăn xếp.

Lua, 3 * 17 = 51

Chiến lược giống như hầu hết mọi người:

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

Chỉ cần một lần nữa vào đếm-log3-out. Không nhỏ lắm, nhưng cái golf đầu tiên của tôi;)