Escreva um programa ou função que utilize uma sequência de linhas simples não vazia. A cadeia terá zero ou mais espaços seguidos por um período (uma partícula ), como .or          ., ou a cadeia será uma sequência de uma ou mais barras alternadas para frente e para trás (uma onda ) que poderiam começar com uma, como \ou /\/ou \/\/\/\/\/\/.

Nos dois casos, propague a partícula / onda para a direita por uma unidade.

Especificamente, no caso das partículas, insira um espaço antes de ., movendo-o um lugar para a direita e, em seguida, imprima a sequência resultante. Por exemplo:

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

No caso de onda, acrescente uma /ou de \forma adequada para que a onda continue alternando e seu comprimento aumente em um, depois produza a string resultante. Por exemplo:

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

Em ambos os casos, a saída pode não ter espaços à direita, mas uma nova linha à direita opcional é permitida.

O código mais curto em bytes vence.

C, 69 bytes

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

Isso requer uma máquina little-endian e saída para um terminal que suporte códigos de escape ASCII.

p=s[strlen(s)-1]^46 pega o último código ASCII da sequência de entrada e o XORs com o código ASCII de um ponto.

p^=p?93:3022856fará com pque p^93se o código ASCII não for uma barra (de volta), onde p^46^93 == p^115, que alternará entre a barra de retorno e a de avanço. Se pé um ponto, será, em vez disso 3022856, o que é pouco endian "\b .".

printf("%s%s",s,&p);imprime a sequência de entrada seguida pelo número inteiro p, interpretada como uma sequência de bytes little-endian.

Geléia , 17 14 bytes

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

Experimente online! ou verifique todos os casos de teste .

Como 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\}"\/"?|

Experimente online! ou verifique todos os casos de teste .

Como 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<'/']

Casework. Usa a ordem classificada ' ', '.', '/', '\'. Para espaços e pontos, precede um espaço. Caso contrário, anexa uma barra ou barra preta oposta ao último caractere.

Pitão, 44 42 bytes

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

Substitui o último caractere pelo conjunto correspondente de dois caracteres. link ideone

(-2 bytes graças à função de mapeamento mais curta do @ xsot)

Linguagem do 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 pressionamentos de teclas

Primeira resposta do vim, nunca usei o vim de maneira alguma.

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

Como funciona: Anexa a /no final da linha, subs //para /\, subs ./para .

MATL , 19 bytes

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

Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Economizou 9 bytes graças a dennis

Economizou mais 1 byte, também graças a dennis

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

Experimente online!

Provavelmente mal jogou golfe, mas não estou muito familiarizado com CJam. Provavelmente existe uma maneira melhor de verificar se um elemento está em uma matriz, mas não consegui encontrar nenhum operador para isso.

Explicação:

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

Explicação

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

Experimente online

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

Ideone

Eu não durmo há cerca de 20 horas, meu código provavelmente pode ser muito jogado.

Braquilog , 35 bytes

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

Suíte de teste. (Ligeiramente modificado.)

Matlab, 74 71 62 57 bytes

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

Ele calcula os dois últimos caracteres com base no s(1)(primeiro caractere) - para determinar se estamos lidando com o \/caso e o último caractere s(end)para fazer a tupla correta para os \/caracteres.

Retina, 19 bytes

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

^Hrepresenta o byte BS. Experimente online!

> <> , 47 bytes

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

Experimente online!

A primeira linha é um loop de entrada padrão> <>. A segunda linha escolhe o caractere apropriado / \para anexar à string, com base no último caractere de entrada. Além disso, se o último caractere de entrada for a ., os dois principais elementos serão alternados. Finalmente, o conteúdo da pilha é impresso ao contrário.

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("/")?'\\':'/')

Experimente aqui.

Haskell, 46 45 44 bytes

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

Tira proveito do fato de que < .< /< 0< \na tabela ASCII para salvar dois bytes

Python 2, 72 bytes

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

Qualquer ajuda no golfe seria muito apreciada!

Isso pega o último caractere na entrada e o converte em seu código ASCII para obter o índice correspondente na lista de dois caracteres. Esses dois caracteres são anexados a todos os caracteres da entrada até o último.

SQF, 91

Usando o formato de função como um arquivo:

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

Ligar como "STRING" call NAME_OF_COMPILED_FUNCTION

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

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

Precisa -pe / -M5.010ou -Eexecutar:

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

Implementação direta do desafio. (Observe que ||entre as duas últimas regex são or, como pode ser difícil de ler, as três regex são:, s/\./ ./e s|/$|/\\|, e 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])]

Pega entrada $n, despeja uma operação de índice de matriz. Nós selecionamos o elemento da matriz com base no índice ['.\/'.IndexOf($n[-1])- ou seja, com base no último caractere da entrada $n, isso irá resultar em 0, 1ou 2. Isso corresponde à sequência apropriada da matriz. De qualquer forma, a sequência resultante é deixada no pipeline e a impressão está implícita.

Casos de teste

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 da máquina ARM no Linux, 50 bytes

Despejo hexagonal:

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

Primeiro post aqui, espero que eu esteja fazendo isso certo. Este é um conjunto ARM de 32 bits, especificamente o Thumb-2. A sequência de entrada é uma sequência terminada em NUL, obtida através de r0, a saída é impressa no stdout. Na sintaxe C, o protótipo para a função seria nulo func_name (char * string). É uma reclamação AAPCS (convenção de chamada do ARM), se não fosse, então 2 bytes poderiam ser removidos.

Aqui está a montagem equivalente, com comentários explicando o que está acontecendo:

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

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

Ungolfed:

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

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

SED, 41 36 27

economizou 7 graças a charlie

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

usa 3 substituições:
s/\./ ./adiciona um espaço, se houver .
s|/$|/\\|, s|$|/|adiciona a barra apropriada aos
usos finais, e |não /como delimitador

t ramifica até o fim se o segundo regex corresponder para que ele não adicione a outra barra

Turtlèd , 32 bytes (não-competitivo)

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

Explicação:

[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:'/');}

Bem direto.

Ungolfed & código de teste:

Experimente aqui.

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

Saída:

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