Açıklama

Senin görevin bir 'derinlik haritası' - yani bir nesnenin yükseklik haritası ama tepesinden değil de önden görünmek.

Örneğin, aşağıdaki nesneyi resimde gösterildiği gibi düşünün. Yükseklik haritası solda gösterilir. Karşılık gelen derinlik haritası (okda dururken görüldüğü gibi) olacaktır:

010
211   <- Depthmap
322

Okta durursanız, sol alt köşede 3, üst sol orta noktada 2, sol üst noktada 0 vb.

Giriş

Giriş, herhangi bir boyutta (zorunlu olarak kare değil) iki boyutlu bir dizidir.

Çıktı

Çıktı, derinlik haritasını temsil eden başka bir iki boyutlu dizidir. Anlayabileceğiniz gibi, boyutları (height x width). Resimde, olurdu (3 x 3). En yüksek küp kulesi 5 ise derinlik haritasının bir dizi olacağını unutmayın (5 x 3).

Kazanma koşulu

En kısa kod kazanır.

İzin verilmeyen

Tüm dillere izin verilir, açık bir kısıtlama yoktur. (Ne bulabileceğinizi bilmiyorum, ama lütfen adil olun.)

Örnekler

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%\;

Sonuçlar

$ 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

Yakut 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}}*""}

Tüm test durumlarını geçiyor.

Windows PowerShell, 108 111 114

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

Tüm test durumlarını geçer.

Haskell, 118 karakter

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

• Düzenleme (122 → 118): yalnızca maksimum yüksekliğe yineleyerek filtrelemekten kaçının

Scala 236 karakter

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

Bazı biçimlendirme ile:

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

Anlayışlar için daha iyi bir tesis, bundan bazı karakterleri kesebileceğim anlamına gelir.

JavaScript, 235 208 195 bayt

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

Sadece kayıt için, soruyu göndermeden önce oluşturduğum kod budur. (Şimdi boğuldu)

Haskell Version (Şimdi optimize edilmiş)

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 versiyonu

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 karakter

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'nun Ruby çözümüne benzer.

APL (Dyalog Genişletilmiş) , 14 bayt

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

Çevrimiçi deneyin!

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

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

Japt , 12 bayt

c rÔÆÕËè>X
w

Tüm test durumlarını deneyin

Satırları ters sırayla vermek, 2 byte tasarruf sağlayacaktı , sütun ana siparişinde girdi almak 1 byte tasarruf sağlayacaktı;3 bytes

Açıklama:

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