숫자가 주어지면 최소 코드 문자를 사용하여 N높이의 크리스마스 트리를 어떻게 인쇄 할 수 N있습니까? N는 최소값 3및 최대 값으로 제한된다고 가정합니다 30(경계 및 오류 검사는 필요하지 않음). N프로그램이나 스크립트에 대한 유일한 명령 줄 인수로 제공됩니다.

언어가 이미 구현되어 있고 더 짧은 언어로 만들 수 있다면 가능하면 편집하십시오. 그렇지 않으면 의견을 말하고 누군가가 혼란을 정리하기를 바랍니다. 명확성을 위해 줄 바꿈과 공백을 포함하지만 문자 수에는 포함시키지 마십시오.

"트렁크"가 중심 "*"로만 구성된 크리스마스 트리가 생성됩니다.

N = 3 :

   *
  ***
 *****
   *

N = 4 :

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

N = 5 :

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

N은 한 줄의 트렁크를 포함하지 않는 가지의 높이를 정의합니다.

메리 크리스마스 PPCG!

J , 24 자

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

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

설명:

'*'$~5
*****

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

그런 다음 }:@|."1각 행을 뒤집고 마지막 열을 제거하고 ,.스테이플 링합니다 ].

그런 다음 ,{.첫 번째 열을 바닥에 붙여 넣습니다.

이전 항목 :

29 자 (공백 없음)

   ((\ : i. @ #),}.) "1 $ & '*'"0> : 0, ~ i.3
  *
 ***
*****
  *
   ((\ : i. @ #),}.) "1 $ & '*'"0> : 0, ~ i.11
          *
         ***
        *****
       *******
      *********
     ***********
    *************
   ***************
  *****************
 *******************
*********************
          *

   NB. 1에서 n 까지 세고 다시 1
   > : 0, ~ i.3
1 2 3 1
   NB. 각각 '*' x 번 복제
   $ & '*' "0> : 0, ~ i.3
*
**
***
*
   NB. 각 행을 반대로
   (\ : i. @ #) "1 $ & '*'"0> : 0, ~ i.3
  *
 **
***
  *
   NB. 선행 컬럼을 제거
   }. "1 $ & '*'"0> : 0, ~ i.3

*
**

   NB. 붙여 넣기
   ((\ : i. @ #),}.) "1 $ & '*'"0> : 0, ~ i.3
  *
 ***
*****
  *

Brainfuck, 240 자

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

아직 끝나지 않았습니다. 한 자리 숫자로만 작동합니다.

편집 : 완료! EOF로 0을 사용하는 통역사에서 작동합니다. NOTE-1을 가진 사람들에 대해서는 주석이 달린 소스를 참조하십시오 .

다시 편집하십시오 : Brainfuck에는 명령 줄 인수를 읽는 표준 방법이 없기 때문에 대신 stdin (표준 입력)을 사용했습니다. 물론 ASCII.

세 번째로 편집하십시오. 오, 여러분, .코드를 압축 할 때 문자를 제거 (출력) 하는 것 같습니다 . 결정된...

다음은 메인 루프의 기본 메모리 관리입니다. 문자 수를 30 정도로 줄이려면 크게 최적화 할 수 있다고 확신합니다.

1. 일시적인
2. 카운터 사본
3. 카운터 (0까지 계산)
4. 공백 문자 (10 진수 32)
5. 별표 문자 (10 진수 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 =)

펄, 50 자

(1 관련 공간)

펄 : 한 줄 버전 :

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

이제 더 많은 whitesapce가 있습니다.

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

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

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

언어 : 파이썬 (쉘을 통해), 문자 수 : 64 (2 개의 유효 공백)

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

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

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

(참고 :이 버전에서 N은 1-9로 제한됩니다)

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

여기에서 다운로드하십시오

언어 : Windows 배치 스크립트 ( 충격! )

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

루비, 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)}

메리 크리스마스!

편집 : Joshua Swink가 제안한 개선 사항

언어 : C #, 문자 수 : 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 :

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

언어 : dc (쉘을 통해) 문자 수 : 83

조금 더 짧은 dc 버전 :

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

편집 : 상수 10을 $ 1로 변경했습니다.

python, "-c"trick ... @ 61 문자 (한 줄)

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

공간적으로 효율적인 Haskell 버전은 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
     *
    ***
   *****
  *******
 *********
***********
     *

메리 크리스마스, 모두 :)

언어 : dc (쉘을 통해), 문자 수 : 119 (유효한 공간 1 개)

그것의 모호함을 위해 :)

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 ++, 약 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;}

언어 : 파이썬, 트릭 없음, 78 자

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

그루비 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) }

ΤΖΩΤΖΙΟΥ의 답변 개선. 댓글을 달 수 없으므로 여기에 새로운 게시물이 있습니다. 72 자

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

"python -c"트릭을 사용하여 61 자

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

나는 중심 기능을 배웠고 "python -c"는 하나 이상의 라인 코드를 수용 할 수 있다는 것을 배웠다. 감사합니다, ΤΖΩΤΖΙΟΥ.

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

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

언어 : 자바, 문자 수 : 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");}}

참고로, 이전 최소 269에서 231 자까지 재귀를 사용하여 이전 Java 솔루션을 면도 할 수있었습니다. 조금 더 길지만, 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);}
 }

언어 : PowerShell, Char count : 41 (1 공백 포함)

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

dyalog APL이있는 21 자

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

⍳는 1로 시작하는 정수 벡터를 제공합니다.

1, ⍨는 벡터 끝에 1을 더합니다. 이것은 나무의 발이 될 것입니다.

'*'\ ¨⍨는 이전 벡터가 제공 한 길이를 가진 *-문자열 벡터를 제공합니다.

↑ 벡터를 행렬로 변환하고 오른쪽에 공백을 추가합니다.

m ← 행렬을 m 단위로 저장합니다.

0 1 ↓는 0 행과 첫 번째 열을 삭제합니다.

⌽는 행렬을 반대로합니다.

m, ⍨는 오른쪽에 m과 연결됩니다.

언어 : C, 문자 수 : 133

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

작동하고 심지어 나무 높이를 인수로 사용합니다. K & R 스타일 코드를 허용하는 컴파일러가 필요합니다.

나는 지금 너무 더럽다 .. 이것은 코드가 못 생겼다.

R (62 바이트)

아직 R 솔루션을 보지 못했습니다. 내가 놓친 경우 수정하십시오.

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

언어 : C, 문자 수 : 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");}

쉘 버전, 134 자 :

#!/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" "*"

언어 : Python, 유효 문자 수 : 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
            *
           ***
          *****
         *******
        *********
       ***********
      *************
     ***************
    *****************
   *******************
  *********************
 ***********************
*************************
            *

이것이 CW이기 때문에 : 나는 코드 골프가 항상 "문자 수"또는 그와 같은 방식으로 구성되는 것을 좋아하지 않습니다. 컴파일러 / 통역사 (또는 유사한 기준)에 대한 명령 수로 구성 할 수 없습니까? 다음은 Ruby 솔루션입니다. 기본적으로 동일하지만 이제는 사람이 소비합니다.

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

숯 , 9 바이트 (비경쟁)

Ｇ↗↘←Ｎ*Ｍ↓*

온라인으로 사용해보십시오!

말 수가 많은

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

온라인으로 사용해보십시오!

젤리 , 12 바이트

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

온라인으로 사용해보십시오!

PHP, 111 자

(마지막 문자는 줄 바꿈이어야합니다.)

<?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) . '*'

?>