Memasukkan

String acak non-kosong yang terdiri dari karakter ASCII dalam kisaran .$[32..126]$

Keluaran

Output diperoleh dengan menerapkan rotasi berturut-turut ke string input.

Untuk setiap huruf ( [a-zA-Z]) dalam string input, dari kiri ke kanan:

• jika huruf dalam huruf besar, putar semua karakter sebelum itu dengan satu posisi ke kiri
• jika huruf dalam huruf kecil, putar semua karakter sebelum itu dengan satu posisi ke kanan

Contoh

Input: "Iklan Cb"

• Huruf pertama adalah " C ". Kita harus melakukan rotasi ke kiri, tetapi tidak ada karakter sebelum " C " ini. Jadi, tidak ada yang berputar.
• Huruf berikutnya adalah " b ". Kami memutar " C " ke kanan. Karena itu karakter tunggal, tidak berubah.
• Karakter " - " tidak memicu rotasi apa pun, karena ini bukan huruf.
• Huruf berikutnya adalah " A ". Kami memutar " Cb- " ke kiri, yang memberi " bC Ad"
• Huruf keempat dan terakhir adalah " d ". Kami memutar " b-CA " ke kanan, yang menghasilkan " Ab-C d"

Oleh karena itu, output yang diharapkan adalah " Ab-Cd ".

Aturan

• Anda dapat mengambil input sebagai string atau sebagai array karakter - yang mungkin atau mungkin tidak sama, tergantung pada bahasa Anda.
• Anda juga dapat menampilkan array karakter alih-alih string.
• Ini adalah golf kode ogl-edocf

Uji kasus

"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

Coba di sini

Penjelasan

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

Cobalah online!

Jelly , 14 byte

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

Tautan monadik yang menerima daftar karakter yang menghasilkan daftar karakter.

Cobalah online! Atau lihat test-suite .

Bagaimana?

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

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

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

Larutan:

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

Contoh:

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

Penjelasan:

Iterasi di atas string input, putar output sebelumnya sebesar 1, -1 atau 0 tergantung pada posisinya di daftar "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 (/)

Catatan:

• -10 byte dengan inspirasi dari solusi 05AB1E

> <> , 45 43 byte

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

Cobalah online!

Fakta bahwa> <> memiliki rotasi stack membantu, tetapi harus memeriksa huruf tidak.

Penjelasan:

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 terinspirasi oleh jawaban Curtis Bechtel (gunakan '@'<c,c<'['lebih elem c['A'..'Z']dan kisaran yang sesuai untuk huruf-huruf kecil).}

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

Cobalah online!

Penjelasan / Tidak Diundang

Operator (!)mengambil string yang tidak kosong xdi mana kita dapat mencocokkan pola dan karakter:

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

Sekarang kita dapat mengurangi ekor input dari kiri ke kanan, dimulai dengan karakter pertama dari input menggunakan:

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

Haskell , 122 92 byte

Terima kasih kepada BWO untuk sarannya! Saya juga menghemat banyak dengan mengambil pendekatan yang sedikit berbeda dari jawaban asli saya.

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

Cobalah 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

Cobalah online!

Asli ( 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 byte

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

Cobalah online!

Input dan output adalah array karakter

Trik-nya:

Kode ini cukup mudah, kecuali mungkin bagian rotasi:

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

x adalah karakter tunggal, yang bisa berupa huruf, ekspresi pertama x=~/\W/kembali niljika itu huruf, dan 0 sebaliknya. Jika 0, kita selesai, jika tidak, logika ormemeriksa ekspresi kedua: ?_<=>xmengembalikan -1 untuk huruf besar dan 1 untuk huruf kecil. Jadi rotasi adalah:

• -1 (1 ke kiri) untuk huruf besar
• +1 (1 ke kanan) untuk huruf kecil
• 0 (tidak ada rotasi) jika bukan huruf

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

Cobalah online!

Penjelasan:

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}

Cobalah online!

Bekerja pada berbagai karakter.

Japt, 17 16 14 byte

Mengambil input sebagai array karakter, menghasilkan string

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

Cobalah

Penjelasan

 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?

Jelly , 19 byte

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

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

Port dari jawaban JavaScript @ShieruAsakoto , jadi pastikan untuk menghapusnya.

Cobalah online.

Penjelasan:

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

