कोड गोल्फ क्रिसमस संस्करण: ऊँचाई एन के एक क्रिसमस ट्री का प्रिंट आउट कैसे लें

89

एक संख्या को देखते हुए N, मैं Nकम से कम कोड वर्णों का उपयोग करके ऊंचाई का एक क्रिसमस ट्री कैसे प्रिंट कर सकता हूं ? Nको न्यूनतम मान के लिए विवश माना जाता है 3, और अधिकतम 30सीमा (सीमा और त्रुटि जाँच आवश्यक नहीं है)। Nआपके प्रोग्राम या स्क्रिप्ट में एक और केवल कमांड लाइन तर्क के रूप में दिया जाता है।

सभी भाषाओं की सराहना की, यदि आप पहले से ही लागू की गई भाषा देखते हैं और आप इसे छोटा बना सकते हैं, यदि संभव हो तो संपादित करें - अन्यथा टिप्पणी करें और आशा करें कि कोई गड़बड़ी को साफ कर देगा। स्पष्टता के लिए नई सूचियाँ और श्वेत रिक्तियाँ शामिल करें, लेकिन उन्हें वर्ण गणना में शामिल न करें।

एक क्रिसमस ट्री इस तरह से उत्पन्न होता है, जिसमें "ट्रंक" होता है, जिसमें केवल एक केंद्रित "*" होता है

एन = 3:

   *
  ***
 *****
   *

एन = 4:

    *
   ***
  *****
 *******
    *

एन = 5:

     *
    ***
   *****
  *******
 *********
     *

एन एक पंक्ति ट्रंक सहित शाखाओं की ऊंचाई को परिभाषित करता है।

मेरी क्रिसमस पीपीसीजी!

code-golf  ascii-art 
— TheSoftwareJedi
स्रोत

जवाबों:

46

जे , 24 वर्ण

