Die IHIH-Pyramide

34

Ich finde es faszinierend, wie sehr sich die Buchstaben "H" und "I" ähneln. "H" ist ein horizontaler Strich, der von zwei vertikalen Strichen umgeben ist; "I" ist ein vertikaler Strich, der von zwei horizontalen Strichen umgeben ist (abhängig von Ihrer Schriftart). Ich wette, das könnte verschachtelt sein ... Weißt du, woran mich das erinnert? Fraktale !!!

Definieren wir die "IHIH" -Pyramide wie folgt: Die erste Iteration ist diese ASCII-Darstellung des Buchstabens "I":

---
 |
---

Die nächste Iteration weist auf beiden Seiten einen vertikalen Strich auf.

|   |
|---|
| | |
|---|
|   |

Wenn Sie das "I" in der Mitte als einen einzelnen horizontalen Strich betrachten, ist diese zweite Iteration im Grunde ein "H". Die dritte Iteration fügt oben und unten einen horizontalen Strich hinzu

-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

Wenn Sie das "H" in der Mitte als einen einzelnen vertikalen Strich betrachten, ist diese Iteration im Grunde ein "I". Dieses Muster setzt sich fort und wechselt bei jeder Iteration zwischen "H" und "I". Als Referenz sind hier die ersten 6 Iterationen:

1:
---
 |
---

2:
|   |
|---|
| | |
|---|
|   |

3:
-------
 |   |
 |---|
 | | |
 |---|
 |   |
-------

4:
|       |
|-------|
| |   | |
| |---| |
| | | | |
| |---| |
| |   | |
|-------|
|       |

5:
-----------
 |       |
 |-------|
 | |   | |
 | |---| |
 | | | | |
 | |---| |
 | |   | |
 |-------|
 |       |
-----------

6:
|           |
|-----------|
| |       | |
| |-------| |
| | |   | | |
| | |---| | |
| | | | | | |
| | |---| | |
| | |   | | |
| |-------| |
| |       | |
|-----------|
|           |

Die Herausforderung:

Schreiben Sie ein Programm oder eine Funktion, die die N-te Iteration der IHIH-Pyramide und einen optionalen Zeilenumbruch ausgibt. Ihre Eingabe ist eine einzelne positive Ganzzahl in dem von Ihnen gewünschten vernünftigen Format. Sie müssen keine ungültigen Eingaben verarbeiten, z. B. Nicht-Ganzzahlen, Zahlen kleiner als 1 usw. Ihr Programm muss mindestens die richtige Ausgabe für Eingaben bis 20 liefern. Da dies , sind Standardlücken nicht zulässig und die kürzeste Antwort in Bytes gewinnt!

DJMcMayhem
quelle
Ist es akzeptabel, wenn ich einen Pfeil mit Zeichenfolgen für jede Zeile zurückgebe?
Rohan Jhunjhunwala
Hat die Herausforderungskriterien nicht ganz erfüllt, aber aus Versehen etwas Gutes getan ... Online ausprobieren!
Magic Octopus Urn

Antworten:

7

Pyth , 50 40 31 25 Bytes

j @ su, J + * \ - K + 2lheN + jR * 2; eN * \ - KjR "||" + * dK + J * dKQ]] \ | 
LXR | -) CbjyW% Q2uy + K * \ - + 2lhG + jR * 2; GKQ] \ | 
juCGQuC + K * @ - | H + 3yH + jR * 2; GKQ \ |
j @ CBujR * @ - | H2CjR * 2; GQ \ |

Testsuite.

Erläuterung

Dies ist ein rekursiver Algorithmus.

In jeder Iteration führen wir drei Aktionen aus:

  1. Stellen Sie jeder Zeile ein Leerzeichen voran und fügen Sie es hinzu
  2. transponieren Sie das Array
  3. prepend und Anfügen zu jeder Zeile entweder "-"oder in "|"Abhängigkeit von der Anzahl der Iteration.

Nach den Iterationen werden die ungeradzahligen Ausgaben transponiert. Deshalb setzen wir sie um.

j@CBujR*@"-|"H2CjR*2;GQ\|   input: Q
j@CBujR*@"-|"H2CjR*2;GQ\|Q  implicit filling of arguments


    u                 Q\|   for Q times, starting with "|", G as current output,
                            H as number of iterations:

                jR*2;G          prepend and append a space to each line
                                (using each line as separator, join [" "," "])
               C                transpose
     jR*      2                 prepend and append the following to each line:
        @"-|"H                      the H-th element of the string "-|" (modular indexing)

 @CB                     Q  select the Q-th element from [output,
                            transposed output] (modular indexing)
j                           join by newlines
Undichte Nonne
quelle
Ich liebe die Transponierungsidee.
Titus
12

Python, 165 145 133 123 Bytes

Eine rekursive Lösung:

def i(e):
 d="|";a=e*2;x=d+" "*(a-1)+d
 if e<1:return d
 if e%2:d,x=[" ","-"*(a+1)]
 return[x]+[d+z+d for z in i(e-1)]+[x]

Wird mit aufgerufen print ("\n".join(i(int(sys.argv[1])))), wobei der Parameter die Iterationsnummer der IHIH-Pyramide ist.

Vielen Dank an @DJMcMayhem für die Einsparung von 20 Bytes. Die Idee hinter diesen Vorschlägen weiter zu nehmen, sparte weitere 12 Bytes. Vielen Dank an @Maltysen für Vorschläge, die mehr Bytes gekürzt haben.

Die Funktion setzt das Trennzeichen dauf "|"und die dazwischen liegenden Leerzeichen auf " "(für ungerade Iterationen), behandelt die Rückkehr im entarteten Fall und setzt dann das Trennzeichen auf " "und die dazwischen liegenden Leerzeichen auf "-"für gerade Iterationen zurück. Die Funktion gibt eine Liste von Zeichenfolgen für jede Zeile der IHIH zurück, wobei das Ergebnis eines rekursiven Aufrufs der Funktion an der richtigen Stelle in der Liste eingebettet wurde.

Simon
quelle
2
Schöne Antwort und willkommen auf der Seite! Sie müssen die Zeilen nicht verbinden, eine Liste von Zeichenfolgen ist in Ordnung. Ein paar Tipps: Ändern Sie die Zeilen 2 und 3 in if e<1:return'|'(kein Zeilenumbruch dazwischen), entfernen Sie dann das "else" und entfernen Sie den zusätzlichen Einzug.
DJMcMayhem
1
Sie können den Raum danach herausnehmen return. Sie können auch die Zeilen ohne ifs mit Semikolons zusammenführen und den Einzug
speichern
1
Ich habe deine Antwort bearbeitet. Bitte zögern Sie nicht, meine Änderungen rückgängig zu machen, wenn Sie sie nicht mögen.
Undichte Nonne
10

Cheddar , 186 177 165 154 148 131 Bytes

(n,b?,c?,q?,g=s->(n-=1)<0?s:g((q=(c=s.lines[0].len)%4>2?b='|'+" "*c+"|":b='-'*(c+2))+"\n"+s.sub(/^|$/gm,q?'|':' ')+"\n"+b))->g("|")

Verwendet die Rekursion. Fügt eine Erklärung hinzu, sobald das Golfen abgeschlossen ist.

Probieren Sie es online!

Erläuterung

Dieses ist auch ein bisschen komplex. Behalte alle Variablen im Auge, die ich verwende, aber ich werde versuchen, es einfach zu halten:

(
 n,    // Input
 b?,   // Stores row to add to top/bottom
 c?,   // Width of string 
 q?,   // false if I-ifying. true if not
 g=
   s->          // Main logic, s is generated string
    (n-=1)<0 ? s :   // Decrease input each iteration. Stop when 0
    g(               // Recurse with....
      (
        q= (         // Set `q` true if h-ifying. false if I-ifying
         c=s.lines[0].len    // Set `c` to width of string
        ) % 4>2 ?
        b='|'+" "*c+"|" :    // Set `b` to top/bottom row adding
        b='-'*(c+2)          // `*` is repeat, c is from before
      ) + "\n" + 
        s.sub(/^|$/gm,       // Add the following to beginning/end of each line
          q?'|':' '          // if H-ifying, add `|`s if I-ifying add spaces
        ) + "\n" + b         // Add bottom row, generated from before
    )
) -> g("|")     // Middle item is `|`

