ค้นหาผลลัพธ์ของเกมแห่งสงคราม

เมื่อฉันอยู่ในโรงเรียนประถมมีเกม "Rock-Paper-Scissors" ที่เราเล่นในระหว่างการชุมนุมเมื่อรออาจารย์ของเราที่พักผ่อน ฯลฯ เราเรียกมันว่า "สงคราม" หลังจากที่บางค้นหา แต่ก็จะเปิดออกนี้เป็นตัวแปรที่ง่ายมากของ"ปืนลูกซองเกม" (ตาม wikiHow) ฉันจะเรียกมันว่า "สงคราม" เนื่องจากกฎแตกต่างกันเล็กน้อย:

2 คนนั่งตรงข้ามกัน เป้าหมายของเกมคือการ "ฆ่า" ผู้เล่นคนอื่น ทุกเทิร์นคุณสามารถเล่นหนึ่งใน 3 ท่าเคลื่อนไหว:

• โหลดใหม่ : คุณมีปืนที่บรรจุกระสุนนัดเดียว ต้องโหลดใหม่ก่อนจึงจะสามารถยิงได้ในแต่ละครั้ง โหลดซ้ำเมื่อคุณมีกระสุนถูกกฎหมาย แต่ไม่ทำอะไรเลย โหลดเป็นสัญลักษณ์โดยการแตะวัดของคุณด้วยมือทั้งสอง ผู้เล่นแต่ละคนเริ่มต้นด้วย 0 กระสุน

• Guard : การเคลื่อนไหวที่ปลอดภัยเพียงอย่างเดียว หากคุณถูกยิงขณะเฝ้าระวังคุณจะไม่ตาย การปกป้องเป็นสัญลักษณ์โดยการกางแขนโอบหน้าอก

• ไฟ : ยิงปืนของคุณ ในการยิงสำเร็จคุณจะต้องโหลดซ้ำตั้งแต่นัดสุดท้าย หากฝ่ายตรงข้ามกำลังโหลดใหม่คุณจะชนะ หากพวกเขายิงด้วยและคุณทั้งคู่มีกระสุนมันเป็นเรื่องเสมอ หากพวกเขากำลังปกป้องอยู่คุณก็สูญเสียกระสุนไป ในขณะที่การยิงโดยไม่มีกระสุนนั้นเป็นการเคลื่อนไหวที่ถูกกฎหมายมันไม่ทำอะไรเลยและทำให้คุณอ่อนแอเหมือนการโหลดซ้ำ การยิงถูกทำสัญลักษณ์โดยชี้ไปที่ผู้เล่นอื่น

มันเล่นคล้ายกับ RPS โดยที่ผู้เล่นแต่ละคนเลือกที่จะโยนลงไปพร้อมกัน (เราเคาะขาของเราสองครั้งในระหว่างรอบเพื่อให้เข้าจังหวะกัน แต่นั่นไม่สำคัญสำหรับความท้าทาย)

ความท้าทาย:

งานของคุณคือการค้นหาผลลัพธ์ของเกมสงคราม มันสามารถเป็นฟังก์ชั่นหรือโปรแกรมเต็มรูปแบบ

อินพุต

• ตัวเลือกผู้เล่นแต่ละคนเลือกแต่ละเทิร์นจะถูกแสดงด้วยตัวละคร / สตริง:

  • r : โหลดซ้ำ

  • g : การ์ด

  • f : ไฟ

• อินพุตจะเป็นรายการของคู่, สตริงที่มีการคั่น / ไม่ จำกัด หรือสิ่งอื่น ๆ ตามบรรทัดเหล่านี้

ตัวอย่างอินพุตใน Python อาจเป็น[("r", "g"), ("f", "r")]ความหมายในเทิร์นแรกที่ผู้เล่นคนแรกรีโหลดและผู้เล่นคนที่สองที่ได้รับการปกป้อง ในเทิร์นที่สองผู้เล่นคนแรกยิงขึ้นในขณะที่ผู้เล่นคนที่สองรีโหลด ผู้เล่นคนหนึ่งชนะเกมนี้ การป้อนข้อมูลเดียวกันอาจเลือกที่จะแสดงเป็น"r g f r", "rgfr", "rg fr" "rg-fr"...

