माइनस्वीपर एक लोकप्रिय पहेली खेल है जहाँ आपको पता होना चाहिए कि उन टाइलों पर क्लिक किए बिना कौन सी टाइलें "खदानें" हैं। प्रत्येक टाइल या तो एक खदान है (जिसका प्रतिनिधित्व किया गया है *) या एक सुराग, यानी 0 से 8 तक की संख्या यह दर्शाती है कि 8 पड़ोसी टाइल में से कितनी खदानें हैं। आपका कार्य आज खदानों से युक्त बोर्ड लेना और सभी सुरागों को भरना है। उदाहरण के लिए, 5 खानों के साथ निम्नलिखित 5x4 बोर्ड को देखें:

 *  
*  * 
  *  
    *

सुराग भरने के बाद, बोर्ड इस तरह दिखेगा:

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

विवरण

आपको या तो एक पूर्ण-कार्यक्रम या एक फ़ंक्शन लिखना होगा जो केवल रिक्त स्थान और तारांकन वाले वर्णों की एक ग्रिड में लेता है और एक और ग्रिड को आउटपुट करता है जहां प्रत्येक स्थान को आसन्न खानों (तारांकन) की संख्या से बदल दिया जाता है। इनमें से कोई भी आपके ग्रिड के लिए स्वीकार्य प्रारूप हैं:

इसमें नए सिरे के साथ एक स्ट्रिंग
पात्रों / एकल चरित्र तार की 2 डी सूची
तार की एक सूची

आप मान सकते हैं कि ग्रिड कम से कम 1x1 होगा, हालांकि यह सभी खानों या सभी रिक्त स्थान के लिए संभव है।

इनपुट ग्रिड को हमेशा उपयुक्त स्थान के साथ गद्देदार किया जाएगा। हमेशा की तरह, यह कोड-गोल्फ है , इसलिए मानक कमियां लागू होती हैं और बाइट्स जीत में सबसे छोटा जवाब होता है!

नमूना IO

ताकि आप व्हॉट्सएप देख सकें, मैं इसके चारों ओर ब्रैकेट के साथ सभी नमूना IO दिखाऊंगा।

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]

— DJMcMayhem
स्रोत

2

FYI करें, मैंने सभी नमूना IO को हाथ से बनाया है, इसलिए यह संभव है कि वहां कुछ छोटी त्रुटियां हैं। अगर कुछ बंद दिखता है तो मुझे बताएं और मैं इसे ASAP को ठीक करने की कोशिश करूंगा।

— DJMcMayhem

सम्बंधित।

— xnor

1

क्या ग्रिड गैर-वर्ग हो सकता है?

— टन हास्पेल

क्या खानों को किसी अन्य चरित्र द्वारा दर्शाया जा सकता है?

— आकांक्षा

@ChristianIrwan नहीं, माइन्स हमेशा एक तारांकन चिह्न होगा।

— DJMcMayhem

21

MATL , 18 17 बाइट्स

टेस्ट केस 6 के इनपुट में सुधार के लिए @ mbomb007 को धन्यवाद

32>t3Y6Z+-6b(48+c

इनपुट प्रारूप में एक 2 डी चार सरणी है

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

इसे ऑनलाइन आज़माएं!

परीक्षण के मामले: 1 , 2 , 3 , 4 , 5 , 6 ।

व्याख्या

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

वाह। यह प्रभावशाली है।

— BladorthinTheGrey

2

टेस्ट केस 6 प्राप्त करने से मुझे वास्तविक गेम खेलने में परेशानी होगी।

— मैजिक ऑक्टोपस Urn

क्यों? टेस्ट केस 6 सबसे यथार्थवादी लगता है।

— WBT

@ carusocomputing टेस्ट केस 2 होने से मुझे बहुत अधिक परेशानी होगी। : P

— DJMcMayhem

10

जावास्क्रिप्ट (ईएस 6), 114 96 बाइट्स

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

संपादित करें: @ETHproductions द्वारा एक विचार के लिए 18 बाइट्स सहेजे गए।

— नील
स्रोत

मुझे लगता है कि यदि कोई सूचकांक गैर-स्थान है, तो आप फ़ंक्शन को परिभाषित करके एक गुच्छा को बचा सकते हैं: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 मैं आपके विचार को चरम पर ले गया ... मुझे आमतौर पर फ़ंक्शन पैरामीटर लिखने की ज़रूरत नहीं है!

— नील

7

आर, 127 112 बाइट्स

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}

सुधार के लिए @gtwebb और @ sebastian-c को धन्यवाद।

उल्लेखनीय बिंदु:

मेट्रिस आर में वैक्टर हैं। आपको तत्वों को बाहर निकालने के लिए 2-डी इंडेक्सिंग की आवश्यकता नहीं है।

seq(M)उसी "लंबाई" (पंक्तियों x कॉलम) के अनुक्रम को वापस लौटाएगा M।

आप सकारात्मक और नकारात्मक निष्कर्षण सूचकांकों को आर में नहीं मिला सकते हैं। M[-3]वैध आर कोड है, लेकिन ऐसा नहीं है जो वांछित है।

इनपुट एक आर मैट्रिक्स के रूप में है। कुछ उदाहरण:

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

— JDL
स्रोत

1

आप Tइसके बजाय का उपयोग करके कुछ वर्ण काट सकते हैं TRUE। मैं कुछ कार्यों में से एक से कुछ ब्रेसिज़ को स्लाइड करने में कामयाब रहा:

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}

— सेबस्टियन-सी

1

आप परिभाषित करते हैं b=ncol(M)और फिर इसका उपयोग नहीं करते हैं ताकि आप उससे छुटकारा पा सकें।

— gtwebb

मैं चार वर्णों (और वेक्टर) से दाढ़ी बना सकता हूं: 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)))}- हालांकि, यह थोड़ा धोखा देता है क्योंकि इसके लिए एक पुनर्परिभाषित लैंबडा की आवश्यकता होती है <-, klmr / फंक्शनल / लैम्ब्डा देखें

— कोनराड रूडोल्फ

@Konrad दिलचस्प विचार है, लेकिन मैं इसे आर धन्यवाद रखने के लिए रखूंगा!

— JDL

6

जावा, 190 बाइट्स

संपादित करें:

-6 बाइट्स बंद। @Frozn को धन्यवाद
-1 बाइट बंद। खुद को धन्यवाद :)
-1 बाइट बंद। कुछ गलतियों को भी देखा। @Kevin क्रूज़सेन को धन्यवाद

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 यह।

— रोमन ग्रैफ़
स्रोत

आप ASCII मूल्यों के खिलाफ चार मूल्यों की तुलना कर सकते हैं जो ज्यादातर मामलों में कम होना चाहिए। आप x,y,i,j

— 14

मैंने पहले से ही ऐसा किया c[i][j]==32और बस उन्हें अनगॉल्फड भाग में बदल दिया

— रोमन ग्रैफ़

और मैं फाइटन से छोटा हूं। कम से कम!

— रोमन ग्रफ

क्या आप सुनिश्चित हैं कि आपका अनलॉक्ड कोड सही है? पहले टेस्ट केस के लिए यह आउटपुट 0000*1\n*10011\n110000\n000000\n00**10\n0*22*1:। क्या आप शायद एक ideone.com परीक्षण लिंक जोड़ सकते हैं? संपादित करें: इसके अलावा, जब तक मैं खुद कुछ गलत नहीं कर रहा हूँ, आपका गोल्फ कोड आउटपुट: ssss0s\n0sssss\nssssss\nssssss\nss00ss\ns0ss0sपहले टेस्ट केस के लिए (यह सभी *शून्य के साथ बदल दिया गया है ..): एस

— केविन क्रूज़सेन

संपादित। जैसे ही मेरा pior इंटरनेट मुझे अनुमति देता है, मैं एक परीक्षण लिंक जोड़ दूंगा।

— रोमन ग्रैफ़

5

जावास्क्रिप्ट (ईएस 6), 107

तार की एक सरणी के रूप में इनपुट / आउटपुट

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

ध्यान दें कि फ़ंक्शन s को सीमा से बाहर की सूची के एक तत्व के साथ कहा जाता है, पैरामीटर aहै undefinedऔर c+aइसके परिणामस्वरूप " undefined"जावास्क्रिप्ट के क्वर्की रूपांतरण नियमों के लिए धन्यवाद होगा

अधिक पठनीय

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

— edc65
स्रोत

5

पायथन 2, 138 बाइट्स

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

एक फ़ंक्शन को परिभाषित fकरता है जो इनपुट स्ट्रिंग को स्वीकार करता है

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

और STDOUT को एक स्ट्रिंग प्रिंट करता है:

23*
**2
*31

— लिन
स्रोत

1

2 से शुरू करें ( enumerate(s,2)और) के i + 2साथ iऔर i - 1साथ की सभी घटनाओं को प्रतिस्थापित करें i - 3। कि बाइट्स के एक जोड़े को दाढ़ी होगी।

— रॉबर्टो बोनालेट

5

जावास्क्रिप्ट (ईएस 6) 186 182 177 161 152 बाइट्स

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}

अपडेट करें

