[Question]
  [
Write a program that takes in a string containing only spaces, newlines, and angle brackets: `<`, `>` (*[chevrons](https://en.wikipedia.org/wiki/Bracket#History)*). Output a string of spaces, newlines, and slashes: `/`, `\` (*[soliduses](https://en.wiktionary.org/wiki/solidus#English)*) whose shapes correspond to the input, **but rotated a quarter turn clockwise, with a column of spaces inserted between each row of the original input** (for aesthetics).
For example, if the input is this:
```
<>
```
The output would be this:
```
/\
\/
```
If the input is this:
```
><<<>
 <><
```
The output would be this:
```
   \/
/\ /\
\/ /\
/\ /\
   \/
```
If the input is this:
```
>>  <<
<>  <>
  <
  ><
```
The output would be this:
```
      /\ \/
      \/ \/
\/ /\    
/\      
      /\ /\
      \/ /\
```
Notice how there is a single column of spaces between the original input rows in the last two examples.
You may write a full program that takes the input in any usual way (command line, stdin) and prints the output, or you may write a function with a string argument, that prints or returns the output.
Empty leading and trailing rows or columns of whitespace in the input do not need to be present in the output. Additionally, there may be any amount of leading and/or trailing spaces and/or newlines in the output, in any locations, as long as the resulting shapes are correct. In other words, **the translation of the ascii art does not matter, only the shapes and their relation to one another do**.
You may optionally assume the input has a trailing newline.
**The shortest code in bytes wins.**
  
[Answer]
# CJam, 35 bytes
```
qN/_s,S*f+{iD%[S3*" \/"_$]=}f%W%zN*
```
[Try it online here](http://cjam.aditsu.net/#code=qN%2F_s%2CS*f%2B%7BiD%25%5BS3*%22%20%5C%2F%22_%24%5D%3D%7Df%25W%25zN*&input=%3E%3E%20%20%3C%3C%0A%3C%3E%20%20%3C%3E%0A%20%20%3C%0A%20%20%3E%3C)
[Answer]
# Python 2, 105 bytes
```
def f(s):
 for row in map(None,*s.split("\n")):print" ".join("\/ /\ "[1-cmp(c,"<")::3]for c in row[::-1])
```
For all the wrong reasons, this has got to be one of the nicest uses of `map(None, ...)` I've had so far. The output even pads to perfect rectangle.
Let's take the second example:
```
><<<>
 <><
```
`map(None,*s.split("\n"))` performs a poor man's `zip_longest`, giving:
```
[('>', ' '), ('<', '<'), ('<', '>'), ('<', '<'), ('>', None)]
```
Notice how the second line is shorter than the first, so we get a `None` at the end. Normally this would be a problem, but for *some* reason almost everything is comparable in Python 2, and in particular
```
>>> None < ""
True
```
This means that the expression `1-cmp(c,"<")` returns `0, 1, 2` for `">", "<", None` respectively, allowing us to use the string slicing trick to extract one of `"\/", "/\", " "`. Using this, we print the output line by line, joining the 2-char groups with spaces.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 19 bytes
```
Ỵz⁶UµOHØ^ṙaf⁶;`$)€G
```
[Try it online!](https://tio.run/##y0rNyan8///h7i1Vjxq3hR7a6u9xeEbcw50zE9OAfOsEFc1HTWvc/x@d/HDn4sPtQHbW//82dly6XHY2NkBawcbOBsSxU1CwseGyAVFAQQUbILaz@Q@UAQA "Jelly – Try It Online")
While I was writing this, it tormented me to no end that the whole mess with `af⁶;`$` could just be `«`, if the codepoint of backslash were somewhere closer to the ballpark of its forward companion. This can *definitely* be golfed further.
```
Ỵ                       Split the input on newlines.
 z⁶                     Transpose with space as filler.
   U                    Reverse each row.
    µ            )€     For each character in each row:
       Ø^ṙ              rotate "/\" by
      H                 half of
     O                  the character's codepoint;
          a             vectorizing logical and with
             ;          concatenate
           f⁶  $        the character filtered to spaces
              `         to itself.
          a             (The slashes are unaffected if the filter removes everything.)
                   G    Grid format: this builtin can do a lot of things,
                        but in this case it joins each row on spaces 
                        then joins the rows on newlines.
```
[Answer]
# CJam, 37 bytes
```
qN/_z,S*f{+"< >""/\    \/ "3/er}W%zN*
```
Try it online in the [CJam interpreter](http://cjam.aditsu.net/#code=qN%2F_z%2CS*f%7B%2B%22%3C%20%3E%22%22%2F%5C%20%20%20%20%5C%2F%20%223%2Fer%7DW%25zN*&input=%3E%3E%20%20%3C%3C%0A%3C%3E%20%20%3C%3E%0A%20%20%3C%0A%20%20%3E%3C).
### How it works
```
qN/                                   e# Read from STDIN and split at linefeeds.
   _z,                                e# Zip a copy and push the results length.
                                      e# This computes the maximum line length.
      S*                              e# Repeat " " that many times.
        f{                     }      e# For each line:
                                      e#   Push the string of spaces.
          +                           e#   Append it to the line.
           "< >""/\    \/ "3/         e#   Push "< >" and ["/\ " "   " "\/ "].
                             er       e#   Perform transliteration.
                                W%z   e# Reverse the lines and zip.
                                      e# This rotates by 90 degrees.
                                   N* e# Join, separating by linefeeds.  
```
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 21 bytes
```
ƛ`<> `k/m6↲ǒĿð+;Ṙ∩øɽ⁋
```
[Try it Online!](https://vyxal.pythonanywhere.com/?v=2#WyIiLCIiLCLGm2A8PiBgay9tNuKGsseSxL/DsCs74bmY4oipw7jJveKBiyIsIiIsIltbXCI+XCIsXCI8XCIsXCI8XCIsXCI8XCIsXCI+XCJdLFtcIiBcIixcIjxcIixcIj5cIixcIjxcIl1dIl0=)
```
ƛ              ;      # For each line
            Ŀ         # Replace
 `<> `                # Each of "<> "
      k/m6↲ǒ          # with corresponding elements of "/\", "\/", "  "
             ð+       # Append a space to each
                Ṙ∩    # Rotate 90°
                  øɽ⁋ # Right align and join by newlines
```
[Answer]
# [Husk](https://github.com/barbuz/Husk), 30 bytes
```
mȯσ" ""  "σ"<""/¦"σ">""¦/"T' ↔
```
[Try it online!](https://tio.run/##yygtzv7/qKnx0Lb/uSfWn29WUlBSUlBQAjJslJT0Dy0DseyUlA4t01cKUVd41Dbl////dnYKCjY2XDYgyo4LSACxnQ0A "Husk – Try It Online")
I made the clunkiest possible solution.
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 19 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
Çºòî@f┬U☺≥•:Γ_ƒ←⌠Φô
```
[Run and debug it](https://staxlang.xyz/#p=80a7958c4066c25501f2073ae25f9f1bf4e893&i=%3E%3E++%3C%3C%0A%3C%3E++%3C%3E%0A++%3C%0A++%3E%3C)
[Answer]
# Scala, ~~201~~ ~~188~~ 180 characters
```
(s:String)⇒(Seq("")→0/:s.lines.flatMap(l⇒Seq(l,l))){case((v,i),l)⇒(l.map(c⇒if(Set('>','<')(c))if(c%4==i)'/'else'\\'else c)+:v,2-i)}._1.init.transpose.map(_.mkString).mkString("\n")
```
### note:
this only works if the provided string has all lines with equal length (i.e. padded with spaces)
## explanation:
I'm using fold with initial value of tuple of a `Seq[String]` and an `Int` (instead of writing `Seq.empty[String]` im writing the shorter `Seq("")` and `.init` after the fold), the fold operates on a collection of strings, each string is a line in the original input, and every line is doubled. the trick here was to test for modulo of the char. since `'<'` value is 60, and `'>'` value is 62, testing for modulo 4, will yield 0 or 2. that's why the fold also carry a flipping `Int` set to 0. and flipped between 0 and 2 with `2-i`. every odd line should map `'>'` to `'/'` and `'<'` to `'\\'`, and every even line should map `'>'` to `'\\`' and `'<'` to `'/'`. this is why i test for `c%4==i` and hit 2 birds with 1 stone. the fold "rebuilds" the initial sequence of strings in reverse, and then (after dropping the last line), I transpose the sequence (this is why all strings must be of exact same length). because of the implicits involved, I need to `_.mkString` on each line (previously column), and then `mkString("\n")` for the final output.
[Answer]
# Perl - 119
```
@l=map[/./g],reverse<>;do{print;$_=join(' ',map({'<'=>'/\\','>'=>'\/'}->{$_->[$b]}||'  ',@l))."\n";$b++;}while(/[^ 
]/)
```
First, `@l` is assigned as a list of lists representing the characters on each line of input with lines in reverse order. Then it loops through the columns of characters, replacing the angle brackets with the corresponding slashes, joining the elements with spaces, and printing the joined slashes as a line.
]