Considere uma gramática sobre o alfabeto { 0, 1, ?, :} definido pela regra de produção

s → 0┃ 1┃ 0 ?s :s ┃ 1 ?s :s

Dada uma sequência gerada a partir de s , analise-a como uma expressão ?:associativa à direita (por exemplo, a?B?X:Y:c?d:e?f:gsignifica a?(B?X:Y):(c?d:(e?f:g))) e avalie-a com a seguinte semântica:

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

Se o resultado for 0 , produza algum valor fixo; se a saída for 1 , produza um valor fixo diferente. Especifique seus valores de saída escolhidos (por exemplo, 0/ 1ou False/ True) em sua resposta.

Casos de teste

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

Regras

• Você não pode usar built-ins de linguagem que interpretam seqüências de caracteres como código em alguma linguagem de programação e as executam (como JavaScript / Perl / Ruby / Python eval).
• Dito isto, seu código não realmente têm para analisar e, em seguida, avaliar a cadeia de entrada. Você pode adotar qualquer abordagem que alcance resultados equivalentes e não viole a regra anterior.
• Seu programa será verificado perl -le 'print eval<>'.
• O código mais curto (em bytes) vence.

GolfScript, 21 bytes

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

Isso gera 0ou 1. Presume-se que a entrada tenha uma única nova linha à direita. Usar ~(que avalia seqüências de caracteres) salvaria um byte:

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

Isso é baseado em http://golf.shinh.org/reveal.rb?The+B+Programming+Language/tails_1462638030&gs .

Retina , 23 bytes

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

Experimente online! (A primeira linha ativa um conjunto de testes separado por avanço de linha.)

Explicação

Na verdade, é bastante simples. A entrada é reduzida ao resultado +avaliando repetidamente ( ) ternários que contêm apenas literais. Para garantir que isso seja feito de maneira associativa, procuramos correspondências da direita para a esquerda ( r) e substituímos apenas a última correspondência que encontramos ( -1=).

A própria expressão regular corresponde 0\?.:e a remove (deixando apenas o material depois :) ou 1\?.:.e o substitui pelo valor após o ?.

Haskell, 106 101 100 90 83 bytes

Isso depende muito dos recursos de correspondência de padrões de Haskell. Antes de tudo, invertemos a string de modo que possamos buscar pela primeira ocorrência de b:a?x(que normalmente seria lida como x?a:b) e a substituímos por seu valor. Isso fornece automaticamente a associatividade correta . Aqui fazemos uso do x:xspadrão. É isso que a função festá fazendo. Basicamente, aplicamos fsua saída repetidamente, até termos um único número (0 ou 1).

Obrigado @Lynn por 12 bytes!

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 bytes

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

A saída é \xffpara 0e \x00para 1. A implementação do brainfuck deve permitir ir para a esquerda da célula inicial.

Isso usa essencialmente a mesma abordagem da resposta Python do xsot , mas a ramificação é provavelmente mais difícil de seguir em comparação com meu envio inicial de 82 bytes:

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

(Para esta solução, a saída é \xfepara 0e \xffpara 1, e uma compatibilidade mais ampla é alcançada quando a entrada termina com uma nova linha.)

Se você não se incomoda em analisar a solução da xsot, a idéia é a seguinte: Prossiga da esquerda para a direita. Se você 1?vir, descarte-o avidamente. Se você 0?vir, descarte tudo entre isso e o correspondente :. Quando ?não aparecer como o segundo caractere, pare o loop e imprima o primeiro caractere da seqüência restante.

Portanto, a solução de 82 bytes realmente reflete esse esquema de perto. O loop interno lida com 0?, assim como o loop interno do xsot. Alguns cuidados são tomados para entrar no loop principal sem verificar nenhum caractere de entrada; ou seja, queremos verificar se o segundo caractere é ?apenas uma vez no final do loop principal e não também no início antes de entrar no loop principal.

A solução de 63 bytes combina essencialmente os loops internos e externos em um, que eu suspeitava ser possível, dada a semelhança entre esses loops. O layout da memória no loop principal pode ser descrito como:

[s] d c

