एक क्रिसमस ट्री प्रिंट करें


26

चुनौती

एक छोटा क्रिसमस ट्री प्रिंट करें, जिसमें सबसे कम कोड का उपयोग करके शीर्ष पर खुद का सितारा संभव है। ट्री स्टार एक एस्टेरिस्क ( *) है और ट्री बॉडी से बना है 0पेड़ की 10 पंक्तियां ऊंची होनी चाहिए। हर पंक्ति को इस तरह से सही तरीके से इंडेंट किया जाना चाहिए कि पिछली पंक्ति अगले एक पर केंद्रित हो। किसी भी दी गई पंक्ति में पिछले की तुलना में 2 अधिक 0 होना चाहिए, सिवाय पहले वाले के जो स्टार और दूसरा है, जिसमें केवल एक ही है। 0. परिणाम कुछ इस प्रकार है:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

सॉफ्टवेयर परिवर्तन के बिना परिवर्तनशील ऊंचाई वाले पेड़ों के लिए टाई तोड़ना (ऊंचाई पैरामीटर को छोड़कर)

कृपया, अपने कोड के परिणामी पेड़ को भी चिपकाएँ!


लीडरबोर्ड


जवाबों:


17

गोल्फस्क्रिप्ट, 27 वर्ण

" "9*"*"9,{n\.4$>\.+)"0"*}%

परिणामस्वरूप पेड़ इस तरह दिखता है:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

एक संस्करण जो ऊंचाई पैरामीटर का उपयोग केवल एक बार करता है वह एक वर्ण लंबा है:

9." "*"*"@,{n\.4$>\.+)"0"*}%

स्टड से ऊंचाई पढ़ना (उदाहरण के पेड़ को उत्पन्न करने के लिए इनपुट "10" के साथ) वर्णों की समान मात्रा (28) लेता है:

~,)" "*"*"@{n\.4$>\.+)"0"*}%

56

मुझे पता है कि यह कल्पना का अनुपालन नहीं करता है, लेकिन मुझे लगा कि मैं जोआन जी स्टार्क द्वारा इस क्लासिक ASCII कला क्रिसमस दृश्य की नकल करके पेड़ों में कुछ विविधता जोड़ने की कोशिश करूंगा ।

मैंने पूरी तस्वीर को पुन: पेश करने की कोशिश नहीं की - जो थोड़ा बहुत हो सकता है - लेकिन सिर्फ पेड़, जिसके लिए मैं यह 138-बाइट पर्ल कार्यक्रम प्रस्तुत करता हूं:

$_=join$/,qw'11| 8\2_2/ 9(\o/) 5---2/1\2--- 10>*<',map(11-$_.A.AA x$_,2..11),'9\|H|/';s/\d+/$"x$&/eg,s/A/substr">>>@*O<<<",rand 9,1/eg,say

और, ज़ाहिर है, यहाँ आउटपुट का एक नमूना है:

           |
        \  _  /
         (\o/)
     ---  / \  ---
          >*<
         >O><@
        <><<>><
       @><><>@<<
      @<O><*@*>>O
     OO@@*O<<<*<OO
    ><<>@><<>@<><><
   >><O<>>><@*>>><<O
  *<>*<><<>@><O*>><*<
 O><><<@<*>><O*@>O><>*
O<><<><@O>>*O*OO<><<>O>
         \|H|/

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

कोड पर्ल 5.10+ sayसुविधा का उपयोग करता है , और इसलिए कमांड लाइन स्विच -M5.010(या -E) के साथ चलाने की आवश्यकता होती है । (वास्तव में, इसके sayसाथ अंत में प्रतिस्थापित करने से printदो अतिरिक्त बाइट की लागत और उत्पादन की अंतिम पंक्ति के बाद नई लाइन के नुकसान से बचना होगा।)

ध्यान दें कि पेड़ का थोक अनियमित रूप से उत्पन्न होता है, इसलिए गहनों का स्थान रनों के बीच अलग-अलग होगा। परी, स्टैंड और पेड़ की शीर्ष पंक्ति हालांकि, तय की गई हैं।


इसे पोस्ट किए जाने के बाद शुरू की गई नीति के तहत संक्षेप में हटाए जाने से इस लोकप्रिय उत्तर को बनाए रखने के लिए , यहां एक टोकन कल्पना-संगत समाधान (45 बाइट्स, पर्ल 5 भी):

$_=$"x10 ."*";say,s/ 0/00/,s/\*?$/0/ while/ /

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

