कुछ पहाड़ की चोटियाँ खींचे

Question

एक कार्यक्रम या फ़ंक्शन लिखें जो एक पर्वत श्रृंखला खींचता है, जहां प्रत्येक बाद की बड़ी पर्वत चोटी सामने वाले लोगों के "पीछे" है, और वैकल्पिक है कि कौन सा पक्ष दिखाई दे रहा है।

यह आकार की एक पर्वत श्रृंखला है 1

/\

यह आकार की एक पर्वत श्रृंखला है 2

 /\
/\ \

यह आकार की एक पर्वत श्रृंखला है 3

  /\
 / /\
/ /\ \

यह आकार की एक पर्वत श्रृंखला है 4

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

यह आकार की एक पर्वत श्रृंखला है 5

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

और इसी तरह।

इनपुट

एक एकल सकारात्मक पूर्णांक किसी भी सुविधाजनक प्रारूप में , n > 0।

उत्पादन

उपरोक्त नियमों का पालन करते हुए पर्वत श्रृंखला का एक ASCII- कला प्रतिनिधित्व। अग्रणी या अनुगामी newlines या अन्य व्हाट्सएप वैकल्पिक हैं, बशर्ते कि चोटियों को उचित रूप से पंक्तिबद्ध किया जाए।

नियम

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

Answer 1

चारकोल , 16 बाइट्स

ＮλＦλ«Ｐ↘⁻λι←↙¹‖Ｔ→

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

कैसे?

Ｎλमें सबसे बड़े पर्वत के आकार का आदान-प्रदान λ। Ｆλ«के माध्यम ιसे के मूल्यों पर एक लूप चलाता है । (समापन कार्यक्रम के अंत में निहित है।)0λ-1»

लूप के अंदर, Ｐ↘⁻λιगणना करता है λ-ιऔर खींचता है, बिना कर्सर को आगे बढ़ाए, उस लंबाई की एक पंक्ति दक्षिण-पूर्व की ओर जा रही है। इसकी दिशा के आधार पर, इस लाइन में \वर्ण शामिल होंगे । ←पश्चिम में एक कदम चलता है, और ↙¹लंबाई 1 की एक रेखा खींचती है जो दक्षिण-पश्चिम की ओर (बनी /) है। अंत में, ‖Ｔ→क्षैतिज रूप से ड्राइंग को दर्शाता है, पात्रों को उपयुक्त रूप में बदलना: \बन जाता है /और /बन जाता है \।

Ｄलूप की शुरुआत में डंप इंस्ट्रक्शन जोड़ना ( इसे आज़माएं ) हमें प्रगति देखने की अनुमति देता है:

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

Comments

मुझे लगता है कि यह चुनौती के लिए आदर्श भाषा है :-)

— ETHproductions 19

@ETHproductions यह भाषा विशेष रूप से ASCII कला के लिए बनाई गई है। इसका अपना कोडपेज भी है।

— आउटगॉल्फ

@EriktheGolfer मेरे पास अपनी (बिना नाम की) ASCII कला भाषा है, जिसे क्रेयॉन कहा जाता है । डॉक्स इस समय एक तरह से खो गए हैं क्योंकि मैं उन्हें स्थानांतरित करने के बीच में हूं, लेकिन आप उनमें से अधिकांश को यहां देख सकते हैं । मुझे आश्चर्य है कि चारकोल की तुलना में इसके लिए एक क्रेयॉन कार्यक्रम कितना छोटा होगा ...

— ETHproductions

@ETHproductions आप इसे कब लागू करने जा रहे हैं? क्या इसके लिए कोई चैट रूम है या क्या मैं एक बना सकता हूं (जिसे "क्रेयॉन इंप्लीमेंटेशन" कहा जाता है)?

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

@EriktheGolfer दुर्भाग्य से, मुझे नहीं पता कि इसे लागू करने के लिए मेरे पास कब समय होगा। आप चाहें तो एक चैट रूम बना सकते हैं ;-)

