Sự miêu tả

Nhiệm vụ của bạn là đưa ra một 'độ sâu' - nghĩa là một sơ đồ chiều cao của một đối tượng nhưng không nhìn thấy từ trên đỉnh của nó mà từ phía trước của nó.

Ví dụ, hãy xem xét các đối tượng sau đây như được hiển thị trên hình ảnh. Bản đồ chiều cao được hiển thị bên trái. Bản đồ độ sâu tương ứng sẽ là (khi nhìn từ đứng ở mũi tên):

010
211   <- Depthmap
322

Nếu bạn đứng ở mũi tên, có 3 khối phía sau nhau ở điểm dưới bên trái, 2 điểm sau nhau ở điểm giữa bên trái, 0 ở điểm trên cùng bên trái, v.v.

Đầu vào

Đầu vào là một mảng hai chiều của bất kỳ kích thước nào (không nhất thiết phải là hình vuông).

Đầu ra

Đầu ra là một mảng hai chiều khác đại diện cho chiều sâu. Như bạn có thể suy luận, kích thước của nó là (height x width). Trong hình ảnh, nó sẽ được (3 x 3). Lưu ý rằng nếu tháp hình khối cao nhất là 5, thì độ sâu sẽ là một mảng (5 x 3).

Điều kiện chiến thắng

Mã ngắn nhất sẽ thắng.

Không được phép

Tất cả các ngôn ngữ được phép, không có hạn chế rõ ràng. (Tôi không biết những gì bạn có thể đưa ra, nhưng vui lòng chơi công bằng.)

Ví dụ

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 ký tự

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

các kết quả

$ 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 ký tự

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

Vượt qua tất cả các thử nghiệm.

Windows PowerShell, 108 111 114

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

Vượt qua tất cả các trường hợp thử nghiệm.

Haskell, 118 ký tự

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

• Chỉnh sửa (122 → 118): tránh lọc bằng cách chỉ lặp lại chiều cao tối đa

Scala 236 ký tự

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

Với một số định dạng:

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

Tôi chắc rằng một cơ sở tốt hơn với sự hiểu biết sẽ có nghĩa là tôi có thể cắt giảm một số nhân vật khỏi điều này.

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

Chỉ cần cho hồ sơ, đây là mã tôi tạo ra trước khi đăng câu hỏi. (Thu nhỏ lại)

Phiên bản Haskell (Hiện đã được tối ưu hóa)

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

Phiên bản ung dung

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 ký tự

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

Tương tự như giải pháp Ruby của Venter.

APL (Dyalog mở rộng) , 14 byte

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

Hãy thử trực tuyến!

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

Hãy thử tất cả các trường hợp thử nghiệm

Xuất ra các hàng theo thứ tự đảo ngược sẽ tiết kiệm được 2 byte , lấy đầu vào theo thứ tự chính của cột sẽ tiết kiệm được 1 byte , làm cả hai (tự nhiên) sẽ tiết kiệm được 3 byte

Giải trình:

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