एलेक्स कभी-कभी सही होता है


50

यह चुनौती हमारे मॉड एलेक्स ए की आत्माओं को उठाना है , जो आमतौर पर गलत है


मान लीजिए आपके पास एलेक्स नाम का एक दोस्त है जिसे बुनियादी तर्क और गणित, विशेष रूप से गणितीय तुल्यता के साथ मदद की ज़रूरत है ।

वह आपको उस फॉर्म के समीकरणों की एक सूची देता है [variable] = [variable]जहां [variable]हमेशा एक एकल अपरकेस अक्षर A से Z होता है (एक लोअरकेस अक्षर नहीं, संख्या नहीं, और न ही कुछ और)। सूची में केवल एक पंक्ति को छोड़कर प्रति पंक्ति में एक समीकरण है जो केवल कहता है therefore

उपरोक्त सभी समीकरणों thereforeहैं परिसर , तथ्यों यह सच माना जाता है। नीचे दिए गए सभी समीकरण thereforeअसत्यापित प्रस्ताव हैं, तथ्य जो एलेक्स परिसर से अनुमान लगाने का प्रयास कर रहे हैं, और वे सच हो सकते हैं या नहीं।

उदाहरण के लिए, इस समीकरण सूची में एकल निष्कर्ष प्रस्ताव A = Cसही होता है:

A = B
B = C
therefore
A = C

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

एक प्रोग्राम / फ़ंक्शन लिखें जो समीकरणों की एक सूची के स्ट्रिंग में लेता है जैसा कि वर्णित और प्रिंट / रिटर्न

Alex is right

यदि सभी निष्कर्ष परिसर से तार्किक रूप से अनुसरण करते हैं, और अन्यथा आउटपुट

Alex is wrong

यदि कोई निष्कर्ष तार्किक रूप से परिसर से पालन नहीं करता है।

बाइट्स में सबसे छोटा कोड जीतता है।

इन मामलों के लिए बाहर देखना सुनिश्चित करें:

  • चर हमेशा खुद के बराबर होती है। जैसे

    B = A
    therefore
    A = A
    X = X
    

    में परिणाम Alex is right

  • अज्ञात रिश्तों वाले चर को समान नहीं माना जा सकता है। जैसे

    P = Q
    therefore
    E = R
    

    में परिणाम Alex is wrong

  • जब thereforeतत्कालीन निष्कर्षों के बाद कोई समीकरण नहीं हैं, तो रिक्तता सच है । जैसे

    D = C
    therefore

    तथा

    therefore

    दोनों में परिणाम Alex is right

  • जब thereforeतत्कालीन से पहले कोई समीकरण नहीं होते हैं तो केवल आत्म-समानता का अनुमान लगाया जा सकता है। जैसे

    therefore
    R = R
    

    परिणाम Alex is right, लेकिन

    therefore
    R = W
    

    में परिणाम Alex is wrong

और ज्यादा उदाहरण

एलेक्स गलत मामले हैं: (खाली लाइनों द्वारा अलग)

A = B
C = D
therefore
A = C

A = L
E = X
A = I
S = W
R = O
N = G
therefore
G = N
L = I
R = O
S = A
X = X
X = E

D = K
D = Q
L = P
O = L
M = O
therefore
K = L

A = B
therefore
B = C

Z = A
S = S
therefore
A = Z
A = A
S = A
A = S
Z = A
Z = A

K = L
K = X
therefore
X = P
L = X
L = P

therefore
A = B
B = C
A = C

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
T = I
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = O
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
A = Z

therefore
C = D
T = Y
A = Z

P = Q
therefore
E = R

therefore
R = W

एलेक्स सही मामलों है:

H = J
therefore
J = H

K = L
K = X
therefore
L = X

C = B
B = A
therefore
A = B

K = L
K = X
K = P
therefore
L = X
L = P
X = P

A = Y
Y = Q
Q = O
therefore
O = Y
O = A

C = C
therefore
C = C

A = B
B = A
therefore
A = B
B = A

A = B
B = C
C = D
therefore
A = A
A = B
A = C
A = D
B = A
B = B
B = C
B = D
C = A
C = B
C = C
C = D
D = A
D = B
D = C
D = D

therefore
A = A
B = B
C = C
D = D
E = E
F = F
G = G
H = H
I = I
J = J
K = K
L = L
M = M
N = N
O = O
P = P
Q = Q
R = R
S = S
T = T
U = U
V = V
W = W
X = X
Y = Y
Z = Z

