Um desafio ogl-edocf

22

Entrada

Uma sequência aleatória não vazia que consiste em caracteres ASCII no intervalo .[32..126]

Saída

A saída é obtida aplicando rotações sucessivas na sequência de entrada.

Para cada letra ( [a-zA-Z]) na sequência de entrada, da esquerda para a direita:

  • se a letra estiver em maiúscula, gire todos os caracteres à sua frente em uma posição à esquerda
  • se a letra estiver em minúscula, gire todos os caracteres à sua frente em uma posição para a direita

Exemplo

Entrada: "Cb-Ad"

  • A primeira letra é um " C ". Deveríamos fazer uma rotação para a esquerda, mas não há caracteres antes deste " C ". Portanto, não há nada para girar.
  • A próxima letra é um " b ". Nós giramos " C " para a direita. Por ser um único personagem, ele permanece inalterado.
  • O caractere " - " não aciona nenhuma rotação, pois não é uma letra.
  • A próxima letra é um " A ". Giramos " Cb- " para a esquerda, o que indica " bC Ad"
  • A quarta e última letra é um " d ". Giramos " b-CA " para a direita, o que indica " Ab-C d"

Portanto, a saída esperada é " Ab-Cd ".

Regras

  • Você pode receber a entrada como uma string ou como uma matriz de caracteres - que podem ou não ser a mesma coisa, dependendo do seu idioma.
  • Você também pode gerar uma matriz de caracteres em vez de uma string.
  • Este é

Casos de teste

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

Respostas:

5

Pitão, 21 20 bytes

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

Experimente aqui

Explicação

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.

fonte
Você pode usar .Upara reduzir a entrada do 2º valor. Isso permite que você saia =kdo início e )kdo final, pois a entrada e a impressão estão implícitas. Programa completo: .U+.>b-}ZG}Zr1GZ- link
Sok
4

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

Experimente online!

TFeld
fonte
3

Gelatina , 14 bytes

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

Um link monádico que aceita uma lista de caracteres que gera uma lista de caracteres.

Experimente online! Ou veja a suíte de testes .

Quão?

ØẠŒ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
fonte
Não conheço Jelly muito bem, mas não deveria Ifazer o mesmo que ḅ-neste caso? Parece funcionar aqui , mas não no seu código. Estou um pouco confuso por quê. Além disso, existe um comando para enviar as listas inteiras como itens separados para a pilha no Jelly (espere, o Jelly não é um idioma baseado na pilha, é ..)? Nesse caso, uma subtração simples pode ser usada e você também não precisará negar se não me engano (semelhante à última edição da minha resposta 05AB1E).
Kevin Cruijssen
1
Iproduz uma lista - adicione ŒṘ para ver uma representação completa . Então ØẠŒHċ€IṪN⁸ṙ;ð/funcionaria.
Jonathan Allan
Ah, ok, isso faz sentido. Obrigada pelo esclarecimento. Boa resposta btw, já votou ontem ontem. :)
Kevin Cruijssen
3

05AB1E , 18 17 16 14 bytes

õsvy.uy.l-._y«

Experimente online ou verifique todos os casos de teste .

Explicação:

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

K4 , 43 33 bytes

Solução:

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

Exemplos:

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

Explicação:

Itere sobre a sequência de entrada, girando a saída anterior em 1, -1 ou 0, dependendo da posição na 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 com inspiração na solução 05AB1E
rua
fonte
3

> <> , 45 43 bytes

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

Experimente online!

O fato de que> <> tem rotação de pilha ajuda, mas ter que verificar o caso da letra não.

Explicação:

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
Brincadeira
fonte
2

Haskell , 101 91 bytes

