Herausforderung

Zeichnen Sie mit einem ASCII- Operator aus der folgenden Liste und einer Zahl n eine ASCII-Darstellung des Operators, wobei dieser Operator als Zeichen mit den Liniensegmenten des Operators der Länge n verwendet wird .

Eingang

Ein ASCII-Zeichen aus der Liste = + - x /und eine Ganzzahl, nbei der n >= 1. (Ich benutze xanstelle von *und /anstelle von ÷, aber Sie können auch eines verwenden, je nachdem, was einfacher ist.) Für +und xmüssen Sie nur ungerade Zahlen verarbeiten, um Probleme mit der Ausrichtung zu vermeiden.

Ausgabe

Eine ASCII-Zeichnung des Operators, die aus dem Zeichen mit Segmenten der Länge n besteht. Horizontale Abschnitte sollten Leerzeichen zwischen den Zeichen enthalten, um vertikale / horizontale Abstandsunterschiede auszugleichen.

Regeln

Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes. Standardlücken sind verboten.

Beispiele

Eingang: + 3

  +
+ + +
  +

Eingang: = 4

= = = =
= = = =

Eingang: = 10

= = = = = = = = = =
= = = = = = = = = =

Eingang: - 2

- -

Eingang: / 10

         /
        /
       /
      /
     /
    /
   /
  /
 /
/

Eingang: x 7

x     x
 x   x
  x x
   x
  x x
 x   x
x     x

Pip , 62 59 56 Bytes

55 Byte Code, +1 für -SFlag.

[sXbRA_AEv-_aM,b(Y^aWR_Xb/2s)MyRVsX,b.aYaXbJsxyRL2x]@Aa

Beachten Sie, dass diese Lösung funktioniert mit Eingang ÷für die Division und *für die Multiplikation, obwohl es diese Zeichen verwendet ASCII-Kunst zu ziehen /und xjeweils. OP hat klargestellt, dass dies in Ordnung ist. Probieren Sie es online!

Wie?

Hier ist eine teilweise beabstandete und kommentierte Version . Beachten Sie, dass aund bdie Befehlszeilenargumente sind, dh der Operator bzw. die Größe. Das -SFlag steuert, wie Listen ausgegeben werden: Es verbindet sich zuerst in Zeilenumbrüchen, verbindet sich jedoch mit verschachtelten Listen in Leerzeichen.

[                 Build a list of all possible figures:
 sXbRA_AEv-_aM,b   0 - Multiplication
 (Y^aWR_Xb/2s)My   1 - Addition
 RVsX,b.a          2 - Division
 YaXbJs            3 - Subtraction
 x                 4 - Empty
 yRL2              5 - Equals
 x                 6 - Empty
] @ Aa            Index, mod 7, with ASCII value of a

Und hier sind die einzelnen Abschnitte:

Multiplikation

Für jede Zeile in der Figur erzeugen wir eine Folge von Leerzeichen und ersetzen dann zwei durch das Eingabezeichen. Für row imöchten wir die Leerzeichen bei index iund ersetzen b-1-i. Beachten Sie jedoch, dass dieser den negativen Index verwenden kann -1-i. (Es ist sogar noch kürzer , da die Variable vzu negati vorinitialisiert ist v e 1.)

sXbRA_AEv-_aM,b
            M,b  Map this function to range(b):
sXb                Space, repeated b times
     _             Function arg
      AE           (Implicitly) convert to list and append element...
        v-_        -1 minus function arg
   RA              Replace the characters at those indices...
           a       ... with input character
                 The resulting list is output with one item per line

Zusatz

