输入项

一个非空的字符串，由范围内的ASCII字符组成。$[32..126]$

输出量

通过对输入字符串进行连续旋转来获得输出。

对于[a-zA-Z]输入字符串中的每个字母（），从左到右：

• 如果字母是大写字母，请将其前面的所有字符向左旋转一个位置
• 如果字母是小写字母，请将其前面的所有字符向右旋转一个位置

例

输入：“ Cb-Ad”

• 第一个字母是“ C ”。我们应该向左旋转，但是这个“ C ” 之前没有字符。因此，没有任何旋转。
• 下一个字母是“ b ”。我们向右旋转“ C ”。因为它是单个字符，所以它保持不变。
• 字符“ - ”不会触发任何旋转，因为它不是字母。
• 下一个字母是“ A ”。我们轮流“ CB- ”到左边，这给“ 公元前广告”
• 第四个也是最后一个字母是“ d ”。我们向右旋转“ b-CA ”，即为“ Ab-C d”

因此，预期输出为“ Ab-Cd ”。

规则

• 您可以将输入作为字符串或字符数组进行输入-根据您的语言，输入内容可能相同也可能不同。
• 您也可以输出字符数组而不是字符串。
• 这是ogl-edocf 代码高尔夫

测试用例

"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⁸ṙ;ð/

一个接受字符列表的单子链接，该链接产生一个字符列表。

在线尝试！或查看测试套件。

怎么样？

ØẠŒ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!"

说明：

遍历输入字符串，根据前一个输出在列表“ a-zA-Z”中的位置旋转1，-1或0。

""{.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字节启发柯蒂斯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

在线尝试！

解释/取消包装

运算符(!)采用一个非空字符串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），116102字节

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答复的端口，因此请确保对他进行投票。

在线尝试。

说明：

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）的范围内折叠到每个成员上。

内部功能

以下函数称为as，f[building, index]并与每个索引从0到#input互斥一起调用。@SplitAt调用SplitAt这些参数，在上分割输入字符串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

本质上，此函数根据右侧部分的第一个字符旋转字符串的左侧部分。

木炭，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字节

我放弃，不能再缩短

@ETHproductions中的-2个字节

£=¯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个字节，这要归功于@Neil删除了?我添加的三个不必要的内容，以及(.*)其他情况下不需要的内容。

在线尝试或验证所有测试用例。（注意：带有尾随换行符的输出。测试套件中的标头将每个输入行作为一个单独的测试用例进行测试，而页脚则删除尾随的换行符，以提供更紧凑的输出。）

说明：

在输入之前添加换行符：

^
¶

只要我们找到匹配项，就继续替换：

+`

其他所有内容是三个不同的检查合并在一起：

如果换行符后的字符是小写字母：请将换行符之前的所有内容向右旋转一次，然后追加该字符和换行符：

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

如果换行符之后的字符是大写字母：请将换行符之前的所有内容向左旋转一次，然后将该字符和换行符附加：

(.)(.*)¶([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]（程序的前半部分）。连续应用换档（下半部分）。如果有更好的方法可以将大写/小写映射到[-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.