Sierpinskified कोड

Question

पाठ का एक आयताकार ब्लॉक लिखिए, जब एक 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क्योंकि इसे शून्य पुनरावृत्ति माना जा सकता है।

यह आगे के सभी पुनरावृत्तियों के लिए काम करना चाहिए। (कम से कम सैद्धांतिक रूप से, कंप्यूटर की स्मृति और सभी है।)

विवरण

• कार्यक्रम उनके स्रोत कोड के बारे में जानकारी को पढ़ या एक्सेस नहीं कर सकते हैं। इसे एक सख्त क्वीन चैलेंज की तरह ट्रीट करें।
• आउटपुट स्टडआउट या समान विकल्प पर जाता है। केवल आउटपुट संख्या और एक वैकल्पिक अनुगामी न्यूलाइन। कोई इनपुट नहीं है।
• टेक्स्ट ब्लॉक में कोई भी वर्ण हो सकता है जिसे लाइन टर्मिनेटर नहीं माना जाता है । पाठ ब्लॉक में रिक्त स्थान हो सकते हैं।
• कालीन में "रिक्त स्थान" में पूरी तरह से अंतरिक्ष वर्ण शामिल होने चाहिए ।
• आप वैकल्पिक रूप से मान सकते हैं कि सभी कार्यक्रमों में एक नई रूपरेखा है।

आप किसी भी पुनरावृत्ति पर दिए गए टेक्स्ट ब्लॉक के लिए कालीन उत्पन्न करने के लिए इस स्टैक स्निपेट का उपयोग कर सकते हैं:

<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उदाहरण 6. के स्कोर के लिए 2 से 3 है (मूल रूप से कम से कम कोड जीतता है, इसलिए कोड गोल्फ टैग।)

टाईब्रेकर प्रस्तुत करने के लिए जाता है जो अपने पाठ ब्लॉक में सबसे कम विशिष्ट वर्णों का उपयोग करता है। यदि अभी भी बंधा हुआ है, तो उत्तर ने पहली जीत दर्ज की।

Answer 1

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

इसे यहाँ ऑनलाइन आज़माएँ

Answer 2

piet - 32 * 6 = 192

मैंने खाली जगह को चेकर पैटर्न से भर दिया। मुझे लगता है कि यह Sierpinski को थोड़ा तिगुना बना देता है।

यहाँ दूसरा पुनरावृत्ति है:

मूल: 32 * 7

Answer 3

> <> , 11 * 2 = 22

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

यहां हम> <> की कूद / टेलीपोर्ट कार्यक्षमता का उपयोग करके एक अलग दृष्टिकोण लेते हैं।

कार्यक्रम केवल शीर्ष पंक्ति में ब्लॉक निष्पादित करता है, 1/2 ब्लॉक को चलाता है, फिर 3/4 वां ब्लॉक, 9 वां / 10 वां ब्लॉक, 27 वां / 28 वां ब्लॉक, आदि (3 की शक्तियों में ऊपर जा रहा है)। जैसा कि शीर्ष पंक्ति में 3^nब्लॉक हैं, केवल nप्रोग्राम को वापस शुरू होने से पहले ही ब्लॉक निष्पादित किया जाता है, स्टैक और हाल्ट के शीर्ष को आउटपुट करता है ( nनिर्देश के माध्यम से रखा गया है p)।

प्रोग्राम नियम का उपयोग करता है "कोई इनपुट नहीं है।", क्योंकि iEOF मिलने पर कमांड स्टैक पर 1 धक्का देता है। तो यह परीक्षण करने के लिए आपको एक खाली फ़ाइल में पाइप करना होगा।

---

पिछला सबमिशन, 7 * 4 = 28

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

पहली पंक्ति लगातार प्रत्येक ब्लॉक के लिए स्टैक की लंबाई को धक्का देती है, और पुट कमांड का उपयोग करके पहली "बोली को डाउन एरो में बदल देती है । जब तक पहली पंक्ति खत्म हो जाती है, तब तक स्टैक दिखता हैvp

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