Dies war eine Herausforderung für den Golfsport, aber seine 55 Bytes sind kürzer als das Original.

Downgoat
quelle
8

Python 2, 93 Bytes

Undichte Nonne sparte 7 Bytes.

r=range(input()+1)
r=r[:0:-1]+r
for y in r:print''.join('| -'[[x%2,y%2+1][x&-2<y]]for x in r)
Lynn
quelle
Geschlossene Form: o: o
Leaky Nun
Ahh, natürlich: Zuerst brauchte ich, int(x/2.)weil ich genommen habe, range(-n,n+1)aber jetzt kann ich nur diese verwenden. Vielen Dank!
Lynn
Ich habe Python 2 in der Kopfzeile angegeben, weil "Python" normalerweise bedeutet, dass der Code entweder unter Python 2 oder Python 3 funktioniert, was hier nicht der Fall ist.
Mego
7

Matricks , 80 62 Bytes

Eine iterative Lösung (Rekursion in Matricks ist schwierig ...)

Laufen Sie mit python matricks.py ihih.txt [[]] <input> --asciiprint

k124; FiQ% 2: v; b [m124: Q * 2 + 3: 1;]; a {z: Q * 2 + 1;} ;: b; v [m45: 1: Q * 2 + 3;] ; u {zQ * 2 + 1:;} ;: 1: n ;;
k124; FiQ% 2: v; b [m124: Q * 2 + 3: 2;]; B1;: b; v [m45: 2: Q * 2 + 3;]; V1 ;;: 1: n;

Erläuterung:

k124;                 # Set the matrix to '|'
F...:1:n;;            # Repeat input times, (Q is iteration variable)
  iQ%2:...:...;       # if statement, check if Q is odd or even
                      # Q is even,
    b;                # Make space to the left
    v[m45:2:Q*2+3;];  # Set the top 2 rows to '-'s
    V1;               # Rotate the matrix up 1 unit, moving the topmost row to the bottom
                      # Q is odd,
    v;                # Make space above
    b[m124:Q*2+3:2;]; # Set the 2 left columns to '|'s
    B1;               # Rotate the matrix left 1 unit, moving the leftmost row to the right
Blau
quelle
1
Wow, iterativ! Ich bin beeindruckt.
Conor O'Brien
@ ConorO'Brien Matricks wurde für die dynamische Größenanpassung von Matrizen entwickelt. Es ist also nicht SO beeindruckend, aber trotzdem vielen Dank!
Blue
5

JavaScript (ES6), 92 bis 90 Byte

f=
(n,[h,c,v]=n&1?`-- `:` ||`)=>n?(c+=h.repeat(n+n-1)+c)+`
${f(n-1).replace(/^|$/gm,v)}
`+c:v
;
<input type=number min=0 oninput=o.textContent=f(+this.value)><pre id=o>

Die rekursive Lösung verwendet die vorherige Iteration, fügt das vZeichen an den Seiten und dann can den Ecken sowie ham oberen und unteren Rand hinzu. Der Zeichensatz wechselt einfach jede Iteration. Bearbeiten: 2 Bytes durch Rückgabe von vwann gespeichert n=0.

Neil
quelle
4

Dyalog APL , 52 43 Bytes

{v=⊃⍵:h⍪⍨hs,⍵,sv,⍨v,s⍪⍵⍪s}⍣⎕⍪⊃v h s'|- '

v h s←'|- 'Abtretungs die drei Zeichen zu drei Namen ( v ertikale, h orizontal, s Tempo)

der erste, dh |

Machen Sie in 1 × 1 Tabelle

{... }⍣⎕erhalten Eingaben und wenden die geschweifte Funktion so oft an

v=⊃⍵: Wenn das linke obere Zeichen des Arguments vertikal ist, gilt Folgendes:

  h⍪⍨ horizontale unten

  h⍪ Horizontale oben

  s, Leerzeichen links von

  ⍵,s das Argument mit Leerzeichen rechts

sonst:

  v,⍨ Vertikale rechts von

  v, Vertikale links von

  s⍪ Leerzeichen darüber

  ⍵⍪s das Argument mit Leerzeichen unten

TryAPL online!

Adam
quelle
3

C 110 Bytes

