17

Ihre Herausforderung besteht darin, genau das folgende Feld auszugeben:

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

Die Box hat eine Höhe und eine Breite von 50, die Zwischenräume sind zwei breit.

Sie müssen eine Funktion oder ein Programm schreiben, das eine Zeichenfolge ausgibt oder zurückgibt und keine Eingaben vornimmt.

Wenigste Bytes gewinnt!

code-golf ascii-art kolmogorov-complexity

— Pavel
quelle

4

Gibt es einen Grund, warum die innerste +Box oben und unten nur eine Schicht hat? Dadurch werden algorithmische Antworten etwas länger, da die innersten beiden Schichten nicht genau quadratisch sind.

— ETHproductions

@Pavel OK. Enge Abstimmung zurückgezogen :)

— Digitales Trauma

4

Warum die Einschränkung eines vollständigen Programms?

— 13.

1

@Pavel warum? Es fügt der Herausforderung wirklich nichts hinzu.

— 13.

1

@Pavel ..... nein. Ich meine ja, einige haben das, aber es ist bei weitem keine Anforderung / Norm für KG-Herausforderungen.

— 13.

10

Pyke, 20 17 Bytes

k25V". + "ohe@A.X

Probieren Sie es hier aus!

k                 - out = ""
 25V              - repeat 25 times:
          oh      -     (o++)+1
            e     -    ^//2
    ". + "   @    -   " + ."[^] (wraps around)
              A.X -  out = surround(out, ^)

Die Surround-Funktion wurde für solche Fragen zur Kolmogorov-Komplexität entwickelt !

— Blau
quelle

14

J , 25 Bytes

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

Probieren Sie es online!

Erläuterung

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
quelle

Ich denke, Sie können das Echo auslassen.

— Conor O'Brien

@ ConorO'Brien Oh, die Ausgaberegel hat sich geändert. ... Hmm, aber wenn ich entferne echo, wird es nicht einmal eine Funktion sein, nur ein Wert. Obwohl J sowieso keine Nullargumentfunktionen hat.

— Zgarb

Ich denke, das ist nach Js Natur erlaubt. In jedem Fall können konstante Funktionen als Nullargument betrachtet werden.

— Conor O'Brien

11

C 115 Bytes

#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);}

Definiert eine Funktion f(Aufruf als f();), die den String an STDOUT ausgibt.

— Lynn
quelle

9

C 535 478 477 Bytes

Nun, das ist viel Golf: - /

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);}

Hier ist die Ausgabe;

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

— Cleblanc
quelle

2

Heilige Scheiße. Ich bewundere Ihr Engagement.

— 13.

Ich habe die Einschränkung geändert, Funktionen, die einen String zurückgeben, sind jetzt erlaubt.

— Pavel

