गोल्फ मुझे एक OOP!

26

गोल्फ मुझे एक OOP!

ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग के दो महत्वपूर्ण घटक वंशानुक्रम और रचना हैं। साथ में, वे समस्याओं को हल करने के लिए सरल लेकिन शक्तिशाली वर्ग पदानुक्रम बनाने की अनुमति देते हैं। आपका काम एक वर्ग पदानुक्रम के बारे में बयानों की एक श्रृंखला को पार्स करना है, और पदानुक्रम के बारे में सवालों के जवाब देना है।

इनपुट

एक वर्ग पदानुक्रम के बारे में कथनों और प्रश्नों की एक श्रृंखला, एक फ़ाइल या मानक इनपुट से पढ़ा जाता है, जो भी आपकी भाषा के लिए सबसे अच्छा है। यदि आप फ़ाइल विकल्प का उपयोग करते हैं, तो फ़ाइलनाम आपके कोड (फ़ंक्शन तर्क या कमांड लाइन तर्क, जो भी आप चुनते हैं) के लिए पहले तर्क के रूप में पारित किया जाएगा। प्रारूप इस प्रकार है:

<statement> : <name> is a <name>. | <name> has a <name>.
<question> : Is <name> a <name>? | Does <name> have a <name>?
<name> : a-z | A-Z | sequence of alphanumerics or underscores, starting with a letter

इनपुट हमेशा बयान होगा, फिर सवाल। सभी वर्ग नाम एक बड़े अक्षर अंग्रेजी अक्षर ( A-Z) के साथ शुरू होंगे, और सभी सदस्य नाम एक निचले अक्षर अंग्रेजी अक्षर ( a-z) के साथ शुरू होंगे । सभी नाम केस-संवेदी हैं - ABC123समान वर्ग नहीं है Abc123।

कोई चक्रीय विरासत नहीं होगी - अगर Bविरासत में मिली है A, तो विरासत में Aनहीं मिलेगी Bया किसी भी Bबच्चे से नहीं होगी ।

केवल श्रेणी के नाम एक पदानुक्रम का एक हिस्सा होंगे - जैसे कि कथन foo is a bar.या document has a name.घटित नहीं होंगे।

उत्पादन

सत्य या गलत मूल्यों की एक श्रृंखला, प्रश्नों के उत्तर के रूप में, मानक आउटपुट के लिए या आपके फ़ंक्शन के रिटर्न मान के रूप में लिखा गया है। यदि आपके पास किसी प्रश्न का उत्तर देने के लिए पर्याप्त जानकारी नहीं है (उदाहरण के लिए ऐसे प्रश्न, जिनमें वे नाम शामिल हैं जिन्हें आपने विवरणों में नहीं देखा है), तो एक गलत मान के साथ उत्तर दें।

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

मामला एक:

इनपुट:

B is a A.
C is a B.
A has a foo.
Does B have a foo?
Is C a A?
Is D a A?

आउटपुट:

True
True
False

केस 2:

इनपुट:

Cop is a Person.
Criminal is a Person.
Sheriff is a Cop.
Crooked_Cop is a Cop.
Crooked_Cop is a Criminal.
BankRobber is a Criminal.
Cop has a badge.
Criminal has a criminal_record.
Person has a name.
Is Crooked_Cop a Person?
Does Criminal have a name?
Is Crooked_Cop a BankRobber?
Does Person have a potato?
Is Cop a Cop?

आउटपुट:

True
True
False
False
True

नियम

  • आप एक समारोह या एक कार्यक्रम के साथ जवाब दे सकते हैं
  • मानक खामियों को मना किया जाता है
  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा सही उत्तर है
  • जीतने वाला जवाब एक सप्ताह में चुना जाएगा

सौभाग्य, और OOP आपके साथ हो सकता है!

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) ए प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई देता है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  decision-problem  graph-theory  natural-language 
— मै जाऊं
स्रोत
के Does Criminal have a name?बराबर कैसे है True? क्या सभी वस्तुओं का एक नाम है?
— जे एटकिन
4
@JAtkin Criminal is a Person। Person has a name।
— रेटो कोराडी
आह… मुझे याद आ गया था।
— जे एटकिन
क्या मुझे एक बार में सभी इनपुट लेने की आवश्यकता है, या क्या मैं इसे इंटरेक्टिव कंसोल की तरह लाइन से ले सकता हूं? यदि # 2, तो क्या इनपुट होने पर भी मैं एक सची / झूठी चीज़ का उत्पादन कर सकता हूँ?
— जे एटकिन
@JAtkin एक बार या लाइन-बाय-लाइन, अपनी पसंद। यदि यह एक बयान है, तो कोई आउटपुट नहीं होना चाहिए। केवल प्रश्नों के उत्तर मिलते हैं।
— मेगो

