_{Bu zorluk , genellikle yanlış olan mod Alex'in ruhunu yükseltmektir .}

Temel mantık ve matematik, özellikle de matematiksel denklik konusunda yardıma ihtiyacı olan Alex adında bir arkadaşınız olduğunu varsayalım .

Sana formun denklemlerin bir listesini verir [variable] = [variable]bir [variable]zaman Z ye tek büyük harf A (bir küçük harf, sayı değil, ne başka bir şey) 'dir. Listede her satırda bir denklem var, sadece yazan tek satır dışında therefore.

Mekanizma aşağıdakiler üzerindeki tüm denklemler thereforeolan tesislerinde , gerçek olduğu varsayılır gerçekler. Aşağıdaki tüm denklemler thereforedoğrulanmamış önermeler, Alex'in binadan çıkarmaya çalıştığı gerçekler ve gerçek olabilir veya olmayabilir.

Örneğin, bu denklem listesinde, tek bir sonuç önerisi A = Cdoğru olur:

A = B
B = C
therefore
A = C

Alex'e tekliflerinin hepsinin mantıklı bir şekilde verilen yerlerden uyup uymadığını söylemek senin işin . Bu, Alex'e vardığı sonuçlarda yanlış veya doğru olup olmadığını söylemeniz gerekir.

Açıklandığı gibi yazdıran / döndüren bir denklemler listesine giren bir program / fonksiyon yazın.

Alex is right

Bütün sonuçlar mantıklı bir şekilde binadan takip edilirse ve çıktılar

Alex is wrong

Herhangi bir sonuç, tesislerden mantıklı gelmiyorsa.

Bayt cinsinden en kısa kod kazanır.

Bu davalara dikkat ettiğinizden emin olun:

• Değişken her zaman kendilerine eşittir. Örneğin

  B = A
  therefore
  A = A
  X = X
  

  sonuçlanır Alex is right.

• Bilinmeyen ilişkileri olan değişkenlerin eşit olduğu kabul edilemez. Örneğin

  P = Q
  therefore
  E = R
  

  sonuçlanır Alex is wrong.

• Ondantherefore sonra denklem olmadığı zaman, sonuçlar kesinlikle doğrudur . Örneğin

  D = C
  therefore

  ve

  therefore

  her ikisi de sonuçlanır Alex is right.

• Daha önce hiç denklem olmadığında, thereforesadece öz eşitlik çıkarılabilir. Örneğin

  therefore
  R = R
  

  sonuçlanır Alex is right, ancak

  therefore
  R = W
  

  sonuçlanır Alex is wrong.

Daha fazla örnek

Alex yanlış durumlar: (boş satırlarla ayrılmış)

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 haklı davalar:

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

CJam, 49

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

Histokratın Ruby çözümünden esinlenmiştir. Çevrimiçi olarak deneyin
jimmy23013 :) tarafından silinmiş 3 byte :)

Açıklama:

Her öncül için, program ilk değişkeni metnin geri kalanındaki 2. değişkenle değiştirir. Daha sonra farklı değişkenlerle bir sonuç olup olmadığını kontrol eder.

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

Eski versiyon, 85

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

Bu bir birlik bulma algoritması kullanır. Çevrimiçi deneyin

Ruby, 80 76 + 2 = 78

Komut satırı bayrakları p0ile çalıştırın

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

Açıklama:

Bu saf dize manipülasyon kullanır. p0tam girişi değişkene tek bir dize olarak okur $_. Ardından, /(.) = (?!\1)(.)/X ve Y'nin aynı harf olmadığı ve "X = Y" biçimindeki tüm dizeleri bulduğu ve X ile $ 1 ve Y ile $ 2 arasında atadığı normal ifadeyle sürekli olarak bu dizeyle eşleşiriz. Böyle bir eşleşme bulunduğunda, gsub$1,$2tüm X örneklerini dizedeki Y ile değiştirir. Bu eşleşmenin "bu nedenle" öncesi veya sonrasında gerçekleştiğini de kontrol ederiz.

