# Tạo lưới Minesweeper

14

Minesweeper là một trò chơi logic được tìm thấy trên hầu hết các hệ điều hành. Mục tiêu của trò chơi là xác định vị trí của các mỏ trên lưới, với các con số cho biết số lượng mỏ xung quanh vị trí đó.

Cho một kích thước lưới và một tập hợp các mỏ, tạo ra lưới Minesweeper cho tập hợp các mỏ đó.

Đầu vào: Hai số nguyên biểu thị kích thước lưới và số nguyên không xác định cho biết vị trí mỏ. Các vị trí sẽ được cung cấp dưới dạng (vị trí cột, vị trí hàng) và các chỉ mục sẽ bắt đầu ở hàng 1.

Đầu ra: Lưới Minesweeper. Nếu không có mỏ xung quanh một khối, in một `x`. Đối với mỗi hàng mới, in một dòng mới. Vui lòng xuất tất cả các mỏ dưới dạng dấu hoa thị `*`. Không để bất kỳ khoảng trắng nào giữa các giá trị trong hàng khi in.

Các trường hợp thử nghiệm:

Nhập "5 5 1 3 3 5 2 4":

``````xxxxx
11xxx
*21xx
2*21x
12*1x
``````

Nhập "3 4 3 1 1 4 2 3 3 2":

``````x2*
13*
2*2
*21
``````

Mã ngắn nhất sẽ thắng.

Chúng ta có an toàn không khi cho rằng tất cả các yếu tố đầu vào sẽ có số lượng chẵn? tức là `5 5 1`sẽ không bao giờ được thông qua?
Gaffi

@Gaffi: Đúng. Đầu vào sẽ luôn là đầu vào hợp lệ.
beary605

Thông số kỹ thuật hiện đang khiến người đọc suy luận từ các ví dụ rằng các vị trí sử dụng chỉ mục dựa trên 1 và hàng 1 ở trên cùng. (Hoặc là cái sau, ít nhất là có thể thương lượng?)
Peter Taylor

@PeterTaylor: Đúng. Tôi đoán tôi nên làm cho nó rõ ràng hơn.
beary605

1
Không vấn đề gì. Tôi vẫn quyết tâm tìm cách loại bỏ một vài nhân vật và lấy lại vị trí dẫn đầu. :-)
Gareth

Câu trả lời:

10

### GolfScript 122 98 94 93 91 88 87 85 82 81 80 71

``````~]2/(\:m;~\:w*,{[.w%)\w/)]:^m\?)42{m{^*~-.*@@-.*+3<},,72or 48+}if}%w/n*
``````

Bản demo trực tuyến:

Trường hợp kiểm tra 1: liên kết

Trường hợp thử nghiệm 2: liên kết

`!!{a}{b}if`sử dụng một ký tự nhiều hơn mức cần thiết. `'*'`có thể được thay thế `42`bởi vì bạn đặt nó trong một mảng và sau đó xâu chuỗi các mảng. Tương tự, bạn có thể sử dụng mã ASCII cho các ký tự đầu ra khác và lưu một ký tự `or`để xử lý trường hợp đặc biệt.
Peter Taylor

@PeterTaylor Wow, `!!{a}{b}if`thực sự rất ngu ngốc. :) Thật buồn cười những lỗi cấp cao bạn có thể làm trong khi tập trung vào chi tiết. Tôi không thể hiểu ý bạn là gì khi sử dụng `or`.
Cristian Lupascu

Thật! Trở lại một vấn đề sau thời gian cũng giúp. Khi tôi viết một vài phân tích mã cho blog GolfScript của mình, tôi đã phát hiện ra những cải tiến đáng kể. Đối với đề nghị cuối cùng của tôi, sau khi `,,`bạn có một số. Bạn muốn chuyển đổi nó thành chuỗi tương ứng (hoặc mã ASCII) trừ khi nó là 0, trong trường hợp bạn muốn x. Mã ASCII cho các chữ số là tuần tự và chạy từ 48. `x`là ASCII 120, là 72 + 48. Vì vậy, bạn có thể làm `72or 48+`và lưu một ký tự theo cách tiếp cận dựa trên chuỗi.
Peter Taylor

@PeterTaylor Tuyệt vời! Trước khi bạn trả lời tôi đã cố gắng giảm phần đó xuống `.48 120if+`, nhưng `or`mẹo của bạn ngắn hơn hai ký tự.
Cristian Lupascu

