У мене є купа дощок, які мені потрібно скласти в якомога менше місця. На жаль, дошки обвалюються, якщо я укладаю їх понад 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]

Спробуйте в Інтернеті!

Обидва рішення, ймовірно, могли би бути в гольфі зовсім небагато.