Boş bölümler için aynı büyüklükteki boşluk bloklarını kullanarak bir Sierpinski halıya yerleştirildiğinde , halının yineleme sayısını veren bir program oluşturan dikdörtgen bir metin bloğu yazın .

Örneğin, eğer metin bloğunuz

TXT
BLK

sonra programı çalıştırıyor

TXTTXTTXT
BLKBLKBLK
TXT   TXT
BLK   BLK
TXTTXTTXT
BLKBLKBLK

1Programın şekli Sierpinski halının ilk yinelemesini temsil ettiği için çıktı vermelidir .

Benzer şekilde, koşu

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 çıkış vermeli, çünkü bu ikinci Sierpinski halı yinelemesinin şeklidir.

Metin bloğunu olduğu gibi çalıştırma

TXT
BLK

çıkmalıdır 0çünkü sıfırıncı yineleme sayılabilir.

Bu, tüm tekrarlamalar için çalışmalıdır. (En azından teorik olarak, bilgisayarın hafızasına ve hepsine sahip olduğunu varsayarak.)

ayrıntılar

• Programlar kaynak kodlarıyla ilgili bilgileri okuyamayabilir veya erişemez. Buna sıkı bir sorgulama gibi davranın.
• Çıktı stdout'a veya benzer bir alternatife gider. Yalnızca sayıyı ve isteğe bağlı izleyen bir yeni satırı girin. Giriş yok.
• Metin bloğu, satır sonlandırıcı olarak kabul edilmeyen karakterleri içerebilir . Metin bloğu boşluk içerebilir.
• Halıdaki "boş alan" tamamen boşluk karakterlerinden oluşmalıdır .
• İsteğe bağlı olarak tüm programların sonunda yeni bir satır sonu olduğunu varsayabilirsiniz.

Herhangi bir yinelemede belirli bir metin bloğu için bir halı oluşturmak için bu yığın pasajını kullanabilirsiniz:

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

puanlama

İlk metin bloğu alana göre en küçük olan gönderim (genişlik kez yükseklik) kazanır. TXT\nBLKÖrnek 6 bir puan için 2 ile 3, (Temel olarak kısa kod kazanır, böylece kod golf etiketi.)

Tiebreaker, metin bloklarında en az belirgin karakteri kullanan gönderime gider. Hala bağlıysa, ilk kazanılanları cevapla.

CJam, 9 bayt

Bunun geliştirilebileceğini düşünüyorum ama şimdilik onunla devam edelim ...

];U):U8mL

Nasıl çalışır :

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

Burada çevrimiçi deneyin

piet - 32 * 6 = 192

Boş alanı denetleyici deseni ile doldurdum. Bence Sierpinski'yi biraz daha iyi yapar.

İşte ikinci yineleme:

orijinal: 32 * 7

> <> , 11 * 2 = 22

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

Burada> <> 'nın atlama / teleport işlevini kullanarak farklı bir yaklaşım izliyoruz.

