विषमताओं की एक श्रृंखला का मूल्यांकन करें

Question

मूल्यांकन करने के लिए कोड लिखें कि क्या असमानताओं की एक श्रृंखला सही है या गलत। एक उदाहरण इनपुट स्ट्रिंग है

3<=4!=9>3==3

यह सत्य है क्योंकि इसका प्रत्येक घटक सत्य है:

(3<=4) and (4!=9) and (9>3) and (3==3)

इनपुट:

एक स्ट्रिंग जो एक या अधिक असमानताओं की श्रृंखला का प्रतिनिधित्व करती है। अनुमत तुलना ऑपरेटर हैं

==   equals
!=   does not equal
>    is greater than
>=   is greater than or equal to
<    is less than
<=   is less than or equal to

अनुमति संख्या एकल अंक नंबर दिए गए हैं 0के माध्यम से9 । कोई स्थान, कोष्ठक या अन्य प्रतीक नहीं होंगे।

आउटपुट:

असमानता की शुद्धता एक सुसंगत सत्य या झूठी मूल्य के रूप में। सुसंगत का मतलब है कि प्रत्येक ट्रू आउटपुट समान है और प्रत्येक फाल्सी आउटपुट समान है।

प्रतिबंध:

इस चुनौती का आशय आपके लिए कोड लिखना है जो असमानताओं को संसाधित करता है, बजाय इसके कि उन्हें कोड के रूप में उनका मूल्यांकन किया जाए, यहां तक ​​कि श्रृंखला में एक असमानता के लिए भी। जैसे, पायथन evalऔर execउस कोड के मूल्यांकन या निष्पादित करने के तरीकों पर प्रतिबंध लगाया गया है। तो ऐसे कार्य हैं जो एक विधि या ऑपरेटर को देखते हैं जो एक स्ट्रिंग के रूप में इसका नाम दिया गया है। न ही यह आपके लिए मूल्यांकन करने के लिए प्रक्रियाओं या कार्यक्रमों को लॉन्च करने की अनुमति है।

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

3<=4!=9>3==3
True

3<=4!=4
False

5>5
False

8==8<9>0!=2>=1
True

Comments

क्या हम <= और> = के बजाय ode और ≤ जैसे यूनिकोड असमानता वाले संकेतों के साथ इनपुट स्वीकार कर सकते हैं?

— फ़ूजएक्सएक्सएल

@FUZxxl आप नहीं कर सकते।

— xnor

Answer 1

रूबी, 71 + 1 = 72

कमांड-लाइन ध्वज के साथ -n, चलाएँ

p (0..99).none?{|i|~/#{a=i%10}(#{%w/!=|. <?=* >?=*/[a<=>b=i/10]})#{b}/}

नियमित अभिव्यक्ति के सभी संभव विफल बनाता है, और जाँचता है कि इनपुट स्ट्रिंग उनमें से किसी से मेल खाती है या नहीं। trueयदि कोई नहीं करता है तो आउटपुटfalse । STDIN के माध्यम से इनपुट लेता है, नई सूचियों द्वारा अलग किया जाता है।

ट्रिक्स:

• हम 0 से 99 तक लूपिंग और 10s और 1s अंकों को निकालने के द्वारा अंकों के सभी संभव जोड़े प्राप्त करते हैं।
• एकमात्र वास्तविक तुलना हम करते हैं a<=>b, जो -1,0, या 1 से कम, के बराबर या उससे अधिक के लिए देता है। ये सभी तीन-स्ट्रिंग सरणी के अलग-अलग तत्वों को स्लाइस करते हैं, तुलना करने के लिए नियमित अभिव्यक्ति ढूंढते हैं जो मेल नहीं खाते हैं।

Comments

कैसी चतुर रणनीति है!

— xnor

Answer 2

पर्ल, 82

$_=<>;($'<=>$&)-61+ord$1&&($2&&$&==$')^('$'lt$1)&&die"\n"while/\d(.)(=?)/g;print 1

प्रिंट 1 जब सही है और एक खाली लाइन झूठी है, क्योंकि खाली स्ट्रिंग पर्ल का मुख्य गलत मूल्य है।

जबकि लूप रेगेक्स से मेल खाते स्ट्रिंग पर चला जाता है \d(.)(=?)। फिर ऑपरेटर के पात्रों के लिए चर $1और $2पत्र, और विशेष चर $&और $'एक संख्यात्मक संदर्भ में दो ऑपरेंड के रूप में व्यवहार करेंगे। <=>ऑपरेटर के साथ तुलना की जाती है और परिणाम ऑपरेटर के पहले चरित्र के खिलाफ मेल खाता है। तब समानता और असमानता से विशेष रूप से निपटा जाता है।

Answer 3

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

यह कोड थोड़ा बदसूरत लगता है और संभावित रूप से पूरी तरह से अनुकूलित नहीं है, लेकिन यह सबसे अच्छा है जो मुझे अब तक मिला है।

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

q_A,sSer_S%@@-(])1\@z{~:X\:^i['=")<"P"(>"P'<'^'>PPP]=~e&X}/;

व्याख्या

