Đưa ra một khóa và một chuỗi các chuỗi, xáo trộn mảng để nó được sắp xếp khi mỗi phần tử là XOR'd với khóa.

XOR'ing hai chuỗi

Để XOR một chuỗi bằng một khóa, XOR từng giá trị ký tự của chuỗi theo cặp của nó trong khóa, giả sử rằng khóa đó lặp lại mãi mãi. Ví dụ: abcde^123trông như:

       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

Sắp xếp

Việc sắp xếp phải luôn luôn được thực hiện theo phương pháp phân tích theo chuỗi của XOR. Đó là, 1 < A < a < ~(Giả sử mã hóa ASCII)

Thí dụ

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

Ghi chú

• Khóa sẽ luôn có ít nhất 1 ký tự
• Khóa và đầu vào sẽ chỉ bao gồm ASCII có thể in được.
• Chuỗi XOR có thể chứa các ký tự không in được.
• Đầu vào và đầu ra có thể được thực hiện thông qua các Phương thức hợp lý
• Lỗ hổng tiêu chuẩn bị cấm.
• Bạn có thể lấy Key và Input theo bất kỳ thứ tự nào.

Các trường hợp thử nghiệm

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

Đây là mã golf , vì vậy ít byte nhất sẽ thắng!

Thạch , 9 7 byte

⁹ṁO^OµÞ

Cảm ơn @EriktheOutgolfer về một đề xuất giúp tiết kiệm 2 byte!

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

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

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

Điều này sắp xếp danh sách x tại chỗ.

Cảm ơn @mercator đã chơi golf 2 byte!

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

Phiên bản thay thế, 62 byte

Điều này nhận đầu vào dưới dạng chuỗi byte, có thể không được phép.

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

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

Haskell, 77 byte

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

Nhập quá nhiều.

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

Ruby , 61 byte

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

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

Sạch , 101 100 94 byte

-6 byte nhờ có Ourous!

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

Hãy thử trực tuyến! Ví dụ sử dụng : s ['3'] [['who'], ['what'], ['when']].

Ung dung:

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

Trên thực tế , 24 byte

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

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

Giải trình:

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

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

$^avà @^blà các đối số khóa và mảng tương ứng cho hàm. @^b.sort(...)chỉ cần sắp xếp mảng đầu vào theo hàm vị ngữ được đưa ra. Hàm đó nhận một đối số duy nhất, do đó sortsẽ lần lượt chuyển từng phần tử và coi giá trị trả về làm khóa cho phần tử đó, sắp xếp danh sách theo các khóa của các phần tử.

Hàm sắp xếp là *.comb Z~^ (|$^a.comb xx *). *là đối số chuỗi đơn cho hàm. *.comblà một danh sách các ký tự riêng lẻ của chuỗi. |$^a.comb xx *là danh sách các ký tự trong khóa sắp xếp xor, được sao chép vô hạn. Hai danh sách này được nén với nhau ( Z) bằng cách sử dụng toán tử chuỗi xor ( ~^). Vì vị từ sắp xếp trả về khóa sắp xếp là danh sách, nên sắp xếp sorthai phần tử bằng cách so sánh các phần tử đầu tiên của danh sách được trả về, sau đó là phần tử thứ hai nếu các phần tử đầu tiên giống nhau, et cetera.

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

Lấy số lượng đối số và con trỏ tới một mảng chuỗi (khóa, theo sau là các chuỗi được sắp xếp) và sửa đổi mảng chuỗi tại chỗ.

Mã này rất không di động và yêu cầu con trỏ 64 bit, gcc và glibc.

Cảm ơn @ceilingcat vì đã chơi golf 2 byte!

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

Python 2,  204 140 134  126 byte

Cảm ơn @Mr. Xcoder để lưu 64 byte, cảm ơn @ovs vì đã lưu sáu byte và cảm ơn @Dennis vì đã lưu tám 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))

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

op86 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            

Mã kiểm tra:

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 dài ở mã hóa ...

Với [0,65536) + 1e4, tất cả có 5 chữ số để có thể so sánh như chuỗi

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

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

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

thử trực tuyến

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

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

Chấp nhận đầu vào dưới dạng key word word ... eg912 abcde hello test honk

Đầu ra sắp xếp không gian từ được phân tách

Hơi dễ đọc hơn

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

Yếu tố, 85

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

Lần thử đầu tiên, tôi sẽ xem liệu tôi có thể đánh gôn thêm vào ngày mai không.

Tôi chấp nhận đề xuất;)

APL Dyalog, 34 byte

Dfn, sử dụng ⎕ml 3

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