क्या सूचियाँ विभाज्य हैं?

20

प्रेरित होकर (विवरण से चोरी के साथ) इस

पृष्ठभूमि

मान लें कि आपके पास दो सूचियाँ A = [a_1, a_2, ..., a_n]और B = [b_1, b_2, ..., b_n]पूर्णांक हैं। हम कहते हैं Aकि संभावित रूप से विभाज्य है Bअगर वहाँ एक क्रमपरिवर्तन है Bजो सभी के लिए a_iविभाज्य बनाता है । तब समस्या यह है: क्या यह संभव है कि पुन: व्यवस्थित किया जाए (अर्थात परमिट) ताकि सभी के लिए विभाज्य हो ? उदाहरण के लिए, यदि आपके पास हैb_iiBa_ib_ii

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]

इसका कारण यह है Falseकि हम B25 और 5 के रूप में पुन: क्रमबद्ध नहीं कर सकते हैं A, लेकिन 5 में एकमात्र विभाजक Bहोगा, इसलिए एक को छोड़ दिया जाएगा।

आपका कार्य

आपका कार्य, जाहिर है, यह निर्धारित करने के लिए है कि दो सूचियां (इनपुट के रूप में दी गई हैं) संभावित रूप से विभाज्य हैं। आप आउटपुट के साथ किसी भी स्वीकृत तरीके से इनपुट ले सकते हैं।

सूचियों में डुप्लिकेट एक संभावना है, और पूर्णांक पर एकमात्र आकार प्रतिबंध आपकी भाषा है। दोनों सूचियों में सभी पूर्णांक 0 से बड़े होंगे, और दोनों सूचियाँ समान आकार की होंगी।

जैसा कि सभी निर्णय-समस्या के साथ आउटपुट मानों में 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
code-golf  math  array-manipulation  decision-problem 
— केर्ड सिक्काहिरिंग
स्रोत
3
@ सवाल से बचना: दोनों सूचियाँ समान आकार की
— होंगी
2
अंतिम परीक्षण मामला अपरिभाषित क्यों है?
— डेनिस
1
सूची में से एक
— डेनिस
1
सही। (निश्चित नहीं कि क्यों, 0 सभी पूर्णांकों द्वारा विभाज्य है।) क्या दो आउटपुट को सत्य और मिथ्या होना है, या केवल सुसंगत है?
— डेनिस
@ डेनिस 1) यह मामले में 0 है दूसरी सूची में, 0 विभाजन त्रुटियों से बचने के लिए 2) बस सुसंगत
— caird coinheringaahing

जवाबों:

10

जेली , 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.
— डेनिस
स्रोत
9

भूसी , 7 6 5 बाइट्स

@ बगर के लिए 2 बाइट्स धन्यवाद सहेजा गया

▼▲‡¦P

रिवर्स ऑर्डर में तर्क देता 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
— H.PWiz
स्रोत
VΠMz¦P6 बाइट्स के लिए काम करना चाहिए।
— ज़गारब
क्या उन लोगों को "दो अलग मूल्य" माना जाता है?
— geokavel
ओह, और Mzहो सकता है ‡।
— ज़र्गब
मुझे लगता है कि आपको ▼▲इसके बजाय की आवश्यकता है ▲▼। किसी भी मामले में अच्छा विचार!
— ज़गर्ब
5

05AB1E , 7 बाइट्स

इनपुट: सूची बी और ए (उलट क्रम)
आउटपुट लेता है : 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
— scottinet
स्रोत
5

MATL , 8 7 6 बाइट्स

डेनिस जैली जवाब से एक विचार का उपयोग कर 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
— लुइस मेंडो
स्रोत
3

गणितज्ञ, 52 बाइट्स

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

-5 बाइट्स के लिए धन्यवाद @ngenisis

— J42161217
स्रोत
2
Casesआम तौर पर कम होता है:Cases[Permutations@#2,p_/;And@@IntegerQ/@(#/p)]!={}&
— ngenisis
3

जावास्क्रिप्ट (ईएस 6), 67 63 बाइट्स

एक बूलियन देता है।

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
3

आर + कॉम्बिनैट , 69 66 58 बाइट्स

-3 बाइट्स जर्को डबेलडैम के लिए धन्यवाद

एक और -8 बाइट्स जर्को के लिए धन्यवाद

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

विचित्र रूप से, आर में सभी क्रमपरिवर्तन उत्पन्न करने के लिए एक बिलिन नहीं है। एक बूलियन देता है।

इसके अतिरिक्त, जारको के दूसरे सुधार के साथ, anyसूची को logicalचेतावनी के साथ सदिश में ले जाता है।

इसे ऑनलाइन आज़माएं! (आर-बेला)

— ग्यूसेप
स्रोत
1
सभी (x <1) किसी भी (x) से अधिक लंबा है और आपको किसी भी राशि के साथ योग करने में सक्षम होना चाहिए
— JAD
@JarkoDubbeldam अच्छी कॉल। धन्यवाद।
— Giuseppe
ओह, और आप अनलिमिटेड छोड़ सकते हैं, निहित जबरदस्ती के लिए याय।
— JAD
@JarkoDubbeldam उत्कृष्ट।
— Giuseppe
1

CJam, 20 17 बाइट्स

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

परीक्षण संस्करण

फ़ंक्शन जो पहले तर्क के रूप में सरणी बी और दूसरे तर्क के रूप में सरणी ए लेता है। ध्यान दें कि परीक्षण संस्करण में मैं ऑर्डर को फिर ए बी पर स्विच करता हूं।

— geokavel
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 100 बाइट्स

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

कुछ हद तक अक्षम; एक अतिरिक्त &इसे गति देगा।

— नील
स्रोत
1

PHP, 112 180 178 बाइट्स

मैं बहुत छोटा सोच रहा था।

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

अनाम फ़ंक्शन दो सरणियाँ लेता है, NULLमिथ्या के लिए रिटर्न और सत्य के 1लिए।
यदि दूसरी सरणी में कोई त्रुटि है तो फेंकता है 0।

इसे ऑनलाइन आज़माएं ।

— टाइटस
स्रोत
के लिए गलत परिणाम प्रिंट करता है $f([6,5],[3,5])।
— nwellnhof
@nwellnhof तय की। ध्यान देने के लिए धन्यवाद।
— टाइटस
1

सी (जीसीसी) , 191 बाइट्स

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

इसे ऑनलाइन आज़माएं!

उपयोग: f(int size, int size, int *a, int *b)

1यदि विभाजन योग्य हो, तो वापस लौटाएं 0। TIO पर उदाहरण का उपयोग देखें।

(सी में कठिन तरीका है, इसलिए यह शायद ही प्रतियोगी है क्रमचय करना)

— फेलिक्स पालमेन
स्रोत
1

पर्ल 6 , 38 बाइट्स

वास्तव में @ nwellnhof का उत्तर बहुत अधिक पठनीय लगता है, इसलिए मैंने राइट-कोड की ठीक पर्ल परंपरा का पालन करने के लिए निर्धारित किया:

1 बाइट @nwellnhof की बदौलत बचा।

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

इसे ऑनलाइन आज़माएं!

यह क्या करता है: यह एक अनाम फ़ंक्शन है जो दो सूची तर्क लेता है। जब हम कहते हैं @^a, हमारा मतलब पहले वाला है, जब @^b, यह दूसरा है।

(@^a,)एक सूची है जिसमें सूची है @^a। @^b.permutationsके सभी क्रमपरिवर्तन की सूची है @^b। "XZ %%" ऑपरेटर बाईं ओर सभी सूची के सभी संभावित जोड़े बनाता है और दाईं ओर सभी क्रमपरिवर्तन करता है, और उन पर ऑपरेटर "Z %%" का उपयोग करता है, जो विभाजन ऑपरेटर का उपयोग करके मानक "ज़िप" ऑपरेशन है %%।

maxऑपरेटर सूची का सबसे बड़ा तत्व (इस मामले में, यह सूची सबसे है कि देता है Trueउस में की)। हम तब तार्किक और ऑपरेटर का उपयोग करके इसे कम करते हैं, यह देखने के लिए कि क्या "सबसे सच्ची" सूची के सभी तत्व सत्य हैं, और यह परिणाम है। यह @nwellnhof ने क्या लिखा, इसकी लगभग सटीक प्रतिलिपि है, बस बाइट्स को शेव करने के लिए अस्पष्ट ऑपरेटरों का उपयोग करना।

— Ramillies
स्रोत
यह कहता है permutations, यह स्पष्ट रूप से बहुत अधिक पठनीय है;)
— caird coinheringaahing
खैर, पर्ल 6 में वास्तव में शक्तिशाली आत्मनिरीक्षण मॉडल है। शायद मैं उस कॉल को अस्पष्ट करने के लिए इसका अध्ययन कर सकता था? : डी
— रामलीज
एक और बाइट को बचाने के [&&]साथ बदलें min।
— nwellnhof
आप आसपास के स्थानों को हटा सकते हैंXZ%%
— जो किंग
काश कुछ ऐसा {all (@^a,)Z%%@^b.permutations.any}संभव होता
— जो किंग
1

ब्रेकीलॉग , 6 बाइट्स

pᵐz%ᵛ0

इसे ऑनलाइन आज़माएं!

यदि दो सूचियाँ संभावित रूप से विभाज्य हैं और वे नहीं हैं तो विफल हो जाता है।

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.
— असंबंधित स्ट्रिंग
स्रोत
0

स्काला, 60 बाइट्स

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.
— लेलेव वलिस
स्रोत
0

जाप , १२ 11 बाइट्स

आउटपुट trueया false।

Vá de@gY vX

झसे आज़माओ

व्याख्या

सरणियों का निहित इनपुट Uऔर V( A& B, क्रमशः)

Vá

के सभी क्रमपरिवर्तन की एक सरणी उत्पन्न करें V।

d

जाँच करें कि क्या कोई तत्व (उप-सरणियाँ) सही है या नहीं।

e@

जाँच करें कि क्या वर्तमान उप-सरणी में प्रत्येक तत्व वर्तमान फ़ंक्शन Xऔर Yवर्तमान इंडेक्स होने के साथ, निम्न फ़ंक्शन से गुजरता है या नहीं ।

gY

Uसूचकांक में तत्व प्राप्त करें Y।

vX

जाँच करें कि क्या यह विभाज्य है X।

— झबरा
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.