Cho một số nguyên dương, tìm bội số nguyên dương nhỏ nhất của nó là một số 9 theo sau là một tùy chọn bằng 0. Nói cách khác, tìm bội số nguyên dương nhỏ nhất của nó được khớp với biểu thức chính quy /^9+0*$/.

Ví dụ: nếu số nguyên dương đã cho là 2, thì trả về 90, vì 90 là bội số nguyên dương của 2 và là số nhỏ nhất được khớp với biểu thức chính quy /^9+0*$/.

Các trường hợp thử nghiệm:

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

Đây là mã golf . Câu trả lời ngắn nhất trong byte thắng. Tiêu chuẩn áp dụng.

Thạch , 13 11 byte

ṚḌ‘DS=ḍ@ð1#

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

ṚḌ‘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

Hãy thử trực tuyến!

Python 2 , 51 byte

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

Hãy thử trực tuyến!

JavaScript (ES6), 47 43 42 byte

-4 byte nhờ @Arnauld -1 byte nhờ @Luke

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

Xét nghiệm

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))

Giải pháp đệ quy (không thành công cho 7, 13 và 14), 38 byte

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

Gọi như thế f(5)(). Đạt tới kích cỡ gọi stack tối đa trong Chrome và Firefox cho n=7, n=13và 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-buộc - mất mãi mãi cho x = 17.

Hãy thử trực tuyến!

Java 8, 61 57 byte

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

-4 byte (và thực thi nhanh hơn) nhờ @JollyJoker .

Giải trình:

Hãy thử nó ở đây.

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)

Hãy thử trực tuyến!

Brachylog , 16 byte

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

Hãy thử trực tuyến!

Cái này khá chậm

Giải trình

;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«_#

Hãy thử trực tuyến!

Nó chỉ tiếp tục thêm đầu vào thành 0, cho đến khi kết quả trừ đi 9 đầu bằng 0.

RProgN 2 , 18 byte

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

Giải thích

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.

Hãy thử trực tuyến!

Toán học , 71 byte

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

Hãy thử trực tuyến!

Không phải là giải pháp vũ phu rất hấp dẫn, nhưng nó đánh bại câu trả lời Mathicala khác, trong đó sử dụng một số thủ thuật thông minh.

Mathicala có chất lượng hoàn lại có liên quan đến thử thách này là thực tế StringMatchQđòi hỏi phải có một trận đấu đầy đủ, vì vậy tôi có thể làm 9+0*hơn là ^9+0*$.

Mẻ, 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%

Đưa đầu vào vào STDIN. Không phải là một giải pháp vũ lực nhưng thực tế dựa trên câu trả lời của tôi về Phân số chính xác để nó hoạt động trong 17, 19, v.v ... dù sao cũng sẽ vượt quá giới hạn số nguyên của nó.

Toán học, 127 byte

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

Đầu vào

[17]

Đầu ra

9999999999999999

đây là 20 điều khoản đầu tiên

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

Haskell , 53 byte

f lấy và trả về một số nguyên.

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

Hãy thử trực tuyến!

Lần này là 17, thuận tiện là vượt ra ngoài các trường hợp thử nghiệm. Phiên bản nhanh hơn với 56 byte:

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

• ftạo ra tất cả bội số của n, chuyển đổi từng chuỗi thành một chuỗi, lọc ra những chuỗi có định dạng đúng, sau đó lấy chuỗi đầu tiên.

• Các phiên bản nhanh hơn thay vì sử dụng rằng những con số cần thiết có dạng 10^a-10^b, a>=1, a>b>=0. Đối với mục đích chơi gôn, nó cũng sử dụng thực tế là với mức tối thiểu a, chỉ một người b có thể làm việc, cho phép nó tạo ra các bs theo thứ tự "sai" ngắn hơn một chút.

Ruby , 38 + 1 = 39 byte

Sử dụng -pcờ.

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

-p bao quanh chương trình với:

while gets
    ...
end
puts $_

