บทนำ

ในความท้าทายนี้คุณจะได้รับกราฟกำกับด้วยการวนรอบตัวเองและงานของคุณคือการแปลงให้เป็นกราฟที่ไม่ได้เปลี่ยนทิศทางโดยไม่มีการวนรอบเอง

อินพุต

การป้อนข้อมูลของคุณเป็นกราฟกำกับโดยมีการตั้งค่าจุดยอด{0, 1, ..., n-1}สำหรับจำนวนธรรมชาติn ≥ 0(หรือ{1, 2, ..., n}ถ้าคุณใช้การจัดทำดัชนีแบบ 1) กราฟจะได้รับเป็น length- 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]]

Pyth, 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

CJam, 43 40 35 34 33 ไบต์

บันทึก 2 ไบต์โดย Sp3000

สิ่งนี้เริ่มต้นจากการเป็นทางออกที่ยอดเยี่ยมจริงๆและจากนั้นก็เพิ่มขึ้นอย่างน่าเกลียดยิ่งขึ้นในขณะที่ฉันพยายามปรับปรุงช่องโหว่ที่ฉันมองข้าม ฉันยังไม่แน่ใจว่าแนวคิดดั้งเดิมยังคงอยู่ แต่ฉันจะพยายามอย่างดีที่สุด ...

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

ทดสอบที่นี่ อีกวิธีหนึ่งคือรันเทียมทดสอบทั้งหมด

ฉันจะเพิ่มคำอธิบายเมื่อฉันมั่นใจว่าผู้ป่วยจะตาย

Python 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}ไม่ได้โยนความผิดพลาดถ้าไม่ได้อยู่ในiS

ทับทิม 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}

ideoneรวมถึงกรณีทดสอบทั้งหมดที่ผ่าน

CJam, 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.

JavaScript (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>

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

โค้ดที่ขยายได้และรันได้:

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

สคริปต์เต็มรูปแบบเพื่อเรียกใช้การทดสอบ:

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 ไบต์

ใช้การจัดทำดัชนีแบบ 1

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

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

ลองออนไลน์

ไม่ใช่ความพยายามที่ดีที่สุดของฉัน ...