Wyjmij ładne pudełko

17

Twoim wyzwaniem jest dokładne wydrukowanie następującego pola:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................

Skrzynia ma wysokość i szerokość 50, odstępy są dwie szerokie.

Musisz napisać funkcję lub program, który generuje lub zwraca ciąg znaków i nie przyjmuje danych wejściowych.

Wygrywa najmniej bajtów!

code-golf ascii-art kolmogorov-complexity Pavel
źródło
4
Czy jest jakiś powód, dla którego najbardziej wewnętrzne +pudełko ma tylko 1 warstwę na górze i na dole? Dzięki temu odpowiedzi oparte na algorytmach będą nieco dłuższe, ponieważ oznacza to, że dwie najbardziej wewnętrzne warstwy nie są dokładnie kwadratowe.
ETHproductions
@Pavel OK. Głosowanie wycofane :)
Cyfrowa trauma
4
Dlaczego ograniczenie pełnego programu?
Rɪᴋᴇʀ
1
@Pavel dlaczego? To naprawdę nic nie dodaje do wyzwania.
Rɪᴋᴇʀ
1
@Pavel ..... nie. Mam na myśli, że tak, niektórzy to mają, ale nie jest to żaden wymóg / standard dla wyzwań KG.
Rɪᴋᴇʀ

Odpowiedzi:

14

jot , 25 bajtów

