इसके शीर्ष पर एक विषम संख्या के साथ छोटे पहाड़ों की एक श्रृंखला प्रदर्शित करें!

Question

पहली पंक्ति उन ceil(n/2)तत्वों से बनी है जहाँ प्रत्येक तत्व है:<space><odd-number><space>

दूसरी पंक्ति ceil(n/2)तत्वों के साथ बनाई गई है, लेकिन प्रत्येक तत्व / \केवल है।

आप मान सकते हैं n >= 0और n <= 10।

उदाहरण

इनपुट: ३

 1  3
/ \/ \

इनपुट: १०

 1  3  5  7  9
/ \/ \/ \/ \/ \

---

पायथन 3, 103 बाइट्स में उदाहरण:

lambda a:print("".join([" "+str(i)+" "for i in range(1,a+1,2)]+["\n"]+["/ \\"for i in range(1,a+1,2)]))

बाइट्स में सबसे छोटा कोड जीत :)

Comments

क्या आप मान सकते हैं कि सभी इनपुट 11 से कम होंगे?

— ब्लू

हाँ, सभी इनपुट 11 से कम होंगे!

— सिगमेई

साइट पर आपका स्वागत है! कोड-गोल्फ के लिए हमारा डिफ़ॉल्ट बाइट्स में गिनना है, वर्ण नहीं। यदि आप इसे ओवरराइड करना चाहते हैं, हालांकि, यह आपकी पसंद है। इसके अलावा, मैं अगली बार सैंडबॉक्स की सिफारिश करूंगा :)

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

मेरा मतलब था बाइट्स तुम सही हो! क्या चारों ओर एक अच्छा बाइट्स काउंटर है?

— Sygmei

हमें व्हॉट्सएप को कैसे संभालना है? आप कहते हैं कि प्रत्येक तत्व है <space><odd-number><space>, लेकिन अंतिम विषम संख्या के बाद परीक्षण के मामलों में जगह नहीं है। क्या यह वैकल्पिक है? इसके अलावा, n=0दो खाली लाइनों के लिए आउटपुट है ?

— xnor

Answer 1

05AB1E , 19 15 14 12 बाइट्स

05AB1E CP-1252 एन्कोडिंग का उपयोग करता है । अदनान की बदौलत
4 बाइट बच गईं ।
सहेजे गए 2 बाइट्स कारुसोकोम्प्यूटिंग के लिए धन्यवाद

ÅÉðìDg…/ \×»

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

व्याख्या

ÅÉ               # list of uneven number up to input
  ðì             # prepend a space to each
    Dg           # get length of list
      …/ \       # push the string "/ \"
          ×      # repeat the string length-list times
           »     # join rows by spaces and columns by newlines

Comments

कैसे Ïलम्बी लग रही है ?! यह उपयोगी सूपर लगता है।

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

@ क्रूसोकोम्पुटिंग एक लंबे समय: पी

— अदनान

LDÉÏके रूप में ही है ÅÉऔर :) „ ýðìद्वारा प्रतिस्थापित किया जा सकता है ðì)»।

— अदनान

आप )नहीं निकाल सकते , क्या आप नहीं कर सकते?

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

ÅÉðìDg…/ \×»एक और बाइट बचाने Dgके ¹;îलिए भी उपयोग करता है ।

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

Answer 2

पाइके, 16 बाइट्स

S2%idm+dJil*"/ \

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

17 बाइट्स और अधिक भयानक

S2%i`~Bd.:il*"/ \

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

यह सुनिश्चित करता है कि पहली पंक्ति सही ढंग से संरेखित हो, इसके लिए IMHO एक भयानक एल्गोरिथ्म का उपयोग करता है।

S                 - range(1, input+1)
 2%               -  ^[::2]
   i              -   i = ^
    `             -    str(^)
     ~Bd.:        -     ^.translate("><+-.,[]", " ") <-- awesome bit here
          il      -  len(i)
            *"/ \ - ^ * "/ \"

यह रिक्त स्थान के साथ सभी पात्रों को सूची में बदल देता है। ~Bमस्तिष्क **** भाषा में सभी वर्ण शामिल हैं और यह पहली बार है जब मैंने इस चर का उपयोग किया है।

