Tidak Langsung Grafik

16

pengantar

Dalam tantangan ini, Anda diberi grafik terarah dengan loop otomatis, dan tugas Anda adalah mengonversinya menjadi grafik tidak terarah tanpa loop otomatis.

Memasukkan

Input Anda adalah grafik terarah dengan set simpul {0, 1, ..., n-1}untuk sejumlah bilangan asli n ≥ 0(atau {1, 2, ..., n}jika Anda menggunakan pengindeksan berbasis 1). Grafik diberikan sebagai ndaftar panjang di Lmana L[i]adalah daftar tetangga vertex i. Misalnya, daftar [[0,1],[0],[1,0,3],[]]mewakili grafik

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

Perhatikan bahwa daftar tetangga tidak perlu dipesan, tetapi mereka dijamin bebas duplikat.

Keluaran

Output Anda adalah grafik lain dalam format yang sama dengan input, diperoleh dari itu sebagai berikut.

  1. Hapus semua loop otomatis.
  2. Untuk setiap tepi yang tersisa u -> v, tambahkan tepi terbalik v -> ujika belum ada.

Seperti halnya input, daftar tetangga dari grafik output mungkin tidak berurutan, tetapi mereka tidak dapat berisi duplikat. Untuk grafik di atas, output yang benar adalah [[1,2],[0,2],[0,1,3],[2]], yang mewakili grafik

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

Aturan

Anda dapat menggunakan pengindeksan berbasis-0 atau berbasis-1 dalam grafik. Fungsi dan program lengkap dapat diterima. Hitungan byte terendah menang, dan celah standar tidak diizinkan.

Uji Kasus

Kasus uji ini menggunakan pengindeksan berbasis 0; menambah setiap angka dalam kasus berbasis 1. Daftar tetangga ini diurutkan dalam urutan menaik, tetapi tidak diperlukan.

[] -> []
[[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]]
Zgarb
sumber

Jawaban:

5

Pyth, 17 16 byte

.e-.|f}k@QTUQbkQ

Cobalah online: Demonstrasi atau Test Suite

Penjelasan

                   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
Jakube
sumber
By the way, .ebaru saja beralih dari k,Yke k,b, jadi untuk menjalankan ini, gunakan.e-.|f}k@QTUQbkQ
isaacg
@isaacg Akan melakukannya, setelah pembaruan kompiler online.
Jakube
Telah diperbarui.
isaacg
5

CJam, 43 40 35 34 33 byte

2 byte disimpan oleh Sp3000.

Ini dimulai sebagai solusi yang sangat elegan dan kemudian semakin mengerikan ketika saya mencoba memperbaiki beberapa lubang yang saya abaikan. Saya belum yakin apakah ide aslinya masih dapat diselamatkan, tetapi saya akan mencoba yang terbaik ...

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

Uji di sini. Atau, jalankan seluruh test harness .

Saya akan menambahkan penjelasan setelah saya yakin pasien sudah mati.

Martin Ender
sumber
3

Python 2, 107 byte

Masih berusaha mencari tahu apakah saya bisa bermain golf lebih banyak, tetapi untuk sekarang, ini adalah yang terbaik yang bisa saya lakukan.

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)

Saya menggunakan set untuk mencegah duplikat; juga, tidak seperti list.remove(i), {S}-{i}tidak membuat kesalahan jika itidak ada S.

Sirpercival
sumber
3

Ruby, 78 byte

Akhirnya beberapa digunakan untuk operator set Ruby ( [1,2]&[2]==[2]dan [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 , termasuk semua test case, yang dilaluinya.

blutorange
sumber
2

CJam, 26 byte

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

Tidak terlalu pendek ...

Penjelasan

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.
jimmy23013
sumber
1

JavaScript (ES6), 96 110

Membuat set adjacency dari daftar adjacency, yang membantu menghindari duplikat. Iklan terakhir membangun kembali daftar mulai dari set.

//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>

edc65
sumber
0

Jawa, 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;}

Kode diperluas, dapat dijalankan:

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()))
        )));
    }
}
Ypnypn
sumber
0

Groovy - 87

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

Script lengkap untuk menjalankan tes:

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]]
dbramwell
sumber
0

Mathematica, 84 66 64 byte

Menggunakan pengindeksan berbasis 1.

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

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)))

Coba online

Bukan usaha terbaik saya ...

OrangeHat
sumber