Data una chiave e una matrice di stringhe, mescola la matrice in modo che venga ordinata quando ogni elemento è XOR con la chiave.

XOR'ing due stringhe

Per XOR una stringa di una chiave, XOR ciascuno dei valori di carattere della stringa per la sua coppia nella chiave, supponendo che la chiave si ripeta per sempre. Ad esempio, abcde^123sembra:

       a        b        c        d        e
       1        2        3        1        2
--------------------------------------------
01100001 01100010 01100011 01100100 01100101
00110001 00110010 00110011 00110001 00110010
--------------------------------------------
01010000 01010000 01010000 01010101 01010111
--------------------------------------------
       P        P        P        U        W

Ordinamento

L'ordinamento dovrebbe sempre essere eseguito lessicograficamente con le stringhe XOR. Cioè, 1 < A < a < ~(Supponendo la codifica ASCII)

Esempio

"912", ["abcde", "hello", "test", "honk"]

-- XOR'd
["XSQ]T", "QT^U^", "MTAM", "Q^\R"]
-- Sorted
["MTAM", "QT^U^", "Q^\R", "XSQ]T"]
-- Converted back
["test", "hello", "honk", "abcde"]

Appunti

• La chiave avrà sempre almeno 1 carattere
• Chiave e input saranno costituiti solo da ASCII stampabile.
• Le stringhe XOR potrebbero contenere caratteri non stampabili.
• L'input e l'output possono essere effettuati attraverso i metodi ragionevoli
• Sono vietate le scappatoie standard .
• È possibile prendere chiave e input in qualsiasi ordine.

Casi test

key, input -> output
--------------------
"912", ["abcde", "hello", "test", "honk"] -> ["test", "hello", "honk", "abcde"]
"taco", ["this", "is", "a", "taco", "test"] -> ["taco", "test", "this", "a", "is"]
"thisisalongkey", ["who", "what", "when"] -> ["who", "what", "when"]
"3", ["who", "what", "when"] -> ["what", "when", "who"]

Questo è code-golf , quindi vince meno byte!

Gelatina , 9 7 byte

⁹ṁO^OµÞ

Grazie a @EriktheOutgolfer per un suggerimento che ha contribuito a salvare 2 byte!

Provalo online!

Come funziona

⁹ṁO^OµÞ  Dyadic link.
         Left argument: A (string array). Right argument: k (key string).

     µ   Combine the code to the left into a chain.
         Begin a new, monadic chain with argument A.
      Þ  Sort A, using the chain to the left as key.
         Since this chain is monadic, the key chain will be called monadically,
         once for each string s in A.
⁹            Set the return value to the right argument of the link (k).
 ṁ           Mold k like s, i.e., repeat its characters as many times as necessary
             to match the length of s.
  O          Ordinal; cast characters in the resulting string to their code points.
    O        Do the same for the chain's argument (s).
   ^         Perform bitwise XOR.

Python 3 , 75 73 byte

lambda k,x:x.sort(key=lambda s:[ord(x)^ord(y)for x,y in zip(s,k*len(s))])

Questo ordina l'elenco x sul posto.

Grazie a @mercator per giocare a golf con 2 byte!

Provalo online!

Versione alternativa, 62 byte

Questo accetta input come stringhe di byte, che potrebbero non essere consentite.

lambda k,x:x.sort(key=lambda s:[*map(int.__xor__,s,k*len(s))])

Provalo online!

Haskell, 77 byte

import Data.Bits
import Data.List
t=fromEnum
sortOn.zipWith((.t).xor.t).cycle

Troppe importazioni.

Provalo online!

Rubino , 61 byte

->k,w{w.sort_by{|x|x.bytes.zip(k.bytes.cycle).map{|x,y|x^y}}}

Provalo online!

Pulito , 101 100 94 byte

-6 byte grazie a Ourous!

import StdEnv
? =toInt
s k=let%s=[b bitxor?a\\a<-s&b<-[?c\\_<-s,c<-k]];@a b= %b> %a in sortBy@

Provalo online! Esempio di utilizzo:s ['3'] [['who'], ['what'], ['when']] .

Ungolfed:

import StdEnv
sort key list = 
   let
      f string = [(toInt a) bitxor (toInt b) \\ a<-string & b<-flatten(repeat key)]
      comp a b = f a <= f b
   in sortBy comp list

In realtà , 24 byte

O╗⌠;O;l;╜@αH♀^♂cΣ@k⌡MS♂N

Provalo online!

Spiegazione:

O╗⌠;O;l;╜@αH♀^♂cΣ@k⌡MS♂N
O╗                        store ordinals of key in register 0
  ⌠;O;l;╜@αH♀^♂cΣ@k⌡M     for each string in array:
   ;O                       make a copy, ordinals
     ;l;                    make a copy of ordinals, length, copy length
        ╜@αH                list from register 0, cycled to length of string
            ♀^              pairwise XOR
              ♂cΣ           convert from ordinals and concatenate
                 @k         swap and nest (output: [[a XOR key, a] for a in array])
                     S♂N  sort, take last element (original string)

Perl 6 , 37 byte

{@^b.sort(*.comb Z~^(|$^a.comb xx*))}

Provalo online!

$^ae @^bsono gli argomenti chiave e matrice della funzione, rispettivamente. @^b.sort(...)ordina semplicemente l'array di input in base alla funzione predicato che viene fornita. Tale funzione accetta un singolo argomento, quindi sortpasserà a turno ogni elemento e tratterà il valore restituito come chiave per quell'elemento, ordinando l'elenco in base alle chiavi degli elementi.

La funzione di ordinamento è *.comb Z~^ (|$^a.comb xx *). *è l'argomento stringa singola per la funzione. *.combè un elenco dei singoli caratteri della stringa. |$^a.comb xx *è un elenco di caratteri nella chiave di ordinamento xor, replicato all'infinito. Questi due elenchi vengono compressi insieme ( Z) usando l'operatore xor a stringhe ( ~^). Poiché il predicato di ordinamento restituisce una chiave di ordinamento che è un elenco, sortordina due elementi confrontando i primi elementi degli elenchi restituiti, quindi i secondi elementi se i primi elementi sono gli stessi, eccetera.

C (gcc) , 132 128 126 byte

char*k;g(a,b,i,r)char**a,**b;{r=k[i%strlen(k)];(r^(i[*a]?:-1))-(r^(i[*b]?:-2))?:g(a,b,i+1);}f(c,v)int*v;{k=*v;qsort(v,c,8,g);}

Accetta un conteggio argomenti e un puntatore a una matrice di stringhe (la chiave, seguita dalle stringhe da ordinare) e modifica la matrice di stringhe sul posto.

Il codice è altamente non portatile e richiede puntatori a 64 bit, gcc e glibc.

Grazie a @ceilingcat per giocare a golf con 2 byte!

Provalo online!

Python 2,  204 140 134  126 byte

Grazie a @Mr. Xcoder per il salvataggio di 64 byte, grazie a @ovs per il salvataggio di sei byte e grazie a @Dennis per il salvataggio di otto byte!

lambda k,l:[x(k,s)for s in sorted(x(k,s)for s in l)]
x=lambda k,s:''.join(chr(ord(v)^ord(k[i%len(k)]))for i,v in enumerate(s))

Provalo online!

Opcode x86, 57 byte

0100  60 89 CD 4D 8B 74 8A FC-8B 3C AA 53 F6 03 FF 75
0110  02 5B 53 8A 23 AC 08 C0-74 0A 30 E0 32 27 47 43
0120  38 E0 74 E8 77 0A 8B 04-AA 87 44 8A FC 89 04 AA
0130  85 ED 5B 75 CE E2 CA 61-C3

    ;input ecx(length), edx(array), ebx(xor-d)
F:  pushad
L1: mov ebp, ecx
L2: dec ebp
    mov esi, [edx+ecx*4-4]
    mov edi, [edx+ebp*4]
    push ebx
L6: test [ebx], byte -1 ; t1b
    jnz L4
    pop ebx
    push ebx
L4: mov ah, [ebx]
    lodsb
    or  al, al
    jz  L7
    xor al, ah
    xor ah, [edi]
    inc edi
    inc ebx
    cmp al, ah
    jz  L6
L7: ja  L8
    mov eax, dword[edx+ebp*4]
    xchg eax, dword[edx+ecx*4-4]
    mov dword[edx+ebp*4], eax
L8: ;call debug
    test ebp, ebp
    pop ebx
    jnz L2
    loop L1
    popad
    ret            

Codice di prova:

if 1
    use32
else
    org $0100
    mov ecx, (Qn-Q0)/4
    mov edx, Q0
    mov ebx, S
    call F
    call debug
    ret

debug:pushad
    mov ecx, (Qn-Q0)/4
    mov edx, Q0
    mov ebx, S
E3:   mov esi, [edx]
    push dx
    mov ah, 2
E4:   lodsb
    cmp al, 0
    jz E5
    mov dl, al
    int $21
    jmp E4