คุณสามารถสมมติสิ่งต่อไปนี้:

• ข้อมูลที่ป้อนจะตรงกับรูปแบบที่คุณเลือกและจะมีเพียงอักขระที่ถูกต้องเท่านั้น

• บางคนจะตายภายใน 100 ตา

อย่างไรก็ตามคุณไม่สามารถสรุปได้ว่าการตายจะเกิดขึ้นเมื่อมีคนตาย

เอาท์พุต

ค่าที่ระบุว่าใครจะชนะ (หรือใครชนะก่อน*) คุณสามารถเลือกสิ่งที่จะส่งออกสำหรับแต่ละสถานการณ์ แต่ต้องบัญชีต่อไปนี้:

• ผู้เล่น 1 ชนะ

• ผู้เล่น 2 ชนะ

• พวกเขาฆ่ากัน (วาด)

ผลลัพธ์แต่ละรายการจะต้องมีค่าเขตและจะต้องเหมือนกันสำหรับแต่ละสถานการณ์

ตัวอย่างเช่นคุณสามารถแสดงผล1เมื่อผู้เล่น 1 ชนะ2เมื่อผู้เล่น 2 ชนะและ0ในกรณีที่เสมอ จากนั้นคุณจะต้องแสดงผลออกมาเสมอ1เมื่อผู้เล่น 1 ชนะ2เมื่อผู้เล่น 2 ชนะและ0ในกรณีที่เสมอ

สามารถส่งคืนหรือพิมพ์ไปยัง stdout ช่องว่างต่อท้ายเป็นเรื่องปกติ

สถานการณ์ที่นำไปสู่การเสมอคือถ้าผู้เล่นทั้งสองยิงและทั้งคู่มีกระสุน

*เนื่องจากในการท้าทายนี้การเลี้ยวอาจดำเนินต่อไปหลังจากมีคนเสียชีวิตมันเป็นไปได้ที่ผู้เล่นมากกว่า 1 คนอาจชนะในที่สุด คุณจำเป็นต้องค้นหาผู้ชนะก่อนตามอินพุท

กรณีทดสอบ (สมมติว่า1เมื่อ P1 ชนะ2เมื่อ P2 ชนะและ0เสมอ):

"rg fr" => 1 (P1 shot P2 while they were reloading)

"rg ff" => 1 (They both shot, but only P1 had ammo)

"rr ff" => 0 (Both had ammo and shot each other)

"rr ff rr fg" => 0 (Both had ammo and shot each other. Everything after the first win is ignored)

"rr fg rf" => 2 (P2 shot P1 while they were reloading)

