16

फाइबोनैचि डोमिनोज़ टाइलिंग से प्रेरित होकर , यह समस्या ASCII कला को एक और प्रसिद्ध कॉम्बीनेटरियल अनुक्रम का प्रतिनिधित्व करने के बारे में है।

एक एन-स्टेप माउंटेन आरेख पर्वत श्रृंखला की एक रेखाचित्र है, जिसमें बिल्कुल n '/' और n '\' वर्णों का उपयोग किया जाता है, जैसे कि वर्ण एक सतत वक्र को स्केच करते हैं जो कभी भी इसके प्रारंभिक "ऊंचाई" से नीचे नहीं गिरता है। उदाहरण के लिए,

   /\/\
/\/    \

तथा

   /\
/\/  \/\

दोनों 4-चरणीय पर्वत आरेख हैं, लेकिन

/\  /\/\
  \/

नहीं है।

इनपुट

कार्यक्रम को स्टैडेन से या किसी फ़ंक्शन के पैरामीटर के रूप में पूर्णांक एन को स्वीकार करना चाहिए ।

उत्पादन

सभी n -स्टेप पर्वत आरेखों को stdout में प्रिंट करें । आरेख किसी भी क्रम में हो सकते हैं, लेकिन किसी प्रकार के व्हाट्सएप द्वारा अलग होना चाहिए। आप यह तय कर सकते हैं कि क्या अलग-अलग आरेख क्षैतिज, लंबवत आदि होंगे।

डोमिनोज़ टाइलिंग समस्या के रूप में, आप जो चाहें व्हाट्सएप का उपयोग कर सकते हैं। इसमें प्रिंट किए गए आउटपुट से पहले या बाद में अतिरिक्त newlines शामिल हैं।

उदाहरण

N = 3 के लिए कुछ नमूना मान्य आउटपुट :

मान्य आउटपुट A:

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

वैध उत्पादन बी:

   /\
/\/  \

 /\/\
/    \

/\/\/\   

  /\
 /  \
/    \

 /\
/  \/\

मान्य उत्पादन C:

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

यह कोड गोल्फ है; सबसे छोटा कार्यक्रम (बाइट्स में) जीतता है।

code-golf ascii-art combinatorics

— मैट नूनन
स्रोत

जब आप कहते हैं "आप तय कर सकते हैं कि क्या अलग-अलग आरेख क्षैतिज, लंबवत, आदि आउटपुट होंगे", तो क्या पर्वत श्रृंखला खुद बग़ल में हो सकती है?

— xnor

पर्वत श्रृंखला खुद बग़ल में नहीं होनी चाहिए। चोटियों के बीच का खाली आसमान मुझे चुनौती देता है।

— मैट नोनान सेप

क्या कुछ श्रेणियां एक से अधिक बार दिखाई दे सकती हैं?

— गौरवशाली हेकेलर

@ मट्टनूनन आप सही हैं, पर्वत श्रृंखलाओं को क्षैतिज रूप से प्रिंट करना निश्चित रूप से मुश्किल था।

— xnor

@ गर्व-हस्केलर यह एक बार होना चाहिए।

— मैट नूनन

10

पायथन 2: 151 वर्ण

N=2*input()
for i in range(2**N):
 L=[];c=1;exec"b=i%2;c+=2*b-1;L+=[[' ']*N];L[-1][b-c]='\/'[b];i=i/2*(c>0);"*N
 for x in(c==1)*zip(*L):print"".join(x)

#Output for n=3:




  /\  
 /  \ 
/    \




 /\/\ 
/    \




   /\ 
/\/  \




 /\   
/  \/\





/\/\/\

वाह, यह एक गड़बड़ है।

पहला विचार संख्याओं का उपयोग करके उनके बिट्स में अप-मूव्स और डाउन-मूव्स के 0 to 2**N-1सभी अनुक्रमों को एनकोड Nकरना है। हम इन बिट्स को एक-एक करके बार-बार पढ़ते हैं , %2और लूप /2में पुनरावृत्त होते हैं exec।

