Diberi kunci, dan array string, kocok array sehingga diurutkan ketika setiap elemen XOR'd dengan kunci.

XOR'ing dua string

Untuk XOR string dengan kunci, XOR masing-masing nilai karakter dari string dengan pasangannya di kunci, dengan asumsi bahwa kunci berulang selamanya. Misalnya, abcde^123terlihat seperti:

       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

Penyortiran

Penyortiran harus selalu dilakukan secara Leksikografis dari string XOR. Yaitu, 1 < A < a < ~(Mengasumsikan pengkodean ASCII)

Contoh

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

Catatan

• Kunci akan selalu setidaknya 1 karakter
• Kunci dan Input hanya akan terdiri dari ASCII yang dapat dicetak.
• String XOR'd mungkin berisi karakter yang tidak dapat dicetak.
• Input dan Output dapat dilakukan melalui Metode yang Wajar
• Celah Standar dilarang.
• Anda dapat mengambil Kunci dan Input dalam urutan apa pun.

Uji Kasus

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

Ini kode-golf , jadi paling tidak byte menang!

Jelly , 9 7 byte

⁹ṁO^OµÞ

Terima kasih kepada @EriktheOutgolfer untuk saran yang membantu menghemat 2 byte!

Cobalah online!

Bagaimana itu bekerja

⁹ṁ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))])

Ini mengurutkan daftar x di tempat.

Terima kasih kepada @mercator untuk bermain golf 2 byte!

Cobalah online!

Versi alternatif, 62 byte

Ini mengambil input sebagai string byte, yang mungkin tidak diizinkan.

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

Cobalah online!

Haskell, 77 byte

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

Terlalu banyak impor.

Cobalah online!

Ruby , 61 byte

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

Cobalah online!

Bersih , 101 100 94 byte

-6 byte terima kasih kepada Ourous!

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

Cobalah online! Contoh penggunaan:s ['3'] [['who'], ['what'], ['when']] .

Tidak Disatukan:

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

Sebenarnya , 24 byte

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

Cobalah online!

Penjelasan:

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

Cobalah online!

$^adan @^bargumen kunci dan array untuk fungsi masing-masing. @^b.sort(...)cukup mengurutkan array input sesuai dengan fungsi predikat yang diberikan. Fungsi itu membutuhkan satu argumen, jadisort akan meneruskannya setiap elemen pada gilirannya dan memperlakukan nilai kembali sebagai kunci untuk elemen itu, menyortir daftar dengan kunci elemen.

Fungsi penyortiran adalah *.comb Z~^ (|$^a.comb xx *). *adalah argumen string tunggal ke fungsi. *.combadalah daftar karakter individu dari string. |$^a.comb xx *adalah daftar karakter dalam kunci sortir xor, direplikasi tanpa batas. Kedua daftar tersebut di-zip bersama-sama ( Z) menggunakan operator xwise stringwise ( ~^). Karena predikat pengurutan mengembalikan kunci pengurutan yang merupakan daftar, sortmemesan dua elemen dengan membandingkan elemen pertama dari daftar yang dikembalikan, maka elemen kedua jika elemen pertama sama, dan lain-lain.

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

Mengambil jumlah argumen dan pointer ke array string (kunci, diikuti oleh string yang akan diurutkan) dan memodifikasi array string di tempat.

Kode ini sangat non-portabel dan membutuhkan pointer 64-bit, gcc, dan glibc.

Terima kasih kepada @ceilingcat untuk bermain golf 2 byte!

Cobalah online!

Python 2,  204 140 134  126 byte

Terima kasih untuk @Mr. Xcoder untuk menyimpan 64 byte, terima kasih kepada @ovs karena telah menghemat enam byte, dan terima kasih kepada @Dennis karena telah menghemat delapan 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))

Cobalah online!

opcode x86, 57 Bytes

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            

Kode uji:

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 Bytes

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 panjang di charcoding ...

Untuk [0,65536) + 1e4 semuanya menjadi 5 digit sehingga dapat dibandingkan seperti string

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

Cobalah 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,@_}

coba 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:""}}}

Cobalah online!

Menerima input dalam bentuk key word word ...mis912 abcde hello test honk

Keluaran kata diurutkan spasi terpisah

Sedikit lebih mudah dibaca

{
  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 : ""
    }
  }
}  

Faktor, 85

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

Coba pertama, saya akan melihat apakah saya bisa bermain golf lebih jauh besok.

Saya menerima saran;)

Dyalog APL, 34 byte

Dfn, gunakan ⎕ml 3

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