title: Draw my downslashes

text:
# Question
Title: Draw my downslashes
As a programmer, you've probably heard of forward slashes and backward slashes. But have you heard of downslashes? That's when you take a bunch of slashes, connect their ends and draw them going down.

For today's challenge, you must write a program or function that takes a string consisting purely of slashes, and outputs all of those slashes drawn downwards in a line connecting them. This will be a lot more clear if you see an example. Given the string `\\\//\/\\`, you should output:

```
\
 \
  \
  /
 /
 \
 /
 \
  \

```

Here are some clarifications:

* There must be one slash per line.
* The first line will have 0 leading spaces.
* For each pair of slashes:

+ If they are different from each other, they will be drawn in the same column. For example, `\/` will give:

    ```
    \
    /

    ```
    + If they are the same character, the lower one is in the direction *pointed* to, that is moving to the right for a backslash, and moving to the left for a forward slash. So `\\//` will give

    ```
    \
     \
     /
    /

    ```
* Each line may have extra trailing whitespace as long as this doesn't change the visual appearance of the output. Up to one trailing and leading newline is also acceptable. Extra leading spaces *are not permitted*!

In order to keep this simpler, you can assume that the string will never contain too many forward slashes. In other words, no prefix of the input will contain more forward slashes than backslashes, so an input like `\\////` or `//` will never be given. This also means that every input will start with a backslash.

If your input is taken as a string literal, you may escape the backslashes if this is necessary. You will also never need to handle an input that is empty, or contains characters other than a slash.

You may output by any reasonable format.

As usual, this is a challenge, so try to make the shortest solution possible, even if you pick a language where this is rather difficult. Bonus points for explaining any interesting techniques you used to take bytes off!

## Examples

```
#Input
\\\\\\\\\\\

#Output
\
 \
  \
   \
    \
     \
      \
       \
        \
         \
          \

#Input
\\\//\\/\//\\///

#Output
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/

#Input
\/\/\/

#Output
\
/
\
/
\
/

```

# Answer
# GNU Sed, 20

```
s|\\|&^L|g
s|/|^H/^L^H|g

```

Note that `^L` and `^H` are literal formfeed and backspace characters (0x12 and 0x8).

This answer works by moving the cursor around using backspace and formfeed characters. The slashes/backslashes are not left-padded with spaces - Not sure of this disqualifies this answer. This doesn't work in TIO, but it looks fine under common terminals such as `xterm` and `gnome-terminal`.

Recreate this sed script as follows:

```
base64 -d <<< c3xcXHwmDHxnCnN8L3wILwwIfGc= > downslash.sed

```

Run it as follows:

```
$ echo '\\\//\/\\' | sed -f downslash.sed
\
 \
  \
  /
 /
 \
 /
 \
  \

$

```

### Explanation:

```
s|\\|&^L|g     # move cursor down after every "\"
s|/|^H/^L^H|g  # move cursor left before every "/", then after, down and left again

```
> 22 votes

# Answer
# ///, 119 bytes

/// has no input commands, so input must be embedded in the program. For this one, the input string is simply appended, with no escaping needed.

```
/=/\/\///M/
|%%=N/%|||=C/BA=\/\\/\/C\\=C\\/CbC=B\A\=CfC=AB=/A/%Mxy=B/|z%N|x|y% %N%x|y%%% |fzN%M%b|zN|M|%
=|/AB\\=%/|=AC

```

# How it works

* In the following, an input of `\\/\//` will be appended to the program for demonstration.
* is used to represent newlines in inline code.

## Abbreviations

The beginning `/=/\/\///M/␤|%%=N/%|||=C/BA=` of the program contains substitutions for golfing abbreviations.

* `=` expands to `//`, `M` to `␤|%%`, `N` to `%|||` and `C` to `BA`.
* After this the current program becomes

```
/\/\\/\/BA\\//BA\\/BAbBA//B\A\//BAfBA//AB///A/%
|%%xy//B/|z%%||||x|y% %%|||%x|y%%% |fz%|||%
|%%%b|z%||||
|%%|%
//|/AB\\//%/|//ABA\\/\//

```

## Input recoding

The next stage transforms the appended input string into a more usable form. Since it consists entirely of ///'s two command characters, this takes some care to avoid mangling the base program.

* The first substantial substitution, `/\/\\/\/BA\\/`, replaces the string `/\` with `/BA\`.
    + The base program does not contain `/\` at this time, so this substitution doesn't affect it.
    + However, this splits up the appended input string into sequences of `\`s followed by sequences of `/`s, which together with the `ABA` at the end of the base program makes it possible to iterate through it with the following substitutions.
    + Including the `ABA` prefix before it, the example input string now becomes `ABA\\/BA\//`.
* The next substitution, `/BA\\/BAbBA/`, replaces `BA\` by `BAbBA`.
    + Because /// substitutions are repeated until they no longer match, this iterates through all the `\`s of the input string, which with prefix now becomes `ABAbBAbBA/BAbBA//`
* Similarly, `/B\A\//BAfBA/` changes `BA/` to `BAfBA`, iterating through the `/`s.
    + The escaping `\` in this substitution is needed since otherwise it would be mangled by the previous one.
    + The input has now turned into `ABAbBAbBAfBABAbBAfBAfBA`.
* Next `/AB//` removes some superfluous parts of the encoding, turning it into `AbBAbBAfBAbBAfBAfBA`.
    + This also removes an `AB` from the `/|/AB\\/` substitution later in the program, which was needed to protect it from the above `/\` manipulation.
    + At this point every `\` in the original input string has become `AbB`, and every `/` has become `AfB`. (`b` and `f` stand for backward and forward.) There's a stray `A` at the end.
* The next two substitutions replace all the `A`s and `B`s with program fragments to run in the final stage. In the replacement strings, `%`s and `|`s encode what will become `/`s and `\`s respectively. This has two benefits:
    + Unlike `/` and `\`, the `%`s and `|`s don't need escaping to be copied.
    + The replacement strings avoid containing the substring `/\`, which would otherwise have been mangled by the previous manipulations.
* After this, the substitution `/|/\\/` (formerly `/|/AB\\/`) now decodes the `|`s, after which the following `/%/|//` has become `/%/\//` and decodes the `%`s.

