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
\
/
\
/
\
/


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


Charcoal, 1312 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

• I think ↓¶ = "Move left" in the description isn't right. – Jonathan Allan Sep 14 '17 at 0:50
• @JonathanAllan That's right (newline printed down = move left), although it would probably be clearer to say "print \n/ down" – ASCII-only Sep 14 '17 at 6:47
• I didn't say print \n/ down because I felt that it was more helpful to describe the effect of the code rather than its literal translation. – Neil Sep 14 '17 at 7:43
• (Tongue in cheek: Describing the effect = MyCode - Do the spec). I get it now though the effect is to move left; might be worth saying "Move left (by printing a newline with a downward printing direction)". – Jonathan Allan Sep 14 '17 at 16:55
• Most concise and self-explanatory of all! – j4hangir Sep 16 '17 at 21:48

///, 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 As and Bs 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.

• The right language for the job! Lol – DJMcMayhem Feb 18 '18 at 19:23

Python 2, 55545157 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!

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 Ʋ.)

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


Try it online!

How?

=”\Ḥ’Ä_Ʋ⁶ẋ;" - Link: list of characters, s    e.g. "\\\//\\/"
”\          - literal '\'                         '\'
=            - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
Ḥ         -   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)            ["\", " \", "  \", "  /", " /", " \", "  \", "  /"]


scanl(\x c->drop(sum[1|'/'<-c:x])(' '<$x)++[c])[]  Try it online! MATL, 2319 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: ['\ '; ' \ '; ' \'; ' /'; ' / '; ' \ '; ' / '; ' \ '; ' \']  • One byte off by a slightly different algorithm to get your indices: Try it online! – Sanchises Sep 15 '17 at 21:29 • @Sanchises Thanks for your very appropriate edits! – Luis Mendo Sep 15 '17 at 21:31 Perl 5, 44 bytes 42 bytes of code + 2 for -F flag say$"x($s+=$\eq$_&&$#i**m|/|).($\=$_)for@F


Try it online!

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

• Doesn't work for /\\/\\/. – Neil Sep 14 '17 at 9:57
• Ç¥.¥0<.SηOv¹Nèy<ú, sobbing in binary – Magic Octopus Urn Sep 15 '17 at 18:21
• Well done! 👏👏 – Salocor May 31 at 0:47

JavaScript (ES8), 6659 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!

C# (.NET Core), 7488827877 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
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
)
)

• Doesn't work for /\\/\\/. – Neil Sep 14 '17 at 9:58
• @Neil thank you for pointing that out! Fixed. – Grzegorz Puławski Sep 14 '17 at 10:06
• I know it's been a while, but you can save a byte by changing s.Take(i).Sum(y=>y<92?-1:1)+(x-s[0])/45+1 to (x-s[0])/45-~s.Take(i).Sum(y=>y<92?-1:1) – Kevin Cruijssen Feb 9 '18 at 13:33
• Nice one @KevinCruijssen ! – Grzegorz Puławski Feb 12 '18 at 9:57

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. pdoesn'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)?

• I was able to save two bytes by using gsub instead of using gmatch. c=0(...):gsub(".",function(s)c=c+(p==s and(s=="/"and-1or 1)or 0)p=s print((" "):rep(c)..s)end) – QuertyKeyboard Sep 14 '17 at 21:03
• Well, not that it matters. You could've easily saved two bytes by changing gmatch(".") to gmatch"." like you did in your next answer. – QuertyKeyboard Sep 14 '17 at 21:23
• @QuertyKeyboard That's weird... I actually used gsub exactly like this in the first version of this code, but then switched to gmatch instead because it somehow turned out shorter. I don't know what I did different though, the file is overwritten unfortunately. – Jonathan S. Sep 14 '17 at 21:50

R, 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.

• huh. I took a quite different approach for 119 bytes which makes me wonder if we could combine our approaches. (nice use of diffinv ;) Also you can set y=x>")" for -1 byte – Giuseppe Sep 14 '17 at 14:07
• @Giuseppe You should post that as a separate answer, it's a different enough approach. Yours is a nice way of avoiding having to do strsplit, which is always a killer. You can also make use of the famous diffinv! – user2390246 Sep 14 '17 at 14:13
• Also I think if you put library(methods) in the header (which should be OK w/o penalty since that package is part base R), you can use el. Also, diffinv turned out to be just as long as cumsum! :) – Giuseppe Sep 14 '17 at 14:34
• Yes, I was just realising that too, it doesn't quite work in that context – user2390246 Sep 14 '17 at 14:40
• well, I came up with a workaround, but yeah, that *S screws things up. – Giuseppe Sep 14 '17 at 14:41

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
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>

• I always upvote brain-flak. :D – DJMcMayhem Sep 14 '17 at 19:33

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.