echo'. + '{~4|>./~2#|i:12

Wypróbuj online!

Wyjaśnienie

echo'. + '{~4|>./~2#|i:12
                     i:12  Range from -12 to 12.
                    |      Take absolute values,
                  2#       duplicate every element,
                /~         compute "multiplication table"
              >.           using maximum,
            4|             take mod 4 of every element,
    '. + '{~               index into this string,
echo                       print char matrix for everyone to see.
Zgarb
źródło
Myślę, że możesz pominąć echo.
Conor O'Brien
@ ConorO'Brien Och, zmieniono regułę wyjściową. ... Hmm, ale jeśli usunę echo, nie będzie to nawet funkcja, tylko wartość. Chociaż J i tak nie ma funkcji zerowego argumentu.
Zgarb
Myślę, że jest to dozwolone zgodnie z naturą repliki J. W każdym razie funkcje stałe można uznać za argument zerowy.
Conor O'Brien
11

C, 115 bajtów

#define M(x,y)x<(y)?x:y
f(i){for(i=2549;i;i--)putchar(i%51?". + "[(M(i%51-1,M(50-i%51,M(i/51,49-i/51))))/2%4]:10);}

Definiuje funkcję f(wywołanie jako f();), która drukuje ciąg do STDOUT.

Lynn
źródło
9

C, 535 478 477 bajtów

Teraz to dużo golfa: - /

i;main(j){for(;++i<51;puts(""))for(j=0;++j<51;)putchar(i<3|i>48?46:j<3|j>48?46:i>4&i<47&j>4&j<47?i<7|(i>44&i<47)|(j>2&j<7)|(j>44&j<47)?43:j>8&j<43&((i>8&i<11)|(i>40&i<43))?46:i>9&i<41&((j>8&j<11)|(j>40&j<43))?46:i>13&i<37&((j>12&j<15)|(j>36&j<39))?43:((i>12&i<15)|(i>36&i<39))&j>12&j<39?43:i>17&i<33&((j>16&j<19)|(j>32&j<35))?46:((i>16&i<19)|(i>32&i<35))&j>16&j<35?46:i>21&i<29&((j>20&j<23)|(j>28&j<31))?43:((i>20&i<23)|(i>28&i<31))&j>20&j<31?43:i>24&i<27&j>24&j<27?46:32:32);}

Oto wynik;

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
cleblanc
źródło
2
Cholera jasna. Podziwiam twoje poświęcenie.
Rɪᴋᴇʀ
Zmieniłem ograniczenie, funkcje zwracające ciąg znaków są teraz dozwolone.
Pavel
Właśnie zdałem sobie sprawę, że mogę zagrać w golfa na kilka bajtów, ponownie pisząc pętle, for(;i++<51;a teraz jestem wszędzie o jeden: - /
cleblanc
@cleblanc++i
dkudriavtsev
MFW Zacząłem próbować to zrozumieć: i.imgur.com/TLV9gJ4.png +1
Magic Octopus Urn
6

Haskell, 72 bajty

q=(\n->[n,n]).abs=<<[-12..12]
unlines[[". + "!!mod(max x y)4|y<-q]|x<-q]

@ Rozwiązanie Zgarba w Haskell. Próbowałem też zbudować pudełko, dodając warstwy wokół rdzenia ["..",".."], ale jest on o 9 bajtów dłuższy (81 bajtów).

e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."
nimi
źródło
5

Skumulowane, niekonkurencyjne, 35 bajtów

Wypróbuj tutaj!

ε'.'3$' + .'2*tostr*+$surroundfold

Nie golfowany:

'' '.  ++  ..  ++  ..  ++  ..' $surround fold

Całkiem proste. surroundjest funkcją, która otacza byt wypełnieniem. Na przykład (0) 1 surroundjest ((1 1 1) (1 0 1) (1 1 1)). $surroundjest surroundfunkcją, nie podlega ocenie. foldprzyjmuje wartość początkową, potem coś do złożenia, a następnie funkcję. W tym przypadku surroundjest foldED, otaczający początkowo pusty ciąg ''(ekw. ε) Z każdego znaku łańcucha.

'.'3$' + .'2*tostr*+

Najpierw tworzy się ciąg znaków $' + .', który pomnożony przez liczbę powtarza każdy znak. To pozostawia nam: ++ ... Jest to następnie rzutowane na ciąg. Następnie powtarzamy ten ciąg trzy razy, a na koniec przygotowujemy a ., dając nam pożądany ciąg.

Inne podejście do 39 bajtów:

' .'3$' + .'2*tostr*+toarr$surround#\out

#\jest wstawiany i przyjmuje początkowy znak ciągu jako wartość początkową. Działa również tylko na tablicach.

Conor O'Brien
źródło
Jak to jest niekonkurencyjne, wyzwanie wzrosło zaledwie kilka godzin temu.
Pavel
@Pavel Zawsze nad tym pracuję
Conor O'Brien
4

JavaScript (ES6), 117 bajtów

f=(n=12,c=`. + `[n%4],t=c.repeat(n*4+2))=>n?t+`
${t}
${f(n-1).replace(/^|$/gm,c+c)}
${t}
`+t:`..
..`
console.log(f())
Rozwiń fragment kodu

Rozwiązanie nierekurencyjne zajęło mi 128 bajtów:

console.log([...Array(100)].map((_,i,a)=>a.map((_,j)=>`. + `[j=j>50?j-50:51-j,(i>j?i:j)%8>>1],i=i>50?i-50:51-i).join``).join`\n`)

Gdzie \nreprezentuje dosłowny znak nowej linii.

Neil
źródło
4

C, 97 bajtów

i,x,y;main(){for(;i<2550;putchar(++i%51?". + "[(x*x<y*y?y:x)&3]:10))x=i%51/2-12,y=i/102-12;}
orlp
źródło
3

Galaretka , 18 bajtów

12ŒRAx2»þ`ị“ + .”Y

Wypróbuj online!

Takie samo podejście, jak odpowiedź J Zgarba: 12ŒRApolega na tym abs([-12 … 12]), że x2każdy element powtarza się dwa razy, »þ`tworzy tabelę maksimów, ị“ + .”cyklicznie indeksuje w łańcuch i Yłączy znak nowej linii.

Lynn
źródło
3

05AB1E , 39 35 33 bajtów

•â3fM~•3B…012… .+‡.pvyD¤sg25s-׫«})«»

Wypróbuj online!

•â3fM~•3B                               # Push 1100220011002200110022001
         …012… .+‡                      # Push ..  ++  ..  ++  ..  ++  .
                  .p                    # All prefixes of the above string.
                    vy            }     # For each prefix.
                      D¤sg25s-×         # Repeat the last letter until length is 25.
                               «Â«      # Concat, bifurcate, concat.
                                   )«» # Wrap to array, bifurcate, concat, print.

Wersja 33-bajtowa, która jest teraz fajniejsza, ponieważ Emigna skomentowała zapisanie 2 bajtów:

". + "DøJ3×'.«.pvy¤25yg-׫«})«»

Wypróbuj online!

