In dem absurden Stück Rosencrantz und Guildenstern sind tot , die beiden Hauptfiguren Rosencrantz und Guildenstern (oder sind sie?) Verwechseln immer welche von ihnen wer - oder manchmal welche ihrer eigenen Körperteile welche - wegen eines wahrgenommenen Mangels an individuelle Identität. Wäre es nicht absurd, wenn sie überhaupt um ihre Namen schlurften?

Ihre Aufgabe ist es, eine Funktion zu schreiben, die eine Zeichenfolge mit einer geraden Länge (und standardmäßig einem Vielfachen von 4) mit mehr als 7 Zeichen enthält, sie zu teilen und zu mischen.

Die Aufteilung muss wie folgt sein : Die Zeichenfolge hat das Format "abscd", wobei s als Trennzeichen fungiert. Der erste Abschnitt und das Trennzeichen sind absdie erste Hälfte der Zeichenfolge, die zweite Hälftecd

Die Länge von awird sein(string length / 4) - 1

Die Länge von bwird sein(string length / 4)

Die Länge von swird sein1

Die Länge von cwird sein(string length / 4) + 1

Die Länge von dwird sein(string length / 4) - 1

Dies kann sehr verwirrend sein. Lassen Sie mich Ihnen einige Beispiele zeigen

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

Schließlich:

Anschließend mischen Sie die Teile und geben sie aus adscb

Ex. "rosencrantz&guildenstern" --> "rosenstern&guildencrantz"

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

Rulez:

1. Standardlücken sind verboten
2. Akzeptable Antworten: Eine Funktion, die Eingaben über eine Eingabezeichenfolge und eine Ausgabezeichenfolge zurückgibt
3. Wenn die Eingabezeichenfolge nicht den oben angegebenen Anforderungen entspricht, MUSS Ihr Code fehlerhaft sein (egal welche Art von Exceptionoder Error)
4. Dies ist code-golf, also gewinnt die kürzeste (gültige) Antwort (in jeder Sprache)!
5. Bonuspunkte für einen Einzeiler :-) (Nicht wirklich, nur coole Punkte)

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

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

Probieren Sie es online aus!

Ohne Eingabevalidierung (für ngns Kopfgeld) _{25 24} 23 Bytes

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

Probieren Sie es online aus!

Ich lernte schnell ein bisschen K und als ich mir die Liste der Verben ansah, dachte ich, dass ein alternativer Ansatz ( ohne Cut) hier funktionieren könnte. Und es hat perfekt funktioniert.

Wie es funktioniert

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

-2 Bytes dank Jo King

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

Probieren Sie es online aus!

Wirft im Fehlerfall "Rotorizing Sublist Length liegt außerhalb des Bereichs".

Erläuterung

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

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

Probieren Sie es online aus!