#define R(A,B,C)for(A=n,B=1;A<=n;putchar(C),A-=B|=-!A)
f(n,y,x,w,v){R(y,w,10)R(x,v,"| -"[x/2*2<y?y%2+1:x%2]);}

Aufrufen als f(n). Für 111 Bytes könnte ich tun:

f(n,y,x,w,v){for(y=n,w=1;y<=n;y-=w|=-!y,puts(""))for(x=n,v=1;x<=n;x-=v|=-!x)putchar("| -"[x/2*2<y?y%2+1:x%2]);}

Dh der #definespeichert genau ein Byte.

Lynn
quelle
3

Dyalog APL, 34 Bytes

{⍉⍣⍵{b,b,⍨⍉s,⍵,⊃s b←' -|'~⊃⍵}⍣⍵⍪'|'}

{... }⍣⍵⍪'|'Wende die Funktion in geschweiften Klammern an , beginnend mit 1x1 Zeichenmatrix |. Das Ergebnis jeder Anwendung ist das Argument für die nächste Anwendung.

s b←' -|'~⊃⍵s ist Leerzeichen und b ist der Balken, der sich nicht in der oberen linken Ecke des Arguments befindet. ( ' -|'~'-'Entfernt den horizontalen Balken und lässt Leerzeichen und den vertikalen Balken frei.)

s,⍵,⊃s bfüge links und rechts Leerzeichen hinzu ( Auswahl s von Vektor sb)

b,b,⍨⍉ transponieren und b nach links und rechts addieren

Bei ungeraden Zahlen bleibt das Ergebnis transponiert, sodass eine endgültige Transponierung erforderlich ist.

⍉⍣⍵Transponierungszeiten (einmal wäre ausreichend, aber kürzer, um auf diese Weise zu codieren)

TryAPL online

Gil
quelle
Willkommen bei PPCG!
Stephen
Vielen Dank! Der Versuch, jetzt an der Party teilzunehmen, macht viel Spaß beim Lösen :)
Gil
2

Cheddar, 85 Bytes

(n,r=(-n|>n).map(v->abs v))->r.map(y->r.map(x->"| -"[(x&-2)<y?y%2+1:x%2]).fuse).vfuse

Meine erste Antwort von Cheddar. Probieren Sie es online!

Wenn ich versuche zu schreiben r=(-n|>n).map(v->abs v).map, r(y->r(x->…))stürzt der Interpreter ab. ; -;

Lynn
quelle
Sie können machen v->abs vin (abs)(zB r.map((abs))) , die eine Funktion zurück , die das Verhalten der ABS - Funktion hat. zB (+)(1,2)-> 3. (^)(2,6)-> 64. Auch großartig, wenn du mich um fast 50%
übertriffst
Nein, das habe ich versucht: Runtime Error: `abs` has no behavior for types `Number` and `Number` ( maperhält vermutlich sowohl das Element als auch seinen Index.)
Lynn
ah: / Ich war gerade dabei, diesen Fehler heute zu beheben> _>
Downgoat
2

APL (Dyalog Classic) , 34 Byte

'- |'[2+∘.(≤-(1+=)×2|⌈)⍨(⌽,0,⊢)⍳⎕]

Probieren Sie es online!

(verwendet ⎕io←1)

⍳⎕ ist 1 2 ... N

(⌽,0,⊢) ist ein Zug, der daraus macht -N ... -1 0 1 ... N

∘.( )⍨ Führt die Klammern für jedes Koordinatenpaar aus ⍺ ⍵

Der Zug (≤-(1+=)×2|⌈)oder sein dfn-Äquivalent {(⍺≤⍵)-(1+⍺=⍵)×2|⍺⌈⍵}erzeugt eine Matrix wie:

 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
  0  1  0  0  0  0  0  0  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  1  0  1  0  1  0
  0  1  0  1 ¯1 ¯1 ¯1  1  0  1  0
  0  1  0  1  0  0  0  1  0  1  0
  0  1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1  1  0
  0  1  0  0  0  0  0  0  0  1  0
 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

'- |'[2+ ]Legt diese gültigen Indizes fest ⎕IO=1und wählt die entsprechenden Zeichen aus

ngn
quelle
1

Ruby, 81 78 77 Bytes