## Program structure at final stage

At this point, the base program has run all its substitutions, and all that remains is the program-encoding of the input string.

* Each input character has become a subprogram

```
/
\//xy*\z//\\\\x\y/ //\\\/x\y/// \fz/\\\/
\///b\z/\\\\
\//\/

```

(trailing newline), where `*` represents either `f` for an original `/`, or `b` for an original `\`.
* There is also an incomplete substitution command `/␤\//xy` at the end of the program, which will have no effect except to provide a necessary `/` for the substitutions of the previous subprogram.

## Shared substring

Before the final iteration through the subprograms starts, there is a substring crossing the boundary after each character's subprogram of the form `\/␤/`.

* These substrings are used as a shared global state. All the remaining substitutions in the program will manipulate them identically and in parallel, such that at the end of each input character's subprogram its copy of this shared substring (except the final `/`, which anchors the substitutions) will be run to print the line for that character.
* The initial version of the substring represents printing a line containing just `/`, which is the right imaginary "previous line" to cause the first input character to be printed at the beginning of its line.
* In general, during the printing steps, the shared substring consists of a number of spaces, `\\` or `\/`, a newline, and a following `/`.

## Running a character subprogram

Several of the following substitutions contain extra `\`s inside to prevent them from being matched and mangled by each other (including other copies in other subprograms). Achieving this is also the reason why both of `x` and `y` are needed.

* The first substitution in a character subprogram, `/␤\//xyf\z/` or `/␤\//xyb\z/`, causes the `␤/` at the end of the shared substring to become `xyfz` or `xybz`, immediately following the `\/` or `\\`.
* The substitution `/\\\\x\y/ /` replaces `\\xy` by a space, and the substitution `/\\\/x\y//` replaces `\/xy` by nothing.
    + They apply when the previous input character printed was a `\` or `/`, respectively.
    + The shared substring now contains the appropriate number of spaces for printing a `\` next, followed by `fz` or `bz`.
* The substitution `/ \fz/\\\/␤\//` replaces ` fz` by `\/␤/`, and `/b\z/\\\\␤\//` replaces `bz` by `\\␤/`.
    + They apply when the current input character is `/` or `\`, respectively.
    + The first one eats an extra space to place `/` correctly.
        - If this space is missing (i.e. input violating the prefix condition), the following substitutions get misinterpreted, printing a lot of junk and usually hitting a `///`, which is an infinite loop.
    + Each adds the correct command to print its own character, and reinstates the original `␤/` at the end of the shared substring.
* The character subprogram has now reached its copy of the shared substring, which is ready to print its line.

After the last character subprogram has run, what remains of the program is `/␤\//xy`. Since this is an incomplete substitution with missing final `/`, the program skips it and halts normally.
> 16 votes

# Answer
# Python 2, ~~55~~ ~~54~~ ~~51~~ ~~57~~ 53 bytes

-3 bytes (and a bug fix) thanks to Felipe Nardi Batista

```
i=0
for c in input():i-=c<'<'*i;print' '*i+c;i+=c>'<'

```

Try it online!
> 15 votes

# Answer
# Charcoal, ~~13~~ ~~12~~ 11 bytes

```
ＦＳ¿⁼ι/↓¶/↘ι

```

Try it online! Link is to verbose version of code. Supports extra `//`s. Explanation:

```
 Ｓ              Input string
Ｆ               Loop over each character
  ¿             If
    ι           Current character
   ⁼            Equals
     /          Literal /
      ↓¶        Move left
      ↓ /       Print a / downwards
         ↘ι     Else it's a \ so print that down and right

```
> 15 votes

# Answer
# Jelly,  ~~14 13~~  12 bytes

-1 thanks to caird coinheringaahing (Use of `;"` in place of `ż` to allow yielding a list of lines and so use of `Ʋ`.)

```
=”\Ḥ’Ä_Ʋ⁶ẋ;"

```

A monadic Link that yields a list of lines.

**Try it online!**

### How?

```
=”\Ḥ’Ä_Ʋ⁶ẋ;" - Link: list of characters, s    e.g. "\\\//\\/"
 ”\          - literal '\'                         '\'
=            - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
       Ʋ     - last four links as a monad - f(e)
   Ḥ         -   double (e)                        [2, 2, 2, 0, 0, 2, 2, 0]
    ’        -   decrement                         [1, 1, 1,-1,-1, 1, 1,-1]
     Ä       -   cumulative sums                   [1, 2, 3, 2, 1, 2, 3, 2]
      _      -   subtract (e)                      [0, 1, 2, 2, 1, 1, 2, 2]
        ⁶    - literal ' '                         ' '
         ẋ   - repeat                              ["", " ", "  ", "  ", " ", " ", "  ", "  "]
           " - zip with:
          ;  -   concatenate (c from s)            ["\", " \", "  \", "  /", " /", " \", "  \", "  /"]

```
> 8 votes

# Answer
# MATL, ~~23~~ ~~19~~ 18 bytes

*1 byte off thanks to @Sanchises*

```
fGqoEq1yd~h*YsGZ?c

```

Input is a string enclosed in single quotes.

**Try it online!** Or verify test cases: **1**, **2**, **3**.

