किसान की मदद करना


10

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

अतिरिक्त लैंप: लैंप जो खेत से हटाने पर जलाई गई कोशिकाओं की संख्या पर कोई फर्क नहीं पड़ेगा। साथ ही, आपके द्वारा इंगित किए गए लैंप को एक-एक करके हटाया नहीं जाएगा, लेकिन वे एक साथ हटा दिए जाएंगे।

नोट: केवल क्रिया जो आप कर सकते हैं वह है कुछ लैंप को हटाने के लिए। आप न तो लैंप को फिर से व्यवस्थित कर सकते हैं और न ही डाल सकते हैं। आपका अंतिम लक्ष्य अधिकतम संख्या में लैंप को हटाना है जैसे कि हर सेल जो पहले जलाया गया था, अभी भी जलाया गया है।

किसान जैक को अधिक से अधिक बेकार लैंपों को देखने में मदद करें ताकि वह उन्हें कहीं और इस्तेमाल कर सके।

इनपुट

आपको क्षेत्र M और N की पहली पंक्ति के आयाम दिए जाएंगे। Next M रेखाएँ प्रत्येक फ़ील्ड का प्रतिनिधित्व करने वाले N वर्णों का अनुसरण करती हैं।

'1' सेल का प्रतिनिधित्व करता है, जहां दीपक रखा जाता है।

'0' एक खाली सेल का प्रतिनिधित्व करता है।

उत्पादन

आपको एक पूर्णांक को आउटपुट करना होगा जिसमें बेकार लैंप की संख्या हो।

नमूना इनपुट:

3 3
100
010
001

नमूना आउटपुट:

2

विजेता:

चूंकि यह कोड गोल्फ है, विजेता वह होगा जो कम से कम वर्णों में सफलतापूर्वक कार्य पूरा करेगा


@PeterTaylor मैंने अपनी पोस्ट संपादित की है। क्या आपको अभी भी भ्रम है?
user2369284

काफी बेहतर। धन्यवाद।
पीटर टेलर

क्या हम मान सकते हैं कि इनपुट एक नई रेखा के साथ समाप्त होता है?
जॉन ड्वोरक

1
यह होमवर्क जैसा दिखता है।
जोहान्स

1
क्या हम गारंटी देते हैं कि इनपुट लैंप पूरे खेत को रोशन करेगा? मैं अनुमान नहीं लगा रहा हूँ ...
कीथ रान्डेल

जवाबों:


5

गणितज्ञ 186 (लालची) और 224 (सभी संयोजन)

लालची समाधान

