Як ми дізналися з IBM PC AT, YouTube (див. Відео) , Вікіпедії (див. Статтю) та вулиці Сезама:

Буква H- це наймиліша буква алфавіту !

(Навіть коли насправді складається з двох елементів у Кодексі . Насправді, це навіть БОЛЬШЕ нещадно.)

Як інопланетяни в, ем ... е ... Інопланетяни , звірі безжально переслідують усіх, хто наважиться підійти до своїх яєць. Міркувань з ними немає. Ви повинні їх розчавити, якщо не загинути.

Для цього сценарію ми будемо вважати, що ви до останнього життя, і ви зустріли звичайних звірів на місцевості без яєць (як на скріншоті Вікіпедії). У вас немає цифрової клавіатури, і ви можете рухатись лише прямо вгору / вниз / вліво / вправо ... але звірі, мабуть, мають її і можуть рухатись по діагоналі по черзі.

Вибір Звіру для вибору серед його варіантів буде той, який мінімізує відстань від гравця. Якщо відстані рівні, то розрив краватки робиться на користь ліворуч + вгору праворуч + вниз, але ось матриця розбірливості має бути явною щодо цього ... найменше число до розриву тай-тай:

1 3 4
2 H 5
6 8 7

Звір ніколи не спить, але вони, на щастя, трохи повільніше, ніж гравець. Вони рухаються кожні інші повороти (даючи гравцеві почати початок, починаючи чергування з другого ходу). Вони повинні рухатися, якщо можливий хід, незалежно від того, чи це відведе їх далі від гравця.

Ви розчавлюєте звіра, якщо пересувати потяг рухомих стін там, де він сидів у закритій щілини. Ці звичайні звірі коштують 2 бали на голову.

Вхідні дані

1. Пара цілих чисел, що вказують розмір карти в стовпцях, а потім рядки.

2. Кількість рядків рядків вводу, розмір кожного стовпця ... містить суцільну стінку ( #), рухому стінку ( ~), звір ( H), програвач ( O) або просто пробіл.

3. Вхід, який буде або U, D, L, R, що вказує на спробу гравця ..., або W, щоб просто почекати. Зауважте, що спроба штовхнути рухому стіну, яка заблокована, є законним введенням, це просто не призведе до жодних дій.

Вихідні дані

1. aHHHH! якщо звірі вбили гравця ... або нічого, якщо гравець виграв, не залишившись звірів

2. Рахунок

(Примітка. Для цілей налагодження та / або розваг, ймовірно, ви хочете мати змогу виводити стан на кожному кроці; але це занадто довго, щоб публікувати тут.)

Роз'яснення

• Карти гарантовано обмежені суцільними стінами.

• Порядок того, хто рухається по черзі, має значення для результату. Таким чином: Гравець завжди йде першим, тоді звірам надається впорядкування виходячи з їх початкового положення на карті, якщо ви переміщалися по екрану зверху вниз зліва направо. (Звір першого ряду рухається перед звіром другого ряду, а два звірі в тому ж ряду, це буде той самий номер, який має найменший номер стовпця, який рухатиметься перед іншим)

• Діагональні рухомі звірі можуть переміщатися у будь-який відкритий сусідній діагональний простір, незалежно від того, чи потребує він стискання між стінами.

• Гравець може штовхати будь-яку кількість рухомих стін у лінії, якщо на іншому кінці є пробіл або звір. Але намагання просунути потяг стін у Звіру, який не закріплений між стінами, трактує Звіру як стіну, і не дозволить рухатись.

• Рішення про хід звіра під час черги ґрунтується на розташуванні гравця на початку повороту. Бажана оптимізація "відстані до гравця" здійснюється за допомогою розрахунку "як ворона летить". Будь-яке наближення, яке дало б такий самий результат, як виміряне від центру його квадрата до центру квадрата гравця, є добре.

• Якщо Звір не зможе зробити те, що було б його першим кращим кроком по черзі, тому що Звір з вищим пріоритетом зайняв своє місце, він наступним найкращим вибором прийме на відміну від перебування на місці (якщо переїзд все-таки можливий).

Зразки справ

Просте розчавлення

Вхідні дані

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

Вихідні дані

2

Матриця переваг -> Смерть

Вхідні дані

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

Вихідні дані

aHHHH!
0

Матриця переваг -> Win

Вхідні дані

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

Вихідні дані

2

Чекаємо жнець

Вхідні дані

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

Вихідні дані

aHHHH!
0

Успішні поразки в сценарії Вікіпедії

Вхідні дані

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

Вихідні дані

8

Карта, надана мною, рухається та виводиться від @bobbel, підтверджується я та @Allbeert.

Критерії виграшу

Я думаю, що це можна пограбувати, тому я піду з кодовими правилами гольфу, якщо люди не скаржаться.

Додатковий кредит

Реалізація Unicode з двократними символами, що нагадують зображення!

Perl 6: 741 символ, 758 байт

Версія для гольфу знаходиться в нижній частині, оскільки в основному це лаєноз. Нагорі - моя попередньо гольф-версія. Обидва є інтерактивними (вони зчитують стільки команд із вхідного файлу, скільки можуть, а потім переходять до використання 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;

Версія для гольфу:

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;

Щасливого Великодня!

Ява, 1843

Моя перша спроба вирішити цю головоломку з 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

Ага, красуня C. Вслід за духом іншої відповіді, я спробував також відформатувати мою :)

Я гадаю, що ще там і там є якісь удосконалення, але це було дуже цікаво писати та гольфу. Кількість символів включає всі необхідні пробіли та нові рядки.

#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);
}