Giới thiệu

Trong thử thách này, bạn được cung cấp một biểu đồ có hướng với các vòng tự, và nhiệm vụ của bạn là chuyển đổi nó thành một đồ thị không có hướng mà không có các vòng lặp.

Đầu vào

Đầu vào của bạn là một biểu đồ có hướng với đỉnh được đặt {0, 1, ..., n-1}cho một số số tự nhiên n ≥ 0(hoặc {1, 2, ..., n}nếu bạn sử dụng lập chỉ mục dựa trên 1). Biểu đồ được đưa ra dưới dạng ndanh sách độ dài Ltrong đó L[i]là danh sách các vùng lân cận của đỉnh i. Ví dụ, danh sách [[0,1],[0],[1,0,3],[]]đại diện cho biểu đồ

.-.
| v
'-0<--2-->3
  ^   |
  |   |
  v   |
  1<--'

Lưu ý rằng danh sách hàng xóm không nhất thiết phải được đặt hàng, nhưng chúng được đảm bảo không trùng lặp.

Đầu ra

Đầu ra của bạn là một biểu đồ khác có cùng định dạng với đầu vào, thu được từ nó như sau.

1. Xóa tất cả các vòng lặp tự.
2. Đối với mỗi cạnh còn lại u -> v, thêm cạnh đảo ngược v -> unếu nó chưa xuất hiện.

Như với đầu vào, các danh sách lân cận của biểu đồ đầu ra có thể không được sắp xếp, nhưng chúng không thể chứa các bản sao. Đối với biểu đồ trên, một đầu ra chính xác sẽ là [[1,2],[0,2],[0,1,3],[2]], đại diện cho biểu đồ

0<->2<->3
^   ^
|   |
v   |
1<--'

Quy tắc

Bạn có thể sử dụng lập chỉ mục dựa trên 0 hoặc 1 dựa trên biểu đồ. Cả hai chức năng và chương trình đầy đủ đều được chấp nhận. Số byte thấp nhất sẽ thắng và các sơ hở tiêu chuẩn không được phép.

Các trường hợp thử nghiệm

Những trường hợp thử nghiệm sử dụng lập chỉ mục dựa trên 0; tăng mỗi số trong trường hợp 1 dựa. Các danh sách hàng xóm này được sắp xếp theo thứ tự tăng dần, nhưng không bắt buộc.

[] -> []
[[0]] -> [[]]
[[],[0,1]] -> [[1],[0]]
[[0,1],[]] -> [[1],[0]]
[[0,1],[0],[1,0,3],[]] -> [[1,2],[0,2],[0,1,3],[2]]
[[3],[],[5],[3],[1,3],[4]] -> [[3],[4],[5],[0,4],[1,3,5],[2,4]]
[[0,1],[6],[],[3],[3],[1],[4,2]] -> [[1],[0,5,6],[6],[4],[3,6],[1],[1,2,4]]
[[6],[0,5,1],[5,4],[3,5],[4],[5,6],[0,3]] -> [[1,6],[0,5],[4,5],[5,6],[2],[1,2,3,6],[0,3,5]]
[[1,0],[5,1],[5],[1],[5,7],[7,1],[],[1]] -> [[1],[0,3,5,7],[5],[1],[5,7],[1,2,4,7],[],[1,4,5]]
[[2,8,0,9],[5,2,3,4],[0,2],[3,7,4],[8,1,2],[5,1,9,2],[6,9],[6,5,2,9,0],[9,1,2,0],[3,9]] -> [[2,7,8,9],[2,3,4,5,8],[0,1,4,5,7,8],[1,4,7,9],[1,2,3,8],[1,2,7,9],[7,9],[0,2,3,5,6,9],[0,1,2,4,9],[0,3,5,6,7,8]]

Bình thường, 17 16 byte

.e-.|f}k@QTUQbkQ

Dùng thử trực tuyến: Trình diễn hoặc Test Suite

Giải trình

                   implicit: Q = input
.e             Q   enumerated mapping of Q (k index, b out-neighbors):
     f     UQ         filter [0, 1, ..., len(Q)-1] for elements T, which satisfy:
      }k@QT              k in Q[T]
                      # this are the in-neighbors
   .|        b        setwise union with b 
  -           k       remove k

CJam, 43 40 35 34 33 byte