D = I
F = H
J = M
therefore
M = J
D = I
H = F

A = B
B = C
C = D
D = E
E = F
F = G
G = H
H = I
I = J
J = K
K = L
L = M
M = N
N = O
O = P
P = Q
Q = R
R = S
S = T
T = U
U = V
V = W
W = X
X = Y
Y = Z
therefore
Z = A
F = R
G = I
W = L

A = B
B = C
therefore
A = C

B = A
therefore
A = A
X = X

P = P
C = G
M = C
therefore

D = C
therefore

therefore

therefore
R = R

42
PHP, 13 बाइट्स Alex is wrongसभी परीक्षण मामलों को सत्यापित करता है।
डेनिस

19
अरे, कभी-कभी इससे बेहतर है। ¯ \ _ (ツ) _ / ¯
एलेक्स ए।


7
therefore\nTABS < SPACES->Alex is right
दरवाज़े

7
प्रोलॉग में समाधान देखने के लिए प्यार।
azz

जवाबों:


18

CJam, 49

"Alex is "qN%S{f{)er}(_el-}h;{)#},"wrong""right"?

हिस्टोक्रेट के रूबी समाधान से प्रेरित। यह कोशिश करो ऑनलाइन
3 बाइट्स jimmy23013 करने के लिए धन्यवाद थकाऊ :)

स्पष्टीकरण:

प्रत्येक आधार के लिए, कार्यक्रम बाकी पाठ में 2 चर के साथ पहले चर की जगह लेता है। यह तब जांचता है कि क्या विभिन्न चर के साथ कोई निष्कर्ष है।

"Alex is "    first push the part we know
qN%           read the input and split into lines
S             push a space (initial no-op replacement string, see below)
{…}h          do-while
  f{…}        for each line and the replacement string
    )         take out the last character
    er        replace the remaining character(s) with that character
  (           afterwards, take out the first line
  _el         duplicate and convert to lowercase
  -           remove all the resulting characters from the line
               this removes all lowercase letters and non-letters
               "X = Y" becomes "XY" (new replacement string)
               and "therefore" becomes "" (ending the loop)
              this is the loop condition and is left on the stack every time
;             after the loop, pop the empty string (from "therefore")
{…},          filter the remaining (conclusion) lines using the condition block
  )           take out the last character
  #           find its index in the remaining string
               this is 0 (false) iff the first character is the same as the last
              afterwards, we have an array of lines with non-equal variables
"wrong"       push "wrong"
"right"       push "right"
?             choose "wrong" if the array was not empty, else choose "right"

पुराना संस्करण, 85

"Alex is "26,:A;{:i{{_A=_@-}g}%$~}:F;0q"= "-'t/Nf%~\{A\Ft:A;}/1>{F=}%-"right""wrong"?

यह एक संघ-खोज एल्गोरिथ्म का उपयोग करता है। इसे ऑनलाइन आज़माएं


1
"Alex is "qN%S{f{)er}(_el-}h;{)#},"wrong""right"?
jimmy23013

1
मैंने अभी-अभी उस आखिरी पंक्ति को पढ़ा है 'यह एक गेंडा- एल्गोरिथ्म एल्गोरिथ्म का उपयोग करता है ' ... प्रतीक्षा? xD
Jan

Alex is * wrong * right * ?
चार्ली

32

रूबी, 80 76 + 2 = 78

कमांड-लाइन झंडे के साथ p0, भागो

gsub$1,$2%p=$`[/e/]while~/(.) = (?!\1)(.)/
$_="Alex is #{p ?:wrong: :right}"

स्पष्टीकरण:

यह शुद्ध स्ट्रिंग हेरफेर का उपयोग करता है। p0वेरिएबल में एक सिंगल स्ट्रिंग के रूप में पूरा इनपुट पढ़ता है $_। फिर, हम बार-बार उस स्ट्रिंग को रेगुलर एक्सप्रेशन के खिलाफ मैच करते हैं /(.) = (?!\1)(.)/, जो "X = Y" फॉर्म के सभी स्ट्रिंग्स को ढूंढता है, जहां X और Y एक ही अक्षर नहीं हैं, और X को $ 1 और Y को $ 2 में असाइन करता है। जब ऐसा मैच पाया जाता है, gsub$1,$2तो स्ट्रिंग में Y के साथ X के सभी उदाहरणों को बदल दिया जाता है । हम यह भी जांचते हैं कि यह मैच "इसलिए" से पहले हुआ था या नहीं

$`[/e/]

