Giúp nông dân


10

Nông dân Jack rất nghèo. Anh ấy muốn thắp sáng toàn bộ trang trại của mình nhưng với chi phí tối thiểu. Một chiếc đèn có thể chiếu sáng tế bào của chính nó cũng như tám người hàng xóm của nó. Anh ấy đã sắp xếp các đèn trong lĩnh vực của mình nhưng anh ấy cần sự giúp đỡ của bạn trong việc tìm hiểu xem anh ấy có giữ thêm đèn không.

Đèn bổ sung: Đèn được tháo ra khỏi trang trại sẽ không có sự khác biệt so với số lượng tế bào được thắp sáng. Ngoài ra, các đèn bạn sẽ chỉ sẽ không được loại bỏ từng cái một, nhưng chúng sẽ bị loại bỏ đồng thời.

Lưu ý: Hành động duy nhất bạn có thể thực hiện là loại bỏ một số đèn. Bạn không thể sắp xếp lại cũng không chèn đèn. Mục tiêu cuối cùng của bạn là loại bỏ số lượng đèn tối đa sao cho mọi ô được thắp sáng trước đó vẫn sáng.

Giúp nông dân Jack phát hiện số lượng đèn vô dụng tối đa để anh ta có thể sử dụng chúng ở nơi khác.

Đầu vào

Bạn sẽ được cung cấp các kích thước dòng đầu tiên của trường MN .Next M dòng theo sau chứa N ký tự đại diện cho trường.

'1' đại diện cho ô nơi giữ đèn.

'0' đại diện cho một ô trống.

Đầu ra

Bạn phải xuất ra một số nguyên chứa số lượng đèn vô dụng.

Đầu vào mẫu:

3 3
100
010
001

Đầu ra mẫu:

2

Người chiến thắng:

Vì là môn đánh gôn, người chiến thắng sẽ là người hoàn thành xuất sắc nhiệm vụ với số lượng nhân vật ít nhất


@PeterTaylor Tôi đã chỉnh sửa bài viết của mình. Bạn vẫn có một sự nhầm lẫn?
dùng2369284

Tốt hơn nhiều. Cảm ơn.
Peter Taylor

chúng ta có thể giả sử đầu vào kết thúc với một dòng mới?
John Dvorak

1
Điều này trông giống như bài tập về nhà.
Johannes

1
Chúng tôi có đảm bảo rằng đèn đầu vào sẽ thắp sáng cả trang trại không? Tôi sẽ đoán không ...
Keith Randall

Câu trả lời:


5

Mathicala 186 (tham lam) và 224 (tất cả các kết hợp)

Giải pháp tham lam

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]

Điều này tắt từng cái đèn thừa. Nếu độ che phủ của ánh sáng không bị giảm khi ánh sáng tắt, ánh sáng đó có thể bị loại bỏ. Cách tiếp cận tham lam rất nhanh và có thể dễ dàng xử lý các ma trận 15x15 và lớn hơn nhiều (xem bên dưới). Nó trả về một giải pháp duy nhất, nhưng không biết liệu điều đó có tối ưu hay không. Cả hai cách tiếp cận, trong các phiên bản golf, trả lại số lượng đèn không sử dụng. Phương pháp tiếp cận không chơi gôn cũng hiển thị các lưới, như dưới đây.

Trước:

trước

Sau:

sau

Giải pháp tối ưu bằng cách sử dụng tất cả các kết hợp đèn (224 ký tự)

Cảm ơn @ Clément.

Phiên bản Ungolfed sử dụng tất cả các kết hợp đèn

f Hàm biến đổi hình thái được sử dụng trong sameCoverageQxử lý như lit (value = 1 thay vì 0) hình vuông 3 x3 trong đó mỗi ánh sáng cư trú. Khi một ánh sáng ở gần rìa trang trại, chỉ có các hình vuông (nhỏ hơn 9) trong các viền của trang trại được tính. Không có quá nhiều; một hình vuông được thắp sáng bởi nhiều hơn một đèn chỉ đơn giản là được thắp sáng. Chương trình tắt từng đèn và kiểm tra xem liệu độ che phủ tổng thể trong trang trại có bị giảm hay không. Nếu không, ánh sáng đó sẽ bị loại bỏ.

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]đếm số lượng tế bào được gắn cờ. Nó được sử dụng để đếm đèn và cũng để đếm các ô sáng

