Schiebetüren haben je nach Türbreite unterschiedliche Preise. Die unterschiedlichen Preise sind wie folgt:

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

Wenn Sie einen Schrank kaufen, möchten Sie natürlich die Kosten minimieren. Ihre Aufgabe ist es daher, die Breite der Türen zu ermitteln, die die Gesamtkosten basierend auf der Gesamtbreite des Schranks minimiert.

Regeln:

• Die Gesamtbreite wird als Eingabe verwendet
• Alle Türen haben die gleiche Breite
• Wählen Sie die kleinsten Türen, wenn zwei Arten von Türen gleich viel kosten
• Die Breiten sind in Zentimetern angegeben, ganze Zahlen und keine Dezimalstellen
  • Dezimalstellen aufrunden
• Der Preis wird als Ganzzahl zurückgegeben (kein Währungssymbol erforderlich)
• Die Ein- und Ausgabeformate sind optional, aber die Reihenfolge der Ausgabe muss sein: Number of doors, Width, Price.
• Die Eingabe wird im Bereich liegen [120 1000).

Das ist Code Golf. Kürzester Code in Bytes gewinnen.

Beispiele:

Input: 156
Output: 2, 78, 300

Input: 331
Output: 3, 111, 660

Input: 420
Output: 4, 105, 880

05AB1E , 47 Bytes

Code:

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

Nicht die beste Vorlage, aber zumindest etwas :)

Probieren Sie es online!

JavaScript (ES6), 101 Byte

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) ist dasselbe wie Math.ceil (a / b) in 31-Bit-Ganzzahlen.

Perl, 190 180 154 133 128 117 Bytes

beinhaltet +1 für -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"

Kommentiert:

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"

• Sparen Sie 11 Bytes, indem Sie Hash in zwei Arrays einbetten und aufteilen

• Sparen Sie 5 Bytes mit -p(danke an @ dev-null)

• Sparen Sie 18 Bytes mit POSIX :: ceil und 3 weitere Bytes mit Listensyntax für Hash (danke an @ msh210)

PowerShell, 137 - 135 Byte

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

Die Ausgabe ist durch Zeilenumbrüche getrennt.

Wir nehmen Input $a, setzen unsere Kosten $jauf 9000000000(eine große Zahl, die weitaus mehr ist, als wir jemals brauchen würden). Als nächstes machen wir eine Schleife 60..120mit |%{...}. Bei jeder Iteration berechnen wir den $pPreis des aktuellen Artikels mit einer pseudo-ternären Aussage und berechnen dann die $cObergrenze von $a/$_. Wenn die aktuelle Summe kleiner ist als die kleinste Summe, die wir gesehen haben ( $j), speichern Sie alle diese Variablen: $j(die Summe), $k(die Anzahl der erforderlichen Türen) und $i(die Türbreite), und setzen Sie die Schleife fort. Sobald die Schleife beendet ist, geben Sie einfach die besten Werte aus.

_{Bearbeiten - Zwei Bytes durch Verschieben der Zuweisungen $cund $pin die ifBedingung gespeichert}

Pyth, 65 Bytes

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

Probieren Sie es hier aus!

Erläuterung

Zunächst wird eine Liste aller möglichen Kombinationen von Türanzahl und Türbreite erstellt und der Preis für jede dieser Kombinationen berechnet. Dann müssen wir es nur noch nach Preis und Türbreite bestellen und das erste Element der resultierenden Liste entnehmen.

Codeerklärung folgt, nachdem ich dieses unten Golf gespielt habe Bitte hilf mir, Golf zu spielen, das ist viel zu lang.

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

                                                   m r2 17 # Kartenbereich (2,17) bis
                                                    [d) # Liste mit der Türanzahl zuerst
                                                      .EcQd # und Breite Sekunde
                                        f # Kartenergebnis mit T filtern
                                         } r60 121 # in Reichweite (60,121)
                                          eT # Türbreite
          m # Kartenfilter Ergebnis mit d
           [d) # zu einer Liste mit der Anzahl und Breite der Türen zuerst
             * hd # Mult Tür zählen mit
                ?> 81ed150? <101ed220 200 # Preis pro Tür, einfache Suche mit Ternaries
 o # Kartenergebnis mit N bestellen
  + eNcehNT # Bestellschlüssel = Preis + Breite / 10
Das erste Element ist das Beste

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]

Wie von @Neil angegeben, =-~(~-n/d)entspricht dies einer Division mit Aufrundung für ganze Zahlen von 32 Bit oder weniger.

R , 135 104 Bytes

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

Probieren Sie es online!

31 Bytes von gespeichert

• Zahlen dekomprimieren
• mit utf8ToInt
• mit "!" Funktionsaufruf verkürzen
• mit vektorisierten Funktionen
• Gesamtlänge nicht definieren
• Verwenden Sie cbinddirekt anstatt nach dem Definieren von Variablen

Wie es funktioniert:

1. approxGibt den Preis einer einzelnen Tür basierend auf ihrer Länge zurück. Es kehrt NAaußerhalb des Bereichs zurück [60,120].
2. Aufgrund der Spezifikation darf die Gesamtzahl der Türen nicht mehr als 16 betragen (Gesamtlänge 1000). Alle Türenzahlen von 16 bis 1 werden getestet, und das Triplet (number of doors, door width, total price)wird zurückgesandt.
3. Die orderFunktion wird verwendet, um den Mindestpreis zu ermitteln. Darauf basierend wird das richtige Triplett extrahiert. Im Falle von Gleichstand order wird der zuerst eintretende Eintrag zurückgegeben, und da wir von 16 auf 1 geschleift sind, wird die größte Anzahl von Türen (kleinste Türbreite) zurückgegeben.