-10 bytes inspirados na resposta de Curtis Bechtel (use '@'<c,c<'['acima elem c['A'..'Z']e o intervalo correspondente 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

Experimente online!

Explicação / Ungolfed

O operador (!)pega uma string não vazia xna qual podemos fazer a correspondência de padrões e um caractere:

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

Agora podemos reduzir a cauda da entrada da esquerda para a direita, começando com o primeiro caractere da entrada usando:

\b a -> b!a ++ [a]
ბიმო
fonte
2

Haskell , 122 92 bytes

Obrigado a BWO pelas sugestões! Também economizei muito ao adotar uma abordagem ligeiramente diferente da minha resposta 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

Experimente online!

Curtis Bechtel
fonte
Você pode trocar a correspondência de padrões de (#), usar ,sobre &&, usar [l!!0,c]sobre head l:[c], em 1>0vez de Truenão precisar contar f=e pode assumir entradas não vazias que salvam a l==[]guarda - economizando 13 bytes: experimente on-line!
ბიმო
Btw. Eu usei o isLowere isUppergolf na minha submissão , espero que você esteja bem com isso, caso contrário eu reverterá minha edição.
ბიმო
@BWO Obrigado pelas sugestões, e siga em frente!
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

Experimente 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

Shieru Asakoto
fonte
É provavelmente mais curto para fazer eval(`regex`)do que usando o construtor
Downgoat
@Downgoat Acho que não é o caso, porque as barras são necessárias no caso de eval(`regex`), então -2 + 2 = 0 e, portanto, não ajuda a reduzir a contagem de bytes.
Shieru Asakoto 19/09/18
@Downgoat Vale a pena usar eval()quando pelo menos um sinalizador é usado: eval('/./g')é 3 bytes menor que RegExp('.','g').
Arnauld
@ Arnauld Isso é verdade, mas eu não uso bandeiras aqui.
Shieru Asakoto
@ShieruAsakoto (certeza que meu comentário foi dirigido principalmente aos Downgoat para explicar por que não vale a pena fazê-lo aqui..)
Arnauld
2

Ruby , 51 bytes

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

Experimente online!

Entrada e saída são matrizes de caracteres

O truque:

O código é bem direto, exceto talvez a parte de rotação:

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

x é um caractere único, que pode ser uma letra, a primeira expressão x=~/\W/retorna nilse for uma letra e 0, caso contrário. Se for 0, terminamos; caso contrário, a lógica orverifica a segunda expressão: ?_<=>xretorna -1 para maiúscula e 1 para minúscula. Então a rotação é:

  • -1 (1 à esquerda) para maiúsculas
  • +1 (1 à direita) para minúsculas
  • 0 (sem rotação) se não for uma letra
GB
fonte
2

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

Experimente online!

Explicação:

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

Perl 6 , 47 bytes

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

Experimente online!

Funciona em uma variedade de caracteres.

Nwellnhof
fonte
Ah, eu teria usado o cmp e o uc / lc, mas isso chega a 49 bytes
Jo King
1
Caramba, 48 bytes Quase apanhados #
Jo King
2

Japonês, 17 16 14 bytes

Recebe entrada como uma matriz de caracteres, gera uma string

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

Tente


Explicação

 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?
Shaggy
fonte
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;}

Porto da resposta JavaScript @ShieruAsakoto , por isso, certifique-se de que o vota.

Experimente online.

Explicação:

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
fonte
1

Stax , 32 bytes

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

Execute e depure

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

Muita troca de pilhas, o que provavelmente é desnecessário. Eu realmente gostaria que isso acontecesse mais, mas estava lutando com a ordem da pilha. Talvez alguém possa descobrir se está entediado. Continuará trabalhando nisso.

Multi
fonte
1

Anexo , 69 bytes

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

Experimente online!

Explicação

Forma geral

A função geralmente se parece com isso:

~Fold[{...}]#Iota

Que se dobra para {...}cima de cada membro na gama a partir 0de #input - 1( Iota), começando com a entrada como uma semente.

A função interna

A função a seguir é chamada como f[building, index]e é chamada com cada índice de 0para #inputexclusivo. @SplitAtchama SplitAtesses argumentos, dividindo a sequência 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

Essencialmente, essa função gira a parte esquerda da string de acordo com o primeiro caractere da parte direita.

Conor O'Brien
fonte
1

Carvão , 20 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

FS

Faça um loop sobre os caracteres de entrada.

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

Mapeie a cadeia de caracteres coletados até o momento, indexando ciclicamente os caracteres coletados até o momento com o índice incrementado ou decrementado se o caractere atual estiver em maiúsculas ou minúsculas, respectivamente. Isso completa a rotação. O próximo caractere é concatenado e o resultado atribuído novamente à string.

ω

Imprima o resultado.

Neil
fonte
1

R , 107 102 100 bytes

Maciço porque o manip de corda de R é volumoso. Alguém pode obtê-lo abaixo de 100?

-5 bytes usando o truque "definir variáveis ​​de loop como F para evitar a inicialização".

-2 bytes, assumindo que todos os caracteres são imprimíveis e usando em 2*!k%%97>25vez de 2*k%in%97:122testar letras minúsculas, usando a precedência do 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)}

