Beschreibung

Ihre Aufgabe ist es, eine 'Tiefenkarte' auszugeben, dh eine Höhenkarte eines Objekts, die nicht von oben, sondern von vorne zu sehen ist.

Betrachten Sie beispielsweise das folgende Objekt wie auf dem Bild gezeigt. Die Höhenkarte wird links angezeigt. Die entsprechende Tiefenkarte würde lauten (vom Pfeil aus gesehen):

010
211   <- Depthmap
322

Wenn Sie am Pfeil stehen, befinden sich am linken unteren Punkt 3 Würfel hintereinander, am linken mittleren Punkt 2 hintereinander, am linken oberen Punkt 0 usw.

Eingang

Die Eingabe ist ein zweidimensionales Array beliebiger Größe (nicht unbedingt quadratisch).

Ausgabe

Die Ausgabe ist ein weiteres zweidimensionales Array, das die Tiefenkarte darstellt. Wie Sie ableiten können, sind seine Größen (height x width). Auf dem Bild wäre es (3 x 3). Wenn der höchste Turm aus Würfeln 5 wäre, wäre die Tiefenkarte ein Array von (5 x 3).

Gewinnbedingung

Der kürzeste Code gewinnt.

Nicht erlaubt

Alle Sprachen erlaubt, keine expliziten Einschränkungen. (Ich weiß nicht, was Sie sich einfallen lassen können, aber spielen Sie bitte fair.)

Beispiele

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 Zeichen

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

Ergebnisse

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

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

Besteht alle Testfälle.

Windows PowerShell, 108 111 114

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

Besteht alle Testfälle.

Haskell, 118 Zeichen

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

• Bearbeiten (122 → 118): Vermeiden Sie das Filtern, indem Sie nur bis zur maximalen Höhe iterieren

Scala 236 Zeichen

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

Mit etwas Formatierung:

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

Ich bin mir sicher, dass eine bessere Möglichkeit zum Verständnis bedeuten würde, dass ich einige Zeichen daraus herausschneiden könnte.

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

Nur zur Veranschaulichung, dies ist der Code, den ich vor dem Posten der Frage erfunden habe. (Smallened jetzt)

Haskell-Version (jetzt optimiert)

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 Zeichen

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

Ähnlich der Ruby-Lösung von Ventero.

APL (Dyalog Extended) , 14 Byte

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

Probieren Sie es 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

Probieren Sie alle Testfälle aus

Das Ausgeben der Zeilen in umgekehrter Reihenfolge würde 2 Bytes einsparen , das Eingeben in Spalten-Hauptreihenfolge würde 1 Byte einsparen , und beides würde (natürlich) 3 Bytes einsparen

Erläuterung:

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