Pertimbangkan tata bahasa lebih alfabet { 0, 1, ?, :} yang didefinisikan oleh aturan produksi

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

Diberikan string yang dihasilkan dari s , parsing sebagai ekspresi di mana ?:asosiatif-benar (misalnya, a?B?X:Y:c?d:e?f:gberarti a?(B?X:Y):(c?d:(e?f:g))) dan mengevaluasinya dengan semantik berikut:

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

Jika hasilnya 0 , hasilkan beberapa nilai tetap; jika output 1 , output nilai tetap berbeda. Tentukan nilai output yang Anda pilih (misalnya 0/ 1, atau False/ True) dalam jawaban Anda.

Uji kasus

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

Aturan

• Anda tidak boleh menggunakan bahasa bawaan yang menafsirkan string sebagai kode dalam beberapa bahasa pemrograman dan menjalankannya (seperti JavaScript / Perl / Ruby / Python eval).
• Yang mengatakan, kode Anda sebenarnya tidak harus diuraikan dan kemudian mengevaluasi string input. Anda dapat mengambil pendekatan apa pun untuk mencapai hasil yang setara dan tidak melanggar aturan sebelumnya.
• Program Anda akan diperiksa perl -le 'print eval<>'.
• Kode terpendek (dalam byte) menang.

GolfScript, 21 byte

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

Ini menghasilkan 0atau 1. Input diasumsikan memiliki satu trailing newline. Menggunakan ~(yang mengevaluasi string) akan menghemat byte:

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

Ini didasarkan pada http://golf.shinh.org/reveal.rb?The+B+Programming+Language/tails_1462638030&gs .

Retina , 23 byte

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

Cobalah online! (Baris pertama memungkinkan suite tes yang dipisahkan dengan linefeed.)

Penjelasan

Ini sebenarnya cukup sederhana. Input dikurangi ke hasil dengan berulang kali ( +) mengevaluasi terner yang hanya mengandung literal. Untuk memastikan ini dilakukan dengan benar secara asosiatif, kami mencari kecocokan dari kanan ke kiri ( r) dan hanya mengganti kecocokan terakhir yang kami temukan ( -1=).

Regex itu sendiri cocok 0\?.:dan menghapusnya (hanya menyisakan barang setelah :) atau 1\?.:.dan menggantinya dengan nilai setelah ?.

Haskell, 106 101 100 90 83 byte

Ini sangat bergantung pada kemampuan pencocokan pola pola Haskell. Pertama-tama, kita membalikkan string sehingga kita bisa mencari kejadian pertama b:a?x(yang biasanya dibaca sebagai x?a:b) dan menggantinya dengan nilainya. Ini secara otomatis memberikan asosiasi yang tepat . Di sini kita menggunakan x:xspola. Inilah fungsi fyang dilakukan. Kemudian kami pada dasarnya berlaku funtuk output itu berulang-ulang, sampai kami memiliki satu nomor (0 atau 1) yang tersisa.

Terima kasih @ Lynn untuk 12 byte!

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 byte

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

Outputnya adalah \xffuntuk 0dan \x00untuk 1. Implementasi brainfuck harus memungkinkan untuk pergi ke kiri sel awal.

Ini pada dasarnya menggunakan pendekatan yang sama dengan jawaban Python xsot , tetapi percabangannya mungkin lebih sulit untuk diikuti dibandingkan dengan pengiriman 82 byte awal saya:

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

(Untuk solusi ini, output adalah \xfeuntuk 0dan \xffuntuk 1, dan kompatibilitas yang lebih luas dicapai ketika input berakhir dengan baris baru.)

Jika Anda tidak dapat repot-repot menganalisis solusi xsot, idenya adalah ini: Lanjutkan dari kiri ke kanan. Jika Anda melihat 1?maka dengan rakus buanglah. Jika Anda melihat 0?maka buang semuanya antara itu dan yang sesuai :. Ketika ?tidak muncul sebagai karakter kedua, hentikan perulangan dan cetak karakter pertama dari string yang tersisa.

Jadi, solusi 82-byte sebenarnya mencerminkan skema itu dengan cukup dekat. Loop dalam menangani 0?, seperti loop dalam xsot. Beberapa perhatian diambil untuk memasuki loop utama tanpa memeriksa karakter input apa pun; yaitu, kami ingin memeriksa apakah karakter kedua ?hanya sekali di akhir loop utama, dan tidak juga di awal sebelum memasukkan loop utama.

Solusi 63-byte pada dasarnya menggabungkan loop dalam dan luar menjadi satu, yang saya duga dimungkinkan karena kesamaan antara loop tersebut. Tata letak memori dalam loop utama dapat digambarkan sebagai:

[s] d c

