У меня есть куча досок, которые нужно разместить как можно меньше. К сожалению, доски падают, если я уложу их более чем на 10. Мне нужна программа, которая скажет мне, как складывать доски так, чтобы они занимали как можно меньше горизонтального пространства, без укладки досок высотой более десяти или без вывешивания досок над пустым пространством.

Твое задание:

Напишите программу или функцию, которая при наличии массива, содержащего длины досок, выводит как ASCII искусство укладки плат, чтобы сохранить как можно больше горизонтального пространства, без укладки досок высотой более 10 или наличия какой-либо части любого из них. доска висит над пустым пространством. Ваш ASCII-арт должен показывать конфигурацию досок, каждая из которых показана с использованием разных символов. Там будет максимум 20 досок. Например, если вход был [2,2,4,2,2,4,4,4], возможный вывод:

dhh
dgg
dff
dee
abc
abc
abc
abc

это стабильная конфигурация (хотя в реальной жизни это может упасть через ~ 0,1 секунды).

Входные данные:

Массив, содержащий до 20 целых чисел, показывающий длины досок.

Выход:

Искусство ASCII, показывающее конфигурации плат, как указано выше.

Тестовые случаи:

Обратите внимание, что могут быть другие решения для тестовых случаев, и символы, показанные для каждой доски, могут отличаться.

[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

Подсчет очков:

Это код-гольф , выигрывает самая низкая оценка в байтах

Python 3 , 513 512 511 509 499 497 485 465 459 458 444 байта

Невероятно плохое время выполнения, закончится в какой-то момент

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]

Попробуйте онлайн!

Изменить: - 2 -8 байт благодаря @Mr. Редактор Xcoder : -8 байт благодаря @notjagan

объяснение

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 байт

На самом деле работает на TIO для некоторых тестовых случаев

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]

Попробуйте онлайн!

Оба решения, вероятно, могли бы быть довольно удачными.