Contribution

Une chaîne mélangée non vide composée de caractères ASCII dans la plage .$[32..126]$

Sortie

La sortie est obtenue en appliquant des rotations successives à la chaîne d'entrée.

Pour chaque lettre ( [a-zA-Z]) de la chaîne d'entrée, de gauche à droite:

• si la lettre est en majuscule, faites pivoter tous les caractères devant elle d'une position vers la gauche
• si la lettre est en minuscule, faites pivoter tous les caractères devant elle d'une position vers la droite

Exemple

Entrée: "Cb-Ad"

• La première lettre est un " C ". Nous devrions faire une rotation vers la gauche, mais il n'y a pas de caractère avant ce " C ". Il n'y a donc rien à faire pivoter.
• La lettre suivante est un " b ". Nous tournons " C " vers la droite. Comme il s'agit d'un seul caractère, il reste inchangé.
• Le caractère " - " ne déclenche aucune rotation, car ce n'est pas une lettre.
• La lettre suivante est un " A ". Nous tournons " Cb- " vers la gauche, ce qui donne " bC Ad"
• La quatrième et dernière lettre est un " d ". Nous tournons " b-CA " vers la droite, ce qui donne " Ab-C d"

Par conséquent, la sortie attendue est " Ab-Cd ".

Règles

• Vous pouvez prendre l'entrée comme une chaîne ou comme un tableau de caractères - qui peut ou non être la même chose, selon votre langue.
• Vous pouvez également générer un tableau de caractères au lieu d'une chaîne.
• Ceci est OGL-edocf Code-golf

Cas de test

"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 20 octets

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

Essayez-le ici

Explication

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 octets

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

Essayez-le en ligne!

Gelée , 14 octets

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

Un lien monadique acceptant une liste de caractères qui donne une liste de caractères.

Essayez-le en ligne! Ou voir le suite de tests .

Comment?

ØẠŒ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 octets

õsvy.uy.l-._y«

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

õ            # 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 octets

Solution:

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

Exemples:

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!"

Explication:

Itérer sur la chaîne d'entrée, en faisant tourner la sortie précédente de 1, -1 ou 0 selon sa position dans la liste "a-zA-Z".

""{.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 (/)

Remarques:

• -10 octets en s'inspirant de la solution 05AB1E

> <> , 45 43 octets

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

Essayez-le en ligne!

Le fait que> <> ait une rotation de pile aide, mais ne pas avoir à vérifier la casse de la lettre.

Explication:

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 octets

^{-10 octets inspirés de la réponse de Curtis Bechtel (à utiliser '@'<c,c<'['sur elem c['A'..'Z']et sur la plage correspondante pour les lettres minuscules).}

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

Essayez-le en ligne!

Explication / Non golfé

L'opérateur (!)prend une chaîne non vide xsur laquelle nous pouvons faire correspondre un motif et un caractère:

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

Maintenant, nous pouvons réduire la queue de l'entrée de gauche à droite, en commençant par le premier caractère de l'entrée en utilisant:

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

Haskell , 122 92 octets

Merci à BWO pour les suggestions! J'ai également économisé beaucoup en adoptant une approche légèrement différente de ma réponse d'origine.

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

Essayez-le en ligne!

JavaScript (Node.js) , 116 102 octets

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

Essayez-le en ligne!

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

Rubis , 51 octets

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

Essayez-le en ligne!

L'entrée et la sortie sont des tableaux de caractères

L'astuce:

Le code est assez simple, sauf peut-être la partie rotation:

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

x est un seul caractère, qui pourrait être une lettre, la première expression x=~/\W/renvoie nils'il s'agit d'une lettre, et 0 sinon. Si c'est 0, nous avons terminé, sinon, la logique orvérifie la deuxième expression: ?_<=>xrenvoie -1 pour les majuscules et 1 pour les minuscules. La rotation est donc:

• -1 (1 à gauche) pour les majuscules
• +1 (1 à droite) pour les minuscules
• 0 (pas de rotation) si ce n'est pas une lettre

Rouge , 110 octets

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]

Essayez-le en ligne!

Explication:

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 octets

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

Essayez-le en ligne!

Fonctionne sur un tableau de caractères.

Japt, 17 16 14 octets

Prend l'entrée comme un tableau de caractères, produit une chaîne

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

Essayez-le

Explication

 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?

Gelée , 19 octets

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

Essayez-le en ligne!

Java 10, 149 119 octets

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

