XOR एक सरणी को सॉर्ट करता है

Question

कुंजी को देखते हुए, और तार की एक सरणी, सरणी को फेरबदल करें ताकि यह तब छांटे जब प्रत्येक तत्व कुंजी के साथ XOR'd हो।

XOR'ing दो तार

कुंजी द्वारा स्ट्रिंग को 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'd तार के लेक्सोग्राफिक रूप से की जानी चाहिए। वह है, 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'd तार में गैर-मुद्रण योग्य वर्ण शामिल हो सकते हैं।
• इनपुट और आउटपुट उचित तरीकों के माध्यम से किया जा सकता है
• मानक ढीले निषिद्ध हैं।
• आप किसी भी क्रम में की और इनपुट ले सकते हैं।

परीक्षण के मामलों

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

यह कोड-गोल्फ है , इसलिए कम से कम बाइट्स जीतता है!

Comments

संबंधित कहीं नहीं एक पास हालांकि

— एमडी एक्सएफ

क्या तार अलग होने की गारंटी है?

— नील

@Neil हालांकि मैं ऐसी स्थिति की कल्पना नहीं कर सकता जहाँ उनके समान होने से समस्याएँ पैदा हों, आप यह मान सकते हैं कि सभी तार अद्वितीय होंगे।

— ATaco

यदि आप बिल्ट-इन स्ट्रिंग तुलना का उपयोग नहीं कर रहे हैं तो यह निश्चित रूप से महत्वपूर्ण है।

— डेनिस

Answer 1

जेली , ९ by बाइट्स

⁹ṁO^OµÞ

एक सुझाव के लिए @EriktheOutgolfer का धन्यवाद जिसने 2 बाइट बचाने में मदद की!

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

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

Answer 2

पायथन 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))])

इसे ऑनलाइन आज़माएं!

Comments

में जगह छँटाई 2 बाइट बचाता है x.sort(key=...):।

— मर्केटर

Answer 3

हास्केल, 77 बाइट्स

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

बहुत सारे आयात।

इसे ऑनलाइन आज़माएं!

Answer 4

रूबी , 61 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Answer 5

क्लीन , 101 100 94 बाइट्स

-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']]।

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

Comments

? =toIntऔर ?इसके बजाय का उपयोग करने से 2 बाइट्स की बचत होती है, और कम-या-समान के बजाय फ़्लिप किए गए से अधिक का उपयोग करने से एक और बचत होती है।

— Οआयुष

इससे भी बेहतर, 6 बाइट्स बचाता है: TIO

— 29urous

Answer 6

दरअसल , 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)

Comments

@ATaco नहीं यह नहीं है। इसे आजमाएँ ["who", "what", "when"]और"thisisalongkey"

— caird coinheringaahing

@cairdcoinheringaahing एक पैच से पहले पोस्ट करने के लिए वास्तव में TIO पर था।

— अताको

Answer 7

पर्ल 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) स्ट्रिंगवाइज़ एक्सोर ऑपरेटर ( ~^) का उपयोग करके । चूंकि छंटाई विधेय एक सॉर्ट कुंजी देता है जो एक सूची है, sortदो तत्वों को लौटाए गए सूचियों के पहले तत्वों की तुलना करके आदेश देता है, फिर दूसरा तत्व यदि पहले तत्व समान हैं, तो एट वगैरह।

Comments

{sort *.comb »~^»$^a.comb,@^b}

— ब्रैड गिल्बर्ट b2gills

Answer 8

सी (जीसीसी) , 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 को धन्यवाद!

इसे ऑनलाइन आज़माएं!

Answer 9

पायथन 2,  204 140 134  126 बाइट्स

@Mr को धन्यवाद। 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))

इसे ऑनलाइन आज़माएं!

Answer 10

x86 ओपकोड, 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

Answer 11

जावास्क्रिप्ट ईएस 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))

जावास्क्रिप्ट चारकोडिंग पर लंबा है ...

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

Comments

Threoiy मैं उपयोग कर सकते हैं k+=kके बजाय p=k+pलेकिन बहुत सारे स्मृति छोटे से परीक्षण मामले के साथ का उपयोग कर

— l4m2

Answer 12

पर्ल 5, 88 बाइट्स

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

इसे ऑनलाइन आज़माएं ।

Answer 13

क्लोजर, 80 बाइट्स

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

Answer 14

पर्ल 5, 80 + 3 ( anl) = 83 , 67 बाइट्स

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

इसे ऑनलाइन आज़माएं

Comments

यह कुंजी को 9 बार दोहराता है, जो सामान्य रूप से पर्याप्त नहीं है। उदाहरण के लिए, आउटपुट गलत होगा 9; abcdeabcde abcdeabcdz(देना चाहिए abcdeabcdz abcdeabcde)

— लिन

@ लियन, 3 बाइट्स तय करते हुए

— नहुएल फौइलुल

— सबट

Answer 15

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

Answer 16

कारक, ,५

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

पहले प्रयास करें, मैं देखूंगा कि क्या मैं इसे कल और आगे बढ़ा सकता हूं।

मैं सुझाव स्वीकार करता हूं;)

Answer 17

डायलाग एपीएल, 34 बाइट्स

Dfn, .ml 3 का उपयोग करता है

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