di mana [x]berarti sel saat ini - sdimulai sebagai nilai bukan nol boneka yang hanya menunjukkan kita masih mengulang, dan segera ditimpa dengan karakter input (baik 0atau 1). The dsel memegang (negatif) kedalaman dalam kasus kita berada di tengah-tengah 0?, sebaliknya 0. The cakan menjadi baik ?atau :atau baris baru atau EOF.

Setelah memperbarui sdan c, kami menangani 0?kasing dengan memperbarui yang dsesuai dan menyesuaikan pointer, jika tidak kami menggunakan nilai saat ini csebagai nilai ddalam iterasi berikutnya, atau berhenti jika kami selesai.

Python 2, 76 74 73 72 byte

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

Dengan input sebagai string literal yang harus dihindari raw_.

Outputnya 0atau 1diikuti oleh <built-in function id>.

Python 2, 89 byte

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

Input diambil sebagai string literal.

Grime , 34 31 byte

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

Mencetak 1untuk input yang benar dan 0yang salah. Cobalah online! Kasing uji terakhir sayangnya kehabisan memori pada TIO.

Penjelasan

Asosiatif-kanan pada dasarnya berarti bahwa a?b:c, aselalu 0atau 1tidak pernah, merupakan ekspresi yang lebih panjang. Saya hanya akan secara rekursif mendefinisikan pola yang cocok dengan ekspresi yang benar seperti itu, dan memeriksa input yang menentangnya. Ini juga tidak perlu untuk memeriksa bahwa setiap :benar-benar a :, jika ?s semua dicentang: ada jumlah ?s dan :s yang sama dalam input, dan jika ada ?yang salah diklasifikasikan sebagai :, yang sesuai :akan gagal untuk mencocokkan, dan pencocokan Grime mesin akan mundur.

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 byte

Sunting: Terima kasih kepada @Zgarb selama 3 byte dan untuk @nimi selama 4 byte!

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

Ini pendekatan rekursif yang agak menyalahgunakan aturan "beberapa nilai tetap" . Sunting: Menyingkirkan tuple tidak hanya menghemat 8 byte, ia juga menghasilkan output yang lebih bagus: "0"atau "1".

Versi tidak disatukan:

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)

Bagaimana cara kerjanya?
The evalFungsi melintasi pohon implisit dari ekspresi

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

dan mengembalikan tuple formulir (result, rest).
Pola pertama (x:'?':r1)cocok xdengan '1'dan r1ke "0?0:1:0?1:0". Melamar secara rekursif evaluntuk r1mengevaluasi sub ekspresi 0?0:1dan pengembalian (0,":0?1:0"). Mencocokkan ini dengan (a,':':r2)hasil pola a=0dan r2=0?1:0. Sub-formula ini juga dievaluasi secara rekursif sehingga b='0'dan r3="". Periksa apakah xini '1'atau '0'dan kembali baik (a, r3)atau (b, r3).

JavaScript (ES6), 53 byte

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

Pengembalian 0atau 1untuk input yang valid; hang untuk input yang tidak valid. Penjelasan: karena membalikkan string adalah canggung dalam JavaScript, upaya 71-byte pertama saya berhasil dengan menggunakan lookahead negatif untuk ?yang akan mengganggu asosiatif:

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

Karena ini agak lama saya bertanya-tanya apakah saya bisa memperbaiki masalah dengan memasukkan pengambilan keputusan ke dalam regexp. Ternyata, itu bukan kesuksesan langsung, karena juga butuh 71 byte:

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

Kemudian terpikir olehku bahwa 0?0:dan 0?1:selalu tanpa usaha, tanpa memperhatikan asosiatif. Ini menyelamatkan saya hampir 25%.

Perl, 32 + 1 ( -pflag) = 33 byte

Penghargaan penuh untuk @Mitch Swartch , karena solusinya 14 byte lebih pendek dari saya!
Terima kasih juga kepada @Neil yang menyarankan solusi 1 byte lebih lama dari Mitch.

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

Membutuhkan -pflag, juga -M5.010atau -Euntuk menjalankan. Contohnya :

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"

Penjelasan : Ini pada dasarnya mengurangi bloka?b:c (mulai dari akhir untuk memastikan tidak ada yang ?mengikuti) menjadi batau ctergantung pada kebenaran a, berulang dan berulang sampai string hanya berisi 1atau 0.

Python 3, 93 69 byte

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

Input adalah string sebagai daftar karakter, output dapat "0"atau"1"

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

Versi tidak disatukan:

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

Percobaan lain, tetapi dengan byte lebih banyak:

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 untuk -r) 41

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

Utilitas Bash + GNU, 42

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

Ide yang mirip dengan sebagian besar jawaban pencocokan pola lainnya.

Ideone .