@ w0lf Gah! Chỉ khi tôi nghĩ rằng tôi đã có được sự dẫn dắt trở lại!
Gareth

8

## J, 124 116 112 101 87 86 85 84 83 82 79 76 75 72 68 ký tự

``````'0x'charsub|:1":3 3(+/@,+9*4&{@,);._3[1(}.x)}0\$~2+>{.x=._2<\".1!:1[1
``````

Tìm thấy những gì tôi đang tìm kiếm - một cách để thoát khỏi khoảng trắng ( `1":`) - và cuối cùng tôi cạnh tranh. Bây giờ tôi chỉ cần tìm ra tập hợp mỏ trống.

Lấy đầu vào từ bàn phím.

Biên tập

Phiên bản mới sử dụng hiệu ứng phụ của `1":`- số lớn hơn 9 được thay thế bằng `*`.

Tôi đã nhận thấy hai điều: 1. Nó in không gian thay vì `0`, không `x`; 2. Thất bại nếu tập hợp các mỏ trống (ví dụ: `10 10`- nên in một bảng 10x10 trống, nhưng trả về `|length error`)
Cristian Lupascu

Nhưng othwerwise nó hoạt động, vì vậy +1.
Cristian Lupascu

@ w0lf Ah, tôi vẫn đang nghĩ về bản thảo đầu tiên của câu hỏi - trong phiên bản đó `x` chỉ đại diện cho một khoảng . Tôi đã không nhận thấy rằng nó đã thay đổi. Hmm, không bao giờ nghĩ rằng bộ mìn sẽ trống rỗng ... Tôi sẽ phải làm việc với nó.
Gareth

bây giờ tôi thấy rằng câu hỏi đã được chỉnh sửa. Tôi đã không thấy bản sửa đổi cũ. :)
Cristian Lupascu

@ w0lf Cảm ơn. Tôi tìm thấy một vài sự sắp xếp lại tốt giúp loại bỏ một số dấu ngoặc không cần thiết. Tôi có thể thấy một không gian tôi có thể xóa, nhưng tôi nghi ngờ tôi khá nhiều ở giới hạn của mình. Và vẫn còn vấn đề danh sách mỏ trống ... :-)
Gareth

2

# Toán học - 247 ký tự

