En tant que programmeur, vous avez probablement entendu parler de barres obliques et de barres obliques inversées. Mais avez-vous entendu parler de slashs? C'est à ce moment-là que vous prenez une série de barres obliques, connectez leurs extrémités et dessinez-les en descendant.

Pour le défi d'aujourd'hui, vous devez écrire un programme ou une fonction qui prend une chaîne composée uniquement de barres obliques et qui les affiche toutes en une ligne. Ce sera beaucoup plus clair si vous voyez un exemple. Étant donné la chaîne \\\//\/\\, vous devriez générer:

\
 \
  \
  /
 /
 \
 /
 \
  \

Voici quelques clarifications:

• Il doit y avoir une barre oblique par ligne.

• La première ligne aura 0 espaces de début.

• Pour chaque paire de barres obliques:

  • S'ils sont différents les uns des autres, ils seront dessinés dans la même colonne. Par exemple, \/donnera:

    \
    /
    

  • S'ils sont identiques, le caractère inférieur est orienté dans la direction indiquée , c'est-à-dire qu'il se déplace vers la droite pour une barre oblique inverse et vers la gauche pour une barre oblique. Donc \\//va donner

    \
     \
     /
    /
    

• Chaque ligne peut avoir des espaces de fin supplémentaires, à condition que cela ne modifie pas l'apparence visuelle de la sortie. Il est également possible d’acquérir jusqu’à une nouvelle ligne précédente et suivante. Les espaces supplémentaires ne sont pas autorisés !

Afin de garder cela plus simple, vous pouvez supposer que la chaîne ne contiendra jamais trop de barres obliques. En d'autres termes, aucun préfixe de l'entrée ne contiendra plus de barres obliques que de barres obliques inverses. Une entrée telle que \\////ou //ne sera jamais donnée. Cela signifie également que chaque entrée commencera par une barre oblique inverse.

Si votre entrée est considérée comme un littéral de chaîne, vous pouvez échapper les barres obliques inverses si cela est nécessaire. En outre, vous ne devrez jamais gérer une entrée vide ou contenant des caractères autres qu'une barre oblique.

Vous pouvez sortir par n'importe quel format raisonnable .

Comme d’habitude, il s’agit d’un défi de code-golf . Essayez donc de trouver la solution la plus courte possible, même si vous choisissez une langue qui est assez difficile. Des points bonus pour expliquer toutes les techniques intéressantes que vous utilisiez pour enlever des octets!

Exemples

#Input
\\\\\\\\\\\

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

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

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


#Input
\/\/\/

#Output
\
/
\
/
\
/

GNU Sed, 20

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

Notez que ^Let ^Hsont des caractères littéraux d’alimentation et de retour arrière (0x12 et 0x8).

Cette réponse fonctionne en déplaçant le curseur en utilisant des caractères de retour arrière et de saut de page. Les barres obliques / barres obliques inverses ne sont pas complétées par des espaces - Une incertitude à ce sujet disqualifie cette réponse. Cela ne fonctionne pas dans TIO, mais cela a l'air bien sous les terminaux courants tels que xtermet gnome-terminal.

Recréez ce script sed comme suit:

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

Exécutez-le comme suit:

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

$ 

Explication:

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

Charbon de bois , 13 12 11 octets

ＦＳ¿⁼ι/↓¶/↘ι

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Soutient extra //s. Explication:

 Ｓ              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

Python 2 , 55 54 51 57 53 octets

^{-3 octets (et un correctif) grâce à Felipe Nardi Batista}

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

Essayez-le en ligne!

/// , 119 octets

/// n'a pas de commande d'entrée, l'entrée doit donc être intégrée au programme. Pour celui-ci, la chaîne d'entrée est simplement ajoutée, sans échappement nécessaire.

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