sameCoverageQ[mat1, mat2] kiểm tra xem các ô sáng trong mat1 có bằng số lượng ô được chiếu sáng trong mat2 hay không. Dạng biến đổi [[mat] có ma trận ánh sáng và trả về ma trận của các ô mà chúng sáng lên.

c[m1]lấy tất cả các kết hợp ánh sáng từ m1 và kiểm tra độ che phủ của chúng. Trong số những người có phạm vi bảo hiểm tối đa, nó chọn những người có ít bóng đèn nhất. Mỗi trong số này là một giải pháp tối ưu.


Ví dụ 1:

Thiết lập 6x6

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

nguyên

Tất cả các giải pháp tối ưu.

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

câu trả lời


Phiên bản chơi golf sử dụng tất cả các kết hợp của đèn.

Phiên bản này tính toán số lượng đèn không sử dụng. Nó không hiển thị các lưới.

c trả về số lượng đèn không sử dụng.

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]đếm số lượng tế bào được gắn cờ. Nó được sử dụng để đếm đèn và cũng để đếm các ô sáng

s[mat1, mat2] kiểm tra xem các ô sáng trong mat1 có bằng số lượng ô sáng trong mat2.t [[mat] có ma trận ánh sáng không và trả về ma trận `của các ô mà chúng sáng lên.

c[j]lấy tất cả các kết hợp ánh sáng từ j và kiểm tra chúng cho phạm vi bảo hiểm. Trong số những người có phạm vi bảo hiểm tối đa, nó chọn những người có ít bóng đèn nhất. Mỗi trong số này là một giải pháp tối ưu.

Ví dụ 2

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

lưới điện

Hai đèn có thể được lưu trong khi có phạm vi bao phủ ánh sáng giống nhau. c [m]

2


Tôi không có Mathicala trong tay vì vậy tôi không thể kiểm tra mã này, nhưng tôi nghĩ thuật toán của bạn không chính xác - trừ khi tôi hiểu sai lời giải thích của bạn. Nếu sự hiểu biết của tôi là chính xác, thì nó dựa vào một chiến lược tham lam phụ thuộc vào thứ tự ánh sáng được xử lý: ví dụ, bắt đầu từ đèn giữa trong trường hợp thử nghiệm 3 * 3 của bạn sẽ loại bỏ nó và để lại hai đèn bên. Tôi không hy vọng rằng thứ tự cụ thể mà bạn sử dụng trong quá trình triển khai sẽ làm cho nó chính xác, nhưng tôi không có ví dụ ngược lại ngay bây giờ.
Clément

Ý tưởng của bạn dường như có thể có 2 đèn thừa, a, b, trong thiết lập ban đầu, một trong số đó là thừa hơn so với cái còn lại. Vì vậy, có thể có nền kinh tế tốt hơn đạt được nếu một người bị loại bỏ (đầu tiên). Tôi cảm thấy rằng điều này không thể xảy ra với tổng số 3 đèn, nhưng nó thực sự có thể xảy ra với số lượng đèn lớn hơn. Ban đầu tôi đã giải quyết vấn đề bằng cách thử nghiệm tất cả các kết hợp đèn. Điều này chắc chắn là tối ưu và do đó lý tưởng, nhưng tôi thấy nó không thực tế với một bộ đèn lớn.
DavidC

@ Clément Tôi đang nghiên cứu một giải pháp sẽ kiểm tra tất cả các kết hợp có thể. Sẽ mất một lúc ...
DavidC

Nó chắc chắn sẽ;) Nhưng đó là điều được mong đợi: vì vấn đề này là một trường hợp của trang bìa tối thiểu - đó là NP. Cho dù các giả định bổ sung (hầu hết tất cả các bộ bao gồm, ngoại trừ các bộ bên, có cùng số lượng thẻ) cho phép thực hiện hiệu quả hay không là một vấn đề thú vị.
Clément

Tôi hoàn toàn nghi ngờ giải pháp tham lam là chính xác nếu bạn đi tuần tự theo hàng và cột, nhưng tôi chưa chứng minh được.
aditsu nghỉ việc vì SE là NGÀY

3

Python, 309 ký tự

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

Hoạt động bằng cách sử dụng bitmasks. Llà một danh sách các đèn, trong đó mỗi ánh sáng được biểu thị bằng một số nguyên với (tối đa) 9 bit được đặt cho mẫu ánh sáng của nó. Sau đó, chúng tôi tìm kiếm triệt để các tập hợp con của danh sách này có bitwise - hoặc giống với bitwise - hoặc của toàn bộ danh sách. Tập hợp con ngắn nhất là người chiến thắng.

m là một mặt nạ ngăn chặn sự quay vòng của các bit khi dịch chuyển.


Vui lòng thử cung cấp một chương trình chạy chính xác.
dùng2369284

3
@ user2369284 bạn đang nói về cái gì vậy?! Nó hoạt động hoàn toàn tốt (với python 2)
aditsu thoát vì SE là EVIL

@aditsu Tôi có trăn 3.
user2369284

1
@ user2369284, cú pháp in khác nhau nên thất bại trong python 3
aditsu thoát vì SE là EVIL

3

Java 6 - 509 byte

Tôi đã đưa ra một số giả định về các giới hạn và giải quyết vấn đề như đã nêu tại thời điểm này.

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

Chạy như thế này: java F <inputfile 2>/dev/null


Không chính xác ngắn, nhưng phù hợp trong một lĩnh vực đĩa: p Tôi có thể thử một ngôn ngữ khác sau.
aditsu bỏ cuộc vì SE là EVIL

@aditsu Làm thế nào để làm việc này trên windows?
dùng2369284

1
@ user2369284: Tôi không thấy cách bạn có thể làm 0011111100 chỉ với 2 đèn. Bạn cần che 8 ô bằng ánh sáng và mỗi đèn có thể làm tối đa 3.
Keith Randall

@ user2369284 có lẽ java F <inputfile 2>nul, nếu thất bại thì java F <inputfilebỏ qua ngoại lệ. Ngoài ra, nó sẽ không chạy với java 7.
aditsu thoát vì SE là NGÀY

@aditsu Tôi thực sự xin lỗi. Đó là một lỗi đánh máy. Chương trình của bạn hoạt động chính xác.
dùng2369284

1

c ++ - 477 byte

#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

Ruby, 303

[điều này đã được mã hóa để trả lời một phiên bản trước của câu hỏi; đọc ghi chú bên dưới]

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

Chuyển đổi sang mảng Booleans và sau đó so sánh các vùng lân cận để thay đổi.

Giới hạn (?): Kích thước cánh đồng tối đa là 1.000 x 1.000. Vấn đề nêu rõ "Nông dân Jack rất nghèo" vì vậy tôi cho rằng trang trại của mình không lớn hơn. ;-) Giới hạn có thể được loại bỏ bằng cách thêm 2 ký tự.

LƯU Ý: Kể từ khi tôi bắt đầu viết mã này, có vẻ như các yêu cầu câu hỏi đã thay đổi. Làm rõ sau đây đã được thêm vào "các đèn bạn sẽ chỉ sẽ không được loại bỏ từng cái một, nhưng chúng sẽ bị loại bỏ đồng thời" . Sự mơ hồ của câu hỏi ban đầu cho phép tôi lưu một số mã bằng cách thử nghiệm loại bỏ đèn riêng lẻ . Vì vậy, giải pháp của tôi sẽ không hoạt động cho nhiều trường hợp thử nghiệm theo các yêu cầu mới. Nếu tôi có thời gian, tôi sẽ sửa nó. Tôi có thể không. Xin vui lòng không đưa ra câu trả lời này vì các câu trả lời khác ở đây có thể được tuân thủ đầy đủ.


1

APL, 97 ký tự / byte *

Giả sử môi trường a ⎕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←⍎⍞

Phiên bản bị đánh cắp:

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

Tôi đồng ý rằng nhiều trường hợp thử nghiệm sẽ tốt hơn. Đây là một trong những ngẫu nhiên:

Đầu vào:

5 5
10001
01100
00001
11001
00010

Đầu ra (đèn vô dụng):

5

Bố cục với đèn tối thiểu (không bao gồm trong phiên bản golf):

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 có thể được viết bằng bộ ký tự byte đơn (di sản) riêng để ánh xạ các ký hiệu APL đến các giá trị 128 byte trên. Do đó, với mục đích ghi điểm, một chương trình gồm các ký tự N chỉ sử dụng các ký tự ASCII và các ký hiệu APL có thể được coi là dài N byte.


0

C ++ 5.806 byte

Điều này chưa được tối ưu hóa cho kích thước. Nhưng vì có ít thí sinh nên tôi sẽ để nó ở đó bây giờ.

Tiêu đề nông dân:

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

}

Nông dân CPP sản xuất:

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

}

Và một tập hợp các thử nghiệm để chỉ ra rằng mã thực hiện những gì nó được xây dựng để làm:

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

Vui lòng cung cấp một tiện ích thử nghiệm sử dụng các thư viện bên ngoài.
dùng2369284


0

Perl 3420 byte

Không phải là một giải pháp golf, nhưng tôi thấy vấn đề này thú vị:

#!/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 đã được lấy ra để tôi có thể hiển thị các bài kiểm tra cụ thể)


0

Python - 305 byte

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()
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.