Wyjdź z legendarnego Yggdrasil

39

Twoim zadaniem jest wygenerowanie reprezentacji legendarnego drzewa życia, Yggdrasil .

Musisz napisać program, którego wynik jest dokładnie taki:

                                       /\
                                      /**\
                                     /****\
                                    /******\
                                    /******\
                                   /********\
                                  /**********\
                                 /************\
                                /**************\
                                 /************\
                                /**************\
                               /****************\
                              /******************\
                             /********************\
                            /**********************\
                              /******************\
                             /********************\
                            /**********************\
                           /************************\
                          /**************************\
                         /****************************\
                        /******************************\
                           /************************\
                          /**************************\
                         /****************************\
                        /******************************\
                       /********************************\
                      /**********************************\
                     /************************************\
                    /**************************************\
                        /******************************\
                       /********************************\
                      /**********************************\
                     /************************************\
                    /**************************************\
                   /****************************************\
                  /******************************************\
                 /********************************************\
                /**********************************************\
                     /************************************\
                    /**************************************\
                   /****************************************\
                  /******************************************\
                 /********************************************\
                /**********************************************\
               /************************************************\
              /**************************************************\
             /****************************************************\
            /******************************************************\
                  /******************************************\
                 /********************************************\
                /**********************************************\
               /************************************************\
              /**************************************************\
             /****************************************************\
            /******************************************************\
           /********************************************************\
          /**********************************************************\
         /************************************************************\
        /**************************************************************\
               /************************************************\
              /**************************************************\
             /****************************************************\
            /******************************************************\
           /********************************************************\
          /**********************************************************\
         /************************************************************\
        /**************************************************************\
       /****************************************************************\
      /******************************************************************\
     /********************************************************************\
    /**********************************************************************\
            /******************************************************\
           /********************************************************\
          /**********************************************************\
         /************************************************************\
        /**************************************************************\
       /****************************************************************\
      /******************************************************************\
     /********************************************************************\
    /**********************************************************************\
   /************************************************************************\
  /**************************************************************************\
 /****************************************************************************\
/******************************************************************************\
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |--------|
                                   |________|

Nie ma końcowych białych znaków. Ostateczna nowa linia może zostać pominięta.

Aby ułatwić sprawdzanie, oto sumy md5 oczekiwanego wyniku:

  • 374899e56bc854d04639c43120642e37 - Brak nowej linii na końcu.
  • 03afb81d960b8e130fe2f9e0906f0482 - Koniec nowej linii

Obowiązują standardowe luki. To jest golf golfowy, więc wygrywa najmniejszy wpis w bajtach!

Cairney Coheringaahing
źródło
10
Powiązane: codegolf.stackexchange.com/q/15860/15599 . Nax, powinieneś pracować w marketingu. Każde gospodarstwo domowe będzie chciało Yggdrasil w te Święta Bożego Narodzenia. Widzę, że odpowiedziałeś również na pytanie liczbowe Grahama. Musisz lubić spiczaste rzeczy. Niech będą nowe nazwy dla „rakiety” i „rożka do lodów”.
Level River St
Powiązane również: codegolf.stackexchange.com/q/4244/194 .
Peter Taylor,
4
@Nax: ponieważ drzewo świata ma owoce, a okrytozalążkowe go nie ma, i jest to wyraźnie pewien opis, niestety wygląda na to, że zrobiłeś zdjęcie niewłaściwego drzewa: P
naught101
@Nax Hmm. Masz rację. Pedant (ja) dźwiga na swoim własnym petardzie. Sumy md5 uległy zmianie.
Scott Leadley,
1
Err, punkt zamówienia, Yggdrasil to zdecydowanie jesion w eddas, a nie jodła. Trochę jak to .
Alex P

Odpowiedzi:

22

Golfscript, 84 77 76 75 72 znaków

Inne podejście niż Howarda . Kliknij liczbę znaków, aby spróbować.

10,{.)4*,\3*>{.39\-' '*'/'@2*'*'*'\
'}/}/12,{' '35*'|'@11<'_-'1/=8*1$n}/

Dzięki Howard za uratowanie 3 postaci!

Objaśnienie :

Jest to mniej więcej prosty port mojego rozwiązania Python . Biorąc trochę ekspresyjnych swobód (używając nazwanych zmiennych zamiast śledzić pozycje stosu i printnaprawdę utrzymuję rzeczy na stosie, nie drukując):

10,{...}/            # for i in range(10):
   .                 #    x = i
   )4*,              #    Y = range((i+1)*4)
   \3*               #    x *= 3
   >                 #    Y = Y[x:]  # y is now range(3*i, (i+1)*4)
   {...}/            #    for j in Y:
      .39\-          #        q = 39 - j
      ' '*           #        print ' '*q  # print right number of spaces
      '/'            #        print '/'
      @2*            #        j *= 2
      '*'*           #        print '*'*j
      '\<NEWLINE>'   #        print "\\\n"
12,{...}/            # for i in range(12):
    ' '35*           #    print ' '*35
    '|'              #    print '|'
    @11<             #    i = i < 11
    '_-'1/=          #    z = "_-"[i] # pick "-" if i < 11, else pick "_"
    8*               #    print z*8
    1$               #    print '|' # (copy from earlier in the stack)
    n                #    print "\n"
Claudiu
źródło
1
Możesz użyć tej samej sztuczki z łamaniem linii, co w moim rozwiązaniu. Zamiast '\\'nciągnąć nową linię do łańcucha (+/- 0 znaków), a teraz odwrotny ukośnik nie musi już być poprzedzany (-1 znak).
Howard,
1
Dwa kolejne: 4*4+jest taki sam )4*i '_-'[=]może być napisany, '_-'1/=co sprawia, że ​​ostatni jest +przestarzały.
Howard,
3
wyjaśnienie może być przydatne ...? czy to zbyt wiele, aby zapytać?
@professorfish: Już wkrótce!
Claudiu,
Nie potrzebujesz ciągłego ';' tutaj? W przeciwnym razie pojawią się dwa nowe znaki, ponieważ golfscript domyślnie dodaje jeden.
Nabb
21

Haml & Sass

37 + 277 = 314

Haml:

%link(rel="stylesheet" href="s")
%pre

Sass:

pre:after{$l:"";@for$k from0 to10{@for$i from0 to4+$k{@for$j from0 to40-($k*6+$i*2)/2{$l:$l+' ';}$l:$l+'/';@for$j from0 to$k*6+$i*2{$l:$l+'*';}$l:$l+"\\\a ";}}@for$i from0 to12{@for$j from0 to35{$l:$l+" ";}@if$i<11{$l:$l+"|--------|\a ";}@else{$l:$l+"|________|";}}content:$l;}

* Sass pozwala na sterowanie dyrektywami, konkatenacją i zmiennymi dereferencjami. Wszystko to jest przydatne podczas stylizacji, ale pełne umiejętności podczas gry w golfa.


zostanie wygenerowany w:

HTML:

<link rel="stylesheet" href="s" /><pre></pre>

CSS:

pre:after {
  content: "                                        /\\\a                                        /**\\\a                                       /****\\\a                                      /******\\\a                                      /******\\\a                                     /********\\\a                                    /**********\\\a                                   /************\\\a                                  /**************\\\a                                   /************\\\a                                  /**************\\\a                                 /****************\\\a                                /******************\\\a                               /********************\\\a                              /**********************\\\a                                /******************\\\a                               /********************\\\a                              /**********************\\\a                             /************************\\\a               
             /**************************\\\a                           /****************************\\\a                          /******************************\\\a                             /************************\\\a                            /**************************\\\a                           /****************************\\\a                          /******************************\\\a                         /********************************\\\a                        /**********************************\\\a                       /************************************\\\a                      /**************************************\\\a                          /******************************\\\a                         /********************************\\\a                        /**********************************\\\a                       /************************************\\\a                      /**************************************\\\a                     /******************************
**********\\\a                    /******************************************\\\a                   /********************************************\\\a                  /**********************************************\\\a                       /************************************\\\a                      /**************************************\\\a                     /****************************************\\\a                    /******************************************\\\a                   /********************************************\\\a                  /**********************************************\\\a                 /************************************************\\\a                /**************************************************\\\a               /****************************************************\\\a              /******************************************************\\\a                    /******************************************\\\a                   /**********************************
**********\\\a                  /**********************************************\\\a                 /************************************************\\\a                /**************************************************\\\a               /****************************************************\\\a              /******************************************************\\\a             /********************************************************\\\a            /**********************************************************\\\a           /************************************************************\\\a          /**************************************************************\\\a                 /************************************************\\\a                /**************************************************\\\a               /****************************************************\\\a              /******************************************************\\\a             /*****************************************************
***\\\a            /**********************************************************\\\a           /************************************************************\\\a          /**************************************************************\\\a         /****************************************************************\\\a        /******************************************************************\\\a       /********************************************************************\\\a      /**********************************************************************\\\a              /******************************************************\\\a             /********************************************************\\\a            /**********************************************************\\\a           /************************************************************\\\a          /**************************************************************\\\a         /****************************************************************\\\a        /*********
*********************************************************\\\a       /********************************************************************\\\a      /**********************************************************************\\\a     /************************************************************************\\\a    /**************************************************************************\\\a   /****************************************************************************\\\a  /******************************************************************************\\\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    |--------|\a                                    
|--------|\a                                    |--------|\a                                    |________|"; }

wynikowa strona

Trevor Hickey
źródło
1
Na CodeGolf nie widać ton rozwiązań HTML / CSS. Dobra robota.
Mordred,
16

CJam , 62 bajty

A,{I4+,{I3*J+_39\-S*'/@2*'**'\N}fJ}fI{35S*'|'-8*'|N++}C*'-/'_*

Wypróbuj online!

Jak to działa

A,           " Push [ 0  …  9 ].                                                   ";
{            " For each I in that array:                                           ";
  I4+,       " Push [ 0  …  I + 3 ].                                               ";
  {          " For each J in that array:                                           ";
    I3*J+_   " Push K := 3 * I + J twice.                                          ";
    39\-S*   " Push a string consisting of 39 - K spaces.                          ";
    '/       " Push a slash.                                                       ";
    @2*'**   " Push a string consisting of 2 * K asterisks.                        ";
    '\N      " Push a backslash and a linefeed.                                    ";
  }fJ        "                                                                     ";
}fI          "                                                                     ";
{            " Do the following 12 times:                                          ";
  35S*       " Push a string consisting of 35 spaces.                              ";
  '|         " Push a vertical bar.                                                ";
  '-8*'|++   " Push the string '--------|\n'.                                      ";
}C*          "                                                                     ";
'-/'_*       " Replace the hyphen-minus signs of the last string with underscores. ";
Dennis
źródło
2
Muszę zacząć używać CJam zamiast GolfScript ...
Claudiu,
Co sprawia, że ​​kod CJam jest tak kompaktowy? Czy to po prostu zwykłe funkcje, które dobrze do siebie pasują, czy jest jakiś super-trick? Czy to właściwie nie CJam, ale programiści CJam, więc?
Vi.
2
@Vi .: To połączenie obu. 1. CJam jest oparty na stosie, więc zwykle uciekasz bez żadnych zmiennych. 2. Wszystkie wbudowane nazwy mają maksymalnie dwa znaki. Z tego powodu nie potrzebujesz białych znaków, z wyjątkiem niektórych specjalnych przypadków. 3. Nawet zgłoszenia w językach golfowych same w sobie nie grają. Moje programy GolfScript / CJam są teraz znacznie krótsze niż kiedyś.
Dennis
Sugestią dla CJam byłoby użycie kodów ASCII 128-256 dla całego innego zestawu wbudowanych. mam specjalnego edytora, który
Claudiu
@Claudiu: Cóż, to zależy od jego twórcy. Gdybym zaprojektował własny język golfa, myślę, że uczynię go opartym na bitach lub koduję wszystkie instrukcje arytmetycznie.
Dennis,
15

GolfScript, 79 znaków

10,{:^4+,{2*^6*+'*'*.,2/~40+' '*'/'@'\
'}/}/[' '35*]12*'|--------|
'*'||''_'8**

Wypróbuj kod tutaj . Zauważ, że podział linii nie jest opcjonalny w tym kodzie

Howard
źródło
24
Wieloliniowe rozwiązanie GolfScript? Nie sądziłem, że zobaczę ten dzień!
Ingo Bürk,
12

Python, 148 129 126 121 121 znaków

R=range
for i in R(10):
 for j in R(i*3,4+i*4):print' '*(39-j)+'/'+'**'*j+'\\'
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'

Dzięki Falko za uratowanie 3 postaci i trzęsienie ziemi za genialne uratowanie kolejnych 5!

Claudiu
źródło
1
Mnożenie znaków w Pythonie jest zbyt idealne do tego wyzwania ...
Sean Latham
Poczekaj, aż zobaczysz moje rozwiązanie w golfa ... = P
Claudiu
2
Użyj, '**'*jaby zapisać 3 znaki. Poza tym moje rozwiązanie jest zbieżne z dokładnie tym samym kodem. :)
Falko,
1
Możesz skrócić ostatni wiersz, pisząc for c in'-'*11+'_':print' '*35+'|'+c*8+'|'.
trzęsienie ziemi
@flornquake: nice! bardzo sprytny
Claudiu
11

Grzmotnąć, 236 197 193

10 bajtów kodu + 1-bajtowa nazwa pliku + 182-bajtowy plik danych = łącznie 193 bajty

zcat y 2>j

Wyjaśnienie

yto plik zawierający Yggdrasil, bez nowej linii końcowej, skompresowany algorytmem zopfli (wywoływany jako zopfli --i64), a następnie usunięty z ostatnich 8 bajtów. zopfli jest kompatybilny z gzip, więc mogę dekompresować plik za pomocą standardowych narzędzi Bash zaprojektowanych dla gzip. Rozmiar pliku danych wynosi 182 bajty (229 bajtów, gdy używany jest zwykły gzip). Rozmiar oryginalnego Yggdrasil, bez nowej linii końcowej, wynosi 5876 bajtów.

Usunięcie ostatnich 8 bajtów powoduje komunikaty o błędach, które są tłumione przez wysyłanie standardowego błędu do pliku o nazwie j. Jeśli jistnieje, zostanie zastąpione.

Base64 z yjest (użyj, base64 -daby uzyskać oryginalny plik):

H4sIAAAAAAACA+3SMQoCURDA0N5TWC+IFxK8yD/8Nul9hfDRnamT6J+du83zdUPwOACNNDb0+3Bs
tMPhSscDvusHgM9wIcUNclL+5r/luJXkmlh5rM3r8txkMdVNcEn1Nc2a1AU72XWz3Xd91r5z7eZD
AQKQgAI0PDFf8xJfExpQgQhkpAIdz8ytzK3AQMg6UMIQpLQELU/NQc5B/thBegtqHpOc16jHOX/v
x1mPZg19MfrdrBM=

A md5sum to:

4a049a80241160cdde0a3cbca323b7f2

źródło
2
Miałem ochotę nacisnąć przycisk „usuń”, kiedy zobaczyłem kod, dopóki nie przeczytałem liczby znaków i wyjaśnień. : P
Klamka
2
Możesz zapisać około 30 bajtów, używając zopfli do skompresowanego pliku. „zopfli --i100 y” daje 190-bajtowy plik, który Zcat może rozpakować.
Glenn Randers-Pehrson,
1
I jeszcze kilka, jeśli usuniesz ostatnie 10 bajtów i zamkniesz STDERR.
Dennis,
@ GlennRanders-Pehrson dziękuję za zwrócenie na to uwagi, zredagowałem również moją odpowiedź na „ Molowe masy związków” codegolf.stackexchange.com/a/35613/16402, aby użyć zopfli, oszczędzając 37 bajtów
@Dennis okazało się, że ma 8 bajtów (więcej i brakuje fragmentów pnia Yggdrasil), dzięki
7

C, 169

i;j;p(a,b){while(b--)putchar(a);}main(){for(;i++<10;)for(j=i*3-4;++j<i*4;p(32,39-j),p(47,1),p(42,j*2),puts("\\"));for(++i;i--;p(32,35),p(124,1),p(i?45:95,8),puts("|"));}

Nie golfowany (i lekko rozplątany):

int i;
int j;
void p(a,b) {
  while (b--) putchar(a);
}
void main() {
  for (;i++<10;) {
    for (j=i*3-4;++j<i*4;) {
      p(32,39-j);
      p(47,1);
      p(42,j*2);
      puts("\\");
    }
  }
  for (++i;i--;) {
    p(32,35);
    p(124,1);
    p(i?45:95,8);
    puts("|");
  }
}
piskliwy kostuch
źródło
7

Rubin - 100

puts (0..21).map{|i|i>9??\ *35+?|+(i>20??_:?-)*8+?|:(0..i+3).map{|y|?\ *(39-z=y+3*i)+?/+?**z*2+?\\}}

Automatycznie spłaszcza, dzięki czemu możemy zbierać wszystkie linie nawet w zagnieżdżonych tablicach. Potrzebuje Ruby 1.9

Spróbuj na ideone

Vectorized
źródło
Myślę, że potrzebuje kilku wiodących miejsc. Działa również z Ruby 1.9, ale nie w wersji 1.8.
Scott Leadley,
7

PowerShell 104 101

0..9|%{(3*$_)..(3+$_*4)|%{" "*(39-$_)+"/"+"*"*2*$_+"\"}};0..11|%{" "*35+"|"+("-","_")[$_-eq11]*8+"|"}
DarkAjax
źródło
6

C # 258 234 bajtów

Podziękowania dla pewnego anonimowego użytkownika za sugerowane zmiany, które dobrze wykorzystują metodę String.PadLeft!

using System;class G{static void Main(){Action<string>p=Console.WriteLine;int i=0,j;for(;i++<10;)for(j=i*3-3;j++<i*4;)p("/".PadLeft(41-j)+"\\".PadLeft(2*j-1,'*'));while(i-->0)p("|--------|".PadLeft(45));p("|________|".PadLeft(45));}}

Kod jest dość prosty, niewiele do golfa.

Sformatowany kod:

using System;
class G
{
    static void Main()
    {
        Action<string> p = Console.WriteLine;
        int i = 0, j;
        for(; i++ < 10 ;)
            for(j = i*3 - 3; j++ < i*4;)
                p("/".PadLeft(41 - j) + "\\".PadLeft(2*j - 1,'*'));
        while(i-- > 0)
            p("|--------|".PadLeft(45));
        p("|________|".PadLeft(45));
    }
}
VisualMelon
źródło
Używanie \rjest tutaj bezcelowe. To jest kod golfowy.
nyuszika7h,
3
@ nyuszika7h wprawdzie, ale na wszelki wypadek znajduje się w sformatowanej kopii, aby ludzie korzystający z notatnika mogli łatwiej zobaczyć chwałę Yggdrasil (nie jest uwzględniony w partyturze)
VisualMelon
Rozumiem. Windows ... Zapraszam do naprawy mojej edycji.
nyuszika7h,
@ nyuszika7h dzięki za zwrócenie uwagi na podświetlanie składni nie było właściwe
VisualMelon
6

J, 98 88 84 75

(85 11 1#3 4$' /*\ |-| |_|')#"1~(39&-,1,+:,1:)"0(12$4),~85(-4&+#-:*>:)&i.10
Robaczek świętojański
źródło
4

Perl, 127

for$i(0..9){for$j($i*3..3+$i*4){print" "x(39-$j),"/","*"x($j*2),"\\\n";}}for$i(0..11){print" "x35,"|",($i>10?"_":"-")x8,"|\n";}

Nie golfowany:

for $i (0..9) {
  for $j ($i*3..3+$i*4) {
    print " "x(39-$j) , "/" , "*"x($j*2) , "\\\n";
  }
}
for $i (0..11) {
  print " "x35 , "|" , ($i>10?"_":"-")x8 , "|\n";
}
piskliwy kostuch
źródło
Zamień $ i na $ _ i zapisz 4 znaki.
choroba
4

Rubin - 139 129 126 123 121

Podniesione „umieszcza” poza tworzeniem tablicy (sugestia bitpwner).

puts (0..9).map{|i|(i*3...(i+1)*4).map{|j|"/#{'**'*j}\\".rjust(41+j,' ')}}+["%45s"%'|--------|']*11<<'%45s'%'|________|'


Ungolfed („odkłada” unhoisted):


# print fill patterns from the intervals
# [0..3, 3..7, 6..11, 9..15, 12..19, 15..23, 18..27, 21..31, 24..35, 27..39]
# centered on columns 81-82
(0..9).each { |i|
  (i*3...(i+1)*4).each { |j|    # x...y vs x..y-1 saves a char
    puts "/#{'**'*j}\\".rjust(41+j,' ')
  }
}
# print the stump
puts ("%45s\n" % '|--------|') * 11
puts '%45s' % '|________|'
Scott Leadley
źródło
@bitpwner Myślę, że zasługuje na własną odpowiedź. Idź po to.
Scott Leadley,
4

PHP 223 202 181 160 156

Edycja Zorientowałem się, jak dokonać aliasu funkcji ze zmienną i byłem w stanie odciąć jeszcze kilka znaków. Ta str_repeatfunkcja była naprawdę pełna

Edycja 2: Dziękujemy wszystkim za sugestie!

Gra w golfa:

<?$s=str_repeat;for($i=-1;$i++<9;)for($j=$i*3;$j<4+$i*4;)echo$s(' ',39-$j).'/'.$s('**',$j++)."\\
";for($i=12;$i--;)echo$s(' ',35),'|'.$s($i?'-':'_',8)."|
";

Czytelny:

    <?

$s=str_repeat;

for($i=-1;$i++<9;)
{
    for($j=$i*3;$j<4+$i*4;)
    {
        echo$s(' ',39-$j).'/'.$s('**',$j++)."\\
        ";
    }
}

for($i=12;$i--;)
{
    echo$s(' ',35),'|'.$s($i?'-':'_',8)."|
    ";
}

Dane wyjściowe: http://brobin.me/yggdrasil.php

Brobin
źródło
Można zapisać 6 znaków poprzez usuwanie nawiasów wokół (39-$j), ($j*2)i ($i==11). -2 przez zastąpienie \nprawdziwymi nowymi znakami wiersza (PHP pozwala na to w literaturze). -5 znaków zastępując (oba) for($i=0;$i<12;$i++)z for($i=12;$i-->0;)i $i==11z $i==0.
sebcap26,
Po tym można również wymienić $s(($i==0?'_':'-'),8)z $s($i?'-':'_',8). (==> -5 znaków)
sebcap26
-1 postaci zastępując $s('*',$j*2)się $s('**',$j). Myślę, że to ostatnia poprawa, jaką mogę znaleźć.
sebcap26,
-2 zmienia ($j*2)się na wewnętrznej do ($j++*2)i wyjmowanie $j++z for()argumentów
avall
@ sebcap26 for($i=12;$i-->0;)można skrócić do for($i=12;$i--;)- kolejne 2 znaki.
avall
3

Delphi 429

Spróbuję poprawić później.
Grał w golfa

uses strutils,SysUtils,Classes;const a='|----';b='|____';c:array [0..9,0..1]of int32=((0,3),(3,7),(6,11),(9,15),(12,19),(15,23),(18,27),(21,31),(24,35),(27,39));var t:TStrings;i,j:integer;begin t:=tstringlist.Create;for I:=0to 9do for J:=c[i,0]to c[i,1]do t.Add('/'+StringOfChar('*',j));for I:=0to 10do t.Add(a);t.Add(b);for I:=0to t.Count-1do t[i]:=t[i].PadLeft(40)+ReverseString(t[i]).Replace('/','\');write(T.TEXT);readln;end.

bez golfa

uses
  strutils,SysUtils,Classes;
const
  a='|----';
  b='|____';
  c:array [0..9,0..1]of int32=((0,3),(3,7),(6,11),(9,15),(12,19),(15,23),(18,27),(21,31),(24,35),(27,39));
var
  t:TStrings;
  i,j:integer;
begin
  t:=tstringlist.Create;
  for I:=0to 9do
    for J:=c[i,0]to c[i,1]do
      t.Add('/'+StringOfChar('*',j));
  for I:=0to 10do
    t.Add(a);
  t.Add(b);
  for I:=0to t.Count-1do
    t[i]:=t[i].PadLeft(40)+ReverseString(t[i]).Replace('/','\');
  write(T.TEXT);
  readln;
end.
Teun Pronk
źródło
3

JavaScript, 288 281

Chrome ukrywa zduplikowane console.logpliki, zamiast tego użyj IE.

function t(w){s="";for(i=0;i++<39-w;)s+=" ";s+="/";for(i=0;i++<w*2;)s+="*";return s+"\\"}function r(l){s="";for(i=0;i++<36;)s+=" ";s+="|";for(i=0;i++<8;)s+=l;return s+"|"}w=0;c=console;for(h=0;h++<10;){for(j=0;j++<3+h;)c.log(t(w++));w-=h}for(j=0;j++<11;)c.log(r('-'));c.log(r('_'))

Nie golfowany:

function t(w)
{
    s="";
    for(i=0;i++<39-w;)
        s+=" ";
    s+="/";
    for(i=0;i++<w*2;)
        s+="*";
    return s+"\\"
}
function r(l)
{
    s="";
    for(i=0;i++<36;)
        s+=" ";
    s+="|";
    for(i=0;i++<8;)
        s+=l;
    return s+"|"
}

w=0;
c=console;
for(h=0;h++<10;)
{
    for(j=0;j++<3+h;)
        c.log(t(w++));
    w-=h;
}
for(j=0;j++<11;)
    c.log(r('-'));
c.log(r('_'))
Sean Latham
źródło
Użyj for(i=0;i++<39-w;)zamiast for(i=0;i<39-w;++i)i tak dalej. Ponadto p=console.logzamiast c=consolei pzamiast c.log(chociaż testowałem ten ostatni tylko w Node.js, nie działa w Firefoksie). Oszczędza to 12 bajtów.
nyuszika7h,
c=console.logteż nie działał w Chrome, więc go nie użyłem. Sztuczki for loop pozwalają jednak zaoszczędzić 7 bajtów.
Sean Latham,
Zazwyczaj uważam na wszystko, co zachęca mnie do korzystania z MSIE ...
Jest to całkiem możliwe, że po raz pierwszy widziałem wyrażenie „zamiast tego użyj IE”. O_o Możesz jednak powstrzymać działanie Chrome, po prostu uruchamiając ten kod w konsoli zamiast ze strony internetowej.
Klamka
Uruchomienie go na stronie i w konsoli daje te same wyniki dla mnie zarówno w przeglądarce Firefox, jak i Chrome.
Sean Latham,
3

JavaScript (console.log), 168 166

(Biały znak tylko dla czytelności)

for(i=c=0;i<11;i++)
  for(j=0;j<4+i&!c;j++)
    l=i*13+j,
    a=Array(n=i-10?3*i+j+1:5).join("*-_"[k=(l>129)+(c=l==141)]),
    console.log(Array(41-n).join(" ")+'/||'[k]+a+a+'\\||'[k])
Robaczek świętojański
źródło
3

C (219)

Dziękujemy wszystkim za wskazówki dotyczące gry w golfa - udało się obniżyć do 219. Nie sądzę, że spadnie znacznie poniżej.

w,W,s,S,i,r;main(){char T[78];memset(T,42,78);for(r=4,s=39;r<14;++r,s-=3,w+=6)for(i=0,S=s,W=w;i<r;++i,W+=2,--S)printf("%*s/%.*s\\\n",S,"",W,T);for(i=0;i<11;i++)printf("%35s|--------|\n","");printf("%35s|________|","");}

Wymagane obejmuje:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
DreamWarrior
źródło
Jeśli chce użyć C89, może również pominąć wszystkie dołączenia. W tym kodzie nie ma przypadku, w którym niejawna deklaracja przywołania jest przekręcana.
Joshua
@Nax; to prowadzi mnie do 263 - a ja wyciągnąłem obejmuje. Dzięki.
DreamWarrior,
@Joshua - 64-bitowe systemy i zestawy mogą być problematyczne, ale ... w przeciwnym razie może nie. Tak czy inaczej większość ludzi usuwa załączniki, więc ja też to zrobiłem.
DreamWarrior,
To właściwie 262 znaki, nie potrzebujesz końcowego znaku nowej linii.
nyuszika7h,
Możesz używać 32zamiast ' 'i 42zamiast '*':)
Quentin
3

Haskell, 153 148

Prosto, bez trików, po prostu gra w golfa:

(a:b:c)%n=(39-n)&' '++a:(2*n)&b++c
n#m=[n..m]++(n+3)#(m+4)
(&)=replicate
main=putStr$unlines$map("/*\\"%)(take 85$0#3)++map("|-|"%)(11&4)++["|_|"%4]

%Operator zwraca pojedynczą linię, jej pierwszy argument będący Stringdługości 3 zawierający granice i znaki wypełnienia w tej linii (obecnie zakładając dokładnie 3 Chars, oszczędzając 5 bajtów), przy czym drugie, Intokreśla połowa liczby znaków wypełnienia. Dopasowywanie wzorów, zużycie i dołączanie jest używane w kombinacji w celu zaoszczędzenia bajtów poprzez dbanie o „klej” pomiędzy Chari String. W tej drugiej wersji również ustawiłem #nieskończoność i wprowadziłem, take 85aby znów była skończona (niestety nie zapisano żadnych bajtów).

#Operator tworzy sekwencję dla nargumentu %wymagana do drzewa: [0..3], [3..7], ...łączone.

&jest po prostu skrótem replicate, który występuje trzy razy.

Drzewo jest złożone w ostatnim wierszu, nowe wiersze są dodawane przez unlines.

TheSpanishInquisition
źródło
138 bajtów
Max Yekhlakov
2

Lua - 164

a=' 'for i=0,9 do for j=i*3,3+i*4 do print(a:rep(39-j)..'/'..(('*'):rep(j*2))..'\\')end end for i=0,11 do print(a:rep(35)..'|'..((i>10 and'_'or'-'):rep(8))..'|')end
Adriweb
źródło
2

Mathematica 191 178

Na pewno nie najlepsze rozwiązanie:

n=Nest;
t=Table;
""<>
    t[
        {n[#<>" "&,"",39-i],"/",n[#<>"*"&,"",2i],"\\\n"}
    ,
        {i,Flatten@t[Range[j+4]-1+3j,{j,0,9}]}
    ]
<>
    t[
        n[#<>" "&,"",35]<>If[i==12,"|________|\n","|--------|\n"]
    ,
        {i,12}
    ]

Nie licząc nowych linii. Mathematica wypacza dane wyjściowe, ponieważ nie przyjmuje takiej samej szerokości dla białych znaków jak dla „*” i „/”. Ale wynik jest poprawny.

freddieknets
źródło
(to mój pierwszy golf)
freddieknets
2

Java - 286

Mój pierwszy golf.

Gra w golfa:

class M{public static void main(String[]args){int i=0,a,f=0;String s="";for(;i++<11;){for(a=i*3-4;++a<i*4;){if(i>10){a=4;if(++f>12)break;}s+=s.format("%"+(40-a)+"s"+(a>0?"%0"+a+"d":"")+"%3$s",f>0?"|":"/",0,f>0?"|":"\\").replace("0",f<1?"**":f>11?"__":"--")+"\n";}}System.out.println(s);}}

Nie golfowany:

class M {
    public static void main(String[] args) {
        int i=0,a,f=0;
        String s = "";
        for(;i++<11;){
            for(a=i*3-4;++a<i*4;a++){
                if(i>10){
                    a=4;
                    if(++f>12)break;
                }
                s+=s.format("%"+(40-a)+"s"+(a>0?"%0"+a+"d":"")+"%3$s",f>0?"|":"/", 0,f>0?"|":"\\").replace("0", f<1?"**":f>11?"__":"--")+"\n";
            }
        }
        System.out.println(s);
    }
}

Przetestuj tutaj

LudziE12
źródło
2

Python 2, 117

j=0
while j<40:j-=j/4;exec(j/3+4)*r"print' '*(39-j)+'/'+'**'*j+'\\';j+=1;"
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'

Inne wersje, które próbowałem, obejmują:

# 118
for i in range(10):j=i*3;exec(i+4)*r"print' '*(39-j)+'/'+'**'*j+'\\';j+=1;"
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'

# 118
i=j=4
while j:j=52-3*i;exec"j-=1;print' '*j+'/'+'**'*(39-j)+'\\\\';"*i;i+=1
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'

# 118
j=0
for b in'\\'*10:j-=j/4;exec(j/3+4)*"print' '*(39-j)+'/'+'**'*j+b;j+=1;"
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'

# 119
s=40
while s:s+=10-s/4;exec(52-s)/3*r"s-=1;print' '*s+'/'+'**'*(39-s)+'\\';"
for c in'-'*11+'_':print' '*35+'|'+c*8+'|'
trzęsienie ziemi
źródło
2

Pyth, 101 100 99 90 81 bajtów

J0Km/*+d7d2S9V85FTKI!-TN=hZ=+JZ))+*d-39-NJ++\/*"**"-NJ\\)Va*]\-11\_+++*d35\|*N8\|

Wypróbuj online!

Tłumaczenie Python 3:
Z=0
d=" "
J=0
K=list(map(lambda d:((d+7)*d)//2,range(1,10)))
for N in range(85):
    for T in K:
        if not T-N:
            Z+=1
            J+=Z
    print(d*(39-(N-J))+"/"+"**"*(N-J)+"\\")
for N in ["-"]*11+["_"]:
    print(d*35+"|"+N*8+"|")
hakr14
źródło
Czy afunkcja zdefiniowana w Pythonie nie jest równoważna z +listami?
Esolanging Fruit
@EsolangingFruit Jest blisko, ale nie do końca: <list>+<str>nie jest prawidłową operacją, ale równie łatwo mogę jej użyć ["-"]*11+["_"]. Zdecydowałem się zdefiniować własną funkcję, aby dokładniej tłumaczyć, co faktycznie robi Pyth.
hakr14
Ok, to ma sens.
Esolanging Fruit
2

PowerShell, 88 bajtów

0..9|%{(3*$_)..(3+$_*4)|%{' '*(39-$_)+"/$('**'*$_)\"}}
,'-'*10+'_'|%{' '*35+"|$($_*8)|"}
mazzy
źródło
1

Groovy 118

10.times{(it*3).upto 3+it*4,{println' '*(39-it)+'/'+'*'*it*2+'\\'}};12.times{println' '*35+'|'+(it>10?'_':'-')*8+'|'}
cfrick
źródło
1
Dlaczego nie jestem zaskoczony, widząc dość krótkie rozwiązanie Groovy. Wrażeniem Groovy było to, że zrobił to programista Java, który nienawidził pisania.
Almo
1

C 194

Ten kod jest gorącym bałaganem i na pewno można w niego grać więcej. Była to jednak okazja, aby wypróbować kilka rzeczy, których nigdy wcześniej nie robiłem: użycie literału dla ciągu gwiazdek i użycie specyfikatora szerokości *z ciągiem w printf.

i,j=5,k=5,n;
main(){
  char d[]={[0 ...77]=42,0};
  for(;i<85;i++)k--,j+=!k,k+=(j-1)*!k,n=39-i+(j-5)*(j-4)/2,printf("%*s/%s\\\n",n,"",d+n*2);
  for(;i<97;i++)printf("%*s|\n",44,i-96?"|--------":"|________");
}
Level River St
źródło
1

Rakieta 223 220 211 204 198

Gra w golfa:

(for-each display(flatten(let([m make-list])`(,(for*/list([i 10][j(range(* i 3)(* 4(+ 1 i)))])`(,(m(- 39 j)" ")"/",(m j"**")"\\\n")),(for/list([c`(,@(m 11"-")"_")])`(,(m 35" ")"|",(m 8 c)"|\n"))))))

Nie golfowany:

(for-each display
     (flatten
      (let([m make-list])
        `(,(for*/list([i 10][j(range(* i 3)(* 4(+ 1 i)))])
             `(,(m(- 39 j)" ")"/",(m j"**")"\\\n"))
          ,(for/list([c`(,@(m 11"-")"_")])
             `(,(m 35" ")"|",(m 8 c)"|\n"))))))
Matthew Butterick
źródło
1

Zestaw (MIPS, SPIM) , 768 671 659 655 654 bajtów

.text
.globl main
main:
li $8 32
li $9 47
li $t2 42
li $t3 92
li $t4 10
li $t5 42
addi $sp -4
move $4 $sp
la $s6 q
la $s5 w
li $t8 0
li $s0 10
li $t9 0
li $s3 40
li $s2 39
q:
sub $s3 $s3 $t8
add $s2 $s2 $t8
addi $t7 $t8 3
addi $t8 1
blt $s0 $t8 e
r:
sw $0 ($4)
blt $t9 $s2 t
beq $t9 $s2 y
beq $t9 $s3 u
beqz $t7 i
sb $t2 ($4)
p:
li $2 4
syscall
addi $t9 1
ble $t9 $s3 r
move $t9 $0
j $s5
o:
addi $t7 -1
bgez $t7 r
jr $s6
w:
addi $s2 -1
addi $s3 1
j o
t:
sb $8 ($4)
j p
y:
sb $9 ($4)
j p
u:
sb $t4 1($4)
sb $t3 ($4)
j p
i:
sb $t5 ($4)
j p
e:
li $t1 124
li $t3 124
li $t2 45
li $t5 95
li $t7 11
la $s6 a
la $s5 o
li $s2 35
li $s3 44
j r
a:
li $2 10
syscall

Wypróbuj online!

Edycja: Zapisano ~ 100 bajtów, kodując na stałe każdy znak w rejestrze i po prostu zapisując na stosie, a następnie nadużywając faktu, że MIPS nie ma typów, więc dozwolone jest niejawne słowo do łańcucha ascii.
Edycja 2: usunięto zduplikowany przydział stosu. ( addi $sp -4) Ups!
Edycja 3: w przepisaniu przypadkowo spowodował, że pień drzewa o 1 znak jest za krótki. (36 zamiast 35). Naprawiony.
Edytuj 4: -4 bajty za pomocą 8 $ i 9 $ zamiast $ t0 i $ t1. oznaczają to samo, ale $ t0 jest łatwiejszy do odczytania. niestety, wszystkie inne rejestry t mają tę samą długość, jeśli są ładnie napisane ($ t2 == 10 $, ale oba mają 3 znaki), więc pozostałe są praniem. Mógłbym (teoretycznie) użyć pozostałych rejestrów „a” (5-7. Print syscall używa 4), ale po zachowaniu nie jest zdefiniowane zachowanie podczas korzystania z syscall.
-1 bajt przez ustawienie t8 na 0 i rozgałęzienie na mniej niż zamiast na równy. wymagał też ode mnie zmiany kolejności dodawania operacji, co niestety wydłużyło czas wykonania aż o 3 dodatkowe kody dłużej.

Nie najlepsze w MIPS, ale po oczyszczeniu sumienia z tego w meta dyskusji, przesyłam je. MIPS nie jest do tego przeznaczony (brak danych wyjściowych, brak pętli), ale mimo to fajnie jest to robić.

Niestety nie stworzyłem skomentowanej wersji tego nowego rozwiązania, ale możesz wyświetlić starą wersję z pełną dokumentacją tutaj

Zachęcam do wzięcia udziału i poprawy tej odpowiedzi, jeśli możesz ją pokonać - prawdopodobnie brakuje mi tu kilku optymalizacji.

Andrew Baumher
źródło
ponieważ to rozwiązanie nie wymaga .data, można przekonwertować na binarne (skompilowane) i zapisać kilka bajtów. jednak SPIM go nie obsługuje, więc c'est la vie.
Andrew Baumher
Nie jestem też pewien, czy addi $sp -4tak naprawdę skrót addi $sp $sp -4pochodzi od SPIM lub MIPS, więc jeśli ktokolwiek to zrobi, daj mi znać.
Andrew Baumher
0

Kobra - 166 228 260

class P
    def main
        for x in 10,for n in 4+x,print' '.repeat(39-x*3-n)+'/['**'.repeat(x*3+n)]\\'
        w=' '.repeat(35)
        print'[w]|--------|\n'.repeat(11)+w+'|________|'
Obrzydliwe
źródło