একটি কী এবং স্ট্রিংগুলির একটি অ্যারে দেওয়া হয়েছে, অ্যারেটি এমনভাবে পরিবর্তন করুন যাতে এটি বাছাই করা হয় যখন প্রতিটি উপাদান কী দিয়ে XOR'd হয়।

দুটি স্ট্রিং XOR'ing

একটি কী দ্বারা একটি স্ট্রিং এক্সওর করতে, কীটি চিরকালের জন্য পুনরাবৃত্তি হবে বলে ধরে নিয়ে তার জোড় দ্বারা স্ট্রিংয়ের প্রতিটি চরিত্রের মানগুলি এক্সওআর করে। উদাহরণস্বরূপ, 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 টি চরিত্রের হবে
কী এবং ইনপুট কেবল প্রিন্টযোগ্য এএসসিআইআই সমন্বিত থাকবে।
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"]

এটি কোড-গল্ফ , তাই কমপক্ষে বাইটস জয়!

— ATaco
সূত্র

যদিও কোনও ডুপের নিকটে সম্পর্কিত কোথাও নেই

— এমডি এক্সএফ

স্ট্রিংগুলি কি আলাদা হওয়ার নিশ্চয়তা রয়েছে?

— নীল

@ নীল যদিও আমি এমন পরিস্থিতিটি কল্পনা করতে পারি না যেখানে সেগুলি অভিন্ন হওয়ার কারণে সমস্যা দেখা দেয়, তবে আপনি ধরে নিতে পারেন যে সমস্ত স্ট্রিং অনন্য হবে।

— এটাকো

@ATaco আপনি যদি অন্তর্নির্মিত স্ট্রিং তুলনা ব্যবহার না করেন তবে অবশ্যই এটি বিবেচনা করতে পারে।

— ডেনিস

7

জেলি , 9 7 বাইট

⁹ṁO^OµÞ

@ এরিকথিউটগলফারকে এমন একটি পরামর্শের জন্য ধন্যবাদ যা 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.

— ডেনিস
সূত্র

10

পাইথন 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 বাইট বন্ধ করে গল্ফ করার জন্য @ জারকেটরকে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

বিকল্প সংস্করণ, 62 বাইট

এটি বাইট স্ট্রিং হিসাবে ইনপুট নেয়, যা অনুমোদিত হতে পারে না।

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

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র

ইন-জায়গা বাছাই 2 বাইট সংরক্ষণ: x.sort(key=...)।

— মার্টারে 19

3

হাস্কেল, 77 বাইট

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

অনেক বেশি আমদানি।

এটি অনলাইন চেষ্টা করুন!

— nimi
সূত্র

2

রুবি , 61 বাইট

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

এটি অনলাইন চেষ্টা করুন!

— Unihedron
সূত্র

2

পরিষ্কার , 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

— Laikoni
সূত্র

? =toIntএবং এর ?পরিবর্তে 2 বাইট সাশ্রয় করে এবং কম-বা সমানের পরিবর্তে ফ্লিপড বৃহত্তর ব্যবহার করে অন্যটি সংরক্ষণ করে।

— 5urous

আরও ভাল, 6 বাইট সংরক্ষণ করে: টিআইও

— ousurous

1

আসলে , 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)

— ঐ মেগো
সূত্র

@ATaco না এটি হয় না। সঙ্গে এটি ব্যবহার করে দেখুন ["who", "what", "when"]এবং"thisisalongkey"

— coinheringaahing caird

1

প্রকৃতপক্ষে টিআইওতে প্যাচ দেওয়ার আগে এটি পোস্ট করা হয়েছিল

— এটাকো

1

পার্ল 6 , 37 বাইট

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

এটি অনলাইন চেষ্টা করুন!

$^aএবং @^bযথাক্রমে ফাংশনটির মূল এবং অ্যারে আর্গুমেন্ট। @^b.sort(...)এটি প্রদত্ত প্রাকটিক্যাল ফাংশন অনুযায়ী ইনপুট অ্যারেটি সাজায়। এই ফাংশনটি একটি একক আর্গুমেন্ট গ্রহণ করে, সুতরাং sortএটি প্রতিটি উপাদানকে ঘুরে দাঁড়ায় এবং রিটার্নের মানটিকে সেই উপাদানটির মূল হিসাবে চিহ্নিত করে উপাদানগুলির কী দ্বারা তালিকাটি বাছাই করে।

বাছাই ফাংশন হয় *.comb Z~^ (|$^a.comb xx *)। *ফাংশনের একক স্ট্রিং আর্গুমেন্ট। *.combস্ট্রিংয়ের স্বতন্ত্র অক্ষরের একটি তালিকা। |$^a.comb xx *জোর সাজানোর কী-এর অক্ষরের একটি তালিকা, অনন্তরূপে প্রতিলিপি করা। এই দুটি তালিকা Zস্ট্রিংওয়াইজ জোর অপারেটর ( ~^) ব্যবহার করে একত্রে জিপ করা হয় । যেহেতু বাছাই করা প্রিকেটটি একটি তালিকা হিসাবে একটি বাছাই কী sortপ্রদান করে, প্রত্যাবর্তিত তালিকার প্রথম উপাদানগুলির সাথে তুলনা করে দুটি উপাদানকে অর্ডার করে, তারপরে দ্বিতীয় উপাদানগুলি যদি প্রথম উপাদানগুলি একই হয় তবে এটি সেটার হয়।

— শন
সূত্র

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

— ব্র্যাড গিলবার্ট

1

সি (জিসিসি) , 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);}

