Bir Noel Ağacı Yazdır


26

Meydan okuma

Mümkün olan en kısa kodu kullanarak tepesinde kendi yıldızı olan güzel bir Noel ağacı yazdırın. Ağaç yıldızı bir yıldızdır ( *) ve ağaç gövdesi ağaçtan yapılır 0. 10 satır yüksekliğinde olmalıdır. Her satır, önceki satırın bir sonraki satırın ortası olacak şekilde girintili olmalıdır. Herhangi bir satırın, birincisi ve yalnızca bir 0'ı olan, birincisi ve birincisi hariç, öncekinden 2 tane daha 0 olması gerekir. Sonuç şunun gibi:

          *
          0
         000
        00000
       0000000
      000000000
     00000000000
    0000000000000
   000000000000000
  00000000000000000

Yazılım değişikliği olmadan yeniden boyutlandırılabilir yükseklik ağaçları için bağlantı kopması (yükseklik parametresinin değiştirilmesi hariç)

Lütfen kodunuzun sonuç ağacını da yapıştırın!


Liderler Sıralaması


Yanıtlar:


17

Golf Betiği, 27 karakter

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

Ortaya çıkan ağaç şöyle görünür:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Height parametresini yalnızca bir kez kullanan sürüm bir karakterden daha uzun:

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

Stdin'den yüksekliği okumak (örnek ağacı oluşturmak için "10" girişiyle) aynı miktarda karakteri alır (28):

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

56

Bunun teknik özelliklere uymadığını biliyorum, ancak bu klasik ASCII sanat Noel sahnesini Joan G. Stark'ı taklit ederek buradaki ağaçlara çeşitlilik katmaya çalışacağımı düşündüm .

Resmin tamamını yeniden üretmeyi denemedim - bu biraz fazla olurdu - ama sadece 138 baytlık Perl programını sunduğum ağaç:

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

Ve elbette, işte çıktının bir örneği:

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

Çevrimiçi deneyin!

Kod, Perl 5.10+ sayözelliğini kullanır ve bu nedenle -M5.010(veya -E) komut satırı anahtarıyla çalıştırılması gerekir . (Aslında, sadece saysonunu değiştirmek, printiki bayt pahasına ve son satırdan sonra yeni satırın kaybolmasından kaçınır.)

Ağacın kütlesinin rastgele üretildiğine dikkat edin, bu nedenle süslerin yerleştirilmesi koşuların arasında değişecektir. Yine de melek, stand ve ağacın üst sırası sabittir.


Bu popüler cevabın , yayınlandıktan sonra kurulan bir politika çerçevesinde özetlenerek silinmesini engellemek için , işte belirteci özellikli bir çözüm de (45 bayt, ayrıca Perl 5):

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

Çevrimiçi deneyin!

Yukarıdaki program gibi, bunun da özelliği -M5.010etkinleştirmek için anahtarla Perl 5.10+ üzerinde çalıştırılması gerekir say. Açıkçası (bu bir mücadelesidir), burada tekrarlamaktan zahmet etmeyeceğim diğer tüm uyumlu girdilerle aynı sıkıcı çıktıyı verir. (Numarayı 10başka bir değere değiştirerek de büyük ölçüde yeniden boyutlandırılabilir .)


1
Harika! Spec tarafından değil ama hakimlerin özel ödülünün sizin için olduğunu düşünüyorum! :)
Averroes,

6
bu, teknik özelliklerin atasözünü, mümkünse +2'yi vurur.
Kris,

3
Üzgünüz, ancak kurallara göre, şartnameye uymayan cevapların silinmesi gerekiyor.
mbomb007


1
Lütfen geçerli cevabı en üstüne götürüp bir başlık ekler misiniz?
Dennis,

13

GolfScript (33 karakter)

Sabit yükseklikli versiyon:

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

Veya tam olarak aynı uzunluk için

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

Ağaç herkesinkine oldukça benziyor:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Stdin'den yükseklik alan versiyon:

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

Önceki satırın başlangıcı, "kullanışlı" bir GolfScript programında yaptığım en iyi ifadelerden biri.


10

Kabuk betiği, 44 karakter

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

Bu ağacı yazdırır:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

9

Akçaağaç, 30/37 karakter

Sihirbazın Mathematica girişinden esinlenerek , bu 30 karakterlik Maple 12 komutunu sunuyorum:

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

Çıktı:

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

Ayrıca, 7 karakter daha paraya ek olarak parantezlerden kurtulabiliyorum:

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

Çıktı atlandı - sadece parantez olmadan yukarıdakine benziyor. Ne yazık ki, Maple’yı metin satırlarında çıktı satırlarının arasına boş satırlar eklemekten alıkoymanın bir yolunu bilmiyorum. Klasik çalışma sayfası modunda daha iyi görünüyor. Sanırım bir ekran görüntüsü ekleyebilirim ...

screenshot

(Ekran görüntüsü komutun daha eski bir 44-char versiyonunu gösterir, ancak onu tekrar almak için çok tembelim. Çıktı hala aynı.)

