Escriba un programa o función que tome una cadena de una sola línea no vacía. La cadena será cero o más espacios seguidos de un período (una partícula ), como .o          ., o la secuencia será una secuencia de una o más barras alternadas hacia adelante y hacia atrás (una onda ) que podría comenzar con cualquiera de estos como \o /\/o \/\/\/\/\/\/.

En cualquier caso, propague la partícula / onda hacia la derecha en una unidad.

Específicamente, en el caso de partículas, inserte un espacio antes del ., moviéndolo un lugar a la derecha, luego envíe la cadena resultante. Por ejemplo:

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

En el caso de la onda, agregue cualquiera /o \apropiadamente para que la onda se mantenga alterna y su longitud aumente en uno, luego envíe la cadena resultante. Por ejemplo:

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

En cualquier caso, la salida puede no tener espacios finales pero se permite una nueva línea final opcional.

El código más corto en bytes gana.

C, 69 bytes

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

Esto requiere una máquina little endian y salida a una terminal que admita códigos de escape ASCII.

p=s[strlen(s)-1]^46 toma el último código ASCII de la cadena de entrada y lo XOR con el código ASCII de un punto.

p^=p?93:3022856causará pque sea p^93si el código ASCII no es una barra diagonal (posterior), donde p^46^93 == p^115, que alternará entre barra diagonal inversa y diagonal. Si pes un punto, lo será 3022856, lo cual es little-endian para "\b .".

printf("%s%s",s,&p);imprime la cadena de entrada seguida por el entero p, interpretado como una cadena de bytes little-endian.

Jalea , 17 14 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

Ṫ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 bytes

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

Pruébalo en línea! o verificar todos los casos de prueba .

Cómo funciona

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 bytes

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

Trabajo de caso Utiliza el orden ordenado ' ', '.', '/', '\'. Para espacios y punto, antecede un espacio. De lo contrario, agrega una barra diagonal o una barra negra opuesta al último carácter.

Python, 44 42 bytes

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

Reemplaza el último carácter con el conjunto correspondiente de dos caracteres. enlace ideone

(-2 bytes gracias a la función de mapeo más corta de @xsot)

Lenguaje Game Maker, 107 bytes

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

Vim, 27 23 pulsaciones de teclas

Primera respuesta de vim, no he usado vim en absoluto, incluso.

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

Cómo funciona: agrega un /al final de la línea, subs //para /\, subs ./para .

MATL , 19 bytes

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

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

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 bytes

Guardado 9 bytes gracias a dennis

Guardado 1 byte más, también gracias a dennis

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

Pruébalo en línea!

Probablemente mal golfizado, pero no estoy muy familiarizado con CJam. Probablemente haya una mejor manera de verificar si un elemento está en una matriz, pero no pude encontrar ningún operador para eso.

Explicación:

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 bytes

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

Explicación

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

Pruébalo en línea

C, 85 bytes

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

Ideona

No he dormido durante aproximadamente 20 horas, mi código probablemente se pueda jugar mucho.

Brachylog , 35 bytes

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

Banco de pruebas. (Ligeramente modificado.)

Matlab, 74 71 62 57 bytes

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

Calcula los dos últimos caracteres en función del s(1)(primer carácter), para determinar si estamos tratando con el \/caso, y el último personaje s(end)para hacer la tupla correcta para los \/personajes.

Retina, 19 bytes

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

^Hrepresenta el byte BS. Pruébalo en línea!

> <> , 47 bytes

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

Pruébalo en línea!

La primera línea es un bucle de entrada estándar> <>. La segunda línea elige el carácter apropiado / \para agregar a la cadena, en función del último carácter de entrada. Además, si el último carácter de entrada fue a ., se cambian los dos elementos superiores. Finalmente, el contenido de la pila se imprime al revés.

JavaScript, 79 70 65 58 bytes

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

C # - 46 bytes

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

Pruébalo aquí.

Haskell, 46 45 44 bytes

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

Se aprovecha del hecho de que < .< /< 0< \en la tabla ASCII para salvar dos bytes

Python 2, 72 bytes

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

¡Cualquier ayuda para jugar más al golf sería muy apreciada!

Esto toma el último carácter en la entrada y lo convierte en su código ASCII para obtener el índice correspondiente en la lista de dos caracteres. Esos dos caracteres se agregan a todos los caracteres de la entrada hasta el último.

SQF, 91

Usando el formato de función como archivo:

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

Llamar como "STRING" call NAME_OF_COMPILED_FUNCTION

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

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

Necesidades -py / -M5.010o -Ecorrer:

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

Implementación directa del desafío. (Tenga en cuenta que ||entre las dos últimas expresiones regulares son or, ya que puede ser difícil de leer, por lo que las tres expresiones regulares son:, s/\./ ./y s|/$|/\\|, y s|\\$|\\/|)

C #, 54 bytes

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

PowerShell v2 +, 59 58 52 51 bytes

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

Toma entrada $n, la convierte en una operación de índice de matriz. Seleccionamos el elemento de la matriz en base al índice ['.\/'.IndexOf($n[-1])- es decir, basado en el último carácter de la entrada $n, esto dará lugar a 0, 1o 2. Eso corresponde a la cadena apropiada de la matriz. En cualquier caso, la cadena resultante se deja en la tubería y la impresión es implícita.

Casos de prueba

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

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

C #, 80 63 bytes

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

Código de máquina ARM en Linux, 50 bytes

Volcado hexadecimal:

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

Primera publicación aquí, espero que esté haciendo esto bien. Este es un ensamblaje ARM de 32 bits, específicamente Thumb-2. La cadena de entrada es una cadena terminada en NUL tomada a través de r0, la salida se imprime en la salida estándar. En la sintaxis C, el prototipo de la función sería nulo func_name (char * string). Es una queja de AAPCS (convención de llamada ARM), si no fuera así, se podrían eliminar 2 bytes.

Aquí está la asamblea equivalente, con comentarios que explican lo que está sucediendo:

    @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 bytes

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

Buena captura Neil.

R, 119 bytes

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

Sin 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

guardado 7 gracias a charlie

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

usa 3 sustituciones:
s/\./ ./agrega un espacio si hay un .
s|/$|/\\|, s|$|/|agrega la barra diagonal a los
usos finales en |lugar de /como delimitador

t se ramifica hasta el final si la segunda expresión regular coincide para que no agregue la otra barra inclinada

Turtlèd , 32 bytes (sin competencia)

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

Explicación:

[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 bytes

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

Muy claro.

Ungolfed y código de prueba:

Pruébalo aquí.

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("\\/\\/"));
  }
}

Salida:

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