ऊपर दिए गए कार्यक्रम की तरह, यह भी सुविधा -M5.010को सक्षम करने के लिए स्विच के साथ पर्ल 5.10+ पर चलाया जाना चाहिए say। जाहिर है (यह एक चुनौती होने के नाते ) यह अन्य सभी आज्ञाकारी प्रविष्टियों के समान सटीक उबाऊ आउटपुट पैदा करता है, जिसे मैं यहां दोहराने से परेशान नहीं करूंगा। (संख्या 10को किसी अन्य मान में बदलकर यह तुच्छ रूप से पुनरुत्पादित भी है।)


1
महान! युक्ति से नहीं, लेकिन मुझे लगता है कि न्यायाधीशों का विशेष पुरस्कार आपके लिए है! :)
Averroes

6
अगर मैं कर सका तो यह चश्मे की लौकिक +2 को पीछे छोड़ता है।
क्राइस

3
क्षमा करें, लेकिन नियमों के अनुसार, जवाब जो कल्पना को पूरा नहीं करते हैं उन्हें हटा दिया जाना चाहिए।
mbomb007


1
क्या आप कृपया शीर्ष पर मान्य उत्तर को स्थानांतरित कर सकते हैं और शीर्ष लेख जोड़ सकते हैं?
डेनिस

13

गोल्फस्क्रिप्ट (33 वर्ण)

निश्चित-ऊंचाई संस्करण:

;8:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

या बिल्कुल उसी लंबाई के लिए