(,{.)(}:@|."1,.])[\'*'$~

   (,{.)(}:@|."1,.])[\'*'$~5
    *    
   ***   
  *****  
 ******* 
*********
    *

स्पष्टीकरण:

'*'$~5
*****

[\'*'$~5
*    
**   
***  
**** 
*****

फिर }:@|."1प्रत्येक पंक्ति को उलट देता है और अंतिम कॉलम को बंद करता है, और ,.इसे स्टेपल करता है ]।

फिर ,{.नीचे के पहले कॉलम को चिपकाता है।

पिछली प्रविष्टियाँ :

29 वर्ण, कोई स्थान नहीं।

   ((\:। मैं @ #),}।) "1 $ और '*' '0>: 0, ~ I.3
  *
 ***
*****
  *
   ((\:। मैं @ #),}।) "1 $ और '*' '0>: 0, ~ i.11
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
*********************
          *

   एनबी। 1 से n तक गिनें , फिर 1 से
   >: 0, ~ I.3
१ २ ३ १
   एनबी। प्रत्येक बार '*' x को दोहराएं
   $ और '*' '0>: 0, ~ I.3
*
**
***
*
   एनबी। प्रत्येक पंक्ति को उल्टा करें
   (\:। मैं @ #) "1 $ और '*' '0>: 0, ~ I.3
  *
 **
***
  *
   एनबी। प्रमुख स्तंभ बंद पट्टी
   } "1 $ और '*' '0>:। 0, ~ I.3

*
**

   एनबी। एक साथ पेस्ट करें
   ((\:। मैं @ #),}।) "1 $ और '*' '0>: 0, ~ I.3
  *
 ***
*****
  *
— ephemient
स्रोत
सिर्फ 9 और किरदारों के साथ आप इस फंक्शन को एक नाम दे सकते हैं:c=:[:((\:i.@#),}.)"1[:$&'*'"0[:>:0,~i.
— इफेमिएंट
11
क्या, आप लोग कोड को समझने-समझने के लिए किसी प्रकार के जे प्रलेखन पुस्तकालय का उपयोग करते हैं? :)
92

ब्रेनफक, 240 वर्ण

              ,
             >++
            +++++
           +[-<---
          --->],[>+
         +++++++[-<-
        ----->]<<[->+
       +++++++++<]>>]<
      [->+>+>>>>>>>+<<<
     <<<<<<]>>>>++++++++
    [-<++++>]>++++++[-<++
   +++++>]+>>>++[-<+++++>]
  <<<<<<[-[>.<-]<[-<+>>+<]<
 [->+<]>>>>>[-<.>>+<]>[-<+>]
>.<<++<<<-<->]>>>>>>>-[-<<<<<
           <.>>>
           >>>]<
           <<<<.

अभी तक नहीं किया गया। यह काम करता है, लेकिन केवल एकल-अंकों की संख्या के साथ।

संपादित करें: हो गया! EOF के रूप में 0 का उपयोग करने वाले दुभाषियों के लिए काम करता है। NOTE-1 वाले लोगों के लिए टिप्पणी स्रोत में देखें ।

EDIT फिर से: मुझे ध्यान देना चाहिए कि क्योंकि Brainfuck के पास कमांड लाइन की दलीलें पढ़ने के लिए एक मानक विधि का अभाव है, मैंने इसके बजाय स्टडिन (मानक इनपुट) का उपयोग किया। ASCII, बेशक।

तीसरी बार संपादित करें: ओह प्रिय, ऐसा लगता है .कि कोड को संघनित करते समय मैंने (आउटपुट) अक्षर छीन लिए थे। फिक्स्ड ...

यहां मुख्य लूप का बेसिक मेमोरी मैनेजमेंट है। मुझे यकीन है कि यह चरित्र गणना को 30 या उससे कम करने के लिए भारी रूप से अनुकूलित किया जा सकता है।

  1. अस्थायी
  2. प्रति की प्रति
  3. काउंटर (गिनती में 0)
  4. अंतरिक्ष चरित्र (दशमलव 32)
  5. तारांकन वर्ण (दशमलव 42)
  6. वर्तमान लाइन पर तारों की संख्या (1 + 2 * काउंटर)
  7. अस्थायी
  8. नई लाइन चरित्र
  9. अस्थाई?
  10. लाइनों की कुल संख्या (यानी इनपुट मूल्य; ट्रंक को प्रिंट करते समय बहुत अंत तक संग्रहीत)

संघनित संस्करण:

,>++++++++[-<------>],[>++++++++[-<------>]<<[->++++++++++<]>>]<[->+>+>>>>>>>+<<<<<<<<<]>>>>++++++++[-<++++>]>++++++[-<+++++++>]+>>>++[-<+++++>]<<<<<<[-[>.<-]<[-<+>>+<]<[->+<]>>>>>[-<.>>+<]>[-<+>]>.<<++<<<-<->]>>>>>>>-[-<<<<<<.>>>>>>]<<<<<.

और सुंदर संस्करण:

ASCII to number
,>
++++++++[-<------>]  = 48 ('0')

Second digit (may be NULL)
,
NOTE:   Add plus sign here if your interpreter uses negative one for EOF
[ NOTE: Then add minus sign here
 >++++++++[-<------>]
 <<[->++++++++++<]>>  Add first digit by tens
]

Duplicate number
<[->+>+>>>>>>>+<<<<<<<<<]>>

Space char
>>++++++++[-<++++>]

Asterisk char
>++++++[-<+++++++>]

Star count
+

New line char
>>>++[-<+++++>]<<<

<<<

Main loop
[
Print leading spaces
-[>.<-]

Undo delete
<[-<+>>+<]
<[->+<]
>>

Print stars
>>>[-<.>>+<]

Add stars and print new line
>[-<+>]
>.<
<++

<<<

-<->
End main loop
]

Print the trunk
>>>>>>>
-[-<<<<<<.>>>>>>]
<<<<<.

Merry Christmas =)
— jrtapsell
स्रोत
1
मेरा मस्तिष्क च ..... बीमार लगता है
3
हे भगवान।
— अनाम कायर
63

पर्ल, 50 चार्ट

(1 प्रासंगिक स्थान)

पर्ल: एक पंक्ति संस्करण:

print$"x($a-$_),'*'x($_*2+1),$/for 0..($a=pop)-1,0

और अब अधिक व्हाट्सएप के साथ:

print $"  x ( $a - $_ ),             #"# Syntax Highlight Hacking Comment
      '*' x ( $_ * 2  + 1),
      $/
for 0 .. ( $a = pop ) - 1, 0;

$ perl tree.pl 3
   *
  ***
 *****
   *
$ perl tree.pl 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *
$

गैर-पर्ल उपयोगकर्ताओं के लिए विस्तारित स्पष्टीकरण।

# print $Default_List_Seperator ( a space )  
#     repeated ( $a - $currentloopiterationvalue ) times,
print $" x ( $a - $_ ), 
#"# print '*' repeated( $currentloopiteration * 2 + 1 ) times. 
  '*' x ( $_ * 2  + 1),
# print $Default_input_record_seperator ( a newline )
  $/
# repeat the above code, in a loop, 
#   iterating values 0 to ( n - 1) , and then doing 0 again
for 0 .. ( $a = pop ) - 1, 0;
# prior to loop iteration, set n to the first item popped off the default list, 
#   which in this context is the parameters passed on the command line.
— MKV
स्रोत
25
पवित्र बकवास ... पर्ल वास्तव में अपठनीय है।
8
@zenazn, भी, यह ध्यान दिया जाना चाहिए कि अधिकांश गोल्फिंग किसी भी भाषा में बीएडी कोड है। अगर यह सबसे साफ कोड की प्रतियोगिता होती, तो हम यह भी जीत सकते थे।
— कैंट फ्रेड्रिक
5
@zenazn: सबूत, आप हमें सहयोग कर सकते हैं और एक-दूसरे के ऊपर कोड सुधारते हुए देख सकते हैं, यह साबित करता है कि हम EACH OTHERS कोड को पूरी तरह से ठीक पढ़ सकते हैं ।
— केंट फ्रेड्रिक
1
पुनश्च: गैर-पर्ल प्रोग्रामर के लिए स्पष्टीकरण के लिए धन्यवाद। यह अभी भी बहुत अपठनीय है, लेकिन कम से कम यह समझ में आता है। मुझे लगता है कि आपको थोड़ी देर बाद इसकी आदत हो जाएगी।
2
@RobH: J APL का बच्चा है। कुछ अर्थों में, यह अधिक अपठनीय है क्योंकि यह हर ऑपरेशन के लिए एक विशेष प्रतीक के साथ एपीएल के चरित्र सेट का उपयोग नहीं करता है - यह ASCII वर्णों को कई अर्थों के साथ ओवरलोड करता है, बजाय। stackoverflow.com/questions/392788/1088931#1088931
— प्रसारक
26

भाषा: अजगर (शेल के माध्यम से), चार गिनती: 64 (2 महत्वपूर्ण स्थान)

python -c "
n=w=$1
s=1
while w:
    print' '*w+'*'*s
    s+=2
    w-=1
print' '*n+'*'"

$ sh ax6 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *
— tzot
स्रोत
8
मुझे इस समाधान के बारे में सबसे ज्यादा पसंद है कि अजगर वास्तव में अस्पष्ट कोड लिखना मुश्किल बना देता है, यह सबसे पठनीय समाधानों में से एक है
आप तर्क को संसाधित करने के लिए शेल का उपयोग कर रहे हैं, जो कोड गोल्फ आईएमओ की भावना में नहीं है। "आयात sys" और "n = w = int (sys.argv [1])" और लूप बॉडी के लिए 1 वर्ण का इंडेंट का उपयोग करते हुए, मैं इस संस्करण के लिए 89 वर्णों के साथ आता हूं।
4
ऐसा मैंने पहले भी किया था। इस सवाल की भावना मज़ेदार है, और इसके अलावा केवल एक भाषा का उपयोग करने का कोई विनिर्देश नहीं था :) उदाहरण के लिए, ब्रेनफैक जवाब देखें; कोई तर्क नहीं।
26

x86 asm 16-बिट, 50 बाइट्स

अभी तक कोई विधानसभा संस्करण नहीं? :)

    bits 16
    org 100h

    mov si, 82h
    lodsb
    aaa
    mov cx, ax
    mov dx, 1
    push cx 
    mov al, 20h
    int 29h
    loop $-2
    push dx
    mov al, 2ah
    int 29h
    dec dx
    jnz $-3
    pop dx
    mov al, 0ah
    int 29h
    inc dx
    inc dx
    pop cx
    loop $-23
    shr dx, 1
    xchg cx, dx
    mov al, 20h
    int 29h
    loop $-2
    mov al, 2ah
    int 29h
    ret

(नोट: एन इस संस्करण में 1 - 9 तक सीमित है)

G:\>tree 9
         *
        ***
       *****
      *******
     *********
    ***********
   *************
  ***************
 *****************
         *

यहाँ डाउनलोड करें

— जोनास गुलाल
स्रोत
24

भाषा: विंडोज बैच स्क्रिप्ट ( चौंकाने वाला! )

@echo off
echo Enable delayed environment variable expansion with CMD.EXE /V

rem Branches
for /l %%k in (1,1,%1) do (
set /a A=%1 - %%k
set /a B=2 * %%k - 1
set AA=
for /l %%i in (1,1,!A!) do set "AA=!AA! "
set BB=
for /l %%i in (1,1,!B!) do set BB=*!BB!
echo !AA!!BB!
)

rem Trunk
set /a A=%1 - 1
set AA=
for /l %%i in (1,1,!A!) do set "AA=!AA! "
echo !AA!*
masochist! मुझे यह पसंद है
बहुत अच्छा ... आपको +1
2
विलंबित चर विस्तार को setlocal enabledelayedexpansionकमांड का उपयोग करके सक्षम किया जा सकता है ।
— हेलन
दोस्त। गंभीरता से?
यह काम नहीं कर सकता। हालांकि मैं पहली बार कोशिश करता हूं।
— फेनबाउट
21

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

n=ARGV[0].to_i
((1..n).to_a+[1]).each{|i|puts' '*(n-i)+'*'*(2*i-1)}


n=$*[0].to_i
((1..n).to_a<<1).each{|i|puts' '*(n-i)+'*'*(2*i-1)}

मेरी क्रिसमस सब!

संपादित करें: जोशुआ स्विंक द्वारा सुझाए गए सुधार

— jrtapsell
स्रोत
खतरे मैं उम्मीद कर रहा था कि किसी ने अभी तक रूबी में कोशिश नहीं की। अच्छी नौकरी।
यह रूबी की एक बहुत अच्छी लाइन है।
क्या मुझे बहुत अशिष्ट लगा? क्षमा करें, मेरा इरादा नहीं! क्रिसमस की शुभकामनाएं! :)
या तो मतलब होने का मतलब नहीं था, और निश्चित रूप से आप सही थे! क्रिसमस की शुभकामनाएं!
1
1.9 पर, आप कुछ और वर्णों को बचा सकते हैं: n=$*[0].to_i;puts [*1..n,1].map{|i|" "*(n-i)+"*"*(2*i-1)}इसे नीचे लाते हैं 58.
14

भाषा: सी #, चार गिनती: 120

static void Main(string[] a)
{
    int h = int.Parse(a[0]);

    for (int n = 1; n < h + 2; n++)
        Console.WriteLine(n <= h ?
            new String('*', n * 2 - 1).PadLeft(h + n) :
            "*".PadLeft(h + 1));
    }
}

बस कोड, बिना प्रारूपण (120 वर्ण):

int h=int.Parse(a[0]);for(int n=1;n<h+2;n++)Console.WriteLine(n<=h?new String('*',n*2-1).PadLeft(h+n):"*".PadLeft(h+1));

109 वर्णों वाला संस्करण (सिर्फ कोड):

for(int i=1,n=int.Parse(a[0]);i<n+2;i++)Console.WriteLine(new String('*',(i*2-1)%(n*2)).PadLeft((n+(i-1)%n)));

परिणाम के लिए ऊंचाई = 10:

          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *
13

भाषा: डीसी (शेल के माध्यम से) चार गिनती: 83

थोड़ा छोटा डीसी संस्करण:

dc -e '?d1rdsv[d32r[[rdPr1-d0<a]dsaxszsz]dsbx1-rd42rlbx2+r10Plv1-dsv0<c]dscxszsz32rlbx[*]p' <<<$1

EDIT: निरंतर 10 को $ 1 में बदल दिया

— हाइनेक-पीची- विचोडिल
स्रोत
11
अच्छा स्वामी, वह क्या है?
1
बस मैन पेज पढ़ें ;-)
12

अजगर, "-सी" चाल ... @ 61 वर्ण (और एक पंक्ति)

python -c"for i in range($1)+[0]:print' '*($1-i)+'*'*(2*i+1)"
वास्तव में, यह 57 वर्णों का है, केवल '' स्पेस ही प्रश्न के विनिर्देशों के अनुसार महत्वपूर्ण है।
10

107 वर्णों पर एक यथोचित स्थान-कुशल हास्केल संस्करण है:

main=interact$(\g->unlines$map(\a->replicate(g-a)' '++replicate(a*2-1)'*')$[1..g]++[1]).(read::[Char]->Int)

इसे चला रहे हैं:

$ echo 6 | runhaskell tree.hs
     *
    ***
   *****
  *******
 *********
***********
     *

मेरी क्रिसमस, सभी :)

10

भाषा: डीसी (शेल के माध्यम से), चार गणना: ११ ९ (१ महत्वपूर्ण स्थान)

बस यह अस्पष्टता के लिए :)

dc -e "$1dsnsm"'
[[ ]n]ss
[[*]n]st
[[
]n]sl
[s2s1[l2xl11-ds10<T]dsTx]sR
[lndlslRxlcdltlRxllx2+sc1-dsn0<M]sM
1sclMxlmlslRxltxllx
'

$ sh ax3 10
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *
— tzot
स्रोत
उह गंभीरता से, wtf? मुझे उस की एक भी पंक्ति समझ में नहीं आती: पी
dc एक रिवर्स-पॉलिश कैलकुलेटर है। 'man dc' जाने का स्पष्ट तरीका है :)
6

बेहतर C ++, लगभग 210 वर्ण:

#include <iostream>
using namespace std;
ostream& ChristmasTree(ostream& os, int height) {
    for (int i = 1; i <= height; ++i) {
        os << string(height-i, ' ') << string(2*i-1, '*') << endl;
    }
    os << string(height-1, ' ') << '*' << endl;
    return os;
}

179 पर न्यूनतम:

#include <iostream>
using namespace std;ostream& xmas(ostream&o,int h){for(int i=1;i<=h;++i){o<<string(h-i,' ')<<string(2*i-1,'*')<<endl;}o<<string(h-1,' ')<<'*'<<endl;return o;}
std का उपयोग कर; किसी को?
स्ट्रेजर - जब मैंने शुरू किया तो केवल एक जोड़े एसटीडी थे: '' और 'नेमस्पेस एसटीडी का उपयोग करते हुए;' बहुत पाठ था। मुझे लगता है कि अब कम पात्र होंगे।
मेरा संस्करण मेरे मुकाबले अधिक अक्षम है, क्योंकि इसमें स्ट्रिंग्स का निर्माण करना है, मेरा संस्करण केवल उन पात्रों को प्रिंट करता है जिनकी इसे आवश्यकता है। :)
— पायोन
6

भाषा: अजगर, कोई चाल, 78 वर्ण

import sys
n=int(sys.argv[1])
for i in range(n)+[0]:print' '*(n-i)+'*'*(2*i+1)
6

ग्रोवी 62B

n=args[0]as Long;[*n..1,n].any{println' '*it+'*'*(n-~n-it*2)}

_

n = args[0] as Long
[*n..1, n].any{ println ' '*it + '*'*(n - ~n - it*2) }
5

Answer के जवाब में सुधार। मैं टिप्पणी नहीं कर सकता, इसलिए यहां एक नई पोस्ट है। 72 अक्षर।

import sys
n=int(sys.argv[1])
for i in range(n)+[0]:
   print ("*"*(2*i+1)).center(2*n)

"अजगर-सी" चाल का उपयोग करते हुए, 61 वर्ण।

python -c "
for i in range($1)+[0]:
   print ('*'*(2*i+1)).center(2*$1)
"

मैंने केंद्र फ़ंक्शन सीखा और यह कि "अजगर-सी" एक से अधिक लाइन कोड स्वीकार कर सकता है। धन्यवाद, ΤΖΩΤΖΙΟΥ

5

Linq का उपयोग करके C:

    using System;
    using System.Linq;
    class Program
        {
            static void Main(string[] args)
            {
                int n = int.Parse(args[0]);
                int i=0;
                Console.Write("{0}\n{1}", string.Join("\n", 
                   new int[n].Select(r => new string('*',i * 2 + 1)
                   .PadLeft(n+i++)).ToArray()),"*".PadLeft(n));
            }
       }

170 दानदाता।

int n=int.Parse(a[0]);int i=0;Console.Write("{0}\n{1}",string.Join("\n",Enumerable.Repeat(0,n).Select(r=>new string('*',i*2+1).PadLeft(n+i++)).ToArray()),"*".PadLeft(n));
5

AWK, एक लाइन पर 86 अक्षर।

awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}'

