কৃষককে সহায়তা করা


10

কৃষক জ্যাক খুব দরিদ্র। তিনি তার পুরো খামারটি আলোকিত করতে চান তবে সর্বনিম্ন ব্যয় সহ। একটি বাতি তার আটটি প্রতিবেশীর পাশাপাশি নিজস্ব কক্ষ আলোকিত করতে পারে। তিনি তার জমিতে প্রদীপগুলি সাজিয়েছেন তবে তিনি কোনও অতিরিক্ত প্রদীপ রেখেছেন কিনা তা জানতে আপনার সহায়তা প্রয়োজন।

অতিরিক্ত ল্যাম্প: ল্যাম্পগুলি যা খামার থেকে সরিয়ে নেওয়ার সাথে সাথে আলোকিত কক্ষের সংখ্যার কোনও পার্থক্য হবে না। এছাড়াও, আপনি যে বাতিগুলি চিহ্নিত করবেন সেগুলি এক এক করে সরানো হবে না, তবে সেগুলি একই সাথে সরানো হবে।

দ্রষ্টব্য: আপনি প্রদত্ত একমাত্র ক্রিয়াটি হ'ল কয়েকটি প্রদীপ মুছে ফেলা। আপনি ল্যাম্পগুলি পুনরায় সাজানো বা সন্নিবেশ করতে পারবেন না। আপনার চূড়ান্ত লক্ষ্যটি হ'ল সর্বাধিক সংখ্যক প্রদীপগুলি সরিয়ে ফেলা যা এর আগে প্রদত্ত প্রতিটি কক্ষটি এখনও জ্বলানো থাকে।

কৃষক জ্যাককে সর্বাধিক সংখ্যক অকেজো প্রদীপ চিহ্নিত করতে সহায়তা করুন যাতে সে সেগুলি অন্য কোথাও ব্যবহার করতে পারে।

ইনপুট

আপনাকে ক্ষেত্রের প্রথম লাইন মাত্রায় এম এবং এন দেওয়া হবে e নেক্সট এম লাইনগুলি প্রতিটি ক্ষেত্রের প্রতিনিধিত্ব করে এমন প্রতিটি এন অক্ষর ধারণ করে।

'1' এমন কক্ষ উপস্থাপন করে যেখানে প্রদীপটি রাখা হয়।

'0' একটি খালি ঘর উপস্থাপন করে।

আউটপুট

আপনাকে বেহুদা প্রদীপের সংখ্যা সহ একটি পূর্ণসংখ্যার আউটপুট দিতে হবে।

নমুনা ইনপুট:

3 3
100
010
001

নমুনা আউটপুট:

2

বিজয়ী:

যেহেতু এটি কোড গল্ফ, তাই বিজয়ী হবেন যিনি কমপক্ষে কয়েকটি অক্ষরে সফলভাবে কাজটি সম্পন্ন করবেন


@ পিটারটেলর আমি আমার পোস্ট সম্পাদনা করেছি। আপনার কি এখনও একটা বিভ্রান্তি আছে?
ব্যবহারকারী 2369284

অনেক ভাল. ধন্যবাদ।
পিটার টেলর

আমরা কি অনুমান করতে পারি ইনপুটটি একটি নতুন লাইন দিয়ে শেষ হবে?
জন ডিভোরাক

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 এর ম্যাট্রিকগুলি হ্যান্ডেল করতে পারে এবং আরও বড় (নীচে দেখুন)। এটি একটি একক সমাধান দেয়, তবে এটি অপটিমাল কিনা তা অজানা। উভয় পন্থা, গল্ফযুক্ত সংস্করণগুলিতে, অব্যবহৃত আলোগুলির সংখ্যা প্রদান করে। নীচে যেমন-গল্ফযুক্ত পদ্ধতিগুলি গ্রিডগুলিও প্রদর্শন করে as

আগে:

আগে

পরে:

পরে

সমস্ত আলোকসজ্জার (224 টি অক্ষর) ব্যবহার করে অনুকূল সমাধানগুলি

ধন্যবাদ @ ক্ল্যামেন্টের সাথে।

আলোকসজ্জার সমস্ত সংমিশ্রণ ব্যবহার করে অসম্পূর্ণ সংস্করণ

