Napisz najkrótszy możliwy program, który przyjmuje zestaw różnych liczb całkowitych dodatnich i generuje renderowanie ASCII koncentrycznych sześciokątów o tych długościach boków, wykonanych z ukośników, znaków podkreślenia, spacji i nowych linii.

Najkrótszy program w bajtach, liczony przez https://mothereff.in/byte-counter, wygrywa.

Przykłady

(Wyglądają lepiej przy mniejszych odstępach między wierszami).

Jeśli dane wejściowe to 1wyjście powinno być sześciokątem o długości boku 1:

 __ 
/  \
\__/

Zauważ, że dwa podkreślenia są używane na górze i na dole sześciokąta, więc jest on bardziej proporcjonalny.

Ogólnie rzecz biorąc, sześciokąt w rozmiarze N zawiera N cięć po każdej stronie pod kątem i 2 * N podkreślenia na górze i na dole.

Jeśli dane wejściowe to 1 2dane wyjściowe, powinny to być koncentryczne sześciokąty o długości boku 1 i 2:

  ____
 / __ \
/ /  \ \
\ \__/ /
 \____/

Jeśli wejście jest 1 3wyjściem powinno być:

   ______
  /      \
 /   __   \
/   /  \   \
\   \__/   /
 \        /
  \______/

Jeśli dane wejściowe to 1 3 2wyjściem powinno być:

   ______
  / ____ \
 / / __ \ \
/ / /  \ \ \
\ \ \__/ / /
 \ \____/ /
  \______/

itp.

Zasady we / wy

Dane wejściowe muszą pochodzić z wiersza polecenia lub standardowego wejścia, ale mogą być w dowolnym dogodnym formacie.

Na przykład możesz podać każdą liczbę jako argument wiersza poleceń: > myprogram 1 3 2lub możesz poprosić użytkownika o wprowadzenie liczb w postaci wstępnie sformatowanej listy:[1, 3, 2] .

Dane wyjściowe muszą przejść do standardowego lub najbliższego odpowiednika Twojego języka.

Dodatkowe zasady

• Dane wejściowe zawsze będą zbiorem wyraźnych liczb całkowitych dodatnich, niekoniecznie w dowolnej kolejności .
• Dane wyjściowe muszą ...
  • nie może zawierać żadnych innych znaków /\ _ i znaków nowej linii.
  • nie mają spacji końcowych ani niepotrzebnych spacji wiodących.
  • nie zawierają obcych początkowych linii, ale mogą mieć jedną opcjonalną nową linię.
• Jeśli nic nie jest wprowadzone, to nic nie wypisuje (z wyjątkiem jednej nowej linii).
• Jeśli to pomoże, możesz założyć, że wejściowe liczby całkowite są mniejsze niż 2 ¹⁶ .

CJam, 148 116 109 bajtów

Trwało to znacznie dłużej niż się spodziewałem. Początkowo chciałem po prostu iteracyjnie zbudować lewą górną ćwiartkę, tak jak w przypadku wyzwań z brylantami, a następnie pozyskać resztę z odbicia lustrzanego. Ale nie zauważyłem, że podkreślenia nie zachowują symetrii lustra między górną i dolną połową. Musiałem więc przerobić większość z nich, aby wygenerować iteracyjnie prawą połowę, a następnie tylko raz wykonać kopię lustrzaną (w lewo).

