Eine Ogl-Edocf-Herausforderung


22

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

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!"
code-golf  string  code-golf  string  code-golf  string  parsing  brainfuck  code-challenge  python  hello-world  error-message  code-golf  string  code-golf  number  integer  counting  subsequence  code-golf  string  cipher  code-golf  array-manipulation  arithmetic  integer  matrix  code-golf  math  sequence  code-golf  restricted-source  pi  popularity-contest  cops-and-robbers  polyglot  popularity-contest  cops-and-robbers  polyglot  code-golf  file-system  king-of-the-hill  code-golf  number  sequence  integer  rational-numbers  string  code-challenge  source-layout  code-golf  ascii-art  king-of-the-hill  code-golf  array-manipulation  sorting  code-golf  string  code-golf  restricted-source  source-layout  tips  math  code-challenge  permutations  logic-gates  code-golf  number  random  integer  code-golf  math  code-golf  math  number  decision-problem  king-of-the-hill  python  board-game  code-challenge  brainfuck  busy-beaver  code-golf  number  cops-and-robbers  polyglot  obfuscation  answer-chaining  code-golf  number  integer  conversion  code-golf  string  parsing  code-golf  ascii-art  number  king-of-the-hill  javascript  code-golf  source-layout  radiation-hardening  code-golf  array-manipulation  matrix  code-golf  string  graph-theory  code-golf  array-manipulation  decision-problem  code-golf  string  ascii-art  code-golf  string  code-golf  array-manipulation 

Antworten:


5

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.

Mit können Sie .Udie Eingabe vom 2. Wert reduzieren. Auf diese Weise können Sie =kvom Anfang bis )kzum Ende wechseln, da sowohl die Eingabe als auch das Drucken implizit sind. Vollständiges Programm: .U+.>b-}ZG}Zr1GZ- Link
Sok


3

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

Ich kenne Jelly nicht so gut, sollte aber nicht Idasselbe tun wie ḅ-in diesem Fall? Es scheint hier zu funktionieren , aber nicht in Ihrem Code. Ich bin ein bisschen verwirrt, warum. Gibt es auch einen Befehl, um die gesamten Listen als getrennte Elemente in den Stapel in Jelly zu verschieben (Warten Sie, Jelly ist keine stapelbasierte Sprache, oder?)? In diesem Fall kann ein einfaches Subtrahieren verwendet werden, und Sie brauchen das Negat auch nicht, wenn ich mich nicht irre (ähnlich wie bei der letzten Änderung in meiner 05AB1E-Antwort).
Kevin Cruijssen

1
Iergibt eine Liste - hinzufügen ŒṘ , um eine vollständige Darstellung zu sehen . So ØẠŒHċ€IṪN⁸ṙ;ð/funktionieren würde.
Jonathan Allan

Ah ok, das macht Sinn. Danke für die Erklärung. Schöne Antwort übrigens, habe es gestern schon hochgeschrieben. :)
Kevin Cruijssen

3

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)

3

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

3

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

2

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]

2

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!


Sie können das Muster-Match von Swap (#), Nutzung ,über &&, verwenden [l!!0,c]über head l:[c], 1>0statt True, brauchen Sie nicht zu zählen , f=und Sie können nicht leere Eingabe übernehmen , die das spart l==[]guard - Sie 13 Bytes speichern: Versuchen Sie es online!
19.

Btw. Ich habe das isLowerund isUpperGolf in meinem Beitrag verwendet . Ich hoffe, dass du damit einverstanden bist, sonst werde ich meine Bearbeitung rückgängig machen.
19.

@ BWO Danke für die Vorschläge, und mach weiter so!
Curtis Bechtel

2

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


Es ist wahrscheinlich kürzer eval(`regex`)als die Verwendung des Konstruktors
Downgoat

@Downgoat Ich fürchte, das ist nicht der Fall, weil die Schrägstriche in dem Fall benötigt werden eval(`regex`), also -2 + 2 = 0, und daher hilft es nicht, die Anzahl der Bytes zu reduzieren.
Shieru Asakoto

@Downgoat Es lohnt sich, eval()wenn mindestens ein Flag verwendet wird: eval('/./g')ist 3 Byte kürzer als RegExp('.','g').
Arnauld

@Arnauld Das stimmt, aber ich benutze hier keine Flaggen.
Shieru Asakoto

@ ShieruAsakoto (Sicher. Mein Kommentar wurde in erster Linie an Downgoat gerichtet, um zu erklären, warum es sich nicht lohnt, es hier zu tun.)
Arnauld

2

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

2

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 
]


2

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?


1

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

1

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.


1

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.


1

Holzkohle , 20 Bytes

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

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

FS

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.


1

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!


1
Kommen Sie zu uns (ich bin es gerade ...) in den R Golf Chatroom , um ein paar Ideen zu sammeln! Ich vermute, dass das Permutationsstück so kurz ist, wie es bei diesem Ansatz sein kann, aber ich kann nicht sicher sagen, dass ich es nicht selbst ausprobiert habe.
Giuseppe

1

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!


Leider kann ich auch keinen kürzeren Weg finden éXè\a -Xè\A:-( Sie könnten zwei Bytes sparen, indem Sie das doppelte Leerzeichen in a ändern )und entfernen ©(implizites Komma bedeutet, dass Ues noch ausgegeben wird)
ETHproductions

Speichern Sie weitere 2 Bytes, ÃUindem Sie das -hFlag ablegen und verwenden .
Zottelig

1

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 ...:


Ich glaube nicht, dass Sie das ?s brauchen - wenn es noch nichts zu drehen gibt, spielt es keine Rolle, ob es einen Buchstaben gibt.
Neil

1
Das Ersetzen (.*)¶(.)durch $1$2¶kann auch auf das Ersetzen ¶(.)durch vereinfacht werden, $1¶da das Ergebnis durch das andere Capture nicht beeinflusst wird.
Neil

@ Neil Ah, natürlich danke. -9 Bytes genau dort! :)
Kevin Cruijssen

1

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 &).


1

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!


Schlagen Sie g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)statta[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
ceilingcat

0

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.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.