``````s[q_] :=
Module[{d, r},
d = ToExpression@Partition[Cases[Characters@q, Except@" "], 2];
r = Rest@d;
StringJoin @@@
ReplacePart[
Table[ToString@
Count[ChessboardDistance[{i, j}, #] & /@ Reverse /@ r, 1], {i,d[[1, 2]]},
{j, d[[1, 1]]}] /. {"0" -> "x"}, # -> "*" & /@ Reverse /@ r] // TableForm]
``````

Ví dụ:

``````s@"5 5 1 3 3 5 2 4"
s@"3 4 3 1 1 4 2 3 3 2"
``````

Đầu ra: `ChessboardDistance`tính toán mỗi ô cách nhau một mỏ, trong đó 1 ô tương ứng với "bên cạnh mỏ". Số `Count`1 mang lại số của tế bào. Sau đó, mỏ (*) được chèn vào mảng.

David, rất vui khi thấy một người dùng Mathicala khác ở đây. Tôi sẽ xem nếu tôi có thể đánh bại điều này! :-)
Mr.Wizard

@ Mr.Wizard Tôi sẽ quan tâm đến việc xem giải pháp của bạn. Hãy cải thiện tôi nếu bạn muốn.
DavidC

2

## Toán học , 140 139 137

``````Grid[(ListConvolve[BoxMatrix@1,#,2,0]/. 0->x)(1-#)/. 0->"*"]&@Transpose@SparseArray[{##2}->1,#]&@@#~Partition~2&@@#~ImportString~"Table"&
``````

Viết rằng ở dạng dễ đọc hơn:

``````"5 5 1 3 3 5 2 4"

ImportString[%, "Table"][] ~Partition~ 2

Transpose @ SparseArray[{##2} -> 1, #]& @@ %

ListConvolve[BoxMatrix@1, %, 2, 0]

(% /. 0 -> x) (1 - %%) /. 0 -> "*" // Grid
``````

Thanh lịch! Tôi thú nhận tôi không thể hiểu làm thế nào `ListCorrelate[BoxMatrix@1, %, 2, 0]`ma thuật của nó.
DavidC

@David Tôi rất vui vì bạn (ngầm) đã hỏi rằng đó là phần yêu thích của tôi. `ListCorrelate`có hiệu quả lớp phủ kernel ( `BoxMatrix@1`) tại mỗi vị trí trong lưới, nhân và cho tổng. (ping tôi trong trò chuyện mma nếu bạn muốn minh họa) - Nhận xét của bạn nhắc tôi rằng `ListConvolve`cũng nên hoạt động ở đây vì đây là một loại hình ảnh phản chiếu `ListCorrelate`và hạt nhân của tôi là đối xứng. Điều đó sẽ cứu tôi một nhân vật. :-)
Mr.Wizard

Mã của bạn tạo ra một mỏ không chính xác tại (5,5). "5 5" đưa ra kích thước của lưới.
DavidC

@David Cảm ơn. Bạn nói đúng, nhưng nó chỉ có trong phiên bản không gian trắng; Tôi bằng cách nào đó mất đi `2`trong `##2`. Tôi sẽ sửa nó ngay. ps: Làm thế nào mà bạn nhận thấy điều này sau một thời gian dài?
Mr.Wizard

Một câu hỏi khác về quét mìn, codegolf.stackexchange.com/questions/10635/ , gần đây đã xuất hiện và tôi quyết định cung cấp cho giải pháp của bạn một cái nhìn khác.
DavidC

1

## VBA - 298 ký tự

``````Sub m(x,y,ParamArray a())
On Error Resume Next:ReDim b(x,y):For i=0 To (UBound(a)-1) Step 2:c=a(i):d=a(i+1):b(c,d)="*":For e=c-1 To c+1:For f=d-1 To d+1:v=b(e,f):If v<>"*" Then b(e,f)=v+1
Next:Next:Next:For f=1 To y:For e=1 To x:v=b(e,f):s=s & IIf(v<>"",v,"x")
Next:s=s & vbCr:Next:MsgBox s
End Sub``````

Bỏ qua lỗi với `On Error Resume Next`tôi đã lưu một số ký tự, nhưng điều này vẫn không tốt bằng một số câu trả lời khác. : - /

1

## Python, 192 182 180 ký tự

Tôi có thể lưu một số nếu đầu vào được phân tách bằng dấu phẩy. Sau đó, dòng đầu tiên sẽ là `d=input()`và chiều dài 171 ký tự.
Có các tọa độ mỏ dựa trên 0 thay vì dựa trên 1 cũng sẽ giúp ích. Tôi phải trả 8 ký tự để khắc phục.

``````d=map(int,raw_input().split())
m=zip(d[2::2],d[3::2])
for y in range(d):print"".join((str(sum(abs(a-x-1)|abs(b-y-1)<2for a,b in m)or'x')+'*')[(x+1,y+1)in m]for x in range(d))
``````

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

``````d=map(int,raw_input().split())          # Read whitespace terminated numbers into a list of numbers
xsize,ysize = d[:2]                     # The first two numbers are the board size
mines=zip(d[2::2],d[3::2])              # Convert items 3,4,5,6... to pairs (3,4),(5,6) representine mine coordinates

def dist(point,mine):                   # Distance between point (0-based coordinates) and mine (1-based coordinates)
dx = abs(mine-(point+1))
dy = abs(mine-(point+1))
return dx | dy                      # Should be max(dx,dy), but this is close enough. Wrong for d>=2, but returns >=2 in this case.

for y in range(ysize):                  # Print lines one by one
line_chars = [
(str(
sum(dist((x,y),(a,b))<2 for a,b in mines)   # Number of neighboring mines
or 'x'                                  # 'x' instead of 0
)
+'*')                                       # For a single neighbor, we get "1*"
[(x+1,y+1)in mines]                         # If a mine, get the '*', else the neighbor number
for x in range(xsize)
]
print "".join(line_chars)``````

1

# Scala, 280 ký tự

``````val n=readLine split" "map{_.toInt}
val b=Array.fill(n(1),n(0))(0)
n drop 2 sliding(2,2)foreach{case Array(x,y)=>b(y-1)(x-1)=9
for{i<-(x-2 max 0)to(x min n(0)-1);j<-(y-2 max 0)to(y min n(1)-1)}b(j)(i)+=1}
b.map{r=>println(r.map{case 0=>"x"case x if x>8=>"*"case x=>""+x}mkString)}
``````

0

## C ++ - 454 ký tự

Điều này còn tệ hơn câu trả lời VBA của tôi, điều đó có nghĩa là tôi không biết mình đang làm gì trong C ++. Tuy nhiên, tôi đang cố gắng xây dựng dựa trên những gì tôi biết về C ++, vì vậy đây là. Nếu bất cứ ai có bất kỳ đề nghị cải thiện, tôi rất biết ơn khi nghe họ!

``````#define Z for(int i=
#define Y for(int j=
#define X d[i][j]
#define W Z 0;i<x;i++){
#define V Y 0;j<y;j++){
#define U cout<<
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
int main(){using namespace std;int x,y,a,b;cin>>y>>x;string c[x][y];int d[x][y];W V X=0;}}while(cin>>b>>a){c[--a][--b]="*";Z a-1;i<=a+1;i++){Y b-1;j<=b+1;j++){if(x>i&&i>=0&&y>j&&j>=0){X=X+1;}}}}W V if(c[i][j]!="*"){if(X>0){U X;}else{U"x";}}else{U"*";}}U endl;}return 0;}
``````

bạn không cần phải `return 0`. Và bạn có thể `#include<cstdio>`, `#include<cstdlib>`. Bạn thậm chí có thể xóa hai bao gồm cả!. Hơn nữa, `using name.....`quá dài, bạn có thể sử dụng `std::cin, std::cout, std::string`thay thế.
Ray

@Ray Aye, bạn nói đúng về không gian tên ... Đã lâu rồi tôi mới kết hợp nó, nhưng tôi nghĩ rằng tôi có nhiều `std::`cuộc gọi sẽ khiến nó trở nên đáng giá hơn (tôi nghĩ rằng một người nữa `string`sẽ thực hiện nó ). Cảm ơn thông tin về các `#include`dòng là tốt. Tôi không phải là chuyên gia về C ++. ;-)
Gaffi

