Như chúng ta đã học từ IBM PC AT, YouTube (xem video) , Wikipedia (xem bài viết) và Sesame Street:

Bức thư Hlà lá thư tàn nhẫn nhất của bảng chữ cái !

(Ngay cả khi thực sự được sáng tác từ hai yếu tố trong Bộ luật 437. Trên thực tế, nó thậm chí còn HƠN NỮA theo cách đó.)

Giống như Người ngoài hành tinh, uhm ... er ... Người ngoài hành tinh , Quái thú không ngừng theo đuổi tất cả những ai dám đến gần trứng của họ. Không có lý do với họ. Bạn phải đè bẹp chúng nếu không để diệt vong.

Đối với kịch bản này, chúng tôi sẽ cho rằng bạn đang ở kiếp trước và bạn đã gặp Quái thú đơn giản ở một địa hình không có trứng (như trong ảnh chụp màn hình Wikipedia). Bạn không có bàn phím số và chỉ có thể di chuyển trực tiếp lên / xuống / trái / phải ... nhưng các con thú rõ ràng có một bàn phím và có thể di chuyển theo đường chéo trong lượt của chúng.

Lựa chọn di chuyển của Quái thú trong số các lựa chọn của nó sẽ là lựa chọn giảm thiểu khoảng cách với người chơi. Nếu khoảng cách bằng nhau thì việc ngắt kết nối được thực hiện theo hướng trái + lên trên phải + xuống, nhưng đây là ma trận định hướng rõ ràng về nó ... số thấp nhất để ngắt kết nối:

1 3 4
2 H 5
6 8 7

Một con thú không bao giờ ngủ, nhưng may mắn là chúng chậm hơn một chút so với người chơi. Họ di chuyển mọi lượt khác (cho người chơi bắt đầu bằng cách bắt đầu thay thế của họ ở lượt thứ hai). Họ phải di chuyển nếu có thể di chuyển, bất kể điều đó có đưa họ đi xa hơn từ người chơi hay không.

Bạn nghiền nát một con thú nếu bạn di chuyển một đoàn tàu có thể di chuyển được, nơi nó đang ngồi trong một khoảng trống kín. Những con thú đơn giản này có giá trị 2 điểm một cái đầu.

Đầu vào

1. Một cặp số nguyên cho biết kích thước của bản đồ trong các cột sau đó là các hàng.

