XOR ordena una matriz

15

Dada una clave y una serie de cadenas, baraje la matriz para que se ordene cuando cada elemento se XOR con la clave.

XOR'ing dos cuerdas

Para XOR una cadena por una clave, XOR cada uno de los valores de caracteres de la cadena por su par en la clave, suponiendo que la clave se repita para siempre. Por ejemplo, se abcde^123ve así:

       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

Clasificación

La clasificación siempre debe hacerse lexicográficamente de las cadenas XOR'd. Es decir, 1 < A < a < ~(suponiendo la codificación ASCII)

Ejemplo

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

Notas

  • La clave siempre tendrá al menos 1 carácter.
  • La clave y la entrada solo consistirán en ASCII imprimible.
  • Las cadenas XOR'd pueden contener caracteres no imprimibles.
  • La entrada y salida se puede hacer a través de los métodos razonables
  • Las lagunas estándar están prohibidas.
  • Puede tomar Clave y Entrada en cualquier orden.

Casos de prueba

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

Este es el código de golf , ¡por lo que gana menos bytes!

code-golf string array-manipulation sorting bitwise Un taco
fuente
Sin embargo
MD XF
¿Se garantiza que las cuerdas sean diferentes?
Neil
@Neil Aunque no puedo imaginar una situación en la que ser idénticos causaría problemas, puede suponer que todas las cadenas serán únicas.
ATaco
@ATaco Sin duda puede importar si no está utilizando una comparación de cadenas incorporada.
Dennis

Respuestas:

7

Jalea , 9 7 bytes

⁹ṁO^OµÞ

¡Gracias a @EriktheOutgolfer por una sugerencia que ayudó a ahorrar 2 bytes!

Pruébalo en línea!

Cómo funciona

⁹ṁ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.
Dennis
fuente
10

Python 3 , 75 73 bytes

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

Esto ordena la lista x en el lugar.

¡Gracias a @mercator por jugar 2 bytes!

Pruébalo en línea!

Versión alternativa, 62 bytes.

Esto toma la entrada como cadenas de bytes, que pueden no estar permitidas.

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

Pruébalo en línea!

Dennis
fuente
En lugar de clasificación ahorra 2 bytes: x.sort(key=...).
mercator
3

Haskell, 77 bytes

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

Demasiadas importaciones.

Pruébalo en línea!

nimi
fuente
2

Limpio , 101 100 94 bytes

-6 bytes gracias a Ourous!

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

Pruébalo en línea! Ejemplo de uso:s ['3'] [['who'], ['what'], ['when']] .

Sin golf:

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
fuente
? =toInty usar en su ?lugar ahorra 2 bytes, y usar un volteado mayor que en lugar de menor o igual guarda otro.
Οurous
Aún mejor, ahorra 6 bytes: TIO
Οurous
1

En realidad , 24 bytes

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

Pruébalo en línea!

Explicació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)
Mego
fuente
@ATaco No, no lo hace. Pruébelo con ["who", "what", "when"]y"thisisalongkey"
caird coinheringaahing
1
@cairdcoinheringaahing Eso fue publicado antes de un parche para Actually en TIO.
ATaco
1

Perl 6 , 37 bytes

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

Pruébalo en línea!

$^ay @^bson los argumentos clave y de matriz para la función, respectivamente. @^b.sort(...)simplemente ordena la matriz de entrada de acuerdo con la función de predicado que se le asigna. Esa función toma un solo argumento, entoncessort lo que pasará cada elemento por turno y tratará el valor de retorno como una clave para ese elemento, ordenando la lista por las claves de los elementos.

La función de clasificación es *.comb Z~^ (|$^a.comb xx *). *es el argumento de cadena única para la función. *.combes una lista de los caracteres individuales de la cadena. |$^a.comb xx *es una lista de los caracteres en la clave de clasificación xor, replicada infinitamente. Esas dos listas se comprimen juntas ( Z) usando el operador xor en cadena ( ~^). Dado que el predicado de clasificación devuelve una clave de clasificación que es una lista, sortordena dos elementos comparando los primeros elementos de las listas devueltas, luego los segundos elementos si los primeros elementos son iguales, etc.

Sean
fuente
{sort *.comb »~^»$^a.comb,@^b}
Brad Gilbert b2gills
1

C (gcc) , 132 128 126 bytes

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

Toma un recuento de argumentos y un puntero a una matriz de cadenas (la clave, seguida de las cadenas que se ordenarán) y modifica la matriz de cadenas en su lugar.

El código es altamente no portátil y requiere punteros de 64 bits, gcc y glibc.

¡Gracias a @ceilingcat por jugar 2 bytes!

Pruébalo en línea!

Dennis
fuente
1

Python 2,  204 140 134  126 bytes

Gracias a @Mr. Xcoder por guardar 64 bytes, gracias a @ovs por guardar seis bytes, y gracias a @Dennis por guardar ocho bytes.

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

Pruébalo en línea!

Steadybox
fuente
1

código de operación x86, 57 bytes

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

Código de prueba:

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
fuente
1

JavaScript ES 6, 113 97 95 Bytes

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 es largo en charcoding ...

Para [0,65536) + 1e4, todos tienen 5 dígitos, por lo que se pueden comparar como una cadena

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

l4m2
fuente
Threoiy puedo usar en k+=klugar de usar p=k+pdemasiada memoria con el caso de prueba pequeño
l4m2
0

Perl 5, 88 bytes

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

Pruébalo en línea .

Denis Ibaev
fuente
0

Clojure, 80 bytes

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

Perl 5, 80 + 3 ( anl) = 83 , 67 bytes

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

pruébalo en línea

Nahuel Fouilleul
fuente
Esto repite la clave 9 veces, lo que no es suficiente en general. Por ejemplo, la salida será incorrecta para 9; abcdeabcde abcdeabcdz(debería dar abcdeabcdz abcdeabcde)
Lynn
@ Lynn, corregido agregando 3 bytes
Nahuel Fouilleul
podría ahorrar 16 bytes usando subs
Nahuel Fouilleul
0

AWK , 285 284 bytes

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

Pruébalo en línea!

Acepta entradas en forma de, key word word ...p. Ej.912 abcde hello test honk

Salidas palabras ordenadas separadas por espacios

Ligeramente más legible

{
  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
fuente
0

Factor, 85

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

Primero intente, veré si puedo jugar más golf mañana.

Acepto sugerencias;)

fede s.
fuente
0

Dyalog APL, 34 bytes

Dfn, usa ⎕ml 3

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