Czy możesz zrobić mi sześciokąt?

53

Dzisiaj zrobimy sześciokąt ASCII. Musisz napisać program lub funkcję, która przyjmuje dodatnią liczbę całkowitą n i wyprowadza sześciokątną siatkę o rozmiarze n , złożoną z gwiazdek. Na przykład sześciokąt wielkości 2 wygląda następująco:

 * *
* * *
 * *

Podczas gdy sześciokąt wielkości 3 wygląda następująco:

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

Możesz użyć dowolnej z domyślnych metod wejścia i wyjścia , na przykład STDIO / STDOUT, argumentów funkcji i zwracanych wartości lub odczytu / zapisu pliku.

Możesz założyć, że dane wejściowe są zawsze prawidłowe, więc jeśli nie jest to dodatnia liczba całkowita, twój program może zrobić, co chcesz. Ci mają jednak trzeba obsłużyć szczególny przypadek rozmiar 1 sześciokąta, co dzieje się pojedyncza gwiazdka:

*

Wiodące i końcowe białe znaki są dozwolone, pod warunkiem, że wynik jest wizualnie taki sam.

Przykłady:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

Jak zwykle jest to , więc obowiązują standardowe luki i powinieneś spróbować napisać możliwie najkrótszy program mierzony w bajtach. Oczywiście niektóre języki są z natury krótsze lub dłuższe niż inne, więc pamiętaj, że celem niekoniecznie jest uzyskanie najkrótszej ogólnej liczby bajtów, ale pokonanie zgłoszeń w tych samych lub podobnych językach.

Niech zwycięży najlepszy golfista!

DJMcMayhem
źródło
15
Dlaczego mamy nawet znacznik siatki sześciokątnej?
Pavel
13
Ponadto ktoś musi napisać rozwiązanie sześciokąta.
Pavel
Jeśli ktoś chce zdobyć nagrodę, prawdopodobnie ponownie użyjesz pętli wyjściowej mojej odpowiedzi Hexagony tutaj .
Martin Ender
6
„Czy mógłbyś zrobić ze mnie sześciokąt?” - jasne, proszę bardzo
aditsu
@Pavel, ponieważ wiele operacji na siatce sześciokątnej różni się od bardziej standardowej siatki kwadratowej i jest przenośny między rozwiązaniami różnych problemów. Takie operacje, jak manipulowanie współrzędnymi, obrót, układ wyjściowy itp.
Sparr

Odpowiedzi:

37

Hexagony + Bash Coreutils, 0 + 3 + 8 = 11 bajtów

Obejmuje +3 za -gflagę i +8 za |tr . \*niestandardowe wywołanie (zobacz ten meta post )


Dane wejściowe są przekazywane jako argument do Hexagony. Po wywołaniu interpretera Sześciokąta z -g Nopcją drukuje sześciokąt .s. Następnie używamy tr, aby zastąpić je *s.

Riley
źródło
2
Wow, to genialne. I pokonujesz wszystkie języki gry w golfa!
DJMcMayhem
6
Tak naprawdę nie nazwałbym tego przy użyciu języka Hexagony, bardziej jak użycie bash (lub innej powłoki) z interpreterem Hexagony jako jednego z poleceń. Byłoby to np. Przy hexagony -g $1|tr . \*założeniu, że interpreter heksagonu ma taką nazwę.
Paŭlo Ebermann
3
Przydałoby się
1
@ jpmc26 Dla heksa o długości 5 biegnieszruby ./interpreter.rb -g 5|tr . \*
Riley
3
@OlivierDulac „Program” ma zero bajtów. Całą pracę wykonują „flagi”.
Riley
20

Python 2, 61 bajtów

i=n=input()
while~-n+i:i-=1;j=abs(i);print' '*j+'* '*(2*n+~j)

Drukuje końcowe spacje na końcu każdej linii.

Dzięki Erikowi Outgolferowi za uratowanie bajtu.

