在数学中，感叹号!通常表示阶乘，并且在论点之后出现。

在编程中，感叹号!通常表示取反，它位于参数之前。

对于这一挑战，我们仅将这些运算应用于零和一。

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

取一个零或多个字符串!，然后是0或1，然后是零个或多个字符串!（/!*[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

以字节为单位的最短代码获胜。

Mathematica，25个 17字节

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

从用户提示输入。假定Mathematica的笔记本环境用于隐式打印。要使其成为命令行脚本，请将其包装Print[...]或使其成为无参数函数（然后从提示符处获取输入），然后追加&。

Mathematica具有两个必需的运算符（具有必需的优先级），因此我们可以“评估”输入（由自动完成Input[]），但是逻辑否定运算符不适用于整数（因此它将保持未赋值的状态）。如果结果中有!x剩余，我们将其替换为1-x。

有关评估的两个有趣事实：

1. Mathematica实际上还具有双阶乘运算符!!，该双因子运算符可以计算n*(n-2)*(n-4)*...但仍应用于0或1仍然给出1，因此，0!!!!!将其实际解析为没关系((0!!)!!)!。
2. 即使Mathematica离开!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字节

感谢Leo节省了1个字节。

0!
1
!!

^1|!0

在线尝试！

说明

0!
1

转0!进1。我们不在乎其他尾随!s，得到的数字与应用所有阶乘相同。

!!

取消成对的否定。这也可能会取消某些阶乘，但这无关紧要。

^1|!0

计算此正则表达式的匹配数，该匹配数为1或，0并给出所需的结果。

污垢，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。除非输入为single，否则它们的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插入器，或者您可以使用此bf可视化器实际观看程序的作用。

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

Python，-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，可以将步骤2中的偏移量校正为==1。Zgarb建议使用差值比较运算符而不是应用另一个反转，从而节省2个字节。

在线尝试！

JavaScript（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的输入会导致将a 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。

接下来的两行，删除对!：双重否定会擦除自身，并且我们已经在上一步中考虑了阶乘。

最后一行，在字符串的开头匹配一个数字并返回匹配数：如果所有的否定都被消除，我们将找到一个匹配项（就像我们之前所说的那样，它等于1），如果还有否定的否定。

在线尝试！

Ruby，12 + 1 = 39 24 15 13个字节

使用-n标志。感谢@GB -9个字节！

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

Perl，20个字节

19个字节的代码+ -p标志。

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

在线尝试！

Perl的否定返回undefor 1，所以我用0+数字对0+undef返回的结果进行量化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;}

挤出了一些字节，但有些滥用

在线尝试！

Perl 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.

Haskell，39个字节

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

定义一个函数f，该函数接受一个字符串并返回一个字符。 在线尝试！

说明

有以下三种情况：输入以开头!，输入的长度为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读取的字符数。不是a的第一个字符!将是a 0或1，但是在测试过程中!我们将减去33，使其成为15或16。然后再读取一个字符，该字符将是a !或EOF，并且比较是否小于0（即EOF）。

取三个数据点-感叹号（c），数字值（d）和文件结束条件（e）-我们可以计算出以下结果：

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

将数字值乘以文件结尾条件意味着，如果数字后面跟有a !，则它将转换为零，从而赋予它与a相同的模2值1（记住已转换为16）。但是在应用模2之前，我们添加了初始感叹号，它可以有效地切换模2结果的!前缀次数。最后，由于和的基线值与我们需要的相反，因此我们没有得到结果。01

详细查看代码：

~                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.

Haskell，27个字节

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

在线尝试！

每个前导!对表达式的其余部分的输出进行补充，如1-。我们一直在翻转，直到达到数字为止。如果剩余数为just "0"，结果为0。否则为a 1或后跟一个或多个!，因此结果为1。

Ruby，22 21 20字节

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

说明：

• 第一种情况，我得到一些“！” 最后，将其删除，将长度取模2。
• 第二种情况，没有'！'，如果最后一个字符为零，则将其删除，将长度取模2
• 如果最后一个字符为1，则返回第一种情况

（-1字节窃取@Value Ink的想法）

果冻，8字节

œr”!LḂ=V

在线尝试！

这是一个函数（monadic链接），它接受一个参数并通过其返回值返回。（它通常还会将垃圾内容写入标准输出，但我们对此并不在意。）

说明

œ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

首先，请注意，由于输入始终由一定数量的组成!，后跟一个数字，然后是more !，因此，如果删除尾随!并取长度，则最终将加一个加!程序中前导的数字。如果奇数个数为奇数!，则取此奇偶校验将返回0；如果偶数个数为奇数，则返回1 !。与0比较是“非”函数，而与1比较是恒等函数。因此œr”!LḂ=有效地实现了问题的“ !非运算符领先”。

至于下半部分，处理阶乘!是Jelly中的阶乘操作，因此，如果程序没有前导!，我们可以使用简单的eval（V）直接解决问题。如果程序确实有前导!，则将其解释为采用阶乘0（可能是多次），产生返回值1，该返回值将被打印到标准输出并在看到一个数字时被丢弃；因此，它们对我提交给问题的函数的返回值没有影响。

Python，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'or的从0开始的索引'1'是否为奇数，即是否需要补码。
之所以可行，是因为按字典顺序检查字符串的顺序是使用大于空字符串的任何非空字符串，并使用ASCII顺序，因此'1'>'0'>'!'。这比简单的字节短一个字节s.index(max(s))%2。

的ord(s[-1])%2检查是否最后的字符不是一个'0'（对于有效的输入），并且导致一个整数（而相同的长度(s[-1]!='0')会返回一个布尔值）。
此操作，因为输入的最后一个字符，s[-1]将是一个'0'，'1'或'!'具有ASCII码分别指向48，49和33，它们是0，1和1模2。

在^然后执行按位上上述两个值异或操作时，由于一个输入，正确的返回的整数，是整数。如果左侧为True，则返回右侧的补码；如果左侧为False，则根据需要返回右侧。

Java 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为每个正确的测试用例打印一个）。

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.

Haskell，67 65字节

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

在线尝试！用法：f "!!!0!!!!"

感谢@nimi，节省了两个字节。

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上输入。批处理实际上可以!正确理解此挑战的前导，但是!需要处理尾随的，这需要三个步骤：

• 更改0!为1
• 删除对!!（这对于!!数字前的s 也是安全的）
• 删除所有剩余的结尾!（目前只能在之后1）

IBM /莲花笔记公式-77字节

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

Notes公式没有TIO，因此所有测试用例的屏幕截图如下所示：

这个怎么运作

@Eval() 将字符串评估为表达式

首先，我们检查字段（输入）a中的输入字符串是否包含1或，0然后将所有字符都放在左边（即为字符串）!。我们不在乎有多少。@Eval()会照顾的。

接下来，我们来看!字符串的末尾是否有一个。如果我们1在!字符串后追加（0!且1!均为1- !末尾有多少个字符都没有关系），否则我们将最后一个字符原样追加，因为它不是a !，可以是a 1或a 0。

现在，我们有一个包含前导倒置的字符串以及一个由是否存在阶乘字符定义的数字，因此我们可以将其提供给@Eval()上面并获得结果。

sed，36 33 31字节

纯sed，无BC / Shell utils。在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可用）

Bean，24个字节

十六进制转储：

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

对不起，脚踩到脚了，阿尔诺德。

说明：

取输入作为无格式串的第一行中a，并替换任意数字，然后通过一个或多个!与1，使其余的可以eval“由JavaScript天。

尝试演示或测试套件