• Essayez-le en ligne!
• Avec -doption (état du programme indiqué entre parenthèses avant l'exécution de chaque commande).

Comment ça fonctionne

• Dans ce qui suit, une entrée de \\/\//sera ajoutée au programme pour démonstration.
• ␤ est utilisé pour représenter les nouvelles lignes dans le code en ligne.

Les abréviations

Le début /=/\/\///M/␤|%%=N/%|||=C/BA=du programme contient des substitutions aux abréviations de golf.

• =se développe vers //, Mvers ␤|%%, Nvers %|||et Cvers BA.

• Après cela, le programme actuel devient

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

Recodage des entrées

L'étape suivante transforme la chaîne d'entrée ajoutée en une forme plus utilisable. Comme il est entièrement composé de deux caractères de commande ///, cela évite de modifier le programme de base.

• La première substitution substantielle /\/\\/\/BA\\/, remplace la chaîne /\par /BA\.
  • Le programme de base ne contient pas /\à ce moment, donc cette substitution ne l'affecte pas.
  • Cependant, cela divise la chaîne d’entrée ajoutée en séquences de \s suivies de séquences de /s, qui, combinées ABAau bout du programme de base, permettent de le parcourir avec les substitutions suivantes.
  • En incluant le ABApréfixe avant, l'exemple de chaîne d'entrée devient ABA\\/BA\//.
• La substitution suivante /BA\\/BAbBA/, remplace BA\par BAbBA.
  • Etant donné que les substitutions /// sont répétées jusqu'à ce qu'elles ne correspondent plus, cela effectue une itération sur tous les \s de la chaîne d'entrée, qui devient désormais préfixe.ABAbBAbBA/BAbBA//
• De même, les /B\A\//BAfBA/modifications apportées BA/à BAfBA, itérant à travers le par /.
  • La fuite \dans cette substitution est nécessaire car sinon elle serait mutilée par la précédente.
  • L'entrée est maintenant devenue ABAbBAbBAfBABAbBAfBAfBA.
• Next /AB//supprime certaines parties superflues de l'encodage, le transformant en AbBAbBAfBAbBAfBAfBA.
  • Cela supprime également ABde la /|/AB\\/substitution plus tard dans le programme, ce qui était nécessaire pour la protéger de ce qui précède la /\manipulation.
  • À ce stade, chaque \chaîne d'entrée d'origine est devenue AbBet chaque chose /est devenue AfB. ( bet fse tenir pour aller et retour.) Il y a un vagabond Aà la fin.
• Les deux substitutions suivantes remplacent tous les As et Bs par des fragments de programme à exécuter dans la dernière étape. Dans les chaînes de remplacement, %s et |s codent ce qui deviendra respectivement /s et \s. Cela a deux avantages:
  • Contrairement à /et \, les %s et |s n'ont pas besoin de s'échapper pour être copiés.
  • Les chaînes de remplacement évitent de contenir la sous-chaîne /\, qui aurait autrement été endommagée par les manipulations précédentes.
• Après cela, la substitution /|/\\/(anciennement /|/AB\\/) décode maintenant le |s, après quoi le suivant /%/|//est devenu /%/\//et décode le %s.

Structure du programme au stade final

À ce stade, le programme de base a exécuté toutes ses substitutions et il ne reste que l'encodage par programme de la chaîne d'entrée.

• Chaque caractère saisi est devenu un sous-programme

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

  (nouvelle ligne), où *représente soit fun original /, soit bun original \.

• Il existe également une commande de substitution incomplète /␤\//xyà la fin du programme, qui n'aura d'effet que sur la nécessité de fournir une /substitution nécessaire au sous-programme précédent.

Sous-chaîne partagée

Avant le début de l'itération finale à travers les sous-programmes, une sous-chaîne traverse la limite après le sous-programme de chaque caractère du formulaire \/␤/.

• Ces sous-chaînes sont utilisées en tant qu'état global partagé. Toutes les substitutions restantes du programme les manipuleront de manière identique et en parallèle, de telle sorte qu'à la fin du sous-programme de chaque caractère saisi, sa copie de cette sous-chaîne partagée (à l'exception de la finale /, qui ancre les substitutions) sera exécutée pour imprimer la ligne correspondante. personnage.
• La version initiale de la sous-chaîne représente l’impression d’une ligne contenant juste /, qui est la "ligne précédente" imaginaire appropriée pour imprimer le premier caractère saisi au début de sa ligne.
• En général, pendant les étapes d'impression, la sous-chaîne partagée est composée d'un nombre d'espaces, \\ou d' \/une nouvelle ligne et d'un texte suivant /.

Exécuter un sous-programme de personnage

Plusieurs des substitutions suivantes contiennent des éléments supplémentaires à l' \intérieur pour les empêcher d'être appariés et mutilés (y compris d'autres copies dans d'autres sous-programmes). La réalisation de c'est aussi la raison pour laquelle les deux xet ysont nécessaires.

• La première substitution dans un sous-programme de caractères, /␤\//xyf\z/ou /␤\//xyb\z/, entraîne la ␤/fin de la sous-chaîne partagée xyfzou xybz, immédiatement après le \/ou \\.
• La substitution /\\\\x\y/ /remplace \\xypar un espace, et la substitution /\\\/x\y//remplace \/xypar rien.
  • Ils s'appliquent lorsque le caractère saisi précédemment imprimé était respectivement un \ou /.
  • La sous-chaîne partagée contient maintenant le nombre approprié d'espaces pour imprimer un \suivant, suivi de fzou bz.
• La substitution / \fz/\\\/␤\//remplace ​ fzpar \/␤/et /b\z/\\\\␤\//remplace bzpar \\␤/.
  • Ils s'appliquent lorsque le caractère d'entrée actuel est /ou \, respectivement.
  • Le premier mange un espace supplémentaire pour placer /correctement.
    • Si cet espace est manquant (c’est-à-dire que l’entrée enfreint la condition de préfixe), les substitutions suivantes sont mal interprétées, générant beaucoup de courrier indésirable et touchant généralement ///une boucle qui est une boucle infinie.
  • Chacun ajoute la commande correcte pour imprimer son propre caractère et rétablit l'original ␤/à la fin de la sous-chaîne partagée.
• Le sous-programme de caractères a maintenant atteint sa copie de la sous-chaîne partagée, qui est prête à imprimer sa ligne.

Une fois que le dernier sous-programme a été exécuté, il ne reste que le programme /␤\//xy. Comme il s’agit d’une substitution incomplète avec une finale manquante /, le programme la saute et s’arrête normalement.

Gelée , 14 octets

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

Un programme complet imprimant le résultat.

Essayez-le en ligne!

Comment?

=”\ðḤ’+\_⁸⁶ẋż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.

Haskell , 49 octets

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

Essayez-le en ligne!

Perl 5 , 44 octets

42 octets de code + 2 pour le -Fdrapeau

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

Essayez-le en ligne!

JavaScript (ES8), 66 59 63 octets

7 octets enregistrés grâce à Justin Mariner
+4 octets à corriger /\\/\\/(remarqué par Neil )

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

Essayez-le en ligne!

MATL , 23 19 18 octets

1 octet sur grâce à @Sanchises

fGqoEq1yd~h*YsGZ?c

L'entrée est une chaîne entre guillemets simples.

Essayez-le en ligne! Ou vérifiez les cas de test: 1 , 2 , 3 .

Explication

Considérez l'entrée '\\\//\/\\'comme un exemple.

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: ['\  ';
                 ' \ ';
                 '  \';
                 '  /';
                 ' / ';
                 ' \ ';
                 ' / ';
                 ' \ ';
                 '  \']

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

-1 octet grâce à Kevin Cruijssen

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

Sort une collection de chaînes, une pour chaque ligne. Le nombre d'octets comprend également:

using System.Linq;

Essayez-le en ligne!

Explication de la réponse sur 77 octets:

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

05AB1E , 14 octets

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

Essayez-le en ligne!

Explication

Ç                # 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

R , 122 121 octets

-1 octet grâce à 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="")

Essayez-le en ligne!

Avec des espaces supplémentaires:

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="")
}