xnor
źródło
Zaczynając od tego, otrzymujesz nie PEP8, ale poprawny kod Pythona 3 z 69 bajtami, int(input())zamiast input()zwykłego print(' '*j+'* '*(2*n+~j))zastępowania print' '*j+'* '*(2*n+~j)- fajny kod btw ;-)
Dilettant
To jest naprawdę fajny kod!
Matias Bjarland,
13

JavaScript (ES6), 77 81 84

@Upvoters: nie przegap odpowiedzi autorstwa @ETHproductions, czyli 76 bajtów

Edytuj Zmieniono po zmianie specyfikacji, dozwolone końcowe miejsce

Tylko na czapkę ... hej! Nie ma kapelusza?

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o

Test

f=(n,b='* '.repeat(n+n-1),o=b)=>--n?f(n,b=` ${b}`.slice(0,-2),b+`
${o}
`+b):o


function update()
{
  O.textContent=f(+I.value)
}

update()
<input id=I type=number min=1 value=3 oninput='update()'>
<pre id=O></pre>

edc65
źródło
11

Sześciokąt , 91 87 86 bajtów

?{2'*=&~}=&}='P0</0P}|@..;>;'.\};0Q/..\&(<>"-_"&}=\?_&\/8.=-\<><;{M/.(.(/.-{><.{&'/_.\

Wypróbuj online!

W końcu to zrobiłem.

Początkowo (zanim zdam sobie sprawę z tego, jak drogie są pętle) spodziewam się, że może zmieścić się w boku o długości 5, ale teraz trudno jest dopasować go do boku o długości 6.

Aby to uzyskać, muszę trochę zmodyfikować kod liniowy. W rzeczywistości napisanie tego sprawia, że ​​zdaję sobie sprawę z golfa kodu liniowego o 1 2 bajty.

użytkownik202729
źródło
10

JavaScript (ES6), 77 76 bajtów

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

Powiedziałem sobie, że nie będę spał, dopóki nie ustanowię nowego rekordu ES6, nie patrząc na inne odpowiedzi, więc oto ...

Testowy fragment kodu

g=(n,s=`
*`+' *'.repeat(n*2-2),c=s,q=c.replace('*',''))=>--n?g(n,q+s+q,q):s

for(var i = 1; i < 7; i++) console.log(g(i)) // joe

ETHprodukcje
źródło
10

C, 91 89 80 74 bajty

w,y;f(s){for(y=-s;++y<s;)for(w=printf("\n%*s",y,"");++w<s*printf(" *"););}

Prawie poprawiłem, aby uzyskać prawidłowe formuły, a następnie zmiksowałem wszystko razem.

Zadzwoń fz numerem n , a wydrukuje sześciokąt na stdout.

Niegolfowane i wyjaśnione (wersja 80-bajtowa):

w,y;
f(s) {
    // y iterates over [-s + 1 ; s - 1] (the number of rows)
    for(y = -s; ++y < s;)
        // w iterates over [abs(y) + 2 ; s * 2 - 1] (the number of stars on the row)
        for(
            // This prints a backspace character (ASCII 8)
            // padded with abs(y) + 2 spaces, effectively
            // printing abs(y) spaces to offset the row.
            // Also initializes w with abs(y) + 2.
            printf("\n%*c", w = abs(y) + 2, 8);

            // This is the for's condition. Makes use
            // of the 2 returned by printf, since we coïncidentally
            // need to double the upper bound for w.
            w++ < s * printf("* ");

            // Empty for increment
        )
            ; // Empty for body
}

Zobacz na żywo na Coliru

Uwagi:

  • printfradzi sobie z dopełnieniem ujemnym, co powoduje wyrównanie do lewej strony z dopełnieniem po prawej stronie. Próbowałem więc czegoś takiego, aby w = printf("%*c*", y, ' ')zajął się wartością bezwzględną i mogłem odzyskać ją z wartości zwracanej. Niestety zarówno szerokość wypełnienia zero, jak i jedna, same drukują znak, więc trzy linie środkowe były identyczne.
    Aktualizacja: Jasen znalazł sposób, aby to zrobić, drukując pusty ciąg zamiast znaku - wygolono 6 bajtów!

  • Znak cofania jest nieprawidłowo obsługiwany przez Coliru - wykonanie tego kodu na lokalnym terminalu usuwa początkowe odstępy w każdym wierszu.