f sameCoverageQআলোকিত রূপান্তর ফাংশনটি লিটার হিসাবে ব্যবহার করা হয় (শূন্যের পরিবর্তে মান = 1) 3 এক্স 3 বর্গ যেখানে প্রতিটি আলো থাকে। খামারটি গণনা করা হয়েছে; একাধিক প্রদীপের দ্বারা প্রজ্জিত একটি বর্গক্ষেত্রটি কেবল প্রজ্বলিত হয় program প্রোগ্রামটি প্রতিটি আলো বন্ধ করে দেয় এবং ফার্মের সামগ্রিক আলোক কভারেজ হ্রাস পেয়েছে কিনা তা পরীক্ষা করে দেখায় it যদি এটি না হয় তবে সেই আলো অপসারণ করা হয়।

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-তে লিটার কোষের সমান কিনা তা পরীক্ষা করে M রূপকেন্দ্রিক ট্রান্সফর্ম [[মাদুর] লাইটের একটি ম্যাট্রিক্স গ্রহণ করে এবং তারা আলোকিত করে এমন কোষগুলির একটি ম্যাট্রিক্স প্রদান করে।

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 তে লিটার কোষগুলি ম্যাট 2.t এর লিটার কোষের সমান কিনা তা পরীক্ষা করে [[মাদুর] একটি ম্যাট্রিক্স লাইট নেয় এবং তারা আলোকিত করে এমন কোষগুলির একটি ম্যাট্রিক্স প্রদান করে।

c[j]জে থেকে সমস্ত আলোকসজ্জা নেয় এবং কভারেজের জন্য তাদের পরীক্ষা করে। যাদের সর্বাধিক কভারেজ রয়েছে তাদের মধ্যে এটি সবচেয়ে কম হালকা বাল্ব রয়েছে এমনগুলি নির্বাচন করে। এগুলির প্রত্যেকটিই একটি অনুকূল সমাধান।

উদাহরণ 2

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

গ্রিড

একই আলো কভারেজ থাকার সময় দুটি লাইট সংরক্ষণ করা যায়। সেমি]

2


আমার হাতে ম্যাথামেটিকা ​​নেই তাই আমি এই কোডটি পরীক্ষা করতে পারছি না, তবে আমি মনে করি আপনার অ্যালগরিদমটি ভুল - যদি না আমি আপনার ব্যাখ্যাগুলি ভুল বুঝে। যদি আমার বোধগম্যতা সঠিক হয় তবে এটি একটি লোভী কৌশলটির উপর নির্ভর করে যা আলো প্রক্রিয়াকরণের ক্রমে নির্ভর করে: উদাহরণস্বরূপ, আপনার 3 * 3 পরীক্ষার ক্ষেত্রে মাঝের প্রদীপ থেকে শুরু করা এটি সরিয়ে ফেলবে এবং দুটি পাশের প্রদীপ ছেড়ে যাবে। আমি আশা করি না যে আপনি বাস্তবায়নের ক্ষেত্রে যে নির্দিষ্ট ক্রমটি ব্যবহার করছেন সেটি এটি সঠিক করে তোলে তবে এই মুহূর্তে আমার কোনও পাল্টা উদাহরণ নেই।
ক্লিমেট

আপনার ধারণাটি দেখে মনে হচ্ছে যে মূল সেটআপে 2 টি অতিরিক্ত অতিরিক্ত আলোকসজ্জা, ক, খ থাকা সম্ভব হতে পারে যার মধ্যে একটি অপরটির চেয়ে বেশি অতিরিক্ত অতিরিক্ত lu সুতরাং, এটি হতে পারে যে কোনওটিকে অপসারণ করা হলে (প্রথম) উন্নততর অর্থনীতি অর্জন করা সম্ভব। আমি বুঝতে পারি যে মোট 3 টি লাইটের সাথে এটি ঘটতে পারে নি, তবে এটি সম্ভবত বৃহত সংখ্যক আলো সহ সম্ভব হতে পারে। আমি মূলত সমস্ত আলোকসজ্জা পরীক্ষা করে সমস্যাটি সমাধান করেছি। এটি অবশ্যই সর্বোত্তম এবং এইভাবে আদর্শ, তবে আমি এটি লাইটের একটি বিশাল সেট দিয়ে অযৌক্তিক বলে মনে করি।
ডেভিডসি

@ ক্লিমেন্ট আমি এমন একটি সমাধান নিয়ে কাজ করছি যা সমস্ত সম্ভাব্য সংমিশ্রণ পরীক্ষা করবে। কিছুক্ষণ সময় নেবে ...
ডেভিডসি

এটি নিশ্চিত হবে;) তবে এটি প্রত্যাশা করা উচিত: যেহেতু এটি দাঁড়িয়েছে এই সমস্যাটি ন্যূনতম সেট কভারের একটি উদাহরণ - যা এনপি। অতিরিক্ত অনুমানগুলি (পার্শ্বযুক্তগুলি বাদে প্রায় সমস্ত কভারিং সেটগুলি একই কার্ডিনালিটি থাকতে পারে) দক্ষ দক্ষতার জন্য বাস্তবায়ন করার অনুমতি দেয় কিনা তা আকর্ষণীয় সমস্যা though
ক্লাইমেন্ট