अगर इसके बाद हुआ, तो यह एक अनुचित दावा है और एलेक्स गलत है। हम ट्रैक करते हैं कि क्या इस तरह की कोई घटना घटित हुई है p=pट्रैकिंग चर के रूप में उपयोग चीजों को टूटने से रोकता है यदि लूप कभी भी एक बार भी हिट नहीं करता है, क्योंकि pयह कभी नहीं सौंपा जाएगा तो शून्य वापस आ जाएगा।

इस पोस्ट के अनुसार, CJam समाधान लंबा है। एक गर्व है, अगर कोई संदेह क्षण क्षणभंगुर नहीं है।

संपादित करें: हाँ, जल्दी से अलग हो गया। इसके अलावा, स्पष्टीकरण को समाप्त करने के लिए, pध्वज के अंतिम $_निष्पादन के अंत में आउटपुट है, इसलिए अंतिम पंक्ति आउटपुट है।


15
सबसे मधुर क्षण वे हैं जिनके समाधान से पहले एक एसोलैंग द्वारा वध किया जाता है।
एलेक्स ए।

String#formatएक अभिव्यक्ति में gsub कॉल और असाइनमेंट दोनों प्राप्त करने के लिए दुरुपयोग एक बहुत साफ विचार है, +1!
वेंचरो

12

सीजेएम, 83 75 68 67 64 बाइट्स

1 बाइट बचाने के लिए डेनिस को धन्यवाद।

"Alex is "q_elN--N/:$La/~{)-},\{__m*{:&},::^|}5*-"wrong""right"?

परीक्षण सूट। परीक्षण के मामले एक पर्मलिंक के लिए बहुत लंबे हैं, इसलिए बस उन्हें प्रश्न से कॉपी करें। ध्यान दें कि यह काफी धीमा है - ऑनलाइन दुभाषिया में एक या दो मिनट लगते हैं। आप इसे बहुत तेजी से बदल 5*सकते 2*हैं जिस स्थिति में यह लगभग तुरंत खत्म हो जाएगा और सभी लेकिन एक परीक्षण मामले को हल करेगा।

व्याख्या

(थोड़ा पुराना है।)

यह विचार संभव समानता के "बाढ़ भरने" का एक प्रकार है और फिर निष्कर्ष सूची से प्राप्त सभी समानताएं हटा दें। यह दिखाया जा सकता है कि हमें बाढ़ भराव के 5 से अधिक चरणों की आवश्यकता नहीं है, क्योंकि वे एक दूरी को कवर करेंगे (असमानताओं के प्रारंभिक ग्राफ में) लेकिन अधिकतम दूरी 25 है।25 = 32

"Alex is " e# Push the string.
q          e# Read the input.
_elN-      e# Make a copy, convert to lower case, remove linefeeds. This gives us a string
           e# with all the characters we don't want from the input.
-          e# Remove them from the input. This leaves two upper-case letters on each line
           e# and an empty line between premises and conclusions.
N/         e# Split into lines.
La/        e# Split around the empty line.
~          e# Dump both halves on the stack.
{)-},      e# Remove any "A = A"-type equalities from the conclusions.
\          e# Swap with the premises.
{          e# Extend the premises 5 times...
  _Wf%     e#   Duplicate the premises and reverse each one, because = is symmetric.
  |        e#   Set union with the original premises.
  __m*     e#   Make two copies and get an array of every possible pair of premises.
  {:&},    e#   Select those which have at least one character in common.
  ::^      e#   For each such pair, take the mutual set difference, i.e. those characters
           e#   that are in only one of the strings.
  |        e#   Set union with the original premises.
}5*
-          e# Remove all the equalities we've obtained from the conclusions. If all
           e# conclusions were valid, the result will now be a empty array, which is falsy.
!          e# Logical not.
"wrong""right"?
           e# Select "wrong" or "right", respectively.

सकर्मक बंद का निर्माण, एह? मैं सीजेएम से परिचित नहीं हूं, लेकिन ऐसा लगता है कि 5 वीं पीढ़ी की समानताएं केवल एक दिशा में उत्पन्न हो सकती हैं। यदि वे हैं, तो आपको उन समानताओं को उलटने के लिए एक और पुनरावृत्ति की आवश्यकता होगी।
user2357112