Quentin
źródło
w=printf("\n%*s",abs(y),"");++w<s*printf(" *");
Jasen
@Jasen Nie mogę uwierzyć, że tęskniłem ... Dzięki!
Quentin,
9

05AB1E , 14 13 bajtów

Kod:

F¹N+„ *×})û.c

Wyjaśnienie:

F       }        # Input times do (N = iteration number)
 ¹N+             #   Calculate input + N
    „ *×         #   Multiply by the string " *"
         )       # Wrap everything into an array
          û      # Palindromize the array
           .c    # Centralize

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Adnan
źródło
1
Nie rozumiem, co robi część „scentralizowana”. Kiedy go usuwam, otrzymuję tablicę ciągów bez odpowiedniej liczby spacji wiodących.
DJMcMayhem
1
@DJMcMayhem Na tablicy można zobaczyć, że jest to ciąg połączony znakami nowej linii z wyrównanym środkiem tekstu. To właśnie robi na wejściu.
Adnan
8

Galaretka , 24 bajty

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY

Wypróbuj online!

Galaretka wstydzi się tego, że nie ma atomu centralizującego, więc została pobita przez 05AB1E i V. O odpowiednio 11 i 7 bajtów!

Jeśli znajdziesz jakiś sposób na grę w golfa, prosimy o komentarz. Każda pomoc jest mile widziana.

Objaśnienie :

R+’µạṀx@€⁶żx@K¥€”*$F€ŒḄY Main link. Arguments: z.
R+’                      The sizes of the hexagon's rows. (implicit argument)
   µ                     Start a new monadic chain with the above argument.
    ȧṀx@€⁶               The spaces you must prepend to each row. (implicit argument)
           x@K¥€”*$      The stars (points) of each row, space-joined, as a single link. (implicit argument)
          ż        F€    Conjoin and merge the leading spaces with the stars appropriately.
                     ŒḄ  Create the second half of the hexagon without the middle row.
                       Y Join the rows with newlines. This makes the shape look like a hexagon.

Premia: Aby sprawdzić, ile gwiazdek jest w sześciokącie, użyj tego:

Ḷ×6S‘
Erik the Outgolfer
źródło
2
Uff, wyjaśnienie było przytłaczające.
Erik the Outgolfer,
Co zrobiłby „atom centralizacji”?
DJMcMayhem
@DJMcMayhem Zobacz przykład 05AB1E.
Erik the Outgolfer,
7

Oktawa, 62 58 bajtów

@(n)' *'(dilate(impad(1,2*--n,n),[k='01010'-48;~k;k],n)+1)

Poprzednia odpowiedź:

@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1)

można to nazwać jako

(@(n)' *'(dilate(impad(1,2*(m=n-1),m),[k='01010'-48;~k;k],m)+1))(5)

Wypróbuj (wklej) w Octave Online

Na przykład obraz podstawowy n=5to

0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

które można utworzyć za pomocą

impad(1,2*(n-1),n-1)

Że dilation morphological operatorzastosowano 4 razy na obrazie stosując następujące maski sąsiada:

0 1 0 1 0
1 0 1 0 1
0 1 0 1 0

które można utworzyć za pomocą [k='01010'-48;~k;k]

wynik dylatacji:

0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1
0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0
0 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 0
0 0 0 1 0 1 0 1 0 1 0 1 0 1 0 0 0
0 0 0 0 1 0 1 0 1 0 1 0 1 0 0 0 0

następnie zamień 0 i 1 odpowiednio na „” i „*”

    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *
rahnema1
źródło
6

postgresql9.6, 290 bajtów

do language plpgsql $$ declare s constant smallint:=4;declare n smallint;declare a constant int[]:=array(select generate_series(1,s));begin foreach n in array a||array(select unnest(a)t order by t desc offset 1)loop raise info'%',concat(repeat(' ',s-n),repeat(' *',s+(n-1)));end loop;end;$$