;8:^' '*.'*'+n@'0'+^{.n\(;'00'+}*

पेड़ हर किसी के समान उल्लेखनीय दिखता है:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

संस्करण जो स्टड से ऊंचाई लेता है:

~((:^' '*.'*'+\'0'+^{.(;'00'+}*]n*

पिछली पंक्ति की शुरुआत बेहतर स्माइली में से एक है जिसे मैंने "उपयोगी" गोल्फस्क्रिप्ट प्रोग्राम में बनाया है।


10

शैल लिपि, 44 वर्ण

printf %9c\\n \* 0|sed ':x
p;s/ 0/000/;tx
d'

इस पेड़ को प्रिंट करता है:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

9

मेपल, 30/37 चार्ट

Mr.Wizard की Mathematica प्रविष्टि से प्रेरित होकर , मैं इस 30-char मेपल 12 कमांड को प्रस्तुत करता हूं:

<`*`,('cat(0$2*i+1)'$i=0..8)>;

आउटपुट:

                              [        *        ]
                              [                 ]
                              [        0        ]
                              [                 ]
                              [       000       ]
                              [                 ]
                              [      00000      ]
                              [                 ]
                              [     0000000     ]
                              [                 ]
                              [    000000000    ]
                              [                 ]
                              [   00000000000   ]
                              [                 ]
                              [  0000000000000  ]
                              [                 ]
                              [ 000000000000000 ]
                              [                 ]
                              [00000000000000000]

मैं सात और चार्ट की लागत से कोष्ठक से छुटकारा पा सकता हूं:

`*`;for i in$0..8 do;cat(0$2*i+1);od;

आउटपुट छोड़ा गया - यह ऊपर की तरह दिखता है, केवल कोष्ठक के बिना। दुर्भाग्य से, मैं मेपल को टेक्स्ट मोड में आउटपुट पंक्तियों के बीच रिक्त लाइनों को सम्मिलित करने से रोकने का कोई तरीका नहीं जानता। यह क्लासिक वर्कशीट मोड में बेहतर दिखता है। मुझे लगता है कि मैं एक स्क्रीनशॉट शामिल कर सकता हूँ ...

स्क्रीनशॉट

(स्क्रीनशॉट कमांड के पहले के 44-चार संस्करण को दिखाता है, लेकिन मैं इसे रीटेक करने के लिए बहुत आलसी हूं। आउटपुट अभी भी वही है।)

ओह, और हाँ, आकार पूरी तरह से समायोज्य है: बस एक n -row पेड़ के लिए n -2 के साथ 8 बदलें । पहले समाधान के साथ, 25 पंक्तियों (या जीयूआई में 10) से ऊपर जाने के लिए भी इंटरफ़ेस सेट करना आवश्यक है (rtablesize = n ), हालाँकि।

(Ps। मुझे लगा कि मैं नवीनतम संस्करण के साथ GolfScript को हराने में कामयाब रहा , लेकिन अफसोस ... )


8

पर्ल, 42 चरस

say$"x9,"*";say$"x(9-$_),"00"x$_,0for 0..8

आउटपुट:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

पेड़ की ऊँचाई को 1 और 11 पंक्तियों के बीच में 8से मूल्यों के साथ अंत में बदलकर बदला जा सकता -1है 9। 11 पंक्तियों से ऊपर 9जाने के लिए कोड में पहले से दो एस बढ़ाने की आवश्यकता होती है , जो नियंत्रण करता है कि स्क्रीन पेड़ के बाईं ओर कितनी दूर है।


यह एक 11 पंक्तियाँ हैं: पी माइनर परिवर्तन मुझे लगता है
Averroes

@ एवर्रोस: हाँ, मैंने पहली बार माना कि यह 10 पंक्तियों के साथ- साथ तारे को भी माना जाता है , लेकिन तब मैंने वास्तव में नमूना आउटपुट में पंक्तियों को गिना और इसे ठीक किया।
इल्मरी करोनें

8

ग्रूवी, 65

(p={c,r->println' '*(9-r)+(c*(r*2-1))})'*',1;(1..9).each{p'0',it}

हैरानी की बात है, पेड़ इस तरह दिखता है:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

'द ट्री आउटपुट' पोस्ट कुछ क्रिसमस स्पिरिट को इस साइट पर लाने के लिए है: P
Averroes

इसके अलावा, आपकी 11 पंक्तियाँ भी हैं!
Averroes

मैं ऊंचाई पैरामीटर को समायोजित करके ठीक कर सकता हूं!
आर्मंड

8

रूबी, 46 वर्ण

puts" "*8+?*;9.times{|i|puts"%8s0"%(v=?0*i)+v}

ऊंचाई को बदलने के लिए आपको दोनों 8 को बदलना होगा और निश्चित रूप से 9. कार्यक्रम का आउटपुट निम्नानुसार है:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

संपादित करें : Inexcusably मैंने पहले सबमिशन में आउटपुट को छोड़ दिया था।


1
आप आउटपुट पोस्ट करना भूल गए। :)
इल्मरी करोनें

7

पॉवरशेल, ४१

" "*8+"*";0..8|%{" "*(8-$_)+"0"+"0"*$_*2}

अप्रत्याशित रूप से, एक ही पेड़ को हर किसी के रूप में आउटपुट करता है :-p

यदि आप उस 8 को पैरामीरिज करते हैं, तो यह आपके कंसोल के आकार तक, 48 अक्षरों में, कहेगा :

" "*($w=8)+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

या, एक पूर्ण-विकसित स्क्रिप्ट के रूप में, जो एक तर्क लेता है, 53 वर्ण :

param($w)" "*$w+"*";0..$w|%{" "*($w-$_)+"0"+"0"*$_*2}

कहा जाता है, ऐसा लगता है:

PS>: Get-Tree.ps1 8
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

7

पायथन 3: 62 वर्ण

print(' '*9+'*',*('\n'+' '*(9-i)+'0'*(i*2+1)for i in range(9)))

आउटपुट:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

ध्यान दें कि यह अनिवार्य रूप से 11 पात्रों द्वारा @ एंटे के उत्तर को धड़कता है, क्योंकि यह उत्तर, जब पायथन 3 में परिवर्तित होता है, 73 वर्णों का उपयोग करता है।

9एक अलग ऊंचाई के लिए प्रत्येक को दूसरे मूल्य में बदलें ।


3
मुझे लगता है कि आप पहले भी जगह खो सकते हैं for
badp

@badp थैंक्स- 63 से बदलकर 62 हो गया!
कज़र्क

6

अजगर, ५ ९

print' '*9+'*'
for i in range(9):print' '*(9-i)+'0'*(i*2+1)

अच्छा काम-यह दर्शाता है कि हालांकि @Ante द्वारा उत्तर पायथन 3 में अधिक समय तक मिलता है, मेरा पायथन 3 उत्तर पायथन 2 ( printएक फ़ंक्शन नहीं) में छोटा है।
कज़र्क

6

प्रस्तावना: 183 या 186

r(0,_,L,L).
r(N,C,L,[C|T]):-N>0,M is N-1,r(M,C,L,T).
y(S,T,C):-r(T,C,[10],X),r(S,32,X,Y),atom_codes(A,Y),write(A).
x(A,B):-A>0,y(A,B,48),C is A-1,D is B+2,x(C,D).
x(N):-y(N,1,42),x(N,1).

प्रिंटों:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
false.

कुछ दुभाषियों के लिए और अधिक निचोड़ा जा सकता है (जैसे SWI पर टैब / 1 का उपयोग करना)

एक्स (एन) के साथ आमंत्रित करें। जहाँ N वास्तविक पेड़ (स्टार को छोड़कर) में पंक्तियों की संख्या है। इसे एक निश्चित ऊंचाई देते हुए इसे 183 तक लाया जाएगा


6

सी

यह वेड टैंडी का C संस्करण है लेकिन थोड़ा संशोधित किया गया है:

           ;
          int
         main(
        ){int i
       =-1,j=0,c
      =10;while(j
     ++<c){printf(
    " ");}{;printf(
   "*");}while(++i<c
  ){for(j=-2;++j<c-i;
 )printf(" ");for(j=0;
++j<2*i;){printf("0");}
          ;;;
        printf(
         "\n")
          ;}}


5

अप्लेसॉफ्ट बेसिक, 143 वर्ण

चूंकि यह प्रश्न मुझे होमवर्क असाइनमेंट की याद दिलाता है जो मैंने हाई स्कूल में वापस किया था (जब वे एक Apple // e पर पढ़ा रहे थे):

1INPUTH:X=(H*2)-2:C=(X/2):S$="*":O=0:GOSUB2:S$="0":FORO=0TOX-2STEP2:GOSUB2:NEXT:END
2FORS=0TOC-(O/2):?" ";:NEXT:FORI=0TOO:?S$;:NEXT:?"":RETURN

मैंने यहां पाया गया जावास्क्रिप्ट एप्स्कॉफ्ट बेसिक का इस्तेमाल किया: http://www.calormen.com/applesoft/

उत्पादन:

?10
          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

5

प्रस्तावना: 127 वर्ण

p:-write('        *'),h(1).
h(L):-(L<10,nl,w(L,-8),h(L+1));!.
w(L,N):-(N<9,N<L,(L>abs(N)->write('0');write(' ')),w(L,N+1));!.

आउटपुट:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

उपयोग किया जाता है Prologक्योंकि मैं Groovyउसके कोड को देखे बिना रिकॉर्ड को हरा नहीं पा रहा था :(


5

पोस्टस्क्रिप्ट (पैरामीटर की ऊंचाई के साथ), 114 वर्ण

/h 9 def/b{{( )=print}repeat}def
h -1 0{dup h eq{dup b(*)=}if dup b h sub neg 2 mul 1 add{(0)=print}repeat()=}for

आउटपुट:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

क्या, आप इसे प्रिंट आउट करना चाहते थे?


4

जावास्क्रिप्ट (राइनो: 108, नोड: 114, वेबकिट देव कंसोल: 119, jQuery प्लगइन: 132)


राइनो सबसे छोटा (108 अक्षरों में) है क्योंकि (ए) के printफंक्शन में एक छोटा नाम है और (बी) यह आपको एक छोटे वेरिएबल नाम में बिल्ट-इन फंक्शन असाइन करने देगा। इसलिए:

h=10,p=print,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}


Node.js एक दूसरे सेकंड (114 वर्णों पर) में आता है क्योंकि इसके प्रिंट फ़ंक्शन console.logका एक लंबा नाम है, लेकिन यह हमें एक छोटे से वैरिएबल को भी असाइन करने देगा:

h=10,p=console.log,m='0',a=Array(h-1),s=a.join(' ');p(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();p(a.join(' ')+m);}


हालाँकि, Webkit Dev Console (और शायद Firebug, too) को लगता p=console.logहै कि थोड़ा बहुत डरपोक है (जब आप कॉल करने की कोशिश करते हैं p(), तो यह आपसे शिकायत करेगा)। इसलिए, हमें चीजों को 119 वर्णों तक लंबा करना होगा:

h=10,m='0',a=Array(h-1),s=a.join(' ');with(console){log(s+'*\n'+s+m);while(h-->2){m+='00';a.pop();log(a.join(' ')+m);}}

(दिलचस्प है, withकेवल हमें एक चरित्र बचाता है)।


अंत में ... एक jQuery प्लगइन (अभी भी 132 वर्णों पर उल्लेखनीय!):

$.fn.xms=function(h){var m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$(this).css({textAlign:'center'}).html(l.join('\n<br/>'));}

और आप इसे इस पृष्ठ के पाद लेख पर भेज सकते हैं: $('#footer').xms(3)

बेशक, यह एक प्लगइन होने की जरूरत नहीं है ... क्योंकि हमें शायद इसे एक पृष्ठ पर जोड़ने के लिए जावास्क्रिप्ट कंसोल का उपयोग करना होगा और इसे लागू करना होगा, हम सिर्फ jQuery का एक स्निपेट कर सकते हैं :

h=10,m='0',w=2,l=['*',m];while(w++<h)l.push(m+='00');$('#footer').css({textAlign:'center'}).html(l.join('\n<br/>'));

जिसका वजन अधिक प्रतिस्पर्धी 116 वर्णों में होता है - वास्तव में, यह अन्य देव कंसोल कार्यान्वयन को समाप्त करता है। लेकिन, फिर, jQuery और / या ब्राउज़र के लेआउट इंजन का उपयोग करके धोखा माना जा सकता है। :)


4

सी, 67

मुझे पता है कि यह बहुत लंबा है, लेकिन यह कोड गोल्फ में मेरा पहला प्रयास है, और मुझे लगता है कि मुझे एक बहुत अच्छा सी समाधान मिला है।

दिलचस्प बात यह है कि मैं स्वतंत्र रूप से @ पैट्रिक के समान समान समाधान के साथ आया था।

और हां, मैं अपने हार्डककोड मूल्यों के साथ कोई संबंध नहीं जीतूंगा;) मैं वैसे भी काफी प्रसन्न हूं।

i;main(){for(;i<10;++i)printf("%*s%0*c\n",i?9-i:8,"",i*2,i?32:42);}
        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
जारी रखने के लिए किसी भी कुंजी को दबाएं । । ।

4

आकाशवाणी

select lpad('*', 11) from dual
union all
select rpad(' ', 10 - level) || rpad(' ', level * 2, '0') from dual
connect by level <= 9;


          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

10 rows selected.

4

PHP, 106 अक्षर

पिछले से 7 कम:

<?php echo str_pad(' ',9)."*\n";for($i=0;$i<9;$i++){echo str_pad("",9-$i).str_pad("",($i*2)+1,"0")."\n";}

2
छोटे टैग सक्षम करें और अपने आप को 3 वर्णों को सहेजें, या उपयोग करें <?=और "इको" से एक और 5 बचाएं।
ब्रोमबॉम

मुझे पता है कि मैं 8 महीने लेट हूँ, लेकिन codegolf.stackexchange.com/a/6783/4967 :)
Leigh

