Trong vở kịch phi lý Rosencrantz và Guildenstern đã chết , hai nhân vật chính Rosencrantz và Guildenstern (hoặc họ?) Luôn luôn trộn lẫn giữa ai trong số họ là ai hoặc đôi khi là bộ phận cơ thể của chính họ mà họ cảm thấy thiếu. bản sắc cá nhân. Sẽ không phải là vô lý nếu họ thậm chí xáo trộn xung quanh tên của họ?

Nhiệm vụ của bạn là viết một hàm có một chuỗi có độ dài chẵn (và theo thiết kế, bội số của 4) lớn hơn 7 ký tự, tách nó và xáo trộn nó.

Việc chia tách sẽ như sau : chuỗi sẽ có định dạng "abscd", với s đóng vai trò là ký tự phân tách . Phần đầu tiên và dấu phân cách, abssẽ là nửa đầu của chuỗi, trong khi nửa sau sẽ làcd

Độ dài của asẽ là(string length / 4) - 1

Độ dài của bsẽ là(string length / 4)

Độ dài của ssẽ là1

Độ dài của csẽ là(string length / 4) + 1

Độ dài của dsẽ là(string length / 4) - 1

Điều này có thể thực sự khó hiểu, vì vậy hãy để tôi chỉ cho bạn một số ví dụ

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

Cuối cùng:

Sau đó, bạn xáo trộn các bộ phận xung quanh, xuất ra adscb

Ví dụ. "rosencrantz&guildenstern" --> "rosenstern&guildencrantz"

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

Quy tắc:

1. Lỗ hổng tiêu chuẩn bị cấm
2. Câu trả lời chấp nhận được: một hàm nhận đầu vào thông qua một chuỗi đầu vào và trả về một chuỗi đầu ra
3. Nếu chuỗi đầu vào không khớp với các yêu cầu được cung cấp ở trên, mã của bạn PHẢI lỗi (không quan trọng là loại nào Exceptionhoặc Error)
4. Đây là code-golf, vì vậy câu trả lời ngắn nhất (hợp lệ) (trong mỗi ngôn ngữ) sẽ thắng!
5. Điểm thưởng cho một lớp lót :-) (Không thực sự tho, chỉ là điểm tuyệt vời)

K (oK) , _{35 34} 33 byte

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

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

Không có xác thực đầu vào (đối với tiền thưởng của ngn), _{25 24} 23 byte

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

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

Nhanh chóng học được một chút về K và, nhìn vào danh sách các động từ, tôi nghĩ rằng một cách tiếp cận khác ( không sử dụng cắt) có thể hoạt động ở đây. Và nó hoạt động hoàn hảo.

Làm thế nào nó hoạt động

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

Perl 6 , 60 58 byte

-2 byte nhờ Jo King

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

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

Ném "Chiều dài danh sách con quay ra ngoài phạm vi" trong trường hợp có lỗi.

Giải trình