Explication: Cette réponse est basée sur l'observation que le nombre d'espaces en tête change de chaque ligne de -1, plus le nombre d'espaces /des lignes précédentes et actuelles.

Si nous avons N barres, la variable yest un vecteur de longueur N, avec 1 pour chaque position avec \, sinon 0. Par conséquent, nous calculons pour obtenir le changement du nombre d'espaces en tête par ligne y[1:(N-1)] + y[2:N] - 1. La fonction diffinvconvertit ces différences en une séquence commençant par 0. Le reste consiste simplement à assembler chaque ligne en tant que nombre requis d'espaces de fin, suivie de la barre oblique appropriée et d'un retour à la ligne.

Brain-Flak , 175 octets (174 caractères + 1 drapeau)

Courir avec un -cdrapeau.

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

Essayez-le en ligne!

Explication

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

Ruby , 80 76 octets

-4 octets grâce à manatwork

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

Essayez-le en ligne!

Explication:

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.

Java 8, 121 118 110 109 102 octets

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 octets grâce à la magie au niveau des bits de @ Nevay . :)

Explication:

Essayez ici.

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

C (GCC), 137 134 97 octets

Essayez-le en ligne!

• 3 octets merci ATaco

• 37 octets grâce à 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);}}

Rien de bien plus qu'une simple fonction récursive qui prend une chaîne et affiche les barres obliques; notez que l'entrée doit d'abord échapper aux barres obliques inverses.