— ETHproductions

Answer 2

जावास्क्रिप्ट (ईएस 6), 75 बाइट्स

for(n=prompt(s="/\\");n--;s=n%2?s+' \\':'/ '+s)console.log(" ".repeat(n)+s)

पूरा कार्यक्रम वर्तमान में पुनरावर्ती कार्य से थोड़ा छोटा है:

f=n=>n?" ".repeat(--n)+`/\\
`+f(n).replace(/\S.+/g,x=>n%2?x+" \\":"/ "+x):""

Answer 3

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

n=input()
s='/\\'
while n:n-=1;print' '*n+s;s=['/ '+s,s+' \\'][n%2]

sवर्तमान की समता के आधार पर, बाईं ओर या दाईं ओर एक स्लैश जोड़कर स्ट्रिंग को जमा करके, लाइन द्वारा प्रिंट की रेखा n। nरिक्त स्थान के साथ उपसर्ग ।

अद्यतन करने का एक वैकल्पिक तरीका समान लंबाई था:

s=n%2*'/ '+s+~n%2*' \\'
s=['/ '+s,s+' \\'][n%2]

एक पुनरावर्ती विधि लंबी (70 बाइट्स) थी।

f=lambda n,s='/\\':n*'_'and' '*~-n+s+'\n'+f(n-1,[s+' \\','/ '+s][n%2])

Answer 4

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

0%_=""
n%s=(' '<$[2..n])++s++'\n':(n-1)%(cycle[s++" \\","/ "++s]!!n)
(%"/\\")

उपयोग:

putStrLn $ f 5
    /\
   / /\
  / /\ \
 / / /\ \
/ / /\ \ \

रेखाओं द्वारा रेखाएँ, n की वर्तमान समता के आधार पर बाईं ओर या दाईं ओर एक स्लैश जोड़कर स्ट्रिंग s को संचित करती हैं। N-1 रिक्त स्थान के साथ उपसर्ग।

Answer 5

बैच, 202 बाइट्स

@echo off
set/af=%1^&1
set m=/\
set s=
for /l %%i in (2,1,%1)do call set s= %%s%%
for /l %%i in (2,1,%1)do call:l
:l
echo %s%%m%
set s=%s:~1%
set/af^^=1
if %f%==1 (set m=%m% \)else set m=/ %m%

कमांड-लाइन पैरामीटर के रूप में इनपुट लेता है। अंतिम लूप को निष्पादित करने के लिए फॉल्स के माध्यम से।

Comments

@TimmyD क्षमा करें, मैंने गोल्फ करते समय टाइप किया। अभी तय किया है।

— नील

Answer 6

रूबी, 61 बाइट्स

ETHproductions 'जावास्क्रिप्ट जवाब का एक बहुत ही सीधा बंदरगाह ।

->n{s="/\\"
(puts" "*n+s
s=n%2>0?s+" \\":"/ "+s)until 0>n-=1}

इसे repl.it पर देखें: https://repl.it/EPU5/1

Ungolfed

->n{
  s = "/\\"
  ( puts " "*n+s
    s = n%2 > 0 ? s+" \\" : "/ "+s
  ) until 0 > n -= 1
}

Answer 7

हास्केल, 117 107 105 97 90 बाइट्स

b!1=["/\\"]
b!n|m<-(1-b)!(n-1)=map(' ':)m++[[("/ "++),(++" \\")]!!b$last m]
(unlines.(1!))

Ideone पर इसे आज़माएं। संपादित करें: नील के एक विचार के साथ 8 बाइट्स सहेजे गए।

Ungolfed संस्करण:

p b 1 = ["/\\"]
p b n = let m = p (1-b) (n-1)
            k = last m
            r = map (' ':) m
        in if b == 1
           then r ++ [k ++ " \\"]
           else r ++ ["/ " ++ k]
f n = unlines(p 1 n)