Mit Hilfe der Strategie von meiner Zeichnen Sie eine leere Quadrat Antwort definieren wir eine Funktion , die eine Wraps +in b/2Kopien ihres Arguments und gibt das Ergebnis als eine Liste von Zeichen. (Eine Ganzzahldivision //ist nicht erforderlich, da der Operator für die Zeichenfolgenwiederholung Xautomatisch auf eine Ganzzahl abschneidet.) Zuerst rufen wir diese Funktion für ein Leerzeichen auf und geben [" ";" ";"+";" ";" "]; dann ordnen wir diesem Ergebnis die gleiche Funktion zu, wobei wir [" ";" ";"+";" ";" "]auf den meisten Linien aber ["+";"+";"+";"+";"+"]auf der Mittellinie angeben. Diese verschachtelte Liste wird dann aufgrund des -SFlags mit Leerzeichen zwischen allen Zeichen in einer Zeile und Zeilenumbrüchen zwischen den Zeilen ausgegeben.

(Y^aWR_Xb/2s)My
                 Anonymous function:
      _Xb/2        Function arg, repeated b/2 times (implicitly rounded down)
   aWR             Wrap a in two copies of the above
  ^                Split resulting string into list of chars
 Y               Yank that function into y
(          s)    Apply function y to space
             My  Map y to that result

Teilung

Jede Zeile enthält zwischen b-1und 0Leerzeichen, gefolgt vom Eingabezeichen a.

RVsX,b.a
    ,b    Range(b)
  sX      Space, repeated that many times (works itemwise)
      .a  Concatenate a (itemwise)
RV        Reverse (puts the larger number of spaces at the beginning)
          Outputs newline-separated

Subtraktion

Erstellen Sie eine durch Leerzeichen getrennte Zeile des Eingabezeichens. Speichern Sie eine Kopie für später.

YaXbJs
 aXb    b copies of a
    Js  Join on space
Y       Yank into y (overwrites the function from earlier, but we're done using it anyway)
        This is a string, so it just gets output

Gleich

Der Subtraktionsschritt speicherte die Hälfte dessen, was wir brauchen y- verdoppeln Sie ihn einfach.

yRL2  (Implicitly) convert y to list and repeat it twice
      Outputs newline-separated

Die Dummy- xWerte dienen zum Auffüllen der Hauptliste, sodass die modulare Indizierung einen eindeutigen Index für jedes eingegebene Zeichen in ergibt +-*÷=.

V , 78, 72, 71, 68, 65, 63, 62 , 61 Bytes

Ç=ü-/Àé X
ç^Ó/é Àä$
ç+/ÀÄM|ÀR+ 
ç=/Ä
ç¯/lòhYpX
çx/rxòl3Äjxlrx

Probieren Sie es online!

Wie immer macht der Zweikampf mit 05AB1E richtig Spaß!

Da dies nicht-ASCII-Zeichen enthält, ist hier ein Hexdump:

0000000: c73d fc2d 2fc0 e920 580a e75e d32f e920  .=.-/.. X..^./. 
0000010: c0e4 240a e72b 2fc0 c44d 7cc0 522b 200a  ..$..+/..M|.R+ .
0000020: e73d 2fc4 0ae7 af2f 6cf2 6859 7058 0ae7  .=/..../l.hYpX..
0000030: 782f 7278 f26c 33c4 6a78 6c72 78         x/rx.l3.jxlrx

Dadurch werden führende Leerzeichen in der Ausgabe für =und erstellt -, dies scheint jedoch zulässig zu sein . Wenn dies nicht erlaubt ist, können Sie dies gerne kommentieren und ich werde es zurücksetzen.

Erläuterung

Der "globale Befehl" çwendet (z. B. ) einen bestimmten Satz von Befehlen auf jede Zeile an, die einem bestimmten regulären Ausdruck entspricht. Die Syntax lautet

ç<compressed regex>/<commands>

Dies ist die einfachste Möglichkeit, eine Bedingungs- / switch-Anweisung zu simulieren. In meiner ursprünglichen Antwort habe ich einfach die gesamte ASCII-Grafik auf der rechten Seite für jedes Zeichen erstellt, nach dem wir suchen müssen. Viele dieser Ausgaben erfordern jedoch ähnliche Befehle. Also habe ich sie kombiniert. Der erste Befehl ('Ç') ist eigentlich die Umkehrung des globalen Befehls. Er wendet den Befehl auf jede Zeile an, die nicht mit dem regulären Ausdruck übereinstimmt. Der erste Befehl lautet also:

Ç=ü-        " On every line not containing an '=' or an '-' (e.g. inputs '/', '+', and 'x'):
    /Àé     "   Insert *n* spaces
        X   "   Delete one of them

Der folgende Befehl gilt für die Eingänge '=' und '-'. Diese zwei sind bequem einfach und ähnlich. Nach diesem Befehl brauchen wir keine Bearbeitung mehr für -.

ç^Ó         " On every line that starts with non-whitespace (e.g. every line not affected by our previous command):
   /é       "   Insert one space
            "   Move back a character
      À     "   Make *n* copies
       ä$   "   Of every character on this line

Von hier aus führen wir nur einige zusätzliche Befehle für jede einzelne mögliche Eingabe aus. Für +:

ç+/         " On every line containing a '+':
   ÀÄ       "   Make *n* copies of this line
     M|     "   Move to the first character of the middle line
       À    "   *n* times:
        R+  "   Replace the next two characters with '+ '

Der Befehl für gleich ist sehr einfach. Wir duplizieren es einfach mit Ä. Für /:

ç¯          " On every line containing a '/':
  /l        "   Move one character to the right
    ò       "   Recursively:
     h      "     Move one character to the left
      Yp    "     Make a copy of this line
        X   "     Delete one character
         ò  "   End loop (implicit)

Der letzte ist der komplizierteste. Es ist im Grunde ein Hafen dieser Antwort .

çx              " On every line containing a 'x':
  /rx           "   Replace the first character with an 'x'
     ò          "   Recursively:
      l         "     Move one char to the right
       3Ä       "     Make 3 copies of this line
         j      "     Move down one line
          x     "     Delete one char
           l    "     Move one char to the right
            rx  "     Replace this char with an 'x'

05AB1E , 81 76 74 73 70 69 68 65 64 62 60 59 57 56 Byte

Derzeit im Krieg mit der V-Antwort . Ich komme für Sie Dr. McMoylex: p.

Auch im Krieg mit der Pip-Antwort . Ich werde Sie Mr. DLosc beobachten.

Code:

Ç6&"¹s<ú.s.Bívy¹'xQiÂðñ}, ¹×S)»¹'=Qƒ= ;ƒ¹})D¦»»Rû.c"#è.V

Oder in besser lesbarer Form:

  Ç6&
"¹s<ú.s.Bívy¹'xQiÂðñ},
 ¹×S)»¹'=Qƒ=
 ;ƒ¹})D¦»»Rû.c"
