60
\$\begingroup\$

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

44 Answers 44

20
\$\begingroup\$

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
\$\endgroup\$
14
\$\begingroup\$

Charcoal, 13 12 11 bytes

FS¿⁼ι/↓¶/↘ι

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

 S              Input string
F               Loop over each character
  ¿             If
    ι           Current character
   ⁼            Equals
     /          Literal /
      ↓¶        Move left
      ↓ /       Print a / downwards
         ↘ι     Else it's a \ so print that down and right
\$\endgroup\$
  • \$\begingroup\$ I think ↓¶ = "Move left" in the description isn't right. \$\endgroup\$ – Jonathan Allan Sep 14 '17 at 0:50
  • \$\begingroup\$ @JonathanAllan That's right (newline printed down = move left), although it would probably be clearer to say "print \n/ down" \$\endgroup\$ – ASCII-only Sep 14 '17 at 6:47
  • \$\begingroup\$ 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. \$\endgroup\$ – Neil Sep 14 '17 at 7:43
  • 1
    \$\begingroup\$ (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)". \$\endgroup\$ – Jonathan Allan Sep 14 '17 at 16:55
  • \$\begingroup\$ Most concise and self-explanatory of all! \$\endgroup\$ – j4hangir Sep 16 '17 at 21:48
14
\$\begingroup\$

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!

\$\endgroup\$
10
+50
\$\begingroup\$

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

\$\endgroup\$
  • 1
    \$\begingroup\$ The right language for the job! Lol \$\endgroup\$ – DJMcMayhem Feb 18 '18 at 19:23
6
\$\begingroup\$

Jelly, 14 bytes

=”\ðḤ’+\_⁸⁶ẋżY

A full program printing the result.

Try it online!

How?

=”\ðḤ’+\_⁸⁶ẋżY - Link: list of characters, s    e.g. "\\\//\\/"
 ”\            - literal '\'                         '\'
=              - equal? (call this e)                [1, 1, 1, 0, 0, 1, 1, 0]
   ð           - new dyadic chain f(e, s)
    Ḥ          - double                              [2, 2, 2, 0, 0, 2, 2, 0]
     ’         - decrement                           [1, 1, 1,-1,-1, 1, 1,-1]
      +\       - cumulative reduce with addition     [1, 2, 3, 2, 1, 2, 3, 2]
         ⁸     - chain's left argument, e            [1, 1, 1, 0, 0, 1, 1, 0]
        _      - subtract (# of leading spaces)      [0, 1, 2, 2, 1, 1, 2, 2]
          ⁶    - literal ' '                         ''
           ẋ   - repeat                              [""," ","  "," "," "," ","  ","  "]
            ż  - zip with s                          [["",'\'],[" ",'\'],["  ",'\'],["  ",'/'],[" ",'/'],[" ",'\'],["  ",'\'],["  ",'/']]
             Y - join with newlines                  ["",'\','\n'," ",'\','\n',"  ",'\','\n',"  ",'/','\n'," ",'/','\n'," ",'\','\n',"  ",'\','\n',"  ",'/']
               - implicit print - this smashes the lists (shown as "..." above) and the characters (shown as '...' above) together.
\$\endgroup\$
6
\$\begingroup\$

Haskell, 49 bytes

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

Try it online!

\$\endgroup\$
5
\$\begingroup\$

Perl 5, 44 bytes

42 bytes of code + 2 for -F flag

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

Try it online!

\$\endgroup\$
5
\$\begingroup\$

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!

\$\endgroup\$
5
\$\begingroup\$

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: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']
\$\endgroup\$
  • \$\begingroup\$ One byte off by a slightly different algorithm to get your indices: Try it online! \$\endgroup\$ – Sanchises Sep 15 '17 at 21:29
  • \$\begingroup\$ @Sanchises Thanks for your very appropriate edits! \$\endgroup\$ – Luis Mendo Sep 15 '17 at 21:31
5
\$\begingroup\$

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
        )
    )
\$\endgroup\$
  • 3
    \$\begingroup\$ Doesn't work for /\\/\\/. \$\endgroup\$ – Neil Sep 14 '17 at 9:58
  • \$\begingroup\$ @Neil thank you for pointing that out! Fixed. \$\endgroup\$ – Grzegorz Puławski Sep 14 '17 at 10:06
  • 1
    \$\begingroup\$ 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) \$\endgroup\$ – Kevin Cruijssen Feb 9 '18 at 13:33
  • \$\begingroup\$ Nice one @KevinCruijssen ! \$\endgroup\$ – Grzegorz Puławski Feb 12 '18 at 9:57
4
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ Doesn't work for /\\/\\/. \$\endgroup\$ – Neil Sep 14 '17 at 9:57
  • \$\begingroup\$ Ç¥.¥0<.SηOv¹Nèy<ú, sobbing in binary \$\endgroup\$ – Magic Octopus Urn Sep 15 '17 at 18:21
3
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ 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 \$\endgroup\$ – Giuseppe Sep 14 '17 at 14:07
  • \$\begingroup\$ @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! \$\endgroup\$ – user2390246 Sep 14 '17 at 14:13
  • 1
    \$\begingroup\$ 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! :) \$\endgroup\$ – Giuseppe Sep 14 '17 at 14:34
  • \$\begingroup\$ Yes, I was just realising that too, it doesn't quite work in that context \$\endgroup\$ – user2390246 Sep 14 '17 at 14:40
  • \$\begingroup\$ well, I came up with a workaround, but yeah, that *S screws things up. \$\endgroup\$ – Giuseppe Sep 14 '17 at 14:41
