23

एक अच्छा भग्न प्यार कौन नहीं करता है? सिएरपिन्स्की कालीन एक भग्न का एक उत्कृष्ट उदाहरण है।

इस कार्य को पूरा करने के लिए, आपको स्तर के कालीन का प्रतिनिधित्व करने के लिए प्रकार की एक कारपेट उत्पन्न करना होगा $n$ और परिणामी छवि को stdout(प्रारूपण के लिए नीचे उदाहरण देखें) प्रिंट करना होगा $n$ । इस विकिपीडिया लेख पर कदम पाए जा सकते हैं ।

यह मान stdinया समकक्ष से लिया जाएगा ।

उदाहरण के लिए, 4 का इनपुट स्तर 4 कालीन का उत्पादन करेगा:

■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■
■   ■       ■   ■                   ■   ■       ■   ■
■ ■ ■       ■ ■ ■                   ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■                   ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■                   ■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■
■   ■       ■   ■ ■   ■       ■   ■ ■   ■       ■   ■
■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ ■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ■

3 के इनपुट से स्तर 3 कालीन का उत्पादन होगा:

■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■ ■ ■       ■ ■ ■
■   ■       ■   ■
■ ■ ■       ■ ■ ■
■ ■ ■ ■ ■ ■ ■ ■ ■
■   ■ ■   ■ ■   ■
■ ■ ■ ■ ■ ■ ■ ■ ■

2 का इनपुट स्तर 2 कालीन का उत्पादन करेगा:

■ ■ ■
■   ■ 
■ ■ ■

और 1 का इनपुट एक स्तर 1 कालीन (सिर्फ एक वर्ग) उत्पन्न करेगा:

■

कॉलम के बीच रिक्त स्थान पर ध्यान दें।

विचार ब्लॉक के लिए ■ चरित्र का उपयोग करना है और अंतराल के लिए जगह है

लाइन की शुरुआत ■ चरित्र से होती है।

हमेशा की तरह, सबसे छोटा समाधान चरित्र गणना (गैर-मानक वर्णों के कारण) से जीतता है।

वैकल्पिक रूप से, यूनिकोड का समर्थन नहीं करने वाली भाषाओं में ■ चरित्र के बजाय # का उपयोग किया जा सकता है।

code-golf ascii-art fractal

— पॉल क्लेवियर
स्रोत

1

क्या पहला उदाहरण दूसरे के बजाय तीसरे स्तर का नहीं है?

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

6

अच्छा सवाल है, लेकिन क्या वे पात्र हैं? वे ASCII नहीं हैं, जो बहुत सारी भाषाओं को नियंत्रित करता है। क्या वे सिर्फ स्पेस और X या O हो सकते हैं? मुझे वास्तव में लगता है कि खाली वर्गों के बजाय रिक्त स्थान के साथ आपकी छवि बेहतर होगी।

— लेवल रिवर सेंट

कालीनों को बदल स्पंज, धन्यवाद।

— पॉल क्लैवियर

यदि आपकी भाषा यूनिकोड आउटपुट का समर्थन नहीं करती है, तो क्या ASCII विकल्प भी है?

— दोष

1

क्या लाइनों में अनुगामी स्थान हो सकते हैं?

— डेनिस

15

CJam, 38 37 31 30 28 वर्ण

ओह ठीक है, हम पात्रों द्वारा गिन रहे हैं, तो चलिए कुछ यूनिकोड अनपैकिंग करते हैं:

"B胷맋풽巓뱖ᮨ㣙¬䙧੥墱륋청"2G#b129b:c~

इसका परीक्षण यहां करें। बस वांछित स्तर को इनपुट क्षेत्र में डालें।

व्याख्या

आधार रूपांतरण के बाद, यह है

3li(#,{3b1f&2b}%_f{f{&S9632c?S}N}

जो कि यूनिकोड वर्ण के साथ निम्नलिखित के समान ही है 9632c:

3li(#,{3b1f&2b}%_f{f{&S'■?S}N}

इस कोड को निम्नलिखित अवलोकन के आधार पर किया जाता है: अगर हम निर्देशांक को देखो (एक्स, वाई) प्रत्येक कोशिका के, तो हम एक खाली सेल मिलता है, जब भी दोनों एक्स और वाई एक है 1उनके आधार -3 प्रतिनिधित्व में एक ही स्थान पर। यदि आप इसके बारे में सोचते हैं, तो छोटे पैमाने पर दोहराता पैटर्न महत्वपूर्ण आधार -3 अंक है, फिर अगला अधिक महत्वपूर्ण अंक अगले बड़े पैमाने पर दोहराव को नियंत्रित करता है और इसी तरह।

3                                      "Push a 3 on the stack.";
 li(                                   "Read input, convert to integer, decrement.";
    #                                  "Raise to that power. This yields the dimensions.";
     ,                                 "Turn into a range array.";
      {       }%                       "Map the block onto the array.";
       3b                              "Convert to base 3.";
         1f&                           "Bit-wise AND each digit with 1.";
            2b                         "Convert to base 2.";
                _                      "Duplicate this list.";
                 f{          }         "Map this block onto one list, with the second list
                                        as an additional parameter.";
                   f{      }           "Map this block onto the second list, with the first
                                        list's current element as an additional parameter.";
                                       "I.e. this iterates over all coordinate pairs.";
                     &                 "Bitwise AND to check that the base-3 representations
                                        had a 1 in the same position.";
                      S'■?             "Select the right character.";
                          S            "Push a space.";
                            N          "Push a newline";

परिणामस्वरूप सरणी की सामग्री स्वचालित रूप से मुद्रित होती है।

डेनिस के लिए धन्यवाद तीन बाइट्स शेविंग के लिए।

— मार्टिन एंडर
स्रोत

2

#0<'■S-> #~S'■1 वर्ण बचाता है।

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

आप बदल सकते हैं [1_]a#~के साथ 3Yba&।

— डेनिस

@ डेनिस साफ-सुथरा। धन्यवाद!

— मार्टिन एंडर

@ डेनिस मैं भूल जाता हूं कि &एक सत्य / मिथ्या मूल्य (या यहां तक कि यह मौजूद है) पैदा करता है। एक सरणी में कुछ तत्व होते हैं या नहीं, इसका परीक्षण करने के लिए विहित तरीके से सीजेएम युक्तियों में एक पोस्ट के लायक हो सकता है।

— मार्टिन एंडर

1

@ य्प्निपन नोप। यह लंबे समय तक दिखता है, लेकिन ऐसा इसलिए है क्योंकि यूनिकोड वर्ण मोनोस्पेस नहीं हैं। अनपैक्ड कोड में 30 अक्षर हैं।

— मार्टिन एंडर

7

मतलाब (113) (110) (99) (85)

आप इसे यहाँ आज़मा सकते हैं (आपको input('')अपने इच्छित इनपुट से बदलना होगा ।)

अब 99 धन्यवाद feersum के लिए! और अब नीचे RTL को 85 धन्यवाद!

golfed:

a=ones(3);a(5)=0;c=1;for i=2:input('');c=kron(c,a);end;disp(char(kron(c,[1,0])*3+32))

Ungolfed:

a=ones(3);a(5)=0;c=1;  %creating the template / anchor
for i=2:input('');
    c=kron(c,a);       %recursive iterations
end;
disp(char(kron(c,[1,0])*3+32))

~~d=[c,c]*0; %this is all just for adding the additional spaces d(:,1:2:end)=c; disp(char(d*3+32)); %converting to spaces (32) and # (35)~~

स्पष्टीकरण:

मैं इस कार्य के लिए क्रोनकर उत्पाद का दुरुपयोग कर रहा हूं। (यह दो मनमाने आकार के मेट्रिसेस के लिए परिभाषित एक विशेष उत्पाद है। उदाहरण:

A = [1,2] is a 3x2 matrix, B is a nxm matrix.
    [3,4]
    [5,6]

फिर

kron(A,B) = [1*B , 2*B] is a 2n x 2m matrix.
            [3*B , 4*B]
            [5*B , 6*B]

तो n = 5 के लिए एक उदाहरण प्रस्तुत करता है (पुरानी गणना पद्धति में यह 4 है);

# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   #                                                       #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # #                                                       # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   #                                                       #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # #                                                       # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   #                                                       #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # #                                                       # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   #                                                       #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # #                                                       # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
#   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # #   #       #   #                   #   #       #   # 
# # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # # # #       # # #                   # # #       # # # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
#   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # #   # #   # #   #                   #   # #   # #   # 
# # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # # # # # # # # # #                   # # # # # # # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
#   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # #   #       #   # 
# # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # # # #       # # # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
#   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # #   # 
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

— flawr
स्रोत

धन्यवाद, मैंने ध्यान नहीं दिया कि आवश्यकताएँ बदल गईं। मैंने कोड भी अपडेट किया (मुझे सिर्फ लूप के लिए शुरुआती मूल्य को बदलना पड़ा।)

— त्रुटी

इसके बजाय d=zeros(size([c,c]))आपको उपयोग करना चाहिए d=[c c]*0।

— feersum

अच्छा, एक सुझाव: चर dकोस से बचा जा सकता kron: एक बार फिर disp(char(kron(c,[1,0])*3+32));,

— RTL

6

हास्केल, ११४ १०ask

s 1=["# "]
s n=k j++k(map(>>" ")j)++k j where j=s$n-1;k i=j%i%j
(%)=zipWith(++)
main=interact$unlines.s.read

— गर्वित हेकलर
स्रोत

5

अजगर - 100

r=range(3**~-input())
for i in r:print" ".join("# "[any(i/3**k%3==j/3**k%3==1for k in r)]for j in r)

— Wrzlprmft
स्रोत

5

पर्ल 5: 68 अक्षर

n स्टड पर।

#!/usr/bin/perl -l
//,print map/2/?"  ":"■ ",map$_+$',@,for@,=grep!/[24-9]/,0..3x<>/10

निर्देशांक की सूची का एक दशमलव कोडित टर्नरी प्रतिनिधित्व पहली बार उत्पन्न होता है @,(नाम चुना जाता है, इसलिए अंकों 0, 1 का उपयोग करके @,और बीच की जगह की कोई आवश्यकता नहीं है for), और 3. अब दशमलव डोमेन में x और y निर्देशांक जोड़ने के लिए एक 2 होगा परिणाम में अगर और केवल अगर दो पदों पर मेल खाते थे। बाहरी लूप ( ) से पोस्टमाच //चर $_तक डिफ़ॉल्ट चर को फैलाने के लिए उपयोग किया जाता है जब यह आंतरिक लूप में डिफ़ॉल्ट चर द्वारा छाया हुआ होता है ।for$'map

— nutki
स्रोत

4

जावा, 330 283 वर्ण

class T{public static void main(String[]a){int n=Integer.valueOf(a[0]);int m=(int)Math.pow(3,n-1);for(n=0;n<m;n++){for(int j=0;j<m;){String s="#";int x=n;int y=j++;while(x>0||y>0){if(x%3==1&&y%3==1){s=" ";}x/=3;y/=3;}p(s);}p("\n");}}static void p(String s){System.out.print(""+s);}}

परम आपको इच्छित आकार है। जब तक एल्गोरिथ्म के लिए एक अनुकूलन नहीं होता है, तब तक मैंने सब कुछ खत्म करने की कोशिश की।

@StretchManiac iविधि को हटाने और घोषणाओं को साफ करने के लिए धन्यवाद ने थोड़ा सा नीचे गिरा दिया।

पठनीय संहिता

class T {
    public static void main(String[] a) {
        int n = Integer.valueOf(a[0]);
        int m = (int) Math.pow(3, n - 1);
        for (n = 0; n < m; n++) {
            for (int j = 0; j < m;) {
                String s = "#";
                int x = n;
                int y = j++;
                while (x > 0 || y > 0) {
                    if (x % 3 == 1 && y % 3 == 1) {
                        s = " ";
                    }
                    x /= 3;
                    y /= 3;
                }
                p(s);
            }
            p("\n");
        }
    }

    static void p(String s) {
        System.out.print("" + s);
    }
}

— दिशा सूचक यंत्र
स्रोत

आप कक्षा से पहले "सार्वजनिक" से छुटकारा पा सकते हैं, जैसा कि आप कर सकते हैं String[]a, और यदि आप केवल iएक बार उपयोग कर रहे हैं , तो आप विधि से छुटकारा पाने से बेहतर होंगे।

— स्ट्रेच

@StretchManiac सुझावों के लिए धन्यवाद। मैं उन्हें थोड़ा सा लागू करूँगा।

— कम्पास

3

पृथ्वी पर आप ""+sअपनी pविधि में क्यों करते हैं ? यह बिल्कुल बिना किसी उद्देश्य के तीन अतिरिक्त वर्ण हैं। यहां तक कि अगर sइसके अलावा कुछ भी थे String, तब भी यह पूरी तरह से अनावश्यक होगा।

— डेविड कॉनरेड

1

यह करने के लिए परिवर्तित करें static void p(int s){System.out.print((char)s);}और मुख्य मेकअप उस में int s=35;, s=32;और p(10);(के बजाय p("\n");) और कुछ और पात्रों को बचाने।

— डेविड कॉनरेड

आप बदल Integer.valueOfसकते हैंnew Byte

— Ypnypn

4

रैकेट 230 229 225 220

गोल्फ के लिए रैकेट का सबसे अच्छा समय नहीं है।

golfed:

(define(s n)(letrec([t(λ(x y)(if(or(= x 0)(= y 0))"■"(if(=(modulo x 3)(modulo y 3)1)" "(t(floor(/ x 3))(floor(/ y 3))))))][i(expt 3(- n 1))])(for-each displayln(for/list([r i])(string-join(for/list([c i])(t r c))" ")))))

Ungolfed:

(define (s n)
  (letrec ([t (λ (x y)
                (if (or (= x 0) (= y 0)) 
                    "■"
                    (if (= (modulo x 3) (modulo y 3) 1)
                        " "
                        (t (floor (/ x 3)) (floor (/ y 3))))))]
           [i (expt 3 (- n 1))])
    (for-each displayln 
              (for/list ([r i])
                (string-join 
                 (for/list ([c i]) 
                   (t r c)) " ")))))

— मैथ्यू बटरिक
स्रोत

4

C: 123 118 111 104 वर्ण

मेरे पर्ल समाधान के समान विचार के आधार पर। कुछ रिक्त स्थान जोड़ने के बाद:

m=0x55555555;
x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&m?"":"%c%c",x&x/n&m?32:35,x&n-1?32:10);
}

2 अंकों के साथ प्रत्येक अंक को कोडित करने के लिए टर्नरी प्रणाली का उपयोग करता है। अवैध मान (विषम-सम स्थिति में दो वाले) को फ़िल्टर किया जाता है x & (x>>1) & 0b01010101। दोनों निर्देशांक एक मूल्य में संग्रहीत किए जाते हैं, इसलिए पिक्सेल रंग की जांच करना नीचे है x & (x >> 2 * n) & 0b01010101। nसुविधा के लिए 2 की शक्ति के रूप में संग्रहीत किया जाता है।

संपादित करें

defineएक साधारण स्थिरांक के साथ प्रतिस्थापित m।

संपादित करें 2

0x5555555मास्क का प्रतिनिधित्व किया जा सकता है (1LL<<32)/3, लेकिन हमें केवल nउन बिट्स की आवश्यकता है जो n/3पर्याप्त हैं।

x;
main(n){
  scanf("%d",&n);
  n=1<<2*--n;
  for(x=n*n;x--;)
    printf(x&x/2&n*n/3?"":"%c%c",x&x/n&n/3?32:35,x&n-1?32:10);
}

संपादित करें 3

छोटी सी टहनी। स्कैन nके निष्पादन के लिए लोडिंग मूल्य से पहले निष्पादित किए जा रहे स्कैनफ पर निर्भर एक 2 चार लाभ --n। अहंकार ही अनुसरण कर सकता है #, दुआ।

x;
main(n){
  n=scanf("%d",&n)<<2*--n;
  for(x=n*n;x--;)
    x&x/2&n*n/3||printf(x&x/n&n/3?"  ":x&n-1?"# ":"#\n");
}

— nutki
स्रोत

3

HTML / जावास्क्रिप्ट, 205 चार्ट

Obfuscatweet , 205 शुल्क

document.write(unescape(escape('🁳𨱲𪑰𭀾𬰽𙰦𫡢𬱰𞰧𞱮🐴𞱭👍𨑴𪀮𬁯𭰨𜰬𫠭𜐩𞱦𫱲𚁩🐰𞱩🁭𞱩𚰫𛁤𚀧🁢𬠾𙰩𚑻𩡯𬠨𪠽𜀻𪠼𫐻𚑩𩠨𨰨𪐬𪠫𚰩𚑤𚀧𘰧𚐻𩑬𬱥𘁤𚁳𚑽𩡵𫡣𭁩𫱮𘁣𚁸𛁹𚑻𭱨𪑬𩐨𮁼𯁹𚑻𪑦𚁸𙐳🐽𜐦𙡹𙐳🐽𜐩𬡥𭁵𬡮𘀰𞱸👦𚁸𚐻𮐽𩠨𮐩𯑲𩑴𭑲𫠠𜑽𩡵𫡣𭁩𫱮𘁦𚁡𚑻𬡥𭁵𬡮𘁍𨑴𪀮𩡬𫱯𬠨𨐯𜰩𯑦𭑮𨱴𪑯𫠠𩀨𨐩𮱤𫱣𭑭𩑮𭀮𭱲𪑴𩐨𬰫𨐩𯐼𛱳𨱲𪑰𭀾🁳𭁹𫁥🠪𮱦𫱮𭀭𩡡𫑩𫁹𞠢𠱯𭑲𪑥𬠢').replace(/uD./g,'')))

HTML / JS, 298 Chars

HTML व्हाट्सएप के साथ खेलने के कारण, कुछ वर्णों को nbsp char के लिए समर्पित होना पड़ा। इसके अलावा, अधिकांश ब्राउज़रों का डिफ़ॉल्ट फ़ॉन्ट कूरियर नहीं है, इसलिए मुझे इसे भी सेट करना था। स्टाइल के लायक लगभग 20 अक्षर। यदि इसके लिए प्रत्यक्ष इनपुट विधि की आवश्यकता होती है, तो मैं इसे जोड़ सकता हूं, लेकिन वर्तमान में इनपुट बदलने से n एक अलग मान पर सेट हो रहा है।

डेमो

<script>s='&nbsp;';n=4;m=Math.pow(3,n-1);for(i=0;i<m;i++,d('<br>')){for(j=0;j<m;)if(c(i,j++))d('#');else d(s)}function c(x,y){while(x||y){if(x%3==1&&y%3==1)return 0;x=f(x);y=f(y)}return 1}function f(a){return Math.floor(a/3)}function d(a){document.write(s+a)}</script><style>*{font-family:"Courier"

पठनीय HTML / JS

<script>
    s='&nbsp;';
    n=4;
    m=Math.pow(3,n-1);
    for(i=0;i<m;i++,d('<br>')){
        for(j=0;j<m;)
            if(c(i,j++))
                d('#');
            else d(s)
    }
    function c(x,y){
        while(x||y){
            if(x%3==1&&y%3==1)
                return 0;
            x=f(x);
            y=f(y)
        }
        return 1
    }
    function f(a){
        return Math.floor(a/3)
    }
    function d(a){
        document.write(s+a)
        }
</script>
<style>
*{font-family:"Courier"

— दिशा सूचक यंत्र
स्रोत

3

CJam, 38 35 32 31 अक्षर

"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

इसे ऑनलाइन आज़माएं।

उदाहरण चलाते हैं

$ cjam <(echo '"■ ""՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~') <<< 3; echo
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■

यह काम किस प्रकार करता है

"՛ୗ䁎뽔휼ꆩ闳⾿➺⥧槲㩡郊"6e4b128b:c~

यूनिकोड स्ट्रिंग को बेस 60,000 ( 6e4b) से बेस 128 ( 128b), कास्ट्स टू कैरेक्टर ( :c) में परिवर्तित करता है और परिणामी स्ट्रिंग () का मूल्यांकन करता है~ ) का ।

परिणामस्वरूप, निम्न कोड निष्पादित हो जाता है:

"■ "                                " C := '■ '                                           ";
    li(                             " J := int(input()) - 1                               ";
       {                      }*    " for I in range(J):                                  ";
        z]A*                        "   T := [zip(C)] * 10                                ";
            ):,                     "   U := pop(T)                                       ";
               Sf*                  "   V := [ ' ' * len(u) : u ∊ U ]                     ";
                  4\t               "   U[4] := V                                         ";
                     3/{:+z~}%      "   C := { c : c ∊ zip(concat(u)), u ∊ U.split(3) }   ";
                              zN*  " print '\n'.join(zip(C))                              ";

— डेनिस
स्रोत

3

अजगर 3 - 116 113 वर्ण

संपादित करें: अच्छी तरह से, इस ट्रिक का इस्तेमाल मैंने खुद को बहुत ज्यादा पसंद नहीं किया और कोड को 3 बाइट्स से संकुचित कर दिया। अगर यह सबसे अच्छा संभव तरीका है, लेकिन मैं इसके साथ जाऊँगा।

exec(bytes('ⱴ㵬❛離₠崧氬浡摢⁡㩺癥污稨✫⁫潦⁲⁫湩琠❝਩潦⁲⁩湩爠湡敧椨瑮椨灮瑵⤨⴩⤱爺瀬氽✨㍛✪Ⱙ⡬嬢⭫‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠⁮㩴牰湩⡴⥩','utf-16')[2:].decode('utf-8'))

इसमें कुछ अनपेक्षित वर्ण हो सकते हैं, इसलिए यहां स्ट्रिंग का एक मुद्रण योग्य संस्करण है।

'ⱴ㵬❛離₠崧氬浡摢\u2061㩺癥污稨✫\u206b潦\u2072\u206b湩琠❝\u0a29潦\u2072\u2069湩爠湡敧椨瑮椨灮瑵⤨\u2d29⤱爺瀬氽✨㍛✪Ⱙ⡬嬢\u2b6b‧✠⠪⨳椪⬩⤢琻爽瀫爫昊牯椠椠\u206e㩴牰湩⡴⥩'

बहुत महान नहीं है, लेकिन कम से कम कुछ भाषाओं को धड़कता है।

इसका विस्तार क्या है:

t=['■ ']
for i in range(int(input())-1):r,p=[k*3for k in t],[k+'  '*(3**i)+k for k in t];t=r+p+r
for i in t:print(i)

अगर कोई यह काम नहीं करता है, तो कुछ हद तक असंयमित

t=['■ ']                                     # iteration 1
for i in range(int(input()) - 1):            # do n-1 more iterations
    r = [k * 3 for k in t]                   # first & last rows are the last carpet x3
    p = [k + '  ' * (3 ** i) + k for k in t] # middle row: last carpet, space, last carpet
    t = r + p + r                            # and put them to the new carpet
for i in t:                                  # print final iteration
    print(i)

— PurkkaKoodari
स्रोत

वाह अजगर, यह प्रभावशाली है

— पॉल क्लेवियर

3

गणितज्ञ, 71 बाइट्स

Grid@Nest[ArrayFlatten@ArrayPad[{{0}},1,{{#}}]&,1,#]/.{0->"",1->"■"}&

इनपुट

3

उत्पादन

— J42161217
स्रोत

मैंने आपको कुल लता की तरह पालन किया। +1;)।

— मैजिक ऑक्टोपस Urn

क्या आपको लगता है कि आप सबस्टीट्यूशन सिस्टम के साथ इसे छोटा कर सकते हैं ?

— विटालि कौरोव

2

सीजेएम, 76 वर्ण

3ri(#:M_*,{_M/:I\M%:J;;{I3%1=J3%1=&0X?:X;I3/:I0>J3/:J0>|}gX'■S?1:X;}%M/Sf*N*

यह यहाँ दिए गए सूत्र का सीधा अनुवाद है

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

— अनुकूलक
स्रोत

2

बैश + कोरुटिल्स, 105 यूनिकोड वर्ण

चूंकि हम वर्णों की गिनती कर रहे हैं और बाइट्स नहीं:

eval `iconv -tunicode<<<潦⡲眨㌽⨪␨ⴱ⤱琬〽琻眼眪琻⬫⤩笻戠ꂖ昻牯⠨㵸╴ⱷ㵹⽴㭷㹸簰祼〾砻㴯ⰳ⽹㌽⤩笻⠠砨㌥ㄭ籼╹ⴳ⤱簩扼尽簠硼〽紻瀻楲瑮⁦␢⁢㬢⠨╴⵷⭷⤱簩敼档㭯੽|cut -b3-`

इसके डिकोड किए गए रूप में:

शुद्ध बैश, 143 बाइट्स

for((w=3**($1-1),t=0;t<w*w;t++));{
b=■
for((x=t%w,y=t/w;x>0||y>0;x/=3,y/=3));{
((x%3-1||y%3-1))||b=\ ||x=0
}
printf "$b "
((t%w-w+1))||echo
}

इनपुट कमांड-लाइन आर्ग्स से लिया गया है:

आउटपुट:

$ ./sierpinskicarpet.sh 3
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■ ■ ■       ■ ■ ■ 
■   ■       ■   ■ 
■ ■ ■       ■ ■ ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
■   ■ ■   ■ ■   ■ 
■ ■ ■ ■ ■ ■ ■ ■ ■ 
$

— डिजिटल आघात
स्रोत

2

सी#

पूरा कार्यक्रम - २३ 23:

using System;class P{static void Main(string[] a){int b=(int)Math.Pow(3,int.Parse(a[0])-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}Console.WriteLine(g);}}}

LINQPad - 166 + Math.Ceiling(Math.Log(a + 1) / Math.Log(10))

int a=3;int b=(int)Math.Pow(3,a-1),c,d,e,f;for(c=0;c<b;c++){var g="";for(d=0;d<b;){var h="■";e=c;f=d++;while(e>0|f>0){h=e%3==1&f%3==1?" ":h;e/=3;f/=3;}g+=h;}g.Dump();}

— विलियम बारबोसा
स्रोत

मुझे पता है कि यह लगभग तीन साल हो गया है, लेकिन आप कुछ चीजों को इस तरह से गोल्फ कर सकते हैं:

using System;class P{static void Main(string[]a){string g,h;for(int b=(int)Math.Pow(3,int.Parse(a[0])-1),c=-1,d,e,f;++c<b;Console.WriteLine(g))for(g="",d=0;d<b;g+=h)for(h="■",e=c,f=d++;e>0|f>0;e/=3,f/=3)h=e%3==1&f%3==1?" ":h;}}

( 229 बाइट्स / 227 अक्षर ) ( ■= 3 बाइट्स, इसलिए आप इसे #2 बाइट्स को बचाने के साथ बदल सकते हैं )। मैंने मुख्य रूप से फॉर-लूप्स के अंदर सब कुछ रखा है, इसलिए कोष्ठक की अब कोई आवश्यकता नहीं है।

— केविन क्रूजसेन

2

सी - 154

स्टड से इनपुट। मैंने एक अतिरिक्त कार्य से बचने के लिए एक अच्छा तरीका खोजने की कोशिश की, लेकिन किसी के साथ नहीं आ सका।

वर्ण गणना में केवल आवश्यक स्थान शामिल हैं।

p(l,x,y){
    return l?x/l&y/l&1||p(l/3,x%l,y%l):0;
}
x,y;
main(v){
    scanf("%d",&v);
    v=pow(3,--v);
    for(;y<v;y++,puts(""))
        for(x=0;x<v;)
            printf("%c ",p(v,x++,y)?32:35);
}

— Allbeert
स्रोत

1

PHP, 194 अक्षर

nकमांड लाइन में पहले तर्क के रूप में प्राप्त किया।

<?php
function d(&$a,$n,$e,$x,$y){if(--$n)for(;$i<9;)$p=pow(3,$n)|d($a,$n,$e|$i==4,$x+$p*$j,$y+$p*($i-$j)/3)|$j=++$i%3;else$a[$x][$y]=$e?" ":■;}@d($a,$argv[1]);foreach($a as$s)echo join($s),"
";

पठनीय

<?php

function draw(&$array, $n, $empty, $x, $y) {
    $n--;
    if ($n != 0) {
        for ($i = 0; $i < 9; $i++) {
            $j = $i % 3;
            $p = pow(3, $n);
            draw($array, $n, $empty || $i == 4, $x + $p * $j, $y + $p * ($i - $j) / 3);
        }
    } else {
        $array[$x][$y] = $empty ? " " : "#";
    }
}

$array = array();
draw($array, $argv[1], false, 0, 0);
foreach ($array as $line) {
    echo join($line), "\n";
}

— Gedrox
स्रोत

1

यदि आप ■इसके बजाय चार का उपयोग करते हैं #, तो आप उद्धरण हटाकर 2 चार्ट बचा सकते हैं।

— इस्माईल मिगुएल

1

स्काला 230 वर्ण

गोल्फ कोड:

object T extends App {def m=math.pow(3,args(0).toInt-1).toInt-1;def p=print _;val x=0 to m;x.map{n=>x.map{j=>if(q(n,j)==1)p(" #");else p("  ")};p("\n");};def q(n:Int,j:Int):Int={if(n>0|j>0)if((n%3&j%3)==1)0 else q(n/3,j/3)else 1}}

अघोषित कोड:

object T extends App {
  def m = math.pow(3, args(0).toInt - 1).toInt - 1;

  def p = print _;
  val x = 0 to m;
  x.map { n => x.map { j => if (q(n, j) == 1) p(" #"); else p("  ")}; p("\n");};

  def q(n: Int, j: Int): Int = {
    if (n > 0 | j > 0) if ((n % 3 & j % 3) == 1) 0 else q(n / 3, j / 3) else 1
  }
}

केवल आवश्यक रिक्त स्थान शामिल हैं।

— Mathill
स्रोत

1

वी , 21 बाइट्स (गैर-प्रतिस्पर्धात्मक)

é*Àñ}yPgvr PGï3pyGHP

इसे ऑनलाइन आज़माएं!

Hexdump:

00000000: e92a c0f1 167d 7950 6776 7220 5047 ef33  .*...}yPgvr PG.3
00000010: 7079 4748 50                             pyGHP

V चुनौती से नया है, इसलिए इसे गैर-प्रतिस्पर्धा के रूप में चिह्नित किया जाना चाहिए। लेकिन फिर भी, यह जवाब देखने में अच्छा लगता है कि वायाए को अन्य सभी की तुलना में कम है, यहां तक कि जब वर्णों के बजाय बाइट्स में गिनती होती है।

— DJMcMayhem
स्रोत

याद दिलाने हेतु; अब यह गैर-प्रतिस्पर्धी नहीं है

— RedClover

1

ओ.के., 40 बाइट्स

`0:" #"{(x-1)(,'//3 3#111101111b*9#,)/1}

इसे ऑनलाइन आज़माएं।

इसके साथ शुरू होता है 1, और फिर इसे एक ग्रिड में खींचता है (1 1 1;1 0 1;1 1 1), जिसे वह फिर एक ग्रिड में उसी तरह से खींचता है, आदि ने आवश्यक संख्या को दोहराया।

— zgrep
स्रोत

1

पायथन 2 , 91 बाइट्स

r=input()-1
for i in range(3**r):x,s='# ','  ';exec"x+=[x,s][i%3%2]+x;s*=3;i/=3;"*r;print x

इसे ऑनलाइन आज़माएं!

— XNOR
स्रोत

1

सी # (.NET कोर) , 162 बाइट्स

n=>{var f="";int s=(int)Math.Pow(3,n),z=0;while(z<s*s){int x=z%s,y=z/s,h=1;for(;x>0|y>0;y/=3,x/=3)if(y%3==1&x%3==1)h=0;f+=" #"[h]+(z++%s<s-1?" ":"\n");}return f;}

इसे ऑनलाइन आज़माएं!

Degolfed

n=>{
    var f="";
    int s=(int)Math.Pow(3,n),z=0;

    while(z<s*s)
    {
        int x=z%s, y=z/s, h=1;
        for(; x>0 | y>0; y/=3, x/=3)
            if(y%3==1 & x%3==1)
                h=0;

        f += " #"[h] + (z++%s<s-1? " " : "\n");
    }

    return f;
}

— Ayb4btu
स्रोत

0

SOGL V0.12 , 27 बाइट्स

 ■¹.H{³³┼┼≥: ■@ŗ;┼┼⁴++}{@∑P

यह कोशिश करो!

— dzaima
स्रोत

0

आर , 92 अक्षर

विशेष चरित्र के साथ 94 बाइट्स।

write(c(" ","■")[1+Reduce("%x%",rep(list(matrix(c(1,1,1,1,0,1),3,3)),n<-scan()-1),1)],1,3^n)

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत

मैं चकित हूं कि लोग अभी भी 4 साल बाद ऐसा कर रहे हैं

— पॉल क्लैविअर

1

@PaulClavier यह एक बड़ी चुनौती है; आपको गर्व होना चाहिए :)

— Giuseppe

0

कैनवास , १ 17 १६ १ 17 अक्षर

■；╷［⌐ ＋２×；┌∔∔；３＊＋

यहाँ यह कोशिश करो!

-1: पहले लूप के अंदर हटाने के बजाय उपयोग किया ［जाता है । ｛；
+1: स्थिर उन्मत्त व्यवहार: ■अब मूल पद में निर्दिष्ट स्तर 1 से मेल खाता है।

— hakr14
स्रोत

यह है एक नए आम सहमति प्रति प्रतिस्पर्धा,।

— एर्ग आउटफोलर

@EriktheOutgolfer ओह, मुझे बताने के लिए धन्यवाद!

— hakr14

और हाँ, इस मामले में स्कोर है 17 है, लेकिन हम बाइट में समाधान, नहीं वर्ण (कैनवास एक कोड पेज है) गिनती।

— आउटगोल्फर

@ EriktheOutgolfer सामान्य रूप से हाँ, लेकिन मल्टीबाइट होने के कारण यह चुनौती वर्णों का उपयोग करती है ■। मूल पोस्ट में नीचे की ओर ऐसा कहते हैं।

— hakr14

आपको अपने सभी इनपुट में एक जोड़ना होगा। 1 को एक वर्ग लौटना चाहिए (यानी 0 यहाँ क्या लौटाता है)

— पॉल क्लैविअर

0

पिप `-S` , 30 अक्षर

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3

इसे ऑनलाइन आज़माएं!

मूल विचार: आधार में एक समन्वित ग्रिड पर विचार करें। कालीन में छेद होता है जहां 1) x- समन्वय में एक ट्रिट है 1, और 2) y- समन्वय में समान स्थिति में ट्रिट भी है 1।

"■■ "@MX{{aTB3R2i}MSg}MC3**a/3
                                i is 0; a is 1st cmdline arg (implicit)
                        3**a/3  Width/height of the carpet
                      MC        Make a coordinate grid that size and map this function
                                to the coordinate pairs:
                    g            Take each [x y] pair
                  MS             Map this function to each coord and add the results:
         {aTB3   }                Convert to base 3
              R2i                 Replace 2's with 0's
                                  E.g. 15 -> 120 -> 100 and 16 -> 121 -> 101
                                 When we add the results, we get [15 16] -> 201
      MX{            }           Take the max of that list (0, 1, or 2)
"■■ "@                           Use that to index into this string (resulting in a space
                                 iff two 1's coincided to make a 2, or ■ otherwise)
                                Print the resulting nested list with each sublist on its
                                own line and space-delimited (implicit, -S flag)

समान समाधान, वर्णों की समान संख्या लेकिन -2 बाइट्स: {2N({aTB3R2i}MSg)?s'■}MC3**a/3

— DLosc
स्रोत

0

K (ngn / k) , 50 बाइट्स

धन्यवाद @DLosc मुझे याद दिलाने के लिए मुझे स्तंभों के बीच रिक्त स्थान का उत्पादन करना चाहिए

1@"\n"/"# "1_',/'1,''+/''a*/:\:a:+2!!1_(. 0:"")#3;

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

@ डल धन्यवाद, निश्चित अन्य अजीब आवश्यकताएं भी: arg / result के बजाय stdin / stdout; ऑफ-वन-एक "स्तर"

— ngn

Sierpinski कालीन

CJam, 38 37 31 30 28 वर्ण

व्याख्या

मतलाब (113) (110) (99) (85)

हास्केल, ११४ १०ask

अजगर - 100

पर्ल 5: 68 अक्षर

जावा, 330 283 वर्ण

पठनीय संहिता

रैकेट 230 229 225 220

C: 123 118 111 104 वर्ण

संपादित करें

संपादित करें 2

संपादित करें 3

HTML / जावास्क्रिप्ट, 205 चार्ट

Obfuscatweet , 205 शुल्क

HTML / JS, 298 Chars

पठनीय HTML / JS

CJam, 38 35 32 31 अक्षर

उदाहरण चलाते हैं

यह काम किस प्रकार करता है

अजगर 3 - 116 113 वर्ण

गणितज्ञ, 71 बाइट्स

सीजेएम, 76 वर्ण

बैश + कोरुटिल्स, 105 यूनिकोड वर्ण

शुद्ध बैश, 143 बाइट्स

आउटपुट:

सी#

सी - 154

PHP, 194 अक्षर

पठनीय

वी , 21 बाइट्स (गैर-प्रतिस्पर्धात्मक)

ओ.के., 40 बाइट्स

पायथन 2 , 91 बाइट्स

सी # (.NET कोर) , 162 बाइट्स

Degolfed

SOGL V0.12 , 27 बाइट्स

आर , 92 अक्षर

कैनवास , १ 17 १६ १ 17 अक्षर

पिप -S , 30 अक्षर

K (ngn / k) , 50 बाइट्स

पिप `-S` , 30 अक्षर