영감 (설명은 도난과) 이

배경

두 개의 목록 A = [a_1, a_2, ..., a_n]과 B = [b_1, b_2, ..., b_n]정수 가 있다고 가정하십시오 . 우리는 말씀 A입니다 잠재적으로 나눌 가 B있는 경우의 순열 B그 수 a_i로 나누어 b_i모두를 위해 i. 문제는 그 다음이다 : 그것은 재정렬 (즉, 변경하다)로 가능하다 B즉 있도록 a_i로 나누어 b_i모두를위한 i? 예를 들어

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

그런 대답이 될 것 True같은 B일을 다시 정렬 할 수 있습니다 B = [3, 6, 4]그리고 우리가있을 것입니다 a_1 / b_1 = 2, a_2 / b_2 = 2그리고 a_3 / b_3 = 2정수 모두, 그래서, A에 의해 잠재적으로 나눌 수있다 B.

출력 해야하는 예로써 False다음을 가질 수 있습니다.

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

이것은 25와 5가 in 이므로 False재정렬 할 수 없기 때문에 유일한 제수는 5이므로 하나는 제외됩니다.BAB

당신의 작업

분명히 당신의 임무는 두 개의 목록 (입력으로 주어진)이 잠재적으로 나눌 수 있는지를 결정하는 것입니다. 출력과 마찬가지로 허용되는 방식으로 입력 할 수 있습니다.

목록에 중복이있을 가능성이 있으며 정수에 대한 유일한 크기 제한은 사용자의 언어입니다. 두 목록의 모든 정수는 0보다 크고 두 목록의 크기는 동일합니다.

모든 의사 결정 문제 와 마찬가지로 출력 값은 true와 false를 나타내는 2 개의 고유 한 값이어야합니다.

이것은 코드 골프 이므로 가장 짧은 코드가 승리합니다!

테스트 사례

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

젤리 , 5 바이트

Œ!%ḄẠ

반환 0 에 대한 사실 , 1 에 대한 거짓 .

온라인으로 사용해보십시오!

작동 원리

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

껍질 , 7 6 5 바이트

@Zgarb 덕분에 2 바이트 절약

▼▲‡¦P

역순으로 argents 되돌아 간다 1위해 True및 0위해 False.

온라인으로 사용해보십시오!

설명

    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 바이트

입력 : 목록 B와 A를 가져옵니다 (역순).
출력 : true이면 1, 그렇지 않으면 0

œvIyÖPM

온라인으로 사용해보십시오!

설명 :

œ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 바이트

Dennis 'Jelly의 아이디어를 사용하여 1 바이트 오프

Y@\!aA

입력은 B다음 A. 출력은 0나눌 수 있거나 1그렇지 않은 경우입니다.

온라인으로 사용해보십시오!

설명

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

매스 매 티카, 52 바이트

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

-5 바이트에 대한 @ngenisis 감사합니다

자바 스크립트 (ES6), 67 63 바이트

부울을 반환합니다.

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

테스트 사례

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

하스켈 , 79 74 68 62 61 바이트

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

온라인으로 사용해보십시오!

@nimi 덕분에 1 바이트 절약

R + 조합 , 69 66 58 바이트

Jarko Dubbeldam 덕분에 -3 바이트

Jarko 덕분에 또 다른 -8 바이트

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

이상하게도 R에는 모든 순열을 생성하기위한 기본 제공 기능이 없습니다. 부울을 반환합니다.

또한 Jarko의 두 번째 개선으로 any목록을 logical경고와 함께 벡터로 강제 변환합니다 .

온라인으로 사용해보십시오! (r- 바이들)

수학, 42 바이트

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

젤리 , 7 바이트

Œ!ọẠ€1e

온라인으로 사용해보십시오!

목록 길이의 요인 복잡성.

Pyth-11 바이트

sm!s%Vdvz.p

테스트 스위트 .

J, 27 바이트

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

온라인으로 사용해보십시오!

첫 번째 목록을 왼쪽 인수로 사용하고 두 번째 목록을 오른쪽으로 사용합니다.

CJam, 20 17 바이트

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

테스트 버전

Function that takes array B as the first argument and array A as the second argument. Note that in the test version I switch the order to A then 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))))

Somewhat inefficient; an extra & would speed it up.

PHP, 112 180 178 bytes

I was thinking too short.

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

anonymous function takes two arrays, returns NULL for falsy and 1 for truthy.
Throws an error if second array contains 0.

Try it online.

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

Try it online!

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

returns 1 if divisable, 0 otherwise. See example usage on TIO.

(Gotta do permutations the hard way in C, so this is hardly competitive)

Perl 6, 38 bytes

Actually @nwellnhof's answer seems to be too much readable, so I set out to follow the fine Perl tradition of write-only code :—).

1 byte saved thanks to @nwellnhof.

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

Try it online!

What does it do: It's an anonymous function that takes two list arguments. When we say @^a, we mean the first one, when @^b, it's the second one.

(@^a,) is a list containing the list @^a. @^b.permutations is the list of all the permutations of @^b. The "XZ%%" operator makes all possible pairs of that one list on the left and all the permutations on the right, and uses the operator "Z%%" on them, which is the standard "zip" operation using the divisibility operator %%.

The max operator gives the largest element of the list (in this case, it's the list that has the most True's in it). We then reduce it using the logical AND operator to see if all elements of that "most true" list are true, and that's the result. It's nearly exact copy of what @nwellnhof wrote, just using obscure operators to shave off bytes.

Brachylog, 6 bytes

pᵐz%ᵛ0

Try it online!

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.