অ্যালেক্স মাঝে মাঝে ঠিক থাকে


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
পিএইচপি, 13 বাইট Alex is wrongসমস্ত পরীক্ষার কেস যাচাই করে।
ডেনিস

19
আরে, কখনও কখনও কখনও কখনও চেয়ে ভাল। ¯ \ _ (ツ) _ / ¯
অ্যালেক্স এ।


7
therefore\nTABS < SPACES->Alex is right
ডোরকনব্ব

7
প্রলগে একটি সমাধান দেখতে ভালোবাসি।
Azz

উত্তর:


18

সিজেম, 49

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

হিস্টোক্র্যাট এর রুবি সমাধান থেকে অনুপ্রাণিত। জিমি 23013 এর জন্য 3 বাইট বিলোপযুক্ত ধন্যবাদ এটি অনলাইনে চেষ্টা করুন
:)

ব্যাখ্যা:

প্রতিটি অনুমানের জন্য, প্রোগ্রামটি প্রথম পাঠ্যটির বাকী অংশে দ্বিতীয় ভেরিয়েবলের সাথে প্রতিস্থাপন করে। এটি তখন বিভিন্ন ভেরিয়েবলের সাথে কোনও উপসংহার আছে কিনা তা পরীক্ষা করে।

"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
আমি কেবল এই শেষ পংক্তিটি পড়লাম 'এটি একটি ইউনিকর্ন- ফাইন্ড অ্যালগরিদম ব্যবহার করে' ... ওয়েটওয়ট? এক্সডি
জানুয়ারি

Alex is * wrong * right * ?
চার্লি 20

32

রুবি, 80 76 + 2 = 78

কমান্ড-লাইন পতাকা সহ p0, চালান

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

ব্যাখ্যা:

এটি খাঁটি স্ট্রিং ম্যানিপুলেশন ব্যবহার করে। p0ভেরিয়েবলের মধ্যে একক স্ট্রিং হিসাবে সম্পূর্ণ ইনপুটটি পড়ে $_। তারপরে, আমরা বারবার সেই স্ট্রিংটিকে নিয়মিত অভিব্যক্তির বিপরীতে মেলে /(.) = (?!\1)(.)/যা "X = Y" ফর্মের সমস্ত স্ট্রিং খুঁজে পায় যেখানে এক্স এবং ওয়াই একই অক্ষর নয়, এবং এক্সকে $ 1 এবং Y কে $ 2 নির্ধারণ করে। যখন এই জাতীয় ম্যাচটি পাওয়া যায়, gsub$1,$2এক্স এর সমস্ত দৃষ্টান্ত স্ট্রিংয়ের সাথে ওয়াইয়ের সাথে প্রতিস্থাপন করে। এই মিলটি "অতএব" এর আগে বা পরে ঘটেছিল কিনা তাও আমরা পরীক্ষা করে দেখি

