एक ग्राफ़ को अप्रत्यक्ष करें

Question

परिचय

इस चुनौती में, आपको स्व-छोरों के साथ एक निर्देशित ग्राफ़ दिया जाता है, और आपका कार्य इसे स्व-छोरों के बिना अप्रत्यक्ष ग्राफ़ में बदलना है।

इनपुट

आपका इनपुट एक निर्देशित ग्राफ है जिसमें {0, 1, ..., n-1}कुछ प्राकृतिक संख्या n ≥ 0(या {1, 2, ..., n}यदि आप 1-आधारित इंडेक्सिंग का उपयोग करते हैं) के लिए शीर्ष सेट है । ग्राफ को एक लंबाई के रूप में दिया गया है - nसूची Lजहां L[i]शीर्ष के पड़ोसियों की सूची है i। उदाहरण के लिए, सूची [[0,1],[0],[1,0,3],[]]ग्राफ का प्रतिनिधित्व करती है

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

ध्यान दें कि पड़ोसी सूचियाँ आवश्यक रूप से क्रमबद्ध नहीं हैं, लेकिन वे डुप्लिकेट-मुक्त होने की गारंटी हैं।

उत्पादन

आपका आउटपुट इनपुट के समान प्रारूप में एक और ग्राफ है, जो निम्नानुसार से प्राप्त किया गया है।

1. सभी स्व-छोरों को हटा दें।
2. प्रत्येक बचे हुए किनारे के लिए u -> v, v -> uयदि वह पहले से मौजूद न हो तो उलटे किनारे को जोड़ें ।

इनपुट के साथ, आउटपुट ग्राफ की पड़ोसी सूचियाँ अनियंत्रित हो सकती हैं, लेकिन उनमें डुप्लिकेट नहीं हो सकते। उपरोक्त ग्राफ के लिए, एक सही आउटपुट होगा [[1,2],[0,2],[0,1,3],[2]], जो ग्राफ का प्रतिनिधित्व करता है

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

नियम

आप ग्राफ़ में 0-आधारित या 1-आधारित अनुक्रमण का उपयोग कर सकते हैं। दोनों कार्य और पूर्ण कार्यक्रम स्वीकार्य हैं। सबसे कम बाइट गिनती जीतता है, और मानक खामियों को रोक दिया जाता है।

परीक्षण के मामलों

ये परीक्षण मामले 0-आधारित अनुक्रमण का उपयोग करते हैं; 1-आधारित मामले में प्रत्येक संख्या में वृद्धि। इन पड़ोसी सूचियों को आरोही क्रम में क्रमबद्ध किया गया है, लेकिन इसकी आवश्यकता नहीं है।

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

Answer 1

पायथ, 17 16 बाइट्स

.e-.|f}k@QTUQbkQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

व्याख्या

                   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

Comments

वैसे, .eबस से स्विच किया k,Yगया था k,b, इसलिए इसे चलाने के लिए, का उपयोग करें.e-.|f}k@QTUQbkQ

— isaacg

ऑनलाइन कंपाइलर अपडेट होने पर @isaacg ऐसा करेगा।

— जकुबे

इसे अपडेट कर दिया गया है।

— इसहाक

Answer 2

CJam, 43 40 35 34 33 बाइट्स

Sp3000 द्वारा बचाए गए 2 बाइट्स।

यह वास्तव में एक सुंदर समाधान के रूप में शुरू हुआ और फिर तेजी से बढ़ता गया क्योंकि मैंने कुछ छेदों को अनदेखा करने की कोशिश की। मुझे यकीन नहीं है कि अगर मूल विचार अभी भी उद्धार योग्य है, लेकिन मैं अपनी पूरी कोशिश करूँगा ...

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

इसका परीक्षण यहां करें। वैकल्पिक रूप से, संपूर्ण परीक्षण दोहन चलाएं ।

एक बार मैं स्पष्टीकरण जोड़ दूंगा कि मुझे यकीन है कि मरीज मर चुका है।

Answer 3

पायथन 2, 107 बाइट्स

अभी भी यह पता लगाने की कोशिश की जा रही है कि क्या मैं इसे और अधिक बढ़ा सकता हूं, लेकिन अभी के लिए, यह सबसे अच्छा है जो मैं कर सकता हूं।

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)

मैं डुप्लिकेट को रोकने के लिए सेट का उपयोग करता हूं; इसके विपरीत list.remove(i), {S}-{i}यदि iनहीं है, तो एक त्रुटि नहीं है S।

Answer 4

रूबी, 78 बाइट्स

अंत में कुछ रूबी के सेट ऑपरेटरों ( [1,2]&[2]==[2]और [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}

आइडोन , सभी परीक्षण मामलों सहित, जो यह गुजरता है।

Answer 5

सीजेएम, 26 बाइट्स

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

बहुत कम नहीं ...

व्याख्या

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.

Answer 6

जावास्क्रिप्ट (ईएस 6), 96 110

आसन्न सूची से आसन्न सेट बनाना, जो डुप्लिकेट से बचने में मदद करता है। विज्ञापन अंतिम बार सेट से शुरू होने वाली सूचियों का पुनर्निर्माण करता है।

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

Answer 7

जावा, 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;}

विस्तारित, रन करने योग्य कोड:

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

Answer 8

ग्रूवी - 87

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

परीक्षण चलाने के लिए पूरी स्क्रिप्ट:

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

Answer 9

गणितज्ञ, .४ ६६ 64 बाइट्स

1-आधारित अनुक्रमण का उपयोग करना।

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

Answer 10

पायथन 3, 127 बाइट्स

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

ऑनलाइन कोशिश करें

मेरी पूरी कोशिश नहीं ...