S]2[l~]:(f#:+2bW%{_,2/~:T;{IT):T1<'\'/?S?S++}%__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+}fI{)T)2*2$,-*1$W%"\/"_W%er@N}/

Sprawdź to tutaj.

Przykład Fibonacciego:

8 3 1 5 2

        ________________
       /                \
      /                  \
     /     __________     \
    /     /          \     \
   /     /   ______   \     \
  /     /   / ____ \   \     \
 /     /   / / __ \ \   \     \
/     /   / / /  \ \ \   \     \
\     \   \ \ \__/ / /   /     /
 \     \   \ \____/ /   /     /
  \     \   \______/   /     /
   \     \            /     /
    \     \__________/     /
     \                    /
      \                  /
       \________________/

Wyjaśnienie:

Jak stwierdzono u góry, zaczynam od iteracyjnego budowania prawej połowy. Oznacza to, że początkowo mam tylko jedną przestrzeń na siatce, a następnie dla każdego możliwego pierścienia albo otaczam istniejącą siatkę w przestrzeni, albo nowy pół-sześciokąt.

Gdy to zrobisz, odbijam lustro każdą linię po lewej stronie i wypełniam ją wiodącymi spacjami, aby uzyskać prawidłowe wyrównanie. Oto podział kodu:

"Prepare the input and the grid:";
S]2[l~]:(f#:+2bW%
S]                "Push string with a space and wrap it in an array. This is the grid.";
  2               "Push a 2 for future use.";
   [l~]           "Read and evaluate the input, wrap it in an array.";
       :(         "Decrement each number by 1.";
         f#       "Map each number i to 2^i.";
           :+     "Sum them all up.";
             2b   "Get the base two representation.";
               W% "Reverse the array.":
"At this point, the stack has the proto-grid at the bottom, and an array of 1s and
 0s on top, which indicates for each hexagon if it's present or not.";

"Next is a for loop, which runs the block for each of those 0s and 1s, storing the
 actual value in I. This block adds the next semi-hexagon or spaces.";
{ ... }fI

"First, append two characters to all existing lines:";
_,2/~:T;{IT):T1<'\'/?S?S++}%
_                            "Duplicate the previous grid.";
 ,2/                         "Get its length, integer-divide by 2.";
    ~:T;                     "Get the bitwise complement and store it in T. Discard it.";
        {                 }% "Map this block onto each line of the grid.";
         I                   "Push the current hexagon flag for future use.";
          T):T               "Push T, increment, store the new value.";
              1<'\'/?        "If T is less than 1, push \, else push /.";
                     S?      "If the current flag is 0, replace by a space.";
                       S++   "Append a space and add it to the current line.";

"So for hexagons this appends '\ ' to the top half and '/ ' to the bottom half.
 For empty rings, it appends '  ' to all lines.";

"Now add a new line to the top and the bottom:"    
__,2/=,2/I'_S?*_S+a@+\I'/S?S++a+
__                               "Get two copies of the grid.";
  ,2/                            "Get its length, integer-divide by 2.";
     =                           "Get that line - this is always the middle line.";
      ,2/                        "Get ITS length, integer'divide by 2.";
         I'_S?*                  "Get a string of that many _ or spaces depending on the 
                                  current flag.";
               _S+               "Duplicate and a space.";
                  a@+            "Wrap in an array, pull up the grid, and prepend the line.";
                     \           "Swap with the other copy.";
                      I'/S?      "Choose between / and a space depending on the flag.";
                           S++   "Append a space, and add both characters to the line.";
                              a+ "Wrap in an array, and append line to the grid.";

"This is all. Rinse and repeat for all rings. The result will look something like this:

_____ 
     \ 
___   \ 
__ \   \ 
_ \ \   \ 
 \ \ \   \ 
_/ / /   / 
__/ /   / 
___/   / 
      / 
_____/ 

Note that there are still trailing spaces.";

"Finish up all lines. These will not be joined together any more, but simply left
 on the stack in pieces to printed out back-to-back at the end of the program.
 The following runs the given block for each line:";
{ ... } /

"This generates the necessary indentation, then mirrors the lines and puts them
 in the right order:"
)T)2*2$,-*\_W%"\/"_W%er\N
)                         "Slice off that trailing space, but leave it on the stack.";
 T                        "Remember T? That still has something like the the size of
                           the grid from the last iteration. In fact it's N-1, where
                           N is the largest visible hexagon. We can use that to figure
                           out how many spaces we need.";
  )2*                     "Increment and double.";
     2$                   "Copy the current line.";
       ,-                 "Subtract its length from 2*N.";
         *                "Repeat the space that often. This is our indentation.";
          \_              "Swap with the line and duplicate.";
            W%            "Reverse the line.";
              "\/"_W%er   "Replace slashes with backslashes and vice versa.";
                       \  "Swap with the original line.";
                        N "Push a line break.";

