Schreiben Sie ein Programm oder eine Funktion, die eine nicht leere einzeilige Zeichenfolge enthält. Die Zeichenfolge besteht entweder aus null oder mehr Leerzeichen, gefolgt von einer Periode (einem Partikel ) wie .oder          ., oder die Zeichenfolge besteht aus einer Folge von einem oder mehreren abwechselnden Schrägstrichen (einer Welle ), die mit einem der beiden beginnen können, z als \oder /\/oder \/\/\/\/\/\/.

In beiden Fällen müssen Sie das Partikel / die Welle um eine Einheit nach rechts ausbreiten .

Fügen Sie im Partikelfall ein Leerzeichen vor dem ein ., verschieben Sie es um eine Stelle nach rechts und geben Sie dann die resultierende Zeichenfolge aus. Beispielsweise:

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

Fügen Sie im Wave-Fall entweder /oder \entsprechend hinzu, damit die Wave abwechselnd und um eins länger bleibt, und geben Sie dann die resultierende Zeichenfolge aus. Beispielsweise:

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

In beiden Fällen darf die Ausgabe keine nachgestellten Leerzeichen enthalten, aber eine optionale nachgestellte Newline ist zulässig.

Der kürzeste Code in Bytes gewinnt.

C 69 Bytes

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

Dies erfordert eine Little-Endian-Maschine und die Ausgabe an ein Terminal, das ASCII-Escape-Codes unterstützt.

p=s[strlen(s)-1]^46 erfasst den letzten ASCII-Code der Eingabezeichenfolge und XOR-verknüpft ihn mit dem ASCII-Code eines Punkts.

p^=p?93:3022856verursacht p, p^93wenn der ASCII-Code kein (umgekehrter) Schrägstrich ist, wobei p^46^93 == p^115zwischen einem umgekehrten und einem vorwärts gerichteten Schrägstrich umgeschaltet wird. Wenn pes ein Punkt ist, wird es stattdessen sein 3022856, was für Little-Endian ist"\b ." .

printf("%s%s",s,&p);Gibt die Eingabezeichenfolge gefolgt von der Ganzzahl aus p, die als Little-Endian-Byte-Zeichenfolge interpretiert wird.

Jelly , 17 14 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

Wie es funktioniert

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. Uses the sorted order ' ', '.', '/', '\'. For spaces and period, prepends a space. Otherwise, appends a slash or blackslash opposite to the last character.

Python, ​ 44 ​ ​42 bytes

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

Replaces the last character with the correspond set of two characters. ideone link

(-2 bytes thanks to @xsot's shorter mapping function)

Game Maker Language, 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 keystrokes

First vim answer ever, haven't used vim at all really even.

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

How it works: It appends a / at the end of line, subs // for /\, subs ./ for .

MATL, 19 bytes

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

Try it online! Or verify all test cases.

Explanation

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

Saved 9 bytes thanks to dennis

Saved 1 more byte, also thanks to dennis

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

Try it online!

Probably poorly golfed, but I'm not too familiar with CJam. There's probably a better way to check if an element is in an array, but I couldn't find any operators for that.

Explanation:

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

Explanation

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

Try it 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

I haven't slept for about 20 hours, my code probably can be golfed a lot.

Brachylog, 35 bytes

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

Test suite. (Slightly modified.)

Matlab, 74 71 62 57 bytes

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

It computes the last two characters based on the s(1) (first character) - to determine if we're dealing with the \/ case, and the last character s(end) to make the correct tuple for the \/ characters.

Retina, 19 bytes

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

^H represents the BS byte. Try it online!

><>, 47 bytes

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

Try it online!

The first line is a standard ><> input loop. The second line chooses the appropriate character from / \ to append to the string, based on the last input character. In addition, if the last input character was a ., the top two elements are switched. Finally, the stack contents are printed in reverse.

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

Try it here.

Haskell, 46 45 44 bytes

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

Nutzt die Tatsache , dass < .</ < 0 < \ in the ASCII table to save two bytes

Python 2, 72 Bytes

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

Jede Hilfe mehr Golf wäre sehr dankbar!

Dies nimmt das letzte Zeichen in der Eingabe und konvertiert es in seinen ASCII-Code, um den entsprechenden Index in der Liste mit zwei Zeichen zu erhalten. Diese beiden Zeichen werden bis zum letzten Zeichen an alle Zeichen der Eingabe angehängt.

SQF, 91

Verwenden des Formats "Funktion als Datei":

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

Anrufen als "STRING" call NAME_OF_COMPILED_FUNCTION

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

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

Bedürfnisse -pund -M5.010oder -Ezu laufen:

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

Einfache Umsetzung der Herausforderung. (Beachten Sie, dass die ||beiden letzten regulären Ausdrücke orschwer lesbar sind. Die drei regulären Ausdrücke sind also:, s/\./ ./und s|/$|/\\|, und. s|\\$|\\/|)

C #, 54 Bytes

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

PowerShell v2 +, 59 58 52 51 Byte

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

Übernimmt die Eingabe $n, gibt eine Array-Indexoperation aus. Wir wählen das Element des Arrays basierend auf dem Index ['.\/'.IndexOf($n[-1])- dh basierend auf dem letzten Zeichen des Eingangs $n, wird dies zur Folge 0, 1oder 2. Das entspricht der entsprechenden Zeichenfolge des Arrays. In jedem Fall verbleibt die resultierende Zeichenfolge in der Pipeline und das Drucken ist implizit.

Testfälle

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+"\\‌​";}

ARM-Maschinencode unter Linux, 50 Byte

Hex-Dump:

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

Erster Beitrag hier, hoffe ich mache das richtig. Dies ist eine 32-Bit-ARM-Assembly, insbesondere Thumb-2. Die Eingabezeichenfolge ist eine mit NUL abgeschlossene Zeichenfolge, die über r0 eingegeben wird. Die Ausgabe wird auf die Standardausgabe gedruckt. In der C-Syntax wäre der Prototyp für die Funktion ungültig func_name (char * string). Es ist eine AAPCS-Beschwerde (ARM Calling Convention), wenn es nicht so wäre, könnten 2 Bytes abgeschnitten werden.

Hier ist die entsprechende Assembly mit Kommentaren, die erklären, was passiert:

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

Guter Fang, 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

7 dank charlie gerettet

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

Verwendet 3 Substitutionen:
s/\./ ./Fügt ein Leerzeichen hinzu, wenn ein vorhanden ist .
s|/$|/\\|, und s|$|/|fügt stattdessen den entsprechenden Schrägstrich an die
Endverwendung |an/ als Begrenzer

t Verzweigt zum Ende, wenn der zweite reguläre Ausdruck übereinstimmt, sodass der andere Schrägstrich nicht hinzugefügt wird

Turtlèd , 32 Bytes (nicht konkurrierend )

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

Erläuterung:

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

Ziemlich einfach.

Ungolfed & Testcode:

Probieren Sie es hier aus.

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

Ausgabe:

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