Tenho certeza de que você conhece o esquema de preços de US $ 9,99, em vez de usar US $ 10. Bem, em seu novo emprego como administrador de sistemas em uma grande loja de varejo, eles querem que os preços sigam um esquema semelhante:

• Todos os preços estão em dólares inteiros, sem centavos.
• Todos os preços devem terminar com 5 ou 9, arredondando para o mais próximo, mas acima se o último dígito estiver entre 5 e 9. (Aplica-se ao último dígito 2 e 7)
• A entrada mais baixa é de US $ 1 e o preço mais baixo produzido deve ser de US $ 5.

Sua entrada é uma lista de números inteiros:

12
8
41
27
144
99
3

E a saída deve uma lista dos novos preços. No caso acima:

15
9
39
29
145
99
5

Brainfuck, 4428 bytes (inválido)

Depois que soube que o algoritmo funcionava, perdi o interesse e não terminei o manipulador de entrada. É por isso que esta solução resolve tecnicamente o problema, mas é muito difícil de usar. Quando você inicia o programa em um intérprete interativo ( quanto mais rápido, melhor), você pode inserir seu "número". Ele deve ser inserido no Base256 se o seu intérprete não suportar a conversão de números (o meu suporta). O preço máximo que você pode inserir é, portanto, 255.

Em seguida, ele executa um módulo de loop se o número for maior que 9 para dividir todos os dígitos, exceto o último. Os resultados da divisão são salvos, enquanto o último dígito é arredondado para 5 ou 9. Em seguida, são adicionados e impressos. Em seguida, o programa limpa todos os registros usados ​​(provavelmente um exagero) e solicita o próximo número.

Ele lida com todos os casos especiais ( $1, $20/$21 -> $19etc.). Assista ao número 4aqui (cerca de 3 minutos, vídeo abreviado):

Código