2. Số lượng hàng của dòng đầu vào, mỗi kích thước cột ... chứa một bức tường vững chắc ( #), một bức tường di động ( ~), một con thú ( H), người chơi ( O) hoặc chỉ một khoảng trắng.

3. Đầu vào sẽ là U, D, L, R cho biết người chơi đã cố gắng di chuyển ... hoặc W chỉ chờ. Lưu ý rằng cố gắng đẩy một bức tường di động bị chặn là đầu vào hợp pháp, nó sẽ không dẫn đến hành động.

Đầu ra

1. aHHHH! nếu quái thú giết người chơi ... hoặc không có gì nếu người chơi chiến thắng mà không còn quái thú nào

2. Điểm số

(Lưu ý: Đối với mục đích gỡ lỗi và / hoặc giải trí, có lẽ bạn sẽ muốn có thể xuất trạng thái ở mỗi bước; nhưng quá lâu để đăng ở đây.)

Làm rõ

• Bản đồ được đảm bảo giới hạn bởi các bức tường vững chắc.

• Thứ tự của người di chuyển trong một lượt quan trọng cho kết quả. Do đó: Người chơi luôn đi trước, sau đó các quái thú được ra lệnh dựa trên vị trí bản đồ ban đầu của chúng nếu bạn quét qua màn hình từ trên xuống dưới từ trái sang phải. (Một con thú 1 hàng di chuyển trước một con thú 2 hàng và hai con thú trên cùng một hàng, nó sẽ là con có số cột thấp nhất sẽ di chuyển trước con kia)

• Các con thú di chuyển chéo có thể di chuyển vào bất kỳ không gian chéo liền kề mở nào, bất kể nó có yêu cầu ép giữa các bức tường.

• Người chơi có thể đẩy bất kỳ số lượng tường di động nào trong một dòng với điều kiện là có một không gian hoặc một con thú ở đầu kia. Nhưng cố gắng đẩy một đoàn tàu thành Quái thú không bị kẹp giữa các bức tường coi Quái thú như một bức tường, và sẽ không cho phép di chuyển.

• Quyết định di chuyển của Quái thú trong lượt chơi dựa trên vị trí của người chơi ở đầu lượt. Tối ưu hóa mong muốn của nó về "khoảng cách đến người chơi" là thông qua tính toán "khi con quạ bay". Bất kỳ phép tính gần đúng nào sẽ cho kết quả tương tự như được đo từ tâm hình vuông đến tâm hình vuông của người chơi đều ổn.

• Nếu một Quái thú không thể thực hiện được bước di chuyển ưa thích đầu tiên của mình trong lượt vì Quái thú có mức độ ưu tiên cao hơn sẽ chiếm vị trí, nó sẽ đưa ra lựa chọn tốt nhất tiếp theo thay vì giữ nguyên vị trí (nếu vẫn có thể di chuyển).

Trường hợp mẫu

Crush đơn giản

Đầu vào

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

Đầu ra

2

Ma trận ưu tiên -> Cái chết

Đầu vào

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

Đầu ra

aHHHH!
0

Ma trận ưu tiên -> Thắng

Đầu vào

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

Đầu ra

2

Chờ người gặt

Đầu vào

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

Đầu ra

aHHHH!
0

Thất bại thành công trong kịch bản Wikipedia

Đầu vào

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

Đầu ra

8

Bản đồ được cung cấp bởi tôi, di chuyển và đầu ra bởi @bobbel, được chứng thực bởi chính tôi và @ ALLbeert.

Tiêu chí chiến thắng

Tôi nghĩ rằng đây là môn đánh gôn, vì vậy tôi sẽ tuân theo luật chơi golf trừ khi mọi người phàn nàn.

Tín dụng thêm

Triển khai Unicode có thể phát với các ký tự rộng gấp đôi để giống với hình ảnh!

Perl 6: 741 ký tự, 758 byte

Phiên bản chơi gôn nằm ở phía dưới, vì về cơ bản là linenoise. Trên nó là phiên bản trước khi chơi golf của tôi. Cả hai đều tương tác (họ sẽ đọc càng nhiều lệnh từ tệp đầu vào càng tốt và sau đó chuyển sang sử dụng STDIN để nhận lệnh). Họ cố gắng sử dụng các ký tự gốc và màu sắc.

Cách sử dụng giống như 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;

Phiên bản chơi gôn:

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;

Chúc mừng lễ Phục sinh!

Java, 1.843

Lần thử đầu tiên của tôi để giải câu đố này với Java. Tôi biết rằng có rất nhiều cải tiến để làm cho nó ngắn hơn. Nhưng cuối cùng nó vẫn hoạt động.

Để thử nó, bạn phải tạo một lớp Cvà dán mã. args[0](nói đúng a[0]) là cho đầu vào. Phương pháp in của bản đồ không được bao gồm vì không cần thiết cho đầu ra câu đố.

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

Để chạy nó, hãy thử ví dụ:

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

Đầu ra của kịch bản lớn cuối cùng một lượt trước khi một con thú ăn thịt người chơi:

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

Không có không gian dòng ngớ ngẩn: http://pastebin.com/raw.php?i=QhpxKcCT

Vì vậy, cách người chơi kết thúc sau khi di chuyển RRDDDRRRWW, bởi vì vào lần cuối W, con thú bên trái sẽ đi sang bên phải để ăn thịt người chơi.

Một ví dụ khác về bản đồ lớn ban đầu nhưng di chuyển khác nhau:

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

Xem hoạt hình này: http://youtu.be/0DIhEhjWd6s

Và ví dụ cuối cùng với bản đồ gốc và các bước di chuyển khác nhau (theo quy tắc di chuyển của quái thú mới):

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

Xem trên youtube: http://youtu.be/jXPzL88TU2A

C - 1004 984 917

Ahh, vẻ đẹp của C. Theo tinh thần của câu trả lời khác, tôi cũng cố gắng định dạng của mình :)

Tôi tưởng tượng vẫn còn một số cải tiến ở đây và đó, nhưng điều này thực sự thú vị để viết và chơi gôn. Số lượng nhân vật bao gồm tất cả các không gian cần thiết và dòng mới.

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

Tôi đã thử nghiệm điều này với tất cả các trường hợp mẫu và một vài trường hợp khác của tôi, và nó dường như đang hoạt động đúng. Nếu bất cứ ai tìm thấy bất kỳ tình huống mà nó không trả lời đúng, xin vui lòng cho tôi biết.

Đầu vào là từ stdin, và đầu ra đến thiết bị xuất chuẩn. Không có kiểm tra cho đầu vào không chính xác. Và, nó sẽ trả về điểm nếu người chơi bị ăn hoặc nếu người chơi còn sống sau khi tất cả các chuyển động được thực hiện (ngay cả khi vẫn còn Hxung quanh.

Phiên bản bị đánh cắp:

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