echo "8" | awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}'
        #
       ###
      #####
     #######
    #########
   ###########
  #############
 ###############
        #

cat tree.txt
3
5

awk '{s="#";for(i=0;i<$1;i++){printf"%"$1-i"s%s\n","",s;s=s"##"}printf"%"$1"s#\n",""}' tree.txt
   #
  ###
 #####
   #
     #
    ###
   #####
  #######
 #########
     #
5

भाषा: जावा, चार गिनती: 219

class T{ /* 219 characters */
  public static void main(String[] v){
    int n=new Integer(v[0]);
    String o="";
    for(int r=1;r<=n;++r){
      for(int s=n-r;s-->0;)o+=' ';
      for(int s=1;s<2*r;++s)o+='*';
      o+="%n";}
    while(n-->1)o+=' ';
    System.out.printf(o+"*%n");}}

संदर्भ के लिए, मैं पिछली जावा समाधान को दाढ़ी बनाने में सक्षम था, पुनरावृत्ति का उपयोग करते हुए, 239 वर्णों से नीचे, 269 के पिछले न्यूनतम से। हालांकि थोड़ी देर, मैं इस समाधान को पसंद करता हूं क्योंकि Tयह वास्तव में ऑब्जेक्ट-ओरिएंटेड है। आप बेतरतीब आकार के Tउदाहरणों का एक छोटा जंगल बना सकते हैं । यहाँ उस सौदे पर नवीनतम विकास है:

