Écrivez un programme ou une fonction qui accepte une chaîne de ligne unique non vide. La chaîne sera soit zéro ou plusieurs espaces suivis d'une période (une particule ), comme .ou          ., ou la chaîne sera une séquence d'une ou plusieurs barres obliques avant et arrière (une vague ) qui pourraient commencer par l'une ou l'autre, telle comme \ou /\/ou \/\/\/\/\/\/.

Dans les deux cas, propagez la particule / l'onde vers la droite d'une unité.

Plus précisément, dans le cas des particules, insérez un espace avant le ., en le déplaçant d'un endroit vers la droite, puis sortez la chaîne résultante. Par exemple:

.→  .
 .→   .
  .→    .
   .→     .
    .→      .
     .→       .
      .→        .
       .→ →        .

Dans le cas de la vague, ajoutez soit /ou de \manière appropriée afin que la vague continue à alterner et que sa longueur augmente d'une unité, puis sortez la chaîne résultante. Par exemple:

/→ /\
\→ \/
/\→ /\/
\/→ \/\
/\/→ /\/\
\/\→ \/\/
/\/\→ /\/\/
\/\/→ →\/\/\

Dans les deux cas, la sortie peut ne pas avoir d'espaces de fin, mais une nouvelle ligne de fin facultative est autorisée.

Le code le plus court en octets gagne.

C, 69 octets

p;f(char*s){p=s[strlen(s)-1]^46;p^=p?93:3022856;printf("%s%s",s,&p);}

Cela nécessite une machine peu endienne et une sortie vers un terminal qui prend en charge les codes d'échappement ASCII.

p=s[strlen(s)-1]^46 saisit le dernier code ASCII de la chaîne d'entrée et le XOR avec le code ASCII d'un point.

p^=p?93:3022856provoquera pêtre p^93si le code ASCII n'est pas une barre oblique (arrière), où p^46^93 == p^115, ce qui permet de basculer entre le dos et barre oblique. Si pest un point, il le sera à la place 3022856, ce qui est petit-endien pour "\b .".

printf("%s%s",s,&p);affiche la chaîne d'entrée suivie de l'entier p, interprété comme une chaîne d'octets petit-boutien.

Gelée , 17 14 octets

ṪO*2.ị“ .\/\”ṭ

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

ṪO*2.ị“ .\/\”ṭ  Main link. Argument: s (string)

Ṫ               Tail; pop and yield the last character.
 O              Ordinal; map “./\” to [46, 47, 92].
  *2.           Elevate the code point to the power 2.5.
                This maps [46, 47, 92] to [14351.41, 15144.14, 81183.84].
     ị“ .\/\”   Index into that string.
                Jelly's indexing is modular, so this takes the indices modulo 5,
                which gives [1.41, 4.14, 3.84].
                Also, for a non-integer index, ị retrieves the elements at both
                adjacent integer indices (1-based). Here, these are [1, 2], [4, 5],
                and [3, 4], so we get " .", "/\", or "\/".
             ṭ  Tack; append the characters to the popped input string.

CJam, 16 octets

l)_'.={S\}"\/"?|

Essayez-le en ligne! ou vérifiez tous les cas de test .

Comment ça marche

l                 Read a line from STDIN.
 )_               Shift out the last character and copy it.
   '.=            Compare the copy with a dot.
              ?   If the last character is a dot:
      {S\}            Push " " and swap the dot on top.
          "\/"    Else, push "\/".
               |  Perform set union, ordering by first occurrence.
                    " " '.  | -> " ."
                    '/ "\/" | -> "/\"
                    '\ "\/" | -> "\/"

Python, 41 octets

lambda s:[s+'\/'[s[-1]>'/'],' '+s][s<'/']

Traitement des dossiers. Utilise l'ordre trié ' ', '.', '/', '\'. Pour les espaces et la période, ajoute un espace. Sinon, ajoute une barre oblique ou une barre oblique noire opposée au dernier caractère.

Python, 44 42 octets

lambda s:s[:-1]+"\/ /\."[-ord(s[-1])&3::3]

Remplace le dernier caractère par l'ensemble correspondant de deux caractères. lien idéone

(-2 octets grâce à la fonction de mappage plus courte de @ xsot)

Langue de Game Maker, 107 octets