(ध्यान दें कि प्रारंभिक lका उपयोग दो बार किया जाता है।)

पिछली तीन पंक्तियाँ तब गिनती हैं कि 1 को हिट करने से पहले हमें कितनी बार 3 से भाग देने की आवश्यकता है (क्योंकि> <> एक लॉग फ़ंक्शन नहीं है)। नीचे शून्य का उपयोग गिनती का ट्रैक रखने के लिए किया जाता है।

Answer 4

पर्ल, २६

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

यह बेस 3 लॉगरिदम को अनुमानित करने के लिए हार्मोनिक श्रृंखला का उपयोग करता है। मुझे लगता है कि यह काम करता है, लेकिन मैंने इसे केवल छोटी संख्या के लिए आज़माया है। का उपयोग करने के विचार के लिए स्क्वीश ossifrage के लिए धन्यवाद die।

पुराना संस्करण (34):

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

Comments

यह बहुत साफ है!

— 15

Answer 5

पर्ल, 30 (15 × 2)

सबसे पहले, मैं यह दावा करने जा रहा हूं कि 10 पुनरावृत्तियां एक उचित सीमा है, न कि 2 ³² । 10 पुनरावृत्तियों के बाद, एन बाइट्स से मिलकर एक कार्यक्रम का विस्तार ( N × 3 ²⁰ ) बाइट्स (प्लस लाइन ब्रेक) हो जाएगा, जो कि N = 1 के लिए भी 3 गीगाबाइट से अधिक है । एक 32-बिट आर्किटेक्चर 11 पुनरावृत्तियों को संभालने में पूरी तरह से असमर्थ होगा। (और स्पष्ट रूप से 2 ³² पुनरावृत्तियों के लिए ब्रह्मांड में पर्याप्त कण नहीं हैं )।

तो यहाँ मेरा समाधान है:

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

यह $nपहली पंक्ति में चर को बढ़ाता है और प्रत्येक चरण में इसके लघुगणक की गणना करके काम करता है । दूसरी पंक्ति इस लघुगणक के पूर्णांक भाग को प्रिंट करती है और क्विट करती है।

आधार ई (2.718 ..) के लिए एक सरल लघुगणक पहले 10 पुनरावृत्तियों के लिए सही परिणाम देने के लिए पर्याप्त है।

Comments

ओपी के अनुसार, इसे सैद्धांतिक रूप से सभी पुनरावृत्तियों के लिए काम करना चाहिए।

— नाथन मेरिल

@NathanMerrill खैर, ठीक है। लेकिन मूल कल्पना के अनुपालन के लिए इसे वैकल्पिक ब्रह्मांडों में भी काम करना होगा। प्रश्न तब से संपादित किया गया है।

— स्क्वीश ossifrage

मैंने यहां बनाए गए अच्छे अंकों के कारण प्रश्न को बदल दिया। मैं सहमत हूं कि प्राकृतिक लॉग का उपयोग करना एक ग्रे क्षेत्र है, लेकिन ईमानदारी से मैं बहुत चिंतित नहीं हूं क्योंकि यह जीत नहीं रहा है।

— केल्विन के शौक

इनमें से अधिकांश प्रस्तुतियाँ केवल 3 ^ nx 1 टाइल की शीर्ष पंक्ति में नियंत्रण रखती हैं। यदि आप कालीन के उस खंड को उत्पन्न करते हैं, तो आप इसे थोड़ा आगे बढ़ा सकते हैं। लगभग निश्चित रूप से जहां गोलाई त्रुटियां आपको तोड़ देगी।

— कैप्टनक्रिग

जैसा कि मैंने पहले ही उल्लेख किया है, मूल प्रश्न ने कोड के लिए कहा जो पुनरावृत्तियों की "उचित" संख्या (2 ^ 32 तक) हो सकता है । यदि आप मैथ्स करते हैं, तो आप पाएंगे कि कई पुनरावृत्तियों के बाद भी 10 ^ 4098440370 बाइट्स से अधिक एकल बाइट का विस्तार होगा। मैंने एक उत्तर प्रस्तावित किया जो मुझे लगा कि थोड़ा अधिक उचित है, लेकिन तब से "उचित" शब्द प्रश्न से गायब हो गया है: - / /। देखिए, मैं यहां कर रहा हूं। यदि आपको यह पसंद नहीं है तो बस इस उत्तर को डाउनवोट करें।

— स्क्वीश ossifrage

Answer 6

गोल्फस्क्रिप्ट, 9 * 2 = 18

0+       
,3base,(}

(ध्यान दें कि पहली पंक्ति में आयताकार बनाने के लिए अनुगामी स्थान हैं)

मुझे गोल्फस्क्रिप्ट के लिए एक लॉग फंक्शन नहीं मिला, इसलिए करना baseपड़ा।

गोल्फस्क्रिप्ट एक खाली स्ट्रिंग के साथ शुरू होता है, इसलिए 0+बस स्ट्रिंग की लंबाई 1 (कुंडली द्वारा) बढ़ाता है। पहली पंक्ति खत्म होने तक, स्टैक में लंबाई की एक स्ट्रिंग होगी 3^n, जिसे हम सुपर कमेंट करने से पहले लॉग बेस 3 लेते हैं। nफिर स्वचालित रूप से मुद्रित किया जाता है।

Comments

आप एक स्ट्रिंग के बजाय पूर्णांक का उपयोग करके 2 वर्णों को बचा सकते हैं और इसलिए ,दूसरी पंक्ति पर बचत कर सकते हैं । पहली पंक्ति 0or):; दूसरी पंक्ति 3base,(}। दूसरी स्पष्ट लक्ष्य (दूसरी पंक्ति पर है। यह पेचीदा है, लेकिन पहली पंक्ति को 1+~abs(7 * 2 आयत के साथ बदलकर भी हटाया जा सकता है ।

— पीटर टेलर

Answer 7

सी, 12x8 = 96

@Ciamej से प्रेरित होकर, मैंने इसे कम कर दिया है। यह उस 3 चाल से विभाजित करता है, साथ ही यह अहसास भी करता है कि कालीन प्रभावी रूप से थोड़ी देर के लूप में परिवर्तित हो जाता है।

कोड को gcc / Ubuntu पर 3 तक पुनरावृत्तियों के लिए परीक्षण किया गया था।

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

---

पिछला समाधान: सी, 11x12

आकार विजेता नहीं, लेकिन हे, यह सी है।

यह बिटशफ्टिंग द्वारा ब्लॉकचेन का लॉग 2 पाता है, फिर लॉग 3 का अनुमान लगाने के लिए कुछ मैजिक नंबर और इंट ट्रंकेशन का उपयोग करता है। गणित को 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//__

Comments

नमस्ते, मैंने आपके समाधान का एक छोटा संस्करण पोस्ट किया है।

— ciamej

अच्छा चाल है कि अगर के साथ! ;)

— ciamej

Answer 8

CJam, 9 बाइट्स

उपयोग करने का विचार ]ऑप्टिमाइज़र का है, लेकिन यह गणना करने के लिए एक बहुत अलग विधि का उपयोग करता है।

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

Comments

यह वास्तव में टाईब्रेकर के साथ भी ऑप्टिमाइज़र को जोड़ता है। : पी टाईब्रेकरब्रेकर: पहले की पोस्ट जीतती है।

— केल्विन के शौक

मुझे लगता है कि यह एक अच्छा समाधान है। मैं 9 वर्णों को हरा नहीं सका हूं।

— PhiNotPi

मुझे लगता है कि सामान्य दृष्टिकोण केवल एक ही है (और जो एकमात्र दृष्टिकोण है जो समझ में आता है) - एक चर है, इसे किसी भी तरह से बढ़ाएं।

— ऑप्टिमाइज़र

