Minesweeper là một trò chơi giải đố phổ biến, nơi bạn phải khám phá những viên gạch nào là "mỏ" mà không cần nhấp vào những viên gạch đó. Mỗi ô là một mỏ (đại diện bởi *) hoặc một đầu mối, tức là một số từ 0 đến 8 đại diện cho bao nhiêu trong số 8 ô lân cận là mỏ. Nhiệm vụ của bạn hôm nay là lấy một tấm bảng chứa mìn và điền vào tất cả các manh mối. Ví dụ: nhìn vào bảng 5x4 sau, với 5 mỏ:

 *  
*  * 
  *  
    *

Sau khi điền vào các đầu mối, bảng sẽ trông như thế này:

2*211
*33*1
12*32
0112*

Chi tiết

Bạn phải viết một chương trình đầy đủ hoặc một hàm có trong một lưới các ký tự chỉ chứa các khoảng trắng và dấu hoa thị và xuất ra một lưới khác trong đó mỗi không gian được thay thế bằng số lượng các mỏ liền kề (dấu hoa thị). Bất kỳ trong số này là các định dạng có thể chấp nhận cho lưới của bạn:

• Một chuỗi có dòng mới trong đó

• Danh sách 2D các ký tự / chuỗi ký tự đơn

• Một danh sách các chuỗi

Bạn có thể giả sử lưới sẽ có ít nhất 1x1, mặc dù có thể nó là tất cả các mỏ hoặc tất cả các không gian.

Lưới đầu vào sẽ luôn được đệm với số lượng khoảng trống thích hợp. Như thường lệ, đây là môn đánh gôn , vì vậy các sơ hở tiêu chuẩn được áp dụng và câu trả lời ngắn nhất bằng byte sẽ thắng!

IO mẫu

Để bạn có thể thấy khoảng trắng, tôi sẽ hiển thị tất cả IO mẫu với dấu ngoặc quanh nó.

Input:
[    * ]
[*     ]
[      ]
[      ]
[  **  ]
[ *  * ]

Output:
[1101*1]
[*10111]
[110000]
[012210]
[12**21]
[1*33*1]

Input:
[****]
[****]

Output:
[****]
[****]

Input:
[   ]
[   ]
[   ]
[   ]

Output:
[000]
[000]
[000]
[000]

Input:
[*   ]
[**  ]
[    ]
[   *]

Ouput:
[*310]
[**10]
[2221]
[001*]

Input:
[**    ]
[*    *]
[  *   ]
[      ]
[*     ]
[****  ]

Output:
[**1011]
[*4211*]
[12*111]
[121100]
[*43210]
[****10]

Input:
[     *    ]
[        * ]
[     *    ]
[**   ***  ]
[      *** ]
[          ]
[       ** ]
[  * *     ]
[*      ** ]
[       ** ]

Output:
[00001*1111]
[00002221*1]
[22102*4321]
[**102***31]
[221013***1]
[0000013542]
[0112111**1]
[12*2*12442]
[*212112**2]
[1100002**2]

MATL , 18 17 byte

Cảm ơn @ mbomb007 vì đã sửa lỗi trong trường hợp kiểm tra 6

