Blöcke stapeln

Geben Sie bei Eingabe einer Liste von Blöcken, die an bestimmten Punkten abgelegt werden sollen, die Höhe des resultierenden "Turms" aus.

Diese Herausforderung lässt sich am besten anhand eines Beispiels erklären. Die Eingabe ist eine Liste von 2n ganzen Zahlen, die n Blöcke darstellen. Die erste Ganzzahl ist die x-Position des Blocks, 0-indiziert, und die zweite ist die Breite des Blocks. Beispielsweise stellt eine Eingabe von 2 4den Block dar (mit den unten angegebenen x-Koordinaten):

  ####
0123456789

Nehmen wir an, die Eingabe ist 2 4 4 6. Das heißt, ein Block bei x = 2 mit einer Breite von 4 und einer bei x = 4 mit einer Breite von 6:

    ######
  ####

Beachten Sie, dass a.) Blöcke immer von der Spitze des Turms "fallen" und b.) Blöcke niemals "umfallen" (dh sie balancieren immer). Eine Eingabe von 2 4 4 6 12 1stellt also Folgendes dar:

    ######
  ####      #

Beachten Sie, dass der letzte Block bis zum "Boden" gefallen ist.

Ihre endgültige Ausgabe sollte die maximale Höhe des Turms bei jedem x-Wert bis zum größten sein. Daher sollte die Eingabe 2 4 4 6 12 1zur Ausgabe führen 0011222222001:

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

Die Eingabe kann entweder als durch Leerzeichen / Komma getrennte Zeichenfolge, als Array von Ganzzahlen oder als Funktions- / Befehlszeilenargument erfolgen. Die Blockpositionen (x-Werte) sind immer ganze Zahlen von 0 oder mehr, die Breite ist immer eine ganze Zahl von 1 oder mehr und es gibt immer mindestens einen Block.

Die Ausgabe kann als einzelne Zeichenfolge, die durch nicht numerische Zeichen getrennt ist (z. B. "0, 0, 1, ..."), als einzelne Zeichenfolge, in der alle Ziffern aufgelistet sind (z. "001..."B. - die maximale Höhe darf garantiert 9 oder weniger betragen), oder als Array von Ganzzahlen erfolgen.

Da es sich um Code-Golf , wird der kürzeste Code in Bytes gewinnen.

Testfälle:

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

CJam, 34 30 Bytes

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

Eingabe als Array im CJam-Stil, Ausgabe als Ziffernfolge.

Führen Sie alle Testfälle aus.

Hier sind zwei Varianten einer anderen Idee, die jedoch derzeit 2 Byte länger ist:

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

Python 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

Probieren Sie es online aus .

Die Funktion nimmt eine Liste von ganzen Zahlen auf und gibt sie zurück.

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

Rubin, 88 87 Bytes

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}

Probieren Sie es online aus.

Inspiriert von der Antwort von grc, aber in einer anderen Sprache und nur etwas kürzer.

Erläuterung:

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
}

APL, 79 Bytes

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

Eingabe als APL-Array, Ausgabe als APL-Array von Ziffern.

Java 1.8, 351 329 Bytes

Ich bin nicht begeistert von diesem ersten Versuch - ich bin sicher, dass das Double-Looping und alle diese Integer.valueOf's noch mehr Golf spielen können.

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]);
    }
}
}