Entrada

Una cadena no vacía que consta de caracteres ASCII en el rango .$[32..126]$

Salida

La salida se obtiene aplicando rotaciones sucesivas a la cadena de entrada.

Para cada letra ( [a-zA-Z]) en la cadena de entrada, yendo de izquierda a derecha:

• Si la letra está en mayúscula, gire todos los caracteres anteriores una posición hacia la izquierda
• Si la letra está en minúscula, gire todos los caracteres delante de ella en una posición a la derecha

Ejemplo

Entrada: "Cb-Ad"

• La primera letra es una " C ". Deberíamos hacer una rotación hacia la izquierda, pero no hay caracteres antes de esta " C ". Entonces, no hay nada para rotar.
• La siguiente letra es una " b ". Giramos " C " a la derecha. Debido a que es un solo personaje, no se modifica.
• El carácter " - " no activa ninguna rotación, ya que no es una letra.
• La siguiente letra es una " A ". Giramos " Cb- " hacia la izquierda, lo que da " bC Ad"
• La cuarta y última letra es una " d ". Giramos " b-CA " hacia la derecha, lo que da " Ab-C d"

Por lo tanto, la salida esperada es " Ab-Cd ".

Reglas

• Puede tomar la entrada como una cadena o como una matriz de caracteres, lo que puede o no ser lo mismo, dependiendo de su idioma.
• También puede generar una matriz de caracteres en lugar de una cadena.
• Esto es ogl-edocf code-golf

Casos de prueba

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

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

Pruébalo aquí

Explicación

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

Pruébalo en línea!

Jalea , 14 bytes

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

Un enlace monádico que acepta una lista de caracteres que produce una lista de caracteres.

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Solución:

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

Ejemplos:

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

Explicación:

Iterar sobre la cadena de entrada, girando la salida anterior en 1, -1 o 0 dependiendo de su posición en la lista "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 (/)

Notas:

• -10 bytes con la inspiración de la solución 05AB1E

> <> , 45 43 bytes

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

Pruébalo en línea!

El hecho de que> <> tenga rotación de pila ayuda, pero tener que verificar el caso de la letra no lo hace.

Explicación:

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 inspirados en la respuesta de Curtis Bechtel (uso '@'<c,c<'['sobre elem c['A'..'Z']y el rango correspondiente para letras minúsculas).}

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

Pruébalo en línea!

Explicación / Ungolfed

El operador (!)toma una cadena no vacía xen la que podemos combinar patrones y un carácter:

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

Ahora podemos reducir la cola de la entrada de izquierda a derecha, comenzando con el primer carácter de la entrada usando:

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

Haskell , 122 92 bytes

Gracias a BWO por las sugerencias! También ahorré mucho al adoptar un enfoque ligeramente diferente al de mi respuesta original.

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

Pruébalo en línea!

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

Pruébalo en línea!

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}

Pruébalo en línea!

La entrada y la salida son matrices de caracteres.

El truco:

El código es bastante sencillo, excepto quizás la parte de rotación:

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

x es un solo carácter, que podría ser una letra, la primera expresión x=~/\W/devuelve nilsi es una letra y 0 en caso contrario. Si es 0, hemos terminado, si no, el lógico orverifica la segunda expresión: ?_<=>xdevuelve -1 para mayúsculas y 1 para minúsculas. Entonces la rotación es:

• -1 (1 a la izquierda) para mayúsculas
• +1 (1 a la derecha) para minúsculas
• 0 (sin rotación) si no es una letra

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

Pruébalo en línea!

Explicación:

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}

Pruébalo en línea!

Funciona en una variedad de caracteres.

Japt, 17 16 14 bytes

Toma la entrada como una matriz de caracteres, genera una cadena

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

Intentalo

Explicación

 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?

Jalea , 19 bytes

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

Pruébalo en línea!

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

Puerto de respuesta de JavaScript @ShieruAsakoto , así que asegúrese de votarlo.

Pruébalo en línea.

Explicación:

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

