Các thách thức

Chương trình của bạn sẽ có 3 đầu vào:

• Một số nguyên dương là số lượng biến,
• Một tập hợp các cặp số nguyên không có thứ tự, trong đó mỗi cặp biểu thị một đẳng thức giữa các biến và
• Một số nguyên dương đại diện cho biến bắt đầu,

Nó sẽ trả về một tập hợp các số nguyên không âm, đại diện cho tất cả các biến có thể được hiển thị tương đương với biến bắt đầu (bao gồm cả biến bắt đầu).

Nói cách khác, đầu vào cho N, Evà S, trả về một tập Q, như vậy:

• S ∈ Q.
• Nếu Z ∈ Qvà (Y = Z) ∈ E, sau đó Y ∈ Q.
• Nếu Z ∈ Qvà (Z = Y) ∈ E, sau đó Y ∈ Q.

Điều này cũng có thể được thể hiện như một vấn đề lý thuyết đồ thị :

Đưa ra một đồ thị vô hướng và một đỉnh trong đồ thị, liệt kê các đỉnh trong thành phần được kết nối của nó .

Thông số kỹ thuật

• Bạn có thể chọn sử dụng lập chỉ mục dựa trên 0 hoặc 1 dựa trên.
• Đầu vào đầu tiên đếm số lượng biến có mặt, trong đó các biến được đưa ra dưới dạng số. Ngoài ra, bạn không thể lấy đầu vào này, trong trường hợp này, nó được coi là bằng với chỉ số biến cao nhất hiện tại, hoặc nhiều hơn chỉ số này, tùy thuộc vào sơ đồ lập chỉ mục của bạn.
• Bạn có thể giả sử đầu vào được hình thành tốt: bạn sẽ không được cung cấp các biến ngoài phạm vi được chỉ định bởi đầu vào đầu tiên. Ví dụ, 3, [1 = 2, 2 = 0], 1là một đầu vào hợp lệ, trong khi 4, [1 = 719, 1 = 2, 3 = 2], -3không.
• Bạn không thể cho rằng bất kỳ biến nào sẽ có bất kỳ đẳng thức nào liên quan đến nó. Nếu được cung cấp đầu vào thứ ba là "cô đơn" (không có đẳng thức), thì đầu ra chính xác là một tập hợp đơn lẻ chỉ chứa đầu vào đó (vì nó bằng chính nó).
• Bạn có thể giả định rằng các đẳng thức sẽ không chứa một đẳng thức từ một biến thành chính nó và rằng cùng một đẳng thức sẽ không được đưa ra nhiều lần (điều này bao gồm những thứ như 1 = 2và 2 = 1).
• Bạn có thể giả định rằng tất cả các số nguyên được cung cấp sẽ nằm trong phạm vi đại diện cho ngôn ngữ của bạn.
• Bạn có thể lấy đầu vào thứ hai ở bất kỳ định dạng hợp lý.

Dưới đây là một số định dạng hợp lý:

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]

• Bạn có thể xuất ở bất kỳ định dạng hợp lý nào (ví dụ: đặt, danh sách, v.v.). Đặt hàng là không liên quan.

Chấm điểm

Đây là môn đánh gôn , vì vậy chương trình hợp lệ ngắn nhất (tính bằng byte) sẽ thắng.

Các trường hợp thử nghiệm (0 chỉ mục)

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}

Các trường hợp thử nghiệm (1 chỉ mục)

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 byte

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

Hãy thử trực tuyến!

Giải trình

{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.

Python 2 , 65 63 byte

^{-2 byte nhờ vào lò nướng}

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

Hãy thử trực tuyến!

Bình thường , 12 byte

u|sf@TGQG.{E

Bộ thử nghiệm.

Sạch , 85 81 byte

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

Hãy thử trực tuyến!

Xác định hàm $ :: [[Int]] -> ([Int] -> [Int])

Ngôn ngữ Wolfram (Mathicala) , 32 byte

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

Định dạng đầu vào : {2<->3, 3<->1}, 3. Nó không có đầu vào đầu tiên.

Hãy thử trực tuyến!

Hoạt động ngôn ngữ kịch bản Flashpoint , 364 byte

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}

Gọi với:

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
]