0

C # (691 ký tự)

``````using System;namespace M{class P{static char C(char[][] g,int r,int c){int n=0;for(int i=r-1;i<=r+1;i++){if(i<0||i>=g.Length)continue;for(int j=c-1;j<=c+1;j++){if((j<0||j>=g.Length)||(i==r&&j==c))continue;if(g[i][j]=='*')n++;}}return n==0?'x':(char)(n+48);}static char[][] G(int[] p){char[][] r=new char[p][];for(int i=0;i<r.Length;i++)r[i]=new char[p];for(int i=2;i<p.Length;){r[p[i+1]-1][p[i]-1]='*';i+=2;}for(int i=0;i<r.Length;i++)for(int j=0; j<r.Length;j++)if(r[i][j]!='*')r[i][j]=C(r,i,j);for(int i=0;i<r.Length;i++){for(int j=0;j<r.Length;j++)Console.Write(r[i][j]);Console.WriteLine();}return r;}static void Main(string[] args){G(new int[]{3,4,3,1,1,4,2,3,3,2});}}}
``````

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

``````using System;
namespace M
{
class P
{
static char C(char[][] g, int r, int c)
{
int n = 0;
for (int i = r - 1; i <= r + 1; i++)
{
if (i < 0 || i >= g.Length) continue;
for (int j = c - 1; j <= c + 1; j++)
{
if ((j < 0 || j >= g.Length) || (i == r && j == c)) continue;
if (g[i][j] == '*') n++;
}
}
return n == 0 ? 'x' : (char)(n + 48);
}

static char[][] G(int[] p)
{
char[][] r = new char[p][];
for (int i = 0; i < r.Length; i++)
r[i] = new char[p];
for (int i = 2; i < p.Length; )
{
r[p[i + 1] - 1][p[i] - 1] = '*';
i += 2;
}
for (int i = 0; i < r.Length; i++)
for (int j = 0; j < r.Length; j++)
if (r[i][j] != '*') r[i][j] = C(r, i, j);
for (int i = 0; i < r.Length; i++)
{
for (int j = 0; j < r.Length; j++)
Console.Write(r[i][j]);
Console.WriteLine();
} return r;
}
static void Main(string[] args)
{
G(new int[] { 3, 4, 3, 1, 1, 4, 2, 3, 3, 2 });
}
}
}
``````

