Cho một số N, làm thế nào tôi có thể in ra một cây Giáng sinh có chiều cao Nbằng cách sử dụng số lượng ký tự mã ít nhất? Nđược giả định ràng buộc với giá trị tối thiểu là 3và giá trị tối đa là 30(giới hạn và kiểm tra lỗi là không cần thiết). Nđược đưa ra làm đối số dòng lệnh một và duy nhất cho chương trình hoặc tập lệnh của bạn.

Tất cả các ngôn ngữ đều được đánh giá cao, nếu bạn thấy một ngôn ngữ đã được triển khai và bạn có thể rút ngắn ngôn ngữ đó, hãy chỉnh sửa nếu có thể - bình luận khác và hy vọng ai đó dọn dẹp mớ hỗn độn. Bao gồm các dòng mới và Không gian trắng cho rõ ràng, nhưng không bao gồm chúng trong số lượng ký tự.

Một cây Giáng sinh được tạo ra như vậy, với "thân cây" của nó chỉ bao gồm một "*" ở giữa

N = 3:

   *
  ***
 *****
   *

N = 4:

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

N = 5:

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

N xác định chiều cao của các nhánh không bao gồm thân một dòng.

Chúc mừng Giáng sinh PPCG!

J , 24 ký tự

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

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

Giải trình:

'*'$~5
*****

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

Sau đó }:@|."1đảo ngược từng hàng và loại bỏ cột cuối cùng và ,.ghim nó vào ].

Sau đó ,{.dán cột đầu tiên lên phía dưới.

Các mục trước :

29 ký tự, không có khoảng trắng nào cả.

   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.3
  *
 ***
*****
  *
   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.11
          *
         ***
        *****
       ******
      ******
     ******
    ****** / TÌM
   ****** / TÌM HIỂU
  ****** / TÌM HIỂU
 ****** / TÌM HIỂU
****** / TÌM HIỂU
          *

   Lưu ý đếm từ 1 đến n , rồi 1 lần nữa
   >: 0, ~ i.3
1 2 3 1
   Lưu ý nhân rộng '*' x lần mỗi lần
   $ & '*' "0>: 0, ~ i.3
*
**
***
*
   Lưu ý đảo ngược từng hàng
   (\: i. @ #) "1 $ & '*'" 0>: 0, ~ i.3
  *
 **
***
  *
   Lưu ý tước cột hàng đầu
   }. "1 $ & '*'" 0>: 0, ~ i.3

*
**

   Lưu ý dán lại với nhau
   ((\: i. @ #),}.) "1 $ & '*'" 0>: 0, ~ i.3
  *
 ***
*****
  *

Brainfuck, 240 ký tự

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

Chưa xong đâu. Nó hoạt động, nhưng chỉ với các số có một chữ số.

EDIT: Xong! Hoạt động cho các thông dịch viên sử dụng 0 là EOF. Xem NOTEs trong nguồn nhận xét cho những người có -1.

EDIT một lần nữa: Tôi nên lưu ý rằng vì Brainfuck thiếu một phương thức tiêu chuẩn để đọc các đối số dòng lệnh, tôi đã sử dụng stdin (đầu vào tiêu chuẩn) để thay thế. ASCII, tất nhiên.

EDIT lần thứ ba: Trời ơi, có vẻ như tôi đã tước .(xuất) ký tự khi ngưng mã. Đã sửa...

Đây là quản lý bộ nhớ cơ bản của vòng lặp chính. Tôi chắc chắn rằng nó có thể được tối ưu hóa mạnh mẽ để giảm số lượng nhân vật xuống khoảng 30 hoặc hơn.

1. Tạm thời
2. Bản sao của quầy
3. Bộ đếm (đếm đến 0)
4. Ký tự khoảng trắng (thập phân 32)
5. Ký tự dấu hoa thị (thập phân 42)
6. Số dấu hoa thị trên dòng hiện tại (bộ đếm 1 + 2 *)
7. Tạm thời
8. Nhân vật dòng mới
9. Tạm thời?
10. Tổng số dòng (tức là giá trị đầu vào; được lưu trữ cho đến hết, khi in thân cây)

Phiên bản thu gọn:

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

Và phiên bản đẹp:

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 =)

Perl, 50 ký tự

(1 không gian liên quan)

perl: một phiên bản dòng:

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

và bây giờ với nhiều whitesapce hơn:

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

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

Giải thích mở rộng cho người dùng không Perl.

# 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. 

Ngôn ngữ: Python (thông qua shell), Char đếm: 64 (2 khoảng trắng đáng kể)

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

$ sh ax6 11
           *
          ***
         *****
        *******
       *********
      ***********
     *************
    ***************
   *****************
  *******************
 *********************
           *

x86 asm 16 bit, 50 byte

Chưa có phiên bản lắp ráp? :)

    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

(Lưu ý: N được giới hạn ở 1 - 9 trong phiên bản này)

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

Tải xuống ở đây

Ngôn ngữ: Windows Batch Script ( gây sốc! )

@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!*

Ruby, 64 byte

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

Chúc mừng giáng sinh vui vẻ!

Chỉnh sửa: Các cải tiến được thêm theo đề xuất của Joshua Swink

Ngôn ngữ: C #, Char đếm: 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));
    }
}

