Tantangan:

Program Anda akan mengambil dua bilangan bulat ndan ksebagai input, dan menghasilkan bilangan bulat terkecil yang lebih besar dari (tetapi tidak sama dengan) nyang berisi paling tidak kkemunculan angka tersebut 5.

Anda dapat mengasumsikan 1 ≤ k ≤ 15dan 1 ≤ n < 10**15.

Ini adalah tantangan waktu terbatas . Program Anda harus berjalan pada TIO untuk semua kasus uji dan selesai dalam 10 detik total.

Aturan umum:

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang.
  Jangan biarkan bahasa kode-golf mencegah Anda memposting jawaban dengan bahasa non-codegolf. Cobalah untuk memberikan jawaban sesingkat mungkin untuk bahasa pemrograman apa pun .

• Aturan standar berlaku untuk jawaban Anda dengan aturan I / O default , sehingga Anda diizinkan untuk menggunakan STDIN / STDOUT, fungsi / metode dengan parameter yang tepat dan tipe pengembalian, program penuh. Panggilanmu. Parameter fungsi dapat diambil dalam urutan apa pun, tetapi harap tentukan dalam jawaban Anda.

• Celah default tidak diperbolehkan.
• Anda harus menambahkan tautan dengan tes untuk kode Anda (yaitu TIO ).
• Header jawaban harus mencantumkan skor dalam byte tetapi juga total waktu yang diambil untuk semua kasus uji pada TIO
• Jika bahasa Anda tidak pada TIO, kode harus selesai jauh di bawah 10 detik pada mesin Anda sehingga Anda yakin itu cukup cepat pada komputer yang masuk akal.
• Menambahkan penjelasan untuk jawaban Anda sangat disarankan.

Kasus uji:

(n, k) ->  output
(53, 2) -> 55
(55, 1) -> 56
(65, 1) -> 75
(99, 1) -> 105
(555, 3) -> 1555
(557, 1) -> 558
(5559, 3) -> 5565
(6339757858743, 5) -> 6339757859555
(99999999999999, 15) -> 555555555555555

Contoh Program:

Program ini benar.

R + stringr, 85 84 76 byte, .062 pada TIO

f=function(n,k,m=2+stringr::str_count(n+1,"5")-k)`if`(m<2,f(n+.1^m*2,k),n+1)

Cobalah online!

-1 byte terima kasih kepada Robert S.
-8 byte terima kasih kepada Giuseppe.

Solusi rekursif sederhana adalah dengan menambah 1 hingga jawabannya ditemukan, tetapi ini tidak akan memenuhi batasan waktu. Untuk memenuhi batasan waktu, fungsi ini menggunakan fakta bahwa jika ada p yang hilang 5s, kita dapat menambah 2 * 10 ^ (p-2).

Perhatikan bahwa ketika p = 1, kenaikannya menjadi 0,2. Ini OK, karena setelah 5 langkah kita kembali ke bilangan bulat, dan tidak ada angka desimal yang ditemui dalam waktu rata-rata yang memiliki 5. tambahan. Jika sebaliknya kita harus menambah 5 * 10 ^ (p-2) atau dengan 1 * 10 ^ (p-2), maka kita akan menemukan f (24, 1) = 24,5 bukan 25 misalnya.

Jelly , 37 byte 0,113 detik pada TIO

»DL‘Ɗ}©5xḌ_DḌÐƤ;®ŻṬ€UḌ¤+⁹D=5S>ʋƇ⁸’¤ḟṂ

Cobalah online!

Ini bekerja dengan

1. bekerja maksimal jumlah digit pada input plus satu dan k, dan membuat angka dengan balita sebanyak itu
2. Mengurangi input dari angka itu
3. Menghasilkan semua sufiks nomor itu
4. Juga menghasilkan semua kekuatan sepuluh dari 1 hingga yang berikutnya lebih besar dari input
5. Menambahkan masing-masing angka dalam 3 dan 4 ke input
6. Menghapus jawaban dengan terlalu sedikit 5
7. Menyaring input dari jawaban
8. Dan mengembalikan minimum

05AB1E , 33 32 byte

sg>‚à©5s×α.s0š®Ý°0šâO+IKʒ§5¢¹@}ß

