Las puertas correderas tienen precios variables según el ancho de las puertas. Los diferentes precios son los siguientes:

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

Al comprar un armario, obviamente querrás minimizar el costo, por lo que tu tarea es encontrar el ancho de las puertas que minimice el costo total en función del ancho total del armario.

Reglas:

• El ancho total se tomará como entrada
• Todas las puertas tendrán el mismo ancho.
• Elija las puertas más pequeñas si dos tipos de puertas cuestan lo mismo
• Los anchos son en centímetros, los enteros no son decimales
  • Redondear decimales
• El precio se devolverá como un número entero (no es necesario el signo de moneda)
• Los formatos de entrada y de salida son opcionales, pero el orden de la salida deben ser: Number of doors, Width, Price.
• La entrada estará en el rango [120 1000).

Este es el código de golf. El código más corto en bytes gana.

Ejemplos:

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*=

No es la mejor presentación, pero al menos algo :)

Pruébalo en línea!

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) es lo mismo que Math.ceil (a / b) en enteros de 31 bits.

Perl, 190 180 154 133 128 117 bytes

incluye +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"

• Ahorre 11 bytes alineando y dividiendo hash en dos matrices

• Ahorre 5 bytes utilizando -p(gracias a @ dev-null)

• Ahorre 18 bytes usando POSIX :: ceil y 3 más usando la sintaxis de lista para hash (gracias 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

La salida está separada por una nueva línea.

Tomamos información $a, establecemos nuestro costo $jen 9000000000(un gran número que es mucho más de lo que necesitaríamos). A continuación, hacemos un bucle 60..120con |%{...}. Cada iteración calculamos el $pprecio del artículo actual con una declaración pseudoternaria , luego calculamos el $clímite máximo de $a/$_. Si el total actual es más pequeño que el total más pequeño que hemos visto ( $j), guarde todas estas variables: $j(el total), $k(el número de puertas requerido) y $i(el ancho de la puerta), y continúe con el ciclo. Una vez que finaliza el ciclo, solo genera los mejores valores.

_{Editar: guardado dos bytes moviendo las asignaciones $cy $pal ifcondicional}

Pyth, 65 bytes

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

Pruébalo aquí!

Explicación

Primero, esto genera una lista de todas las combinaciones posibles de cuenta / ancho de puerta y calcula el precio de cada una de esas combinaciones. Luego solo tenemos que ordenarlo por precio y ancho de puerta y tomar el primer elemento de la lista resultante.

La explicación del código sigue después de jugar golf, ayúdame a jugar golf, esto es demasiado largo.

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

                                                   m r2 17 # rango del mapa (2,17) a
                                                    [d) # lista con número de puertas primero
                                                      .EcQd # y ancho segundo
                                        f # Filtrar el resultado del mapa con T
                                         } r60 121 # en rango (60,121)
                                          eT # ancho de puerta
          m # resultado del filtro de mapa con d
           [d) # a una lista con recuento de puertas y ancho primero
             * HD # cuenta con múltiples puertas con
                ?> 81ed150? <101ed220 200 # precio por puerta, búsqueda simple con terrarios
 o # resultado del mapa de pedido con N
  + eNcehNT # clave de pedido = precio + ancho / 10
h # primer elemento es el mejor

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]

Como señaló @Neil, =-~(~-n/d)es equivalente a la división con redondeo para números enteros de 32 bits o menos.

R , 135104 bytes

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

Pruébalo en línea!

Guardado 31 bytes por

• números descomprimidos
• utilizando utf8ToInt
• utilizando "!" acortar llamada de función
• usando funciones vectorizadas
• no define la longitud total
• usando cbinddirectamente en lugar de después de definir variables

Cómo funciona:

1. approxdevuelve el precio de una sola puerta en función de su longitud. Regresa NAfuera del rango [60,120].
2. Según la especificación, el número total de puertas no puede ser superior a 16 (longitud total 1000). Se prueban todas las puertas de 16 a 1 y (number of doors, door width, total price)se devuelve el triplete .
3. La orderfunción se utiliza para ubicar el precio mínimo; el triplete correcto se extrae en base a eso. En caso de empate, order devolverá la entrada que viene primero, y dado que recorrimos de 16 a 1 , se devolverá el mayor número de puertas (ancho de puerta más pequeño).