Oh ve evet, boyut tamamen ayarlanabilir: Sadece ile 8 yerine n -2 bir için n -row ağacın. İlk çözümde, 25 sıradan (veya GUI'den 10'a ) geçmek aynı zamanda ayar ara yüzünü de gerektirir (rtablesize = n ).

(Ps. GolfScript'i en son sürümle yenmeyi başardığımı sanıyordum , ama ne yazık ki ... )


8

Perl, 42 karakter

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

Çıktı:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000

Ağacın yüksekliği değiştirilerek 1 ve 11 sıraları arasında değiştirilebilir 8değerlerle sonunda -1için 9. 11 satırın üstüne çıkmak 9, ekranın sol tarafından ağacın girintisinin ne kadar uzağında olduğunu kontrol eden koddaki iki saniyenin de artırılmasını gerektirir .


Bu 11 satır var: P Sanırım Küçük değişiklikler
Averroes

@Averroes: Evet, ilk önce 10 satır artı yıldız olması gerektiğini varsaydım , ancak daha sonra aslında örnek çıktındaki satırları saydım ve düzelttim.
Ilmari Karonen

8

Groovy, 65

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

Şaşırtıcı bir şekilde, ağaç şöyle görünür:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

'Ağaç çıktısı sonrası' bölümü, bu siteye biraz Noel ruhu getirmek içindir: P
Averroes

Ayrıca, sizinki de 11 satır var!
Averroes

Yükseklik parametrelerini ayarlayarak bunu düzeltebilirim!
Armand

8

Yakut, 46 karakter

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

Yüksekliği değiştirmek için hem 8'i, hem de tabii ki 9'u değiştirmek zorunda kalacaksınız. Programın çıktısı aşağıdaki gibidir:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Düzenleme : Müsaade edilemez bir şekilde ilk başvurudaki çıktıyı atladım.


1
Çıktıyı göndermeyi unuttun. :)
Ilmari Karonen

7

PowerShell, 41

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

Şaşırtıcı olmayan bir şekilde, diğerleriyle aynı ağacı çıkarır :-p

Bu 8'i parametreleştirirseniz, konsolunuzun boyutuna, yani 48 karaktere kadar :

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

Veya, bir argüman alır tam gelişmiş bir komut dosyası olarak, 53 karakter :

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

Denilen gibi görünüyor:

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

7

Python 3: 62 karakter

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

Çıktı:

        * 
        0 
       000 
      00000 
     0000000 
    000000000 
   00000000000 
  0000000000000 
 000000000000000
00000000000000000

Bunun esas olarak @ Ante'nin cevabını 11 karakter attığını unutmayın, çünkü bu cevap Python 3'e dönüştürüldüğünde 73 karakter kullanır.

9Farklı bir yükseklik için her birini başka bir değerle değiştirin .


3
Bence daha önce bu alanı da kaybedebilirsin for.
badp

@ badp Teşekkürler - 63'ten 62'ye değiştirildi!
Kazark

6

Python, 59

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

İyi iş — bu, @Ante'nin Python 3'te cevapları uzadığı halde Python 3 cevabımın Python 2'de daha kısa olduğunu gösteriyor ( printbir işlev değil).
Kazark

6

Prolog: 183 veya 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).

Baskılar:

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

Bazı tercümanlar için daha fazla sıkılabilir (örneğin, SWI'da sekme / 1 kullanarak).

X (N) ile çağır. Burada N, gerçek ağaçtaki satır sayısıdır (yıldız hariç). Sabit bir yükseklik verilmesi onu 183'e indirir.


6

C

Bu Wade Tandy'nin C versiyonu, ancak biraz değiştirildi:

           ;
          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

Mathematica, 50

MatrixForm@Prepend[Row/@Table[0,{n,9},{2n-1}],"*"]

5

Applesoft BASIC, 143 karakter

Bu soru bana, lisede geri aldığım ev ödevini hatırlattığından (bir Apple // e öğretirken):

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

Burada bulunan JavaScript Applesoft BASIC'i kullandım: http://www.calormen.com/applesoft/

ÇIKTI:

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

5

Prolog: 127 karakter

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));!.

Çıktı:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000
true 

Kullanılan Prologben yenmek mümkün değildi çünkü Groovyonun kod :( bakmadan rekoru.


5

PostScript (parametreli yükseklik), 114 karakter

/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

Çıktı:

         *
         0
        000
       00000
      0000000
     000000000
    00000000000
   0000000000000
  000000000000000
 00000000000000000
0000000000000000000

Çıkmak mı istedin?


4

JavaScript (Rhino: 108, Düğüm: 114, Webkit Dev Konsol: 119, jQuery Eklentisi: 132)


Rhino en kısa olandır (108 karakter) çünkü (a) printişlevi kısa bir isme sahiptir ve (b) yerleşik işlevleri daha kısa bir değişken ismine atamanıza izin verir. Yani:

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 kısa bir saniyede (114 karakterde) geliyor çünkü yazdırma işlevi console.logdaha uzun bir isme sahip, ancak bunu kısa bir değişkene de atamamıza izin verecek:

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);}