Port dari pendekatan @NickKennedy yang luar biasa dalam jawaban Jelly-nya , jadi pastikan untuk mendukungnya !!

Mengambil sebagai input pertama; sebagai yang kedua.$k$$n$

Cobalah secara online atau verifikasi semua kasus uji .

Penjelasan:

sg>                # Get the length+1 of the second (implicit) input-integer
   ‚à              # Pair it with the first input-integer, and leave the maximum
     ©             # Store this maximum in the register (without popping)
      5s×          # Create an integer (actually, create a string..) with that many 5s
         α         # Take the absolute difference with the second (implicit) input
          .s       # Get the prefixes of that number
            0ª     # Prepended with an additional 0
    ®              # Get the maximum from the register again
     Ý             # Create a list in the range [0, max]
      °            # Raise 10 to the power of each integer
       0ª          # And also prepend an additional 0 to this list
              â    # Then create each possible pair of these two lists
               O   # Sum each pair
                +  # Add the second input to each sum
IK                 # Then remove the second input from this list (if present)
  ʒ                # And filter this list by:
   §               #  Cast the number to a string (bug, shouldn't be necessary)
    5¢             #  Count the amount of 5s in the string
      ¹@           #  And check if this count is larger than or equal to the first input
        }ß         # After the filter: only leave the lowest number
                   # (which is output implicitly as result)

Stax , 17 byte (6,861 detik total pada TIO)

≈ª╞¥é£ôñτ←╝α┴╢JLd

Jalankan dan debug itu

Program ini mengambil kdan nmenggunakan input standar yang dipisahkan oleh ruang. Stax tidak memiliki cara yang mudah untuk menjalankan beberapa test case di TIO, jadi saya menjalankan setiap input secara terpisah dan menambahkan waktu. 99% dari waktu dalam startup proses juru bahasa. Menggunakan penerjemah javascript di staxlang.xyz, semua kasus uji berjalan dalam 50 milidetik.

Test case terakhir di Coba online!

Prosedur :

1. Input penambahan
2. Jika ada cukup 5, hentikan dan cetak
3. t= jumlah jejak 5di angka
4. Menambahkan 10 ** t
5. Goto 2

Python 2 , 70 68 byte (0,025 detik pada TIO)

l=lambda n,k:'5'*k*(10**~-k>n)or-~n*(`n+1`.count('5')>=k)or l(n+1,k)

Cobalah online!

Ini mungkin sedikit peregangan; itu benar dalam semua kasus, dan selesai dalam waktu yang dapat diabaikan untuk kasus uji, tetapi tidak selesai dalam waktu yang wajar untuk beberapa kasus lainnya. Namun secara teknis memenuhi persyaratan.

Singkatnya, jika angka terkecil dengan kbalita lebih besar daripada n, kita menggunakan angka itu karena jelas solusi yang tepat. Jika tidak, kami menggunakan pendekatan rekursif standar.

Perl 5 -pl , 44 byte

$k=<>;$_++;s/.*?(?=5*$)/1+$&/e while$k>y/5//

Cobalah online!

Menemukan nomornya tanpa angka 5. Menambah porsi itu dengan 1. Berlanjut sampai cukup 5s ada dalam angka. Membutuhkan sekitar 0,012 pada TIO untuk menjalankan semua kasus uji.

Python 3 , 144 98 86 75 byte

