Stacking blocks

Dato un input di un elenco di blocchi da rilasciare in determinati punti, genera l'altezza della "torre" risultante.

Il modo migliore per spiegare questa sfida è l'esempio. L'input sarà un elenco di 2n numeri interi che rappresentano n blocchi. Il primo numero intero è la posizione x del blocco, indicizzata 0, e il secondo è la larghezza del blocco. Ad esempio, un input di 2 4rappresenta il blocco (con le coordinate x etichettate di seguito):

  ####
0123456789

Ora, supponiamo che l'input sia 2 4 4 6. Cioè, un blocco in x = 2 con una larghezza di 4 e uno in x = 4 con una larghezza di 6:

    ######
  ####

Si noti che a.) I blocchi "cadono" sempre dalla cima della torre e b.) I blocchi non "cadono mai" (cioè si bilanciano sempre). Quindi, un input di 2 4 4 6 12 1rappresenta:

    ######
  ####      #

Si noti che l'ultimo blocco è caduto fino al "suolo".

L'output finale dovrebbe essere l'altezza massima della torre per ciascun valore x fino al massimo. Quindi, l'input 2 4 4 6 12 1dovrebbe risultare in output 0011222222001:

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

L'input può essere dato come una stringa separata da spazi bianchi / virgola, una matrice di numeri interi o argomenti della riga di comando / funzione. Le posizioni dei blocchi (valori x) saranno sempre numeri interi 0 o maggiori, la larghezza sarà sempre un numero intero 1 o maggiore e ci sarà sempre almeno un blocco.

L'output può essere dato come una singola stringa separata da caratteri non numerici (es. "0, 0, 1, ..."), Una singola stringa che elenca tutte le cifre (es. "001..."- l'altezza massima è garantita essere 9 o meno) o una matrice di numeri interi.

Poiché si tratta di code-golf , vincerà il codice più breve in byte.

Casi 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 byte

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

Input come un array in stile CJam, output come una stringa di cifre.

Esegui tutti i casi di test.

Ecco due varianti di un'altra idea, ma attualmente è più lunga di 2 byte:

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

Provalo online .

La funzione accetta e restituisce un elenco di numeri interi.

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

Rubino, 88 87 byte

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}

Provalo online.

Ispirato dalla risposta di grc, ma in una lingua diversa e leggermente più breve.

Spiegazione:

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 byte

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

Input come array APL, output come array APL di cifre.

Java 1.8, 351 329 byte

Non sono entusiasta di questo primo tentativo - sono sicuro che il doppio loop e tutti quelli di Integer.valueOf possano essere giocati ancora un po '.

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