Inspirado (con la explicación robada) esto

Antecedentes

Digamos que tiene dos listas A = [a_1, a_2, ..., a_n]y B = [b_1, b_2, ..., b_n]de enteros. Decimos que Aes potencialmente divisible por Bsi hay una permutación de Beso que hace a_idivisible por b_ipara todos i. El problema es entonces: ¿es posible reordenar (es decir, permutar) de Bmodo que a_isea ​​divisible por b_ipara todos i? Por ejemplo, si tienes

A = [6, 12, 8]
B = [3, 4, 6]

A continuación, la respuesta sería True, como Bpueden ser reordenados B = [3, 6, 4]y entonces tendríamos que a_1 / b_1 = 2, a_2 / b_2 = 2y a_3 / b_3 = 2, todos los cuales son números enteros, por lo que Aes potencialmente divisible por B.

Como un ejemplo que debería generar False, podríamos tener:

A = [10, 12, 6, 5, 21, 25]
B = [2, 7, 5, 3, 12, 3]

La razón Falsees que no podemos reordenar Bya que 25 y 5 están dentro A, pero el único divisor en Bsería 5, por lo que uno quedaría fuera.

Tu tarea

Obviamente, su tarea es determinar si dos listas (dadas como entrada) son potencialmente divisibles. Puede tomar la entrada de cualquier manera aceptada, como con la salida.

Los duplicados en las listas son una posibilidad, y las únicas restricciones de tamaño en los enteros son su idioma. Todos los enteros en ambas listas serán mayores que 0, y ambas listas serán del mismo tamaño.

Como con todos los problemas de decisión, los valores de salida deben ser 2 valores distintos que representen verdadero y falso.

Este es un código de golf, ¡el código más corto gana!

Casos de prueba

Input, input => output

[6, 12, 8], [3, 4, 6] => True
[10, 5, 7], [1, 5, 100] => False
[14, 10053, 6, 9] [1,1,1,1] => True
[12] [7] => False
[0, 6, 19, 1, 3] [2, 3, 4, 5, 6] => undefined

Jalea , 5 bytes

Œ!%ḄẠ

Devuelve 0 para Verdadero , 1 para Falso .

Pruébalo en línea!

Cómo funciona

Œ!%ḄẠ  Main link. Arguments: A, B (arrays)

Œ!     Generate all permutations of A.
  %    Take each permutation modulo B (element-wise).
   Ḅ   Convert all resulting arrays from binary to integer.
       This yields 0 iff the permutation is divisible by B.
    Ạ  All; yield 0 if the result contains a 0, 1 otherwise.

Casco , 7 6 5 bytes

Guardado 2 bytes gracias a @Zgarb

▼▲‡¦P

Toma los argumentos en orden inverso y devuelve 1por Truey 0para False.

Pruébalo en línea!

Explicación

    P     -- Permutations of the first argument
  ‡       -- Deep zip (vectorises function) with second argument
   ¦      --   Does x divide y
 ▲        -- Get the maximum of that list, returns [1,1...1] if present
▼         -- Get the minimum of that list, will return 0 unless the list is all 1s

05AB1E , 7 bytes

Entrada: toma las listas B y A (orden inverso)
Salida: 1 cuando es verdadero, 0 de lo contrario

œvIyÖPM

Pruébalo en línea!

Explicaciones:

œvIyÖPM    Complete program
œ          Pushes all permutations of B as a list
 v         For each permutation
  I        Pushes last input on top of the stack
   yÖ      Computes a % b == 0 for each element of A and B
     P     Pushes the total product of the list
      M    Pushes the largest number on top of the stack

MATL , 8 7 6 bytes

1 byte apagado usando una idea de la respuesta de Dennis 'Jelly

Y@\!aA

Las entradas son B, entonces A. La salida es 0si es divisible o 1si no.

Pruébalo en línea!

Explicación

Y@     % Implicit input: row vector B. Matrix of all permutations, each on a row
\      % Implicit input: row vector A. Modulo, element-wise with broadcast. Gives
       % a matrix in which each row contains the moduli of each permutation of B
       % with respect to A
!a     % True for rows that contain at least a nonzero value
A      % True if all values are true. Implicit display

Mathematica, 52 bytes

