Descrizione

Il tuo compito è quello di produrre una "mappa di profondità", ovvero una mappa di altezza di un oggetto ma non vista dalla sua parte superiore ma dalla sua parte anteriore.

Ad esempio, considera il seguente oggetto come mostrato nell'immagine. La mappa dell'altezza è mostrata a sinistra. La corrispondente mappa di profondità sarebbe (vista dalla posizione della freccia):

010
211   <- Depthmap
322

Se ti trovi sulla freccia, ci sono 3 cubi uno dietro l'altro nel punto in basso a sinistra, 2 uno dietro l'altro nel punto in mezzo a sinistra, 0 nel punto in alto a sinistra ecc.

Ingresso

L'input è una matrice bidimensionale di qualsiasi dimensione (non necessariamente quadrata).

Produzione

L'output è un altro array bidimensionale che rappresenta la mappa di profondità. Come puoi dedurre, le sue dimensioni sono (height x width). Nell'immagine, sarebbe (3 x 3). Si noti che se la torre di cubi più alta fosse 5, la mappa di profondità sarebbe una matrice di (5 x 3).

Condizioni vincenti

Vince il codice più corto.

Non consentito

Sono ammesse tutte le lingue, nessuna restrizione esplicita. (Non so cosa puoi inventare, ma per favore gioca bene, per favore.)

Esempi

Input:     Ouput:

5321       0001
1456       1012
2105       1112
           1212
           2222
           3323


Input:     Output:

22         01
13         12
00         22


Input:     Output:    (of the sample image)

232        010
210        211
101        322

Golfscript, 42 caratteri

n%{n*~]}%zip:|[]*$),{:);n|{{)>},,}%}%-1%\;

risultati

$ golfscript 2657.gs < 2657-1.txt 
0001
1012
1112
1212
2222
3323

$ golfscript 2657.gs < 2657-2.txt 
01
12
22

$ golfscript 2657.gs < 2657-3.txt 
010
211
322

Ruby 1.9, 102 caratteri

f=$<.map{|g|[*g.chop.bytes]}
f.flatten.max.downto(49){|j|puts f.transpose.map{|n|n.count{|r|r>=j}}*""}

Supera tutti i test.

Windows PowerShell, 108 111 114

(($i=@($input))-split''|sort)[-1]..1|%{$h=$_
-join(1..$i[0].Length|%{$x=$_-1
@($i|?{"$h"-le$_[$x]}).count})}

Supera tutti i casi di test.

Haskell, 118 caratteri

import List
p h=map(\c->transpose(lines h)>>=show.length.filter(>=c))['1'..maximum h]
main=interact$unlines.reverse.p

• Modifica (122 → 118): evita il filtraggio ripetendo solo l'altezza massima

Scala 236 caratteri

object D extends App{var(l,m,z)=(io.Source.stdin.getLines.toList,0,0);val a=Array.ofDim[Int](l.head.size,10);for(i<-l;(j,q)<-i.zipWithIndex;x<-1 to j-48){a(q)(x-1)+=1;m=List(m,j-48).max};for(i<-1 to m){for(j<-a){print(j(m-i))};println}}

Con un po 'di formattazione:

object Depthmap extends App
{
    var(l,m,z)=(io.Source.stdin.getLines.toList,0,0)
    val a=Array.ofDim[Int](l.head.size,10)
    for(i<-l;(j,q)<-i.zipWithIndex;x<-1 to j-48)
    {
        a(q)(x-1)+=1
        m=List(m,j-48).max
    }
    for(i<-1 to m)
    {
        for(j<-a)
        {
            print(j(m-i))
        }
        println
    }
}

Sono sicuro che una migliore struttura per la comprensione significherebbe che potrei tagliare alcuni personaggi da questo.

JavaScript, 235 208 195 byte

function _(b){for(e=Math.max.apply(0,b.join().split(",")),f=[],c=i=0;i<e;i++){for(
c=[],a=0;a<b[0].length;a++)for(d=c[a]=0;d<b.length;d++)b[d][a]>i&&c[a]++;f[e-i-1]
=c.join("")}return f.join("\n")}

Solo per la cronaca, questo è il codice che ho inventato prima di pubblicare la domanda. (Ridotto ora)

Versione Haskell (ora ottimizzata)

import Data.List
import Text.Parsec
import Text.Parsec.String

main= readFile"in.txt">>=(\t->either print(putStrLn.intercalate"\n".map(concatMap show).(\j->map (\n->(map(length.(filter(>=n)))(transpose$reverse j))) (reverse [1..(maximum$map maximum j)])))(parse(many1$many1 digit>>=(\x->newline>>(return$map(read.return)x)))""t))

Versione Ungolfed

import Data.List (foldl', transpose, intercalate)
import Text.Parsec
import Text.Parsec.String

-- Source:  http://codegolf.stackexchange.com/questions/2657/swapping-heightmaps-to-depthmaps

digitArray :: Parser [[Int]]
digitArray = many1 $ do xs <- many1 digit
                        optional newline
                        return $ map (read . return) xs

maxHeight :: Ord c => [[c]] -> c
maxHeight = maximum . (map maximum)

heightToDepth :: [[Int]] -> [[Int]]
heightToDepth ins = level (maxHeight ins)
        where level 0 = []
              level n = (map (length . (filter (>=n))) xs) : level (n-1)
              xs      = transpose $ reverse ins

lookNice xs = intercalate ['\n'] $ map (concatMap show) xs

main = do inText <- readFile "in.txt"
          case parse digitArray "" inText of
              Left err -> print err
              Right xs -> putStrLn $ lookNice $ heightToDepth xs

Python, 117 caratteri

import sys
a=zip(*sys.stdin)[:-1]
n=int(max(map(max,a)))
while n:print''.join(`sum(e>=`n`for e in r)`for r in a);n-=1

Simile alla soluzione Ruby di Ventero.

APL (Dyalog Extended) , 14 byte

{⊖⍉+⌿⍵≥⍀⍳⌈/,⍵}

Provalo online!

{⊖⍉+⌿⍵≥⍀⍳⌈/,⍵}    Monadic function:
             ⍵     Start with a 2D array ⍵.
          ⌈/,      Find the overall maximum value h.
         ⍳         Make the list 1...h
       ≥⍀          Make a ≥ table between that list and ⍵.
                   Now we have a 3D matrix where position [a,b,c]
                   represents whether ⍵[a,b] is at least c.
    +⌿             We sum along the outermost (first) dimension, 
                   since that corresponds to a column of ⍵.
                   Now we have a 2D matrix where position [b,c]
                   represents how many values in column b of ⍵ are at least c.
  ⍉                Transpose so the heights are rows.
 ⊖                 Flip vertically.

Clojure, 102 byte

#(for[h(range(apply max(flatten %))0 -1)](map(fn[w _](count(for[r % :when(>=(r w)h)]_)))(range)(% 0)))

Japt , 12 byte

c rÔÆÕËè>X
w

Prova tutti i casi di test

L'output delle righe in ordine inverso risparmierebbe 2 byte , prendendo l'input nell'ordine della colonna maggiore risparmierebbe 1 byte , facendo entrambi salverebbe (naturalmente) 3 byte

Spiegazione:

c rÔ          #Find the maximum height
    Æ         #For each number X in the range [0...max_height]:
     Õ        # Get the columns of the input
      Ë       # For each column:
       è>X    #  Count how many items are greater than X

w             #Reverse the output