q               "Read the input";
_A,sSer         "Copy the input and replace each digit with a space";
_S%             "Split around spaces to obtain the operation list";
@@-             "Remove operations from the input to obtain the operand list";
(])1\@z         "Remove the first operand from the list to be the initial left
                 operand, initialize the result to 1 (true), and pair up the
                 operations and remaining operands";
{               "For each operation-operand pair:";
  ~:X             "Let the operand be the right operand of this operation";
  \:^i            "Hash the operation (bitwise XOR of all characters)";
  [               "Begin cases:";
    '=              " 0: Equals";
    ")<"            " 1: Less than or equal to";
    P               " 2: (Invalid)";
    "(>"            " 3: Greater than or equal to";
    P               " 4: (Invalid)";
    '<              " 5: Less than";
    '^              " 6: Bitwise XOR (stand-in for not equal to)";
    '>              " 7: Greater than";
    P               " 8: (Invalid)";
    P               " 9: (Invalid)";
    P               "10: (Invalid)";
  ]=~             "Execute the case selected by the operation hash modulo 11";
  e&              "Compute the logical AND of the result and the value produced
                   by this operation to be the new result";
  X               "Let the right operand be the new left operand";
}/              "End for each";
;               "Clean up and implicitly print result";

Answer 4

जावास्क्रिप्ट (ईएस 6) 110 116

सीधा: स्कैन स्ट्रिंग, सी वर्तमान अंक है, एल अंतिम अंक है, ओ ऑपरेटर है।

F=x=>(l='',[for(c of x)10-c?(v=!l||v&&(o<'<'?l!=c:(o[1]&&c==l)||(o<'='?l<c:o<'>'?c==l:l>c)),l=c,o=''):o+=c],v)

फ़ायरफ़ॉक्स / फायरबग कंसोल में टेस्ट करें

;['3<=4!=9>3==3','3<=4!=4','5>5','8==8<9>0!=2>=1']
.forEach(s=>console.log(s,F(s)))

3 <= 4! = 9> 3 == 3 सच
3 <= 4! = 4 झूठा
5> 5 झूठा
8 == 8 <9> 0! = 2> = 1 सच!

Answer 5

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

r a=read[a]::Int
l"!"=(/=)
l"="=(==)
l">"=(>=)
l"<"=(<=)
k">"=(>)
k"<"=(<)
[]#_=1<2
(a:'=':b:c)#i=l[a]i(r b)&&c#r b
(a:b:c)#i=k[a]i(r b)&&c#r b
f(h:t)=t#r h

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

f "3<=4!=9>3==3"        -> True
f "3<=4!=4"             -> False
f "5>5"                 -> False
f "8==8<9>0!=2>=1"      -> True

Ungolfed संस्करण:

digitToInt d = read [d] :: Int

lookup2 "!" = (/=)
lookup2 "=" = (==)
lookup2 ">" = (>=)
lookup2 "<" = (<=)

lookup1 ">" = (>)
lookup1 "<" = (<)

eval []              _ = True
eval (op:'=':d:rest) i = lookup2 [op] i (digitToInt d) && eval rest (digitToInt d)
eval (op:d:rest)     i = lookup1 [op] i (digitToInt d) && eval rest (digitToInt d)

evalChain (hd:rest) = eval rest (digitToInt hd)

evalदो तर्क लेता है: पार्स करने के लिए स्ट्रिंग (एक तुलना ऑपरेटर के साथ हमेशा शुरू) और एक संख्या iजो तुलना के लिए बाएं तर्क है (और पिछले दौर में सही तर्क था)। lookup2यदि यह एक दो चरित्र ऑपरेटर है (तो केवल 1 वर्ण की जांच करें, क्योंकि 2nd हमेशा होता है =) और lookup1यदि यह सिर्फ एक ही वर्ण है, तो ऑपरेटर इसे लौटा देता है । evalखुद को पुनरावर्ती कहता है और सभी रिटर्न मानों को तार्किक और के साथ जोड़ता है &&।

Answer 6

आम लिस्प - 300 185 169 165

(lambda(s)(loop for(a o b)on(mapcar'read-from-string(cdr(ppcre:split"([0-9]+)"s :with-registers-p t)))by #'cddr always(if o(funcall(case o(=='=)(!='/=)(t o))a b)t)))

उदाहरण

(mapcar (lambda(s) ...)
       '("2<=3<=6>2<10!=3"
         "3<=4!=9>3==3" 
         "3<=4!=4" 
         "5>5"
         "8==8<9>0!=2>=1"))
=> (T T NIL NIL T)

व्याख्या

