Remplissez les indices du démineur


54

Minesweeper est un jeu de puzzle populaire dans lequel vous devez découvrir quelles tuiles sont des "mines" sans cliquer dessus. Chaque tuile est soit une mine (représentée par *), soit un indice, c'est-à-dire un nombre compris entre 0 et 8 représentant le nombre de tuiles voisines qui sont des mines. Votre tâche aujourd'hui est de prendre un tableau contenant les mines et de renseigner tous les indices. Par exemple, regardez le tableau 5x4 suivant, avec 5 mines:

 *  
*  * 
  *  
    *

Une fois les indices renseignés, le tableau ressemblera à ceci:

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

Détails

Vous devez écrire un programme complet ou une fonction qui prend une grille de caractères ne contenant que des espaces et des astérisques et génère une autre grille dans laquelle chaque espace est remplacé par le nombre de mines adjacentes (astérisques). Tous ces formats sont acceptables pour vos grilles:

  • Une chaîne avec des nouvelles lignes dedans

  • Une liste 2D de caractères / chaînes de caractères uniques

  • Une liste de chaînes

Vous pouvez supposer que la grille sera au moins 1x1, bien qu'il soit possible que ce soit toutes les mines ou tous les espaces.

La grille d’entrée sera toujours complétée avec le nombre approprié d’espaces. Comme d'habitude, c'est du , donc des échappatoires standard s'appliquent et la réponse la plus courte en octets l'emporte!

Échantillon IO

Pour que vous puissiez voir les espaces, je vais montrer tous les exemples d'E / S entre parenthèses.

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]

2
Pour votre information, j'ai fait tous les échantillons IO à la main, il est donc possible qu'il y ait des erreurs mineures. Faites-moi savoir si quelque chose ne va pas et je vais essayer de le réparer dès que possible.
DJMcMayhem


1
La grille peut-elle être non-carrée?
Ton Hospel

Les mines peuvent-elles être représentées par un autre personnage?
Akangka

@ChristianIrwan Non, les mines seront toujours un astérisque.
DJMcMayhem

Réponses:


21

MATL , 18 17 octets

Merci à @ mbomb007 pour une correction dans l'entrée du scénario de test 6

32>t3Y6Z+-6b(48+c

L'entrée est un tableau de caractères 2D, au format

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

Essayez-le en ligne!

Cas de test: 1 , 2 , 3 , 4 , 5 , 6 .

Explication

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

1
Sensationnel. C'est impressionnant.
a25bedc5-3d09-41b8-82fb-ea6c353d75ae

2
Obtenir le cas de test 6 me ferait chier de jouer au jeu réel.
Urne magique Octopus

Pourquoi? Le cas de test 6 semble le plus réaliste.
WBT

@carusocomputing Obtenir le cas de test 2 me ferait chier beaucoup plus. : P
DJMcMayhem

10

JavaScript (ES6), 114 à 96 octets

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

Edit: 18 octets sauvés grâce à une idée de @ETHproductions.


Je pense que vous pouvez économiser beaucoup en définissant une fonction pour vérifier si un index est non-espace:a=>a.map((s,i)=>s.replace(/ /g,(_,j)=>a.slice(i-!!i,i+2).reduce((t,s)=>t+(q=i=>s[i+j]>' ')(-1)+q(0)+q(1),0)))
ETHproductions

@ETHproductions J'ai poussé votre idée à l'extrême ... je n'ai généralement pas la possibilité d'écrire des paramètres de fonction!
Neil

7

R, 127 112 octets

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}

merci à @gtwebb et @ sebastian-c pour les améliorations apportées.

Points notables:

Les matrices sont des vecteurs dans R. Vous n'avez pas besoin d'indexation 2D pour extraire des éléments.

seq(M)retournera une séquence de la même "longueur" (lignes x colonnes) que M.

Vous ne pouvez pas mélanger des indices d'extraction positifs et négatifs dans R. M[-3]C'est un code R légitime, mais pas ce qui est souhaité.

L'entrée se présente sous la forme d'une matrice R. Quelques exemples:

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

