Blocs d'empilage

Étant donné l'entrée d'une liste de blocs à déposer à certains points, affichez la hauteur de la "tour" résultante.

La meilleure façon d'expliquer ce défi est par l'exemple. L'entrée sera une liste de 2n entiers représentant n blocs. Le premier entier est la position x du bloc, indexé 0, et le second est la largeur du bloc. Par exemple, une entrée de 2 4représente le bloc (avec les coordonnées x marquées ci-dessous):

  ####
0123456789

Maintenant, disons que l'entrée est 2 4 4 6. Autrement dit, un bloc à x = 2 avec une largeur de 4, et un à x = 4 avec une largeur de 6:

    ######
  ####

Notez que a.) Les blocs "tombent" toujours du haut de la tour et b.) Les blocs ne "tomberont" jamais (c'est-à-dire qu'ils seront toujours en équilibre). Ainsi, une entrée de 2 4 4 6 12 1représente:

    ######
  ####      #

Notez que le bloc final est tombé jusqu'au «sol».

Votre sortie finale doit être la hauteur maximale de la tour à chaque valeur x jusqu'à la plus grande. Par conséquent, l'entrée 2 4 4 6 12 1devrait entraîner une sortie 0011222222001:

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

L'entrée peut être donnée sous la forme d'une chaîne séparée par des espaces / virgules, un tableau d'entiers ou des arguments de ligne de fonction / commande. Les positions des blocs (valeurs x) seront toujours des entiers 0 ou plus, la largeur sera toujours un entier 1 ou plus, et il y aura toujours au moins un bloc.

La sortie peut être donnée sous la forme d'une chaîne unique séparée par des caractères non numériques (par exemple "0, 0, 1, ..."), une chaîne unique répertoriant tous les chiffres (par exemple "001...", la hauteur maximale est garantie à 9 ou moins) ou un tableau d'entiers.

Puisqu'il s'agit de code-golf , le code le plus court en octets gagnera.

Cas de test:

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 octets

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

Entrée sous forme de tableau de style CJam, sortie sous forme de chaîne de chiffres.

Exécutez tous les cas de test.

Voici deux variantes d'une autre idée, mais elle est actuellement de 2 octets de plus:

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

Essayez-le en ligne .

La fonction prend et retourne une liste d'entiers.

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

Rubis, 88 87 octets

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}

Essayez-le en ligne.

Inspiré par la réponse de grc, mais dans une langue différente et juste un peu plus courte.

Explication:

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 octets

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

Entrée en tant que tableau APL, sortie en tant que tableau APL de chiffres.

Java 1,8, 351 329 octets

Pas ravi de cette première tentative - je suis sûr que la double boucle, et tous ces Integer.valueOf peuvent être joués un peu plus.

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

Non golfé

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