Python - 251, 240, 239 228

l=input()+[0];m=max(l);A=abs;R=range
for j in R(2*m+1):print''.join([[' \\'[(A(j-i+m-1)/2.in l)*(2*m-i)/(j-m-.5)>1],'/'][(A(3*m-i-j)/2.in l)*(i-m-j+.5)/(j-.5-m)>0],'_'][(A(m-j)in l)*(A(2*m-i-.5)<A(m-j))]for i in R(4*m)).rstrip()

Alternatywne podejście (251):

l=input()+[0]
l.sort()
m=max(l)
M=2*m
s=[[' ']*m*4for j in' '*(M+1)]
for i in l:
 I=2*i;s[m-i][M-i:M+i]=s[m+i][M-i:M+i]='_'*I
 for k in range(i):K=k+1;s[m-k][M-I+k]=s[m+K][M+I-K]='/';s[m-k][M+I-K]=s[m+K][M-I+k]='\\'
for t in s:print''.join(t).rstrip()

APL (222 bajty w UTF-8)

(i 133 znaków)

Ponieważ pytanie to dotyczy konkretnie liczby bajtów w reprezentacji UTF8, musiałem trochę go rozholfować , aby było dłuższe, ale jego reprezentacja UTF8 jest krótsza. (W szczególności znak operatora dojeżdżania do pracy ⍨ma trzy bajty, a ()tylko dwa, więc optymalizacja już nie działa, a ponadto przypisywanie jest bardzo kosztowne).

{⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]

Poprzednia wersja, która jest krótsza w znakach (124), ale używa więcej bajtów, gdy jest reprezentowana w UTF-8 (230, co umieściłoby ją na drugim miejscu):