Dies basiert auf Lynns Python-Antwort . Golfvorschläge sind willkommen.

Edit: 3 Bytes dank Lynn. Korrekturen und Golfen 1 Byte dank Jordan.

->n{r=(-n..n).map &:abs;r.map{|y|puts r.map{|x|"| -"[x&-2<y ?y%2+1:x%2]}*""}}

Ungolfing:

def f(n)
  r = -n..n            # Range from -n to n (inclusive)
  r = r.map{|i|i.abs}  # Turns every element of r positive
  r.each do |y|
    s = ""             # a line of the fractal
    r.each do |x|      # build up the fractal based on x and y
      if x/2*2 < y
        s += " -"[y%2]
      else
        s += "| "[x%2]
      end
    end
    puts s             # print the line
  end
end
Sherlock9
quelle
Können Sie .map(&:abs)?
Lynn
@Lynn Gut gesehen. Irgendwelche anderen Vorschläge?
Sherlock9
Der erste *macht gar nichts. Sie können *""anstelle von verwenden .join. Wenn Sie pdie einzelnen Zeilen in Anführungszeichen setzen (dabei werden inspectdie Argumente aufgerufen), kann dies zu einer Disqualifikation führen.
Jordanien
Sie können auch die Klammern um &:abs( map &:abs) entfernen . Möglicherweise können Sie etwas mit Array#productverschachtelten maps tun , aber Zeilenumbrüche sind schwierig.
Jordanien
@Jordan Deine ersten vier Tipps funktionieren, aber r.product(r).map(wie auch immer) sind länger und lassen keine Zeilenumbrüche zu.
Sherlock9
1

MATLAB, 168 163 Bytes

Dies ist wahrscheinlich nicht die clevere Methode: Erweitern einer Zeichenfolge nach allen Seiten in nSchritten:

function s=g(n);s='|';for m=1:n;if mod(m,2);a=45;b=a;c=0;else a='|';b=0;c=a;end;s=[a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];s(:,end+1)=s(:,1);s(end+1,:)=s(1,:);end

Verwendung: Speichern unter g.m(muss ich das zur Byteanzahl hinzufügen?) Und rufen zB auf g(15).

Ungolfed:

function s=g(n)

% // Initialize s
s = '|';

for m=1:n
   % // Decide if odd or even number and which symbol to add where
   if mod(m,2)
      a=45;b=a;c=0; % // char(45) is '-' and char(0) is ' ' (thx to Luis Mendo)
   else
      a='|';b=0;c=a;
   end
      % // Add symbols at top and left to s
      s = [a repmat(b,1,2*m-1);repmat(c,2*m-1,1) s];
      % // Add symbols at right and bottom to s
      s(:,end+1) = s(:,1);
      s(end+1,:) = s(1,:);
end
Wauzl
quelle
Sie können ersetzen ' 'durch 0(Matlab behandelt Zeichen 0 als Leerzeichen) und '-' durch 45. Der Dateiname muss nicht in der Byteanzahl enthalten sein
Luis Mendo
1

Eigentlich , 48 45 44 Byte

Dies ist ein Versuch, meine Ruby-Antwort auf Actually zu portieren. Das ist viel zu lang und Golfvorschläge werden sehr geschätzt. Probieren Sie es online!

u;±ux♂A╗╜`╝╜";2@%2╛%u╛(2±&<I'-' '|++E"£MΣ.`M

Hier ist eine 46-Byte-Version, die die verschachtelten Funktionen aufteilt, damit wir sie "| -"in weniger Bytes definieren können . Probieren Sie es online!

u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£MΣ."%£M

Ungolfing:

Erster Algorithmus

u         Increment implicit input.
;±u       Duplicate, negate, increment. Stack: [-n n+1]
x♂A       Range [-n, n+1). Abs(x) over the range.
╗         Save list to register 0. Let's call it res.
╜         Push res so we can iterate over it.
  `         Start function (with y from map() at the end)
  ╝         Save y to register 1.
  ╜         Push res so we can iterate over it.
    "         Start function as string (with x from map() at the end)
    ;         Duplicate x.
    2@%       x mod 2.
    2╛%u      y mod 2 + 1.
    ╛(2±&<I   If x&-2 < y, then y%2+1, else x%2.
    '-' '|++  Push "| -" (We're inside a string right now,
                          so we need to push each char individually)
    E         Grab index of "| -"
    "£        End string and turn into function.
  M         Map over res.
  Σ.        sum() (into a string) and print.
  `         End function.
