Ispirato (con la spiegazione rubata da) questo

sfondo

Supponi di avere due elenchi A = [a_1, a_2, ..., a_n]e B = [b_1, b_2, ..., b_n]di numeri interi. Diciamo che Aè potenzialmente divisibile per Bse esiste una permutazione Bche rende a_idivisibile b_iper tutti i. Il problema è quindi: è possibile riordinare (cioè permutare) in Bmodo che a_isia divisibile b_iper tutti i? Ad esempio, se hai

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

Poi la risposta sarebbe True, come Beventuale ricambio di essere B = [3, 6, 4]e allora avremmo che a_1 / b_1 = 2, a_2 / b_2 = 2e a_3 / b_3 = 2, che sono tutti numeri interi, quindi Aè potenzialmente-divisibile per B.

Come esempio che dovrebbe essere prodotto False, potremmo avere:

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

Il motivo Falseè che non possiamo riordinare Bdato che sono presenti 25 e 5 A, ma l'unico divisore in Bsarebbe 5, quindi uno verrebbe lasciato fuori.

Il tuo compito

Il tuo compito è, ovviamente, determinare se due liste (fornite come input) sono potenzialmente divisibili. È possibile accettare input in qualsiasi modo accettato, come per l'output.

I duplicati negli elenchi sono una possibilità e le uniche restrizioni di dimensione sugli interi sono la tua lingua. Tutti i numeri interi in entrambi gli elenchi saranno maggiori di 0 ed entrambi gli elenchi avranno le stesse dimensioni.

Come per tutti i problemi di decisione, i valori di output devono essere 2 valori distinti che rappresentano vero e falso.

Questo è un code-golf quindi vince il codice più corto!

Casi 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

Gelatina , 5 byte

Œ!%ḄẠ

Restituisce 0 per True , 1 per False .

Provalo online!

Come funziona

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

Buccia , 7 6 5 byte

Salvato 2 byte grazie a @Zgarb

▼▲‡¦P

Accetta gli argomenti in ordine inverso e restituisce 1per Truee 0per False.

Provalo online!

Spiegazione

    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 byte

Input: accetta le liste B e A (ordine inverso)
Output: 1 se vero, 0 altrimenti

œvIyÖPM

Provalo online!

spiegazioni:

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

1 byte di distanza usando un'idea della risposta Jelly di Dennis

Y@\!aA

Gli input sono B, quindi A. L'output è 0se divisibile o 1no.

Provalo online!

Spiegazione

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 byte

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

grazie @ngenisis per -5 byte

JavaScript (ES6), 67 63 byte

Restituisce un valore booleano.

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

Casi 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 byte

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

Provalo online!

Salvato 1 byte grazie a @nimi

Combinazione R + , 69 66 58 byte

-3 byte grazie a Jarko Dubbeldam

altri -8 byte grazie a Jarko

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

stranamente, R non ha un builtin per generare tutte le permutazioni. Restituisce un valore booleano.

Inoltre, con il secondo miglioramento di Jarko, anycostringe l'elenco a un vettore di logicalcon un avvertimento.

Provalo online! (R-violino)

Mathematica, 42 byte

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

Gelatina , 7 byte

Œ!ọẠ€1e

Provalo online!

Complessità fattoriale nella lunghezza dell'elenco.

Pyth - 11 byte

sm!s%Vdvz.p

Test Suite .

J, 27 byte

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

Provalo online!

Prende il primo elenco come argomento sinistro e il secondo elenco come diritto.

CJam, 20 17 byte

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

Versione di prova

Funzione che accetta l'array B come primo argomento e l'array A come secondo argomento. Si noti che nella versione di prova cambio l'ordine in A e poi in B.

JavaScript (ES6), 100 byte

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 po 'inefficiente; un extra &lo accelererebbe.

PHP, 112 180 178 byte

Stavo pensando troppo breve.

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 funzione anonima prende due array, ritorna NULLper falsità e 1verità.
Genera un errore se il secondo array contiene 0.

Provalo online .

C (gcc) , 191 byte

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

Provalo online!

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

ritorna 1se divisibile, 0altrimenti. Vedi esempio di utilizzo su TIO.

(Devo fare le permutazioni nel modo più duro in C, quindi questo non è affatto competitivo)

Perl 6 , 38 byte

In realtà la risposta di @ nwellnhof sembra essere troppo leggibile, quindi ho deciso di seguire la buona tradizione del codice Perl di sola scrittura :—).

1 byte salvato grazie a @nwellnhof.

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

Provalo online!

Cosa fa: è una funzione anonima che accetta due argomenti dell'elenco. Quando diciamo@^a , intendiamo il primo, quando @^b, è il secondo.

(@^a,)è un elenco contenente l'elenco @^a. @^b.permutationsè l'elenco di tutte le permutazioni di@^b . L'operatore "XZ %%" crea tutte le possibili coppie di quell'elenco a sinistra e tutte le permutazioni a destra e utilizza l'operatore "Z %%" su di esse, che è l'operazione "zip" standard utilizzando l'operatore di divisibilità %%.

L' maxoperatore fornisce l'elemento più grande dell'elenco (in questo caso, è l'elenco che contiene il maggior numero Truedi elementi). Lo riduciamo quindi usando l'operatore AND logico per vedere se tutti gli elementi di quell'elenco "più vero" sono veri, e questo è il risultato. È una copia quasi esatta di ciò che ha scritto @nwellnhof, usando solo operatori oscuri per radere i byte.

Brachylog , 6 byte

pᵐz%ᵛ0

Provalo online!

Il predicato ha esito positivo se le due liste sono potenzialmente divisibili e in caso contrario non lo sono.

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 byte

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

Provalo online!

La tua implementazione di base.

Python 2 , 90 byte

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

Provalo online!

Rubino , 56 byte

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

Provalo online!

Abbastanza semplice, sfrutta il fatto che permutationesiste.

Scala, 60 byte

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 byte

Uscite trueo false.

Vá de@gY vX

Provalo

Spiegazione

Input implicito di array Ue V( Ae B, rispettivamente)

Vá

Genera una matrice di tutte le permutazioni di V.

d

Controlla se uno qualsiasi degli elementi (sotto-array) restituisce true.

e@

Controlla se ogni elemento nell'array secondario corrente restituisce true quando passa attraverso la seguente funzione, Xessendo l'elemento corrente e Yl'indice corrente.

gY

Ottieni l'elemento Uall'indice Y.

vX

Controlla se è divisibile per X.