### Explanation

Consider input `'\\\//\/\\'` as an example.

```
f      % Implicit input. Array of indices of nonzeros. Since all chars in the input
       % have nonzero code point, this gives [1 2 ... n] where n is input length
       % STACK: [1 2 3 4 5 6 7 8 9]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], '\\\//\/\\'
qo     % Subtract 1 from (the code-point) of each char and then compute modulo 2.
       % This transforms '\' into 1 and '/' into 0
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 0 1 0 1 1]
Eq     % Double, subtract 1. This transforms 0 into -1
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1]
1y     % Push 1 and duplicate from below
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 1 -1 -1 1 -1 1 1]
d~     % Consecutive differences, logical negation: gives 1 if consecutive entries
       % are equal, 0 otherwise
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], 1, [1 1 0 1 0 0 0 1]
h      % Horizontally concatenate
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 -1 -1 1 -1 1 1], [1 1 1 0 1 0 0 0 1]
*      % Element-wise multiplication
       % STACK: [1 2 3 4 5 6 7 8 9], [1 1 1 0 -1 0 0 0 1]
Ys     % Cumulative sum
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3]
G      % Push input again
       % STACK: [1 2 3 4 5 6 7 8 9], [1 2 3 3 2 2 2 2 3], '\\\//\/\\'
Z?     % Build sparse matrix with those row indices, column indices, and values
       % STACK: [92  0  0;
                  0 92  0;
                  0  0 92;
                  0  0 47;
                  0 47  0;
                  0 92  0;
                  0 47  0;
                  0 92  0;
                  0  0 92]
c      % Convert to char. Char 0 is shown as space. Implicitly display
       % STACK: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']

```
> 6 votes

# Answer
# Haskell, 49 bytes

```
scanl(\x c->drop(sum[1|'/'<-c:x])(' '<$x)++[c])[]

```

Try it online!
> 6 votes

# Answer
# JavaScript (ES8), ~~66~~ ~~59~~ 63 bytes

*7 bytes saved thanks to Justin Mariner
+4 bytes to fix `/\\/\\/` (noticed by Neil)*

```
f=([a,...z],b=a<'0')=>a?a.padStart(b+=k=a>'/')+`
`+f(z,b-!k):''

```

Try it online!
> 5 votes

# Answer
# Perl 5, 44 bytes

42 bytes of code + 2 for `-F` flag

```
say$"x($s+=$\eq$_&&$#i**m|/|).($\=$_)for@F

```

Try it online!
> 5 votes

# Answer
# 05AB1E, 14 bytes

```
ÇÈx<ηOs-W-ISú»

```

Try it online!

**Explanation**

```
Ç                # convert input string to a list of ascii codes
 È               # check each for evenness
  x              # push a doubled copy
   <             # decrement
    η            # compute prefixes
     O           # sum each prefix
      s          # swap the unaltered copy of evenness to the top
       -         # subtract from the prefix-sum list
        W-       # subtract the minimum value
          IS     # push input split to a list of chars
            ú    # pad each with the number of spaces computed
             »   # join on newline

```
> 5 votes

# Answer
# C# (.NET Core), ~~74~~ ~~88~~ ~~82~~ ~~78~~ ~~77~~ 76 + 18 bytes

*-1 byte thanks to Kevin Cruijssen*

```
s=>s.Select((x,i)=>$"{x}".PadLeft((x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1)))

```

Outputs a collection of strings, one for each line. Byte count also includes:

```
using System.Linq;

```

Try it online!

Explanation for 77 byte answer:

```
s =>                              // Take input, a string
    s.Select((x, i) =>            // Replace every character with:
        $"{x}"                    //     The character as string
        .PadLeft(                 //     Pad with this many spaces:
            s.Take(i)             //         Take characters, in the input string, preceding current one
            .Sum(y =>             //         Sum them by:
                y < 92 ? -1 : 1   //             If it's a \ add 1, if / subtract 1
            )
            + (x - s[0]) / 45 + 1 //         If first slash is a / add one more space, if current slash is a \ add one more space (I got this through power of MATHS!)
                                  //         How I arrived at this function:
                                  //         + x / 48        If current slash is a \ add one more space
                                  //         - s[0] / 48 + 1 If the first slash is a / add one more space
        )
    )

```
> 5 votes

# Answer
# Lua, 96 bytes

```
c=0 for s in(...):gmatch(".")do c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end

```

Try it online!

Shortest one I could come up with in Lua. Input is taken from the command line.

This does use a few tricks:

1. `(...):gmatch(`
This should be the shortest form of getting a single string into a Lua program from the command line. The `...` expression in Lua captures any excess parameters to a function that aren't specified in the function declaration and is used for varargs. Since the main body of a Lua program gets called as a function with the command line arguments as its parameters, the command line arguments will end up in `...`.
The parentheses around it turn the potentially multi-valued `...` expression into a single-valued expression. Consider this (somewhat surprising) example:
```
function multipleReturnValues()
    return "abc", "def"
end
print(  multipleReturnValues()  ) --This prints: abc    def
print( (multipleReturnValues()) ) --This prints: abc
```
2. The Lua parser does not need any line terminators, or even whitespace between statements, as long as the two statements' tokens can be clearly separated and there's only one interpretation of the text that's valid Lua code.
3. Abusing `and`/`or` for "if x then value1 else value2" logic.
Lua's `and` operator returns its first argument if it is falsy; otherwise, it returns its second argument. The `or` operator returns its first argument if it is truthy; otherwise, the second argument.
4. `p`doesn't need any initialization.
`p==s` always has to be false in the first run of the loop, regardless of the input. Not setting `p` to any value before entering the loop (leaving it `nil`) will make that happen and save bytes, too.

