พิจารณาไวยากรณ์กว่าอักษร{ 0, 1, ?, :}กำหนดโดยกฎการผลิต

s →การ0┃ 1┃ 0 ?s :s ┃ 1 ?s :s

รับสตริงที่สร้างจากs , แยกมันเป็นนิพจน์ที่?:เป็นความสัมพันธ์ที่ถูกต้อง (ตัวอย่างเช่นa?B?X:Y:c?d:e?f:gหมายถึง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=)

regex ตัวเองทั้งการแข่งขัน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การใช้สมองต้องอนุญาตให้ไปทางซ้ายของเซลล์เริ่มต้น

วิธีนี้ใช้หลักการเดียวกับคำตอบ Python ของ xsot แต่การแตกแขนงอาจจะยากกว่าเมื่อเทียบกับการส่ง 82- ไบต์ของฉัน:

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

(สำหรับโซลูชันนี้เอาต์พุต\xfeสำหรับ0และ\xffสำหรับ1และความเข้ากันได้ที่กว้างขึ้นจะทำได้เมื่ออินพุตสิ้นสุดด้วยบรรทัดใหม่)

หากคุณไม่สามารถวิเคราะห์วิธีแก้ปัญหาของ xsot ได้แนวคิดก็คือดำเนินการต่อจากซ้ายไปขวา หากคุณเห็น1?แล้วละโมบทิ้งมัน ถ้าคุณเห็นทุกอย่างแล้วทิ้งระหว่างที่และสอดคล้องกัน0? :เมื่อ?ไม่ปรากฏเป็นอักขระตัวที่สองให้หยุดการวนซ้ำและพิมพ์อักขระตัวแรกของสตริงที่เหลือ

ดังนั้นวิธีแก้ปัญหาแบบ 82 ไบต์นั้นสะท้อนถึงรูปแบบนั้นอย่างใกล้ชิด ห่วงด้านในจับ0?เช่นเดียวกับวงในของ xsot มีการระมัดระวังบางอย่างเพื่อป้อนลูปหลักโดยไม่ตรวจสอบอักขระอินพุตใด ๆ นั่นคือเราต้องการตรวจสอบว่าตัวละครที่สองเป็น?เพียงครั้งเดียวในตอนท้ายของวงหลักและไม่ได้ที่จุดเริ่มต้นก่อนที่จะเข้าสู่วงหลัก

การแก้ปัญหา 63- ไบต์เป็นหลักรวมลูปด้านในและด้านนอกเป็นหนึ่งซึ่งฉันสงสัยว่าเป็นไปได้ที่ให้ความคล้ายคลึงกันระหว่างลูปเหล่านั้น เลย์เอาต์ของหน่วยความจำในลูปหลักสามารถอธิบายได้ดังนี้:

[s] d c

โดยที่[x]หมายถึงเซลล์ปัจจุบัน - sเริ่มต้นเป็นค่าที่ไม่ใช่ศูนย์จำลองที่เพิ่งบ่งบอกว่าเรายังคงวนลูปและจะถูกเขียนทับด้วยอักขระอินพุตทันที (อย่างใดอย่างหนึ่ง0หรือ1) dมือถือถือ (ลบ) ความลึกในกรณีที่เรายังอยู่ในช่วงของการเป็นอย่างอื่น0? เป็นไปได้อย่างใดอย่างหนึ่งหรือหรือขึ้นบรรทัดใหม่หรือ EOF0c?:

หลังจากอัปเดต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]

อินพุตถูกใช้เป็นตัวอักษรสตริง

Grime , 34 31 ไบต์

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

พิมพ์1สำหรับอินพุตที่เป็นความจริงและ0สำหรับคนที่เป็นเท็จ ลองออนไลน์! กรณีทดสอบล่าสุดน่าเสียดายที่หน่วยความจำหมดใน TIO

คำอธิบาย

ขวา associativity หลักหมายความว่าในa?b:c, aอยู่เสมออย่างใดอย่างหนึ่ง0หรือ1ไม่เคยแสดงออกอีกต่อไป ฉันจะกำหนดรูปแบบซ้ำ ๆ ซึ่งตรงกับนิพจน์ที่เป็นความจริงแบบนั้นและตรวจสอบอินพุตกับมัน นอกจากนี้ยังไม่จำเป็นที่จะต้องตรวจสอบว่าทุกคน:เป็น a จริง ๆ:ถ้า?มีการตรวจสอบทั้งหมด: มีจำนวน?s และ:s ที่เท่ากันในอินพุตและถ้าบางอย่าง?ถูกจัดประเภทอย่างไม่ถูกต้องเป็น a :ที่สอดคล้องกัน:จะล้มเหลว เครื่องยนต์จะย้อนกลับ

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

นี้เป็นวิธีการเวียนเกิดที่ค่อนข้างละเมิดสิทธิมนุษยชน "บางค่าคงที่" กฎ แก้ไข: การกำจัด tuples ไม่เพียง แต่ประหยัด 8 ไบต์ก็ยังดีกว่าผลผลิตออก A: หรือ"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

และส่งกลับ tuple (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- ไบต์แรกของฉันทำงานโดยใช้ lookahead เชิงลบ?ซึ่งจะรบกวนการเชื่อมโยง:

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

ตั้งแต่นี้ค่อนข้างนานฉันสงสัยว่าฉันจะปรับปรุงเรื่องต่าง ๆ ด้วยการรวมการตัดสินใจเข้ากับ regexp หรือไม่ เมื่อมันปรากฏออกมาก็ไม่ประสบความสำเร็จทันทีเนื่องจากใช้ 71 ไบต์ด้วย:

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

จากนั้นก็เกิดขึ้นกับฉันที่0?0:และ0?1:มักจะไม่มี ops โดยไม่ต้องกังวลสำหรับการเชื่อมโยง สิ่งนี้ช่วยฉันได้เกือบ 25%

Perl, 32 + 1 (-pแฟล็ก) = 33 ไบต์

ให้เครดิตกับ @Mitch Swartch อย่างเต็มที่เนื่องจากโซลูชันของเขาสั้นกว่าของฉัน 14 ไบต์!
ขอขอบคุณ@Neilที่แนะนำวิธีแก้ปัญหา 1 ไบต์ที่ยาวกว่า Mitch

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กว่าและมากกว่าจนกว่าสตริงมีเพียงหรือ10

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

อินพุตคือสตริงเป็นรายการของอักขระเอาต์พุตเป็น"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 (40 + 1 สำหรับ -r) 41

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

ยูทิลิตี Bash + GNU, 42

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

แนวคิดที่คล้ายคลึงกับคำตอบการจับคู่รูปแบบอื่น ๆ ส่วนใหญ่

ไอดีโอ