E5:   mov dl, $0A
    int $21
    mov dl, $0D
    int $21
    pop dx
    add edx, 4
    loop E3
    ;mov ah, 1
    ;int $21
    int1
    popad
    ret
    align 128
Q0:
    dd str1, str2, str3, str4
Qn:
S     db '912', 0
str1  db 'abcde', 0
str2  db 'hello', 0
str3  db 'test', 0
str4  db 'honk', 0
    align 128
end if
    ;input ecx(length), edx(array), ebx(xor-d)
F:  pushad
L1: mov ebp, ecx
L2: dec ebp
    mov esi, [edx+ecx*4-4]
    mov edi, [edx+ebp*4]
    push ebx
L6: test [ebx], byte -1 ; t1b
    jnz L4
    pop ebx
    push ebx
L4: mov ah, [ebx]
    lodsb
    or  al, al
    jz  L7
    xor al, ah
    xor ah, [edi]
    inc edi
    inc ebx
    cmp al, ah
    jz  L6
L7: ja  L8
    mov eax, dword[edx+ebp*4]
    xchg eax, dword[edx+ecx*4-4]
    mov dword[edx+ebp*4], eax
L8: ;call debug
    test ebp, ebp
    pop ebx
    jnz L2
    loop L1
    popad
    ret

JavaScript ES 6, 113 97 95 byte

k=>p=>p.sort((a,b,F=x=>[...x].map((y,i)=>1e9|y.charCodeAt()^(p=k+p).charCodeAt(i)))=>F(a)>F(b))

JavaScript richiede molto tempo per la codifica ...

Per [0,65536) + 1e4 sono tutte 5 cifre, quindi possono essere confrontate come una stringa

Q=
k=>p=>p.sort((a,b,F=x=>[...x].map((y,i)=>1e9|y.charCodeAt()^(p=k+p).charCodeAt(i)))=>F(a)>F(b))
;
console.log(Q("912")(["abcde", "hello", "test", "honk"]));
console.log(Q("taco")(["this", "is", "a", "taco", "test"]));
console.log(Q("thisisalongkey")(["who", "what", "when"]));
console.log(Q("3")(["who", "what", "when"]));

Perl 5, 88 byte

sub{[map@$_[0],sort{@$a[1]cmp@$b[1]}map[$_,substr$_^($_[0]x length),0,length],@{$_[1]}]}

Provalo online .

Clojure, 80 byte

#(sort-by(fn[s](apply str(apply map bit-xor(for[i[(cycle %)s]](map int i)))))%2)

Perl 5, 80 + 3 ( anl) = 83 , 67 byte

sub{$,=shift;sub X{$_^substr$,x y///c,0,y///c};map X,sort map X,@_}

provalo online

AWK , 285 284 byte

{for(;z++<128;){o[sprintf("%c",z)]=z}split(substr($0,0,index($0,FS)),k,"");$1="";split($0,w);for(q in w){split(w[q],l,"");d="";for(;i++<length(l);){d=d sprintf("%c",xor(o[k[(i-1)%(length(k)-1)+1]],o[l[i]]))}a[q]=d;i=0}asort(a,b);for(j in b){for(i in a){printf(a[i]==b[j])?w[i]FS:""}}}

Provalo online!

Accetta input sotto forma di key word word ... es912 abcde hello test honk

Stampa le parole ordinate nello spazio separato

Leggermente più leggibile

{
  for (; z++ < 128;) {
    o[sprintf("%c", z)] = z
  }
  split(substr($0, 0, index($0, FS)), k, "");
  $1 = "";
  split($0, w);
  for (q in w) {
    split(w[q], l, "");
    d = "";
    for (; i++ < length(l);) {
      d = d sprintf("%c", xor(o[k[(i - 1) % (length(k) - 1) + 1]], o[l[i]]))
    }
    a[q] = d;
    i = 0;
  }
  asort(a, b);
  for (j in b) {
    for (i in a) {
      printf(a[i] == b[j]) ? w[i] FS : ""
    }
  }
}  

Fattore, 85

[ [ dup length rot <array> concat [ bitxor ] 2map ] with
[ dup bi* <=> ] curry sort ]

Primo tentativo, vedrò se posso golf ulteriormente domani.

Accetto suggerimenti;)

Dyalog APL, 34 byte

Dfn, usa ⎕ml 3

{⍵[⍋⊃82⎕dr¨⊃≠/11⎕dr¨¨⍵((⍴¨⍵)⍴⊂⍺)]}