考虑过字母表语法{ 0， 1， ?， :}由定义的产生式规则

小号→交通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's 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中，106 101 100 90 83个字节

这在很大程度上依赖于模式Haskell的模式匹配功能。首先，我们反转字符串，以便可以仅搜索第一次出现的b:a?x（通常会读作x?a:b）并将其替换为它的值。这将自动提供正确的关联性。在这里，我们利用x:xs模式。该功能f正在执行此操作。然后，我们基本上f一遍又一遍地将其应用于输出，直到剩下单个数字（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字节

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

输出是\xff用于0与\x00供1。精明的实现必须允许转到起始单元格的左侧。

这使用了与xsot的Python 答案基本相同的方法，但是与我最初的82字节提交相比，分支可能更难遵循：

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

（对于此解决方案，输出为\xfefor 0和\xfffor 1，当输入以换行符结尾时，可实现更大的兼容性。）

如果您不愿意分析xsot的解决方案，那么您的想法就是这样：从左到右。如果看到，1?则将其贪婪地丢弃。如果看到的0?话，则丢弃该位置和相应位置之间的所有内容:。当?不显示为第二个字符时，请停止循环并打印剩余字符串的第一个字符。

因此，该82字节的解决方案实际上非常接近地反映了该方案。内循环处理0?，就像xsot的内循环一样。为了不进入任何输入字符就进入主循环要特别注意。也就是说，我们要检查第二个字符?在主循环结束时是否只是一次，而不是在进入主循环之前在开始时是否仅一次。

63字节的解决方案实质上将内部和外部循环组合为一个，我怀疑考虑到这些循环之间的相似性，这是可能的。主循环中的内存布局可以描述为：

[s] d c

其中[x]表示当前单元格- s以一个虚拟非零值开头，该值表示我们仍在循环，并立即用输入字符（0或1）覆盖。d如果我们位于a的中间0?，则该单元格保持（负）深度，否则为0。该c会是两种?或:或换行或EOF。

更新s和之后c，我们将0?通过相应地更新d并调整指针来处理这种情况，否则我们将使用当前值c作为d下一个迭代中的值，或者如果完成则停止。

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

打印1真实的输入和0。 在线尝试！ 不幸的是，最后一个测试用例在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字节

编辑：感谢@Zgarb 3个字节和@nimi 4个字节！

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=""。检查xis '1'或，'0'然后返回(a, r3)or (b, r3)。

JavaScript（ES6），53个字节

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

返回0或1用于有效输入；因无效输入而挂起。说明：因为在JavaScript中反转字符串很尴尬，所以我的第一个71字节尝试是通过对a使用负数超前工作来进行的?，否则会干扰关联性：

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个字节

完全 感谢@Mitch Swartch，因为他的解决方案比我的解决方案短14个字节！
也要感谢@Neil，他建议的解决方案比Mitch长1个字节。

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取决于，的真实性的块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'

与大多数其他模式匹配答案相似的想法。

伊迪奥。