3
\$\begingroup\$

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
{({}<>)(({})(())){({}[()]<([{}]())>)}{}{<>{}<>(<{}>)}{}<>}<>
\$\endgroup\$
  • \$\begingroup\$ I always upvote brain-flak. :D \$\endgroup\$ – DJMcMayhem Sep 14 '17 at 19:33
3
\$\begingroup\$

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.
\$\endgroup\$
  • 1
    \$\begingroup\$ 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. \$\endgroup\$ – manatwork Sep 14 '17 at 19:59
  • \$\begingroup\$ @manatwork My ruby version is 2.4.1. Thanks for the suggestion about chars, I didn't know about that one. \$\endgroup\$ – Pazzaz Sep 14 '17 at 20:13
  • \$\begingroup\$ You can save another two bytes by moving i+= to the beginning of the nested ternary expression, and ending it with -1:1:0. \$\endgroup\$ – benj2240 Feb 13 '18 at 20:31
3
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ 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;} \$\endgroup\$ – Nevay Sep 14 '17 at 10:31
  • \$\begingroup\$ @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 &/|/~/^..>.> \$\endgroup\$ – Kevin Cruijssen Sep 14 '17 at 11:45
3
\$\begingroup\$

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

enter image description here

\$\endgroup\$
  • \$\begingroup\$ You can replace c=='\0' with !c for the same effect. \$\endgroup\$ – ATaco Sep 14 '17 at 3:57
  • \$\begingroup\$ Awesome thanks just updated the solution! \$\endgroup\$ – Asleepace Sep 14 '17 at 4:46
  • \$\begingroup\$ Can you use printf("%*s%c", n, "", c) to print the the char c with n leading spaces? \$\endgroup\$ – Digital Trauma Sep 14 '17 at 5:29
  • \$\begingroup\$ 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. \$\endgroup\$ – user72349 Sep 14 '17 at 6:50
  • 1
    \$\begingroup\$ 78 bytes \$\endgroup\$ – ASCII-only Sep 14 '17 at 7:26
3
\$\begingroup\$

C, 60 bytes

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

Try it online!

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

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.

\$\endgroup\$
2
\$\begingroup\$

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)?

\$\endgroup\$
  • \$\begingroup\$ 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) \$\endgroup\$ – QuertyKeyboard Sep 14 '17 at 21:03
  • \$\begingroup\$ Well, not that it matters. You could've easily saved two bytes by changing gmatch(".") to gmatch"." like you did in your next answer. \$\endgroup\$ – QuertyKeyboard Sep 14 '17 at 21:23
  • \$\begingroup\$ @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. \$\endgroup\$ – Jonathan S. Sep 14 '17 at 21:50
