Saper to popularna gra logiczna, w której musisz odkryć, które kafelki są „kopalniami”, bez klikania na te kafelki. Każdy kafelek jest kopalnią (reprezentowaną przez *) lub wskazówką, tj. Liczbą od 0 do 8, która reprezentuje liczbę 8 sąsiadujących kafelków to miny. Twoim zadaniem dzisiaj jest zabranie planszy zawierającej miny i wypełnienie wszystkich wskazówek. Na przykład spójrz na następującą planszę 5x4 z 5 minami:

 *  
*  * 
  *  
    *

Po wypełnieniu wskazówek tablica będzie wyglądać następująco:

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

Detale

Musisz napisać pełny program lub funkcję, która przyjmuje siatkę znaków zawierającą tylko spacje i gwiazdki i wypisuje inną siatkę, w której każda spacja jest zastępowana liczbą sąsiednich min (gwiazdkami). Każdy z tych formatów jest akceptowalny dla twoich siatek:

• Ciąg z znakami nowej linii

• 2D lista znaków / ciągi pojedynczych znaków

• Lista ciągów

Możesz założyć, że siatka będzie wynosić co najmniej 1x1, chociaż możliwe jest, że będą to wszystkie miny lub wszystkie pola.

Siatka wejściowa zawsze będzie wypełniona odpowiednią liczbą spacji. Jak zwykle jest to gra w golfa , więc obowiązują standardowe luki i wygrywa najkrótsza odpowiedź w bajtach!

Próbka IO

Aby zobaczyć białą przestrzeń, pokażę wszystkie próbki IO z nawiasami wokół tego.

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 bajtów

Dzięki @ mbomb007 za poprawkę na wejściu przypadku testowego 6

32>t3Y6Z+-6b(48+c

Dane wejściowe to tablica znaków 2D w formacie

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

Wypróbuj online!

Przypadki testowe: 1 , 2 , 3 , 4 , 5 , 6 .

Wyjaśnienie

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 bajtów

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

Edycja: Zapisano 18 bajtów dzięki pomysłowi @ETHproductions.

R, 127 112 bajtów

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}

dzięki @gtwebb i @ sebastian-c za ulepszenia.

Ważne punkty:

Macierze są wektorami w R. Nie potrzebujesz indeksowania 2-D, aby wydobyć elementy.

seq(M)zwróci ciąg o tej samej „długości” (wiersze x kolumny) co M.

Nie można mieszać dodatnich i ujemnych wskaźników ekstrakcji w R. M[-3]jest to prawidłowy kod R, ale nie to, co jest pożądane.

Dane wejściowe mają postać macierzy R. Kilka przykładów:

> 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 bajtów

Edytować:

• -6 bajtów wyłączone. Dzięki @Frozn
• -1 bajt off. Dzięki sobie :)
• -1 bajt off. Zauważyłem też kilka błędów. Dzięki @Kevin Cruijssen

Snipet

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

Nie golfowany:

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

Ideone to.

JavaScript (ES6), 107

Wejścia / wyjścia jako tablica ciągów

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

Uwaga: gdy funkcja s zostanie wywołana z elementem listy l poza granicami, parametr ajest undefinedi c+aspowoduje " undefined"dzięki dziwacznym regułom konwersji javascript

Bardziej czytelny

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 bajtów

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

Definiuje funkcję, fktóra akceptuje ciąg wejściowy, taki jak

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

i wypisuje ciąg do STDOUT:

23*
**2
*31

JavaScript (ES6) 186 182 177 161 152 bajtów

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}

Aktualizacja

Powyższy kod " *"zwrotów "2*". Zostało to naprawione w następującym skrypcie.

168 167 bajtów

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}

Wypróbuj tutaj.

Haskell, 115 bajtów

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]

Definiuje funkcję fna listach ciągów

Python 2, 192 bajty

-3 bajty dzięki Copper, -10 bajtów, jeśli dozwolona jest modyfikacja siatki wejściowej, kolejne -11 bajtów poprzez pozbycie się continuei kolejne -12 bajtów w celu wyeliminowania zmiennej licznika

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)`

Wykorzystuje listę znaków Li tworzy wyściełaną wersję K, więc nie ma problemu na granicach. Wcięcie jest

1. Przestrzeń
2. Patka
3. Tab + spacja
4. Tab + Tab

Stosowanie:

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

Bierze i zwraca ciąg znaków. Ciąg musi być oddzielony znakiem nowej linii i zakończony znakiem nowej linii.

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

w programie testowym

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 bajtów

Gra w golfa:

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 @

Nie golfowany:

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 @

Skrzypce

Rakieta 415 bajtów

(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 ""))))

Nie golfowany:

(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 "")))))

Testowanie (wyszczególnia jako pojedynczy ciąg znaków z określonym numerem kolumny; działa również ze spacjami):

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

Wynik:

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

PHP, 145 133 132 127 bajtów

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];

pobiera dane wejściowe jako pojedynczy ciąg rozdzielony znakiem nowej linii. Uruchom z -r.

awaria

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 bajtów

(ups, ciągle zapominam o linku: |)

Pobiera dane w nawiasach wokół każdej linii

Turtlèd nie może przyjmować wejścia wieloliniowego, więc po ostatnim wierszu napisz |na koniec sygnału wejścia

Zwróć uwagę, że niedopasowane nawiasy są, ponieważ otwarte nawiasy parsują następny znak jako część polecenia nawiasu

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

Wypróbuj online!

Jak to działa (opis ogólny):

Dopóki nie |zostanie wprowadzony, zapisuje dane wejściowe w każdym wierszu, w nawiasach, aby pomóc mu rozpoznać koniec każdego wiersza. Kiedy to się stanie, nastąpi powrót na szczyt danych wejściowych. Przechodzi przez każdy wprowadzany znak. Jeśli jest to spacja, rozgląda się po niej, dodając jeden do licznika za każdą znalezioną bombę. po każdej linii usuwa nawiasy. Kiedy dojdzie do ostatniej linii, za pomocą | w nim zatrzymuje się i usuwa |. siatka jest domyślnie drukowana.

C, 152 150 147 145 bajtów

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

Dane wejściowe mają postać dwuwymiarowej tablicy znaków, po której następują liczby wierszy i kolumn. Wynik zostanie zwrócony na miejscu.

(Przeważnie) Nie golfowany:

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

Podejście jest proste - pętla nad każdą pozycją, pętla nad sąsiadami i sumowanie wszystkich gwiazdek. Istnieją dwa triki na poziomie bitowym:

• Kiedy decydujemy, czy komórka jest gwiazdką, czy nie, możemy po prostu sprawdzić, czy ustawiony jest bit ósemki, ponieważ liczba w komórce musi być mniejsza niż 8 (maksymalna wartość komórki).

• Możemy zamienić znak spacji na znak zerowy przez OR-16.

Edycja: Oderwano dwa bajty, używając /zamiast >=.

Edycja: Kolejne pięć bajtów poprzez odwrócenie kierunku pętli.

C #, 341 bajtów

Naiwne wdrożenie, które można zdecydowanie skrócić.

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 bajtów

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]