Bạn có một mảng đầu vào có kích thước m * n. Mỗi ô trong mảng được điền bằng P hoặc T. Thao tác duy nhất bạn có thể thực hiện trên mảng là lật cột. Khi bạn lật một cột, các chữ cái trong tất cả các ô của cột đó sẽ chuyển (P trở thành T và viceversa). Nếu bạn có 'x' số hàng có cùng chữ cái (ví dụ: PPPP) thì bạn sẽ nhận được điểm. Thiết kế một thuật toán lấy trong mảng và trả về một giải pháp (cột nào cần lật) sao cho mảng kết quả có số điểm tối đa có thể.

Lưu ý: Trong trường hợp có nhiều giải pháp mang lại số điểm cao nhất, hãy chọn giải pháp có số lần lật thấp nhất. Thí dụ:

Mảng đầu vào:

PPTPP
PPTPP
PPTTP
PPPTT
PPPTT

Đầu ra:

3

Giải thích:
Một giải pháp mang lại điểm cao nhất: Lật cột số. 3
Sau đó, mảng ban đầu sẽ là:

PPPPP // 1 point
PPPPP // 1 point
PPPTP
PPTTT
PPTTT

//Total: 2 points

Lưu ý rằng người ta cũng có thể lật cột 4 và 5 để có được hai điểm, nhưng điều đó cần một lần lật bổ sung.

Bạn có thể sử dụng bất kỳ định dạng đầu vào thuận tiện nào để biểu diễn mảng hai chiều và bạn cũng có thể sử dụng bất kỳ hai giá trị riêng biệt nhưng cố định nào để biểu diễn Pvà T.

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

APL, 37

{x/1+⍳⍴x←y[↑⍋(+/∘.≠⍨2⊥⍉y),¨+/y←⍵⍪~⍵]}

Thí dụ:

{x/1+⍳⍴x←y[↑⍋(+/∘.≠⍨2⊥⍉y),¨+/y←⍵⍪~⍵]} 5 5⍴0 0 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 1

Đã thử nghiệm ở đây.

Bình thường , 28

f@eo+/QN/Qm!dN_osZ^U2lhQTUhQ

Đưa đầu vào ở dạng danh sách lồng nhau, vd

[[0,0,1,0,0],[0,0,1,0,0],[0,0,1,1,0],[0,0,0,1,1],[0,0,0,1,1]]

Cung cấp đầu ra 0-index, vd

[2]

^U2lhQ: Tạo tất cả các danh sách có thể có 0 và 1 có độ dài phù hợp.

_osZ: Đặt hàng các danh sách này từ hầu hết 1 đến ít nhất.

+/QN/Qm!dN: Đếm số lần mỗi danh sách ( N) và nghịch đảo của nó, 0s và 1s hoán đổi ( m!dN) xảy ra trong đầu vào. Cái trước tương ứng với một loạt các lần lật để lại tất cả các số không, cái sau để lại tất cả các số không.

eo: Sắp xếp danh sách theo khóa trên và lấy phần tử cuối cùng của nó, đây sẽ là kết quả có các cột khớp nhất và trong số đó có cột có ít cột nhất.

f@ ... TUhQ: Chuyển đổi danh sách 1 và 0 này thành danh sách các chỉ số sẽ được lật.

Đối với chỉ mục 1, thay đổi dthành a k, sau đó đặt mhdở đầu.

CJam, 53 51 byte

l~z:X,,La\{1$f++}/{,}${X\{_X=:!t}/z{_&,(},,}$0=:)S*

Điều này đọc một mảng hai chiều 0 và 1 từ STDIN. Ví dụ: ví dụ trong câu hỏi sẽ là

[[0 0 1 0 0] [0 0 1 0 0] [0 0 1 1 0] [0 0 0 1 1] [0 0 0 1 1]]

Kiểm tra nó ở đây.

Điều này đầu tiên nhận được tất cả các tập hợp con có thể của các cột, theo thứ tự độ dài tăng dần, sau đó thực hiện các lần lật cho mỗi tập hợp con và sắp xếp chúng theo số lượng hàng vẫn có cả 0 và 1 trong đó. Cuối cùng, chúng tôi chỉ trả lại tập hợp con đầu tiên như vậy. Điều này phụ thuộc vào việc sắp xếp ổn định, sao cho thứ tự ban đầu tăng chiều dài sẽ chăm sóc bộ ngắt kết nối.

Haskell, 98

g s=snd$maximum[((sum[1|o<-s,o==r||o==map(1-)r],-sum r),[i|(i,1)<-zip[1..]r])|r<-s++map(map(1-))s]

định dạng đầu vào là một danh sách các danh sách ints. bạn có thể sử dụng phiên bản chuỗi để kiểm tra:

gg = g . map (map (\c -> case c of 'T' -> 0 ; _ -> 1) ) . lines

_{oh không có không gian! đau quá}

điều này hoạt động bằng cách lặp qua các hàng và tính toán số điểm chúng ta sẽ nhận được nếu chúng ta lật các cột theo cách mà hàng này giúp chúng ta đạt được một điểm.

Điều đầu tiên cần chú ý là việc lật hàng cho tất cả Truehoặc tất cả đều Falsekhông thành vấn đề, bởi vì các lưới sẽ chính xác là nghịch đảo của nhau và do đó sẽ có cùng số điểm.

cách chúng ta tính toán khi một hàng nhất định đạt được một điểm là như vậy: chúng ta lặp lại các hàng một lần nữa và tính tổng các điểm mà mỗi hàng cung cấp cho chúng ta, sử dụng thực tế là chúng thực hiện chính xác khi các hàng giống hệt nhau hoặc nghịch đảo chính xác.

ví dụ: nếu hàng chúng ta đang lật TPPTPvà hàng hiện tại chúng ta đang lặp lại là PTTPThoặc TPPTPsau đó hàng đó cho chúng ta một điểm, nhưng khi đó là bất kỳ hàng nào khác, nó sẽ không cho chúng ta bất kỳ điểm nào.

CJam, 37

q~_{:!}%+:T{T1$a-,\0-+}$0={U):U*}%0-`

Định dạng đầu vào:

[[0 0 1 0 0] [0 0 1 0 0] [0 0 1 1 0] [0 0 0 1 1] [0 0 0 1 1]]

Toán học - 76

{
{P, P, T, P, P},
{P, P, T, P, P},
{P, P, T, T, P},
{P, P, P, T, T},
{P, P, P, T, T}
}/.{P -> 1, T -> 0};
First@MaximalBy[
  Subsets@Range@Length[%],
  MapAt[1-#&,%,{All,#}]~Count~{1..}&
]

Con trăn 2, 234

from itertools import *
A=input()
n=len(A[0])
R=range(n)
S=(0,)
for p in[q for i in R[:-1] for q in combinations(R,i)]:
    s=[sum([(l[q]+(q in p))%2 for q in R])for l in A]
    m=s.count(n)+s.count(0)
    if m>S[0]:S=(m,p)
print S[1]

Đầu vào là danh sách các danh sách:

[[0,0,1,0,0],[0,0,1,0,0],[0,0,1,1,0],[0,0,0,1,1],[0,0,0,1,1]]

Đầu ra là một bộ các lần lật bằng cách sử dụng chỉ mục python từ 0:

(2,)

Nếu đầu ra phải được lập chỉ mục từ 1, thì mã là 272 ký tự với 0 biểu thị không lật:

print 0 if len(S[1])==0 else [p+1 for p in S[1]]