Erstellen Sie ASCII-Leitern

28

Bei einer Eingabe von zwei Ganzzahlen n und m wird eine ASCII-Leiter mit der Länge n und der Größe m ausgegeben .

Dies ist eine ASCII-Leiter der Länge 3 und der Größe 3:

o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Dies ist eine ASCII-Leiter mit Länge 5 und Größe 1:

o-o
| |
+-+
| |
+-+
| |
+-+
| |
+-+
| |
o-o

Dies ist eine ASCII-Leiter mit Länge 2 und Größe 5:

o-----o
|     |
|     |
|     |
|     |
|     |
+-----+
|     |
|     |
|     |
|     |
|     |
o-----o

Um genau zu sein:

  • Die Länge ( n ) gibt an, aus wie vielen Quadraten die Leiter besteht.

  • Die Größe ( m ) gibt die Breite und Höhe des Innenraums jedes Quadrats an, dh ohne die "Ränder".

  • Jedes Quadrat besteht aus dem Innenbereich, der mit Leerzeichen gefüllt ist, -die oben und unten von |s, links und rechts von +s und an allen vier Ecken von s umgeben sind .

  • Die Ränder zwischen den Quadraten verschmelzen, sodass zwei Zeilen in einer Reihe +--...--+zu einer verschmelzen.

  • Die Ecken der gesamten Leiter werden durch den Charakter ersetzt o.

  • Optional können Sie eine abschließende Newline ausgeben.

Die Länge der Leiter ( n ) ist immer ≥ 2 und die Größe ( m ) ist immer ≥ 1.

Die Eingabe kann als durch Leerzeichen / Kommas getrennte Zeichenfolge, als Array / Liste / etc. Oder als zwei Funktionen / Befehlszeile / etc. Erfolgen. Argumente. Die Argumente können in der Reihenfolge angegeben werden, die für Sie am bequemsten bzw. am besten ist.

Da es sich um Code-Golf , der kürzeste Code in Bytes gewinnt.

Tipp: Die obigen Beispiele können auch als Testfälle verwendet werden.

code-golf ascii-art Türknauf
quelle
Müssen wir erst die Länge nehmen, dann die Größe?
RK.
@RK. Sie können sie in der Reihenfolge nehmen, die für Sie am bequemsten ist.
Türklinke
1
Kann es eine führende Newline geben?
Conor O'Brien
1
@ CᴏɴᴏʀO'Bʀɪᴇɴ Ähh ... Ich gehe mit Nein.
Türklinke
1
Okay: P Es war einen Versuch wert.
Conor O'Brien

Antworten:

4

Pyth, 34 Bytes

.NjjNm*QTvz*2YjC:M++J"+|o"m"- -"QJ

Testsuite

Nimmt Argumente in Zeilenumbrüchen getrennt auf STDIN.

Verwendet eine Hilfsfunktion :, die jede vertikale Zeichenfolge aus drei Zeichen zusammensetzt, bei Bedarf repliziert, transponiert und in Zeilenumbrüche einfügt.

isaacg
quelle
11

Ruby, 71

->m,n{h=0;(?o+?+*(n-1)+?o).chars{|c|puts [?|+' '*m+?|]*h,c+?-*m+c;h=m}}

im Testprogramm ungolfed

f=->m,n{
  h=0                             #The number of | above the 1st rung is 0
  (?o+?+*(n-1)+?o).chars{|c|      #Make a string of all the rung ends o++...++o and iterate through it
    puts [?|+' '*m+?|]*h,         #draw h vertical segments |  ...  |
      c+?-*m+c                    #and a rung with the correct ends
    h=m                           #The number of | above all rungs except the 1st is m
  }
}


f[gets.to_i,gets.to_i]
Level River St
quelle
Es scheint kleinere Probleme mit der Golf-Version zu geben: brauchen ;nach h=0, brauchen Platz nach puts. Die Punktzahl wächst jedoch nur mit 1 Zeichen, da zuvor ein zusätzliches Leerzeichen vorhanden ist puts.
Manatwork
@manatwork oops, danke, behoben. Ich weiß nicht, wie das passiert ist, ich muss Golf gespielt haben und es danach nicht mehr laufen lassen.
Level River St
9

