59

बैकग्राउंड: ब्लांडिया के बहुत से अवैध अप्रवासी लोग सीमा पार करके अस्तन में आ रहे हैं। एस्टन के सम्राट ने आपको उन्हें बाहर रखने के लिए खाई खोदने का काम सौंपा है, और ब्लंडिया को खर्चों के लिए भुगतान करना होगा। चूँकि सभी टाइपिस्ट को ट्रेंच की व्यवस्था होने तक फ़र्ज़ी ठहराया गया है, इसलिए आपका कोड यथासंभव छोटा होना चाहिए। ^{_{^{_{^{_{^_*}}}}}}

कार्य: एस्टन और ब्लांडिया के बीच सीमा के 2 डी मानचित्र को देखते हुए, सीमा खाई के लिए ब्लांड का भुगतान (भूमि के साथ) करें।

उदाहरण के लिए: एस्टनियन कोशिकाओं के साथ चिह्नित A, ब्लैंडिक कोशिकाएं चिह्नित Bऔर ट्रेंच सेल चिह्नित +(मानचित्र फ़्रेम केवल स्पष्टता के लिए हैं):

┌──────────┐ ┌──────────┐
│AAAAAAAAAA│ │AAAAAAAAAA│
│ABAAAAAABA│ │A+AAAAAA+A│
│ABBBAABABA│ │A+++AA+A+A│
│ABBBAABABA│ │A+B+AA+A+A│
│ABBBBABABA│→│A+B++A+A+A│
│ABBBBABBBB│ │A+BB+A++++│
│ABBBBABBBB│ │A+BB+A+BBB│
│ABBBBBBBBB│ │A+BB+++BBB│
│BBBBBBBBBB│ │++BBBBBBBB│
└──────────┘ └──────────┘

विवरण: नक्शे में कम से कम तीन पंक्तियाँ और तीन कॉलम होंगे। शीर्ष पंक्ति पूरी तरह से एस्टनियन होगी और नीचे की पंक्ति पूरी तरह से ब्लैंडिक होगी।
जब तक इनपुट और आउटपुट अनुरूप हैं, आप एस्टनियन क्षेत्र, ब्लांडिक क्षेत्र और सीमा ट्रेंच का प्रतिनिधित्व करने के लिए किसी भी तीन मूल्यों का उपयोग कर सकते हैं।

ऑटोमेटन सूत्रीकरण: मूर के पड़ोस में कम से कम एक एस्टनियन सेल के साथ एक ब्लैंडिक सेल एक सीमा ट्रेंच सेल बन जाता है।

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

[
  "AAAAAAAAAA",
  "ABAAAAAABA",
  "ABBBAABABA",
  "ABBBAABABA",
  "ABBBBABABA",
  "ABBBBABBBB",
  "ABBBBABBBB",
  "ABBBBBBBBB",
  "BBBBBBBBBB"
]

हो जाता है:

[
  "AAAAAAAAAA",
  "A+AAAAAA+A",
  "A+++AA+A+A",
  "A+B+AA+A+A",
  "A+B++A+A+A",
  "A+BB+A++++",
  "A+BB+A+BBB",
  "A+BB+++BBB",
  "++BBBBBBBB"
]

[
  "AAA",
  "AAA",
  "BBB"
]

हो जाता है:

[
  "AAA",
  "AAA",
  "+++"
]

[
  "AAAAAAAAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAABBBAAA",
  "AAAAAAAAAA",
  "BBBBBBABBB",
  "BBBBBBAABB",
  "BBBAAAAABB",
  "BBBBBBBBBB"
]

हो जाता है:

[
  "AAAAAAAAAA",
  "AAAA+++AAA",
  "AAAA+B+AAA",
  "AAAA+++AAA",
  "AAAAAAAAAA",
  "++++++A+++",
  "BB++++AA+B",
  "BB+AAAAA+B",
  "BB+++++++B"
]

^{_{^{_{^{_{^{_{* अस्वीकरण: सक्रिय भूविज्ञान के लिए कोई भी परिणाम पुरातात्विक है!}}}}}}}}

code-golf matrix cellular-automata

— एडम
स्रोत

23

कोड गोल्फ के रूप में राजनीतिक व्यंग्य, मुझे यह पसंद है: ओ)

— सोक

4

-1 के लिए :-P

— लुइस मेंडो

25