32>t3Y6Z+-6b(48+c

Đầu vào là một mảng char 2D, ở định dạng

[' *   '; '*  * '; '  *  '; '    *']

Hãy thử trực tuyến!

Các trường hợp thử nghiệm: 1 , 2 , 3 , 4 , 5 , 6 .

Giải trình

32>      % Input 2D char array implicitly. Transform it into a 2D logical
         % array with asterisk replaced by true and space by false
t        % Duplicate
3Y6      % Push [1 1 1; 1 0 1; 1 1 1]. This defines the neighbourhood
Z+       % 2D convolution, keeping size. Gives the number of neighbouring
         % mines for each position
-6       % Push -6
b        % Bubble up in stack
(        % Assign -6 to the entries indicated by the logical array, i.e.
         % to the positions that originally contained asterisks 
48+      % Add 48. This transforms each number of neighbouring mines
         % into its ASCII code, and -6 into 42 (ASCII code of asterisk)
c        % Convert to char. Display implicitly

JavaScript (ES6), 114 96 byte

a=>a.map((s,i)=>s.replace(/ /g,(_,j)=>g(k=>(s=a[i+k])?g(k=>s[j+k]>' '):0)),g=f=>f(-1)+f(0)+f(1))

Chỉnh sửa: Đã lưu 18 byte nhờ một ý tưởng của @ETHproductions.

R, 127 112 byte

function(M){a=nrow(M);for(i in seq(M))if(M[i]!="*")M[i]=sum(M[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)]=="*",na.rm=T);M}

cảm ơn @gtwebb và @ sebastian-c vì những cải tiến.

Điểm đáng chú ý:

Ma trận là các vectơ trong R. Bạn không cần lập chỉ mục 2 chiều để lấy các phần tử ra.

seq(M)sẽ trả về một chuỗi có cùng "chiều dài" (hàng x cột) như M.

Bạn không thể trộn lẫn các chỉ số trích xuất dương và âm trong R. M[-3]là mã R hợp pháp, nhưng không phải là những gì mong muốn.

Đầu vào ở dạng ma trận R. Vài ví dụ:

> M <- matrix("",5,5)
> M[3,3] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "0"  "0"  "0"  "0"  "0" 
[2,] "0"  "1"  "1"  "1"  "0" 
[3,] "0"  "1"  "*"  "1"  "0" 
[4,] "0"  "1"  "1"  "1"  "0" 
[5,] "0"  "0"  "0"  "0"  "0" 
> M[2,2] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "1"  "1"  "1"  "0"  "0" 
[2,] "1"  "*"  "2"  "1"  "0" 
[3,] "1"  "2"  "*"  "1"  "0" 
[4,] "0"  "1"  "1"  "1"  "0" 
[5,] "0"  "0"  "0"  "0"  "0" 
> M[3,2] <- "*"
> f(M)
     [,1] [,2] [,3] [,4] [,5]
[1,] "1"  "1"  "1"  "0"  "0" 
[2,] "2"  "*"  "3"  "1"  "0" 
[3,] "2"  "*"  "*"  "1"  "0" 
[4,] "1"  "2"  "2"  "1"  "0" 
[5,] "0"  "0"  "0"  "0"  "0" 
> 

Java, 190 byte

Biên tập:

• -6 byte tắt. Cảm ơn @Frozn
• -1 byte tắt. Cảm ơn bản thân :)
• -1 byte tắt. Cũng phát hiện ra một số sai lầm. Cảm ơn @Kevin Cruijssen

Bắn tỉa

c->{for(int x,y,j,i=-1;++i<c.length;)for(j=-1;++j<c[0].length;){if(c[i][j]<33){c[i][j]=48;for(x=i-2;++x<i+2;)for(y=j-2;++y<j+2;)try{if(c[x][y]==43)c[i][j]++;}catch(Exception e){}}}return c;}

Ung dung:

public class Main{
  public static char[][] minesweeper(char[][] woclues){
    for(int i = 0; i < woclues.length ; i++){
      for(int j = 0; j < woclues[0].length ; j++){
        if( woclues[i][j] == ' '){
          woclues[i][j] = '0';
          for(int x = i - 1; x < i + 2 ; x++){
            for(int y = j - 1; y < j + 2 ; y++){
              try{
                if(woclues[x][y] == '*'){
                  woclues[i][j]++;
                }
              }catch( ArrayIndexOutOfBoundsException e){}
            }
          }
        }
      }
    }
    return woclues;
  }
  public static void main(String[]args){
    char[][] in = new char[args.length][args[0].length()];
    for(int i = 0; i < args.length;i++){
      in[i]=args[i].toCharArray();
    }
    for(char[] c:minesweeper(in)){
      System.out.println(new String(c));
    }
  }
}

Có nghĩa là nó.

JavaScript (ES6), 107

Nhập / xuất dưới dạng một chuỗi các chuỗi

f=l=>l.map((r,i)=>r.replace(/ /g,(c,j)=>(s=r=>(c+r).substr(j,3).split`*`.length,s(l[i-1])+s(l[i+1])+s(r)-3)))