1
Vous pouvez couper quelques caractères en utilisant à la Tplace de TRUE. J'ai aussi réussi à faire glisser certaines bretelles de l'une des fonctions if:f=function(M){a=nrow(M);b=ncol(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}
sebastian-c

1
Vous définissez b=ncol(M)et ne l'utilisez pas pour vous en débarrasser.
gtwebb

Je peux raser quatre caractères (et vectoriser): M->{a=nrow(M);p=M=='*';M[]=ifelse(p,'*',sapply(seq(M),i->sum(p[pmax(i+c(-1,1,-a+-1:1,a+-1:1),0)],na.rm=T)))}- Cependant, cela triche légèrement car il nécessite un <-lambda redéfini , voir klmr / functional / lambda
Konrad Rudolph

@ Konrad idée intéressante, mais je vais le garder pour la base R merci!
JDL

6

Java, 190 octets

Modifier:

  • -6 octets désactivés. Merci à @Frozn
  • -1 octet off. Merci à moi :)
  • -1 octet off. A également repéré des erreurs. Merci à 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;}

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

Idéone-le.


Vous pouvez comparer les valeurs de caractères avec les valeurs ASCII, qui devraient être plus courtes dans la plupart des cas. Vous pouvez également combiner les déclarations dex,y,i,j
Frozn

Je l'ai déjà fait c[i][j]==32et ainsi de suite et je les ai simplement modifiés dans la partie Ungolfed
Roman Gräf

Et je suis plus petit que Phyton. Au moins!
Roman Gräf

Etes-vous sûr que votre code non-golfé est correct? Pour le premier cas de test , il émet: 0000*1\n*10011\n110000\n000000\n00**10\n0*22*1. Pourriez-vous peut-être ajouter un lien de test ideone.com? EDIT: De plus, à moins que je ne fasse quelque chose de mal moi-même, votre sortie du code golfé: ssss0s\n0sssss\nssssss\nssssss\nss00ss\ns0ss0spour le premier cas de test (il a tout remplacé *avec des zéros ..): S
Kevin Cruijssen

Édité. J'ajouterai un lien de test dès que mon pior internet me le permettra.
Roman Gräf

5

JavaScript (ES6), 107

Entrée / sortie sous forme de tableau de chaînes

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

remarque lorsque la fonction s est appelée avec un élément de la liste l hors limites, le paramètre aest undefinedet c+arésultera " undefined"grâce aux règles de conversion originales de javascript

Plus lisible

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

5

Python 2, 138 octets

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

Définit une fonction fqui accepte une chaîne d'entrée telle que

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

et imprime une chaîne sur STDOUT:

23*
**2
*31

1
Faites enumerate start from 2 ( enumerate(s,2)), et remplacez toutes les occurrences de i + 2with iet i - 1with i - 3. Cela va nous faire perdre quelques octets.
Roberto Bonvallet

5

JavaScript (ES6) 186 182 177 161 152 octets

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}

Mise à jour

Le code ci-dessus pour les " *"retours "2*". Ceci est corrigé dans le script suivant.

168 167 octets

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}

Essayez ici.


1
Je pense que t+=(a[x+i%3-1]||[])[y+i/3-1|0]==kdevrait fonctionner de manière similaire et vous sauver la try/ catchpartie.
Arnauld

1
@Arnauld. En fait, la lecture d’une propriété de nombre littéral ne génère pas d’erreur, elle peut donc aussi être améliorée en tant que (a[x+i%3-1]||1)[y+i/3-1|0].
samedi

4

Haskell, 115 octets

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]

Définit une fonction fsur les listes de chaînes


3

Python 2, 192 octets

-3 octets grâce au cuivre, -10 octets si la modification de la grille d'entrée est autorisée, un autre -11 octets par continuesuppression et un autre -12 octets pour éliminer la variable de compteur

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

Utilise une liste de caractères Let crée une version rembourrée K, donc pas de problème aux limites. L'indentation est

  1. Espace
  2. Languette
  3. Onglet + Espace
  4. Tab + Tab

Usage:

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

1
Quelques golfs mineurs: vous pouvez placer vos trois premières affectations de variables sur la même ligne, séparées par des points-virgules, et perdre l'indentation. En outre, utilisez if'*'==L[y][x]:pour enregistrer un octet.
Cuivre

Si vous attribuez r=range;sur la même ligne que n,S,s, vous pouvez enregistrer cinq caractères en remplaçant les appels range(...)avec r(...).
alexwlchan