Experimente online!

J.Doe
fonte
1
Venha se juntar a nós (sou apenas eu agora ...) na sala de bate - papo de golfe R para dar algumas dicas! Meu palpite é que a peça de permutação é a mais curta possível com essa abordagem, mas sem ter tentado eu mesma, não posso dizer com certeza.
Giuseppe
1

Japonês , 25 23 bytes

Eu desisto, Não posso torná-lo mais curto

-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    

Experimente online!

Luis felipe De jesus Munoz
fonte
Infelizmente, eu não posso encontrar um caminho mais curto para fazer éXè\a -Xè\Aqualquer :-( Você poderia salvar dois bytes, alterando o espaço duplo a um ), e removendo ©(meio vírgula implícitas que Uainda é emitido)
ETHproductions
Salve outros 2 bytes soltando ÃUe usando a -hbandeira.
Shaggy
1

Retina , 67 64 58 bytes

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

-9 bytes graças ao @Neil removendo os três desnecessários que ?eu adicionara e os desnecessários (.*)no caso contrário.

Experimente online ou verifique todos os casos de teste . (OBSERVAÇÃO: Saídas com uma nova linha final. O cabeçalho no conjunto de testes é testar cada linha de entrada como um caso de teste separado e o rodapé é remover essa nova linha final para obter uma saída mais compacta.)

Explicação:

Anexe uma nova linha antes da entrada:

^
¶

Continue substituindo enquanto encontrarmos uma correspondência:

+`

Tudo o resto são três verificações diferentes mescladas:

Se o caractere logo após a nova linha for uma letra minúscula: gire tudo antes da nova linha uma vez para a direita e anexe esse caractere e a nova linha:

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

Se o caractere logo após a nova linha for uma letra maiúscula: gire tudo antes da nova linha uma vez para a esquerda e acrescente esse caractere e a nova linha:

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

Senão (nem uma letra minúscula nem uma maiúscula): simplesmente mude a nova linha uma vez para a direita para a próxima 'iteração':

¶(.)
$1¶

Essas três verificações acima são mescladas com as expressões regex OR ( |) e substituições de grupos maiores para fazer com que funcione como if(lowercase) ... elseif(uppercase) ... else ...:

Kevin Cruijssen
fonte
Eu não acho que você precise do ?s - se não houver nada para rodar ainda, não importa se há uma carta.
Neil
1
Além disso, substituir (.*)¶(.)por $1$2¶pode ser simplificado para substituir ¶(.)por, $1¶pois a outra captura não afeta o resultado.
Neil
@ Neil Ah, claro, obrigado. -9 bytes ali! :)
Kevin Cruijssen
1

MATL , 20 bytes

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

Experimente online!

-4 bytes graças a Luis Mendo.

Converte maiúsculas / minúsculas / sem letra em [-1,0,1] (primeira metade do programa). Aplica a mudança de circuitos consecutivamente (segunda metade). Estou destruindo meu cérebro se há uma maneira melhor de mapear maiúsculas / minúsculas para [-1,0,1] (veja a segunda versão), e talvez uma maneira de reverter a string imediatamente, a fim de se livrar das duas wé necessário para o &).

Sanchises
fonte
1

C (clang) , 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 graças a @ceilingcat

Experimente online!

Logern
fonte
Sugerir em g=a[j=i++];islower(a[i])?bcopy(a,a+1,j)vez dea[j=i++];islower(a[i])?g=a[j],bcopy(a,a+1,j)
ceilingcat 30/10/19
0

Pitão, 16 bytes

em=+.>k-F}RGrBd2

Experimente aqui!

Explicação:

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