수학에서 느낌표는 !종종 계승을 의미 하며 인수 뒤에옵니다.

느낌표를 프로그래밍 할 때 !종종 부정을 의미 하며 인수 앞에옵니다.

이 과제에서는 이러한 작업을 0과 1에만 적용합니다.

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

제로 이상의 문자열을 가지고 !'의 다음의, 0또는 10 개 이상의 뒤에, !S'을 ( /!*[01]!*/).
예를 들어, 입력은 !!!0!!!!또는 !!!1또는 !0!!또는 0!또는 일 수 있습니다 1.

!'는 이전의 0나 1있는 부정과 !후들'계승이다.

계승은 부정보다 우선 순위가 높으므로 계승이 항상 먼저 적용됩니다.
예를 들어, !!!0!!!!진정으로 !!!(0!!!!)또는 더 나은 것을 의미 !(!(!((((0!)!)!)!)))합니다.

모든 계승과 부정의 결과적인 적용을 출력합니다. 출력은 항상 0또는 1입니다.

테스트 사례

0 -> 0
1 -> 1
0! -> 1
1! -> 1
!0 -> 1
!1 -> 0
!0! -> 0
!1! -> 0
0!! -> 1
1!! -> 1
!!0 -> 0
!!1 -> 1
!0!! -> 0
!!!1 -> 0
!!!0!!!! -> 0
!!!1!!!! -> 0

바이트 단위의 가장 짧은 코드가 이깁니다.

수학, 25 17 바이트

Input[]/.!x_:>1-x

사용자 프롬프트에서 입력을받습니다. 암시 적 인쇄를위한 Mathematica의 노트북 환경 을 가정합니다 . 그것을 명령 행 스크립트 Print[...]로 만들려면 그것을 감싸 거나 인수가없는 함수로 만드십시오 (프롬프트에서 입력을받습니다) &.

Mathematica에는 필수 연산자 (필수 우선 순위)가 모두 있으므로 입력을 "평가"할 수 Input[]있지만 ( 자동으로 수행됨 ) 논리 부정 연산자는 정수에서 작동하지 않으므로 평가되지 않은 상태로 유지됩니다. !x결과에 왼쪽 이 있으면 이를로 바꿉니다 1-x.

평가에 대한 몇 가지 재미있는 사실 :

1. 매스 매 티카는 사실 또한 이중 계승 연산자가 !!계산, n*(n-2)*(n-4)*...하지만, 적용 0또는 1여전히 준다 1, 그래서는이 문제가되지 않는 0!!!!!사실로 분석됩니다 ((0!!)!!)!.
2. 매스 매 티카 잎에도 불구 !0하고 !1평가되지 않은, 그 알고 않는 !자기 역, 그래서 자동으로 선도의 모든 쌍을 취소합니다 !. 애프터 ToExpression우리는있어 항상 중 하나를 왼쪽 0, 1, !0, !1.

[Bash] + Unix 유틸리티, 21 17 바이트

sed s/.!!*$/1/|bc

파일로 저장하고 프로그램으로 실행해야합니다. 명령 행에서 직접 명령을 입력하려고하면 !! bash의 대화식 모드에서 히스토리 대체가 활성화되어 확장되었습니다. 또는을 사용하여 기록 대체를 끌 수 있습니다 set +H.

테스트 사례 실행 :

for x in 0 1 '0!' '1!' '!0' '!1' '!0!' '!1!' '0!!' '1!!' '!!0' '!!1' '!0!!' '!!!1' '!!!0!!!!' '!!!1!!!!'; do ./excl <<<"$x"; done

0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0

망막 , 20 15 14 바이트

1 바이트를 절약 해 준 Leo에게 감사합니다.

0!
1
!!

^1|!0

온라인으로 사용해보십시오!

설명

0!
1

돌려 0!으로 1. 우리는 다른 후행에 대해서는 신경 쓰지 않으며 !결과 수는 모든 계승을 적용 한 것과 같습니다.