#è.V

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python 3, 304 283 278 Bytes

Einfach genug, erstellt nur eine Zeichenmatrix und wendet die verschiedenen Operationen an, je nachdem, um welche es sich handelt. Die =und -haben nachgestellte Leerzeichen, wenn das nicht so schlimm ist.

EDIT: Danke an @Shebang und @Rod für ihre Vorschläge, die am Ende 21 Bytes einsparen!

EDIT2: Danke an @Artyer für das Speichern von 5 Bytes!

t,s=input().split()
s=int(s)
r=range(s)
b=[[' ']*s for x in r]
exec(['for x in r:b[s//2][x]=b[x][s//2]=t','b=[t*s]'+'*2'*(t=='='),'for x in r:b[x][s-x-1]='+'b[x][x]='*(t=='x')+'t'][(t>'+')+(t in'x/')])
if t in'-=+':b=[[x+' 'for x in l]for l in b]
print(*map(''.join,b),sep='\n')

JavaScript (ES6), 238 225 215 202 196 Bytes

(c,n)=>[...Array(i=n*(c=="="?4:c+1-1?2:c<"-"?n+n:n+1))].map(_=>--i%(n+(c=='/'|c>'w'||n))?c>'w'?i%n&&~-i%(n+2)?" ":c:c<'-'?i%(n*2)-n&&(~i&1|(n/2^i/n/2))?" ":c:c=="/"?i%n?" ":c:i%2?c:" ":`
`).join``

Könnte wahrscheinlich Golf spielen, aber es ist ein Anfang.

Scala, 275 Bytes

(i,c)=>if(c<44){val b=(" "*(i-1)+"+\n")*((i-1)/2)
b+"+ "*i+"\n"+b}else
if(c<46)"- "*i else
if(c<48)i-1 to(0,-1)map(" "*_+"/\n")mkString else
if(c<62)"= "*i+"\n"+"= "*i
else{val a=0 to i/2-1 map(x=>" "*x+"x"+" "*((i/2-x)*2-1)+"x"+" "*x+"\n")mkString;a+" "*(i/2)+"x"+a.reverse}

Verwendung:

val f:((Int,Char)=>String)=...
print(f(10, '/'))

Erläuterung:

Der Code prüft den ASCII-Wert des Zeichens, um die richtige Art der Image-Generierung auszuwählen. Die ASCII-Werte der betreffenden Bediener sind: ('+' -> 43), ('-' ->45), ('/' -> 47), ('=' -> 61), ('x' -> 120)

