부조리 연극에서 Rosencrantz와 Guildenstern 죽은 두 주인공 Rosencrantz 와 Guildenstern (또는은?) 항상 자신의 신체 부위 중 어느은 때때로 사람 또는 그들 중 어느 최대 혼합하는-때문에의 인식 부족 개인의 정체성. 그들이 그들의 이름을 뒤섞어도 터무니없는 것이 아닐까요?

당신의 임무 는 7 자보다 큰 짝수 길이 (디자인에 의해 4의 배수) 를 취하는 함수를 작성하고 , 분할하고 섞습니다.

분할은 다음과"abscd" 같아야합니다. 문자열은 분리 문자로 작동하는 형식이어야 합니다. 첫 번째 섹션과 구분 기호 abs는 문자열의 첫 번째 절반이되고 나머지 절반은cd

의 길이 a될 것입니다(string length / 4) - 1

의 길이 b될 것입니다(string length / 4)

의 길이 s될 것입니다1

의 길이 c될 것입니다(string length / 4) + 1

의 길이 d될 것입니다(string length / 4) - 1

이것은 실제로 혼란 스러울 수 있으므로 몇 가지 예를 보여 드리겠습니다.

("a" + "bb" + "s" + "ccc" + "d").length //8
  1     2      1      3      1
|-------4--------|  |----4-----| <--- (4 is half of 8)

("rosen" + "crantz" + "&" + "guilden" + "stern").length  //24
    5         6        1        7          5

("foo" + "barr" + "?" + "barry" + "foo").length
   3       4       1      5         3

드디어:

그런 다음 부품을 섞어 출력 adscb

전의. "rosencrantz&guildenstern" --> "rosenstern&guildencrantz"

"foobarr?barryfoo" --> "foofoo?barrybarr"

룰즈 :

1. 표준 허점 은 금지되어 있습니다
2. 허용되는 답변 : 하나의 입력 문자열을 통해 입력을 받고 하나의 출력 문자열을 반환하는 함수
3. 입력 문자열은 위에 제시된 요구 사항과 일치하지 않는 경우, 코드는 (어떤 종류의 문제가되지 않는 오류가 밖으로해야 Exception또는 Error)
4. 이것은 code-golf이므로 가장 짧은 (유효한) 답변 (각 언어로)이기는 것입니다!
5. 한 줄짜리 보너스 포인트 :-) (실제로는 멋진 점이 아니라 멋진 점)

K (oK) , _{35 34} 33 바이트

