기술

당신의 임무는 '뎁스 맵', 즉 객체의 하이트 맵을 출력하는 것입니다.

예를 들어 이미지에 표시된 다음 객체를 고려하십시오. 높이 맵이 왼쪽에 표시됩니다. 해당 깊이 맵은 (화살표에서 서서 볼 때) 다음과 같습니다.

010
211   <- Depthmap
322

화살표에 서 있으면 왼쪽 하단 지점에 서로 뒤에 3 개의 큐브가 있고, 왼쪽 중앙 지점에 서로 뒤에 2 개의 큐브가 있으며 왼쪽 상단 지점에 0이 있습니다.

입력

입력은 모든 크기의 2 차원 배열입니다 (정사각형 일 필요는 없음).

산출

출력은 깊이 맵을 나타내는 또 다른 2 차원 배열입니다. 추론 할 수 있듯이 크기는 (height x width)입니다. 이미지에서는입니다 (3 x 3). 가장 높은 큐브 타워가 5 인 경우 깊이 맵은의 배열이 (5 x 3)됩니다.

승리 조건

가장 짧은 코드가 승리합니다.

허용되지 않음

모든 언어가 허용되며 명시적인 제한은 없습니다. (나는 당신이 무엇을 생각 해낼 수 있는지 모르지만 공정하게하십시오.)

예

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

골프 스크립트, 42 문자

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

결과

$ 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

루비 1.9, 102 자

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

모든 테스트 케이스를 통과합니다.

Windows PowerShell을 108 111 114

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

모든 테스트 사례를 통과합니다.

하스켈, 118 자

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

• 편집 (122 → 118) : 최대 높이까지만 반복하여 필터링하지 마십시오.

스칼라 236 자

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

몇 가지 형식으로 :

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

이해력을 갖춘 더 나은 시설은 이것에서 일부 문자를자를 수 있음을 의미합니다.

자바 스크립트, 235 208 195 바이트

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

기록을 위해, 이것은 질문을 게시하기 전에 작성한 코드입니다. (지금 도전)

하스켈 버전 (지금 최적화)

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

언 골프 버전

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

파이썬, 117 자

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

Ventero의 Ruby 솔루션과 유사합니다.

APL (Dyalog Extended) , 14 바이트

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

온라인으로 사용해보십시오!

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

클로저, 102 바이트

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

Japt , 12 바이트

c rÔÆÕËè>X
w

모든 테스트 사례를 시도하십시오

행을 역순으로 출력하면 2 바이트 가 절약 되고 열 주요 순서로 입력하면 1 바이트 가 절약되고 자연스럽게 3 바이트가 절약 됩니다.

설명:

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