Ejecutar y depurarlo

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

Mucho intercambio de pila que probablemente sea innecesario. Realmente me gustaría entender esto más, pero estaba luchando con el orden de la pila. Tal vez alguien pueda resolverlo si está aburrido. Seguiremos trabajando en ello.

Adjunto , 69 bytes

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

Pruébalo en línea!

Explicación

Forma general

La función generalmente se ve así:

~Fold[{...}]#Iota

Que se pliega {...}sobre cada miembro en el rango de 0a #input - 1( Iota), comenzando con la entrada como semilla.

La función interna

La siguiente función se llama como f[building, index]y se llama con cada índice de 0a #inputexclusivo. @SplitAtinvoca SplitAtestos argumentos, dividiendo la cadena de entrada 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

Esencialmente, esta función gira la porción izquierda de la cadena de acuerdo con el primer carácter de la porción derecha.

Carbón de leña , 20 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

ＦＳ

Pase sobre los caracteres de entrada.

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

Asigne sobre la cadena de caracteres recopilados hasta el momento, indexando cíclicamente en los caracteres recopilados hasta el momento con el índice aumentado o disminuido si el carácter actual es mayúscula o minúscula, respectivamente. Esto completa la rotación. El siguiente carácter se concatena y el resultado se asigna nuevamente a la cadena.

ω

Imprime el resultado.

R , 107 102 100 bytes

Masivo porque el manipulador de cuerdas de R es voluminoso. ¿Alguien puede obtenerlo por debajo de 100?

-5 bytes usando el truco "establecer variables de bucle en F para evitar inicializar"

-2 bytes asumiendo que todos los caracteres son imprimibles y que se usan en 2*!k%%97>25lugar de 2*k%in%97:122probar en minúsculas, usando la precedencia del operador.

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

Pruébalo en línea!

Japt , 25 23 bytes

Me rindo, no puedo hacerlo más corto

-2 bytes 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    

Pruébalo en línea!

Retina , 67 64 58 bytes

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

-9 bytes gracias a que @Neil eliminó los tres innecesarios ?que había agregado, así como los innecesarios (.*)en el caso contrario.

Pruébelo en línea o verifique todos los casos de prueba . (NOTA: Salidas con una nueva línea final. El encabezado en el conjunto de pruebas es probar cada línea de entrada como un caso de prueba separado, y el pie de página es eliminar esa nueva línea posterior para una salida más compacta).

Explicación:

Anteponer una nueva línea antes de la entrada:

^
¶

Continúe reemplazando mientras podamos encontrar una coincidencia:

+`

Todo lo demás son tres controles diferentes combinados:

Si el carácter justo después de la nueva línea es letra minúscula: gire todo antes de la nueva línea una vez hacia la derecha, y luego agregue ese carácter y la nueva línea:

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

Si el carácter justo después de la nueva línea es una letra mayúscula: gire todo antes de la nueva línea una vez hacia la izquierda, y luego agregue ese carácter y la nueva línea:

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

De lo contrario (ni una letra minúscula ni mayúscula): simplemente desplace la nueva línea una vez hacia la derecha para la próxima 'iteración':

¶(.)
$1¶

Estas tres comprobaciones anteriores se fusionan con declaraciones OR de expresión regular ( |) y reemplazos de grupos más grandes para que actúe como un if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 bytes

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

Pruébalo en línea!

-4 bytes gracias a Luis Mendo.

Convierte mayúsculas / minúsculas / no letras a [-1,0,1] (primera mitad del programa). Aplica circshift consecutivamente (segunda mitad). Estoy arruinando mi cerebro si hay una mejor manera de asignar mayúsculas / minúsculas a [-1,0,1] (ver la segunda versión), y tal vez una forma de invertir la cadena de inmediato para deshacerse de los dos wEs necesario para el &).

C (sonido metálico) , 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 gracias a @ceilingcat

Pruébalo en línea!

Pyth, 16 bytes

em=+.>k-F}RGrBd2

Pruébalo aquí!

Explicación:

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.