Menemukan Kebuntuan

Ketika memprogram aplikasi multithreading kita harus berhati-hati untuk menghindari kebuntuan berbagai utas saat mengakses sumber daya bersama. Sebuah kebuntuan terjadi ketika upaya thread untuk mengakses sumber daya yang terkunci di thread lain pada saat yang sama bahwa benang lainnya sedang mencoba untuk mengakses sumber daya dikunci oleh yang pertama. Ini adalah kasus sederhana, tetapi bisa menjadi lebih kompleks dengan rantai sumber daya yang lebih lama.

Tantangan

Anda harus menulis sebuah program atau fungsi yang dapat mendeteksi situasi jalan buntu yang mungkin dalam daftar sumber daya yang diakses oleh setiap utas. Ini adalah kode-golf, jadi jawaban tersingkat dalam byte menang.

Setiap utas dimulai pada saat yang sama, tetapi setelah itu mereka dapat berjalan pada setiap kombinasi interleaving. Jika ada 2 benang dengan 4 tindakan masing-masing, itu bisa dijalankan sebagai (di mana masing-masing nomor adalah tindakan yang diambil oleh benang dengan id itu) 1,1,1,1,2,2,2,2, 2,2,2,2,1,1,1,1, 1,2,1,2,1,2,1,2, 1,1,2,2,2,2,1,1, atau kombinasi lain yang mungkin.

Memasukkan

Anda akan menerima, melalui STDIN, parameter fungsi, atau alternatif terdekat, daftar string. Setiap string akan berada dalam format +a -b. Setiap string ini mewakili penguncian ( +) / unlocking ( -) sumber daya oleh utas. Antara setiap utas akan menjadi ---pemisah. Dijamin bahwa utas tidak akan mencoba untuk mengunci sumber daya yang sudah dikunci, dan bahwa semua utas secara eksplisit akan membuka semua sumber daya yang telah dikunci sebelum keluar. Berikut ini adalah contoh untuk diperagakan:

+a    # Lock resource a
+b    # Lock resource b
-a    # Unlock resource a
-b    # Unlock resource b
---   # Thread separator
+b    # Lock resource b
-b    # Unlock resource b

Keluaran

Output harus palsu jika input tidak mengandung kemungkinan kebuntuan, dan jujur ​​jika berisi kemungkinan kebuntuan. Sebagai contoh:

• true
• false
• 1
• 0

semua hasil yang valid, tetapi segala sesuatu yang didefinisikan dengan jelas sebagai kebenaran / kepalsuan akan diterima.

Contohnya

+a
-a
---
+a
-a

Keluaran: false

+a
+b
-b
-a
---
+b
+a
-a
-b

Keluaran true

Jalan buntu saat mencoba mendapatkan b,amasing-masing untuk utas1,2

+a
+b
-a
-b
---
+a
+b
-b
-a

Keluaran false

+a
+b
-b
-a
---
+b
+c
-c
-b
---
+c
+a
-a
-c

Keluaran: true

Jalan buntu di utas 1,2,3 saat mencoba mengakuisisi b,c,amasing-masing.

http://pastebin.com/vMYRZxtW

Keluaran false

http://pastebin.com/V5MVgNgS

Keluaran true

Jalan buntu di utas 1,2,3 saat mencoba b,d,amasing-masing.

Tentu saja ini bisa menjadi jauh lebih kompleks, dengan lebih banyak utas, lebih banyak sumber daya untuk masing-masing, dan seterusnya, tetapi saya percaya tes ini mencakup dasar-dasarnya.

Bonus

Karena sangat menyedihkan ketika Anda menemukan situasi kebuntuan saat menulis sebuah program, ada bonus -8 byte untuk jawaban yang dihasilkan :(dan :)masing-masing sebagai kebenaran / kepalsuan.

Python 2 - 227

Pada dasarnya memastikan tidak ada loop 'prioritas'. Sebagai contoh dalam tes kedua, utas pertama memiliki a(b)prioritas dan utas kedua memiliki b(a)prioritas.

Saya berpikir untuk menulis ulang ini dalam Pyth karena saya pikir itu akan bekerja dengan baik dengan semua operasi itertools, tetapi mengubah regex akan membutuhkan beberapa pekerjaan jadi untuk sekarang saya akan memposting ini dan mungkin mencoba untuk mengubahnya dan mengirim jawaban lain nanti.

from itertools import*
import re
f=lambda t:any(re.search(r"(.)((.)\3)+\1",''.join(p))for i in product(*[[m.group(1)+m.group(2)for m in re.finditer(r"(\w).*(\w).*\2.*\1",e,16)]for e in t.split('---')])for p in permutations(i))

Python - 586 539 524 501 485 byte - 8 = 477

Tingkat lekukan:

1: 1 space
2: 1 tab
3: 1 tab + 1 space
4: 2 tabs

-

import sys
V=set()
t=[[[]]]
for r in sys.stdin:
 r=r.strip()
 if'---'==r:t.append([[]])
 else:v=r[1:];V.add(v);l=t[-1][-1];t[-1].append(l+[v]if'+'==r[0]else filter(lambda x:x!=v,l))
s=lambda l:s(l[1:])+map(lambda x:(l[0],x),l[1:])if 1<len(l)else[]
E=reduce(set.union,map(lambda x:set(sum(map(s,x),[])),t),set())
for v in V:
 k=set();q=[v]
 while 0<len(q):
    u=q.pop(0)
    if u in k:continue
    k.add(u)
    for x,y in E:
     if u==x:
        if y in k:print':(';sys.exit()
        else:q.append(y)
print':)'