Descripción

Su tarea es generar un 'mapa de profundidad', es decir, un mapa de altura de un objeto pero no visto desde su parte superior, sino desde su frente.

Por ejemplo, considere el siguiente objeto como se muestra en la imagen. El mapa de altura se muestra a la izquierda. El mapa de profundidad correspondiente sería (como se ve desde la flecha):

010
211   <- Depthmap
322

Si se para en la flecha, hay 3 cubos uno detrás del otro en el punto inferior izquierdo, 2 uno detrás del otro en el punto central izquierdo, 0 en el punto superior izquierdo, etc.

Entrada

La entrada es una matriz bidimensional de cualquier tamaño (no necesariamente cuadrada).

Salida

La salida es otra matriz bidimensional que representa el mapa de profundidad. Como puedes deducir, sus tamaños son (height x width). En la imagen, sería (3 x 3). Tenga en cuenta que si la torre más alta de cubos fuera 5, el mapa de profundidad sería una matriz de (5 x 3).

Condición ganadora

El código más corto gana.

No permitido

Todos los idiomas permitidos, sin restricciones explícitas. (No sé qué se te ocurre, pero juega limpio, por favor).

Ejemplos

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 caracteres

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

resultados

$ 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 caracteres

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

Pasa todos los casos de prueba.

Windows PowerShell, 108 111 114

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

Pasa todos los casos de prueba.

Haskell, 118 caracteres

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

• Editar (122 → 118): evite el filtrado solo iterando a la altura máxima

Scala 236 caracteres

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 algo de formato:

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
    }
}

Estoy seguro de que una mejor instalación para la comprensión significaría que podría cortar algunos personajes de esto.

JavaScript, 235 208 195 bytes

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 para que conste, este es el código que inventé antes de publicar la pregunta. (Smallened ahora)

Versión Haskell (ahora optimizada)

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))

Versión sin golf

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 caracteres

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

Similar a la solución Rubí de Ventero.

APL (Dyalog Extended) , 14 bytes

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

Pruébalo en línea!

{⊖⍉+⌿⍵≥⍀⍳⌈/,⍵}    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 bytes

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

Japt , 12 bytes

c rÔÆÕËè>X
w

Pruebe todos los casos de prueba

La salida de las filas en orden inverso ahorraría 2 bytes , tomar la entrada en orden de columna principal ahorraría 1 byte , haciendo ambas (naturalmente) ahorraría 3 bytes

Explicación:

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