З огляду на число 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 символів

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

Ще не зроблено. Це працює, але тільки з одноцифровими числами.

EDIT: Готово! Працює для перекладачів, що використовують 0 як EOF. Дивіться NOTEs у коментованому джерелі для тих, хто має -1.

ЗНО ЗНО: Я мушу зазначити, що оскільки Brainfuck не має стандартного методу для читання аргументів командного рядка, я використовував натомість stdin (стандартний ввід). 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 =)

Perl, 50 символів

(1 відповідне пробіл)

perl: версія одного рядка:

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

Розширене пояснення для користувачів, що не мають 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. 

Мова: Python (через оболонку), кількість знаків: 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)}

З Різдвом Христовим усім!

Редагувати: Поліпшення додано, як запропонував Джошуа Свінк

Мова: 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

EDIT: змінено константу 10 на $ 1

python, "-c" трюк ... @ 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)

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

Удосконалення відповіді ΤΖΩΤΖΙΟΥ. Я не можу коментувати, тому ось нова публікація. 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" може приймати більше одного коду рядка. Дякую, ΤΖΩΤΖΙΟΥ.

C # за допомогою 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 статутів.

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

Мова: Java, кількість чарів: 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");}}

Для довідки, я зміг поголити попереднє рішення Java, використовуючи рекурсію, до 231 символів, від попереднього мінімуму 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);}
 }

Мова: PowerShell, Кількість Char: 41 (включаючи 1 пробіл)

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

21 символ з діалогом APL.

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

⍳ дає вектор цілих чисел, починаючи з 1.

1, ⍨ додає одиницю до кінця вектора. Це буде підніжжя дерева.

'*' \ ¨⍨ дає вектор *-рядків з довжинами, заданими попереднім вектором.

↑ перетворює вектор у матрицю і додає пробіли праворуч.

m ← зберігає матрицю в m.

0 1 ↓ випадає нульові рядки та перший стовпець.

⌽ повертає матрицю.

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

?>