aHHHH! ¡Las bestias están HHH here!

19

Como aprendimos de IBM PC AT, YouTube (ver video) , Wikipedia (ver artículo) y Sesame Street:

¡La letra Hes la letra más despiadada del alfabeto !

(Incluso cuando en realidad está compuesto de dos elementos en la página de código 437. De hecho, es incluso MÁS despiadado de esa manera).

Al igual que los Aliens en, uhm ... er ... Aliens , Bestias persiguen implacablemente a todos los que se atrevan a acercarse a sus huevos. No hay razonamiento con ellos. Debes aplastarlos para no perecer.

Un encuentro aterrador con el 4H Club

Para este escenario, asumiremos que estás en tu última vida y que has conocido a Bestias simples en un terreno sin huevos (como en la captura de pantalla de Wikipedia). No tiene un teclado numérico y solo puede moverse directamente hacia arriba / abajo / izquierda / derecha ... pero las bestias aparentemente tienen uno, y pueden moverse en diagonal en su turno.

La opción de movimiento de una Bestia entre sus opciones será la que minimice la distancia del jugador. Si las distancias son iguales, el desempate se realiza favoreciendo la izquierda + arriba sobre la derecha + abajo, pero aquí está la matriz de desambiguación para ser explícito al respecto ... el número más bajo para el desempate:

1 3 4
2 H 5
6 8 7

Una bestia nunca duerme, pero afortunadamente son un poco más lentas que el jugador. Se mueven cada dos turnos (dando al jugador una ventaja al comenzar sus alternancias en el segundo turno). Deben moverse si es posible, independientemente de si eso los aleja más del jugador.

Aplastas a una bestia si mueves un tren de paredes móviles donde estaba sentado en un espacio cerrado. Estas bestias simples valen 2 puntos por cabeza.

Entrada

  1. Un par de enteros que indican el tamaño de un mapa en columnas y luego en filas.

  2. Recuento de filas de líneas de entrada, cada una del tamaño de columna ... que contiene un muro sólido ( #), un muro móvil ( ~), una bestia ( H), el jugador ( O) o simplemente un espacio.

  3. Entrada que será U, D, L, R que indica un intento de movimiento por parte del jugador ... o W para esperar. Tenga en cuenta que intentar empujar una pared móvil que está bloqueada es una entrada legal, simplemente no dará lugar a ninguna acción.

Salida

  1. aHHHH! si las bestias mataron al jugador ... o nada si el jugador ganó sin que queden bestias

  2. El marcador

(Nota: para fines de depuración y / o diversión, probablemente querrá poder generar el estado en cada paso; pero eso es demasiado largo para publicar aquí).

Aclaraciones

  • Se garantiza que los mapas estarán delimitados por paredes sólidas.

  • El orden de quién se mueve por turno es importante para el resultado. Por lo tanto: el jugador siempre va primero, luego las bestias reciben una orden basada en su posición inicial del mapa si estabas barriendo la pantalla de arriba a abajo de izquierda a derecha. (Una bestia de la fila 1 se mueve antes que una bestia de la fila 2, y dos bestias en la misma fila sería la que tenga el número de columna más bajo que se movería antes que la otra)

  • Las bestias en movimiento diagonales pueden moverse en cualquier espacio diagonal adyacente abierto, independientemente de si requiere apretarse entre las paredes.

  • Un jugador puede empujar cualquier número de paredes móviles en una línea siempre que haya un espacio o una bestia en el otro extremo. Pero tratar de empujar un tren de paredes hacia una Bestia que no está atrapada entre las paredes trata a la Bestia como una pared, y no permite el movimiento.

  • La decisión de movimiento de una Bestia durante un turno se basa en la ubicación del jugador al comienzo del turno. La optimización deseada de la "distancia al jugador" es a través de un cálculo "en línea recta". Cualquier aproximación que dé el mismo resultado medido desde el centro de su cuadrado hasta el centro del cuadrado del jugador está bien.

  • Si una Bestia no puede hacer lo que hubiera sido su primer movimiento preferido en un turno porque una Bestia de mayor prioridad tomó su lugar, tomará su próxima mejor opción en lugar de permanecer en su lugar (si un movimiento aún es posible).

Casos de muestra

Simple Crush

Entrada

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

Salida

2

Matriz de preferencias -> Muerte

Entrada

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

Salida

aHHHH!
0

Matriz de preferencias -> Ganar

Entrada

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

Salida

2

Esperando al segador

Entrada

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

Salida

aHHHH!
0

Derrota exitosa en el escenario de Wikipedia

Entrada

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

Salida

8

Mapa proporcionado por mí, movimientos y resultados de @bobbel, corroborado por mí y @Allbeert.

Criterios ganadores

Creo que esto es golfable, así que seguiré las reglas del código de golf a menos que la gente se queje.

Crédito adicional

¡Implementación Unicode jugable con los caracteres de doble ancho para parecerse a la imagen!

Dr. Rebmu
fuente
¿Los movimientos diagonales saltan sobre las líneas de paredes antidiagonales? Dado que una bestia hace un movimiento cada turno, ¿cómo rompe los lazos de distancia entre dos movimientos horizontales o dos movimientos verticales? ¿Se mueve hacia donde estaba el jugador al comienzo del turno, o después del movimiento del jugador? Cuando dices "tren de paredes móviles", ¿eso significa que el jugador puede empujar cualquier número de paredes móviles en una línea siempre que haya un espacio o una bestia en el otro extremo?
Peter Taylor
2
Si lo entiendo correctamente, el segundo ejemplo es incorrecto, porque pastebin.com/raw.php?i=CqPJPjTR .
Pomo de la puerta
1
@ Dr.Rebmu: generalmente me gusta mucho su tarea, pero hay muchas preguntas que hacer. ¡Gracias por aclararlo! Entonces, a continuación: ¿qué pasa con esta situación de Dos Bestias: pastebin.com/raw.php?i=FENVAkCH ¿Es correcta mi suposición?
bobbel
1
Otra pregunta: ¿Qué pasa si mueves un tren de paredes hacia una bestia que no está "inmovilizada"? pastebin.com/raw.php?i=isN4L6pJ
Claudiu
3
@bobbel Man, escribir preguntas es más difícil que resolverlas. :-) Digo, dada la propensión de las Bestias a no quedarse quietas, tomarán su próximo mejor movimiento si está disponible en lugar de renunciar a su movimiento ese turno, si una Bestia de mayor prioridad tomó su lugar ideal. Aclarado
Dr. Rebmu