f=lambda N,k,d=1:k>str(-~N).count("5")and f(N+-(-~N//d+5)%10*d,k,d*10)or-~N

Cobalah online!

Ini , (waktu sistem .008 pada TIO) dan telah bermain golf dengan baik dengan saran dari ASCII saja.$\mathcal{O}(k)$

Algoritma ini untuk mengumpulkan setiap digit (mulai dari yang paling signifikan) ke nilai terdekat 5 hingga representasi desimal angka baru memiliki jumlah yang diinginkan.

Pendekatan asli menggunakan pemahaman daftar gagal (D = iter (rentang (k)) dan daftar (D) di sini), tetapi @ ASCII-only telah meyakinkan saya bahwa tidak akan pernah memenangkan golf kode. Saya tidak menyukai rekursi, tetapi jika algoritma ini ditulis untuk meminimalkan kedalaman rekursi, maka kompiler / juru bahasa di masa depan akan cukup pintar untuk mengimplementasikannya kembali sebagai loop sementara.

Python 3 , 59 byte

Solusi rekursif. Kedalaman rekursi adalah masalah (harus diubah untuk angka yang lebih tinggi), tetapi itu benar.

lambda x,k:eval(("f(x+1,k)","x+1")[str(x+1).count("5")==k])

Cobalah online!

Python 3, 72 byte

def f(n,k):
 while(1):
  n+=1
  if str(n).count('5')>=k:return n

Cobalah online!

Java 8, 69 byte, 60+ detik pada TIO dengan test case terakhir, ~ 1,5 detik tanpa.

(n,k)->{for(;(++n+"").chars().filter(i->i==53).count()<k;);return n;}

Adakah yang tahu bagaimana cara lulus ujian terakhir?

PHP ,109 97 byte, (<0,03 detik pada TIO)

function($n,$k){++$n;do if(count_chars($n)[53]>=$k)return$n;while($n+=10**strspn(strrev($n),5));}

Cobalah online!

Berdasarkan algoritma @ rekursif .

Retina , 63 byte

.+$
*
^.+
$.(*__
/((5)|.)+¶(?<-2>_)+$/^+`^.*?(?=5*¶)
$.(*__
1G`

Cobalah online! Mengambil ndan kpada baris yang berbeda, tetapi tautan menyertakan header yang mengubah suite pengujian ke dalam format yang sesuai. Penjelasan:

.+$
*

Konversikan kke unary.

^.+
$.(*__

Penambahan n. The *mengulangi argumen kanan (di sini pertama _karakter) jumlah kali diberikan oleh argumen kiri (yang, seperti di sini, default untuk pertandingan). Ini menghasilkan string dengan panjang itu. The $((yang )tersirat) kemudian merangkai bahwa dengan kedua _dan .menyebabkan panjang yang dihasilkan harus diambil. (Sebenarnya Retina 1 lebih pintar dari itu dan hanya melakukan perhitungan pada panjang yang mendasarinya di tempat pertama.)

/((5)|.)+¶(?<-2>_)+$/

Tes apakah cukup 5s dapat ditemukan nuntuk mencocokkan dengan _representasi unary k. Tes ini telah golf dan akan tiga kali lebih cepat dengan ^ditambahkan setelah inisial /dan lebih cepat lagi jika [^5]digunakan sebagai gantinya ..

^+`

Sampai tes berlalu ...

^.*?(?=5*¶)
$.(*__

... increment ntetapi tidak termasuk trailing 5s.

1G`

Hapus k.

Clam , 30 byte, ~ 0.2s pada TIO

=Q+r1=qC5R1?<qQ[=qrw<n#:q5QqiQ

Transpile ke JS ini (paket uji lengkap ditambahkan untuk penentuan waktu tentu saja), di mana inputsterdapat array input ( npertama, kkedua)

Terima kasih @ ArBo untuk pendekatannya

Penjelasan

=Q+r1=qC5R1?<qQ[=qrw<n#:q5QqiQ - Implicit Q = first input
=Q+r1                          - Q = next input (1st input) + 1
     =qC5R1                    - q = 2nd input 5s (eg 555 for k=3)
           ?<qQ[               - if q < Q...
                =qr            -   q = next input (2nd input)
                   w           -   while...
                     n         -     length of...
                      #:q5Q    -       Q.filter(q=>q==5)
                    <          -     is less than...
                           q   -       q
                            iQ -     Increment Q
                               - Implicit output of Q

C (gcc) , 159 158 152 150 149 byte, ~ 0,04 dtk

Menghasilkan jawaban untuk STDOUT, dengan nol terkemuka.

-3 byte terima kasih kepada ceilingcat

m,j;f(n,k)long n;{char*t,s[17];for(t=s+sprintf(s,"%016ld",++n),m=n=0;m<k&--t>s;m<k&&*t-53?n=*t>53,*t=53:0)for(*t+=n,m=j=17;j--;)m-=s[j]!=53;puts(s);}

Cobalah online!