Stacking blocks
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
Try it online.
The function takes and returns a list of integers.
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
Ruby, 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}
Try it online.
Inspired by grc's answer, but in a different language and just slightly shorter.
Explanation:
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
}
CJam, 34 30 bytes
Lq~2/{eeWf%e~_2$:).*:e>f*.e>}/
Input as a CJam-style array, output as a string of digits.
Run all test cases.
Here are two variants of another idea, but it's currently 2 bytes longer:
Lq~2/{_:\3$><0+:e>)aeez.*e_.e>}/
LQ~2/{_:\3$><0+:e>)aeez.+e~.e>}/