Respuestas:

3

Perl 6: 741 caracteres, 758 bytes

La versión de golf está en la parte inferior, ya que es básicamente linenoise. Arriba está mi versión pre-golf. Ambos son interactivos (leerán tantos comandos del archivo de entrada como puedan y luego usarán STDIN para obtener comandos). Intentan usar los caracteres y colores originales.

El uso es 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;

La versión de golf:

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;

¡Felices Pascuas!

Mouq
fuente
Son reglas de código de golf, así que dado que su solución gana ... incluso si no me gusta mucho Perl. ;-) ¡Buen trabajo con la consola y el color!
Dr. Rebmu
14

Java, 1,843

Mi primer intento de resolver este rompecabezas con Java. Sé que hay muchas mejoras para acortarlo. Pero al final funciona por ahora.

Para probarlo, debes crear una clase Cy pegar el código. args[0](estrictamente hablando a[0]) es para la entrada. El método de impresión del mapa no está incluido, ya que no es necesario para la salida del rompecabezas.

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 ejecutarlo, intente por ejemplo:

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

Salida del último gran escenario un turno antes de que una bestia se coma al jugador:

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

Sin espacios de línea tontos: http://pastebin.com/raw.php?i=QhpxKcCT

Entonces el camino de los jugadores termina después de los movimientos RRDDDRRRWW, porque en el último Wgolpe, la bestia a la izquierda irá a la derecha para comer al jugador.


Otro ejemplo del gran mapa original pero con diferentes movimientos:

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

Ver esta animación: http://youtu.be/0DIhEhjWd6s


Y el último ejemplo con mapa original y diferentes movimientos (de acuerdo con las nuevas reglas de movimiento de bestias):

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

Ver en youtube: http://youtu.be/jXPzL88TU2A

bobbel
fuente
1
¡Jaja! :-) Muy genial. Mientras lo hayas obtenido, ¿quieres jugar algunos juegos y dar más datos de casos de prueba en ese mapa?
Dr. Rebmu
He agregado un nuevo escenario con mapa original y diferentes movimientos. Pero realmente no se puede seguir los pasos, porque no desea pegar los 75 pasos para Pastebin :)
Bobbel
Entonces, ¡agregué un video para ver el resultado como una animación!
bobbel
Buen video ... ¡aunque parece mostrar que las bestias se mueven demasiado rápido para ser divertidas! ¿Deberíamos cambiar la regla para que se muevan cada dos turnos en lugar de cada turno?
Dr. Rebmu
No me importa ¡Unos diez bytes más para mí! Pero estoy totalmente de acuerdo. Es difícil ganar como lo es ahora :)
bobbel
5

C - 1004 984 917

Ahh, la belleza de C. Siguiendo el espíritu de la otra respuesta, traté de formatear la mía también :)

Me imagino que todavía hay algunas mejoras aquí y allá, pero fue muy divertido escribir y jugar golf. El recuento de caracteres incluye todos los espacios necesarios y las nuevas líneas.

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

Probé esto con todos los casos de muestra y algunos más míos, y parece estar funcionando correctamente. Si alguien encuentra alguna situación en la que no responde correctamente, avíseme.

La entrada es desde stdin y la salida hacia stdout. No hay comprobaciones de entrada incorrecta. Y, devuelve el puntaje si el jugador es comido, o si el jugador está vivo después de que se ejecutan todos los movimientos (incluso si todavía hay Halrededor).

Versión sin golf:

#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
fuente
¡¡Agradable!! Aunque en la entrada de @ bobbel RRRUWWWRRRURWWWWRDRRWWRDWWWWD en el mapa grande, obtienes 6 mientras que él obtiene 8. Hizo un video , tal vez podrías imprimir cada paso y buscar cualquier anomalía ...
Dr. Rebmu
(¡notando, por supuesto, que cambié la regla para hacer que las bestias se muevan cada dos turnos cuando vi cuán injugable era la jugada de las bestias en cada turno ...!)
Dr. Rebmu
Para ser honesto: no estoy seguro, si mi solución también funciona al 100% correctamente. Pero me parece :)
bobbel
@ Dr.Rebmu Me di cuenta de que editó la pregunta casi al mismo tiempo que publiqué la mía. Así que hice un truco rápido que aparentemente funcionó. Lo revisaré este fin de semana y lo actualizaré. También publicaré una versión "agradable" para que cualquier error sea más fácil de detectar por otras personas también :)
Allbeert
FWIW Resolví esto hoy en Rebol y estoy recibiendo la respuesta de @ bobbel de 8 también.
Dr. Rebmu