พิมพ์ต้นคริสต์มาส


26

ความท้าทาย

พิมพ์ต้นคริสต์มาสที่ดีด้วยดาวของตัวเองที่ด้านบนโดยใช้รหัสที่สั้นที่สุด ต้นไม้ดาวเป็นเครื่องหมายดอกจัน ( *) และต้นไม้ทำจาก0ต้นไม้จะต้องมีความสูง 10 แถว ทุกแถวควรมีการย่อหน้าที่ถูกต้องในลักษณะที่แถวก่อนหน้าอยู่กึ่งกลางแถวถัดไป แถวใด ๆ ที่ระบุจะต้องมี 0 0 วินาทีมากกว่าแถวก่อนหน้ายกเว้นแถวแรกนั่นคือดาวฤกษ์และแถวที่สองซึ่งมีเพียง 0 เดียวผลลัพธ์ที่ได้จะเป็นเช่นนี้:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Tie breakสำหรับต้นไม้สูงปรับขนาดได้โดยไม่มีการเปลี่ยนแปลงซอฟต์แวร์ (ยกเว้นการเปลี่ยนพารามิเตอร์ความสูง)

กรุณาวางต้นไม้ผลลัพธ์ของรหัสของคุณด้วย!


ลีดเดอร์บอร์ด


3
ไม่ซ้ำกันอย่างแน่นอน แต่มีสิ่งนี้ใน SO: Code Golf Christmas Edition: วิธีการพิมพ์ต้นคริสต์มาสสูง N
Hasturkun

คำตอบ:


17

Golfscript, 27 ตัวอักษร

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

ต้นไม้ที่เกิดขึ้นมีลักษณะเช่นนี้:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

เวอร์ชันที่ใช้พารามิเตอร์ height เพียงครั้งเดียวจะยาวกว่าหนึ่งอักขระ

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

การอ่านความสูงจาก stdin (ด้วยอินพุต "10" เพื่อสร้างแผนผังตัวอย่าง) ใช้จำนวนอักขระเท่ากัน (28):

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

56

ฉันรู้ว่านี้ไม่สอดคล้องกับข้อมูลจำเพาะ แต่ฉันคิดว่าฉันพยายามที่จะเพิ่มความหลากหลายบางอย่างเพื่อให้ต้นไม้ที่นี่โดยการเลียนแบบศิลปะ ASCII คลาสสิกนี้ฉากคริสมาสต์โดยโจแอนนาจีสตาร์

ฉันไม่ได้พยายามที่จะทำซ้ำภาพทั้งหมด - ที่จะได้รับมากเกินไป - แต่เพียงแค่ต้นไม้ที่ฉันนำเสนอโปรแกรม 138- ไบต์ Perl นี้:

$_=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|/

ลองออนไลน์!

รหัสใช้คุณสมบัติ Perl 5.10+ sayและจำเป็นต้องเรียกใช้ด้วยสวิตช์บรรทัดคำสั่ง-M5.010(หรือ-E) (อันที่จริงเพียงแค่แทนที่sayตอนท้ายด้วยprintจะหลีกเลี่ยงที่ค่าใช้จ่ายของอีกสองไบต์และการสูญเสียของบรรทัดใหม่หลังจากบรรทัดสุดท้ายของการส่งออก)

โปรดทราบว่ากลุ่มของต้นไม้ถูกสร้างแบบสุ่มดังนั้นตำแหน่งของเครื่องประดับจะแตกต่างกันระหว่างการวิ่ง แม้ว่าทูตสวรรค์ที่ยืนและแถวบนของต้นไม้ได้รับการแก้ไข


เพื่อป้องกันไม่ให้คำตอบที่ได้รับความนิยมนี้ถูกสรุปอย่างย่อภายใต้นโยบายที่กำหนดหลังจากโพสต์แล้วนี่เป็นวิธีแก้ปัญหาที่ตรงตามข้อกำหนดของโทเค็นเช่นกัน (45 ไบต์และ Perl 5):

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

ลองออนไลน์!

เช่นเดียวกับโปรแกรมข้างต้นสิ่งนี้ยังต้องทำงานบน Perl 5.10+ พร้อม-M5.010สวิตช์เพื่อเปิดใช้งานsayคุณลักษณะ เห็นได้ชัดว่า (นี่เป็นท้าทายที่ ) มันให้ผลลัพธ์ที่น่าเบื่อเช่นเดียวกันกับรายการที่สอดคล้องอื่น ๆ ทั้งหมดซึ่งฉันจะไม่สนใจที่จะทำซ้ำที่นี่ (นอกจากนี้ยังปรับขนาดได้เล็กน้อยโดยการเปลี่ยนจำนวน10เป็นค่าอื่น ๆ )


1
ที่ดี! ไม่ใช่ตามสเป็ค แต่ฉันคิดว่าผู้ตัดสินรางวัลพิเศษสำหรับคุณ :)
เฉลี่ย

6
นี่เป็นการแสดงให้เห็นว่าภาษิตของ specs อยู่ข้างหลัง +2 ถ้าทำได้
กริช

