Dengan bilangan bulat positif, temukan kelipatan bilangan bulat positif terkecil yang merupakan run dari 9 diikuti oleh run opsional 0. Dengan kata lain, temukan multiple integer positif terkecil yang cocok dengan regex /^9+0*$/.

Misalnya, jika bilangan bulat positif yang diberikan adalah 2, maka kembalikan 90, karena 90 adalah bilangan bulat positif dari 2 dan merupakan yang terkecil yang cocok dengan regex /^9+0*$/.

Kasus uji:

n  f(n)
1  9
2  90
3  9
4  900
5  90
6  90
7  999999
8  9000
9  9
10 90
11 99
12 900
13 999999
14 9999990
15 90
16 90000

Ini adalah kode-golf . Jawaban terpendek dalam byte menang. Celah standar berlaku.

Jelly , 13 11 byte

ṚḌ‘DS=ḍ@ð1#

Cobalah online!

Bagaimana itu bekerja

ṚḌ‘DS=ḍ@ð1#  Main link. Argument: n

        ð    Start a dyadic chain with arguments n and n.
         1#  Execute the chain to the left with left argument k = n, n+1, n+2, ...
             and right argument n until 1 match has been found. Return the match.
Ṛ                Get the decimal digits of k, reversed.
 Ḍ               Convert from base 10 to integer.
                 This essentially removes trailing zeroes. As a side effect, it
                 reverses the digits, which doesn't matter to us.
  ‘              Increment the resulting integer. If and only if it consisted
                 entirely of 9's, the result is a power of 10.
   DS            Compute the sum of the digits. The sum is 1 if and only if the
                 integer is a power of 10. Note that the sum cannot be 0.
      ḍ@         Test k for divisibility by n.
     =           Compare the results.

Python 2 , 55 54 byte

n=r=input()
while int(`10*r`.lstrip('9')):r+=n
print r

Cobalah online!

Python 2 , 51 byte

f=lambda n,r=9:r%n and f(n,10*r-10**n*r%-n/n*9)or r

Cobalah online!

JavaScript (ES6), 47 43 42 byte

-4 byte terima kasih kepada @Arnauld
-1 byte terima kasih kepada @Luke

n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

Tes

let f=
n=>eval('for(i=0;!/^9+0*$/.test(i);)i+=n')

for(let i=1;i<=16;i++)console.log(`f(${i}) = `+f(i))

Solusi rekursif (gagal untuk 7, 13, dan 14), 38 byte

n=>g=(i=0)=>/^9+0*$/.test(i+=n)?i:g(i)

Disebut seperti f(5)(). Mencapai ukuran panggilan tumpukan max di Chrome dan Firefox untuk n=7, n=13, dan n=14.

f=
n=>g=(i=0)=>/^9+0*$/.test(i+=n)?i:g(i)

for(let i=1;i<=16;i++){
	try { console.log(`f(${i}) = `+f(i)()) }
	catch(e) { console.log(`f(${i}) = FAILED`) }
}

Ruby , 36 byte

->x{r=0;1until"#{r+=x}"=~/^9+0*$/;r}

Brute-forcing - membutuhkan selamanya untuk x = 17.

Cobalah online!

Java 8, 61 57 byte

n->{int r=0;for(;!(""+r).matches("9+0*");r+=n);return r;}

-4 byte (dan eksekusi lebih cepat) berkat @JollyJoker .

Penjelasan:

Coba di sini.

n->{                              // Method with integer as parameter and return-type
  int r=0;                        //  Result-integer
  for(;!(""+r).matches("9+0*");   //  Loop as long as `r` doesn't match the regex
    r+=n                          //   And increase `r` by the input every iteration
  );                              //  End of loop
  return r;                       //  Return the result-integer
}                                 // End of method

Python 3 , 56 byte

f=lambda n,r=0:{*str(r).strip('0')}!={'9'}and n+f(n,n+r)

Cobalah online!

Brachylog , 16 byte

;I×≜.ẹḅhᵐc~a₀90∧

Cobalah online!

Ini sangat lambat

Penjelasan

