ดังที่เราได้เรียนรู้จาก IBM PC AT, YouTube (ดูวิดีโอ) , Wikipedia (ดูบทความ)และ Sesame Street:

ตัวอักษรHเป็นตัวอักษรที่ไร้ความปราณีที่สุดของตัวอักษร !

(แม้ว่าจริง ๆ แล้วประกอบด้วยสององค์ประกอบในรหัสหน้า 437 ที่จริงแล้วมันไร้ความปราณียิ่งกว่านั้น)

เหมือนเอเลี่ยนในเอ่อ ... เอ่อ ... เอเลี่ยนสัตว์ร้ายไล่ตามทุกคนที่กล้าเข้ามาใกล้ไข่ของพวกมัน ไม่มีเหตุผลกับพวกเขา คุณจะต้องสควอชพวกเขาหากไม่ให้ตาย

สำหรับสถานการณ์นี้เราจะสมมติว่าคุณยังอยู่กับชีวิตสุดท้ายของคุณและคุณได้พบกับ Beasts ธรรมดาในภูมิประเทศที่ไม่มีไข่ คุณไม่มีปุ่มกดตัวเลขและสามารถเลื่อนขึ้น / ลง / ซ้าย / ขวาได้โดยตรง ... แต่สัตว์มีปุ่มเดียวและสามารถเคลื่อนที่ในแนวทแยงมุมได้

ตัวเลือกการเคลื่อนที่ของสัตว์เดรัจฉานในตัวเลือกของมันจะเป็นสิ่งที่ช่วยลดระยะห่างจากผู้เล่นให้เหลือน้อยที่สุด ถ้าระยะทางเท่ากันแล้วการแตกไทจะทำได้โดยการเลือกซ้าย + ขึ้นไปทางขวา + ลง แต่นี่คือเมทริกซ์ disambiguation ที่ชัดเจนเกี่ยวกับมัน ... จำนวนต่ำสุดที่จะทำให้ไทเบรค:

1 3 4
2 H 5
6 8 7

สัตว์ร้ายไม่เคยหลับ แต่โชคดีที่ช้ากว่าผู้เล่นเล็กน้อย พวกเขาขยับทุก ๆ เทิร์น (ให้ผู้เล่นเริ่มต้นโดยเริ่มต้นการสลับกับเทิร์นที่สอง) พวกเขาจะต้องย้ายถ้าเป็นไปได้โดยไม่คำนึงว่ามันจะพาพวกเขาไปไกลกว่าจากผู้เล่น

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

อินพุต

1. คู่ของจำนวนเต็มระบุขนาดของแผนที่ในคอลัมน์แล้วแถว

