Tôi có một loạt các bảng tôi cần phải xếp trong một không gian nhỏ nhất có thể. Thật không may, các bảng rơi xuống nếu tôi xếp chúng cao hơn 10. Tôi cần một chương trình để cho tôi biết làm thế nào để xếp các tấm ván để có ít không gian ngang nhất có thể, mà không cần xếp chồng các tấm gỗ cao hơn mười, hoặc có các tấm ván treo trên không gian trống.

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm, khi được cung cấp một mảng chứa độ dài của các bảng, xuất ra dưới dạng nghệ thuật ASCII, cách xếp chồng các bảng để bảo tồn càng nhiều không gian ngang càng tốt, mà không xếp chồng các bảng cao hơn 10 hoặc có bất kỳ phần nào của bất kỳ bảng treo trên không gian trống. Nghệ thuật ASCII của bạn sẽ hiển thị cấu hình của các bảng, với mỗi bảng được hiển thị bằng một ký tự khác nhau. Sẽ có tối đa 20 bảng. Ví dụ: nếu đầu vào là [2,2,4,2,2,4,4], thì đầu ra có thể là:

dhh
dgg
dff
dee
abc
abc
abc
abc

đó là một cấu hình ổn định (mặc dù điều này sẽ giảm trong ~ 0,1 giây trong cuộc sống thực).

Đầu vào:

Một mảng chứa tối đa 20 số nguyên, hiển thị độ dài của bảng.

Đầu ra:

Nghệ thuật ASCII hiển thị các cấu hình của bảng, như đã nêu ở trên.

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

Lưu ý rằng có thể có các giải pháp khác cho các trường hợp thử nghiệm và các ký tự hiển thị cho mỗi bảng có thể khác nhau.

[12,2,2,2,3,4,4,8,8]        -> ffgghhiii
                               ddddeeeeeeee
                               bbbbbbbbcccc
                               aaaaaaaaaaaa

[4,4,4,4,4,4,4,4,4,4,4,4]   -> llll
                               aaaa
                               cfghk
                               cfghk
                               cfghk
                               cfghk
                               debij
                               debij
                               debij
                               debij

[4,4,4,4,4,4,3,3,3,2,2,2,1] -> jjml
                               iiil
                               hhhk
                               gggk
                               ffff
                               eeee
                               dddd
                               cccc
                               bbbb
                               aaaa

Ghi điểm:

Đây là môn đánh gôn , điểm số thấp nhất tính theo byte

Python 3 , 513 512 511 509 499 497 485 465 459 458 444 byte

Thời gian chạy cực kỳ tồi tệ, sẽ kết thúc tại một số điểm

e,j,c=enumerate,len,range
def f(n,p=[],o=97):
    r,l,m=lambda x:min(b,f(n[:i]+n[i+1:],x,o+1),key=j),chr(o),j(p)
    b=[p,l*(sum(n)*2+m)][n>[]]
    for i,a in e(n):
        for h,d in e(p):
            if a<11-j(d):b=r([p[f]+l*a*(f==h)for f in c(m)])
            if(j(d)<10)*all(j(x)==j(d)for x in p[h:h+a])*(a<=m-h):b=r([p[f]+l*(h<=f<h+a)for f in c(m)])
        if a<11:b=r(p+[l*a])
        b=r(p+[l]*a)
    return["\n".join("".join(9-u<j(x)and x[9-u]or" "for x in b)for u in c(10)),b][o>97]

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

Chỉnh sửa: - 2 -8 byte nhờ @Mr. Xcoder Chỉnh sửa: -8 byte nhờ @notjagan

Giải trình

e,j,c=enumerate,len,range      
         # These built-ins are used a lot
def f(n,p=[],o=97):
         # n is the remaining blocks
         # p is the current stack
         # o is the ASCI code for the next letter to use
    r,l,m=lambda x:min(b,f(n[:i]+n[i+1:],x,o+1),key=j),chr(o),j(p)
         # r is the recursive call, that also selects the smallest stack found
         # l is the letter to use next
         # m is the length of the current stack
    b=[p,l*(sum(n)*2+m)][n>[]]
         # Sets the current best, if there are no remaining blocks, select the found stack, else we set it to be worse than the possible worst case
    for i,a in e(n):
         # Loop through all the remaining blocks
        for h,d in e(p):
         # Loop through all the columns in the current stack
            if a<11-j(d):b=r([p[f]+l*a*(f==h)for f in c(m)])
         # If we can place the current block vertically in the current column, try it
            if(j(d)<10)*all(j(x)==j(d)for x in p[h:h+a])*(a<=m-h):b=r([p[f]+l*(h<=f<h+a)for f in c(m)])
         # If we can place the current block horizontally starting in the current column, try it
        if a<11:b=r(p+[l*a])
         # If the current block is lower than 10, try place it vertically to the right of the current stack
        b=r(p+[l]*a)
         # Try to place the current horizontally to the right of the current stack
    return["\n".join("".join(9-u<j(x)and x[9-u]or" "for x in b)for u in c(10)),b][o>97]
         # Return the best choice if we aren't in the first call to the function, that is the next letter is a. Else return the found best option formatted as a string

Python 3 , 587 byte

Trên thực tế có thể chạy trên TIO cho một số trường hợp thử nghiệm

e,j,c=enumerate,len,range
def f(n,p=[],o=97,b=[]):
    if(not n):return p
    if not b:b="a"*sum(n)*2
    r,q,s,l,m=lambda x:q(f(n[:i]+n[i+1:],x,o+1,b)),lambda x:[b,x][j(b)>j(x)],b,chr(o),j(p)
    if j(b)<=m:return b
    for i,a in e(n):
        for h,d in e(p):
            if a<11-j(d):b=r([p[f]+l*a*(f==h)for f in c(m)])
            if j(d)<10 and a<=m-h and all(map(lambda x:j(x)==j(d),p[h:h+a])):b=r([p[f]+l*(h<=f<h+a)for f in c(m)])
        if s==b:
            if a<11and m+1<j(b):b=r(p[:]+[l*a])
            if m+a<j(b):b=r(p[:]+[l for r in c(a)])
    return["\n".join("".join(map(lambda x:" "if u>=j(x)else x[u],b))for u in c(9,-1,-1)),b][o>97]

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

Cả hai giải pháp có thể có thể được chơi golf khá nhiều.