Nell'assurdista dramma Rosencrantz e Guildenstern sono morti , i due personaggi principali Rosencrantz e Guildenstern (o sono?) Mescolano sempre chi di loro è - o talvolta quale delle loro parti del corpo è quale - a causa di una percepita mancanza di identità individuale. Non sarebbe assurdo se si trascinassero intorno ai loro nomi?

Il vostro compito è di scrivere una funzione che prende in una stringa di un ancora di lunghezza (e in base alla progettazione, un multiplo di 4) che è maggiore di 7 caratteri, divise, e shuffle esso.

La divisione sarà la seguente : la stringa sarà di formato "abscd", con s che agisce da carattere separato. La prima sezione e il separatore abssaranno la prima metà della stringa, mentre la seconda saràcd

La lunghezza di asarà(string length / 4) - 1

La lunghezza di bsarà(string length / 4)

La lunghezza di ssarà1

La lunghezza di csarà(string length / 4) + 1

La lunghezza di dsarà(string length / 4) - 1

Questo può essere davvero confuso, quindi lascia che ti mostri alcuni esempi

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

Finalmente:

Quindi mescoli le parti in giro, producendo adscb

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

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

Rulez:

1. Sono vietate le scappatoie standard
2. Risposte accettabili: una funzione che accetta l'input attraverso una stringa di input e restituisce una stringa di output
3. Se la stringa di input non corrisponde ai requisiti sopra indicati, il codice DEVE essere in errore (non importa quale tipo di Exceptiono Error)
4. Questa è code-golf, quindi vince la risposta (valida) più breve (in ogni lingua)!
5. Punti bonus per un solo giocatore :-) (Non proprio però, solo punti interessanti)

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

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

Provalo online!

Senza convalida dell'input (per la taglia di ngn), _{25 24} 23 byte

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

Provalo online!

Ho imparato rapidamente un po 'di K e, guardando l'elenco dei verbi, ho pensato che un approccio alternativo ( non usando il taglio) potesse funzionare qui. E ha funzionato perfettamente.

Come funziona

{<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 grazie a Jo King

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

Provalo online!

Genera "La rotazione della lunghezza dell'elenco secondario non rientra nell'intervallo" in caso di errore.

Spiegazione

{               # 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%~#

Provalo online!

-1 byte per {.+ lunghezze negative e ;.2che taglia invece quelle come marcatori "finali".

Risposta originale, 36 byte

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

Provalo online!

ngn ha menzionato "tagliare" in un commento a una precedente risposta di K , e mi ha fatto provare J che ha lo stesso "taglio" (non ho idea di come K funzioni).

Come funziona

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

Questa funzione gestisce automaticamente input non validi:

• Se la lunghezza dell'input non è un multiplo di quattro, {.genera domain errorpoiché il suo argomento length deve essere numeri interi.
• Se la lunghezza di input è 4, il taglio produce solo due segmenti e 5 A.genera index error.
• Se la lunghezza dell'input è 0, i due argomenti da tagliare non hanno la stessa lunghezza, quindi length errorviene lanciato.

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]

Provalo online!

Non è un one-liner, ma ;è un byte in meno per riga rispetto all'interruzione di riga e al rientro.

ZeroDivisionErrorViene generato se la lunghezza della stringa di input è inferiore a 8 o non un multiplo intero di 4.

Funziona anche in Python 2.

_{-4 byte grazie a Jo King}

_{-9 byte grazie agli ovs}

_{-2 byte grazie a Jonathan Frech}

_{-2 byte grazie a Gorgogliatore}

Perl 6 , 78 byte

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

Provalo online!

Blocco di codice anonimo che accetta una stringa e restituisce la stringa modificata se valida, altrimenti restituisce una divisione per zero errori. So di poter modificare direttamente un array, in modo da poter scambiare le due sezioni della stringa, ma non riesco proprio a capirlo.

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

Si spera che si possa giocare di più, inclusa una funzione aggiuntiva per testare se la lunghezza della stringa è divisibile per quattro, genera un errore con riferimento alla variabile non dichiarata se l'input non è valido

EDIT: condizione mancante su lunghezza superiore a 7, inclusa

EDIT: combinato in una funzione, rimosse dichiarazioni variabili ridondanti

Provalo online!

Retina 0.8.2 , 58 o 73 o 83 o 93 byte

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

Provalo online! Spiegazione:

((((.)))*?)

Cattura ain $1, e renderlo il più breve possibile *?. $#2, $#3E $#4finire come la lunghezza a.

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

Cattura bdentro $4. Le (?<-2>.)+catture fino alla lunghezza a, mentre l'altro .aggiunge 1 alla sua lunghezza come richiesto.

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

Cattura se cdentro $6. La loro lunghezza combinata è tre in più della lunghezza di a.

((?<-4>.)+)

Cattura ddentro $7. La sua lunghezza non è superiore alla lunghezza di a.

$

Abbiamo reso il apiù breve possibile, ma vogliamo comunque raggiungere la fine dell'input.

$1$7$6$5

Scambio be d.

La fase precedente non convalida il suo input. Poiché Retina non presenta errori di runtime, esistono diverse opzioni per la convalida dell'input:

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

Non genera nulla se la lunghezza è inferiore a 8 o non un multiplo di 4. (+15 byte)

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

Emette Errorse la lunghezza è inferiore a 8 o non un multiplo di 4. (+25 byte)

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

Si blocca se la lunghezza è inferiore a 8 o non un multiplo di 4. (+35 byte)

C (gcc) con -Dx=memcpye -DL=(l-1), 154 158 160 byte

Restituisce NULL se la lunghezza della stringa di input non è divisibile per 4 o inferiore a 8 caratteri.

Grazie a Rogem e Jonathan Frech per i suggerimenti.

EDIT: Il preprocessore spostato definisce la riga di comando e ha reso la stringa allocata dinamicamente per conformarsi rigorosamente al puzzle.

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)

Provalo online!

Gelatina , 28 byte

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

(Se è consentito un programma completo possiamo rimuovere il trailing F)
Se la lunghezza è inferiore a 8 o non divisibile per quattro a ValueErrorviene sollevato durante la divisione intera di inf(un float) per 4- la divisione produce NaN(anche un float) che quindi non può essere lanciato su un int.

Provalo online!

Come?

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)

Gelatina , 25 byte

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

Provalo online!

Il Ẏpuò essere rimosso per trasformarlo in un programma completo.

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

Provalo online!

JavaScript (ES6), 97 89 byte

Risparmiato 8 byte grazie a @ l4m2

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

Provalo online!

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)

Provalo online!

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)

Provalo online!

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)

Provalo online!

Più corto di 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);}

Genera ArithmeticException(si divide per zero) se la stringa di input non corrisponde ai requisiti. Provalo online qui .

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 byte

Restituisce per modifica. Compilare con:

-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

File sorgente:

l;

Provalo online!

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.