Saya yakin Anda tahu tentang skema harga $ 9,99, daripada menggunakan $ 10. Nah, dalam pekerjaan baru Anda sebagai admin sistem di sebuah toko ritel besar, mereka ingin harga mematuhi skema serupa:

• Semua harga dalam dolar penuh, tidak ada sen.
• Semua harga harus diakhiri dengan 5 atau 9, pembulatan ke yang terdekat tetapi naik jika digit terakhir tepat antara 5 dan 9. (Berlaku untuk digit terakhir 2 dan 7)
• Input terendah adalah $ 1, dan harga output terendah adalah $ 5.

Input Anda adalah daftar bilangan bulat:

12
8
41
27
144
99
3

Dan output harus daftar harga baru. Dalam kasus di atas:

15
9
39
29
145
99
5

Brainfuck, 4428 byte (tidak valid)

Setelah saya tahu algoritme berfungsi, saya kehilangan minat dan tidak menyelesaikan input handler. Itu sebabnya solusi ini secara teknis menyelesaikan masalah, tetapi sangat sulit digunakan. Saat Anda memulai program dengan juru bahasa interaktif (lebih cepat lebih baik), Anda dapat memasukkan "nomor" Anda. Itu harus dimasukkan dalam Base256 jika juru bahasa Anda tidak mendukung konversi nomor (milik saya). Karena itu, harga maksimum yang dapat Anda masukkan adalah 255.

Ini kemudian melakukan perulangan modulo jika angkanya lebih besar dari 9 untuk memisahkan semua digit kecuali yang terakhir. Hasil pembagian disimpan, sedangkan digit terakhir dibulatkan menjadi 5 atau 9. Kemudian ditambahkan dan dicetak. Kemudian program membersihkan semua register yang digunakan (mungkin berlebihan) dan meminta nomor berikutnya.

Ini menangani semua kasus khusus ( $1, $20/$21 -> $19dll.). Tonton terus untuk nomornya di 4sini (sekitar 3 menit, video disingkat):

Kode

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

CJam, 19 17 byte

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

Uji di sini.

Mengambil input sebagai daftar gaya-CJam dan mengembalikan garis keluaran yang baru dipisahkan.

Penjelasan

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]

Jika kita melihat urutan nilai-nilai bulat, kita melihat bahwa mereka datang dalam blok 5.

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

Kami menemukan blok nomor apa yang kami pakai (n+3)/5(sebut nilai ini J). Kemudian, kita mendapatkan kelipatan 5dengan yang benar J*5, dan menyesuaikan hal-hal seperti 30turun 29dengan mengurangi 1setiap kali Jgenap.

Untuk 1pemberian kasus khusus dan 5bukan -1, kami meneruskan hasilnya max(5,_).

Retina, 32 byte

Menerima input dalam daftar yang dipisahkan koma. Harus ada koma tertinggal. Output dalam format yang sama.

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

Penjelasan:

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 byte

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

Harus ada ruang untuk meningkatkan ini, tetapi saya pikir strategi yang berbeda mungkin lebih baik. Mengambil vektor bilangan bulat dari pemindaian dan menghasilkan vektor bilangan bulat. Pada dasarnya ini menggunakan divisi integer untuk membulatkan angka ke bawah, menambah 1 dan mengalikannya dengan lima. Apa pun yang habis dibagi 10 telah diambil. Jika n = 1 maka ia menambah pembagian bilangan bulat dengan 1.

Uji coba

> (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 byte

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

Saya berjuang untuk singkatnya nilai kurang dari 11 dan persyaratan untuk 1 untuk mengevaluasi ke 5.

Pyth, 21 18 29 28 byte

Terima kasih kepada @Jakube untuk memotong 3 byte!

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

Coba di sini.

EDIT: Rupanya itu tidak valid. Saya memperbaikinya dengan biaya 11 byte; Saya akan mencoba golf lebih banyak.

Pyth, 21 byte

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

Sayangnya saya harus menghabiskan 4 byte untuk menangani $ 1 dengan benar.

Pyth, 18 byte

m-|*K5hJ/-d2K6%J2Q

Cobalah online: Demonstrasi atau Test Suite

Jawaban ini didasarkan pada solusi Python / Pyth @xor. Perbedaan utamanya adalah, saya menangani kasus khusus secara 1berbeda. Hasil aktual untuk 1menjadi 0 - 1 = -1. Menggunakan Python, orsaya bisa mengganti 0dengan 6, menghasilkan 6 - 1 = 5. Ini menghemat rasa sakit dari mengambil maksimum 5dan hasilnya.

Penjelasan:

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)

Hassium , 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);}}

Jalankan dan lihat diperluas secara online: http://hassiumlang.com/Hassium/index.php?code=4f1c14f4d699b11da7a6392a74b720c4

TI-BASIC, 19 byte

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

Menggunakan algoritma xnor. TI-BASIC mendapatkan vektorisasi dan perkalian secara gratis, tetapi kami menghabiskan beberapa byte lagi karena tidak memiliki modulo.

Haskell, 114 byte

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)

Penjelasan:

Fungsi gkembali 9-njika n>6atau 5-njika n>1tidak -n-1. gdiberikan digit terakhir dan mengembalikan apa yang harus ditambahkan ke nomor input. fgunakan guntuk mendapatkan solusinya (ditambah banyak manipulasi string). mainmenampilkan hasil funtuk setiap jalur input.

Rubi, 55 50 +1 byte

Menjalankannya dengan nbendera, seperti: ruby -n prices.rb. Masukkan setiap harga pada baris terpisah.

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