"rf gg rr fg rr fr" => 1
    (P2 tried to shoot but didn't have any ammo, then they both guarded, then they both reloaded, then P2 blocked a shot, then they both reloaded again [but P2 still only has 1 ammo!], then P1 shoots P2 while they're reloading.

"rr gf fr rf gg rg ff" => 1
       ^ Player 1 wins here. The rest to the right has no effect on the output

นี่คือรหัสกอล์ฟดังนั้นจำนวนไบต์ที่น้อยที่สุดจะเป็นผู้ชนะ!

หมายเหตุตามที่กรณีทดสอบแสดงคุณต้องจัดการการเคลื่อนไหว "โง่" มันใช้ได้อย่างสมบูรณ์แบบสำหรับผู้เล่นที่พยายามยิงเมื่อไม่มีกระสุนหรือโหลด 2 รอบติดต่อกัน (และสะสมกระสุนเพียงนัดเดียว)

เรติน่า 36 ไบต์

s`(?<=r..([^f]..)*)f
!
A`g
G1`!
\w
_

รูปแบบอินพุตควรเป็นคู่ที่แยกกันของตัวป้อนบรรทัดเช่น

rr
fr

ผลลัพธ์คือ!_ผู้เล่น 1 ชนะ_!หากผู้เล่น 2 ชนะและ!!หากมีการเสมอกัน

ลองออนไลน์!(ชุดทดสอบที่ใช้การแยกพื้นที่เพื่อความสะดวก)

ฉันต้องมองข้ามความท้าทายนี้อย่างสมบูรณ์ ฉันแน่ใจว่าฉันจะลองใน Retina ก่อนหน้านี้อย่างอื่น :)

คำอธิบาย

s`(?<=r..([^f]..)*)f
!

เราเริ่มต้นด้วยการทำเครื่องหมายภาพ "ถูกต้อง" โดยการหมุนครั้งแรกfหลังจากที่แต่ละเข้าไปr !เราทำเช่นนี้โดยการจับคู่แต่ละfที่สามารถหาบนเครื่องเล่นเดียวกันโดยไม่ต้องข้ามไปอีกr fการ จำกัด การค้นหาไปยังrผู้เล่นเดียวกันนั้นทำได้ง่ายโดยการไปที่ตัวละครสามตัวพร้อมกัน

A`g

ตอนนี้เราละทิ้งทุกเทิร์นที่ใครบางคนปกป้องตัวเองไว้เพราะเทิร์นตอนจบไม่สามารถเป็นหนึ่งในนั้นได้

G1`!

ตอนนี้เราให้เพียง!เปิดครั้งแรกที่มี หากการยิงที่ถูกต้องเกิดขึ้น (และเรารู้ว่าไม่มีใครป้องกัน) เกมจะจบลง

\w
_

สุดท้ายเราต้องรวมสตริงที่จะให้ผลที่สอดคล้องกันและเราก็ทำเช่นนี้โดยการหมุนที่ไม่ใช่!ตัวอักษร (อย่างใดอย่างหนึ่งrหรือf) _ลง

Python ขนาด 139 ไบต์

c=d=0
for i in input():
 b=(c&(i=='fr'))-(d&(i=='rf'));p,q=i
 if b|(i=='ff')&c&d:print b;break
 c,d=(p=='r',i!='fg')[c],(q=='r',i!='gf')[d]

รับอินพุตบน stdin ในรูปแบบของรายการของสตริง 2 ตัวอักษร (เช่น ['rf', 'rr', 'rg', 'ff']) เอาท์พุต 1 หากผู้เล่น 1 ชนะ -1 ถ้าผู้เล่น 2 ชนะและ 0 สำหรับการเสมอ

คำอธิบาย:ตรวจสอบก่อนว่ามีใครยิงกระสุนหรือไม่ถ้าเกมจบลง จากนั้นเราจะตัดสินว่าผู้เล่นได้โหลดกระสุนใหม่หรือเปล่า

นี่คือ codegolf โพสต์แรกของฉัน :)

JavaScript (ES6), 108 107 93 91 89 85 ไบต์

บันทึก 4 ไบต์ด้วยความช่วยเหลือของ Titus

รับอินพุตเป็นอาร์เรย์ของสตริง 2 ตัวอักษรที่อธิบายการเคลื่อนไหวที่ผู้เล่นแต่ละคนเล่น

b=>b.map(c=>w=w||b&'312'[b=(s='0210231')[m='ffrfgrrggf'.search(c)]|s[m-2]&b,m],w=0)|w

ผลตอบแทน:

• 1 หากผู้เล่น 1 ชนะ
• 2 หากผู้เล่น 2 ชนะ
• 3 สำหรับการเสมอกัน

มันทำงานอย่างไร

เรายังคง bitmask bอธิบายว่าใครมีสัญลักษณ์แสดงหัวข้อโหลด:

• bit # 0: ผู้เล่น 1 มีกระสุน
• bit # 1: ผู้เล่น 2 มีกระสุน