sformatowany sql jest tutaj:

do language plpgsql $$
declare s constant smallint := 4;
declare n smallint;
declare a constant int[] := array(select generate_series(1, s));
begin
foreach n in array a || array(select unnest(a)t order by t desc offset 1) loop
    raise info '%', concat(repeat(' ', s - n), repeat(' *', s + (n - 1)));
end loop;
end;
$$;

wynik:

INFO:      * * * *
INFO:     * * * * *
INFO:    * * * * * *
INFO:   * * * * * * *
INFO:    * * * * * *
INFO:     * * * * *
INFO:      * * * *
andryk
źródło
lpadmoże być w stanie zaoszczędzić ci kilka bajtów. Nazwałbym też język pl / pgsql, ale to rodzi pytania o to, czy trzeba liczyć do language plpgsql $$i zamknięcie $$;. Najlepiej byłoby, gdyby adresowano je na meta, jeśli wcześniej nie pojawiły się.
jpmc26
Ponadto, dlaczego potrzebujesz wielu DECLAREs? Czy ani jeden nie działałby?
jpmc26
6

V , 17 bajtów

é*À­ñ>{MÄpXA *Î.

Wypróbuj online!

Jak zwykle, tutaj jest zrzut heksowy, ponieważ zawiera on niedrukowalne znaki:

00000000: e92a c0ad f13e 7b4d c470 5841 202a 1bce  .*...>{M.pXA *..
00000010: 2e                                       .
DJMcMayhem
źródło
6

APL (Dyalog Unicode) , 40 36 35 33 27 25 bajtów

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨

Zakłada ⎕IO←0, tj. Indeksowanie od zera. Dane wyjściowe zawierają jedną spację wiodącą i jedną spację końcową w każdym wierszu.

Ogromne podziękowania dla @FrownyFrog i @ngn za dużo gry w golfa.

Wypróbuj online!

Jak to działa

(⍉⊖⍪1↓⊢)⍣2∘↑⍳↓¨∘⊂'* '⍴⍨+⍨   Main function train
                 '* '⍴⍨+⍨     Repeat '* ' up to length 2×⍵
            ⍳↓¨∘⊂             Generate lower-right corner of the hexagon
          ∘↑                  Convert to matrix
(⍉⊖⍪1↓⊢)                      Palindromize vertically and transpose
        2                    ... twice
Bubbler
źródło
5

JavaScript (ES6), 83 81 bajtów

To moja pierwsza odpowiedź (code golf). Mam nadzieję, że sformatowałem wszystko poprawnie.

a=>{for(b=c=2*a-1;c;)console.log(" ".repeat(d=Math.abs(a-c--))+"* ".repeat(b-d))}

W przeciwieństwie do 2 bieżących odpowiedzi ES6, nie wywołuję rekurencyjnie funkcji i używam konsoli do wyjścia.

Łukasz
źródło
Czy możesz użyć, alertjeśli określisz js przeglądarki?
FlipTack,
@FlipTack, niezupełnie, ponieważ stopniowo buduję ciąg (linia po linii). Gdybym to alertzredagował, ostrzegałby linia po linii, a nie całość.
Łukasz
5

Haskell, 99 97 79 bajtów

h n=mapM_(putStrLn.(\k->([k..n]>>" ")++([2..n+k]>>"* ")))([1..n-1]++[n,n-1..1])

Objaśnienie: Program ten opiera się na spostrzeżeniu, że każda linia n-Hexagon zawiera (nk) spacje, po których następują gwiazdki (n + k-1), dla niektórych k zależnych od numeru linii.

h n=                                             h is a function of type Int -> IO ()
  mapM_                                          mapM_ executes a function returning 
                                                 monadic actions on all objects 
                                                 in a list, in order. Then it executes 
                                                 these actions, in order. For this code, it 
                                                 transforms each value in the list into a 
                                                 monadic action that prints 
                                                 the corresponding line

      (                                          the function consists of two components
        putStrLn                                 the second part is printing the result of 
                                                 the first part to stdout 

        .                                        concatenating both components

        (\k->                                    the first parts first prints (n-k) spaces 
                                                 and then (n+k-1) asterisks

          ([k..n]>>" ")                          create the list of the integers from 
                                                 k to n (That is actually one more entry
                                                 than necessary, but just results in a
                                                 leading whitespace per line, while
                                                 saving 2 bytes compared to [1..n-k]).
                                                 Then create a new list where 
                                                 each element of that first list is 
                                                 replaced with the string " " and 
                                                 concatenate that result into one string

          ++                                     concatenate both lists

          ([2..n+k]>>"* ")                       create the list of the integers 
                                                 from 2 to n+k (of length n+k-1). 
                                                 Then create a new list where each 
                                                 element of that first list is replaced 
                                                 with the string "* " and concatenate 
                                                 that result into one big string
        ) 

      )         
      ([1..n-1]++[n,n-1..1])                     the list simply goes from 1 to n and 
                                                 back, supplying the k 

Edycja: Przełączono na mapM_. Nie wiedziałem, że jest dostępny bez użycia importu

Sacchan
źródło
5

Python 2 , 100 97 89 88 87 81 79 bajtów

-1 z @ Flp.Tkc

-6 ponownie od @Flp

-2 dzięki dzięki @ nedla2004. Próbowałem znaleźć sposób na pozbycie się drugiego plasterka, ale nie pomyślałem o tym :)

i=input()
a=[" "*(i-x)+"* "*(i+x)for x in range(i)]
print'\n'.join(a+a[-2::-1])

Wypróbuj online!

Tworzy tablicę dla górnej połowy, następnie dodaje tablicę odwróconą minus środkową linię, a następnie drukuje. Drukuje dokładnie tak, jak jest, poza 1tym, że drukuje ze spacją wiodącą (wydaje mi się, że dozwolone jako a *jest wizualnie takie samo jak *z lub bez spacji wiodącej).

ElPedro
źródło
1
To daje złe rozwiązanie dla 1 - „*”. Myślę, że powinna to być gwiazdka bez miejsca z przodu?
Андрей Ломакин
@ АндрейЛомакин - From OP: „Wiodące i końcowe białe znaki są dozwolone, o ile dane wyjściowe są wizualnie takie same”. Pojedyncza gwiazda jest wizualnie taka sama jak pojedyncza gwiazda ze spacją przed nią, a przynajmniej taka była moja interpretacja ;-)
ElPedro
Ale w rzeczywistości masz rację, ponieważ zaprzeczam temu, co właśnie powiedziałem w mojej odpowiedzi. Zaktualizowałem odpowiedź, aby wyjaśnić. Lepiej teraz? BTW, niezła robota w znalezieniu starej odpowiedzi i wykryciu potencjalnego błędu. Szacunek.
ElPedro
1
Sam próbowałem tego wyzwania i nie mogę wymyślić nic lepszego, szukałem twojego inspiracji.
Андрей Ломакин
Mam nadzieję, że mój skromny wysiłek ci pomógł. Pewnie, że w przyszłości będziemy się razem bawić w golfa. Ciesz się PPCG. I sure do ☺
ElPedro
4

