도전

프로그램은 3 개의 입력을 받아야합니다 :

• 변수의 수인 양의 정수
• 순서가없는 음이 아닌 정수 쌍의 세트. 여기서 각 쌍은 변수 사이의 동등성을 나타냅니다.
• 시작 변수를 나타내는 양의 정수

시작 변수 (시작 변수 자체 포함)와 전 이적으로 동일한 것으로 표시 될 수있는 모든 변수를 나타내는 음이 아닌 정수 세트를 리턴해야합니다.

즉, 주어진 입력에 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]

• 합리적인 형식 (예 : 세트, 목록 등)으로 출력 할 수 있습니다. 순서는 관련이 없습니다.

채점

이것은 code-golf 이므로 가장 짧은 유효한 프로그램 (바이트)이 이깁니다.

테스트 사례 (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}

Brachylog , 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.

파이썬 2 , 65 63 바이트

^{ovs 덕분에 -2 바이트}

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

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

Pyth , 12 바이트

u|sf@TGQG.{E

테스트 스위트.

클린 , 85 81 바이트

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

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

기능을 정의 $ :: [[Int]] -> ([Int] -> [Int])

Wolfram Language (Mathematica) , 32 바이트

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

입력 형식 : {2<->3, 3<->1}, 3. 첫 번째 입력은받지 않습니다.

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

Flashpoint 스크립팅 언어 작업 , 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
]

산출:

풀림 :

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
}

파이썬 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})

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

이것은 단락 업데이트를 사용하는 Rod의 훌륭한 솔루션 을 기반으로합니다 b|=b&p and p. 변수 수를 입력으로 사용 n하면 루프 코드가 단축됩니다.

젤리 ,  12   11  10 바이트

-1 에릭 덕분은 Outgolfer (원자 교체 œ&와를 f)

⁹fÐfȯFµÐLQ

E왼쪽 (길이 2 목록의 목록으로)과 S오른쪽 (정수로)에서 [중복 제거 된] 목록을 리턴하는 2 진 링크 .

온라인으로 사용해보십시오! 또는 테스트 스위트를 참조하십시오.

어떻게?

⁹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

펄 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

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

루비 , 39 바이트

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

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

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을 추가합니다.yy

+y,,&2 한 쌍의 목록에서 한 쌍의 목록으로 옮긴 것과 동일한 것

{ }[+y,,&2]즉 기능시키는 투영된다 x값 것 +y,,&2및 y투사 호출시에 전달되는 인수 될 것이다

|y x인 y인덱스에 x반전 (| )

@[y;x;&;|y x]기존 요소와 요소 의 최소값 ( )을 취하여 y지수 x를 수정&|y x

/ 수렴 할 때까지 계속 전화

a: 에 할당

a[z]=z요소의 부울 마스크 a받는 동일한 z번째

& 부울 마스크를 인덱스 목록으로 변환

옥타브 , 48 45 바이트

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

입력을 "adjaency-matrix"로 사용 [0 0 0; 0 0 1; 1 0 0]합니다 ( 예 : for use [2 = 3, 3 = 1], online).

설명

먼저 eye(size(A))(요소는 반사적), A(입력) 및A' (관계는 대칭 적) .

우리는 충분한 전력 nnz(A)( nnz(A)경로 길이의 상한) 을 계산하여 전이 폐쇄를 계산 하므로, 남은 것은 모두 0이 아닌 항목 (u,:)과 올바른 행을 얻는 것 find입니다.

파이썬 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

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

Pari / GP , 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))

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

JavaScript (ES6), 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 바이트의 비용 으로 가능 합니다.