!!

부정 쌍을 취소하십시오. 이것은 또한 일부 계승을 취소 할 수 있지만 관련이 없습니다.

^1|!0

중 하나 인이 정규식의 일치의 수를 카운트 1하거나 0원하는 결과를 제공한다.

Grime , 14 12 9 바이트

e`\0!~\!_

온라인으로 사용해보십시오!

설명

이것은 패턴과 입력 1을 일치시키고 일치와 0일치하지 않는 인쇄 를 합니다.

e`\0!~\!_
e`         Match entire input against this pattern:
    !      not
  \0       a sole 0
     ~     xor
      \!   exclamation mark
        _  followed by this pattern matched recursively.

아이디어는 이것입니다. 입력이 숫자로 시작하면 재귀 부분은 \!_항상 실패 \0!하고 단일이 없으면 성공합니다 0. 입력 값이 단일이 아니면 xor가 성공합니다 0. 입력이 시작되는 경우 !, 다음 \0!항상 성공하고, \!_재귀 일치가 성공하면 성공합니다. 그들의 xor는 재귀 적 일치가 실패 할 때 정확하게 성공하므로 그것을 무시합니다.

Brainfuck, 85 72 (84) 바이트

,[>-[-----<->]<++[>++++[-<++++>]+<[[+],[[-]>-<]]]>[<<+[-->]>[<],>-]<]<+.

숫자로 반환하거나

,[>-[-----<->]<++[>++++[-<++++>]+<[[+],[[-]>-<]]]>[<<+[-->]>[<],>-]<]-[-----<+>]<--.

ASCII 텍스트 메모리 줄 바꿈을 피하기 위해 접두사를 붙일 수도 있습니다.

온라인으로 사용해보십시오!

Loops over the input.
On 1, ends.
On "!", toggles bool a stored as 0 or 255.
On "0", toggles if there is no trailing bit, then ends.

Memory labels  | BOOL | INPUT | FLAG |

,                   first input 
[                     # loop on INPUT
  >-[-----<->]<++     subtract 49 == "1"

  [                     # case not "1"
    >++++[-<++++>]      add 16 since 49 take 16 == "!"

    +                   set FLAG
    <                   move to INPUT
    [                     # case "0"
      [+],                clear and new INPUT
      [                     # case "0!"
        [-]>-<              clear INPUT and FLAG
      ]
    ]
  ]

  >                   move to FLAG
  [                     # case "!" or "0" without tail
    <<+[-->]>[<]        not the BOOL
    ,                   take new input
    >-                  clear FLAG
  ]
  <                   move to INPUT
]

+.                    return 0 or 1

또는 텍스트 응답의 경우 마지막 줄을

-[-----<+>]<--.       add 49 for "0" or "1" conversion and return

Brainfuck-많은 바이트로가는 길 (232 바이트)

코드 골프에서 우승하기에는 분명히 잘못된 언어입니다. 주로 나는이 esolang를 사용하는 사람이 부족하다는 것을 알았습니다. 좋은 온라인 통역사 bf interpeter가 있거나 실제로이 bf visualizer를 사용하여 프로그램이하는 일을 볼 수 있습니다 .

>>>>>,[>+++[<---------------->-]<<<<<<[-]+>[-]>>>>[-[<<[>+<<<<->>>[<<+>>-] ]<<[>>+<<-]<[>>+<<[-]]>>>>>[-]]<<<<<[>>>++<<<-]>+>>>>[-]]<<<<-[>>+<<[-]]>>>>,]<<->[<[-]+>[-]]<<[<[-]>>[<<+>>[-]]+<<[->>-<<]>-]>>[-]+++[<++++++++++++++++>-]<.

파이썬, -44- 42 바이트

Zgarb 덕분에 2 바이트를 절약했습니다!

lambda x:(x[-1]=='0')^len(x.rstrip('!'))%2

단계별 :

1. x[-1]!='0'
   경우 x와 단부 1또는 !⇔ x로 끝나지는 0, 팩토리얼 부가 가치 있어야 1밖의을0
2. ^len(x.rstrip('!'))%2
   "조건이 아닌"xor의 속성을 이용하십시오. 이 경우의 조건은 초기 길이 !s가 홀수 인 경우입니다. 그러나 .rstrip문자열에서 숫자를 제거하지 않으므로 계산 된 길이가 1로 오프셋되므로 조건이 반전됩니다
3. 2 단계에서 1 씩 오프셋은 1 단계에서로 변경 !=하여 수정됩니다 ==. Zgarb는 다른 반전을 적용하지 않고 2 바이트를 절약하는 대신 차이 비교 연산자를 사용하도록 제안했습니다.

온라인으로 사용해보십시오!

자바 스크립트 (ES6), 43 41 29 바이트

s=>+eval(s.replace(/.!+$/,1))

비정규 방법 ( 41 31 바이트)

아래는 내 초기 접근 방식입니다. 약간 더 흥미롭지 만 Neil (10 바이트 절약)에 의한 상당한 최적화 후에도 훨씬 더 길다 .

f=([c,...s])=>1/c?c|s>'':1-f(s)

테스트 사례

let f =

s=>+eval(s.replace(/.!+$/,1))

;[
  "0", "1", "0!", "1!", "!0", "!1", "!0!", "!1!", "0!!",
  "1!!", "!!0", "!!1", "!0!!", "!!!1", "!!!0!!!!", "!!!1!!!!"
].map(
  s => console.log(s, '=>', f(s))
)

젤리 , 5 바이트

VeMḂ$

온라인으로 사용해보십시오!

문자열을 기대하는 Monadic 함수. 선행 !s가있는 입력 1은 도중에 STDOUT에 인쇄되므로, 내가 제공하는 TIO 링크는 첫 번째 출력 라인 아래에 입력-출력 쌍을 인쇄하는 테스트 하네스입니다.

어떻게?

VeMḂ$ - Monadic link: string
V     - eval the string
          - the implicit input of 0 causes !...! to evaluate to 1 (which gets printed),
          - the result is the evaluation of the rest: "0"=0; "0!"=1; "1"=1; "1!"=1; ...
 e    - exists in?
    $ - last two links as a monad:
  M   -     Maximal indexes - the "0" and "1" characters are greater than "!",
                            - so this results in a list of one item [i] where
                            - i is the 1-based index of the 0 or 1 character.
   Ḃ  -     %2 (vectorises) - [i%2], so a 0 if we need to logically negate and a 1 if not
                            - hence we check equality with e rather than inequality.

05AB1E , 9 바이트

암호:

.V¹'!ÜgG_

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오!

설명:

.V         # Evaluate the input as 05AB1E code. This computes the factorial part.
   '!Ü     # Remove trailing exclamation marks..
  ¹        # ..from the first input
      g    # Get the length of the resulting string
       G   # Do the following length - 1 times:
        _  #   Negate the number

레티 나 , 13 바이트

다소 이상한 접근법이지만 짧고 작동합니다.

0$
!1
!!

^\d

처음 두 줄을 사용하여 끝 0을 !1다음과 같이 바꿉니다.이 대체를 사용하면 이제 숫자부터 문자열 부분이 1과 같습니다.

다음 두 줄은 쌍을 제거합니다 !: 이중 부정 자체가 지워지고 이미 이전 단계에서 계승을 설명했습니다.

마지막 줄은 문자열의 시작 부분에서 숫자를 일치시키고 일치 수를 반환합니다. 부정이 모두 제거되면 일치 항목을 찾을 수 있습니다. 부정이 일치하지 않습니다.

온라인으로 사용해보십시오!

루비, 12 + 1 = 39 24 15 13 바이트

-n플래그를 사용합니다 . -9 바이트의 @GB 덕분에 !

p~/!*$|0$/%2

펄 , 20 바이트

19 바이트의 코드 + -p플래그.

s/\d!+/1/;$_=0+eval

온라인으로 사용해보십시오!

Perl의 부정은 undef또는을 반환 1하므로 0+결과 0+undefreturn 을 수치화하는 데 사용 합니다 0. 게다가 코드에 대해서는별로 말할 것이 없습니다.

C, 68 62 61 53 바이트

c;e(char*a){for(c=1;*a<34;a++)c^=1;c=a[1]?c:*a&1^!c;}

남용으로 몇 바이트 더 짜내

온라인으로 사용해보십시오!

펄 6 , 32 28 23 바이트

{m/(\!)*(1|0.)*/.sum%2}

작동 원리

{                     }  # A lambda.
{m/            /      }  # Match the lambda argument against the regex:
   (\!)*                 #   Zero or more `!`.
                         #     (First capture will be an array with one element per negation).
        (1|0.)*          #   A `1`, or a `0` and another character, zero or more times.
                         #     (Second capture will be a one-element array if the factorial
                         #     part evaluates to 1, and an empty array otherwise.)
                .sum     # Add the lengths of the two captures,
                    %2   # and return that sum modulo 2.

하스켈 , 39 바이트

f('!':b)="10"!!read[f b]
f[a]=a
f _='1'

f문자열을 가져 와서 문자를 반환 하는 function을 정의합니다 . 온라인으로 사용해보십시오!

설명

입력은로 시작하고 !입력의 길이는 1이며 다른 모든 경우가 있습니다.

f('!':b)=    -- If input has head '!' and tail b,
 "10"!!      -- we index into the string "10"
  read[f b]  -- using f b converted to int. This essentially inverts f b.
f[a]=        -- If input has only one character, we know it's a digit,
 a           -- so we can just return it.
f _=         -- In all other cases, we know the input is a digit followed by !s,
 '1'         -- so we can return '1'.

Befunge, 24 바이트

~"!"-:#v_$1+
*+2%!.@>0~`

