Compila gli indizi di Minesweeper


54

Minesweeper è un popolare gioco di puzzle in cui devi scoprire quali tessere sono "miniere" senza fare clic su quelle tessere. Ogni tessera è una miniera (rappresentata da *) o un indizio, ovvero un numero compreso tra 0 e 8 che rappresenta quante delle 8 tessere vicine sono miniere. Il tuo compito oggi è quello di prendere una scheda contenente le mine e compilare tutti gli indizi. Ad esempio, guarda la seguente scheda 5x4, con 5 mine:

 *  
*  * 
  *  
    *

Dopo aver compilato gli indizi, la scheda apparirà così:

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

Dettagli

È necessario scrivere un programma completo o una funzione che accetta una griglia di caratteri contenente solo spazi e asterischi e genera un'altra griglia in cui ogni spazio viene sostituito con il numero di mine adiacenti (asterischi). Ognuno di questi sono formati accettabili per le tue griglie:

  • Una stringa con newline al suo interno

  • Un elenco 2D di caratteri / stringhe di caratteri singoli

  • Un elenco di stringhe

Puoi presumere che la griglia sarà almeno 1x1, anche se è possibile che siano tutte le miniere o tutti gli spazi.

La griglia di input verrà sempre riempita con il numero appropriato di spazi. Come al solito, si tratta di , quindi si applicano scappatoie standard e vince la risposta più breve in byte!

IO di esempio

In modo che tu possa vedere gli spazi bianchi, mostrerò tutti i campioni di IO con parentesi attorno ad esso.

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
Cordiali saluti, ho fatto tutto il campione IO manualmente, quindi è possibile che ci siano alcuni piccoli errori. Fammi sapere se qualcosa sembra fuori posto e proverò a risolverlo al più presto.
DJMcMayhem


1
La griglia può essere non quadrata?
Ton Hospel,

Le miniere possono essere rappresentate da un altro personaggio?
Akangka,

@ChristianIrwan No, le miniere saranno sempre un asterisco.
DJMcMayhem

Risposte:


21

MATL , 18 17 byte

Grazie a @ mbomb007 per una correzione nell'input del test case 6

32>t3Y6Z+-6b(48+c

L'input è un array di caratteri 2D, nel formato

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

Provalo online!

Casi di test: 1 , 2 , 3 , 4 , 5 , 6 .

Spiegazione

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
Wow. Questo è impressionante.
BladorthinTheGrey,

2
Ottenere il test case 6 mi farebbe incazzare giocando al gioco vero e proprio.
Magic Octopus Urn,

Perché? Il test case 6 sembra il più realistico.
WBT,

@carusocomputing Ottenere il test case 2 mi farebbe incazzare molto di più. : P
DJMcMayhem

10

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

Modifica: salvato 18 byte grazie a un'idea di @ETHproductions.


Penso che puoi salvare un sacco definendo una funzione per verificare se un indice non è spazio: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 Ho portato la tua idea all'estremo ... Di solito non riesco a scrivere parametri di funzione!
Neil,

7

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}

grazie a @gtwebb e @ sebastian-c per i miglioramenti.

Punti notevoli:

Le matrici sono vettori in R. Non è necessario l'indicizzazione 2D per estrarre gli elementi.

seq(M)restituirà una sequenza della stessa "lunghezza" (righe x colonne) di M.

Non è possibile mescolare indici di estrazione positivi e negativi in ​​R. M[-3]è il codice R legittimo, ma non ciò che si desidera.

L'input ha la forma di una matrice R. Qualche esempio:

> 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
Puoi tagliare alcuni caratteri usando Tinvece di TRUE. Sono riuscito a far scivolare alcune parentesi graffe anche su una delle funzioni 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
Lo definisci b=ncol(M)e quindi non lo usi in modo da poterlo eliminare.
gtwebb,

Posso radere quattro caratteri (e vettorializzare): 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)))}- tuttavia, questo inganna leggermente perché richiede un <-lambda ridefinito , vedi klmr / funzionale / lambda
Konrad Rudolph,

@Konrad idea interessante, ma la terrò alla base R grazie!
JDL,

6

Java, 190 byte

Modificare:

  • -6 byte di sconto. Grazie a @Frozn
  • -1 byte spento. Grazie a me stesso :)
  • -1 byte spento. Ho anche notato alcuni errori. Grazie a @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));
    }
  }
}

Ideone.


È possibile confrontare i valori char con i valori ASCII che dovrebbero essere più brevi nella maggior parte dei casi. Puoi anche combinare le dichiarazioni dix,y,i,j
Frozn,

L'ho già fatto c[i][j]==32e così via e li ho appena cambiati nella parte Ungolfed
Roman Gräf,

E sono più basso di Phyton. Almeno!
Roman Gräf,

Sei sicuro che il tuo codice non salvato sia corretto? Per il primo test emette: 0000*1\n*10011\n110000\n000000\n00**10\n0*22*1. Potresti forse aggiungere un link di prova ideone.com? EDIT: Inoltre, a meno che non stia facendo qualcosa di sbagliato, l'output del tuo codice golf: ssss0s\n0sssss\nssssss\nssssss\nss00ss\ns0ss0sper il primo caso di test (ha sostituito tutto *con zeri ..): S
Kevin Cruijssen,

Modificato. Aggiungerò un link di prova non appena il mio pior internet me lo consente.
Roman Gräf,

5

JavaScript (ES6), 107

Input / output come una matrice di stringhe

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

nota quando la funzione s viene chiamata con un elemento della lista l fuori dai limiti, il parametro aè undefinede c+arisulterà " undefined"grazie alle eccentriche regole di conversione di javascript