lưu ý khi hàm s được gọi với một phần tử của danh sách nằm ngoài giới hạn, tham số anày sẽ undefinedvà c+asẽ dẫn đến " undefined"nhờ các quy tắc chuyển đổi kỳ quặc của javascript

Dễ đọc hơn

l=>
  l.map(
    (r,i) =>
      r.replace(/ /g, (c,j) =>
        (
          s = a => (c+a).substr(j,3).split`*`.length,
          s(l[i-1])+s(l[i+1])+s(r)-3
        )
      )
  )

Python 2, 138 byte

def f(s):w=s.find('\n')+1;print''.join([c,`(s[i-(i>0):i+2]+(w*' '+s)[i-1:i+2]+s[i-1+w:i+2+w]).count('*')`][c==' ']for i,c in enumerate(s))

Xác định hàm fchấp nhận chuỗi đầu vào như

"  *\n** \n*  \n"

và in một chuỗi thành STDOUT:

23*
**2
*31

JavaScript (ES6) 186 182 177 161 152 byte

f=a=>{for(s='',y=a[0].length;y--;)for(s=`
`+s,x=a.length;x--;)(k=>{for(t=0,i=9;i--;)t+=(a[x+i%3-1]||[])[y+i/3-1|0]==k;s=(a[x][y]<k?t:k)+s})`*`;return s}

Cập nhật

Các mã trên cho " *"lợi nhuận "2*". Điều này được cố định trong kịch bản sau đây.

168 167 byte

f=a=>{for(s='',y=a[0].length;y--;)for(s=`
`+s,x=a.length;x--;)a[x][y]=='*'?s='*'+s:(k=>{for(t=0,j=3;j--;)for(i=3;i--;)t+=(a[x+i-1]||1)[y+j-1]=='*';s=t+s})`*`;return s}

Hãy thử nó ở đây.

Haskell, 115 byte

z=zip[1..]
x%i=[a|(j,a)<-z x,abs(i-j)<2]
f x=[[head$[c|c>' ']++show(sum[1|'*'<-(%j)=<<x%i])|(j,c)<-z r]|(i,r)<-z x]

Xác định hàm ftrên danh sách các chuỗi

Python 2, 192 byte

-3 byte nhờ Đồng, -10 byte nếu sửa đổi lưới đầu vào được cho phép, -11 byte khác bằng cách loại bỏ continuevà -12 byte khác để loại bỏ biến đếm

def f(L):
 n,S,s=len(L[0]),[0,1,2],[' '];P=[s*(n+2)];K=P+[s+x+s for x in L]+P
 for y in range(len(L)):
    for x in range(n):
     if'*'!=L[y][x]:L[y][x]=`sum(K[y+d][x+e]=='*'for d in S for e in S)`

Sử dụng danh sách các danh sách các ký tự Lvà tạo một phiên bản đệm K, do đó không có vấn đề gì ở ranh giới. Lõm là

1. Không gian
2. Chuyển hướng
3. Tab + Không gian
4. Tab + Tab

Sử dụng:

s=""" *   
*  * 
  *  
    *"""
print s
s=[[c for c in x] for x in s.split('\n')]
f(s)
s='\n'.join([ ''.join(x) for x in s])
print s

Ruby, 112

Đưa và trả về một chuỗi. Chuỗi phải được phân tách dòng mới và dòng mới kết thúc.