(i,c)=>                              //define a function
  if(c<44){                            //if c is a plus
    val b=(" "*(i-1)+"+\n")*((i-1)/2)    //define the top/bottom part b as (i-1)/2 times (i-1) spaces, a plus sign and a newlineine
    b+"+ "*i+"\n"+b                      //return b, i times a plus and a space, a newline and b
  }else if(c<46)                       //if c is a '-'
    "- "*i                               //return "- " repeated i times
  else if(c<48)                        //if c is a '/'
    i-1 to(0,-1)                         //create a range from i-1 to 0 in steps of -1
    map(" "*_+"/\n")                     //map each number to that number of spaces plus a "/" and a newline
    mkString                             //join them together
  else if(c<62)                        //if c is '='
    "= "*i+"\n"+"= "*i                   //return "= " repeated i times, a newline and "= " repeated i times again
  else{                                //if c if 'x'
    val a=                               //define a, which will be the top part, as...
      0 to i/2-1                         //a range from 0 to i/2-1
      map(n=>                            //map each number n to
        " "*n                              //n spaces
        +"x"                               //plus an "x"
        +" "*((i/2-n)*2-1)                 //plus ((i/2)-n)*2-1 spaces
        +"x"                               //plus an "x"
        +" "*n                             //plus n spaces
        +"\n"                              //and a newline
      )mkString;                         //join them
    a+" "*(i/2)+"x"+a.reverse          //return a, i/2 spaces, "x" and the reverse of a 
  }

JavaScript (ES6), 156 Byte

(c,n)=>[...Array(n--)].map((_,i,a)=>a.map((_,j)=>({'/':a=i+j-n,x:a&&i-j,'-':a=i+i-n,'+':a&&j+j-n,'=':a+2&&a-2}[c]?' ':c)).join(c=='='|c<'/'?' ':'')).join`\n`

Wobei \ndas wörtliche Zeilenumbruchzeichen darstellt.

Dyalog APL , 91 86 Bytes

Needs ⎕IO←0, was bei vielen Systemen Standard ist. Nimmt n als linkes Argument und eines von + - × ÷ = als rechtes Argument.

{s←⌈⍎⍕3⍵2
t←' '⍵
d←⌽∘.=⍨⍺
s∊2 6:t[d∨⌽d∧6=s]
5=s:t[↑,/2↑¨∨/¨(⌊⍺÷2)=⍳⍺ ⍺]
(2-s)(2×⍺)⍴t}

Erläuterung

{
    s ← ⌈ ⍎ ⍕ 3 ⍵ 2             ⍝ calculate ceil(3 f 2), where f is the given symbol
    t ← ' '⍵                    ⍝ create a string with a space before the symbol
    d ← ⌽ ∘.=⍨ ⍺                ⍝ Boolean \ diagonal
    s ∊ 2 6: t[d ∨ ⌽ d ∧ 6 = s] ⍝ if ÷ or × index t with one or both diagonals
⍝ find coordinates that are in the middle of at least one dimension
⍝ pad with zeros for spacing
⍝ use that to index into t
    5 = s: t[ ↑ ,/ 2↑¨ ∨/¨ (⌊ ⍺ ÷ 2) = ⍳ ⍺ ⍺]
⍝ - or =:
    (2 - s) (2 × ⍺) ⍴ t       ⍝ one or two rows of double-spaced symbols
}

Mathematica, 191 Bytes

e=#~Mod~2==1&;StringRiffle[Normal@SparseArray[{a_,b_}/;(a+b==d+1||a==b)[e@b&&a<3,,e@b&&(a==⌈d/2⌉||b==d),,e@b&&a<2,,a+b==d+1][[Last@ToCharacterCode@#~Mod~10]]:>#,{d=#2,2d-1}," "],"
"," "]&

Anonyme Funktion. Nimmt eine Zeichenfolge und eine Zahl als Eingabe und gibt eine Zeichenfolge als Ausgabe zurück. Bei weitem nicht die kürzeste, aber es macht trotzdem Spaß zu schreiben.

C 396 Bytes

#define p(x) printf(x);
i,j,k,m;f(char s,int n){i=k=0;if(s==45)for(;i<n;++i)p("- ")m=n/2;if(s==43)for(;i<n;++i)for(j=0;j<=m;++j)if(i-m)p(j-m?"  ":"+\n")else{for(;k<n;++k)p("+ ")p("\n")j+=m;}if(s==61)for(;i<2;++i){for(k=0;k<n;++k)p("= ")p("\n")}j=n;if(s==47)for(;i<n;++i){--j;for(k=0;k<j;++k)p(" ")p("/\n")}if(s==120)for(;i<n;++i){k=m-abs(m-i);for(j=0;j<n-k;++j)p(j-k?" ":"x")p(i-m?"\bx\n":"\n")}}

