키와 문자열 배열이 주어지면 각 요소가 키와 XOR 될 때 정렬되도록 배열을 섞습니다.

두 줄 XOR

키를 사용하여 문자열을 XOR하려면 키가 영원히 반복된다고 가정하고 문자열의 각 문자 값을 키의 쌍으로 XOR하십시오. 예를 들면 abcde^123다음과 같습니다.

       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

정렬

정렬은 항상 XOR의 문자열을 사 전적으로 수행해야합니다. 즉, 1 < A < a < ~(ASCII 인코딩 가정)

예

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

노트

• 키는 항상 1 자 이상이어야합니다.
• 키와 입력은 인쇄 가능한 ASCII로만 구성됩니다.
• XOR 문자열에는 인쇄 할 수없는 문자가 포함될 수 있습니다.
• 입력 및 출력은 합리적인 방법을 통해 수행 될 수 있습니다
• 표준 허점 은 금지되어 있습니다.
• 어떤 순서로든 키와 입력을 할 수 있습니다.

테스트 사례

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

이것은 code-golf 이므로 최소 바이트가 이깁니다!

젤리 , 9 7 바이트

⁹ṁO^OµÞ

2 바이트를 절약 할 수있는 제안에 대한 @EriktheOutgolfer에게 감사합니다!

온라인으로 사용해보십시오!

작동 원리

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

파이썬 3 , 75 73 바이트

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

이것은 x 를 그 자리에 정렬합니다 .

2 바이트를 골라 낸 @mercator에게 감사드립니다!

온라인으로 사용해보십시오!

대체 버전, 62 바이트

이것은 입력을 바이트 문자열로 가져 오며 허용되지 않을 수 있습니다.

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

온라인으로 사용해보십시오!

하스켈, 77 바이트

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

수입품이 너무 많습니다.

온라인으로 사용해보십시오!

루비 , 61 바이트

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

온라인으로 사용해보십시오!

면도 , 101 (100) 94 바이트

Ourous 덕분에 -6 바이트!

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

온라인으로 사용해보십시오! 사용법 예 : s ['3'] [['who'], ['what'], ['when']].

언 골프 드 :

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

실제로 24 바이트

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

온라인으로 사용해보십시오!

설명:

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)

펄 6 , 37 바이트

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

온라인으로 사용해보십시오!

$^a그리고 @^b함수에 대한 핵심 및 배열 인수입니다. @^b.sort(...)주어진 술어 함수에 따라 입력 배열을 간단히 정렬합니다. 이 함수는 단일 인수를 취하므로sort 각 요소를 차례로 전달하고 반환 값을 해당 요소의 키로 취급하여 요소의 키별로 목록을 정렬합니다.

정렬 기능은 *.comb Z~^ (|$^a.comb xx *)입니다. *함수에 대한 단일 문자열 인수입니다. *.comb문자열의 개별 문자 목록입니다. |$^a.comb xx *xor 정렬 키의 문자 목록으로 무한 복제됩니다. 이 두 목록은 Z문자열 xor 연산자 ( ~^)를 사용하여 함께 압축됩니다 ( ). 정렬 술어는 목록 인 정렬 키를 리턴하므로 리턴 된 목록 sort의 첫 번째 요소를 비교하여 두 요소를 정렬 한 다음 첫 번째 요소가 동일한 경우 두 번째 요소를 정렬합니다 .

C (GCC) , 132 (128) 126 바이트

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

인수 개수와 문자열 배열에 대한 포인터 (키 다음에 정렬 할 문자열)를 가져 와서 문자열 배열을 수정합니다.

코드는 이식성이 뛰어나며 64 비트 포인터, gcc 및 glibc가 필요합니다.

2 바이트를 골라내는 @ceilingcat에게 감사드립니다!

온라인으로 사용해보십시오!

파이썬 2  204 140 134  126 바이트

@Mr에게 감사합니다. 6 바이트를 저장하는 @ovs와 8 바이트를 저장하는 @Dennis 덕분에 64 바이트를 절약하는 Xcoder!

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

온라인으로 사용해보십시오!

x86 opcode, 57 바이트

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            

테스트 코드 :

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

자바 스크립트 ES 6, 113 97 95 바이트

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는 오랫동안 문자 인코딩에 사용됩니다 ...

[0,65536)의 경우 + 1e4는 모두 5 자리이므로 문자열과 비교할 수 있습니다.

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

펄 5, 88 바이트

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

온라인으로 사용해보십시오 .

클로저, 80 바이트

#(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 바이트

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

온라인으로 사용해보십시오

AWK , 285 284 바이트

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

온라인으로 사용해보십시오!

key word word ...예를 들어 다음 과 같은 형식으로 입력을 받아들입니다.912 abcde hello test honk

정렬 된 단어 공간을 구분하여 출력합니다.

약간 더 읽기

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

계수, 85

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

먼저 내일 골프를 더 할 수 있는지 살펴 보겠습니다.

나는 제안을 받아 들인다;)

Dyalog APL, 34 바이트

Dfn, ⎕ml 3 사용

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