->s{w=1+s=~/\n/
s.size.times{|i|s[i]==' '&&(n=0;9.times{|j|(s+$/*w)[i+j%3-1+j/3*w-w]==?*&&n+=1};s[i])=n.to_s}
s}

trong chương trình thử nghiệm

f=->s{
  w=(s=~/\n/)+1                              #Calculate width.
  s.size.times{|i|                           #For each char in s
    s[i]==' '&&(                             #If it is a space
      n=0                                    #set counter n to 0 and visit
      9.times{|j|                            #a 3x3 square of chars.
        (s+$/*w)[i+j%3-1+j/3*w-w]==?*&&n+=1  #If *, increment n.
      }                                      #(Pad s with w newlines to avoid *'s detected by wraparound.)
      s[i]=n.to_s                            #Write n back to s in string format
    )
  }
s}                                           #Return s.

puts f[
" *   
*  * 
  *  
    *
"]

TSQL 292 291 byte

Chơi gôn

DECLARE @ varchar(max)=
' *   
*  * 
  *  
    *';
WITH C as(SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c FROM master..spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z WHERE type='P'and x<len(@))SELECT @=stuff(@,i,1,z)FROM(SELECT i,(SELECT count(*)FROM C WHERE abs(D.c-c)<2and abs(D.r-r)<2and'*'=v)z FROM C D WHERE''=v)h PRINT @

Ung dung:

DECLARE @ varchar(max)=
' *   
*  * 
  *  
    *';
WITH C as
(
  SELECT x+1i,substring(@,x+1,1)v,x/z r,x%z c
  FROM master..spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE type='P'and x<len(@)
)
SELECT @=stuff(@,i,1,z)
FROM
(
  SELECT
    i,
    (
      SELECT count(*)
      FROM C
      WHERE 
       abs(D.c-c)<2and abs(D.r-r)<2and'*'=v
    )z
  FROM C D
  WHERE''=v
)h
PRINT @

Vĩ cầm

Vợt 415 byte

(let*((l(string->list s))(g (λ(r c)(if(or(>= r n)(>= c n)(< r 0)(< c 0))#f(list-ref l(+ c(* n r))))))(ng (λ(r c)(let*((h'(-1 0 1))(k(filter(λ(x)x)
(for*/list((i h)(j h)#:unless(= 0 i j))(g(+ r i)(+ c j))))))(count(λ(x)(equal? x #\*))k))))(k(for*/list((i n)(j n))(ng i j)))
(ol(map(λ(x y)(if(equal? x #\*)"*"(number->string y)))l k)))(for((i(* n n))(j ol))(display j)(when(= 0(modulo(add1 i)n))(displayln ""))))

Ung dung:

(define (f s n)
  (let* ((l (string->list s))
         (get                            ; fn to get value at a (row, col)
          (lambda(r c)                   ; #f if invalid row or col
            (if (or (>= r n)
                    (>= c n)
                    (< r 0)
                    (< c 0))
                #f (list-ref l (+ c (* n r))))))

         (neighbors                      ; fn to count neighboring "*"
          (lambda(r c)
            (let* ((h '(-1 0 1))
                   (u (filter
                       (lambda(x) x)
                       (for*/list ((i h)(j h)
                                   #:unless (= 0 i j))
                         (get (+ r i) (+ c j))))))
              (count (lambda(x)(equal? x #\*)) u))))

         (k (for*/list ((i n) (j n))    ; for each row,col count neighboring "*"
              (neighbors i j)))
         (ol(map (lambda(x y)           ; get outlist- replace blanks with neighboring star count
                   (if(equal? x #\*) 
                      "*"
                      (number->string y)))
                 l k)))

    (for ((i (* n n))(j ol))            ; display outlist
      (display j)
      (when (= 0 (modulo (add1 i) n))
        (displayln "")))))

Kiểm tra (liệt kê dưới dạng một chuỗi với số cột được chỉ định; cũng sẽ hoạt động với khoảng trắng):

(f "----*-*-------------------**---*--*-" 6) 

Đầu ra:

1101*1
*10111
110000
012210
12**21
1*33*1

PHP, 145 133 132 127 byte

for($s=$argv[1];$s[$p];print$c)if(" "==$c=$s[$p++])for($y=-2;$y++<1;)for($x=$p-3;$x++<$p;)$c+="!"<$s[$x+$y*strpos($s,"\n")+$y];

lấy đầu vào dưới dạng chuỗi đơn, dòng mới tách ra. Chạy với -r.

phá vỡ

for($s=$argv[1];$s[$p]; // loop through all characters (including newlines)
    print$c                     // 3. print result
)
    if(" "==$c=$s[$p++])        // 1. if character is space
        for($y=-2;$y++<1;)      // 2. count surrounding asterisk characters
            for($x=$p-3;$x++<$p;)
                $c+="!"<$s[$x+$y*strpos($s,"\n")+$y];

Turtlèd , 99 byte

(Rất tiếc tôi tiếp tục quên liên kết: |)

Đưa đầu vào với dấu ngoặc quanh mỗi dòng

Turtlèd không thể nhận đầu vào nhiều dòng, vì vậy sau dòng cuối cùng, ghi |vào tín hiệu kết thúc đầu vào

Lưu ý dấu ngoặc không khớp là vì dấu ngoặc mở phân tích char tiếp theo như một phần của lệnh ngoặc

[|!.([[]r+.][[l]d)][ u]d[|[]r( #012345678#l(*+)u(*+)r(*+)r(*+)d(*+)d(*+)l(*+)l(*+)ur.)]' [[l]' d]' 

Hãy thử trực tuyến!

Cách thức hoạt động (mô tả chung):

Cho đến khi |được nhập, nó ghi ra đầu vào trên mỗi dòng, với dấu ngoặc để giúp nó nhận ra phần cuối của mỗi dòng. Sau khi điều đó đã xảy ra, nó sẽ quay trở lại đầu vào. Nó đi qua từng ký tự trong đầu vào. Nếu đó là một không gian, nó nhìn xung quanh không gian, thêm một cái vào quầy cho mỗi quả bom mà nó tìm thấy. sau mỗi dòng, nó xóa dấu ngoặc. Khi nó đến dòng cuối cùng, với | trong đó, nó dừng lại và xóa |. lưới được in ngầm.

C, 152 150 147 145 byte

i,j,r,c;f(B,R,C)char**B;{for(i=R*C;i--;)for(j=9;j--;){char*b=B[i/C]+i%C;r=i/C+j/3-1;c=i%C+j%3-1;r<0|c<0|r/R|c/C|*b&8||(*b=16|*b+(B[r][c]==42));}}

Đầu vào ở dạng một mảng các ký tự hai chiều, theo sau là số lượng hàng và cột. Kết quả sẽ được trả lại tại chỗ.

(Hầu hết) Ungolfed:

i, j, r, c;
f(B, R, C) char **B; {
    for (i = R*C; i--;)
        for (j = 9; j--;) {
            char *b = B[i/C] + i%C;
            r = i/C + j/3 - 1;
            c = i%C + j%3 - 1;
            r < 0 | c < 0 | r / R | c / C | *b & 8 ||
                (*b = 16 | *b + (B[r][c] == 42));
        }
}

Cách tiếp cận rất đơn giản - lặp qua từng vị trí, lặp qua các hàng xóm của nó và cộng tất cả các dấu sao. Có hai thủ thuật cấp bit:

• Khi chúng tôi quyết định xem một ô có phải là dấu hoa thị hay không, chúng tôi chỉ có thể kiểm tra xem bit vị trí cao có được đặt hay không, bởi vì số trong ô phải nhỏ hơn 8 (giá trị ô tối đa).

• Chúng ta có thể biến một ký tự khoảng trắng thành ký tự 0 bằng cách OR-ing 16.

Chỉnh sửa: Đánh bại hai byte bằng cách sử dụng /thay thế >=.

Chỉnh sửa: Năm byte khác bằng cách đảo ngược hướng của các vòng.

C #, 341 byte

Một thực hiện ngây thơ mà chắc chắn có thể được rút ngắn.

s=>s=="*"?1:0;s=>{for(int i=0,j,n,l=s.Length,c=s[i].Length;i<l;++i)for(j=0;j<c;++j)if(s[i][j]!="*"){n=0;if(i>0){n+=a(s[i-1][j]);n+=j>0?a(s[i-1][j-1]):0;n+=j+1<c?a(s[i-1][j+1]):0;}n+=a(s[i][j]);n+=j>0?a(s[i][j-1]):0;n+=j+1<c?a(s[i][j+1]):0;if(i+1<l){n+=a(s[i+1][j]);n+=j>0?a(s[i+1][j-1]):0;n+=j+1<c?a(s[i+1][j+1]):0;}s[i][j]=n+"";}return s;};

Python 2, 183 byte

def s(m):
 j=m.find('\n')+1;q='q'*j*2;m=list(q+m+q)
 for i in range(len(m)):
  if m[i]==' ':m[i]=`sum([m[k+i]=='*'for k in [-j-1,-j,-j+1,-1,1,j-1,j,j+1]])`
 return''.join(m)[j*2:-j*2]