Mayın Tarlası , hangi karolara tıklayıp hangi karoların "mayın" olduğunu keşfetmeniz gereken popüler bir bulmaca oyunudur. Her karo bir mayın (temsil edilen *) veya bir ipucudur, yani 8 komşu karodan kaçının mayın olduğunu gösteren 0 ila 8 arasında bir sayıdır. Bugün sizin göreviniz madenleri içeren bir tahta almak ve tüm ipuçlarını doldurmak. Örneğin, 5 adet mayınlı 5x4'lük tahtaya bakınız:

 *  
*  * 
  *  
    *

İpuçlarını doldurduktan sonra tahta şöyle görünecektir:

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

ayrıntılar

Yalnızca bir boşluk ve yıldız işaretleri içeren bir karakter ızgarasına giren ve her boşluğun bitişik mayınların (yıldız işaretlerinin) sayısıyla değiştirildiği başka bir ızgara çıkaran bir tam program veya bir işlev yazmalısınız. Bunlardan herhangi biri ızgaralarınız için kabul edilebilir biçimlerdir:

• İçinde newlines olan bir dize

• 2B karakter / tek karakter dizgisi listesi

• Dizelerin listesi

Izgaraların en az 1x1 olacağını varsayalım , bununla birlikte tüm mayınlar veya tüm alanlar olması mümkündür.

Giriş ızgarası her zaman uygun sayıda boşlukla doldurulur. Her zaman olduğu gibi, bu kod golf , bu yüzden standart boşluklar uygulanır ve bayt cinsinden en kısa cevap kazanır!

Örnek io

Beyaz alanı görebilmeniz için, tüm örnek IO'yu etrafına parantez ile göstereceğim.

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 bayt

Test senaryosu 6 girişindeki bir düzeltme için @ mbomb007 sayesinde

32>t3Y6Z+-6b(48+c

Giriş, biçiminde 2B karakter dizisidir.

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

Çevrimiçi deneyin!

Test durumları: 1 , 2 , 3 , 4 , 5 , 6 .

açıklama

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 bayt

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

Düzenleme: @ETHproductions'un bir fikri sayesinde 18 bayt kaydedildi.

R, 127 112 bayt

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}

iyileştirmeler için @gtwebb ve @ sebastian-c sayesinde.

Önemli noktalar:

Matrisler R'deki vektörlerdir. Öğeleri çıkarmak için 2 boyutlu indekslemeye ihtiyacınız yoktur.

seq(M)aynı "uzunluk" (sıra x sütunlar) dizisini döndürür M.

R'deki pozitif ve negatif çıkarma endekslerini karıştıramazsınız M[-3], meşru R kodudur, ancak istenen şey değildir.

Girdi bir R matrisi şeklindedir. Bazı örnekler:

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

Düzenle:

• -6 bayt kapalı. @Frozn'a teşekkürler
• -1 bayt kapalı. Kendime teşekkürler :)
• -1 bayt kapalı. Ayrıca bazı hatalar tespit edildi. @Kevin Cruijssen 'e teşekkürler

Snippet

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

Ungolfed:

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

Onu deone.

JavaScript (ES6), 107

Dizelerin bir dizisi olarak giriş / çıkış

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

dikkat işlev s sınırların dışında listesi l'lik bir elemanı ile çağrıldığında, parametre aolduğu undefinedve c+aneden olur " undefined"JavaScript ilginç dönüşüm kuralları sayesinde

Daha okunabilir

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 bayt

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

fGibi bir giriş dizesini kabul eden bir işlev tanımlar.

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

ve bir dize STDOUT için yazdırır:

23*
**2
*31

JavaScript (ES6) 186 182 177 161 152 bayt

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}

Güncelleme

Yukarıda kod " *"getiri "2*". Bu, aşağıdaki komut dosyasında sabittir.

168 167 bayt

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}

Burada dene.

Haskell, 115 bayt

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]

fDizelerin listelerinde bir işlev tanımlar .

Python 2, 192 bayt

Bakır sayesinde -3 bayt, giriş ızgarasının değiştirilmesine izin verilirse -10 bayt continue, sayaç değişkenini ortadan kaldırmak için bir diğer -11 bayt ve bir diğer -12 bayt

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

Bir karakter listesi kullanır Lve dolgulu bir sürüm oluşturur K, yani sınırlarda sorun olmaz. Girinti

1. Alan, boş yer, mekan
2. çıkıntı
3. Sekme + Boşluk
4. Sekme + Sekme

Kullanımı:

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

Bir dize alır ve döndürür. Dize newline ayrılmış ve newline sonlandırılmalıdır.

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

test programında

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 bayt

golfed:

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 @

Ungolfed:

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 @

Keman

Raket 415 bayt

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

Ungolfed:

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

Test (belirtilen sütun numarasına sahip tek bir dize olarak listeler; boşluklarla da çalışacaktır):

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

Çıktı:

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

PHP, 145 133 132 127 bayt

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

girişi tek satır olarak alır, yeni satır ayrılmış. İle koş -r.

Yıkmak

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 bayt

(bağlantıyı unutmaya devam ediyorum. |)

Her satırın çevresinde parantez bulunan girişleri alır

Turtlèd çok hatlı giriş yapamıyor, bu nedenle son satırdan sonra |girişin sinyalini yazmak

Eşleşmeyen parantezlerin açık parantezlerin parantez komutunun bir parçası olarak sonraki karakteri ayrıştırmasından kaynaklandığını unutmayın.

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

Çevrimiçi deneyin!

Nasıl çalışır (genel açıklama):

Girilene kadar |her satırın girişini, her satırın sonunu tanımasına yardımcı olacak parantezler ile yazar. Bu olduktan sonra, girişin tepesine geri döner. Girişteki her karakterden geçer. Bir boşluk ise, boşluğa bakar ve bulduğu her bomba için tezgaha bir tane ekler. Her satırdan sonra, parantezleri siler. Son satıra geldiğinde, | içinde durur ve siler. ızgara örtük olarak yazdırılır.

C, 152 150 147 145 bayt

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

Giriş, iki boyutlu bir karakter dizisi, ardından satır ve sütun sayıları şeklindedir. Sonuç yerinde iade edilir.

(Çoğunlukla) 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));
        }
}

Yaklaşım açıktır - her pozisyonda döngü, komşuları üzerinden döngü ve yıldız işaretlerini ekleme. İki bit seviyesi hile vardır:

• Bir hücrenin yıldız olup olmadığına karar verirken, sadece sekizinci bitin ayarlanıp ayarlanmadığını kontrol edebiliriz, çünkü hücredeki sayının 8'den az olması gerekir (maksimum hücre değeri).

• 16 boşluk bırakarak boşluk karakterini sıfır karakterine dönüştürebiliriz.

Düzenleme: /yerine kullanarak iki bayt kapalı Golf >=.

Düzenleme: Döngülerin yönünü tersine çevirerek başka bir beş bayt.

C #, 341 Bayt

Kesinlikle kısaltılabilen saf bir uygulama.

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 bayt

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]