चुनौती

आपके प्रोग्राम को 3 इनपुट लेने चाहिए:

एक धनात्मक पूर्णांक जो चर की संख्या है,
Nonnegative पूर्णांकों के अनियंत्रित जोड़े का एक सेट, जहां प्रत्येक जोड़ी चर के बीच एक समानता का प्रतिनिधित्व करता है, और
एक सकारात्मक पूर्णांक जो प्रारंभिक चर का प्रतिनिधित्व करता है,

इसे नॉनजेगेटिव पूर्णांकों का एक सेट लौटाया जाना चाहिए जो सभी चर का प्रतिनिधित्व करता है जो कि प्रारंभिक चर (प्रारंभिक चर स्वयं सहित) के समान रूप से दिखाया जा सकता है।

दूसरे शब्दों में, दिए गए इनपुट N, Eऔर S, एक सेट लौटाएं Q, जैसे:

S ∈ Q।
तो Z ∈ Qऔर (Y = Z) ∈ E, फिर Y ∈ Q।
तो Z ∈ Qऔर (Z = Y) ∈ E, फिर Y ∈ Q।

इसे ग्राफ़-थ्योरी समस्या के रूप में भी व्यक्त किया जा सकता है:

अप्रत्यक्ष ग्राफ और ग्राफ में एक शीर्ष को देखते हुए, इसके जुड़े घटक में कोने सूचीबद्ध करें ।

विशेष विवरण

आप 0-आधारित या 1-आधारित अनुक्रमण का उपयोग करना चुन सकते हैं।
पहला इनपुट मौजूद चर की संख्या को गिनाता है, जहां चर को संख्या के रूप में दिया जाता है। वैकल्पिक रूप से, आप इस इनपुट को नहीं ले सकते हैं, इस स्थिति में यह आपकी अनुक्रमित योजना के आधार पर, या तो मौजूद उच्चतम चर सूचकांक के बराबर माना जाता है या इससे अधिक है।
आप मान सकते हैं कि इनपुट अच्छी तरह से बना है: आपको पहले इनपुट द्वारा निर्दिष्ट सीमा से बाहर चर नहीं दिया जाएगा। उदाहरण के लिए, 3, [1 = 2, 2 = 0], 1एक वैध इनपुट है, जबकि 4, [1 = 719, 1 = 2, 3 = 2], -3ऐसा नहीं है।
आप यह नहीं मान सकते हैं कि किसी भी चर के साथ कोई समानता जुड़ी होगी। यदि तीसरा इनपुट दिया जाता है जो "अकेला" (जिसमें कोई समानता नहीं है), सही आउटपुट एक सिंगलटन सेट है जिसमें केवल वह इनपुट होता है (क्योंकि यह स्वयं के बराबर है)।
आप मान सकते हैं कि समानताओं में एक चर से स्वयं में समानता नहीं होगी, और एक ही समानता को कई बार नहीं दिया जाएगा (इसमें चीजें शामिल हैं जैसे 1 = 2और 2 = 1)।
आप मान सकते हैं कि दिए गए सभी पूर्णांक आपकी भाषा की प्रतिनिधित्व योग्य सीमा के भीतर होंगे।
आप किसी भी उचित प्रारूप में दूसरा इनपुट ले सकते हैं।

यहाँ कुछ उचित प्रारूप दिए गए हैं:

0 = 2
0 = 3
1 = 0

{(0, 2), (0, 3), (1, 0)}

[0, 2, 0, 3, 1, 0]

0 2 0 3 1 0

Graph[{{0, 2}, {0, 3}, {1, 0}}]

[0 = 2, 0 = 3, 1 = 0]

आप किसी भी उचित प्रारूप (जैसे सेट, सूची, आदि) में आउटपुट कर सकते हैं। आदेश अप्रासंगिक है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध कार्यक्रम (बाइट्स में) जीतता है।

परीक्षण मामले (0-अनुक्रमित)

3, [1 = 2, 2 = 0], 1                      -> {0, 1, 2}
5, [0 = 2, 0 = 3, 1 = 2], 3               -> {0, 1, 2, 3}
6, [0 = 3, 1 = 3, 2 = 4, 5 = 1], 4        -> {2, 4}
6, [0 = 3, 1 = 3, 2 = 4, 5 = 1], 5        -> {0, 1, 3, 5}
5, [0 = 1, 2 = 0, 0 = 3, 4 = 0], 2        -> {0, 1, 2, 3, 4}
6, [0 = 1, 1 = 2, 2 = 3, 3 = 4, 4 = 5], 3 -> {0, 1, 2, 3, 4, 5}
4, [0 = 1, 1 = 2, 2 = 0], 3               -> {3}
5, [0 = 2, 2 = 4], 2                      -> {0, 2, 4}
8, [], 7                                  -> {7}

