数学では、感嘆符は!しばしば階乗を意味し、議論の後に来ます。

プログラミングでは、感嘆符は!しばしば否定を意味し、それは議論の前に来ます。

この課題では、これらの操作をゼロと1にのみ適用します。

Factorial
0! = 1
1! = 1

Negation
!0 = 1
!1 = 0

ゼロ個以上の文字列を取る!「が続いS、0または1ゼロ個以上続く、!S」を（/!*[01]!*/）。
たとえば、入力は!!!0!!!!or !!!1または!0!!or 0!または1です。

or !の前の' は否定で、'の後は階乗です。01!

階乗は否定よりも優先順位が高いため、階乗が常に最初に適用されます。
例えば、!!!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[...]するか、引数のない関数（プロンプトから入力を取得する）にするには、appendを追加します&。

Mathematicaには両方の必須演算子（優先順位が必要）があるため、入力を「評価」できます（これはによって自動的に行われますInput[]）が、論理否定演算子は整数に対して機能しません（したがって、評価されないままになります）。ある場合!x、左の結果に、我々はと交換してください1-x。

評価に関するいくつかの楽しい事実：

1. Mathematicaには実際に二重階乗演算子もあります!!。これは計算n*(n-2)*(n-4)*...されますが、適用される0か、1それでも与えられる1ので、0!!!!!実際にとして解析されることは問題ではありません((0!!)!!)!。
2. Mathematicaは終了!0して!1評価されていませんが、それ!が自己逆であることを知っているので、leadingのすべてのペアを自動的にキャンセルします!。後ToExpression、私たちはしているいつもの1を残し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。他の後続!の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ます。入力が単一でない限り、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バイト）への道

コードゴルフで勝つための明らかに間違った言語。主に、このエソランを使用している人がいないことに気付きました。優れたオンラインインタープリターbf interpeterがあるか、この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のプロパティを「条件付きnot」として活用します。この場合の条件は、初期!sの長さが奇数である場合です。ただし、.rstrip文字列から数値を削除しないため、計算される長さは1オフセットされるため、条件は反転します
3. 手順2の1によるオフセットは、手順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Ḃ$

オンラインでお試しください！

文字列を期待するモナド関数。先頭に!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

最初の2行で、末尾0を!1：で置き換えます。この置き換えにより、文字列の数字以降の部分が1に等しいことがわかります。

次の2行では、!：のペアを削除します。二重否定はそれ自体を消去し、前のステップで階乗をすでに考慮しました。

最後の行は、文字列の先頭の数字と一致し、一致の数を返します：否定がすべて除去された場合、一致が見つかります（前に言ったように、これは1に等しい）、まだある場合否定はこれと一致しません。

オンラインでお試しください！

ルビー、12 + 1 = 39 24 15 13バイト

-nフラグを使用します。-9バイトの@GBに感謝します！

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

Perl、20バイト

19バイトのコード+ -pフラグ。

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

オンラインでお試しください！

Perlの否定はundefまたはを返す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文字列を受け取って文字を返す関数を定義します。 オンラインでお試しください！

説明

次の3つの場合があります。入力はで始まり!、入力の長さは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にします。次に、もう1つの文字を読み取ります。これはan !またはEOFです。それが0（つまりEOF）より小さいかどうかを比較します。

これらの3つのデータポイント-感嘆符（c）、数字の値（d）、およびファイルの終わり条件（e）を取得すると、次のように結果を計算できます。

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

数字の値にファイル終了条件を掛けると、数字の後にaが続くとゼロに変換されるため!、a と同じモジュロ2値が得られます1（16に変換されていることを覚えています）。ただし、モジュロ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.

Haskell、27バイト

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

オンラインでお試しください！

各先頭!は、として行われる式の残りの出力を補完します1-。数字がヒットするまで反転し続けます。残りがjustの"0"場合、結果は0です。それ以外の場合、a 1またはorの後に1つ以上が続く!ため、結果は1です。

ルビー、22 21 20バイト

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

説明：

• 最初のケースでは、「！」最後に、それらを削除し、2を法とした長さを取得します。
• 2番目の場合、「！」はありません。最後の文字がゼロの場合は削除し、2を法とした長さを取得します
• 最後の文字が1の場合、最初のケースに戻る

（@Value Inkのアイデアを盗む-1バイト）

ゼリー、8バイト

œr”!LḂ=V

オンラインでお試しください！

これは、1つの引数を取り、その戻り値を介して返す関数（単項リンク）です。（多くの場合、副作用として標準出力にジャンクを書き込みますが、それについては気にしません。）

説明

œ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 !で構成される!ため、末尾を削除して長さを取る!と、プログラムの先頭に1を加えた数になることに注意してください。奇数の数があった場合には、こののパリティは0を返します服用!、または1の偶数があった場合!。0と比較することは「not」関数であり、1と比較することは恒等関数です。したがって、質問の「NOT演算子としてœ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を有しています。

次に^、上記の2つの値に対してビット単位の排他的論理和演算を実行し、1つの入力（右側の入力）が整数であるため整数を返します。左が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正しいテストケースごとに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.

Haskell、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は実際!にこの課題の先頭のsを正しく理解しますが、末尾!のsに対処する必要があり、これには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() 文字列を式として評価します

最初に、フィールド（入力）の入力文字列にor aが含まれている1かどうかを確認0し、それが文字列になる左側のすべての文字を取得します!。いくつでも構いません。@Eval()それの世話をします。

次に!、文字列の末尾にがあるかどうかを確認します。我々は追加がある場合1に!、文字列（0!と1!両方とも1です-どのように多くの問題ではありません!最後にある文字は）それがないので、そうでない場合は、私たちは変わらず、最後の文字を追加!し、Aのいずれかです1か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バイトを保存し、長い関数名を持たない新しいバージョンとリターン
• -R（$argn使用可能にする）を使用して2バイトを保存しました

Bean、24バイト

Hexdump：

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つ以上の続く任意の数字置き換える!とし1、残りをすることができるように、evalのJavaScriptによって日間。

デモまたはテストスイートをお試しください