4

LOLCODE, 527 बाइट्स

CAN HAS STDIO?
HAI 1.2
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 8
    VISIBLE " "!
IM OUTTA YR LOOP
VISIBLE "*"
I HAS A SPACES
SPACES R 8
I HAS A ZEROS
ZEROS R 1
IM IN YR LOOP UPPIN YR VAR TIL BOTH SAEM VAR AN 9
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN SPACES
        VISIBLE " "!
    IM OUTTA YR LOOP
    IM IN YR LOOP UPPIN YR VAR2 TIL BOTH SAEM VAR2 AN ZEROS 
        VISIBLE "0"!
    IM OUTTA YR LOOP
    VISIBLE ""
    SPACES R DIFF OF SPACES AN 1
    ZEROS R SUM OF ZEROS AN 2
IM OUTTA YR LOOP
KTHXBYE

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

आउटपुट:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

1
यह कोड-गोल्फ है , इसलिए कृपया शीर्ष लेख में अपनी प्रविष्टि की बाइट गिनती जोड़ें।
lirtosiast

4

अजगर, 70 वर्ण

इतना छोटा नहीं है, लेकिन पुनरावर्ती समाधान :-)

def a(s):
 print s
 if s<"0":a(s[1:]+"00")
print" "*8+"*"
a(" "*8+"0")