t=MorphologicalTransform;n@w_:=Flatten@w~Count~1
p_~w~q_:=n[p~t~Max]==n[q~t~Max]
g@m_:=Module[{l=m~Position~1,r,d=m},While[l!={},If[w[m,r=ReplacePart[d,#-> 0]&    
[l[[1]]]],d=r];l=Rest@l];n@m-n@d]

यह एक के बाद एक शानदार रोशनी बंद कर देता है। यदि प्रकाश के जाने पर प्रकाश का कवरेज कम नहीं होता है, तो उस प्रकाश को समाप्त किया जा सकता है। लालची दृष्टिकोण बहुत तेज है और आसानी से 15x15 के मैट्रिक्स को संभाल सकता है और बहुत बड़ा (नीचे देखें)। यह एक एकल समाधान लौटाता है, लेकिन यह अज्ञात है कि क्या यह इष्टतम है या नहीं। दोनों दृष्टिकोण, गोल्फ संस्करणों में अप्रयुक्त रोशनी की संख्या वापस करते हैं। गैर-गोल्फ दृष्टिकोण भी नीचे के रूप में ग्रिड प्रदर्शित करता है।

इससे पहले:

इससे पहले

उपरांत:

उपरांत

प्रकाश के सभी संयोजनों का उपयोग कर इष्टतम समाधान (224 चार्ट)

@ क्लेमेंट के लिए धन्यवाद के साथ।

रोशनी के सभी संयोजनों का उपयोग करते हुए अनप्लग्ड संस्करण

एफ। रूपात्मक sameCoverageQव्यवहार फ़ंक्शन का उपयोग लिट के रूप में किया जाता है (शून्य के बजाय मूल्य = 1) 3 x3 वर्ग जिसमें प्रत्येक प्रकाश रहता है। जब एक प्रकाश खेत के किनारे के पास होता है, केवल चौकों (9 से कम) सीमाओं के भीतर खेत गिने जाते हैं। एक से अधिक लैंप जलाया हुआ एक वर्ग बस जलाया जाता है। कार्यक्रम प्रत्येक प्रकाश को बंद कर देता है और यह देखने के लिए जांच करता है कि क्या खेत पर समग्र प्रकाश कवरेज कम हो गया है। यदि ऐसा नहीं है, तो प्रकाश समाप्त हो जाता है।

nOnes[w_]:=Count[Flatten@w,1]
sameCoverageQ[m1_,m2_]:=nOnes[MorphologicalTransform[m1,Max]]==
  nOnes[MorphologicalTransform[m2,Max]]

(*draws a grid with light bulbs *)
h[m_]:=Grid[m/.{1-> Style[\[LightBulb],24],0-> ""},Frame-> All,ItemSize->{1,1.5}]

c[m1_]:=GatherBy[Cases[{nOnes[MorphologicalTransform[ReplacePart[Array[0&,Dimensions[m1]],
#/.{{j_Integer,k_}:> {j,k}-> 1}],Max]],#,Length@#}&/@(Rest@Subsets[Position[m1,1]]),
{nOnes[MorphologicalTransform[m1,Max]],_,_}],Last][[1,All,2]]

nOnes[matrix]ध्वजांकित कोशिकाओं की संख्या को गिना जाता है। इसका उपयोग रोशनी को गिनने के लिए और जली हुई कोशिकाओं को गिनने के लिए भी किया जाता है

sameCoverageQ[mat1, mat2] परीक्षण करता है कि क्या मैट 1 में जलाई गई कोशिकाएं चटाई 2 में जलाई गई कोशिकाओं की संख्या के बराबर हैं। मॉर्फोलॉजिकल ट्रान्सफॉर्म [[चटाई] रोशनी का एक मैट्रिक्स लेती हैं और उन कोशिकाओं के एक मैट्रिक्स को वापस लौटाती हैं जिन्हें वे प्रकाश करते हैं।

c[m1]एम 1 से रोशनी के सभी संयोजन लेता है और कवरेज के लिए उनका परीक्षण करता है। अधिकतम कवरेज वाले लोगों में, यह उन लोगों का चयन करता है जिनके पास सबसे कम प्रकाश बल्ब हैं। इनमें से प्रत्येक एक इष्टतम समाधान है।


उदाहरण 1:

एक 6x6 सेटअप

(*all the lights *)
m=Array[RandomInteger[4]&,{6,6}]/.{2-> 0,3->0,4->0}
h[m]

मूल

सभी इष्टतम समाधान।

(*subsets of lights that provide full coverage *)
h/@(ReplacePart[Array[0&,Dimensions[m]],#/.{{j_Integer,k_}:> {j,k}-> 1}]&/@(c[m]))

जवाब


रोशनी के सभी संयोजनों का उपयोग कर गोल्फ संस्करण।

यह संस्करण अप्रयुक्त रोशनी की संख्या की गणना करता है। यह ग्रिड प्रदर्शित नहीं करता है।

c अप्रयुक्त रोशनी की संख्या लौटाता है।

n@w_:=Flatten@w~Count~1;t=MorphologicalTransform;
c@r_:=n@m-GatherBy[Cases[{n@t[ReplacePart[Array[0 &,Dimensions[r]],#
/.{{j_Integer,k_}:> {j,k}-> 1}],Max],#,Length@#}&/@(Rest@Subsets[r~Position~1]),
{n[r~t~Max],_,_}],Last][[1,1,3]]

n[matrix]ध्वजांकित कोशिकाओं की संख्या को गिना जाता है। इसका उपयोग रोशनी को गिनने के लिए और जली हुई कोशिकाओं को गिनने के लिए भी किया जाता है

s[mat1, mat2] यह परीक्षण करता है कि क्या मैट 1 में जलाई गई कोशिकाएं mat2.t में जलाई गई कोशिकाओं की संख्या के बराबर होती हैं [[चटाई] रोशनी का एक मैट्रिक्स लेती हैं और उन कोशिकाओं के एक मैट्रिक्स को लौटा देती हैं जिन्हें वे प्रकाश करते हैं।

c[j]जम्मू से रोशनी के सभी संयोजन लेता है और कवरेज के लिए उनका परीक्षण करता है। अधिकतम कवरेज वाले लोगों में, यह उन लोगों का चयन करता है जिनके पास सबसे कम प्रकाश बल्ब हैं। इनमें से प्रत्येक एक इष्टतम समाधान है।

उदाहरण 2

m=Array[RandomInteger[4]&,{6,6}]/.{2-> 0,3->0,4->0};
m//Grid

ग्रिड

एक ही प्रकाश कवरेज होने पर दो रोशनी को बचाया जा सकता है। से। मी]

2


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

आपके विचार से ऐसा प्रतीत होता है कि मूल सेटअप में 2 सुपरफ्लिश लाइट्स, ए, बी होना संभव है, जिनमें से एक दूसरे की तुलना में अधिक शानदार है। तो, यह हो सकता है कि एक को हटा दिया जाए (पहले) तो बेहतर अर्थव्यवस्था है। मुझे लगता है कि यह कुल 3 रोशनी के साथ नहीं हो सकता है, लेकिन यह वास्तव में अधिक संख्या में रोशनी के साथ संभव हो सकता है। मैंने मूल रूप से रोशनी के सभी संयोजनों का परीक्षण करके समस्या को हल किया। यह निश्चित रूप से इष्टतम है और इस प्रकार आदर्श है, लेकिन मैंने इसे रोशनी के एक बड़े सेट के साथ अव्यवहारिक पाया।
डेविड जेएन

@ क्लेमेंट मैं एक समाधान पर काम कर रहा हूं जो सभी संभावित संयोजनों का परीक्षण करेगा। थोड़ा समय लगेगा ...
डेविड जेएन

यह सुनिश्चित होगा;) लेकिन इसकी उम्मीद की जानी चाहिए: क्योंकि यह इस समस्या को न्यूनतम सेट कवर का उदाहरण है - जो एनपी है। क्या अतिरिक्त मान्यताओं (लगभग सभी कवरिंग सेट, पार्श्व वाले को छोड़कर, एक ही कार्डिनैलिटी है) एक कुशल कार्यान्वयन के लिए अनुमति देते हैं, हालांकि एक दिलचस्प समस्या है।
क्लीमेंट

यदि आप पंक्तियों और स्तंभों द्वारा क्रमिक रूप से चलते हैं, तो मुझे संदेह है कि लालची समाधान सही है, लेकिन मैंने अभी तक इसे साबित नहीं किया है।
एडित्सो ने छोड़ दिया क्योंकि SE

3

अजगर, 309 चरस

import sys
I=sys.stdin.readlines()[1:]
X=len(I[0])
L=[]
m=p=1
for c in''.join(I):m|=('\n'!=c)*p;L+=('1'==c)*[p<<X+1|p<<X|p<<X-1|p*2|p|p/2|p>>X-1|p>>X|p>>X+1];p*=2
O=lambda a:m&reduce(lambda x,y:x|y,a,0)
print len(L)-min(bin(i).count('1')for i in range(1<<len(L))if O(L)==O(x for j,x in enumerate(L)if i>>j&1))

बिटमास्क का उपयोग कर काम करता है। Lरोशनी की एक सूची है, जहां प्रत्येक प्रकाश को उसके प्रकाश पैटर्न के लिए निर्धारित 9 बिट्स के साथ (ऊपर तक) एक पूर्णांक द्वारा दर्शाया जाता है। फिर हम पूरी तरह से इस सूची के सबसेट की खोज करते हैं, जिसकी बिटवाइज़-या बिटवाइज़-या पूरी सूची के समान होती है। सबसे छोटा उप विजेता विजेता है।

m एक मुखौटा है जो शिफ्टिंग के दौरान बिट्स के आवरण को रोकता है।


कृपया एक प्रोग्राम प्रदान करने का प्रयास करें जो सही ढंग से चलता हो। जावा / सी++ किसी भी तरह के इंडेंटेशन या स्पेसिंग के लिए सुरक्षित हैं लेकिन पायथन नहीं है। कोडिंग या शॉर्टिंग कोड एक और बात है लेकिन एक प्रोग्राम प्रदान करना जो नहीं चलता है वह दूसरा है।
user2369284

3
@ user2369284 आप किस बारे में बात कर रहे हैं ?! यह पूरी तरह से ठीक काम करता है (अजगर 2 के साथ)
एडिट्स ने छोड़ दिया क्योंकि एसई ईवीआईएल

@aditsu I में अजगर 3 है
user2369284

1
@ user2369284 अच्छी तरह से, प्रिंट सिंटैक्स अलग है, इसलिए यह अजगर 3 में विफल रहता है
विज्ञापन छोड़ दिया क्योंकि एसई EVIL

3

जावा 6 - 509 बाइट्स

मैंने इस समय सीमा के बारे में कुछ धारणाएँ बनाईं और समस्या को हल किया।

import java.util.*;enum F{X;{Scanner s=new Scanner(System.in);int m=s.nextInt(),n=s.nextInt(),i=m,j,k=0,l=0,r=0,o,c,x[]=new int[30],y[]=x.clone();int[][]a=new
int[99][99],b;while(i-->0){String t=s.next();for(j=n;j-->0;)if(t.charAt(j)>48){x[l]=i;y[l++]=j;}}for(;k<l;++k)for(i=9;i-->0;)a[x[k]+i/3][y[k]+i%3]=1;for(k=1<<l;k-->0;){b=new
int[99][99];for(j=c=l;j-->0;)if((k&1<<j)>0)for(c--,i=9;i-->0;)b[x[j]+i/3][y[j]+i%3]=1;for(o=i=0;i++<m;)for(j=0;j++<n;)o|=a[i][j]^b[i][j];r=c-o*c>r?c:r;}System.out.println(r);}}

इस तरह से चलाएं: java F <inputfile 2>/dev/null


बिल्कुल छोटा नहीं है, लेकिन एक डिस्क क्षेत्र में फिट बैठता है: पी मैं बाद में एक अलग भाषा की कोशिश कर सकता हूं।
एडित्सू ने छोड़ दिया क्योंकि SE

@aditsu खिड़कियों पर यह काम कैसे करें?
user2369284

1
@ user2369284: मैं नहीं देखता कि आप केवल 2 लैंप के साथ 0011111100 कैसे कर सकते हैं। आपको प्रकाश के साथ 8 कोशिकाओं को कवर करने की आवश्यकता है, और प्रत्येक दीपक अधिकतम 3 पर कर सकते हैं
कीथ रान्डेल

@ user2369284 शायद java F <inputfile 2>nul, अगर वह विफल रहता है java F <inputfileऔर अपवाद को अनदेखा करता है। इसके अलावा यह जावा 7 के साथ नहीं चलेगा
एडिट्स ने छोड़ दिया क्योंकि एसई ईवीआईएल

@aditsu मैं वास्तव में माफी चाहता हूँ। यह एक टाइपो त्रुटि थी। आपका प्रोग्राम सही तरीके से काम करता है।
user2369284

1

सी ++ - 477 बाइट्स

#include <iostream>
using namespace std;int main(){
int c,i,j,m,n,p,q=0;cin>>m>>n;
int f[m*n],g[m*n],h[9]={0,-1,1,-m-1,-m,-m+1,m-1,m,m+1};
for(i=0;i<m*n;i++){f[i]=0;g[i]=0;do{c=getchar();f[i]=c-48;}while(c!='0'&&c!='1');}
for(i=0;i<m*n;i++)if(f[i])for(j=0;j<9;j++)if(i+h[j]>=0&&i+h[j]<m*n)g[i+h[j]]++;
for(i=0;i<m*n;i++)if(f[i]){p=0;for(j=0;j<9;j++)if(i+h[j]>=0&&i+h[j]<m*n)if(g[i+h[j]]<2)p++;if(p==0){for(j=0;j<9;j++)if(i+h[j]>=0&&i+h[j]<m*n)g[i+h[j]]--;q++;}}cout<<q<<endl;}

1

रूबी, 303

[यह प्रश्न के पिछले संस्करण का जवाब देने के लिए कोडित किया गया था; नीचे पढ़ें नोट]

def b(f,m,n,r)b=[!1]*1e6;(n..n+m*n+m).each{|i|b[i-n-2,3]=b[i-1,3]=b[i+n,3]=[1]*3if f[i]};b[r*n+r+n+1,n];end
m,n=gets.split.map(&:to_i)
f=[!1]*n
m.times{(?0+gets).chars{|c|f<<(c==?1)if c>?*}}
f+=[!u=0]*n*n
f.size.times{|i|g=f.dup;g[i]?(g[i]=!1;u+=1if m.times{|r|break !1if b(f,m,n,r)!=b(g,m,n,r)}):0}
p u

बूलियंस के सरणियों में बदलना और फिर परिवर्तनों के लिए पड़ोस की तुलना करना।

सीमा (?): अधिकतम खेत क्षेत्र का आकार 1,000 x 1,000 है। समस्या बताती है "किसान जैक बहुत गरीब है" इसलिए मैं मान रहा हूं कि उसका खेत बड़ा नहीं है। ;-) सीमा को 2 वर्ण जोड़कर हटाया जा सकता है।

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


1

एपीएल, 97 चार्ट / बाइट्स *

एक ⎕IO←1और ⎕ML←3APL वातावरण मानता है।

m←{s↑⊃∨/,v∘.⊖(v←⍳3)⌽¨⊂0⍪0⍪0,0,s⍴⍵}⋄n-⌊/+/¨t/⍨(⊂m f)≡¨m¨(⊂,f)\¨t←⊂[1](n⍴2)⊤⍳2*n←+/,f←⍎¨⊃{⍞}¨⍳↑s←⍎⍞

Ungolfed संस्करण:

s ← ⍎⍞                                         ⍝ read shape of field
f ← ⍎¨ ⊃ {⍞}¨ ⍳↑s                              ⍝ read original field (lamp layout)
n ← +/,f                                       ⍝ original number of lamps
c ← ⊂[1] (n⍴2) ⊤ ⍳2*n                          ⍝ all possible shutdown combinations
m ← {s↑ ⊃ ∨/ ,v ∘.⊖ (v←⍳3) ⌽¨ ⊂ 0⍪0⍪0,0, s⍴⍵}  ⍝ get lighted cells given a ravelled field
l ← m¨ (⊂,f) \¨ c                              ⍝ map of lighted cells for every combination
k ← c /⍨ (⊂ m f) ≡¨ l                          ⍝ list of successful combinations
u ← ⌊/ +/¨ k                                   ⍝ min lamps used by a successful comb.
⎕ ← n-u                                        ⍝ output number of useless lamps

⎕ ← s⍴ ⊃ (⊂,f) \¨ (u= +/¨ k) / k               ⍝ additional: print the layout with min lamps

मैं मानता हूं कि अधिक परीक्षण मामले बेहतर होंगे। यहाँ एक यादृच्छिक है:

इनपुट:

5 5
10001
01100
00001
11001
00010

आउटपुट (बेकार लैंप):

5

न्यूनतम लैंप के साथ लेआउट (गोल्फ संस्करण में शामिल नहीं):

0 0 0 0 1
0 1 0 0 0
0 0 0 0 0
0 1 0 0 1
0 0 0 0 0

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: APL को अपनी (विरासत) सिंगल-बाइट चारसेट में लिखा जा सकता है जो APL प्रतीकों को ऊपरी 128 बाइट मानों में मैप करता है। इसलिए, स्कोरिंग के उद्देश्य से, N वर्णों का एक प्रोग्राम जो केवल ASCII वर्णों और APL प्रतीकों का उपयोग करता है, को N बाइट्स माना जा सकता है।


0

सी ++ 5.806 बाइट्स

यह आकार के लिए अभी तक अनुकूलित नहीं है। लेकिन जब से कुछ प्रतियोगी हैं मैं इसे अभी के लिए छोड़ दूंगा।

फार्मरफिल्ड हैडर:

#pragma once

namespace FarmersLand
{

class FarmersField
{
private:
    unsigned _m_size, _n_size;
    int * _lamp, * _lumination;
    char * _buffer;
    void _illuminate(unsigned m, unsigned n);
    void _deluminate(unsigned m, unsigned n);
    void _removeLamp(unsigned m, unsigned n);
    void _setLamp(unsigned m, unsigned n);
    int _canRemoveLamp(unsigned m, unsigned n);
    int _coordsAreValid(unsigned m, unsigned n);
    int _getLuminationLevel(unsigned m, unsigned n);
    int * _allocIntArray(unsigned m, unsigned n);
    int _coordHelper(unsigned m, unsigned n);
public:
    FarmersField(char * input[]);
    FarmersField(const FarmersField & field);
    ~FarmersField(void);
    int RemoveLamps(void);
    char * Cstr(void);
};

}

फार्मरफिल्ड सीपीपी:

#include "FarmersField.h"
#include <stdio.h>


namespace FarmersLand
{

void FarmersField::_illuminate(unsigned m, unsigned n)
{
    if(this -> _coordsAreValid(m,n))
    {
        ++this -> _lumination[this -> _coordHelper(m,n)];
    }
}

void FarmersField::_deluminate(unsigned m, unsigned n)
{
    if(this -> _coordsAreValid(m,n))
    {
        --this -> _lumination[this -> _coordHelper(m,n)];
    }
}

void FarmersField::_removeLamp(unsigned m, unsigned n)
{
    if(this -> _coordsAreValid(m,n))
    {
        unsigned mi_start = (m == 0) ? 0 : m - 1;
        unsigned mi_end = m + 1;
        unsigned ni_start = (n == 0) ? 0 : n - 1;
        unsigned ni_end = n + 1;

        for(unsigned mi = mi_start; mi <= mi_end; ++mi)
        {
            for(unsigned ni = ni_start; ni <= ni_end; ++ni)
            {
                this -> _deluminate(mi, ni);
            }
        }
        --this -> _lamp[this -> _coordHelper(m,n)];
    }
}

void FarmersField::_setLamp(unsigned m, unsigned n)
{
    if(this -> _coordsAreValid(m,n))
    {
        unsigned mi_start = (m == 0) ? 0 : m - 1;
        unsigned mi_end = m + 1;
        unsigned ni_start = (n == 0) ? 0 : n - 1;
        unsigned ni_end = n + 1;

        for(unsigned mi = mi_start; mi <= mi_end; ++mi)
        {
            for(unsigned ni = ni_start; ni <= ni_end; ++ni)
            {
                this -> _illuminate(mi, ni);
            }
        }
        ++this -> _lamp[this -> _coordHelper(m,n)];
    }
}

int FarmersField::_canRemoveLamp(unsigned m, unsigned n)
{
    unsigned can = 1;
    unsigned mi_start = (m == 0) ? 0 : m - 1;
    unsigned mi_end =   (m == (this->_m_size - 1)) ? m : m + 1;
    unsigned ni_start = (n == 0) ? 0 : n - 1;
    unsigned ni_end =   (n == (this->_n_size - 1)) ? n : n + 1;

    for(unsigned mi = mi_start; mi <= mi_end; ++mi)
    {
        for(unsigned ni = ni_start; ni <= ni_end; ++ni)
        {
            if( 1 >= this -> _getLuminationLevel(mi, ni) )
            {
                can = 0;
            }
        }
    }
    return can;
}

int FarmersField::_coordsAreValid(unsigned m, unsigned n)
{
    return m < this -> _m_size && n < this -> _n_size;
}

int FarmersField::_getLuminationLevel(unsigned m, unsigned n)
{
    if(this -> _coordsAreValid(m,n))
    {
        return this -> _lumination[this -> _coordHelper(m,n)];
    }
    else
    {
        return 0;
    }
}

int * FarmersField::_allocIntArray(unsigned m, unsigned n)
{
    int * a = new int[m * n];
    for(unsigned i = 0; i < m*n; ++i)
    {
        a[i] = 0;
    }
    return a;
}

int FarmersField::_coordHelper(unsigned m, unsigned n)
{
    return m * this -> _n_size + n;
}

int FarmersField::RemoveLamps(void)
{
    int r = 0;
    for(unsigned m = 0 ; m < this -> _m_size; ++m)
    {
        for(unsigned n = 0 ; n < this -> _n_size; ++n)
        {
            if(this -> _canRemoveLamp(m,n))
            {
                ++r;
                this -> _removeLamp(m,n);
            }
        }
    }
    return r;
}

char * FarmersField::Cstr(void)
{
    unsigned size = this -> _m_size * this -> _n_size + _m_size ;
    unsigned target = 0;
    delete(this -> _buffer);
    this -> _buffer = new char[ size ];
    for(unsigned m = 0 ; m < this -> _m_size; ++m)
    {
        for(unsigned n = 0 ; n < this -> _n_size; ++n)
        {
            this -> _buffer[target++] =  (0 == this -> _lamp[this -> _coordHelper(m,n)])? '0' : '1';
        }
        this -> _buffer[target++] = '-'; 
    }
    this -> _buffer[size - 1 ] = 0;
    return this -> _buffer;
}

FarmersField::FarmersField(char * input[])
{
    sscanf_s(input[0], "%u %u", &this -> _m_size, &this -> _n_size);

    this -> _lamp = this -> _allocIntArray(this -> _m_size, this -> _n_size);
    this -> _lumination = this -> _allocIntArray(this -> _m_size, this -> _n_size);
    this -> _buffer = new char[1];

    for(unsigned m = 0 ; m < this -> _m_size; ++m)
    {
        for(unsigned n = 0 ; n < this -> _n_size; ++n)
        {
            if('0' != input[m+1][n])
            {
                this -> _setLamp(m,n);
            }
        }
    }
}

FarmersField::FarmersField(const FarmersField & field)
{
    this -> _m_size = field._m_size;
    this -> _n_size = field._n_size;

    this -> _lamp = this -> _allocIntArray(this -> _m_size, this -> _n_size);
    this -> _lumination = this -> _allocIntArray(this -> _m_size, this -> _n_size);
    this -> _buffer = new char[1];

    for(unsigned m = 0 ; m < this -> _m_size; ++m)
    {
        for(unsigned n = 0 ; n < this -> _n_size; ++n)
        {
            if(0 != field._lamp[this -> _coordHelper(m,n)])
            {
                this -> _setLamp(m,n);
            }
        }
    }

}

FarmersField::~FarmersField(void)
{
    delete(this -> _lamp);
    delete(this -> _lumination);
    delete(this -> _buffer);
}

}

और यह दिखाने के लिए परीक्षणों का एक सेट कि कोड वह करता है जो इसे करने के लिए बनाया गया था:

#include "../../Utility/GTest/gtest.h"

#include "FarmersField.h"

TEST(FarmersField, Example1) 
{
    using namespace FarmersLand;
    char * input[] = {"3 3", "100", "010", "001"};
    FarmersField f(input);
    EXPECT_STREQ("100-010-001", f.Cstr());
    EXPECT_EQ(2, f.RemoveLamps());
    EXPECT_STREQ("000-010-000", f.Cstr());
}

TEST(FarmersField, Example2) 
{
    using namespace FarmersLand;
    char * input[] = {"3 6", "100000", "010000", "001000"};
    FarmersField f(input);
    EXPECT_STREQ("100000-010000-001000", f.Cstr());
    EXPECT_EQ(1, f.RemoveLamps());
    EXPECT_STREQ("000000-010000-001000", f.Cstr());
 }

TEST(FarmersField, Example3) 
{
    using namespace FarmersLand;
    char * input[] = {"6 3", "100", "010", "001", "000", "000", "000",};
    FarmersField f(input);
    EXPECT_STREQ("100-010-001-000-000-000", f.Cstr());
    EXPECT_EQ(1, f.RemoveLamps());
    EXPECT_STREQ("000-010-001-000-000-000", f.Cstr());
 }

TEST(FarmersField, Example4) 
{
    using namespace FarmersLand;
    char * input[] = {"3 3", "000", "000", "000",};
    FarmersField f(input);
    EXPECT_STREQ("000-000-000", f.Cstr());
    EXPECT_EQ(0, f.RemoveLamps());
    EXPECT_STREQ("000-000-000", f.Cstr());
 }

TEST(FarmersField, Example5) 
{
    using namespace FarmersLand;
    char * input[] = {"3 3", "111", "111", "111",};
    FarmersField f(input);
    EXPECT_STREQ("111-111-111", f.Cstr());
    EXPECT_EQ(8, f.RemoveLamps());
    EXPECT_STREQ("000-010-000", f.Cstr());
 }

TEST(FarmersField, Example6) 
{
    using namespace FarmersLand;
    char * input[] = {"6 6", "100001", "001010", "001001", "001010", "110000", "100001",};
    FarmersField f(input);
    EXPECT_STREQ("100001-001010-001001-001010-110000-100001", f.Cstr());
    EXPECT_EQ(6, f.RemoveLamps());
    EXPECT_STREQ("100011-001010-000000-000010-010000-000001", f.Cstr());
 }

कृपया परीक्षण उपयोगिता प्रदान करें जो बाहरी पुस्तकालयों का उपयोग करती है।
user2369284


0

पर्ल 3420 बाइट्स

एक गोल्फ समाधान नहीं है, लेकिन मुझे यह समस्या दिलचस्प लगी:

#!/usr/bin/perl
use strict;
use warnings; 

{
   package Farm; 
   use Data::Dumper; 

   # models 8 nearest neighbors to position i,j forall i,j
   my $neighbors = [ [-1, -1],
                     [-1,  0],
                     [-1, +1], 
                     [ 0, -1], 
                     # current pos 
                     [ 0,  1], 
                     [+1, -1], 
                     [+1,  0], 
                     [+1, +1] ];

   sub new { 
      my ($class, %attrs) = @_; 
      bless \%attrs, $class;
   }  

   sub field { 
      my $self = shift;
      return $self->{field};
   }

   sub rows {
      my $self = shift;
      return $self->{rows};
   }

   sub cols {
      my $self = shift;
      return $self->{cols};
   }
   sub adjacents {
      my ($self, $i, $j) = @_;

      my @adjs; 
   NEIGHBORS:
      for my $neighbor ( @$neighbors ) {
         my ($imod, $jmod) = ($neighbor->[0] + $i, $neighbor->[1] + $j); 
         next NEIGHBORS 
            if $imod >= $self->rows || $jmod >= $self->cols;

         # push neighbors
         push @adjs, 
            $self->field->[$imod]->[$jmod];

      }

      return @adjs;
   }

   sub islit { 
      my ($lamp) = @_;

      return defined $lamp && $lamp == 1;
   }

   sub can_remove_lamp { 
      my ($self, $i, $j) = @_; 

      return scalar grep { islit($_) } $self->adjacents($i, $j);
   }

   sub remove_lamp { 
      my ($self, $i, $j) = @_;

      $self->field->[$i]->[$j] = 0;
   }

   sub remove_lamps {
      my ($self) = @_; 

      my $removed = 0;
      for my $i ( 0 .. @{ $self->field } - 1) {
         for my $j ( 0 .. @{ $self->field->[$i] } - 1 ) { 
            next unless islit( $self->field->[$i]->[$j] ); 

            if( $self->can_remove_lamp($i, $j) ) {
               $removed++; 
               $self->remove_lamp($i, $j);
            }
         }
      }

      return $removed;
   }

   1;
}

{ # Tests
   use Data::Dumper;
   use Test::Deep;
   use Test::More; 

   { # 3x3 field
      my $farm = Farm->new( rows  => 3,
                            cols  => 3,
                            field => [ [1,0,0],
                                       [0,1,0],
                                       [0,0,1]
                                     ]
      );

      is( 2, 
          $farm->remove_lamps,
          'Removed 2 overlapping correctly'
      );

      is_deeply( $farm->field, 
                 [ [0,0,0],
                   [0,0,0],
                   [0,0,1],
                 ],
                 'Field after removing lamps matches expected'
      );

   }

   { # 5x5 field
      my $farm = Farm->new( rows  => 5,
                            cols  => 5,
                            field => [ [0,0,0,0,0],
                                       [0,1,0,0,0],
                                       [0,0,1,0,0],
                                       [0,0,0,0,0],
                                       [0,0,0,0,0]
                                     ]
      );

      is( 1, 
          $farm->remove_lamps,
          'Removed 1 overlapping lamp correctly'
      );

      is_deeply( $farm->field,
                 [ [0,0,0,0,0],
                   [0,0,0,0,0],
                   [0,0,1,0,0],
                   [0,0,0,0,0],
                   [0,0,0,0,0],
                 ],
                 'Field after removing lamps matches expected'
      );
   }
}

(I / O को बाहर निकाला गया ताकि मैं ठोस परीक्षण दिखा सकूं)


0

पायथन - 305 बाइट्स

import sys,itertools
w,h=map(int,input().split());w+=1
l=[i for i,c in enumerate(sys.stdin.read())if c=="1"]
f=lambda l:{i+j for i in l for j in(0,1,-1,w-1,w,w+1,1-w,-w,-w-1)if(i+j+1)%w}&set(range(w*h))
for n in range(1,len(l)):
 for c in itertools.combinations(l,n):
  if f(c)^f(l):print(len(l)-n);exit()
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.