Encontre a largura ideal da porta deslizante

13

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
Stewie Griffin
fonte
A largura de 201é um caso de teste interessante ...
AdmBorkBork 23/02
8
Porta deslizante? Claramente, todas as portas precisam de um @Doorknob.
Alex A.

Respostas:

2

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!

Adnan
fonte
Colocar 333 no TIO fornece uma saída de [3, 112, 660] quando (afaik) a saída deve ser [3, 111, 660], pois 3 * 111 é igual a 333 perfeitamente #
Helen
Problema semelhante com 201 dando [2, 101, 400] em vez de [2, 101, 440] #
928 Helen Helen
4

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.

Neil
fonte
4

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)

Kenney
fonte
Mais curto do que sub r{$a=$_[0];~~$a==$a?$a:1+~~$a}é sub r{use POSIX;ceil pop}.
Msh210
Mais curto do que (80=>150,100=>200,120=>220)é (80,150,100,200,120,220).
Msh210
Isso funciona para portas muito amplas (onde o preço é superior a 10_000)?
Msh210
@ msh210 Obrigado pelas dicas, vou incorporá-las! Não, ele só funciona para o intervalo especificado na questão [120-1000), mas sempre se pode mudar 1E4para 1E9...
Kenney
Ah, eu não percebi que a pergunta havia especificado um intervalo.
Msh210
3

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

AdmBorkBork
fonte
2

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
Denker
fonte
1

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.

edc65
fonte
1

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.
JayCe
fonte
A utilização stepfuné mais longa - pois é necessário remover a largura fora de [60,120].
Jayce