Khối xếp chồng

Đưa ra một đầu vào của một danh sách các khối để thả tại các điểm nhất định, xuất ra chiều cao của "tháp" kết quả.

Cách tốt nhất để giải thích thách thức này là ví dụ. Đầu vào sẽ là danh sách các số nguyên 2n đại diện cho n khối. Số nguyên đầu tiên là vị trí x của khối, được lập chỉ mục 0 và thứ hai là khối này rộng bao nhiêu. Ví dụ: một đầu vào 2 4đại diện cho khối (với tọa độ x được dán nhãn bên dưới):

  ####
0123456789

Bây giờ, giả sử đầu vào là 2 4 4 6. Nghĩa là, một khối tại x = 2 có chiều rộng là 4 và một khối tại x = 4 có chiều rộng là 6:

    ######
  ####

Lưu ý rằng các khối a.) Luôn "thả" từ đỉnh tháp và khối b.) Sẽ không bao giờ "đổ" (tức là chúng sẽ luôn cân bằng). Vì vậy, một đầu vào 2 4 4 6 12 1đại diện:

    ######
  ####      #

Lưu ý rằng khối cuối cùng đã rơi xuống "mặt đất".

Đầu ra cuối cùng của bạn phải là chiều cao tối đa của tháp ở mỗi giá trị x lên đến lớn nhất. Do đó, đầu vào 2 4 4 6 12 1sẽ dẫn đến đầu ra 0011222222001:

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

Đầu vào có thể được cung cấp dưới dạng một chuỗi được phân tách bằng khoảng trắng / dấu phẩy, một mảng các số nguyên hoặc các đối số dòng lệnh / hàm. Vị trí khối (giá trị x) sẽ luôn là số nguyên 0 hoặc lớn hơn, chiều rộng sẽ luôn là số nguyên 1 hoặc lớn hơn và sẽ luôn có ít nhất một khối.

Đầu ra có thể được cung cấp dưới dạng một chuỗi được phân tách bằng các ký tự không phải là số (ví dụ "0, 0, 1, ..."), một chuỗi đơn liệt kê tất cả các chữ số (ví dụ: "001..."chiều cao tối đa được đảm bảo là 9 hoặc ít hơn) hoặc một mảng các số nguyên.

Vì đây là môn đánh gôn , mã ngắn nhất tính bằng byte sẽ thắng.

Các trường hợp thử nghiệm:

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>}/

Nhập dưới dạng mảng kiểu CJam, xuất dưới dạng một chuỗi các chữ số.

Chạy tất cả các trường hợp thử nghiệm.

Đây là hai biến thể của một ý tưởng khác, nhưng hiện tại nó dài hơn 2 byte:

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

Con trăn 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

Hãy thử trực tuyến .

Hàm lấy và trả về một danh sách các số nguyên.

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

Hồng ngọc 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}

Hãy thử trực tuyến.

Lấy cảm hứng từ câu trả lời của grc, nhưng trong một ngôn ngữ khác và chỉ ngắn hơn một chút.

Giải trình:

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×≢⍵)⍴⍵}

Nhập dưới dạng Mảng APL, đầu ra dưới dạng mảng APL gồm các chữ số.

Java 1.8, 351 329 byte

Không vui mừng với lần thử đầu tiên này - Tôi chắc chắn rằng vòng lặp kép và tất cả những Integer.valueOf đó có thể được chơi thêm một số lần nữa.

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

Ung dung

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