एक माइनस्वीपर बोर्ड को पलटना

Question

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

एक माइनस्वीपर ग्रिड (उर्फ बोर्ड) के बारे में एक निफ़्टी गणितीय तथ्य यह है कि:

एक बोर्ड और उसके पूरक की कुल संख्या समान है । ( प्रमाण )

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

उदाहरण के लिए, माइनस्वीपर ग्रिड के लिए

**1..
34321
*2**1

मेरा कुल 1 + 3 + 4 + 3 + 2 + 1 + 2 + 1 = 17 है।

ग्रिड का पूरक है

24***
*****
3*44*

जिसमें मेरा कुल 2 + 4 + 3 + 4 + 4 = 17 फिर से है।

एक प्रोग्राम है जो पाठ के रूप में एक मनमाना माइनस्वीपर ग्रिड जहां में लेता लिखें *और एक खदान का प्रतिनिधित्व करता है 1के माध्यम से 8एक गैर-माइन के निकट खानों की संख्या का प्रतिनिधित्व करते हैं। आप उपयोग कर सकते हैं .या 0या (स्थान) कोई मेरा पड़ोसियों, अपनी पसंद के साथ कोशिकाओं प्रतिनिधित्व करते हैं। आप यह मान सकते हैं कि इनपुट ग्रिड को सही तरीके से चिह्नित किया जाएगा, अर्थात प्रत्येक गैर-खान सेल तुरंत खानों की कुल संख्या को सही रूप से निरूपित करेगा, जो इसे orthogonally या तिरछे से सटे हुए हैं।

(समान का उपयोग कर अपने कार्यक्रम उसी स्वरूप में ग्रिड के पूरक मुद्रित करने के लिए की जरूरत है ., 0या के रूप में आप इनपुट में होने की उम्मीद)।

बाइट्स में सबसे छोटा कोड जीतता है।

• एक कार्यक्रम के बजाय आप एक फ़ंक्शन लिख सकते हैं जो इनपुट ग्रिड को स्ट्रिंग और प्रिंट के रूप में लेता है या पूरक ग्रिड को वापस करता है।
• इनपुट या आउटपुट में एक अनुगामी न्यूलाइन ठीक है, लेकिन ग्रिड बनाने वालों के अलावा कोई अन्य वर्ण नहीं होना चाहिए।
• आप मान सकते हैं कि 1 × 1 ग्रिड सबसे छोटा इनपुट होगा।

परीक्षण के मामलों

^{सभी इनपुट और आउटपुट को अदला-बदली किया जा सकता है क्योंकि सप्लीमेंट का मूल ग्रिड है। ग्रिड को आगे के परीक्षण के मामलों के लिए भी घुमाया जा सकता है।}

इनपुट:

111
1*1
111

आउटपुट:

***
*8*
***

---

इनपुट:

.

आउटपुट:

*

---

इनपुट:

*11*1.1**1...1***1.....1*****1..........

आउटपुट:

1**2***11*****1.1*******1...1***********

---

इनपुट: ( कट द नॉट उदाहरण )

**212*32
333*33**
1*22*333
222222*1
*33*2232
2**22*2*

आउटपुट:

24***4**
***7**64
*8**7***
******8*
4**7****
*33**5*3

Comments

TI-BASIC इनपुट की एक खाली लाइन को स्वीकार नहीं कर सकता है। क्या ?बोर्ड के अंतिम लाइन के स्वीकार्य होने के बाद लाइन पर एक अंतिम सीमांकक (उदाहरण के लिए ) का उपयोग किया जा रहा है, या मैं कमांड लाइन के माध्यम से इनपुट लाइनों की संख्या ले सकता हूं?

— lirtosiast

@ThomasKwa एक अंत परिसीमन TI-BASIC और अन्य भाषाओं के लिए ठीक लगता है जिनकी अजीब नई सीमाएँ हैं।

— केल्विन के शौक

Answer 1

पायथ, 39 38 बाइट्स

j.es.eh-+K\*l-s:RtWYY+Y2:+K.zk+k3KZb.z

इसे ऑनलाइन आज़माएँ: प्रदर्शन

मुख्य एल्गोरिथ्म वास्तव में सीधा है। मैं बस प्रत्येक सेल पर पुनरावृति करता हूं, आसपास के 3x3 बॉक्स (या जब सेल बॉर्डर पर छोटा होता है) को लेता हूं और उस बॉक्स में एक स्टार या गैर-सितारों की संख्या प्रिंट करता हूं।

स्पष्टीकरण:

j.es.eh-+K\*l-s:RtWYY+Y2:+K.zk+k3KZb.z  implicit: .z = list of input strings
 .e                                 .z  map each index k, line b of .z to:
    .e                             b      map each index Y, char Z of b to:
         K\*                                assign "*" to K
                         +K.z               insert K at the front of .z
                        :    k+k3           slice from k to k+3
               :RtWYY+Y2                    take the slice from Y-1 or 0 
                                            to Y+2 for each line
              s                             join, this gives the 3x3 rectangle
                                             (or smaller on the border)
             -                   K          remove all "*"s
            l                               take the length
        +K                                   "*" + ^
       -                          Z         remove Z from this string
      h                                     and take the first char
                                            (if cell=mine take the number, 
                                             otherwise take the number)
  s                                       join the chars of one line
j                                       join by newlines

Comments

वास्तव में साफ, +1

— MKII

Answer 2

सीजेएम, 58 57 बाइट्स

