Les portes coulissantes ont des prix variables en fonction de la largeur des portes. Les différents prix sont les suivants:

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

Lors de l'achat d'un placard, vous souhaiterez évidemment minimiser le coût, votre tâche consiste donc à trouver la largeur des portes qui minimise le coût total en fonction de la largeur totale du placard.

Règles:

• La largeur totale sera prise en entrée
• Toutes les portes auront la même largeur
• Choisissez les plus petites portes si deux types de portes coûtent le même prix
• Les largeurs sont en centimètres, les nombres entiers ne sont pas décimaux
  • Arrondir les décimales
• Le prix doit être retourné sous forme d'entier (pas besoin du signe de devise)
• Les formats d'entrée et de sortie sont facultatifs, mais l'ordre de la sortie doit être: Number of doors, Width, Price.
• L'entrée sera dans la plage [120 1000).

C'est le golf de code. Le code le plus court en octets gagne.

Exemples:

Input: 156
Output: 2, 78, 300

Input: 331
Output: 3, 111, 660

Input: 420
Output: 4, 105, 880

05AB1E , 47 octets

Code:

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

Pas la meilleure soumission, mais au moins quelque chose :)

Essayez-le en ligne!

JavaScript (ES6), 101 octets

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) est identique à Math.ceil (a / b) dans les entiers 31 bits.

Perl, 190 180 154 133 128 117 octets

comprend +1 pour -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"

Commenté:

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"

• Économisez 11 octets en insérant et en divisant le hachage en deux tableaux

• Économisez 5 octets en utilisant -p(grâce à @ dev-null)

• Économisez 18 octets en utilisant POSIX :: ceil et 3 autres en utilisant la syntaxe de liste pour le hachage (grâce à @ msh210)

PowerShell, 137 135 octets

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 sortie est séparée par des sauts de ligne.

Nous prenons des informations $a, fixons nos coûts $jà 9000000000(un grand nombre qui est bien plus que ce dont nous aurions besoin). Ensuite, nous bouclons 60..120avec |%{...}. À chaque itération, nous calculons le $pprix de l'article actuel avec une déclaration pseudo-ternaire , puis calculons le $cplafond de $a/$_. Si le total actuel est inférieur au plus petit total que nous ayons vu ( $j), enregistrez toutes ces variables: $j(le total), $k(le nombre de portes requises) et $i(la largeur de la porte), et continuez la boucle. Une fois la boucle terminée, il suffit de sortir les meilleures valeurs.

_{Édition - Enregistrement de deux octets en déplaçant les affectations $cet $pdans le ifconditionnel}

Pyth, 65 octets

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

Essayez-le ici!

Explication

Tout d'abord, cela génère une liste de toutes les combinaisons possibles de nombre de portes / largeur de porte et calcule le prix pour chacune de ces combinaisons. Il suffit ensuite de le commander par prix et largeur de porte et de prendre le premier élément de la liste résultante.

L'explication du code suit après avoir joué au golf. Aidez-moi à jouer au golf, c'est beaucoup trop long.

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

                                                   m r2 17 # plage de carte (2,17) à
                                                    [d) # liste avec le nombre de portes en premier
                                                      .EcQd # et largeur seconde
                                        f # Filtrer le résultat de la carte avec T
                                         } r60 121 # dans la plage (60,121)
                                          eT # largeur de porte
          m # résultat du filtre de carte avec d
           [d) # à une liste avec le nombre de portes et la largeur en premier
             * nombre de portes hd # mult avec
                ?> 81ed150? <101ed220 200 # prix par porte, recherche simple avec ternaires
 o # résultat de la carte d'ordre avec N
  + eNcehNT # clé de commande = prix + largeur / 10
h # le premier élément est le meilleur

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]

Comme indiqué par @Neil, =-~(~-n/d)équivaut à une division avec arrondi pour des nombres entiers de 32 bits ou moins.

R , 135104 octets

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

Essayez-le en ligne!

Enregistré 31 octets par

• décompression des nombres
• en utilisant utf8ToInt
• en utilisant "!" pour raccourcir l'appel de fonction
• en utilisant des fonctions vectorisées
• ne définissant pas la longueur totale
• utiliser cbinddirectement plutôt qu'après avoir défini des variables

Comment ça fonctionne:

1. approxrenvoie le prix d'une seule porte en fonction de sa longueur. Il revient en NAdehors de la plage [60,120].
2. Selon les spécifications, le nombre total de portes ne peut pas dépasser 16 (longueur totale 1000). Toutes les portes de 16 à 1 sont testées et le triplet (number of doors, door width, total price)est retourné.
3. La orderfonction est utilisée pour localiser le prix minimum; le triplet correct est extrait sur cette base. En cas d'égalité, order retournera l'entrée qui vient en premier, et puisque nous avons bouclé de 16 à 1, le plus grand nombre de portes (largeur de porte la plus petite) sera retourné.