Đầu vào

Một chuỗi xáo trộn không trống bao gồm các ký tự ASCII trong phạm vi .$[32..126]$

Đầu ra

Đầu ra thu được bằng cách áp dụng các phép quay liên tiếp vào chuỗi đầu vào.

Đối với mỗi chữ cái ( [a-zA-Z]) trong chuỗi đầu vào, đi từ trái sang phải:

• nếu chữ in hoa, hãy xoay tất cả các ký tự trước nó theo một vị trí bên trái
• nếu chữ in thường, xoay tất cả các ký tự trước nó theo một vị trí bên phải

Thí dụ

Đầu vào: "Cb-Ad"

• Chữ cái đầu tiên là " C ". Chúng ta nên xoay một vòng sang trái, nhưng không có ký tự nào trước chữ " C " này. Vì vậy, không có gì để xoay.
• Chữ tiếp theo là " b ". Chúng tôi xoay " C " sang phải. Bởi vì nó là một ký tự duy nhất, nó không thay đổi.
• Ký tự " - " không kích hoạt bất kỳ phép quay nào, vì đó không phải là một chữ cái.
• Chữ tiếp theo là " A ". Chúng tôi xoay " Cb- " sang trái, cung cấp " Quảng cáo bC "
• Chữ cái thứ tư và cuối cùng là " d ". Chúng tôi xoay " b-CA " sang phải, cung cấp " Ab-C d"

Do đó, đầu ra dự kiến ​​là " Ab-Cd ".

Quy tắc

• Bạn có thể lấy đầu vào dưới dạng chuỗi hoặc dưới dạng một mảng các ký tự - có thể giống hoặc không giống nhau, tùy thuộc vào ngôn ngữ của bạn.
• Bạn cũng có thể xuất ra một mảng các ký tự thay vì một chuỗi.
• Đây là mã ogl-edocf -golf

Các trường hợp thử nghiệm

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

Bình thường, 21 20 byte

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

Hãy thử nó ở đây

Giải trình

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

Hãy thử trực tuyến!

Thạch , 14 byte

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

Một liên kết đơn âm chấp nhận một danh sách các ký tự mang lại một danh sách các ký tự.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Làm sao?

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

Dung dịch:

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

Ví dụ:

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

Giải trình:

Lặp lại chuỗi đầu vào, xoay đầu ra trước đó bằng 1, -1 hoặc 0 tùy thuộc vào vị trí của nó trong danh sách "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 (/)

Ghi chú:

• -10 byte lấy cảm hứng từ giải pháp 05AB1E

> <> , 45 43 byte

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

Hãy thử trực tuyến!

Thực tế là> <> có tính năng xoay ngăn xếp, nhưng phải kiểm tra trường hợp của chữ cái thì không.

Giải trình:

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 lấy cảm hứng từ câu trả lời của Curtis Bechtel (sử dụng '@'<c,c<'['trên elem c['A'..'Z']và phạm vi theo các chữ cái viết thường).}

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

Hãy thử trực tuyến!

Giải thích / Ungolfed

Toán tử (!)lấy một chuỗi không trống xđể chúng ta có thể khớp mẫu và ký tự:

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

Bây giờ chúng ta có thể giảm đuôi của đầu vào từ trái sang phải, bắt đầu bằng ký tự đầu tiên của đầu vào bằng cách sử dụng:

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

Haskell , 122 92 byte

Cảm ơn BWO về những gợi ý! Tôi cũng đã tiết kiệm rất nhiều bằng cách thực hiện một cách tiếp cận hơi khác so với câu trả lời ban đầu của tôi.

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Bản gốc ( 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}

Hãy thử trực tuyến!

Đầu vào và đầu ra là các mảng ký tự

Bí quyết:

Mã này khá đơn giản, ngoại trừ phần xoay vòng:

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

x là một ký tự đơn, có thể là một chữ cái, biểu thức đầu tiên x=~/\W/trả về nilnếu đó là một chữ cái và 0 khác. Nếu là 0, chúng ta đã hoàn thành, nếu không, logic sẽ orkiểm tra biểu thức thứ hai: ?_<=>xtrả về -1 cho chữ hoa và 1 cho chữ thường. Vì vậy, vòng quay là:

• -1 (1 bên trái) cho chữ hoa
• +1 (1 bên phải) cho chữ thường
• 0 (không quay) nếu đó không phải là một chữ cái

Đỏ , 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]

Hãy thử trực tuyến!

Giải trình:

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}

Hãy thử trực tuyến!

Hoạt động trên một mảng của ký tự.

Japt, 17 16 14 byte

Lấy đầu vào dưới dạng một mảng các ký tự, xuất ra một chuỗi

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

Thử nó

Giải trình

 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?