0

# K, 175

``````f:{g::(y;x)#(x*y)#"x";{.[`g;x;:;"*"]}@'-1+|:'(_(#z)%2;2)#z;{if[~"0"~z;\$["x"=g .(x;y);.[`g;(x;y);:;z];]]}.'i,'\$s:+/'{"*"=g . x}''{,/((x-1)+!3),\:/:(y-1)+!3}.'i:,/(!x),\:/:!y;g}
``````

.

``````k)f[5;5;1 3 3 5 2 4]
"xxxxx"
"11xxx"
"*21xx"
"2*21x"
"12*1x"
k)f[3;4;3 1 1 4 2 3 3 2]
"x2*"
"13*"
"2*2"
"*21"
``````

0

ECMAScript 2019 (Javascript hiện đại) - 116 byte

``````m.map((r,i)=>r.map((c,j)=>c=='X'?c:[,...m].splice(i,3).map(r=>[,...r].splice(j,3)).flat().filter(v=>v=='X').length))
``````

phiên bản vô văn hóa

``````m.map(
(r,i) => r.map(
(c,j) => c=='X' ? c :
[,...m].splice(i,3).map(r=>[,...r].splice(j,3)).flat().filter(v=>v=='X').length
)
)
``````

giải pháp này không tuân thủ nghiêm ngặt định dạng đầu vào / đầu ra nhưng thể hiện thuật toán cô đọng.

0

# Brainfuck , 1001 896 byte

``````,[>,]-[<]>>++[<[<+<+>>-]<[>+<-]>[>]>[>>[>>>>]>]++[-<+]-[<]<++[>>[>]>[>>[>>>>]>]+<++[-<+]-[<]<-]>>>-]>[>]>[>>[>>>>]<<<->>>>]+[-<+]-[<]>>[[>]>--<<[<]>>[[>]+[->+]+>>[>>>>]>--<+[-<+]-[<]>>-]>[>]+[->+]+>>--<+[-<+]-[<]<[>>[>]+[->+]+>>>>--<+[-<+]-[<]<-]>>[>]+[->+]+>++[-<+]-[<]>>]>[+>>[>>>>]>]<<<<<[<<<<]>>-<+[-<+]>>>>[>>>>]>[-[--<<<<<[<<<<]>>>>--[>>>>]>>>[>>>>]>>>--<+[-<+]++>>>>>>[>[<--<<<[-[>>>>>>+<<<<<+<-]>+<]>[<+>-]>>>>+++[<<<+[-<+]->[-[+[->+]->>>+<<<<+[-<+]->>+<-]>+<]>[<+>-]+[->+]->>-[<<<+[-<+]+>>>>-->+[->+]->>[<<<+>>>-]]<<<[>>>+<<<-]>>>]<<<+[-<+]+<<<<-->+[->+]->>>>>[-[<<+>>>+<-]>+<]>[<+>-]<<<<+++[+[->+]->[-[<<+[-<+]->>>++[->+]->>+<-]>+<]>[<+>-]<<<+[-<+]->>-[+[->+]+>>>>--<+[-<+]->>[<<<+>>>-]]<<<[>>>+<<<-]>>>]+[->+]+<<<<--<+[-<+]->-[>>[-]<<++++++[>++++++<-]>.[-]+<<<]<[>>>[<++++++[>++++++++<-]>.[-]<]<<<[<++++++++[<+++++++++++>-]<.[-]>]<]>>>>+<<++>]>[<+>-]>>]->+[->+]++[-<+]++++++++++.[-]]>]
``````

Một ngày lập trình và ba ngày sửa lỗi ^^

Điều này sử dụng một vài phần trong mã Game Of Life của tôi. Thay vì đếm các tế bào sống, điều này đếm bom. Vì đầu vào dưới dạng mã được cho phép theo quy tắc chung, nên điều này sử dụng chúng thay vì số nguyên "có thể đọc được".

``````[
Data: colCount, rowCount, {BombCoordinates}, -1 (start of arrays/"soa"), 0, {RowData}
BombCoordinates: bombCol, bombRow
RowData: rowFlag, 0, {CellData}, 0
CellData: cellFlag, cellState, temp, bombCount

rowFlag: 0=EOF, 1=inactive (all cells inactive), 2=active
cellFlag: -1=marker for finding cell (cell to be counted or current cell), 0=EOF, 1=normal
cellState: 0=inactive, 1=normal, 2=bomb
temp: helper to exit if-statements
bombCount: count of neighbor cells that contain bombs
inactive cells or rows will not be printed. They are only used for an easier counting algorithm.
]