जवाबों:

13

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

q_'.e=\N/{)'?=\S/>_,(%}%/(__,*{(2$z~@f=.*\m*|}/ff{1$e=>:=N}

यह दोनों परीक्षण मामलों के लिए तुरन्त समाप्त होता है।

यह या तो प्रश्न का दूसरा नाम नाम 1( या दोनों सत्य), या 0(मिथ्या) छापता है।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

कक्षाओं और सदस्यों के बीच अंतर के कारण, चुनौती एक ऐसे प्रीऑर्डर को बनाने के लिए उबलती है जिसके लिए इनपुट एक आंशिक परिभाषा प्रदान करता है।

हम परिभाषित करते हैं कि x if y iff x एक y है या x का y है ।

पहला परीक्षण मामले के लिए, इनपुट कहा गया है कि बी ≺ एक , सी ≺ बी और एक ≺ foo । संक्रामिता की वजह से, हम भी है बी ≺ foo , सी ≺ एक और एक ≺ foo । इसके अलावा, रिफ्लेक्सिटी के कारण, x because x हमेशा सही होता है।

दिए गए इनपुट के लिए, हम इस प्रकार बयानों से we की आंशिक परिभाषा निकाल सकते हैं, sufficient की परिभाषा को पूरा करने के लिए पर्याप्त मात्रा में ट्रांज़िटिविटी लागू कर सकते हैं और अंत में प्रश्नों का उत्तर दे सकते हैं।

कोड

q_     e# Push all input from STDIN and a copy.
'.e=   e# Count the number of dots/statements (C).
\N/    e# Split the original input at linefeeds.
{      e# For each line:
  )'?= e#   Pop the last character and check if it is a question mark.
       e#   Pushes 1 for '?', 0 for '.'.
  \S/  e#   Split the modified line at spaces.
  >    e#   Remove the first chunk ("Does" or "Is") for questions.
  _,(% e#   Keep the first and last element of the resulting array.
}%/    e# Split the line array into chunks of length C.
(_     e# Extract the first chunk (statements) and push a copy.
       e# The original becomes an accumulator for ≺.
_,*    e# Repeat the statements C times.
{      e# For each of the repeated statements:
  (    e#   Shift out the first name.
       e#     ["w" "x"] -> ["x"] "w"
  2$z~ e#   Copy the accumulator, zip it and dump.
       e#     [["x" "y"] ["z" "w"]] -> ["x" "z"] ["y" "w"]
  @f=  e#   Rotate the shifted out name on top and check for equality.
       e#     ["y" "w"] "w" -> [0 1]
  .*   e#   Vectorized string repetition.
       e#     ["x" "z"] [0 1] -> ["" "z"]
  \m*  e#   Swap the result with the shifted array and apply Cartesian product.
       e#     ["" "z"] ["x"] -> [["" "x"] ["z" "x"]]
       e#   This accounts for transitivity; we had ["w" "x"] and ["z" "w"],
       e#   so now we have ["z" "x"].
  |    e#   Perform set union with the accumulator to add the new pairs.
}/     e#
ff{    e# For each of the questions on the bottom of the stack.
  1$e= e#   Count the occurrences of the question pair in the accumulator.
  >    e#   Remove 0 or 1 elements from the question pair.
  :=   e#   Check for equality.
       e#   If the question pair occurs in the accumulator, this pushes the
       e#   second name of the question pair. Otherwise, it pushes 1 if the
       e#   names are equal (to account for reflexivity) and 0 otherwise.
  N    e#   Push a linefeed.
}      e#
— डेनिस
स्रोत
2
यह देखते हुए प्रभावशाली है कि सीजेएम में कक्षाएं नहीं हैं: डी
— बीटा
ये सुन्दर है।
— मीगो
@ बीटाडेके कक्षाएं अनिवार्य रूप से नेस्टेड सेट हैं; कक्षाएं हर भाषा में लागू की जाती हैं। पहले उदाहरण में कहें। C:{B:{A:{foo:{}}}}
— एक
8

पायथन 3, 431 331 308 बाइट्स

o={}
f={}
def h(z,f):
 if z not in o:f[z]=[z];o[z]=[]
while 1:
 g=input().split(' ');r=2;l=g[-1][:-1]
 if'.'in g[3]:
  if'i'in g[1]:h(g[0],f);h(l,f);f[g[0]]+=f[l]
  if'h'in g[1]:o[g[0]]+=l,
 else:
  if'I'in g[0]:r=any(l in z for z in f[g[1]])
  if'D'in g[0]:r=any(l in o[z] for z in f[g[1]])
 if r<2:print(r)

यह टिप्पणियों के साथ पूर्ण संस्करण है

objects = {}
synonyms = {}

def createObject(name):
    """
    Create a object with `name` if is does not yet exist and start a synonym tree.
    """
    if name not in objects:
        synonyms[name] = [name]
        objects[name] = []

# use this to read from a file
# with open("questions.txt") as file: 
#     for l in file:
        # print(">>> " + l, end='')
        # inArg = l.replace("\n","").split(" ")


while True: # to read from a file comment this
        inArg = input(">>> ").split(" ") # and this out

        out = -1

        if '.' in inArg[3]: # statement
            last = inArg[3].replace('.','')

            if 'i' in inArg[1]: # is a
                createObject(inArg[0])
                createObject(last)
                synonyms[inArg[0]] += synonyms[last]

            if 'h' in inArg[1]: # has a
                objects[inArg[0]] += [last]

        else:# question
            last = inArg[-1].replace('?','')

            createObject(inArg[1])
            if 'I'in inArg[0]: # Is a
                out = any([last in syn for syn in synonyms[inArg[1]]])

            if 'D'in inArg[0]: # Does have a
                out = any(last in objects[syn] for syn in synonyms[inArg[1]])

        if out != -1:
            print(out)

परीक्षण मामले के लिए आउटपुट # 1:

True
True
False

केस # 2:

True
True
False
False
True

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

— जे एटकिन
स्रोत
इसके बजाय का उपयोग करने का global fमें h(z), उपयोग def h(z,f)और वैश्विक पारित fजब यह बुला में। वास्तव में, आपको बिल्कुल भी ज़रूरत नहीं है h(z)- बस उस शरीर को डालें जहां आप इसे कहते हैं। आप की जरूरत नहीं है r=2, और आप बस के print(r)बिना कर सकते हैं if, क्योंकि आपको झूठे प्रश्नों के लिए एक गलत मूल्य का उत्पादन करने की आवश्यकता है। आप नाम बदल सकते हैं synकरने के लिए zऔर कई बाइट्स बंद वहाँ दाढ़ी। मुझे नहीं लगता कि आपको []पहले अपनी सूची के आसपास की जरूरत है any।
— मीगो
आप eएक बार भी उपयोग करते हैं , इसलिए आप परिभाषा के साथ दूर कर सकते हैं और बस उपयोग कर सकते हैं [a,b,c,d]। इसके बजाय if s(i,g) is not None, क्या करें if s(i,g)- re.Matchवस्तुओं का मूल्यांकन हमेशा किया जाता है Trueयदि एक मैच पाया जाता है। आप 2 बाइट्स भी छोड़ सकते हैं f[x]+=f[y]।
— मेगो
@ मेगो वाह, सभी युक्तियों के लिए धन्यवाद। मुझे उन्हें बाद में लगाने की आवश्यकता होगी।
— जे एटकिन
यह पोस्ट शायद आपको बहुत मदद करेगी
— Mego
@ मीगो बिग थैंक्स, इसकी डाउन टू 396 नाउ। मैं शीघ्र ही पोस्ट करूंगा।
— जे एटकिन
4

हास्केल, 157 बाइट्स

o s=v(x 0#k)#(x 1#q)where(k,q)=break((=='?').l.l)(words#lines s)
x n w=(w!!n,init$l w)
v k(a,c)=a==c||or[v k(b,c)|b<-snd#(filter((==a).fst)k)]
(#)=map
l=last

के लिए स्ट्रिंग दें o। सुनिश्चित नहीं है कि अगर बनाना xऔर v('अर्क' और 'सत्यापित') infixes mapएक infix बनाने से अधिक कटौती करते हैं , या यदि दोनों संभव है।

संपादित करें: स्पष्टीकरण

तो, (#)कैसे आप एक infix ऑपरेटर को परिभाषित करते हैं, मैं इसे केवल एक आशुलिपि के रूप में उपयोग करता हूं map, एक सूची के प्रत्येक तत्व पर फ़ंक्शन लागू करता है। इसे और अन्य उपनामों को हल करते हुए l, 'डायरेक्ट-फंक्शन-एप्लिकेशन-ऑपरेटर' से परहेज करें $और इससे भी अधिक कोष्ठक और चीजों को जोड़कर, और वास्तविक फ़ंक्शन नामों के साथ हम यहां पहुंचें:

oop string = map (verify (map (extract 0) knowledge)) (map (extract 1) questions)
 where (knowledge,questions) = break ((=='?').last.last) (map words (lines string))

extract n wordlist = (wordlist!!n,init (last wordlist))

verify knowledge (a,c) = (a==c)
               || or [verify knowledge (b,c) | b <- map snd (filter ((==a).fst) knowledge)]

map words (lines string) इनपुट स्ट्रिंग में प्रत्येक पंक्तियों की शब्द सूची की एक सूची है।

(=='?').last.last एक विधेय है जो यह दर्शाता है कि एक पंक्ति के अंतिम शब्द में अंतिम अक्षर एक प्रश्न चिह्न है, अर्थात क्या रेखा एक प्रश्न है।

break सूची को बिना किसी प्रश्न (सभी कथन) के पहले भाग में और पहले प्रश्न पर (सभी प्रश्नों) के भाग को तोड़ देता है।

mapextract nइनमें से पिंग प्रत्येक शब्द सूची में से उन तत्वों को सूचीबद्ध करता है जिन्हें हम वास्तव में चाहते हैं, nवें एक (जो बयानों में पहला शब्द है - इसलिए n == 0, और सवालों में दूसरा शब्द है - इसलिए n == 1) !!ऑपरेटर और पिछले एक का उपयोग करके , जिसमें से हम अंतिम अक्षर (या तो कटौती करनी '.'या '?') का उपयोग कर init।

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

अब, map (extract 0) knowledgeऔर map (extract 1) questionsपहले से दूसरे तक एक उपवर्ग या सदस्य-संबंध का प्रतिनिधित्व करने वाले नामों के टपल्स की सूची है।

टुपल्स map (extract 0) knowledgeसभी सच्चे रिश्ते हैं, उन में map (extract 1) questionsअब verifyपहले से तय किए गए तर्क के साथ फ़ंक्शन को मैप किया जाता है map (extract 0) knowledge।

(अब से, अंदर verify, knowledgeएक पैरामीटर नाम है और पहले से extractएड ट्यूपल सूची को संदर्भित करता है ।)

(इसके अलावा, जब पढ़ते हैं verify, तो ध्यान दें कि ||एसई पर क्षैतिज-स्क्रॉल से बचने के लिए एक अभेद्य लाइनब्रेक के बाद) 'रिफ्लेक्सिव' और 'पुनरावर्ती' मामले के बीच एक सामान्य बूलियन डिस्जंक्शन है, जो orकिसी सूची पर तह करता है, अर्थात यदि कोई हो सूची तत्व सत्य है।)

अब, एक संबंध स्पष्ट रूप से सही है यदि यह प्रतिवर्त है। सच पूछिये तो, नहीं, एक potatoनहीं करता है एक potato(और यह, भावना 'है' यहाँ प्रयोग किया जाता है में एक भी नहीं है के रूप में 'ए कॉप एक कॉप है'), लेकिन वह सिर्फ समाप्ति हालत है कि कवर सभी रिश्तों के बाद पेड़ के नीचे चलना (जो असली पेड़ों के मामले में विपरीत है 'का अर्थ है' छलांग की ओर ')।

अन्य सभी मामलों में, हम एक टपल लेने की कोशिश करते हैं knowledge(इसके बाद filterकि हम यह सुनिश्चित करने के लिए एड करते हैं कि हम 'पहले जोड़े को केवल उसी तत्व के साथ देखें, जिसे हम जांचना चाहते हैं), और जहां से यह इशारा करता है। सूची की समझ verifyहर मामले में जारी रखने और फिर से कॉल करने के लिए सभी संभव टपल से संबंधित है। एक मृत अंत में यहां एक खाली सूची होगी और falseकुल मिलाकर वापस आ जाएगी , और इसलिए इसका उदाहरण प्रभावित न करें verify।

— लीफ़ विलर्ट्स
स्रोत
क्या आप गैर हैस्केल धाराप्रवाह लोगों के लिए एक छोटी व्याख्या जोड़ सकते हैं?
— J Atkin
आनंद से! मैं अनुरोध करने तक हर पद के लिए ऐसा नहीं करता।
— लीव विलर्ट्स
ठीक है धन्यवाद! (फिलर)
— J Atkin
वाह, यह कुछ स्पष्टीकरण है।
— J Atkin
2
मैंने अभी पहली छमाही पढ़ना शुरू किया है Learn you a haskell for great good!और अब मुझे यह समझ में आया है! (यह जवाब वास्तव में क्या है जो मुझे हैक्सेल और एफपी के बारे में अधिक जानने के लिए प्रेरित करता है, और यह बहुत अच्छा है!)
— जे एटकिन
4

जावास्क्रिप्ट, 265 263 बाइट्स

for(o={};i=prompt().split(/\W/);)a=i[0],b=i[1],d=i[2],b=="is"?((o[a]=o[a]||{p:[],k:{}}).p.push(d),o[d]=o[d]||{p:[],k:{}}):b=="has"?o[a].k[d]=1:alert(o[b]&&(a>"E"?b==d|(c=n=>~(p=o[n].p).indexOf(d)|p.some(c))(b):(c=n=>o[n].k.hasOwnProperty(i[4])|o[n].p.some(c))(b)))

छोड़ने के लिए एक रिक्त स्ट्रिंग दर्ज करें।

व्याख्या

for(
  o={};                               // o = all objects
  i=prompt().split(/\W/);             // i = command as an array of words
)
  a=i[0],                             // a = first word
  b=i[1],                             // b = second word
  //c=i[2],                           // c = third word
  d=i[3],                             // b = fourth word
  //e=i[4],                           // e = fifth word

  // Case: <name> is a <name>.
  b=="is"?(
    (o[a]=o[a]||{p:[],k:{}})          // create the object if it does not exist
      .p.push(d),                     // add the parent to the object's list of parents
    o[d]=o[d]||{p:[],k:{}}            // create the parent if it does not exist
  ):

  // Case: <name> has a <name>.
  b=="has"?
    o[a].k[d]=1                       // set the specified property

  :
  alert(                              // display the responses to the questions
    o[b]                              // false if the queried object does not exist
    &&(

      // Case: Is <name> a <name>?
      a>"E"?                          // "Is" > "E" and "Does" < "E"
        b==d                          // check if it is itself
        |(c=n=>
          ~(p=o[n].p)                 // p = direct parents of current object
            .indexOf(d)               // check direct parents for the object
          |p.some(c)                  // check the grandparents
        )(b)

      // Case: Does <name> have a <name>?
      :
        (c=n=>
          o[n].k.hasOwnProperty(i[4]) // check if this object has the property
          |o[n].p.some(c)             // check it's parents for the property also
        )(b)
    )
  )
— user81655
स्रोत
क्या आप उपयोग कर सकते हैं string.split(" ");?
— जे एटकिन
@JAtkin मैंने .match(/\w+/g)शब्दों से विराम चिह्न को हटा दिया।
— 2:81 बजे user81655
मैंने देखा कि, लेकिन .split(" ")कम नहीं होगा या मैं कुछ याद कर रहा हूँ? (मैं जावास्क्रिप्ट नहीं जानता)
— जे एटकिन
@JAtkin अगर मैंने इस्तेमाल किया है तो .splitमुझे भी .slice(0,-1)(दो बार) इस्तेमाल B is a A.करना होगा क्योंकि यह Bवारिस A.( .) के साथ होगा ।
— 2:81 बजे user81655
@Jtkin वास्तव में मुझे पता चला है कि विभाजन नियमित अभिव्यक्ति को स्वीकार करता है इसलिए मैं उपयोग कर सकता हूं .split(/\W/)। मुझे देखने के लिए धन्यवाद कि ऊपर!
— user81655
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.