class T{ /* 231 characters */
  public static void main(String[] v){new T(new Integer(v[0]));}}
  String o="";
  T(int n){
    for(int r=1;r<=n;++r){
      x(' ',n-r);x('*',2*r-1);o+="%n";}
    x(' ',n-1);
    System.out.printf(o+"*%n");
  }
  void x(char c,int x){if(x>0){o+=c;x(c,x-1);}
 }
— joel.neely
स्रोत
आपकी नई वर्ण गणना 251 (1 प्रासंगिक स्थान) है
"सार्वजनिक स्थैतिक शून्य मुख्य" से छुटकारा पाएं, एक स्थिर ब्लॉक का उपयोग करें और जावा 6 के साथ संकलित करें;)
— फेबिनआउट
मुझे पता है कि यह लगभग 9 साल (lol ..) है, लेकिन आप कुछ चीजों को गोल्फ कर सकते हैं: class T{public static void main(String[]v){long n=new Long(v[0]),r=1,s;String o="";for(;r<=n;r++){for(s=n-r;s-->0;)o+=' ';for(;++s<2*r;)o+='*';o+="\n";}while(n-->1)o+=' ';System.out.println(o+"*");}}(199 अक्षर / बाइट्स)
— केविन क्रूज़सेन 25'17
5

भाषा: पावरशेल, चार गणना: 41 (1 स्थान सहित)

