स्टैकिंग ब्लॉक

Question

कुछ बिंदुओं पर ड्रॉप करने के लिए ब्लॉकों की एक सूची के इनपुट को देखते हुए, परिणामस्वरूप "टॉवर" की ऊंचाई का उत्पादन करें।

इस चुनौती को समझाने का सबसे अच्छा तरीका है उदाहरण। इनपुट एन ब्लॉक का प्रतिनिधित्व करने वाले 2 एन पूर्णांक की एक सूची होगी । पहला पूर्णांक ब्लॉक की x स्थिति, 0-अनुक्रमित है, और दूसरा यह है कि ब्लॉक कितना चौड़ा है। उदाहरण के लिए, एक इनपुट ब्लॉक का प्रतिनिधित्व करता है (नीचे दिए गए x निर्देशांक के साथ):2 4

  ####
0123456789

अब, मान लें कि इनपुट है 2 4 4 6। अर्थात्, x = 2 पर 4 की चौड़ाई के साथ एक ब्लॉक, और 6 की चौड़ाई के साथ x = 4 पर एक:

    ######
  ####

ध्यान दें कि टॉवर और बी के ऊपर से ए।) ब्लॉक हमेशा "ड्रॉप" करता है। ब्लॉक कभी भी "फॉल ओवर" नहीं होगा (यानी वे हमेशा संतुलन बनाएंगे)। तो, एक इनपुट का 2 4 4 6 12 1प्रतिनिधित्व करता है:

    ######
  ####      #

ध्यान दें कि अंतिम ब्लॉक "जमीन" के सभी रास्ते गिर गए हैं।

आपका अंतिम आउटपुट टॉवर की अधिकतम ऊंचाई प्रत्येक x-मान पर सबसे बड़ा होना चाहिए। इसलिए, इनपुट 2 4 4 6 12 1को आउटपुट में परिणामित करना चाहिए 0011222222001:

    ######
  ####      #
0011222222001

इनपुट या तो व्हाट्सएप के रूप में दिए जा सकते हैं- / अल्पविराम से अलग किए गए स्ट्रिंग, पूर्णांक का एक सरणी, या फ़ंक्शन / कमांड लाइन तर्क। ब्लॉक स्थिति (x मान) हमेशा पूर्णांक 0 या अधिक होगी, चौड़ाई हमेशा पूर्णांक 1 या अधिक होगी, और हमेशा कम से कम एक ब्लॉक होगा।

आउटपुट को एक एकल स्ट्रिंग के रूप में दिया जा सकता है जो गैर-संख्यात्मक वर्णों (उदा। "0, 0, 1, ...") द्वारा अलग किया जाता है , एक एकल स्ट्रिंग सभी अंकों को सूचीबद्ध करता है (उदा। "001..."अधिकतम ऊंचाई 9 या उससे कम होने की गारंटी है), या पूर्णांक की एक सरणी।

चूंकि यह कोड-गोल्फ है , बाइट्स में सबसे छोटा कोड जीत जाएगा।

परीक्षण के मामलों:

In                                   Out
---------------------------------------------------------
2 4 4 6 12 1                         0011222222001
0 5 9 1 6 4 2 5                      1133333222
0 5 9 1 2 5 6 4                      1122223333
0 5 2 5 6 4 9 1                      1122223334
20 1 20 1 20 1                       00000000000000000003
5 5                                  000011111
0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 4  123456789999

Comments

क्या हम 2-ट्यूपल्स की एक सरणी के रूप में इनपुट ले सकते हैं?

— lirtosiast

@ThomasKwa नहीं, इनपुट 1-आयामी सरणी होना चाहिए।

— दरवाज़े

Answer 1

CJam, 34 30 बाइट्स

Lq~2/{eeWf%e~_2$:).*:e>f*.e>}/

CJam- शैली सरणी के रूप में इनपुट, अंकों की एक स्ट्रिंग के रूप में आउटपुट।

सभी परीक्षण मामलों को चलाएं।

यहाँ एक और विचार के दो संस्करण हैं, लेकिन यह वर्तमान में 2 बाइट्स लंबा है:

Lq~2/{_:\3$><0+:e>)aeez.*e_.e>}/
LQ~2/{_:\3$><0+:e>)aeez.+e~.e>}/

Answer 2

पायथन 3, 89

def f(a):
 h=[]
 while a:x,w,*a=a;h[:x+w]=(h+[0]*x)[:x]+[max(h[x:x+w]+[0])+1]*w
 return h

इसे ऑनलाइन आज़माएं ।

फ़ंक्शन पूर्णांक की एक सूची लेता है और वापस करता है।