@ user2357112 मेरा मानना ​​है कि उन्हें दोनों दिशाओं में उत्पन्न किया जाना चाहिए, क्योंकि पहला चरण इनपुट के सभी उलट जोड़ता है (या इसके आगे के संस्करण में जो है, मैं इसे शुरू करने के लिए सभी आधार और निष्कर्ष समानताएं सॉर्ट करता हूं)।
मार्टिन एंडर

जब आप सममित अंतर लेते हैं, हालांकि, क्या आपको दोनों दिशाओं में किनारे मिलते हैं? (या, आगे के गोल्फ संस्करण में, सममित अंतर आवश्यक दिशा में किनारों का उत्पादन करते हैं?)
user2357112

@ user2357112 चूंकि मैं पूरे कार्टेशियन उत्पाद को संसाधित कर रहा हूं, इसलिए मुझे प्रत्येक ऑर्डर में समानता की प्रत्येक जोड़ी मिलेगी, जिसके परिणामस्वरूप दोनों निष्कर्ष निकाले जाएंगे (केवल कारण मुझे स्पष्ट रूप से उलटने की जरूरत है, या प्रारंभिक इनपुट को सॉर्ट करना है,) मूल प्रक्रिया इस प्रक्रिया में आवश्यक रूप से उत्पन्न नहीं होती है, इसलिए वे कार्टेशियन उत्पाद के सेट अंतर को ले कर उलट नहीं होते हैं)।
मार्टिन एंडर

6

आर, 183 192 बाइट्स

मैंने अपने उत्तर को उपयोगकर्ता 2357112 द्वारा इंगित सीमा को संबोधित करने के लिए संशोधित किया है। वास्तव में सही होने पर एलेक्स को बाहर बुलाने की अभी भी एक बहुत छोटी संभावना है (जो कि चुनौती के संदर्भ को समझने पर मुझे बहुत बार नहीं लगता है :-)। मुझे आशा है कि वह बुरा नहीं मानेंगे।

i=grep("t",z<-scan(,"",,,"\n"))
cat("Alex is",if(eval(parse(t=c(paste(LETTERS,"=",1:26),sample(rep(head(z,i-1),1e3)),paste(c(TRUE,sub("=","==",tail(z,-i))),collapse="&")))))"right"else"wrong")

मुझे इसे थोड़ा सा डी-गोल्फ करने की आवश्यकता है:

lines = scan(, what = "", sep = "\n")
therefore_idx = grep("therefore", lines)
setup = paste(LETTERS, "=", 1:26)
premises = sample(rep(head(lines, therefore_idx - 1), 1000))
propositions = paste(c(TRUE, sub("=", "==", tail(lines, -therefore_idx))), collapse = "&")
things_to_evaluate = c(setup, premises, propositions)
boolean_result = eval(parse(text = things_to_evaluate))
cat("Alex is", if (boolean_result) "right" else "wrong")

उदाहरण के लिए, यदि इनपुट है

A = B
B = C
therefore
A = C
B = C

यह पहले मूल्यांकन करेगा setup:

A = 1
B = 2
...
Z = 26

फिर premises

A = B
B = C

एक यादृच्छिक क्रम में प्रत्येक बार 1,000 बार चलाया जाएगा। यह सुनिश्चित करने के लिए है ("लगभग सुनिश्चित") कि सभी समानताएं प्रचारित हैं। अंत में, यह मूल्यांकन करेगा propositions:

TRUE & A == B & B == C

3
यदि परिसर हैं A = B, B = C, C = A, तो मान हमेशा के लिए चक्र में होते हैं। मूल्यांकन के 26 दौर पर्याप्त नहीं हैं।
user2357112

मेरा विफल तर्क ... उदाहरण के लिए धन्यवाद, मुझे तब कुछ और काम करना होगा।
फ्लोडेल

मुझे लगता है कि यह तय है, या लगभग ...!
फ्लोडेल

5

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