Cases[Permutations@#2,p_/;And@@IntegerQ/@(#/p)]!={}& 

gracias @ngenisis por -5 bytes

JavaScript (ES6), 67 63 bytes

Devuelve un booleano.

f=([x,...a],b)=>!x||b.some((y,i)=>x%y?0:f(a,c=[...b],c[i]=1/0))

Casos de prueba

f=([x,...a],b)=>!x||b.some((y,i)=>x%y?0:f(a,c=[...b],c[i]=1/0))

console.log(f([6, 12, 8],[3, 4, 6]))        // true
console.log(f([10, 5, 7],[1, 5, 100]))      // false
console.log(f([14, 10053, 6, 9],[1,1,1,1])) // true
console.log(f([12],[7]))                    // false

Haskell , 79 74 68 62 61 bytes

import Data.List
f a=any((<1).sum.zipWith rem a).permutations

Pruébalo en línea!

Guardado 1 byte gracias a @nimi

R + combinat , 69 66 58 bytes

-3 bytes gracias a Jarko Dubbeldam

otro -8 bytes gracias a Jarko

function(a,b)any(combinat::permn(b,function(x)all(!a%%x)))

Curiosamente, R no tiene un generador incorporado para generar todas las permutaciones. Devuelve un booleano.

Además, con la segunda mejora de Jarko, anyobliga la lista a un vector delogical con una advertencia.

Pruébalo en línea! (violín r)

Mathematica, 42 bytes

MemberQ[Permutations@#2,a_/;And@@(a∣#)]&

Jalea , 7 bytes

Œ!ọẠ€1e

Pruébalo en línea!

Complejidad factorial en la longitud de la lista.

Pyth - 11 bytes

sm!s%Vdvz.p

Test Suite .

J, 27 bytes

0=[:*/(A.~i.@!@#)@]+/@:|"1[

Pruébalo en línea!

Toma la primera lista como el argumento izquierdo y la segunda lista como el derecho.

CJam, 20 17 bytes

:A;e!{A\.%:+!}#W>

Versión de prueba

Función que toma la matriz B como primer argumento y la matriz A como segundo argumento. Tenga en cuenta que en la versión de prueba cambio el orden a A y luego a B.

JavaScript (ES6), 100 bytes

f=(a,b)=>!a[0]||a.some((c,i)=>b.some((d,j)=>c%d<1&f(e=[...a],d=[...b],e.splice(i,1),d.splice(j,1))))

Algo ineficiente; un extra &lo aceleraría.

PHP, 112 180 178 bytes

Estaba pensando demasiado corto.

function($a,$b){for($p=array_keys($b);++$i<count($b);){foreach($b as$k=>$x)$f|=$a[$k]%$x;if($f=!$f)return 1;$p[$i]?[$b[$j],$b[$i],$i]=[$b[$i],$b[$j=$i%2*--$p[$i]],0]:$p[$i]=$i;}}

La función anónima toma dos matrices, devuelve NULLfalso y 1verdadero.
Lanza un error si la segunda matriz contiene 0.

Pruébalo en línea .

C (gcc) , 191 bytes

#define F(v)for(i=0;i<v;++i){
#define X if(f(s,n,a,b))return 1
j;f(s,n,a,b,i)int*a,*b;{if(--n){F(n)X;j=i*(n%2);b[j]^=b[n];b[n]^=b[j];b[j]^=b[n];}X;}else{F(s)if(a[i]%b[i])return 0;}return 1;}}

Pruébalo en línea!

Uso: f(int size, int size, int *a, int *b)

devuelve 1si es divisible, de lo 0contrario. Ver ejemplo de uso en TIO.

(Tengo que hacer permutaciones de la manera difícil en C, por lo que esto no es competitivo)

Perl 6 , 38 bytes

En realidad, la respuesta de @ nwellnhof parece ser demasiado legible, así que me propuse seguir la excelente tradición de Perl de código de solo escritura :—).

1 byte guardado gracias a @nwellnhof.

{min max (@^a,) XZ%% @^b.permutations}

Pruébalo en línea!

Qué hace: es una función anónima que toma dos argumentos de lista. Cuando decimos @^a, nos referimos al primero, cuando @^b, es el segundo.

(@^a,)es una lista que contiene la lista @^a. @^b.permutationses la lista de todas las permutaciones de @^b. El operador "XZ %%" hace todos los pares posibles de esa lista a la izquierda y todas las permutaciones a la derecha, y usa el operador "Z %%" en ellos, que es la operación estándar "zip" usando el operador de divisibilidad %%.

El maxoperador proporciona el elemento más grande de la lista (en este caso, es la lista que tiene más True's'). Luego lo reducimos usando el operador lógico AND para ver si todos los elementos de esa lista "más verdadera" son verdaderos, y ese es el resultado. Es una copia casi exacta de lo que escribió @nwellnhof, simplemente usando operadores oscuros para recortar bytes.

Brachylog , 6 bytes

pᵐz%ᵛ0

Pruébalo en línea!

The predicate succeeds if the two lists are potentially divisible and fails if they are not.

pᵐ        For some pair of permutations of the two input lists,
  z       for each pair of corresponding elements
   %ᵛ0    the first mod the second is always zero.

Python 2, 92 bytes

lambda a,b:any(all(x%y<1for x,y in zip(a,p))for p in permutations(b))
from itertools import*

Try it online!

Yer basic implementation.

Python 2, 90 bytes

lambda a,b:any(sum(map(int.__mod__,a,p))<1for p in permutations(b))
from itertools import*

Try it online!

Ruby, 56 bytes

->x,y{x.permutation.any?{|p|p.zip(y).all?{|a,b|a%b==0}}}

Try it online!

Fairly straightforward, exploits the fact that permutation exists.

Scala, 60 Bytes

Golfed:

a=>b=>b.permutations exists(a zip _ forall(p=>p._1%p._2==0))

Ungolfed:

a=>b=>         // Function literal taking 2 lists of integers, a and b.
b.permutations // All permutations of b.
exists(        // Whether the given function is true for any element.
a zip _        // Zips a and the current permutation of b into a list of pairs.
forall(        // Whether the given function is true for all elements.
p=>            // Function literal taking a pair of integers.
p._1%p._2==0)) // If the remainder of integer division between the members of the pair is 0.

Japt, 12 11 bytes

Outputs true or false.

Vá de@gY vX

Test it

Explanation

Implicit input of arrays U & V (A & B, respectively)

Vá

Generate an array of all permutations of V.

d

Check if any of the elements (sub-arrays) return true.

e@

Check if every element in the current sub-array returns true when passed through the following function, with X being the current element and Y the current index.

gY

Get the element in U at index Y.

vX

Check if it's divisible by X.