$`[/e/]

Daha sonra meydana geldi ise, haksız bir iddia ve Alex yanılıyor. Bu tür olayların kullanarak olup olmadığını takip ediyoruz p=. pBir izleme değişkeni olarak kullanılması , döngü bir kez bile hiç vurmazsa işlerin kopmasını önler, çünkü patanmamışsa sıfır döndürür.

Bu yazı itibariyle, CJam çözümü daha uzun. Gurur verici, şüphesiz ani bir an.

Düzenleme: Evet, hızlıca tahttan çıktı. Ayrıca, açıklamayı bitirmek için, pbayrak ile nihai değer $_yürütmenin sonunda çıktıdır, bu nedenle son satır çıktıdır.

CJam, 83 75 68 67 64 bayt

1 byte tasarruf için Dennis teşekkürler.

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

Test odası. Test vakaları kalıcı bir bağlantı için çok uzun, bu yüzden onları sorudan kopyalamanız yeterli. Bunun oldukça yavaş olduğuna dikkat edin - çevrimiçi tercümanda bir veya iki dakika sürer. Neredeyse anında bitireceği ve tek bir test senaryosunun hepsini çözeceği duruma 5*geçerek bunu daha hızlı yapabilirsiniz 2*.

açıklama

(Biraz modası geçmiş.)

Buradaki fikir olası eşitliklerden bir çeşit "sel dolgusu" yapmak ve sonuç listesinden elde ettiğimiz bütün eşitlikleri kaldırmaktır. Sel dolgusunun 5 basamağından daha fazlasına ihtiyaç duymadığımız gösterilebilir, çünkü bunların (eşitsizliklerin ilk grafiğinde) bir mesafeyi kapsayacağı ancak maksimum mesafenin 25 olduğu.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.

R, 183 192 bayt

Cevabımı user2357112 tarafından belirtilen bir sınırlamayı ele almak için değiştirdim. Hala doğru olduğunda Alex'i çağırmak için hala çok küçük bir olasılık var (bu zorluğun içeriğini anlarsam çok sık olmuyor gibi görünüyor). Umarım umursamaz.

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

Bunu biraz çözmem gerekiyor:

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

Örneğin, giriş

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

ilk önce değerlendirecek setup:

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

sonra premises

A = B
B = C

rastgele bir sırada her biri 1000 kez çalıştırılacak. Bu, tüm eşitliklerin yayıldığından ("neredeyse kesin") emin olmak içindir. Son olarak, değerlendirecek propositions:

TRUE & A == B & B == C

Haskell, 208 bayt

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"

Eşitlik Data.Equivalence.Persistentsınıflarını değiştirmek için işlevler sağlayan işi modüle yüklüyorum . Geriye kalan tek şey, doğru golf oynamak için çok uzun isimleri olan giriş ve arama fonksiyonlarını ayrıştırmaktır.

Kullanım örneği:

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

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

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

Dize girişinde, zorluğa göre çalışır.

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

Retina, 90 bayt

Çalıştırmak için, aşağıdaki 12 kod satırını 12 ayrı dosyaya yerleştirin (her bir dosya için ilk sayının ötesindeki +11 bayt). <empty>boş bir dosya belirler; \ndeğişmez bir yeni hat belirler. Alternatif olarak, s'leri olduğu \ngibi tutun, tüm satırları tek bir dosyaya koyun ve -sseçeneği kullanın. Tüm dosyaların Windows'un değil, değişmez satırların kullanıldığından emin olun \r\nve son satırın sonundaki boşluğu not edin.

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

Nasıl çalışır

İlk değiştirme, öncülün lh'leri dosyada daha sonra gerçekleştiğinde girişteki ilk öncül ile eşleşir. Daha sonra meydana geldiği yer öncülün rh ile değiştirilir. +Değiştirici bir daha uymuyor kadar yedek tekrarlanır olmasını sağlar. Bu nedenle, ilk öncül ise A = B, Adosyadaki sonraki tüm s'ler s'ye dönüştürülür B.

İkinci değişiklik, ilk önceliği girdiden kaldırıyor, çünkü şimdi işimiz bitti. Daha sonra )değiştirici ilk değiştirmeye geri döner ve döngü boyunca bir bütün geçişte hiçbir değişiklik olmadıkça tekrar eder. Bu, tüm mülkler değiştirilip çıkarıldığında ve girişle başladığında olur therefore.

Üçüncü değiştirme, girişin ilk satırıyla (yani therefore) veya formdaki herhangi bir şeyle eşleşir A = Ave siler. Eğer bütün önermeler mülkler tarafından destekleniyorsa, hepsi bu formla eşleşecektir, bu yüzden geriye kalanlar yalnızca yeni satırlardan oluşmalıdır. Dördüncü değişiklik bunu değiştirir right. Aksi takdirde, beşinci değişiklik kalan her şeyi ( silindiğinden rberi içermeyen therefore) olarak değiştirir wrong. Son olarak, en son değişiklik Alex is başlangıçta eklenir .

Python 2,264 bayt

Mbomb007 tarafından zaten dikkate değer bir Python 3 cevabı var . Bu cevap, ondan açık bir şekilde çalıyor (özellikle "Alex, wrriognhgt" numarasıdır).

Ve bu cevap da bundan çok daha uzun.

Her neyse, bu cevaptaki fikir, anahtarların 26 büyük harfli karakter olduğu anahtar değer çiftlerinin sözlüğünü sürdürmektir ve her bir tuşun karşılık gelen değeri, tuşa eşdeğer harf kümesidir. (26 harfin tümü eşdeğer olsaydı, her tuşun karşılık gelen değeri için 26 harflik bir kümesi olurdu.)

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]

(Baytları kurtarmak için bu yanıt Python 2'de yasal olan boşlukları ve sekmeleri karıştırır .)

Bu kod gerçekten oldukça etkilidir, çünkü sözlük giriş satırlarının sayısına bağlı olmayan maksimum olası bir boyutla (yukarıda tanımlandığı gibi 26 ile 26) sınırlıdır.

Şimdi, bu çözüme devam ederken, sözlük değerleri için kümeler yerine dizeleri kullanarak dört bayttan tasarruf edebileceğimi farkettim.

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

ile

d={C:C for C in map(

Tabii ki daha sonra (NOT: BU YAPMAYIN) set birlikteliğinin üç örneğini |string bitiştirmeyle +değiştirmeniz gerekir, ancak bu kod uzunluğunu değiştirmez. Sonuçta, her şeyin hala aynı şekilde çalışması gerekir, çünkü setlerde yaptığınız gibi kopyaları ortadan kaldırmaz (dizgenin sonuna eklemeye devam eder). Tamam Sesler - biraz daha az verimli, emin, ancak 264 yerine 260 bayt.

Peki, bu çıkıyor 260 bayt versiyonu o kadar verimsizdir bir neden olduğunu MemoryErrorben bunu test edildiğinde

A = B
A = B
therefore
B = A

Bu benim için şaşırtıcıydı. 260 baytlık "string bitiştirme" versiyonunu araştıralım!

Tabi ki anahtar-değer çiftleriyle başlayacak A:Ave B:B(farketmeyen 24 kişi). d[A]Anahtarın karşılığı olan sözlük değerini yazacağız A, yani başlangıçta sahip olacaktık d[A] = A. Şimdi, öncül verildiğinde, A = Bdeğerleri birleştirerek d[A]=Ave d[B]=Belde ederek başlayacaktır y = AB. Sonra bu dizgiye iki kez dönecekti: for v in AB: for w in AB:...

Yani, döngü boyunca ilk kez, biz v=Ave w=A. Aşağıdaki sözlükler sırasına göre uygulamak d[v] += d[w]ve d[w] += d[v]sonuçları:

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

Sonra, v=Ave ile w=B:

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

Sıradaki 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])

Ve 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])

Adımların yukarıda sırası tek önermeyi gerçekleştireceği A = Bsonuçla, Adizede Her mektubunda eşittir AAAABBAAAABAAAABederken, Bher harfin eşittir BAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Şimdi, bir sonraki öncülün A = B tekrar olduğunu varsayalım . İlk önce sen hesapla y = d[A] + d[B] = AAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAABBAAAABAAAAB.

Sonra, bu dizginin üzerine iki kere dönersiniz: for v in y: for w in y:...

Evet. Belki bu çok verimli bir uygulama olmaz.

ES6, 128 bayt

Gevşekçe Ruby versiyonuna göre.

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

“Dolayısıyla” ndan önce öz eşitlik bulunmadığına bakar ve her seferinde dizedeki değişkeni tekrarlı olarak değiştirir (bu, bir süre döngüsünde bayt tasarrufu sağlar).

C, 240 bayt

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

Bu, değerleri küme ağaçlarında birleştirerek çalışır, böylece eşdeğer değerler aynı kümeye neden olur. Ungolfed, üstü kapalı tiplerle açıkça belirtilmiştir.

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

Bu kısa versiyon OP’deki tüm durumlar için işe yarar, ancak diğer bazı girdiler için hatalı Alex’in yanlış olduğunu iddia eder. Benzer bir yaklaşım kullanır, ancak her öncül için ikinci girişi ilk girişin geçerli değerine ayarlar. Karşılaştırma yaparken, bir ağaç aramak yerine sadece kesin değerlere bakar.

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

Bunun başarısız olduğu bir örnek giriş:

A = B
C = B
bu nedenle
A = C

05AB1E , 32 bayt

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

Esinlenerek @aditsu 'ın CJam cevap .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

Benim bu 05AB1E ucu bakın (bölüm nasıl sözlüğü kullanılır? ) Anlamak için …±º€ˆise "alex is "ve „–у©olup "wrong right".

bash + awk + SWI-Prolog , 167 bayt

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)

Çevrimiçi deneyin!

Aslında, bu sadece bir Prolog cevabı olacaktı, ancak giriş biçimini kullanılabilir bir şeye dönüştürmek için bulabildiğim araçlar, bir kısmı tecrübesiz bir deneyimim olsa bile, bu kısmını bash içerisinde yapmaya karar verdiğimde sınırlıydı. bash bir şey yapmak ve asla awk dokunmamış bile. Bu 167-byte'lık büyüdükten sonra bile tüm canavarlarda zorlukla golf oynayabilmek için yeterli saat harcadım.

Esasen, awk programının yaptığı şey stdin'den girdi almak, çizgiyi silmek, sonrasının thereforeyerini almak ve eklemek . Daha sonra her yeni satırı değiştirir , ancak sonuncusunu virgül ile değiştirir, onu geçerli bir iki sorguya dönüştürür, sonra SWI-Prolog kabuğuna dönüştürür, bu da yazdırılan sonuç bir boru hattının kesilmesinden sonra bir boruya ihtiyaç duyulmasını gerektirir . Benim anlayışım Bütün bunlar, sadece bir yerleşik kullanmak için !A = B?=(A,B)write(\"Alex is right\");write(\"Alex is wrong\"). halt.paste -sd ,head -n1<(...)