{               # 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 byte

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

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

Thay vào đó, 1 byte bằng {.+ độ dài âm và ;.2sẽ cắt trên những cái làm dấu "kết thúc".

Câu trả lời gốc, 36 byte

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

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

ngn đã đề cập "cắt" trên một nhận xét cho câu trả lời K trước đó và nó đã khiến tôi thử J có cùng "cắt" (tôi không biết K hoạt động như thế nào).

Làm thế nào nó hoạt động

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

Lưu ý rằng chức năng này tự động xử lý các đầu vào không hợp lệ:

• Nếu độ dài đầu vào không phải là bội số của bốn, {.ném domain errorvì đối số độ dài của nó phải là số nguyên.
• Nếu độ dài đầu vào là 4, phần cắt chỉ tạo ra hai đoạn và 5 A.ném index error.
• Nếu độ dài đầu vào là 0, hai đối số cần cắt không có cùng độ dài, do đó length errorsẽ bị ném.

Python 3 , 103 102 101 97 88 86 84 byte

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]

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

Không thực sự là một lớp lót, nhưng ;là một byte ít hơn trên mỗi dòng so với ngắt dòng và thụt lề.

Ném ZeroDivisionErrornếu độ dài chuỗi đầu vào nhỏ hơn 8 hoặc không phải là bội số nguyên của 4.

Cũng hoạt động trong Python 2.

_{-4 byte nhờ Jo King}

_{-9 byte nhờ vào ovs}

_{-2 byte nhờ Jonathan Frech}

_{-2 byte nhờ Bubbler}

Perl 6 , 78 byte

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

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

Khối mã ẩn danh nhận một chuỗi và trả về chuỗi đã sửa đổi nếu hợp lệ, khác sẽ trả về một phép chia bằng 0. Tôi biết tôi có thể sửa đổi một mảng trực tiếp, vì vậy tôi có thể trao đổi hai phần của chuỗi, nhưng tôi không thể tìm ra nó.

K (ngn / k) , 120 113 103 99 95 byte

{$[(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]}

Hy vọng có thể được đánh xuống nhiều hơn, bao gồm một chức năng bổ sung để kiểm tra nếu độ dài chuỗi chia hết cho bốn, lỗi đầu ra có tham chiếu đến biến không được khai báo nếu đầu vào không hợp lệ

EDIT: Điều kiện bị thiếu trên chiều dài lớn hơn 7, bao gồm

EDIT: Kết hợp thành một hàm, loại bỏ khai báo biến dư thừa

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

Retina 0.8.2 , 58 hoặc 73 hoặc 83 hoặc 93 byte

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

Hãy thử trực tuyến! Giải trình:

((((.)))*?)

Chụp atrong $1, và làm cho nó càng ngắn càng tốt *?. $#2, $#3Và $#4kết thúc như độ dài của a.

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

Chụp btrong $4. Các (?<-2>.)+ảnh chụp lên đến chiều dài a, trong khi cái còn lại .thêm 1 vào chiều dài của nó theo yêu cầu.

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

Chụp svà ctrong $6. Chiều dài kết hợp của chúng là ba nhiều hơn chiều dài a.

((?<-4>.)+)

Chụp dtrong $7. Chiều dài của nó không quá chiều dài a.

$

Chúng tôi đã thực hiện acàng ngắn càng tốt, nhưng chúng tôi vẫn muốn đạt đến cuối của đầu vào.

$1$7$6$5

Trao đổi bvà d.

Giai đoạn trên không xác nhận đầu vào của nó. Vì Retina không có lỗi thời gian chạy, nên có một số tùy chọn để xác thực đầu vào:

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

Không tạo ra kết quả nếu độ dài nhỏ hơn 8 hoặc không phải là bội số của 4. (+15 byte)

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

Đầu ra Errornếu độ dài nhỏ hơn 8 hoặc không phải là bội số của 4. (+25 byte)

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

Treo nếu độ dài nhỏ hơn 8 hoặc không phải là bội số của 4. (+35 byte)

C (gcc) với -Dx=memcpyvà -DL=(l-1), 154 158 160 byte

Trả về NULL nếu độ dài chuỗi đầu vào không chia hết cho 4 hoặc ngắn hơn 8 ký tự.

Cảm ơn Rogem và Jonathan Frech cho những lời đề nghị.

EDIT: Bộ tiền xử lý đã di chuyển xác định dòng lệnh và làm cho chuỗi được phân bổ động để tuân thủ nghiêm ngặt câu đố.

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)

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

Thạch , 28 byte

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

(Nếu chương trình đầy đủ được cho phép, chúng tôi có thể xóa dấu vết F)
Nếu độ dài nhỏ hơn 8 hoặc không chia hết cho bốn a ValueErrorđược tăng lên trong phép chia số nguyên của inf(một số float) bởi 4- phép chia sẽ mang lạiNaN (cũng là một float) mà sau đó có thể không được đúc thành một int.

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

Làm sao?

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)

Thạch , 25 byte

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

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

Có Ẏthể được gỡ bỏ để làm cho điều này thành một chương trình đầy đủ.

Ruby , 64 byte

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

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

JavaScript (ES6), 97 89 byte

Đã lưu 8 byte nhờ @ l4m2

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

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

JavaScript (Node.js) , 80 byte

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)

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

JavaScript (Node.js) , 84 byte

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)

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

JavaScript (Node.js) , 87 byte

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)

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

Ngắn hơn RegExp

Java 8, 135 byte

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

Ném ArithmeticException(chia cho số không) nếu chuỗi đầu vào không khớp với yêu cầu. Dùng thử trực tuyến tại đây .

Ung dung:

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 byte

Trả về bằng cách sửa đổi. Biên dịch với:

-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

Nguồn tập tin:

l;

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

Thuốc khử trùng

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