" *"रिटर्न के लिए उपरोक्त कोड "2*"। यह निम्नलिखित स्क्रिप्ट में तय किया गया है।

168 167 बाइट्स

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}

इसे यहाँ आज़माएँ।

— sbisit
स्रोत

1

मुझे लगता है कि t+=(a[x+i%3-1]||[])[y+i/3-1|0]==kएक समान तरीके से काम करना चाहिए और आपको try/ catchहिस्सा बचाना चाहिए ।

— Arnauld

1

@Arnauld। दरअसल, शाब्दिक संख्या की संपत्ति को पढ़ने से कोई त्रुटि नहीं होगी, इसलिए इसे भी बेहतर बनाया जा सकता है (a[x+i%3-1]||1)[y+i/3-1|0]।

— sbisit

4

हास्केल, 115 बाइट्स

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]

fतार की सूची पर एक समारोह को परिभाषित करता है

— डायने
स्रोत

3

पायथन 2, 192 बाइट्स

-3 बाइट्स कॉपर के लिए धन्यवाद, -10 बाइट्स यदि इनपुट ग्रिड को संशोधित करने की अनुमति है, तो -11 बाइट्स से छुटकारा पाने के लिए continueऔर दूसरा -12 बाइट्स काउंटर चर को खत्म करने के लिए

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

पात्रों की सूची की सूची का उपयोग करता है Lऔर एक गद्देदार संस्करण बनाता है K, ताकि सीमाओं पर कोई समस्या न हो। इंडेंटेशन है

अंतरिक्ष
टैब
Tab + space
टैब + टैब

उपयोग:

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

कुछ मामूली गोल्फ: आप अपने पहले तीन चर असाइनमेंट्स को सेमीकोलन के साथ अलग की गई एक ही लाइन पर रख सकते हैं और इंडेंटेशन खो सकते हैं। इसके अलावा, if'*'==L[y][x]:एक बाइट को बचाने के लिए उपयोग करें।

— कॉपर

आप असाइन करते हैं r=range;एक ही लाइन पर के रूप में n,S,s, आप के लिए कॉल की जगह पांच अक्षरों को बचा सकता है range(...)के साथ r(...)।

— अलेक्सवचन

@alexwlchan ऐसा करने से 2 * ange8 बाइट्स बचती हैं , लेकिन मुझे जोड़ना होगा ,rऔर ,rangeजो 8 बाइट्स भी हैं, इसलिए कुछ भी अर्जित नहीं किया गया है।

— कार्ल नेप ने

@ कार्ललफ गाह, तुम सही हो - मैं इसके बारे में भूल गया था range।

— एलेक्सवचन

3

रूबी, ११२

लेता है और एक स्ट्रिंग लौटाता है। स्ट्रिंग को न्यूलाइन अलग किया जाना चाहिए और न्यूलाइन को समाप्त किया जाना चाहिए।

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

परीक्षण कार्यक्रम में

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 बाइट्स

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 @

बेला

— t-clausen.dk
स्रोत

क्या ;आपके कोड के सामने की तरफ गिनती है? ऐसा लगता है कि आपने इसे गिना है।

— आउटगॉल्फ

@EriktheGolfer हाँ, जहाँ स्क्रिप्ट से पहले है। यदि इसे हटा दिया जाता है तो कंपाइलर एक त्रुटि देगा।

— फिडेल

मेरा मतलब है, क्या यह सामान्य स्रोत के बाइट काउंट में होना चाहिए? क्योंकि ऐसा लगता है कि इसके बजाय "प्रारंभिक STDIN" कथन का हिस्सा होना चाहिए।

— आउटगॉल्फ

@EriktheGolfer मुझे वास्तव में नहीं पता, मुझे लगता है कि यह घोषणा का हिस्सा हो सकता है। मास्टर को भी बाहर कर सकते हैं .. अगर स्क्रिप्ट की शुरुआत में कोई यूएसई मास्टर है। लेकिन यह फिडल में एक कष्टप्रद संदेश देता है।

— t-clausen.dk 13:24

मैंने पिछली पंक्ति पर अर्धविराम लगाने की कोशिश की, और यह काम किया। मुझे लगता है कि अंतिम पंक्ति क्या मायने रखती है।

— आउटगॉल्फ

2

रैकेट 415 बाइट्स

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

परीक्षण (निर्दिष्ट कॉलम संख्या के साथ एक स्ट्रिंग के रूप में सूचियां; रिक्त स्थान के साथ भी काम करेगी):

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

आउटपुट:

— rnso
स्रोत

2

PHP, 145 133 132 127 बाइट्स

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