कार्यक्रम `~Bd.:यह करता है:

`~Bd.: - input = [1, 3, 5, 7]
`      - str(input)  # stack now ["[1, 3, 5, 7]"]
 ~B    - "><+-.,[]"  # stack now ["[1, 3, 5, 7]", "><+-.,[]"]
   d   - " "         # stack now ["[1, 3, 5, 7]", "><+-.,[]", " "]
    .: - translate() # stack now [" 1  3  5  7 "]

Comments

... यह है ... बस कमाल? तुम्हें पता है कि तुम सिर्फ 05AB1E और सबको हरा दो, है ना?

— निकोलग्राफ

मैंने जेली की कोशिश की है; यह निश्चित रूप से बहुत लंबा होगा।

— निकोलग्राफ

"मैंने बीएफ चार्टसेट का उपयोग समान रूप से संख्याओं की एक जगह के लिए किया था" जिन चीजों के बारे में आपने कभी नहीं सोचा था कि आप कहेंगे ...

— ETHproductions

यह वास्तव में चतुर है :) अच्छी तरह से किया

— Sygmei

@ErikGolfer エ リ fer fer fer fer fer 05 more 05AB1E अधिक नहीं धड़क रहा है।

— बोबोक्वैक

Answer 3

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

lambda n:' '.join(n%2*`n`for n in range(n+1))+'\n'+-~n/2*'/ \\'

पहली पंक्ति के लिए छोटी चाल: यह सम संख्याओं को प्रिंट नहीं करती है, लेकिन उन्हें एक खाली स्ट्रिंग के रूप में लेती है, जो खाली स्थान को शुरू करने की ओर ले जाती है (0 वहां होगी), और सीमा के बीच की संख्याओं के बीच की डबल रिक्तियाँ, सीमा पर बिना किसी संशोधन के नकारात्मक पक्ष भी गिने जाने में एक अग्रणी स्थान है n

Answer 4

पायथन 2 3, 67 65 63 60 बाइट्स

यहां कुछ भी पागल नहीं है, मुझे लगता है कि पहला खंड शायद कम किया जा सकता है लेकिन मुझे यकीन नहीं है कि कैसे । मैं इस तथ्य का उपयोग करता हूं कि इस मामले -~n/2में काम करेगा ceil।

lambda n:-~n//2*' %d '%(*range(1,n+1,2),)+'\n'+-~n//2*'/ \\'

नीचे पायथन 2 में वैकल्पिक 61 और 65 बाइट समाधान दिए गए हैं:

lambda n:-~n/2*' %d '%tuple(range(1,n+1,2))+'\n'+-~n/2*'/ \\'
lambda n:' '+'  '.join(map(str,range(1,n+1,2)))+'\n'+-~n/2*'/ \\'

^{2 बाइट्स और Artyer को बचाने के लिए रॉड के लिए धन्यवाद संस्करण स्विच करके एक और बाइट बचाने के लिए :)}

Comments

आप अजगर 3 पर चला, तो आप जगह ले सकता है %(tuple(...))के साथ %[*...]है, लेकिन तुम क्या करने के लिए होता है-~n//2

— Artyer

@Artyer ने इसकी कोशिश की, लेकिन यह त्रुटियों का एक समूह है। मुझे लगता है कि मुझे rangeएक सूची में डालने की आवश्यकता होगी क्योंकि 3 rangeपायथन 2 की तरह है xrange।

— Kade

आप कोष्ठकों को भी गिरा सकते हैं जो कि आसपास हैंtuple()

— रॉड

आप क्या कर सकते हैं (*<iterable>,)यह 1 बाइट की बचत होती है पायथन 3. में टपल करने के लिए कलाकारों को हालांकि बाद आप बारी n/2में n//2के लिए अजगर 3.

— Artyer

@Rod और Artyer एक गुच्छा धन्यवाद! :)

— Kade

Answer 5

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

f=n=>n%2?f(n-1).replace(`
`,` ${n} 
/ \\`):n?f(n-1):`
`

<input type=number min=1 max=10 oninput=o.textContent=f(this.value)><pre id=o>

दूसरी पंक्ति के अंत में अंतरिक्ष पर ध्यान दें।

Comments

खतरे, मैंने सोचा .replaceकि यह बेहतर हो सकता है लेकिन मैंने जांच करने की जहमत नहीं उठाई ...

— ETHproductions

प्रश्न कहता है "आप मान सकते हैं ..."

— सोलोमन उको

@SolomonUcko HTML उत्तर का हिस्सा नहीं है, यह केवल अपने ऑपरेशन को प्रदर्शित करने के लिए कार्य करता है। इस प्रकार, यह 1 और 10 के बीच के मूल्य को सीमित कर सकता है, क्योंकि परिणाम अन्यथा मान्य नहीं होगा।

— नील

समझा। आपको सही रिक्ति का निर्धारण करना होगा अन्यथा

— सोलोमन उको

Answer 6

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

lambda n:" 1  3  5  7  9"[:-~n/2*3]+'\n'+-~n/2*"/ \\"

n <= 10हार्डकॉन्ड स्ट्रिंग से एक टुकड़ा काटकर शीर्ष पंक्ति उत्पन्न करने के लिए प्रतिबंध का लाभ उठाता है ।

1 से 10 के लिए आउटपुट हैं

 1 
/ \
 1 
/ \
 1  3 
/ \/ \
 1  3 
/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5 
/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7 
/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \
 1  3  5  7  9
/ \/ \/ \/ \/ \

0 के लिए आउटपुट दो खाली लाइनें हैं।

Answer 7

विम, 73 59 56 बाइट्स

यह एक साधारण समस्या की तरह लगता है के लिए एक बहुत ही उच्च बाइट गिनती IMO है। मुझे लगता है कि मुझे कुछ स्पष्ट याद आ रहा है।

caw="/2*2
caw1357911/"
DYp:s;.;/ \\;g
k:s// & /g

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

Unprintables:

^Acaw^R=^R"/2*2      # Transform a number into the next odd number (3->5,4>5)
^[^Acaw1357911^[/^R" # Insert 1357911, delete everything after the number above
DYp:s;.;/ \\;g       # Duplicate the line, replace numbers with / \
k:s// & /g           # On the line above, add spaces around numbers
<trailing newline>

Comments

अच्छा, मैं हमेशा विम अपवोट करता हूं! हालांकि, अप्राप्य वर्ण भी बाइट्स के रूप में गिने जाते हैं, इसलिए यह समाधान वास्तव में 73 बाइट्स है। उसके लिए माफ़ करना!

— डीजेएमकेमहेम

मेरे पास हालांकि कुछ सुझाव हैं। 1) यदि आप अपने स्थानापन्न कमांड पर एक अलग सेपरेटर का उपयोग करते हैं, तो आपको आगे स्लैश से बचने की आवश्यकता नहीं होगी, इसलिए आप कर सकते हैं :s;.;/ \\;g। 2) अपने दूसरे स्थानापन्न आदेश पर, आप खोज को खाली छोड़ सकते हैं और यह आपकी अंतिम खोज का उपयोग करेगा (जो अभी ऐसा ही होता है)। इसके अलावा, एक बाइट के &बराबर \0और छोटा होता है। तो तुम मिल:s// & /g

— DJMcMayhem

धन्यवाद! मैं आपसे एक वी उत्तर देखने की उम्मीद कर रहा था कि क्या आपने कम बाइट के लिए एक अलग दृष्टिकोण का उपयोग किया है, लेकिन यह ठीक है! मुझे लगता है कि पहली टिप्पणी, यह कोशिश ऑनलाइन लिंक को अद्यतन करने के लिए भूल के एक समारोह है। दूसरा मुझे 3 बाइट्स मिला, इसलिए धन्यवाद!

— nmjcman101

Answer 8

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

" "<>Range[1,#,2]~StringRiffle~"  "<>"
"<>"/ \\"~Table~⌈#/2⌉&

अनाम फ़ंक्शन। इनपुट के रूप में एक संख्या लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है। यूनिकोड वर्ण, क्रमशः U + 2308 LEFT CEILING हैं \[LeftCeiling]और U + 2309 राइट CEILING हैं \[RightCeiling]।

Answer 9

WinDbg, 100 बाइट्स

.echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}

इनपुट छद्म रजिस्टर में मान सेट करके किया जाता है $t0।

ऐसा लगता है कि यह सबसे छोटा है यहाँ सिर्फ स्ट्रिंग को प्रिंट करने के लिए जैसा कि इसे बनाने के बजाय इसे पहले बनाने की कोशिश करें और पूरी चीज़ को प्रदर्शित करें। यदि WinDbg मुझे पता लिखने देता है तो मेरे पास एक छोटा समाधान होगा 0।

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

.echo;                                            * Print a new line that'll be deleted
.for(r$t1=1; @$t1 <= 2*@$t0+@$t0%2; r$t1=@$t1+2)  * Enumerate 1 to 4*ceil($t0/2), count by 2
{
    j@$t1<=@$t0                                   * If $t1 <= $t0...
        .printf"\b %d \n",@$t1;                   * ...Print $t1 (and newline for last n)
        .printf"/ \\"                             * ...Else print the / \'s
}

प्रत्येक मूल्य के लिए आउटपुट n:

0:000> .for(r$t0=0;b>@$t0;r$t0=@$t0+1){.printf"\n\nn=%d\n",@$t0; .echo;.for(r$t1=1;@$t1<=2*@$t0+@$t0%2;r$t1=@$t1+2){j@$t1<=@$t0 .printf"\b %d \n",@$t1;.printf"/ \\"}}


n=0



n=1
 1 
/ \

n=2
 1 
/ \

n=3
 1  3 
/ \/ \

n=4
 1  3 
/ \/ \

n=5
 1  3  5 
/ \/ \/ \

n=6
 1  3  5 
/ \/ \/ \

n=7
 1  3  5  7 
/ \/ \/ \/ \

n=8
 1  3  5  7 
/ \/ \/ \/ \

n=9
 1  3  5  7  9 
/ \/ \/ \/ \/ \

n=10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

Answer 10

> <> (मछली), 69 60 68 55 बाइट्स

5|v&+%1:,2
1->:?!v:
8~v!?l<on$o:*4
a&/o
1->:?!;"\ /"ooo

इसे इस ऑनलाइन दुभाषिया में चिपकाएँ!

पहली पंक्ति पर नंबर 5 आपके इनपुट मूल्य (5 के रूप में कोडित, उपयोगकर्ता इनपुट के लिए 0-या या i) द्वारा प्रतिस्थापित है।

संपादित 1: नई लाइन से 9 बाइट्स को अंतरिक्ष में समग्र रूप से सहेजने के लिए पहली पंक्ति के स्थान (खाली था) में नई लाइन प्लेसमेंट ले जाया गया।

संपादित करें 2: जैसा कि user7150406 द्वारा नोट किया गया था कि आउटपुट गलत था (कोई स्पेस प्रिंटिंग नहीं) यह 8 बाइट्स के नुकसान के साथ तय किया गया है।

संपादन 3: तर्क को पूरी तरह से बदल दिया, संख्या विषम होने पर कोई जाँच बिंदु नहीं है - बल्कि सभी संख्याओं को स्टैक पर रखें और हर दूसरे को हटा दें। बाइट बचाई 13!

Answer 11

जावा, 118 112 बाइट्स

संपादित करें: @ बाइट के लिए 6 बाइट्स सहेजे गए

golfed:

String M(int n){String o=" ";int i=1;n+=1;for(;i<n;i+=2)o+=i+"  ";o+="\n";for(i=0;i<n/2;i++)o+="/ \\";return o;}

Ungolfed:

public String M(int n)
{
    String o = " ";
    int i=1;
    n += 1;
    for (; i < n;i+=2)
        o += i + "  ";
    o += "\n";
    for (i = 0; i < n/2; i++)
        o += "/ \\";
    return o;  
}

परिक्षण:

    OddMountains om = new OddMountains();
    System.out.println(om.M(1));
    System.out.println();
    System.out.println(om.M(3));
    System.out.println();
    System.out.println(om.M(5));
    System.out.println();
    System.out.println(om.M(7));
    System.out.println();
    System.out.println(om.M(10));

 1  
/ \

 1  3  
/ \/ \

 1  3  5  
/ \/ \/ \

 1  3  5  7  9  
/ \/ \/ \/ \/ \

Comments

आह, आपने मुझे इसके लिए हरा दिया है :) मैं भी जावा उत्तर पोस्ट करना चाहता था। किसी भी तरह, यहाँ यह थोड़ा और अधिक गोल्फ के लिए कुछ सुझाव हैं: आपको iलूप के लिए अपने पहले में इनिशियलाइज़ करने की आवश्यकता नहीं है , यह इस तरह दिख सकता है for(; i < n; i++)। : आप गोल्फ इसे आगे इस परिवर्तन के साथ भी कर सकते हैं o += i + " ";करने के लिए परिवर्तन o += i++ + " ";और पाश हो जाता है के लिए for(; i < n; )। अगर आप बयान रखना चाहते हैं तो यह है। यदि आप i += 2 कथन के अनुसार मैं अपना वेतन वृद्धि कर सकते हैं और हटा सकते हैं, लेकिन उस स्थिति में मेरा दूसरा प्रस्ताव लागू नहीं होगा :) (ps: i havent

— test

@ भाषण यदि यह कोई सांत्वना है, तो यह आम तौर पर मेरे लिए पहला C # उत्तर प्राप्त करने की दौड़ है। यदि वह चला गया है, तो मैं एक जावा उत्तर के माध्यम से अपना रास्ता भर देता हूं :) युक्तियों के लिए धन्यवाद। मैंने लूप iसे आरंभीकरण को हटा दिया है for, लेकिन अन्य चीजें इसे लूप में फंस गई हैं। मुझे इसके साथ थोड़ा और खेलने की आवश्यकता हो सकती है :)

— पीट आर्डेन

हुह, मुझे बहुत खुशी है कि मेरी पिछली टिप्पणी में मैंने कहा "मैंने यह परीक्षण किया है" ... बेशक यह काम नहीं करता है o += i++ + " ";:)। Btw, आपके पास अपने कोड में एक छोटा बग है :) चूंकि जावा floor()पूर्णांक विभाजन (4/3 = 1) पर उपयोग करता है , आपको इसे इस तरह करना चाहिए int i = 1; n += 1; for (; i < n; i += 2) { ... jada jada ... }:। यदि आप मेरे द्वारा वेतन वृद्धि i += 2करते हैं, तो आपको आवश्यकता नहीं है कि यदि वक्तव्य समानता के लिए जाँच कर रहा हो। यह एक और 3 बाइट्स भी बचाता है :) इसे यहाँ आज़माएँ

— पीच

@ भाषण यदि कोई मेरे कोड को सही करने के लिए पर्याप्त आश्वस्त है, तो मुझे लगता है कि यह सही होना चाहिए, इसलिए जब यह काम नहीं करता है, तो मैं फिर से कोशिश करता हूं, यह सोचकर कि "यह मुझे होना चाहिए ..." :) कोई चिंता नहीं! युक्तियों के लिए धन्यवाद - मैंने floorकुछ दिनों पहले कुछ जावा के साथ खेलते समय खुद को विभाजन का पता लगाया :)

— पीट आर्डेन

Answer 12

सी # 6, 95 बाइट्स

n=>{var o="";int i=1;for(;i<=n;i+=2)o+=$" {i} ";o+='\n';for(i=1;i<=n;i+=2)o+="/ \\";return o;};

पूर्ण लंबोदर:

Func<int, string> a = n=>
{
    var o="";int i=1;
    for(;i<=n;i+=2)
        o+=$" {i} ";
    o+='\n';
    for(i=1;i<=n;i+=2)
        o+="/ \\";
    return o;
};

Answer 13

CJam, 26 23 बाइट्स

Sri,:)2%_S2**N@,"/ \\"*

झसे आज़माओ!

-3 8478 के लिए धन्यवाद (मार्टिन एंडर)

Comments

स्टैक हेरफेर से बचने के लिए आप 3 बाइट्स बचा सकते हैं:Sri,:)2%_S2**N@,"/ \\"*

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

@MartinEnder ओह, इसीलिए मैं इसे हटा नहीं सका +। और मैं कसम खाता हूँ, मैं वास्तव में इस्तेमाल किया ed! ... पायथ से छोटा।

— आउटगोल्फर

Answer 14

गेम मेकर लैंग्वेज (जीएम 8.0), 97 बाइट्स

m=ceil(argument0/2)e=""for(i=1;i<2*m;i+=2)e+=" "+string(i)+" "return e+"#"+string_repeat("/ \",m)

यह देखते हुए कि इनपुट अधिकतम 10 पर है, के chr(48+i)स्थान पर काम करेगाstring(i) , हालांकि बाइट्स की संख्या समान है।

पठनीय:

m = ceil(argument0/2)
e = ""
for (i = 1; i < 2*m; i += 2 )
  e += " " + string(i) + " "
return e + "#" + string_repeat("/ \", m)

Answer 15

पायथ, 24 22 बाइट्स

K-SQyMS5+dj*2dK*lK"/ \

-1 बाइट के लिए 42545 (ETHproductions) को धन्यवाद

ऑनलाइन दुभाषिया

11 परीक्षण मामले

Comments

साथ एक उद्धरण सहेजें*lK"/ \\

— ETHproductions

@ETHproductions आप \इसके बजाय \\:) का उपयोग कर सकते हैं

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

Answer 16

> <> (मछली) 52 63 62 बाइट्स

<v!?:-1:!?-1%2:
 >~la}}" "72.
v!?-2lno<o"  "
o
>:?!;"\ /"ooo1-

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

बस जगह का उपयोग करने के लिए nस्टैक पर और दूर तुम जाओ!

इसमें से बहुत कुछ @ टीले-पेलिकन के उत्तर से लिया गया है :)।

संपादित करें: आउटपुट वास्तव में या तो सही ढंग से संरेखित नहीं है> <> सबमिशन! फिक्सिंग ...

Edit2: मुझे कुछ बाइट्स का त्याग करना था, लेकिन आउटपुट वास्तव में अब सही है।

Edit3: \ /दर्पण के साथ कोई और अधिक मज़ा नहीं है और मैं 1 बाइट बचाता हूं।

आउटपुट:

 1  3  5  7  9
/ \/ \/ \/ \/ \

Comments

प्रिंटिंग में त्रुटि को देखने के लिए धन्यवाद, मैं अपना उत्तर अब संपादित कर रहा हूं (मेरे लिए काफी तुच्छ है) यह दिलचस्प है क्योंकि आधार का उत्तर एक ही है लेकिन बहुत से बाइट बचाता है।

— पेलिकन

कोई बात नहीं, मुझे एक> <> प्रस्तुत करते हुए खुशी हुई! यह देखना दिलचस्प होगा कि अब कौन सा छोटा होता जा रहा है क्योंकि इन बदलावों ने मेरा बुरा हाल कर दिया।

— redstarcoder

ऐसा लगता है कि मैं juuuust हूँ 5 बाइट्स छोटे: पी।

— redstarcoder

मैं अब मेरा एक और रूप देखने जा रहा हूं कि क्या मैं कुछ डॉट बाइट्स को आह से निकाल सकता हूं।

— चैले पेलिकन

मुझे घर मिल गया और इसके बारे में जाने के लिए एक नए तरीके का विचार आया। मेरा नया जवाब है 55 बाइट्स! : डी - मुझे इस पर काम करने के लिए धन्यवाद, यह मजेदार रहा है।

— चैले पेलिकन

Answer 17

सी, 100 79 77 बाइट्स

#define P(s)for(i=0;i++<n;printf(s,i++));puts("");
i;f(n){P(" %d ")P("/ \\")}

Answer 18

आर, 70 69 68 58 बाइट्स

cat(paste("",z<-seq(,scan(),2)),"\n");for(i in z)cat("/ \\")

3:
#>  1  3 
#> / \/ \

10:
#>  1  3  5  7  9 
#> / \/ \/ \/ \/ \

Answer 19

दे घुमा के, 64, 59, 57, 51, 49, 48, 45 बाइट्स

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

• माइनस 3 बाइट्स (STDIN के बजाय $ 1 का उपयोग करें)
• एक और बाइट के -s ""साथ बदलकर-s\
• sef -f के साथ प्रिंटफ को बदलकर माइनस 2 बाइट्स (धन्यवाद @Adam!)
• फ़ंक्शन के बजाय स्क्रिप्ट के लिए फिर से सक्रिय (हरा करने के लिए <<> )
• हटाए गए रिक्त स्थान
• sed अभिव्यक्ति को थोड़ा अनुकूलित किया

golfed

चंक (45 बाइट):

seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

समारोह (मूल संस्करण) (57 बाइट्स):

M() { printf " %s %.0s" `seq 1 $1`|sed 'p;s| . |/ \\|g';}

परीक्षा

--- mountains.sh ----
#!/bin/bash
seq -f" %g " -s\  1 2 $1|sed 'p;s| . |/ \\|g'

>./mountains.sh 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

>M 10
 1  3  5  7  9 
/ \/ \/ \/ \/ \

Comments

sedशानदार है। एक फ़ंक्शन और न ही प्रिंटफ का उपयोग न करके, आप 10 बाइट्स बचाते हैं:seq -f" %g " -s "" 1 2 $1|sed 'p;s| . |/ \\|g'

— एडम

यह एक अच्छी सलाह है! धन्यवाद ! मैं अभी भी catएसटीडीआईएन से इनपुट को पढ़ने के लिए उपयोग करता हूं , क्योंकि आईएमओ डेटा को डेटा में पास करने के लिए पूर्व-परिभाषित चर का उपयोग करना वास्तव में उचित नहीं है।

— zeppelin

$1कार्यक्रम के लिए प्रेषित सिर्फ पहला पैरामीटर है। मुझे नहीं लगता कि यह meta.codegolf.stackexchange.com/questions/2447/…

— एडम

हां, आप सही हैं। एक बार फिर धन्यवाद !

— जेपेलिन

Answer 20

बीफयून 93 , 64 बाइट्स

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

 &61p1   v+2,,,"/ \"
_v#!`" ":<+2.," ":
 <^p00p10"|<"
