Tratto da Google Code Jam 2013 Qualification Round Problema B :

Alice e Bob hanno un prato davanti alla loro casa, a forma di rettangolo N metro per metro M. Ogni anno, cercano di tagliare il prato in un modello interessante. Hanno usato il loro taglio con le cesoie, che ha richiesto molto tempo; ma ora hanno un nuovo rasaerba automatico con più impostazioni e vogliono provarlo.

Il nuovo tosaerba ha un'impostazione di altezza: puoi impostarlo su qualsiasi altezza h tra 1 e 100 millimetri e taglierà tutta l'erba più in alto di h che incontra in altezza h. Lo corri entrando nel prato in qualsiasi parte del bordo del prato; quindi il rasaerba procede in linea retta, perpendicolare al bordo del prato in cui è entrato, tagliando l'erba in un'andana larga 1 m, fino a quando non esce dal prato dall'altro lato. L'altezza del rasaerba può essere impostata solo quando non è sul prato.

Alice e Bob hanno una serie di vari schemi di erba che potrebbero avere sul prato. Per ognuno di questi, vogliono sapere se è possibile tagliare l'erba in questo modello con il loro nuovo tosaerba. Ogni modello è descritto specificando l'altezza dell'erba su ogni quadrato 1m x 1m del prato.

L'erba è inizialmente alta 100 mm su tutto il prato.

Scrivi una funzione che accetta una matrice 2D di altezze intere e determina se il prato può essere tagliato di conseguenza.

Ecco 100 casi di test da Google Code Jam. I primi 35 casi dovrebbero passare, il resto no.

Il codice più corto vince.

J, 15 caratteri

   (-:>./"1<./>./)

Non mi aspettavo questa soluzione breve.

Breve spiegazione:

(input == ((max of rows of input) table with min of left and right (max in columns of input)))
(      -:          >./"1                        <./                       >./              )

Se la tua funzione è un'altra 4 come nella soluzione: (f1 f2 f3 f4)e un input J la calcola come f1(input,f3(f2(input),f4(input)))ie input f1 ((f2 input) f3 (f4 input)).

APL, 15 caratteri

{⍵≡(⌈/⍵)∘.⌊⌈⌿⍵}

Spiegazione:

• ⌈⌿⍵ calcola il massimo delle colonne di rhs
• ⌈/⍵ fa lo stesso con le righe
• ∘.⌊ fa il prodotto esterno dei due precedenti rispetto al minimo funzionale
• ⍵≡ confronta il risultato con rhs

Esempi:

      {⍵≡(⌈/⍵)∘.⌊⌈⌿⍵} 3 3 ⍴ 2 1 2 1 1 1 2 1 2
1

      {⍵≡(⌈/⍵)∘.⌊⌈⌿⍵} 2 3 ⍴ 2 2 2 2 1 1
0 

Python, 112 104

z=zip
y=lambda l:[[max(r)]*len(r)for r in l]
f=lambda l:l==[map(min,z(*r))for r in z(y(l),z(*y(z(*l))))]

Ho un codice Python un po 'più lungo ma ha superato tutti i casi di test forniti a Google Code Jam 2013.

 a=input();io=0
 while io<a:
     io+=1;[b,c]=map(int,raw_input("").strip().split());koi=[];koi1=[]
     for i in xrange(b):
         koi.append(map(int,raw_input("").strip().split()))
    rowmax=[]
    for i in koi:
        rowmax.append(max(i))
    for i in xrange(c):
        t=[]
        for j in koi:
            t.append(j[i])
        koi1.append(t);colmax=[]
    for i in koi1:
        colmax.append(max(i))
    toi1=[]
    for i in xrange(b):
        s=[]
        for j in xrange(c):
           s.append(min(colmax[j],rowmax[i]))
        toi1.append(s)
     if toi1==koi:
        print "Case #%d:"%io,"YES"
     else:
        print "Case #%d:"%io,"NO"