(lambda (s)
  (loop for (a o b) on (mapcar
                        'read-from-string
                        (cdr
                         (cl-ppcre:split "([0-9]+)" s
                                         :with-registers-p t))) by #'cddr
        always (if o
                   (funcall (case o
                                  (== '=)
                                  (!= '/=)
                                  (t o))
                            a b)
                   t)))

• ppcre:splitअंकों पर विभाजन; उदाहरण के लिए:

  (ppcre:split "([0-9]+)" "2<=3<=6>2<10!=3" :with-registers-p t)
  => ("" "2" "<=" "3" "<=" "6" ">" "2" "<" "10" "!=" "3")
  

  पहली खाली स्ट्रिंग पर ध्यान दें, जिसका उपयोग करना छोड़ दिया गया है cdr

• read-from-stringइस सूची में मैपिंग readप्रत्येक तार के लिए फ़ंक्शन को कॉल करता है , जो प्रतीकों और संख्याओं को वापस करता है।

• loop for (a op b) on '(3 < 5 > 2) by #'cddrसूची में 2 के एक कदम से iterates और इस प्रकार बांधता है a, opऔर bप्रत्येक क्रमिक पास के लिए निम्नानुसार है।

  a  op  b
  ----------
  3  <    5
  5  >    2
  2  nil  nil
  

• alwaysजाँच करता है कि क्या अगली अभिव्यक्ति हमेशा सच है: या तो ऑपरेटर nil(ऊपर देखें) या तुलना का परिणाम है (नीचे देखें)।

• caseपहले पढ़े गए प्रतीक के अनुसार, कॉमन-लिस्प तुलनात्मक फ़ंक्शन का चयन करता है; चूंकि कुछ ऑपरेटर लिस्प और दी गई भाषा में समान हैं, हम केवल oडिफ़ॉल्ट मामले में वापस आ सकते हैं ।

Answer 7

अजगर 2, 95 102

t=1
n=o=3
for c in map(ord,raw_input()):
 o+=c
 if 47<c<58:t&=627>>(o-c+3*cmp(n,c))%13;n=c;o=0
print t

लूप एक समय में स्ट्रिंग एक वर्ण के माध्यम से एक सीधा पास है। t&=...हिस्सा है जहां जादू होता है। मूल रूप से, मैंने ऑपरेटर को एक साथ cmp(lhs,rhs)(-1, 0, या 1 के मान से lhsकम, बराबर या अधिक से अधिक rhs) के आधार पर हैश दिया है । परिणाम एक लुकअप तालिका में एक कुंजी है जो 0 या 1 देता है जो इस बात पर निर्भर करता है कि संख्या उस ऑपरेटर द्वारा दिए गए ठीक से तुलना करती है या नहीं। क्या लुकअप टेबल, आप पूछें? यह संख्या 627 = है0001001110011 बाइनरी में है। बिटवाइज ऑपरेटर्स बाकी काम करते हैं।

यह चार दिए गए परीक्षण मामलों पर काम करता है; मुझे बताएं कि क्या आपको किसी अन्य मामले के लिए कोई त्रुटि मिलती है। मैंने बहुत कठोरता से इसका परीक्षण नहीं किया है।

Comments

आपको aइनपुट के रूप में लेने की आवश्यकता है ।

— xnor

@xnor वूप्स। सही किया।

— DLosc

Answer 8

जावास्क्रिप्ट 101 बाइट्स

यहाँ पोस्ट किए गए js समाधान से एक अलग दृष्टिकोण

F=(s,i=0,l=o="")=>[...s].every(c=>c>=0?[l^c,l==c,,l<c,l>c,l<=c,,l>=c]["!==<><=>=".search(o,l=c,o="")]:o+=c,l=o="")

console.log(F("3<=4!=9>3==3")==true)
console.log(F("3<=4!=4")==false)
console.log(F("5>5")==false)
console.log(F("8==8<9>0!=2>=1")==true)

Answer 9

जावा 8, 283 बाइट्स

s->{String[]a=s.split("\\d"),b=s.split("\\D+");int i=0,r=1,x,y;for(;i<a.length-1;)if((x=new Byte(b[i]))!=(y=new Byte(b[++i]))&(a[i].equals("=="))|(a[i].equals("!=")&x==y)|(a[i].equals(">")&x<=y)|(a[i].equals(">=")&x<y)|(a[i].equals("<")&x>=y)|(a[i].equals("<=")&x>y))r--;return r>0;}

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

s->{                            // Method with String parameter and boolean return-type
  String[]a=s.split("\\d"),     //  All the inequalities
          b=s.split("\\D+");    //  All the digits
  int i=0,                      //  Index-integer (starting at 0)
      r=1,                      //  Flag integer for the result, starting at 1
      x,y;                      //  Temp integer `x` and `y`
  for(;i<a.length-1;)           //  Loop from 0 to the length - 1
  if((x=new Byte(b[i]))!=(y=new Byte(b[++i]))&(a[i].equals("=="))
                                //   If "==" and `x` and `y` as int are not equal:
     |(a[i].equals("!=")&x==y)  //   Or "!=" and `x` and `y` are equal
     |(a[i].equals(">")&x<=y)   //   Or ">" and `x` is smaller or equal to `y`
     |(a[i].equals(">=")&x<y)   //   Or ">=" and `x` is smaller than `y`
     |(a[i].equals("<")&x>=y)   //   Or "<" and `x` is larger or equal to `y`
     |(a[i].equals("<=")&x>y))  //   Or "<=" and `x` is larger than `y`
    r--;                        //    Decrease `r` by 1
                                //  End of loop (implicit / single-line body)
  return r>0;                   //  Return if `r` is still 1
}                               // End of method