M         Map over res.

Zweiter Algorithmus

u;±ux♂A╗╜                  Create res as before.
`;2@%2╛%u╛(2±&<I"| -"E`#   The inner function from the first algorithm put into a list.
                             The only change to the function is the definition of "| -".
"╝╜  £MΣ."                 Most of the outer function from the first algorithm as a string.
   %r      %               %-formats the list into the outer function.
            £M             Turns the string into a function, maps over res.
Sherlock9
quelle
u;±ux♂A╗╜`;2@%2╛%u╛(2±&<I"| -"E`#"╝╜%r£Mεj."%£Mist länger als das, was Sie derzeit haben (um 2 Byte), aber Sie finden möglicherweise Anregungen, wie Sie es kürzer machen können, die ich nicht sehe.
Mego
1

Canvas , 19 18 17 14 Bytes

|╶[ e↷l|*e}╶[↷

Probieren Sie es hier aus!

Wenn ich jede zweite Ausgabe um 90 ° gedreht ausgeben dürfe, könnten die letzten 4 Zeichen entfernt werden.

Erläuterung (einige Zeichen wurden so geändert, dass sie ~ monospace aussehen):

|               push "|" - the canvas
 ╶[       }     repeat input times
    e             encase the canvas in spaces horizontally
     ↷            rotate the canvas 90°
      l|*         push "-" repeated the canvas height times vertically
         e        and encase the canvas if two of those horizontally
           ╶[   repeat input times
             ↷    rotate the canvas 90°
dzaima
quelle
Ich würde 6 Bytes verlieren, wenn sie diese Einschränkung auch lösen würden: P.
Magic Octopus Urn
@MagicOctopusUrn wellp, mach das -5 Bytes für mich: p (könnte deine Antwort auch von einer Transponierungsschleife profitieren?)
dzaima
Meine Implementierung ist eine Transponierungsschleife: D.
Magic Octopus Urn
1

05AB1E , 29 28 Bytes

„|-S¹>∍ƶćsvy‚˜.Bζ}¹Fζ}»R.∞.∊

Probieren Sie es online!

-1 dank Dzaima ...

Dies ist eine iterative Lösung.


Dies erfolgt im Wesentlichen durch Erstellen des folgenden Musters:

['|','--','|||',...]

Dann paarweise jedes Element zusammen transponieren und die Polsterung hinzufügen.

Durch das Transponieren nach jeder Iteration wird eine einzelne Ecke des Musters erstellt.

Dann können wir die Reflexionsbefehle von 05AB1E verwenden.


„|-S                         # Push ['|','-']
    ¹>∍                      # Extended to input length.
       ƶ                     # Each element multiplied by its index.
        ćs                   # Extract head of list, swap remainder to top.
          v      }           # For each element in the '|-' list...
           y‚˜               # Wrap current 2D array with new entry, flatten.
              .Bζ            # Pad and transpose, leaving it transposed for the next addition.
                 }           # End loop.
                  ¹Fζ}       # Transpose N times.
                      »R     # Bring it all together into a newline string, reverse.
                        .∞.∊ # Mirror horizontally, then vertically with overlap.
Magische Kraken-Urne
quelle
0

Mathematica, 158 bis 164 Bytes

