डेप्थमैप्स के लिए ऊंचाई स्वैपिंग

Question

विवरण

आपका कार्य एक 'डेप्थमैप' का उत्पादन करना है - जो कि किसी वस्तु का एक ऊँचाई है, लेकिन उसके शीर्ष से नहीं बल्कि उसके सामने से देखा जाता है।

उदाहरण के लिए, छवि पर दिखाए अनुसार निम्न वस्तु पर विचार करें। ऊंचाई का नक्शा बाईं ओर दिखाया गया है। इसी गहराई का नक्शा होगा (जैसा कि तीर पर खड़े होने से देखा जाता है):

010
211   <- Depthmap
322

यदि आप तीर पर खड़े होते हैं, तो निचले बाएं-बिंदु पर एक दूसरे के पीछे 3 क्यूब्स होते हैं, मध्य बाएं हाथ के बिंदु पर एक दूसरे के पीछे, शीर्ष बाएं हाथ के बिंदु पर 0 आदि।

इनपुट

इनपुट किसी भी आकार का दो आयामी सरणी है (जरूरी नहीं कि वर्ग)।

उत्पादन

आउटपुट एक और दो आयामी सरणी है जो डेप्थमैप का प्रतिनिधित्व करता है। जैसा कि आप घटा सकते हैं, इसके आकार हैं (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

Comments

क्या आप पोस्ट की गई उदाहरण छवि के लिए एक नमूना इनपुट / आउटपुट प्रदान कर सकते हैं?

— मेलमोकब

@pimvdb: अच्छी पहेली। हम पोस्ट करने से पहले लोगों को पहेली लैब चार या मेटा सैंडबॉक्स पर सलाह लेने के लिए प्रोत्साहित करते हैं। इस तरह, इस प्रकार के मुद्दों को आपकी पहेली के लाइव होने से पहले ही सामने लाया जा सकता है। हम सभी को एक आदर्श विनिर्देश बनाने में परेशानी होती है, खासकर यदि कार्य गैर तुच्छ हो।

— dmckee

@pimvdb: इसे फेट न करें; यह किसी प्रकार की आवश्यकता नहीं है। साइट को थोड़ा बेहतर बनाने की उम्मीद में बस हम एक दूसरे के लिए प्रदान करते हैं।

— dmckee

ठीक है, अंतिम पंक्ति के बारे में भ्रम यह हो सकता है कि आपकी »गहराई मानचित्र« की परिभाषा असामान्य है, मुझे लगता है। आमतौर पर एक गहराई का नक्शा एक ऊंचाई के नक्शे के समान होता है, जिसे केवल एक विशिष्ट कैमरे से देखा जाता है - यानी यह किसी दिए गए दृश्य के दृष्टिकोण की ओर विस्तार बताता है (कम से कम यह है कि 3D रेंडरर्स इसे कैसे मानते हैं)। आपके पास अनिवार्य रूप से एक जगह में एक दूसरे के पीछे कितने ब्लॉक हैं। हालांकि यह सुनिश्चित करने के लिए नहीं कि इसे कैसे बुलाया जाए। एक एनील आंशिक रूप से कांच के ब्लॉक को पार कर सकता है और जितना अधिक आप एक दूसरे के पीछे होते हैं, उतना ही गहरा परिणाम प्राप्त होता है - उनके बीच की जगह की परवाह किए बिना।

— जॉय

चिंता मत करो। यह अब जैसा है ठीक काम है।

— जॉय

Answer 1

गोल्फस्क्रिप्ट, 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

Comments

बधाई हो।

— pimvdb

@pimvdb, धन्यवाद, लेकिन मुझे लगता है कि आपको कुछ समय के लिए कोई जवाब स्वीकार किए बिना इसे खोलना चाहिए (एक सप्ताह हो सकता है)।

— आप

चूंकि स्वीकृत उत्तर को किसी भी समय फिर से बदला जा सकता है, इसलिए नुकसान कहां है?

— जॉय

+100: 42

— चरस

मैंने आपके समाधान को देखने से परहेज किया जब तक कि मैंने अपना खुद का लिखा नहीं किया। उनकी तुलना अब, वे नहीं बल्कि आप के साथ वर्णों की एक टन बचाने के लिए समान हैं []*। अच्छी चाल।

— पीटर टेलर

Answer 2

रूबी 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}}*""}

सभी टेस्टकेस पास करता है।

Answer 3

विंडोज पॉवरशेल, 108 111 114

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

सभी परीक्षण मामलों को पारित करता है।

Answer 4

हास्केल, 118 अक्षर

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

---

• संपादित करें (122 → 118): केवल अधिकतम ऊंचाई तक चलने से फ़िल्टरिंग से बचें

Answer 5

स्काला 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
    }
}

मुझे यकीन है कि समझ के लिए एक बेहतर सुविधा का मतलब होगा कि मैं इसमें से कुछ पात्रों को काट सकता हूं।

Answer 6

जावास्क्रिप्ट, 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")}

सिर्फ रिकॉर्ड के लिए, यह वह कोड है जिसे मैंने प्रश्न पोस्ट करने से पहले बनाया था। (अब छोटा किया गया)

Answer 7

हास्केल संस्करण (अब अनुकूलित)

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

Comments

[कोड-गोल्फ] सवालों के लंबे जवाब स्वीकार्य हैं जब लंबाई अनुपयुक्त भाषाओं (फोरट्रान 77) का उपयोग करने से उत्पन्न होती है, लेकिन आपको अभी भी उन्हें गोल्फ करने का प्रयास करने की उम्मीद है । एकल पत्र के लिए अपने पहचानकर्ताओं को कम करने की जहमत भी नहीं उठा रहा है, खेल की भावना में उतरने में असफल हो रहा है, जिस पर मुझे संदेह है।

— dmckee

गोल्फ में आपका स्वागत है! क्या आप अपने गोल्फ कोड को अपने अ-कोड कोड से अलग कर सकते हैं, और कृपया अपने गोल्फ कोड के लिए अपनी पोस्ट में एक चरित्र गणना डालें? धन्यवाद! यह आपकी पोस्ट को पढ़ने में थोड़ा आसान बना देगा और सामान्य पैटर्न है जिसका हम उपयोग करते हैं।

— मेलमोकब

कोड गोल्फ का लक्ष्य सबसे छोटा कोड संभव बनाना है। तुम्हारा बल्कि क्रियात्मक है, इसलिए कठिन प्रयास करें!

— फूजएक्सएक्सएल

Answer 8

पायथन, 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

वेंटरो के रूबी समाधान के समान।

Answer 9

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.

Answer 10

क्लोजर, 102 बाइट्स

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

Answer 11

जाप , 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