सीरपिन्स्की परतें

Question

/\आप के साथ शुरू एक Sierpinski त्रिकोण पैटर्न की तरह बना सकते हैं कि नीचे एक लाइन जोड़कर ...

1. कोई भी ढीली शाखा /या \दो शाखाओं में फिर से विभाजित /\:।
2. शाखाओं की कोई भी टक्कर \/इसके तहत कुछ भी नहीं (लेकिन रिक्त स्थान) के साथ मर जाती है।

इन नियमों को दोहराने से पैदावार होती है

     /\
    /\/\
   /\  /\
  /\/\/\/\
 /\      /\
/\/\    /\/\
etc...

( विहार्ट द्वारा प्रेरणा )

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है और इस पैटर्न की पहली एन लाइनों को स्टडआउट में प्रिंट करता है, जिसमें आवश्यक से अधिक अग्रणी या अनुगामी स्थान नहीं है।

उदाहरण के लिए, यदि इनपुट 1आउटपुट है तो होना चाहिए

/\

यदि इनपुट है 2तो आउटपुट होना चाहिए

 /\
/\/\

यदि इनपुट है 8तो आउटपुट होना चाहिए

       /\
      /\/\
     /\  /\
    /\/\/\/\
   /\      /\
  /\/\    /\/\
 /\  /\  /\  /\
/\/\/\/\/\/\/\/\

और इसी तरह।

सबसे कम बाइट्स वाला कोड जीतता है।

Comments

क्या आप कृपया कोड कम्प्रेशन शेंनिगन से बचने के लिए इसे "सबसे छोटा बाइट्स" बना सकते हैं?

— xnor

@xnor बदल गया।

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

मैं सचमुच इसे पोस्ट करने वाला था। Meanie। : /

— कज़ वोल्फ

एपीएल जवाब कहां है?

— जो

Answer 1

गोल्फस्क्रिप्ट (42 बाइट्स)

~,-1%1\{' '*\.2base{'  /\\'2/=}%n@.2*^}/;;

ऑनलाइन डेमो

यह पास्कल के त्रिकोण और सीरपिन्स्की त्रिकोण के बीच एक प्रसिद्ध संबंध का शोषण करता है।

Answer 2

CJam, 48 46 बाइट्स

li(_S*"/\\":T+\{_N@S+TW%/S2**" /"/"\ "f/:+T*}*

प्रश्न में टिप्पणियों 1 और 2 पर आधारित सरल पुनरावर्ती दृष्टिकोण।

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

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

li(         " L := int(input()) - 1            ";
_S*         " A := L * ' '                     ";
"/\\":T+    " A += (T := '/\')                 ";
\{          " do L times:                      ";
  _N        "   push A, '\n'                   ";
  @S+       "   A += ' '                       ";
  TW%/      "   B := A.split(reverse(T))       ";
  S2**      "   A := '  '.join(B)              ";
  " /"/     "   B := A.split(' /')             ";
  "\ "f/    "   C := { X.split('\ ') : X ∊ B } ";
  :+T*      "   A := T.join(sum(C, []))        ";
}*          "                                  ";

---

सीजेएम, 51 बाइट्स

li__2mL,1a\{2_@##)1$f*+}/<f{2b_"  /\\"2/f=@@,-S*\N}

मुझे यह तरीका बेहतर लगता है, लेकिन यह पुनरावर्ती के साथ प्रतिस्पर्धा नहीं कर सकता। समाप्त करने के बाद भी 2mL(जिसके परिणामस्वरूप कम से कम हे (2 ^एन ) निष्पादन समय), मैं अभी भी 48 बाइट्स पर हूं ...

यह दृष्टिकोण /\1 के रूप में और उनके बीच के दोहरे स्थान को 0 के रूप में एन्कोड करता है । परिणामी सरणियों को द्विआधारी संख्याओं को ध्यान में रखते हुए, हम देखते हैं कि nth पंक्ति का कॉन्फ़िगरेशन nth पूर्णांक से बड़ा है जो 1 से बड़ा है जिसे विभिन्न फ़र्मेट्स संख्याओं के रूप में व्यक्त किया जा सकता है (फॉर्म 2 ^{2 k} +1 का पूर्णांक )।

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

li__2mL,1a         " push L := int(input()), L, R := range(log(L)/log(2)), A := [1] ";
\{2_@##)1$f*+}/    " for I in R: A += { a × 2**(2**I) : a ∊ A }                     ";
<                  " A := A[:L]                                                     ";
f{                 " for I in R: push L, I                                          ";
  2b_"  /\\"2/     "   push (B := base(I, 2)), B, S := [ '  ' '/\' ]                ";
  f=               "   for J in I: J := S[J]                                        ";
  @@,-S*\N         "   push (L - len(B)) * ' ', J, '\n'                             ";
}                  "                                                                ";

Answer 3

अजगर 2 - 140 139 127 122 121 118 116

N=input()
b,V,m,n=' V/\\'
s=b*~-N+m+n
R=str.replace
while N:print s;N-=1;s=R(R(R(R(s+b,b+m,V),n+b,V),n+m,b+b),V,m+n)

अस्थायी स्ट्रिंग प्रतिस्थापन के आधार पर ( /programming//a/8687380/3419103 ):

1. / > V
2. \ > V
3. \/> __(2 रिक्त स्थान)
4. V > /\

Comments

b*(N-1)+m+nहो सकता हैb*~-N+m+n

— FryAmTheEggman

@FryAmTheEggman: बहुत बढ़िया! अब मैं तुम्हें, जावास्क्रिप्ट मिला! ;)

— फॉकियो

Answer 4

जावास्क्रिप्ट - 117 बाइट्स

न्यूनतम किया गया:

T=n=>{S=' '.repeat(n-1);a='/\\';for(t=s=S+a+S;--n;t+='\n'+s)s=s.replace(/\\\//g,'  ').replace(/ \/|\\ /g,a);return t}

विस्तारित:

T = n => {
    S = ' '.repeat( n-1 );
    a = '/\\';
    for( t = s = S + a + S; --n; t += '\n' + s )
        s = s.replace( /\\\//g, '  ' ).replace( / \/|\\ /g, a );

    return t;
}

नमूना उत्पादन (के लिए n = 20):

                   /\                   
                  /\/\                  
                 /\  /\                 
                /\/\/\/\                
               /\      /\               
              /\/\    /\/\              
             /\  /\  /\  /\             
            /\/\/\/\/\/\/\/\            
           /\              /\           
          /\/\            /\/\          
         /\  /\          /\  /\         
        /\/\/\/\        /\/\/\/\        
       /\      /\      /\      /\       
      /\/\    /\/\    /\/\    /\/\      
     /\  /\  /\  /\  /\  /\  /\  /\     
    /\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\    
   /\                              /\   
  /\/\                            /\/\  
 /\  /\                          /\  /\ 
/\/\/\/\                        /\/\/\/\

अब अगर केवल repeatऔर replaceफ़ंक्शन नाम इतने लंबे नहीं थे। : पी

Answer 5

पायथ, 45 बाइट्स

K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"

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

$ pyth -c 'K"/\\"Jt+*QdKVQpbJ=JjKsmcd"\ "cj*2dc+Jd_K" /"' <<< 16
               /\
              /\/\
             /\  /\
            /\/\/\/\
           /\      /\
          /\/\    /\/\
         /\  /\  /\  /\
        /\/\/\/\/\/\/\/\
       /\              /\
      /\/\            /\/\
     /\  /\          /\  /\
    /\/\/\/\        /\/\/\/\
   /\      /\      /\      /\
  /\/\    /\/\    /\/\    /\/\
 /\  /\  /\  /\  /\  /\  /\  /\
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

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

                            # Q = eval(input())
K"/\\"                      # K = "/\\"
      Jt+*QdK               # J = (Q * " " + K)[1:]
             VQ             # for N in range(Q):
               pbJ          #     print(J, end="\n")
                            #
=JjK                        #     J = K.join(
    sm                      #         sum(list(map(lambda d:
      cd"\ "                #             d.split("\ "),
            c               #                                                .split(    )
             j*2d           #              " ".join(                        )
                 c   _K     #                                .split(K[::-1])
                  +Jd       #                       (J + " ")
                       " /" #                                                       " /"
                            #     ))))

Answer 6

रूबी, 90

f=->n{a=["/\\".center(2*n)]
2.upto(n){a<<a[-1].gsub("\\/","  ").gsub(/ \/|\\ /,"/\\")}
puts a}

व्याख्या

• इनपुट को एक लंबोदर के तर्क के रूप में लिया जाता है। यह एक होने की उम्मीद है Integer।
• प्रत्येक तरफ रिक्त स्थान के साथ String#centerबनाने के लिए उपयोग करें और इसे ( ) में डालें ।String "/\"n - 2Arraya
• में जोड़े aके पिछले तत्व aके हर घटना के साथ "\/"साथ बदल दिया " "और के हर घटना " /"या " \"के साथ बदल दिया "/\"।
• putsप्रत्येक तत्व aको अपनी लाइन पर प्रिंट करने के लिए उपयोग करें ।

Answer 7

हास्केल, १२ , ११२

g n=unlines$take n$i t([1..n]>>" ")%(i(\l->l++l%i(t.t)(t l>>"  ")%l)["/\\"]!!n)
t=tail
(%)=zipWith(++)
i=iterate

Comments

यदि मैं वर्णों की गिनती करता हूं, तो मुझे 128 मिलते हैं - आप भी भूल गए import Data.List(जब से आप उपयोग करते हैं unlines), जो इसे 145 तक लाता है

— 17

@Flonk unlinesप्रस्तावना में है।

— गर्वित हैकेलर 17

उफ़, शायद मुझे टिप्पणी करने से पहले देखना चाहिए था। मेरी गलती!

— फ्लॉन्क

Answer 8

जावास्क्रिप्ट (E6) 107 106

संपादित करें: फिक्स्ड बाइट काउंट, पुनरावर्ती बनाया।

अन्य जेएस उत्तर से बहुत अलग नहीं है ... कम से कम यह अनुरोध किए गए पैटर्न को प्रिंट करता है। कोर '' / '\' को '/' के साथ बदल रहा है और शेष सभी को '' नई लाइन पर '' के साथ बदल रहा है।

F=(n,o=t='/\\',b=' ')=>
  n--&&
    console.log(b.repeat(n)+o)|
    F(n,(b+o+b).replace(/../g,s=>s==b+b|s=='\\/'?b+b:t))

फायरफॉक्स / फायरबग कंसोल में टेस्ट

F(15)

उत्पादन

                  /\
                 /\/\
                /\  /\
               /\/\/\/\
              /\      /\
             /\/\    /\/\
            /\  /\  /\  /\
           /\/\/\/\/\/\/\/\
          /\              /\
         /\/\            /\/\
        /\  /\          /\  /\
       /\/\/\/\        /\/\/\/\
      /\      /\      /\      /\
     /\/\    /\/\    /\/\    /\/\
    /\  /\  /\  /\  /\  /\  /\  /\

Answer 9

पर्ल 5 - 56 बाइट्स

\ 0 को वास्तविक अशक्त बाइट वर्णों द्वारा प्रतिस्थापित किया जा सकता है

#!/usr/bin/perl -l
$p="/\\";$_=$"x~$_.$p,y/\0/ /,print,$p^="\0\0$p"for-<>..-1

यह इस तथ्य का उपयोग कर रहा है कि यदि आप प्रमुख स्थानों को अनदेखा करते हैं और '/ \' को 1 और '' का प्रतिनिधित्व करते हैं तो दिए गए पंक्ति f (n) = f (n-1) ^ (f (n-1) < <1)। हालाँकि ऊपर दिए गए कोड में गणना उन स्ट्रिंग्स पर निष्पादित की जाती है जो अपेक्षित आउटपुट के करीब हैं (कोई अग्रणी स्थान, नल बाइट्स द्वारा प्रतिस्थापित अन्य रिक्त स्थान) पर्ल के बिटवाइज़ स्ट्रिंग हेरफेर के लिए धन्यवाद।

$p="/\\";          # initialize
  $_=$"x~$_.$p,    # loop start, add spaces
  y/\0/ /,         # replace nulls with spaces
  print,           # output
  $p^="\0\0$p"     # calculate next string
for-<>..-1         # loop from -n to -1

Answer 10

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

n=i=input()
while i:print' '*i+''.join("/ \ "[j&i+1>0::2]for j in range(n-i+1));i-=1

Answer 11

लैम्ब्डा के साथ जावास्क्रिप्ट, 141 128

141

f=n=>{for(a="25",q=0;++q<n;a=a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25));return a[r](/./g,x=>"  /  \\"[x])}

128

f=n=>(t=a=>--n?t(a[r='replace'](/^|$/mg,1)[r](/(.*)$/,"$1\n$1")[r](/..(?=.*$)/g,x=>x%3?11:25)):a)("25")[r](/./g,x=>"  /  \\"[x])

फ़ायरफ़ॉक्स में परीक्षण किया जा सकता है (n = 16):

               /\               
              /\/\              
             /\  /\             
            /\/\/\/\            
           /\      /\           
          /\/\    /\/\          
         /\  /\  /\  /\         
        /\/\/\/\/\/\/\/\        
       /\              /\       
      /\/\            /\/\      
     /\  /\          /\  /\     
    /\/\/\/\        /\/\/\/\    
   /\      /\      /\      /\   
  /\/\    /\/\    /\/\    /\/\  
 /\  /\  /\  /\  /\  /\  /\  /\ 
/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\

Answer 12

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

i=input()
x=1
while i:i-=1;print " "*i+bin(x)[2:].replace("0","  ").replace("1", "/\\");x^=2*x

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! अच्छा जवाब: D

— बिल्ली

Answer 13

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

Column[Row/@Mod[Table[Binomial[n,k],{n,0,#-1},{k,0,n}],2]/.{1->"/\\",0->"  "},Center]&