Can anyone golf this (in Lua)?
> 3 votes

# Answer
# Retina, 47 bytes

```
^|\\
 $&
+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3
m`^

```

Try it online! Link includes test cases. Explanation:

```
^|\\
 $&

```

Add a space at the beginning of each line and before each `\`.

```
+m`^( *)( /|\\)(/| \\)
$1$2¶$1$3

```

Consider the first two characters of the string. If the first is a `/` then the indent needs to be decremented; this is achieved by including the preceding space in the capture (which always exists because the first stage added it); if the second is a `\\` then it needs to be incremented; this is achieved by including the space that the first stage added in the capture. Having given the second character the correct indent, the stage is repeated for the second and third character etc.

```
m`^

```

Remove the extra indent.

I've written a 94-byte version which (like my Charcoal answer) allows any combination of slashes: Try it online! Explanation:

```
.$
¶$.`$* $&

```

Get the ball rolling by taking the last slash and indenting it to the same position on its own line.

```
/
 /

```

Prefix spaces to all forward slashes so that they can be captured.

```
+`^(.*)( /|\\)¶( *)( \\|/)
$1¶$3$2¶$3$4

```

Repeatedly take the last slash of the input and align it on its own line with the slash on the line below.

```
+ms`^(?<!^[\\/].*) (?!.*^[\\/])

```

Delete any left-over indentation.

```
G`.

```

Delete the now empty input.
> 3 votes

# Answer
# C (GCC), 137 134 97 bytes

Try it online!

• 3 bytes thanks ATaco

• 37 bytes thanks to Digital Trauma & ThePirateBay

```
i,d;f(char*s){char c=s[i],n=s[++i];if(c){printf("%*c%c\n",d+1,c);(c-n)?d:(c==47)?--d:++d;f(s);}}

```

Nothing too fancy just a simple recursive function that takes a string and prints out the slashes, note that the input needs to escape the backslashes first.

## Usage

```
f("\\\\\\//\\/\\\\",0,0);

```

## Ungolfed

This is for the old answer, view the try it online link for updated one!

```
f(char *s, i, d) {
    char c=s[i], n=s[++i];
    if(!c) return;
    for(int j=0; j<d; j++) printf(" ");
    printf("%c\n",c);
    f(s, i, (c!=n)?d:(c=='/')?d-1:d+1);
}

```

## Output
> 3 votes

# Answer
# Java 8, ~~121~~ ~~118~~ ~~110~~ ~~109~~ 102 bytes

```
a->{String r="";int s=0,p=0,i;for(char c:a){for(i=s+=p+(p=c-63)>>5;i-->0;r+=" ");r+=c+"\n";}return r;}

```

-7 bytes thanks to *@Nevay*'s bit-wise magic. :)

**Explanation:**

Try it here.

```
a->{                    // Method with char-array parameter and String return-type
  String r="";          //  Return-String
  int s=0,              //  Amount of spaces
      p=0,              //  Previous characters (starting at 0)
      i;                //  Index-integer
  for(char c:a){        //  Loop over the input
    for(i=s+=p+(p=c-63)>>5;
                        //   If the current does not equals the previous character
                        //    Leave `s` the same
                        //   Else-if it's a '\':
                        //    Increase `s` by 1
                        //   Else (it's a '/'):
                        //    Decrease `s` by 1
                        //   And set the previous character to the current in the process
        i-->0;r+=" ");  //   Append `r` with `s` amount of spaces
    r+=c+"\n";          //   Append the character + a new-line to the result
  }                     //  End of loop
  return r;             //  Return result-String
}                       // End of method

```
> 3 votes

# Answer
# , ~~122~~ 121 bytes

-1 byte thanks to Giuseppe

```
x=el(strsplit(scan(,""),""));n=seq(x);y=x>"/";for(i in n)cat(rep(" ",diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]),x[i],"\n",sep="")

```

Try it online!

With extra whitespace:

```
x = el(strsplit(scan(,""),""))
n = seq(x)
y = x>"/"
for(i in n) {
  cat(rep(" ", diffinv(y[n[-1]-1]+y[n[-1]]-1)[i]), x[i], "\n", sep="")
}

