Le porte scorrevoli hanno prezzi variabili in base alla larghezza delle porte. I diversi prezzi sono i seguenti:

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

Quando acquisti un armadio, ovviamente, vorrai minimizzare il costo, quindi il tuo compito è trovare la larghezza delle ante che minimizzi il costo totale in base alla larghezza totale dell'armadio.

Regole:

• La larghezza totale verrà presa come input
• Tutte le porte avranno la stessa larghezza
• Scegli le porte più piccole se due tipi di porte costano lo stesso
• Le larghezze sono in centimetri, numeri interi non decimali
  • Arrotondare i decimali
• Il prezzo deve essere restituito come intero (non è necessario il segno di valuta)
• I formati di ingresso e di uscita sono opzionali, ma l'ordine di uscita devono essere: Number of doors, Width, Price.
• L'ingresso sarà nell'intervallo [120 1000).

Questo è il codice golf. Il codice più corto in byte vince.

Esempi:

Input: 156
Output: 2, 78, 300

Input: 331
Output: 3, 111, 660

Input: 420
Output: 4, 105, 880

05AB1E , 47 byte

Codice:

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

Non la migliore presentazione, ma almeno qualcosa :)

Provalo 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) è uguale a Math.ceil (a / b) in numeri interi a 31 bit.

Perl, 190 180 154 133 128 117 byte

include +1 per -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"

ha commentato:

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"

• Salvare 11 byte incorporando e suddividendo l'hash in due array

• Salva 5 byte usando -p(grazie a @ dev-null)

• Risparmia 18 byte utilizzando POSIX :: ceil e altri 3 utilizzando la sintassi dell'elenco per l'hash (grazie a @ 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

L'output è separato da una nuova riga.

Prendiamo input $a, impostiamo i nostri costi $jsu 9000000000(un numero elevato che è molto più di quanto avremmo mai bisogno). Quindi, passiamo da 60..120con |%{...}. Ogni iterazione calcoliamo il $pprezzo dell'articolo corrente con una dichiarazione pseudo-ternaria , quindi calcoliamo il $cmassimale di $a/$_. Se il totale corrente è inferiore al totale più piccolo che abbiamo visto ( $j), salva tutte queste variabili: $j(il totale), $k(il numero di porte richiesto) e $i(la larghezza della porta) e continua il ciclo. Una volta terminato il ciclo, emetti solo i valori migliori.

_{Modifica: salvato due byte spostando le assegnazioni $ce $pnel ifcondizionale}

Pyth, 65 byte

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

Provalo qui!

Spiegazione

In primo luogo, questo genera un elenco di tutte le possibili combinazioni di porte / larghezza delle porte e calcola il prezzo per ciascuna di tali combinazioni. Quindi dobbiamo solo ordinarlo per prezzo e larghezza della porta e prendere il primo elemento dell'elenco risultante.

La spiegazione del codice segue dopo che ho giocato a golf Per favore aiutami a giocare a golf, è troppo lungo.

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

                                                   m r2 17 # intervallo mappa (2,17) a
                                                    [d) # elenco con prima il numero di porte
                                                      .EcQd # e larghezza secondo
                                        f # Filtra il risultato della mappa con T
                                         } r60 121 # nel range (60.121)
                                          eT # larghezza della porta
          m # risultato del filtro della mappa con d
           [d) # in un elenco con prima il numero e la larghezza della porta
             * conteggio porte hd # mult con
                ?> 81ed150? <101ed220 200 # prezzo per porta, ricerca semplice con ternari
 o # ordina il risultato della mappa con N
  + chiave di ordine n. N. = prezzo + larghezza / 10
h # first element è il migliore

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]

Come notato da @Neil, =-~(~-n/d)è equivalente alla divisione con arrotondamento per numeri interi di 32 bit o meno.

R , 135 104 byte

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

Provalo online!

Salvato 31 byte da

• numeri di decompressione
• utilizzando utf8ToInt
• usando "!" per abbreviare la chiamata di funzione
• utilizzando funzioni vettoriali
• non definisce la lunghezza totale
• usando cbinddirettamente piuttosto che dopo aver definito le variabili

Come funziona:

1. approxrestituisce il prezzo di una singola porta in base alla sua lunghezza. Ritorna NAal di fuori dell'intervallo [60,120].
2. Sulla base delle specifiche, il numero totale di porte non può essere superiore a 16 (lunghezza totale 1000). (number of doors, door width, total price)Viene testato tutto il numero di porte da 16 a 1 e viene restituita la tripletta .
3. La orderfunzione viene utilizzata per individuare il prezzo minimo; la tripletta corretta viene estratta in base a quello. In caso di vincoli, order verrà restituita la voce che viene prima, e poiché abbiamo passato da 16 a 1 , verrà restituito il maggior numero di porte (larghezza della porta più piccola).