Alex đôi khi đúng


50

Thử thách này là để nâng đỡ tinh thần của mod Alex A. của chúng tôi , người thường sai .


Giả sử bạn có một người bạn tên Alex, người cần sự giúp đỡ về logic và toán học cơ bản, cụ thể là tương đương toán học .

Anh ta đưa cho bạn một danh sách các phương trình có dạng [variable] = [variable]trong đó a [variable]luôn luôn là một chữ cái viết hoa từ A đến Z (không phải chữ thường, không phải số, cũng không phải thứ gì khác). Có một phương trình cho mỗi dòng trong danh sách ngoại trừ một dòng duy nhất chỉ nói therefore.

Tất cả các phương trình trên thereforecơ sở , sự kiện được coi là đúng. Tất cả các phương trình dưới đây thereforelà các đề xuất chưa được xác minh, các sự kiện mà Alex đang cố gắng suy ra từ các cơ sở, và chúng có thể hoặc không thể đúng.

Ví dụ, trong phương trình này liệt kê các mệnh đề kết luận duy nhất A = Cxảy ra là đúng:

A = B
B = C
therefore
A = C

Đó là công việc của bạn để nói với Alex nếu tất cả các đề xuất của anh ấy tuân theo logic từ các cơ sở nhất định. Đó là, bạn cần nói với Alex nếu anh ta sai hoặc đúng trong kết luận của mình.

Viết chương trình / hàm lấy một chuỗi danh sách các phương trình như được mô tả và in / trả về

Alex is right

nếu tất cả các kết luận tuân theo logic từ các cơ sở, và nếu không thì kết quả đầu ra

Alex is wrong

nếu bất kỳ kết luận nào không hợp lý theo sau các cơ sở.

Mã ngắn nhất tính bằng byte thắng.

Hãy chắc chắn để ý những trường hợp này:

  • Biến luôn luôn bằng chính họ. ví dụ

    B = A
    therefore
    A = A
    X = X
    

    kết quả trong Alex is right.

  • Các biến có mối quan hệ không xác định không thể được coi là bằng nhau. ví dụ

    P = Q
    therefore
    E = R
    

    kết quả trong Alex is wrong.

  • Khi không có phương trình sau therefoređó thì kết luận là không đúng sự thật . ví dụ

    D = C
    therefore

    therefore

    cả hai kết quả trong Alex is right.

  • Khi không có phương trình nào trước therefoređó thì chỉ có thể tự suy ra. ví dụ

    therefore
    R = R
    

    kết quả Alex is right, nhưng

    therefore
    R = W
    

    kết quả trong Alex is wrong.

Thêm ví dụ

Alex là trường hợp sai: (cách nhau bởi các dòng trống)

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

Alex là trường hợp đúng:

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 byte Alex is wrongXác minh tất cả các trường hợp thử nghiệm.
Dennis

19
Này, đôi khi tốt hơn là không bao giờ. ¯ \ _ (ツ) _ / ¯
Alex A.


7
therefore\nTABS < SPACES->Alex is right
Doorknob

7
Thích nhìn thấy một giải pháp trong prolog.
azz

Câu trả lời:


18

CJam, 49

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

Lấy cảm hứng từ giải pháp Ruby của histocrat. Dùng thử trực tuyến
3 byte bị xóa sạch nhờ jimmy23013 :)

Giải trình:

Đối với mỗi tiền đề, chương trình thay thế biến đầu tiên bằng biến thứ 2 trong phần còn lại của văn bản. Sau đó nó kiểm tra xem có kết luận nào với các biến khác nhau không.

"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"

Phiên bản cũ, 85

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

Điều này sử dụng một thuật toán tìm liên minh. Dùng thử trực tuyến


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

1
Tôi chỉ đọc dòng cuối cùng là 'Điều này sử dụng thuật toán kỳ lân ' Tìm kiếm '? xD
1

Alex is * wrong * right * ?
Charlie

32

Hồng ngọc, 80 76 + 2 = 78

Với cờ dòng lệnh p0, chạy

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

Giải trình:

Điều này sử dụng thao tác chuỗi thuần túy. p0đọc đầu vào đầy đủ dưới dạng một chuỗi vào biến $_. Sau đó, chúng tôi liên tục khớp chuỗi đó với biểu thức chính quy /(.) = (?!\1)(.)/, tìm thấy tất cả các chuỗi có dạng "X = Y" trong đó X và Y không cùng một chữ cái và gán X cho $ 1 và Y thành $ 2. Khi tìm thấy kết quả khớp như vậy, gsub$1,$2thay thế tất cả các phiên bản của X bằng Y trong chuỗi. Chúng tôi cũng kiểm tra xem trận đấu này xảy ra trước hay sau "do đó" với

$`[/e/]

Nếu nó xảy ra sau đó, đó là một yêu cầu vô lý và Alex đã sai. Chúng tôi theo dõi xem có bất kỳ sự cố như vậy đã xảy ra bằng cách sử dụng p=. Việc sử dụng pnhư một biến theo dõi sẽ ngăn mọi thứ phá vỡ nếu vòng lặp không bao giờ chạm đến dù chỉ một lần, vì pnó sẽ không trở lại nếu nó không bao giờ được gán.

Khi đăng bài này, giải pháp CJam dài hơn. Một niềm tự hào, nếu không có nghi ngờ thoáng qua.

Chỉnh sửa: Yup, nhanh chóng bị truất ngôi. Ngoài ra, để kết thúc phần giải thích, với pcờ, giá trị cuối cùng $_là đầu ra ở cuối thực thi, vì vậy dòng cuối cùng là đầu ra.


15
Những khoảnh khắc ngọt ngào nhất là những khoảnh khắc trước khi giải pháp của một người bị tàn sát bởi một esolang.
Alex A.

Việc lạm dụng String#formatđể nhận cả lệnh gọi và gán gsub vào một biểu thức là một ý tưởng khá gọn gàng, +1!
Ventero

12

CJam, 83 75 68 67 64 byte

Cảm ơn Dennis vì đã tiết kiệm 1 byte.

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

Bộ thử nghiệm. Các trường hợp kiểm tra quá dài cho một permalink, vì vậy chỉ cần sao chép chúng từ câu hỏi. Lưu ý rằng điều này khá chậm - phải mất một hoặc hai phút trong trình thông dịch trực tuyến. Bạn có thể làm cho nó nhanh hơn nhiều bằng cách thay đổi 5*để 2*trong trường hợp này nó sẽ kết thúc gần như ngay lập tức và giải quyết tất cả nhưng có một trường hợp thử nghiệm.

Giải trình

(Hơi lỗi thời.)

Ý tưởng là thực hiện một loại "lấp đầy" các công bằng có thể và sau đó loại bỏ tất cả các công bằng chúng ta thu được từ danh sách kết luận. Có thể thấy rằng chúng ta cần không quá 5 bước để lấp lũ, bởi vì những bước đó sẽ bao phủ một khoảng cách (trong biểu đồ bất bình đẳng ban đầu) của nhưng khoảng cách tối đa là 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.

Xây dựng các đóng cửa bắc cầu, eh? Tôi không quen thuộc với CJam, nhưng có vẻ như thế hệ thứ 5 chỉ có thể được tạo theo một hướng. Nếu có, bạn cần thêm một lần lặp để đảo ngược các đẳng thức đó.
user2357112

@ user2357112 Tôi tin rằng chúng nên được tạo theo cả hai hướng, bởi vì bước đầu tiên thêm tất cả các đảo ngược của đầu vào (hoặc trong phiên bản được đánh gôn thêm, tôi sắp xếp tất cả các tiền đề và kết luận bắt đầu bằng).
Martin Ender

Tuy nhiên, khi bạn có sự khác biệt đối xứng, bạn có nhận được các cạnh theo cả hai hướng không? (Hoặc, trong phiên bản chơi gôn xa hơn, sự khác biệt đối xứng có tạo ra các cạnh theo hướng cần thiết không?)
user2357112

@ user2357112 Vì tôi đang xử lý toàn bộ sản phẩm của Cartesian, tôi sẽ nhận được từng cặp cân bằng trong cả hai thứ tự, điều này sẽ dẫn đến cả hai thứ tự của kết luận rút ra (Lý do duy nhất tôi cần đảo ngược rõ ràng hoặc sắp xếp đầu vào ban đầu là rằng các cơ sở ban đầu không nhất thiết phải được tạo ra trong quy trình này, vì vậy chúng không bị đảo ngược bằng cách lấy sự khác biệt đã đặt của sản phẩm Cartesian).
Martin Ender

6

R, 183 192 byte

Tôi đã sửa đổi câu trả lời của mình để giải quyết một giới hạn được chỉ ra bởi user2357112. Vẫn còn một xác suất cực kỳ nhỏ để gọi Alex ra ngoài khi anh ấy thực sự đúng (điều này dường như không xảy ra rất thường xuyên nếu tôi hiểu bối cảnh của thử thách :-). Tôi hy vọng anh ấy sẽ không phiền.

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

Tôi cần phải giải golf này một chút:

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

Ví dụ: nếu đầu vào là

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

đầu tiên nó sẽ đánh giá setup:

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

sau đó premises

A = B
B = C

sẽ được chạy 1.000 lần mỗi thứ tự ngẫu nhiên. Điều này là để đảm bảo ("gần như chắc chắn") rằng tất cả các đẳng thức được truyền bá. Cuối cùng, nó sẽ đánh giá propositions:

TRUE & A == B & B == C

3
Nếu các tiền đề là A = B, B = C, C = A, các giá trị chỉ xoay quanh mãi mãi. 26 vòng đánh giá là không đủ.
user2357112

Logic thất bại của tôi ... Cảm ơn ví dụ, tôi sẽ phải làm việc khác sau đó.
flodel

Tôi nghĩ đã sửa nó, hoặc gần như ...!
flodel

5

Haskell, 208 byte

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"

Tôi đang giảm tải công việc cho Data.Equivalence.Persistentmô-đun, cung cấp các hàm để thao tác các lớp tương đương. Tất cả còn lại phải làm là phân tích cú pháp các chức năng gọi và nhập mà đôi khi có tên quá dài để chơi golf đúng cách.

Ví dụ sử dụng:

*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

Toán học, 182

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"]

Hoạt động trên đầu vào chuỗi, theo thách thức.

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

Bạn có thể mất 8 byte bằng cách khai báo flà một hàm thuần túy, thay thế Simplify[#2,#1]bằng #2~Simplify~#và thay thế StringSplit[s,"\n"]bằng #~StringSplit~"<actual newline>".
LegionMammal978

Điểm tốt! Ngoài ra q=StringSplit;và sau đó s / StringSplit / q / cho 6 byte khác được lưu. Nhưng cuối cùng, đây không phải là một thử thách tốt cho Mathicala mà tôi sợ, mặc dù nhân vật logic có vẻ phù hợp hoàn hảo.

Ngoài ra, a___b___có lẽ có thể được thay đổi thành a__b__, và s=Symbol;.
LegionMammal978

a__b__sẽ không làm việc nếu cơ sở, mệnh đề hoặc cả hai đều có sản phẩm nào dù

3

Võng mạc, 90 byte

Để chạy, đặt 12 dòng mã sau vào 12 tệp riêng biệt (+11 byte được tính cho mỗi tệp ngoài tệp đầu tiên). <empty>chỉ định một tập tin trống; \nchỉ định một dòng mới. Thay phiên, giữ nguyên \ns, đặt tất cả các dòng trong một tệp và sử dụng -stùy chọn. Đảm bảo rằng tất cả các tệp sử dụng dòng mới theo nghĩa đen, không phải Windows \r\nvà lưu ý khoảng trống ở cuối dòng cuối cùng.

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

Làm thế nào nó hoạt động

Sự thay thế đầu tiên phù hợp với tiền đề đầu tiên trong đầu vào, bất cứ khi nào lhs của tiền đề xảy ra sau đó trong tệp. Nó thay thế sự xuất hiện sau đó với rhs của tiền đề. Công cụ +sửa đổi đảm bảo rằng sự thay thế được lặp lại cho đến khi nó không khớp nữa. Do đó, nếu tiền đề đầu tiên là A = B, tất cả các As tiếp theo trong tệp sẽ được chuyển thành Bs.

Sự thay thế thứ hai loại bỏ tiền đề đầu tiên khỏi đầu vào, vì chúng ta đã hoàn thành nó ngay bây giờ. Sau đó, bộ )sửa đổi lặp lại lần thay thế đầu tiên và lặp lại cho đến khi không có thay đổi nào trong toàn bộ thông qua vòng lặp. Điều này xảy ra khi tất cả các tiền đề đã được thay thế và loại bỏ, và đầu vào bắt đầu bằng therefore.

Sự thay thế thứ ba phù hợp với dòng đầu vào đầu tiên (đó là therefore) hoặc bất cứ thứ gì có trong mẫu A = Avà xóa nó. Nếu tất cả các đề xuất được hỗ trợ bởi các cơ sở, tất cả các đề xuất sẽ phù hợp với hình thức này, vì vậy những gì còn lại chỉ nên bao gồm các dòng mới. Sự thay thế thứ tư thay đổi điều này thành right. Mặt khác, thay thế thứ năm thay đổi mọi thứ còn lại (không chứa rkể từ khi thereforebị xóa) thành wrong. Cuối cùng, sự thay thế cuối cùng thêm Alex is vào lúc bắt đầu.


3

Python 2, 264 byte

Đã có một câu trả lời Python 3 đáng chú ý của mbomb007 . Câu trả lời này đánh cắp một cách trắng trợn từ câu hỏi đó (cụ thể là thủ thuật "Alex is wrriognhgt").

Và câu trả lời này cũng dài hơn đáng kể so với ...

Dù sao, ý tưởng trong câu trả lời này là duy trì một từ điển các cặp khóa-giá trị, trong đó các khóa là 26 ký tự viết hoa và mỗi giá trị tương ứng của mỗi khóa là tập hợp các chữ cái tương đương với khóa. (Nếu tất cả 26 chữ cái là tương đương, thì mỗi khóa sẽ có một bộ 26 chữ cái cho giá trị tương ứng của nó.)

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]

(Để lưu byte, câu trả lời này trộn các khoảng trắng và tab , là hợp pháp trong Python 2.)

Mã này thực sự khá hiệu quả, vì từ điển được giới hạn ở kích thước tối đa có thể (26 x 26 như mô tả ở trên), điều này không phụ thuộc vào số lượng dòng đầu vào.

Bây giờ, khi tôi đang chơi giải pháp này, tôi nhận ra rằng tôi có thể tiết kiệm bốn byte bằng cách sử dụng các chuỗi thay vì các bộ cho các giá trị từ điển, bằng cách thay thế

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

với

d={C:C for C in map(

Tất nhiên sau đó, bạn cũng phải thay thế (LƯU Ý: KHÔNG LÀM NÀY) ba trường hợp của hoạt động hợp nhất được thiết lập |bằng nối chuỗi +, nhưng điều đó không thay đổi độ dài mã. Kết quả là mọi thứ vẫn hoạt động như nhau, ngoại trừ việc nó sẽ không loại bỏ các bản sao giống như bạn làm với các bộ (nó sẽ chỉ tiếp tục thêm vào cuối chuỗi). Âm thanh OK - ít hiệu quả hơn, chắc chắn, nhưng 260 byte thay vì 264.

Chà, hóa ra là phiên bản 260 byte kém hiệu quả đến mức nó gây ra MemoryErrorkhi tôi thử nghiệm nó với

A = B
A = B
therefore
B = A

Điều này là đáng ngạc nhiên đối với tôi. Chúng ta hãy điều tra phiên bản "nối chuỗi" 260 byte!

Tất nhiên, nó sẽ bắt đầu với các cặp khóa-giá trị A:AB:B(cộng với 24 cặp khác không quan trọng). Chúng tôi sẽ viết d[A]để có nghĩa là giá trị từ điển tương ứng với khóa A, vì vậy, lúc đầu chúng tôi sẽ có d[A] = A. Bây giờ, với tiền đề A = B, nó sẽ bắt đầu bằng cách nối các giá trị d[A]=Ad[B]=Bnhận được y = AB. Sau đó, nó sẽ lặp lại chuỗi này hai lần: for v in AB: for w in AB:...

Vì vậy, lần đầu tiên thông qua các vòng lặp, chúng tôi có v=Aw=A. Áp dụng d[v] += d[w]d[w] += d[v]kết quả trong chuỗi từ điển sau đây:

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

Tiếp theo, với v=Aw=B:

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

Tiếp theo 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])

Trình tự các bước trên sẽ thực hiện tiền đề duy nhất A = B, với kết luận Abằng với mỗi chữ cái trong chuỗi AAAABBAAAABAAAAB, trong khi Bbằng với mỗi chữ cái trong BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Bây giờ, giả sử rằng tiền đề tiếp theo là A = B một lần nữa . Bạn tính toán trước y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Tiếp theo, bạn lặp lại chuỗi này hai lần: for v in y: for w in y:...

Vâng. Có lẽ đó sẽ không phải là một triển khai rất hiệu quả.


Câu trả lời của tôi không "tuyệt vời" vì nó không hợp lệ, nhưng đó là một nỗ lực đáng chú ý. Quá tệ, tôi không thể làm cho nó hoạt động.
mbomb007

1
@ mbomb007 Huh, tôi rất tiếc khi nghe điều đó. (Tôi đã nghĩ rằng bạn có một cách tiếp cận tuyệt vời!) Vì bạn đã phản đối từ "tuyệt vời", tôi đã thay thế "đáng chú ý". :)
toán học

2

ES6, 128 byte

Dựa trên phiên bản Ruby.

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

Tìm kiếm bất kỳ sự không tự bình đẳng nào trước "do đó" và thường xuyên thay thế biến trong suốt chuỗi (điều này giúp tiết kiệm byte trong một vòng lặp while).


1

C, 240 byte

#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]);}

Điều này hoạt động bằng cách kết hợp các giá trị thành các cây được đặt, do đó, bất kỳ giá trị tương đương nào cũng dẫn đến cùng một bộ gốc. Ungolfed, với các loại ngầm định được thực hiện rõ ràng.

// 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 byte

Phiên bản ngắn hơn này hoạt động cho tất cả các trường hợp từ OP, nhưng đối với một số đầu vào khác, tuyên bố không chính xác Alex là sai. Nó sử dụng một cách tiếp cận tương tự, nhưng đối với mỗi tiền đề chỉ cần đặt mục nhập thứ hai thành giá trị hiện tại của mục nhập đầu tiên. Khi so sánh, nó chỉ nhìn vào các giá trị chính xác thay vì tìm kiếm một cái cây.

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

Một ví dụ đầu vào mà điều này không thành công:

A = B
C = B
do đó
A = C


1

05AB1E , 32 byte

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

Lấy cảm hứng từ @aditsu 's CJam câu trả lời .

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

…±º€ˆ      # 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)

Xem mẹo 05AB1E này của tôi (phần Làm thế nào để sử dụng từ điển? ) Để hiểu tại sao …±º€ˆ"alex is "„–у©"wrong right".


0

bash + awk + SWI-Prolog , 167 byte

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)

Hãy thử trực tuyến!

Ban đầu, đây chỉ là một câu trả lời của Prolog, nhưng các công cụ tôi có thể tìm thấy để thực sự chuyển đổi định dạng đầu vào thành một thứ có thể sử dụng được đủ hạn chế đến mức tôi quyết định thực hiện phần đó trong bash, mặc dù tôi không có kinh nghiệm làm bất cứ điều gì trong bash, và thậm chí chưa bao giờ chạm vào awk. Cuối cùng tôi đã dành đủ thời gian cho nó để muốn đăng nó ngay cả sau khi nó phát triển thành 167 byte, hầu như không chơi golf với tất cả các con quái vật.

Về cơ bản, những gì chương trình awk làm là lấy đầu vào từ stdin, xóa dòng bằng therefore, thay thế mọi thứ A = Bsau nó bằng ?=(A,B)và nối thêm write(\"Alex is right\");write(\"Alex is wrong\"). halt.. Sau đó, paste -sd ,thay thế mọi dòng mới nhưng cuối cùng bằng dấu phẩy, chuyển đổi nó thành hai truy vấn hợp lệ sang trình bao SWI-Prolog, sau đó được chạy với kết quả được in bị cắt thành một dòng head -n1, yêu cầu <(...)thay vì một đường ống vì lý do vượt quá sự hiểu biết của tôi. Tất cả điều này, chỉ để sử dụng một nội dung !

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.