;I×≜.              Output = Input × I
    .ẹḅ            Deconcatenate into runs of consecutive equal digits
       hᵐ          Take the head of each run
         c         Concatenate into a number
          ~a₀90∧   That number is a prefix of 90 (i.e. it's 9 or 90)

05AB1E , 10 byte

0[+D9Û0«_#

Cobalah online!

Itu hanya terus menambahkan input ke 0, sampai hasil minus memimpin 9 sama dengan 0.

RProgN 2 , 18 byte

x={x*'^9+0*$'E}éx*

Dijelaskan

x={x*'^9+0*$'E}éx*
x=                  # Set the value of "x" to the input.
  {           }é    # Find the first positive integer in which passing it to the defined function returns truthy.
   x*               # Multiply the index by x, this essentially searches multiples now.
     '^9+0*$'       # A Regex defined by a literal string.
             E      # Does the multiple match the regex?
                x*  # Multiple the outputted index by x, giving the result.

Cobalah online!

Matematika , 71 byte

(x=#;While[!StringMatchQ[ToString@x,RegularExpression@"9+0*"],x+=#];x)&

Cobalah online!

Tidak terlalu keras solusi brute force, tetapi mengalahkan jawaban Mathematica lainnya, yang menggunakan beberapa trik pintar.

Salah satu kualitas penukaran Mathematica sehubungan dengan tantangan ini adalah fakta yang StringMatchQmembutuhkan pertandingan penuh, jadi saya bisa melakukannya 9+0*daripada ^9+0*$.

Batch, 175 byte

@set/pn=
@set s=
:g
@set/ag=-~!(n%%2)*(!(n%%5)*4+1)
@if not %g%==1 set s=0%s%&set/an/=g&goto g
@set r=1
:r
@set s=9%s%
@set/ar=r*10%%n
@if %r% gtr 1 goto r
@echo %s%

Mengambil input pada STDIN. Bukan solusi brute force tetapi sebenarnya berdasarkan jawaban saya untuk Fraksi ke desimal yang tepat sehingga akan bekerja selama 17, 19, dll. Yang sebaliknya akan melebihi batas integernya.

Mathematica, 127 byte

Select[FromDigits/@Select[Tuples[{0,9},c=#],Count[#,9]==1||Union@Differences@Flatten@Position[#,9]=={1}&],IntegerQ[#/c]&][[1]]&

Memasukkan

[17]

Keluaran

9999999999999999

di sini adalah 20 istilah pertama

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 9999990, 90, 90000, 9999999999999999, 90, 999999999999999999, 900}

Haskell , 53 byte

f mengambil dan mengembalikan bilangan bulat.

f n=filter(all(<'1').snd.span(>'8').show)[n,n+n..]!!0

Cobalah online!

Kali ini untuk 17, yang nyaman hanya di luar kasus uji. Versi yang lebih cepat dalam 56 byte:

f n=[x|a<-[1..],b<-[0..a-1],x<-[10^a-10^b],mod x n<1]!!0

Cobalah online!

Bagaimana itu bekerja

• f menghasilkan semua kelipatan n , mengonversi masing-masing menjadi string, memfilter mereka dengan format yang tepat, lalu mengambil yang pertama.

• Versi lebih cepat bukan menggunakan angka-angka yang diperlukan adalah formulir 10^a-10^b, a>=1, a>b>=0. Untuk tujuan bermain golf, ia juga menggunakan fakta bahwa untuk permainan minimal a, hanya satu yang b dapat bekerja, yang memungkinkannya untuk menghasilkan huruf bs dalam urutan "salah" yang sedikit lebih pendek.

Rubi , 38 + 1 = 39 byte

Menggunakan -pbendera

$_=y=eval$_
1until"#{$_+=y}"=~/^9+0*$/

-p mengelilingi program dengan:

while gets
    ...
end
puts $_

getsmenyimpan hasilnya di $_. evaldigunakan untuk mengubahnya menjadi angka, karena lebih pendek dari .to_i, maka brute force digunakan, menambah $ _ hingga cocok dengan regex. "#{}"interpolasi sttring, itu lebih pendek dari .to_spanggilan karena akan membutuhkan paranthes di sekitar $_+=y. Akhirnya,$_ dicetak.

Cobalah online!

Coba semua test case!

Dyalog APL, 34 byte

{∧/'0'=('^9+'⎕R'')⊢⍕⍵:⍵⋄∇⍵+r}n←r←⎕

DFF rekursif, berdasarkan pada solusi Python Dennis .

C ++, 106 byte

int main(){long N,T=9,j=10,M;cin>>N;while(T%N){if(T/j){T+=(M/j);j*=10;}else{T=(T+1)*9;j=10;M=T;}}cout<<T;}

Formulir Rinci:

int main()
{
    long N,T=9,j=10,M;
    cin >> N;

    while (T%N)
    {
        if (T/j)
        {
            T += (M/j);
            j *= 10;
        }
        else
        {
            T = (T+1)*9;
            j = 10;
            M = T;
        }
    } 

    cout << T;
}

COBA online!

Python 2 , 79 byte

x=input();n=10;y=9
while y%x:
 b=n
 while(b-1)*(y%x):b/=10;y=n-b
 n*=10
print y

Cobalah online!

Beberapa penjelasan. Ia menemukan bentuk alami terkecil 10**n-10**bdengan n>b>=0yang membagi input.

Beberapa IO

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000
f(17) = 9999999999999999
f(18) = 90
f(19) = 999999999999999999

PHP , 39 byte

for(;ltrim($r=$argn*++$i,9)>0;);echo$r;

Cobalah online!

PHP , 52 byte

for(;!preg_match("#^9+0*$#",$r=$argn*++$i););echo$r;

Cobalah online!

Swift 3.0, Bytes: 121

var i=2,m=1,n=""
while(i>0){n=String(i*m)
if let r=n.range(of:"^9+0*$",options:.regularExpression){print(n)
break};m=m+1}

Cobalah online!

Python 3 , 62 byte

Fungsi ini mengambil bilangan bulat ndan menginisialisasi mke nol. Kemudian menghapus semua nol dari ujung mdan memeriksa apakah hasilnya hanya berisi 9, kembali mjika itu. Jika tidak, ia menambahkan nuntuk mdan cek lagi, dll

def f(n,m=0):
 while{*str(m).strip('0')}!={'9'}:m+=n
 return m

Cobalah online!

Java (OpenJDK 8) , 66 byte, tidak tersedak 17

n->{long a=10,b=1;for(;(a-b)%n>0;b=(b<10?a*=10:b)/10);return a-b;}

Cobalah online!

Lebih lama dari solusi @ KevinCruijssen tetapi dapat menangani jumlah yang sedikit lebih besar. Ini menghitung angka-angka kandidat seperti 10 ^ 6 - 10 ^ 3 = 999000. Panjang 64-bit masih batas, melanggar untuk n = 23.

Mungkin bisa bermain golf sedikit tetapi sudah terlalu lama untuk membuatnya bekerja ...

> <> , 35 byte

&a:v ;n-<
:,a/?(1:^!?%&:&-}:{
a*:\~

Cobalah online , atau tonton di taman bermain ikan !

Mengasumsikan input sudah ada di stack. Bekerja dengan mencari angka dari formulir 10 ^a  - 10 ^b , dengan a <b (ya, itu kurang dari tanda - dibutuhkan lebih sedikit byte!) Sampai habis dibagi input, lalu mencetak 10 ^b  - 10 ^a . Ini jauh lebih cepat daripada metode brute force (yang akan sulit di> <>).

V , 19 14 byte

é0òÀ/[1-8]ü09

Cobalah online!

Penjelasan

é0              ' <m-i>nsert a 0
  ò             ' <m-r>ecursively
   À            ' <m-@>rgument times
               ' <C-A> increment the number (eventually gives all multiples)
     /[1-8]ü09  ' find ([1-8]|09) if this errors, the number is of the form
                ' (9+0*) (because there won't ever be just zeros)
                ' implicitly end the recursion which breaks on the above error

JavaScript (ES6), 51 49 byte

let
f=(n,x=1,y=1)=>(x-y)%n?f(n,x,y*10):x-y||f(n,x*10)

<input type=number value=1 step=1 min=1 oninput=O.value=f(value)>
<input type=number value=9 id=O disabled>

Bukan pendekatan terpendek, tetapi cepat jahat.

Mathematica, 82 byte

Menggunakan pola pengajuan dari jawaban @Jenny_mathy ...

(d=x=1;y=0;f:=(10^x-1)10^y;n:=If[y>0,y--;x++,y=d;d++;x=1];While[Mod[f,#]!=0,n];f)&

Memasukkan:

[17]

Keluaran:

9999999999999999

Dan relatif terhadap argumen dalam komentar di jawaban @ Jenny_mathy dengan @Phoenix ... RepeatedTiming[]aplikasi ke input [17]memberikan

{0.000518, 9999999999999999}

jadi setengah milidetik. Pergi ke input sedikit lebih besar, [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

sedikit di bawah 4 detik.

Tabel uji: Pada 30 bilangan bulat positif pertama, hasilnya adalah

{9, 90, 9, 900, 90, 90, 999999, 9000, 9, 90, 99, 900, 999999, 
9999990, 90, 90000, 9999999999999999, 90, 999999999999999999, 900, 
999999, 990, 9999999999999999999999, 9000, 900, 9999990, 999, 
99999900, 9999999999999999999999999999, 90}

Penjelasan: Satu-satunya keajaiban di sini adalah iterator khusus ("iterator" dalam pengertian CS, bukan arti M'ma)

n := If[ y>0  ,  y-- ; x++  ,  y=d ; d++ ; x=1]

yang bertindak pada variabel global x, jumlah "9" s,, yjumlah trailing "0", dan d, jumlah total digit. Kami ingin mengulang melalui jumlah digit, dan, untuk setiap pilihan jumlah digit, mulai dengan "0" paling banyak dan paling sedikit "9". Jadi hal pertama yang dilakukan kode adalah menginisialisasi dke 1, memaksa adalah nilai yang diinginkan .)x ke 1 dany ke 0. Iterator kustom memeriksa bahwa string "0" dapat dipersingkat. Jika demikian, itu memendek string "0" s satu dan meningkatkan string "1" s satu. Jika tidak, itu menambah jumlah digit, menetapkan jumlah "0" menjadi satu kurang dari jumlah digit, dan mengatur jumlah "9" menjadi 1.dy

Ti-Basic (TI-84 Plus CE), 48 41 byte

Prompt X
For(K,1,0
For(M,-K+1,0
10^(K)-10^(-M
If 0=remainder(Ans,X
Return
End
End

Masukan Prompt-ed selama program; output disimpan di Ans.

Penjelasan:

Mencoba angka-angka dari bentuk (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^m , di mana m + n = k mulai dari 1 dan meningkat, dan untuk setiap nilai k, ia mencoba m = 1, n = k -1; m = 2, n = k-2; ... m = k, n = 0; sampai menemukan kelipatan X.

Ini berfungsi hingga 16; 17 memberikan kesalahan domain karena remainder(hanya dapat menerima dividen hingga 9999999999999 (13 nines), dan 17 harus menghasilkan 999999999999999999 (16 nines).

Prompt X               # 3 bytes, input number
For(K,1,0              # 7 bytes, k in the description above; until a match is found
For(M,-K+1,0           # 10 bytes, start with n=1, m=(k-n)=k-1;
                           # then n=2, m=(k-n)=k-2, up to n=k, m=(k-n)=0
                           # (M=-m because it saved one byte)
10^(K)-10^(-M           # 8 bytes, n=(k-m) nines followed by m zeroes → Ans
If not(remainder(Ans,X # 8 bytes, If X is a factor of Ans (remainder = 0)
Return                 # 2 bytes, End program, with Ans still there
End                    # 2 bytes,
End                    # 1 byte (no newline)

QBIC , 53 byte

{p=p+1┘o=p*9_F!o$|┘n=!A!~(_l!n$|=_l!n+1$|)-(o%:)|\_Xo

Penjelasan

{        infinitely DO
p=p+1    raise p (starts out as 0)
┘o=p*9   Get the mext multiple of 9 off of p
_F!o$|   Flip a string representation of p*9
┘n=!A!   and set 'n' to be an int version of the flipped p*9 
         (this effectively drops trailing 0's)
~        This IF will subtract two values: the first is either 0 for n=x^10, or -1
         and the second bit does (p*9) modulo 'a' (input number): also 0 for the numbers we want
(
 _l!n$|  the length of n's string representation
=        is equal to
_l!n+1$| the length of (n+1)'s string rep (81 + 1 = 82, both are 2 long; 99 + 1 = 100, there's a difference)
)        The above yields -1 (Qbasic's TRUE value) for non-9 runs, 0 for n=x^10
-        Subtract from that 
(o%:)    (p*9) modulo a     0 for p*9 = a*y
|       THEN (do nothing, since we want 0+0=0 in the conditionals above, execution of the right path jumps to ELSE
\_Xo    ELSE quit, printing (p*9)

C (gcc) , 126 byte

#include<stdio.h>
main(x,n,y,b){n=10;y=9;scanf("%d",&x);while(y%x){b=n;while((b-1)*(y%x)){b/=10;y=n-b;}n*=10;}printf("%d",y);}

Cobalah online!

Beberapa penjelasan. Ia menemukan bentuk alami terkecil 10**n-10**bdengan n>b>=0yang membagi input.

Beberapa IO

f(1) = 9
f(2) = 90
f(3) = 9
f(4) = 900
f(5) = 90
f(6) = 90
f(7) = 999999
f(8) = 9000
f(9) = 9
f(10) = 90
f(11) = 99
f(12) = 900
f(13) = 999999
f(14) = 9999990
f(15) = 90
f(16) = 90000

Perl 5 , 23 + 2 (-pa) = 25 byte

Metode Brute Force

$_+=$F[0]while!/^9+0*$/

Cobalah online!

Ini lambat, tapi kecil.

Metode yang Lebih Efisien:

41 + 2 (-pa) = 43 byte

$_=9;s/0/9/||($_=9 .y/9/0/r)while$_%$F[0]

Cobalah online!

Ini bekerja dengan baik untuk input apa pun, tapi ini kode yang lebih panjang.