निर्धारित करें कि क्या कोई संबंध सकर्मक है

15

चुनौती का वर्णन

आइए कुछ परिभाषाओं के साथ शुरू करें:

  • एक संबंध तत्वों के आदेशित जोड़े का एक सेट है (इस चुनौती में, हम पूर्णांक का उपयोग करेंगे)

उदाहरण के लिए, [(1, 2), (5, 1), (-9, 12), (0, 0), (3, 2)]एक संबंध है।

  • किसी भी दो तत्वों के तत्वों के लिए एक संबंध को संक्रमणीय कहा जाता है (a, b)और (b, c)इस संबंध में, एक जोड़ी (a, c)भी मौजूद है,

  • [(1, 2), (2, 4), (6, 5), (1, 4)], सकर्मक है, क्योंकि यह होता है (1, 2)और (2, 4)है, लेकिन (1, 4)साथ ही साथ,

  • [(7, 8), (9, 10), (15, -5)]सकर्मक है, क्योंकि कोई भी दो जोड़े नहीं हैं (a, b), (c, d)ऐसा वर्तमान b= c।

  • [(5, 9), (9, 54), (0, 0)]सकर्मक नहीं है, क्योंकि इसमें सम्‍मिलित है (5, 9)और है (9, 54), लेकिन नहीं(5, 54)

पूर्णांकों के जोड़े की सूची को देखते हुए, यह निर्धारित करें कि कोई संबंध सकर्मक है या नहीं।

इनपुट आउटपुट

आपको किसी भी उचित प्रारूप में पूर्णांकों के जोड़े की सूची दी जाएगी। एक संबंध पर विचार करें

[(1, 6), (9, 1), (6, 5), (0, 0)]

निम्नलिखित प्रारूप समकक्ष हैं:

[(1, 6), (9, 1), (6, 5), (0, 0)] # list of pairs (2-tuples)
[1, 9, 6, 0], [6, 1, 5, 0] # two lists [x1, x2, ..., xn] [y1, y2, ..., yn]
[[1, 6], [9, 1], [6, 5], [0, 0] # two-dimentional int array
[4, 1, 6, 9, 1, 6, 5, 0, 0] # (n, x1, y1, ..., xn, yn)
[1+6i, 9+i, 6+5i, 0+0i] # list of complex numbers

... many others, whatever best suits golfing purposes

आउटपुट: एक सकर्मक संबंध के लिए एक सत्य मूल्य, अन्यथा मिथ्या। आप मान सकते हैं कि इनपुट में कम से कम एक जोड़ी होगी, और यह जोड़ी अद्वितीय है।

code-golf  math  graph-theory  decision-problem 
— shooqie
स्रोत
क्या इनपुट को सूची जैसा प्रारूप होना चाहिए, या यह एक आसन्न - मैट्रिक्स जैसा प्रारूप हो सकता है?
— xnor
आपके पास एक परीक्षण मामला होना चाहिए जो केवल संक्रामक है क्योंकि जोड़े का आदेश दिया गया है। जैसे (1,3) (2,1) (3,4) (1,4) (2,4)। यदि जोड़े का आदेश नहीं दिया गया था, तो यह परिवर्तनशील नहीं होगा क्योंकि (2,3)गायब है।
— मार्टिन एंडर
1
@MartinEnder मुझे लगता है कि आपने "ऑर्डर किए गए जोड़े" की गलत व्याख्या की है। मुझे नहीं लगता कि इसका मतलब एक क्रम में जोड़े हैं - मुझे लगता है कि इसका मतलब है कि प्रत्येक जोड़ी का एक क्रम है, पहले दूसरा।
— isaacg
@ आइसाकग यही मेरा मतलब है। दूसरे शब्दों में, मेरा परीक्षण का मामला केवल सत्य है क्योंकि संबंध सममित रूप से नहीं है।
— मार्टिन एंडर
क्या तीसरा परीक्षण मामला ( [(7, 8), (9, 10), (15, -5)]) संक्रामक नहीं होना चाहिए ?
— wnnmaw

जवाबों:

8

हास्केल, 42 बाइट्स

f x=and[elem(a,d)x|(a,b)<-x,(c,d)<-x,b==c]

प्रयोग उदाहरण: f [(1,2), (2,4), (6,5), (1,4)]-> True।

(आउटर) सभी जोड़ियों पर लूप (a,b)और (इनर) लूप एक ही जोड़े पर, जिसे अब कॉल किया जाता है (c,d)और हर बार जब b==cचेक होता (a,d)है कि यह भी मौजूद है। परिणामों को तार्किक के साथ मिलाएं and।

— nimi
स्रोत
अब तक का सबसे पठनीय जवाब!
— लिन
@Lynn प्रोलॉग उत्तर की जाँच करें, फिर ;-)
— coredump
4

 प्रोलॉग, 66 बाइट्स