Partia, 161 bajtów

@echo off
set s=*
set l=for /l %%i in (2,1,%1)do call 
%l%set s= %%s%% *
%l%echo %%s%%&call set s=%%s:~1%% *
echo %s%
%l%set s= %%s:~0,-2%%&call echo %%s%%

Uwaga: Końcowe spacje w linii 2. Nie golf:

@echo off
set s=*
rem build up the leading spaces and stars for the first row
for /l %%i in (2,1,%1) do call :s
rem output the top half of the hexagon
for /l %%i in (2,1,%1) do call :t
rem middle (or only) row
echo %s%
rem output the bottom half of the hexagon
for /l %%i in (2,1,%1) do call :b
exit/b
:s
set s= %s% *
exit/b
:t
echo %s%
rem for the top half remove a space and add a star to each row
set s=%s:~1% *
exit/b
:b
rem for the bottom half add a space and remove a star from each row
set s= %s:~0,-2%
echo %s%
exit/b
Neil
źródło
4

JavaScript (ES6), 83 bajty

f=
n=>[...Array(n+--n)].map((_,i,a)=>a.map((_,j)=>j<n-i|j<i-n?``:`*`).join` `).join`
`
<input type=number min=1 oninput=o.textContent=f(+this.value)><pre id=o>

Neil
źródło
4