Thạch , 19 byte

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

Hãy thử trực tuyến!

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

Cổng @ShieruAsakoto JavaScript trả lời , vì vậy hãy đảm bảo nâng cấp anh ta.

Hãy thử trực tuyến.

Giải trình:

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

Chạy và gỡ lỗi nó

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

Rất nhiều hoán đổi ngăn xếp có lẽ là không cần thiết. Tôi thực sự muốn có được điều này nhiều hơn, nhưng tôi đã cố gắng với thứ tự của ngăn xếp. Có lẽ ai đó có thể tìm ra nếu họ chán. Sẽ tiếp tục làm việc trên nó.

Tùy viên , 69 byte

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

Hãy thử trực tuyến!

Giải trình

Hình dạng chung

Hàm nhìn chung như thế này:

~Fold[{...}]#Iota

Mà gấp {...}trên mỗi thành viên trong phạm vi từ 0đến #input - 1( Iota), bắt đầu với đầu vào là một hạt giống.

Chức năng bên trong

Các chức năng sau đây được gọi là f[building, index]và được gọi với mỗi chỉ số từ 0để #inputđộc quyền. @SplitAtgọi SplitAtcác đối số này, tách chuỗi đầu vào 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

Về cơ bản, hàm này xoay phần bên trái của chuỗi theo ký tự đầu tiên của phần bên phải.

Than , 20 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

ＦＳ

Lặp lại các ký tự đầu vào.

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

Ánh xạ qua chuỗi các ký tự được thu thập cho đến nay, lập chỉ mục theo chu kỳ thành các ký tự được thu thập cho đến nay với chỉ số tăng hoặc giảm nếu ký tự hiện tại là chữ hoa hoặc chữ thường tương ứng. Điều này hoàn thành vòng quay. Ký tự tiếp theo sau đó được nối và kết quả được gán lại cho chuỗi.

ω

In kết quả.

R , 107 102 100 byte

Lớn vì thao tác chuỗi của R là cồng kềnh. Bất cứ ai cũng có thể nhận được nó dưới 100?

-5 byte sử dụng thủ thuật "đặt biến vòng lặp thành F để tránh khởi tạo".

-2 byte bằng cách giả sử tất cả các ký tự có thể in và sử dụng 2*!k%%97>25thay vì 2*k%in%97:122để kiểm tra chữ thường, sử dụng quyền ưu tiên của toán tử.

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

Hãy thử trực tuyến!

Japt , 25 23 byte

Tôi từ bỏ, không thể làm cho nó ngắn hơn

-2 byte từ @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    

Hãy thử trực tuyến!

Võng mạc , 67 64 58 byte

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

-9 byte nhờ @Neil loại bỏ ba không cần thiết ? tôi đã thêm, cũng như không cần thiết(.*) trong trường hợp khác.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm . .

Giải trình:

Chuẩn bị một dòng mới trước khi đầu vào:

^
¶

Tiếp tục thay thế miễn là chúng ta có thể tìm thấy một trận đấu:

+`

Mọi thứ khác là ba kiểm tra khác nhau được hợp nhất với nhau:

Nếu ký tự ngay sau dòng mới là chữ thường: xoay mọi thứ trước dòng mới một lần về phía bên phải, sau đó nối thêm ký tự đó và dòng mới:

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

Nếu ký tự ngay sau dòng mới là một chữ cái viết hoa: xoay mọi thứ trước dòng mới một lần về phía bên trái, sau đó nối thêm ký tự đó và dòng mới:

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

Khác (không phải chữ thường hay chữ in hoa): chỉ cần dịch chuyển dòng mới một lần sang bên phải cho 'lần lặp' tiếp theo:

¶(.)
$1¶

Ba kiểm tra ở trên được hợp nhất với các câu lệnh regex OR ( |) và các thay thế nhóm lớn hơn để làm cho nó hoạt động như một if(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 byte

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

Hãy thử trực tuyến!

-4 byte nhờ Luis Mendo.

Chuyển đổi chữ hoa / chữ thường / không chữ thành [-1,0,1] (nửa đầu của chương trình). Áp dụng tuần hoàn liên tiếp (nửa sau). Tôi đang phá hỏng bộ não của mình nếu có cách tốt hơn để ánh xạ chữ hoa / chữ thường thành [-1,0,1] (xem phiên bản thứ hai), và có lẽ là một cách để đảo ngược chuỗi ngay lập tức để loại bỏ hai chuỗi wCần thiết cho &).

C (tiếng kêu) , 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 cảm ơn @ceilingcat

Hãy thử trực tuyến!

Bình thường, 16 byte

em=+.>k-F}RGrBd2

Hãy thử nó ở đây!

Giải trình:

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.