-1 Byte mal {.+ negative Längen & ;.2die stattdessen als "Endmarker" auf diejenigen schneiden.

Ursprüngliche Antwort, 36 Bytes

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

Probieren Sie es online aus!

ngn erwähnte "cut" in einem Kommentar zu einer früheren K-Antwort und brachte mich dazu, J zu versuchen, das den gleichen "cut" hat (ich habe keine Ahnung, wie K funktioniert).

Wie es funktioniert

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

Beachten Sie, dass diese Funktion ungültige Eingaben automatisch verarbeitet:

• Wenn die Eingabelänge kein Vielfaches von vier ist, wird {.ausgelöst, domain errorda das Längenargument Ganzzahlen sein muss.
• Wenn die Eingabelänge 4 beträgt, erzeugt der Schnitt nur zwei Segmente und 5 A.wirft index error.
• Wenn die Eingabelänge 0 ist, haben die beiden zu schneidenden Argumente nicht dieselbe Länge und werden daher length errorausgelöst.

Python 3 , 103 102 101 97 88 86 84 Bytes

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]

Probieren Sie es online aus!

Nicht wirklich ein ;Einzeiler , aber ein Byte weniger pro Zeile als Zeilenumbruch und Einzug.

ZeroDivisionErrorWird ausgelöst, wenn die Länge der Eingabezeichenfolge kleiner als 8 ist oder kein ganzzahliges Vielfaches von 4.

Funktioniert auch in Python 2.

_{-4 Bytes dank Jo King}

_{-9 Bytes dank Ovs}

_{-2 Bytes dank Jonathan Frech}

_{-2 Bytes dank Bubbler}

Perl 6 , 78 Bytes

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

Probieren Sie es online aus!

Anonymer Codeblock, der eine Zeichenfolge verwendet und die geänderte Zeichenfolge zurückgibt, falls gültig, andernfalls wird ein Fehler durch Division durch Null zurückgegeben. Ich weiß, dass ich ein Array direkt ändern kann, damit ich die beiden Abschnitte der Zeichenfolge austauschen kann, aber ich kann es nicht ganz herausfinden.

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

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

Hoffentlich kann mehr Golf gespielt werden, eine zusätzliche Funktion zum Testen, ob die Stringlänge durch vier teilbar ist, gibt einen Fehler in Bezug auf eine nicht deklarierte Variable aus, wenn die Eingabe ungültig ist

BEARBEITEN: Fehlende Bedingung bei einer Länge von mehr als 7, inklusive

BEARBEITEN: In einer Funktion zusammengefasst, wurden redundante Variablendeklarationen entfernt

Probieren Sie es online aus!

Retina 0,8,2 , 58 oder 73 oder 83 oder 93 Bytes

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

Probieren Sie es online aus! Erläuterung:

((((.)))*?)

Capture ain $1und macht es so kurz wie möglich *?. $#2, $#3Und $#4bis zu der Länge des Ende a.

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

Erfassen bin $4. Der (?<-2>.)+erfasst bis zur Länge von a, während der andere .nach Bedarf 1 zu seiner Länge hinzufügt.

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

Erfassen sund cein $6. Ihre kombinierte Länge ist drei mehr als die Länge von a.

((?<-4>.)+)

Erfassen din $7. Seine Länge ist nicht größer als die Länge von a.

$

Wir haben aso kurz wie möglich gemacht, aber wir wollen immer noch das Ende der Eingabe erreichen.

$1$7$6$5

Austausch bund d.

Die obige Stufe validiert ihre Eingabe nicht. Da Retina keine Laufzeitfehler aufweist, gibt es eine Reihe von Optionen für die Eingabevalidierung:

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

Gibt nichts aus, wenn die Länge kleiner als 8 ist oder nicht ein Vielfaches von 4. (+15 Bytes)

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

ErrorWird ausgegeben, wenn die Länge weniger als 8 oder nicht ein Vielfaches von 4 beträgt. (+25 Byte)

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

Hängt, wenn die Länge weniger als 8 beträgt oder nicht ein Vielfaches von 4. (+35 Bytes)

C (GCC) mit -Dx=memcpyund -DL=(l-1), 154 158 160 Byte

Gibt NULL zurück, wenn die Länge der Eingabezeichenfolge nicht durch 4 oder weniger als 8 Zeichen teilbar ist.

Vielen Dank an Rogem und Jonathan Frech für die Vorschläge.

BEARBEITEN: Der verschobene Präprozessor definiert die Befehlszeile und hat die Zeichenfolge dynamisch zugewiesen, um sie genau an das Puzzle anzupassen.

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)

Probieren Sie es online aus!

Gelee , 28 Bytes

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

(Wenn ein vollständiges Programm erlaubt ist, können wir das Trailing entfernen. F)
Wenn die Länge kleiner als 8 ist oder nicht durch vier teilbar ValueErrorist, wird a während der ganzzahligen Division von inf(einem Float) durch 4- die Division ergibt NaN(auch ein Float), was dann nicht kann zu einem gegossen werden int.

Probieren Sie es online aus!

Wie?

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)

Gelee , 25 Bytes

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

Probieren Sie es online aus!

Das Ẏkann entfernt werden, um daraus ein vollständiges Programm zu machen.

Ruby , 64 Bytes

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

Probieren Sie es online aus!

JavaScript (ES6), 97 89 Byte

8 Bytes dank @ l4m2 gespeichert

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

Probieren Sie es online aus!

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)

Probieren Sie es online aus!

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)

Probieren Sie es online aus!

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)

Probieren Sie es online aus!

Kürzer als RegExp

Java 8, 135 Bytes

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

Wirft ArithmeticException(dividiert durch Null), wenn die Eingabezeichenfolge nicht den Anforderungen entspricht. Probieren Sie es hier online aus .

Ungolfed:

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 Bytes

Rückgabe durch Änderung. Kompilieren mit:

-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

Quelldatei:

l;

Probieren Sie es online aus!

Degolf

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