Usage

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

Ungolfed

Ceci est pour l’ancienne réponse, consultez le lien d’essai en ligne pour la mise à jour!

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);
}

Sortie

C, 60 octets

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

Essayez-le en ligne!

Retina , 47 octets

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

Essayez-le en ligne! Le lien inclut des cas de test. Explication:

^|\\
 $&

Ajoutez un espace au début et à la fin de chaque ligne \.

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

Considérons les deux premiers caractères de la chaîne. Si le premier est un, /le retrait doit être décrémenté; ceci est réalisé en incluant l'espace précédent dans la capture (qui existe toujours car le premier étage l'a ajouté); si le second est un, \\il doit être incrémenté; ceci est réalisé en incluant l'espace que la première étape a ajouté dans la capture. Après avoir donné le deuxième tiret correct, la scène est répétée pour les deuxième et troisième caractères, etc.

m`^ 

Supprimer le retrait supplémentaire.

J'ai écrit une version de 94 octets qui (comme ma réponse Charcoal) autorise toute combinaison de barres obliques: essayez-le en ligne! Explication:

.$
¶$.`$* $&

Faites rouler la balle en prenant la dernière barre oblique et indentez-la à la même position sur sa propre ligne.

/
 /

Préfixez les espaces à toutes les barres obliques afin qu'elles puissent être capturées.

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

Prenez à plusieurs reprises la dernière barre oblique de l'entrée et alignez-la sur sa propre ligne avec la barre oblique de la ligne ci-dessous.

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

Supprimez tout retrait laissé.

