aHHHH! Os animais são HHHHere!

19

Como aprendemos com o IBM PC AT, YouTube (ver vídeo) , Wikipedia (ver artigo) e Vila Sésamo:

A letra Hé a letra mais impiedosa do alfabeto !

(Mesmo quando realmente composto de dois elementos no Código Página 437. De fato, é ainda MAIS impiedoso dessa maneira.)

Como os alienígenas, uhm ... er ... alienígenas , bestas perseguem implacavelmente todos os que ousariam chegar perto de seus ovos. Não há raciocínio com eles. Você deve esmagá-los para não perecer.

Um encontro assustador com o 4H Club

Nesse cenário, assumiremos que você está em sua última vida e conheceu Bestas comuns em um terreno sem ovos (como na captura de tela da Wikipedia). Você não tem um teclado numérico e só pode se mover diretamente para cima / baixo / esquerda / direita ... mas as bestas aparentemente têm um e podem se mover na diagonal na sua vez.

A escolha de uma besta entre as opções será a que minimiza a distância do jogador. Se as distâncias forem iguais, o desempate é feito favorecendo a esquerda + para cima sobre a direita + para baixo, mas aqui está a matriz de desambiguação para ser explícita sobre isso ... número mais baixo para desempate:

1 3 4
2 H 5
6 8 7

Uma fera nunca dorme, mas felizmente é um pouco mais lenta que o jogador. Eles se movem a cada dois turnos (dando ao jogador uma vantagem iniciando suas alternâncias no segundo turno). Eles devem se mover se for possível, independentemente de isso os afastar do jogador.

Você esmaga um animal se mover um trem de paredes móveis onde ele estava sentado em um espaço fechado. Essas bestas comuns valem 2 pontos por cabeça.

Entrada

  1. Um par de números inteiros indicando o tamanho de um mapa em colunas e depois em linhas.

  2. Contagem de linhas de linhas de entrada, cada uma do tamanho da coluna ... contendo uma parede sólida ( #), uma parede móvel ( ~), uma besta ( H), o player ( O) ou apenas um espaço.

  3. Entrada que será U, D, L, R indicando uma tentativa de movimento do jogador ... ou W para apenas esperar. Observe que a tentativa de empurrar uma parede móvel bloqueada é uma entrada legal, apenas resultará em nenhuma ação.

Resultado

  1. aHHHH! se os animais mataram o jogador ... ou nada se o jogador ganhou sem animais restantes

  2. A pontuação

(Observação: para fins de depuração e / ou diversão, você provavelmente desejará gerar o estado a cada etapa; mas isso é muito tempo para ser postado aqui.)

Esclarecimentos

  • É garantido que os mapas sejam delimitados por paredes sólidas.

  • A ordem de quem se move por sua vez é importante para o resultado. Assim: O jogador sempre segue primeiro, então as bestas recebem uma ordem com base na posição inicial do mapa, se você estiver varrendo a tela de cima para baixo, da esquerda para a direita. (Um animal da linha 1 se move antes de um animal da linha 2 e dois animais na mesma linha seria aquele com o menor número de coluna que se moveria antes do outro)

  • Bestas em movimento na diagonal podem se mover para qualquer espaço diagonal aberto adjacente, independentemente de exigir espremer entre paredes.

  • Um jogador pode empurrar qualquer número de paredes móveis em uma linha, desde que exista um espaço ou um animal no outro extremo. Mas tentar empurrar um conjunto de paredes para dentro de uma Besta que não esteja presa entre as paredes trata a Besta como uma parede e não permitirá o movimento.

  • A decisão de movimentação de uma Besta durante um turno é baseada na localização do jogador no início do turno. Sua otimização desejada de "distância ao jogador" é feita através de um cálculo "enquanto o corvo voa". Qualquer aproximação que daria o mesmo resultado medido do centro do quadrado ao centro do quadrado do jogador é boa.

  • Se uma Besta não puder fazer o que teria sido o seu primeiro movimento preferido em um turno porque uma Besta de maior prioridade tomou o seu lugar, ela fará a próxima melhor escolha em vez de permanecer no lugar (se ainda for possível).

Casos de amostra

Simple Crush

Entrada

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

Resultado

2

Matriz de Preferências -> Morte

Entrada

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

Resultado

aHHHH!
0

Matriz de Preferências -> Ganhar

Entrada

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

Resultado

2

Esperando o Ceifador

Entrada

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

Resultado

aHHHH!
0

Derrota bem-sucedida no cenário da Wikipedia

Entrada

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

Resultado

8

Mapa fornecido por mim, movimentos e saída da @bobbel, corroborado por mim e pela @Allbeert.

Critérios Vencedores

Eu acho que isso é jogável, então vou seguir as regras do código, a menos que as pessoas se queixem.

Crédito extra

Implementação Unicode reproduzível com caracteres de largura dupla para se parecer com a imagem!

Dr. Rebmu
fonte
Os movimentos diagonais saltam sobre linhas antidiagonais de paredes? Dado que uma fera faz um movimento a cada turno, como ele quebra os laços de distância entre dois movimentos horizontais ou dois movimentos verticais? Ele se move para onde o jogador estava no início do turno ou após o movimento do jogador? Quando você diz "trem de paredes móveis", isso significa que o jogador pode empurrar qualquer número de paredes móveis em uma linha, desde que exista um espaço ou um animal no outro extremo?
22414 Peter Peter Taylor
2
Se estou entendendo corretamente, o segundo exemplo está errado, porque pastebin.com/raw.php?i=CqPJPjTR .
Maçaneta
11
@ Dr.Rebmu: geralmente eu gosto muito da sua tarefa, mas há muitas perguntas a fazer. Obrigado por esclarecer! Então, a seguir: e a situação das duas feras : pastebin.com/raw.php?i=FENVAkCH Minha suposição está correta?
bobbel
11
Outra pergunta: E se você mover um trem de muros para um animal que não esteja "preso"? pastebin.com/raw.php?i=isN4L6pJ
Claudiu
3
@ Bobber Man, escrever perguntas é mais difícil do que resolvê-las! :-) Eu digo que, dada a propensão das Bestas por não ficarem paradas, elas farão a próxima jogada melhor, se disponível, em vez de desistir da jogada nesse turno, se uma Besta de maior prioridade tomar o lugar ideal. Esclarecido.
perfil completo de Rebmu

