As portas deslizantes têm preços variados com base na largura das portas. Os preços diferentes são os seguintes:

• 60 - 80 cm: ¤150
• 81 - 100 cm: ¤200
• 101 - 120 cm: ¤220

Ao comprar um armário, obviamente, você deseja minimizar o custo; portanto, sua tarefa é encontrar a largura das portas que minimiza o custo total com base na largura total do armário.

Regras:

• A largura total será tomada como entrada
• Todas as portas terão a mesma largura
• Escolha as portas menores se dois tipos de portas custarem o mesmo
• As larguras estão em centímetros, números inteiros não decimais
  • Decimais arredondados
• O preço deve ser retornado como um número inteiro (não é necessário o sinal de moeda)
• Os formatos de entrada e saída são opcionais, mas a ordem da saída deve ser: Number of doors, Width, Price.
• A entrada estará no intervalo [120 1000).

Isso é código de golfe. O código mais curto em bytes vence.

Exemplos:

Input: 156
Output: 2, 78, 300

Input: 331
Output: 3, 111, 660

Input: 420
Output: 4, 105, 880

05AB1E , 47 bytes

Código:

D120/ó>DU=/ó>=D101›iX220*=q}D80›iX200*=q}X150*=

Não é a melhor apresentação, mas pelo menos alguma coisa :)

Experimente online!

JavaScript (ES6), 101 bytes

t=>[[80,150],[100,200],[120,220]].map(([w,p])=>[n=-~(~-t/w),-~(~-t/n),n*p]).sort((a,b)=>a[2]-b[2])[0]

-~(~-a/b) é o mesmo que Math.ceil (a / b) em números inteiros de 31 bits.

Perl, 190 180 154 133 128 117 bytes

inclui +1 para -p

use POSIX;$m=1E4;for$q(80,100,120){($m,@z)=($p,$n,ceil$_/$n)if$m>($p=(150,200,220)[$x++]*($n=ceil$_/$q))}$_="@z $m"

Comentado:

use POSIX;                                  # for ceil()
$m = 1E4;                                   # init min price to 10k
for $q (80,100,120) {                       # iterate widths
    ($m,@z) = ($p,$n, ceil $_/$n)           # update min, output
    if $m > (                               #
       $p = (150,200,220)[$x++]             # grab price
          * ( $n = ceil $_/$q )             # times nr of doors needed
    )
}
$_="@z $m"

• Salve 11 bytes inserindo e dividindo o hash em duas matrizes

• Salve 5 bytes usando -p(graças a @ dev-null)

• Economize 18 bytes usando POSIX :: ceil e mais 3 usando a sintaxe da lista para hash (graças a @ msh210)

PowerShell, 137 135 bytes

param($a)$j=9e9;60..120|%{if((($c=[math]::ceiling($a/$_))*($p=(220,(200,150)[$_-le80])[$_-le100]))-lt$j){$j=($k=$c)*$p;$i=$_}}
$k;$i;$j

A saída é separada por nova linha.

Tomamos informações $a, definimos nosso custo $jpara 9000000000(um grande número que é muito mais do que precisaríamos). Em seguida, passamos de 60..120com |%{...}. Cada iteração calcula o $ppreço do item atual com uma declaração pseudo-ternária e calcula o $cteto de $a/$_. Se o total atual for menor que o menor que já vimos ( $j), salve todas essas variáveis: $j(o total), $k(o número de portas necessárias) e $i(a largura da porta) e continue o loop. Quando o loop terminar, basta exibir os melhores valores.

_{Editar - salvou dois bytes movendo as atribuições $ce $ppara a ifcondição}

Pitão, 65 bytes

ho+eNcehNTm[d*hd?>81ed150?<101ed220 200)f}eTr60 121m[d.EcQd)r2 17

Experimente aqui!

Explicação

Primeiro, isso gera uma lista de todas as combinações possíveis de contagem / largura de porta e calcula o preço de cada uma dessas combinações. Depois, basta solicitar por preço e largura da porta e pegar o primeiro elemento da lista resultante.

A explicação do código segue depois que eu joguei isso para baixo Por favor me ajude a jogar isso, isso é muito longo.

ho + eNcehNTm [d * hd?> 81ed150? <101ed220 200) f} eTr60 121m [d.EcQd) r2 17 # Q = entrada

                                                   m r2 17 # faixa de mapa (2,17) a
                                                    [d) # lista com contagem de portas primeiro
                                                      .EcQd # e largura em segundo
                                        f # Filtre o resultado do mapa com T
                                         } r60 121 # no intervalo (60.121)
                                          largura da porta eT #
          resultado do filtro m # map com d
           [d) # para uma lista com número e largura de portas primeiro
             * número de portas hd # mult com
                ?> 81ed150? <101ed220 200 # preço por porta, consulta simples com ternários
 o # ordem do resultado do mapa com N
  + eNcehNT # chave do pedido = preço + largura / 10
h # primeiro elemento é o melhor

JavaScript (ES6) 96

n=>[80,100,120].map((d,i)=>[d=-~(~-n/d),-~(~-n/d),d*[150,200,220][i]]).sort((a,b)=>a[2]-b[2])[0]

Conforme observado por @Neil, =-~(~-n/d)é equivalente à divisão com arredondamentos para números inteiros de 32 bits ou menos.

R , 135 104 bytes

"!"=utf8ToInt;cbind(n<-16:1,w<-ceiling(scan()/n),p<-n*approx(!"<Qex",!"–ÈÜÜ",w,"c")$y)[order(p)[1],]

Experimente online!

Salvo 31 bytes por

• descomprimir números
• usando utf8ToInt
• usando "!" reduzir a chamada de função
• usando funções vetorizadas
• não definindo comprimento total
• usando cbinddiretamente ao invés de definir variáveis

Como funciona:

1. approxretorna o preço de uma única porta com base no seu comprimento. Retorna NAfora do intervalo [60,120].
2. Com base nas especificações, o número total de portas não pode ser superior a 16 (comprimento total 1000). Todo o número de portas de 16 a 1 é testado e o trio (number of doors, door width, total price)é retornado.
3. A orderfunção é usada para localizar o preço mínimo; o trigêmeo correto é extraído com base nisso. Em caso de empate, order retornará a entrada que vem primeiro e, como passamos de 16 para 1, o maior número de portas (menor largura de porta) será retornado.