M←' '⋄{⎕←⍵/⍨~⌽∧\⌽⍵=M}¨↓⊃{⍵{⍺=M:⍵⋄⍺}¨K↑⍺↑⍨-.5×(K←⍴⍵)+⍴⍺}/{Z⍪⊖⌽Z←↑(⊂(⍵/M),'-'/⍨2×⍵),⍵{('/'↑⍨-⍵),'\',⍨M/⍨2 4-.×⍵⍺}¨⌽⍳⍵}¨N[⍋N←,⎕]

Test:

      {⎕←(~⌽∧\⌽⍵=' ')/⍵}¨↓⊃{⍵{⍺=' ':⍵⋄⍺}¨K↑(-.5×(K←⍴⍵)+⍴⍺)↑⍺}/{Z⍪⌽⊖Z←↑(⊂(⍵/' '),(2×⍵)/'-'),⍵{((-⍵)↑'/'),((2 4-.×⍵⍺)/' '),'\'}¨⌽⍳⍵}¨N[⍋N←,⎕]
⎕:
      3 1 5 2
     ----------
    /          \
   /   ------   \
  /   / ---- \   \
 /   / / -- \ \   \
/   / / /  \ \ \   \
\   \ \ \  / / /   /
 \   \ \ -- / /   /
  \   \ ---- /   /
   \   ------   /
    \          /
     ----------

Perl 5, 352 (349 bajtów + 3 dla anEflag)

Prawdopodobnie można by to znacznie pograć w golfa ..

@b=sort{$a>$b}@F;map{$_<$j||($j=$_)}@b;$k=++$j;for(;$j--;){$z=$"x$j;for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '} $z.=($j~~@b?'_':$")x(2*$j);$z.=$_~~@b?' \\':'  'for($j+1..$k-1);say$z}for(0..$k-2){$z=$"x$_;for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}$z.=(($_+1)~~@b?'_':$")x(2*$_+2);$z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1);say$z}

Nie golfowany:

# sort list of side lengths 
@b=sort{$a>$b}@F; 
# set $k and $j to max side length + 1
map{$_<$j||($j=$_)}@b;$k=++$j;
for(;$j--;){
  $z=$"x$j;
  for($e=$k;--$e>$j;){$z.=$e~~@b?'/ ':'  '}
  $z.=($j~~@b?'_':$")x(2*$j);
  $z.=$_~~@b?' \\':'  'for($j+1..$k-1);
  say$z
}
for(0..$k-2){
  $z=$"x$_;
  for($e=$k;--$e>$_;){$z.=($e-$k+1?$":'').($e~~@b?'\\':$")}
  $z.=(($_+1)~~@b?'_':$")x(2*$_+2);
  $z.=($_~~@b?'/':$").($_-$k+1?$":'')for($_+1..$k-1);
  say$z 
}

Przykład ( 1 5 3 14):

              ____________________________
             /                            \
            /                              \
           /                                \
          /                                  \
         /                                    \
        /                                      \
       /                                        \
      /                                          \
     /                 __________                 \
    /                 /          \                 \
   /                 /   ______   \                 \
  /                 /   /      \   \                 \
 /                 /   /   __   \   \                 \
/                 /   /   /  \   \   \                 \
\                 \   \   \__/   /   /                 /
 \                 \   \        /   /                 /
  \                 \   \______/   /                 /
   \                 \            /                 /
    \                 \__________/                 /
     \                                            /
      \                                          /
       \                                        /
        \                                      /
         \                                    /
          \                                  /
           \                                /
            \                              /
             \____________________________/

C # - 388 316 bajtów

Edycja: Zmieniono sposób, w jaki unika drukowania końcowych spacji i wrzucił w LINQ

Prosty program, który przyjmuje argumenty wiersza poleceń. Iteruje przez każdy możliwy znak w każdej linii prostokąta zdefiniowanego przez maksymalny wymiar sześciokąta i dołącza go do bieżącej linii, przed przycięciem linii i wydrukowaniem ich kolejno (tworzy opcjonalną końcową nową linię).

Kod do gry w golfa:

using System.Linq;class P{static void Main(string[]A){var I=A.Select(int.Parse);int m=I.Max(),i,j,y,x;for(j=m+1;j-->-m;){var r="";for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);)r+="/\\_- "[(x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?(i^j)&1:x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?j<0?2:3:4];System.Console.WriteLine(r);}}}

Nieskluczony kod:

using System.Linq; // all important

class P
{
    static void Main(string[]A)
    {
        var I=A.Select(int.Parse); // create int array

        for(int m=I.Max(),j=m+1,i,y,x;j-->-m;) // for each line...
        {
            var r=""; // current line

            for(i=-2*m-1;++i<2*m-(y=j<0?-j-1:j);) // for each char...
                r+="/\\_- "[// append something to the current line
                (x=i<0?-i-1:i)>y&(x+=y)%2>0&x/2<m&&I.Contains(x/2+1)?
                    (i^j)&1: // slashes as appropriate - I can't work out why this bit works, but it seems to
                x-y<(y=j<0?-j:j)&y<=m&I.Contains(y)?
                    j<0?2:3: // _ or - if required
                4]; // otherwise a space

            System.Console.WriteLine(r); // print current line
        }
    }
}

APL (Dyalog Classic) , 151 bajtów (93 z klasycznym kodowaniem APL)

{a←0⍴⍨1 0+1 2×n←⌈/⍵⋄a[⊃,/i,¨¨⍵+⍵-1+i←⍳¨⍵]←1⋄a←(⊖⍪-)a⋄a[⊃,/(n+⍵,-⍵),¨¨,⍨i]←2⋄' /_\'[4|(⌽,-)a]}

Wypróbuj online!