Port de @ShieruAsakoto Réponse JavaScript , alors assurez-vous de le voter.

Essayez-le en ligne.

Explication:

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 octets

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

Exécuter et déboguer

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

Beaucoup de permutation de pile, ce qui est probablement inutile. J'aimerais vraiment en savoir plus, mais j'avais du mal avec l'ordre de la pile. Peut-être que quelqu'un peut comprendre s'il s'ennuie. Continuera à y travailler.

Attaché , 69 octets

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

Essayez-le en ligne!

Explication

Forme générale

La fonction ressemble généralement à ceci:

~Fold[{...}]#Iota

Qui se replie {...}sur chaque membre dans la plage de 0à #input - 1( Iota), en commençant par l'entrée en tant que graine.

La fonction intérieure

La fonction suivante est appelée as f[building, index]et est appelée avec chaque index de 0à #inputexclusif. @SplitAtappelle SplitAtces arguments, divisant la chaîne d'entrée 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

Essentiellement, cette fonction fait tourner la partie gauche de la chaîne en fonction du premier caractère de la partie droite.

Fusain , 20 octets

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

Essayez-le en ligne! Le lien est vers la version détaillée du code. Explication:

ＦＳ

Faites une boucle sur les caractères saisis.

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

Mappez sur la chaîne de caractères collectés jusqu'à présent, indexation cyclique dans les caractères collectés jusqu'à présent avec l'index incrémenté ou décrémenté si le caractère actuel est respectivement en majuscule ou en minuscule. Ceci termine la rotation. Le caractère suivant est ensuite concaténé et le résultat est affecté à nouveau à la chaîne.

ω

Imprimez le résultat.

R , 107 102 100 octets

Massif car la manipulation des cordes de R est volumineuse. Quelqu'un peut-il obtenir moins de 100?

-5 octets en utilisant l'astuce "définir les variables de boucle sur F pour éviter l'initialisation".

-2 octets en supposant que tous les caractères sont imprimables et en utilisant 2*!k%%97>25plutôt qu'en 2*k%in%97:122testant les minuscules, en utilisant la priorité de l'opérateur.

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)}

Essayez-le en ligne!

Japt , 25 23 octets

J'abandonne, je ne peux pas le raccourcir

-2 octets de @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    

Essayez-le en ligne!

Rétine , 67 64 58 octets

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

-9 octets grâce à @Neil supprimant les trois inutiles ?que j'avais ajoutés, ainsi que les inutiles(.*) dans le cas .

Essayez-le en ligne ou vérifiez tous les cas de test . (REMARQUE: sorties avec une nouvelle ligne de fin. L'en-tête de la suite de tests consiste à tester chaque ligne d'entrée en tant que scénario de test distinct et le pied de page supprime cette nouvelle ligne de fin pour une sortie plus compacte.)

Explication:

Ajoutez une nouvelle ligne avant l'entrée:

^
¶

Continuez à remplacer tant que nous pouvons trouver une correspondance:

+`

Tout le reste est constitué de trois contrôles différents fusionnés:

Si le caractère juste après la nouvelle ligne est une lettre minuscule: faites tout tourner avant la nouvelle ligne vers la droite, puis ajoutez ce caractère et la nouvelle ligne:

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

Si le caractère juste après la nouvelle ligne est une lettre majuscule: faites pivoter tout avant la nouvelle ligne vers la gauche, puis ajoutez ce caractère et la nouvelle ligne:

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

Sinon (ni une lettre minuscule ni une lettre majuscule): déplacez simplement la nouvelle ligne une fois vers la droite pour la prochaine 'itération':

¶(.)
$1¶

Ces trois vérifications ci-dessus sont fusionnées avec des instructions regex OR ( |) et des remplacements de groupe plus importants pour le faire agir comme un if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 octets

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

Essayez-le en ligne!

-4 octets grâce à Luis Mendo.

Convertit les majuscules / minuscules / non-lettres en [-1,0,1] (première moitié du programme). S'applique consécutivement (deuxième mi-temps). Je suis en train de détruire mon cerveau s'il existe un meilleur moyen de mapper les majuscules / minuscules à [-1,0,1] (voir la deuxième version), et peut-être un moyen d'inverser immédiatement la chaîne afin de se débarrasser des deux west nécessaire pour le &).

C (tintement) , 168 159 153 119 octets

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 grâce à @ceilingcat

Essayez-le en ligne!

Pyth, 16 octets

em=+.>k-F}RGrBd2

Essayez-le ici!

Explication:

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.