क्या हमें दोस्त होना चाहिए?

Question

ध्यान दें कि यह मुख्य रूप से डेटा-संरचनाओं पर ध्यान केंद्रित करने वाला प्रश्न है

परिचय

Bacefook चाहता है कि लोगों को दोस्ती हो! जैसे, वे दोस्तों को सुझाव देने के लिए एक नई प्रणाली लागू कर रहे हैं! आपका कार्य अपने नए सुझाव प्रणाली को लागू करने के लिए Bacefook की मदद करना है।

विशेष विवरण:

आपका कार्यक्रम एक आरईपीएल (पठन-eval प्रिंट पाश) आदेश के 3 प्रकार का समर्थन होना चाहिए: FRIEND, SUGGESTऔर KNOW।

FRIEND X Y- निर्दिष्ट करता है कि Xऔर Yसामाजिक नेटवर्क में दोस्त हैं।

• यदि X, Y से मित्र है, तो Y, X से मित्र है

• कर सकते हैं, लेकिन उत्पादन करने के लिए नहीं है

• X हमेशा X के साथ मित्र है

KNOW X Y - यदि X और Y मित्र हैं, तो मिथ्या अन्यथा आउटपुट करें

• KNOW X X हमेशा एक सत्य मूल्य का उत्पादन करेगा

SUGGEST X Y- यदि X और Y मित्र हों तो मिथ्या होना चाहिए अन्यथा सत्य मूल्य का उत्पादन करें। X और Y मित्र होने चाहिए यदि:

• X और Y मित्र नहीं हैं

• X और Y में कम से कम 1 दोस्त है

आपको प्रतिस्थापित करने की अनुमति है FRIEND, SUGGESTऔर KNOWअपने स्वयं के तार के साथ, लेकिन आपको यह उल्लेख करना होगा कि आपने प्रत्येक कमांड को किस स्ट्रिंग से बदल दिया है।

आपका कार्यक्रम किसी भी तरह से इनपुट / आउटपुट आउटपुट में ले सकता है, जब तक कि यह कैसे काम करता है, इसे पहचानना काफी आसान है।

सोशल नेटवर्क में लोगों की संख्या N1 से 100,000 के बीच है, लेकिन किसी भी संख्या में "मित्र लिंक" (किनारे) हो सकते हैं।

यदि आपने अभी तक ध्यान नहीं दिया है, तो यह एक ग्राफ खोज समस्या है। इसे लागू करने के लिए (संभावना) सबसे आसान (और संभवतः सबसे तेज़) डेटा संरचना एक आसन्न मैट्रिक्स होगी।

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

FRIEND A B
FRIEND A C
FRIEND B D
SUGGEST A B -> Falsy, as they are friends
SUGGEST A D -> Truthy, as they share B as a common friend
SUGGEST C D -> Falsy, they do not share a common friend
KNOW D B -> Truthy, they are friends
KNOW B C -> Falsy, not friends
=============
FRIEND Tom Tim
KNOW Tom Tim -> Truthy
KNOW Tim Tom -> Truthy
KNOW Tom Kit -> Falsy
=============
KNOW Tim Kit -> Falsy
FRIEND Tim Tom
KNOW Tim Kit -> Falsy
FRIEND Tom Kit
SUGGEST Tim Kit -> Truthy
=============
FRIEND X Y
SUGGEST X Y -> Falsy since X is friends with X

यहाँ छवि के रूप में कुछ और परीक्षण मामले हैं

जीत की स्थिति

यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है!

Comments

उदाहरण के लिए, क्या हम नेटवर्क में सभी लोगों की सूची को इनपुट करके शुरू कर सकते हैं, जैसे {A, B, C, D}?

— ग्रेग मार्टिन

पाठ मामलों में परीक्षण के मामले होने से रास्ता अधिक उपयोगी होगा।

— ग्रेग मार्टिन

क्या हम FRIEND कमांड के बाद आउटपुट कर सकते हैं?

— अंडा

SUGGEST UK EU।

— WBT

पायथन में @ थुंडा, अंतर्निहित REPL का उपयोग करने के लिए कमांड में दो अतिरिक्त पात्रों की आवश्यकता होती है। क्या इस तरह की भाषाओं को कार्यक्रम की कुल लंबाई में उन अतिरिक्त बाइट्स को जोड़ना चाहिए?

