アルファベット上文法を考える{ 0、 1、 ?、 :}によって定義されるプロダクションルール

S→ 0┃ 1┃ 0 ?秒:秒┃ 1 ?秒:秒

sから生成された文字列が与えられると、それを?:右結合式（たとえば、a?B?X:Y:c?d:e?f:gmeans a?(B?X:Y):(c?d:(e?f:g))）の式として解析し、次のセマンティクスで評価します。

eval(0) = 0
eval(1) = 1
eval(0?a:b) = eval(b)
eval(1?a:b) = eval(a)

結果が0の場合、固定値を出力します。出力が1の場合、異なる固定値を出力します。回答で選択した出力値（0/ / 1またはFalse/ True）を指定します。

テストケース

0 -> 0
1 -> 1
0?0:1 -> 1
0?1:0 -> 0
1?0:1 -> 0
1?1:0 -> 1
0?1?0:1:1 -> 1
1?0?1:1:1 -> 1
1?0:1?0:1?1:1 -> 0
1?1?1:0?1?0:0:0:0 -> 1
1?0:1?0?1:1?1:0:1?1?1:1:1?0:1 -> 0
1?1?1:0?0?1:1:0?1:0:1?1?0?0:0:1?1:0:0?1?0:1:1?0:1 -> 1
0?0?1?0?0:1:0?0:0:0?0?1:1:1?0:1:0?0?0?1:0:0?1:1:1?1?0:1:1 -> 0

ルール

• 文字列を一部のプログラミング言語のコードとして解釈して実行する言語組み込み機能（JavaScript / Perl / Ruby / Pythonなど）を使用することはできませんeval。
• つまり、実際にコードを解析して入力文字列を評価する必要はありません。同等の結果を達成し、前のルールに違反しないアプローチをとることができます。
• プログラムはに対してチェックされますperl -le 'print eval<>'。
• 最短のコード（バイト単位）が優先されます。

GolfScript、21バイト