परीक्षण मामले (1-अनुक्रमित)

3, [2 = 3, 3 = 1], 2                      -> {1, 2, 3}
5, [1 = 3, 1 = 4, 2 = 3], 4               -> {1, 2, 3, 4}
6, [1 = 4, 2 = 4, 3 = 5, 6 = 2], 5        -> {3, 5}
6, [1 = 4, 2 = 4, 3 = 5, 6 = 2], 6        -> {1, 2, 4, 6}
5, [1 = 2, 3 = 1, 1 = 4, 5 = 1], 3        -> {1, 2, 3, 4, 5}
6, [1 = 2, 2 = 3, 3 = 4, 4 = 5, 5 = 6], 4 -> {1, 2, 3, 4, 5, 6}
4, [1 = 2, 2 = 3, 3 = 1], 4               -> {4}
5, [1 = 3, 3 = 5], 3                      -> {1, 3, 5}
8, [], 8                                  -> {8}

code-golf graph-theory equation

— फल तोड़ना
स्रोत

सैंडबॉक्स

— फल

क्या हम चाहने पर पहला इनपुट लेने से चूक सकते हैं? मुझे लगता है कि सही आउटपुट प्राप्त करने के लिए यह आवश्यक नहीं है

— डायलन

@dylnan "पहला इनपुट मौजूद चर की संख्या को गिनाता है, जहां चर को संख्या के रूप में दिया जाता है। वैकल्पिक रूप से, आप इस इनपुट को नहीं ले सकते हैं, इस स्थिति में इसे या तो उच्चतम चर सूचकांक के बराबर माना जाता है, या एक । इस से भी अधिक, अपने अनुक्रमण योजना पर निर्भर करता है "(कल्पना की बात 2)

— Esolanging फल

क्षमा करें कभी-कभी मैं पढ़ना समाप्त करना भूल जाता हूं

— dylnan

क्या उत्पादन में डुप्लिकेट शामिल हैं? (मैं दावा कर सकता हूं कि यह एक सेट का प्रतिनिधित्व करता है ...)

— टन हास्पेल

7

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

{tc⊇,?k.&¬(t∋;.xȮ)∧}ᶠt

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

व्याख्या

{tc⊇,?k.&¬(t∋;.xȮ)∧}ᶠt  Input is a pair, say [2,[[1,3],[2,4],[5,2]]]
{                   }ᶠ   Find all outputs of this predicate:
 t                        Tail: [[1,3],[2,4],[5,2]]
  c                       Concatenate: [1,3,2,4,5,2]
   ⊇                      Choose a subset: [4,5]
    ,?                    Append the input: [4,5,2,[[1,3],[2,4],[5,2]]]
      k                   Remove the last element: [4,5,2]
       .                  This list is the output.
        &¬(      )∧       Also, the following is not true:
           t∋              There is a pair P in the second part of the input.
             ;.x           If you remove from P those elements that occur in the output,
                Ȯ          the result is a one-element list.
                      t  Take the last one of these outputs, which is the shortest one.

— Zgarb
स्रोत

5

पायथन 2 , 65 63 बाइट्स

^{-2 बाइट्स ओव्स के लिए धन्यवाद}

def f(e,s):b={s};exec"for p in e:b|=b&p and p\n"*len(e);print b

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

— छड़ी
स्रोत

2

पायथ , 12 बाइट्स