@ >91+,$1v

Answer 21

रूबी 82 60 बाइट्स

यदि मैं रूबी के साथ बेहतर था तो त्वरित और गंदा रूबी समाधान निश्चित रूप से बेहतर अनुकूलित हो सकता है

puts "",1.step($*[0].to_i,2).map{|x|$><<" #{x} ";"/ \\"}*""

उपयोग: prog.rb 10
आउटपुट:

 1  3  5  7  9
/ \/ \/ \/ \/ \

संपादित करें: @ प्रबंधन द्वारा कई संपादन और अनुकूलन!

Comments

print→ $><<और स्ट्रिंग प्रक्षेप का उपयोग करें " #{x} "। लेकिन सबसे अच्छा की संख्या को कम करने के लिए किया जाएगा .eachकॉलबैक से सीधे 1 लाइन outputting और एक चर में 2 लाइन के निर्माण द्वारा: s="";(1..$*[0].to_i).step(2){|x|$><<" #{x} ";s+="/ \\"};puts"",s। या भी puts"",(1..$*[0].to_i).step(2).map{|x|$><<" #{x} ";"/ \\"}*""।

— मैनटवर्क

Numeric#step2 पैरामीटर को स्वीकार करता है, इसलिए लम्बी श्रेणी के सिंटैक्स से बच सकता है जिसके लिए कोष्ठक की आवश्यकता होती है: (1..$*[0].to_i).step(2)→ 1.step($*[0].to_i,2)।