s=argument0;if string_pos(" ",s)return " "+s;if string_pos(s,string_length(s))="/"s+="\"else s+="/"return s

Vim, 27 23 frappes

Première réponse de vim jamais utilisée, je n'ai jamais vraiment utilisé vim.

A/<esc>:s#//#/\\<cr>:s#\./# .<cr>

Comment ça marche: Il ajoute un /à la fin de la ligne, des sous //pour /\, des sous ./pour .

MATL , 19 octets

t47<?0w}'\/'yO)o)]h

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication

t        % Input string implicitly. Duplicate
47<      % Are entries less than 47 (i.e dot or spaces)?
?        % If all are
  0      %   Push a 0. When converted to char it will be treated as a space
  w      %   Swap, so that when concatenated the space will be at the beginning
}        % Else
  '\/'   %   Push this string
  y      %   Duplicate the input string onto the top of the stack
  O)     %   Get its last element
  o      %   Convert to number    
  )      %   Use as (modular) index to extract the appropripate entry from '\/'
]        % End
h        % Concatenate string with either leading 0 (converted to char) or
         % trailing '\'  or '/'. Implicitly display

CJam, 35 26 25 octets

9 octets enregistrés grâce à Dennis

Enregistré 1 octet de plus, également grâce à Dennis

q:I'.&SI+IW='/=I'\+I'/+??

Essayez-le en ligne!

Probablement mal joué, mais je ne connais pas trop CJam. Il y a probablement une meilleure façon de vérifier si un élément est dans un tableau, mais je n'ai trouvé aucun opérateur pour cela.

Explication:

q:I e# take input
'.& e# push union of input and ".", effectively checking if input contains it
SI+ e# push string with space in beginning
IW='/= e# push 1 if the last chsaracter in the input is /
I'\+ e# push the input with a \ appended
I'/+ e# push the input with a / appended
? e# ternary if to select correct /
? e# ternary if to select final result

05AB1E, 17 15 octets

D'.åiðì뤄\/s-J

Explication

D'.åi              # if input contains dot
     ðì            # prepend a space
       ë           # else
        ¤„\/s-     # subtract last char of input from "\/"
              J    # join remainder to input
                   # implicitly print

Essayez-le en ligne

C, 85 octets

j;f(char*n){j=strlen(n)-1;printf("%s%s",n[j]<47?" ":n,n[j]==46?n:n[j]==47?"\\":"/");}

Ideone

Je n'ai pas dormi depuis environ 20 heures, mon code peut probablement être joué beaucoup.

Brachylog , 35 octets

t~m["\/.":X]t:"/\ "rm:?{.h" "|r.}c.

Suite de tests. (Légèrement modifié.)

Matlab, 74 71 62 57 octets

@(s)[s(1:end-1) ' .'+(s(1)>46)*'/.'+(s(end)>47)*[45 -45]]

Il calcule les deux derniers caractères sur la base du s(1)(premier caractère) - pour déterminer si nous avons affaire à la \/casse, et le dernier caractère s(end)pour créer le tuple correct pour les \/caractères.

Rétine, 19 octets

\.
 .
/$
/\^H
\\$
\/

^Hreprésente l'octet BS. Essayez-le en ligne!

> <> , 47 octets

