Hai un array di input di dimensioni m * n. Ogni cella dell'array viene popolata con P o T. L'unica operazione che è possibile eseguire sull'array è capovolgere le colonne. Quando si capovolge una colonna, le lettere in tutte le celle di quella colonna cambiano (P diventa T e viceversa). Se hai un numero "x" di righe con la stessa lettera (ad es. PPPP), ottieni un punto. Progettare un algoritmo che includa l'array e restituisca una soluzione (quali colonne da capovolgere) in modo tale che l'array risultante abbia il numero massimo di punti possibili.

Nota: se esistono più soluzioni che danno il punteggio più alto, scegli quella con il minor numero di lanci. Esempio:

Matrice di input:

PPTPP
PPTPP
PPTTP
PPPTT
PPPTT

Produzione:

3

Spiegazione:
Una soluzione che dà il punteggio più alto: capovolgere la colonna n. 3
Quindi l'array originale sarebbe:

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

//Total: 2 points

Si noti che è possibile capovolgere anche le colonne 4 e 5 per ottenere un punteggio di due, ma è necessario un ulteriore capovolgimento.

È possibile utilizzare qualsiasi formato di input conveniente per rappresentare l'array bidimensionale e due valori distinti, ma fissi, da rappresentare Pe T.

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

APL, 37

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

Esempio:

{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

Testato qui.

Pyth , 28

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

Accetta input sotto forma di un elenco nidificato, ad es

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

Fornisce output indicizzato 0, ad es

[2]

^U2lhQ: Genera tutti gli elenchi possibili di 0 e 1 della lunghezza corretta.

_osZ: Ordina questi elenchi dalla maggior parte degli 1 al minimo.

+/QN/Qm!dN: Conta quante volte ogni elenco ( N) e il suo inverso, 0s e 1s swapped ( m!dN) si verificano nell'input. Il primo corrisponde a una serie di lanci che lasciano tutti gli zeri, il secondo a lasciare tutti gli zeri.

eo: Ordina l'elenco con la chiave sopra e prende il suo ultimo elemento, che sarà il risultato con le colonne più corrispondenti, e tra queste quella con le meno.

f@ ... TUhQ: Converte questo elenco di 1 e 0 in un elenco di indici da capovolgere.

Per 1-indicizzazione, cambia din a k, quindi mettilo mhdall'inizio.

CJam, 53 51 byte

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

Questo legge una matrice bidimensionale di 0 e 1 da STDIN. Ad esempio, l'esempio nella domanda sarebbe

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

Provalo qui.

Questo prima ottiene tutti i possibili sottoinsiemi di colonne, in ordine di lunghezza crescente, quindi esegue i flip per ciascun sottoinsieme e li ordina in base al numero di righe che contengono ancora 0 e 1. Infine, restituiamo il primo sottoinsieme di questo tipo. Ciò dipende dal fatto che l'ordinamento sia stabile, in modo tale che l'ordine iniziale di lunghezza crescente si occupi del pareggio.

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]

il formato di input è un elenco di elenco di ints. è possibile utilizzare una versione di stringa per il test:

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

_{oh no gli spazi! fa male!}

questo funziona ripetendo le righe e calcolando il numero di punti che otterremo se capovolgiamo le colonne in modo che questa riga ci guadagni un punto.

la prima cosa da notare è che capovolgere la riga su tutti Trueo tutti Falsenon ha importanza, perché le griglie saranno esattamente inverse l'una rispetto all'altra e quindi avranno lo stesso punteggio esatto.

il modo in cui calcoliamo il conteggio quando una determinata riga guadagna un punto è così: iteriamo di nuovo sulle righe e sommiamo i punti che ogni riga ci dà, usando il fatto che fanno esattamente quando le righe sono identiche o esattamente inverse.

per esempio, se la riga che stiamo girando è TPPTPe la riga corrente su cui stiamo iterando è PTTPTo TPPTPallora la riga ci guadagna un punto, ma quando è un'altra riga, non ci guadagna alcun punto.

CJam, 37

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

Formato di input:

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

L'input è un elenco di elenchi:

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

L'output è una tupla di lanci che utilizzano l'indicizzazione python da 0:

(2,)

Se l'output deve essere indicizzato da 1, allora il codice è di 272 caratteri con 0 che indica nessun ribaltamento:

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