import Data.Equivalence.Persistent
c l=equate(l!!0)$last l 
r=foldr(c)$emptyEquivalence('A','Z')
l#r=equiv r(l!!0)$last l
f x|(h,_:t)<-span((<'t').head)$lines x="Alex is "++if all(#r h)t then"right"else"wrong"

मैं Data.Equivalence.Persistentमॉड्यूल के लिए काम को लोड कर रहा हूं , जो समतुल्यता वर्गों में हेरफेर करने के लिए कार्य प्रदान करता है। सभी करने के लिए छोड़ दिया इनपुट और कॉलिंग फ़ंक्शन को पार्स कर रहा है जो कभी-कभी उचित गोल्फिंग के लिए बहुत लंबे नाम हैं।

उपयोग उदाहरण:

*Main> f "A = B\nB = C\ntherefore\nA = C"
"Alex is right"

*Main> f "A = B\nB = D\ntherefore\nA = C"
"Alex is wrong"

3

गणितज्ञ, १ 18२

f[s_]:="Alex is "<>If[True===And@@Simplify[#2,#1]&@@(StringSplit[s,"\n"]/.{a___,"therefore",b___}:>StringSplit/@{{a},{b}}/.{x_,_,y_}:>Symbol[x<>"$"]==Symbol[y<>"$"]),"right","wrong"]

चुनौती के अनुसार, स्ट्रिंग इनपुट पर काम करता है।

In[]:= f["A = B
B = C
therefore
A = C"]
Out[]= Alex is right

In[]:= f["D = K
D = Q
L = P
O = L
M = O
therefore
K = L"]
Out[]= Alex is wrong

आप की घोषणा के द्वारा 8 बाइट्स खो सकते हैं f, एक शुद्ध समारोह के रूप में जगह Simplify[#2,#1]के साथ #2~Simplify~#, और जगह StringSplit[s,"\n"]के साथ #~StringSplit~"<actual newline>"
२al बजे लीजियनममाल

अच्छे अंक! इसके अलावा q=StringSplit;एक और 6 बाइट्स के लिए s / StringSplit / q / या तो बचाया। लेकिन अंत में, यह मैथमेटिका के लिए एक अच्छी चुनौती नहीं है, मुझे डर है, भले ही तर्क चरित्र एक सही फिट लग रहा था।

इसके अलावा, a___और b___शायद a__और b__, और के लिए बदला जा सकता है s=Symbol;
लीजनमोनमाल 978

a__और b__अगर परिसर, प्रस्ताव या दोनों खाली हैं काम नहीं करेगा, हालांकि

3

रेटिना, 90 बाइट्स

चलाने के लिए, कोड की निम्नलिखित 12 पंक्तियों को 12 अलग-अलग फ़ाइलों (पहले से परे प्रत्येक फ़ाइल के लिए गिने जाने वाले +11 बाइट्स) में रखें। <empty>एक खाली फ़ाइल नामित करता है; \nएक शाब्दिक नई रूपरेखा तैयार करता है। वैकल्पिक रूप से, \nजैसे हैं वैसे ही रखें , सभी लाइनों को एक फाइल में रखें, और -sविकल्प का उपयोग करें । सुनिश्चित करें कि सभी फाइलें शाब्दिक newlines का उपयोग करती हैं, न कि विंडोज \r\n, और अंतिम पंक्ति के अंत में स्थान पर ध्यान दें।

s+`^(.) = (.)(.*)\1
$1 = $2$3$2
)`^. .+\n
<empty>
^.+|(.) = \1
<empty>
^\n*$
right
^[^r]+
wrong
^
Alex is 

यह काम किस प्रकार करता है

पहला प्रतिस्थापन इनपुट में पहले आधार से मेल खाता है, जब भी फ़ाइल में आधार का लैश बाद में होता है। यह प्रतिस्थापित करता है कि बाद में आधार की छतों के साथ घटना होती है। +संशोधक सुनिश्चित करता है कि प्रतिस्थापन जब तक यह किसी भी अधिक से मेल नहीं खाता दोहराया जाता है। इस प्रकार, यदि पहला आधार है A = B, Aतो फ़ाइल के सभी बाद के s में ट्रांसमिट हो जाते हैं B

दूसरा प्रतिस्थापन इनपुट से पहला आधार हटाता है, क्योंकि हम अभी इसके साथ काम कर रहे हैं। तब )संशोधक पहले प्रतिस्थापन में वापस जाता है, और तब तक दोहराता है जब तक कि लूप के माध्यम से पूरे पास में कोई बदलाव नहीं होता है। यह तब होता है जब सभी परिसरों को प्रतिस्थापित और हटा दिया जाता है, और इनपुट के साथ शुरू होता है therefore

तीसरा प्रतिस्थापन इनपुट की पहली पंक्ति (जो है therefore) या फॉर्म का कुछ भी मेल खाता है A = A, और इसे हटा देता है। यदि सभी प्रस्तावों को परिसर द्वारा समर्थित किया जाता है, तो वे सभी इस फॉर्म से मेल खाएंगे, इसलिए जो शेष हैं, उनमें पूरी तरह से नई सूची शामिल होनी चाहिए। चौथा प्रतिस्थापन इसे में बदल देता है right। अन्यथा, पाँचवाँ प्रतिस्थापन शेष सब कुछ (जो हटाए जाने के rबाद से समाहित नहीं thereforeहै) में बदल जाता है wrong। अंत में, अंतिम प्रतिस्थापन Alex is शुरुआत में जोड़ता है ।


3

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

Mbomb007 द्वारा पहले से ही एक उल्लेखनीय पायथन 3 उत्तर है । यह जवाब उस एक से झंडा चुराता है (विशेष रूप से "एलेक्स है wrriognhgt" चाल)।

और यह उत्तर भी उस से काफी लंबा है ...

खैर, वैसे भी, इस जवाब में विचार कुंजी-मूल्य जोड़े के एक शब्दकोश को बनाए रखने के लिए है, जहां चाबियाँ 26 पूंजी अक्षर अक्षर हैं, और प्रत्येक कुंजी का संबंधित मूल्य अक्षरों का सेट है जो कुंजी के बराबर हैं। (यदि सभी 26 अक्षर समान थे, तो प्रत्येक कुंजी में इसके संबंधित मान के लिए 26 अक्षरों का एक सेट होगा।)

def a(s):
 d={C:set(C)for C in map(chr,range(65,91))};p,c=s.split('t');c,p=[x.split('\n')for x in[c[9:],p]]
 for u in p[:-1]:
    g,h=u[::4];y=d[g]|d[h]
    for v in y:
     for w in y:d[v]|=d[w];d[w]|=d[v]
 print'Alex is','wrriognhgt'[all(u[0]in d[u[4]]for u in c if u)::2]

(बाइट्स को बचाने के लिए, यह उत्तर रिक्त स्थान और टैब को मिलाता है , जो कि पायथन 2 में कानूनी है)

यह कोड वास्तव में बहुत कुशल है, क्योंकि शब्दकोश अधिकतम संभव आकार (26 के अनुसार 26 तक ऊपर वर्णित है) तक सीमित है जो इनपुट की लाइनों की संख्या पर निर्भर नहीं करता है।

अब, जैसा कि मैं इस समाधान को पूरा कर रहा था, मुझे एहसास हुआ कि मैं कर सकता था शब्दकोश मूल्यों के लिए सेट के बजाय तार का उपयोग करके चार बाइट्स बचा , प्रतिस्थापित करके

d={C:set(C)for C in map(

साथ में

d={C:C for C in map(

बेशक तब आपको भी बदलना होगा (नोट: सेट करें ऑपरेशन के तीन उदाहरण) | स्ट्रिंग संघनन के साथ+ , लेकिन यह कोड लंबाई नहीं बदलता है। नतीजा यह है कि सब कुछ अभी भी उसी तरह काम करना चाहिए, सिवाय इसके कि आप डुप्लिकेट को खत्म नहीं करेंगे जैसे कि आप सेट के साथ करते हैं (यह सिर्फ स्ट्रिंग के अंत में जोड़कर रखेगा)। ठीक लगता है - थोड़ा कम कुशल, सुनिश्चित, लेकिन 264 के बजाय 260 बाइट्स।

ठीक है, यह पता चला है कि 260-बाइट संस्करण इतना अक्षम है कि MemoryErrorजब मैंने इसके साथ परीक्षण किया तो यह हुआ

A = B
A = B
therefore
B = A

यह मेरे लिए आश्चर्यजनक था। आइए 260-बाइट "स्ट्रिंग कॉन्टेनेशन" संस्करण की जांच करें!

बेशक यह कुंजी-मूल्य जोड़े A:Aऔर B:B(24 अन्य जो कोई फर्क नहीं पड़ता) के साथ शुरू होगा । हम d[A]कुंजी के अनुरूप शब्दकोष का अर्थ लिखेंगे A, इसलिए शुरुआत में हमारे पास होगा d[A] = A। अब, आधार को देखते हुए A = B, यह मूल्यों को प्राप्त करने d[A]=Aऔर d[B]=Bप्राप्त करने के लिए शुरू होगा y = AB। तो यह दो बार इस स्ट्रिंग पर लूप करेगा: for v in AB: for w in AB:...

तो, पहली बार लूप के माध्यम से, हमारे पास है v=Aऔर w=A। शब्दकोशों के निम्नलिखित अनुक्रम में आवेदन d[v] += d[w]और d[w] += d[v]परिणाम:

{A:A, B:B}      (start)
{A:AA, B:B}     (d[A] += d[A])
{A:AAAA, B:B}     (d[A] += d[A])

इसके बाद, साथ v=Aऔर w=B:

{A:AAAA, B:B}     (start)
{A:AAAAB, B:B}    (d[A] += d[B])
{A:AAAAB, B:BAAAAB}   (d[B] += d[A])

अगला v=B, w=A:

{A:AAAAB, B:BAAAAB}   (start)
{A:AAAAB, B:BAAAABAAAAB}     (d[B] += d[A])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (d[A] += d[B])

और v=B, w=B:

{A:AAAABBAAAABAAAAB, B:BAAAABAAAAB}     (start)
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])
{A:AAAABBAAAABAAAAB, B:BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB}     (d[B] += d[B])

चरणों का उपरोक्त अनुक्रम एकल आधार को लागू करेगा A = B, इस निष्कर्ष के साथ कि Aस्ट्रिंग में प्रत्येक अक्षर के बराबर है AAAABBAAAABAAAAB, जबकि Bहर अक्षर के बराबर है BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB

अब, मान लीजिए कि अगला आधार A = B फिर से है । आप पहले गणना करें y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB

अगला, आप इस स्ट्रिंग पर दो बार लूप करते हैं: for v in y: for w in y:...

हाँ। शायद यह एक बहुत ही कुशल कार्यान्वयन नहीं होगा।


अमान्य होने के बाद से मेरा उत्तर "महान" नहीं है, लेकिन यह एक उल्लेखनीय प्रयास था। बहुत बुरा मुझे यह काम करने के लिए नहीं मिला।
mbomb007

1
@ mbomb007 हुह, मुझे यह सुनकर दुख हुआ। (मुझे लगता है कि आपके पास एक शांत दृष्टिकोण था!) ​​जब से आपने "महान" शब्द पर आपत्ति जताई, मैंने "उल्लेखनीय" प्रतिस्थापित किया है। :)
मैथमैटंदन

2

ईएस 6, 128 बाइट्स

पूरी तरह से रूबी संस्करण पर आधारित है।

r=s=>(m=/^[^e]*(.) = (?!\1)(.)/.exec(s))?r(s.replace(RegExp(m[1],'g'),m[2])):'Alex is '+(/(.) = (?!\1)/.test(s)?'wrong':'right')

"इसलिए" से पहले किसी भी गैर-स्व-समानता की तलाश करता है और प्रत्येक बार पुनरावृत्ति को स्ट्रिंग के दौरान चर को बदलता है (यह थोड़ी देर लूप पर बाइट्स बचाता है)।


1

सी, 240 बाइट्स

#define V[v-65]
v[26];char*r[]={"wrong","right"};i=65;j;g(a){return a V^a?g(a V):a;}main(){char b[16];for(;i<91;++i)i V=i;while(gets(b)&&*b<99)b[0]V=b[4]V=b[0]V<b[4]V?b[0]V:b[4]V;while(gets(b))j|=g(*b)^g(b[4]);printf("Alex is %s\n",r[!j]);}

यह निर्धारित पेड़ों में मूल्यों को जोड़कर काम करता है, इसलिए किसी भी समकक्ष मूल्य समान सेट रूट की ओर ले जाते हैं। अस्पष्ट, निहित प्रकार के साथ स्पष्ट किया गया।

// Anything before `V` becomes an index into `v`, offset by -'A'.
#define V [v-65]
int v[26];
char* r[] = {"wrong", "right"};
int i=65;
int j;
// Finds a set identifier for a by recursing until some index points to itself.
int g(int a) {
    return a V ^ a
           ? g(a V)
           : a;
}
int main() {
    char b[16];
    // Initialize all entries to point to themselves.
    for(; i < 91; ++i)
        i V = i;
    // For each premise "A = B", set the entries for A and B to point to the
    // smaller of their current values. This exits after reading "therefore"
    // as 't' > 99.
    while (gets(b) && *b < 99)
        b[0]V = b[4]V = b[0]V < b[4]V
                        ? b[0]V
                        : b[4]V;
    // For each conclusion "A = B", OR j with non-zero if the set identifiers
    // for A and B are different.
    while (gets(b))
        j |= g(*b) ^ g(b[4]);
    printf("Alex is %s\n", r[!j]);
}

180 बाइट्स

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

v[26];*V=v-65;char*r[]={"wrong","right"};i;j;main(){char b[16];for(;i<26;++i)v[i]=i;while(gets(b)&&*b<99)V[b[4]]=V[*b];while(gets(b))j|=V[*b]^V[b[4]];printf("Alex is %s\n",r[!j]);}

एक उदाहरण इनपुट जिसके लिए यह विफल रहता है:

ए = बी
सी = बी
इसलिए
ए = सी


1

05AB1E , 32 बाइट्स

…±º€ˆ „–у©#|€á[ćD.l#`:}\€ËPè«.ª

@Aditsu की CJam जवाब से प्रेरित ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें

स्पष्टीकरण:

…±º€ˆ      # Push dictionary string "alex is "
„–у©      # Push dictionary string "wrong right"
     #     # Split by spaces: ["wrong","right"]
|          # Push all input-lines as list
 ۈ        # Only leave the letters of each line
   [       # Start an infinite loop:
    ć      #  Extract the head of the list; pop and push remainder-list and head separately
     D     #  Duplicate the head
      .l   #  If it's a lowercase string:
        #  #   Stop the infinite loop
    `      #  Push both letters in the string to the stack
     :     #  Replace all these letters in the remainder-list
 }\        # After the infinite loop: discard the duplicated "therefore"
          # For each letter-pair in the remainder list of condition-lines:
    Ë      #  Check if both letters are equal (1 if truhy; 0 if falsey)
   P       # Check if everything was truthy by taking the product
    è      # Use this to index into the earlier ["wrong","right"]-list
     «     # Append it to the "alex is " string
         # Sentence capitalize it
           # (after which the result is output implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों …±º€ˆहै "alex is "और „–у©है "wrong right"


0

bash + awk + SWI-Prolog , 167 बाइट्स

head -n1 <(awk '/therefore/{s=1;next};{if(s)print"?=("$1","$3")";else print};END{print"write(\"Alex is right\");write(\"Alex is wrong\"). halt."}' -|paste -sd ,|swipl)

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

मूल रूप से, यह सिर्फ एक प्रोलॉग उत्तर होने जा रहा था, लेकिन जिन टूल से मैं वास्तव में इनपुट प्रारूप को कुछ उपयोगी में बदल सकता था, वे इतने सीमित थे कि मैंने इसका एक हिस्सा बैश में करने का फैसला किया, भले ही मुझे कोई अनुभव नहीं था मार-काट में कुछ भी करना, और जागते हुए भी कभी नहीं छुआ था। मैंने इस पर 167-बाइट बढ़ने के बाद भी इसे पोस्ट करने के लिए पर्याप्त घंटों का समय व्यतीत किया, सभी राक्षसों पर मुश्किल से घूमा।

अनिवार्य रूप से, awk प्रोग्राम क्या करता है, स्टड से इनपुट लें, इसके साथ लाइन को मिटाएं therefore, A = Bइसके बाद हर जगह बदलें ?=(A,B), और जोड़ें write(\"Alex is right\");write(\"Alex is wrong\"). halt.। फिर, paste -sd ,प्रत्येक नई पंक्ति को बदल देता है , लेकिन अंतिम को अल्पविराम से बदलकर, उसे दो मान्य प्रश्नों में बदलकर SWI-Prolog शेल में बदल दिया जाता है, जो तब मुद्रित परिणाम के साथ एक पंक्ति में विभाजित हो जाते हैं head -n1, जिसके लिए <(...)एक पाइप के बजाय कारणों से परे की आवश्यकता होती है मेरी समझ। यह सब, सिर्फ एक बिलिन का उपयोग करने के लिए !

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.