Ancak, Webkit Dev Konsolu'nun (ve muhtemelen Firebug'un da) p=console.logbiraz fazla sinsi olduğunu düşünüyor (aramaya çalıştığınızda p()sizi şikayet edecek). Bu yüzden, işleri 119 karaktere kadar uzatmamız gerekiyor:

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);}}

(İlginçtir, withbize sadece bir karakter kazandırır).


Sonunda ... bir jQuery eklentisi (hala 132 karakterde gözle görülür!):

$.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/>'));}

Ve bu sayfanın alt kısmında onu çağırabilirsiniz: $('#footer').xms(3)

Tabii ki, bir eklenti olmak zorunda değil ... muhtemelen bir sayfaya eklemek ve onu çağırmak için bir JavaScript konsolu kullanmamız gerekeceğinden, sadece bir jQuery pasajı yapabilirdik :

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

daha rekabetçi bir 116 karaktere sahip olan - aslında, diğer dev konsol uygulamasını yener. Ancak, daha sonra, jQuery ve / veya tarayıcının düzen motorunun kullanılması hile olarak kabul edilebilir. :)


4

C, 67

Bunun çoktan bittiğini biliyorum, ama kod golfe ilk girişim ve sanırım oldukça hoş bir C çözümüm var.

İlginçtir ki, @ Patrick'in çok benzer bir çözümünden bağımsız olarak bununla karşılaştım.

Ve evet, kodlanmış değerlerimle hiçbir bağ kazanmayacağım;) Yine de çok memnunum.

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
Devam etmek için herhangi bir tuşa basın . . .

4

torpil

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

LOLCODE, 527 bayt

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

Çevrimiçi deneyin!

Çıktı:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

1
Bu kod-golf , bu nedenle lütfen gönderinizin bayt sayısını başlığa ekleyin.
lirtosiast

4

Python, 70 karakter

Çok kısa değil, ama özyinelemeli çözüm :-)

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

Yüksekliği ayarlamak için 8'i değiştirin.


4

Javascript, 119 karakter

Firebug konsoluna çıkışlar

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
Bu aslında 120 karakterdir.
Rob Fox,

3

PHP 113

Bir php versiyonu ile chime olacağını düşündüm:

113 karakter ( $hyüksekliği değiştirmek için ayarlayın , satır sayısı yıldızı içerir):

$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";}

Kısa kılmaya çalıştım, okunabilir değil ve zaten php'in özle rekabet edemeyeceğini biliyorduk, bu yüzden bu bir şey kazanmayacak, yine de eğlenceli küçük bir bulmaca tho.

çıktı spec:

        *
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Bir litl bit daha fazla kodlama, 103 karakter, (bu yorumun içindeki ilk yankıdaki boşlukları göremezsiniz) $ n = 0; echo "* \ n"; için ($ i = 9; $ i> 0; $ i -, baskı str_repeat ('', $ i) .str_repeat ('0', $ n + 9- $ i). "\ n", $ n ++);
Lucia

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 spec daha dikkatli bir şekilde okumadan önce, 138 karaktere kadar bu sevimli küçük sayıya sahiptim:

#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, param ile)

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="";}}}

İstenen ağacı yazdırır:

        *           
        0
       000
      00000
     0000000
    000000000
   00000000000
  0000000000000
 000000000000000
00000000000000000

Değişken yükseklik için, biraz daha uzun:

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="";}}}

Komut satırı bağımsız değişken listesinin uzunluğu yüksekliği belirler (örneğin java W a a a a a, yükseklik 5 verir).

(Bu temelde Wade Tandy'nin C çözümünün Java sürümüdür.)


Ben :) bu bir süre önce gönderilmiş biliyorum ama burada gördüğüm iki şey vardır: 1. Eğer java 8'de yerine bir sınıfın bir arayüz kullanabilirsiniz iki karakter kaydetmek için 2. while (++i < c) {-> for (s += "*";++i < c;s = "") {ve kaldırmak s += "*";ves = "";
Reinis Mazeiks

3

Vim, 18 bayt

17i0<esc>qqYPxr q8@qa*

Geriye doğru uyumlu V tercümanında çevrimiçi olarak deneyin !

Bu benim V cevabımla çok benzer bir yaklaşım olsa da, vim çılgın yaşlı olduğu için bu yarışmacı değil . :)

Açıklama:

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

Scala, 74 bayt

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

h - ağacın yüksekliği

Çıktı

        *          
        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'yi ağaç yüksekliğine, i'den k-1'e sıfırlayın. F ilk satır bayrağıdır. Herhangi bir argüman verilmediğinde, F girişe 1 girmelidir.

F ilk satır bayrağı olmayan, biraz daha uzun (81) bir sürüm:

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));}
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.