— क्विंटोपिया

Answer 1

एसडब्ल्यूआई-प्रोलॉग, 62 47 41 बाइट्स

X*Y:-X+Y;Y+X;X==Y.
X?Y:-not(X*Y),X*Z,Y*Z.

प्रोलॉग बहुत बार उपयोगी नहीं होता है, लेकिन जब यह सिर्फ सुंदर होता है। हम उन दोस्तों a+bको सूचित करने के लिए उपयोग करेंगे , जो जानते हैं और जिनका सुझाव दिया जाना चाहिए या नहीं। पहली पंक्ति बस यही कहती है कि यदि सत्य है , या तो सत्य है। यह प्रत्येक अभिजन को जानने की समरूपता को लागू करता है। यह पूछना कि क्या कोई सुझाव होना चाहिए, अविश्वसनीय रूप से सरल है। हम सिर्फ वहाँ है अगर एक पूछना ऐसी है कि गलत है और और सच है। बिल्कुल चुनौती के रूप में वर्णित है।aba*baba?bbaX*YX+YY+XX == YZX*YX*ZY*Z

यदि आप इसे एक फ़ाइल के रूप में सहेजते हैं (उदाहरण के लिए friends.pl) और इस फ़ाइल के साथ SWI-Prolog खोलें ( prolog -l friends.pl) तो आप एक REPL में गिर जाते हैं।

आप इस तरह दोस्ती का दावा कर सकते हैं:

assert('a' + 'b').
assert('a' + 'c').
assert('b' + 'd').

आप यह देख सकते हैं कि लोगों को पता है कि प्रत्येक को सुझाव या सुझाव दिया जाना चाहिए:

'a'*'b'.
'a'?'d'.

Comments

आप की जगह बाइट्स का एक समूह को बचाने के लिए सक्षम होना चाहिए k(X,Y)के साथ X*Yऔर के साथ एक ही fहै और sअलग अलग ऑपरेंड का उपयोग कर। 21 बाइट्स अगर मैंने सही तरीके से गिना है।

— एमिग्ना

यकीन नहीं है कि वे कैसे जोर के साथ काम करते हैं, इसलिए मैं अनिश्चित हूं f।

— एमिग्ना

पूरी तरह से डेटा संरचना के माध्यम से farts सवाल का हिस्सा डिजाइनिंग। गजब का।

— थुंडा

@Emigna मैंने इसे लागू किया है, लेकिन यह उतना नहीं बचा जितना आपने गिना था।

— orlp

मैंने इसे 41 बाइट्स पर इस तरह से परखा । मेरे पास इसकी कोशिश करने के लिए कोई REPL नहीं है, हालांकि मुझे नहीं पता कि यह वहाँ अलग काम करता है।

— एमिग्ना

Answer 2

PHP, 138 133 129 बाइट्स

PHP मैथमेटिका को धड़कता है - एक दुर्लभ घटना।

for(;$s=fgets(STDIN);$s>G?print$$a[$b]?$s<L:$s>L&&@array_intersect_key($$a,$$b):$$a[$b]=$$b[$a]=1)[,$a,$b]=explode(" ",trim($s));

1सत्य के लिए प्रिंट , झूठा के लिए खाली स्ट्रिंग। इसे ऑनलाइन चलाएं -nrया परीक्षण करें ।
सूची असाइनमेंट के लिए PHP 7.1 की आवश्यकता है; उपयोगकर्ता नाम केस संवेदी होते हैं और बाहर रखना चाहिए a, b, s।

टूट - फूट

for(;$s=fgets(STDIN);                       # loop through input
    $s>G                                        # 2. evaluate command
        ?print$$a[$b]
            # command KNOW: true if $$a[$b]
            ?$s<L
            # command SUGGEST: true if !$$a[$b] and array_intersect_key returns truthy
            :$s>L&&@array_intersect_key($$a,$$b)
        # command FRIEND: set keys in $$a and $$b
        :$$a[$b]=$$b[$a]=1
)
    [,$a,$b]=explode(" ",trim($s));             # 1. parse user names to $a and $b

• $s ट्रिम किया जाना है क्योंकि इसमें न्यूलाइन वर्ण शामिल है।
• array_intersect_keyम्यूट किया जाना है या यह खाली $$aया के लिए चेतावनी देना होगा $$b।
• सभी उपयोगकर्ता नामों के लिए +18 +15 बाइट्स: $$aसाथ $f[$a]और $$bसाथ बदलें $f[$b]।