#### input values as codepoints ####
,[>,]

#### setup two dimensional array ####
-                   set soa
[<]>>               go to rowCount
[                   for each row
<[<+<+>>-]          copy colCount two times to the next left cells
<[>+<-]             move one of the copies back to the original cell
>[>]>[>>[>>>>]>]    go to new row position
+                   set rowFlag (only 1 while initialization)
+[-<+]-[<]<         go to copy of colCount
++                  add two inactive cells per row
[                   for each col
>>[>]>[>>[>>>>]>]   go to new cell position
+<+                 set cellFlag and cellState = normal
-                   decrement
]
>>>-                decrement rowCount
]

#### setup active/inactive flags of cells ####
>[>]>[              for each row
>>[>>>>]<<<-        set last cell inactive
>>>>                go to next row
]

#### mark the bombs ####
+[-<+]-[<]>>        go to bombRow
[                   while there are bombRow values left
[>]>--              set rowFlag of first row = neg 1 (as a marker)
[                   for each bombRow
[>]+[->+]           find first marker after soa
+                   set rowFlag = 1
>>[>>>>]>           go to next rowFlag
--                  make a marker of it
-                   decrement
]
>[>]+[->+]          go to selected rowFlag
+                   set rowFlag = 1
>>--                set cellFlag of first cell = marker
<+[-<+]-[<]<        go to bombCol
[                   for each bombCol
>>[>]+[->+]         find first marker after soa
+                   set cellState = 1
>>>>                go to next cellState
--                  set it neg 1 (as a marker)
-                   decrement
]
>>[>]+[->+]         find first marker after soa
+                   set cellFlag = normal
>+                  set cellState = bomb
+[-<+]-[<]>>        go to next bombRow
]

#### setup active/inactive flags of rows ####
>[                  for each row
+                   set rowFlag = 2 (active)
>>[>>>>]>           go to next rowFlag
]
<<<<<[<<<<]>>-      set rowFlag of last row = 1 (inactive)

#### count bombs in neighborhood ####
<+[-<+]>>>>[>>>>]>  go to second row
[                   for each row
-[                  if active
--                  set it neg 1 (marker)
<<<<<[<<<<]>>>>     go to cellFlag of first cell in previous row
--                  set it neg 1 (marker)
[>>>>]>>>[>>>>]>>>  go to cellFlag of first cell in next row
--                  set it neg 1 (marker)
++                  set rowFlag = 2 (active)

>> >>>>[            for each cell (starting with second)
>[                  if active
<--                 set cellFlag = neg 1 (marker)

# check if cell to the left is a bomb
< <<                go to cellState of previous cell
[                   if active
-[                  if bomb
>> >>>>+            increment bombCount
<<<< <              go back to checked cell
+                   set temp = 1
<-                  set cellState = 0 to exit if
]
>+<                 increment temp
]
>[<+>-]             restore cellState

# check if cells on top are bombs
> >>>               go to temp of current cell
+++[                do three times
<<<+[-<+]-          go to next marker to the left
>[                  if active
-[                  if bomb
>>>+                increment bombCount
>+                  set temp = 1
<-                  set cellState = 0 to exit if
]
>+<                 increment temp
]
>[<+>-]             restore cellState
+[->+]-             go to current cell
>>-                 decrement temp
[                   if temp != 0
<<<+[-<+]           go to marked cell
+                   set cellFlag = normal
>>>>--              set cellFlag of next cell = marker
[<<<+>>>-]          store value of temp in previous cell bombCount (to exit if)
]
<<<[>>>+<<<-]>>>    restore temp value
]
<<<+[-<+]           go to marked cell
+                   set cellFlag = normal
<<<<--              set previous cellFlag = marker

# check if cell to the right is a bomb
>>> >>              go to cellState of next cell
[                   if active
-[                  if bomb
<<+                 increment bombCount
>>>                 go back to checked cell
+                   set temp = 1
<-                  set cellState = 0 to exit if
]
>+<                 increment temp
]
>[<+>-]             restore cellState

# check if cells below are bombs
<<< <               go to currentCell temp
+++[                do three times
+[->+]-         go to next marker to the right
>[              if active
-[              if bomb
>>>+            increment bombCount
>+              set temp = 1
<-              set cellState = 0 to exit if
]
>+<             increment temp
]
>[<+>-]         restore cellState
<<<+[-<+]-      go to current cell
>>-             decrement temp
[               if temp != 0
+[->+]          go to marked cell
+               set cellFlag = normal
>>>>--          set cellFlag of next cell = marker
[<<<+>>>-]      store value of temp in previous cell bombCount (to exit if)
]
<<<[>>>+<<<-]>>>restore temp value
]
+[->+]          go to marked cell
+               set cellFlag = normal
<<<<--          set previous cellFlag = marker

# print
>-[             if bomb
>>[-]<<         delete bombCount
++++++[>++++++<-]>.print "*"
[-]+            set temp = 1
<<<             use previous cell bombCount as exitIf
]
<[              else
>>>[            if bombCount != 0
<++++++[>++++++++<-]add 48 to get ascii number
>.              print
[-]             set number = 0 (for use as exitIf from next cell)
<               go to temp for exit if
]
<<<[            else
<++++++++[<+++++++++++>-]<.print "X"
[-]             delete value (for use as exitIf from next cell)
>               go to exitIf
]
<               go to exitElse
]
> >>>+          increment temp
<<++>           set cellFlag = normal
]
>[<+>-]         restore cellState
>>              go to cellFlag of next cell
]
-               set marker
>+[->+]         go to next marker
+               set cellFlag = normal
+++++ +++++.[-] print newline
]
>               go to next row
]
``````

