Un desafío ogl-edocf

22

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

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

Respuestas:

5

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.

fuente
Puede usar .Upara reducir la entrada del segundo valor. Esto le permite caer =kdesde el principio y )kdesde el final, ya que tanto la entrada como la impresión están implícitas. Programa completo: .U+.>b-}ZG}Zr1GZ- enlace
Sok
3

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
Jonathan Allan
fuente
No conozco a Jelly demasiado bien, pero ¿no debería Ihacer lo mismo que ḅ-en este caso? Parece funcionar aquí , pero no en su código. Estoy un poco confundido por qué. Además, ¿hay un comando para enviar las listas enteras como elementos separados a la pila en Jelly (espera, Jelly no es un lenguaje basado en la pila, ¿verdad?)? En ese caso, se puede usar una simple resta y tampoco necesitará la negación si no me equivoco (similar a la última edición en mi respuesta 05AB1E).
Kevin Cruijssen
1
Iproduce una lista: agregue ŒṘ para ver una representación completa . Así ØẠŒHċ€IṪN⁸ṙ;ð/funcionaría.
Jonathan Allan
Ah de acuerdo, eso tiene sentido. Gracias por la explicación. Buena respuesta por cierto, ya lo voté ayer. :)
Kevin Cruijssen
3

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)
Kevin Cruijssen
fuente
3

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
callejero
fuente
3

> <> , 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
Jo King
fuente
2

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]
ბიმო
fuente
2

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!

Curtis Bechtel
fuente
Puede cambiar el patrón-partido de (#), el uso ,más &&, utiliza [l!!0,c]más head l:[c], 1>0en lugar de True, no es necesario contar f=y se puede asumir de entrada no está vacía lo que ahorra la l==[]guardia - que le ahorra 13 bytes: Pruébelo en línea!
ბიმო
Por cierto. Utilicé el isLowery isUppergolf en mi envío , espero que estés de acuerdo con eso, de lo contrario revertiré mi edición.
ბიმო
@BWO Gracias por las sugerencias, y ¡adelante!
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

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

Shieru Asakoto
fuente
Probablemente sea más corto eval(`regex`)que usar el constructor
Downgoat
@Downgoat Me temo que ese no es el caso porque las barras son necesarias en el caso de eval(`regex`), por lo que -2 + 2 = 0 y, por lo tanto, no ayuda a reducir el recuento de bytes.
Shieru Asakoto
@Downgoat Vale la pena usar eval()cuando se usa al menos un indicador: eval('/./g')es 3 bytes más corto que RegExp('.','g').
Arnauld
@Arnauld Eso es cierto, pero no uso banderas aquí.
Shieru Asakoto
@ShieruAsakoto (Claro. Mi comentario fue dirigido principalmente a Downgoat para explicar por qué no vale la pena hacerlo aquí.)
Arnauld
2

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
GB
fuente
2

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 
]
Galen Ivanov
fuente
2

Perl 6 , 47 bytes

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

Pruébalo en línea!

Funciona en una variedad de caracteres.

nwellnhof
fuente
Ah, habría optado por usar cmp y uc / lc, pero eso llega a 49 bytes
Jo King
1
Maldición, 48 bytes Casi atrapado
Jo King
2

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?
Lanudo
fuente
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;}

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
Kevin Cruijssen
fuente
1

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.

Multi
fuente
1

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.

Conor O'Brien
fuente
1

Carbón de leña , 20 bytes

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

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

FS

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.

Neil
fuente
1

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!

J.Doe
fuente
1
¡Únase a nosotros (soy solo yo ahora ...) en la sala de chat de golf R para intercambiar algunas ideas! Supongo que la pieza de permutación es tan corta como puede ser con este enfoque, pero no haberlo probado yo mismo, no puedo decir con certeza.
Giuseppe
1

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!

Luis felipe De jesus Munoz
fuente
Lamentablemente, tampoco puedo encontrar una forma más corta de hacerlo éXè\a -Xè\A:-( Podría ahorrar dos bytes cambiando el doble espacio a a )y eliminando ©(la coma implícita significa que Utodavía se
emite
Ahorre otros 2 bytes soltando ÃUy usando la -hbandera.
Shaggy
1

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

Kevin Cruijssen
fuente
No creo que necesite la ?s: si todavía no hay nada que rotar, no importa si hay una letra.
Neil
1
Además, reemplazar (.*)¶(.)con $1$2¶se puede simplificar a reemplazar ¶(.)con, $1¶ya que la otra captura no afecta el resultado.
Neil
@Neil Ah, por supuesto, gracias. -9 bytes justo allí! :)
Kevin Cruijssen
1

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

Sanchises
fuente
1

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!

Logern
fuente
Sugerir en g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)lugar dea[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
ceilingcat
0

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.
Steven H.
fuente