Jalankan dan debug itu

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

Banyak stack swapping yang mungkin tidak perlu. Saya benar-benar ingin mendapatkan ini lebih banyak, tetapi saya berjuang dengan pemesanan tumpukan. Mungkin seseorang bisa mengetahuinya jika mereka bosan. Akan terus mengerjakannya.

Attache , 69 byte

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

Cobalah online!

Penjelasan

Bentuk umum

Fungsi umumnya terlihat seperti ini:

~Fold[{...}]#Iota

Yang melipat {...}setiap anggota dalam kisaran dari 0ke #input - 1(Iota ), dimulai dengan input sebagai seed.

Fungsi dalam

Fungsi berikut disebut sebagai f[building, index]dan dipanggil dengan setiap indeks dari 0ke #inputeksklusif. @SplitAtpanggilan SplitAtpada argumen ini, membelah string input aktif 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

Pada dasarnya, fungsi ini memutar bagian kiri dari string sesuai dengan karakter pertama dari bagian kanan.

Arang , 20 byte

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

Cobalah online! Tautan adalah untuk mengucapkan versi kode. Penjelasan:

ＦＳ

Ulangi karakter input.

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

Peta atas string karakter yang dikumpulkan sejauh ini, pengindeksan secara siklis ke karakter yang dikumpulkan sejauh ini dengan indeks bertambah atau berkurang jika karakter saat ini masing-masing huruf besar atau kecil. Ini melengkapi rotasi. Karakter selanjutnya kemudian digabungkan, dan hasilnya ditugaskan kembali ke string.

ω

Cetak hasilnya.

R , 107 102 100 byte

Masif karena manipulasi string R adalah besar. Adakah yang bisa mendapatkannya di bawah 100?

-5 byte menggunakan trik "set variabel loop ke F untuk menghindari inisialisasi".

-2 byte dengan mengasumsikan semua karakter dapat dicetak dan digunakan 2*!k%%97>25daripada 2*k%in%97:122untuk menguji huruf kecil, menggunakan prioritas operator.

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

Cobalah online!

Japt , 25 23 byte

Aku menyerah, tidak bisa membuatnya lebih pendek

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

Cobalah online!

Retina , 67 64 58 byte

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

-9 byte terima kasih kepada @Neil menghapus tiga yang tidak perlu ?telah saya tambahkan, serta yang tidak perlu (.*)dalam kasus-lain.

Cobalah secara online atau verifikasi semua kasus uji . (CATATAN: Output dengan baris tambahan. Header dalam rangkaian uji adalah untuk menguji setiap jalur input sebagai tempat uji terpisah, dan catatan kaki adalah untuk menghapus baris tambahan tersebut untuk output yang lebih kompak.)

Penjelasan:

Tambahkan baris baru sebelum input:

^
¶

Lanjutkan mengganti selama kami dapat menemukan kecocokan:

+`

Yang lainnya adalah tiga cek berbeda yang digabung menjadi satu:

Jika karakter tepat setelah baris baru adalah huruf kecil: putar semuanya sebelum baris baru ke kanan, lalu tambahkan karakter dan baris baru:

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

Jika karakter tepat setelah baris baru adalah huruf besar: putar semuanya sebelum baris baru ke kiri, dan kemudian tambahkan karakter itu dan baris baru:

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

Lain-lain (bukan huruf kecil atau huruf besar): cukup geser baris baru ke kanan untuk 'iterasi' berikutnya:

¶(.)
$1¶

Tiga cek di atas digabung dengan regex ATAU pernyataan ( |) dan penggantian grup yang lebih besar untuk membuatnya bertindak seperti if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 byte

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

Cobalah online!

-4 byte terima kasih kepada Luis Mendo.

Ubah huruf besar / kecil / non-huruf ke [-1,0,1] (paruh pertama program). Berlaku pengalihan secara berturut-turut (babak kedua). Saya merusak otak saya jika ada cara yang lebih baik untuk memetakan huruf besar / huruf kecil ke [-1,0,1] (lihat versi kedua), dan mungkin cara untuk membalikkan string segera untuk menyingkirkan keduanya wDibutuhkan untuk &).

C (dentang) , 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 terima kasih kepada @ceilingcat

Cobalah online!

Pyth, 16 byte

em=+.>k-F}RGrBd2

Coba di sini!

Penjelasan:

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.