0WX]2m*qN/{'*f+z}2*f{\~@m<fm<W<}:..+{W<{_'*#'*@'*-,?}/N}/

इनपुट लाइनफीड से खत्म नहीं होना चाहिए। आउटपुट 0पास की खानों के बिना कोशिकाओं के लिए होता है ।

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

विचार

हम इनपुट मैट्रिक्स को एक पंक्ति और तारांकन के एक कॉलम के साथ शुरू करते हैं।

इनपुट के लिए

*4*
**2

इसका परिणाम यह होगा

*4**
**2*
****

अब हम सभी संभावित संशोधनों को उत्पन्न करते हैं जो पंक्तियों और स्तंभों को 0, -1 या 1 इकाइयों को ऊपर / बाएं घुमाते हैं:

*4** **** **2* **4* **** ***2 4*** **** *2**
**2* *4** **** ***2 **4* **** *2** 4*** ****
**** **2* *4** **** ***2 **4* **** *2** 4***

हम प्रत्येक रोटेशन से "गद्दी स्थानों" को त्याग देते हैं, अर्थात

*4* *** **2 **4 *** *** 4** *** *2*
**2 *4* *** *** **4 *** *2* 4** ***

और प्रत्येक घूर्णन के संबंधित वर्णों को समेटकर एक एकल मैट्रिक्स बनाएं:

******4** 4*******2 **24*****
*******4* *4****2** 2***4****

प्रत्येक स्थिति का पहला चरित्र इसका मूल चरित्र है।

• यदि यह एक गैर-तारांकन है, तो इसे तारांकन के साथ बदलना होगा।

• यदि यह एक तारांकन चिह्न है, तो उस स्ट्रिंग में गैर-तारांकन संख्या पड़ोसी खानों की संख्या है।

यह काम किस प्रकार करता है

0WX]2m*   e# Push the array of all vectors of {0,-1,1}^2.
qN/       e# Read all input from STDIN and split at linefeeds.
{'*f+z}2* e# Append a '*' to each row and transpose rows with columns. Repeat.
f{        e# For each vector [A B], push the modified input Q; then:
  \~      e#   Swap Q with [A B] and dump A and B on the stack.
  @m<     e#   Rotate the rows of Q B units up.
  fm<     e#   Rotate each row of the result A units left.
  W<      e#   Discard the last row.
}         e# This pushes all nine rotations with Manhattan distance 1.
:..+      e# Concatenate the corresponding characters for each position.
{         e# For each row:
  W<      e#   Discard the character corresponding to the last column.
  {       e#   For each remaining string:
    _'*#  e#     Find the first index of '*' in a copy.
    '*    e#     Push '*'.
    @'*-, e#     Count the non-asterisks in the string.
    ?     e#     Select '*' if the index is non-zero, the count otherwise.
  }/      e#
  N       e#   Push a linefeed.
}/        e#

Comments

मैं डर गया - यह अद्भुत है।

— देसुवी

आपने सर, सिस्टम को तोड़ा है। +1! क्या मैं पूछ सकता हूं कि आपको यह सिद्धांत कहां मिला?

— गेमक्रॉप्स 16

@IonLee यह सब मैं है। यह वास्तव में एक बहुत ही सरल विचार है: किसी दिए गए सेल के चारों ओर की कोशिकाओं की जाँच करने के बजाय, हम पूरे ग्रिड को चारों ओर घुमाते हैं और देखते हैं कि सेल में क्या गिरता है।

— डेनिस

वाहवाही! मैं उस बारे में कभी नहीं सोचा था।

— GamrCorps

Answer 3

रूबी, 119

->s{w=1+s.index('
')
s.size.times{|c|t=0;9.times{|i|(s+?**w*2)[c+i/3*w-w+i%3-1]<?0||t+=1}
print [t,?*,'
'][s[c]<=>?*]}}

परीक्षण कार्यक्रम में अनगढ़

f=->s{
  w=1+s.index("\n")                          #width of board
  s.size.times{|c|                           #iterate through input
    t=0;                                     #number of digits surrounding current cell
    9.times{|i|                              #iterate through 3x3 box (centre must be * if this ever gets printed.)
      (s+"*"*w*2)[c+i/3*w-w+i%3-1]<"0"||t+=1 #copy of s has plenty of * appended to avoid index errors
    }                                        #add 1 every time a number is found.
  print [t,"*","\n"][s[c]<=>"*"]             #if * print t. if after * in ACSII it's a number, print *. if before, it's \n, print \n
  }
}


f['**212*32
333*33**
1*22*333
222222*1
*33*2232
2**22*2*']

Answer 4

ऑक्टेव, 76

m=@(s)char(conv2(b=(cell2mat(strsplit(s)'))~='*',ones(3),'same').*~b-6*b+48)

व्याख्या

• का उपयोग कर स्ट्रिंग के मैट्रिक्स के लिए इनपुट स्ट्रिंग परिवर्तित करें strsplitऔर cell2mat।

• 1जहां *मूल मैट्रिक्स में नहीं है, वहां तार्किक मैट्रिक्स प्राप्त करें ।

• 1 के 3x3 मैट्रिक्स के साथ इसके कनवल्शन को लें।

• इसे उल्टे लॉजिकल मैट्रिक्स *से मास्क करें और मास्क की जगह लगाएं।

• नोट: बिना खदान के पड़ोसियों वाली कोशिकाओं का प्रतिनिधित्व नहीं किया जाता है 0।

क्रियान्वयन

>> m(['**100' 10 '34321' 10 '*2**1'])   %// `10` is newline
ans =

24***
*****
3*44*

>> m(['24***' 10 '*****' 10 '3*44*'])
ans =

**100
34321
*2**1