i:0(?\
*=?$r\~:1[:"./ \/"{=?@r=?$r~~]:48
l?!;o>

Essayez-le en ligne!

La première ligne est une boucle d'entrée standard> <>. La deuxième ligne choisit le caractère approprié de / \à ajouter à la chaîne, en fonction du dernier caractère entré. De plus, si le dernier caractère saisi était a ., les deux premiers éléments sont commutés. Enfin, le contenu de la pile est imprimé à l'envers.

JavaScript, 79 70 65 58 octets

(a,b="/\\/",i=b.indexOf(a[a.length-1]))=>i<0?" "+a:a+b[i+1]

C # - 46 octets

s=>s[0]<47?' '+s:s+(s.EndsWith("/")?'\\':'/')

Essayez-le ici.

Haskell, 46 45 44 octets

f z@(x:_)|x<'/'=' ':z|x<'0'='\\':z|1<2='/':z

Profite du fait que < .< /< 0< \dans la table ASCII pour enregistrer deux octets

Python 2, 72 octets

lambda x:x[:-1]+(" .","\/","/\\")[ord(x[-1])/46+(-1,1)[ord(x[-1])%46>0]]

Toute aide au golf serait grandement appréciée!

Cela prend le dernier caractère de l'entrée et le convertit en son code ASCII pour obtenir l'index correspondant dans la liste de deux caractères. Ces deux caractères sont ajoutés à tous les caractères de l'entrée jusqu'au dernier.

SQF, 91

Utilisation du format de fonction en tant que fichier:

s=_this;switch(s select[(count s)-1])do{case".":{" "+s};case"\":{s+"/"};case"/":{s+"\"};}

Appelez en tant que "STRING" call NAME_OF_COMPILED_FUNCTION

Perl, 30 + 1 ( -p) = 31 octets

s/\./ ./,s|/$|/\\|||s|\\$|\\/|

Besoins -pet -M5.010ou -Epour fonctionner:

perl -pE 's/\./ ./,s|/$|/\\|||s|\\$|\\/|' <<< ".
  .
    .
/
/\/" 

Mise en œuvre simple du défi. (Notez que les ||entre les deux dernières expressions régulières sont or, comme cela peut être difficile à lire, donc les trois expressions régulières sont:, s/\./ ./et s|/$|/\\|, et s|\\$|\\/|)

C #, 54 octets

s=>s.EndsWith(".")?" "+s:s+(s.EndsWith("/")?"\\":"/");

PowerShell v2 +, 59 58 52 51 octets

param($n)(" $n","$n/","$n\")['.\/'.IndexOf($n[-1])]

Prend l'entrée $n, la vide une opération d'index de tableau. Nous sélectionnons l'élément du tableau en fonction de l'indice -à- ['.\/'.IndexOf($n[-1])dire, sur la base du dernier caractère de l'entrée - $ncela entraînera, 0, 1ou 2. Cela correspond à la chaîne appropriée du tableau. Dans tous les cas, la chaîne résultante est laissée sur le pipeline et l'impression est implicite.

Cas de test

PS C:\Tools\Scripts\golfing> 0..7|%{' '*$_+'.'}|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")}
. =>  .
 . =>   .
  . =>    .
   . =>     .
    . =>      .
     . =>       .
      . =>        .
       . =>         .

PS C:\Tools\Scripts\golfing> '/,\,/\,\/,/\/,\/\,/\/\,\/\/'-split','|%{"$_ => "+(.\wave-particle-duality.ps1 "$_")}
/ => /\
\ => \/
/\ => /\/
\/ => \/\
/\/ => /\/\
\/\ => \/\/
/\/\ => /\/\/
\/\/ => \/\/\

C #, 80 63 octets

s=>{var c=s[s.Length-1];retu‌​rn c<'/'?" "+s:c>'/'?s+"/":s+"\\‌​";}

Code machine ARM sous Linux, 50 octets

Vidage hexadécimal:

b580 1e41 f811 2f01 2a00 d1fb 3901 780b 1a0a 4601 2001 2704 df00 2000 a103 2202 f013 0303 2b03 4159 df00 bd80 2e202f5c 5c2f

Premier post ici, j'espère que je fais ça correctement. Il s'agit d'un assemblage ARM 32 bits, en particulier le Thumb-2. La chaîne d'entrée est une chaîne terminée par NUL prise par r0, la sortie est imprimée sur la sortie standard. En syntaxe C, le prototype de la fonction serait void func_name (char * string). C'est une plainte AAPCS (convention d'appel ARM), si ce n'était pas le cas, 2 octets pourraient être rasés.

Voici l'assemblage équivalent, avec des commentaires expliquant ce qui se passe:

    @Input: r0 is char* (the string)
    @Output: Modified string to console
    push {r7,lr} @Save r7 and the link register
    subs r1,r0,#1 @Make a copy of the char*, subtracting because we're
    @going to pre-increment.
    loop: @This loop is a little strlen routine
            ldrb r2,[r1,#1]! @In C-syntax, r2=*++r1;
            cmp r2,#0
            bne loop
    @Now r1 points to the null character that terminates the string
    subs r1,r1,#1 @Make r1 point to the last character
    ldrb r3,[r1] @Load the last character into r3
    subs r2,r1,r0 @r2=length(r0) - 1;
    mov  r1,r0 @r0 holds the original char*
    movs r0,#1 @1 is the file descriptor for stdout
    movs r7,#4 @4 is write
    swi #0

    @Now all the characters from the initial string have been printed,
    @except for the last one, which is currently in r3.

    movs r0,#1 @1 is stdout, have to reload this since the system call
    @returns in r0.
    adr r1,msg @Load msg into r1 (the pointer to the string)
    movs r2,#2 @We're going to print two more characters.

    @Now the bit magic. The ascii codes for '\', '.', and '/' map onto
    @0, 2, and 3 when bitwise anded with 3 (0b11).
    @This will be the offset into our string. However, since we must print
    @2 characters, we need our offsets to be 0, 2, and 4.
    @Therefore, we only set the carry if our value is >=3, then add with
    @carry (adcs). Thus we get the correct offset into the string msg.
    ands r3,r3,#3
    cmp r3,#3 @Sets carry if r3>=3
    adcs r1,r1,r3 @Add the offset to r1
    swi #0 @Make the system call
    pop {r7,pc} @Return and restore r7
msg:
    .ascii "\\/ ./\\" @The three different sequences of 2 characters that
    @can go at the end.

ECMAScript 6/2015 (JavaScript), 41 octets

s=>s<'/'?' '+s:s+'\\/'[s.slice(-1)>'/'|0]

Bonne prise Neil.

R, 119 octets

a=scan(,"");if((q=strsplit(a,"")[[1]][nchar(a)])=="."){cat(" ",a,sep="")}else{s=switch(q,"/"="\\","/");cat(a,s,sep="")}

Non golfé:

a=scan(,"")
if((q=strsplit(a,"")[[1]][nchar(a)])==".")
    cat(" ",a,sep="")

else
s=switch(q,"/"="\\","/")
cat(a,s,sep="")

SED, 41 36 27

sauvé 7 grâce à charlie

 s|\.| .|;s|/$|/\\|;t;s|$|/|

utilise 3 substitutions:
s/\./ ./ajoute un espace s'il y a une .
s|/$|/\\|, s|$|/|ajoute la barre oblique appropriée aux extrémités des
utilisations au |lieu de /comme séparateur

t branches à la fin si la deuxième expression régulière correspond de sorte qu'il n'ajoute pas l'autre barre oblique

Turtlèd , 32 octets (non concurrentiel)

l!-[*+.r_]l(/r'\r)(\r'/)(." .")$

Explication:

[implicit]                       first cell is an asterisk

l                                move left, off the asterisk, so the '[*+.r_]' loop runs
 !                               take input into string var, char pointer=0, 1st char
  -                              decrement char pointer, mod length input             

   [*    ]                       while current cell isn't *:
     +.                          increment string pointer, and write the pointed char
       r_                        move right, write * if pointed char is last char, else " "

          l                      move left

           (/    )               if the current cell is /
             r'\r                move right, write /, move right

                  (\   )         If the current cell is \
                    r'/          move right, write /

                        (.    )  If the current cell is .
                          " ."   Write " .", the first space overwriting the existing '.'

                               $ Program won't remove leading spaces when printing

    [implicit]                   Program prints grid after finishing execution

Java 7, 76 octets

String c(String i){return i.contains(".")?" "+i:i+(i.endsWith("/")?92:'/');}

Assez simple.

Code non testé et testé:

Essayez-le ici.

class M{
  static String c(String i){
    return i.contains(".")
            ? " " + i
            : i + (i.endsWith("/")
                    ? 92
                    : '/');
  }

  public static void main(String[] a){
    System.out.println(c(" ."));
    System.out.println(c("  ."));
    System.out.println(c("   ."));
    System.out.println(c("    ."));
    System.out.println(c("     ."));
    System.out.println(c("      ."));
    System.out.println(c("       ."));
    System.out.println(c("        ."));
    System.out.println(c("/"));
    System.out.println(c("\\"));
    System.out.println(c("/\\"));
    System.out.println(c("\\/"));
    System.out.println(c("/\\/"));
    System.out.println(c("\\/\\"));
    System.out.println(c("/\\/\\"));
    System.out.println(c("\\/\\/"));
  }
}

Sortie:

  .
   .
    .
     .
      .
       .
        .
         .
/\
\/
/\/
\/\
/\/\
\/\/
/\/\/
\/\/\