Ingresso

Una stringa mescolata non vuota composta da caratteri ASCII nell'intervallo .$[32..126]$

Produzione

L'output si ottiene applicando rotazioni successive alla stringa di input.

Per ogni lettera ( [a-zA-Z]) nella stringa di input, da sinistra a destra:

• se la lettera è in maiuscolo, ruota tutti i caratteri prima di essa di una posizione a sinistra
• se la lettera è in minuscolo, ruota tutti i caratteri prima di una posizione verso destra

Esempio

Input: "Annuncio Cb"

• La prima lettera è una " C ". Dovremmo fare una rotazione a sinistra, ma non c'è carattere prima di questa " C ". Quindi, non c'è nulla da ruotare.
• La lettera successiva è una " b ". Ruotiamo " C " verso destra. Poiché è un singolo personaggio, rimane invariato.
• Il carattere " - " non attiva alcuna rotazione, in quanto non è una lettera.
• La lettera successiva è una " A ". Ruotiamo " Cb- " a sinistra, che fornisce " Annuncio bC "
• La quarta e ultima lettera è una " d ". Ruotiamo " b-CA " verso destra, che dà " Ab-C d"

Pertanto, l'output previsto è " Ab-Cd ".

Regole

• Puoi prendere l'input come stringa o come matrice di caratteri, che può essere o meno la stessa cosa, a seconda della tua lingua.
• È inoltre possibile generare una matrice di caratteri anziché una stringa.
• Questo è ogl-edocf code-golf

Casi 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 byte

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

Provalo qui

Spiegazione

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 byte

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

Provalo online!

Gelatina , 14 byte

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

Un collegamento monadico che accetta un elenco di caratteri che produce un elenco di caratteri.

Provalo online! Oppure vedi la suite di test .

Come?

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

õsvy.uy.l-._y«

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

Soluzione:

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

Esempi:

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

Spiegazione:

Scorrere sulla stringa di input, ruotando l'uscita precedente di 1, -1 o 0 a seconda della sua posizione nell'elenco "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 (/)

Gli appunti:

• -10 byte con ispirazione dalla soluzione 05AB1E

> <> , 45 43 byte

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

Provalo online!

Il fatto che> <> abbia la rotazione dello stack aiuta, ma non è necessario controllare il caso della lettera.

Spiegazione:

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 byte