Płótno , 9 bajtów

╷⁸+* ×]/─

Wypróbuj tutaj!

Pokonanie wbudowanego: D

Wyjaśnienie:

{╷⁸+* ×]/─  implicit "{"
{      ]    map over 1..input
 ╷            decrement: 0..input-1
  ⁸+          add the input: input..(input*2-1)
    * ×       repeat "* " that many times
        /   diagonalify that - pad each line with 1 less space than the previous
         ─  palindromize vertically

Nie mam pojęcia, dlaczego jest to duża wyściółka, ale jest to dozwolone i naprawię to wkrótce ™. naprawiony? Mam nadzieję, że nic nie zepsułem

dzaima
źródło
3

Perl 6 , 49 bajtów

->\n{say " "x n*2-1-$_~"*"xx$_ for n...n*2-1...n}

Wypróbuj online!

Jak to działa

->\n{                                           }  # Lambda accepting edge size (e.g. 3)
                               for n...n*2-1...n   # For each row-size (e.g. 3,4,5,4,3):
                       "*"xx$_                     # List of stars     (e.g. "*","*","*")
         " "x n*2-1-$_                             # Spaces to prepend (e.g. "  ")
                      ~                            # Concatenate.      (e.g. "  * * *")
     say                                           # Print
smls
źródło
3

PowerShell, 91 89 78 68 63 52 48 bajtów

param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}

Skrypt testowy:

$script = {
param($n)$n..1+1..$n|gu|%{' '*$_+'* '*(2*$n-$_)}
}

12,6,5,4,3,2,1 |%{
    $_
    . $script $_
}

Wyjście (dodatkowa spacja):

12
            * * * * * * * * * * * *
           * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * * *
          * * * * * * * * * * * * * *
           * * * * * * * * * * * * *
            * * * * * * * * * * * *
6
      * * * * * *
     * * * * * * *
    * * * * * * * *
   * * * * * * * * *
  * * * * * * * * * *
 * * * * * * * * * * *
  * * * * * * * * * *
   * * * * * * * * *
    * * * * * * * *
     * * * * * * *
      * * * * * *
5
     * * * * *
    * * * * * *
   * * * * * * *
  * * * * * * * *
 * * * * * * * * *
  * * * * * * * *
   * * * * * * *
    * * * * * *
     * * * * *
4
    * * * *
   * * * * *
  * * * * * *
 * * * * * * *
  * * * * * *
   * * * * *
    * * * *
3
   * * *
  * * * *
 * * * * *
  * * * *
   * * *
2
  * *
 * * *
  * *
1
 *

Wyjaśnienie:

param($n)           # define script parameter
$n..1+              # int range from n to 1 step -1; append
1..$n|              # int range from 1 to n
gu|                 # alias for Get-unique eliminates equal neighbors - here is 1,1 -> 1
%{                  # for each int from [n, n-1, n-2, ... 2, 1, 2, ... n-2, n-1, n]
    ' '*$_+         # string (' ' have repeated $_ times) append
    '* '*(2*$n-$_)  # string ('* ' have repeated 2*n-$_ times)
}
mazzy
źródło
1
Niezłe wykorzystanie gu.
AdmBorkBork
3

PHP, 83 79 bajtów

