เขียนโค้ดเพื่อประเมินว่าสายโซ่ของความไม่เท่าเทียมกันเป็นจริงหรือเท็จ ตัวอย่างอินพุตคือสตริง

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ไม่มีช่องว่างวงเล็บหรือสัญลักษณ์อื่น ๆ

เอาท์พุท:

ความถูกต้องของความไม่เท่าเทียมกันในฐานะที่สอดคล้องTruthy หรือ Falseyค่า ที่สอดคล้องกันหมายถึงทุกเอาท์พุท Truthy เหมือนกันและเอาต์พุต Falsey ทุกอันเหมือนกัน

ข้อ จำกัด :

จุดประสงค์ของการท้าทายนี้สำหรับคุณที่จะเขียนโค้ดที่ประมวลผลความไม่เท่าเทียมกันแทนที่จะให้พวกเขาประเมินว่ามันเป็นโค้ดหรือแม้แต่ความไม่เท่าเทียมในสายโซ่ ดังนั้นวิธีการเช่น Python evalและการexecประเมินหรือรันรหัสถูกแบน ฟังก์ชันที่ค้นหาเมธอดหรือโอเปอเรเตอร์คือชื่อของสตริง ไม่อนุญาตให้มีการเปิดตัวกระบวนการหรือโปรแกรมเพื่อทำการประเมินผลสำหรับคุณ

กรณีทดสอบ:

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

3<=4!=4
False

5>5
False

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

ทับทิม, 71 + 1 = 72

ด้วยการตั้งค่าสถานะบรรทัดคำสั่ง -nให้รัน

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

สร้างนิพจน์ทั่วไปที่เป็นไปได้ที่ล้มเหลวทั้งหมดและตรวจสอบว่าสตริงอินพุตตรงกับสตริงใด ๆ หรือไม่ ขาออกถ้าไม่มีทำอย่างอื่นtrue falseรับอินพุตผ่าน STDIN คั่นด้วยบรรทัดใหม่

เคล็ดลับ:

• เราได้รับตัวเลขที่เป็นไปได้ทั้งหมดโดยการวนลูปจาก 0 ถึง 99 และแยก 10 และ 1 หลัก
• การเปรียบเทียบจริงที่เราทำคือการa<=>bคืนค่า -1,0 หรือ 1 น้อยกว่าเท่ากับหรือมากกว่า ชิ้นส่วนเหล่านี้ทั้งหมดไปยังองค์ประกอบที่แตกต่างกันของอาเรย์สามสตริงค้นหานิพจน์ทั่วไปสำหรับการเปรียบเทียบที่ไม่ตรงกัน

Perl, 82

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

พิมพ์ 1 เมื่อเป็น true และบรรทัดว่างเมื่อ false เนื่องจากสตริงว่างเป็นค่าเท็จหลักของ Perl

ห่วงในขณะที่ไปมากกว่าการจับคู่สาย \d(.)(=?)regex จากนั้นตัวแปร$1และ$2สอดคล้องกับตัวละครของผู้ประกอบการและตัวแปรพิเศษ$&และ$'จะทำหน้าที่เป็นตัวถูกดำเนินการทั้งสองในบริบทที่เป็นตัวเลข ตัวถูกดำเนินการถูกเปรียบเทียบกับ<=>และผลลัพธ์ที่ตรงกับอักขระตัวแรกของตัวดำเนินการ จากนั้นความเท่าเทียมและความไม่เท่าเทียมจะได้รับการจัดการเป็นพิเศษ

CJam, 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";

JavaScript (ES6) 110 116

ตรงไปตรงมา: สตริงการสแกน, c คือตัวเลขปัจจุบัน, l คือตัวเลขสุดท้าย, o คือโอเปอเรเตอร์

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)

ทดสอบในคอนโซล Firefox / FireBug

;['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 false
5> 5 false
8 == 8 <9> 0! = 2> = 1 จริง

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

เวอร์ชันที่ไม่ถูกปรับแต่ง:

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 เนื่องจากตัวที่ 2 เสมอ=) และlookup1ถ้าเป็นตัวอักษรตัวเดียวeval&&เรียกตัวเองซ้ำและรวมค่าที่ส่งคืนทั้งหมดที่มีตรรกะและ

เสียงกระเพื่อมสามัญ - 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 #'cddriterates กว่ารายการโดยขั้นตอนของการที่2จึงผูกa, opและbดังต่อไปนี้สำหรับแต่ละผ่านต่อเนื่อง

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

• alwaysตรวจสอบว่าการแสดงออกต่อไปเป็นจริงเสมอ: ทั้งผู้ประกอบการเป็นnil(ดูด้านบน) หรือผลของการเปรียบเทียบถือ (ดูด้านล่าง)

• caseเลือกฟังก์ชั่นการเปรียบเทียบ Common-เสียงกระเพื่อมตามสัญลักษณ์อ่านก่อนหน้านี้ เนื่องจากโอเปอเรเตอร์บางตัวเหมือนกันใน Lisp และภาษาที่กำหนดเราสามารถส่งคืนoในกรณีเริ่มต้นได้

Python 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เลขฐานสอง ตัวดำเนินการ Bitwise ทำส่วนที่เหลือ

วิธีนี้ใช้ได้กับกรณีทดสอบทั้งสี่กรณี แจ้งให้เราทราบหากคุณพบข้อผิดพลาดสำหรับกรณีอื่น ฉันไม่ได้ทดสอบอย่างจริงจัง

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

Java 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