where [x]significa célula atual - scomeça como um valor fictício diferente de zero que apenas indica que ainda estamos em loop e é imediatamente substituído por um caractere de entrada ( 0ou 1). A dcélula mantém a profundidade (negativa) no caso de estarmos no meio de uma 0?, caso contrário 0. O cque vai ser ?ou :ou nova linha ou EOF.

Após a atualização se c, lidamos com o 0?caso atualizando de dacordo e ajustando o ponteiro; caso contrário, usamos o valor atual de ccomo o valor da dpróxima iteração ou paramos se tivermos terminado.

Python 2, 76 74 73 72 bytes

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

Com entrada como string literal para evitar raw_.

A saída é 0ou é 1seguida por <built-in function id>.

Python 2, 89 bytes

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

A entrada é aceita como uma string literal.

Grime , 34 31 bytes

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

Imprime 1para entradas 0verdadeiras e falsas. Experimente online! Infelizmente, o último caso de teste fica sem memória no TIO.

Explicação

A associatividade correta significa essencialmente que em a?b:c, asempre é um 0ou 1, nunca uma expressão mais longa. Definirei recursivamente um padrão que corresponda a uma expressão verdadeira como essa e verificarei a entrada. Também é desnecessário verificar se every :é realmente a :, se todos os ?s estão marcados: existe um número igual de ?s e :s na entrada e se alguns ?são classificados incorretamente como a :, o correspondente :falhará em corresponder e o emparelhamento do Grime o motor retornará.

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 bytes

Edit: Obrigado a @ Zgarb por 3 bytes e a @nimi por 4 bytes!

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

Essa é uma abordagem recursiva que abusa um pouco da regra de saída "algum valor fixo" . Edit: Livrar-se das tuplas não apenas salva 8 bytes, mas também produz uma saída melhor: "0"ou "1".

Versão não destruída:

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)

Como funciona?
A evalfunção percorre a árvore implícita das expressões

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

e retorna uma tupla do formulário (result, rest).
O primeiro padrão (x:'?':r1)corresponde xa '1'e r1para "0?0:1:0?1:0". Aplicando recursivamente evalpara r1avaliar a subexpressão 0?0:1e retornos (0,":0?1:0"). Combinar isso com o padrão (a,':':r2)gera a=0e r2=0?1:0. Essa subfórmula também é avaliada recursivamente para que b='0'e r3="". Verifique se xé '1'ou '0'e retorne (a, r3)ou (b, r3).

JavaScript (ES6), 53 bytes

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

Retorna 0ou 1para entrada válida; trava para entrada inválida. Explicação: como a reversão de uma string é desajeitada no JavaScript, minha primeira tentativa de 71 bytes funcionou usando um cabeçote negativo negativo para um ?que, de outra forma, perturbaria a associatividade:

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

Como isso foi um pouco longo, fiquei pensando se poderia melhorar as coisas incorporando a tomada de decisão no regexp. Como se viu, não foi um sucesso imediato, pois também levou 71 bytes:

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

Então me ocorreu que 0?0:e 0?1:sempre são não-ops, sem preocupação com associatividade. Isso me salvou quase 25%.

Perl, 32 + 1 ( -psinalizador) = 33 bytes

Crédito total para @Mitch Swartch , pois sua solução era 14 bytes menor que a minha!
Agradecemos também a @ Neil, que sugeriu uma solução 1 byte mais que Mitch.

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

Precisa de -psinalizador, bem como -M5.010ou -Epara executar. Por exemplo :

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"

Explicações : Basicamente, reduz os blocos de a?b:c(começando do final para garantir que não se ?segue) em bou cdependendo da verdade de a, repetidamente, até que a sequência contenha apenas 1ou 0.

Python 3, 93 69 bytes

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

Entrada é a sequência como uma lista de caracteres, a saída é "0"ou"1"

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

Versão não destruída:

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

Outra tentativa, mas com consideravelmente mais bytes:

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 (40 + 1 para -r) 41

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

Utilitários Bash + GNU, 42

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

Idéia semelhante à maioria das outras respostas de correspondência de padrões.

Ideone .