একটি স্ট্রিং অ্যারেতে একটি আর্গুমেন্ট গণনা এবং একটি পয়েন্টার নেয় (কীটি, তারপরে সরানোর জন্য স্ট্রিংগুলি অনুসরণ করে) এবং জায়গায় স্ট্রিং অ্যারে সংশোধন করে।

কোডটি অত্যন্ত নন-পোর্টেবল এবং এর জন্য -৪-বিট পয়েন্টার, জিসিসি এবং গ্লিবসি প্রয়োজন।

2 বাইট বন্ধ করে গল্ফ করার জন্য @ সেলিংক্যাটকে ধন্যবাদ!

এটি অনলাইন চেষ্টা করুন!

— ডেনিস
সূত্র

1

পাইথন 2, 204 140 134 126 বাইট

@ মিঃ কে ধন্যবাদ 64৪ বাইট সংরক্ষণের জন্য এক্সকোডার, ছয় বাইট সংরক্ষণের জন্য @ ওভসকে ধন্যবাদ এবং আটটি বাইট সংরক্ষণের জন্য @ ডেনিসকে ধন্যবাদ!

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

এটি অনলাইন চেষ্টা করুন!

— Steadybox
সূত্র

1

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

— l4m2
সূত্র

1

জাভাস্ক্রিপ্ট ইএস 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"]));

স্নিপেট প্রসারিত করুন

— l4m2
সূত্র

Threoiy আমি ব্যবহার করতে পারেন k+=kপরিবর্তে p=k+pকিন্তু অনেকগুলি মেমরির ছোট পরীক্ষা ক্ষেত্রে এর মাধ্যমে ব্যবহার

— l4m2

0

পার্ল 5, 88 বাইট

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

এটি অনলাইনে চেষ্টা করুন ।

— ডেনিস ইবায়েভ
সূত্র

0

ক্লোজার, 80 বাইট

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

— NikoNyrh
সূত্র

0

পার্ল 5, 80 + 3 ( `anl`) = 83 , 67 বাইট

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

অনলাইনে চেষ্টা করুন

— নাহুয়েল ফৌইলুল
সূত্র

এটি 9 বার কীটি পুনরাবৃত্তি করে যা সাধারণভাবে পর্যাপ্ত নয়। উদাহরণস্বরূপ, আউটপুট এর জন্য ভুল হবে 9; abcdeabcde abcdeabcdz(দেওয়া উচিত abcdeabcdz abcdeabcde)

— লিন

@ লিন, স্থির করে 3 বাইট যুক্ত করুন

— নাহুয়েল ফিউইলুল

সাব ব্যবহার করে 16 বাইট সংরক্ষণ করতে পারে

— নাহুয়েল ফিউইলুল

0

এডাব্লুকে , 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 : ""
    }
  }
}

— Noskcaj
সূত্র

0

ফ্যাক্টর, 85

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

প্রথমে চেষ্টা করুন, আমি আগামীকাল আরও গল্ফ করতে পারি কিনা তা দেখতে পাচ্ছি।

আমি পরামর্শ গ্রহণ করি;)

— ফেডারেশন এস।
সূত্র

0

ডায়ালগ এপিএল, 34 বাইট

ডিফএন, আইএমএল 3 ব্যবহার করে

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

— Lobachevsky
সূত্র

XOR একটি অ্যারে বাছাই করুন

দুটি স্ট্রিং XOR'ing

শ্রেণীবিভাজন

উদাহরণ

মন্তব্য

পরীক্ষার কেস

জেলি , 9 7 বাইট

কিভাবে এটা কাজ করে

পাইথন 3 , 75 73 বাইট

বিকল্প সংস্করণ, 62 বাইট

হাস্কেল, 77 বাইট

রুবি , 61 বাইট

পরিষ্কার , 101 100 94 বাইট

Ungolfed:

আসলে , 24 বাইট

পার্ল 6 , 37 বাইট

সি (জিসিসি) , 132 128 126 বাইট

পাইথন 2, 204 140 134 126 বাইট

x86 অপকোড, 57 বাইট

জাভাস্ক্রিপ্ট ইএস 6, 113 97 95 বাইট

পার্ল 5, 88 বাইট

ক্লোজার, 80 বাইট

পার্ল 5, 80 + 3 ( `anl`) = 83 , 67 বাইট

এডাব্লুকে , 285 284 বাইট

ফ্যাক্টর, 85

ডায়ালগ এপিএল, 34 বাইট

XOR একটি অ্যারে বাছাই করুন

দুটি স্ট্রিং XOR'ing

শ্রেণীবিভাজন

উদাহরণ

মন্তব্য

পরীক্ষার কেস

জেলি , 9 7 বাইট

কিভাবে এটা কাজ করে

পাইথন 3 , 75 73 বাইট

বিকল্প সংস্করণ, 62 বাইট

হাস্কেল, 77 বাইট

রুবি , 61 বাইট

পরিষ্কার , 101 100 94 বাইট

Ungolfed:

আসলে , 24 বাইট

পার্ল 6 , 37 বাইট

সি (জিসিসি) , 132 128 126 বাইট

পাইথন 2, 204 140 134 126 বাইট

x86 অপকোড, 57 বাইট

জাভাস্ক্রিপ্ট ইএস 6, 113 97 95 বাইট

পার্ল 5, 88 বাইট

ক্লোজার, 80 বাইট

পার্ল 5, 80 + 3 ( anl) = 83 , 67 বাইট

এডাব্লুকে , 285 284 বাইট

ফ্যাক্টর, 85

ডায়ালগ এপিএল, 34 বাইট

পার্ল 5, 80 + 3 ( `anl`) = 83 , 67 বাইট