La description

Votre tâche consiste à générer une «carte de profondeur», c'est-à-dire une carte de hauteur d'un objet, mais pas vue de dessus mais de face.

Par exemple, considérez l'objet suivant comme indiqué sur l'image. La carte des hauteurs est affichée à gauche. La carte de profondeur correspondante serait (vue de la position de la flèche):

010
211   <- Depthmap
322

Si vous vous tenez à la flèche, il y a 3 cubes les uns derrière les autres au point en bas à gauche, 2 derrière les uns les autres au point au milieu à gauche, 0 au point en haut à gauche, etc.

Contribution

L'entrée est un tableau bidimensionnel de n'importe quelle taille (pas nécessairement carré).

Sortie

La sortie est un autre tableau à deux dimensions qui représente la carte de profondeur. Comme vous pouvez en déduire, ses tailles sont (height x width). Dans l'image, ce serait (3 x 3). Notez que si la tour de cubes la plus haute était de 5, la carte de profondeur serait un tableau de (5 x 3).

Condition gagnante

Le code le plus court gagne.

Rejeté

Toutes les langues sont autorisées, aucune restriction explicite. (Je ne sais pas ce que vous pouvez trouver, mais jouez bien s'il vous plaît.)

Exemples

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 caractères

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

résultats

$ 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 caractères

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

Réussit tous les tests.

Windows PowerShell, 108 111 114

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

Réussit tous les cas de test.

Haskell, 118 caractères

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

• Edit (122 → 118): évitez le filtrage en itérant uniquement à la hauteur maximale

Scala 236 caractères

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

Avec une mise en forme:

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

Je suis sûr qu'une meilleure facilité de compréhension signifierait que je pourrais couper certains caractères de cela.

JavaScript, 235 208 195 octets

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

Juste pour mémoire, c'est le code que j'ai inventé avant de poster la question. (Réduit maintenant)

Version Haskell (maintenant optimisée)

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

Version non golfée

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 caractères

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

Similaire à la solution Ruby de Ventero.

APL (Dyalog Extended) , 14 octets

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

Essayez-le en ligne!

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

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

Japt , 12 octets

c rÔÆÕËè>X
w

Essayez tous les cas de test

La sortie des lignes dans un ordre inversé permettrait d'économiser 2 octets , la prise de données dans l'ordre des colonnes permettrait d'économiser 1 octet , et les deux économiseraient (naturellement) 3 octets

Explication:

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