सिंगल स्ट्रिंग के रूप में इनपुट लेता है, न्यूलाइन अलग हो जाता है। के साथ भागो -r।

टूट - फूट

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]के बजाय " "==$n=$s[$p]एक बाइट बचाता है

— Jörg Hülsermann

@ JörgHülsermann जो लाइनब्रेक को नष्ट कर देगा।

— टाइटस

@ JörgHülsermann ... लेकिन चाल तारांकन तुलना (नए संस्करण में) के लिए काम करती है

— टाइटस

2

टर्टल , 99 बाइट्स

(जो मैं लिंक को भूलता रहता हूं: |)

प्रत्येक पंक्ति के चारों ओर कोष्ठक के साथ इनपुट लेता है

Turtlèd मल्टी-लाइन इनपुट नहीं ले सकता है, इसलिए अंतिम पंक्ति के बाद, |इनपुट के सिग्नल एंड को लिखें

ध्यान दें बेमेल कोष्ठक हैं क्योंकि खुले ब्रैकेट ब्रैकेट कमांड के हिस्से के रूप में अगले चार्ट को पार्स करते हैं

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

इसे ऑनलाइन आज़माएं!

यह कैसे काम करता है (सामान्य विवरण):

|दर्ज किए जाने तक , यह प्रत्येक पंक्ति पर इनपुट लिखता है, कोष्ठक के साथ प्रत्येक पंक्ति के अंत को पहचानने में मदद करता है। उसके बाद हुआ है, यह इनपुट के शीर्ष पर वापस चला जाता है। यह इनपुट में प्रत्येक वर्ण के माध्यम से जाता है। यदि यह एक स्थान है, तो यह अंतरिक्ष के चारों ओर दिखता है, प्रत्येक बम के लिए एक काउंटर को जोड़ता है। प्रत्येक पंक्ति के बाद, यह कोष्ठक हटाता है। जब यह अंतिम पंक्ति के साथ हो जाता है, | इसमें, यह बंद हो जाता है, और हटाता है | ग्रिड को स्पष्ट रूप से मुद्रित किया जाता है।

— विनाशकारी नींबू
स्रोत

0

सी, 152 150 147 145 बाइट्स

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

इनपुट दो-आयामी वर्णों के रूप में है, इसके बाद पंक्तियों और स्तंभों की संख्या। परिणाम अंदर-ही-अंदर वापस हो जाएगा।

(अधिकतर) अनलॉल्फ़्ड:

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

दृष्टिकोण सीधे-आगे है - प्रत्येक स्थिति पर लूप, अपने पड़ोसियों पर लूप, और सभी तारांकन जोड़ें। दो बिट-स्तरीय ट्रिक्स हैं:

जब हम यह तय कर रहे हैं कि सेल एक तारांकित है या नहीं, तो हम सिर्फ यह देख सकते हैं कि क्या आठ-स्थान बिट सेट है, क्योंकि सेल में संख्या 8 (अधिकतम सेल मान) से कम होनी चाहिए।
हम एक स्पेस कैरेक्टर को OR-ing 16 से शून्य कैरेक्टर में बदल सकते हैं।

संपादित करें: के /स्थान पर उपयोग करके दो बाइट्स को बंद कर दिया >=।

संपादित करें: छोरों की दिशा को उलट कर एक और पांच बाइट्स।

— क्रिस बूचर्ड
स्रोत

0

सी #, 341 बाइट्स

एक भोली कार्यान्वयन जिसे निश्चित रूप से छोटा किया जा सकता है।

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

— TheLethalCoder
स्रोत

0

पायथन 2, 183 बाइट्स

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]

— स्काईलर
स्रोत

माइनस्वीपर सुराग में भरें

विवरण

नमूना IO

MATL , 18 17 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6), 114 96 बाइट्स

आर, 127 112 बाइट्स

जावा, 190 बाइट्स

जावास्क्रिप्ट (ईएस 6), 107

पायथन 2, 138 बाइट्स

जावास्क्रिप्ट (ईएस 6) 186 182 177 161 152 बाइट्स

अपडेट करें

168 167 बाइट्स

इसे यहाँ आज़माएँ।

हास्केल, 115 बाइट्स

पायथन 2, 192 बाइट्स

रूबी, ११२

TSQL 292 291 बाइट्स

रैकेट 415 बाइट्स

PHP, 145 133 132 127 बाइट्स

टर्टल , 99 बाइट्स

इसे ऑनलाइन आज़माएं!

यह कैसे काम करता है (सामान्य विवरण):

सी, 152 150 147 145 बाइट्स

सी #, 341 बाइट्स

पायथन 2, 183 बाइट्स