```

Explanation: This answer is based on the observation that the number of leading spaces changes each line by -1, plus the number of `/` in the previous and current lines.

If we have N slashes, the variable `y` is a vector of length N, with 1 for each position with `\`, 0 otherwise. Therefore, to get the change in number of leading spaces per line, we calculate `y[1:(N-1)] + y[2:N] - 1`. The function `diffinv` converts these differences into a sequence, starting with 0. The rest is just a matter of assembling each line as the required number of trailing spaces, followed by the relevant slash and a newline.
> 3 votes

# Answer
# Brain-Flak, 175 bytes (174 chars + 1 flag)

Run with `-c` flag.

```
{(({})<(())>){({}[()]<([{}])>)}{}(({}<>{}<><({}<>)((()()()()()){})>)<{({}[()]<((((()()()()){}){}){})>)}>{})<>}<>{}{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

```

Try it online!

## Explanation

```
{ for each char in the input...
  (({})<(())>){({}[()]<([{}])>)}{} push 1/-1 for backslash/slash
  ((
   {}<>{}<> add the 1/-1 to a running total
   <
    ({}<>) move slash/backslash to other stack
    ((()()()()()){}) newline
   >
  )<{({}[()]<((((()()()()){}){}){})>)}>{}) spaces
  <>
}<>{} end for
reverse data order, removing one space before backslash
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

```
> 3 votes

# Answer
# Ruby, 80 76 bytes

-4 bytes thanks to manatwork

```
puts"\\";$*[i=0].chars.each_cons 2{|b,c|puts" "*(b==c ?b==?/?i-=1:i+=1:i)+c}

```

Try it online!

Explanation:

```
puts "\\"           # Output the first backslash
$*[i=0].            # Get the first argument and set i to 0
chars.              # Go through every individual character,
each_cons 2 { |b,c| # In pairs to compare easily
                    #
    puts " " *      # Decide how many padding spaces to use based on the value
                    # of i. The expression inside the parenthesis will return
                    # i but before that, it will increment/decrement i based
                    # on what the previous character was.
                        #
    ( b==c ?            # if b == c
        b==?/ ?         #   if b == "/" (Going to the left)
            i-=1        #       return decremented i
            :           #   else        (Going to the right)
            i+=1        #       return incremented i
        :               # else
        i) +            #   return i
                    #
                c   # Finally, write the second of the characters that we're
}                   # iterating through.

```
> 3 votes

# Answer
# C, 60 bytes

```
i;f(char*s){for(i=1;*s;s++)printf("%*c\n",*s%2?--i:i++,*s);}

```

Try it online!
> 3 votes

# Answer
# brainfuck, 98 bytes

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

```

Try it online!
> 3 votes

# Answer
# Vyxal, 16 bytes

```
ƛ\/=&-ð¥*n+,C₂&+

```

Try it Online!

```
ƛ                # Map by...
    &-           # Decrement register by
 \/=             # (is a forward-slash)
      ð¥*        # (register) spaces
         n+,     # prepended to n and outputted
              &+ # Increment register by
            C₂   # (is a backslash)

```
> 3 votes

# Answer
# Pyth, 28 bytes

```
j.u+?qeNY?>Y\/+PNdPPNPNYtzhz

```

Try it online!
> 2 votes

# Answer
# , 119 bytes

```
function(s)for(i in 1:nchar(s))cat(rep(" ",cumsum(c(0,!diff(S<-(utf8ToInt(s)>48)*2-1))*S)[i]),substr(s,i,i),"
",sep="")

```

Try it online!

This differs somewhat from user2390246's answer. They each iterate over the string, printing out a certain number of space characters and then the appropriate `/\` character.

However, I avoided splitting the string, opting instead to replace the characters with their UTF-8 encoding value instead, which then allows me to do arithmetic on the numbers directly, which saved me just a few bytes.
> 2 votes

# Answer
# Lua, ~~88~~ 84 bytes

Improved version (-4 bytes thanks to QuertyKeyboard)

```
s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end)

```

Try it online!

# Original version (88 bytes)

Another attempt in Lua, this time with a completely different approach using string manipulation instead of a counter variable.

```
s=""for c in(...):gmatch"."do s=s:gsub("\\"," "):gsub("/?$",c):gsub(" /","/")print(s)end

```

Ungolfed:

```
s = ""
for c in string.gmatch((...), ".") do --for each character in the input
  --s contains the output from the previous iteration
  s = s:gsub("\\", " ") --Replace backslash with space -> indent by 1
  s = s:gsub("/?$", c) --Remove any / at the end of the string and append c to the string
  s = s:gsub(" /", "/") --Remove a single space in front of any / -> un-indent by 1
  print(s)
end

```

There's one interesting thing in the code: `(...):gmatch"."`
This uses some quirks in the Lua parser. When Lua encounters a piece of code in the form `func "string"`, it'll convert this to `func("string")`. This is so that one can write `print "string"` to print a constant string and it only works with a single string literal after the function. Anything else will give a syntax error. However, this syntactic sugar also works with function calls in the middle of an expression, and more surprising, it works just fine together with the `:` method call syntactic sugar. So in the end, Lua will interpret the code like this:

```
(...):gmatch"."
-> (...):gmatch(".")
-> string.gmatch((...), ".")
```

~~If anyone can think of a way to remove one of the three gsub calls, please tell me.~~
> 2 votes

# Answer
# C# (.NET Core), 60/65 bytes

I tried shorter C# version

```
s=>{int i=0;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

```

as there was stated: "This also means that every input will start with a backslash." Or slighly longer which solve starting "/"

```
s=>{int i=s[0]&1;return s.Select(x=>"".PadLeft(x<92?--i:i++)+x);}

```

Try it online!
> 2 votes

# Answer
# Dyalog APL, 31 bytes

```
{↑⍵,¨⍨' '/¨⍨{⍵-⍨+\¯1+2×⍵}⍵='\'}

```

Try it here!
> 2 votes

# Answer
# QBasic, 79 bytes

```
DO
c$=INPUT$(1)
IF"/">c$THEN END
c=2*ASC(c$)-139
i=i+c+p
?SPC(i\90);c$
p=c
LOOP

```

This program prints the slashes as you type them. To quit, press `Enter` (or anything earlier in the ASCII table than `/`).

### Explanation

With the variables `i` and `p` implicitly initialized to `0`, we enter an infinite loop. `INPUT$(1)` reads one character from keyboard input. If this character is less than forward slash, `END` the program. Otherwise, we calculate `c` such that an input of `/` gives `c=-45` and `\` gives `c=45`. We then add `c` and `p` (the **p**revious value) to `i` (the **i**ndent).

If `p` and `c` are the same, they add together to change `i` by either `-90` or `+90`. If they are different, they cancel out and do not change `i`. We then print `i\90` spaces followed by the character. (We use integer division because the value of `i` is actually going to be `45`, `135`, etc., since `p` is `0` on the first iteration instead of `-45`.)

Finally, set `p=c` for the next iteration, and loop.
> 2 votes

# Answer
# Perl, 33 bytes

Includes `+1` for the `n` option

```
perl -nE 's%.%say$"x(l^$&?--$a:$a++).$&%eg' <<< '\\\//\/\\'

```

Where it not for the fact that `-F` counts as `+3` this would be `32`:

```
echo -n '\\\//\/\\' | perl -F -E 'say$"x(l^$_?--$a:$a++).$_ for@F'

```
> 2 votes

# Answer
# Zsh, 43 bytes

```
for c (`fold -1`)echo ${(l/#c%2?w--:++w/)c}

```

Try it online!

Explanation:

* `fold -1`: line-wrap the input to a width of 1 (i.e., insert a line-break between every character)
* `for c (``)`: for each character `$c`:
    + `${c}`: take the character,
    + `(l//)`: left-padded with spaces to the width of:
        - `#c`: the character code of `$c`
        - `%2`: modulo 2 (this is 1 for `/` and 0 for `\`)
        - `?`: if 1 then:
            * `w--`: decrement `$w` (and return the original value)
        - `:`: else:
            * `++w`: increment `$w` (and return the mutated value)
        - note that `$w` starts at 0 implicitly
    + `echo`: print; we can't use the 2 bytes shorter `<<<` since its argument is evaluated in a sub-shell so the mutation of `$w` has no effect
> 2 votes

# Answer
# Pyth - 33 bytes

First attempt, will golf.

```
jsMC,*L;+ZsM._*VqVtzztMxL"/ \\"zz

```

Try it online here.
> 1 votes

# Answer
# , 14 bytes

```
\ÓçÜ/j>G
ç¯/<G

```

Try it online!
> 1 votes

# Answer
# Perl, 40 + 2 bytes

```
/\//&&$.--,say($"x$.,$_),/\\/&&$.++for@F

```

You need the `-F` flag.
> 1 votes

# Answer
# Perl, ~~34~~ 38 + 1 bytes

to handle the two cases

```
s,(/)|.,$"x($1?$c&&--$c:$c++).$&.$/,ge

```

to be run with `-p` option

```
s,(/)|.,$"x($1?--$c:$c++).$&.$/,ge

```

EDIT: following comment doesn't work when first character is `/`

```
s,(/)|.,$"x($1?$c--:++$c).$&.$/,ge

```

however output will be shifted one character on the right if first char is `\`
> 1 votes

# Answer
# Pyth, ~~24~~ 21 bytes

Port from Rod's answer.

```
VQ=-Z<N\<+*ZdN=+Z>N\<

```

Try it online!
> 1 votes

# Answer
**VBA (Excel), 181 bytes**

```
Sub q()
a = Cells(1, 1)
For x = 1 To Len(a)
c = Mid(a, x, 1)
If c = "\" Then: Debug.Print b & c: b = b + " "
If c = "/" Then: b = Left(b, Len(b) - 1): Debug.Print b & c
Next
End Sub

```
> 1 votes

# Answer
# SOGL V0.12, ~~16~~ 13 bytes

```
{└=-:↕PFoF┘=+

```

Try it Here! \- expects input on the stack, so for ease-of-use `,` is added
> 1 votes

# Answer
# Excel VBA, ~~74~~ 72 Bytes

Anonymous VBE immediate window function that takes input from cell `[A1]` and outputs to the VBE immediate window

```
For i=1To[Len(A1)]:c=Mid([A1],i,1):s=s+(c="/"):?Spc(s)c:s=s-(c="\"):Next

```

### Example I/O

```
[A1]="\\\//\\/\//\\///"
For i=1To[Len(A1)]:c=Mid([A1],i,1):s=s+(c="/"):?Space(s)c:s=s-(c="\"):Next
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/

```
> 1 votes

# Answer
# Implicit, 25 bytes

```
~.(´?`/ò](0ß´);@ß1?`\ó~.ö

```

Try it online!

Ungolfed/explanation:

```
~.         read input, increment
(          do..while top of stack truthy
 ´         decrement

 ?`/{      if input equal to /
   ]´[      decrement memory
 }

 ](0       pull memory, do..while truthy
  @32       print a space
  ´         decrement
 );        pop

 @@10      print input, print a newline

 ?`\{      if input equal to \
   ].[      increment memory
 }

 ~.        read input, increment
)          loop
&          exit (avoid implicit output)

```

Note that `ß` is equal to `@32`, `ò` is equal to `]´[`, `ó` is equal to `].[`, and `ö` can be used in place of `)&` when at the end of a program.
> 1 votes

# Answer
# Python 3, 78 bytes

```
a,x='',0
for i in input():x+=((1*i!='/')-(1*i=='/'))*(a==i);print(' '*x+i);a=i

```

Try it online!
> 1 votes

# Answer
# brainfuck, 151 bytes

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

```

Try it online!
> 1 votes

# Answer
# C (gcc), ~~96~~ ~~71~~ 70 bytes

Awesome -25 solution by ceilingcat

And another -1 by ceilingcat. ASCII bit hacks ftw

```
c;p;main(i){for(;read(0,&c,1);printf("%*c\n",i,p=c))c-p?:c&1?--i:++i;}

```

Try it online!

**Ungolfed**

```
c; /* character */
p; /* previous character */

main(i /* indent */)
{
    for (; read(0, &c, 1); printf("%*c\n", i, p = c))
        c - p ? : c & 1 ? --i : ++i;
}

```

**Explanation**

`read` takes `1` byte from the file descriptor `0` (`stdin`) and stores it in `c`.

`c - p` checks if `c` and `p` are different. `c & 1` checks if `c` is a forward slash. So the entire conditional increments the indent if the character and the previous character are both backslashes, and decrements the indent if they're both forward slashes.

Then we print `c` with `i` leading spaces. We also assign `p = c` for the next iteration.
> 1 votes

# Answer
# , 28 27 22 bytes

```
({."0~+/\-0&<)_1^'\'=]

```

Try it online!

*Thanks to Bubbler for catching a bug and for -6 bytes!*
> 1 votes

# Answer
# PowerShell, ~~71~~ 69 bytes

-2 bytes thanks to mazzy

```
$z=92
$args|%{$i+=($x=2*($_-eq92)-1)*($z-ne$_)
' '*$i+($z=$_)
$i+=$x}

```

Try it online!

Takes input by splatting. This also saves us two bytes because we can just treat it as an int instead of writing `'\'` which we do twice.
> 1 votes

# Answer
# PowerShell, 47 bytes

```
switch($args){'\'{' '*$i+++$_}'/'{' '*--$i+$_}}

```

Try it online!
> 1 votes

# Answer
# Rockstar, ~~110~~ ~~92~~ 90 bytes

```
listen to S
cut S
Y's -1
while S
roll S in C
let Y be+C's "\"
say " "*Y+C
let Y be-C's "/"

```

Try it here (Code will need to be pasted in)

```
listen to S     :Read input string into variable S
cut S           :Split into an array
Y's -1          :Initialise Y as -1
while S         :While S is not empty
roll S in C     :  Pop the first element into variable C
let Y be+       :  Increment Y by
  C's "\"       :    C is equal to "\"
say " "*Y+C     :  Output Y spaces & C
let Y be-       :  Decrement Y by
  C's "/"       :    C is equal to "/"

```
> 1 votes

# Answer
# Excel, 125 bytes

```
=LET(q,SEQUENCE(LEN(A1)),x,MID(A1,q,1),REPT(" ",MMULT(IF(TRANSPOSE(q)>q,,1),IF(q=1,,(INDEX(x,q-1)="\")-(INDEX(x,q)="/"))))&x)

```

Link to Spreadsheet

This is a port of Taylor Scott's VBA answer.

## Explanation

* `=LET(q,SEQUENCE(LEN(A1)),` q = vertical array `[1..LEN(A1)]`
* `x,MID(A1,q,1),` x = The characters in `A1` in a vertical array
* `IF(q=1,,(INDEX(x,q-1)="\")-(INDEX(x,q)="/"))` the change in the number of spaces from the prior line; +1 if the prior line was "", -1 if the current line is "/"
* `IF(TRANSPOSE(q)>q,,1)` a lower triangular matrix of 1s
* `MMULT(~,~)` matrix multiply the change array and the lower triangular matrix to get the number of spaces for each line
* `REPT(" ",~)&x)` for each line output the number of spaces & characters
> 1 votes

# Answer
# Pyth, 20 bytes

```
jm?qd\\+*;~hZd+*;=tZ

```

Test suite

The other two existing Pyth answers use different approaches (and an older version of the language).

##### Explanation:

```
jm?qd\\+*;~hZd+*;=tZ   | Full program
jm?qd\\+*;~hZd+*;=tZdQ | with implicit variables added
-----------------------+------------------------------------------------
 m                   Q | For each character d in the input:,
  ?qd\\                |  if d is '\',
        *;             |   create a string of n spaces, where n is
          ~hZ          |    Z, but then store Z + 1 in Z (Z begins as 0)
       +     d         |   add d to the end of the string
  ?                    |  otherwise,
              +*;   d  |   do the same, but with (below) spaces
                 =tZ   |    Z - 1, stored in Z
j                      | Join the results by newline.

```
> 1 votes

# Answer
# Julia 1.0, 67 bytes

```
s->(x=[s...];@.println(lpad(x,$cumsum(1-2(x<'0')-[0;$diff(x)]%2))))

```

Try it online!

* -3 bytes thanks to @MarcMush: replace `isodd(_)` with `(_.%2)`
* -6 bytes thanks to @MarcMush: use `@.` to vectorize multiple expressions
* -3 bytes thanks to @amelies: replace string repeats with `lpad`
* -1 byte thanks to @MarcMush: replace `'x=='/'` with `x<'0'`
> 1 votes

# Answer
# Vyxal, 8 bytes

```
Cæ:d⌐¦+↳

```

Try it Online! Outputs as a list of lines, formatting in footer

```
C        # Charcodes: "/" -> 47, "\" -> 92
 æ       # Are prime? "/" -> 1, "\" -> 0
   d⌐    # Double and take one's complement "/" -> -1, "\" -> 1
     ¦   # Cumulative sums
      +  # Add...
 æ:      # Is prime? (indents "/" by one extra space)
       ↳ # Pad to these lengths

```
> 1 votes

# Answer
# Python 2, ~~86~~ ~~76~~ 75 bytes

*-1 byte thanks to Neil.*

```
p,i='',0
for c in input():i+={'\\\\':1,'//':-1}.get(p+c,0);print' '*i+c;p=c

```

Try it online!

~~Fairly lame approach, I will try to golf the mapping at least.~~ NVM I got rekt by another answer. \>\_\>
> 0 votes

# Answer
# Rust, 165 bytes

```
fn f(s:&str){let(_,a)=s.chars().fold((0,"".to_string()),|(i,r),c|(if c<'<'{i-1}else{i+1},format!("{}{}{}\n",r," ".repeat(if c<'<'{i-1}else{i}),c)));println!("{}",a)}

```

Try it online!

It's an adaptation of Rod's answer in Python 2.
> 0 votes

# Answer
### c64 basic v2, 71 70 61 bytes

```
1rEs:x=1024:fOy=1tolE(s):a=aS(mI(s,y,1)):pOx,a:x=x-165+a*2:nE

```

Input can be given as

```
0dA"\\/\/\\/\//"

```

If the string is longer as 25, the program will overwrite its own memory. And we won't do that, because basic programs overwriting themselves with `POKE`s contradict the OO paradigm.
> 0 votes

# Answer
# GolfScript \- 117 bytes

```
1/{'/'=}%1:s;[{s}{..(\;!?.0<{;,0:s;}{.@\>}if}while]0:M;1:i;{,{i*}%:a{M+' '*i 0<{'/'}{"\\"}if +"\n"+}/a)M+:M;;i~):i;}/

```

Ungolfed version

```
1/{'/'=}%
1:s;
[{s}
{
  ..(\;!?.0<{;,0:s;}{.@\>}if
}
while]
0:M;
1:i;
{
  ,{i*}%:a{M+' '*i 0<{'/'}{"\\"}if +"\n"+}/
  a)M+:M;;
  i~):i;
}/

```

At first glance it looked easy... it took me 2.5 hours. Probably there is room for improvement, perhaps tomorrow I'll do some optimization.
> 0 votes

# Answer
# JavaScript, ~~49~~ 48 bytes

Takes input as an array of individual characters and outputs an array of lines.

```
a=>a.map(c=>" ".repeat(x+=d=c>'/',x-=!d)+c,x=-1)

```

Saved a byte borrowing a trick from the other JS solution.

---

## Try it

```
f=
a=>a.map(c=>" ".repeat(x+=d=c>'/',x-=!d)+c,x=-1)
o.innerText=[String.raw`\\\\\\\\\\\\`,String.raw`\\\//\\/\//\\///`,String.raw`\/\/\/`].map(s=>f([...s]).join`\n`).join`\n\n`
oninput=_=>o.innerText=f([...i.value]).join`\n`
```

```
<input id=i><pre id=o>
```
> 0 votes

# Answer
# SmileBASIC, 65 bytes

```
INPUT S$WHILE""<S$C$=SHIFT(S$)DEC N,@L>C$?" "*N;C$INC N,@H<C$WEND

```
> 0 votes

# Answer
# **K4**, 31 bytes

**Solution:**

```
-1(-1+\a-a*~~':a:-1 1"/"=x)$$x:

```

**Examples:**

```
q)k)-1(-1+\a-a*~~':a:-1 1"/"=x)$$x:"\\\\\\//\\\\/\\//\\\\///"
\
 \
  \
  /
 /
 \
  \
  /
  \
  /
 /
 \
  \
  /
 /
/

```

Works if you start with a `/` too:

```
q)k)-1(-1+\a-a*~~':a:-1 1"/"=x)$$x:"/\\\\/\\\\/"
/
\
 \
 /
 \
  \
  /

```

**Explanation:**

Generate list of negative numbers to (left) pad each of the input characters. Struggled to get a formula that worked, will look at the other solutions to see if there is a more simple method:

```
q)k)"/"=x
0001100101100111b
q)k)-1 1"/"=x
-1 -1 -1 1 1 -1 -1 1 -1 1 1 -1 -1 1 1 1
q)k)~~':a:-1 1"/"=x
1001010111010100b
q)k)a*~~':a:-1 1"/"=x
-1 0 0 1 0 -1 0 1 -1 1 0 -1 0 1 0 0
q)k)a-a*~~':a:-1 1"/"=x
0 -1 -1 0 1 0 -1 0 0 0 1 0 -1 0 1 1
q)k)+\a-a*~~':a:-1 1"/"=x
0 -1 -2 -2 -1 -1 -2 -2 -2 -2 -1 -1 -2 -2 -1 0
q)k)-1+\a-a*~~':a:-1 1"/"=x
-1 -2 -3 -3 -2 -2 -3 -3 -3 -3 -2 -2 -3 -3 -2 -1