1..$args[0]+1|%{" "*(30-$_)+"*"*($_*2-1)}
— Jaykul
स्रोत
5

21 अक्षर dyalog APL के साथ।

m,⍨⌽0 1↓m←↑'*'\¨⍨1,⍨⍳

। 1 से शुरू होने वाले पूर्णांक का एक वेक्टर देता है।

1, ⍨ वेक्टर के अंत में एक जोड़ता है। यह पेड़ का पैर होगा।

'*' '\ _ पिछले वेक्टर द्वारा दी गई लंबाई के साथ * -स्ट्रिंग्स का सदिश देता है।

Vector वेक्टर को मैट्रिक्स में बदल देता है और दाईं ओर रिक्त स्थान जोड़ देता है।

मी matrix मी में मैट्रिक्स को स्टोर करता है।

0 1 ↓ शून्य पंक्तियों और पहले स्तंभ को छोड़ देता है।

The मैट्रिक्स को उलट देता है।

मी, दाईं ओर m के साथ at संघनित होती है।

— user10639
स्रोत
m,⍨⌽0 1↓m←->(⌽,0 1↓⊢)
— ngn
4

भाषा: सी, चार गिनती: 133

सी-वर्जन का सुधार। 

char s[61];

l(a,b){printf("% *.*s\n",a,b,s);}