$`[/e/]

যদি এটি পরে ঘটে থাকে তবে এটি একটি অযৌক্তিক দাবি এবং অ্যালেক্স ভুল। ব্যবহার করে এ জাতীয় কোনও ঘটনা ঘটেছে কিনা তা আমরা ট্র্যাক করি p=pট্র্যাকিং ভেরিয়েবল হিসাবে ব্যবহার pলুপগুলি একবারে কখনও আঘাত না করে যদি জিনিসগুলি ভাঙ্গা থেকে বাধা দেয়, যেহেতু এটি কখনই বরাদ্দ করা হয়নি তা শূন্য হবে।

এই পোস্ট হিসাবে, সিজেএম সমাধান দীর্ঘ। একটি গর্বিত, সন্দেহ নেই ক্ষণস্থায়ী মুহূর্ত।

সম্পাদনা: হ্যাঁ, দ্রুত দমন করা। এছাড়াও, ব্যাখ্যার সাথে সমাপ্তির জন্য, pপতাকাটির সাথে চূড়ান্ত মান $_নির্বাহের শেষে আউটপুট হয়, তাই শেষ লাইনটি আউটপুট হয়।


15
মধুরতম মুহুর্তগুলি সেগুলির সমাধানের আগে একটি ইশোলং দ্বারা জবাই করা।
অ্যালেক্স এ।

String#formatGsub কল এবং অ্যাসাইনমেন্ট উভয়কেই একটি অভিব্যক্তিতে পাওয়ার অপব্যবহার একটি সুন্দর ঝরঝরে ধারণা, +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.

ট্রানজিটিভ ক্লোজার তৈরি করছে, তাই না? আমি সিজেমের সাথে পরিচিত নই, তবে দেখে মনে হচ্ছে যে ৫ ম প্রজন্মের সমতা কেবলমাত্র এক দিকে তৈরি হতে পারে। যদি সেগুলি হয় তবে সেই সমতাগুলি বিপরীত করতে আপনার আরও একটি পুনরাবৃত্তি প্রয়োজন।
ব্যবহারকারী 2357112

@ ব্যবহারকারী 2357112 আমি বিশ্বাস করি যে এগুলি উভয় দিকেই উত্পন্ন করা উচিত, কারণ প্রথম পদক্ষেপে ইনপুটটির সমস্ত বিপরীত যুক্ত হয় (বা যে সংস্করণটি আরও গল্ফ করা হয়েছে তাতে আমি সমস্ত ভিত্তি এবং উপসংহারের সমতাগুলি শুরু করে দিয়েছি)।
মার্টিন ইন্ডার

আপনি যখন প্রতিসাম্যগত পার্থক্যগুলি গ্রহণ করেন, তবে কি আপনি উভয় দিকেই প্রান্তগুলি পান? (অথবা, আরও গল্ফযুক্ত সংস্করণে, প্রতিসম পার্থক্যগুলি প্রয়োজনীয় দিকের প্রান্তগুলি তৈরি করে?)
ব্যবহারকারী 2357112

@ ব্যবহারকারী 2357112 যেহেতু আমি সম্পূর্ণ কার্টেসিয়ান পণ্যটি প্রক্রিয়া করছি, তাই আমি উভয় ক্রমে প্রতিটি জুটি পাব, যার ফলে টানা সমাপ্তির উভয় ক্রম হবে (আমার স্পষ্টভাবে বিপরীত হওয়া বা প্রাথমিক ইনপুটটি বাছাই করার একমাত্র কারণটি হ'ল) মূল প্রক্রিয়াটি এই প্রক্রিয়াটিতে অগত্যা উত্পন্ন হয় না, সুতরাং কার্টেসিয়ান পণ্যটির নির্ধারিত পার্থক্য গ্রহণ করে তারা বিপরীত হয় না)।
মার্টিন ইন্ডার

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

এলোমেলো ক্রমানুসারে প্রতি এক হাজার বার চালানো হবে। এটি নিশ্চিত করা ("প্রায় নিশ্চিত") যে সমস্ত সমতা প্রচারিত। শেষ পর্যন্ত, এটি মূল্যায়ন করবে propositions:

TRUE & A == B & B == C

3
যদি প্রাঙ্গণটি হয় A = B, B = C, C = A, মানগুলি চিরকাল চারিদিকে চক্কর দেয়। 26 টি রাউন্ড মূল্যায়ন যথেষ্ট নয়।
ব্যবহারকারী 2357112

আমার ব্যর্থ যুক্তি ... উদাহরণস্বরূপ ধন্যবাদ, আমাকে তখন অন্য কিছু কাজ করতে হবে।
ফ্লোডেল

আমার মনে হয় এটা ঠিক করে দিয়েছে, নাকি প্রায় ...!
ফ্লোডেল

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

গণিত, 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"]

চ্যালেঞ্জ অনুযায়ী স্ট্রিং ইনপুট নিয়ে কাজ করে।

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

ভাল দিক! এছাড়াও q=StringSplit;এবং তারপরে আর / স্ট্রিংস্প্লিট / কিউ / আরও 6 বাইট বা তার বেশি সংরক্ষণের জন্য। তবে শেষ পর্যন্ত, ম্যাথামেটিকাকে আমি ভয় পাচ্ছি এমন পক্ষে এটি চ্যালেঞ্জ নয়, যদিও যুক্তি চরিত্রটি একেবারে উপযুক্ত বলে মনে হয়েছিল।

এছাড়াও, a___এবং b___সম্ভবত থেকে পরিবর্তন করা যাবে a__এবং b__আর s=Symbol;
LegionMammal978

a__এবং b__প্রাঙ্গনে, প্রস্তাবগুলি বা উভয়ই ফাঁকা থাকলে কাজ করবে না

3

রেটিনা, 90 বাইট

চালানোর জন্য, 12 টি পৃথক ফাইলগুলিতে নিম্নলিখিত 12 টি লাইন কোড দিন (প্রথমটির বাইরে প্রতিটি ফাইলের জন্য গণনা করা +11 বাইট)। <empty>একটি খালি ফাইল ডিজাইন করে; \nএকটি আক্ষরিক নিউলাইন ডিজাইন করে। পর্যায়ক্রমে, \nগুলি যেমন হয় তেমন রাখুন, সমস্ত লাইন একক ফাইলে রাখুন এবং -sবিকল্পটি ব্যবহার করুন । নিশ্চিত হয়ে নিন যে সমস্ত ফাইল উইন্ডোজ নয়, আক্ষরিক নিউলাইনগুলি ব্যবহার করে \r\nএবং শেষ লাইনের শেষে স্থানটি নোট করে।

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

কিভাবে এটা কাজ করে

প্রথম প্রতিস্থাপন ইনপুটটিতে প্রথম ভিত্তির সাথে মেলে, যখনই ফাইলে পরে lime এর lhs ঘটে। এটি প্রতিস্থাপনের আরএইচএসের সাথে পরবর্তী ঘটনাটি প্রতিস্থাপন করে। +পরিবর্তক নিশ্চিত করে যে প্রতিস্থাপন পর্যন্ত এটি কোনো সাথে মেলে না পুনরাবৃত্তি করা হয়। সুতরাং, যদি প্রথম অনুমান হয় তবে ফাইলের A = Bপরবর্তী সমস্ত Aগুলি এস-এ রূপান্তরিত হয় B

দ্বিতীয় প্রতিস্থাপনটি ইনপুট থেকে প্রথম ভিত্তি সরিয়ে দেয়, যেহেতু আমরা এখন এটি সম্পন্ন করেছি। তারপরে )সংশোধকটি প্রথম প্রতিস্থাপনে ফিরে ফিরে আসে এবং লুপটি দিয়ে পুরো পাসে কোনও পরিবর্তন না হওয়া পর্যন্ত পুনরাবৃত্তি করে। এটি ঘটে যখন সমস্ত প্রাঙ্গনে প্রতিস্থাপিত করা এবং সরানো হয়, এবং ইনপুট শুরু হয় therefore

তৃতীয় প্রতিস্থাপন প্রথম ইনপুট (যা হয় therefore) বা ফর্মের যে কোনও কিছুর সাথে মেলে A = Aএবং এটি মুছে ফেলে। সমস্ত প্রস্তাব যদি প্রাঙ্গণ দ্বারা সমর্থিত হয় তবে সেগুলির সমস্তই এই ফর্মটির সাথে মিলবে, তাই যা অবশিষ্ট রয়েছে তা কেবলমাত্র নতুন লাইনের অন্তর্ভুক্ত should চতুর্থ প্রতিস্থাপন এটি এ পরিবর্তন করে right। অন্যথায়, পঞ্চম প্রতিস্থাপন বাকী সমস্ত কিছু (যা মুছে ফেলা rথেকে thereforeএটি ধারণ করে না ) পরিবর্তন করে wrong। শেষ অবধি, সর্বশেষ প্রতিস্থাপন Alex is শুরুতে যুক্ত হয়।


3

পাইথন 2, 264 বাইট

এমবম্ব ২০০ দ্বারা ইতিমধ্যে একটি অজস্র পাইথন 3 উত্তর রয়েছে । এই উত্তরটি সেই উত্তরটি থেকে প্রত্যাশিতভাবে চুরি করে (বিশেষত "অ্যালেক্সটি রিগ্রাগনেজিট" কৌশল)।

এবং এই উত্তরটি তার চেয়ে উল্লেখযোগ্যভাবে দীর্ঘ ...

ঠিক আছে, যাইহোক, এই উত্তরের ধারণাটি হ'ল কী-মান জোড়ার একটি অভিধান বজায় রাখা হবে, যেখানে কীগুলি 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]

(বাইটগুলি সংরক্ষণ করতে, এই উত্তরটি ফাঁকা স্থান এবং ট্যাবগুলিকে মিশ্রিত করে , যা পাইথন ২ এ বৈধ)

এই কোডটি সত্যই বেশ দক্ষ, কারণ অভিধানটি সর্বোচ্চ সম্ভাব্য আকারের (সর্বাধিক বর্ণিত 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

ES6, 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

05 এ বি 1 ই , 32 বাইট

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

@ অদিতসুর সিজেএম উত্তর দ্বারা অনুপ্রাণিত ।

এটি অনলাইনে চেষ্টা করুন বা সমস্ত পরীক্ষার কেস যাচাই করুন

ব্যাখ্যা:

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

বাশ + অজক + এসডাব্লুআই-প্রোলোগ , 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)

এটি অনলাইন চেষ্টা করুন!

মূলত, এটি কেবল একটি প্রোলগ উত্তর হতে চলেছিল, তবে ইনপুট ফর্ম্যাটটিকে ব্যবহারযোগ্য কিছুতে রূপান্তর করতে যে সরঞ্জামগুলি আমি খুঁজে পেতে পারলাম তা যথেষ্ট সীমাবদ্ধ ছিল যে আমি এর অংশটি ব্যাশে করার সিদ্ধান্ত নিয়েছিলাম, যদিও আমার কোনও অভিজ্ঞতা না থাকলেও ছিল না though ব্যাশে কিছু করছেন, এবং এমনকি কখনও জাদুকর স্পর্শও করেনি। আমি এটির জন্য পর্যাপ্ত ঘন্টা ব্যয় করে শেষ করেছিলাম এটি পোস্ট করতে চাই এমনকি এটি 167-বাইটে বেড়ে যাওয়ার পরেও সবেমাত্র সমস্ত দানবকে দেখে গল্ফ করে।

মূলত, অজক প্রোগ্রামটি যা করে তা হ'ল স্টিডিনের কাছ থেকে ইনপুট নেওয়া, লাইনটি মুছে ফেলুন, প্রতিটির পরে thereforeপ্রতিস্থাপন করুনA = B?=(A,B) প্রতিটির এবং সংযোজন write(\"Alex is right\");write(\"Alex is wrong\"). halt.। তারপরে, paste -sd ,প্রতিটি নিউলাইন কিন্তু শেষটিকে কমা দিয়ে প্রতিস্থাপন করে এটি এসডাব্লুআই-প্রোলোগ শেলকে বৈধ দুটি প্রশ্নের মধ্যে রূপান্তরিত করে, যা মুদ্রিত ফলাফলের সাথে এক লাইনে ছাঁটাইয়া চালিত হয় head -n1, যার <(...)বাইরে পাইপের পরিবর্তে পাইপের পরিবর্তে প্রয়োজন হয় আমার বোঝাপড়া এই সব, শুধু একটি বিল্টিন ব্যবহার করতে !

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.