@alexwlchan économise ainsi 2 * angedonc 8 octets, mais je dois aussi ajouter ,ret ,rangece qui correspond également à 8 octets, donc rien n'est gagné.
Karl Napf

@ KarlNapf Gah, vous avez raison - j'avais oublié le range.
alexwlchan

3

Ruby, 112

Prend et retourne une chaîne. La chaîne doit être séparée et reliée par une nouvelle ligne.

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

dans le programme de test

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[
" *   
*  * 
  *  
    *
"]

3

TSQL 292 291 octets

Golfé:

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 @

Violon


Le ;à l'avant de votre code compte-t-il? Il semble que vous l'avez compté.
Erik l'Outgolfer

@EriktheGolfer Oui, où il y a un script avant WITH. Le compilateur donnera une erreur s'il est supprimé. Il est possible de tester des idées au violon
t-clausen.dk

Je veux dire, devrait-il être dans le nombre d'octets de la source générale? Parce qu'il semble que cela devrait plutôt faire partie de l'instruction "Initial STDIN".
Erik l'Outgolfer

@EriktheGolfer Je ne sais pas vraiment, je suppose que cela peut faire partie de la déclaration. Peut également exclure maître .. s'il existe un maître USE au début du script. Mais cela donne un message agaçant dans le violon.
t-clausen.dk

J'ai essayé de mettre le point-virgule sur la ligne précédente, et cela a fonctionné. Je suppose que la dernière ligne est ce qui compte.
Erik l'Outgolfer

2

Raquette 415 octets

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

Testing (liste sous forme de chaîne unique avec le numéro de colonne spécifié; fonctionnera également avec des espaces):

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

Sortie:

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

2

PHP, 145 133 132 127 octets

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

prend les entrées en tant que chaîne simple, séparées par une nouvelle ligne. Courez avec -r.

panne

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

"!">$n=$s[$p]au lieu de " "==$n=$s[$p]sauver un octet
Jörg Hülsermann

@ JörgHülsermann Cela détruirait les sauts de ligne.
Titus

@ JörgHülsermann ... mais l'astuce fonctionne pour la comparaison des astérisques (dans la nouvelle version)
Titus

2

Tortue , 99 octets

(oups je continue à oublier le lien: |)

Prend des entrées avec des crochets autour de chaque ligne

Turtlèd ne peut pas prendre une entrée multiligne, donc après la dernière ligne, écrivez |pour signaler la fin de l’entrée

Notez que les crochets incompatibles sont dus au fait que les crochets ouverts analysent le caractère suivant dans le cadre de la commande crochet

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

Essayez-le en ligne!

Comment ça marche (description générale):

Jusqu'à |est entré, il écrit l'entrée sur chaque ligne, avec des crochets pour l'aider à reconnaître la fin de chaque ligne. Une fois que cela est arrivé, cela remonte au début des entrées. Il passe par chaque caractère en entrée. S'il s'agit d'un espace, il regarde autour de lui, en ajoutant un au compteur pour chaque bombe trouvée. après chaque ligne, il supprime les crochets. Quand il arrive à la dernière ligne, avec le | dans celui-ci, il s'arrête et supprime le |. la grille est implicitement imprimée.


0

C, 152 150 147 145 octets

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

L'entrée se présente sous la forme d'un tableau de caractères à deux dimensions, suivi du nombre de lignes et de colonnes. Le résultat sera retourné sur place.

(La plupart du temps) 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));
        }
}

L’approche est simple: boucle sur chaque position, boucle sur ses voisins et addition de tous les astérisques. Il existe deux astuces au niveau des bits:

  • Lorsque nous décidons si une cellule est un astérisque ou non, nous pouvons simplement vérifier si le bit des huitièmes est défini, car le nombre dans la cellule doit être inférieur à 8 (la valeur maximale de la cellule).

  • Nous pouvons transformer un caractère d'espace en un caractère zéro en effectuant une opération OR-ing 16.

Edit: Golfé deux octets en utilisant /à la place de >=.

Edit: Cinq autres octets en inversant le sens des boucles.


0

C #, 341 octets

Une implémentation naïve qui peut définitivement être raccourcie.

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

0

Python 2, 183 octets

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]
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.