हम स्ट्रिंग्स की ट्रांसपोज़्ड लिस्ट में रनिंग माउंटेन रेंज बग़ल में स्टोर करते हैं L। हर बार, हम एक नई जगह बनाते हैं, नई पंक्ति में एक स्थान को एक पंक्ति से प्रतिस्थापित किया जाता है /या \इस पर निर्भर करता है कि अप-मूव या डाउन-मूव हुआ है या नहीं।

उस स्थान का सूचकांक cअंत से रिक्त स्थान है , जहां cचलने की ऊंचाई है। इसे सामने से करने से पहाड़ उलटे हो जाते थे। हम इसे आगे bऔर नीचे की ओर ले जाने के लिए बदलते हैं, प्राप्त करते हैं [b-c]। 1 cपर शुरू होने के बजाय 0 से एक ऑफ-वन त्रुटि को ठीक करता है।

ऐसे मामलों को खत्म करने के लिए जहां cशुरुआती मूल्य से नीचे गिरावट आती है 1, जब ऐसा होता है, तो हम सेट iकरते हैं 0, जो आगे की सभी चालों को नीचे की ओर ले जाता है, और cअधिक नकारात्मक बनाता है । फिर, जब हम जाँचते हैं कि क्याc समाप्त हुआ 1, हम यह भी जाँचते हैं कि क्या cकभी इसके नीचे गिर गया था। हम केवल printपर्वत श्रृंखला है, तो cहै 1।

प्रिंट करने के लिए, हम zip(*L)ऊर्ध्वाधर से क्षैतिज तक की सीमा को स्थानांतरित करने के लिए करते हैं , और प्रत्येक सम्मिलित स्ट्रिंग को प्रिंट करते हैं। इस जवाब में बहुत परेशानी हुई कि पायथन स्ट्रिंग्स को अपरिवर्तनीय मानता है, इसलिए हमने उनके साथ पात्रों की सूची के रूप में काम किया और केवल मुद्रण के लिए उन्हें स्ट्रिंग्स में शामिल किया।

मदद और सुधार के लिए @flornquake को धन्यवाद।

— XNOR
स्रोत

यदि आप लूप का उपयोग करना चाहते हैं तो आपको ' 'इसके बजाय उपयोग करने की आवश्यकता होगी । :) Btw, आपको बैकस्लैश से बचने की आवश्यकता नहीं है। " "exec

— 13:14 बजे फ़्लिकरनकेक

@flornquake मैं लिखना भूल गया, मैंने उपयोग किया ' 'और स्ट्रिंग को इसके साथ एक चर के साथ बदलने की कोशिश की। इसने फिर भी सूचकांक को सीमा से बाहर कर दिया:for _ in[0]*N:exec("b=i%2;c+=2*b-1;L+=[[" "]*N];L[-1][b-c]='\\/'[b];i=i//2*(c>0);")

— xnor

मेरा मतलब था कि आपको लिखने की ज़रूरत है exec("b=i%2;c+=2*b-1;L+=[[' ']*N];L[-1][b-c]='\\/'[b];i=i//2*(c>0);"), यानी भीतर के उद्धरणों को बाहरी लोगों से अलग होना होगा।

— फ्लॉर्नकेक

@flornquake वाह क्या मुझे मूर्खतापूर्ण लगता है, मैंने एक जोड़ी उद्धरण बदले लेकिन दूसरे को नहीं। धन्यवाद!

— xnor

7

एपीएल (88)

{{⍉↑'\/'[1+⍵=1]/⍨¨¯1+2×K=⊂⌽⍳⌈/K←(⍵≠1)++\⍵}¨Z/⍨{(0=+/⍵)∧∧/0≤+\⍵}¨Z←↓⍉¯1+2×(N/2)⊤⍳2*N←2×⍵}