2 byte được lưu bởi Sp3000.

Điều này bắt đầu như một giải pháp thực sự tao nhã và sau đó ngày càng trở nên gớm ghiếc khi tôi cố gắng vá một số lỗ hổng mà tôi bỏ qua. Tôi không chắc chắn nếu ý tưởng ban đầu vẫn có thể cứu vãn được, nhưng tôi sẽ cố gắng hết sức ...

q~_,,\ff{&W+0=)}_z..-{_,{;(},+}%`

Kiểm tra nó ở đây. Ngoài ra, chạy toàn bộ khai thác thử nghiệm .

Tôi sẽ thêm một lời giải thích một khi tôi chắc chắn bệnh nhân đã chết.

Python 2, 107 byte

Vẫn đang cố gắng tìm hiểu xem tôi có thể chơi golf này nhiều hơn không, nhưng bây giờ, đây là điều tốt nhất tôi có thể làm.

def u(g):e=enumerate;o=[set(_)-{i}for i,_ in e(g)];[o[j].add(i)for i,_ in e(o)for j in _];print map(list,o)

Tôi sử dụng các bộ để ngăn ngừa trùng lặp; Ngoài ra, không giống như list.remove(i), {S}-{i}không ném lỗi nếu ikhông có S.

Ruby, 78 byte

Cuối cùng, một số sử dụng cho các toán tử tập hợp ruby ​​( [1,2]&[2]==[2]và [3,4,5]-[4]==[3,5]).

->k{n=k.size;n.times{|i|n.times{|j|(k[j]&[i])[0]&&k[i]=(k[i]<<j).uniq-[i]}};k}

ideone , bao gồm tất cả các trường hợp thử nghiệm, mà nó vượt qua.

CJam, 26 byte

l~_,,:T.-_T\ff&Tf.e&.|:e_p

Không ngắn lắm ...

Giải trình

l~                           e# Read the input.
  _,,:T                      e# Get the graph size and store in T.
       .-                    e# Remove self-loops from the original input.
         _T\ff&              e# Check if each vertex is in each list, and
                             e# return truthy if yes, or empty list if no.
               Tf.e&         e# Convert truthy to vertex numbers.
                    .|       e# Merge with the original graph.
                      :e_    e# Remove empty lists.
                         p   e# Format and print.

JavaScript (ES6), 96 110

Tạo tập hợp kề từ danh sách kề, giúp tránh trùng lặp. Quảng cáo cuối cùng nó xây dựng lại các danh sách bắt đầu từ các bộ.

//Golfed 
U=l=>
  l.map((m,n)=>m.map(a=>a-n?s[n][a]=s[a][n]=1:0),s=l.map(m=>[]))
  &&s.map(a=>[~~k for(k in a)])

// Ungolfed

undirect=(adList)=>(
  adSets=adList.map(_ => []),
  adList.forEach((curAdList,curNode)=>{
    curAdList.forEach(adNode=>{
      if (adNode!=curNode) {
        adSets[curNode][adNode]=1,
        adSets[adNode][curNode]=1
      }
    })  
  }),
  adSets.map(adSet=>[~~k for(k in adSet)])
)

// Test
out=s=>OUT.innerHTML+=s+'\n'

test=[
 [ [], [] ]
,[ [[0]], [[]] ]
,[ [[],[0,1]] , [[1],[0]] ]
,[ [[0,1],[]] , [[1],[0]] ]

,[ [[0,1],[0],[1,0,3],[]] , [[1,2],[0,2],[0,1,3],[2]] ]
,[ [[3],[],[5],[3],[1,3],[4]] , [[3],[4],[5],[0,4],[1,3,5],[2,4]] ]
,[ [[0,1],[6],[],[3],[3],[1],[4,2]] , [[1],[0,5,6],[6],[4],[3,6],[1],[1,2,4]] ] 
,[ 
   [[6],[0,5,1],[5,4],[3,5],[4],[5,6],[0,3]] ,
   [[1,6],[0,5],[4,5],[5,6],[2],[1,2,3,6],[0,3,5]]  
 ]
,[
  [[1,0],[5,1],[5],[1],[5,7],[7,1],[],[1]] , 
  [[1],[0,3,5,7],[5],[1],[5,7],[1,2,4,7],[],[1,4,5]]
 ]

,[
  [[2,8,0,9],[5,2,3,4],[0,2],[3,7,4],[8,1,2],[5,1,9,2],[6,9],[6,5,2,9,0],[9,1,2,0],[3,9]] ,
  [[2,7,8,9],[2,3,4,5,8],[0,1,4,5,7,8],[1,4,7,9],[1,2,3,8],[1,2,7,9],[7,9],[0,2,3,5,6,9],  [0,1,2,4,9],[0,3,5,6,7,8]]
 ]
] 

show=l=>'['+l.map(a=>'['+a+']').join(',')+']'

test.forEach(t => (
  r = U(t[0]),
  ck = show(r) == show(t[1]),           
  out('Test ' + (ck ? 'OK: ':'FAIL: ') + show(t[0])+' -> ' + 
      '\nResult: ' + show(r) + 
      '\nCheck : ' + show(t[1]) + '\n\n')
) )

<pre id=OUT></pre>

Java, 150

a->{int i=0,j,k=a.size();for(;i<k;a.get(i).remove((Object)i++))for(j=k;j-->0;)if(a.get(j).contains(i)&!a.get(i).contains(j))a.get(i).add(j);return a;}

Mã mở rộng, có thể chạy được:

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Function
public class C {
    static Function<List<List<Integer>>, List<List<Integer>>> f = a -> {
        int i = 0, j, k = a.size();
        for (; i < k; a.get(i).remove((Object) i++)) {
            for (j = k; j-- > 0;) {
                if (a.get(j).contains(i) & !a.get(i).contains(j)) {
                    a.get(i).add(j);
                }
            }
        }
        return a;
    };
    public static void main(String[] args) {
        System.out.println(f.apply(new ArrayList(Arrays.asList(
                new ArrayList(Arrays.asList(0, 1)),
                new ArrayList(Arrays.asList(1)),
                new ArrayList(Arrays.asList(1, 0, 3)),
                new ArrayList(Arrays.asList()))
        )));
    }
}

Groovy - 87

u={g->g.eachWithIndex{n,i->g[i]=n-i;g[i].each{g[it]<<i}};g.each{it=it.sort().unique()}}

Kịch bản đầy đủ để chạy thử nghiệm:

u={g->g.eachWithIndex{n,i->g[i]=n-i;g[i].each{g[it]<<i}};g.each{it=it.sort().unique()}}
assert u([]) == []
assert u([[0]]) == [[]]
assert u([[],[0,1]]) == [[1],[0]]
assert u([[0,1],[]]) == [[1],[0]]
assert u([[0,1],[0],[1,0,3],[]]) == [[1,2],[0,2],[0,1,3],[2]]
assert u([[3],[],[5],[3],[1,3],[4]]) == [[3],[4],[5],[0,4],[1,3,5],[2,4]]
assert u([[0,1],[6],[],[3],[3],[1],[4,2]]) == [[1],[0,5,6],[6],[4],[3,6],[1],[1,2,4]]
assert u([[6],[0,5,1],[5,4],[3,5],[4],[5,6],[0,3]]) == [[1,6],[0,5],[4,5],[5,6],[2],[1,2,3,6],[0,3,5]]
assert u([[1,0],[5,1],[5],[1],[5,7],[7,1],[],[1]]) == [[1],[0,3,5,7],[5],[1],[5,7],[1,2,4,7],[],[1,4,5]]
assert u([[2,8,0,9],[5,2,3,4],[0,2],[3,7,4],[8,1,2],[5,1,9,2],[6,9],[6,5,2,9,0],[9,1,2,0],[3,9]]) == [[2,7,8,9],[2,3,4,5,8],[0,1,4,5,7,8],[1,4,7,9],[1,2,3,8],[1,2,7,9],[7,9],[0,2,3,5,6,9],[0,1,2,4,9],[0,3,5,6,7,8]]

Toán học, 84 66 64 byte

Sử dụng lập chỉ mục 1 dựa trên.

MapIndexed[Union[#,First/@l~Position~Tr@#2]~Complement~#2&,l=#]&

Python 3, 127 byte

l=list;g=l(map(set,eval(input())))
for i in range(len(g)):
    for j in g[i]:g[j]=g[j]^g[j]&{j}|{i}
print(l(map(l,g)))

Thử trực tuyến

Không phải nỗ lực tốt nhất của tôi ...