M * n boyutunda bir giriş diziniz var. Dizideki her hücre P veya T ile doldurulur. Dizide yapabileceğiniz tek işlem çevirme sütunlarıdır. Bir sütunu çevirdiğinizde, o sütun anahtarındaki tüm hücrelerdeki harfler değişir (P, T ve viceversa olur). Aynı harfe (örneğin PPPP) sahip 'x' satırınız varsa bir puan alırsınız. Diziyi alan ve sonuçta elde edilen dizi mümkün olan en fazla noktaya sahip olacak şekilde bir çözüm (döndürecek sütunlar) döndüren bir algoritma tasarlayın.

Not: En yüksek puanı veren birden fazla çözüm olması durumunda, en az döndürme olan çözümü seçin. Misal:

Giriş Dizisi:

PPTPP
PPTPP
PPTTP
PPPTT
PPPTT

Çıktı:

3

Açıklama:
En yüksek noktaları veren bir çözüm: Flip sütun no. 3
O zaman orijinal dizi şöyle olur:

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

//Total: 2 points

Birinin iki puan almak için sütun 4 ve 5'i çevirebileceğini, ancak bunun ek bir çevirmeye ihtiyacı olduğunu unutmayın.

İki boyutlu dizi temsil etmek üzere uygun bir giriş formatını kullanabilir ve aynı zamanda herhangi iki farklı fakat sabit değerler temsil etmek edebilir Pve T.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

APL, 37

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

Misal:

{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

Burada test edildi.

Pyth , 28

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

İç içe geçmiş bir liste biçiminde girdi alır, ör.

[[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]]

0 dizinli çıktı verir, ör.

[2]

^U2lhQ: Doğru uzunluktaki 0 ​​ve 1'lerin olası tüm listelerini oluşturur.

_osZ: Bu listeleri en fazla 1'den en aza doğru sıralar.

+/QN/Qm!dN: Girişte her listenin ( N) ve tersinin 0s ve 1s swapped ( m!dN) öğesinin kaç kez meydana geldiğini sayar . Birincisi tüm sıfırları terk eden bir dizi döndürür, ikincisi ise hepsini terk eder.

eo: Listeyi yukarıdaki tuşa göre sıralar ve en çok eşleşen sütunlarla sonuçlanacak olan son öğesini alır ve aralarında en azına sahip olanı alır.

f@ ... TUhQ: Bu 1'ler ve 0'lar listesini çevrilecek dizin listesine dönüştürür.

1-indeksleme için, da değerini değiştirin ve başında kkoyun mhd.

CJam, 53 51 bayt

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

Bu, STDIN'den iki boyutlu bir 0s ve 1s dizisi okur. Örneğin, sorudaki örnek

[[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]]

Burada test edin.

Bu, ilk önce, artan uzunluk sırasına göre olası tüm sütun alt kümelerini alır, ardından her alt kümeler için döndürmeleri gerçekleştirir ve bunlarda kaç satırın hala 0 ve 1'lere sahip olduğunu sıralar. Son olarak, sadece bu tür ilk alt kümeyi döndürüyoruz. Bu, sıralamanın kararlı olmasına dayanır, böylece artan uzunluktaki ilk sıra, bağ kırıcıya bakar.

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]

girdi biçimi, içerik listesinin listesidir. sınamak için bir dize sürümü kullanabilirsiniz:

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

_{Ah boşluk yok! yaralıyor!}

bu, satırları yineleyerek ve sütunları bu satırın bize bir puan kazandıracak şekilde çevirdiğimizde alacağımız nokta sayısını hesaplayarak çalışır.

fark edilmesi gereken ilk şey, sıranın ya herkese Trueya da hepsine çevrilmesinin Falseönemli olmadığıdır, çünkü ızgaralar tam olarak birbirinin tersi olacak ve böylece tam olarak aynı puana sahip olacaktır.

belirli bir satır bir puan kazandığında sayıyı hesaplama şeklimiz böyledir: satırlar üzerinde tekrar tekrar tekrarlanır ve satırların tam olarak aynı veya tam ters olduğunda yaptıklarını kullanarak her satırın bize verdiği noktaları toplarız.

örneğin, çevirdiğimiz satır TPPTPise PTTPTve yinelediğimiz satır şu veya TPPTPbu satır bize bir puan kazandırır, ancak başka bir satır olduğunda bize puan kazandırmaz.

CJam, 37

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

Giriş biçimi:

[[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]]

Mathematica - 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..}&
]

Python 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]

Girdi, listelerin bir listesidir:

[[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]]

Çıktı, 0'dan python indeksleme kullanan bir döndürme demetidir:

(2,)

Çıktı 1'den indekslenecekse, kod 272 karakterdir ve 0 döndürme olmadığını gösterir:

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