Chỉ là mã, không có định dạng (120 ký tự):

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

Phiên bản có 109 ký tự (chỉ mã):

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

Kết quả cho chiều cao = 10:

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

Ngôn ngữ: dc (qua shell) Số đếm Char: 83

Phiên bản dc ngắn hơn một chút:

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

EDIT: thay đổi hằng 10 thành $ 1

python, "-c" lừa ... @ 61 ký tự (và một dòng)

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

Đây là phiên bản Haskell hợp lý, tiết kiệm không gian, với 107 ký tự:

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

chạy nó:

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

Giáng sinh vui vẻ nhé

Ngôn ngữ: dc (qua shell), Char đếm: 119 (1 khoảng trống đáng kể)

Chỉ vì sự tối nghĩa của nó :)

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

$ sh ax3 10
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
          *

C ++ tốt hơn, khoảng 210 ký tự:

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

Thu nhỏ đến 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;}

Ngôn ngữ: trăn, không thủ đoạn, 78 ký tự

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

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

Cải thiện câu trả lời. Tôi không thể bình luận, vì vậy đây là một bài viết mới. 72 ký tự.

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

Sử dụng thủ thuật "python -c", 61 ký tự.

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

Tôi đã học được chức năng trung tâm và "python -c" có thể chấp nhận nhiều hơn một mã dòng. Cảm ơn,.

C # sử dụng Linq:

    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 xe ngựa.

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

AWK, 86 ký tự trên một dòng.

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
   #
  ###
 #####
   #
     #
    ###
   #####
  #######
 #########
     #

Ngôn ngữ: Java, Char đếm: 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");}}

Để tham khảo, tôi đã có thể cạo giải pháp Java trước đó, bằng cách sử dụng đệ quy, xuống còn 231 ký tự, từ mức tối thiểu trước đó là 269. Mặc dù lâu hơn một chút, tôi thích giải pháp này vì Tnó thực sự hướng đối tượng. Bạn có thể tạo một rừng nhỏ các Ttrường hợp có kích thước ngẫu nhiên . Đây là sự phát triển mới nhất về chiến thuậ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);}
 }

Ngôn ngữ: PowerShell, Số đếm Char: 41 (bao gồm 1 khoảng trắng)

1..$args[0]+1|%{" "*(30-$_)+"*"*($_*2-1)}

21 ký tự với APL dyalog.

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

Đưa ra một vectơ số nguyên bắt đầu bằng 1.

1, thêm một vào cuối vectơ. Đây sẽ là chân cây.

'*' \ Đưa ra một vectơ * -strings với độ dài được cho bởi vectơ trước đó.

Biến vectơ thành ma trận và thêm khoảng trắng ở bên phải.

m ← lưu trữ ma trận trong m.

0 1 giảm hàng 0 và cột đầu tiên.

Đảo ngược ma trận.

m, nối với m ở bên phải.

Ngôn ngữ: C, Char đếm: 133

Cải tiến phiên bản C.

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

Hoạt động và thậm chí lấy chiều cao cây làm đối số. Cần một trình biên dịch chấp nhận mã kiểu K & R.

Tôi cảm thấy rất bẩn bây giờ .. Đây là mã là xấu xí.

R (62 byte)

Tôi chưa thấy giải pháp R. Sửa tôi nếu tôi bỏ lỡ.

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

Đầu ra:

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

Ngôn ngữ: C, Char đếm: 176 (2 khoảng trắng có liên quan)

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

Phiên bản Shell, 134 ký tự:

#!/bin/sh
declare -i n=$1
s="*"
for (( i=0; i<$n; i++ )); do
    printf "%$(($n+$i))s\n" "$s"
    s+="**"
done
printf "%$(($n))s\n" "*"

Ngôn ngữ: Python, số char đáng kể: 90

Nó xấu nhưng nó hoạt động:

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

Vì đây là CW: Tôi không thích rằng các golf mã luôn được tổ chức theo "số lượng ký tự" hoặc somesuch. Họ không thể được tổ chức theo số lượng hướng dẫn cho trình biên dịch / trình thông dịch (hoặc một số tiêu chí tương tự)? Đây là giải pháp Ruby một lần nữa và về cơ bản là giống nhau, nhưng bây giờ đối với tiêu dùng của con người cũng vậy:

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

Than , 9 byte (không biên dịch)

Ｇ↗↘←Ｎ*Ｍ↓*

Hãy thử trực tuyến!

Rực rỡ

Polygon(:UpRight, :DownRight, :Left, InputNumber(), "*")
Move(:Down)
Print("*")

Hãy thử trực tuyến!

Thạch , 12 byte

R”*ẋz⁶ṚŒBṁ‘Y

Hãy thử trực tuyến!

PHP, 111 ký tự

(Char cuối cùng phải là một dòng mới.)

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

Phiên bản dễ đọc:

<?php

$n = $argv[1];

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

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

?>