온라인으로 사용해보십시오!

!stdin에서 읽은 문자 수를 세면서 시작합니다 . 아닌 첫 번째 문자 !의 뜻이 될 중 하나 0이나 1, 그러나 시험하는 과정에있어 !우리가 만드는 (33)를 뺀 것 어느 쪽이 될 것입니다 중 15 우리는 다음 한 번 더 문자를 읽어 (16), !또는 EOF하고, 이 값이 0보다 작은 경우 비교하십시오 (예 : EOF).

이 세 가지 데이터 포인트-느낌표 ( c ), 숫자 값 ( d ) 및 파일 끝 조건 ( e )의 를 사용하여 다음과 같이 결과를 계산할 수 있습니다.

!((c + d*e) % 2)

숫자 값에 파일 끝 조건을 곱하면 숫자 뒤에 a가 오는 경우 0으로 변환 !되므로 1(16으로 변환 된 기억) 과 같은 모듈로 2 값이 제공됩니다 . 그러나 모듈로 2를 적용하기 전에 초기 느낌표 카운트를 추가하여 모듈러스 2 결과를 !접두사 만큼 여러 번 효과적으로 토글합니다 . 그리고 마지막으로 우리 하지 결과에 대한 우리의 기본 값 이후 0와 1우리가 필요로하는 것과 반대입니다.