Answer 9

अजगर 2, 15 * 3 = 45

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

गिनती-पहली-पंक्ति-फिर-लॉग-तीन-और-निकास विचार का एक और कार्यान्वयन। शायद अभी भी थोड़ा और अधिक गोल्फ हो सकता है।

Answer 10

बीसी, 2 * 16 + 1 = 33

स्कोर में अतिरिक्त +1 इसलिए है क्योंकि -lbc विकल्प की आवश्यकता है:

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

Answer 11

गोल्फस्क्रिप्ट, 7 * 2 = 14

1+~abs(
3base,}

यह Sp3000 के उत्तर से प्रेरित है , और विशेष रूप से लंबी दूसरी पंक्ति को अनुकूलित करने की इच्छा से। 3base,बेस -3 लॉगरिदम जीएस में मिलेगा, और सुपर-कमेंट }स्पष्ट रूप से इष्टतम है।

पहली पंक्ति के लिए जो आवश्यक ''है वह है प्रारंभिक स्ट्रिंग को 0 से खाली स्ट्रिंग को मैप करना , और फिर प्रत्येक गैर-नकारात्मक पूर्णांक को इसके उत्तराधिकारी को मैप करना। इस तरह हम 3^n - 1स्टैक पर पहली पंक्ति को समाप्त करते हैं , और 3base,इसके लिए किसी भी अपघटन की आवश्यकता नहीं होती है।

Answer 12

सी, 13x8

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

Answer 13

पर्ल, 76

मुझे पता है कि इसे पोस्ट करने में शायद कोई बात नहीं है क्योंकि यह पहले से ही पूरी तरह से पिट चुका है, लेकिन यहाँ मेरा वर्तमान समाधान है।

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

Comments

@ एलेक्स जो 1 पुनरावृत्ति पर भी काम नहीं करता है।

— PhiNotPi

हाँ, यह काम करता है क्योंकि यह खड़ा है। क्या आपने अपनी विधि का परीक्षण किया है?

— PhiNotPi

मेरा ideone पर काम करता है: ideone.com/othumP ।

— PhiNotPi

पकड़ लिया। मुझे एक महत्वपूर्ण विवरण याद आया जिसने इसे पहले काम करने से रोक दिया था। आप सही हैं, मेरा सुझाव गलत है।

— एलेक्स ए।

Answer 14

> <> (मछली), १२ * ३ = ३६

अधिक सीधा> <> समाधान:

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

हम पहले शीर्ष ब्लॉकों की शीर्ष पंक्ति चलाते हैं। 'v'00pपुट vकार्यक्रम सूचक नीचे की ओर निर्देशन जब यह पंक्ति के अंत तक पहुंचने के बाद वापस शुरू करने के लिए हो जाता है पूरे कार्यक्रम के पहले की स्थिति में। इससे पहले कि हर ब्लॉक 0 और स्टैक की लंबाई + 1 को आगे बढ़ाता है। (स्टैक होगा 0 2 0 4 0 6 ...)

दूसरी और तीसरी की पहली छमाही में हम गिनते हैं कि हम 2 से पहले शीर्ष स्टैक तत्व को कितनी बार विभाजित कर सकते हैं (हम इसे दूसरे में शीर्ष तत्व में संग्रहीत करते हैं)।

अंत में हम स्टैक के शीर्ष तत्व के लिए दूसरा उत्पादन करते हैं।

Answer 15

लुआ, 3 * 17 = 51

ज्यादातर लोगों के रूप में एक ही रणनीति:

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

Answer 16

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

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

बस एक और गिनती-लॉग-आउट पर ले लो। बहुत छोटा नहीं है, लेकिन मेरा पहला गोल्फ;)

Comments

PCG.SE पर हर जगह की तरह, कृपया पोस्ट करने से पहले दस्तावेज़ देखें :)।

— ब्लैकहोल

@ ब्लेकहोल अच्छा कैच! साभार

— लार्स एबर्ट