Urna Magicznej Ośmiornicy
źródło
1
". + "DøJ3×'.«.pvy¤25yg-׫«})«»dla 33 bajtów.
Emigna
… .+•â3fM~•3BSè.pvy¤25yg-׫«})«»dla 34 bajtów w „chłodniejszej wersji”.
Emigna,
Fajny nie był prawidłowym wyborem słowa haha. Może „mniej getta”?
Magic Octopus Urn
Uwielbiam korzystanie z polecenia prefiksu. Znakomity!
Emigna,
1
@Emigna prefiksy tworzą trójkąt, jeśli transponujesz trójkąt i obrócisz go, a następnie połącz go z oryginalnymi prefiksami, możesz być w stanie zgolić bajty. To był główny plan, do którego nie mogłem się dostać.
Magic Octopus Urn
2

MATL , 21 bajtów

'. + '[]25:"TTYaQ]2/)

Wypróbuj online!

'. + '    % Push this string
[]        % Push empty array. This will be used as "seed"
25:"      % Do the following 25 times
  TTYa    %   Extend the array with a frame of zeros
  Q       %   Add 1 to each entry
]         % End
2/        % Divide by 2
)         % Index modularly into the string. Non-integer indices are rounded
          % Implicitly display
Luis Mendo
źródło
2

Rubinowy, 77 bajtów

-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}
Level River St
źródło
Myślę, że możesz zastąpić wyrażenie indeksu [i%26-13,i/52].map(&:abs).max%4(zapisuje bajt)
Conor O'Brien
2

Python 3 , 89 bajtów