코드를보다 자세히 살펴보면 다음과 같습니다.

~                Read a character from stdin.
 "!"-            Subtract 33 (ASCII for '!').
     :  _        Make a duplicate and check if zero (i.e. is it a '!').
         $1+     If so, drop the duplicate, increment a counter, and repeat.
       v         Otherwise move to the second line, leaving the digit value on the stack.
       >0~`      Read one more character and check if less than 0 (i.e. EOF).
*                Multiple by the digit value, making it zero if not followed by EOF.
 +               Add to the exclamation count.
  2%             Modulo 2 the result.
    !            Then not that value.
     .@          And finally write to stdout and exit.

하스켈 , 27 바이트

f('!':b)=1-f b
f"0"=0
f _=1

온라인으로 사용해보십시오!

각 행간 !은 다음과 같이 나머지 식에 대한 출력을 보완합니다 1-. 우리는 숫자를 칠 때까지 계속 뒤집습니다. 나머지가 just "0"인 경우 결과는 0입니다. 그렇지 않으면 a 1또는 뒤에 하나 이상이 오므로 !결과는 1입니다.

루비, 22 21 20 바이트

->s{(s=~/!*$|0$/)%2}

설명:

• 첫 번째 경우, 나는 '!' 끝에서 그들을 제거하고 길이 모듈로 2를 얻습니다.
• 두 번째 경우, 아니 '!', 마지막 문자가 0이면 제거하고 길이 모듈로 2를 얻습니다.
• 마지막 문자가 1이면 첫 번째 문자로 돌아갑니다.

(@Value Ink의 아이디어를 훔치는 1 바이트)

젤리 , 8 바이트

œr”!LḂ=V

온라인으로 사용해보십시오!

이것은 기능입니다 하나의 인수를 취하고 리턴 값을 통해 리턴 (모나 딕 링크)입니다. (또한 종종 부작용으로 표준 출력에 정크를 기록하지만 우리는 그것에 대해 신경 쓰지 않습니다.)

설명

œr”!LḂ=V
œr”!      Take {the input}, with all trailing ! deleted
    L     Take the length of this
     Ḃ    Take the parity of that length
      =   Return 0 if unequal, 1 if equal to:
       V    the value of {the input} when eval'ed as a niladic Jelly program

먼저, 입력은 항상 몇 개의 숫자와 !숫자, 그다음으로 구성 !되므로 후행을 삭제 !하고 길이를 취 !하면 프로그램에서 1을 더한 숫자로 끝납니다 . 이 패리티를 취하면 홀수가이면 0을 반환하고 짝수이면 !1을 반환 !합니다. 0과 비교하는 것은 "not"함수이고, 1과 비교하는 것은 항등 함수입니다. 따라서 문제 œr”!LḂ=의 " !NOT 연산자로 취급 "부분 을 효과적으로 구현합니다 .

후반부에서 !계승 처리는 젤리의 계승 연산이므로 프로그램에 선행이 없으면 !간단한 eval( V)으로 직접 문제를 해결할 수 있습니다 . 프로그램에 선행 이 있는 경우 !0의 계승 (아마도 여러 번)을 취하는 것으로 해석되어 1의 리턴 값을 생성합니다.이 값은 표준 출력으로 인쇄되고 숫자가 표시되면 폐기됩니다. 따라서 그들은 내 질문에 제출하는 함수의 반환 값에 영향을 미치지 않습니다.

파이썬, 38 바이트

lambda s:(s[1::2]>s[::2])^ord(s[-1])%2

TryItOnline!

익명 함수 입력 문자열을 복용 s하고 정수를 반환 0하거나 1.

s[1::2] 색인 1에서 시작하고 단계 크기가 2 인 입력 문자열의 조각입니다.
'Like this' -> 'ieti'

s[::2] 비슷하지만 기본 인덱스 0에서 시작합니다.
'Like this' -> 'Lk hs'

테스트 (s[1::2]>s[::2])는 '0'또는 의 0 기반 인덱스 '1'가 홀수인지, 즉 보완해야하는지 확인합니다.
빈 문자열보다 비어 있지 않은 문자열과 ASCII 순서로 문자열 순서를 사전 식으로 검사하기 때문에 작동합니다 '1'>'0'>'!'. 이것은 단순한 것보다 짧은 바이트 s.index(max(s))%2입니다.

ord(s[-1])%2마지막 문자가 아닌 있는지 검사 '0'정수의 (유효 입력), 및 결과 (동일한 길이 반면 (s[-1]!='0')boolean를 돌려 준다).
입력의 마지막 문자 때문 작동 s[-1]하는 것 '0', '1'또는 '!'0, 1, 1만큼 감소되는 ASCII 코드는 각각 48, 49, 33 포인트가 어느.

그런 ^다음 위의 두 값에 대해 비트 배타적 또는 연산을 수행하고 오른쪽 입력 하나가 정수이므로 정수를 반환합니다. 왼쪽이 True이면 오른쪽의 보수가 반환되고 왼쪽이 False이면 필요에 따라 오른쪽이 반환됩니다.

자바 7, 105 82 81 바이트

int a(char[]a){int b=0,c=0;for(;a[b++]<34;c^=1);return(b<a.length?1:a[b-1]&1)^c;}

온라인으로 사용해보십시오!

오래된 정규식 솔루션

int a(String a){a=a.replace("0!","1").replaceAll("1.*","1");int b=a.length()-1;return b%2^a.charAt(b)&1;}

CJam , 12 11 바이트

r_W='0=!\~;

온라인으로 사용해보십시오! 테스트 스위트 ( 1올바른 테스트 케이스마다 a 를 인쇄 )

r      e# Read input.
_W='0= e# Duplicate and check whether the string ends in '0'. This is the
       e# only case in which the factorial part results in 0.
!      e# Negate this to get the actual result of the factorial part.
\      e# Swap with the input.
~      e# Evalute the input as CJam code. The leading `!` will apply the logical
       e# negations to the factorial result. The 0 or 1 will then push a junk value
       e# which is potentially negated a few times as well, by the factorials.
;      e# Discard the junk value.

하스켈 , 67 65 바이트

f s|foldr(\_->not)(last s`elem`"1!")$fst.span(<'0')$s="1"|1<3="0"

온라인으로 사용해보십시오! 용법:f "!!!0!!!!"

@nimi 덕분에 2 바이트를 절약했습니다.

Brainfuck, 115 바이트

>,[->++++[<-------->-]<[--------------->,[<[-]+>-]<<[->-[>+<+]>[-<+>]<<]>>++++++[-<++++++++>]<.>>+<]>-[<<+>,>[-]]<]

온라인으로 사용해보십시오!

언 골프 드 :

% 0: inverter count
% 1: result
% 2: if/else flag; tmpspace in inner loop 0

>1,[
    ->2++++[<-------->-]<1 subtract 33 (!)
    [ 
        % we've reached the number
        ---------------
        % now it's either 0 or 1

        % check next char; If it's not 0 then it's '!'
        % 0! = 1! = 1!...! so we only need to determine if at least one ! exists
        >2,
                [<[-]+>-]<1

        % apply inversions
        <0
        [->1
            % invert cell 1 once each iteration
                       % cell 1 is 0 or 1
            -          % cell 1 is 255 or 1
            [>+<+]     % cell 1 is 0; cell 2 is 1 iff cell 1 should be 1
            >2[-<+>]<1 % cell 1 is 1 or 0
        <0]

        % print result
        >1>++++++[-<++++++++>]<1.

        >>2+< % tape={0 r 0 1}
    ]
    >2-[ % we haven't seen the number yet
        <<0+>1,>2 % add to inverter count
        [-]
    ]<1
]

배치, 62 바이트

@set/ps=
@set s=%s:0!=1%
@set s=%s:!!=%
@cmd/cset/a%s:1!=1%

STDIN에서 입력을받습니다. Batch는 실제로이 !도전에 대한 선행을 올바르게 이해 하지만 후행 !을 처리해야하며 3 단계가 필요합니다.

• 변경 0!에1
• 쌍을 삭제합니다 !!(이 !!숫자 는 s 앞에 안전합니다 )
• 나머지 후행을 삭제합니다 !(현재 까지는 이후에만 가능 1).

IBM / Lotus Notes 공식-77 바이트

@Eval(@Left(a;@If(@Like(a;"%1%");"1";"0"))+@If(@Ends(a;"!");"1";@Right(a;1)))

Notes Formula에 대한 TIO가 없으므로 모든 테스트 사례의 스크린 샷이 아래에 나와 있습니다.

작동 원리

@Eval() 문자열을 표현식으로 평가

먼저 필드의 입력 문자열 (입력)이 a포함되어 1있는지 확인 0하고 모든 문자를 왼쪽으로 가져 가면 문자열이 !됩니다. 우리는 얼마나 많은 상관하지 않습니다. @Eval()그것을 처리 할 것입니다.

다음으로 !문자열 끝에 가 있는지 확인 합니다. 문자열에 추가 1하면 !( 0!그리고 1!둘 다 1- !끝에 몇 개의 문자가 있는지는 중요하지 않습니다 ) 그렇지 않으면 마지막 문자는 a가 아니고 !a 1또는 a 일 수 있으므로 변경되지 않은 마지막 문자를 추가합니다 0.

우리는 이제 주요 역전을 포함하는 문자열과 계승 문자가 있는지 여부에 따라 정의 된 숫자를 가지므로이를 제공 @Eval()하고 위의 결과를 얻을 수 있습니다 .

sed, 36 33 31 바이트

순수한 sed, bc / shell 유틸리티는 없습니다. GNU sed <4.3에서 작동; BSD 및 GNU 4.3 이상에서 33 바이트.

s/.!!*$/1/
:
s/!0/1/
s/!1/0/
t

익숙하다면 충분히 간단합니다 sed. 그렇지 않은 사람들을 위해 논평 :

# Since 0! == 1! == 1 and factorial has precedence, just collapse any trailing "!" 
s/.!!*$/1/
# Define an anonymous label
:
# Invert 0 if needed
s/!0/1/
# Invert 1 if needed
s/!1/0/
# If a change was made, go back to the anonymous label.
t

테스트:

% cat 109248.sed
s/.!!*$/1/
:l
s/!0/1/
s/!1/0/
tl
% wc -c 109248.sed
      33 109248.sed
% cat cases
0
1
0!
1!
!0
!1
!0!
!1!
0!!
1!!
!!0
!!1
!0!!
!!!1
!!!0!!!!
!!!1!!!!
% sed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
% gsed -f 109248.sed cases
0
1
1
1
1
0
0
0
1
1
0
1
0
0
0
0
%

PHP 7.1, 58 55 54 37 35 바이트

참고 : IBM-850 인코딩 사용

echo!!$argn[-1]^strspn($argn,~Ì)%2;

다음과 같이 실행하십시오.

echo '!!!0!!!!' | php -nR 'echo!!$argn[-1]^strspn($argn,~Ì)%2;';echo
> 0

설명

echo
  strspn($a=$argv[1],~Ì) # Count the number of leading exclamation marks.
  % 2                    # Make 0 (even) or 1 (odd).
  ^ !!$a[-1];            # Negate with factorial part (truthy value of the 
                         # last char):
                         # - "0" is considered falsy.
                         # - "1" or "!" is considered truthy.

조정

• IBM-850 인코딩을 사용하여 3 바이트 절약
• 정규식을 약간 변경하여 바이트를 저장했습니다.
• 긴 함수 이름없이 반환 된 17 바이트, 새 버전 및 반환
• 사용하여 2 바이트 절약 -R(사용 $argn가능하게 함)

빈 , 24 바이트

16 진 덤프 :

00000000 26 4a c1 53 a0 17 53 d0 80 a0 5d 20 80 0a a1 80  &JÁS .SÐ. ] ..¡.
00000010 81 00 25 3a ae a1 ab 24                          ..%:®¡«$
00000018

동등한 JavaScript :

+eval(a.replace(/.!+$/,1))

당신의 발가락에 스테핑 죄송 Arnauld .

설명:

서식없는 문자열 입력의 첫 번째 행을 취하고 a, 하나 이상의 이어 어떤 숫자 대체 !와를 1나머지가 될 수 있도록, eval"자바 스크립트에 의해 거라고.

데모 또는 테스트 스위트를 사용해보십시오