^{-10 byte ispirati alla risposta di Curtis Bechtel (utilizzare '@'<c,c<'['sopra elem c['A'..'Z']e l'intervallo corrispondente per le lettere minuscole).}

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

Provalo online!

Spiegazione / Non golf

L'operatore (!)prende una stringa non vuota xsu cui possiamo abbinare pattern e un carattere:

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

Ora possiamo ridurre la coda dell'input da sinistra a destra, iniziando dal primo carattere dell'input usando:

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

Haskell , 122 92 byte

Grazie a BWO per i suggerimenti! Ho anche risparmiato molto adottando un approccio leggermente diverso rispetto alla mia risposta originale.

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

Provalo online!

JavaScript (Node.js) , 116 102 byte

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

Provalo online!

Originale ( 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

Rubino , 51 byte

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

Provalo online!

Input e output sono array di caratteri

Il trucco:

Il codice è piuttosto semplice, tranne forse la parte di rotazione:

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

x è un singolo carattere, che potrebbe essere una lettera, la prima espressione x=~/\W/restituisce nilse è una lettera e 0 altrimenti. Se è 0, abbiamo finito, altrimenti la logica orcontrolla la seconda espressione: ?_<=>xrestituisce -1 per le lettere maiuscole e 1 per le lettere minuscole. Quindi la rotazione è:

• -1 (1 a sinistra) per le maiuscole
• +1 (1 a destra) per le lettere minuscole
• 0 (nessuna rotazione) se non è una lettera

Rosso , 110 byte

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]

Provalo online!

Spiegazione:

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 byte

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

Provalo online!

Funziona su una serie di caratteri.

Japt, 17 16 14 byte

Prende l'input come una matrice di caratteri, genera una stringa

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

Provalo

Spiegazione

 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?

Gelatina , 19 byte

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

Provalo online!

Java 10, 149 119 byte

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

Risposta di Port of @ShieruAsakoto JavaScript , quindi assicurati di votarlo.

Provalo online.

Spiegazione:

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 byte

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

Esegui ed esegui il debug

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

Molti scambi di stack che probabilmente non sono necessari. Mi piacerebbe davvero scendere di più, ma stavo lottando con l'ordinamento della pila. Forse qualcuno può capire se sono annoiati. Continuerò a lavorarci su.

Attache , 69 byte

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

Provalo online!

Spiegazione

Forma generale

La funzione è generalmente simile a questa:

~Fold[{...}]#Iota

Che si ripiega {...}su ciascun membro nell'intervallo da 0a #input - 1( Iota), iniziando con l'input come seme.

La funzione interiore

La seguente funzione è chiamato come f[building, index]e viene chiamato con ogni indice da 0a #inputesclusivo. @SplitAtchiama SplitAtquesti argomenti, suddividendo la stringa di input 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

In sostanza, questa funzione ruota la parte sinistra della stringa in base al primo carattere della parte destra.

Carbone , 20 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

ＦＳ

Scorri i caratteri di input.

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

Mappa sulla serie di caratteri raccolti finora, indicizzando ciclicamente i caratteri raccolti finora con l'indice incrementato o decrementato se il carattere corrente è rispettivamente maiuscolo o minuscolo. Questo completa la rotazione. Il carattere successivo viene quindi concatenato e il risultato assegnato alla stringa.

ω

Stampa il risultato.

R , 107 102 100 byte

Massiccio perché il manip di stringhe di R è voluminoso. Qualcuno può farlo sotto i 100?

-5 byte usando il trucco "imposta le variabili del ciclo su F per evitare l'inizializzazione".

-2 byte assumendo che tutti i caratteri siano stampabili e che utilizzino 2*!k%%97>25anziché 2*k%in%97:122per testare le lettere minuscole, usando la precedenza dell'operatore.

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

Provalo online!

Japt , 25 23 byte

Mi arrendo, non posso accorciarlo

-2 byte da @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    

Provalo online!

Retina , 67 64 58 byte

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

-9 byte grazie a @Neil rimuovendo i tre inutili ?che avevo aggiunto, oltre a quelli inutili nell'altro (.*)caso.

Provalo online o verifica tutti i casi di test . (NOTA: Output con una nuova riga finale. L'intestazione nella suite di test consiste nel testare ciascuna riga di input come un caso di test separato e il piè di pagina deve rimuovere quella nuova riga finale per un output più compatto.)

Spiegazione:

Prepara una nuova riga prima dell'input:

^
¶

Continua a sostituire finché riusciamo a trovare una corrispondenza:

+`

Tutto il resto sono tre diversi controlli uniti:

Se il carattere subito dopo la nuova riga è una lettera minuscola: ruota tutto prima della nuova riga una volta verso destra, quindi aggiungi quel carattere e la nuova riga:

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

Se il carattere subito dopo la nuova riga è una lettera maiuscola: ruota tutto prima della nuova riga una volta verso sinistra, quindi aggiungi quel carattere e la nuova riga:

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

Altrimenti (né una lettera minuscola né maiuscola): sposta semplicemente la nuova riga una volta verso destra per la successiva 'iterazione':

¶(.)
$1¶

Questi tre controlli di cui sopra sono uniti a istruzioni regex OR ( |) e sostituzioni di gruppi più grandi per farlo agire come if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 byte

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

Provalo online!

-4 byte grazie a Luis Mendo.

Converte maiuscolo / minuscolo / non lettera in [-1,0,1] (prima metà del programma). Applica il turno consecutivamente (seconda metà). Sto distruggendo il mio cervello se c'è un modo migliore per mappare maiuscole / minuscole su [-1,0,1] (vedi la seconda versione), e forse un modo per invertire immediatamente la stringa in modo da sbarazzarsi delle due wè necessario per il &).

C (clang) , 168 159 153 119 byte

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 grazie a @ceilingcat

Provalo online!

Pyth, 16 byte

em=+.>k-F}RGrBd2

Provalo qui!

Spiegazione:

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.