3
ขออภัยตามกฎแล้วคำตอบที่ไม่เป็นไปตามข้อกำหนดจะต้องถูกลบออก
mbomb007

ฉันกำลังจะลบโพสต์นี้ในการปฏิบัติตามนโยบายของเราเกี่ยวกับคำตอบที่ไม่ตรงตามสเปคที่ท้าทาย
เดนนิส

1
คุณช่วยย้ายคำตอบที่ถูกต้องไปที่ด้านบนและเพิ่มหัวข้อได้ไหม?
เดนนิส

13

GolfScript (33 ตัวอักษร)

รุ่นความสูงคงที่:

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

หรือสำหรับความยาวเท่ากัน

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

ต้นไม้ดูคล้ายกับคนอื่น ๆ อย่างน่าทึ่ง:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

เวอร์ชันที่ใช้ความสูงจาก stdin:

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

การเริ่มต้นของบรรทัดก่อนหน้าเป็นหนึ่งในรอยยิ้มที่ดีกว่าที่ฉันเคยทำในโปรแกรม GolfScript "มีประโยชน์"


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 ตัวอักษร

แรงบันดาลใจจากรายการ Mathematica ของ Mr.Wizardฉันขอนำเสนอคำสั่ง Maple 12 แบบ 30 ถ่านนี้:

<`*`,('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;

ละเว้นการส่งออก - ดูเหมือนว่าด้านบนโดยไม่มีเครื่องหมายวงเล็บเท่านั้น น่าเสียดายที่ฉันไม่รู้วิธีที่จะป้องกันไม่ให้ Maple แทรกบรรทัดว่างระหว่างแถวผลลัพธ์ในโหมดข้อความ มันดูดีขึ้นในโหมดแผ่นงานคลาสสิก ฉันเดาว่าฉันสามารถใส่ภาพหน้าจอ ...

screenshot

(ภาพหน้าจอแสดงคำสั่งเวอร์ชัน 44 char ก่อนหน้านี้ แต่ฉันขี้เกียจเกินกว่าที่จะลองใหม่อีกครั้งเอาต์พุตยังคงเหมือนเดิม)

โอ้และใช่ขนาดนั้นปรับได้เต็มที่: เพียงแทนที่ 8 ด้วยn -2 สำหรับต้นn -row ด้วยวิธีแก้ปัญหาแรกการข้ามไป 25 แถว (หรือ 10 ใน GUI) ต้องมีการตั้งค่าอินเทอร์เฟซ (rtablesize = n ) ด้วย

(สดุดีฉันคิดว่าฉันสามารถเอาชนะ GolfScriptด้วยเวอร์ชันล่าสุดได้แต่ทว่า ... )


8

Perl, 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 แถว: P การเปลี่ยนแปลงเล็กน้อยฉันเดา
Averroes

@Averroes: ใช่ก่อนอื่นฉันคิดว่ามันควรจะเป็น 10 แถวบวกกับดาว แต่จริงๆแล้วฉันนับจำนวนแถวในผลลัพธ์ตัวอย่างและแก้ไขมัน
Ilmari Karonen

8

Groovy, 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 แถวด้วย!
เฉลี่ย

ฉันสามารถแก้ไขได้โดยปรับพารามิเตอร์ height!
อาร์มันด์

8

Ruby, 46 ตัวอักษร

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

ในการเปลี่ยนความสูงคุณจะต้องเปลี่ยนทั้ง 8 และแน่นอนด้วย 9 ผลลัพธ์ของโปรแกรมมีดังนี้:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

แก้ไข : อภัยฉันละเว้นผลลัพธ์ในการส่งครั้งแรก


1
คุณลืมโพสต์เอาท์พุท :)
Ilmari Karonen

7

PowerShell, 41

" "*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

Python 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

โปรดทราบว่านี่เป็นคำตอบที่เต้นได้ถึง @ Ante 11 ตัวอักษรเพราะคำตอบนั้นเมื่อแปลงเป็น Python 3 ใช้ 73 ตัวอักษร

เปลี่ยน9เป็นค่าอื่นสำหรับความสูงที่แตกต่างกัน


3
forฉันคิดว่าคุณยังสามารถสูญเสียพื้นที่ก่อน
badp

@badp Thanks— เปลี่ยนจาก 63 เป็น 62!
Kazark

6

Python 59

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

การทำงานที่ดี - นี่แสดงให้เห็นว่าถึงแม้ว่าคำตอบของ @Ante จะยาวขึ้นใน Python 3 แต่คำตอบของ Python 3 ของฉันนั้นสั้นกว่าใน Python 2 ( printไม่ใช่ฟังก์ชั่น)
Kazark

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.

อาจถูกบีบอัดเพิ่มเติมสำหรับล่ามบางตัว (เช่นใช้แท็บ / 1 บน SWI)

เรียกใช้ด้วย x (N) โดยที่ N คือจำนวนแถวในต้นไม้จริง (ไม่รวมดาว) การให้ความสูงคงที่จะทำให้มันลดลงเหลือ 183


