Dividi array e programmi a metà

introduzione

Ti è stato assegnato il compito di scrivere un programma che divide uniformemente un array intero rettangolare a metà (per qualsiasi motivo). Questa attività è intensiva dal punto di vista computazionale, ma fortunatamente hai una macchina dual core per eseguire i calcoli. Per massimizzare i vantaggi del parallelismo, decidi di dividere il programma in modo uniforme a metà e lasciare che ciascun core esegua una delle parti indipendentemente dall'altra.

Ingresso e uscita

Il tuo input è un array 2D rettangolare di numeri interi non negativi di dimensioni almeno 1 × 1 , presi in qualsiasi formato ragionevole. Una divisione di un tale array si ottiene suddividendo ciascuna riga orizzontale in un prefisso e un suffisso (uno dei quali può essere vuoto). Perché una divisione sia valida, due righe adiacenti devono essere divise nello stesso indice o indici adiacenti. Ad esempio, considerare l'array

2 4 5 5 6 3
9 7 1 7 7 0
0 0 3 6 7 8
1 2 4 7 6 1
6 6 8 2 0 0

Questa è una suddivisione valida:

 2;4 5 5 6 3
;9 7 1 7 7 0
;0 0 3 6 7 8
 1;2 4 7 6 1
 6 6;8 2 0 0

Anche questa è una divisione valida:

2 4 5 5 6 3;
9 7 1 7 7;0
0 0 3 6 7;8
1 2 4 7;6 1
6 6 8;2 0 0

Questa non è una divisione valida:

2 4;5 5 6 3
9 7 1;7 7 0
0;0 3 6 7 8
1 2;4 7 6 1
6 6;8 2 0 0

Il risultato deve essere il valore minimo di

abs(sum_of_prefixes - sum_of_suffixes)

su tutte le suddivisioni valide dell'input.

Regole e punteggio

Devi scrivere due programmi (programmi completi o funzioni) nella stessa lingua, che non devono avere alcun codice condiviso tra di loro. Chiamiamoli P1 e P2 . Il programma P1 prende l'array di input e produce qualcosa . Il programma P2 prende questo qualcosa come input ed emette la risposta dell'attività precedente per l'array di input.

Il tuo punteggio è il massimo dei conteggi di byte di P1 e P2 , il punteggio più basso è migliore.

Alcuni chiarimenti:

• È possibile scrivere due prorgam completi, una funzione e un programma completo o due funzioni.
• Nel caso di due programmi completi, l'intero output di P1 viene inviato a P2 come input, come nella pipeline Unix P1 | P2. I programmi devono funzionare correttamente se compilati / interpretati da due file di origine separati.
• Se uno dei due programmi è una funzione, viene convertito in un programma completo aggiungendo il codice di caldaia necessario e viene applicata la regola sopra. In particolare, due funzioni non possono utilizzare funzioni ausiliarie condivise, istruzioni di importazione condivise o variabili globali condivise.

Casi test

[[1]] -> 1
[[4,5],[8,3]] -> 4
[[8],[11],[8],[10],[4]] -> 1
[[5,7,0,9,11,2,1]] -> 7
[[146,194,71,49],[233,163,172,21],[121,173,14,302],[259,169,26,5],[164,30,108,37],[88,55,15,2]] -> 3
[[138,2,37,2],[168,382,33,77],[31,199,7,15],[192,113,129,15],[172,88,78,169],[28,6,97,197]] -> 7
[[34,173,9,39,91],[169,23,56,74,5],[40,153,80,60,28],[8,34,102,60,32],[103,88,277,4,2]] -> 0
[[65,124,184,141],[71,235,82,51],[78,1,151,201],[12,24,32,278],[38,13,10,128],[9,174,237,113]] -> 2
[[164,187,17,0,277],[108,96,121,263,211],[166,6,57,49,73],[90,186,26,82,138],[173,60,171,265,96]] -> 8

Haskell, 102 byte

Funzione 1 (102 byte):

l=length
[]#i=[[]]
(r:s)#i=id=<<[(splitAt j r:)<$>s#j|j<-[i-1..i+1],j>=0,j<l r]
f r=(r#)=<<[0..l$r!!0]

Funzione 2 (90 byte):

g::[[([Int],[Int])]]->Int 
g a=minimum$map(\(x,y)->abs$sum(sum<$>x)-sum(sum<$>y))$unzip<$>a

Bollettino mancante per F1 per renderlo un programma completo, incluso l'array di numeri interi hardcoded per verificare:

main = print $ f [[164,187,17,0,277],[108,96,121,263,211],[166,6,57,49,73],[90,186,26,82,138],[173,60,171,265,96]]

e per F2:

main = print . g . read =<< getContents

Ora puoi chiamare runhaskell f1.hs | runhaskell f2.hsquali output 8.

Come funziona: fprende un elenco di un elenco di numeri interi.

f r = (r#)=<<[0..l$r!!0]          -- for each index [0 .. length r] call # with
                                  -- the first parameter being r and
                                  -- collect the results in a single list

[]#i=[[]]                         -- base case. If the list of lists is empty, stop
(r:s)#i                           -- else let r be the first list, s all others
           j<-[i-1..i+1],         -- foreach possible index j for the next line
                 j>=0,j<l r       --    (skipping out of range indices)
     (splitAt j r:)<$>            -- split the current line at j into a pair of
                                  -- lists and prepend it to every element of
                      s#j         -- a recursive call with s and j
id=<<                             -- flatten into a single list

Ora abbiamo un elenco di tutte le possibili divisioni, ad esempio il primo e uno casuale dal centro

[([],[164,187,17,0,277]),                  [([164,187],[17,0,277]),
 ([],[108,96,121,263,211]),                 ([108,96],[121,263,211]),
 ([],[166,6,57,49,73]),                     ([166],[6,57,49,73]),
 ([],[90,186,26,82,138]),                   ([90,186],[26,82,138]),
 ([],[173,60,171,265,96])]                  ([173,60,171],[265,96])]

La funzione gaccetta tale elenco e

                    unzip<$>a       -- turn every pair of lists into a list of pairs
  map(\(x,y)->                      -- foreach such pair     
      abs$sum(sum<$>x)-sum(sum<$>y) -- calculate the score
minimum                             -- and find the minimum

Nota: la seconda funzione può essere giocata un po 'di più, ma non cambia il punteggio.