2/-1%{)2%{0`=@@if}*}/

これは0またはを出力します1。入力には、単一の末尾改行があると想定されます。使用して~バイトを保存します（文字列を評価します）：

2/-1%{)2%{~!@@if}*}/

これはhttp://golf.shinh.org/reveal.rb?The+B+Programming+Language/tails_1462638030&gsに基づいています。

網膜、23バイト

r-1=+`0\?.:|1\?(.):.
$1

オンラインでお試しください！（最初の行は、改行で区切られたテストスイートを有効にします。）

説明

実際には非常に簡単です。入力は、+リテラルのみを含む三項を繰り返し評価することにより結果に還元されます。これが右連想的に行われることを確認するために、右から左にr一致を探し（-1=）、最後に見つかった一致のみを置き換えます（）。

正規表現自体は、一致して0\?.:それを削除するか（の後のものだけを残す:）、またはの1\?.:.後の値に置き換え?ます。

Haskell、106101100 90 83バイト

これは、パターンHaskellのパターンマッチング機能に大きく依存しています。まず最初に、文字列を反転して、最初に出現するb:a?x（通常はとして読み取られるx?a:b）だけを検索し、その値で置き換えることができるようにします。これにより、適切な結合性が自動的に提供されます。ここでは、x:xsパターンを使用します。これは、関数fが実行していることです。その後、基本的fには、1つの数値（0または1）が残るまで、出力に繰り返し適用します。

@ Lynn、12バイトありがとう！

f(b:':':a:'?':x:l)|x>'0'=a:l|1>0=b:l
f(x:l)=x:f l
f x=x
until((<2).length)f.reverse

Brainfuck、82 64 63バイト

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

出力は\xfffor 0および\x00for 1です。Brainfuckの実装では、開始セルの左側への移動を許可する必要があります。

これは本質的にxsotのPython answerと同じアプローチを使用しますが、分岐は最初の82バイトのサブミッションと比較してたぶん難しいでしょう：

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

（このソリューションでは、出力は\xfefor 0と\xfffor 1であり、入力が改行で終了すると、より広い互換性が実現します。）

xsotのソリューションを分析するのが面倒な場合、アイデアは次のとおりです。左から右に進んでください。表示された場合1?、貪欲に破棄します。表示されている場合は0?、それと対応するの間のすべてを破棄します:。?が2番目の文字として表示されない場合、ループを停止し、残りの文字列の最初の文字を出力します。

したがって、82バイトのソリューションは、実際にそのスキームをかなり厳密に反映しています。内側のループは0?、xsotの内側のループと同じように処理します。入力文字をチェックせずにメインループに入るように注意します。つまり、?メインループに入る前の最初の文字ではなく、メインループの最後で2番目の文字が1回だけであるかどうかを確認する必要があります。

63バイトのソリューションは、本質的に内側と外側のループを1つに結合します。これらのループ間の類似性を考えると、これは可能だと思われます。メインループのメモリレイアウトは次のように説明できます。

[s] d c

where [x]は現在のセルを意味しsます- まだループしていることを示すダミーのゼロ以外の値として始まり、入力文字（0または1）ですぐに上書きされます。d細胞は、我々は途中にある場合に（負）の深さを保持している0?それ以外の場合は、0。cどちらかになるだろう?か、:改行またはEOFか。

とを更新sした後、それに応じて更新してポインタを調整することでケースcを処理します。そうでない場合は、次の反復での値として現在の値を使用します。0?dcd

Python 2、76 74 73 72バイト

a=`id`
for c in input()[::-1]:a=(c+a,a[ord(c)*7%9]+a[4:])[a>'?']
print a

を避けるため、文字列リテラルとして入力しますraw_。

出力は0またはが1続き<built-in function id>ます。

Python 2、89バイト

s=input()
while'?'<=s[1:]:
 n=s<'1'
 while n:s=s[2:];n+=-(s[1]<'?')|1
 s=s[2:]
print s[0]

入力は文字列リテラルとして取得されます。

グライム、34 31バイト

E=d|d\?E.E
e`\1|\1\?_.E|\0\?E._

プリント1truthy入力用と0falsyもののために。 オンラインでお試しください！ 残念ながら、最後のテストケースではTIOのメモリが不足しています。

説明

右結合性は、本質的であることを意味しa?b:c、a常にどちらかではない0か1、長く表現決して。そのような真実の表現に一致するパターンを再帰的に定義し、それに対して入力をチェックします。sがすべてチェックされている場合、すべて:が実際にa :であることをチェックする必要もありません。入力?に?sと:sの数が等しく、一部?がaとして誤って分類された:場合、対応:するものは一致せず、Grimeの一致しますエンジンはバックトラックします。

E=d|d\?E.E
E=                      Define nonterminal E (for "expression") as
  d|                     a digit, OR
    d                    a digit,
     \?                  a literal ?,
       E                 a match of E,
        .                any character (will match a :), and
         E               another match of E.
e`\1|\1\?_.E|\0\?E._
e`                      Match entire input against this pattern (truthy expression):
  \1|                    a literal 1, OR
     \1\?                a literal 1?,
         _               a recursive match of truthy expression,
          .              any character (will match a :), and
           E|            any expression, OR
             \0\?E._     the same, but with 0 in front, and _ and E swapped.

Haskell、79 71 70 62 60 56バイト

編集： 3バイトの@Zgarbと4バイトの@nimiに感謝します！

e(x:'?':r)|a:_:s<-e r=last$e s:[a:tail(e s)|x>'0']
e x=x

これは、「何らかの固定値」出力規則を多少乱用する再帰的なアプローチです。編集：タプルを取り除くことは8バイトを節約するだけでなく、より良い出力をもたらします："0"または"1"。

ゴルフされていないバージョン：

eval (x:'?':r1) = if x=='1' then (a, r3) else (b, r3)
    where (a,':':r2) = eval r1
          (b, r3)    = eval r2
eval (x:r) = (x,r)

どのように機能しますか？この関数は、式の暗黙のツリーをトラバース
eval

eval 1?0?0:1:0?1:0 -> eval 1?          :
                             eval 0?0:1 eval 0?1:0

そして、形式のタプルを返します(result, rest)。
最初のパターンが(x:'?':r1)一致するxまで'1'とr1します"0?0:1:0?1:0"。再帰的に適用evalしr1て部分式を評価し、0?0:1を返します(0,":0?1:0")。これをパターンに一致さ(a,':':r2)せるa=0と、とが得られr2=0?1:0ます。また、この部分式は再帰的に評価されるため、b='0'およびr3=""です。かどうかをチェックしxている'1'か'0'とリターンのいずれか(a, r3)または(b, r3)。

JavaScript（ES6）、53バイト

f=s=>s[1]?f(s.replace(/0\?.:|1\?(.):.(?!\?)/,"$1")):s

戻り値0または1有効な入力のために、無効な入力に対してハングします。説明：JavaScriptでは文字列の反転が厄介であるため、最初の71バイトの試みは、?そうでなければ結合性を妨げる負の先読みを使用して機能しました。

f=s=>s[1]?f(s.replace(/(.)\?(.):(.)(?!\?)/,(_,a,b,c)=>+a?b:c)):s

これはやや長かったので、意思決定を正規表現に組み込むことで問題を改善できるかどうか疑問に思いました。判明したように、71バイトもかかったため、すぐに成功するわけではありませんでした。

f=s=>s[1]?f(s.replace(/0\?.:(.)(?!\?)|1\?(.):.(?!\?)/,"$1$2")):s

それから、私は0?0:、0?1:連想性を気にすることなく、常に何もしないことを知りました。これにより、約25％節約できました。

Perl、32 + 1（-pフラグ）= 33バイト

彼の解決策は私のものよりも14バイト短いため、@ Mitch Swartchの功績 です！Mitchより1バイト長いソリューションを提案
してくれた@Neilにも感謝します。

s/.*\K(0\?..|1\?(.)..)/\2/&&redo

ニーズ-pフラグを、だけでなく、-M5.010または-E実行します。例えば ​​：

perl -pE 's/.*\K(0\?..|1\?(.)..)/\2/&&redo' <<< "0
0?0:1
0?1?0:1:1
1?0:1?0?1:1?1:0:1?1?1:1:1?0:1
0?0?1?0?0:1:0?0:0:0?0?1:1:1?0:1:0?0?0?1:0:0?1:1:1?1?0:1:1"

説明：これは、基本的にブロック削減a?b:c（なしは確かに終わりから始め?に従う）bまたはcのtruthnessに応じて、a文字列のみを含むようになるまで何度も繰り返しを、1か0。

Python 3、93 69バイト

def f(s):z=s.pop;r=z(0);return s and':'<z(0)and(f(s),f(s))[r<'1']or r

入力が文字のリストとして文字列で、出力のいずれかです"0"か"1"

>>>f(list("0?0:1"))
<<<"1"

ゴルフされていないバージョン：

def parse(s):
    predicate = s.pop(0)
    if s and s.pop(0) == '?':
        left, right = parse(s), parse(s)
        if predicate == '0':
            return right
        return left
    return predicate

別の試みが、かなり多くのバイトで：

i=input()[::-1]
a=[i[0]]
for o,z in zip(i[1::2],i[2::2]):a+=[z]if o<'?' else[[a.pop(),a.pop()][z>'0']]
print(a[0])

SED、75 74 68（-rの場合は40 + 1）41

:
s,(.*)1\?(.):.,\1\2,
s,(.*)0\?.:,\1,
t

Bash + GNUユーティリティ、42

rev|sed -r ':
s/(.):.\?0|.:(.)\?1/\1\2/
t'

他のほとんどのパターンマッチング回答と同様のアイデア。

イデオネ。