Bir anahtar ve bir dize dizisi verildiğinde, diziyi her öğe anahtarla XOR'd olduğunda sıralanacak şekilde karıştırın.

XOR'ing iki dize

Bir dizeyi anahtarla XOR yapmak için, dizenin karakter değerlerinin her birini, anahtarın sonsuza kadar yinelendiği varsayılarak, anahtardaki çiftiyle XOR yapın. Örneğin, abcde^123şuna benzer:

       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ınıflandırma

Sıralama her zaman XOR'd dizelerinin sözlükbilimsel olarak yapılmalıdır. Yani, 1 < A < a < ~(ASCII kodlaması varsayarsak)

Misal

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

notlar

• Anahtar her zaman en az 1 karakter olacaktır
• Anahtar ve Giriş yalnızca yazdırılabilir ASCII'den oluşur.
• XOR'd dizeleri yazdırılamayan karakterler içerebilir.
• Girdi ve Çıktı Makul Yöntemlerle yapılabilir
• Standart Loopholes yasaktır.
• Anahtar ve Girdileri istediğiniz sırayla alabilirsiniz.

Test Durumları

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

Bu kod golf , bu yüzden en az bayt kazanır!

Jöle , 9 7 bayt

⁹ṁO^OµÞ

2 bayt tasarruf edilmesine yardımcı olan bir öneri için @EriktheOutgolfer'a teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Bu, x listesini yerinde sıralar .

@Mercator 2 bayt golf için teşekkürler!

Çevrimiçi deneyin!

Alternatif sürüm, 62 bayt

Bu, girdiye izin verilmeyen bayt dizeleri olarak alır.

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

Çevrimiçi deneyin!

Haskell, 77 bayt

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

Çok fazla ithalat.

Çevrimiçi deneyin!

Ruby , 61 bayt

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

Çevrimiçi deneyin!

Temiz , 101 100 94 bayt

Ourous sayesinde -6 bayt!

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

Çevrimiçi deneyin! Örnek kullanımı: 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

Aslında 24 bayt

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

Çevrimiçi deneyin!

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

$^ave @^bsırasıyla işleve ait anahtar ve dizi bağımsız değişkenleridir. @^b.sort(...)giriş dizisini, verilen yüklem işlevine göre sıralar. Bu işlev tek bir argüman alır,sort her öğeyi sırayla iletir ve dönüş değerini bu öğenin anahtarı olarak ele alır ve listeyi öğelerin tuşlarına göre sıralar.

Sıralama işlevi *.comb Z~^ (|$^a.comb xx *). *işlevin tek dize bağımsız değişkenidir. *.combdizenin tek tek karakterlerinin listesidir. |$^a.comb xx *xor sıralama tuşundaki sonsuz şekilde yinelenen karakterlerin bir listesidir. Bu iki liste Z, stringwise xor operatörü ( ~^) kullanılarak birlikte sıkıştırılır ( ). Sıralama yüklemi bir liste olan bir sıralama anahtarı sortdöndürdüğünden, döndürülen listelerin ilk öğelerini, ardından ilk öğeler aynı ise ikinci öğeleri karşılaştırarak iki öğe sipariş eder.

C (GCC) , 132 128 126 bayt

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

Bir dize dizisine (anahtar, ardından sıralanacak dizeler) bir bağımsız değişken sayısı ve bir işaretçi alır ve dize dizisini yerinde değiştirir.

Kod oldukça taşınabilir değildir ve 64 bit işaretçiler, gcc ve glibc gerektirir.

2 bayt golf için @ ceilingcat teşekkürler!

Çevrimiçi deneyin!

Python 2,  204140136126  bayt

@Mr. 64 bayt tasarrufu için Xcoder, altı bayt tasarrufu için @ov ve sekiz bayt tasarrufu için @Dennis sayesinde!

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

Çevrimiçi deneyin!

x86 opcode, 57 Bayt

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            

Test kodu:

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 Bayt

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 kodlama konusunda uzundur ...

[0,65536) + 1e4 için tümü 5 basamaklı olduğundan dize gibi karşılaştırılabilir

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 bayt

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

Çevrimiçi deneyin .

Clojure, 80 bayt

#(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 bayt

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

çevrimiçi dene

AWK , 285 284 bayt

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

Çevrimiçi deneyin!

Şeklinde girişlerini kabul key word word ...örneğin912 abcde hello test honk

Çıktılar ayrılmış kelimeler boşlukla ayrılmış

Biraz daha okunabilir

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

Faktör, 85

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

İlk olarak yarın daha fazla golf oynayabileceğimi göreceğim.

Önerileri kabul ediyorum;)

Dyalog APL, 34 bayt

Dfn, 3ml 3 kullanır

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