def f(a):                       # input as list of integers
  h=[]                          # list of heights
  while a:                      # while there's input left
    x,w,*a=a;                   # pop first 2 integers as x and w

    h[:x+w]=                    # change the heights between 0 and x+w
      (h+[0]*x)[:x]+            # left of x -> unchanged but padded with zeros
      [max(h[x:x+w]+[0])+1]*w   # between x and x+w -> set to the previous max + 1

  return h                      # return the list of heights

Answer 3

माणिक, 88 87 बाइट्स

f=->i{o=[]
(s,l,*i=i
r=s...s+l
o[r]=[([*o[r]]+[0]).max+1]*l
o.map! &:to_i)while i[0]
o}

इसे ऑनलाइन आज़माएं।

Grc के उत्तर से प्रेरित है, लेकिन एक अलग भाषा में और थोड़ा छोटा है।

स्पष्टीकरण:

f=->i                        # lambda with parameter i, expects array of ints
{
    o=[]                     # output
    (
        s,l,*i=i             # pop start and length
        r = s...s+l          # range is used twice, so shorten it to 1 char
        o[r] =
            [(
                    [*o[r]]  # o[r] returns nil if out of bounds, so splat it into another array
                    +[0]     # max doesn't like an empty array, so give it at least a 0
            ).max+1]*l       # repeat max+1 to fill length
        o.map! &:to_i        # replace nil values with 0
    ) while i[0]             # i[0] returns nil when i is empty, which is falsy
    o                        # return o
}

Answer 4

एपीएल, 79 बाइट्स

{⊃{o←(z←(≢⍵)⌈a←+/⍺)↑⍵⋄e←(z↑(-a)↑⍺[1]⍴1)⋄o+0⌈o-⍨e×e⌈.+e×o}/⌽(⊂⍬),↓(⌽2,0.5×≢⍵)⍴⍵}

एपीएल सरणी के रूप में इनपुट, अंकों के एपीएल सरणी के रूप में आउटपुट।

Comments

{⊃{o←⍵↑⍨z←(≢⍵)⌈a←+/⍺⋄e←z↑(-a)↑⍺[1]⍴1⋄o+0⌈o-⍨e×e⌈.+e×o}/⌽(⊂⍬),↓⍵⍴⍨⌽2,.5×≢⍵}(मेरे भगवान, ⍨सही उपयोग करना सीखें )

— ज़ाचरी

कृपया, अपने शब्दों के साथ सावधान रहें ... आप के बीच का अंतर पता नहीं लगता है ⊃और 1↑इस वजह से आप ऐसे सुझाव देते हैं जो अद्यतन प्रोग्राम को गलत परिणाम देते हैं, लेकिन मैं आपको संरक्षण नहीं देता।

— लेस्टिफ़ानो

हाँ, मुझे कभी-कभी ऐसा लगता है कि जब मैं चीजों का एक समूह देखता हूं , जो कि गोल्फ हो सकते हैं। लेकिन अन्य गोल्फ को अभी भी लागू करना चाहिए, हालांकि।

— Zacharý

वे सब करते हैं। और मैंने आपके सुझावों को एकीकृत किया है, उम्मीद है कि उचित क्रेडिट के साथ।

— lstefano

- - क्या तुमने? - -0.5

— Zacharý

Answer 5

जावा 1.8, 351 329 बाइट्स

इस पहले प्रयास से रोमांचित नहीं हूं - मुझे यकीन है कि डबल लूपिंग, और उन सभी Integer.valueOf को कुछ और गोल्फ दिया जा सकता है।

interface B{static void main(String[]x){Byte b=1;int i=0,s,c,m=0,h,a=x.length,t[];for(;i<a;){s=b.valueOf(x[i++]);c=b.valueOf(x[i++]);m=m>s+c?m:s+c;}t=new int[m];for(i=0;i<a;){h=0;s=b.valueOf(x[i++]);c=b.valueOf(x[i++]);for(m=s;m<s+c;m++)if(t[m]>=h)h=t[m]+1;for(m=s;m<s+c;)t[m++]=h;}for(i=0;i<t.length;)System.out.print(t[i++]);}}

Ungolfed

interface B {
static void main(String[]x){
    int start, count, maxWidth=0, height, args=x.length, totals[];
    Byte b=1;
    for (int i=0; i<args;){
        start = b.valueOf(x[i++]);
        count = b.valueOf(x[i++]);
        maxWidth = maxWidth>start+count ? maxWidth : start+count; 
    }
    totals=new int[maxWidth];
    for (int i=0; i<args;){
        height=0;
        start = b.valueOf(x[i++]);
        count = b.valueOf(x[i++]);
        for (int j = start; j<start+count; j++) {
            if (totals[j]>=height) {
                height=totals[j]+1;
            }
        }
        for (int j = start; j<start+count; j++) {
            totals[j] = height;
        }
    }
    for (int i=0;i<totals.length; i++){
        System.out.print(totals[i]);
    }
}
}