• Which Ruby version? The 2.3.3 I have demands parenthesis around parameter when code block follows: .each_cons(2){…}. In change you can save by replacing .each_char.chars. – manatwork Sep 14 '17 at 19:59
• @manatwork My ruby version is 2.4.1. Thanks for the suggestion about chars, I didn't know about that one. – Pazzaz Sep 14 '17 at 20:13
• You can save another two bytes by moving i+= to the beginning of the nested ternary expression, and ending it with -1:1:0. – benj2240 Feb 13 '18 at 20:31

Java 8, 121118110109 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

• 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;} – Nevay Sep 14 '17 at 10:31
• @Nevay Thanks. I knew it could be shortened with some bitwise operations, but couldn't figure it out. Mainly because I forgot about trying the effects of >>/>>>/<<... I had only checked some things with &/|/~/^..>.> – Kevin Cruijssen Sep 14 '17 at 11:45

C (GCC), 137134 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

• You can replace c=='\0' with !c for the same effect. – ATaco Sep 14 '17 at 3:57
• Awesome thanks just updated the solution! – Asleepace Sep 14 '17 at 4:46
• Can you use printf("%*s%c", n, "", c) to print the the char c with n leading spaces? – Digital Trauma Sep 14 '17 at 5:29
• I'm pretty sure you can save few bytes by replacing (c!=n) with c-n and rearranging ternary expressions. Same with (c=='/'). Also, you can replace '/' with literal number 47. I think it is 7 bytes in total. – user72349 Sep 14 '17 at 6:50
• 78 bytes – ASCII-only Sep 14 '17 at 7:26

C, 60 bytes

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


Try it online!

• -1 no TIO link :P – ASCII-only Sep 14 '17 at 23:38
• TIO – ASCII-only Sep 14 '17 at 23:45
• @ASCII-only you're welcome – Stan Strum Sep 25 '17 at 2:48

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¶$34  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. Pyth, 28 bytes j.u+?qeNY?>Y\/+PNdPPNPNYtzhz  Try it online! R, 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. • Just been pondering this some more, I think there is an error in your algorithm: TIO – user2390246 Sep 14 '17 at 14:48 • @user2390246 I fixed it! I had some misplaced parentheses, but now the diffinv definitely won't work here. – Giuseppe Sep 14 '17 at 20:04 • what about tio.run/##HYy7DsIwEAR/… – JayCe Jun 4 '18 at 1:44 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! • Welcome to the site! :) – DJMcMayhem Sep 14 '17 at 20:09 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.

• I was disappointed to find that my gsub trick I commented in your other answer didn't quite work for this one. It actually ended up adding one byte. However, I wouldn't give up that easily. First, I tried to store gsub as a variable to shorten the code. To my surprise, my code was exactly the same amount of bytes - 88. However, I realized that with gsub being saved, my gsub trick could now work! Here's my code that shaved off 4 bytes: s=""g=s.gsub g(...,".",function(c)s=g(g(g(s,"\\"," "),"/?$",c)," /","/")print(s)end) – QuertyKeyboard Sep 14 '17 at 21:22 • @QuertyKeyboard Yup, I also tried storing gsub in a variable before the loop and then using it instead of writing gsub three time, and I was just as surprised to see it making absolutely no difference. Combining the "gsub instead of loop" and "store gsub" tricks is really neat, didn't think of that one! Thanks! :) – Jonathan S. Sep 14 '17 at 21:53 Dyalog APL, 31 bytes {↑⍵,¨⍨' '/¨⍨{⍵-⍨+\¯1+2×⍵}⍵='\'}  Try it here! • {↑⍵↑¨⍨a-1-+\¯1*a←⍵='\'} – ngn Feb 9 '18 at 0:19 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 /).

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 previous value) to i (the indent). 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. 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'  brainfuck, 98 bytes ++++++++[->++++<]<<<,[[->+++++++++++<<+>]>-----[>+>+<<[-]]>-[->>.<+<]>[-<+>]<<<<.[-]>++++++++++.,]  Try it online! 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)  Pyth - 33 bytes First attempt, will golf. jsMC,*L;+ZsM._*VqVtzztMxL"/ \\"zz  • my first attempt 32 bytes – Stan Strum Sep 15 '17 at 19:24 • second attempt 28 bytes – Stan Strum Sep 15 '17 at 19:26 • third attempt 26 bytes – Stan Strum Sep 16 '17 at 3:27 • pinged @maltysen – Stan Strum Sep 25 '17 at 2:51 • @StanStrum at this point, u can just post it as your own answer – Maltysen Sep 25 '17 at 17:10 Perl, 40 + 2 bytes /\//&&$.--,say($"x$.,$_),/\\/&&$.++for@F


You need the -F flag.