Giriş

Bu meydan okumada, kendinden döngüler içeren yönlendirilmiş bir grafik verilir ve göreviniz onu kendinden döngüler olmadan yönlendirilmemiş bir grafiğe dönüştürmektir.

Giriş

Girişiniz {0, 1, ..., n-1}, bazı doğal sayılar için tepe noktası ayarlanmış n ≥ 0(veya {1, 2, ..., n}1 tabanlı dizine ekleme kullanıyorsanız) yönlendirilmiş bir grafiktir . Grafik, uzunluk- olarak verilir nliste tepe noktası dışında komşu bir listesidir . Örneğin, liste grafiği temsil ederLL[i]i[[0,1],[0],[1,0,3],[]]

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

Komşu listelerinin mutlaka sipariş edilmediğini, ancak yinelemesiz olduklarının garanti edildiğini unutmayın.

Çıktı

Çıktınız, girdiyle aynı biçimde elde edilen ve aşağıdaki gibi elde edilen başka bir grafiktir.

1. Tüm otomatik döngüleri silin.
2. Kalan her kenar için u -> v, v -> uyoksa , ters kenarı ekleyin .

Girişte olduğu gibi, çıkış grafiğinin komşu listeleri sıralanmamış olabilir, ancak kopyaları içeremezler. Yukarıdaki grafik için [[1,2],[0,2],[0,1,3],[2]], grafiği temsil eden doğru bir çıktı olur

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

kurallar

Grafiklerde 0 veya 1 tabanlı indeksleme kullanabilirsiniz. Hem fonksiyonlar hem de tam programlar kabul edilebilir. En düşük bayt sayısı kazanır ve standart boşluklara izin verilmez.

Test Durumları

Bu test senaryolarında 0 tabanlı indeksleme kullanılır; 1 tabanlı durumda her sayıyı artırın. Bu komşu listeleri artan sırada sıralanır, ancak zorunlu değildir.

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

Pyth, 17 16 bayt

.e-.|f}k@QTUQbkQ

Çevrimiçi deneyin: Gösteri veya Test Paketi

açıklama

                   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 bayt

Sp3000 tarafından kaydedilen 2 bayt.

Bu gerçekten zarif bir çözüm olarak başladı ve daha sonra gözden kaçtığım bazı delikleri yamalamayı denediğimde giderek daha iğrenç hale geldi. Orijinal fikrin hala kurtarılabilir olup olmadığından henüz emin değilim, ama elimden gelenin en iyisini yapacağım ...

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

Burada test edin. Alternatif olarak, tüm test kayışını çalıştırın .

Hastanın öldüğünden emin olduktan sonra bir açıklama ekleyeceğim.

Python 2, 107 bayt

Hala bunu daha fazla golf olup olmadığını anlamaya çalışıyorum, ama şimdilik, bu yapabileceğim en iyisi.

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)

Yinelemeleri önlemek için setler kullanıyorum; Ayrıca, aksine list.remove(i), {S}-{i}eğer bir hata atmak değil ideğil S.

Ruby, 78 bayt

Sonunda bazı Ruby'nin set operatörleri ( [1,2]&[2]==[2]ve [3,4,5]-[4]==[3,5]) için kullanın.

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

ideone , geçtiği tüm test senaryoları dahil.

CJam, 26 bayt

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

Çok kısa değil ...

açıklama

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

Bitişik listeden yinelenenleri önlemeye yardımcı olan bitişik kümeler oluşturma. Reklam son olarak kümelerden başlayarak listeleri yeniden oluşturur.

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

Genişletilmiş, çalıştırılabilir kod:

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

Harika - 87

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

Testleri çalıştırmak için tam komut dosyası:

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

Mathematica, 84 66 64 bayt

1 tabanlı indeksleme kullanma.

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

Python 3, 127 bayt

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

Çevrimiçi deneyin

En iyi girişimim değil ...