>+<+[>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<[>[-]+<-]>
[<+>>>>>>>>>>>[-],>>[-]<[-]<[>+<<<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>
>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]+++++++++>[<<<<+
>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]
+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>>>-<<<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>
>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>>+<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<
-]>>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<<
<[>[-]+<-]>[<+>>>>>>>>>>>>[-]<[>+<<<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>
>>>>>[-]++++++++++>>>[<<<<<<<+>>>>>>>-]<<<<<<<[>>>>[<<<<<+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<
<<<<<-]>>[>-[<<+<+>>>-]<<<[>>>+<<<-]+>[<->[-]]<[>>-[>>>>>>>>-<<<<<<<<[-]]+<<[-]]>>-]>>>>
>>>>+<<<<<<<]>>>>>[-]>>[<<+<<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>>>
>[-]++++++++++>[<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<
<<<-]>-]>>>>>>>>>[-]<<[>>+<<-][-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<
<<<<<<<<<<-]>>>>>>>[-]>>>[<<<+<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>
>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>>>>>[-]<<<[>>>+<<<-][-]>[<+<<<<<
<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]>>>[<<<+<<<<<<<+>>>>>>>>>>-]<<<<
<<<<<<[>>>>>>>>>>+<<<<<<<<<<-]>>>>>>>[>-<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>
>>>>[-]<[>+<-]<<<<<<<<<-]>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>-]
<<<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>>[<<+<<<<<<<<+>>>>>>>>>>-]<<<<<<<<<<[>>>>
>>>>>>+<<<<<<<<<<-]>>>>>>>[-]>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<
-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>>>-<<
<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>>>>>>
>>>+<<<<<<<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<+>>>>>
>>>>>>>>>>-]<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>
>>>>>>>>+<<<<<<<<<-]>>>>>>>[-]++++>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<
<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]>>[>>
>>-<<<<[-]]<<<[-]<->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>>+<<<<<<<<-]>>>>>>>>[>>>>
>>+<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]<[>[-]+<-]>[<+>>>>>>>>>>>[-]+++++++++>>>>>>
>>+<<<<<<<<<<<<<<<<<<<->-]>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>-]<<<<<<<<<<<
<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>[<+<<<<<<<<+>>>>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>
>>>>>[-]++>[<<<<+>>>>-]<[<<<<<<+>+<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>[>>[<+<<<+>>>>-
]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]<[>>>>>>>-<<<<<<<[-]]>>>[-]>>
>[-]>>>>[<<<<+<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>>>>>>[-]+
++++++++<<<<<[<<<+>>>-]>>>>>[<<<<<<<<<<<+>+<<+>>>>>>>>>>>>-]<<<<<<<<<<<<[>>>>>>>>>>>>+<<
<<<<<<<<<<-]>>[>>[<+<<<+>>>>-]<<<<[>>>>+<<<<-]+>>>[<<->>>-<<<<->>>[-]]<<<[>>[-]+<<-]>>-]
>>[>>>-<<<[-]]<<<[-]>>>>>>>[<<<<<<<<+>>>>>>>>-]<<<<<<<<[[-]>>>>>>>[<<<<<<<+>+>>>>>>-]<<<
<<<[>>>>>>+<<<<<<-]<[>>>>>>>>-<<<<<<<<[-]]]->>>>>>>>[<<<<<<<<->>>>>>>>-]<<<<<<<<[>>>>>>>
>+<<<<<<<<-]>>>>>>>>[>>>>>>>>+<<<<<<<<<<<<<<<<<<->>>>>>>>>>[-]]<<<<<<<<<-]<[>[-]+<-]>[<+
>>>>>>>>>>[-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>>
->>>[-]<<<[>>>+<<<-]>[-]>>>>>>>>>>>>+<<<<<<<<<<<<<<<<<<<<<<<->-]>>>>>>>>>>>>>>>>>[<<<<<<
<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>>[-]+++++<<<<<
<<<<<-]>>>>>>>>>>>>>>>>>>>>>>[<<<<<<<<<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>>>>>-]<<<<[<<<<
<<<<<<<<<<<<<<<+>>>>>>>>>>>>>>>>>>>-]<<<<<<<<<<<<<<<<<<<[>[-]+<-]>[<+>>>>>>>>>>[-]>>>[<<
<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+<<<<<<<<<<<-]>>>>>>>[-]>>[<<+<<<<<<<+>>>
>>>>>>-]<<<<<<<<<[>>>>>>>>>+<<<<<<<<<-]>>>>>>>[>+<<<<<<<<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<
<<-]>>>>>>>>>>>[-]<<<[>>>+<<<-][-]>>>[<<<+<<<<<<<<+>>>>>>>>>>>-]<<<<<<<<<<<[>>>>>>>>>>>+
<<<<<<<<<<<-]>[-]>[-]>[-]>[-]>>>>[<<<<<+[>+<<<<+>>>-]<<<[>>>+<<<-]+>>>>----------[<<<<->
>>>[-]]<<<<[>>+>[-]<<<-]>>[>>+<<<<+>>-]<<[>>+<<-]+>>>>----------[<<<<->>>>[-]]<<<<[>+>[-
]<<-]>>>>>>>>-]<<<<<<<[<++++++++[>++++++>++++++<<-]>.>.[-]<[-]]>[<<++++++++[>>++++++<<-]
>>.[-]]<<++++++++[>>>++++++<<<-]>>>.[-]<<<++++++++++.[-]>>>>>>>>>>>>>>>+<<<<<<<<<<<<<<<<
<->-]<[>[-]+<-]>[<+<->>-]<<]

CJam, 19 17 bytes

q~{2-Ab)4>59s=N}/

Teste aqui.

Recebe a entrada como uma lista no estilo CJam e retorna a nova linha de saída separada.

Explicação

qN/{   e# Run this block for each line of the input...
  ~    e#   Evaluate the current line to get the integer.
  2-   e#   Subtract 2 to get all but the last digit right.
  Ab)  e#   Convert to base 10 (discarding a potential minus sign) and split off
       e#   the last digit.
  4>   e#   Test if it's greater than 4.
  59s= e#   Select the correct digit from the string "59" based on this result.
  N    e#   Push a line feed.
}/

Python 2, 47

lambda l:[max(5,(n+3)/5*5-(n-2)/5%2)for n in l]

Se observarmos a sequência de valores arredondados, veremos que eles vêm em blocos de 5.

... 25, 29, 29, 29, 29, 29, 35, 35, 35, 35, 35, 39, ...

Encontramos o bloco numérico em que estamos (n+3)/5(chame esse valor J). Então, temos o direito de múltiplos 5com J*5e ajustar coisas como 30até 29subtraindo 1sempre Jé uniforme.

A-caso especial 1de dar 5em vez de -1, nós passar o resultado para max(5,_).

Retina, 32 bytes

Aceita entrada em uma lista separada por vírgula. Deve haver uma vírgula à direita. Saídas no mesmo formato.

