Eingang

Eine nicht leere, gemischte Zeichenfolge, die aus ASCII-Zeichen im Bereich $[32..126]$ .

Ausgabe

Die Ausgabe wird durch Anwenden aufeinanderfolgender Rotationen auf die Eingabezeichenfolge erhalten.

Für jeden Buchstaben ( [a-zA-Z]) in der Eingabezeichenfolge von links nach rechts:

• Wenn der Buchstabe in Großbuchstaben geschrieben ist, drehen Sie alle Zeichen davor um eine Position nach links
• Wenn der Buchstabe in Kleinbuchstaben geschrieben ist, drehen Sie alle Zeichen davor um eine Position nach rechts

Beispiel

Eingabe: "Cb-Ad"

• Der erste Buchstabe ist ein " C ". Wir sollten nach links drehen, aber vor diesem " C " steht kein Zeichen . Es gibt also nichts zu drehen.
• Der nächste Buchstabe ist ein " b ". Wir drehen " C " nach rechts. Da es sich um ein einzelnes Zeichen handelt, bleibt es unverändert.
• Das Zeichen " - " löst keine Rotation aus, da es sich nicht um einen Buchstaben handelt.
• Der nächste Buchstabe ist ein " A ". Wir drehen " Cb- " nach links, was " bC Ad" ergibt
• Der vierte und letzte Buchstabe ist ein " d ". Wir drehen " b-CA " nach rechts, was " Ab-C d" ergibt

Daher ist die erwartete Ausgabe " Ab-Cd ".

Regeln

• Sie können Eingaben als Zeichenfolge oder als Array von Zeichen annehmen - je nach Sprache kann dies das Gleiche sein oder auch nicht.
• Sie können auch ein Array von Zeichen anstelle einer Zeichenfolge ausgeben.
• Das ist ogl-edocf Code-Golf

Testfälle

"cbad" -> "abcd"
"ACBD" -> "ABCD"
"Cb-Ad" -> "Ab-Cd"
"caeBDF" -> "aBcDeF"
"aEcbDF" -> "abcDEF"
"ogl-edocf" -> "code-golf"
"W o,ollelrHd!" -> "Hello, World!"
"ti HIs SSta ET!" -> "tHis IS a tEST!"

Pyth, 21 bis 20 Bytes

VQ=k+.>k-}NG}Nr1GN)k

Probieren Sie es hier aus

Erläuterung

VQ=k+.>k-}NG}Nr1GN)k
VQ                )      For each N in the input...
     .>k                 ... rotate k (initially '')...
        -}NG}Nr1G        ... by (N is lowercase) - (N is uppercase)...
    +            N       ... then append N...
  =k                     ... and update k.
                   k     Output the result.

Python 2 , 100 98 95 Bytes

f=lambda s,p='':s and f(s[1:],[p[x:]+p[:x]+s[0]for x in[s[0].isupper()-s[0].islower()]][0])or p

Probieren Sie es online!

Jelly , 14 Bytes

ØẠŒHċ€ḅ-N⁸ṙ;ð/

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, die eine Liste von Zeichen ergibt.

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Wie?

ØẠŒHċ€ḅ-N⁸ṙ;ð/ - Link - list of characters
             / - reduce by:
            ð  -   a dyadic chain:  1st call is f(L=1stCharacter, R=2ndCharacter)
               -                    ...then calls are f(L=previousResult, R=nextCharacter)
ØẠ             -     alphabet characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
  ŒH           -     split in half = ["ABCDEFGHIJKLMNOPQRSTUVWXYZ","abcdefghijklmnopqrstuvwxyz"]
     €         -     for each:
    ċ          -       count occurrences (of R)
               -                          e.g.: 'W' -> [1,0]; 'c' -> [0,1]; '@' -> [0,0]
      ḅ-       -     convert from base -1             -1             1             0
        N      -     negate                            1            -1             0
         ⁸     -     chain's left argument (i.e. L)
          ṙ    -     rotate left by (the negate result)
           ;   -     concatenate R

05AB1E , 18 17 16 14 Bytes

õsvy.uy.l-._y«

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

Erläuterung:

õ            # Start with an empty string
 sv          # Loop over the characters `y` of the input
   y.u       #  Check if `y` is an uppercase letter (1 if truthy; 0 if falsey)
   y.l       #  Check if `y` is a lowercase letter (1 if truthy; 0 if falsey)
      -      #  Subtract them from each other
       ._    #  Rotate the string that many times (-1, 0, or 1) toward the left
   y«        #  Append the current character `y` to the string
             # (And implicitly output the string after the loop)

K4 , 43 33 Bytes

Lösung:

""{.q.rotate[-/y in'.Q`A`a;x],y}/

Beispiele:

q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"Cb-Ad"
"Ab-Cd"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ogl-edocf"
"code-golf"
q)k)""{.q.rotate[-/y in'.Q`A`a;x],y}/"ti HIs SSta ET!"
"tHis IS a tEST!"

Erläuterung:

Durchlaufen Sie die Eingabezeichenfolge und drehen Sie die vorherige Ausgabe um 1, -1 oder 0, je nachdem, an welcher Position sie in der Liste "a-zA-Z" steht.

""{.q.rotate[-/y in'.Q`A`a;x],y}/ / the solution
""{                            }/ / iterate (/) over, starting x as ""
                             ,y   / append y to
   .q.rotate[             ;x]     / rotate x by ...
                    .Q`A`a        / the lists "a..z" and "A..Z"
               y in'              / y in each (') alphabet?
             -/                   / subtract (-) over (/)

Anmerkungen:

• -10 Bytes mit Inspiration aus der 05AB1E- Lösung

> <> , 45 43 Bytes

ii:2+7$.::&"`{"@)@(*?}"@["&::&@)@(*?{&!
ror

Probieren Sie es online!

Die Tatsache, dass> <> Stapelrotation hat, hilft, aber die Groß- und Kleinschreibung des Buchstabens überprüfen zu müssen, tut dies nicht.

Erläuterung:

i    Get first inputted character
 i   Get second. This is to prevent errors from rotating an empty stack
  :2+7$.      Jump to the second line if that was EOF
        ::&   Create copies of the input and store one in the register
           "`{"@)@(*     Check if the char is lower case
                    ?}   If so rotate the stack
                      "@["&::&@)@(*?{   Rotate the other way if uppercase
                                     &  Push the new char
                                      ! Skip the first i instruction
Skip to the second line on EOF
ro      Reverse the stack and output
r r     Cancel out the first reverse
 o      Output the rest of the stack

Haskell , 101 91 Bytes

^{-10 Bytes, inspiriert von Curtis Bechtels Antwort (verwenden Sie '@'<c,c<'['over elem c['A'..'Z']und den entsprechenden Bereich für Kleinbuchstaben).}

g(x:y)=foldl((<>pure).(!))[x]y
x@(a:b)!c|'`'<c,c<'{'=last x:init x|'@'<c,c<'['=b++[a]|0<1=x

Probieren Sie es online!

Erklärung / Ungolfed

Der Operator verwendet (!)eine nicht leere Zeichenfolge, xfür die ein Mustervergleich durchgeführt werden kann, und ein Zeichen:

x@(a:b) ! c
  | '`' < c, c < '{' = last x : init x  -- rotate x to the right by one
  | '@' < c, c < '[' = b ++ [a]         -- rotate x to the left by one
  | otherwise = x                       -- keep x as is

Jetzt können wir den Schwanz der Eingabe von links nach rechts verkleinern, beginnend mit dem ersten Zeichen der Eingabe, indem wir Folgendes verwenden:

\b a -> b!a ++ [a]

Haskell , 122 92 Bytes

Danke an BWO für die Vorschläge! Ich habe auch viel gespart, indem ich einen etwas anderen Ansatz gewählt habe als meine ursprüngliche Antwort.

l@(a:b)!c|'`'<c,c<'{'=last l:init l++[c]|'@'<c,c<'['=b++[a,c]|0<1=l++[c]
f(c:s)=foldl(!)[c]s

Probieren Sie es online!

JavaScript (Node.js) , 116 102 Bytes

f=(s,i=1)=>s[i]?f(s.replace(RegExp(`^(.)(.{${i}})(?=[A-Z])|^(.{${i}})(.)(?=[a-z])`),"$4$3$2$1"),i+1):s

Probieren Sie es online!

Original ( 116 111 106B)

s=>Buffer(s).map((x,i)=>s=(t=s[S="slice"](i),i<2)?s:x>64&x<91?s[S](1,i)+s[0]+t:x>96&x<123?s[i-1]+s[S](0,i-1)+t:s)&&s

s=>Buffer(s).map((x,i)=>i<2|--x%32>25|x<64?s:s=[s[S="slice"](1,i)+s[0],s[i-1]+s[S](0,i-1)][+(x>95)]+s[S](i))&&s

s=>Buffer(s).map((x,i)=>!i|--x%32>25|x<64?s:s=(w=x>95,t=s.slice(1-w,i-w),w?s[i-1]+t:t+s[0])+s.slice(i))&&s

Ruby , 51 Bytes

->s{w=[];s.map{|x|w.rotate!(x=~/\W/||?_<=>x)<<x};w}

Probieren Sie es online!

Eingabe und Ausgabe sind Arrays von Zeichen

Der Trick:

Der Code ist ziemlich einfach, mit Ausnahme des Rotationsteils:

(x=~/\W/||?_<=>x)

x ist ein einzelnes Zeichen, das ein Buchstabe sein kann. Der erste Ausdruck gibt x=~/\W/zurück, nilwenn es sich um einen Buchstaben handelt, und ansonsten 0. Wenn es 0 ist, sind wir fertig. Wenn nicht, orprüft die Logik den zweiten Ausdruck: ?_<=>xGibt -1 für Großbuchstaben und 1 für Kleinbuchstaben zurück. Die Rotation ist also:

• -1 (1 nach links) für Großbuchstaben
• +1 (1 nach rechts) für Kleinbuchstaben
• 0 (keine Drehung), wenn es kein Buchstabe ist

Rot , 110 Bytes

func[s][p: s forall s[if all[(a: first s)>#"@"a < #"["][move p back s]if all[a >#"`"a <#"{"][move back s p]]p]

Probieren Sie es online!

Erläuterung:

f: func [ s ] [
    p: s                                ; store the starting position of the string in p
    forall s [                          ; iterate through the entire string
        a: first s                      ; store the current character in a
        if all [ a > #"@" a < #"[" ] [  ; if `a` is a uppercase letter
            move p back s               ; move the starting char to the position before current
        ]
        if all [ a > #"`" a < #"{" ] [  ; if `a` is a lowercase letter
            move back s p               ; move the character before the current one to the start
        ]
    ]
    p                                   ; return the string 
]

Perl 6 , 47 Bytes

*.reduce:{|@$^a.rotate($^b~~/\w/&&'_'leg$b),$b}

Probieren Sie es online!

Funktioniert mit einer Reihe von Zeichen.

Japt, 17 16 14 Bytes

Nimmt Eingaben als Array von Zeichen und gibt eine Zeichenfolge aus

;rÏiXéCøY -BøY

Versuch es

Erläuterung

 rÏ                :Reduce by passing the current result (X) & the current element (Y) through a function
   i               :  Prepend to Y
    Xé             :  X rotated right by
;     B            :    Uppercase alphabet
       øY          :    Contains Y?
          -        :    Subtract
;          C       :    Lowercase alphabet
            øY     :    Contains Y?

Jelly , 19 Bytes

W€ḷṙ01ŒlƑ?-ŒuƑ?};ʋ/

Probieren Sie es online!

Java 10, 149 119 Bytes

s->{for(int i=1;i<s.length();)s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");return s;}

Port of @ShieruAsakoto Antworte mit JavaScript , also stelle sicher, dass du ihn positiv bewertest.

Probieren Sie es online aus.

Erläuterung:

s->{                          // Method with String as both parameter and return-type
  for(int i=1;i<s.length();)  //  Loop `i` in the range [1, length)
    s=s.replaceAll("^(.)(.{"+i+"})(?=[A-Z])|^(.{"+i+++"})(.)(?=[a-z])","$4$3$2$1");
                              //   Rotate the substring of [0, i] either left or right
  return s;}                  //  Return the modified input-String as result

Stax , 32 Bytes

éG7[Æ┐äZ▬Θε♫∙~╞ÉH╔u╬←J╛ü╢(┼▒uX)Ü

Führen Sie es aus und debuggen Sie es

B]s{c97 123:bsaa|)sc65 91:bsaa|(s+c}fd  #Full program, unpacked, implicit input
B]s                                     #Unons-left, singleton, swap top 2 of stack
   {c                                   #Copy iterative letter
     97 123                             #Put 97 and 123 on stack(lower case)
           :bsaa                        #Check if iterative letter is between range, swap orientation back to proper order
                |)                      #Rotate if the letter is within range
                  sc                    #Swap top 2 and copy top
                    65 91               #Put 65 and 91 on stack (Capitals)
                         :bsaa          #Check if iterative letter is between range, swap orientation back to proper order
                              |(        #Rotate if the letter is within range
                                s+c     #swap, concat and copy
                                   }fd  #remove duplicate of original answer after loop and implicitly print

Viel Stack-Swap, was wahrscheinlich unnötig ist. Ich würde das wirklich gerne mehr runterholen, aber ich hatte Mühe, den Stapel zu ordnen. Vielleicht kann jemand es herausfinden, wenn er gelangweilt ist. Ich werde weiter daran arbeiten.

Attache , 69 Bytes

~Fold[{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}@SplitAt]#Iota

Probieren Sie es online!

Erläuterung

Allgemeine Form

Die Funktion sieht im Allgemeinen so aus:

~Fold[{...}]#Iota

Welche faltet {...}über jedes Mitglied im Bereich von 0bis #input - 1(Iota ) , beginnend mit der Eingabe als Startwert.

Die innere Funktion

Die folgende Funktion wird aufgerufen als f[building, index]und wird mit jedem Index von 0bis #inputexklusiv aufgerufen . @SplitAtruft SplitAtdiese Argumente auf und teilt die Eingabezeichenfolge auf index.

{s'r.=_'sp;Rotate[s,&`-!Has&r[0]=>ALPHA'alpha]+r}
{                                               }    anonymous function taking the split string
                                                     e.g.: ["cd-", "Adf!"]
      _'sp                                           concat the input with a space
                                                     e.g.: ["cd-", "Adf!", " "]
                                                     (this is to handle index = 0)
 s'r.=                                               `s` is the first member, and `r` is the second
           Rotate[s,                         ]       rotate `s` by:
                                  ALPHA'alpha          over uppercase and lowercase alphabets:
                        Has&r[0]=>                       test if r[0] is in each alphabet
                                                       e.g.: [true, false]
                    &`-!                               subtract the second from the first
                                                       e.g.: (true - false) = 1 - 0 = 1
                                                     s is rotated according to the following map:
                                                       uppercase =>  1
                                                       symbol    =>  0
                                                       lowercase => -1
                                              +r     append the right portion of the string

Im Wesentlichen dreht diese Funktion den linken Teil der Zeichenfolge entsprechend dem ersten Zeichen des rechten Teils.

Holzkohle , 20 Bytes

ＦＳ≔⁺⭆ω§ω⁻⁺λ№αι№βιιωω

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

ＦＳ

Schleife über die eingegebenen Zeichen.

≔⁺⭆ω§ω⁻⁺λ№αι№βιιω

Ordnen Sie die Zeichenfolge der bisher gesammelten Zeichen zu, und indizieren Sie sie zyklisch in die bisher gesammelten Zeichen, wobei der Index inkrementiert oder dekrementiert wird, wenn das aktuelle Zeichen Groß- oder Kleinbuchstaben enthält. Damit ist die Drehung abgeschlossen. Das nächste Zeichen wird dann verkettet und das Ergebnis dem String zurückgegeben.

ω

Drucken Sie das Ergebnis.

R , 107 102 100 Bytes

Massiv, weil Rs Saitenmanipulation sperrig ist. Kann es jemand unter 100 bekommen?

-5 Bytes mit dem Trick "Setze Schleifenvariablen auf F, um Initialisierung zu vermeiden".

-2 Bytes, wenn angenommen wird, dass alle Zeichen druckbar sind und 2*!k%%97>25nicht 2*k%in%97:122zum Testen von Kleinbuchstaben verwendet werden, sondern mit Operatorpriorität.

function(x){for(k in u<-utf8ToInt(x))u[1:F-1]=u[(1:(F=F+1)+k%in%65:90-2*!k%%97>25)%%F];intToUtf8(u)}

Probieren Sie es online!

Japt , 25 23 Bytes

Ich gebe auf, kann es nicht kürzer machen

-2 Bytes von @ETHproductions

£=¯Y éXè\a -Xè\A)+UsYÃU

£=¯Y éXè\a -Xè\A)+UsYÃU     Full program. Implicit input U
£                           map each char
 =                          set U equal to:
  ¯Y                        U sliced to current mapped value
    éXè\a -Xè\A)            and rotated left or right 1 char
                +UsY        append the non-sliced U value
                      ÃU    Output U    

Probieren Sie es online!

Retina , 67 64 58 Bytes

^
¶
+`(.*)(.)¶([a-z])|(.)(.*)¶([A-Z])|¶(.)
$2$1$3$5$4$6$7¶

-9 Bytes dank @Neil Entfernen der drei unnötigen, die ?ich hinzugefügt hatte, sowie der unnötigen(.*) im Sonst-Fall.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle . (ANMERKUNG: Ausgaben mit einer nachgestellten Zeile. Die Kopfzeile in der Testsuite dient zum Testen jeder Eingabezeile als separater Testfall, und die Fußzeile dient zum Entfernen dieser nachgestellten Zeile, um eine kompaktere Ausgabe zu erzielen.)

Erläuterung:

Stellen Sie eine neue Zeile vor die Eingabe:

^
¶

Ersetzen Sie weiter, solange wir eine Übereinstimmung finden können:

+`

Alles andere sind drei verschiedene Schecks, die zusammengeführt werden:

Wenn das Zeichen direkt nach dem Zeilenumbruch ein Kleinbuchstabe ist: Drehen Sie alles vor dem Zeilenumbruch einmal nach rechts und hängen Sie dann das Zeichen und den Zeilenumbruch an:

(.*)(.)¶([a-z])
$2$1$3¶

Wenn das Zeichen direkt nach der neuen Zeile ein Großbuchstabe ist: Drehen Sie alles vor der neuen Zeile einmal nach links und hängen Sie dann das Zeichen und die neue Zeile an:

(.)(.*)¶([A-Z])
$2$1$3¶

Andernfalls (weder Klein- noch Großbuchstaben): Verschieben Sie die neue Zeile für die nächste Iteration einfach einmal nach rechts:

¶(.)
$1¶

Diese drei Prüfungen werden mit regulären ODER-Anweisungen ( |) und Ersetzungen größerer Gruppen zusammengeführt, um das Verhalten wie folgt zu verbessern if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 Bytes

ttYo-ZS"X@q:&)w@YSwh

Probieren Sie es online!

-4 Bytes dank Luis Mendo.

Konvertiert Groß- / Kleinschreibung / Nichtbuchstaben in [-1,0,1] (erste Hälfte des Programms). Wendet die Schaltung nacheinander an (zweite Hälfte). Ich mache mir einen Hirnschaden, wenn es eine bessere Möglichkeit gibt, Groß- / Kleinschreibung auf [-1,0,1] abzubilden (siehe die zweite Version), und vielleicht eine Möglichkeit, die Zeichenfolge sofort umzukehren, um die beiden zu beseitigen wwird für das benötigt &).

C (Klappern) , 168 159 153 119 Bytes

g,i,j;f(char*a){for(i=0;a[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j),*a=g:isupper(a[i])?g=*a,bcopy(a+1,a,j),a[j]=g:0);}

-26 danke an @ceilingcat

Probieren Sie es online!

Pyth, 16 Bytes

em=+.>k-F}RGrBd2

Probieren Sie es hier aus!

Erläuterung:

em=+.>k-F}RGrBd2dQ    Autofill variables
 m               Q    for each d in Q (the input):
            rBd2       Take [d, swapcase(d)]
         }RG           Figure out which are in the lowercase alphabet (returns [1,0] for lowercase, [0,1] for uppercase, [0,0] for non-letters)
       -F              Fold on subtraction (1 for lowercase, -1 for uppercase, 0 for non-letter)
    .>k                Cycle the processed part (k) of the input right by ^ steps
   +            d      Add in the new character at the end
  =   k                Store new process step back into k (k starts as an empty string)
e                     Get the (e)nd step's output.