2. จำนวนแถวของบรรทัดอินพุตแต่ละขนาดคอลัมน์ ... ที่มีทั้ง solid wall ( #), wall movable ( ~), beast ( H), beast ( ), player ( O) หรือแค่เว้นวรรค

3. อินพุตที่จะเป็น U, D, L, R ซึ่งระบุว่าผู้เล่นพยายามย้าย ... หรือ W เพื่อรอ โปรดทราบว่าการพยายามดันกำแพงที่สามารถเคลื่อนย้ายได้ซึ่งถูกบล็อกเป็นอินพุตที่ถูกกฎหมายจะทำให้ไม่มีการดำเนินการใด ๆ

เอาท์พุต

1. aHHHH! ถ้าสัตว์ร้ายฆ่าผู้เล่น ... หรือไม่มีอะไรเลยถ้าผู้เล่นชนะโดยไม่เหลือสัตว์

2. คะแนน

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

ชี้แจง

• แผนที่รับประกันว่าจะถูกล้อมรอบด้วยกำแพงทึบ

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

• สัตว์ที่มีการเคลื่อนไหวในแนวทแยงสามารถเคลื่อนย้ายเข้าไปในพื้นที่แนวทแยงที่เปิดอยู่โดยไม่คำนึงว่ามันต้องการการบีบระหว่างผนังหรือไม่

• ผู้เล่นสามารถดันกำแพงที่เคลื่อนที่ได้จำนวนหนึ่งในแนวใดก็ได้โดยมีพื้นที่หรือสัตว์ร้ายอยู่อีกด้านหนึ่ง แต่พยายามผลักดันกำแพงรถไฟเข้าไปในสัตว์ร้ายที่ไม่ได้ถูกตรึงระหว่างกำแพงถือว่าสัตว์ร้ายนั้นเป็นเหมือนกำแพงและจะไม่ยอมให้มีการเคลื่อนไหว

• การตัดสินใจย้ายของเดรัจฉานระหว่างเทิร์นเทิร์นอิงจากตำแหน่งของผู้เล่นในตอนเริ่มเทิร์น การเพิ่มประสิทธิภาพที่ต้องการของ "ระยะทางสู่ผู้เล่น" นั้นผ่านการคำนวณแบบ "เหมือนอีกาบิน" การประมาณใด ๆ ซึ่งจะให้ผลลัพธ์เช่นเดียวกับที่วัดจากศูนย์กลางของจัตุรัสถึงศูนย์กลางของจัตุรัสของผู้เล่นนั้นดี

• หากสัตว์เดรัจฉานไม่สามารถทำสิ่งที่จะเป็นครั้งแรกที่ต้องการย้ายในเทิร์นเพราะสัตว์ที่มีลำดับความสำคัญสูงกว่าเอามันก็จะเลือกที่ดีที่สุดต่อไปเมื่อเทียบกับการอยู่ในสถานที่ (ถ้ายังคงเป็นไปได้)

กรณีตัวอย่าง

Crush ง่าย

อินพุต

5 3
#####
#O~H#
#####
R

เอาท์พุต

2

เมทริกซ์ที่ต้องการ -> ความตาย

อินพุต

5 5
#####
#O  #
# ~ #
#  H#
#####
WWDW

เอาท์พุต

aHHHH!
0

การตั้งค่าเมทริกซ์ -> ชนะ

อินพุต

5 5
#####
#O  #
# ~ #
#  H#
#####
WRD

เอาท์พุต

2

รอการเก็บเกี่ยว

อินพุต

5 5
#####
#O  #
# ~ #
#  H#
#####
WWW

เอาท์พุต

aHHHH!
0

ความพ่ายแพ้ที่ประสบความสำเร็จในฉาก Wikipedia

อินพุต

40 23
########################################
#~      ~ ~~  ~  ~ ~~   ~ ~~    ~ ~ ~~ #
#~~ ~          ~~   ~   ~ ~~         ~ #
#~# ~~   ~~~~      ~  ~~~~  ~    ~~~  ~#
# ~        ~   ~ ~~ #~~       ~        #
#~~  ~~~   ~ ~ ~      ~ ~~ ~  ~  ~  ~  #
#     ~~  ~  ~ ~ ~~~       H    ~  #~  #
#  O~  ~  #  ~~~ ~      ~ ~~  ~  ~ ~~  #
#       ~ ~H~~   ~~ ~ #        ~~   ~  #
# ~~         ~ ~~~  ~~   ~~~~      ~  ~#
#~  ~    ~~~  ~   ~        ~   ~ ~~  ~~#
#     ~      # ~ ~~  ~~~   ~ ~ ~ #    ~#
#~ ~ ~~  ~  ~   H     ~~  ~~ ~ ~ ~~~   #
#       ~   ~   ~   ~  ~     ~~~ ~     #
# ~~  ~  ~ ~~   ~       ~ ~ ~     ~    #
#      ~~   ~   ~  ~         ~      ~~ #
#~ ~     #    ~~~~  ~    ~~~H   # ~    #
#  ~   ~ ~   ~        ~          ~~  ~ #
#  ~   ~     #~  ~   ~~  ~  ~         ~#
# ~~ ~ ~  ~~                ~   ~      #
#    ~~~        ~ ~~  ~  ~  ~   ~      #
# ~ ~     ~            ~~   ~   ~  ~   #
########################################
RRRUWWWRRRURWWWWRDRRWWRDWWWWD

เอาท์พุต

8

แผนที่จัดทำโดยฉันเคลื่อนไหวและส่งออกโดย @bobbel ยืนยันด้วยตัวเองและ @Allbeert

เกณฑ์การชนะ

ฉันคิดว่ามันสามารถเล่นได้ดังนั้นฉันจะไปกับกฎการตีกอล์ฟเว้นแต่ผู้คนจะบ่น

สินเชื่อพิเศษ

การใช้ Unicode ที่เล่นได้ด้วยตัวละครที่มีความกว้างสองเท่าเพื่อให้ดูเหมือนภาพ!

Perl 6: 741 ตัวอักษร, 758 ไบต์

รุ่น golfed อยู่ที่ด้านล่างเนื่องจากเป็นพื้น linenoise ด้านบนเป็นเวอร์ชั่นก่อนตีกอล์ฟของฉัน ทั้งคู่เป็นแบบโต้ตอบ (พวกเขาจะอ่านคำสั่งจำนวนมากจากไฟล์อินพุตที่สามารถทำได้จากนั้นไปยังการใช้ STDIN เพื่อรับคำสั่ง) พวกเขาพยายามใช้ตัวอักษรและสีดั้งเดิม

การใช้งานเป็นเช่นperl6 beast.p6 beast-input:

use Term::ANSIColor;
class BeastGame {
    enum BeastParts <None Player Beast M-Wall S-Wall>;

    has @.board;
    has Int $.turn = 0;
    has Int $.score = 0;

    method indices (\matcher) {
        @.board.pairs.map: {
            .key*i X+ .value[].pairs.map: {
                .key if .value ~~ matcher
            }
        }
    }
    multi postcircumfix:<[ ]> (BeastGame \SELF, Complex \c) is rw { SELF.board[c.im][c.re] }

    has Complex $!player;
    method player { $!player = $.indices(Player)[0] }
    method Bool { so $.indices(Player) & $.indices(Beast) }

    method new (@lines) {
        my @board = @lines.map:
            {[ %(' ',<O H ~ #> Z=> None, Player, Beast, M-Wall, S-Wall){ .comb } ]}

        self.bless: :@board
    }
    method gist {
        state @symbol-map = map {colored .key, .value~' on_black'},
            ('  ',<◄► ├┤ ▒▒ ██> Z=> <default cyan red green yellow>);

        @.board.map({ @symbol-map[@$_].join }).join("\n")
    }

    method step ($d) {
        my $direction = %(:W(0), :L(-1+0i), :R(1+0i), :U(-1i), :D(1i)){$d};
        $direction // return self;
        self.move($.player,$direction);

        if ++$!turn %% 2 {
            for $.indices(Beast).eager -> $c {
                for (-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i)\
                        .sort({abs $c + $^d - $!player})
                {
                    last if self.move($c, $_).defined;
                }
            }
        }

        self;
    }
    method move ($cur, $by) {
        return $cur if $by == 0;

        my $to = $cur + $by;
        my &cur-is  = { self[$cur] ~~ $^o }
        my &next-is = { self[$to]  ~~ $^o }
        return if cur-is S-Wall;
        (self[$to], self[$cur]) = (self[$cur], None)
            if next-is None
            # Move wall
            or cur-is Player | M-Wall and next-is M-Wall and self.move($to, $by)
            # Kill Player
            or cur-is Beast  and next-is Player
            # Squish Beast
            or cur-is M-Wall and next-is Beast  and self[$to+$by] ~~ M-Wall|S-Wall and $!score += 2
    }
}
my $width = get.words[1];
my $game  = BeastGame.new(lines[^$width]);
my @commands = '',lines.comb,{$*IN.get.comb}...*;

while $game {
    $game.step: @commands.shift;
    print "\e[2J";
    print "\e[H";
    say $game;
}

say "aHHHH!" unless $game.player;
say $game.score;

รุ่น golfed:

my ($u,$s,$m)=0,0;my@b=lines[^get.words[1]].map:{[%(' ',<O H ~ #>Z=>^5){.comb}]}
my@a='',lines.comb,{$*IN.get.comb}...*;sub g(\c)is rw {@b[c.im][c.re]}
my&n=->\o{@b.kv.map:{$^k*i X+$^v[].kv.map:{$^l if $^w==o}}}
my&p={$m=n(1)[0]}
my&M=->$c,$b{my$t=$c+$b;my&c={$^o==g $c}
my&x={$^o==g $t}
c(4)??0!!$b??(($c,$t)».&g=(0,g $c)
if x(0)||c(1|3)&&x(3)&&M($t,$b)||c(2)&&x(1)||c(3)&&x(2)&&2 <g($t+$b)&&($s+=2))!!1}
while n(1)&n(2) {for 1
{M p,%(:W(0),:L(-1),:R(1),:U(-1i),:D(1i)){@a.shift}//last;if $u++%2
{for n(2).eager ->$c{last if M $c,$_
for(-1-1i,-1+0i,-1i,1-1i,1+0i,-1+1i,1+1i,1i,0i).sort({abs $c+$_-$m})}}}
say "\e[2J\e[H",join "\n",map {[~]
(map {"\e[$^v;40m$^k\e[0m"},'  ',<39 ◄► 36 ├┤ 31 ▒▒ 32 ██ 33>)[@$_]},@b}
say "aHHHH!" if !p;say $s;

สุขสันต์วันอีสเตอร์!

Java, 1,843

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

เพื่อลองใช้งานคุณจะต้องสร้างคลาสCและวางรหัส args[0](พูดอย่างเคร่งครัดa[0]) สำหรับการป้อนข้อมูล วิธีการพิมพ์ของแผนที่ไม่รวมอยู่ด้วยเนื่องจากไม่จำเป็นสำหรับการแสดงผลตัวต่อ

class C{static char                    [][]C;static int A=
0,B=0,D=0,E=0,F=0,G                    = 0 ; public static
void main(String[]a                    ){String []b= a[0].
split("\n");int c =                    Byte. decode(b [0].
split(" ")[1]); G=a                    [ 0 ] . replaceAll(
"[^H]","").length()                    ; String d = b [ b.
length - 1 ] ;C=new                    char[c][];for(int e
=1;e<b.length-1;e++                    ) C [ e - 1 ]=b[e].
toCharArray ( ) ; f                    ();boolean X= 0> 1;
for ( char  g : d .                    toCharArray ( ) ) {
switch(g){case 'U':                    h(0,-1);break; case
'D':h(0, 1); break;                    case 'L':h( -1, 0);
break;case'R':h(1,0                    );}if(X)i();X=!X;f(
);}System.out.print                    (D);}static void f(
){for(int a= 0;a<C.                    length;a++)for( int
b=0;b<C[a].length;b                    ++)if(C[a][b]=='O')
{A=b;B= a;}}static void h(int x,int y){E =x;F =y;switch(C[
B +y][A +x]){case 'H':g();break;case ' ':j(A,B);break;case
'~':k();}}static void i(){if(G<1){return;}int[][]l=new int
[G][];int m=0;for(int r=0;r<C.length;r++){for(int c=0;c<C[
r].length; c++){if(C[r][c]=='H'){l[m++]=new int[]{c,r};}}}
for(int[]n:l){o(n[0],n[1]);}} static void o(int a, int b){
int[]c=d (a,b);E=c[0];F =c[1];if(E !=0||F !=0){ j(a,b);} }
static int[]d(int a,int b){int[][]d={{1,3,4},{2,0,5},{6,8,
7},};int[]e=new int[]{0,0};double f=999;for(int r=-1;r<2;r
++){for(int c=-1;c<2;c++){if(C[b+r][a+c]==' '||C[b+r][a+c]
=='O'){int g=a+c-A;                    int h=b+r-B; double
i=Math.sqrt(g*g+h*h                    );if(i<f){e=new int
[]{ c,r};f =i;}else                    if(i==f){if(d[r+1][
c+1]<d[e[1]+1][e[0]                    +1]){e=new int[]{c,
r};}}} }}return e;}                    static void k(){if(
p(E,F,false)){q(E,F                    );} }static void q(
int x,int y){switch                    (C[B+y][A+x]){ case
'~':q(x+E,y+F);case                    'H':case ' ':j(A+x-
E,B+y- F);}} static                    boolean p(int x,int
y,boolean h){switch                    (C[B+y][ A+x]){case
' ':return !h; case                    '~':return h?h:p(x+
E,y +F, false);case                    'H':return h?!h:p(x
+E , y+ F, true) ;}                    return h&&C[B+y][A+
x] == '#' ; }static                    void j(int a,int b)
{char c=C[b][a];if(                    C[b+F][a+E]=='O'){g
();}else if(C[b+F][                    a+E]=='H'){D+=2;G--
;c=C[b][a];C[b][a]=                    ' ';}else{C[b][a]=C
[b+F][a+E];}C[b+F][                    a+E]=c;}static void
g () { System .out.                    print("aHHHH!\n"+D)
;     System      .                    exit  ( 0  ) ;  } }

หากต้องการเรียกใช้ลองตัวอย่าง:

root@host:/cygdrive/c/workspace/project/bin> java C "5 5
> #####
> #O  #
> # ~ #
> #  H#
> #####
> WWDW"
aHHHH!
0
root@host:/cygdrive/c/workspace/project/bin>

ผลลัพธ์ของสถานการณ์สมมติขนาดใหญ่ครั้งสุดท้ายก่อนที่สัตว์ร้ายจะกินผู้เล่น:

████████████████████████████████████████████████████████████████████████████████
██▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓  ▓▓▓▓        ▓▓  ▓▓  ▓▓▓▓  ██
██▓▓▓▓  ▓▓                    ▓▓▓▓      ▓▓      ▓▓  ▓▓▓▓                  ▓▓  ██
██▓▓██  ▓▓▓▓      ▓▓▓▓▓▓▓▓            ▓▓    ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓    ▓▓██
██  ▓▓                ▓▓      ▓▓  ▓▓▓▓  ██▓▓▓▓              ▓▓                ██
██▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓            ▓▓  ▓▓▓▓  ▓▓    ▓▓    ▓▓    ▓▓    ██
██          ▓▓▓▓    ▓▓    ▓▓  ▓▓  ▓▓▓▓▓▓                        ▓▓    ██▓▓    ██
██          ▓▓▓▓    ██    ▓▓▓▓▓▓  ▓▓            ▓▓  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓    ██
██              ▓▓  ▓▓  ▓▓▓▓      ▓▓▓▓  ▓▓  ██                ▓▓▓▓      ▓▓    ██
██  ▓▓▓▓                  ▓▓  ▓▓▓▓▓▓    ▓▓▓▓  ├┤  ▓▓▓▓▓▓▓▓            ▓▓    ▓▓██
██▓▓    ▓▓    ├┤◄►▓▓▓▓▓▓├┤  ▓▓      ▓▓                ▓▓      ▓▓  ▓▓▓▓    ▓▓▓▓██
██          ▓▓            ██  ▓▓  ▓▓▓▓    ▓▓▓▓▓▓      ▓▓  ▓▓  ▓▓  ██        ▓▓██
██▓▓  ▓▓  ▓▓▓▓    ▓▓    ▓▓                  ▓▓▓▓    ▓▓▓▓  ▓▓  ▓▓  ▓▓▓▓▓▓      ██
██              ▓▓      ▓▓      ▓▓      ▓▓    ▓▓├┤        ▓▓▓▓▓▓  ▓▓          ██
██  ▓▓▓▓    ▓▓    ▓▓  ▓▓▓▓      ▓▓              ▓▓  ▓▓  ▓▓          ▓▓        ██
██            ▓▓▓▓      ▓▓      ▓▓    ▓▓                  ▓▓            ▓▓▓▓  ██
██▓▓  ▓▓          ██        ▓▓▓▓▓▓▓▓    ▓▓        ▓▓▓▓▓▓        ██  ▓▓        ██
██    ▓▓      ▓▓  ▓▓      ▓▓                ▓▓                    ▓▓▓▓    ▓▓  ██
██    ▓▓      ▓▓          ██▓▓    ▓▓      ▓▓▓▓    ▓▓    ▓▓                  ▓▓██
██  ▓▓▓▓  ▓▓  ▓▓    ▓▓▓▓                                ▓▓      ▓▓            ██
██        ▓▓▓▓▓▓                ▓▓  ▓▓▓▓    ▓▓    ▓▓    ▓▓      ▓▓            ██
██  ▓▓  ▓▓          ▓▓                        ▓▓▓▓      ▓▓      ▓▓    ▓▓      ██
████████████████████████████████████████████████████████████████████████████████

ไม่มีช่องว่างของเส้นว่าง: http://pastebin.com/raw.php?i=QhpxKcCT

ดังนั้นวิธีที่ผู้เล่นจะจบลงหลังจากการเคลื่อนไหวRRDDDRRRWWเพราะในสัตว์ตัวสุดท้ายWสัตว์ร้ายทางด้านซ้ายจะไปทางขวาเพื่อกินผู้เล่น

อีกตัวอย่างหนึ่งของแผนที่ขนาดใหญ่ดั้งเดิม แต่การเคลื่อนไหวที่แตกต่าง:

http://pastebin.com/raw.php?i=nBWjC3PZ

ดูภาพเคลื่อนไหวนี้: http://youtu.be/0DIhEhjWd6s

และตัวอย่างสุดท้ายที่มีแผนที่ดั้งเดิมและการเคลื่อนไหวที่แตกต่างกัน (ตามกฎการเคลื่อนที่ของสัตว์ร้ายใหม่):

http://pastebin.com/raw.php?i=NNmgzx7U

ดูใน youtube: http://youtu.be/jXPzL88TU2A

C - 1004 984 917

อ่าความงามของค. ตามจิตวิญญาณของคำตอบอื่น ๆ ฉันพยายามจัดรูปแบบของฉันเช่นกัน :)

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

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
   #define E {printf("aHHHH!\n%d",Z);exit(0);}
    #define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
           #define L (char)(m[s]>>8)
            #define G (char)(m[s])
             #define B(b) if(T==b)
              #define J M(Y,X,79)
               #define T t[P][Q]

r,c,X,Y,H,i,j,k,Z,p,q,P,Q,u,v,s,w,m[99],b[8]={
-1,255,65280,65281,1,511,257,256},t[999][999],
x[99],y[99];main(){char N[99];m[85]=b[2];m[68]
=256;m[76]=255; m[82]=1; scanf("%d %d",&c,&r);
for(;P<r;P++)                    for(Q=0;Q<c&&
scanf("%c",&T                    );T-10&&T-13?
Q++:Q){B(79){                    Y=P;X=Q;}B(72
){y[H]=P ;x[H                    ++]=Q;}}scanf
("%s",N);for(                    ;i<strlen(N);
i++){s=N[i];P                    =p=Y+L;Q=q=X+
G;B(32)J B('~')                  {while(P+=L,Q
+=G,T=='~');B                    (72){u=P+L;v=
Q+G;if(t[u][v]                   ==35||t[u][v]
=='~'){Z+=2;T=                   '~';J}}B(32){
T='~';J}}else                    B(72)E if(r=!r)
for(j=0;j<H;j                    ++){P=y[j];Q=
x[j];if(T-72)continue;v=A;s=0;for(k=0;k<8;k++)
{P=y[j]+(char)(b[k]>>8);Q=x[j]+(char)(b[k]);u=
A;B(32)if((c=v-u+99)>s){s=c;q=Q;p=P;}B(79)E}if
(s)M(y[j],x[j],72)}}printf("%d",Z);}//////////

ฉันทดสอบกับกรณีตัวอย่างทั้งหมดและอีกไม่กี่ของฉันและดูเหมือนว่าจะทำงานได้อย่างถูกต้อง หากใครพบสถานการณ์ใด ๆ ที่ไม่สามารถตอบได้อย่างถูกต้องโปรดแจ้งให้เราทราบ

อินพุตจาก stdin และเอาต์พุตไปยัง stdout ไม่มีการตรวจสอบอินพุตที่ไม่ถูกต้อง และมันจะคืนคะแนนถ้าผู้เล่นได้กินหรือหากผู้เล่นยังมีชีวิตอยู่หลังจากการเคลื่อนไหวทั้งหมดถูกประหารชีวิต (แม้ว่าจะยังมีอยู่Hรอบ ๆ ก็ตาม)

เวอร์ชันที่ไม่ถูกปรับแต่ง:

#define M(y,x,c) {t[y][x]=32;t[p][q]=c;y=p;x=q;}
#define E {printf("aHHHH!\n%d",Z);exit(0);}
#define A sqrt(pow(X-Q,2)+pow(Y-P,2))*30
#define L (char)(m[s]>>8)
#define G (char)(m[s])
#define B(b) if(T==b)
#define J M(Y,X,79)
#define T t[P][Q]

r, c, X, Y, H, i, j, k, Z, p, q, P, Q, u, v, s, w, m[99], b[8] = { -1, 255,
        65280, 65281, 1, 511, 257, 256 }, t[999][999], x[99], y[99];
main() {
    char N[99];
    m[85] = b[2];
    m[68] = 256;
    m[76] = 255;
    m[82] = 1;
    scanf("%d %d", &c, &r);
    for (; P < r; P++)
        for (Q = 0; Q < c && scanf("%c", &T);T-10&&T-13?Q++:Q) {
            B(79) {
                Y=P;
                X=Q;
            }
            B(72) {
                y[H]=P;
                x[H++]=Q;
            }
        }

    scanf("%s", N);
    for (; i < strlen(N); i++) {
        s = N[i];
        P = p = Y + L;
        Q = q = X + G;
        B(32)
            J
        B('~') {
            while (P += L, Q += G, T=='~');
            B(72) {
                u=P+L;
                v=Q+G;
                if(t[u][v]==35||t[u][v]=='~') {
                    Z+=2;
                    T='~';
                    J
                }
            }
            B(32) {
                T='~';
                J
            }
        } else B(72)E
        if (r = !r)
            for (j = 0; j < H; j++) {
                P = y[j];
                Q = x[j];
                if (T-72)
                continue;

                v = A;
                s = 0;

                for (k = 0; k < 8; k++) {
                    P = y[j] + (char) (b[k] >> 8);
                    Q = x[j] + (char) (b[k]);
                    u = A;
                    B(32)
                        if ((c = v - u + 99) > s) {
                            s = c;
                            q = Q;
                            p = P;
                        }

                    B(79)
                        E
                }
                if (s)
                    M(y[j], x[j], 72)
            }
    }
    printf("%d", Z);
}