เราใช้ลำดับ De Bruijn 'ffrfgrrggf'เพื่อระบุการเคลื่อนไหวที่เป็นไปได้ทั้ง 9 แบบ เราใช้ OR และ AND bitmasks เพื่ออัปเดตbตามชุดค่าผสมการย้าย เราใช้ชุดที่ 3 ของ bitmasks ซึ่งมี AND'ed กับการตัดสินผู้ชนะb w(เพียงสามชุดที่ชนะเป็นff, frและrf .)

เป็นที่น่าสังเกตว่ารูปแบบ OR และ AND สามารถจัดเก็บในรูปแบบเดียวกันโดยเลื่อนไปสองตำแหน่ง

 Index in | Combination | Bullet   | Bullet  | Winner
 sequence |             | AND mask | OR mask | mask
----------+-------------+----------+---------+--------
    0     |     ff      |    0     |    0    |   3
    1     |     fr      |    0     |    2    |   1
    2     |     rf      |    0     |    1    |   2
    3     |     fg      |    2     |    0    |   0
    4     |     gr      |    1     |    2    |   0
    5     |     rr      |    0     |    3    |   0
    6     |     rg      |    2     |    1    |   0
    7     |     gg      |    3     |    0    |   0
    8     |     gf      |    1     |    0    |   0

กรณีทดสอบ

let f =

b=>b.map(c=>w=w||b&'312'[b=(s='0210231')[m='ffrfgrrggf'.search(c)]|s[m-2]&b,m],w=0)|w

console.log(f(["rg","fr"]));                            // 1
console.log(f(["rg","ff"]));                            // 1
console.log(f(["rr","ff"]));                            // 3
console.log(f(["rr","ff","rr","fg"]));                  // 3
console.log(f(["rr","fg","rf"]));                       // 2
console.log(f(["rf","gg","rr","fg","rr","fr"]));        // 1
console.log(f(["rr","gf","fr","rf","gg","rg","ff"]));   // 1

Perl 6 , 71 62 ไบต์