0

Đây là sự khởi đầu của một giải pháp Brainfuck. Nó sẽ khá dễ đọc với các chú thích ngăn xếp và ngăn xếp ( `@`biểu thị con trỏ ngăn xếp):

``````>>,>,  |0|x|@y| Pop the first two characters
[>>+<<-]>>  |0|x|0|0|@y|
[<<+>+>-]<  |0|x|@y|y|0|
[  |0|x|y|@y|
[>>+<<-]< |0|x|@y|0|0|y|
[>>+<<-]< |0|@x|0|0|y|y|
[>>+<<-]>> |0|0|0|@x|y|y|
[<<+>+>-]<<  |0|@x|x|0|y|y|
[>>+<<-]> |0|0|@x|x|y|y|
[<< |@0|0|x|x|y|y|
++++++++[>+++++++++++<-]>>>>> |0|88|x|x|@y|y|
[>+<-]< [>+<-]< [>+<-]< [>+<-]< |0|@88|0|x|x|y|y|
[<+>-]>>-  |88|0|0|@x_1|x|y|y|
]<< |x x's|@0|0|0|x|y|y|
++++++++++>>> x's|\n|0|0|@x|y|y|
[<+>-]>  x's|\n|0|x|0|@y|y|
[<+>-]>  x's|\n|0|x|y|0|@y|
[<+>-]<- |x 88s|0|x|@y_1|y|
] |@x 88s|0|x|y|
``````

Tuy nhiên vẫn còn lâu mới hoàn thành và tôi bắt đầu nghi ngờ nếu cách tiếp cận của tôi là tối ưu. Cho đến nay, nó chỉ xem xét hai ký tự đầu tiên và in một bảng Xs. Ví dụ: "43" sẽ cung cấp cho bạn:

``````XXXX
XXXX
XXXX
``````

Tôi rất muốn xem liệu ai đó có những gì nó cần và có khả năng giải quyết vấn đề này trong Brainfuck.

Tối ưu là hoàn toàn không liên quan trong tâm trí của tôi khi giao dịch với BrainFuck. Thông số kỹ thuật phiên dịch bạn đang nhắm mục tiêu là gì? Giống như các tế bào 8 bit hay gì? Tôi rất thích nhìn thấy điều này kết thúc.
captncraig

Tôi nghĩ rằng nó là khá độc lập với bất kỳ intepreter cụ thể? Miễn là con số không lớn một cách vô lý.
paldepind

Làm việc trên một tâm hồn, nhưng tất nhiên nó luôn trở nên khó khăn hơn so với lúc đầu ở Brainfuck.
captncraig

Tôi đã dành vài ngày qua để xây dựng một mã não đang chạy cho việc này.
Dorian
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.