G`.

Supprimez l'entrée maintenant vide.

Lua , 96 octets

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

Essayez-le en ligne!

Le plus court que j'ai pu trouver à Lua. La saisie est effectuée à partir de la ligne de commande.

Cela utilise quelques astuces:

1. (...):gmatch(
   Cela devrait être la forme la plus courte pour obtenir une seule chaîne dans un programme Lua à partir de la ligne de commande. L' ...expression en Lua capture tout paramètre en excès dans une fonction non spécifiée dans la déclaration de fonction et est utilisé pour les variables. Puisque le corps principal d'un programme Lua est appelé comme une fonction avec les arguments de la ligne de commande comme paramètres, les arguments de la ligne de commande se retrouveront dans ....
   Les parenthèses qui l'entourent transforment l' ...expression potentiellement à valeurs multiples en une expression à valeur unique. Considérez cet exemple (quelque peu surprenant):

   function multipleReturnValues()
       return "abc", "def"
   end
   print(  multipleReturnValues()  ) --This prints: abc    def
   print( (multipleReturnValues()) ) --This prints: abc

2. L'analyseur Lua n'a besoin d'aucun terminateur de ligne, ni même d'espacement entre les instructions, tant que les jetons des deux instructions peuvent être clairement séparés et qu'il n'existe qu'une seule interprétation du texte qui soit du code Lua valide.
3. Abuser and/ orpour "si x alors valeur1 sinon valeur2" logique.
   L' andopérateur de Lua retourne son premier argument s'il s'agit de fausseté; sinon, il retourne son deuxième argument. L' oropérateur retourne son premier argument s'il s'agit de la vérité; sinon, le deuxième argument.
4. pn'a pas besoin d'initialisation.
   p==sdoit toujours être faux lors de la première exécution de la boucle, quelle que soit l'entrée. Si vous ne définissez paucune valeur avant d'entrer dans la boucle (en la quittant nil), cela sera possible et vous économiserez des octets.

Quelqu'un peut-il jouer au golf (à Lua)?

Pyth , 28 octets

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

Essayez-le en ligne!

R , 119 octets

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="")

Essayez-le en ligne!

Cela diffère quelque peu de la réponse de user2390246 . Ils parcourent chacun la chaîne en imprimant un certain nombre de caractères d'espace, puis le /\caractère approprié .

Cependant, j’évitais de scinder la chaîne, préférant remplacer les caractères par leur valeur de codage UTF-8, ce qui me permettait alors de calculer directement les nombres, ce qui ne me permettait d’économiser que quelques octets.

C # (.NET Core) , 60/65 octets

J'ai essayé la version C # plus courte

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

comme il a été dit: "Cela signifie également que chaque entrée commencera par une barre oblique inverse." Ou un peu plus longtemps qui résolvent de commencer "/"

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

Essayez-le en ligne!

Lua , 88 84 octets

Version améliorée (-4 octets grâce à QuertyKeyboard)

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

Essayez-le en ligne!

Version originale (88 octets)

Une autre tentative à Lua, cette fois avec une approche complètement différente en utilisant la manipulation de chaîne au lieu d'une variable de compteur.

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

Il y a une chose intéressante dans le code: (...):gmatch"."
cela utilise quelques bizarreries dans l'analyseur Lua. Lorsque Lua rencontre un morceau de code dans le formulaire func "string", il le convertit en func("string"). Cela permet d'écrire print "string"pour imprimer une chaîne constante et cela ne fonctionne qu'avec un seul littéral de chaîne après la fonction. Tout le reste donnera une erreur de syntaxe. Cependant, ce sucre syntaxique fonctionne également avec les appels de fonction au milieu d'une expression, et plus surprenant, il fonctionne parfaitement avec l' :appel de méthode sucre syntaxique. Donc à la fin, Lua interprétera le code comme suit:

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

Si quelqu'un peut trouver un moyen de supprimer l'un des trois appels gsub, dites-le-moi.

Pyth - 33 octets

Première tentative, va jouer au golf.

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

Essayez-le en ligne ici .

Perl, 40 + 2 octets

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

Vous avez besoin du -Fdrapeau.

Perl, 34 38 + 1 octets

gérer les deux cas

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

être couru avec -poption

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

EDIT: le commentaire suivant ne fonctionne pas quand le premier caractère est /

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

cependant, la sortie sera décalée d’un caractère à droite si le premier caractère est \

VBA (Excel), 181 octets

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

Pyth , 24 21 octets

Port de la réponse de Rod .

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

Essayez-le en ligne!

SOGL V0.12 , 16 13 octets

{└=-:↕PFoF┘=+

Essayez-le ici! - attend des entrées sur la pile, donc pour plus de facilité d'utilisation ,est ajouté

Dyalog APL, 31 octets

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

Essayez-le ici!