{&[<=>](|map {m/r[..[r|g]]*.$^f/.to//∞},/[r|f]f/,/.f[r|f]/)}

โซลูชันที่ใช้ Regex

"rg fr"จะเข้าเป็นสตริงในรูปแบบที่
ทั้งสามเอาท์พุทที่เป็นไปได้ค่า enum More(ผู้เล่น 1 วอน) Less(ผู้เล่นที่ 2 วอน) Same(วาด) - ซึ่งกลายเป็นคำพูดเหล่านั้นเมื่อพิมพ์หรือเข้า1, -1, 0เมื่อบังคับให้ตัวเลข

ลองออนไลน์!

มันทำงานอย่างไร

• map { m/r[..[r|g]]*.$^f/.to // ∞ }, /[r|f]f/, /.f[r|f]/

  ดำเนินการจับคู่ regex สองรายการบนอินพุต หลังจากการแก้ไขทั้งสอง regexes คือ:

  • r[..[r|g]]*.[r|f]f - จับคู่ช็อตแรกที่สำเร็จโดยผู้เล่น 2
  • r[..[r|g]]*..f[r|f] - จับคู่ช็อตแรกที่สำเร็จโดยผู้เล่น 1

  ในแต่ละกรณีจะส่งคืนตำแหน่งสิ้นสุดของการแข่งขัน ( .to) หรือไม่มีที่สิ้นสุดหากไม่มีการแข่งขัน

• &[<=>](|   )

  ใช้<=>โอเปอเรเตอร์กับตำแหน่งสิ้นสุดการแข่งขันทั้งสอง ส่งคืนค่าจากOrder enum ( More, LessหรือSame) ขึ้นอยู่กับว่าอาร์กิวเมนต์แรกมากกว่าหรือน้อยกว่าหรือเท่ากับสอง

Haskell , 101 91 87 ไบต์

n!(c:r)|'g'>c=n:1!r|'g'<c=1:0!r|1<3=2:n!r
_!r=[]
a#b=[x|x@(y,z)<-zip(1!a)$1!b,2>y+z]!!0

ลองออนไลน์! ฟังก์ชั่น infix #ใช้สองสายที่แสดงถึงการกระทำของผู้เล่นสองคนแต่ละคนและส่งคืน(0,1)หากผู้เล่น 1 ชนะ(1,0)สำหรับผู้เล่น 2 และ(0,0)เพื่อเสมอ

ตัวอย่างการใช้งาน:

Prelude> "rgrfrf" # "fgrgrr"
(0,1)

คำอธิบาย:

ฟังก์ชั่น infix !แปลลำดับของการกระทำ'r'(โหลด), 'f'(ไฟ) และ'g'(ยาม) เป็นลำดับของการกระทำที่สังเกตได้0(ไฟจริง), 1(ไม่มีการกระทำ) และ2(การ์ด) ที่การกระทำไฟจะนับเฉพาะการกระทำไฟจริงเท่านั้นถ้ากระสุนถูกโหลดและไม่มีการดำเนินการเป็นอย่างอื่น เพื่อให้บรรลุถึงสิ่งนี้อาร์กิวเมนต์แรกnคือ0ถ้ากระสุนถูกโหลดและ1ถ้าปืนไม่ได้โหลด วิธีนี้แต่ละคนก็สามารถถูกแทนที่ด้วยปัจจุบัน'f' n(n=0 -> โหลด -> ไฟจริง -> 0, n=1-> ไม่โหลด -> ไม่มีการกระทำ -> 1)

n ! (c:r)                -- n is 0 or 1, c is 'f', 'g' or 'r' and r the rest of the string
    |'g'>c = n : (1 ! r) -- c is smaller 'g', so it must be 'f'. append n to the list
                         --  and set load status to 1 (unloaded)
    |'g'<c = 1 : (0 ! r) -- c is larger 'g', so it must be 'r'. append 1 (no action)
                         --  and set load status to 0 (loaded)
    |1<3   = 2 : (n ! r) -- c must be equal to 'g'. append 2 (guard)
                         --  and leave the load status unchanged
_ ! r = []               -- base case for recursion

ความเป็นไปได้ที่เกิดขึ้นเก้าประการนั้นคือ

• (0,0): ผู้เล่นทั้งสองยิงและตายจบเกม
• (0,1)หรือ(1,0): ผู้เล่นคนหนึ่งยิงผู้อื่นจบเกม
• (0,2) หรือ (2,0) : ผู้เล่นคนหนึ่งยิง แต่ผู้พิทักษ์คนอื่นเกมยังคงดำเนินต่อไป
• (1,1), (1,2), (2,1)หรือ(2,2) : ไม่มีผู้เล่นยอดเกมอย่างต่อเนื่อง

ด้วยการออกแบบผลรวมของตัวเลือกการสิ้นสุดเกมนั้นมีขนาดเล็กกว่า 2 และผลรวมของแต่ละเกมที่มีความเป็นไปได้ที่จะมีขนาดใหญ่กว่าหรือเท่ากับ 2 ผลของเกมคือ tuple ตัวแรกที่มีผลรวมน้อยกว่า 2

a#b=[x|         -- build the list of all x
    x@(y,z) <-  -- where x is an alias for the tuple (y,z) which is drawn from the list
    zip (1!a)   -- of tuples where the first component is from 1!a = eg. [1,2,1,0,1,0] 
        (1!b)   -- and the second from 1!b = eg. [1,2,1,2,1,1]
    , 2 > y+z]  -- and y+z are smaller 2.
    !!0         -- return the first element of this list

แบตช์ 249 ไบต์

@echo off
set g=goto gg
set/ax=y=0
:gg
shift&goto %1
:fg
set x=0
%g%
:gf
set y=0
%g%
:rr
set/ax=y=1
%g%
:fr
if %x%==1 exit/b1
:gr
set y=1
%g%
:rf
if %y%==1 exit/b2
:rg
set x=1
%g%
:ff
set/az=3-x-x-y
if %z%==3 %g%
exit/b%z%

อินพุตอยู่ในรูปแบบของคู่อักขระสำหรับแต่ละเทิร์นและเอาท์พุทตามระดับข้อผิดพลาด (0 = วาด, 1 = ผู้เล่น 1, 2 = ผู้เล่น 2) xและyติดตามว่าผู้เล่นมีกระสุนหรือไม่ดังนั้นเมื่อทั้งคู่ยิงออกผลลัพธ์จะเป็น3-x-x-yเว้นแต่ว่าเป็น 3 ซึ่งในกรณีนี้เราจะไปต่อ ในบรรทัดที่ 5 ฉันใช้เครื่องมือแยกวิเคราะห์ข้อความในชุด - %1(ซึ่งเป็นการย้ายปัจจุบัน) ถูกแทนที่ก่อนที่shiftคำสั่งจะดำเนินการและลบออกดังนั้นเราจึงยังคงไปที่ป้ายกำกับที่ถูกต้อง

Clojure, 168 ไบต์

#(reduce(fn[[l L r R][a A]](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)][l L r R])[l L r R]))[1 1 nil nil]%)

ตีกอล์ฟน้อยลง (ถ้าทั้งสองคนยังมีชีวิตอยู่เราใช้Mเพื่ออัปเดตกระสุนและสถานะชีวิตของศัตรูมิฉะนั้นเราจะคืนสถานะปัจจุบัน):

(def f (fn[A] (reduce
                (fn [[l1 l2 r1 r2] [a1 a2]]
                  (if (and l1 l2)
                    (let[M (fn [r1 a1 a2]
                             (if (and(= a1 \f)r1)
                               [false (= a2 \g)]        ; we lost the ammo, a2 lives if he was guarding
                               [(or(= a1 \r)r1) true])) ; we might gain or keep ammo, a2 lives no matter what
                         [r1 l2] (M r1 a1 a2)
                         [r2 l1] (M r2 a2 a1)]
                      [l1 l2 r1 r2])
                    [l1 l2 r1 r2]))
                [true true false false] A)))

ตัวอย่างการใช้งาน (องค์ประกอบแรกบอกว่าผู้เล่น 1 ยังมีชีวิตอยู่ในตอนท้ายเกมองค์ประกอบที่สองบอกว่าผู้เล่น 2 ยังมีชีวิตอยู่หรือไม่อันดับ 3 และ 4 บอกสถานะกระสุนซึ่งไม่เกี่ยวข้องเมื่อพิจารณาผู้ชนะ):

(-> (for[[a b s] (partition 3 "rr fg rf fr ")][a b]) f (subvec 0 2))

Update: ดูสิว่ามันloopมีความยาวเท่ากัน! ผมพบว่ารุ่นได้ง่ายขึ้นในการพัฒนาเท่าที่คุณสามารถตรวจสอบรัฐกลางถ้าคุณใช้reducereductions

#(loop[l 1 L 1 r nil R nil[[a A]& I]%](if(and l L)(let[M(fn[r a A](if(and(= a \f)r)[nil(= A \g)][(or(= a \r)r)1]))[r L](M r a A)[R l](M R A a)](recur l L r R I))[l L]))

PHP, 107 101 90 ไบต์

ใช้ bit mask $ d สำหรับสถานะการโหลดและลำดับ DeBruijn สำหรับการยิง

for(;!$x=$d&strpos(_frff,$m=$argv[++$i]);)$d=$d&g<$m|h<$m|2*($d/2&f<$m[1]|g<$m[1]);echo$x;

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง 2 อักขระรันด้วย -nrตัวละครอาร์กิวเมนต์บรรทัดคำสั่งเรียกใช้ด้วย

1 = ผู้เล่น 1 ชนะ
2 = ผู้เล่น 2 ชนะ
3 = เสมอ

ชำรุด

for(;!$x=$d&strpos(_frff,       // 1. $x=someone dies, loop while not
    $m=$argv[++$i]          // loop throug moves
);)
    $d=
        $d&g<$m|h<$m            // 2. unload/reload Player 1 = bit 0
    |2*(
        $d/2&f<$m[1]|g<$m[1]    // 3. unload/reload Player 2 = bit 1
    );
echo$x;

• ลำดับ DeBruijn: fr :: position = 1 = P1 ไฟ; rf= ตำแหน่ง 2 = P2 ไฟff = ตำแหน่ง 3 = ทั้งไฟ
• g<$m<=> f<$m[0]( f<$mเป็นจริงเสมอเนื่องจากมีอักขระตัวที่สอง)

Python ขนาด 200 ไบต์

def war_game(turns):
    turn=0
    player1=True
    player2=True
    ammo1=False
    ammo2=False
    while turn<len(turns):
        if turns[turn][0]=='f' and ammo1==True and turns[turn][1]!='g':
            player2=False
        elif turns[turn][0]=='f' and turns[turn][1]=='g':
            ammo1=False
        elif turns[turn][0]=='r':
            ammo1=True
        if turns[turn][1]=='f' and ammo1==True and turns[turn][0]!='g':
            player1=False
        elif turns[turn][1]=='f' and turns[turn][0]=='g':
            ammo2=False            
        elif turns[turn][1]=='r':
            ammo2=True
        if player2==False or player1==False:
            break
        turn+=1
    if player1==True and player2==False:
        print('Player 1 wins')
        return 1
    elif player1==False and player2==True:
        print('Player 2 wins')
        return 2
    print('Draw')
    return 0

Clojure, 180 173 ไบต์

(fn[t](loop[z nil x nil[[c v]& r]t](let[k #(and %3(= %\f)(not= %2\g))h #(and(not= %\f)(or %2(= %\r)))q(k v c x)w(k c v z)](cond(and q w)0 q 2 w 1 1(recur(h c z)(h v x)r)))))

-7 ไบต์โดยการเปลี่ยนฟังก์ชั่นเป็นฟังก์ชั่นเต็มรูปแบบแทนการใช้แมโคร ให้ฉันทำมาโครฟังก์ชั่นด้านในซึ่งช่วยประหยัดนิดหน่อย

นี่เป็นทางออกที่แท้จริงมาก ฉันเป็นคนช่างคิดมากเพราะฉันเพิ่งเขียนเวอร์ชันเต็มของเกมและนี่เป็นอัลกอริทึมที่ฉันใช้ อาจมีการเพิ่มประสิทธิภาพหลายอย่างที่ฉันทำได้ แต่ฉันมีความสุขมาก ดูรหัส pregolfed สำหรับคำอธิบาย

(defn outcome [turns] ; Take input as ["rr" "ff"]
  (loop [p1-ammo? false ; Keep track of if each player has ammo
         p2-ammo? false
         [[p1-move p2-move] & rest-turns] turns] ; Deconstruct the turns out

    (let [killed? (fn [m m2 a] (and a (= m \f) (not= m2 \g))) ; Function that checks if one player killed the other
          has-ammo? (fn [m a] (and (not= m \f) (or a (= m \r)))) ; Function that decides if a player has ammo in the
                                                                 ;  next turn
          p1-killed? (killed? p2-move p1-move p2-ammo?) ; Check if each player was killed.
          p2-killed? (killed? p1-move p2-move p1-ammo?)]

      (cond ; Check who (if any) died. If no one died, recur to next turn.
        (and p1-killed? p2-killed?) 0
        p1-killed? 2
        p2-killed? 1
        :else (recur (has-ammo? p1-move p1-ammo?)
                     (has-ammo? p2-move p2-ammo?)
                     rest-turns)))))