Rufen Sie an mit:

int main()
{
   f('x', 5);
   return 0;
}

SOML , 104 100 Bytes (nicht konkurrierend)

    Cd³³b»E +=?ce*d+e{t}bd*Oe{t}} ==?b*tt} -=?b*t} /=?bc*b{j:d+p}} x=?"”cb*e{jj⁴⁴d;d+++tGG;c+;}XOdoe{O

Dies ist eine Art Konkurrenz, da ich mir ziemlich sicher bin, dass alles, was ich hier verwendet habe, Dokumente auf github vor dem Veröffentlichungsdatum dieser Frage enthält, der Parser jedoch einige Funktionen, die ich so idk verwendet habe, nicht unterstützt.

PHP, 306 292 281 282 281 275 270 Bytes

$r=str_pad("",2*$n=$argv[2],($c=$argv[1])." ")."\n";if(",">$c)$r=($m=str_repeat(str_pad($c,$n," ",0)."\n",$n/2))."$r$m";if(9<$c)$r.=$r;if(w<$c)for($r=$c;$i<$n;$r[$i*(2+$n)]=$r[++$i*$n-1]=x)$r[$i*$n+$i+$n]="\n";if("/"==$c)for($r=$s="";$i++<$n;$s.=" ")$r="$s/\n$r";echo$r;

Oh, das ist sperrig ... braucht weiteres Golfen.
Ich könnte 4 Bytes mit physischen Zeilenumbrüchen oder ein Byte mit "\ n" in eine Variable speichern.

C #, 744 Bytes

Es ist ungefähr 1 Million Zeichen lang, denke ich, aber es ist mir egal, ich bin nur so froh, dass ich das gelöst habe ...

Golf gespielt:

string A(string s,int n){string O="";Func<string,int,string>R=(a,b)=>{return string.Join("",Enumerable.Repeat(a,b))+"\r\n";};switch(s){case"+":for(int i=0;i<n;i++){if(i==n/2){O+=R("+",n);}else{O+="+".PadLeft(n-n/2,' ').PadRight(n-n/2,' ')+"\r\n";}}return O;case"=":return R("=",n)+R("=",n);case "-":return R("-",n);case "/":for(int i=n;i>0;i--){O+="/".PadLeft(i)+"\r\n";}return O;case "x":int x=0;string[]r=new string[n];for(int i=n;i>0;i--){if(n-x-x<0){O+="x".PadLeft(x+1)+"\r\n";break;}string row=string.Join("",Enumerable.Repeat(" ",x))+"x"+string.Join("",Enumerable.Repeat(" ",n-x-x))+"x"+"\r\n";O+=row;x++;r[x]=row;if(i==n/2)break;}for(int i=r.Length-1;i>0;i--){if(string.IsNullOrEmpty(r[i]))continue;O+=r[i];}return O;default:return "";}}

Ungolfed:

public string A(string s, int n)
{
  string O = "";

  Func<string, int, string> R = (a, b) =>
  {
    return string.Join("", Enumerable.Repeat(a, b)) + "\r\n";
  };

  switch (s)
  {
    case "+":
      for (int i = 0; i < n; i++)
      {
        if (i == n / 2)
        {
          O += R("+", n);
        }
        else
        {
          O += "+".PadLeft(n - n / 2, ' ').PadRight(n - n / 2, ' ') + "\r\n";
        }
      }
      return O;
    case "=":
      return R("=", n) + R("=", n);
    case "-":
      return R("-", n);
    case "/":
      for (int i = n; i > 0; i--)
      {
        O += "/".PadLeft(i) + "\r\n";
      }
      return O;
    case "x":
      int x = 0;
      string[] r = new string[n];
      for (int i = n; i > 0; i--)
      {
        if (n - x - x < 0)
        {
          O += "x".PadLeft(x + 1) + "\r\n";
          break;
        }
        string row = string.Join("", Enumerable.Repeat(" ", x))
          + "x"
          + string.Join("", Enumerable.Repeat(" ", n - x - x)) + "x" + "\r\n";
        O += row;
        x++;
        r[x] = row;
        if (i == n / 2)
          break;
      }
      for (int i = r.Length - 1; i > 0; i--)
      {
        if (string.IsNullOrEmpty(r[i]))
          continue;
        O += r[i];
      }
      return O;
    default:
      return "";
  }
}