getslưu trữ kết quả của nó trong $_. evalđược sử dụng để chuyển đổi nó thành một số, vì nó ngắn hơn .to_i, sau đó lực lượng vũ phu được sử dụng, tăng $ _ cho đến khi nó khớp với biểu thức chính quy. "#{}"là nội suy sttring, nó ngắn hơn một .to_scuộc gọi vì nó sẽ yêu cầu các phép đối xứng xung quanh $_+=y. Cuối cùng, $_được in.

Hãy thử trực tuyến!

Hãy thử tất cả các trường hợp thử nghiệm!

APL Dyalog, 34 byte

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

Các dfns đệ quy, dựa trên giải pháp Python của 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;}

Mẫu chi tiết:

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;
}

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Một số giải thích Nó tìm thấy dạng tự nhiên nhỏ nhất 10**n-10**bvới n>b>=0phân chia đầu vào.

Một số 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;

Hãy thử trực tuyến!

PHP , 52 byte

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

Hãy thử trực tuyến!

Swift 3.0, byte: 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}

Hãy thử trực tuyến!

Python 3, 62 bytes

This function takes an integer n and initializes m to zero. Then it removes all zeros from the ends of m and checks if the result only contains 9's, returning m if it does. If not, it adds n to m and checks again, etc.

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

Try it online!

Java (OpenJDK 8), 66 bytes, doesn't choke on 17

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

Try it online!

Longer than @KevinCruijssen's solution but can handle slightly larger numbers. It calculates the candidate numbers like 10^6 - 10^3 = 999000. 64-bit longs are still the limit, breaking for n=23.

Can probably be golfed a bit but already took too long to make it work...

><>, 35 bytes

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

Try it online, or watch it at the fish playground!

Assumes the input is already on the stack. Works by looking for numbers of the form 10^a − 10^b, with a < b (yes, that's a less than sign — it takes fewer bytes!) until that's divisible by the input, then printing 10^b − 10^a. This is much faster than the brute force method (which would be difficult in ><> anyway).

V, 19 14 bytes

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

Try it online!

Explanation

é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 bytes

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>

Not the shortest approach, but it is wicked fast.

Mathematica, 82 bytes

Using the pattern of submission from @Jenny_mathy 's answer...

(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)&

Input:

[17]

Output:

9999999999999999

And relative to the argument in comments at @Jenny_mathy's answer with @Phoenix ... RepeatedTiming[] of application to the input [17] gives

{0.000518, 9999999999999999}

so half a millisecond. Going to a slightly larger input, [2003] :

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

a bit under 4 seconds.

Test table: On the first 30 positive integers, the results are

{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}

Explanation: The only magic here is the custom iterator ("iterator" in the CS sense, not the M'ma sense)

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

which acts on the global variables x, the number of leading "9"s, y, the number of trailing "0"s, and d, the total number of digits. We wish to iterate through the number of digits, and, for each choice of number of digits, start with the most "0"s and the least "9"s. Thus the first thing the code does is initialize d to 1, forcing x to 1 and y to 0. The custom iterator checks that the string of "0"s can be shortened. If so, it shortens the string of "0"s by one and increases the string of "1"s by one. If not, it increments the number of digits, sets the number of "0"s to one less than the number of digits, and sets the number of "9"s to 1. (This is actually done in a slightly different order to shave a few characters, since the old value of d is the desired value of y.)

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

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

Input is Prompt-ed during the program; output is stored in Ans.

Explanation:

Tries numbers of the form (10ⁿ)(10^m-1) = 10^k-10^m, where m+n=k starts at 1 and increases, and for each value of k, it tries m=1,n=k-1; m=2,n=k-2; ... m=k,n=0; until it finds a multiple of X.

This works up to 16; 17 gives a domain error because remainder( can only accept dividends up to 9999999999999 (13 nines), and 17 should output 9999999999999999 (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 bytes

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

Explanation

{        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 bytes

#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);}

Try it online!

Some explanations It finds the smallest natural of form 10**n-10**b with n>b>=0 that divides the input.

Some 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 bytes

Brute Force Method

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

Try it online!

It's slow, but it's tiny.

More Efficient Method:

41 + 2 (-pa) = 43 bytes

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

Try it online!

It works well for any input, but it's longer code.