r=range(-24,26)
for i in r:print("".join([". + "[max(abs(i//2),abs(j//2))%4]for j in r]))

Wypróbuj online!

Leaky Nun
źródło
1

Haskell, 385 bajtów 

    b 0 = ["..", ".."]
b n = f:f:s:s:m (b (n - 1)) ++s:s:f:f:[]
    where f = replicate (8*n+2) $ d
          s = l++replicate ((8*n)-6) ' ' ++r
          m (x:xs) = map (\x -> l ++ x ++ r ) $ t
          l = d:d:' ':' ':[]
          r = reverse l
          t = b (n - 1)
          d :: Char
          d | n `mod` 2 == 0 = '.'
            | n `mod` 2 == 1 = '+'
main = mapM_ putStrLn $ b 6

Pierwsza runda kodu golfa tutaj ... nie mogę się doczekać, aby zobaczyć, jak inni sobie z tym poradzą.

Wynik:

..................................................
..................................................
..                                              ..
..                                              ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++      ++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..  ++++++++++  ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..              ..  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++  ..................  ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++                      ++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..  ++++++++++++++++++++++++++  ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..                              ..  ++  ..
..  ++  ..................................  ++  ..
..  ++  ..................................  ++  ..
..  ++                                      ++  ..
..  ++                                      ++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..  ++++++++++++++++++++++++++++++++++++++++++  ..
..                                              ..
..                                              ..
..................................................
..................................................
brander
źródło
3
1) Masz mnóstwo niepotrzebnych białych znaków. 2) umieść wszystkie definicje funkcji w wherejednym wierszu i użyj ;do rozdzielenia. 3) f:f:[]jest f:[f] and d: '': '': [] `is d:" ". 4) mprzyjmuje parametr, ale go nie używa. Inline mi t. 5) zdefiniuj nową funkcję #do zastąpienia replicate: c#x=c<$[1..8*n+x]i wywołaj ją jak d#2i ' '#(-6). 6) mod 2 == 0można zastąpić evenlub odwrócić oraz wykorzystywania oddi golfisty otherwise: 1<2. ...
nimi
2
... w sumie: b n=f:f:s:s:map(\x->l++x++r)(b$n-1)++s:s:f:[f]where f=d#2;s=l++' '#(-6)++r;l=d:d:" ";r=reverse l;d|odd n='+'|1<2='.';c#x=c<$[1..8*n+x].
nimi
1

Oktawa, 53 bajty

 '.  ++  .'(mod(bsxfun(@max,x=[24:-1:0 0:24],x'),8)+1)

Wygeneruj powtarzający się wzór od 1 do 8 od środka na zewnątrz i użyj go jako wskaźnika do ekstrakcji elementów . ++ .

Wypróbuj online!

rahnema1
źródło
1

Bash, 191 bajtów

echo H4sIAGUcgFgAA73VOw7AIAyD4b2n6F6J+x+v6k5CnPy1F6ZPAvNaS80li4/cUvrkKWdGapOak3O5DDmVS5G8XI5k5ZIkLpclUbk02ZfLk125f5B4JIljLY59cZwxx31x3H3HO5aFIo7/pZIpqWZClHSJmg55AeBhTxb2CQAA|base64 -d|gunzip

Prawdopodobnie może być mniejszy, ale był mniejszy niż moje próby algorytmiczne.

throx
źródło
1

C #, 203 bajtów

Kompletny, czytelny program:

using System;
public class P
{
    public static void Main(string[] a)
    {
        Func<string> f = () =>
        {
            var z = 25;
            var t = "";
            Func<int, string> c = (q) => q % 4 == 0 ? ".." : (q % 4 != 2 ? "  " : "++");
            for (var y = 0; y < z; y++)
            {
                var l = "";
                for (var x = 0; x < z; x++)
                        l += ((y > z / 2) ? (x >= y | x < z - y) : (x < y | x >= z - y)) ? c(x):c(y);
                l += "\n";
                t += l + l;
            }
            return t;
        };

        Console.Write(f());
        Console.ReadKey();
    }
}

Funkcja gry w golfa :

()=>{var z=25;var t="";Func<int,string>c=(q)=>q%4==0?"..":(q%4!=2?"  ":"++");for(var y=0;y<z;y++){var l="";for(var x=0;x<z;x++)l+=((y>z/2)?(x>=y|x<z-y):(x<y|x>=z-y))?c(x):c(y);l+="\n";t+=l+l;}return t;};
CSharpie
źródło
1

05AB1E , 33 bajty

14G" . +"NL¤¸13N-.׫€D¨Â«èD})¨Â«»

Wypróbuj online!

Wyjaśnienie

14G                               # for N in [1 ... 13]
   " . +"                         # push this string
         NL                       # push range [1 ... N]
           ¤¸13N-.×               # push a list of 13-N repetitions 
                                  # of the last element of the above range
                   «              # concatenate the two ranges
                    €D            # duplicate each element
                      ¨           # remove the last element
                       «         # concatenate a reversed copy to the list
                         è        # use the elements of the list to index into the string
                          D       # duplicate the resulting string
                           }      # end loop
                            )     # wrap the strings in a list
                             ¨    # remove the last element
                              «  # concatenate a reversed copy
                                » # join the list on newlines
Emigna
źródło
Wyjaśnienie, które nadejdzie?
Pavel
@Pavel: oczywiście! :)
Emigna,
1

PowerShell , 171 151 bajtów

($x=(1..12|%{' . +'[$_%4]}|%{($a+=$_+$_)})+"$a."|%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}|%{,($_+-join$_[25..0])*2});$x[23..0]

Wypróbuj online!

Ho-hum odpowiedź. Jestem pewien, że jest krótsza droga (biorąc pod uwagę długość innych odpowiedzi, jestem pewien), ale to pokazuje kilka fajnych sztuczek.

Wyjaśnienie:

1..12|%{' . +'[$_%4]}generuje tablicę ciągów (o długości jednego znaku), we właściwym wzorze, którego potrzebujemy. Wypróbuj online!

Następnie dodajemy, |%{($a+=$_+$_)})+"$a."który pobiera tablicę i rozwija ją na boki w oparciu o poprzedni wiersz. Wypróbuj online!

Ciągi te są następnie przesyłane do pętli |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. W każdej iteracji wybieramy właściwy znak (plus, kropka lub spacja), a następnie używamy .PadRightfunkcji, aby wprowadzić odpowiednią liczbę znaków. Wypróbuj online!

Teraz mamy fundament w prawym górnym rogu. Musimy odwrócić każdy ciąg |%{,($_+-join$_[($z=25..0)])*2}i dołączyć je razem, abyśmy mogli dostać się na górę bloku. Odbywa się to za pomocą -joinpolecenia i indeksowania wstecz 25..0. Dodatkowo, enkapsulujemy łańcuchy w tablicy ,(...)i *2robimy je podwójnie, aby uzyskać całą górę. Wypróbuj online!

To wszystko jest przechowywane $xi zamykane w parens, więc umieszcza ciągi w rurociągu. W końcu odwracamy $x(pamiętając, aby wyciąć duplikat-duplikat środkowego rzędu, w przeciwnym razie mielibyśmy cztery ..w środku) i pozostawić te w przygotowaniu. Domniemany Write-Outputwstawia nową linię między ciągami, więc otrzymujemy ją za darmo.

AdmBorkBork
źródło