{$[8>#x;.;<x!4!-&4#-1 0 2+-4!#x]}

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

입력 검증 없음 (ngn 현상금), _{25 24} 23 바이트

{<x!4!-&4#-1 0 2+-4!#x}

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

K를 조금 배웠고 동사 목록을 살펴보면 다른 접근법 ( cut을 사용 하지 않음 )이 효과가 있다고 생각했습니다 . 그리고 그것은 완벽하게 작동했습니다.

작동 원리

{<x!4!-&4#-1 0 2+-4!#x}
                 -4!#x    Length divided by four (floor division)
        4#-1 0 2+         Generate lengths (x/4-1, x/4, x/4+2, x/4-1)
       &                  Generate that many 0, 1, 2, 3's
    4!-                   Negate and modulo 4; effectively swap 1 and 3
 <x!                      Sort the original string by above

{$[8>#x;.; <code> ]}  Input validation
 $[8>#x           ]   If the length is less than 8
        .             Dynamically generate an error
           <code>     Otherwise, run the main code

펄 6 , 60 58 바이트

Jo King 덕분에 -2 바이트

{[~] .rotor($_/4 X-1,0,+^-$_+>2,-1,1)[0,4,2,3,1;*]}o*.comb

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

오류가 발생하면 "회전 하위 목록 길이가 범위를 벗어났습니다"가 발생합니다.

설명

{               # Anonymous block
 [~]            # Join
   .rotor(      # Split into sublists of specific length
     $_/4 X-    # Subtract from len/4
     1,
     0,
     +^-$_+>2,  # (len-1)>>2
                #   subtraction yields 1 if len is multiple of 4
                #   otherwise a value less than 1 causing an error
     -1,       
     1)
   [0,4,2,3,1;*]  # Rearrange sublists and take inner elements
}o*.comb          # Split into characters and feed into block

J , ₃₆ 35 바이트

5;@A.](<;.2~;)1<@{."+~1 0 _2 1-4%~#

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

-1 바이트 {.+ 음수 길이 & ;.2대신 "종료"마커로 자릅니다.

원래 답변, 36 바이트

5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#

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

ngn은 이전 K 답변 에 대한 주석에서 "cut"을 언급 했으며 동일한 "cut"을 가진 J를 시도하게했습니다 (K의 작동 방식을 모릅니다).

작동 원리

5;@A.](<;.1~;)1<@{."+~_1 0 2 _1+4%~#  Monadic train.
                                4%~#  Length divided by four
                      _1 0 2 _1+      Generate the four segment lengths
              1<@{."+~  Generate [1 0 0...] boxed arrays of those lengths
      (     ;)          Raze; unbox and concatenate
     ] <;.1~            Cut the input string on ones as starting marker, then box each
5  A.  Rearrange the boxes in the order 0 3 2 1
 ;@    Raze again

이 함수는 유효하지 않은 입력을 자동으로 처리합니다.

• 입력 길이가 4의 배수가 아닌 경우, {.슬로우 domain error길이 인수는 정수이어야하기 때문이다.
• 입력 길이가 4 인 경우 컷은 두 개의 세그먼트 만 생성 5 A.하고을 던집니다 index error.
• 입력 길이가 0 인 경우 잘라낼 두 인수의 길이가 같지 않아 length error발생합니다.

파이썬 (3) , 103 (102) 101 97 88 86 84 바이트

def f(s):l=len(s);l//=4*(l%4<1<l/4);return s[:l-1]+s[1-l:]+s[2*l-1:1-l]+s[l-1:2*l-1]

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

실제로 한 줄짜리 ;가 아니라 줄 바꿈 및 들여 쓰기보다 줄 당 바이트가 1 줄입니다.

예외 ZeroDivisionError입력 문자열 길이가 8 미만의 여부 (4)의 정수배 인 경우.

파이썬 2에서도 작동합니다.

_{Jo King 덕분에 -4 바이트}

_{ovs 덕분에 -9 바이트}

_{Jonathan Frech 덕분에 -2 바이트}

_{Bubbler 덕분에 -2 바이트}

펄 6 , 78 바이트

*.comb[0..*/4-2,3* */4+1..*,*/2-1/(*>7)..3* */4,*/4-1/(*%%4)..*/2-2].flat.join

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

문자열을 가져와 유효한 경우 수정 된 문자열을 반환하는 익명 코드 블록, 그렇지 않으면 0으로 나누기 오류를 반환합니다. 배열을 직접 수정할 수 있다는 것을 알고 있으므로 문자열의 두 섹션을 바꿀 수는 있지만 알아낼 수는 없습니다.

K (NGN / K) , 120 (113) 103 99 95 바이트

{$[(r>7)&0=4!r:#:x;{g:(s:*|(y*2)#x)\x;((y-1)#*g),((-y-1)#*|g),s,((y+1)#*|g),(-y)#*g}[x;r%4];l]}

문자열 길이를 4로 나눌 수 있는지 테스트하기위한 추가 기능을 포함하여 더 많이 골프를 치기를 바랍니다. 입력이 유효하지 않은 경우 선언되지 않은 변수를 참조하여 출력 오류

편집 : 7보다 큰 길이의 누락 된 조건

편집 : 하나의 기능으로 결합, 중복 변수 선언 제거

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

Retina 0.8.2 , 58 또는 73 또는 83 또는 93 바이트

((((.)))*?)(.(?<-2>.)+)(...(?<-3>.)+)((?<-4>.)+)$
$1$7$6$5

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

((((.)))*?)

캡처 a하여 $1가능한 한 짧게 만드십시오 *?. $#2, $#3및 $#4길이로 끝 a.

(.(?<-2>.)+)

캡처 b에서 $4. (?<-2>.)+길이까지 캡처 a, 다른하면서 .필요한 길이에 1을 추가한다.

(...(?<-3>.)+)

캡처 s및 c에서 $6. 결합 된 길이는의 길이보다 3 이상입니다 a.

((?<-4>.)+)

캡처 d에서 $7. 길이는의 길이를 초과하지 않습니다 a.

$

우리는 a가능한 한 짧게 만들었지 만 여전히 입력의 끝에 도달하고 싶습니다.

$1$7$6$5

교환 b및 d.

위 단계는 입력을 확인하지 않습니다. Retina에는 런타임 오류가 없으므로 입력 유효성 검사를위한 여러 가지 옵션이 있습니다.

G`^(....){2,}$

길이가 8보다 작거나 4의 배수가 아닌 경우 아무것도 출력하지 않습니다 (+15 바이트).

^(?!(....){2,}$).*
Error

Error길이가 8보다 작거나 4의 배수가 아닌 경우 출력 합니다 (+25 바이트).

+`^(....)*..?.?$|^(....)?$
.....$1

길이가 8보다 작거나 4의 배수가 아닌 경우 정지합니다 (+35 바이트).

C (GCC) 로 -Dx=memcpy하고 -DL=(l-1), 154 158 160 바이트

입력 문자열 길이를 4 자 또는 8 자보다 짧게 나누지 않으면 NULL을 반환합니다.

Rogem과 Jonathan Frech에게 감사의 말을 전합니다.

편집 : 이동 전처리 기는 명령 줄에 정의하고 퍼즐을 엄격하게 준수하도록 문자열을 동적으로 할당했습니다.

f(s,t,l)char*s,*t;{l=strlen(s);l%4|l<8?t=0:(t=malloc(l+1),l/=4,x(t,s,L),x(t+L,s+3*l+1,L),x(t+2*L,s+L+l,l+2),x(t+3*l,s+L,l),t[4*l]=0);l=t;}//-Dx=memcpy -DL=(l-1)

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

젤리 , 28 바이트

L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F

(전체 프로그램이 허용되면 후행을 제거 할 수 있습니다. F)
길이가 8보다 작거나 4로 나눌 수없는 경우 (float) ValueError의 정수 나누기 동안 a 가 발생 inf합니다 4-나누기 수율 NaN(또한 float) 에 캐스팅됩니다 int.

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

어떻게?

L7»4ḍİ×L:4;;ĖÄƲFÄœṖ⁸⁽%[D¤ị$F - Link: list of characters
L                            - length
 7                           - literal seven
  »                          - maximum (of length & 7)
   4ḍ                        - divisible by four? (yields 1 for good inputs; 0 otherwise)
     İ                       - inverse (1 yields 1; 0 yields inf)
      ×L                     - multiply by length (length or inf)
        :4                   - integer divide by 4 (errors given inf)
              Ʋ              - last four links as a monad (f(x)):
          ;                  -   concatenate -> [x,x]
            Ė                -   enumerate -> [1,x]
           ;                 -   concatenate -> [x,x,[1,x]]
             Ä               -   cumulative sum (vectorises at depth 1) -> [x,x,[1,1+x]]
               F             - flatten -> [x,x,1,1+x]
                Ä            - cumulative sum -> [x,2x,2x+1,3x+2]
                   ⁸         - chain's left argument (the input)
                 œṖ          - partition at indices (chops up as per requirements)
                          $  - last two links as a monad (f(z)):
                        ¤    -   nilad followed by link(s) as a nilad:
                    ⁽%[      -     10342
                       D     -     decimal digits -> [1,0,3,4,2]
                         ị   -   index into z (rearranges the pieces as per requirements)
                           F - flatten (back to a list of characters)

젤리 , 25 바이트

L:4’+“¡¢¢£¡‘Ṡ3¦ÄṬk⁸Ṛ2,5¦Ẏ

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

는 Ẏ전체 프로그램에이를 만들기 위해 제거 할 수 있습니다.

루비 , 64 바이트

->s{a=s.size/4;s[1-a,a],s[a-1,a]=s[a-1,a],s[1-a,a];s[a*4]?1/0:s}

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

자바 스크립트 (ES6), 97 89 바이트

@ l4m2 덕분에 8 바이트 절약

s=>(l=s.length/4)<2||l%1?Z:s.replace(eval(`/(.{${l}})(.{${l+2}})(.{${l-1}})$/`),'$3$2$1')

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

자바 스크립트 (Node.js) , 80 바이트

s=>(g=s.substr.bind(s))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

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

자바 스크립트 (Node.js) , 84 바이트

s=>(g=(a,b)=>s.substr(a,b))(0,l=s.length/4-1)+g(-l)+g(l-~l,l+3)+g(l,l+1,l<1==l%1||Z)

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

JavaScript (Node.js) , 87 바이트

s=>(l=s.length/4)<2||l%1?Z:(g=(a,b)=>s.substr(a,b))(0,l-1)+g(1-l)+g(l+l-1,l+2)+g(l-1,l)

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

RegExp보다 짧음

자바 8, 135 바이트

s->{int l=s.length();l=l>7&l%4<1?l/4:l/0;return s.substring(0,l-1)+s.substring(3*l+1)+s.substring(2*l-1,3*l+1)+s.substring(l-1,2*l-1);}

ArithmeticException입력 문자열이 요구 사항과 일치하지 않으면 던집니다 (0으로 나눔). 여기에서 온라인으로 사용해보십시오 .

언 골프 드 :

s -> { // lambda function taking a String argument and returning a String
    int l = s.length(); // take the length of the input ...
    l = l > 7 &         // ... if it's  greater than 7 and ...
        l % 4 < 1       // ... a multiple of 4 ...
      ? l / 4           // ... divide by 4; otherwise ...
      : l / 0;          // ... error out (division by zero throws ArithmeticException)
    return // concatenate and return:
           s.substring(0, l - 1)             // a
         + s.substring(3 * l + 1)            // d
         + s.substring(2 * l - 1, 3 * l + 1) // sc
         + s.substring(l - 1, 2 * l - 1);    // b
}

C (gcc) 129 바이트

수정하여 반환합니다. 다음과 같이 컴파일하십시오.

-Df(s)=({char t[l=strlen(s)];l%4|l<8?0:(l/=4,x(t,s+l*2-1,l-~l),x(x(x(s+l*3,s+l-1,l)-l-2,t,l+2)-l+1,t+l+2,l-1),s);}) -Dx=memcpy

소스 파일:

l;

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

데 고프

-Df(s)=({ // Function-like macro f. Takes a char* as a parameter.
          // Return value is a pointer to s if successful, and to NULL if string was invalid.
     char t[l=strlen(s)]; // Allocate a local temp string.
     l%4|l<8?0: // Detect invalid strings. Return 0 (NULL) on invalid string.
         (l/=4, // We're only really concerned with floor(len/4), and this will yield that.
             memcpy(t,s+l*2-1,l-~l), // Copy the second half of chars to the temp storage.
             memcpy( // Because memcpy returns the address of the destination, we can chain
                     // the calls to save quite a few bytes, even after x->memcpy substitution.
                 memcpy(memcpy(s+l*3,s+l-1,l) // Next, copy the second quarter to the end.
                     -l-2,t,l+2) // After that, we copy back the third quarter to its place.
                          -l+1,t+l+2,l-1) // Finally, copy the fourth quarter to where the second
                                          // quarter was.
                      ,s);}) // And return the pointer.