ऊँचाई सेट करने के लिए 8 को बदलें।


4

जावास्क्रिप्ट, 119 अक्षर

फायरबग कंसोल को आउटपुट

i=h=9;a=new Array(h);a[0]=a.join(' ');b=a.join('000');a[0]+='*';while(i)a[i--]=b.substr(i,h+i);console.log(a.join('\n'))


        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

2
यह वास्तव में 120 अक्षर है।
रोब फॉक्स

3

PHP 113

मैं एक php संस्करण के साथ चूना लगा था:

113 वर्ण ( $hऊंचाई बदलने के लिए समायोजित करें, लाइनों की संख्या में तारा शामिल है):

$h=10;for($n=0;$n<$h;$n++){$i=$n>0?$n:1;$c=$n<1?"*":"0";echo str_repeat(" ",$h-$i).str_repeat($c,($i*2)-1)."\n";}

मैंने इसे छोटा बनाने की कोशिश की, पठनीय नहीं है और हम पहले से ही जानते थे कि php समरसता पर प्रतिस्पर्धा नहीं कर सकता है इसलिए यह कुछ भी जीतने वाला नहीं है, फिर भी एक मजेदार छोटी पहेली थी।

उत्पादन के रूप में कल्पना है:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

एक लिट्ल बिट को अधिक हार्ड करना, 103 वर्ण, (आप इस टिप्पणी के अंदर पहली गूंज में रिक्त स्थान नहीं देख सकते हैं) $ n = 0; गूंज "* \ n"; के लिए ($ i = 9; $ i> 0; $; i - प्रिंट str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i); "\ n", $ n ++);
लूसिया