इसके लिए आउटपुट n=3:

      {{⍉↑'\/'[1+⍵=1]/⍨¨¯1+2×K=⊂⌽⍳⌈/K←(⍵≠1)++\⍵}¨Z/⍨{(0=+/⍵)∧∧/0≤+\⍵}¨Z←↓⍉¯1+2×(N/2)⊤⍳2*N←2×⍵}3
 /\/\/\     /\    /\      /\/\     /\   
         /\/  \  /  \/\  /    \   /  \  
                                 /    \

स्पष्टीकरण:

(N/2)⊤⍳2*N←2×⍵: से प्रत्येक संख्या के लिए एक बिटफ़ील्ड प्राप्त 0करें 2^⍵।
Z←↓⍉¯1+2×: 2 से गुणा करें और 1 घटाएं, 1ऊपर और -1नीचे के लिए। वेक्टर के वेक्टर को स्टोर करें, प्रत्येक वेक्टर जिसमें एक नंबर के लिए प्रतिनिधित्व होता है, में Z।
{... }¨Z: के प्रत्येक तत्व के लिए Z:
- ∧/0≤+\⍵: जांचें कि रनिंग योग नीचे कभी नहीं गिरता है 0 (जमीनी स्तर है),
- (0=+/⍵): और वह कुल योग है 0(जमीनी स्तर पर वापस समाप्त होता है)।
{... }¨Z/⍨: उन तत्वों का चयन करें जिनके Zलिए यह सत्य है। उनमें से प्रत्येक के लिए:
- K←(⍵≠1)++\⍵: प्रत्येक चरित्र के लिए ऊंचाई खोजें, और में स्टोर करें K। प्रत्येक \को एक ऊपर उठाएं , ताकि वे /ठीक से एस के साथ ऊपर उठें। इससे जमीन की ऊंचाई बढ़ती है 1।
- ¯1+2×K=⊂⌽⍳⌈/K: प्रत्येक कॉलम के लिए, एक सूची बनाएं [1..max(K)], और उस कॉलम में चरित्र की स्थिति 1और बाकी के रूप में चिह्नित करें -1। (एक स्थान के साथ -1 उस स्थिति को भरता है।)
- '\/'[1+⍵=1]/⍨¨: प्रत्येक कॉलम के लिए सही वर्ण ढूंढें, और उस कॉलम के लिए सूची द्वारा इसे दोहराएं।
- ⍉↑: परिणाम को मैट्रिक्स में बदलें और इसे राइट-साइड-अप में डालें

— मारीनस
स्रोत

ठीक है, एक क्षैतिज एक!

— मैट नूनन

2

पायथन, 261 241 236 वर्ण

import itertools as I
n=input()
S={}
for q in I.permutations((-1,1)*n):
 s=0;B=[[' ']*n*2 for _ in range(n+2)];o=0
 for i in q:
    B[n-s+(i==-1)][o]=' /\\'[i];s+=i;o+=1
    if s<0:break
 else:
    for l in (B,[])[q in S]:print''.join(l)
 S[q]=1

इसके लिए थोड़ी देर n=5और लगने लगती है ...

$ echo 1 | py mountrange.py

/\



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 2 | py mountrange.py


/\/\



 /\
/  \



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 3 | py mountrange.py



/\/\/\




   /\
/\/  \




 /\
/  \/\




 /\/\
/    \



  /\
 /  \
/    \



Laxori@Laxori-PC /cygdrive/c/Programmin
$ echo 4 | py mountrange.py




/\/\/\/\





     /\
/\/\/  \





   /\
/\/  \/\





   /\/\
/\/    \




    /\
   /  \
/\/    \





 /\
/  \/\/\





 /\  /\
/  \/  \





 /\/\
/    \/\





 /\/\/\
/      \




    /\
 /\/  \
/      \




  /\
 /  \
/    \/\




  /\
 /  \/\
/      \




  /\/\
 /    \
/      \



   /\
  /  \
 /    \
/      \

— Claudiu
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 159 163