Più leggibile

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

Definisce una funzione fche accetta una stringa di input come

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

e stampa una stringa su STDOUT:

23*
**2
*31

1
Fai enumerare inizio da 2 ( enumerate(s,2)) e sostituisci tutte le occorrenze di i + 2con ie i - 1con i - 3. Quello si raderà un paio di byte.
Roberto Bonvallet,

5

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}

Aggiornare

Il codice sopra riportato per i " *"resi "2*". Questo problema è stato risolto nel seguente script.

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}

Provalo qui.


1
Penso che t+=(a[x+i%3-1]||[])[y+i/3-1|0]==kdovrebbe funzionare in modo simile e salvarti la try/ catchparte.
Arnauld,

1
@Arnauld. In realtà, la lettura di una proprietà del numero letterale non genererà un errore, quindi può anche essere migliorata come (a[x+i%3-1]||1)[y+i/3-1|0].
sbisit

4

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]

Definisce una funzione fnegli elenchi di stringhe


3

Python 2, 192 byte

-3 byte grazie a Copper, -10 byte se è consentita la modifica della griglia di input, altri -11 byte eliminando continuee altri -12 byte per eliminare la variabile contatore

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

Utilizza un elenco di elenchi di caratteri Le crea una versione imbottita K, quindi nessun problema ai confini. Il rientro è

  1. Spazio
  2. linguetta
  3. Tab + Spazio
  4. Tab + Tab

Uso:

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
Alcuni campi da golf minori: puoi mettere i tuoi primi tre compiti variabili sulla stessa riga separati da punti e virgola e perdere il rientro. Inoltre, utilizzare if'*'==L[y][x]:per salvare un byte.
Rame

Se si assegna r=range;sulla stessa linea di n,S,s, è possibile salvare cinque caratteri sostituendo le chiamate range(...)con r(...).
alexwlchan,

@alexwlchan facendo questo risparmia 2 * angequindi 8 byte, ma devo aggiungere ,re ,rangeche è anche 8 byte quindi niente guadagnato.
Karl Napf,

@KarlNapf Gah, hai ragione - mi ero dimenticato del range.
alexwlchan,

3

Ruby, 112

Prende e restituisce una stringa. La stringa deve essere separata da newline e terminata newline.

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

nel programma di 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 byte

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 @

Violino


Fa il ;di fronte il valore del tuo codice? Sembra che tu l'abbia contato.
Erik the Outgolfer,

@EriktheGolfer Sì, dove è presente uno script prima di WITH. Il compilatore genererà un errore se viene rimosso. È possibile testare idee nel violino
t-clausen.dk

Voglio dire, dovrebbe essere nel conteggio dei byte della fonte generale? Perché sembra che dovrebbe invece essere parte dell'istruzione "Initial STDIN".
Erik the Outgolfer,

@EriktheGolfer Non lo so davvero, suppongo che possa far parte della dichiarazione. Può anche escludere il master .. se c'è un master USE all'inizio dello script. Ma dà un messaggio fastidioso nel violino.
t-clausen.dk,

Ho provato a mettere il punto e virgola sulla riga precedente e ha funzionato. Presumo che l'ultima riga sia ciò che conta.
Erik the Outgolfer,

2

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

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 (elenca come singola stringa con il numero di colonna specificato; funzionerà anche con spazi):

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

Produzione:

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

2

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

accetta l'input come singola stringa, newline separato. Corri con -r.

abbattersi

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]invece di " "==$n=$s[$p]salvare un byte
Jörg Hülsermann,

@ JörgHülsermann Questo distruggerebbe le interruzioni di linea.
Tito,

@ JörgHülsermann ... ma il trucco funziona per il confronto con l'asterisco (nella nuova versione)
Tito

2

Turtlèd , 99 byte

(whoops continuo a dimenticare il link: |)

Accetta input con parentesi attorno a ciascuna riga

Turtlèd non può accettare input su più righe, quindi dopo l'ultima riga, scrivi |per segnalare la fine dell'ingresso

Notare che le parentesi non corrispondenti sono perché le parentesi aperte analizzano il carattere successivo come parte del comando parentesi

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

Provalo online!

Come funziona (descrizione generale):

Fino a quando non |viene immesso, scrive l'input su ciascuna riga, con parentesi che lo aiutano a riconoscere la fine di ogni riga. Dopo che ciò è accaduto, torna in cima all'input. Attraversa ogni personaggio in input. Se è uno spazio, si guarda intorno, aggiungendo uno al segnalino per ogni bomba che trova. dopo ogni riga, elimina le parentesi. Quando arriva all'ultima riga, con | in esso, si interrompe ed elimina il |. la griglia viene implicitamente stampata.


0

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

L'input ha la forma di un array bidimensionale di caratteri, seguito dal numero di righe e colonne. Il risultato verrà restituito sul posto.

(Principalmente) 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'approccio è diretto: passa su ogni posizione, passa sui suoi vicini e aggiungi tutti gli asterischi. Esistono due trucchi a livello di bit:

  • Quando decidiamo se una cella è un asterisco o meno, possiamo semplicemente verificare se il bit di otto posizioni è impostato, poiché il numero nella cella deve essere inferiore a 8 (il valore massimo della cella).

  • Possiamo trasformare un carattere spazio in un carattere zero OR-ing 16.

Modifica: golfato di due byte usando /al posto di >=.

Modifica: altri cinque byte invertendo la direzione dei loop.


0

C #, 341 byte

Un'implementazione ingenua che può essere sicuramente abbreviata.

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 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]
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.