u|sf@TGQG.{E

परीक्षण सूट।

— लीक नन
स्रोत

2

क्लीन , 85 81 बाइट्स

import StdEnv
$l=limit o iterate(\v=removeDup(flatten[v:filter(isAnyMember v)l]))

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

फ़ंक्शन को परिभाषित करता है $ :: [[Int]] -> ([Int] -> [Int])

— Οurous
स्रोत

दिलचस्प। कैसे limitकाम करता है ?

— फलों का

@EsolangingFruit यह एक सूची लेता है, अनंत माना जाता है, और एक पंक्ति में दो बार होने वाला पहला तत्व देता है।

— Οurous

1

ओह, यह बहुत उपयोगी लगता है!

— फल

1

वोल्फ्राम भाषा (गणितज्ञ) , 32 बाइट्स

#~VertexComponent~#2~Check~{#2}&

इनपुट प्रारूप: {2<->3, 3<->1}, 3। यह पहला इनपुट नहीं लेता है।

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

— alephalpha
स्रोत

1

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 364 बाइट्स

f={t=_this;r=t select 1;i=0;while{i<t select 0}do{call format["V%1=[%1]",i];i=i+1};i=0;while{i<count r}do{call format(["V%1=V%1+V%2;V%2=V%1"]+(r select i));i=i+1};l=call format["V%1",t select 2];g={i=0;c=count l;while{i<c}do{if(i<count l)then{e=l select i;call _this};i=i+1}};{l=l+call format["V%1",e]}call g;"l=l-[e]+[e];if(count l<c)then{c=count l;i=0}"call g;l}

के साथ बुलाना:

hint format
[
    "%1\n%2\n%3\n%4\n%5\n%6\n%7\n%8\n%9",
    [3, [[1, 2], [2, 0]], 1] call f,
    [5, [[0, 2], [0, 3], [1, 2]], 3] call f,
    [6, [[0, 3], [1, 3], [2, 4], [5, 1]], 4] call f,
    [6, [[0, 3], [1, 3], [2, 4], [5, 1]], 5] call f,
    [5, [[0, 1], [2, 0], [0, 3], [4, 0]], 2] call f,
    [6, [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5]], 3] call f,
    [4, [[0, 1], [1, 2], [2, 0]], 3] call f,
    [5, [[0, 2], [2, 4]], 2] call f,
    [8, [], 7] call f
]

आउटपुट:

unrolled:

f =
{
    t = _this;
    r = t select 1;
    i = 0;
    while {i < t select 0} do
    {
        call format["V%1=[%1]", i];
        i = i + 1
    };

    i = 0;
    while {i < count r} do
    {
        call format(["V%1=V%1+V%2;V%2=V%1"] + (r select i));
        i = i + 1
    };

    l = call format["V%1", t select 2];

    g =
    {
        i = 0;
        c = count l;
        while {i < c} do
        {
            if (i < count l) then
            {
                e = l select i;
                call _this
            };
            i = i + 1
        }
    };

    {l = l + call format["V%1", e]} call g;
    "l = l - [e] + [e];

    if (count l<c)then
    {
        c = count l;
        i = 0
    }" call g;

    l
}

— Steadybox
स्रोत

1

पायथन 2 , 53 बाइट्स

e,s,n=input()
b={s}
for p in n*e:b|=b&p and p
print b

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

समारोह के रूप में एक ही लंबाई:

lambda e,s,n:reduce(lambda b,p:b|(b&p and p),n*e,{s})

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

यह शॉर्ट-सर्कुलेटिंग अपडेट का उपयोग करके रॉड के अच्छे समाधान पर आधारित है b|=b&p and p। चरों की संख्या को इनपुट के रूप में लेने से nलूप कोड को छोटा करने में मदद मिलती है।

— XNOR
स्रोत

1

जेली , 12 11 10 बाइट्स

-1 एग्री टू द आउटगॉल्फ (परमाणु को œ&साथ बदलें f)

⁹fÐfȯFµÐLQ

Eबाईं ओर स्वीकार करने वाला एक डाइएडिक लिंक (लंबाई-दो-सूचियों की सूची के रूप में) और Sदाईं ओर (पूर्णांक के रूप में) एक [डी-डुप्लीकेटेड] सूची लौटाता है।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

⁹fÐfȯFµÐLQ - Link: list of lists, E; integer S
      µÐL  - repeat the monadic chain to the left until a fixed point is reached:
  Ðf       -   (for each pair in E) filter keep if:
 f         -     filter discard if in
⁹          -     chain's right argument
           -     (originally [S], thereafter the previous result as monadic)
    ȯ      -   logical OR with implicit right
           -   (force first pass to become S if nothing was kept)
     F     -   flatten to a single list
           -   (S -> [S] / [[1,4],[1,0]]->[1,4,1,0] / etc...)
         Q - de-duplicate

— जोनाथन एलन
स्रोत

œ&'s और fरिटर्न रिटर्न वैल्यू हमेशा एक ही बूलियन प्रॉपर्टी होती है।

— एर्ग आउटफोलर

1

पर्ल 5 `-n0` , 49 39 बाइट्स

STDIN पर एक पंक्ति पर आरंभिक मूल्य दें, इसके बाद समतुल्य संख्याओं के जोड़ों की पंक्तियों (या अंतिम मूल्य को अंतिम या बीच में दें या कई प्रारंभिक मान दें, यह सभी काम करता है)

#!/usr/bin/perl -n0
s/
$1? | $1/
/ while/^(\d+
)/msg;say//g

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

यह परिणाम में एक तत्व को कई बार सेट कर सकता है। यह 48 बाइट्स भिन्नता प्रत्येक समकक्ष तत्व को केवल एक बार आउटपुट करती है:

s/
$1? | $1/
/ while/^(\d+
)(?!.*^\1)/msg;say//g

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

— टन हास्पेल
स्रोत

1

रूबी , 39 बाइट्स

->e,*s{e.map{e.map{|a|a-s!=a&&s|=a}};s}

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

— जीबी
स्रोत

1

K (ngn / k) , 37 36 35 बाइट्स

{&a[z]=a:{y[x]&:|y x;y}[+y,,&2]/!x}

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

{ }तर्क के साथ समारोह x, yऔर zप्रतिनिधित्व करने N, Eऔर Sक्रमशः

!x सूची 0 1 ... x-1 है

&2 सूची है 0 0

y,,&2हम जोड़ी 0 0को yखाली के विशेष मामले से बचने के लिए जोड़ते हैंy

+y,,&2 समान चीज़ों को एक सूची से जोड़े की सूची में स्थानांतरित कर दिया गया

{ }[+y,,&2]एक प्रक्षेपण है, अर्थात एक फ़ंक्शन जिसमें प्रक्षेपण के लिए कॉल करते समय xका मान होगा +y,,&2और yतर्क दिया जाएगा

|y xहै yसूचकांकों में x, उलट ( |)

@[y;x;&;|y x]मौजूदा तत्व के न्यूनतम ( ) और एक तत्व से yसूचकांकों में संशोधनx&|y x

/ अभिसरण तक कॉल करते रहें

a: a को असाइन करें

a[z]=zके तत्वों में से बूलियन मुखौटा aके बराबर z-वें

& सूचकांकों की सूची में बूलियन मास्क को परिवर्तित करें

— NGN
स्रोत

1

ऑक्टेव , 48 45 बाइट्स

t=@(A,u)find(((eye(size(A))+A+A')^nnz(A))(u,:));

इनपुट को "आसन्न-मैट्रिक्स" के रूप में लेता है, उदाहरण के लिए इसका उपयोग करता [0 0 0; 0 0 1; 1 0 0]है [2 = 3, 3 = 1], इसे ऑनलाइन आज़माएं!

व्याख्या

पहले हम ट्रांज़िटिव ग्राफ़ के लिए पूर्ण आसन्न मैट्रिक्स का निर्माण करते हैं, eye(size(A))(तत्व रिफ्लेक्टिव हैं), A(इनपुट) और A'(संबंध सममित है) के योग का उपयोग करते हुए ।

हम उस शक्ति की गणना करके सकर्मक समापन की गणना करते हैं, nnz(A)जो पर्याप्त है (जो nnz(A)किसी पथ की लंबाई के लिए ऊपरी सीमा है), इसलिए वहां से जो कुछ बचा है वह सभी (u,:)और findशून्य-शून्य प्रविष्टियों के साथ सही पंक्ति प्राप्त करना है ।

— ბიმო
स्रोत

0

पायथन 2 , 87 बाइट्स

g,v=input();x={v};d=[v]
for c in d:x|={c};d+={k[k[0]==c]for k in g if c in k}-x
print x

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

— OVS
स्रोत

0

परी / जीपी , 80 बाइट्स

f(g,p)=c=concat;if(p==q=c(c(p=Set(p),[e|e<-g,setintersect(Set(e),p)])),p,f(g,q))

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

— alephalpha
स्रोत

0

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

(a,n)=>a.map(([b,c])=>[...d[b]||[b],...d[c]||[c]].map((e,_,a)=>d[e]=a),d=[])&&d[n]||[n]

&&[...new Set(d[n]||[n])]14 बाइट्स की लागत से डेडुप्लीकेशन संभव होगा ।

— नील
स्रोत

सकर्मक समानता

चुनौती

विशेष विवरण

स्कोरिंग

परीक्षण मामले (0-अनुक्रमित)

परीक्षण मामले (1-अनुक्रमित)

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

व्याख्या

पायथन 2 , 65 63 बाइट्स

पायथ , 12 बाइट्स

क्लीन , 85 81 बाइट्स

वोल्फ्राम भाषा (गणितज्ञ) , 32 बाइट्स

ऑपरेशन फ्लैशपॉइंट स्क्रिप्टिंग भाषा, 364 बाइट्स

पायथन 2 , 53 बाइट्स

जेली , 12 11 10 बाइट्स

कैसे?

पर्ल 5 -n0 , 49 39 बाइट्स

रूबी , 39 बाइट्स

K (ngn / k) , 37 36 35 बाइट्स

ऑक्टेव , 48 45 बाइट्स

व्याख्या

पायथन 2 , 87 बाइट्स

परी / जीपी , 80 बाइट्स

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

पर्ल 5 `-n0` , 49 39 बाइट्स