Inspiré (avec l'explication volée) de cette

Contexte

Disons que vous avez deux listes A = [a_1, a_2, ..., a_n]et B = [b_1, b_2, ..., b_n]des nombres entiers. Nous disons Aest potentiellement divisible par Bs'il y a une permutation Bqui rend a_idivisible par b_ipour tous i. Le problème est alors: est-il possible de réorganiser (c'est-à-dire permuter) de Bsorte que cela a_isoit divisible par b_ipour tous i? Par exemple, si vous avez

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

Alors la réponse serait True, comme Bpeut être réorganisés pour être B = [3, 6, 4]et nous aurions que a_1 / b_1 = 2, a_2 / b_2 = 2et a_3 / b_3 = 2, qui sont tous des entiers, donc Aest potentiellement divisible par B.

À titre d'exemple qui devrait sortir False, nous pourrions avoir:

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

La raison en Falseest que nous ne pouvons pas réorganiser Bcar 25 et 5 sont entrés A, mais le seul diviseur en Bserait 5, donc un serait omis.

Ta tâche

Votre tâche consiste évidemment à déterminer si deux listes (données en entrée) sont potentiellement divisibles. Vous pouvez accepter les entrées de n'importe quelle manière acceptée, comme pour les sorties.

Les doublons dans les listes sont une possibilité, et les seules restrictions de taille sur les entiers sont votre langue. Tous les entiers des deux listes seront supérieurs à 0 et les deux listes seront de taille égale.

Comme pour tous les problèmes de décision, les valeurs de sortie doivent être 2 valeurs distinctes qui représentent vrai et faux.

C'est un code-golf donc le code le plus court gagne!

Cas de test

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

Gelée , 5 octets

Œ!%ḄẠ

Renvoie 0 pour Vrai , 1 pour Faux .

Essayez-le en ligne!

Comment ça fonctionne

Œ!%ḄẠ  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.

Husk , 7 6 5 octets

Sauvegardé 2 octets grâce à @Zgarb

▼▲‡¦P

Prend les arguments dans l'ordre inverse et retourne 1pour Trueet 0pour False.

Essayez-le en ligne!

Explication

    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 octets

Entrée: prend les listes B et A (ordre inversé)
Sortie: 1 si vrai, 0 sinon

œvIyÖPM

Essayez-le en ligne!

Explications:

œ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 octets

1 octet de moins en utilisant une idée de la réponse de Dennis 'Jelly

Y@\!aA

Les entrées sont Bdonc A. La sortie est 0divisible ou 1non.

Essayez-le en ligne!

Explication

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 octets

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

merci @ngenisis pour -5 octets

JavaScript (ES6), 67 63 octets

Renvoie un booléen.

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

Cas de test

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 octets

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

Essayez-le en ligne!

1 octet enregistré grâce à @nimi

Combinaison R + , 69 66 58 octets

-3 octets grâce à Jarko Dubbeldam

encore -8 octets grâce à Jarko

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

bizarrement, R n'a pas de fonction intégrée pour générer toutes les permutations. Renvoie un booléen.

De plus, avec la deuxième amélioration de Jarko, anycontraint la liste à un vecteur logicalavec un avertissement.

Essayez-le en ligne! (r-violon)

Mathematica, 42 octets

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

Gelée , 7 octets

Œ!ọẠ€1e

Essayez-le en ligne!

Complexité factorielle dans la longueur de la liste.

Pyth - 11 octets

sm!s%Vdvz.p

Suite de tests .

J, 27 octets

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

Essayez-le en ligne!

Prend la première liste comme argument de gauche et la deuxième liste comme argument de droite.

CJam, 20 17 octets

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

Version de test

Fonction qui prend le tableau B comme premier argument et le tableau A comme deuxième argument. Notez que dans la version test, je passe la commande à A puis B.

JavaScript (ES6), 100 octets

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

Un peu inefficace; un supplément &l'accélérerait.

PHP, 112 180 178 octets

Je pensais trop court.

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 fonction anonyme prend deux tableaux, renvoie NULLpour la fausse et 1pour la vérité.
Lance une erreur si le second tableau contient 0.

Essayez-le en ligne .

C (gcc) , 191 octets

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

Essayez-le en ligne!

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

renvoie 1si divisable, 0sinon. Voir l'exemple d'utilisation sur TIO.

(Je dois faire des permutations à la dure en C, donc ce n'est guère compétitif)

Perl 6 , 38 octets

En fait, la réponse de @ nwellnhof semble trop lisible, alors j'ai décidé de suivre la belle tradition Perl du code en écriture seule :—).

1 octet enregistré grâce à @nwellnhof.

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

Essayez-le en ligne!

Qu'est-ce que cela fait: c'est une fonction anonyme qui prend deux arguments de liste. Quand nous disons @^a, nous voulons dire le premier, quand @^b, c'est le second.

(@^a,)est une liste contenant la liste @^a. @^b.permutationsest la liste de toutes les permutations de @^b. L'opérateur "XZ %%" crée toutes les paires possibles de cette liste à gauche et toutes les permutations à droite, et utilise l'opérateur "Z %%" sur elles, qui est l'opération "zip" standard utilisant l'opérateur de divisibilité %%.

L' maxopérateur donne le plus grand élément de la liste (dans ce cas, c'est la liste qui contient le plus True). Nous la réduisons ensuite à l'aide de l'opérateur logique AND pour voir si tous les éléments de cette liste "la plus vraie" sont vrais, et c'est le résultat. C'est une copie presque exacte de ce que @nwellnhof a écrit, en utilisant simplement des opérateurs obscurs pour raser les octets.

Brachylog , 6 octets

pᵐz%ᵛ0

Essayez-le en ligne!

Le prédicat réussit si les deux listes sont potentiellement divisibles et échoue dans le cas contraire.

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 octets

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

Essayez-le en ligne!

Votre implémentation de base.

Python 2 , 90 octets

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

Essayez-le en ligne!

Rubis , 56 octets

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

Essayez-le en ligne!

Assez simple, exploite le fait qui permutationexiste.

Scala, 60 octets

Golfé:

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

Non golfé:

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 octets

Sorties trueou false.

Vá de@gY vX

Essaye-le

Explication

Saisie implicite des tableaux U& V( A& B, respectivement)

Vá

Générez un tableau de toutes les permutations de V.

d

Vérifiez si l'un des éléments (sous-tableaux) renvoie true.

e@

Vérifiez si chaque élément du sous-tableau actuel retourne vrai lorsqu'il est passé par la fonction suivante, Xétant l'élément courant et Yl'index courant.

gY

Obtenez l'élément dans l' Uindex Y.

vX

Vérifiez si elle est divisible par X.