6

C

นี่คือรุ่น C ของ Wade Tandy แต่ได้ปรับเปลี่ยนเล็กน้อย:

           ;
          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

Applesoft BASIC 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

ฉันใช้ JavaScript Applesoft BASIC อยู่ที่นี่: 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

PostScript (ที่มีพารามิเตอร์ความสูง), 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

JavaScript (แรด: 108, โหนด: 114, คอนโซล Webkit Dev: 119, ปลั๊กอิน jQuery: 132)


แรดสั้นที่สุด (ที่ 108 ตัวอักษร) เพราะ (a) printฟังก์ชั่นของมันมีชื่อสั้น ๆ และ (b) มันจะช่วยให้คุณกำหนดฟังก์ชั่นในตัวให้เป็นชื่อตัวแปรที่สั้นกว่า ดังนั้น:

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มาในconsole.logไม่กี่วินาที (ที่ 114 chars) เพราะฟังก์ชั่นการพิมพ์มีชื่อที่ยาวกว่า แต่มันจะให้เรากำหนดให้ตัวแปรสั้นเช่นกัน:

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 ด้วย) คิดว่า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)

แน่นอนว่าไม่จำเป็นต้องเป็นปลั๊กอิน ... เนื่องจากเราอาจต้องใช้คอนโซล JavaScript เพื่อเพิ่มลงในหน้าและเรียกใช้เราจึงอาจทำตัวอย่างของ 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 ตัวอักษร - ในความเป็นจริงมันเต้นออกจากการใช้งานคอนโซล dev อื่น ๆ แต่จากนั้นอีกครั้งการใช้ jQuery และ / หรือเครื่องมือเค้าโครงของเบราว์เซอร์อาจถือว่าเป็นการโกง :)


4

C, 67

ฉันรู้ว่านี่นานเกินไป แต่มันเป็นความพยายามครั้งแรกของฉันที่การตีกอล์ฟและฉันคิดว่าฉันมีวิธีแก้ปัญหา C ที่ดีงาม

น่าสนใจฉันคิดวิธีแก้ปัญหาที่คล้ายกันนี้ของ @ Patrick โดยอิสระ

และใช่ฉันจะไม่ชนะความผูกพันใด ๆ กับค่า hardcoded ของฉัน;) ฉันยินดีเป็นอย่างยิ่ง

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 ตัวจาก "echo"
Brombomb

ฉันรู้ว่าฉันมา 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

Python 70 ตัวอักษร

ไม่สั้นนัก แต่มีวิธีแก้ปัญหาซ้ำ :-)

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

เปลี่ยน 8 เพื่อตั้งความสูง


4

Javascript, 119 ตัวอักษร

ส่งออกไปยังคอนโซล firebug

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 ตัวอักษรจริง
Rob Fox

3

PHP 113

คิดว่าฉันจะพูดสอดกับ php version:

113 chars (ปรับ$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

ฮาร์ดโค้ด litlle เพิ่มอีกเล็กน้อย 103 ตัวอักษร (คุณไม่เห็นช่องว่างในเสียงสะท้อนแรกในความคิดเห็นนี้) $ n = 0; echo "* \ n"; สำหรับ ($ i = 9; $ i> 0; $ i -, พิมพ์ str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
ลูเซีย

บรรทัดแรกของ hardcoded ของคุณจะไม่สมดุลถ้าคุณเปลี่ยนความสูงของต้นไม้ tho :-(
Kris

3

C, 77

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

ก่อนที่จะอ่านข้อมูลจำเพาะของ printf อย่างละเอียดยิ่งขึ้นฉันมีเลขตัวน้อยน่ารักนี้ลงไปที่ 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

Java, 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)

(นี่เป็นโซลูชัน Java C ของ Wade Tandy's รุ่น C)


ฉันรู้ว่ามันถูกโพสต์เมื่อไม่นานมานี้ :) แต่นี่คือสองสิ่งที่ฉันเห็น: 1. คุณสามารถใช้อินเทอร์เฟซแทนคลาสใน java 8 2. เพื่อบันทึกอักขระสองตัวwhile (++i < c) {-> for (s += "*";++i < c;s = "") {และลบs += "*";และs = "";
Reinis Mazeiks

3

เป็นกลุ่ม, 18 ไบต์

17i0<esc>qqYPxr q8@qa*

ลองออนไลน์ในล่าม V ที่ใช้งานร่วมกับรุ่นหลังได้!

แม้ว่านี่จะเป็นวิธีที่คล้ายกันมากกับคำตอบ V ของฉัน แต่วิธีนี้ไม่ใช่เป็นการแข่งขันเนื่องจากเสียงเรียกเข้านั้นเก่ามาก :)

คำอธิบาย:

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

C, 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 กับความสูงของต้นไม้ i ถึง k-1 F คือการตั้งค่าสถานะบรรทัดแรก ไม่มีข้อโต้แย้งดังนั้น F ควรเป็น 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));}
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.