Đầu ra:

Chưa được kiểm soát:

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
}

Con trăn 2 , 53 byte

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

Hãy thử trực tuyến!

Cùng độ dài với hàm:

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

Hãy thử trực tuyến!

Điều này dựa trên giải pháp tốt đẹp của Rod bằng cách sử dụng bản cập nhật ngắn mạch b|=b&p and p. Lấy số lượng biến làm đầu vào ngiúp rút ngắn mã vòng lặp.

Thạch ,  12   11  10 byte

-1 nhờ Erik the Outgolfer (thay thế nguyên tử œ&bằng f)

⁹fÐfȯFµÐLQ

Một liên kết dyadic chấp nhận Eở bên trái (dưới dạng danh sách các danh sách dài hai) và Sbên phải (dưới dạng số nguyên) trả về danh sách [không trùng lặp].

Hãy thử trực tuyến! hoặc xem một bộ thử nghiệm .

Làm sao?

⁹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

Perl 5 -n0 , 49 39 byte

Đưa ra giá trị bắt đầu trên một dòng trên STDIN, theo sau là các cặp số tương đương (hoặc đưa giá trị bắt đầu cuối hoặc ở giữa hoặc đưa ra nhiều giá trị bắt đầu, tất cả đều hoạt động)

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

Hãy thử trực tuyến!

Điều này có thể xuất ra một phần tử trong tập kết quả nhiều lần. Biến thể 48 byte này chỉ xuất ra mỗi phần tử tương đương một lần:

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

Hãy thử trực tuyến!

Ruby , 39 byte

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

Hãy thử trực tuyến!

K (ngn / k) , 37 36 35 byte

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

Hãy thử trực tuyến!

{ }chức năng với các đối số x,y và zđại diện N, Evà Stương ứng

!x là danh sách 0 1 ... x-1

&2 là danh sách 0 0

y,,&2 chúng tôi thêm cặp 0 0 để ytránh trường hợp đặc biệt của một sản phẩm nàoy

+y,,&2 điều tương tự được chuyển từ danh sách các cặp sang một cặp danh sách

{ }[+y,,&2]là một phép chiếu, tức là một hàm trong đó xsẽ là giá trị của+y,,&2 và ysẽ là đối số được truyền vào khi gọi phép chiếu

|y xlà ytại các chỉ sốx , đảo ngược ( |)

@[y;x;&;|y x]sửa đổi ytại các chỉ số xbằng cách lấy tối thiểu (& ) của phần tử hiện có và một phần tử từ|y x

/ tiếp tục gọi cho đến khi hội tụ

a: gán cho một

a[z]=zmặt nạ boolean của các yếu tố abằngz -th

& chuyển đổi mặt nạ boolean thành một danh sách các chỉ số

Octave , 48 45 byte

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

Lấy đầu vào là "ma trận kề", ví dụ sử dụng [0 0 0; 0 0 1; 1 0 0]cho [2 = 3, 3 = 1], hãy thử trực tuyến!

Giải trình

Trước tiên, chúng tôi xây dựng ma trận kề hoàn chỉnh cho biểu đồ bắc cầu, sử dụng tổng eye(size(A))(phần tử là phản xạ), A(đầu vào) vàA' (quan hệ là đối xứng).

Chúng tôi tính toán đóng cửa bắc cầu bằng cách tính toán sức mạnh nnz(A)đủ ( nnz(A)được giới hạn trên cho chiều dài của một đường dẫn), do đó, từ đó tất cả những gì còn lại là để có được hàng bên phải (u,:)và findtất cả các mục nhập khác không.

Python 2 , 87 byte

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

Hãy thử trực tuyến!

Pari / GP , 80 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 87 byte

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

Có thể sử dụng sự trùng lặp &&[...new Set(d[n]||[n])]với chi phí 14 byte.