T`d`aa555559`.,
T+`da`ad`\da
a
5

Explicação:

T`               #Transliteration mode.
  d`aa555559`    #Map the digits 0-9 to aa55555999
             .,  #Map only the trailing digits.
T+`              #Do until input does not change.
   da`ad`        #Map a to 9, 0 to a, and 1-9 to 0-8
         \da     #Only do this to each a and the character before each a.
a                #Match all leftover a's. This only happens when the input contains the integer 1.
5                #Replace them with 5.

R, 51 49 47 43 bytes

(f=((n=scan()-2)%/%5+1+(n<0))*5)-(f%%10==0)

Deveria haver espaço para melhorar isso, mas acho que uma estratégia diferente pode ser melhor. Tira um vetor de números inteiros da varredura e gera um vetor de números inteiros. Essencialmente, isso usa divisão inteira para arredondar o número para baixo, adiciona 1 e multiplica por cinco. Qualquer coisa divisível por 10 tem 1 retirado. Se n = 1, ele incrementa a divisão inteira em 1.

Execução de teste

> (f=((n=scan()-2)%/%5+1+(n<0))*5)-(f%%10==0)
1: 1
2: 12
3: 8
4: 41
5: 27
6: 144
7: 99
8: 3
9: 
Read 8 items
[1]   5  15   9  39  29 145  99   5
> 

Python 3, 74 82 bytes

a=eval(input())
for i in a:print(round(i,-1)+[5,-1][max(4,i-2)%10>4])

Eu lutei pela brevidade em valores menores que 11 e pelo requisito de 1 para avaliar até 5.

Pyth, 21 18 29 28 bytes

Obrigado a @Jakube por cortar 3 bytes!

KeQJ-QKI<K2tJ.q;I<K6+J5;E+J9

Experimente aqui.

EDIT: Aparentemente, era inválido. Eu consertei isso ao custo de 11 bytes; Vou tentar jogar mais.

Pitão, 21 bytes

m?tdtt+d@jC"²a<"6ed5Q

Infelizmente eu tenho que gastar 4 bytes para lidar corretamente com $ 1.

Pitão, 18 bytes

m-|*K5hJ/-d2K6%J2Q

Experimente on-line: Demonstration or Test Suite

Esta resposta é baseada na solução Python / Pyth do @ xor. A principal diferença é que eu trato o caso especial de maneira 1diferente. O resultado real para 1seria 0 - 1 = -1. Usando Pythonor posso substituir o 0por a 6, resultando em 6 - 1 = 5. Isso economiza a dor de tirar o máximo de 5e o resultado.

Explicação:

m-|*K5hJ/-d2K6%J2Q
m                Q   map each number d of the input list Q to:
    K5                  K = 5
       J/-d2K           J = (d - 2) / K
   *K hJ                   K * (J + 1)
  |                     or
             6             6 # if K*(J+1)==0
 -            %J2       minus (J mod 2)

Hássio , 133 bytes

func main(){i=[12,8,41,27,144,99,3];foreach(e in i){f=e%10;if(!(e/10==0))print(e/10);if(f<5)r=5;else if(f>5)r=9;elser=f;println(r);}}

Execute e veja o online expandido: http://hassiumlang.com/Hassium/index.php?code=4f1c14f4d699b11da7a6392a74b720c4

TI-BASIC, 19 bytes

int(Ans/5+.6
max(5,5Ans-not(fPart(Ans/2

Usa o algoritmo do xnor. O TI-BASIC obtém vetorização e multiplicação de graça, mas gastamos mais alguns bytes porque ele não possui módulo.

Haskell, 114 bytes

g n
 |n>6=9-n
 |n>1=5-n
 |1>0=(-n-1)
f n=show$(read n)+(g$read$(:[])$last n)
main=interact(unlines.(map f).lines)

Explicação:

A função gretorna 9-nif n>6or else 5-nif n>1or else -n-1. grecebe o último dígito e retorna o que deve ser adicionado ao número de entrada. fusa gpara obter a solução (mais muita manipulação de string). mainproduz o resultado de fpara cada linha de entrada.

Rubi, 55 50 + 1 bytes

Executá-lo com a nbandeira, assim: ruby -n prices.rb. Insira cada preço em uma linha separada.

x=$_.to_i
p x<7?5:(x-2).round(-1)+(~/[2-6]$/?5:-1)