একটি গ্রাফ অপ্রচলিত করুন

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

মনে রাখবেন যে প্রতিবেশী তালিকাগুলি অগত্যা অর্ডার করা হয়নি তবে এগুলি সদৃশ-মুক্ত থাকার গ্যারান্টিযুক্ত।

আউটপুট

আপনার আউটপুট হ'ল ইনপুট হিসাবে একই বিন্যাসে অন্য গ্রাফ, এটি থেকে নিম্নলিখিত প্রাপ্ত obtained

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

সিজেম, 43 40 35 34 33 বাইট

2 বাইট স্প3000 দ্বারা সংরক্ষিত।

এটি সত্যিই মার্জিত সমাধান হিসাবে শুরু হয়েছিল এবং তারপরে আমি অগ্রাহ্য কিছু গর্তের প্যাচিংয়ের চেষ্টা করার সাথে সাথে ক্রমশই ঘৃণ্য আকার ধারণ করে। আমি এখনও নিশ্চিত নই যে আসল ধারণাটি এখনও উদ্ধারযোগ্য কিনা, তবে আমি যথাসাধ্য চেষ্টা করব ...

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

জাভাস্ক্রিপ্ট (ES6), 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

গণিত, 84 66 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)))

অনলাইন চেষ্টা করুন

আমার সেরা চেষ্টা নয় ...