अजगर, 4 बाइट्स : passबॉर्डर ट्रेंच बनाने की योजना से सरकार बंद हो जाती है और कुछ नहीं होता है।

— theEspinosa

3

@Espinosa नहीं नहीं, जब तक खाई की व्यवस्था नहीं होती है तब तक बंद रहेगा ।

— अदम

1

मैं सिर्फ बैकग्राउंड स्टोरी की वजह से अपवेट हुआ। पढ़ना भी जारी नहीं रखा।

— पाइप

30

वोल्फ्राम भाषा (गणितज्ञ) , 15 बाइट्स

2#-#~Erosion~1&

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

या (39 बाइट्स):

MorphologicalPerimeter[#,Padding->1]+#&

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

हम गणितज्ञ से और क्या उम्मीद करेंगे? उपयोग किए गए वर्ण हैं {Astan -> 0, Blandia -> 1, Trench -> 2}।

— lirtosiast
स्रोत

9

MATL , 11 8 बाइट्स

@ त्रुटिपूर्ण ऑक्टेव उत्तर और @ लिरटोसिस्ट्स मैथमेटिका उत्तर से प्रेरित ।

EG9&3ZI-

इनपुट एस्टन के साथ एक मैट्रिक्स है जिसके द्वारा 0और ब्लांडिया द्वारा प्रतिनिधित्व किया गया है 1। ट्रेंच द्वारा आउटपुट में दर्शाया गया है 2।

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

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

E       % Implicit input. Multiply by 2, element-wise
G       % Push input again
9       % Push 9
&3ZI    % Erode with neighbourhood of 9 elements (that is, 3×3) 
-       % Subtract, element-wise. Implicit display

— लुइस मेंडो
स्रोत

8

जावास्क्रिप्ट (ईएस 7), 84 82 बाइट्स

@ बग्घी के लिए 2 बाइट्स को सहेजा गया

पूर्णांक के एक मैट्रिक्स के रूप में इनपुट लेता है, एस्टन के लिए और ब्लांडिया के लिए के साथ। खाई के लिए अतिरिक्त मूल्य साथ एक मैट्रिक्स लौटाता है । $3$ $0$ $1$

a=>(g=x=>a.map(t=(r,Y)=>r.map((v,X)=>1/x?t|=(x-X)**2+(y-Y)**2<v:v||g(X,y=Y)|t)))()

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

टिप्पणी की गई

a => (                      // a[] = input matrix
  g = x =>                  // g = function taking x (initially undefined)
    a.map(t =               //   initialize t to a non-numeric value
      (r, Y) =>             //   for each row r[] at position Y in a[]:
      r.map((v, X) =>       //     for each value v at position X in r[]:
        1 / x ?             //       if x is defined (this is a recursive call):
          t |=              //         set the flag t if:
            (x - X) ** 2 +  //           the squared Euclidean distance
            (y - Y) ** 2    //           between (x, y) and (X, Y)
            < v             //           is less than v (3 = Astan, 0 = Blandia)
        :                   //       else (this is the initial call to g):
          v ||              //         yield v unchanged if it's equal to 3 (Astan)
          g(X, y = Y)       //         otherwise, do a recursive call with (X, Y) = (x, y)
          | t               //         and yield the flag t (0 = no change, 1 = trench)
      )                     //     end of inner map()
    )                       //   end of outer map()
)()                         // initial call to g

— Arnauld
स्रोत

82 बाइट्स?

— झबरा

4

@ शागिर्द हाल ही में पर्याप्त प्रश्न नहीं हैं। मैं नहीं जानता कि अब और कैसे गोल्फ करूं। : D धन्यवाद!

— अरनौल

मैं केवल यही बात पहले सोच रहा था!

— झबरा

7

के (ngn / k) , 23 बाइट्स

{x+x&2{++/'3'0,x,0}/~x}

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

के लिए उपयोग करता 0 1 2है"AB+"

{ } तर्क के साथ कार्य करें x

~ तार्किक नहीं

2{ }/ दो बार करते हैं

0,x,0 0-एस के साथ चारों ओर (मैट्रिक्स के ऊपर और नीचे)
3' लगातार पंक्तियों के त्रिभुज
+/' प्रत्येक राशि
+ खिसकाना

x&तार्किक और के xसाथ

x+जोड़ने xके लिए

— NGN
स्रोत

5

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS

⊢⌈{2∊⍵}⌺3 3

यह चैट में @ dzaima के 12-बाइट समाधान पर आधारित है । @ dfn में उपयोग करने के बारे में सोचने के ∊लिए @ और खुद को इनपुट और आउटपुट के लिए एक ही एन्कोडिंग का उपयोग करने के लिए हमें याद दिलाने के लिए @ H.PWiz को @ श्रेय

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

क्रमशः प्रतिनिधित्व 'AB+'करता 2 0 1है

{ }⌺3 3 इनपुट के प्रत्येक अतिव्यापी 3 × 3 क्षेत्र के लिए एक फ़ंक्शन लागू करें, जिसमें मैट्रिक्स के बाहर 1 इकाई का विस्तार करने वाले क्षेत्र शामिल हैं, जो कि पीएस के साथ गद्देदार हैं

2∊⍵2 तर्क में मौजूद है? 0/1 बूलियन वापस करें

⊢⌈ प्रति-तत्व अधिकतम और मूल मैट्रिक्स

— NGN
स्रोत

बेशक, स्टैंसिल पर स्विच करने से आप अपने बाइट्स के आधे से ज्यादा हिस्से को बचा पाएंगे।

— एडम

@ Adám कि एक अलग भाषा में एक जवाब होगा, इसलिए इस जवाब के खिलाफ तुलनीय या प्रतिस्पर्धा नहीं है। और मैं विशेष रूप से दिलचस्प, खेद विशेष प्रयोजन भाषाओं में गोल्फ नहीं मिल रहा है

— NGN

@ Adám एक उपनाम displayजिसके लिए मैं निकालना भूल गया था। हटाया अब

— NGN

5

पॉवरशेल , 220 बाइट्स

यह अन्य सबमिशन जितना छोटा नहीं है, लेकिन मुझे लगा कि मैं इसे संदर्भ के लिए जोड़ूंगा। [सामने!]

function m($i,$m){($i-1)..($i+1)|?{$_-in0..$m}}
$h=$a.count-1;$w=$a[0].length-1
foreach($i in 0..$h){-join$(foreach($j in 0..$w){if ($a[$i][$j]-eq'B'-and($a[(m $i $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$i][$j]}})}

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

— कीथ एस गार्नर
स्रोत

1

PPCG में आपका स्वागत है। अच्छा पहला उत्तर, TIO लिंक के साथ भी! कोड लंबाई के बारे में चिंता मत करो; प्रत्येक भाषा खुद के खिलाफ प्रतिस्पर्धा करती है। Btw, आप बिना किसी प्रभाव के पहली पंक्ति को तोड़कर एक बाइट बचा सकते हैं।

— आदम

क्या फाइनल लाइन

0..$h|%{-join$(foreach($j in 0..$w){if ($a[$_][$j]-eq'B'-and($a[(m $_ $h)]|?{$_[(m $j $w)]-match'A'})){'+'}else{$a[$_][$j]}})}

207 बाइट्स के लिए बन सकती है ?

— गेब्रियल मिल्स

4

ऑक्टेव , 37 31 26 बाइट्स

यह फ़ंक्शन उपयोग करने वाली "छवि" के एस्टन ( ) भाग पर एक रूपात्मक कटाव करता है , और फिर सभी तीन क्षेत्रों को अलग-अलग प्रतीकों को बनाने के लिए कुछ अंकगणित का उपयोग करता है। धन्यवाद @LuisMendo -5 बाइट्स के लिए!1-b~~conv2~~ imerode

@(b)2*b-imerode(b,ones(3))

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

— flawr
स्रोत

2

-1 कनवल्शन के लिए :-P

— लुइस मेंडो

@LuisMendo एक पुराने संस्करण में एक

— कन्वर्शन

धन्यवाद, अद्यतन!

— flawr

3

जे , 28 बाइट्स

>.3 3(2 e.,);._3(0|:@,|.)^:4

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

'AB+' -> 2 0 1

Ngn के APL समाधान से प्रेरित है। शून्य के साथ मैट्रिक्स पैड करने के लिए 12 बाइट्स ...

— गैलेन इवानोव
स्रोत

शून्य पैडिंग किए बिना एपीएल समाधान क्यों नहीं निकल पा रहा है?

— योना

@ जोना: एपीएल ⌺(स्टैंसिल) इसे परमाणु रूप से करता है: "आयतें वाई के क्रमिक तत्वों पर केंद्रित होती हैं और (जब तक कि आयत का आकार 1 नहीं है), भरण तत्वों के साथ गद्देदार।"

— गैलेन इवानोव

जे के संस्करण की तुलना में यह बहुत अधिक उपयोगी लगता है ...

— जोनाह

@ जोना हां, यह है!

— गेलन इवानोव

2

चारकोल , 20 बाइट्स

≔⪫θ⸿θＰθＦθ⎇∧№ＫＭA⁼Bι+ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⪫θ⸿θ

सामान्य नईलाइनों के बजाय गाड़ी के रिटर्न के साथ इनपुट ऐरे से जुड़ें। इसकी आवश्यकता है ताकि पात्रों को व्यक्तिगत रूप से मुद्रित किया जा सके।

Ｐθ

कर्सर को हिलाए बिना इनपुट स्ट्रिंग को प्रिंट करें।

Ｆθ

इनपुट स्ट्रिंग के प्रत्येक वर्ण पर लूप।

⎇∧№ＫＭA⁼Bι

यदि मूर पड़ोस में एक है A, और वर्तमान चरित्र एक है B...

... तो Bएक के साथ अधिलेखित +...

ι

... अन्यथा वर्तमान चरित्र को प्रिंट करें (या यदि वर्तमान चरित्र एक गाड़ी वापसी है तो अगली पंक्ति में जाएं)।

— नील
स्रोत

2

जावास्क्रिप्ट, 85 बाइट्स

कल देर रात इसे एक साथ फेंक दिया और इसके बारे में भूल गया। शायद अभी भी कहीं न कहीं कुछ सुधार की गुंजाइश है।

इनपुट और आउटपुट अंक सारणियों के एक सरणी के रूप में है, 3एस्टन के लिए, 0ब्लांडिया के 1लिए और खाई के लिए उपयोग किया जाता है।

a=>a.map((x,i)=>x.map((y,j)=>o.map(v=>o.map(h=>y|=1&(a[i+v]||x)[j+h]))|y),o=[-1,0,1])

इसे ऑनलाइन आज़माएं (सुविधा के लिए, चुनौती में उपयोग किए जाने वाले I / O प्रारूप से मानचित्र)

— झबरा
स्रोत

2

जावास्क्रिप्ट, 126 118 बाइट्स

_=>_.map(x=>x.replace(/(?<=A)B|B(?=A)/g,0)).map((x,i,a)=>[...x].map((v,j)=>v>'A'&&(a[i-1][j]<v|(a[i+1]||x)[j]<v)?0:v))

प्रश्न से स्ट्रिंग सरणियों में से एक में पास करें, और आपको ट्रेंच के लिए 0 का उपयोग करके ~~तार~~ वर्ण सरणियों का धन्यवाद मिलेगा (धन्यवाद @Shaggy!)। कर सकते हैं शायद अधिक (संख्यात्मक सरणियों पर स्विच करने के बिना) golfed सकता है, लेकिन मैं इस समय कुछ भी नहीं सोच सकते हैं।

— एम डिरर
स्रोत

मुझे लगता है कि यह 120 बाइट्स के लिए काम करता है।

— झबरा

या 116 बाइट्स वर्ण सरणियों की एक सरणी लौटाते हैं।

— झबरा

1

@ शैगी आपका गोल्फ काम नहीं करता है, दुख की बात है - यह उन जगहों को नहीं पकड़ता है जहां ए और बी एक-दूसरे के लिए विकर्ण हैं। दूसरी ओर, यह कुछ बहुत ही सरल

— गोल्फ

1

रेटिना 0.8.2 , 92 80 बाइट्स

(?<=¶(.)*)B(?=.*¶(?<-1>.)*(?(1)_)A|(?<=¶(?(1)_)(?<-1>.)*A.*¶.*))
a
iT`Ba`+`.?a.?

इसे ऑनलाइन आज़माएं! क्या मैं इसे समय पर खत्म कर दूंगा ? स्पष्टीकरण: किसी भी Bएस के ऊपर या नीचे के एस तुरंत Aएस में बदल जाते हैं a। यह तब s या s Bके बाएँ या दाएँ जाँच करने के लिए समस्या को कम करता है । एस खुद को भी में बदल पाने के लिए की जरूरत है निश्चित रूप से है, लेकिन सौभाग्य से ध्वज को केवल regex मैच, न कि वास्तविक लिप्यंतरण को प्रभावित करता है, तो रों अप्रभावित रहते हैं।Aaa+iTA

— नील
स्रोत

1

05AB1E , 29 बाइट्स

_2FIн¸.øVgN+FYN._3£})εøO}ø}*Ā+

Matrices वास्तव में 05AB1E के मजबूत सूट नहीं हैं (और न ही वे मेरे मजबूत सूट हैं) .. निश्चित रूप से कुछ और गोल्फ हो सकते हैं, हालांकि।
से प्रेरित होकर @ngn की कश्मीर (NGN / ट) जवाब है, तो भी मैं के साथ एक 2 डी पूर्णांक मैट्रिक्स के / ओ का उपयोग करता है 012के लिए AB+क्रमशः।

इसे ऑनलाइन आज़माएं । (TIO में पाद लेख आउटपुट को प्रिंट करने के लिए है। मैट्रिक्स आउटपुट देखने के लिए इसे बेझिझक हटा दें।)

स्पष्टीकरण:

_                # Inverse the values of the (implicit) input-matrix (0→1 and 1→0)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #   → [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]]
 2F              # Loop `n` 2 times in the range [0, 2):
   Iн            #  Take the input-matrix, and only leave the first inner list of 0s
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → [0,0,0,0]
     ¸           #  Wrap it into a list
                 #   i.e. [0,0,0,0] → [[0,0,0,0]]
      .ø         #  Surround the inverted input with the list of 0s
                 #   i.e. [[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0]] and [0,0,0,0]
                 #    → [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]]
        V        #  Pop and store it in variable `Y`
   g             #  Take the length of the (implicit) input-matrix
                 #   i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]] → 4
    N+           #  Add `n` to it
                 #   i.e. 4 and n=0 → 4
                 #   i.e. 4 and n=1 → 5
      F          #  Inner loop `N` in the range [0, length+`n`):
       Y         #   Push matrix `Y`
        N._      #   Rotate it `N` times towards the left
                 #    i.e. [[0,0,0,0],[1,1,1,1],[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0]] and N=2
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
            3£   #   And only leave the first three inner lists
                 #    i.e. [[1,0,1,1],[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0],[1,1,1,1]]
                 #     → [[1,0,1,1],[1,0,0,0],[0,0,0,0]]
              }  #  After the inner loop:
    )            #  Wrap everything on the stack into a list
                 #   → [[[0,0,0,0],[1,1,1,1],[1,0,1,1]],[[1,1,1,1],[1,0,1,1],[1,0,0,0]],[[1,0,1,1],[1,0,0,0],[0,0,0,0]],[[1,0,0,0],[0,0,0,0],[0,0,0,0]]]
     €ø          #  Zip/transpose (swapping rows/columns) each matrix in the list
                 #   → [[[0,1,1],[0,1,0],[0,1,1],[0,1,1]],[[1,1,1],[1,0,0],[1,1,0],[1,1,0]],[[1,1,0],[0,0,0],[1,0,0],[1,0,0]],[[1,0,0],[0,0,0],[0,0,0],[0,0,0]]]
       O         #  And take the sum of each inner list
                 #   → [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
        ø        #  Zip/transpose; swapping rows/columns the entire matrix again
                 #   i.e. [[2,1,2,2],[3,1,2,2],[2,0,1,1],[1,0,0,0]]
                 #    → [[2,3,2,1],[1,1,0,0],[2,2,1,0],[2,2,1,0]]
               } # After the outer loop:
                 #   i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
  *              # Multiple each value with the input-matrix at the same positions,
                 # which implicitly removes the trailing values
                 #  i.e. [[3,5,5,4,2],[4,6,5,4,2],[2,3,2,2,1],[1,1,0,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
   Ā             # Truthify each value (0 remains 0; everything else becomes 1)
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,2,1,0],[2,2,1,0]]
                 #   → [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
    +            # Then add each value with the input-matrix at the same positions
                 #  i.e. [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,0,0]]
                 #   and [[0,0,0,0],[0,1,0,0],[0,1,1,1],[1,1,1,1]]
                 #    → [[0,0,0,0],[0,2,0,0],[0,2,2,2],[2,2,1,1]]
                 # (and output the result implicitly)

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

1

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 187 बाइट्स

a=>a.Select((b,i)=>b.Select((c,j)=>{int k=0;for(int x=Math.Max(0,i-1);x<Math.Min(i+2,a.Count);x++)for(int y=Math.Max(0,j-1);y<Math.Min(j+2,a[0].Count);)k+=a[x][y++];return k>1&c<1?9:c;}))

इसके बजाय Take()एस, Skip()एस और Select()एस का पीछा करते हुए , यह पड़ोसियों को खोजने के लिए छोरों के लिए डबल का उपयोग करता है। विशाल बाइट में कमी, 392 बाइट्स से 187 तक। लिनक हमेशा सबसे छोटा नहीं होता है!

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

— अज्ञान का अवतार
स्रोत

1

पर्ल 5, 58 46 बाइट्स

$m=($n=/$/m+"@+")-2;s/A(|.{$m,$n})\KB|B(?=(?1)A)/+/s&&redo

TIO

-12 बाइट्स थैंक्स टू @Grimy

/.
/;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo

TIO

-p-nप्रिंट भी पसंद है
-00 पैरा मोड
चौड़ाई -1 प्राप्त करने के लिए /.\n/पहली पंक्ति के अंतिम वर्ण से मेल खाता है
@{-} विशेष मिलान पिछले मिलान समूहों के मैच की शुरुआत की स्थिति, स्ट्रिंग के रूप में (पहले तत्व)
s/../+/s&&redoद्वारा मैच की जगह +है, जबकि मैचों
- /sध्वज, ताकि .मैच भी newline वर्ण
A(|.{@{-}}.?.?)\KB माचिस
- ABया A(चौड़ाई -1) के बाद (चौड़ाई + 1) वर्णों के आधार परB
- \KBअपरिवर्तित के बाईं ओर रखने के लिए
B(?=(?1)A),
- (?1) पिछले अभिव्यक्ति को संदर्भित करने के लिए पुनरावर्ती को निष्क्रिय करना (|.{$m,$o})
- (?=..) लुकहेड, बिना उपभोग इनपुट के मिलान करने के लिए

— नहुएल फौलीउल
स्रोत

-9 बाइट्स /. /,@m=@-while s/A(|.{@m}.?.?)\KB|B(?=(?1)A)/+/s(पहले रेगेक्स में शाब्दिक न्यूलाइन)। टीआईओ

— ग्रिम्मी

1

डाउन टू 46 /. /;s/A(|.{@{-}}.?.?)\KB|B(?=(?1)A)/+/s&&redo:। टीआईओ

— ग्रिम्मी

धन्यवाद, मुझे यह भी पता था, लेकिन त्याग दिया क्योंकि कोड गोल्फ प्रदर्शन के लिए विनाशकारी बैकट्रैकिंग के लिए सोच रहा था महत्वपूर्ण नहीं है

— नाहुएल फौइउल

1

जावा 8, 169 145 बाइट्स

m->{for(int i=m.length,j,k;i-->0;)for(j=m[i].length;j-->0;)for(k=9;m[i][j]==1&k-->0;)try{m[i][j]=m[i+k/3-1][j+k%3-1]<1?2:1;}catch(Exception e){}}

-24 बाइट्स @ OlivierGrégoire को धन्यवाद ।

के 0बजाय Aऔर के 1बजाय का उपयोग करता है B, इनपुट 2 डी पूर्णांक-मैट्रिक्स होने के साथ। बाइट्स को बचाने के लिए एक नया वापस करने के बजाय इनपुट-मैट्रिक्स को संशोधित करता है।

सभी एकल आठ चुनौती के लिए मेरे जवाब के रूप में कोशिकाओं की जाँच की जाती है ।

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

स्पष्टीकरण:

m->{                            // Method with integer-matrix parameter and no return-type
  for(int i=m.length,j,k;i-->0;)//  Loop over the rows
    for(j=m[i].length;j-->0;)   //   Inner loop over the columns
      for(k=9;m[i][j]==1&       //    If the current cell contains a 1:
          k-->0;)               //     Inner loop `k` in the range (9, 0]:
        try{m[i][j]=            //      Set the current cell to:
             m[i+k/3-1]         //       If `k` is 0, 1, or 2: Look at the previous row
                                //       Else-if `k` is 6, 7, or 8: Look at the next row
                                //       Else (`k` is 3, 4, or 5): Look at the current row
              [j+k%3-1]         //       If `k` is 0, 3, or 6: Look at the previous column
                                //       Else-if `k` is 2, 5, or 8: Look at the next column
                                //       Else (`k` is 1, 4, or 7): Look at the current column
               <1?              //       And if this cell contains a 0:
                  2             //        Change the current cell from a 1 to a 2
                 :              //       Else:
                  1;            //        Leave it a 1
        }catch(Exception e){}}  //      Catch and ignore ArrayIndexOutOfBoundsExceptions
                                //      (try-catch saves bytes in comparison to if-checks)

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

1

मैंने बहुत जाँच नहीं की है, लेकिन क्या कुछ गड़बड़ है m[i+k/3-1][j+k%3-1]? 145 बाइट्स

— ओलिवियर ग्रेजायर

@ OlivierGrégoire डांग, यह इतना आसान है .. धन्यवाद!

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

मुझे लगता है कि यह पिछली चुनौतियों के आपके जवाबों के लिए भी मान्य है जो उन्हें एक ही संरचना के लिए लगती हैं

— ओलिवियर ग्राईगोइरे

@ ओलिवियरग्रैगोयर हाँ, मैं उन लोगों के बारे में सुझाव देने के साथ-साथ आपको गोल्फ के बारे में बताने वाला था, लेकिन फिर एक और टिप्पणी (और काम का एक सवाल) बीच में आ गई। एक क्षण में कर लेंगे।

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

1

पॉवरशेल , 86 80 बाइट्स

$p="(.?.?.{$(($args|% i*f '
')-1)})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'

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

नक्शा newlines के साथ एक स्ट्रिंग है। यह स्क्रिप्ट regexp के साथ बदल Bजाती है ।+(?<=A(.?.?.{$MapWidth-1})?)B|B(?=(.?.?.{$MapWidth-1})?A)

कम गोल्फ वाली टेस्ट स्क्रिप्ट:

$f = {
$l=($args|% indexOf "`n")-1
$p="(.?.?.{$l})?"
$args-replace"(?s)(?<=A$p)B|B(?=$p`A)",'+'
}

@(
,(@"
AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
A+AAAAAA+A
A+++AA+A+A
A+B+AA+A+A
A+B++A+A+A
A+BB+A++++
A+BB+A+BBB
A+BB+++BBB
++BBBBBBBB
"@)
,(@"
AAA
AAA
BBB
"@,@"
AAA
AAA
+++
"@)
,(@"
AAAAAAAAAA
AAAABBBAAA
AAAABBBAAA
AAAABBBAAA
AAAAAAAAAA
BBBBBBABBB
BBBBBBAABB
BBBAAAAABB
BBBBBBBBBB
"@,@"
AAAAAAAAAA
AAAA+++AAA
AAAA+B+AAA
AAAA+++AAA
AAAAAAAAAA
++++++A+++
BB++++AA+B
BB+AAAAA+B
BB+++++++B
"@)
) | % {
    $map,$expected = $_
    $result = &$f $map
    $result-eq$expected
    #$result # uncomment this line to display results
}

आउटपुट:

True
True
True

— Mazzy
स्रोत

0

रूबी , 102 बाइट्स

->a{a+=?.*s=a.size
(s*9).times{|i|a[j=i/9]>?A&&a[j-1+i%3+~a.index($/)*(i/3%3-1)]==?A&&a[j]=?+}
a[0,s]}

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

इनपुट / आउटपुट एक नई लाइन के रूप में अलग स्ट्रिंग

— स्तर नदी सेंट
स्रोत

0

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

lambda m:[[[c,'+'][c=='B'and'A'in`[x[j-(j>0):j+2]for x in m[i-(i>0):i+2]]`]for j,c in e(l)]for i,l in e(m)];e=enumerate

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

I / O सूचियों की एक सूची है

— TFeld
स्रोत

0

TSQL, 252 बाइट्स

स्ट्रिंग को विभाजित करना बहुत महंगा है, अगर स्ट्रिंग को विभाजित किया गया था और पहले से ही एक तालिका में बाइट गिनती 127 वर्ण होगी। स्क्रिप्ट नीचे और पूरी तरह से अलग में शामिल है। इतना स्थान लेने के लिए क्षमा करें।

golfed:

WITH C as(SELECT x,x/z r,x%z c,substring(@,x+1,1)v
FROM spt_values CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
WHERE'P'=type)SELECT @=stuff(@,x+1,1,'+')FROM c WHERE
exists(SELECT*FROM c d WHERE abs(r-c.r)<2and
abs(c-c.c)<2and'AB'=v+c.v)PRINT @

Ungolfed:

DECLARE @ varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB';

WITH C as
(
  SELECT x,x/z r,x%z c,substring(@,x+1,1)v
  FROM spt_values
  CROSS APPLY(SELECT number x,charindex(char(10),@)z)z
  WHERE'P'=type
)
SELECT
  @=stuff(@,x+1,1,'+')
FROM c
WHERE exists(SELECT*FROM c d 
         WHERE abs(r-c.r)<2 
           and abs(c-c.c)<2 and'AB'=v+c.v)
PRINT @

कोशिश करके देखो

TSQL, 127 बाइट्स (इनपुट के रूप में टेबल वेरिएबल का उपयोग करके)

प्रबंधन स्टूडियो में इस स्क्रिप्ट को निष्पादित करें - इसे पढ़ने योग्य बनाने के लिए "क्वेरी" - "टेक्स्ट को परिणाम" का उपयोग करें

--populate table variable
USE master
DECLARE @v varchar(max)=
'AAAAAAAAAA
ABAAAAAABA
ABBBAABABA
ABBBAABABA
ABBBBABABA
ABBBBABBBB
ABBBBABBBB
ABBBBBBBBB
BBBBBBBBBB'

DECLARE @ table(x int, r int, c int, v char)

INSERT @
SELECT x+1,x/z,x%z,substring(@v,x+1,1)
FROM spt_values
CROSS APPLY(SELECT number x,charindex(char(10),@v)z)z
WHERE'P'=type and len(@v)>number

-- query(127 characters)

SELECT string_agg(v,'')FROM(SELECT
iif(exists(SELECT*FROM @
WHERE abs(r-c.r)<2and abs(c-c.c)<2and'AB'=v+c.v),'+',v)v
FROM @ c)z

इसे आज़माएं - चेतावनी आउटपुट चयनित है और पठनीय नहीं है। प्रिंट के साथ पढ़ने योग्य होगा, लेकिन इस पद्धति का उपयोग करना संभव नहीं है

— t-clausen.dk
स्रोत

आपको क्या लगता है कि आप एक टेबल को तर्क के रूप में नहीं ले सकते हैं?

— एडम

@ एक तर्क के रूप में एक तालिका का उपयोग कर कोड बनाने के लिए एक बुरा विचार नहीं है - मैं इस पर सही हो जाएगा

— t-clausen.dk

@ Adám मुझे लगता है कि मैं गलत था, स्क्रिप्ट को 120 वर्णों के लिए काम करने के लिए, मुझे इनपुट के रूप में तालिका और varchar दोनों की आवश्यकता होगी, मैंने इसे फिर से लिखा। इसने 151 पात्रों को लिया

— t-clausen.dk

एक सीमा खाई खोदो

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

वोल्फ्राम भाषा (गणितज्ञ) , 15 बाइट्स

MATL , 11 8 बाइट्स

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

जावास्क्रिप्ट (ईएस 7), 84 82 बाइट्स

टिप्पणी की गई

के (ngn / k) , 23 बाइट्स

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स SBCS

पॉवरशेल , 220 बाइट्स

ऑक्टेव , 37 31 26 बाइट्स

जे , 28 बाइट्स

चारकोल , 20 बाइट्स

जावास्क्रिप्ट, 85 बाइट्स

जावास्क्रिप्ट, 126 118 बाइट्स

रेटिना 0.8.2 , 92 80 बाइट्स

05AB1E , 29 बाइट्स

सी # (विजुअल सी # इंटरएक्टिव कंपाइलर) , 187 बाइट्स

पर्ल 5, 58 46 बाइट्स

जावा 8, 169 145 बाइट्स

पॉवरशेल , 86 80 बाइट्स

रूबी , 102 बाइट्स

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

TSQL, 252 बाइट्स

TSQL, 127 बाइट्स (इनपुट के रूप में टेबल वेरिएबल का उपयोग करके)

एपीएल (Dyalog यूनिकोड) , 11 बाइट्स ^SBCS