main(int i,char**a){
  int n=atoi(a[1]);memset(s,42,61);
  for(i=0;i<n;i++)l(i+n,i*2+1);l(n,1);
}

काम करता है और यहां तक ​​कि एक तर्क के रूप में पेड़ की ऊंचाई लेता है। एक कंपाइलर की जरूरत है जो K & R-style कोड को सहन करे।

मुझे अब बहुत गंदा लग रहा है .. यह कोड बदसूरत है।

जावा में मेरी पहली कटौती के रूप में यह एक ही समस्या है; यह कमांड-लाइन तर्क के उपयोग के साथ एक पूर्ण कार्यक्रम नहीं है!
ओह? क्या यह आवश्यक है? कोई दिक्कत नहीं है। मैं ठीक कर दूँगा।
यह 138 अक्षर हैं जब सभी अनावश्यक नए समाचार हटा दिए जाते हैं।
— Güder बर्क सकते हैं
मैं 133 गिनती करता हूं (बस सभी
4

आर (62 बाइट्स)

मैंने अभी तक आर समाधान नहीं देखा। अगर मैं चूक गया तो मुझे सुधारो।

for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")

आउटपुट:

> N <- 3
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
  *
 ***
*****
  *
> 
> N <- 4
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
   *
  ***
 *****
*******
   *
> 
> N <- 5
> for(i in c(1:N,1))cat(rep(" ",N-i),rep("*",2*i-1),"\n",sep="")
    *
   ***
  *****
 *******
*********
    *
— djhurio
स्रोत
3

भाषा: सी, चार गिनती: 176 (2 प्रासंगिक स्थान)

#include <stdio.h>
#define P(x,y,z) for(x=0;x++<y-1;)printf(z);
main(int c,char **v){int i,j,n=atoi(v[1]);for(i=0;i<n;i++){P(j,n-i," ")P(j,2*i+2,"*")printf("\n");}P(i,n," ")printf("*\n");}
— कैन बर्क गडर
स्रोत
3

भाषा: अजगर, महत्वपूर्ण चार गिनती: 90

यह बदसूरत है, लेकिन यह काम करता है:

import sys
n=int(sys.argv[1])
print"\n".join(" "*(n-r-1)+"*"*(r*2+1)for r in range(n)+[0])

...

$ python tree.py 13
            *
           ***
          *****
         *******
        *********
       ***********
      *************
     ***************
    *****************
   *******************
  *********************
 ***********************
*************************
            *
आपकी वर्ण गणना 98 (2 महत्वपूर्ण स्थान, उद्धरणों में) है
3

चूंकि यह एक सीडब्ल्यू है: मुझे यह पसंद नहीं है कि कोड गोल्फ को हमेशा "वर्णों की संख्या" या सोमेसुच के रूप में व्यवस्थित किया जाता है। संकलक / दुभाषिया (या कुछ इसी तरह की कसौटी) के लिए निर्देशों की संख्या के संदर्भ में उन्हें व्यवस्थित नहीं किया जा सकता है? यहाँ रूबी समाधान फिर से है , और यह मूल रूप से एक ही है, लेकिन अब मानव उपभोग के लिए भी है:

SPACE = " "
ASTERISK = "*"
height_of_tree=ARGV[0].to_i
tree_lines = (1..height_of_tree).to_a
tree_lines.push 1 # trunk
tree_lines.each do | line |
   spaces_before = SPACE*(height_of_tree-line)
   asterisks = ASTERISK*(2*line-1) 
   puts spaces_before + asterisks
end
— समुदाय
स्रोत
मैं पहले बयान से सहमत हूं। ऐसे शब्दों में, पर्ल जैसी भाषाओं का शुरुआती लाभ है। स्टेटमेट्स की संख्या या पसंद की तरह कुछ होना चाहिए।
धन्यवाद ... मैंने कल गोल्फ के बारे में एक सवाल पूछा और ऐसा करने का तरीका "टोकन" के साथ हो सकता है ... इस तरह से नाम-लंबाई और आगे दंडित नहीं किया गया है।
2

PHP, 111 chars

(बहुत अंतिम चार्ट एक नई पंक्ति होनी चाहिए।)

<?php $n=$argv[1];for($r='str_repeat';$i<$n;$i++)echo $r(' ',$n-$i).$r('*',$i*2+1)."\n";echo $r(' ',$n).'*' ?>

पठनीय संस्करण:

<?php

$n = $argv[1];

for ($r = 'str_repeat'; $i < $n; $i++)
    echo $r(' ', $n - $i) . $r('*' , $i * 2 + 1) . "\n";

echo $r(' ', $n) . '*'

?>
आप स्ट्रिंग का निर्माण करके, फिर उसे प्रतिध्वनित करके कई पात्रों को बचा सकते हैं। मुझे लगता है। कोशिश है कि बाहर।
अच्छा विचार है, लेकिन मैंने इसकी कोशिश की और यह केवल इसे लंबा बनाता है। '$ t। = (...)' 'इको (...)' की तुलना में केवल एक चार छोटा है, और फिर आपको अंत में 'इको $ t' भी करना होगा।
'$ I = 0;' को हटाकर इसे 4 वर्णों से छोटा कर दिया। कथन का पहला भाग। PHP मानती है कि पूर्णांक संदर्भ में प्रयुक्त कोई भी भिन्न चर 0 पहले से ही नहीं हैं! : पी
के लिए अंदर $ r = .. लगाकर एक चरखी को बचाया। इसके अलावा, मैं कहता हूं कि न्यूलाइन वर्ण एक बाइट होना चाहिए, दो नहीं। =]
हाँ, मुझे एहसास हुआ कि मैं अपने पाठ संपादक में कॉलम संख्या का उपयोग करके गिना क्योंकि मैं एक से दुखी था। मैं linux का उपयोग करता हूँ इसलिए newline char एक बाइट है।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.