Ich habe gerade gemerkt, dass ich ein paar Bytes Golf spielen kann, indem for(;i++<51;ich die Loops neu schreibe, und jetzt bin ich überall um eins weg: - /

— cleblanc

@cleblanc++i

— dkudriavtsev

MFW Ich habe versucht, dies zu verstehen: i.imgur.com/TLV9gJ4.png +1

— Magic Octopus Urn

6

Haskell, 72 Bytes

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

@ Zgarbs Lösung in Haskell. Ich habe auch versucht, die Box durch Hinzufügen von Schichten um den Kern herum zu konstruieren ["..",".."], aber sie ist 9 Bytes länger (81 Bytes).

e!b=e:e:b++[e,e];s#c=(c!)<$>(c<$s!!0)!s
unlines$foldl(#)["..",".."]" + . + . + ."

— nimi
quelle

5

Gestapelt, nicht konkurrierend, 35 Bytes

Probieren Sie es hier aus!

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

Ungolfed:

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

Ziemlich einfach. surroundist eine Funktion, die ein Objekt mit einem Füllobjekt umgibt. Zum Beispiel (0) 1 surroundist ((1 1 1) (1 0 1) (1 1 1)). $surroundwird surroundals Funktion nicht ausgewertet. foldNimmt einen Anfangswert, dann etwas umzuklappen, dann eine Funktion. In diesem Fall surroundwird foldED, rund um die zunächst leere Zeichenfolge ''(equiv. ε) Mit jedem Zeichen des Strings.

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

Dabei wird zunächst eine Zeichenfolge erstellt $' + .', die bei Multiplikation mit einer Zahl jedes Zeichen wiederholt. Dies lässt uns mit: ++ ... Dies wird dann in eine Zeichenfolge umgewandelt. Dann wiederholen wir diese Zeichenfolge dreimal und stellen schließlich a voran ., um die gewünschte Zeichenfolge zu erhalten.

Ein anderer Ansatz für 39 Bytes:

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

#\ist insert und verwendet das Anfangszeichen der Zeichenfolge als Startwert. Es funktioniert auch nur auf Arrays.

— Conor O'Brien
quelle

Wie ist das konkurrenzlos, die Herausforderung ist erst vor wenigen Stunden gestiegen.

— Pavel

@Pavel Ich arbeite immer daran

— Conor O'Brien

4

JavaScript (ES6), 117 Byte

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())

Erweitern Sie das Snippet

Die nicht rekursive Lösung hat mich 128 Bytes gekostet:

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`)

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt.

— Neil
quelle

4

C 97 Bytes

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
quelle

3

Jelly , 18 Bytes

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

Probieren Sie es online!

Gleicher Ansatz wie Zgarbs J-Antwort: 12ŒRAis abs([-12 … 12]): x2Wiederholt jedes Element zweimal, »þ`erstellt eine Tabelle mit Maximalwerten, ị“ + .”indiziert zyklisch einen String und Yfügt Zeilenumbrüche hinzu.

— Lynn
quelle

3

05AB1E , 39 35 33 Bytes

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

Probieren Sie es 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.

33-Byte-Version, die jetzt cooler ist, weil Emigna mir 2 Byte erspart hat:

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

Probieren Sie es online!

— Magische Kraken-Urne
quelle

1

". + "DøJ3×'.«.pvy¤25yg-×«Â«})Â«»für 33 Bytes.

— Emigna

… .+•â3fM~•3BSè.pvy¤25yg-×«Â«})Â«»für 34 Bytes auf der "cooler version".

— Emigna

Cool war nicht die richtige Wortwahl haha. "Weniger Ghetto" vielleicht?

— Magic Octopus Urn

Ich mag Ihre Verwendung des Präfix-Befehls. Brillant!

— Emigna

1

@Emigna die Präfixe bilden ein Dreieck, wenn Sie das Dreieck transponieren und drehen, dann kombinieren Sie es mit den ursprünglichen Präfixen, die Sie möglicherweise in der Lage sind, Bytes zu entfernen. Das war der Hauptplan, den ich nicht erreichen konnte.

— Magic Octopus Urn

2

MATL , 21 Bytes

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

Probieren Sie es 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
quelle

2

Ruby, 77 Bytes

-623.upto(676){|i|print i%26>0?". + "[[(i%26-13).abs,(i/52).abs].max%4]*2:$/}

— Level River St
quelle

Ich denke, Sie können den Indexausdruck durch [i%26-13,i/52].map(&:abs).max%4(speichert ein Byte) ersetzen

— Conor O'Brien

2

Holzkohle , 25 Bytes

Ｆ…¹¦²⁶⁺×ι§. + ÷ι²¶‖Ｏ↗‖Ｃ↑←

Probieren Sie es online! Der Link enthält einen ausführlichen Erklärungsmodus

— Nur ASCII
quelle

2

Python 3 , 89 Bytes

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

Probieren Sie es online!

— Undichte Nonne
quelle

1

Haskell, 385 Bytes

    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

Erste Runde Code Golf hier ... Ich freue mich darauf zu sehen, wie andere dieses Problem angehen.

Ausgabe:

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

— Brander
quelle

3