Testen:

+: 3, 5, 7, 9, 11
/: 7, 8, 9, 10
-: 3, 4, 5, 6
=: 3, 4, 5, 6, 7
x: 5, 7, 9, 11

Zu viel zum Einfügen und Formatieren, ich habe einen Pastebin erstellt:

Pastebin

C 331 Bytes

i,j;f(o,n){if(47==o)for(i=n;i;puts("")){for(j=i--;j--;putchar(j?32:o)){}}
if(43==o)for(i=n;i--;puts("")){for(j=n;j--;printf(i==n/2||!j?"+ ":" ")){}}
if(45==o)for(i=n;i--;putchar(o)){}
if(61==o)for(i=3;i--;puts("")){for(j=n;j--;putchar(i&1?32:o)){}}
if(120==o)for(i=n;i;puts("")){for(j=0;j++<n;putchar(j==i||j==n-i+1?o:32)){}i--;}}

Der Operator wird als ASCII-Code an ound die Zeichenanzahl an übergeben n. Ich habe nur Leerzeichen zwischen horizontal aufeinanderfolgenden Zeichen in das Pluszeichen eingefügt, da dies das einzige war, bei dem die Ausgabe verzerrt gewesen wäre, wenn ich es nicht getan hätte, und in der Aufgabe stand nur "sollte". Ich verwende zwei verschachtelte Schleifen, die abwärts zählen (mit Ausnahme von- wenn ich nur eine Zeile benötige).

= Drei Zeilen, eine davon leer, geradeaus

+ mit printf wegen der Räume

- geradeaus

/ Lassen Sie die innere Schleife auf Null drucken und beginnen Sie am Zähler der äußeren Schleife

x Lasse die innere Schleife auf den Zähler der äußeren Schleife drucken und die "Inverse" n-i . Ich muss noch nachsehen, warum ich hier allein bin.

Beispielanruf:

#include <stdio.h>
/*  =       61
    +       43
    -       45
    /       47
    Space   32
    x       120
*/
int main(int argc, char **argv){
    printf("%s\n%s\n",argv[1], argv[2]);
    f(*argv[1],strtol(argv[2],NULL,10));
}

Lua, 402 344 312 Bytes

312

r,p,b,x=string.rep,print,' ','x'function d(s,n)h,l=(n+1)/2,s..b;e=r(l,n)if s=='-'then p(e)elseif s=='='then p(e)p(e)else for f=1,n do p(s=='/'and(r(b,n-f)..s)or s=='+'and(f~=h and r(' ',n-1)..'+'or r('+ ',n))or f<h and r(b,f-1)..x..r(b,n-2*f)..x or f>h and r(b,n-f)..x..r(b,2*f-2-n)..x or r(b,f-1)..x)end end end

344

r,p,b,x=string.rep,print,' ','x'function d(s,n)h,l=(n+1)/2,s..b;e=r(l,n)if s=='-'then p(e)elseif s=='='then p(e)p(e)else for f=1,n do if s=='/'then p(r(b,n-f)..s)elseif s=='+'then p(f~=h and r(' ',n-1)..'+'or r('+ ',n))elseif s=='x'then p(f<h and r(b,f-1)..x..r(b,n-2*f)..x or f>h and r(b,n-f)..x..r(b,2*f-2-n)..x or r(b,f-1)..x)end end end end

402

r,p,b,x=string.rep,print,' ','x'function d(s,n)h=(n+1)/2;if s=='-'then p(r(s..b,n))end;if s=='='then p(r(s..b,n))p(r(s..b,n))end;if s=='/'then for i=1,n do p(r(b,n-i)..s)end end;if s=='+'then for i=1,n do p(i~=h and r(' ',n-1)..'+'or r('+ ',n))end end;if s=='x'then for i=1,n do if i<h then p(r(b,i-1)..x..r(b,n-2*i)..x)elseif i>h then p(r(b,n-i)..x..r(b,-n+2*i-2)..x)else p(r(b,i-1)..x)end end end end

90 Zeichen reduziert, und es ist jetzt schmerzhaft, sie zu betrachten, selbst wenn sie erweitert sind. : |