t(L):-not((member((A,B),L),member((B,C),L),not(member((A,C),L)))).

संबंध है नहीं करता है, तो हम (ए, बी) और पा सकते हैं सकर्मक (बी, सी) ऐसी है कि (ए, सी) नहीं रखता है।

— कोर निपात
स्रोत
4

MATL , 27 25 बाइट्स

7#u2e!l6MX>thl4$XQttY*g<~

इनपुट प्रारूप एक मैट्रिक्स है ( ;पंक्ति विभाजक के रूप में) जहां संबंध का प्रत्येक जोड़ा एक स्तंभ है। उदाहरण के लिए, मामलों की जाँच करें

[(1, 2), (2, 4), (6, 5), (1, 4)]
[(7, 8), (9, 10), (15, -5)]
[(5, 9), (9, 54), (0, 0)]

क्रमशः इनपुट हैं

[1 2 6 1; 2 4 5 4]
[7 9 15; 8 10 -5]
[5 9 0; 9 54 0]

ट्रू आउटपुट एक मैट्रिक्स है जो लोगों द्वारा बनाई जाती है। मिथ्या एक मैट्रिक्स है जिसमें कम से कम एक शून्य होता है।

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

व्याख्या

कोड पहले इनपुट पूर्णांकों को अद्वितीय, 1-आधारित पूर्णांक मानों को कम करता है। उन मूल्यों से यह आसन्न मैट्रिक्स उत्पन्न करता है; मैट्रिक्स-इसे खुद से गुणा करता है; और परिणाम मैट्रिक्स में नॉनज़रो मानों को धर्मान्तरित करता है। अंत में, यह जाँचता है कि बाद वाली मैट्रिक्स में कोई प्रविष्टि आसन्न मैट्रिक्स में अधिक नहीं है।

— लुइस मेंडो
स्रोत
3

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

a=>(g=f=>a.every(f))(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))

@ ब्यॉय द्वारा एक विचार के लिए 2 बाइट्स को सहेजा गया। पिछले चार 69-बाइट फॉर्मूलेशन थे:

a=>a.every(([b,c])=>a.every(([d,e])=>c-d|a.some(([d,c])=>b==d&c==e)))
a=>!a.some(([b,c])=>!a.some(([d,e])=>c==d&a.every(([d,c])=>b-d|c-e)))
a=>a.every(([b,c])=>a.every(([d,e])=>c-d|!a.every(([d,c])=>b-d|c-e)))
(a,g=f=>a.every(f))=>g(([b,c])=>g(([d,e])=>c-d|!g(([d,c])=>b-d|c-e)))
— नील
स्रोत
1
आप के लिए एक संक्षिप्त नाम बनाकर दूसरा समाधान छोटा करने के लिए सक्षम हो सकता है.every
— Cyoce
@ सच में, आप हर बार लिखकर 3 बाइट्स बचाते हैं [e], इसलिए भले ही eआपको बाइट बचाने के लिए 8 बाइट्स का खर्च आता हो । हालाँकि, मैं इसके लिए एक संक्षिप्त नाम देकर एक कदम आगे बढ़ गया a.every, जिससे एक दूसरी बाइट बच गई।
— नील
3

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

'{psc[A:B:B:C],?'e[A:C]}

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

स्पष्टीकरण:

'{psc[A:B:B:C],?'e[A:C]}
'{                     } it is impossible to find
    c                    a flattened
   s                     subset of
  p                      a permutation of the input
     [A:B:B:C]           that has four elements, with the second and third equal
              ,?         and such that the input
                'e       does not contain
                  [A:C]  a list formed of the first and fourth element

दूसरे शब्दों में, यदि इनपुट में जोड़े हैं [A:B]और [B:C], हम इनपुट को डालने [A:B]और [B:C]शुरू करने की अनुमति दे सकते हैं, अन्य सभी तत्वों को हटा सकते हैं, और एक सूची तैयार कर सकते हैं [A:B:B:C]। अगर [A:C]हम वहाँ नहीं है तो हम आंतरिक विधेय (पूरे कार्यक्रम से फ़र्ज़ी) से सच्चाई लौटाते हैं ।

2

CJam (22 बाइट्स)

{__Wf%m*{z~~=*}%\-e_!}

ऑनलाइन टेस्ट सूट । यह एक अनाम ब्लॉक (फ़ंक्शन) है जो तत्वों को दो-स्तरीय सरणी के रूप में लेता है, लेकिन परीक्षण सूट इनपुट को एक उपयुक्त प्रारूप में डालने के लिए स्ट्रिंग हेरफेर करता है।

विच्छेदन

{         e# Begin a block
  _       e#   Duplicate the argument
  _Wf%    e#   Duplicate again and reverse each pair in this copy
  m*      e#   Cartesian product
  {       e#   Map over arrays of the form [[a b][d c]] where [a b] and [c d]
          e#   are in the relation
    z~~=* e#     b==c ? [a d] : []
  }%
  \-      e#   Remove those transitive pairs which were in the original relation
  e_!     e#   Test that we're only left with empty arrays
}
— पीटर टेलर
स्रोत
2

अजगर, 14 बाइट्स

!-eMfqFhTCM*_M

परीक्षण सूट

इनपुट प्रारूप होने की उम्मीद है [[0, 0], [0, 1], ... ]

!-eMfqFhTCM*_M
!-eMfqFhTCM*_MQQQ    Variable introduction
            _MQ      Reverse all of the pairs
           *   Q     Cartesian product with all of the pairs
         CM          Transpose. We now have [[A2, B1], [A1, B2]] for each pair
                     [A1, A2], [B1, B2] in the input.
    f                Filter on
       hT            The first element (the middle two values)
     qF              Being equal
  eM                 Take the end of all remaining elements (other two values)
 -              Q    Remove the pairs that are in the input
!                    Negate. True if no transitive pairs were not in the input
— isaacg
स्रोत
2

मैथेमेटिका, 49 बाइट्स

#/.{x=___,{a_,b_},x,{b_,c_},x}/;#~FreeQ~{a,c}:>0&

शुद्ध कार्य जो जोड़े की एक सूची लेता है। यदि इनपुट सूची में है {a,b}और कुछ के लिए {b,c}नहीं {a,c}है a, b, c, तो इसे बदल देता है 0। ट्रू, इनपुट लिस्ट है, मिथ्या है 0।

— ngenisis
स्रोत
1

सी ++ 14, 140 बाइट्स

अनाम लैम्बडा के रूप में संदर्भ पैरामीटर के माध्यम से लौट रहा है। एक कंटेनर होने के लिए इसके इनपुट की आवश्यकता होती है pair<int,int>। बोरिंग ओ (एन ^ 3) दृष्टिकोण लेना।

[](auto m,int&r){r=1;for(auto a:m)for(auto b:m)if (a.second==b.first){int i=0;for(auto c:m)i+=a.first==c.first&&b.second==c.second;r*=i>0;}}

अधूरा और उपयोग:

#include<vector>
#include<iostream>

auto f=
[](auto m,int&r){
  r=1;                         //set return flag to true
  for(auto a:m)                //for each element
    for(auto b:m)              //check with second element
      if (a.second==b.first){  //do they chain?
        int i=0;               //flag for local transitivity
        for(auto c:m)          //search for a third element
          i+=a.first==c.first&&b.second==c.second;
        r*=i>0;                //multiply with flag>0, resulting in 0 forever if one was not found
      }
}
;

int main(){
 std::vector<std::pair<int,int>> m={
  {1, 2}, {2, 4}, {6, 5}, {1, 4}
 };

 int r;
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,6);
 f(m,r);
 std::cout << r << std::endl;

 m.emplace_back(3,5);
 f(m,r);
 std::cout << r << std::endl;

}
— कार्ल नेफ
स्रोत
1

पायथन 2 , 91 67 55 बाइट्स

lambda s:all(b-c or(a,d)in s for a,b in s for c,d in s)

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

-24 बाइट्स लीक-नून
-12 बाइट्स की बदौलत बब्बलर को धन्यवाद

— HyperNeutrino
स्रोत
67 बाइट्स (और बदलकर अपना कोड तय lambda xकिया lambda s।
— लीकी नून
@LeakyNun ओह हूप्स, वह मुझे बेवकूफ था। धन्यवाद!
— हाइपरनेत्रिनो
forएस पर अनपैक करके 55 बाइट्स ।
— बब्बलर
@ बब्बल ओह कूल
— थैंक्स
0

Axiom 103 बाइट्स

c(x)==(for i in x repeat for j in x repeat if i.2=j.1 and ~member?([i.1, j.2],x)then return false;true)

ungolfed:

c(x)==
  for i in x repeat
    for j in x repeat
       if i.2=j.1 and ~member?([i.1, j.2],x) then return false
  true

                                                                   Type: Void

अभ्यास

(2) -> c([[1,2],[2,4],[6,5],[1,4]])
   Compiling function c with type List List PositiveInteger -> Boolean
   (2)  true
                                                                Type: Boolean
(3) -> c([[7,8],[9,10],[15,-5]])
   Compiling function c with type List List Integer -> Boolean
   (3)  true
                                                            Type: Boolean
(4) -> c([[5,9],[9,54],[0,0]])
   Compiling function c with type List List NonNegativeInteger ->
      Boolean
   (4)  false
— RosLuP
स्रोत
0

क्लोजर, 56 53 बाइट्स

अद्यतन: :whenमैं उपयोग करने के बजाय सिर्फ जाँच करूंगा कि इनपुट सेट से या [a b] [c d]तो सभी जोड़े मिले हैं b != cया [a d]नहीं।

#(every? not(for[[a b]%[c d]%](=[b nil][c(%[a d])])))

मूल:

वाह, लूप्स के लिए क्लोजर शांत हैं: डी यह जांचता है कि forलूप एक मिथ्या मान उत्पन्न नहीं करता है, जो तब होता है जब [a d]इनपुट सेट से नहीं मिला है।

#(not(some not(for[[a b]%[c d]% :when(= b c)](%[a d]))))

इस इनपुट में दो-तत्व वैक्टर का एक सेट होना चाहिए:

(f (set [[1, 2], [2, 4], [6, 5], [1, 4]]))
(f (set [[7, 8], [9, 10], [15, -5]]))
(f (set [[5, 9], [9, 54], [0, 0]]))

यदि इनपुट को सूची की तरह होना चाहिए तो अतिरिक्त 6 बाइट के लिए (%[a d])प्रतिस्थापित करना होगा ((set %)[a d])।

— NikoNyrh
स्रोत
0

इन दोनों समाधान इनपुट और लौटने के रूप में आदेश दिया जोड़ों की सूची लेने अनाम कार्य हैं Trueया False।

मैथेमेटिका, 65 बाइट्स

SubsetQ[#,If[#2==#3,{#,#4},Nothing]&@@@Join@@@#~Permutations~{2}]&

#~Permutations~{2}]इनपुट से आदेश दिए गए जोड़े के सभी ऑर्डर किए गए जोड़े की सूची बनाता है, और Join@@@उन लोगों को आदेश दिया है जो चौगुनी का आदेश देते हैं। फिर उन्हें फ़ंक्शन द्वारा संचालित किया जाता है If[#2==#3,{#,#4},Nothing]&@@@, जिसमें एक शांत संपत्ति होती है: यदि मध्य दो तत्व समान हैं, तो यह पहले और आखिरी नंबर से मिलकर क्रमबद्ध जोड़ी को वापस करता है; अन्यथा यह वापस आ जाता है Nothing, एक विशेष गणितज्ञ टोकन जो स्वचालित रूप से सूचियों से गायब हो जाता है। तो परिणाम आदेशित जोड़े का सेट है जिसे इसके लिए इनपुट में होने की आवश्यकता है ताकि यह सकर्मक हो; SubsetQ[#,...]उस संपत्ति का पता लगाता है।

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

And@@And@@@Table[Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j},{i,#},{j,#}]&

Table[...,{i,#},{j,#}]एक 2 डी सरणी द्वारा अनुक्रमित बनाता है iऔर j, जो सीधे इनपुट (इसलिए दोनों का आदेश दिया जोड़े हैं) से लिया जाता है। उन दो सूचकांकों का कार्य है Last@i!=#&@@j||#~MemberQ~{#&@@i,Last@j}, जो "या तो दूसरे तत्व का iऔर पहले तत्व का jमेल नहीं खाते, या फिर इनपुट में आदेशित जोड़ी है जिसमें पहले तत्व iऔर अंतिम तत्व शामिल हैं j"। यह And@@And@@@बूलियन का 2 डी सरणी बनाता है, जो एक एकल बूलियन में समतल होता है।

— ग्रेग मार्टिन
स्रोत
0

एपीएल (एनएआरएस), 39 चार्ट, 78 बाइट्स

{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}

परीक्षा:

  f←{∼∨/{(=/⍵[2 3])∧∼(⊂⍵[1 4])∊w}¨,⍵∘.,w←⍵}
  f (1 2) (2 4) (6 5) (1 4)
1
  f (7 8) (9 10) (15 ¯5)
1
  f (5 9) (9 54) (0 0)
0

एक दूसरा 'समाधान' गोटो तरीके का पालन करें:

r←q w;i;j;t;v
r←1⋄i←0⋄k←↑⍴w⋄→3
r←0⋄→0
→0×⍳k<i+←1⋄t←i⊃w⋄j←0
→3×⍳k<j+←1⋄v←j⊃w⋄→4×⍳t[2]≠v[1]⋄→2×⍳∼(⊂t[1]v[2])∊w
— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.