1) Sie haben Tonnen unnötiger Leerzeichen. 2) Setze alle Funktionsdefinitionen wherein eine einzige Zeile und verwende sie ;zur Trennung. 3) f:f:[]ist f:[f] and d: '': '': [] 'ist d:" ". 4) mNimmt einen Parameter, verwendet ihn aber nicht. Inline mund t. 5) Definieren Sie eine neue #zu ersetzende Funktion replicate: c#x=c<$[1..8*n+x]und nennen Sie sie wie d#2und ' '#(-6). 6) mod 2 == 0ersetzt werden kann even, oder drehen Sie den Test und die Verwendung oddund die Golfer otherwise: 1<2. ...

— nimi

2

... alles in allem:

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

Oktave, 53 Bytes

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

Generieren Sie ein sich wiederholendes Muster von 1 bis 8 von der Mitte nach außen und verwenden Sie es als Index für die Extraktion von Elementen von . ++ .

Probieren Sie es online!

— rahnema1
quelle

1

Bash, 191 Bytes

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

Kann wahrscheinlich kleiner werden, war aber kleiner als meine algorithmischen Versuche.

— throx
quelle

1

203 Bytes

Vollständiges, lesbares Programm:

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();
    }
}

Golf Funktion :

()=>{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
quelle

1

05AB1E , 33 Bytes

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

Probieren Sie es online!

Erläuterung

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
quelle

Erklärung zu kommen?

— Pavel

@Pavel: natürlich! :)

— Emigna

1

PowerShell , 171 151 Byte

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

Probieren Sie es online!

Hallo Antwort. Ich bin sicher, dass es einen kürzeren Weg gibt (angesichts der Länge der anderen Antworten bin ich zuversichtlich), aber dies zeigt einige nette Tricks.

Erläuterung:

1..12|%{' . +'[$_%4]}generiert ein Array von Strings (mit einer Länge von einem Zeichen) in dem richtigen Muster, das wir brauchen. Probieren Sie es online!

Wir fügen dann hinzu, |%{($a+=$_+$_)})+"$a."welches Array das Array annimmt und es basierend auf der vorherigen Zeile seitlich erweitert. Probieren Sie es online!

Diese Zeichenfolgen werden dann in einer Schleife gesendet |%{$c=if(++$i%2){('+','.')[($b=!$b)]}else{' '};$_.PadRight(25,$c)}. Bei jeder Iteration wählen wir das richtige Zeichen (entweder ein Pluszeichen, ein Punkt oder ein Leerzeichen) und verwenden dann die .PadRightFunktion, um die entsprechende Anzahl von Zeichen aufzufüllen. Probieren Sie es online!

Jetzt haben wir das Fundament der oberen rechten Ecke. Wir müssen jeden String umkehren |%{,($_+-join$_[($z=25..0)])*2}und zusammenfügen, damit wir den oberen Rand des Blocks erreichen. Dies geschieht mit dem -joinBefehl und der Rückwärtsindizierung 25..0. Außerdem kapseln wir die Zeichenfolgen in ein Array ,(...)und machen sie doppelt, *2damit wir die gesamte Spitze erhalten. Probieren Sie es online!

Das alles wird in $xParens gespeichert und eingekapselt, so dass die Strings in der Pipeline platziert werden. Zum Schluss kehren wir um $x(um sicherzustellen, dass die doppelte mittlere Reihe herausgeschnitten wird, sonst hätten wir vier ..in der Mitte) und belassen diese in der Pipeline. Ein implizites Write-OutputZeichen setzt einen Zeilenumbruch zwischen die Zeichenfolgen, sodass wir diesen kostenlos erhalten.

— AdmBorkBork
quelle

Gib eine hübsche Box aus

Pyke, 20 17 Bytes

J , 25 Bytes

Erläuterung

C 115 Bytes

C 535 478 477 Bytes

Haskell, 72 Bytes

Gestapelt, nicht konkurrierend, 35 Bytes

JavaScript (ES6), 117 Byte

C 97 Bytes

Jelly , 18 Bytes

05AB1E , 39 35 33 Bytes

MATL , 21 Bytes

Ruby, 77 Bytes

Holzkohle , 25 Bytes

Python 3 , 89 Bytes

Oktave, 53 Bytes

Bash, 191 Bytes

203 Bytes

05AB1E , 33 Bytes

PowerShell , 171 151 Byte

Erläuterung: