불평등의 사슬이 참인지 거짓인지 평가하는 코드를 작성하십시오. 입력 예는 문자열입니다

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

각 구성 요소가 true이기 때문에 이것은 사실입니다.

(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을 반환합니다. 이들은 모두 3 문자열 배열의 다른 요소로 분할되어 일치하지 않는 비교를위한 정규 표현식을 찾습니다.

펄, 82

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

빈 문자열은 Perl의 주요 거짓 값이므로 true이면 1을, false이면 빈 줄을 인쇄합니다.

while 루프는 정규식과 일치하는 문자열을 넘어갑니다 \d(.)(=?). 그런 다음 변수 $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";

자바 스크립트 (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 true
3 <= 4! = 4 false
5> 5 false
8 == 8 <9> 0! = 2> = 1 true

하스켈, 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두 문자 연산자 인 경우 (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 #'cddr의 공정에 의해 목록을 반복 2 따라서 바인딩 a, op및 b로는 다음, 각각의 연속적인 패스.

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

• always다음 표현식이 항상 참인지 확인합니다. 연산자가 nil위인지, 비교 결과인지 (아래 참조).

• case선택 공통 리스프 비교 함수 이전에 판독 된 심볼에있어서; 일부 연산자는 Lisp와 지정된 언어에서 동일하므로 o기본 경우에 간단히 반환 할 수 있습니다 .

파이썬 (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을 제공하는 조회 테이블의 키입니다. 조회 테이블이 무엇입니까? 0001001110011이진수 의 숫자 627 = 입니다. 비트 연산자는 나머지를 수행합니다.

이것은 주어진 네 가지 테스트 사례에서 작동합니다. 다른 경우에 오류가 있으면 알려주세요. 나는 그것을 엄격하게 테스트하지 않았습니다.

자바 스크립트 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)

자바 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