Respostas:

3

Perl 6: 741 caracteres, 758 bytes

A versão golfada está na parte inferior, pois é basicamente linenoise. Acima está a minha versão pré-golfe. Ambos são interativos (eles lêem o máximo de comandos do arquivo de entrada possível e passam a usar STDIN para obter comandos). Eles tentam usar os caracteres e cores originais.

O uso é como 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;

A versão 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;

Feliz Páscoa!

Mouq
fonte
São regras de código de golfe, portanto, sua solução vence ... mesmo que eu não goste muito do Perl. ;-) Bom trabalho com o console e a cor!
Dr. Rebmu
14

Java, 1.843

Minha primeira tentativa de resolver esse quebra-cabeça com Java. Eu sei que existem muitas melhorias para torná-lo mais curto. Mas, no final, funciona por enquanto.

Para experimentá-lo, você precisa criar uma classe Ce colar o código. args[0](estritamente falando a[0]) é para entrada. O método de impressão do mapa não está incluído, pois não é necessário para a saída do quebra-cabeça.

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

Para executá-lo, tente por exemplo:

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

Saída do último grande cenário um turno antes de uma besta comer o jogador:

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

Sem espaços de linha tolos: http://pastebin.com/raw.php?i=QhpxKcCT

Assim, o caminho dos jogadores termina após os movimentos RRDDDRRRWW, porque no último Wturno, a besta à esquerda irá para a direita para comer o jogador.


Outro exemplo do mapa grande original, mas com movimentos diferentes:

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

Veja esta animação: http://youtu.be/0DIhEhjWd6s


E o último exemplo com mapa original e movimentos diferentes (de acordo com as novas regras de movimento das bestas):

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

Veja no youtube: http://youtu.be/jXPzL88TU2A

bobina
fonte
11
HHHa! :-) Muito legal. Desde que você o tenha adquirido, gostaria de jogar alguns jogos e fornecer mais dados de casos de teste nesse mapa?
perfil completo de Rebmu
Eu adicionei um novo cenário com mapa original e movimentos diferentes. Mas você realmente não pode seguir as etapas, porque eu não queria colar todas as 75 etapas para colar :)
Bobbel
Então, adicionei um vídeo para ver o resultado como uma animação!
bobbel
Bom vídeo ... embora pareça mostrar que os animais se movem rápido demais para ser divertido! Devemos mudar a regra para que eles se movam a cada dois turnos, em vez de todos os turnos?
Dr. Rebmu
Eu não me importo. Cerca de dez bytes a mais para mim! Mas eu concordo totalmente. É difícil ganhar como ele está agora :)
bobbel
5

C - 1004 984 917

Ahh, a beleza de C. Seguindo o espírito da outra resposta, tentei formatar a minha também :)

Imagino que ainda haja algumas melhorias aqui e ali, mas isso foi realmente divertido de escrever e jogar golfe. A contagem de caracteres inclui todos os espaços necessários e novas linhas.

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

Testei isso com todos os casos de amostra e mais alguns dos meus, e parece estar funcionando corretamente. Se alguém encontrar alguma situação em que ela não responda adequadamente, entre em contato.

A entrada é de stdin e a saída para stdout. Não há verificações para entrada incorreta. E, retorna a pontuação se o jogador for comido ou se estiver vivo após a execução de todos os movimentos (mesmo se ainda houver por aí H.

Versão não destruída:

#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);
}
Allbeert
fonte
Agradável!! Embora on @ de bobbel entrada RRRUWWWRRRURWWWWRDRRWWRDWWWWD no grande mapa, você recebe 6, enquanto ele recebe 8. Ele fez um vídeo , você talvez pudesse imprimir cada passo e olhar para qualquer anomalia ...
Dr. Rebmu
(percebendo, claro, que eu mudei a regra para fazer bestas mover cada dois por sua vez, quando eu vi como impossível de jogar a bestas-move-cada-vez foi ...!)
Dr. Rebmu
Para ser sincero: não tenho certeza, se minha solução também funciona 100% corretamente. Mas parece que para mim :)
bobbel
@ Dr.Rebmu, percebi que você editou a pergunta na mesma época em que publiquei a minha. Então, eu apenas fiz um hack rápido que aparentemente funcionou. Vou verificar novamente neste fim de semana e atualizá-lo. Eu também vou postar uma versão "agradável" para que quaisquer erros poderia ser mais fácil de detectar por outras pessoas, bem :)
Allbeert
FWIW Resolvi isso hoje em Rebol e estou recebendo a resposta de 8 da @bobbel também.
Dr. Rebmu