อินพุต

ไม่ว่างเปล่าสตริงสับประกอบด้วยอักขระ ASCII ในช่วง ]$[32..126]$

เอาท์พุต

เอาต์พุตได้มาจากการใช้การหมุนต่อเนื่องกับสตริงอินพุต

สำหรับแต่ละตัวอักษร ( [a-zA-Z]) ในสตริงอินพุตให้เปลี่ยนจากซ้ายไปขวา:

• ถ้าตัวอักษรเป็นตัวพิมพ์ใหญ่หมุนตัวอักษรทั้งหมดก่อนโดยตำแหน่งเดียวไปทางซ้าย
• หากตัวอักษรเป็นตัวพิมพ์เล็กให้หมุนตัวอักษรทั้งหมดก่อนโดยตำแหน่งเดียวไปทางขวา

ตัวอย่าง

อินพุต: "Cb-Ad"

• อักษรตัวแรกคือ " C " เราควรหมุนไปทางซ้าย แต่ไม่มีตัวละครอยู่ก่อนหน้านี้ " C " ดังนั้นจึงไม่มีอะไรจะหมุน
• ตัวอักษรถัดไปคือ " b " เราหมุน " C " ไปทางขวา เนื่องจากเป็นอักขระตัวเดียวจึงไม่เปลี่ยนแปลง
• อักขระ " - " ไม่เรียกใช้การหมุนใด ๆ เนื่องจากไม่ใช่ตัวอักษร
• ตัวอักษรถัดไปคือ " A " เราหมุน " Cb- " ไปทางซ้ายซึ่งให้ " โฆษณาbC "
• ตัวอักษรที่สี่และตัวสุดท้ายคือ " d " เราหมุน " b-CA " ไปทางขวาซึ่งให้ " Ab-C d"

ดังนั้นผลลัพธ์ที่คาดหวังคือ " Ab-Cd "

กฎระเบียบ

• คุณอาจป้อนข้อมูลเป็นสตริงหรืออาเรย์ของอักขระซึ่งอาจหรือไม่เหมือนกันขึ้นอยู่กับภาษาของคุณ
• นอกจากนี้คุณยังสามารถส่งออกอาร์เรย์ของตัวละครแทนสตริง
• นี่คือogl-edocf code-golf

กรณีทดสอบ

"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 ไบต์

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

ลองที่นี่

คำอธิบาย

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 ไบต์

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

ลองออนไลน์!

เยลลี่ขนาด 14 ไบต์

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

ลิงก์ monadic ยอมรับรายการของอักขระที่ให้รายการของอักขระ

ลองออนไลน์! หรือดูการทดสอบในตัว

อย่างไร?

ØẠŒ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 ไบต์

õsvy.uy.l-._y«

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

õ            # 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 ไบต์

วิธีการแก้:

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

ตัวอย่าง:

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

คำอธิบาย:

ทำซ้ำผ่านสตริงอินพุตหมุนเอาต์พุตก่อนหน้า 1, -1 หรือ 0 ขึ้นอยู่กับตำแหน่งในรายการ "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 (/)

หมายเหตุ:

• -10 ไบต์ด้วยแรงบันดาลใจจากโซลูชัน05AB1E

> <> , 45 43 ไบต์

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

ลองออนไลน์!

ข้อเท็จจริงที่นั้น> <> มีการหมุนสแต็คช่วย แต่การตรวจสอบตัวอักษรของตัวอักษรไม่ได้

คำอธิบาย:

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 ไบต์

^{-10 ไบต์แรงบันดาลใจจากคำตอบของ Curtis Bechtel (ใช้'@'<c,c<'['เกินelem c['A'..'Z']และช่วงตามสำหรับตัวอักษรที่ต่ำกว่าซอง)}

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

ลองออนไลน์!

คำอธิบาย / Ungolfed

โอเปอเรเตอร์(!)ใช้สตริงที่ไม่ว่างxซึ่งเราสามารถจับคู่รูปแบบและอักขระ:

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 a -> b!a ++ [a]

Haskell , 122 92 ไบต์

ขอบคุณ BWO สำหรับคำแนะนำ! ฉันยังประหยัดได้มากโดยใช้วิธีที่แตกต่างจากคำตอบเดิมเล็กน้อย

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

