Deskripsi

Tugas Anda adalah menampilkan 'peta kedalaman' - yaitu peta ketinggian suatu objek tetapi tidak terlihat dari atas tetapi dari depannya.

Misalnya, perhatikan objek berikut seperti yang ditunjukkan pada gambar. Peta ketinggian ditampilkan di sebelah kiri. Peta kedalaman yang sesuai akan (seperti yang terlihat dari berdiri di panah):

010
211   <- Depthmap
322

Jika Anda berdiri di panah, ada 3 kubus di belakang satu sama lain di titik kiri bawah, 2 di belakang satu sama lain di titik kiri tengah, 0 di titik kiri atas dll.

Memasukkan

Input adalah array dua dimensi dari berbagai ukuran (tidak harus persegi).

Keluaran

Output adalah array dua dimensi yang mewakili peta kedalaman. Seperti yang dapat Anda simpulkan, ukurannya adalah (height x width). Dalam gambar, itu akan menjadi (3 x 3). Perhatikan bahwa jika menara kubus tertinggi adalah 5, maka depthmap akan menjadi array (5 x 3).

Kondisi menang

Kode terpendek menang.

Tidak diizinkan

Semua bahasa diizinkan, tidak ada batasan eksplisit. (Aku tidak tahu apa yang bisa kamu lakukan, tapi tolong bersikap adil.)

Contohnya

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 karakter

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

hasil

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

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

Lewati semua testcases.

Windows PowerShell, 108 111 114

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

Passes all test cases.

Haskell, 118 characters

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

• Edit (122 → 118): avoid filtering by only iterating to maximal height

Scala 236 characters

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

With some formatting:

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

I'm sure a better facility with for comprehensions would mean I could cut some characters from this.

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

Just for the record, this is the code I made up before posting the question. (Smallened now)

Haskell Version (Now optimized)

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

Ungolfed version

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 chars

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 to Ventero's Ruby solution.

APL (Dyalog Extended), 14 bytes

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

Try it 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 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

Try all test cases

Outputting the rows in reversed order would save 2 bytes, taking input in column-major order would save 1 byte, doing both would (naturally) save 3 bytes

Explanation:

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