Program sadece 1. / 2. bloğu, daha sonra 3. / 4. blokları, 9. / 10. blokları, 27 / 28. blokları vb. (3'ün gücünde yükseliyor) çalıştırarak en üst sıradaki blokları yürütür. Üst satırda bloklar bulunduğundan, program bloklar başa dönmeden önce 3^nsadece nbloklar yürütülür, yığının tepesini çıkarır ve durur ( nyerleştirilen komut nedeniyle p).

Program, "Giriş yok" kuralını kullanır, çünkü ikomut EOF karşılanırsa istifin üzerine -1 iter. Bu yüzden, bunu test etmek için boş bir dosyaya geçmeniz gerekir.

Önceki başvuru, 7 * 4 = 28

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

İlk satır, her blok için yığının uzunluğunu sürekli olarak iter ve put komutunu kullanarak ilk "teklifi bir aşağı oka dönüştürür . İlk satır bittiğinde, yığın benziyorvp

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

(İlk lharfin iki kez kullanıldığını unutmayın .)

Son üç satır daha sonra 1'e basmadan önce 3'e ne kadar bölmemiz gerektiğini sayar (> <> bir günlük işlevine sahip değildir). Alt sıfır, sayımı takip etmek için kullanılır.

Perl, 26

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

Bu, taban 3 logaritmasını yaklaşık olarak belirlemek için harmonik serileri kullanır. Sanırım işe yarıyor, ama sadece küçük sayılar için denedim. Kullanım fikri için istah açıcı ossifrage sayesinde die.

Eski versiyon (34):

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

Perl, 30 (15 × 2)

Her şeyden önce, 10 yinelemenin 2 ³² değil, makul bir sınır olduğunu iddia edeceğim . 10 yinelemeden sonra, N bayttan oluşan bir program , N = 1 için bile 3 gigabayttan fazla olan ( N × 3 ²⁰ ) bayta (artı satır kesmeleri) genişleyecektir . 32 bit mimari, 11 yinelemeyi tamamen kaldıramadı. (Ve belli ki evrende 2 ³² yineleme için yeterli parçacık yok ).

İşte benim çözümüm:

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

Bu, değişkeni $nilk satırda artırarak ve her adımda logaritmasını hesaplayarak çalışır. İkinci satır bu logaritmanın tamsayı kısmını basar ve çıkar.

E bazında (2.718 ..) basit bir logaritma ilk 10 tekrar için doğru sonuçlar verecek kadar yakındır.

Golfscript, 9 * 2 = 18

0+       
,3base,(}

(İlk satırın dikdörtgen yapmak için sonda boşlukları olduğunu unutmayın)

Golfscript için bir günlük işlevi bulamadım, bu yüzden baseyapmak zorunda kaldı.

Golfscript boş bir dizeyle başlar, bu yüzden dizenin 0+uzunluğunu 1'e kadar (zorlayarak) arttırır. İlk satır sona erdiğinde, yığının, 3^nsüper yorumu yapmadan önce 3 günlük kütük tabanını alacağımız bir dizi uzunluğu olacaktır . ndaha sonra otomatik olarak yazdırılır.

C, 12x8 = 96

@ Ciamej'den ilham aldım, düşürdüm. Bu üçlü hile ile bölmeyi kullanır, ayrıca halının etkin bir şekilde bir süre döngüsüne dönüştüğü idrakını kullanır.

Kod, gcc / Ubuntu'da, 3'e kadar tekrarlamalar için test edildi.

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

Önceki Çözüm: C, 11x12

Büyüklük kazanan değil, ama hey, C.

Blok sayısının log2'sini bit kaydırma yoluyla bulur, daha sonra log3'ü tahmin etmek için bazı sihirli sayılar ve int kesmeyi kullanır. Matematik 26 tekrarlamaya kadar çalışmalıdır (42 bitlik bir sayı).

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

Kullanma fikri ]Optimizer’dan geliyor ancak saymak için çok farklı bir yöntem kullanıyor.

X~]:X,8mL

Çevrimiçi deneyin

Nasıl çalışır:

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

İki diğer 9 byte çözüm

]X+:X,8mL

],X+:X8mL

Python 2, 15 * 3 = 45

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

Count-first-row-then-log-three-and-exit fikrinin başka bir uygulaması. Muhtemelen hala biraz daha golf oynayabilir.

bc, 2 * 16 + 1 = 33

Skordaki ekstra +1, -lbc seçeneğinin gerekli olmasından kaynaklanır:

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

Golfscript, 7 * 2 = 14

1+~abs(
3base,}

Bu Sp3000'in cevabından ve özellikle uzun ikinci çizgiyi optimize etme arzusundan esinlenmiştir . 3base,bir baz-3 logaritmasının GS'de alacağı kadar kısa ve süper yorum }açıkça optimal.

İlk satır için gerekli olan, boş dizgiyi ''ilk stdin'den 0'a eşlemek ve ardından her negatif olmayan tamsayı halefi ile eşlemektir. Bu sayede 3^n - 1istifin ilk satırını sonlandırırız ve 3base,herhangi bir azalma gerektirmez.

C, 13x8

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

Perl, 76

Zaten iyice dövüldüğünden beri bunu göndermenin pek bir anlamı olmadığını biliyorum, ama yine de şu andaki çözümüm.

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

> <> (Balık), 12 * 3 = 36

Daha basit bir> <> çözüm:

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

İlk önce üst blokların en üst sırasını çalıştırıyoruz. Tüm programın ilk pozisyonuna 'v'00pkoyar v, satırın sonuna ulaştıktan sonra program imlecini başa döndüğünde program işaretçisini aşağıya doğru yönlendirir. Bundan önce her blok 0 ve yığının uzunluğu + 1 üzerine itilir. (yığın olacak 0 2 0 4 0 6 ...)

İkinci ve üçüncü ayların ilk yarısında, üst yığın elemanını 2 almadan önce kaç kez bölebileceğimizi sayarız (bunu ikinci-üst elemanda saklarız).

Sonunda yığının ikinci ila üst elemanını çıkarırız.

Lua, 3 * 17 = 51

Çoğu insanla aynı strateji:

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'ta bir tane daha var. Çok küçük değil, ilk golfüm;)