```

Full breakdown:

```
-1(-1+\a-a*~~':a:-1 1"/"=x)$$x: / the solution
                             x: / save input as variable x
                            $   / string (converts to char lists))
                           $    / pad
  (                       )     / do this together
                     "/"=x      / boolean list of x equal to /
                 -1 1           / index into this list
               a:               / save as variable a
           ~~':                 / differ (not-not-each-previous)
         a*                     / multiply by a
       a-                       / subtract from a
     +\                         / sums
   -1                           / (start summing from -1)
-1                              / print to stdout

```
> 0 votes

# Answer
# Japt `-R`, 13 bytes

```
¬®ùZ>'/?°V:V´

```

Try it online!

### Unpacked & How it works

```
Uq mZ{ZùZ>'/?++V:V--

Input: U = string of / and \, V = 0 (default)

Uq                    Split into chars
   mZ{                Map...
        Z>'/?           If the char is rightward (backslash)...
             ++V          Pre-increment V
                :V--      Otherwise, post-decrement V
      Zù                Left-pad the char with spaces to length V

-R                    Join with newline before printing

```
> 0 votes

# Answer
# Pip, 28 bytes

```
FlaIlQ'\PsX++v.lE{PsXv.l--v}

```

With a post decrement operator, this could be way shorter.

Try it online!
> 0 votes

# Answer
# Ruby, ~~47~~ 42 bytes

-5 bytes thanks to Steffan

Inspired by pxeger's Zsh answer.

```
->a{w=0
a.map{" "*(_1<?@?w-=1:~-w+=1)+_1}}

```

Attempt This Online!
> 0 votes

# Answer
# Thunno 2, 11 bytes

```
JCPDḌ€ḷṡ+ðṙ

```

Attempt This Online!

#### Explanation

```
JCPDḌ€ḷṡ+ðṙ  # Implicit input
JC           # Charcodes of input
  PD         # Are prime, duplicate
    Ḍ€ḷ      # Double, complement
       ṡ+    # Add to cumsums
         ðṙ  # Right-justify
             # Implicit output

```
> 0 votes

---
Tags: code-golf, string, ascii-art
---