f[n_]:=Print/@StringJoin/@Map[{{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}}[[##]]&@@#&,Table[{1+i~Mod~2, 1+j~Mod~2, 2+Sign[Abs[i]-Abs[j]]}, {i,-n,n}, {j,-n,n}],{2}]

Berechnet mathematisch das richtige Symbol an den Koordinaten (i, j), wobei beide von -n nach n verlaufen. Menschlich formatiert:

f[n_]:=Print/@
 StringJoin/@
  Map[
   {{{"|","|", },{ , , }},{{"|", ,"-"},{ ,"-","-"}}[[##]]&@@#&,
   Table[{1+i~Mod~2,1+j~Mod~2,2+Sign[Abs[i]-Abs[j]]},{i,-n,n},{j,-n,n}],
   {2}]
Greg Martin
quelle
@Adam Danke für den Hinweis auf diesen Thread!
Greg Martin
0

PHP, 166 Bytes

mehr als 100 Bytes von meinem ersten Ansatz golfen und es ist immer noch die längste Antwort hier.

function i($n){for($m=['|'];$k++<$n;){array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));foreach($m as$i=>&$r)$r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;}return$m;}

Nervenzusammenbruch

function h($n)
{
    for($m=['|'];$k++<$n;)
    {
        array_unshift($m,$m[]=str_repeat(' -'[$f=$k&1],2*$k-1));
        foreach($m as$i=>&$r)
            $r=($c='||- '[2*$f+($i&&$i<2*$k)]).$r.$c;
    }
    return$m;
}

ungolfed

function ihih($n)
{
    $m=['|'];                   // iteration 0
    for($k=1;$k<=$n;$k++)       // loop $k from 1 to $n
    {
        $f=$k&1;                        // flag for odd iterations
        // add lines:
        $r=str_repeat(' -'[$f],2*$k-1); // new line: ' ' for even, '-' for odd iterations
        $m[]=$r;                                // append
        array_unshift($m,$r);                   // prepend
        // add columns:
        foreach($m as$i=>&$r)           // for each line
        {
            $c='| '[$f];                        // '|' for even, ' ' for odd iterations
            if($f && (!$i || $i==2*$k)) $c='-'; // '-' in corners for odd iterations
            $r=$c.$r.$c;                        // prepend and append character
        }
    }
    return $m;
}
Titus
quelle
0

Perl 5 , 150 Bytes

sub h{my$i=pop;my$c=$i%2?$":'|';return(map{"$c$_$c"}h($i-1)),$i%2?'-'x($i*2+1):$c.$"x($i*2-1).$c if$i;()}say for reverse(@q=h<>),$q[0]=~s/---/ | /r,@q

Probieren Sie es online!

Xcali
quelle
0

Haskell , 110 Bytes

f 0=["|"]
f n|odd n=g ' '!n$'-'|1>0=g '|'$id!n$' '
g c=map$(c:).(++[c])
(g!n)c|p<-g.f$n-1=(:p)<>pure$c<$head p

Probieren Sie es online!

Erklärung / Ungolfed

Die gHilfsfunktion nimmt ein Zeichen und eine Liste von Zeichenfolgen entgegen und hängt dieses Zeichen an jede Zeichenfolge an:

g c = map (\s-> [c] ++ s ++ [c])

Als nächstes nimmt der Operator (!)eine Funktion ( g), eine Zahl ( n) und ein Zeichen ( c). Dann berechnet es die Ausgabe für n-1, wendet die Funktion darauf gan und fügt cam Anfang und am Ende eine Zeichenfolge mit der gleichen Breite ein, die aus s besteht:

(g ! n) c | prev <- g $ f (n-1), ln <- [c | _ <- head p]
          = [ln] ++ prev ++ [ln]

Damit wir die Ausgaben rekursiv generieren können, müssen wir zunächst den Basisfall abdecken:

f 0 = ["|"]

Und dann die Rekursion:

-- for odd n: the previous output needs a space at the end and beginning and then a string of '-' characters at the top and bottom
f n | odd n     = (g ' ' ! n) '-'
-- for even n: the previous output needs a line of spaces at the top and bottom and then each line needs to be enclosed with '|' characters
    | otherwise = g '|' $ (id ! n ) ' '
ბიმო
quelle
0

J , 37 Bytes

f=:{&' |-'@*@(-:@=+<-2&|@>.)"{~@:|@i:

TIO

Jayprich
quelle
0

Stax , 22 Bytes

âeò↕\┐▄┤╚╬8φ8Δ☺Pä≤δ₧߃

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

'|          string literal "|"
{           begin block to repeat
  . |G      push " |", then jump to trailing `}` below 
  '-z2lG    push ["-",[]], then jump to trailing `}` below again
}N          repeat block according to number specified in input
m           output each row in grid

}           goto target - `G` from above jumps to here
  i@        modularly index into pair using iteration index
  ~         push to input stack
  {;|Sm     surround each row with the extracted element
  M         transpose grid

Führen Sie dieses aus

rekursiv
quelle