Wydrukuj siatkę sześcianu o określonym rozmiarze

26

Wyzwanie

Biorąc pod uwagę rozmiar s, wydrukuj siatkę sześcianu o tym rozmiarze wykonaną z symboli skrótu ( #) i spacji ( ).

Przykłady:

1:
  #
# # #    
  #
  #

2:
    # #
    # #
# # # # # #
# # # # # #
    # #
    # #
    # #
    # #

3:
      # # #
      # # #
      # # #
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
      # # #
      # # #
      # # #
      # # #
      # # #
      # # #

Siatką może być właściwie każda poprawna siatka kostki, która może się złożyć w kostkę, na przykład:

    # #
    # #
# # # # # # # #
# # # # # # # #
    # #
    # #

    # # # #
    # # # #
    # #
    # #
    # #
    # #
# # # #
# # # #

Zasady

  • Powstała siatka musi być poprawna geometrycznie (składana w kostkę)
  • Standardowe luki zabronione
  • Przeczytaj uważnie zasady
  • To jest , najkrótsza odpowiedź wygrywa, ale nie zostanie wybrana
dkudriavtsev
źródło
1
Czy mogą istnieć wiodące / końcowe spacje / nowe linie?
Kritixi Lithos
@KritixiLithos Tak
dkudriavtsev
13
Dla porównania, wszystkie 11 sieci sześcianów .
xnor
3
Co jeśli nie przeczytam dokładnie zasad?
steenbergh
1
@steenbergh Twoje rozwiązanie jest nieważne
dkudriavtsev

Odpowiedzi:

23

Python 2, 47 bajtów

n=input()
for c in 1,4,1:exec"print'# '*c*n;"*n

Wypróbuj online!

Drukuje tę siatkę, wybraną do wyrównania do lewej:

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# # 

Linie mają nlub 4*nkopie '# '. Dla każdego z nich 1,4,1drukujemy nrazy tyle kopii, zrobione nczasy dla nlinii. Posiadanie execpętli wewnątrz forpętli wydaje się marnotrawstwem, ale nie widziałem lepiej.

Alternatywy, które testowałem:

lambda n:('# '*n*3+'\n')*n+('  '*n+'# '*n+'\n')*3*n

lambda n:('# '*n*3+'\n')*n+(' '*4*n+'# '*n*3+'\n')*n

def f(n):
 for c in[3]*n+[1]*3*n:print('# '*c*n).center(6*n)

def f(n):
 for c in[4]*n+[0]*n:print' '*c*n+'# '*n*3

def f(n):
 for c in[1]*n+[4]*n+[1]*n:print'# '*c*n

def f(n):
 c=1;exec("print'# '*c*n;"*n+"c^=5;"*n)*3

def f(n):
 for i in range(3*n):print'# '*[1,4,1][i/n]*n

def f(n):
 for c in 1,4,1:print('# '*c*n+'\n')*n,

def f(n):
 for c in 1,4,1:exec"print'# '*c*n;"*n

(Wszystkie deffunkcje mogą być o jeden krótsze jako program).

xnor
źródło
8

Oktawa, 58 44 42 32 bajty

@(n)[z=repmat('# ',n);z,z,z,z;z]

częściowo zainspirowany pythonową odpowiedzią @xnor.

z=repmat('# ',n);

tworzy wzór squre z „#” dla danych wejściowych 2, następujący wzór:

# #             
# # 

y=[z,z,z,z];

cztery zsą połączone w poziomie:

# # # # # # # # 
# # # # # # # # 

[z;y;z]

zi ya zsą łączone w pionie

Wypróbuj online!

# #             
# #             
# # # # # # # # 
# # # # # # # # 
# #             
# #             

Poprzednia odpowiedź:

@(n){h(1:n,1:2:n*6)=1;h(1:n*4,n*2+1:2:4*n)=1;' #'(h+1)}{3}

Wypróbuj online!

Generuje kształt litery T.

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

Mathematica, 77 60 52 bajtów

Podziękowania dla Martina Endera za grę w golfa w odległości 8 bajtów!

{±s_:=s~Table~#;b=±{a=±"# ","
"},±{a,a,a,a,"
"}}<>b&

Funkcja bez nazwy, przyjmująca dodatni argument liczby całkowitej #i zwracająca ciąg znaków z nowymi liniami (w tym końcowy nowy wiersz); każda linia ma również spację końcową. Najpierw definiujemy, ±że jest funkcją, która powtarza swoje #czasy wejściowe ; następnie ajest zdefiniowany jako ±"# "( #jest to znak, a nie dane wejściowe!), a od tego bjest zdefiniowany zestaw #krótkich linii, podczas gdy ±{a,a,a,a}<>njest to zestaw #długich linii. (W obu przypadkach istnieje dosłowne przesunięcie wiersza między pasującymi cytatami.) Końcowy <>bkonkatenuje wynikową listę ciągów z drugą kopią zestawu krótkich wierszy. Przykład danych wyjściowych, gdy #=2( odpowiedź xnora nauczyła mnie, że ta orientacja jest bardziej golfowa):

# #     
# #     
# # # # # # # # 
# # # # # # # # 
# #     
# #     

Poprzednia wersja tej implementacji:

""<>(±s_:=s&~Array~#;{b=±{a=±"# ",n="\n"},±{a,a,a,a}<>n,b})&

Oryginalne zgłoszenie:

""<>If[(m=n~Mod~t)==0,"\n",If[n<t#||#<m<=2#,"# ","  "]]~Table~{n,4(t=3#+1)#}&

Buduje out ciąg 4*(3#+1)elementów, z których każdy jest albo "# ", " "lub "\n"; po prostu oblicza, które elementy użyć na podstawie indeksu n. Przykładowe dane wyjściowe, gdy #=2:

# # # # # # 
# # # # # # 
    # #     
    # #     
    # #     
    # #     
    # #     
    # #     
Greg Martin
źródło
5

JavaScript (ES6), 59 bajtów

f=
n=>`141`.replace(/./g,m=>`${`# `.repeat(n*m)}\n`.repeat(n))
<input type=number oninput=o.textContent=f(this.value)><pre id=o>

Dane wyjściowe obejmują końcowe spacje na końcu każdej linii i końcowy nowy wiersz.

Neil
źródło
5

Rubinowy, 36 bajtów

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}

Stosowanie:

f=->n{puts (t=[s="# "*n]*n)+[s*4]*n+t}
f[3]
# # #
# # #
# # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # # # # # # # # # # #
# # #
# # #
# # #

Rubinowy, 38 bajtów

Ten kształt jest dłuższy w Ruby, ale spodziewam się, że niektóre języki są krótsze.

->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}

Stosowanie:

g=->n{puts [s="# "*n*3]*n+[" "*n*4+s]*n}
g[3]
# # # # # # # # #
# # # # # # # # #
# # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #
            # # # # # # # # #

Obie odpowiedzi mogą być krótsze, jeśli dozwolone jest zwrócenie (najlepiej) tablicy ciągów lub (mniej korzystnie) pojedynczego ciągu zamiast drukowania.

Level River St
źródło
Zwracanie ciągu jest uważane za prawidłową formę wyniku.
dkudriavtsev
4

Scala, 56 bajtów

(n:Int)=>Seq(1,4,1)map("# "*_*n+"\n")map(_*n)mkString ""
jaxad0127
źródło
4

JavaScript (ES6), 71

n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

Test

f=
n=>((z='# '[R='repeat'](n))[R](3)+`
`)[R](n)+('  '[R](n)+z+`
`)[R](n*3)

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

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

edc65
źródło
Nie jestem do końca pewien, ale myślę, że musisz wyprowadzić spacje wraz z skrótami. (Popełniłem również ten błąd, nie włączając spacji w pierwszej edycji mojej odpowiedzi)
Kritixi Lithos
@KritixiLithos, rozumiem. Dzięki
edc65
4

Java 8, 99 bajtów

l->{for(int i=-1,j;++i<3*l;)for(j=-1,k=(i/l==2)?4*l:l;++j<k;)System.out.print("# "+j>k-2?"\n":"");}
Roman Gräf
źródło
4

V , 24 23 20 18 20 bajtów

Ài# ddÀpLyGïp3PGïp

Pokazano wszystkie ukryte postacie

Ài# ^[ddÀp^VLyGïp3PGoïp

^[is 0x1b(dosłowny znak ucieczki) i ^Vis 0x16( C-v)

Wypróbuj online!

Musiałem zwiększyć liczbę bajtów, ponieważ Äpolecenie było błędne w tym nowym ciągnięciu V.

Dane wyjściowe w tym formacie:

# 
# # # # 
# 

z wiodącą nową linią

Hexdump:

00000000: c069 2320 1b64 64c0 7016 4c79 47ef 7033  .i# .dd.p.LyG.p3
00000010: 5047 ef70                                PG.p

Wyjaśnienie

Ài# ^[              " Argument times insert "# "
ddÀp                " Argument times duplicate line

Teraz, gdy jedna strona sieci została ukończona, musimy ją utworzyć

^VLy                " Copy the face
Gïp                 " Paste it at the end of buffer
3P                  " Paste 3 times (these form the line)
Gïp                 " Paste at end of buffer again

Alternatywne rozwiązanie, jeśli nie wyprowadzamy spacji:

21 20 18 16 18 bajtów

Àé#ddÀpLyGïp3pGïp

(z tego samego powodu, co najlepsze rozwiązanie, ten link TIO został zmodyfikowany)

Wypróbuj online!

Kritixi Lithos
źródło
4

V , 14 bajtów (niekonkurencyjny)

Ài# 5Ù4JjòÀÄk

Wypróbuj online!

00000000: c069 2320 1b35 d934 4a6a f2c0 c46b       .i# .5.4Jj...k

Z jakiegokolwiek powodu wyzwanie to ujawniło wiele błędów. Teraz, gdy wszystkie zostały naprawione, ta wersja jest niestety niekonkurencyjna, ale fajnie jest zobaczyć, jak powinna wyglądać odpowiedź V na to wyzwanie, gdy nie musi dodawać ton bajtów, aby nadążyć za moim niechlujnym kodowaniem.

Wyjaśnienie:

À                   " Arg 1 times:
 i# <esc>           "   Insert the string "# "
         5Ù         " Make 5 copies of this line, and put the cursor on the second copy
           4J       " Join four of these lines together
             j      " Move down to the last line
              ò     " Recursively:
               ÀÄ   "   Make Arg 1 copies of this line
                 k  "   And move up a line
DJMcMayhem
źródło
Szczerze Jmówiąc , problemem nie było niechlujne kodowanie AFAIK, myślę, że to był tylko domyślny nvim?
nmjcman101
Tak to prawda. Ale zduplikowany operator zdecydowanie był niechlujny. Na szczęście ta nowa wersja jest znacznie prostsza.
DJMcMayhem
4

Galaretka , 20 19 bajtów

”#xẋ³Wẋ³K€Y
141DÇ€Y

Wypróbuj online!

-1 dzięki 44874 (steenbergh).

NIE MOGĘ WYCHŁAĆ POMOCY MUDDYFISH!

Czy to gra w golfa? 20 19 bajtów wydaje się po prostu za dużo , widząc Link 1.

Wyjaśnienie:

”#xẋ³Wẋ³K€Y Helper link. Arguments: z
”#          Character #.
            y (implicit)
  x         Repeat each element of y x times.
    ³       1st command-line argument.
   ẋ        Repeat x y times.
     W      Wrap z.
       ³    1st command-line argument.
      ẋ     Repeat x y times.
        K   Join z on spaces.
         €  Map this link on x.
          Y Join z on newlines.

141DÇ€Y Main link. Arguments: 0
141     Integer 141.
   D    Convert z to base 10.
    Ç   The above link as a monad.
     €  Map this link on x.
      Y Join z on newlines.
Erik the Outgolfer
źródło
Teraz jest V kontra Jelly :)
Kritixi Lithos
@KritixiLithos Nah, twoje rozwiązanie było pierwsze.
Erik the Outgolfer
V ma teraz 18 bajtów :)
Kritixi Lithos
Można upuścić bajt nie używając @jednak zamiana argumentów do xsiebie: ”#xẋ³Wẋ³K€Y.
steenbergh
3

Węgiel drzewny , 20 bajtów

NλG↑λ←×⁶λ↓λ# DM×⁴λ← 

Kod kończy się spacją. Wypróbuj online!

Wyjaśnienie

Węgiel drzewny to język specjalizujący się w sztuce ASCII. Jest również niekompletny, błędny i niedokumentowany. Wystarczy powiedzieć, że zajęło to sporo prób i błędów, zanim zrobiło to, co powinno.

  • Nλwprowadza liczbę do λ.
  • to polecenie wielokąta, którego użyjemy tutaj do narysowania prostokąta. ↑λ←×⁶λ↓λokreśla granicę wielokąta: λkroki w górę, kroki w lewo 6 razy λi λkroki w dół . (To trzy λprzez λbloki side-by-side). Dolna krawędź prostokąta jest sugerowane. Wielokąt jest następnie wypełniany łańcuchem # .
  • zrzuca bieżące płótno na standardowe wyjście, czego wynikiem jest coś takiego:
 # # # # # # # # #
 # # # # # # # # #
 # # # # # # # # #
  • Po poleceniu kursor znajduje się w lewym dolnym rogu obszaru roboczego. M×⁴λ←Porusza się w lewo przez 4 razy λetapów (odpowiadającymi dwóm λprzez λbloki).
  • wyprowadza tam przestrzeń, przedłużając płótno w lewo o odpowiednią wartość.
  • Pod koniec programu płótno jest (ponownie) wysyłane do standardowego:
             # # # # # # # # #
             # # # # # # # # #
             # # # # # # # # #

Złóż je razem, a otrzymasz sześcianową siatkę.

DLosc
źródło
Wow, naprawdę musiałaś wtedy walczyć! (Oblong został dodany dopiero kilka tygodni później.)
Neil
2

Narzędzia Bash / Unix, 72 69 68 66 bajtów

b()(yes `dc<<<2o4d$n^$1^3/p`|tr 01 ' #'|head -$n);n=$1;b 1;b 4;b 1

Wypróbuj online!

Działa to na podstawie faktu, że [4 ^ k / 3], gdy jest zapisany w bazie 2, to 10101010 ... 01, z k 1. (Nawiasy kwadratowe tutaj oznaczają funkcję podłogi.)

Mitchell Spector
źródło
2

Pyke, 16 bajtów

uAD,sXF**"# 

Wypróbuj tutaj!

Równoważny

1 4 1]3AD,sXF**"# 

Ze względu na niedrukowalne

Wykorzystuje kilka sztuczek, aby obniżyć liczbę bajtów:

  • Używa niektórych niedrukowalnych do reprezentowania listy [1, 4, 1]
  • XF automatycznie zrzuca dane wyjściowe na stos
  • Łańcuch "#na końcu zostaje zamieniony na ostatni *, co oznacza, że ​​zamknięcie "nie jest wymagane. Dzieje się to domyślnie, gdy ostatni token jest łańcuchem.


u                -      [1, 4, 1]
     AD          -     apply(*, ^, input)
       ,         -    zip(^)
        s        -   sum(^)
          F**"#  -  for i in ^:
           *     -    ^ * input
            *    -   ^ * v
             "#  -    "# "
         X       - splat(^)
niebieski
źródło
2

Python 2 , 68 71 65 bajtów

-6 dzięki dzięki @sagiksp

def f(i,c=1):
 print(' '*i*4,'')[c>i]+'# '*i*3
 if i*2>c:f(i,c+1)

Wypróbuj online!

W przypadku braku sposobu na pokonanie @xnor opublikuję moją funkcję rekurencyjną po prostu jako alternatywne podejście. Dla wydruków f (5)

                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
                    # # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 
# # # # # # # # # # # # # # # 

Ten wzór został wybrany po prostu dlatego, że można go podzielić na dwie części, w przeciwieństwie do wszystkich innych.

ElPedro
źródło
2
Gdzie są przestrzenie?
dkudriavtsev
1
Bez spacji na wyjściu nie jest to poprawne.
Mego
Mój błąd +3, aby dodać spacje. Zaktualizowano
ElPedro
1
Właściwie dlaczego potrzebujesz j? Możesz przedefiniować całość w zakresie i i zaoszczędzić ~ 6 bajtów!
sagiksp
@sagiksp - Dzięki. Zaktualizowano przy użyciu Twojej sugestii.
ElPedro
2

PHP, 64 62 bajtów

Zaoszczędzono 2 bajty dzięki Christophowi .

while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("
",$a,"# ");

Drukuje sieć w następujący sposób:

# #
# #
# # # # # # # #
# # # # # # # #
# #
# #

(z wiodącą nową linią)

użytkownik63956
źródło
1
while($a="282"[$i++/$s=$argv[1]]*$s)echo str_pad("\n",$a,"# ");oszczędza 2 bajty.
Christoph
1

Partia, 111 bajtów

@set s=
@set i=@for /l %%i in (1,1,%1)do @
%i%call set s=%%s%% #
%i%echo%s%
%i%echo%s%%s%%s%%s%
%i%echo%s%
Neil
źródło
1

Pushy , 32 29 28 bajtów

Drukuje siatkę sześcianu wyrównaną do lewej. Trudno było grać w golfa ...

&V:`# `;{:";N^:4:";T'.;TD^:"

Wypróbuj online!

FlipTack
źródło
1

Retina , 39 37 bajtów

Po raz pierwszy używam Retiny, wciąż próbuję zrozumieć, jak to robić.

.+
$*#
#
# 
\`# 
$_¶
G`.
)*%`^
$_$_$_

(z dwoma końcowymi spacjami po 4 i 5 linii)

Dzięki Martin Ender za grę w golfa 2 bajty!

Wypróbuj online!

Lew
źródło
@MartinEnder Dziękuję, nie zauważyłem tego wymogu, teraz powinien być poprawny. Czy masz jakieś sugestie, jak powinienem spróbować zagrać w golfa?
Leo
Nie mając wielu genialnych pomysłów, ale tio.run/nexus/… oszczędza dwa bajty. Możesz uniknąć końcowych kanałów, zawijając wszystko w grupie, która ma swoją flagę wyjściową (a ponieważ grupa jest ostatnią rzeczą w programie, flaga wyjściowa domyślnie nie jest cicha). Drugi bajt unika czwartego $_na dole, zmieniając niektóre rzeczy po usunięciu pustej linii. tio.run/nexus/… to ta sama liczba bajtów, ale trochę brzydsza.
Martin Ender
@MartinEnder Dziękuję za wskazówki i dziękuję również za ten język, to naprawdę miłe!
Leo
Dziękuję za miłe słowa. :) Jest do tego pokój czatowy, jeśli masz jakieś pytania lub chcesz dyskutować. Obecnie jest raczej cicho, ale staram się go nie zamrażać na wypadek, gdyby ludzie mieli pytania (i powinieneś być w stanie pingować mnie tam w dowolnym momencie).
Martin Ender
1

QBIC , 52 67 40 bajtów

Zakończ przepisywanie:

:[a*3|G=G+@#`][a*2|G=G+@ `][a|?G][a|?_fG

Teraz używa tego wzorca:

###--
--###

Gdzie -są wypełnione spacjami.

:        Read 'a' from the command line        > Assume 3
[a*3|    Create 3 segments times 'a' filling   > 3*3 = 9
G=G+@#`] Define A$ to be '#' and add this to G > G = "#########" 
[a*2|    Create 2 segments times 'a' spacer
G=G+@ `] Define B$ to be ' ' and add this to G > G = "#########       " 
[a|      FOR d == 1; d <= a; d++
?G]      Display G$:
            "#########       " 
            "#########       " 
            "#########       " 
[a|      FOR e == 1; e <= a; e++
?_fG     Display G$ in reverse (_f...|):
            "      #########" 
            "      #########" 
            "      #########" 
         (For loop and function call to Flip impicitly closed by QBIC)
Steenbergh
źródło
@EriktheOutgolfer Zaktualizowano.
steenbergh
2
Odpowiednia nazwa języka dla wyzwania!
FlipTack,
1

Pip , 28 17 16 bajtów

15 bajtów kodu, +1 dla -nflagi.

"# "Xa*_RLaM141

Przyjmuje rozmiar jako argument wiersza polecenia. Wypróbuj online!

Wyjaśnienie

                 a is 1st cmdline arg
       _         Build a lambda function
     a*          (a) times argument
"# "X            Repeat string "# " that many times
        RLa      Wrap in a list and repeat list (a) times
           M141  Map that function to the characters of 141
                 Autoprint (-n flag separating list items with newlines)

Poniżej nie jest dokładnie, w jaki sposób dane są modyfikowane, ale daje podstawowy pomysł (na a=2):

141

[1;4;1]

[2;8;2]

["# # ";"# # # # # # # # ";"# # "]

[["# # ";"# # "];["# # # # # # # # ";"# # # # # # # # "];["# # ";"# # "]]

# # 
# # 
# # # # # # # # 
# # # # # # # # 
# # 
# # 
DLosc
źródło
0

05AB1E , 13 bajtów

D141S×S*„# ×»

Wypróbuj online!

Wyjaśnienie

Przykładowe dane wejściowe n=2

D              # duplicate input
               # STACK: 2, 2
 141S          # push the list [1,4,1]
               # STACK: 2, 2, [1,4,1]
     ×         # repeat each item in the list input_no times
               # STACK: 2, [11, 44, 11]
      S        # split into list of digits
               # STACK: 2, [1, 1, 4, 4, 1, 1]
       *       # multiply each digit with input
               # STACK: [2, 2, 8, 8, 2, 2]
        „# ×   # repeat the string "# " for each item in the list
               # STACK: ['# # ','# # ','# # # # # # # # ','# # # # # # # # ','# # ','# # ']
            »  # join by newlines
               # OUTPUT: # # 
                         # # 
                         # # # # # # # # 
                         # # # # # # # # 
                         # # 
                         # # 
Emigna
źródło
0

C #, 152 bajty

n=>{var m="";foreach(int c in new[]{1,4,1})for(int i=0,j;i++<n;){for(j=0;j++<c;)m+=new System.Text.StringBuilder().Insert(0,"# ",n);m+="\n";}return m;};
TheLethalCoder
źródło
0

SmileBASIC, 57 50 bajtów

INPUT S
E$=("#"*S*3+CHR$(10))*S?E$SCROLL-S*2,-1?E$

Wyjaśnił:

INPUT SIZE
PART$=("#"*SIZE*3+CHR$(10))*S 'generate half of the pattern
PRINT PART$ 'print half the pattern
SCROLL SIZE*-2,-1 'scroll the text 2 squares right (and 1 character down)
PRINT PART$ 'print half the pattern again

Po pierwszym WYDRUKIE (rozmiar = 2, @ to pozycja kursora):

######
######

@ 

Po przewinięciu:

    ######
    ######
@

Po drugim DRUKOWANIU:

    ######
    ######
######
######
@
12Me21
źródło
W takim przypadku możesz pominąć spacje
dkudriavtsev
0

Common Lisp, 83 81 79 bajtów

(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))

Stosowanie:

(funcall #'(lambda(x)(format t"~v@{~v@{# ~}~:*~%~}~v@{~vt~0@*~v{# ~}~%~}"x(* x 3)(* x 2)))2)

Wydajność:

# # # # # #
# # # # # #
    # # 
    # # 
    # # 
    # #       
    # # 
    # #           

Jak to działa?

in format there is control string (inside "") and arguments after it
certain commands in string can use arguments (for example ~a displays argument)
~v{~} - takes argument and does commends inside {~} number of times 
                                      (number is given by argument)
       we can write text in loop body - it'll get displayed. Even if
       in loop body there are none commends to use arguments loop itself                 
       will consume one argument (it doesn't matter what it'll be -
       it doesn't seem to affect output)
~% - newline
~n* - jump n arguments forward (relative)
~n:* - jump n arguments backwards (relative)
~n@* - jump to argument n (global, counting from 0)

~v@{~v{# ~}~%~1@*~} <--- we make x rowns, 3x columns of string "# ". 
                         ~1@* is used during looping, it also means we end on argument 1. 
                         (second argument: (* x 3))
~v@{~vt~0@*~v{# ~}~%~} <--- we now make 3x rows, x columns of "(spaces)# "
                         ~vt - is used to move to accurate column. 
                         Here it takes argument (* x 2) - this is 
                         minimal number of columns to display. It uses
                         space as default character for missing characters
                         (when string inside <~> is shorter than min 
                         number of columns). I use it to make (* x 2) spaces, 
                         by giving it no text.
      ~0@* <--- after making spaces we have no new arguments, we go back to
                argument number zero - it is used to determine number of columns in our block

Pomysły na ulepszenia są mile widziane.


źródło