2
\$\begingroup\$

Pyth, 28 bytes

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

Try it online!

\$\endgroup\$
2
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ Just been pondering this some more, I think there is an error in your algorithm: TIO \$\endgroup\$ – user2390246 Sep 14 '17 at 14:48
  • \$\begingroup\$ @user2390246 I fixed it! I had some misplaced parentheses, but now the diffinv definitely won't work here. \$\endgroup\$ – Giuseppe Sep 14 '17 at 20:04
  • \$\begingroup\$ what about tio.run/##HYy7DsIwEAR/… \$\endgroup\$ – JayCe Jun 4 '18 at 1:44
2
\$\begingroup\$

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!

\$\endgroup\$
  • \$\begingroup\$ Welcome to the site! :) \$\endgroup\$ – DJMcMayhem Sep 14 '17 at 20:09
2
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ 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) \$\endgroup\$ – QuertyKeyboard Sep 14 '17 at 21:22
  • \$\begingroup\$ @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! :) \$\endgroup\$ – Jonathan S. Sep 14 '17 at 21:53
1
\$\begingroup\$

Pyth - 33 bytes

First attempt, will golf.

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

Try it online here.

\$\endgroup\$
  • \$\begingroup\$ my first attempt 32 bytes \$\endgroup\$ – Stan Strum Sep 15 '17 at 19:24
  • \$\begingroup\$ second attempt 28 bytes \$\endgroup\$ – Stan Strum Sep 15 '17 at 19:26
  • \$\begingroup\$ third attempt 26 bytes \$\endgroup\$ – Stan Strum Sep 16 '17 at 3:27
  • \$\begingroup\$ pinged @maltysen \$\endgroup\$ – Stan Strum Sep 25 '17 at 2:51
  • \$\begingroup\$ @StanStrum at this point, u can just post it as your own answer \$\endgroup\$ – Maltysen Sep 25 '17 at 17:10
1
\$\begingroup\$

Perl, 40 + 2 bytes

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

You need the -F flag.

\$\endgroup\$
1
\$\begingroup\$

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 \

\$\endgroup\$
  • 1
    \$\begingroup\$ Doesn't work for /\\/\\/. \$\endgroup\$ – Neil Sep 14 '17 at 9:59
  • \$\begingroup\$ With the updated question your original 34 solution is now perfectly valid \$\endgroup\$ – Ton Hospel Feb 8 '18 at 19:35
1
\$\begingroup\$

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
\$\endgroup\$
  • 1
    \$\begingroup\$ You can golf this down significantly without changing your algorithm by taking advantage of the autoformatting nature of Excel VBA and by use of [...] notation: I got it down to 128 Bytes Sub q For x=1To[Len(A1)] c=Mid([A1],x,1) If c="\"Then Debug.?b;c:b=b+" " If c="/"Then b=Left(b,Len(b)-1):Debug.?b;c Next End Sub \$\endgroup\$ – Taylor Scott Sep 15 '17 at 17:50
  • \$\begingroup\$ Thank you for golfing my script. I learned something from this and will apply in the future. :) Didn't know I can use that to fetch data directly to the cells. Thanks again :) \$\endgroup\$ – remoel Sep 18 '17 at 4:42
1
\$\begingroup\$

Pyth, 24 21 bytes

Port from Rod's answer.

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Invalid, prints [extra leading space on the first line if the string starts with \. BTW where is your code? \$\endgroup\$ – Mr. Xcoder Sep 14 '17 at 12:59
  • \$\begingroup\$ @Mr.Xcoder fixed \$\endgroup\$ – Felipe Nardi Batista Sep 14 '17 at 13:05
1
\$\begingroup\$

SOGL V0.12, 16 13 bytes

{└=-:↕PFoF┘=+

Try it Here! - expects input on the stack, so for ease-of-use , is added

\$\endgroup\$
1
\$\begingroup\$

Dyalog APL, 31 bytes

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

Try it here!

\$\endgroup\$
  • \$\begingroup\$ {↑⍵↑¨⍨a-1-+\¯1*a←⍵='\'} \$\endgroup\$ – ngn Feb 9 '18 at 0:19

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.