আমি দৃ strongly়ভাবে সন্দেহ করি যে লোভী সমাধানটি সঠিক কিনা আপনি যদি সারি এবং কলামগুলি অনুসারে ক্রমে যান তবে আমি এখনও এটি প্রমাণ করি নি।
অ্যাডিটসু ছেড়ে গেছে কারণ এসই এভিল

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 এমন একটি মুখোশ যা স্থানান্তরিত হওয়ার সময় বিটগুলির মোড়ক রোধ করে।


দয়া করে এমন কোনও প্রোগ্রাম সরবরাহ করার চেষ্টা করুন যা সঠিকভাবে চলমান।
ব্যবহারকারী 2369284

3
@ ব্যবহারকারী 2369284 আপনি কী সম্পর্কে কথা বলছেন ?! এটি পুরোপুরি সূক্ষ্মভাবে কাজ করে (পাইথন 2 সহ)
এডিটসু প্রস্থান করুন কারণ এসই ইভিল

@ এডিটসু আমার অজগর 3 আছে
ব্যবহারকারী 2369284

1
@ ব্যবহারকারী 2369284 ভাল, মুদ্রণ সিনট্যাক্সটি আলাদা তাই এটি অজগর 3 এ ব্যর্থ হয়
অদিতসু প্রস্থান করুন কারণ এসই এভিল

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


হুবহু সংক্ষিপ্ত নয়, তবে এটি একটি ডিস্ক সেক্টরে ফিট করে: পি আমি পরে কোনও ভিন্ন ভাষা চেষ্টা করতে পারি।
অ্যাডিটসু ছেড়ে গেছে কারণ এসই এভিল

@ অ্যাডিটস উইন্ডোতে এই কাজটি কীভাবে করবেন?
ব্যবহারকারী 2369284

1
@ ব্যবহারকারী 2369284: আমি কেবল 2 টি প্রদীপ দিয়ে 0011111100 কীভাবে করতে পারি তা আমি দেখতে পাচ্ছি না। আপনাকে আলোর সাথে 8 টি কক্ষকে আচ্ছাদন করতে হবে এবং প্রতিটি প্রদীপ সর্বাধিক 3 টি করতে পারে
কেথ র্যান্ডাল

@ ব্যবহারকারী 2369284 সম্ভবত java F <inputfile 2>nul, যদি তা ব্যর্থ হয় java F <inputfileএবং ব্যতিক্রমটি উপেক্ষা করে। এছাড়াও এটি জাভা with দিয়ে চলবে না
ad

@ অ্যাডিটসু আমি সত্যিই দুঃখিত hat এটি টাইপোর ত্রুটি ছিল। আপনার প্রোগ্রামটি সঠিকভাবে কাজ করে।
ব্যবহারকারী 2369284

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

এপিএল, ৯rs টি চর / বাইট *

একটি ⎕IO←1এবং ⎕ML←3এপিএল পরিবেশ ধরে।

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

অবরুদ্ধ সংস্করণ:

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

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯ *: এপিএল নিজস্ব (লিগ্যাসি) একক বাইট অক্ষরে
লেখা যেতে পারে যা এপিএল প্রতীকগুলিকে উপরের 128 বাইট মানগুলিতে মানচিত্র করে। সুতরাং, স্কোর করার উদ্দেশ্যে, এন চরগুলির একটি প্রোগ্রাম যা কেবলমাত্র ASCII অক্ষর এবং এপিএল প্রতীক ব্যবহার করে 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());
 }

দয়া করে একটি পরীক্ষামূলক ইউটিলিটি সরবরাহ করুন যা বাহ্যিক গ্রন্থাগারগুলি ব্যবহার করে।
ব্যবহারকারী 2369284

এটি জিটিস্ট: কোড. google.com/p/googletest/downloads/list
জোহানেস

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()
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.