— मैनटवर्क

@manatwork वास्तव में अच्छे सुझाव! मैं अपने भविष्य के कोडगॉल्फ पोस्ट में आपकी सलाह का भरपूर उपयोग करके खुद को देख सकता हूं इसलिए मैं वास्तव में इनपुट की सराहना करता हूं।

— बेन हिली

Answer 22

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

n=>(f=n=>n?f(n-1)+(n%2?n+s:s):s=" ")(n)+`
`+"/ \\".repeat(++n/2)

पुनरावर्ती पहली पंक्ति बनाता है, फिर दूसरा जोड़ता है। पहली पंक्ति को इस अवलोकन के साथ बनाया गया है कि यह बस रेंज है [0 ... n] प्रत्येक आइटम n के साथ एक स्थान में तब्दील होने पर भी अगर या विषम हो तो n किसी स्थान के साथ समाप्‍त हो जाता है।

Answer 23

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

सहेजे गए 6 बाइट @Kade की बदौलत!

lambda s:" "+"  ".join(`range(s+1)`[4::6])+"\n"+-~s/2*"/ \\"

Comments

आपको एक list()कास्ट का उपयोग करने की आवश्यकता नहीं है , इसे हटाने से आपको 60 :)

— Kade

@ केक बैकटिक्स `` `को एक स्ट्रिंग बनाते हैं। मैं इसे पसंद नहीं कर सकता lambda s:" "+" ".join(range(s+1)[1::2])+"\n"+-~s/2*"/ \\"eक्योंकि तब यह चींटियों की एक सूची देगा और यह मर जाएगा

— ओलिवर नी

क्या आपको यकीन है?

— Kade

@ केड हू। यह ऑनलाइन काम नहीं करता है ... कोई बात नहीं, मुझे नहीं पता कि मैंने सोचा कि यह काम क्यों नहीं किया ...

— ओलिवर नी

Answer 24

बैच, 107 बाइट्स

@set s=
@set t=
@for /l %%i in (1,2,%1)do @call set s=%%s%%  %%i&call set t=%%t%%/ \
@echo%s%
@echo %t%

Answer 25

स्काला, 99 95 बाइट्स

(? :Int)=>for(i<-0 to 1)println(1 to ?filter(c=>c%2>0)map(c=>if(i<1)s" $c "else"/ \\")mkString)

Ungolfed

(? :Int) => 
    for (i<-0 to 1)
        println(
            1 to ?filter(c=>c%2>0)
                  map(c=>if(i<1)s" $c "else"/ \\")
                  mkString
        )

Answer 26

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

->x{" 1  3  5  7  9 "[0..3*x-=x/2]+?\n+"/ \\"*x}

Answer 27

ऑक्टेव, 45 बाइट्स

f=@(n)reshape(sprintf(' /%d \',1:2:n),2,[]);

टेस्ट:
f (8)

 1  3  5  7
/ \/ \/ \/ \

Comments

जब इनपुट = 0, एक / बाएँ है :)

— Sygmei

नहीं कहा कि आपका जवाब सही नहीं है! बस उस छोटे से अजीब गड़बड़ पर ध्यान दिया :)

— Sygmei

मैं n == 0 :(

— rahnema1

Answer 28

QBIC , 35 बाइट्स

:[1,a,2|X=X+!b$+@ | Y=Y+@/ \|]?X ?Y

स्पष्टीकरण:

:           gets a CMD line param as INT 'a'
[1,a,2|     FOR b = 1 to a STEP 2
X=X+!b$+@ | Add to X$ the counter of our FOR loop and a trailing space
            Leading space is provided by the cast-to-string function.
Y=Y+@/ \|   Add to Y$ the mountain.
]           Close the first possible language construct (IF, DO or FOR). In this case: NEXT
?X ?Y       Print X$, Print Y$. The space adds a newline in the resulting QBASIC.

Answer 29

खेतानई , 140 बाइट्स

$0[0]$1[int(input":")]$2[""]$3[""]$0#?(mod@2)($2[add(add(@" ")(string($0@)))"  "]
$3[add@"/ \"])?(neq@($1@))([add@1]&1)print($2@)print($3@)%

Answer 30

पर्ल, 46 + 2 ( -plध्वज) = 48 बाइट्स

@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)

का उपयोग करते हुए:

perl -ple '@_=map$_%2?$_:"",0..$_;$_="@_$/"."/ \\"x(@_/2)' <<< 7    

या 52 बाइट्स:

@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/

का उपयोग करते हुए:

perl -e '@_=map$_%2?$_:"",0..pop;print"@_$/","/ \\"x(@_/2),$/' 7