Scrivi un programma o una funzione che accetta una stringa a riga singola non vuota. La stringa sarà zero o più spazi seguita da un punto (una particella ), come .o          ., oppure la stringa sarà una sequenza di una o più barre alternate avanti e indietro ( un'onda ) che potrebbero iniziare con una di queste, ad esempio come \o /\/o \/\/\/\/\/\/.

In entrambi i casi, propagare la particella / onda a destra di un'unità.

In particolare, nel caso delle particelle, inserire uno spazio prima di ., spostandolo di un posto a destra, quindi emettere la stringa risultante. Per esempio:

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

Nel caso wave, aggiungi /o in \modo appropriato in modo che l'onda continui ad alternarsi e la sua lunghezza aumenti di uno, quindi emetta la stringa risultante. Per esempio:

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

In entrambi i casi, l'output potrebbe non avere spazi finali ma è consentita una nuova riga finale opzionale.

Vince il codice più breve in byte.

C, 69 byte

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

Ciò richiede una macchina little-endian e l'output su un terminale che supporti i codici di escape ASCII.

p=s[strlen(s)-1]^46 prende l'ultimo codice ASCII della stringa di input e lo XORs con il codice ASCII di un punto.

p^=p?93:3022856causerà pessere p^93se il codice ASCII non è un (retro) barra, dove p^46^93 == p^115, che si alterna tra schienale e barra. Se pè un punto, lo sarà invece 3022856, il che è little-endian per "\b .".

printf("%s%s",s,&p);stampa la stringa di input seguita dal numero intero p, interpretata come una stringa di byte little-endian.

Gelatina , 17 14 byte

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

Provalo online! o verifica tutti i casi di test .

Come funziona

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

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

Provalo online! o verifica tutti i casi di test .

Come funziona

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 byte

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

Casework. Utilizza l'ordine ordinato ' ', '.', '/', '\'. Per spazi e periodo, antepone uno spazio. Altrimenti, aggiunge una barra o una barra nera opposta all'ultimo carattere.

Pitone, 44 42 byte

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

Sostituisce l'ultimo carattere con il corrispondente set di due caratteri. collegamento ideone

(-2 byte grazie alla funzione di mappatura più breve di @xsot)

Lingua di Game Maker, 107 byte

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

Vim, 27 23 sequenze di tasti

La prima risposta di VIM di sempre, non ho usato Vim per davvero.

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

Come funziona: aggiunge /a alla fine della riga, subs //per /\, subs ./per .

MATL , 19 byte

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

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione

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 byte

Salvataggio di 9 byte grazie a dennis

Salvato 1 byte in più, anche grazie a dennis

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

Provalo online!

Probabilmente ha giocato male, ma non ho familiarità con CJam. Probabilmente esiste un modo migliore per verificare se un elemento si trova in un array, ma non sono riuscito a trovare alcun operatore per quello.

Spiegazione:

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 byte

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

Spiegazione

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

Provalo online

C, 85 byte

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

Ideone

Non ho dormito per circa 20 ore, probabilmente il mio codice può essere giocato a golf molto.

Brachylog , 35 byte

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

Suite di test. (Leggermente modificato.)

Matlab, 74 71 62 57 byte

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

Calcola gli ultimi due caratteri in base al s(1)(primo carattere) - per determinare se abbiamo a che fare con il \/caso e l'ultimo carattere s(end)per creare la tupla corretta per i \/personaggi.

Retina, 19 byte

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

^Hrappresenta il byte BS. Provalo online!

> <> , 47 byte

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

Provalo online!

La prima riga è un loop di input> <> standard. La seconda riga sceglie il carattere appropriato da / \aggiungere alla stringa, in base all'ultimo carattere di input. Inoltre, se l'ultimo carattere di input è stato a ., vengono commutati i primi due elementi. Infine, il contenuto dello stack viene stampato al contrario.

JavaScript, 79 70 65 58 byte

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

C # - 46 byte

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

Provalo qui.

Haskell, 46 45 44 byte

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

Sfrutta il fatto che < .< /< 0< \nella tabella ASCII per salvare due byte

Python 2, 72 byte

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

Qualsiasi aiuto per giocare a golf in più sarebbe molto apprezzato!

Questo prende l'ultimo carattere nell'input e lo converte nel suo codice ASCII per ottenere l'indice corrispondente nell'elenco di due caratteri. Questi due caratteri vengono aggiunti a tutti i caratteri dell'input fino all'ultimo.

MQ, 91

Utilizzando il formato funzione-come-un-file:

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

Chiama come "STRING" call NAME_OF_COMPILED_FUNCTION

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

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

Necessità -pe / -M5.010o -Eesecuzione:

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

Implementazione diretta della sfida. (Notare che ||tra le ultime due regex sono or, poiché potrebbe essere difficile da leggere, quindi le tre regex sono:, s/\./ ./e s|/$|/\\|, e s|\\$|\\/|)

C #, 54 byte

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

PowerShell v2 +, 59 58 52 51 byte

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

Accetta input $n, esegue il dump di un'operazione di indice dell'array. Selezioniamo l'elemento della matrice in base all'indice ['.\/'.IndexOf($n[-1])- cioè, sulla base dell'ultimo carattere dell'ingresso $n, questo si tradurrà in 0, 1o 2. Ciò corrisponde alla stringa appropriata dell'array. In ogni caso, la stringa risultante viene lasciata sulla pipeline e la stampa è implicita.

Casi 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 byte

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

Codice macchina ARM su Linux, 50 byte

Discarica esadecimale:

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

Primo post qui, spero di farlo bene. Questo è un assembly ARM a 32 bit, in particolare Thumb-2. La stringa di input è una stringa terminata con NUL presa attraverso r0, l'output viene stampato sullo stdout. Nella sintassi C, il prototipo della funzione sarebbe void func_name (char * string). È un reclamo AAPCS (convenzione di chiamata ARM), se non lo fosse, allora si potrebbero radere 2 byte.

Ecco l'assemblaggio equivalente, con commenti che spiegano cosa sta succedendo:

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

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

Buona cattura Neil.

R, 119 byte

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

salvato 7 grazie a Charlie

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

usa 3 sostituzioni:
s/\./ ./aggiunge uno spazio se presente .
s|/$|/\\|, s|$|/|aggiunge la barra appropriata agli
usi finali |anziché /come delimitatore

t si ramifica fino alla fine se la seconda regex corrisponde in modo da non aggiungere l'altra barra

Turtlèd , 32 byte (non competitivo)

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

Spiegazione:

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

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

Abbastanza diretto.

Codice non testato e test:

Provalo qui.

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

Produzione:

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