입력

범위의 ASCII 문자로 구성된 비어 있지 않은 섞인 문자열 입니다.$[32..126]$

산출

입력 문자열에 연속적인 회전을 적용하여 출력을 얻습니다.

[a-zA-Z]입력 문자열의 각 문자 ( )에 대해 왼쪽에서 오른쪽으로 :

• 문자가 대문자 인 경우 모든 문자를 왼쪽으로 한 위치 씩 회전
• 문자가 소문자 인 경우 오른쪽 앞의 한 위치 씩 모든 문자를 회전

예

입력 : "Cb-Ad"

• 첫 글자는 " C "입니다. 왼쪽으로 회전해야하지만이 " C " 앞에는 문자가 없습니다 . 따라서 회전 할 것이 없습니다.
• 다음 문자는 " b "입니다. " C "를 오른쪽으로 돌립니다. 단일 문자이므로 변경되지 않습니다.
• 문자 " - "는 문자 가 아니므로 회전을 트리거하지 않습니다.
• 다음 글자는 " A "입니다. " Cb- "를 왼쪽으로 돌리면 " bC Ad"
• 네 번째이자 마지막 문자는 " 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.

파이썬 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 (/)

노트:

• 05AB1E 솔루션 에서 영감을 얻은 -10 바이트

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

하스켈 , 101 91 바이트

^{Curtis Bechtel의 답변에서 영감을 얻은 -10 바이트 ( 소문자에 대해서는 범위를 '@'<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]

하스켈 , 122 92 바이트

제안 해 주셔서 감사합니다! 또한 원래 답변과 약간 다른 접근 방식을 취함으로써 많은 비용을 절약했습니다.

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

온라인으로 사용해보십시오!

자바 스크립트 (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

루비 , 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 
]

펄 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Ƒ?};ʋ/

온라인으로 사용해보십시오!

자바 10, 149119 바이트

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

@ShieruAsakoto 포트는 자바 스크립트 응답 이므로 그를 찬성 해야합니다.

온라인으로 사용해보십시오.

설명:

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호출 SplitAt하여 입력 문자열을 on으로 분할합니다 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 미만으로 얻을 수 있습니까?

"초기화를 피하기 위해 루프 변수를 F로 설정"트릭을 사용하는 -5 바이트

모든 문자가 인쇄 가능하고 연산자 우선 순위를 사용하여 소문자를 테스트 2*!k%%97>25하기보다는 사용한다고 가정하여 -2 바이트 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)}

온라인으로 사용해보십시오!

apt , 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¶

@Neil 덕분에 -9 바이트 덕분에 ?내가 추가 한 불필요한 3 가지를 제거 (.*)하고 else 경우에는 불필요한 것을 제거했습니다 .

온라인으로 시도 하거나 모든 테스트 사례를 확인하십시오 . (참고 : 후행 줄 바꿈이있는 출력. 테스트 스위트의 헤더는 각 입력 라인을 별도의 테스트 케이스로 테스트하는 것이며 바닥 글은 더 작은 출력을 위해 후행 줄 바꿈을 제거하는 것입니다.)

설명:

입력 전에 개행을 추가하십시오.

^
¶

일치하는 것을 찾을 수있는 한 계속 교체하십시오.

+`

다른 모든 것들은 세 가지 수표가 합쳐져 ​​있습니다.

줄 바꿈 바로 뒤에있는 문자가 소문자 인 경우 : 줄 바꿈 앞의 모든 항목을 오른쪽으로 한 번 회전 한 다음 해당 문자와 ​​줄 바꿈을 추가하십시오.

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

줄 바꿈 바로 뒤에있는 문자가 대문자 인 경우 : 줄 바꿈 앞의 모든 문자를 왼쪽으로 한 번 회전 한 다음 해당 문자와 ​​줄 바꿈을 추가하십시오.

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

그렇지 않으면 (소문자 또는 대문자가 아님) : 다음 '반복'을 위해 개행을 오른쪽으로 한 번만 이동하십시오.

¶(.)
$1¶

위의 세 가지 검사는 정규식 OR 문 ( |) 및 더 큰 그룹 교체와 병합되어 다음과 같이 작동합니다 if(lowercase) ... elseif(uppercase) ... else ....

MATL , 20 바이트

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

온라인으로 사용해보십시오!

Luis Mendo 덕분에 -4 바이트

대문자 / 소문자 / 비 문자를 [-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);}

@ceilingcat 덕분에 -26

온라인으로 사용해보십시오!

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.