यदि आप पेड़ की ऊँचाई को बदल देते हैं तो आपकी हार्डकोड पहली पंक्ति संतुलन से बाहर हो जाएगी:
Kris

3

सी, 77

i;main(c){printf("%*c\n",c,42);while(i<c)printf("%*s%0*d\n",c-i,"",i++*2+1,0);}

प्रिंटफ स्पेक को और अधिक ध्यान से पढ़ने से पहले, मेरे पास यह प्यारा सा नंबर था, जो कि 138 चार्ट्स तक था:

#define x sprintf(b,
#define y printf(b,
i;main(c){char b[9]="%%%dc\n",*t="%%%ds%%0%dd\n";x b,c);y 42);while(i<c)x t,c-i,i++*2+1),y "",0);}

3

जावा, 192 (परम के साथ 198)

class V{public static void main(String[]a){int c=10,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

अनुरोधित पेड़ प्रिंट करता है:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

थोड़ी ऊंचाई के लिए:

class W{public static void main(String[]a){int c=a.length,i=-1,j=0;String s="";while(j++<c)s+=" ";s+="*";while(++i<c){for(j=-2;++j<c-i;)s+=" ";for(j=0;++j<2*i;)s+="0";System.out.println(s);s="";}}}

कमांड लाइन तर्क सूची की लंबाई ऊंचाई निर्धारित करती है (जैसे java W a a a a aऊंचाई 5 देगी)।

(यह मूल रूप से वेड टैंडी के सी समाधान का जावा संस्करण है।)


मुझे पता है कि यह थोड़ी देर पहले पोस्ट किया गया था :), लेकिन यहां दो चीजें हैं जो मैं देख रहा हूं: 1. आप जावा 8 में एक क्लास के बजाय एक इंटरफ़ेस का उपयोग कर सकते हैं 2. दो वर्णों को बचाने के लिए, while (++i < c) {-> for (s += "*";++i < c;s = "") {, औरs += "*";s = "";
रीइन

3

विम, 18 बाइट्स

17i0<esc>qqYPxr q8@qa*

ऑनलाइन बैकवर्ड-संगत वी दुभाषिया में इसे आज़माएं !

हालांकि यह मेरा वी जवाब के रूप में एक बहुत ही समान दृष्टिकोण है, यह एक है नहीं vim के बाद से गैर प्रतिस्पर्धा पागल पुराना है। :)

स्पष्टीकरण:

17i0<esc>               " Insert 17 '0's
         qq     q       " Start recording into register 'q'
           YP           " Duplicate this line upwards
             x          " Delete one character
              r         " Replace this character with a space
                 8@q    " Playback macro 'q' 8 times
                    a*  " Append an asterisk

3

स्काला, 74 बाइट्स

val h=10;println(" "*h+"*");for(i<-0 to h-2)println(" "*(h-i)+"0"*(i*2+1))

h - पेड़ की ऊंचाई

उत्पादन

        *          
        0          
       000         
      00000        
     0000000       
    000000000      
   00000000000     
  0000000000000    
 000000000000000   
00000000000000000  

2

सी, 80

i=9,k=10,j;main(F){while(i)putchar(++j<i?32:j<k?48-F*6:(i-=!F,k+=!F,F=j=0,10));}

पेड़ की ऊंचाई के लिए शुरू में, मैं k-1 करने के लिए। एफ पहली पंक्ति का झंडा है। कोई तर्क नहीं दिया, तो प्रवेश पर एफ 1 होना चाहिए।

थोड़ा लंबा (81) संस्करण जहां f गैर प्रथम पंक्ति ध्वज है:

i=9,k=10,j,f;main(){while(i)putchar(++j<i?32:j<k?42+f*6:(i-=f,k+=f,f=1,j=0,10));}
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.