IBM PC AT, YouTube (비디오 참조) , Wikipedia (기사 참조) 및 Sesame Street 에서 배운 대로 :

편지 H는 알파벳 의 가장 무자비한 편지입니다 !

(실제로 Code Page 437의 두 가지 요소로 구성 될 때도 마찬가지입니다. 실제로는 훨씬 무자비합니다.)

에서 외계인처럼, 음 ... 어 ... 외계인 , 짐승은 끊임없이 알 가까이 오지 감히 모든 사람을 추구한다. 그들에 대한 추론은 없습니다. 멸망하지 않으려면 스쿼시해야합니다.

이 시나리오에서 우리는 당신이 당신의 마지막 삶에 있다고 가정하고, Wikipedia 스크린 샷에서와 같이 계란이없는 지형에서 평범한 야수를 만났습니다. 숫자 키패드가없고 직접 위 / 아래 / 왼쪽 / 오른쪽으로 만 이동할 수 있지만 짐승에게는 분명히 하나가 있으며 차례에 대각선으로 움직일 수 있습니다.

옵션 중 Beast의 선택은 플레이어와의 거리를 최소화하는 것입니다. 거리가 같으면 왼쪽에서 위로, 오른쪽에서 아래로 선호하는 타이 브레이킹이 수행되지만 명확하게 표시되는 명확성 매트릭스는 다음과 같습니다.

1 3 4
2 H 5
6 8 7

짐승은 결코 잠을 자지 않지만 다행히 플레이어보다 약간 느립니다. 그들은 매 턴마다 움직입니다 (두 번째 턴에서 교대를 시작함으로써 선수가 헤드 스타트하도록합니다). 플레이어로부터 멀어 지더라도 움직일 수 있으면 움직여야합니다.

닫힌 틈새에 앉아 움직일 수있는 벽 열차를 움직이면 짐승이 부서집니다. 이 평범한 짐승은 머리 당 2 포인트의 가치가 있습니다.

입력

1. 열의 크기와 행의 맵 크기를 나타내는 정수 쌍입니다.

2. 입력 열의 행 수, 각 열 크기 ... 단단한 벽 ( #), 이동식 벽 ( ~), 짐승 ( H), 플레이어 ( O) 또는 공간 만 포함합니다.

3. 플레이어가 이동을 시도 했음을 나타내는 U, D, L, R, 또는 W를 기다리는 입력입니다. 막힌 이동식 벽을 밀려 고하면 합법적 인 입력이므로 아무런 조치도 취하지 않습니다.

산출

1. aHHHH! 짐승이 플레이어를 죽인 경우 ... 또는 플레이어가 짐승없이 남았다면 아무것도 아닙니다

2. 점수

(참고 : 디버깅 목적 및 / 또는 오락을 위해 각 단계에서 상태를 출력 할 수는 있지만 여기에 게시하기에는 너무 깁니다.)

설명

• 지도는 단단한 벽으로 둘러싸여 있습니다.

• 차례대로 움직이는 사람의 순서는 결과에 중요합니다. 따라서 플레이어는 항상 먼저 진행 한 다음 화면에서 왼쪽에서 오른쪽으로 왼쪽에서 오른쪽으로 스윕 하면 짐승에게 초기 맵 위치를 기준으로 순서가 지정 됩니다 . (행 1 짐승은 행 2 짐승보다 먼저 움직이고, 같은 줄에있는 두 짐승은 다른 열보다 먼저 가장 낮은 열 번호를 가진 짐승이됩니다)

• 대각선으로 움직이는 짐승은 벽 사이의 압박이 필요한지 여부에 관계없이 인접한 대각선 공간으로 이동할 수 있습니다.

• 다른 쪽 끝에 공간이나 짐승이있는 경우 플레이어는 움직일 수있는 벽을 여러 줄로 밀 수 있습니다. 그러나 벽 사이에 고정되어 있지 않은 벽을 짐승 안으로 밀어 넣으려고하면 야수가 벽으로 취급되어 이동을 허용하지 않습니다.

• 턴 중 야수의 이동 결정은 턴 시작 시 플레이어의 위치를 ​​기반으로합니다 . "플레이어와의 거리"에 대한 원하는 최적화는 "까마귀 비행으로"계산을 통해 이루어집니다. 정사각형 중심에서 플레이어 정사각형 중심까지 측정 한 것과 동일한 결과를 제공하는 근사치는 괜찮습니다.

• 우선 순위가 높은 Beast가 자리를 잡았 기 때문에 Beast가 첫 번째로 선호하는 이동을 한 번에 할 수 없다면, 이동이 가능한 경우에 대비하여 차선책을 선택합니다.

샘플 케이스

간단한 호감

입력

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

위키 백과 시나리오에서 성공적인 패배

입력

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

산출

8

나에 의해 제공, @bobbel에 의해 이동 및 출력, 나 자신과 @Allbeert에 의해 확증.

승리 기준

나는 이것이 골프 가능하다고 생각하므로 사람들이 불평하지 않으면 코드 골프 규칙을 따르게됩니다.

추가 크레딧

이미지를 닮은 이중 폭 문자로 재생 가능한 유니 코드 구현!

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;

행복한 부활절!

자바, 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

Ahh, 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주변에 있더라도) 플레이어가 살아 있다면 점수를 반환합니다 .

Ungolfed 버전 :

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