Answer 3

सीएमडी (बैच), 50 + 20 + 135 = 205 बाइट्स

• FRIEND.CMD

  @for %%f in (%1.%1 %1.%2 %2.%2 %2.%1)do @set %%f=1
  

• KNOW.CMD

  @call echo(%%%1.%2%%
  

  1दोस्तों के लिए प्रिंट , अजनबियों के लिए एक रिक्त रेखा।

• SUGGEST.CMD

  @call set k=0%%%1.%2%%
  @set k=1&if %k%==0 for /f "tokens=2 delims=.=" %%f in ('set %1.')do @call set k=%%k%%%%%%f.%2%%
  @echo(%k:~1,1%
  

  प्रिंट 1या एक रिक्त रेखा। मुझे लगता है कि छह लगातार %एक नया व्यक्तिगत सर्वश्रेष्ठ हो सकता है।

Comments

वह कमाल का पागल है। अच्छा समाधान है।

— AdBBorkBork

Answer 4

पायथन 3, 122 118 + 2 = 120 बाइट्स

l={}
def f(*r):l[r]=l[r[::-1]]=1
k=lambda a,b:a==b or(a,b)in l
s=lambda a,b:1-k(a,b)and any(k(a,z)&k(b,z)for z,_ in l)

उपयोग ठीक वैसा ही है जैसा कि ओवस का जवाब है।

Comments

यह मेरे लिए बहुत स्पष्ट है, लेकिन आवश्यकताओं का कहना है कि आपको यह निर्दिष्ट करने की आवश्यकता है कि अपने REPL का उपयोग कैसे करें और किन आदेशों के साथ करें। उन लोगों के लिए उपयोगी हो सकता है जो अजगर को नहीं जानते हैं। (संयोग से, यह वास्तव में मेरे द्वारा इस्तेमाल की जाने वाली विधि है।)

— क्विंटोपिया

Answer 5

पायथन 3, 163 149 143 + 2 = 145 बाइट्स

-6 बाइट्स @FelipeNardiBatista को धन्यवाद

l=[]
def f(a,b):l.extend([(a,b),(b,a)])
k=lambda a,b:a==b or(a,b)in l
s=lambda a,b:k(a,b)-1and{c for c,d in l if d==a}&{c for c,d in l if d==b}

यह सहेजें एक फाइल करने के लिए और के रूप में चलाते python3 -i file.py
उपयोग
- f("a", "b")के बजाय FRIENDS a b
- k("a", "b")के बजाय KNOW a b
- s("a", "b")के बजायSUGGEST a b

गलत आउटपुट: 0, सेट (), गलत
सत्य आउटपुट: गैर-रिक्त सेट, ट्रू

इसे ऑनलाइन आज़माएं

---

REPL के रूप में अजगर दुभाषिया का उपयोग नहीं करने पर 164 बाइट्स:

f=[]
while 1:c,a,b=input().split();i=(a,b)in f;f+=c=="f"and[(a,b),(b,a)]or[(i+(a==b),-i+1and{c for c,d in f if d==a}&{c for c,d in f if d==b})];print(f[-1][c=="s"])

उपयोग
- के fलिए FRIEND
- के sलिए SUGGEST
कुछ औरKNOW

इसे ऑनलाइन आज़माएं

Comments

दूसरे लिंक के लिए सुझाव समारोह टूट गया है

— थुंडा

@ थुंडा ने इसे तय किया

— अंडा

अगर मुझे कुछ याद आ रहा है, तो मुझे ठीक करें, लेकिन l.extend([(a,b),(b,a)])क्या आप ऐसा नहीं कर सकते l+=[(a,b),(b,a)]? (मैंने अभी तक इसका परीक्षण नहीं किया है)

— हाइपरनेत्रिनो

ओह माफ करना, मैं अपनी गलती, कि एक कारण बनता है एहसास हुआ UnboundLocalError। वैसे अच्छा जवाब!

— हाइपरनेत्रिनो

यदि आप फंक्शन bool()से हटाते हैं s, और उपयोग करते हैं 0, {}और Falseफल्सी और सत्य के रूप में Trueखाली नहीं है set, तो आप 6 बाइट्स बचा सकते हैं

— फेलिप

Answer 6

गणितज्ञ, 164 बाइट्स

f={}
p:=Union@@f
i=Position[p,#][[1,1]]&
m:=Outer[Boole@MemberQ[f,{##}]&,p,p]
a=(#[[i@#2,i@#3]]/._@__->0)>0&
F=(f=#~Tuples~2~Join~f;)&
K=m~a~##&
S=a[m.m,##]&&!K@##&

परिभाषित करता है तीन मुख्य कार्य F, Sऔर Kवांछित व्यवहार के साथ। उदाहरण के लिए, आज्ञाओं का क्रम

F@{David, Bob}
F@{Bob, Alex}
F@{Alex, Kitty}
F@{Daniel, David}
F@{David, Kit}
S[David, Alex]
S[Bob, Kitty]
S[David, Kitty]
S[David, Bob]
K[David, Bob]
F@{Kit, Kitty}
S[David, Kitty]

ओपी में जुड़ी छवि से अंतिम परीक्षण मामला है; Fआदेशों उपज नहीं निर्गम (एकल अर्धविराम इस के लिए भुगतान करने के लिए एक छोटी सी कीमत लगती है) है, जबकि छह Sऔर Kआदेशों उपज

True
True
False
False
True
True

जैसी इच्छा।

किसी भी समय, fउस प्रपत्र के आदेशित जोड़े की सूची है {A, B}जहां Aजानता है B, जबकि pकुछ तत्वों में दिखाई देने वाले लोगों की सूची है f। कॉलिंग F@{A, B}कहते हैं चार आदेश दिया जोड़े {A, B}, {B, A}, {A, A}, और {B, B}करने के लिए f।

इसके अलावा, किसी भी समय, mअंतर्निहित ग्राफ की आसन्न मैट्रिक्स है (एक व्यक्ति खुद को और उनके सभी Fरेंड्स के निकट है); पंक्तियों और स्तंभों को अनुक्रमित किया जाता है p, और iएक व्यक्ति को संबंधित पंक्ति / स्तंभ संख्या में परिवर्तित करता है। हेल्पर फ़ंक्शन aमैट्रिक्स और दो लोगों को इनपुट के रूप में लेता है और मैट्रिक्स की प्रविष्टि को देखता है जिनके "निर्देशांक" दो लोग हैं, Trueयदि संख्या सकारात्मक है और Falseयदि यह शून्य है तो वापस आ जाएगी। (यह aतब भी कॉल करना संभव है जब इनपुट लोगों में से एक को अभी तक मान्यता नहीं मिली है - उदाहरण के लिए, किसी भी FRIEND घोषणाओं से पहले KNOW या SUGGEST क्वेरी बनाना, या किसी ऐसे गरीब व्यक्ति के बारे में पूछना जिसके पास कोई दोस्त नहीं है; यह त्रुटियों को बढ़ाता है, लेकिन नियम वैसे भी /._@__->0आउटपुट को बल देता Falseहै।)

K[A, B]इसलिए कॉलिंग यह देखती है कि क्या m[A, B]सकारात्मक है, जो Kअब क्रिया को लागू करता है । मैट्रिक्स उत्पाद m.mलंबाई-2-पथ मैट्रिक्स है, जिसमें लंबाई 2 के मार्ग के साथ एक व्यक्ति से दूसरे तक जाने के तरीकों की संख्या होती है; यह S[A, B]सबसे Sबदसूरत क्रिया को लागू करने की अनुमति देता है , जब तक कि हम इसके अतिरिक्त हाथ से जांच करते हैं ( &&!K@##) कि इनपुट लोग पहले से ही एक दूसरे को नहीं जानते हैं।

मज़ेदार तथ्य: मुक्त करने के लिए, इसलिए ऐसा करना हम में से क्लिक्स घोषित करने के लिए अनुमति देता है मित्र कमान F@{A, B, C, D}के सभी के बराबर है F@{A, B}, F@{A, C}, F@{A, D}, F@{B, C}, F@{B, D}, और F@{C, D}संयुक्त।

Answer 7

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

F=[]
def s(f,c):c=set(c);r=c in F;return F.append(c)if f%2 else not r^(4 in[len(x|c)for x in F])if f else 2>len(c)or r

इसे ऑनलाइन आज़माएं!

चूँकि मैं अजगर 2 के लिए रिप्लाई ऑनलाइन टूल नहीं खोज पाया, इसलिए मैंने TIO Nexus (REPL प्रारूप में) जोड़ा है।

विकल्प और इसके संभावित आउटपुट के लिए क्वेरी

ज्ञात के लिए 0 - कोई नहीं

1 दोस्तों के लिए - सच्चा या गलत

सुझाव के लिए 2 - सही या गलत

एक उदाहरण अजगर दुभाषिया में उपयोग और नमूना आउटपुट का उदाहरण।

>>> F=[]
>>> def s(f,c):c=set(c);r=c in F;return F.append(c)if f%2 else not r^(4 in[len(x|c)for x in F])if f else 2>len(c)or r
...
>>> s(1,['A','B'])
>>> s(1,['A','C'])
>>> s(1,['B','D'])
>>> s(2,['A','B'])
False
>>> s(2,['A','D'])
True
>>> s(2,['C','D'])
False
>>> s(0,['D','B'])
True
>>> s(0,['D','C'])
False

Answer 8

GNU सेड , 158 + 2 (आरएन झंडे) = 160 बाइट्स

चूँकि sed एक regex आधारित भाषा है, इसमें कोई आदिम प्रकार नहीं हैं, न कि सार डेटा संरचनाओं का उल्लेख करने के लिए। नेटवर्क डेटा को नि: शुल्क प्रारूप पाठ के रूप में संग्रहीत किया जाता है, इस मामले में अनावश्यक मित्र लिंक जैसेA-B;B-A; आदि, जो बाद में विभिन्न rexx पैटर्न के खिलाफ मेल खाता है।

G
/^F/{s:. (.+) (.+)\n:\1-\1;\1-\2;\2-\1;\2-\2;:;h}
/^K |^S /{s:(.) (.+) (.+)\n.*\2-\3.*:\1:;/^K$/p}
/^S /s:(.) (.+) (.+)\n.*(.+)-(\2.*\4-\3|\3.*\4-\2).*:\1:p

इसे ऑनलाइन आज़माएं!

डिज़ाइन के अनुसार, sed प्रत्येक इनपुट लाइन के लिए पूरी स्क्रिप्ट चलाता है। टाइपिंग के तुरंत बाद कमांड का आउटपुट देखने के लिए, मैं इंटरैक्टिव मोड में परीक्षण करने की सलाह देता हूं।

उपयोग: sed में कोई सत्य / मिथ्या मूल्य नहीं हैं, इसलिए मेरे द्वारा उपयोग किए जाने वाले आउटपुट कन्वेंशन को बैश से उधार लिया जाता है, जिससे गैर-रिक्त स्ट्रिंग को सत्य माना जाता है, और झूठा के रूप में एक खाली स्ट्रिंग।

• F X Y के लिये FRIEND X Y । इसका कोई आउटपुट नहीं है।
• K X Y के लिये KNOW X Y । आउटपुट 'के' सत्य के रूप में, और मिथ्या के रूप में कुछ भी नहीं।
• S X Y के लिये SUGGEST X Y । आउटपुट 'S' सत्य के रूप में, और मिथ्या के रूप में कुछ भी नहीं।

स्पष्टीकरण:

G
# append stored network data, if any, to the current input line
/^F/{
# if command is 'F' (FRIEND), for ex. 'F X Y'
   s:. (.+) (.+)\n:\1-\1;\1-\2;\2-\1;\2-\2;:
   # generate friend links, for ex. 'X-X;X-Y;Y-X;Y-Y'
   h
   # store updated network data
}
/^K |^S /{
# if command is either 'K' (KNOW) or 'S' (SUGGEST), for ex. 'K X Y'
   s:(.) (.+) (.+)\n.*\2-\3.*:\1:
   # search friend link 'X-Y'. If found, delete pattern except the command letter.
   /^K$/p
   # if only letter K left, print it (command is 'K', 'X' and 'Y' are friends)
}
/^S /
# if command is 'S', for ex. 'S X Y', but 'X' and 'Y' aren't friends
   s:(.) (.+) (.+)\n.*(.+)-(\2.*\4-\3|\3.*\4-\2).*:\1:p
   # search if 'X' and 'Y' have a friend in common (for ex. 'C'), and if so print
   #letter S. The search is for ex. 'C-X.*C-Y' and 'C-Y.*C-X'.