CJam, 43 42 Bytes

Ich bin nicht von der Partitur erschüttert. Aber ich bin nicht Dennis, oder?

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$

Die Eingabe erfolgt durch 2 durch Leerzeichen getrennte Elemente. Länge zuerst

2 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Erläuterung

q~:Z;'-'o{[\Z*1$N]}:X~['-_'+X\'|XZ*]@*1>1$
q~                                         e# read input
  :Z;                                      e# Record the size in Z and discard
     '-'o{[\Z*1$N]}:X~                     e# Create the initial line (and final). also creates a shorcut to do this later
           \                               e# Capture two arguments
            Z*                             e# The separator is repeated size times
              1$                           e# Repeat the first argument
                N                          e# Add newline
                                           e# X is a function to create line in a ladder
                      ['-_'+X\'|XZ*]       e# Design the repeating part
                                    @*     e# Repeat the pattern n times
                                      1>   e# Discard the initial
                                        1$ e# Since the final line is same than the initial, we just write it.
                                           e# Implicit printing
Akangka
quelle
1
Es gefällt mir, dass Sie es als Frage formuliert haben. "Ich bin nicht Dennis ... richtig?"
bahnmonorail
7

JavaScript (ES6), 89

... wiederholen, wiederholen, wiederholen ...

(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

Prüfung 

F=(n,m,R=x=>x.repeat(m),b=R(`|${R(' ')}|
`),d=`o${c=R('-')}o
`)=>d+R(b+`+${c}+
`,m=n-1)+b+d

// Less golfed
U=(n,m)=>
{
  var R=x=>x.repeat(m),
      a=R(' '),
      b=R(`|${a}|\n`);
      c=R('-'),
      d=`o${c}o\n`;
  m=n-1;
  return d+R(b+`+${c}+\n`)+b+d
}

function test() {
  var i=I.value.match(/\d+/g)
  if (i) O.textContent=F(+i[0],+i[1])
  console.log(i,I.value)
}  
 
test()
N,M: <input id=I value="3,5" oninput=test()>
<pre id=O></pre>
Erweitern Sie das Snippet

edc65
quelle
Ich wusste nicht, dass document.getElementById('elem').das durch ersetzt werden könnte elem.! +1 für diese, aber bitte, könnten Sie einige Dokumente darüber hinweisen?
F. Hauri
2
@ F.hauri es funktioniert in fast jedem browser, sollte aber vermieden werden (außer beim codieren zum spaß). Informationen
edc65
6

C #, 1412 Bytes

... Mein erster CodeGolf-Versuch, Gewinnt wahrscheinlich nicht, aber es funktioniert.

using System;

namespace Ascii_Ladders
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = 0;
            int m = 0;

            Console.Write("Please enter Height: ");
            n = int.Parse(Console.ReadLine());
            Console.Write("Please Enter Width: ");
            m = int.Parse(Console.ReadLine());

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                Console.Write("-");
            }
            Console.WriteLine("o");

            for (int k = 0; k < n; k++)
            {
                for (int i = 0; i < m; i++)
                {
                    Console.Write("|");
                    for (int j = 0; j < m; j++)
                    {
                        Console.Write(" ");
                    }
                    Console.WriteLine("|");
                }
                if (k != n - 1)
                {
                    Console.Write("+");
                    for (int i = 0; i < m; i++)
                    {
                        Console.Write("-");
                    }
                    Console.WriteLine("+");
                }
            }

            Console.Write("o");
            for (int i = 0; i < m; i++)
            {
                 Console.Write("-");
            }
            Console.WriteLine("o");

            Console.ReadKey();
        }
    }
}
Reed Jones
quelle
9
Willkommen bei Programming Puzzles & Code Golf! Ihr Code enthält viele Leerzeichen, die Sie entfernen können, um Ihren Code zu verkürzen. Wenn Sie mehr Hilfe beim Golfen Ihres Codes benötigen, lesen Sie die Tipps zum Golfen in C # .
Ziegenbock
Ich stimme @ Do with hier zu. Ich war in der Lage, es auf nur 533 Bytes zu golfen . Aber es könnte besser sein. (Warnung: Ich programmiere nicht in C #.)
user48538
Ich habe es mitusing System;class P{static int m;static void Main(){int n = int.Parse(Console.ReadLine());m = int.Parse(Console.ReadLine());M('o','-');for(int k=0;k<n;k++){for(int i=0;i<m;i++){M('|',' ');}if(k!=n-1){M('+','-');}}M('o','-');Console.ReadKey();}static void M(char x,char y){Console.WriteLine(x+new string(y,m)+x);}}
RedLaser
3
Verpasste ein paar Plätze also 310 mit using System;class P{static int m;static void Main(){int n=int.Parse(Console.ReadLine());m=int.Parse(Console.ReadLine());M('o','-');for(int k=0;k<n;k++){for(int i=0;i<m;i++){M('|',' ');}if(k!=n-1){M('+','-');}}M('o','-');Console.ReadKey();}static void M(char x,char y){Console.WriteLine(x+new string(y,m)+x);}}
RedLaser
2
Down to 270 ohne Änderungen im Ansatz verwendet: using C=System.Console;class P{static void Main(){int i,k,n=int.Parse(C.ReadLine()),m=int.Parse(C.ReadLine());System.Action<char,char> M=(x,y)=>C.WriteLine(x+new string(y,m)+x);M('o','-');for(k=0;k<n;k++){for(i=0;i<m;i++){M('|',' ');}if(k<n-1){M('+','-');}}M('o','-');}}. Hier liegt höchstwahrscheinlich mehr Potenzial, wenn man einfach die Vorgehensweise ein wenig ändert.
Joey
6

Julia, 87 Bytes

f(n,m)=(g(x)=(b=x[1:1])x[2:2]^m*b*"\n";(t=g("o-"))join([g("| ")^m for i=1:n],g("+-"))t)

Dies ist eine Funktion, die zwei Ganzzahlen akzeptiert und eine Zeichenfolge zurückgibt.

Ungolfed:

function f(n::Int, m::Int)
    # Create a function g that takes a string of two characters and
    # constructs a line consisting of the first character, m of the
    # second, and the first again, followed by a newline.
    g(x) = (b = x[1:1]) * x[2:2]^m * b * "\n"

    # Assign t to be the top and bottom lines. Construct an array
    # of length n where each element is a string containing the
    # length-m segment of the interior. Join the array with the
    # ladder rung line. Concatenate all of this and return.
    return (t = g("o-")) * join([g("| ")^m for i = 1:n], g("+-")) * t
end
Alex A.
quelle
5

pb - 147 Bytes

^t[B]>>[B]vw[T!0]{b[43]<[X]b[43]>w[B=0]{b[45]>}v[X-1]w[B=0]{b[124]^}v[X]t[T-1]}t[111]b[T]<w[X!0]{b[45]<}b[T]w[Y!0]{w[B!0]{^}b[124]^}b[T]^>>[B]vb[T]

Dies ist die Art von Herausforderung, bei der pb von Rechts wegen wirklich gut sein sollte. Das Zeichnen einfacher Bilder mit Zeichen ist genau das, wofür pb entwickelt wurde. Leider ist es nur eine wortreiche Sprache, denke ich.

Nimmt zuerst die Länge der Eingabe, gefolgt von der Größe. Nimmt Eingaben in Form von Bytewerten vor, zum Beispiel:python -c 'print(chr(5) + chr(7))' | ./pbi.py ladder.pb

Schau, eine lustige Animation!

Mit Kommentaren:

^t[B]            # Save length to T
>>[B]v           # Go to X=size+1, Y=0

w[T!0]{          # While T is not 0:
    b[43]            # Write a '+'
    <[X]b[43]        # Write a '+' on the left side as well
    >w[B=0]{b[45]>}  # Travel back to the right '+', writing '-' on the way
    v[X-1]           # Go down by X-1 (== size)
    w[B=0]{b[124]^}  # Travel back up to the '+', writing '|' on the way
    v[X]             # Go down by X (== size + 1, location of next '+')
    t[T-1]           # Decerement T
}

t[111]           # Save 'o' to T (it's used 4 times so putting it
                 # in a variable saves bytes)

b[T]             # Write an 'o' (bottom right)

<w[X!0]{         # While not on X=0:
    b[45]<           # Travel left, writing '-' on the way
}

b[T]             # Write an 'o' (bottom left)

w[Y!0]{          # While not on Y=0:
    w[B!0]{^}        # Skip nonempty spaces
    b[124]           # Write a '|'
    ^                # Travel up
}

b[T]             # Write an 'o' (top left, replaces existing '+')

^>>[B]v          # Go back to where the size is saved and go to X=size+1, Y=0

b[T]             # Write an 'o' (top right, replaces existing '+')
untergrundbahn
quelle
5

Pure Bash, 132 130 128 127 Bytes

Ja, ich könnte 1 weiteres Byte fallen lassen und das letzte ersetzen ${p% *}, aber ich bevorzuge Folgendes:

p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"

Probe:

ladders() {
    p=printf\ -v;$p a %$1s;$p b %$2s;o="|$a|\n";h=+${a// /-}+\\n v=${a// /$o}
    a=${b// /$h$v}${h//+/o};a=${a/+/o};${p% *} "${a/+/o}"
}

ladders 3 4
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

ladders 2 1
o--o
|  |
|  |
o--o
F. Hauri
quelle
4

Haskell, 100 97 Bytes

l#s=unlines$t:m++[t]where _:m=[1..l]>>["+"!"-"]++("|"!" "<$u);t="o"!"-";o!i=o++(u>>i)++o;u=[1..s]

Anwendungsbeispiel:

*Main> putStr $ 4 # 3
o---o
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
+---+
|   |
|   |
|   |
o---o

Wie es funktioniert:

l#s=unlines$t:m++[t]         -- concat top line, middle part and end line
                             -- with newlines between every line
  where                      -- where
  _:m=                       -- the middle part is all but the first line of
     [1..l]>>                -- l times
         ["+"!"-"]           --    a plus-dashes-plus line
         ++("|"!" "<$u)      --    followed by s times a bar-spaces-bar line

  t="o"!"-"                  -- very first and last line
  o!i=o++(u>>i)++o           -- helper to build a line
  u=[1..s]

Edit: @Christian Irwan hat 3 Bytes gefunden. Vielen Dank!

nimi
quelle
Patternmatching für -1 Punktzahl m=init$[1..l]>>("|"!" "<$u)++["+"!"-"]=>(_:m)=[1..l]>>["+"!"-"]++("|"!" "<$u)
Akangka
Überraschenderweise _:m=[1..l]>>["+"!"-"]++("|"!" "<$u)funktioniert
Akangka
@ChristianIrwan: gut gesehen! Vielen Dank!
nimi
3

Brainfuck - 334 Bytes

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-]<----[>---<----]--[>[+>>]<<[<<]>++++++]>[+.>>]-[<+>---]<+++++++>>--[<+>++++++]->---[<------->+]++++++++++[<++<]+++++[>[++++++>>]<<[<<]>-]>[-]>.-<<----[>>+++<<----]--[>+<--]>---<<<<++++++++++.,[>[>+>+<<-]>[<+>-]>[<<<<[>>>>>>[.>>]<<[<<]>>-]>>>>>[.>>]<<[<<]>-]<<<<+>-]>>>>[-]----[>---<----]>+.[>]<<<<<[.<<]

Ich habe erwartet, dass dies viel kürzer sein wird.

Dadurch wird eine "Zeichenfolge" eingerichtet, die aussieht | (...) |und eine, die aussieht +----(...)----+, wobei jede nach Bedarf mit einem speziellen Gehäuse für die Zeichenfolge gedruckt wirdo oben und unten ein s vorgesehen ist.

Benötigt einen Interpreter, der 8-Bit-Zellen verwendet und es Ihnen ermöglicht, von Zelle 0 nach links zu gehen (sei es in negative Zellen oder in eine Schleife). Nach meiner Erfahrung sind dies die häufigsten Standardeinstellungen.

Mit Kommentaren:

,[<+<<<<+>>>>>-]<[[>>]+[<<]>>-] Get m from input; make a copy
                      Turn it into m cells containing 1 with empty cells between

<----[>---<----]      Put 67 at the beginning (again with an empty cell between)

--[>[+>>]<<[<<]>++++++]  Add 43 to every nonempty cell

>[+.>>]               Add 1 to each cell and print it

-[<+>---]<+++++++    Put 92 after the last 45 (no empty cell!)

>>--[<+>++++++]      Put 43 immediately after the 92

->---[<------->+]    Put 234 after 43

++++++++++           And 10 after that

[<++<]             Add two to the 234; 92; the empty spaces; and left of the 111

+++++[>[++++++>>]<<[<<]>-] Add 30 to each 2; the 94; and the 236

>[-]>.-<<----[>>+++<<----] Erase leftmost 32; Print 111; subtract 68 from it

--[>+<--]>---        Put 124 where the 32 was

<<<<++++++++++.,     Print a newline; override the cell with n from input

[                    n times:

  >[>+>+<<-]>[<+>-]    Make a copy of m

  >[                   m times:

    <<<<                 Look for a flag at a specific cell

    [                    If it's there:

      >>>>>>[.>>]          Go to the 43; print it and every second cell after

      <<[<<]>>-            Clear the flag

    ]

    >>>>>[.>>]           Go to the 124; print it and every second cell after

    <<[<<]>              Go back to the copy of m

  -]

  <<<<+>               Plant the flag

-]

>>>>

[-]----[>---<----]>+ Erase the 124; add 68 to 43

.[>]                 Print it; then head to the end

<<<<<[.<<] Go to the last 45; print it; then print every second cell to the left
untergrundbahn
quelle
3

PowerShell, 77 80

param($l,$s)$a='-'*$s
($c="o$a`o")
(($b=,"|$(' '*$s)|"*$s)+"+$a+")*--$l
$b
$c
Joey
quelle
77 Bytes
Veskah
2

Jolf, 36 Bytes

Probieren Sie es hier aus!

ρpi,a+2J+2J"o-| "j"o(.+)o
o.+o'+$1+

Erläuterung

ρpi,a+2J+2J"o-| "j"o(.+)o\no.+o'+$1+
 pi              j                   repeat vertically j times
   ,a+2J+2J"o-| "                    a box with dimensions 2+J
ρ                 "o(.+)p\np.+o'     replace with regex
                                +$1+ with the -...-
Conor O'Brien
quelle
2

Perl, 98 Bytes

($n,$m)=@ARGV;print$h="o"."-"x$m."o\n",((("|".(" "x$m)."|\n")x$m.$h)x$n)=~s{o(-+)o(?=\n.)}{+$1+}gr
ZILjr
quelle
1
Eine ausgezeichnete erste Antwort. Aber ich sehe keine +Zeichen in Ihrem Code. Haben Sie gedacht, dass die Zwischensprossen +an jedem Ende Zeichen haben?
Level River St
Vielen Dank für den sehr schön formulierten Kommentar - ich habe die Pluszeichen total vertan! Hat mich auch einiges an Platz gekostet; Ich denke immer noch darüber nach, wie ich es verkürzen kann ... abgesehen ($n,$m)=@ARGV;davon, dass das weggelassen wurde und davon ausgegangen wird, dass dies bereits festgelegt ist - ich bin mir nicht sicher, ob das im Geiste liegt oder nicht. Ich muss es nachschlagen.
ZILjr
Sofern in der Frage nicht anders angegeben, lautet die Regel hier meta.codegolf.stackexchange.com/a/2422/15599 . Sie können nicht einfach davon ausgehen, dass die Variablen gesetzt sind, sondern Sie können eine Funktion anstelle eines Programms schreiben, wenn dies hilfreich ist. Ich mache kein Perl, aber ich nehme an, das könnte dir das ersparen @ARGV. Wenn Sie jemandem antworten, denken Sie daran, @Benutzername einzuschließen, damit dieser eine Warnung erhält. Ich muss es nicht tun, da dies dein Beitrag ist.
Level River St
1

C, 122 Bytes

f(int m,int n,char*s){int i=0,w=3+m++;for(;i<w*m*n+w;++i)*s++=i%w>m?10:" |-+-o"[!(i/w%m)*2+!(i%w%m)+!(i/w%(m*n))*2];*s=0;}

Probieren Sie es online aus .

grc
quelle
1

Tcl, 187 Bytes

lassign $argv n w
set c 0
while { $c < [expr {($w * $n) + ($n + 2)}]} {if {[expr {$c % ($n + 1)}] == 0} {puts "o[string repeat "-" $w ]o"} else {puts "|[string repeat " " $w ]|"}
incr c}

Dieser Code wird in eine Datei mit Argumenten eingefügt, die in die Befehlszeile eingegeben werden. Geben Sie die Anzahl der Kisten und die Breite in dieser Reihenfolge an.

Cjolly
quelle
1

PHP, 81 Byte

Erwartet 2 Argumente, die beim direkten Aufruf des PHP-Befehls übergeben werden. Die erste ist die Größe und die zweite ist die Anzahl der Schritte.

$R=str_repeat;echo$P="o{$R('-',$W=$argv[1])}o
",$R("|{$R(' ',$W)}|
$P",$argv[2]);

Möglicherweise sind einige Verbesserungen erforderlich.

Ismael Miguel
quelle
0

Python 2, 94 Bytes

def F(n,m):a,b,c,d='o|+-';r=[a+d*m+a]+([b+' '*m+b]*m+[c+d*m+c])*n;r[-1]=r[0];print'\n'.join(r)

"Ungolfed":

def F(n,m):
 # 'o---o'
 r = ['o'+'-'*m+'o']
 # ('|   |'*m+'+---+') n times
 r += (['|'+' '*m+'|']*m+['+'+'-'*m+'+'])*n
 # replace last +---+ with o---o
 r[-1] = r[0]
 print '\n'.join(r)
TFeld
quelle
0

Perl 5 , 91 + 1 (-a) = 92 Bytes

$_='|'.$"x$F[1].'|';push@a,y/| /+-/r,($_)x$F[1]while$F[0]--;$a[0]=y/| /o-/r;say for@a,$a[0]

Probieren Sie es online!

Xcali
quelle
0

Pip -l , 35 Bytes

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o

Probieren Sie es online!

Erläuterung

(^YsXbRLaJW'-)XbWR^('|XbRLaJ'+)WR'o
                                     a is length, b is size, s is space (implicit)
   sXb                               String containing b spaces
      RLa                            List containing a copies of that string
         JW'-                        Join on "-" and wrap the result in "-" as well
  Y                                  Necessary for operator precedence reasons
 ^                                   Split into a list of characters
(            )Xb                     String-repeat each character in the list b times
                                     This list represents the central columns of the ladder

                    '|Xb             String containing b pipe characters
                        RLa          List containing a copies of that string
                           J'+       Join on "+"
                   (          )WR'o  Wrap in "o"
                  ^                  Split into a list of characters
                                     This list represents the outer columns of the ladder

                WR                   Wrap the left list in the right list, vectorizing

Einige andere Versionen

Ich habe viele verschiedene Ansätze ausprobiert, um Pyth zu fangen ...

[Y'-XbWR'o;@>(sXbWR'|RLbPE'-XbWR'+RL:a)y]  41
Y^(t**b.1*:t**bX--a.1)" --"@yXbWR"|o+"@y   40
Y'|XbRLaJ'+YyWR'o;Z:sXbRLaJW'-RLbPEyAEy    39
t**:b(" |-o-+"<>2)@_@^t.1M$*Y[ttXa-1].1    39
J*Z:sXbRLaJW'-RLbWR:^('|XbRLaJ'+)WR'o      37
Y^$*Y[t**:btXa-1].1" --"@yXbWR"|o+"@y      37

Ich mag besonders t**bdiejenigen, die Mathematik verwenden, um das vertikale Muster der Leiter zu generieren:

        b           Size; e.g. 3
    t               Preset variable for 10
     **:            Set t to t**b (e.g. 1000)
           a        Length; e.g. 3
            -1      2
         tX         String-repeat (the new value of) t 2 times: 10001000
   [          ]     Put t and the above into a list: [1000; 10001000]
               .1   Append 1 to both of them: [10001; 100010001]
$*(              )  Fold on multiplication: 1000200020001

Mit dem 1000200020001können dann die Muster o|||+|||+|||ound erzeugt werden - - - -, aus denen die Leiter besteht. Leider konnte ich diesen Ansatz nicht kürzer als den Join / Wrap-Ansatz machen.

DLosc
quelle