पुनरावर्ती दृष्टिकोण। के लिए आकार आकृति nकी प्रत्येक पंक्ति के सामने एक स्थान जोड़कर n-1और अंतिम पंक्ति लेने से पहले उत्पन्न होता है n-1और "/ "अगर nविषम है या " \"बाद में है, तो इससे पहले जोड़ दें n... या इसलिए मैंने यह नोट करने से पहले सोचा कि यह अंतिम चरण इसके लिए उल्टा है फाइनल होने पर सभी पुनरावर्ती चरण n। इसलिए एक ध्वज bपारित किया जाता है जो प्रत्येक पुनरावर्ती कॉल को वैकल्पिक करता है और निर्धारित करता है कि अगला पर्वत भाग बाएं या दाएं जोड़ा गया है या नहीं।

Comments

हर बार तुलना bकरने के बजाय odd n, क्या आप शुरुआत में एक ध्वज को पारित नहीं कर सकते हैं और इसे हर पुनरावर्ती कॉल पर फ्लिप कर सकते हैं? जैसे कुछ f n = unlines(p 0 n)और let m = p (1-b) (n-1)।

— नील

फ़्लिपिंग -bएक और चार है।

— xnor

@xnor संकेत के लिए धन्यवाद, लेकिन मैंने इसे आगे गोल्फ के लिए एक और तरीका ढूंढ लिया जो bकि होना चाहिए 0या 1।

— लकोनी 11

Answer 8

जावा 7,130 बाइट्स

String f(int n,String s){String l="";for(int i=1;i++<n;l+=" ");return n>1?n%2<1?l+s+"\n"+f(--n,s+" \\"):l+s+"\n"+f(--n,"/ "+s):s;}

Ungolfed

class Mountain {
 public static void main(String[] args) {
    System.out.println(f( 5 , "/\\" ) );
  }
 static String f(int n,String s){
    String l = "";
    for (int i = 1; i++ < n; l += " ") ;
      return n > 1? n % 2 < 1?l + s + "\n" + f(--n , s + " \\")
                           :l + s + "\n" + f(--n , "/ " + s)
                            :s;
    }

}

Comments

अच्छा जवाब, +1। आप इसे 2 बाइट्स से गोल्फ कर सकते हैं: n%2टू n--%2और --nटू टू n। संपादित करें: और ,x=s+"\n"दोनों s+"\n"को जोड़कर और बदलकर 1 और x। (तो कुल में: String f(int n,String s){String l="",x=s+"\n";for(int i=1;i++<n;l+=" ");return n>1?n--%2<1?l+x+f(n,s+" \\"):l+x+f(n,"/ "+s):s;} 127 बाइट्स )

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

Answer 9

C ++ 138 (फ़ंक्शन)

समारोह :-

#define c(X) cout<<X;
#define L(X,Y) for(X=0;X<Y;X++)  

void M(int h){int l=1,r=1,j,H=h,i;L(i,h){for(j=H;j>0;j--)c(" ")L(j,l)c(" /")L(j, r)c("\\ ")c("\ n")(h%2)?(i%2)?r++:l++:(i%2)?l++:r++;H--;}  

पूरा कार्यक्रम: -

#include<conio.h>
#include<iostream>

using namespace std;

#define c(X) cout<<X;
#define L(X,Y) for(X=0;X<Y;X++)

void M(int h)
{
    int l=1,r=1,j,H=h,i;

    L(i, h)
    {
        for (j = H;j > 0;j--)
            c(" ")
        L(j, l)
            c(" /")
        L(j, r)
            c("\\ ")
        c("\n")

        (h % 2) ? (i % 2) ? r++ : l++ :(i % 2) ? l++ : r++;
        H--;
    }
}

int main()
{
    int h;
    cin >> h;
    M(h);
    _getch();
    return 0;
}  

नोट: फ़ंक्शन _getch()में विभिन्न संकलक के अलग-अलग प्रोटोटाइप नाम हो सकते हैं।