फिबोनाची डोमिनोज़ टाइलिंग के लिए मेरे जवाब की तरह, मैं n + n बिट्स के सभी अनुक्रमों की जांच करता हूं, जिसमें 1 अंक '/' और 'a' (केवल आउटपुट के लिए, '2' अंकन है, बाद में एक नई रेखा को चिह्नित करने के लिए जोड़ा गया है । जब मैं थची एसेसी पैटर्न का निर्माण कर रहा था, तो मैं 0 और 1 की समान संख्याओं की शेष राशि की जांच करता हूं, और शुरुआती आधार रेखा से नीचे कभी नहीं जा रहा हूं - और आउटपुट जो नियमों का पालन करता है।

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

F=n=>{
  for(i=0;++i<1<<n+n;l||alert((o+'').replace(/,\d?/g,r=>'\\/\n '[r[1]||3])))
    for(p=l=o=[],j=i;l+1&&p++-n-n;j/=2)
      b=j&1,
      l-=1-b-b,
      (o[k=b+n-l]=o[k]||[2])[p]=b;
}

कम गोल्फ वाला

F=n=>{
  m = n+n
  outer:
  for (i=1; i < 1<<m; i+=2)
  {
    o=[]
    l=0;
    p=1;
    for (j = 1; j <1<<m; j+=j,p++)
    {
      if (i&j)
      {
        q=o[n-l]||[]
        q[p]=1;
        o[n-l]=q
        ++l;
      }
      else
      {
        --l;
        if (l<0) continue outer;
        q=o[n-l]||[]
        q[p]=0;
        o[n-l]=q
      }
    }
    if (l==0) console.log(o.join('\n').replace(/,\d?/g,r=>'\\/'[r[1]]||' '));
  }
}

FireFox / FireBug कंसोल में टेस्ट करें ।

F(4)

उत्पादन

   /\
  /  \
 /    \
/      \ 

  /\/\
 /    \
/      \ 

    /\
 /\/  \
/      \ 

    /\
   /  \
/\/    \ 

  /\
 /  \/\
/      \ 

 /\/\/\
/      \ 

   /\/\
/\/    \ 

 /\  /\
/  \/  \ 

     /\
/\/\/  \ 

  /\
 /  \
/    \/\ 

 /\/\
/    \/\ 

   /\
/\/  \/\ 

 /\
/  \/\/\ 

/\/\/\/\

— edc65
स्रोत

जिज्ञासु अगर कोई विशेष कारण है जो आप लिखते हैं -b-bऔर -n-nइसके बजाय -2*b?

— स्टीव बेनेट

@SteveBennett कोई कारण नहीं। कभी-कभी यह पैटर्न छोटा होता है, लेकिन इस बार नहीं (उदाहरण के लिए: 2*b+1-> b-~b)

— edc65

1

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

q~:Q{Q[XW]*mr1\{\_@+}%_{*}*{(\{_Q\-)S*@2$m0<" /""\\"?+QS*+Q)<\}%);z{N\++}*o}{;}?1}g

ध्यान दें कि यह कार्यक्रम एक अनंत लूप में पहाड़ों को प्रिंट करता है, इसलिए ऑनलाइन दुभाषिया आपकी मदद नहीं करेगा; कमांड लाइन का उपयोग करके आह्वान करें

java -jar cjam-0.6.2.jar mountain.cjam <<< 5

या ऑनलाइन उपयोग करने का प्रयास करें

q~:Q{Q[XW]*mr1\{\_@+}%_{*}*{(\{_Q\-)S*@2$m0<" /""\\"?+QS*+Q)<\}%);z{N\++}*o}{;}?}fZ

और बस रन बटन को उत्तराधिकार में बार का एक गुच्छा मारो और कल्पना करें कि आउटपुट को सुधारा गया है।

मूल विचार यह है कि हम जानते हैं कि आकार की एक पर्वत श्रृंखला Q में प्रत्येक ऊपर और नीचे की ओर संक्रमण होता है।

 Q[XW]*mr                                   #shuffled list of Q 1s and -1s
