[Question]
  [
**Objective**: Write a program that generates beautiful (?) ASCII-art landscapes and skylines!
Your program has just one input: a string composed of any combination/repetition of the chars `0123456789abc`.
For each input character, output a vertical line composed as follows:
```
         .
        ..
       ...
      oooo
     ooooo
    OOOOOO
   OOOOOOO
  XXXXXXXX
 XXXXXXXXX
XXXXXXXXXX
0123456789
```
Letters `abc` instead are followed by one number n, and draw the vertical line n with respectively 1,2 or 3 holes (spaces) at the bottom.
**Examples**
**The Chrysler Building**
Input: `2479742`
```
   .
   .
  ...
  ooo
  ooo
 OOOOO
 OOOOO
XXXXXXX
XXXXXXX
XXXXXXX
```
**The Taj Mahal**
Input: `0804023324554233204080`
```
 .                  .
 .                  .
 o                  o
 o        oo        o
 O O     OOOO     O O
 O O  OO OOOO OO  O O
 X X XXXXXXXXXXXX X X
 X X XXXXXXXXXXXX X X
XXXXXXXXXXXXXXXXXXXXXX
```
**The Eiffel Tower**
Input: `011a2b3b5c9c9b5b3a2110`
```
      ..
      ..
      ..
      oo
     oooo
     OOOO
    OOOOOO
   XXX  XXX
 XXX      XXX
XXX        XXX
```
You can assume input is not empty and that it's well-formed.  
Any language is accepted, from [A+](http://en.wikipedia.org/wiki/A+_%28programming_language%29) to [Z++](http://en.wikipedia.org/wiki/Z++).
This is code-golf: **the shortest source code wins**.  
If anything in the rules is not clear, feel free to ask below in the comments.
Have fun, and capture hundred meters high structures in a few bytes!
(and don't forget to include your favourite building in your solution)
P.S.: no, you can't download/access data from the Internet, use your file name as data and all that stuff. Be fair, and use only your code-golf skills.
  
[Answer]
## GolfScript, 69
```
'XXXOOoo...':s\{.96>{96-.' '*\@>+}{47-<' '10*+10<s\}if}%10/zip-1%n*\;
```
Not far off the APL solution.
[Test online](http://golfscript.apphb.com/?c=OyIwMTFhMmIzYjVjOWM5YjViM2EyMTEwIgonWFhYT09vby4uLic6c1x7Ljk2Pns5Ni0uJyAnKlxAPit9ezQ3LTwnICcxMCorMTA8c1x9aWZ9JTEwL3ppcC0xJW4qXDs%3D)
[Answer]
## Ruby, ~~88~~ 85
Fun challenge!
```
9.downto(0){|h|puts$*[0].gsub(/(\D?)(.)/){'XXXOOoo... '[h<$1.hex-9||$2.hex<h ?-1:h]}}
```
Takes input on the commandline, eg:
```
ruby landscapes.rb 011a2b3b5c9c9b5b3a2110
```
Will print out:
```
      ..      
      ..      
      ..      
      oo      
     oooo     
     OOOO     
    OOOOOO    
   XXX  XXX   
 XXX      XXX 
XXX        XXX
```
[Answer]
## Python 2.7 - 186
Probably can be shorter...
```
x=[]
l=iter(raw_input())
a="XXX00oo..."
for i in l:
 try:i=int(i);o=0
 except:o=" abc".index(i);i=int(next(l))
 x.append(" "*o+a[o:i+1]+" "*(9-i))
for i in zip(*x)[::-1]:print''.join(i)
```
Sample run:
```
08040233245542332040800000247974200000011a2b3b5c9c9b5b3a2110
                             .              ..
 .                  .        .              ..
 .                  .       ...             ..
 o                  o       ooo             oo
 o        oo        o       ooo            oooo
 0 0     0000     0 0      00000           0000
 0 0  00 0000 00  0 0      00000          000000
 X X XXXXXXXXXXXX X X     XXXXXXX        XXX  XXX
 X X XXXXXXXXXXXX X X     XXXXXXX      XXX      XXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX        XXX
```
## Sydney Harbour Bridge
```
a1a13443a1a2a3a4a5a6a6a7a7a8a8a8a8a9a9a9a9a9a9a8a8a8a8a7a7a6a6a5a4a4a3a2a13443a1a1
                   ......
               ..............
             ..................
           oooooooooooooooooooooo
          oooooooooooooooooooooooo
   00    000000000000000000000000000    00
  0000  00000000000000000000000000000  0000
  XXXX XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX XXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  XXXX                                 XXXX
```
## Golden gate bridge / Cisco logo
```
a2a0a0a4a0a06a0a0a4a0a0a2a0a0a4a0a06a0a0a4a0a0a2
      o           o
      o           o
   0  0  0     0  0  0
   0  0  0     0  0  0
X  X  X  X  X  X  X  X  X
X  X  X  X  X  X  X  X  X
      X           X
```
Great question by the way!
[Answer]
# C64 BASIC, 276 PETSCII chars
My own solution, golfed down to 276 chars and 10 lines of BASIC V2.0!
```
0inputa$:dIc$(10):fOi=0to9:rE c$(i):nE:fOr=0to9
1z=1
2c=aS(mI(a$,z,z+1))
3ifc>57tHgO8
4ifc>=57-r tH?c$(9-r);:gO6
5?" ";
6z=z+1:ifz<=len(a$)gO2
7?:nE:eN
8z=z+1:w=aS(mI(a$,z,z+1)):ifw>=57-r aNc<=73-r tH?c$(9-r);:gO6
9?" ";:gO6:dA"x","x","x","o","o","W","W",".",".","."
```
(copy and paste in an emulator to see the result).
And finally, my favourite monument, the Brooklyn Bridge :)
![enter image description here](https://i.stack.imgur.com/NzHew.png)
[Answer]
## C, ~~130~~ 126 chars
Kinda long compared to the competition, but I blame the language...
```
char*p,b[99];r=10,q;main(o){for(gets(&b);r--;puts(""))
for(p=b;q=*p++;)o=q<60?putchar("XXXOOoo... "[o<r&r<q-47?r:10]),-1:q-97;}
```
I don't know about *favourite* building, but one of the more recognizable ones around here is [Globen](http://en.wikipedia.org/wiki/Globen), so here is a poor rendition of it.
```
% ./a.out <<<24556667777776665542
       ......       
    oooooooooooo    
  oooooooooooooooo  
 OOOOOOOOOOOOOOOOOO 
 OOOOOOOOOOOOOOOOOO 
XXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXX
```
[Answer]
# [APL](https://dyalog.com), 59 bytes [SBCS](https://github.com/abrudz/SBCS)
```
{⊖⍉↑(-N)↑¨(L/⍨1,2≤/L←A⍸⍵)↓¨(N←⎕D⍳⍵~A←'abc')↑¨⊂'XXXOOoo...'}
```
[Try it on online!](https://razetime.github.io/APLgolf/?h=AwA&c=q37UNe1Rb@ejtokaun6aQOrQCg0f/Ue9Kwx1jB51LtH3edQ2wfFR745HvVuBspOBsn5AkUd9U10e9W4GCtY5ArnqiUnJ6hDNj7qa1CMiIvz98/P19PTUawE&f=e9Q39VHbBIU0BXUDQ8NEoyTjJNNky2TLJNMk40QjQ0MDdQWFR71zFVwz09JScxRC8stTi7gegfWAtFgYmBgYGRsbmZiamoBoINcCpiUkMUvBNzEjMQehHqTOzMzMHAyADJAuoGqIevec/KTUPAA&i=AwA&r=tryAPL&l=apl-dyalog&m=dfn&n=f)
Shorter than the other APL answers so far! I think it can probably be further golfed. Will add explanation soon!
Thanks to [dzaima](https://codegolf.stackexchange.com/users/59183/dzaima) & [hyper-neutrino](https://codegolf.stackexchange.com/users/68942/hyper-neutrino) for their advice in the [The APL Orchard](https://chat.stackexchange.com/rooms/52405/the-apl-orchard)!
[Answer]
## APL (~~69~~ 66)
```
' XXXOOoo...'[1+⌽⍉⌽↑{z×(z<' abc'⍳⍵)<(1+⍎⍺)≥z←⍳10}/↑2↑¨I⊂⍨⎕D∊⍨I←⌽⍞]
```
Examples:
```
      ' XXXOOoo...'[1+⌽⍉⌽↑{z×(z<' abc'⍳⍵)<(1+⍎⍺)≥z←⍳10}/↑2↑¨I⊂⍨⎕D∊⍨I←⌽⍞]
0804023324554233204080
 .                  . 
 .                  . 
 o                  o 
 o        oo        o 
 O O     OOOO     O O 
 O O  OO OOOO OO  O O 
 X X XXXXXXXXXXXX X X 
 X X XXXXXXXXXXXX X X 
XXXXXXXXXXXXXXXXXXXXXX
      ' XXXOOoo...'[1+⌽⍉⌽↑{z×(z<' abc'⍳⍵)<(1+⍎⍺)≥z←⍳10}/↑2↑¨I⊂⍨⎕D∊⍨I←⌽⍞]
011a2b3b5c9c9b5b3a2110
      ..      
      ..      
      ..      
      oo      
     oooo     
     OOOO     
    OOOOOO    
   XXX  XXX   
 XXX      XXX 
XXX        XXX
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 127 bytes
```
$r=,''*10
$args|% t*y|%{if($_-in97..99){$b=$_-96}else{,' '*$b+'XXXOOoo...'[$b.."$_"]+,' '*(9-"$_")|%{$r[--$i]+=$_}
$b=$i=0}}
$r
```
[Try it online!](https://tio.run/##jZBrb4IwFIa/91ecYF29QAOIUz6Q7B/wlcQsBrBOErQOMJtBfrtry2VG3OU0wNvn7YX3HPkHy/IdS9Mr3nrlFWeeTsjEMhEOs7f8MoRicr4My2Q7wmsjObgLSl13XOLIE3P3uWJpzkqdAJngaEqCIPB9zimlZIUjSjW81l6nyh65hpyNxWE4WxkGTl6n4owKyaMSz6yEyq4VQi8jRGxn4S4cm@iIAAAVT0@KO1rJOe9LX9a9DOr6QaKxrm43l6Zj2rOZ7cznjvyK6dJs/uBBKYf2Of3L4X2H3zmc3zm@GLJUJiXAv3EEVI40OyeQ46YU@N0JHtZ3iywrtKNZNI/d2I3m0Sy0LeumRZTetObfpA3bEc4b1JEudkt8v0UNkSnqVxNRycZoorU9rSPBBYZQIglwrgNmn0cWF2wDHuB1jTOWn9JCgCe8FYsU1BqqGexd6zZpyht0WwZwOsR8v2eHAopdkkOaHBgUHDZJfkzDM9TrclSh6xc "PowerShell – Try It Online")
[Answer]
# [Canvas](https://github.com/dzaima/Canvas), ~~35~~ 33 [bytes](https://github.com/dzaima/Canvas/blob/master/files/chartable.md)
```
±｛⌐╷≡？┤╵“`Fc|C！‟ｍ］ｃ96－ ×１１╋╋｝｝）⤢⇵
```
[Try it here!](https://dzaima.github.io/Canvas/?u=JUIxJXVGRjVCJXUyMzEwJXUyNTc3JXUyMjYxJXVGRjFGJXUyNTI0JXUyNTc1JXUyMDFDJTYwRmMlN0NDJXVGRjAxJXUyMDFGJXVGRjREJXVGRjNEJXVGRjQzOTYldUZGMEQlMjAlRDcldUZGMTEldUZGMTEldTI1NEIldTI1NEIldUZGNUQldUZGNUQldUZGMDkldTI5MjIldTIxRjU_,i=JTIyMDExYTJiM2I1YzljOWI1YjNhMjExMCUyMg__,v=8)
[Answer]
# [PHP](https://php.net/), ~~131~~ 114 bytes
```
for($b=10;$b--;print"
")foreach(str_split($argn)as$a)$c=strpos(' abc',$a)?:!print$a<$b|$b<$c?' ':'XXXOOoo...'[$b];
```
[Try it online!](https://tio.run/##dU9BasMwEDxXr9gGgWyIE1mWYztOyKmlh0ByNISQaIVbG9JYWO6p7dtd2UnpqSxoZ2d2Fo2pTL/amMoQQrvSdhbWcCAAjIcikvEiSTM2HWYhkyyRgk0fRjXlkosoEjKO5dDdmPLbJg9DJTDCWGc6wxgjJcLwrimhuCs5vIs/@C99c@FwTrpTC3T/STFxIHZEhIKRY07IfA62fv@4qK6EswsDwfX5DK9NC2Mm4lCpdOXBPaOyQFX7dgUfPknvVI/iOuQ5xSDITVtfuwmZ@L8u27Unay51540mX1mqfKrXjjeN9Rgo1GzquM3ycTRTtaL4RXFF9YYBW7KiKHa7ppnNZuxA8Zj3UOqqgf3L/vS02@bku/8B "PHP – Try It Online")
```
$ echo 2479742|php -nF land.php 
   . 
   . 
  ... 
  ooo 
  ooo 
 OOOOO 
 OOOOO 
XXXXXXX 
XXXXXXX 
XXXXXXX 
$ echo 011a2b3b5c9c9b5b3a2110|php -nF land.php 
      .. 
      .. 
      .. 
      oo 
     oooo 
     OOOO 
    OOOOOO 
   XXX  XXX 
 XXX      XXX 
XXX        XXX 
$ echo a2a0a0a4a0a06a0a0a4a0a0a2a0a0a4a0a06a0a0a4a0a0a2|php -nF land.php 
      o           o 
      o           o 
   O  O  O     O  O  O 
   O  O  O     O  O  O 
X  X  X  X  X  X  X  X  X 
X  X  X  X  X  X  X  X  X 
      X           X
```
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 33 bytes
```
~kµṪV‘R×ØaiⱮ0xƲ)Ṗz0Ṛị“XXXOOoo... 
```
[Try it online!](https://tio.run/##y0rNyan8/78u@9DWhztXhT1qmBF0ePrhGYmZjzauM6g4tknz4c5pVQYPd856uLv7UcOciIgIf//8fD09PYX/jxrmAiUPLeE63B6pmfWocd@hbYe2/f@vZGRibmluYqSko6BkYGFgYmBkbGxkYmpqAqKBXAsDsIyhYaJRknGSabJlsmWSaZJxopGhIVgGpNbMzMwcDIAMkE6QuKWFuZmpibGRoYGhkbGJqZm5haUSAA "Jelly – Try It Online")
Full program returning a list of lines. If that isn't acceptable, [+2 bytes](https://tio.run/##HUu9CoJAAH4VuU0Iuf@fpxAawkZPGjLBtRrCpob2kqgXaAgKEiRoUOg97l7k8vyW7z9fFMXGud2qe5v2PrNVPe3PfZ0u7fMB179XaNrTFpr2Yj5HW12TJInjsoyiKLDVbe76Q5jb/bdrusY5gKlQgmIwCQCUkEJMCKaMUc@DlXBsEEqxJpplKlOaaZJihMbGbznnYsQg/NPnSgrOKMEIIkwo40Iq8Ac).
Note the trailing space. Included my favourite:
```
.                 .
..               ..
...             ...
oooo           oooo
ooooo         ooooo
OOOOOO       OOOOOO
OOOOOOO     OOOOOOO
XXXXXXXX   XXXXXXXX
XXXXXXXXX XXXXXXXXX
XXXXXXXXXXXXXXXXXXX
```
## How it works
```
~kµṪV‘R×ØaiⱮ0xƲ)Ṗz0Ṛị“XXXOOoo...  - Main link. Takes a string on the left
~                                 - Bitwise NOT. This maps digits d to ~d and non-digits to 0
 k                                - Partition the string after falsey values
                                     This groups the string as we want, with a trailing []
  µ            )                  - Over each element, either [L, x] or [x]:
   Ṫ                              -   Extract x, modifying the element
    V                             -   Evaluate as a digit
     ‘                            -   Increment
      R                           -   Create a range
              Ʋ                   -   Last 4 links as a monad f([L]) or f([]):
        ØaiⱮ                      -     Index in the alphabet
            0x                    -     Get that many zeros
                                       If the element was [x], this yields []
                                       If the element was [L, x], this returns 1, 2 or 3 zeros, depending on L
       ×                          -   Multiple elementwise, zeroing the first 1,2 or 3 elements in the range if L is in the element
                Ṗ                 - Remove the trailing [] element
                 z0               - Transpose, padding with zeros
                   Ṛ              - Reverse
                    ị“XXXOOoo...  - Index into "XXXOOoo... "
```
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 93 bytes
```
{for 9...0 ->\n {say .subst(/(\D)?(.)/,{'XXXOOoo... '.comb[$1>=n>=ord($0//0)-96??n!!10]}):g}}
```
A block that takes in the string and prints to stdout.
[Try it online!](https://tio.run/##dY5BC4JAEIXP9SumkFLIdXZdzc3US3evQkXsWnZJN7QOIf52UzpEh3gw73vDMLz7pb75ffmCRRH1baFrEIQQBDs@VNA28gWkearmYTrmYWclJrGcVbvMsixNtR4uYUlyXaq9QeOoiiNdn00DHQctW/hJUs1mFI@dtbl2XR9Ox/dbxtdizRlggByZ6zLueXz0IQYISKlkylVeLnKhPOVKRimCZBIH8XH6X/y7jqGdTsb6xin8wHw@QPGbu/4N "Perl 6 – Try It Online")
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), 34 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
Rvy.ïi"XXXOOoo..."y>£ëðAykÝǝ])ζRí»
```
Uses the legacy version of 05AB1E to save 2 bytes, since `ζ` also works on strings instead of just lists of characters.
[Try it online.](https://tio.run/##MzBNTDJM/f8/qKxS7/D6TKWIiAh///x8PT09pUq7Q4sPrz68wbEy@/Dc43NjNc9tCzq89tDu//@NTMwtzU2MEg1A0MDCwMTAyNjYyMTU1AREA7kWBlA5Q8NEoyTjJNNky2TLJNMk40QjQ0MDAA)
**Explanation:**
```
R                  # Reverse the (implicit) input-string
 v                 # Loop `y` over each character:
  y.ïi             #  If `y` is a digit:
      "XXXOOoo..." #   Push string "XXXOOoo..."
        y>£        #   And only leave the first `y`+1 characters as substring
     ë             #  Else (`y` is a letter):
       Ayk         #   Get the index of `y` in the lowercase alphabet
          Ý        #   Create a list in the range [0, alphabet-index]
      ð    ǝ       #   Replace in the string at the top of the stack the characters at
                   #   those indices with a space
 ]                 # Close the if-else statement and loop
  )                # Wrap all strings on the stack into a list
   ζ               # Zip/transpose; swapping rows/columns
    Rí             # Reverse this list, as well as each individual line
      »            # And join the strings by newlines
                   # (after which the result is output implicitly)
```
As for my favorite 'building', let's go with this tree. ;)
```
b2b3b4b5b6b7898b7b6b5b4b3b2
       .       
      ...      
     .....     
    ooooooo    
   ooooooooo   
  OOOOOOOOOOO  
 OOOOOOOOOOOOO 
XXXXXXXXXXXXXXX
      XXX      
      XXX      
 
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt) [`-R`](https://codegolf.meta.stackexchange.com/a/14339/), 36 bytes
```
óÈ¦nÃ£ÒXÌ î"XXXOOoo..."hSpXÎnD)s9Ãz3
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&flags=LVI&code=88imbsOj0ljMIO4iWFhYT09vby4uLiJoU3BYzm5EKXM5w3oz&input=IjI0Nzk3NDJhMGEwYTAwODA0MDIzMzI0NTU0MjMzMjA0MDgwYTBhMGEwMDExYTJiM2I1YzljOWI1YjNhMjExMCI)
```
óÈ¦nÃ£ÒXÌ î"..."hSpXÎnD)s9Ãz3     :Implicit input of string
ó                                 :Partition at
 È                                :Characters that return true when passed through the following function
  ¦                               :  Test for inequality with
   n                              :  Convert to number
    Ã                             :End function
     £                            :Map each X
      Ò                           :  Bitwise increment
       XÌ                         :  Last character of X
          î                       :  Slice the following to that length
           "..."                  :    Literal string
                h                 :    Replace as many characters as necessary at the start of that string with
                 S                :      Space
                  p               :      Repeat
                   XÎ             :        First character of X
                     n            :        Convert from base
                      D           :        14
                       )          :      End repeat
                        s9        :      Slice off the first 9 characters
                          Ã       :End map
                           z3     :Rotate clockwise by 90 degrees 3 times
                                  :Implicit output, joined by newlines
```
[Answer]
# [Pip](https://github.com/dloscutoff/pip) `-l`, 45 bytes
```
Z:R{sXtRAb:Ab%4\,c"XXXOOoo..."@b}MRaC KXL.CXD
```
Takes input as a command-line argument. [Try it here!](https://replit.com/@dloscutoff/pip) Or, here's a 46-byte equivalent in Pip Classic: [Try it online!](https://tio.run/##K8gs@P8/yioorLo4oiTIMcnKMUnVJEYnWSkiIsLfPz9fT09PySGp1jco0VnBO8JHzznC5f///7o5/w0MDRONkoyTTJMtky2TTJOME40MDQ0A "Pip – Try It Online")
### Explanation
High-level:
```
  R{sXtRAb:Ab%4\,c"XXXOOoo..."@b}              Apply this function
                                 MR            to each match
                                    C KXL.CXD  of this regex
                                   a           in the input string
Z:                                             Transpose the result
                                               Autoprint as lines (-l flag)
```
The regex:
```
   XL       Lowercase letter            [a-z]
  K         Apply Kleene star           [a-z]*
C           Wrap in a capturing group   ([a-z]*)
       XD   Digit                       \d
      C     Wrap in a capturing group   (\d)
     .      Concatenate                 ([a-z]*)(\d)
```
The replacement function takes three arguments: `a` is the full match, `b` is the first capturing group (a letter or empty string), `c` is the second capturing group (a digit).
```
R{sXtRAb:Ab%4\,c"XXXOOoo..."@b}
  s                              Space character
   Xt                            repeated 10 times
         Ab                      ASCII code of the letter (nil if empty string)
           %4                    Mod 4 ("a"->1, "b"->2, "c"->3, ""->nil)
             \,c                 Inclusive range from that number to the digit
                                 (treats a left argument of nil as 0)
       b:                        Assign that value to b
     RA                          and replace those indices in the space string
                "XXXOOoo..."@b   with the equivalent indices in this string
R                                Reverse to put the "top" of the building at the left
```
[Answer]
# [APL (Dyalog Extended)](https://github.com/abrudz/dyalog-apl-extended), 67 bytes
```
{⊖⍉↑(((' '⍴⍨2⊃⊢),'XXXOOoo...'↑⍨1+⊃)∘⌽0,48|⎕UCS)¨'[abc]?\d'⎕S'\0'⊢⍵}
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/P@1R24TqR13THvV2PmqbqKGhoa6g/qh3y6PeFUaPupofdS3S1FGPiIjw98/P19PTUweqAUoZagPlNB91zHjUs9dAx8Si5lHf1FDnYM1DK9SjE5OSY@1jUtSBQsHqMQbqQCMe9W6tBdqkoG5kYm5pbmKkzgVkG1gYmBgYGRsbmZiamoBoINfCACJlaJholGScZJpsmWyZZJpknGhkaGigDgA "APL (Dyalog Extended) – Try It Online")
Longer than the other answer, but I'll try golfing it later. Proper explanation coming soon.
* `'[abc]?\d'⎕S'\0'⊢⍵` - Extract single digits or characters followed by digits
* `(((' '⍴⍨2⊃⊢),'XXXOOoo...'↑⍨1+⊃)∘⌽0,48|⎕UCS)¨` - Train to turn each digit or pair into a horizontal string
* `⊖⍉↑` - Turn it into a matrix, transpose to make it vertical, and flip it upside-down.
]