ลองออนไลน์!

JavaScript (Node.js) , 116 102 ไบต์

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

ลองออนไลน์!

ต้นฉบับ ( 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 ไบต์

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

ลองออนไลน์!

อินพุตและเอาต์พุตเป็นอาร์เรย์ของอักขระ

เคล็ดลับ:

รหัสค่อนข้างตรงไปตรงมายกเว้นบางทีส่วนการหมุน:

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

x คืออักขระตัวเดียวซึ่งอาจเป็นตัวอักษรนิพจน์แรก x=~/\W/ส่งกลับnilถ้าเป็นตัวอักษรและ 0 เป็นอย่างอื่น ถ้าเป็น 0 เราก็เสร็จถ้าไม่ตรรกะorตรวจสอบนิพจน์ที่สอง: ?_<=>xส่งกลับ -1 สำหรับกรณีบนและ 1 สำหรับกรณีที่ต่ำกว่า ดังนั้นการหมุนคือ:

• -1 (1 ไปทางซ้าย) สำหรับตัวพิมพ์ใหญ่
• +1 (1 ทางด้านขวา) สำหรับตัวพิมพ์เล็ก
• 0 (ไม่มีการหมุน) หากไม่ใช่ตัวอักษร

สีแดง 110 ไบต์

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]

ลองออนไลน์!

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

ทำงานในอาร์เรย์ของตัวอักษร

Japté, 17 16 14 ไบต์

รับอินพุตเป็นอาร์เรย์ของอักขระส่งออกสตริง

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

ลองมัน

คำอธิบาย

 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?

เยลลี่ขนาด 19 ไบต์

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

ลองออนไลน์!

Java 10, 149 119 ไบต์

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

คำตอบของพอร์ตของ@ShieruAsakoto JavaScriptดังนั้นอย่าลืม upvote เขา

ลองออนไลน์

คำอธิบาย:

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 ไบต์

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

เรียกใช้และแก้ไขข้อบกพร่อง

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

การสลับสแต็กจำนวนมากซึ่งอาจไม่จำเป็น ฉันต้องการทำให้เรื่องนี้แย่ลง แต่ฉันก็ลำบากกับการเรียงลำดับของสแต็ก บางทีใครบางคนสามารถคิดออกว่าพวกเขาจะเบื่อ จะทำงานต่อไปเรื่อย ๆ

ทูต , 69 ไบต์

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

ลองออนไลน์!

คำอธิบาย

รูปร่างทั่วไป

ฟังก์ชั่นโดยทั่วไปมีลักษณะเช่นนี้:

~Fold[{...}]#Iota

ซึ่งพับ{...}มากกว่าสมาชิกแต่ละคนในช่วงจาก0ถึง#input - 1(Iota ) เริ่มต้นด้วยอินพุตเป็นเมล็ด

ฟังก์ชั่นด้านใน

ฟังก์ชั่นต่อไปนี้เรียกว่าเป็นf[building, index]และถูกเรียกกับแต่ละดัชนีจาก0ถึง#inputพิเศษ @SplitAtสายข้อโต้แย้งเหล่านี้แยกสายเข้าในSplitAtindex