1        {\_@+}%                            #height map after each transition
                _{*}*                       #if it passes through 0 it's invalid

यदि यह मान्य है तो हम इसे प्रिंट करते हैं, यदि हम इसे स्टैक से नहीं हटाते हैं तो यह अतिप्रवाह नहीं करता है।

प्रिंट रूटिंग मूल रूप से प्रत्येक कॉलम को Q - ऊँचाई रिक्त स्थान के रूप में बनाता है, फिर प्रतीक, फिर Q + 1 कुल वर्णों को हिट करने के लिए पर्याप्त स्थान, और फिर हम उन दोनों के बीच नई लाइनों के साथ लाइनों को स्थानांतरित और प्रिंट करते हैं।

z{N\++}*o                                   #transpose, insert newlines, print

— paradigmsort
स्रोत

जब मैं इस पर काम कर रहा था, तो यह प्रश्न स्पष्ट हो गया था कि पहाड़ों को एक बार छापने की आवश्यकता है। इसके लिए कुछ पुनर्विचार और शायद अधिक पात्रों की आवश्यकता होगी: /

— प्रतिमान

0

सी, 179

अनावश्यक व्हाट्सएप को छोड़कर।

Edc65 के लिए एक समान रणनीति। मैं =-1 और = 0 पर n*2विचार करते हुए सभी- बिट बाइनरी मानों के माध्यम से चलता हूं ।/\

मैं nहर n*3अक्षर को पंक्तिबद्ध करने वाला एक एकल स्ट्रिंग प्रारूपित करता हूं । जैसा कि लिखा गया है कि स्ट्रिंग में 1000 वर्ण हैं, इसलिए आमतौर पर पहाड़ के बाद बहुत सारे व्हाट्सएप मुद्रित होते हैं। (इसे s[n*n*3]=0पहले से जोड़कर तय किया जा सकता है puts।) वैसे भी, यह मुझे पूरे पहाड़ को एक एकल के साथ आउटपुट करने के लिए सक्षम बनाता putsहै यह जांचने के बाद कि यह नियमों का अनुपालन करता है।

मैं इसे एक फ़ंक्शन में परिवर्तित करने और forबाद में एक ही लूप में कम करने की कोशिश करूंगा ।

i,n,x,y,q,r;
main(){
  scanf("%d",&n);
  for(i=1<<n*2;i--;){                              //run though all n*2-digit binary numbers
    char s[]={[0 ...999]=32};                      //fill an array with spaces. This syntax is allowed by GCC
    y=n;                                           //start y one square below the grid (note: r is initialised to 0 by default.)
    for(x=n*2;x--;)                                //for each digit of i
      q=i>>x&1,
      y+=q+r-1,                                    //move up if the current and last digit are 0, down if they are 1, and stay on the same line if they are different.
      y<n?s[y*n*3]=10,s[y*n*3+x+1]=92-45*q:(x=0),  //if y is within the grid, put a newline (ASCII 10)at the beginning of the row and write \ or / (ASCII 92 or 47) to the correct square. Otherwise abort the x loop.
      r=q;                                         //store the current bit of i to r as it will be needed on the next iteration 
    n-1-y||puts(s);                                //if y is on the bottom row of the grid, output the mountain 
  }
}

आउटपुट (दाईं ओर व्हॉट्सएप की भारी मात्रा पर ध्यान दें)

— स्तर नदी सेंट
स्रोत

0

हास्केल, 140 बाइट्स

कई प्रयास विफल होने के बाद, मैं इस हास्केल कार्यान्वयन के साथ समाप्त हुआ। मैं एपीएल समाधान के 2 के एक कारक के भीतर ही खुश हूं!

गोल्फ समाधान:

e=' ':e
m=[[]]:[[('/':e):map(' ':)x++('\\':e):y|k<-[0..n],x<-m!!(n-k),y<-m!!k]|n<-[0..]]
f n=putStr$unlines[map(!!(n-k))a|a<-m!!n,k<-[1..n]]

असंबद्ध और टिप्पणी:

कार्यक्रम एन- स्टेप पर्वत आरेखों के सेट को पुनरावर्ती बनाता है । प्रत्येक आरेख को असीम रूप से लंबे तारों की एक सूची द्वारा दर्शाया जाता है, पर्वत खींचे गए बग़ल में अनंत तक फैले स्थानों के बाद का प्रतिनिधित्व करता है। यह सुनिश्चित करता है कि सभी आरेखों की ऊंचाई समान है, जो पुनरावृत्ति को आसान बनाता है। पर्वत प्रिंटर एक पैरामीटर को स्वीकार करता है जो ऊंचाई को एक सीमित मूल्य पर क्लिप करता है।

import Data.List (transpose)

-- Elementary picture slices, extending to infinity.
empty = ' ' : empty
up    = '/' : empty
down  = '\\': empty

-- A function which draws a mountain picture to stdout, clipping
-- its height to n.
printMtn n = putStr . unlines . reverse . take n . transpose 

{-- Combine mountain pictures x and y by

              x
 x # y  ==   / \y

--}
x # y = up : raised x ++ down : y
    where raised = map (' ':)

-- Given two sets X,Y of mountain pictures, compute the set X <> Y of all
-- combined pictures x#y for x in X, y in Y.
xs <> ys = [ x # y | x <- xs, y <- ys ]

-- Compute the (++,<>)-convolution of a list with itself, e.g.:
--   autoConvolve [x0,x1,x2] == (x2 <> x0) ++ (x1 <> x1) ++ (x0 <> x2)
autoConvolve xs = concat $ zipWith (<>) (reverse xs) xs

{--
    mtns is a list whose nth entry is the list of all n-step mountain diagrams.
    It is defined recursively by:
        --  The only 0-step mountain diagram is empty.
        --  Each (n+1)-step diagram can be uniquely drawn as x#y for
            some k-step diagram x and (n-k)-step diagram y.
--}
mtns = [[]] : [autoConvolve (prefix n) | n <- [1..]]
    where prefix n = take n mtns

-- The driver function: apply the height n mountain printer to each
-- n-step mountain diagram.  Whitespace is guaranteed by the order
-- in which the diagrams appear.
test n = mapM_ (printMtn n) $ mtns!!n

नमूना उपयोग:

$ ghci mtn3.hs
GHCi, version 7.6.3: http://www.haskell.org/ghc/  :? for help
Loading package ghc-prim ... linking ... done.
Loading package integer-gmp ... linking ... done.
Loading package base ... linking ... done.
[1 of 1] Compiling Main             ( mtn3.hs, interpreted )
Ok, modules loaded: Main.
λ> f 3
  /\  
 /  \ 
/    \

 /\/\ 
/    \

 /\   
/  \/\

   /\ 
/\/  \


/\/\/\
λ>

— मैट नूनन
स्रोत

0

गोल्फक्राफ्ट 103 ( डेमो )

2*:§2\?,{2base.,§\-[0]*\+:a 1\{.2*@(.@+@@+}%:l$)\;),-1%{a,,{.l=2$=\a=1$+*' \\/'= }%\;n+}%\1=*l$(\;0>*}/

कार्यक्रम पूर्णांक पैरामीटर को लेता है, ताकि 0 से 2 ^ (n-1) की संख्याओं के सभी द्विआधारी निरूपण को पहाड़ों के रूप में प्रस्तुत किया जा सके। यह अमान्य संयोजनों को प्रस्तुत नहीं करता है (उदा: वे जो नीचे स्तर 0 पर जाते हैं)।

— क्रिस्टियन लुपस्कू
स्रोत

पर्वत श्रृंखला की एक श्रृंखला बनाएं

पायथन 2: 151 वर्ण

एपीएल (88)

पायथन, 261 241 236 वर्ण

जावास्क्रिप्ट (ईएस 6) 159 163

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

सी, 179

हास्केल, 140 बाइट्स

गोल्फक्राफ्ट 103 ( डेमो )