for($p=str_pad;++$y<2*$n=$argn;)echo$p($p("
",1+$k=abs($n-$y)),4*$n-$k-2,"* ");

Uruchom jako potok z -nRlub spróbuj online .


Jest to bliskie odpowiedzi Kodos ; ale str_padjest krótszy niż str_repeatnawet podczas gry w golfa.
A ++w głowie pętla oszczędza trochę więcej.

Tytus
źródło
2

Rubinowy, 54 bajty

->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

Funkcja lambda przyjmuje n jako argument i zwraca ciąg oddzielony znakami nowej linii. ( $/jest zmienną zawierającą domyślny separator linii).

w programie testowym

f=->n{(1-n..n-1).map{|j|i=j.abs;' '*i+'* '*(n*2+~i)}*$/}

puts f[gets.to_i]
Level River St
źródło
Możesz zapisać 1 bajt, używając (1-n ... n) z 3 kropkami
PL
Wydaje się, że konsensus polega na włączeniu kodu wyjściowego (tj. puts) Do liczby znaków. Ale ponowne odczytanie definicji mówi tylko, że twoja funkcja powinna „wypisać” wynik, który można odczytać jako „zwrócenie” wyniku. Fajne rozwiązanie.
Matias Bjarland,
@MatiasBjarland meta.codegolf.stackexchange.com/a/2456/15599
Level River St
2

SmileBASIC, 74 bajty

FOR I=0TO N-1P
NEXT
FOR I=N-2TO.STEP-1P
NEXT
DEF P?" "*(N-I);"* "*(N+I)END

Dodaje wiodące i końcowe miejsce.

Te „sześciokąty” wyglądają okropnie, gdy postacie mają tę samą szerokość i wysokość ...

12Me21
źródło
2

rakieta / program

(define (f n)
  (define (s t n)
    (if (= n 0) t (s (~a t "* ") (- n 1))))
  (define (h t p a i)
    (if (= i 0)
        (display t)
        (let ((x (~a t (make-string p #\space) (s "" a) "\n"))
              (q (if (> i n) (- p 1) (+ p 1)))
              (b (if (> i n) (+ a 1) (- a 1))))
          (h x q b (- i 1)))))
  (h "" (- n 1) n (- (* 2 n) 1)))

testowanie:

(f 1)
*

(f 4)
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *
Kevin
źródło
3
Witamy na stronie! To zawody w golfa kodowego, dlatego należy podać liczbę bajtów. Możesz również usunąć wiele białych znaków obecnych w tej odpowiedzi, aby je skrócić.
Wheat Wizard
Dziękujemy za Twój wkład, Cat Wizard. Jestem nowy w golfie kodowym i przypuszczam, że schemat nie jest najlepszym językiem dla niego, ale postaram się go skrócić, wyeliminować białe znaki i dodać liczbę bajtów przy następnym wpisie.
Kevin
2

Python 2, 111 bajtów

n=input()
l=range(n,2*n-1)
S=l+[2*n-1]+l[::-1]
W=range(1,n)
for w in W[::-1]+[0]+W:print" "*w+"* "*S[0];S=S[1:]

Nudna, prosta implementacja (i pełny program). Zwraca końcowe białe znaki w każdej linii.

Przypadki testowe:

1:
*

2:
 * * 
* * * 
 * * 

3:
  * * * 
 * * * * 
* * * * * 
 * * * * 
  * * * 

4:
   * * * * 
  * * * * * 
 * * * * * * 
* * * * * * * 
 * * * * * * 
  * * * * * 
   * * * * 
Yytsi
źródło
2

JavaScript (ES6), 143 bajty

Nareszcie jest przerwa świąteczna (wesołych świąt!), Więc mam trochę czasu na grę w golfa.
A chłopcze minęło trochę czasu - stąd duża liczba bajtów.
Tutaj idzie:

c=[];a=a=>{for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}for(j=c.length-2;j>-1;j--)c.push(c[j]);return a==1?"*":c.join`\n`}
console.log(a(3));

Łysa Bantha
źródło
2
Kilka ulepszeń: for(j=c.length-2;j>-1;j--)c.push(c[j])można napisać jak for(j=a-1;j;c.push(c[--j]))i for(i=0;i<a;i++){c.push(" ".repeat(a-i-1)+"* ".repeat(i+a-1)+"*")}można for(i=0;i<a;c.push(" ".repeat(a-i-1)+"* ".repeat(a-1+i++));. Instrukcja return może zostać skrócona do return a-1?c.join\ n :"*"W sumie zmiany te zapisują 18B (11 + 7 + 1).
Łukasz
2

Java, 157 149 129 127 bajtów

s->{for(int j=~--s,t;++j<=s;p(s-~s-t,"* "),p(1,"\n"))p(t=j<0?-j:j," ");};<T>void p(int j,T s){for(;j-->0;)System.out.print(s);}
  • 8 bajtów usuniętych przez Jonathana Frecha.
  • 20 bajtów usuniętych przez Kevina Cruijssena.
  • 2 bajty usunięte przez Kevina Cruijssena.

Wypróbuj online!

Eugene
źródło
1
149 bajtów .
Jonathan Frech
1
94 bajty. UWAGA: Java 11 ma String#repeat(int), ale TIO to wciąż JDK 10, stąd emulowana repeat(String,int)metoda (z tą samą liczbą bajtów). Rzeczywisty kod w Javie 11 to:s->{for(int j=~--s,t;++j<=s;System.out.println(" ".repeat(t)+"* ".repeat(s-~s-t)))t=j<0?-j:j;}
Kevin Cruijssen
1
@Eugene Sure. :) W takim przypadku niektóre rzeczy do gry w aktualną wersję Java (8+) na razie: 129 bajtów .
Kevin Cruijssen
1
@KevinCruijssen To dość ciężka gra w golfa, zaktualizowałem ją, dzięki.
Eugene
1
Znowu ja. Znalazłem jeszcze jedną rzecz do gry w golfa za -2 bajty. 127 bajtów Może to być również użyte do golfa 1 bajta w powyższym rozwiązaniu Java 11 .
Kevin Cruijssen
2

Sześciokąt (liniowy), 128 127 126 bajtów

Zauważ, że to nie jest heksagonia, tylko (meta-) język Timwi obsługiwany w Esoteric IDE, więc nie kwalifikuje się do nagrody.

Można to jednak przekonwertować na rozwiązanie sześciokątne (i myślę, że będzie mniejsze niż to rozwiązanie), mogę to zrobić później. Potrzebuję więcej wysiłku , żeby to tutaj zrobić .

Inicjał zajmuje 3 bajty ( e2 9d a2). Każda nowa linia zajmuje 1 bajt ( 0a).

❢?{2'*=(
A
if > 0
 "-"&}=&~}=&}=?&
 B
 if > 0
  }P0;'(
  goto B
 &{&'-{=-(
 C
 if > 0
  'P0;Q0;}(
  goto C
 {M8;{(
 goto A
@

Nie Wypróbuj online! Działa to tylko w Esoteric IDE.

Kod z adnotacjami:

❢?        # read input n
[n]
{2'*=(     # x = 2n-1
[x]
A
if > 0    # loop (x) from 2n-1 to 1
 "-      # a = x - n
 [a]
 "&}=&~}=&    # a = abs(a). Let K be this amount
 }=?&
 B
 if > 0       # print ' ' (a) times
  }P0;'(
  goto B
 &        # current cell = a (= K)
 {&       # a = n if K>0 else x
          # Note that K=abs(x-n). So if K==0 then x==n.
          # Therefore after this step a is always equal to n.
 '-{=-    # compute n-(K-n) = 2n+K
 (        # decrement, get 2n+K-1
 C
 if > 0   # print ' *' this many times
  'P0;Q0;}(
  goto C
 {M8;{    # print a newline, goto x
 (        # x -= 1
 goto A
@
użytkownik202729
źródło
2

Japt -R, 11 10 bajtów

Æ°çSi*Ãû ê

Wypróbuj (lub użyj TIO, aby uruchomić wiele testów)


Wyjaśnienie

               :Implicit input of integer U
Æ              :Map the range [0,U)
 °             :  Postfix increment U
  ç            :  Repeat
   S           :    Space
    i*         :    Prepend asterisk
      Ã        :End map
       û       :Centre pad each string with spaces to the length of the longest string
         ê     :Palindromise
               :Implicitly join with newlines and output
Kudłaty
źródło