{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

โดยพื้นฐานแล้วฟังก์ชั่นนี้จะหมุนส่วนด้านซ้ายของสตริงตามอักขระตัวแรกของส่วนด้านขวา

ถ่าน 20 ไบต์

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

ลองออนไลน์! การเชื่อมโยงคือการสร้างรหัสเวอร์ชัน คำอธิบาย:

ＦＳ

วนซ้ำอักขระที่ป้อนเข้า

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

แม็พกับสตริงของอักขระที่รวบรวมจนถึงการทำดัชนีวนรอบเป็นอักขระที่รวบรวมจนถึงดัชนีที่เพิ่มขึ้นหรือลดลงหากอักขระปัจจุบันเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็กตามลำดับ การหมุนเสร็จสิ้น อักขระถัดไปจะถูกต่อกันและผลลัพธ์จะถูกกำหนดกลับไปที่สตริง

ω

พิมพ์ผลลัพธ์

R , 107 102 100 ไบต์

มีขนาดใหญ่มากเนื่องจากตัวจัดการสตริงของ R มีขนาดใหญ่มาก ใครสามารถรับมันต่ำกว่า 100

-5 ไบต์โดยใช้ "ตั้งค่าตัวแปรลูปเป็น F เพื่อหลีกเลี่ยงการเริ่มต้น" เคล็ดลับ

-2 ไบต์โดยสมมติว่าตัวละครทุกตัวสามารถพิมพ์ได้และใช้2*!k%%97>25แทน2*k%in%97:122การทดสอบตัวพิมพ์เล็กโดยใช้ตัวดำเนินการที่สำคัญกว่า

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

ลองออนไลน์!

Japt , วันที่ 25 23 ไบต์

ฉันยอมแพ้ทำให้มันสั้นลงไม่ได้

-2 ไบต์จาก @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    

ลองออนไลน์!

เรติน่า , 67 64 58 ไบต์

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

-9 bytes ขอบคุณ @Neil ลบทั้งสามที่ไม่จำเป็น?ฉันได้เพิ่มเช่นเดียวกับที่ไม่จำเป็น(.*)ในกรณีอื่น

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด (หมายเหตุ: เอาต์พุตที่มีบรรทัดใหม่ต่อท้ายส่วนหัวในชุดทดสอบคือการทดสอบแต่ละบรรทัดอินพุตเป็นกรณีทดสอบแยกต่างหากและส่วนท้ายคือการลบบรรทัดใหม่ที่ต่อท้ายเพื่อให้ได้เอาต์พุตที่กะทัดรัดยิ่งขึ้น)

คำอธิบาย:

เตรียมขึ้นบรรทัดใหม่ก่อนอินพุต:

^
¶

ทำการแทนที่ต่อไปตราบใดที่เราพบการแข่งขัน:

+`

ทุกอย่างอื่นคือเช็คที่แตกต่างกันสามอย่างที่รวมเข้าด้วยกัน:

หากตัวละครที่อยู่หลัง newline เป็นตัวอักษรตัวเล็ก: หมุนทุกอย่างก่อนที่จะขึ้นบรรทัดใหม่ไปทางขวาหนึ่งครั้งแล้วผนวกอักขระนั้นและบรรทัดใหม่ต่อท้าย:

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

หากตัวละครที่อยู่หลัง newline เป็นตัวอักษรตัวใหญ่: หมุนทุกอย่างก่อนที่จะขึ้นบรรทัดใหม่หนึ่งครั้งไปทางซ้ายจากนั้นผนวกอักขระนั้นและบรรทัดใหม่:

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

อื่น (ไม่ใช่ตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่): เพียงแค่เลื่อนขึ้นบรรทัดใหม่หนึ่งครั้งไปทางขวาสำหรับ 'การทำซ้ำ' ถัดไป:

¶(.)
$1¶

การตรวจสอบทั้งสามด้านบนนี้ถูกรวมเข้ากับคำสั่ง regex OR ( |) และการแทนที่กลุ่มที่ใหญ่ขึ้นเพื่อให้มันทำหน้าที่เหมือนif(lowercase) ... elseif(uppercase) ... else ...:

MATL , 20 ไบต์

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

ลองออนไลน์!

-4 ไบต์ขอบคุณ Luis Mendo

แปลงตัวพิมพ์ใหญ่ / ตัวพิมพ์เล็ก / ไม่ใช่ตัวอักษรเป็น [-1,0,1] (ครึ่งแรกของโปรแกรม) ใช้ circshift ติดต่อกัน (ครึ่งหลัง) ฉันทำลายสมองของฉันหากมีวิธีที่ดีกว่าในการทำแผนที่ตัวพิมพ์ใหญ่ / ตัวพิมพ์เล็กเป็น [-1,0,1] (ดูรุ่นที่สอง) และอาจเป็นวิธีที่จะย้อนกลับสตริงทันทีเพื่อกำจัดทั้งสองwจำเป็นสำหรับ&).

C (เสียงดังกราว) , 168 159 153 119 ไบต์

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 ขอบคุณ @ceilingcat

ลองออนไลน์!

Pyth, 16 ไบต์

em=+.>k-F}RGrBd2

ลองที่นี่!

คำอธิบาย:

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.