ได้รับจำนวนเต็มบวกหาเล็ก ๆ ของมันหลายจำนวนเต็มบวกซึ่งเป็นระยะที่ 9 ตามด้วยการดำเนินการที่ไม่จำเป็นของ 0. ในคำอื่น ๆ พบว่ามีขนาดเล็กที่สุดหลายจำนวนเต็มบวกซึ่งจะถูกจับคู่โดย /^9+0*$/regex

ตัวอย่างเช่นถ้าจำนวนเต็มบวกที่ได้รับคือ 2 แล้วกลับ 90 ตั้งแต่ 90 เป็นจำนวนเต็มบวกของ 2 และเป็นที่เล็กที่สุดซึ่งมีการจับคู่โดย /^9+0*$/regex

กรณีทดสอบ:

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

นี่คือรหัสกอล์ฟ คำตอบที่สั้นที่สุดในการชนะไบต์ ช่องโหว่มาตรฐานใช้

เยลลี่ , 13 11 ไบต์

ṚḌ‘DS=ḍ@ð1#

ลองออนไลน์!

มันทำงานอย่างไร

ṚḌ‘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 ไบต์

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

ลองออนไลน์!

Python 2 , 51 ไบต์

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

ลองออนไลน์!

JavaScript (ES6), 47 43 42 ไบต์

-4 ไบต์ขอบคุณ @Arnauld
-1 ไบต์ขอบคุณ @Luke

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

การทดสอบ

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

โซลูชันแบบเรียกซ้ำ (ล้มเหลวสำหรับ 7, 13 และ 14), 38 ไบต์

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

f(5)()เรียกว่าเหมือน ถึงขนาดโทรสูงสุดสแต็คใน Chrome และ Firefox สำหรับn=7, และn=13n=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 ไบต์

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

Brute-forcing - ใช้เวลาตลอดไปสำหรับ x = 17

ลองออนไลน์!

Java 8, 61 57 ไบต์

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

-4 ไบต์ (และการดำเนินการได้เร็วขึ้น) ขอบคุณที่@JollyJoker

คำอธิบาย:

ลองที่นี่

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 ไบต์

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

ลองออนไลน์!

Brachylogขนาด 16 ไบต์

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

ลองออนไลน์!

นี่ค่อนข้างช้า

คำอธิบาย

;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 ไบต์

0[+D9Û0«_#

ลองออนไลน์!

มันแค่เพิ่มการป้อนข้อมูลเป็น 0 จนกว่าผลลัพธ์จะลบนำหน้า 9 เท่ากับ 0

RProgN 2 , 18 ไบต์

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

อธิบาย

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.

ลองออนไลน์!

คณิตศาสตร์ , 71 ไบต์

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

ลองออนไลน์!

ไม่ใช่วิธีการแก้ปัญหาที่ดุร้ายมาก แต่มันก็ตอบโจทย์ Mathematica คนอื่นซึ่งใช้เทคนิคที่ชาญฉลาด

คุณภาพหนึ่งไถ่ Mathematica มีอยู่ในเรื่องที่เกี่ยวกับความท้าทายนี้เป็นความจริงที่StringMatchQต้องมีการแข่งขันเต็มรูปแบบเพื่อที่ฉันจะทำมากกว่า9+0*^9+0*$

แบตช์ 175 ไบต์

@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%

ใช้อินพุตบน STDIN ไม่ใช่วิธีการบังคับเดรัจฉาน แต่อันที่จริงตามคำตอบของฉันในการเศษส่วนเป็นทศนิยมที่แน่นอนดังนั้นมันจึงใช้ได้สำหรับ 17, 19 และอื่น ๆ ซึ่งอาจเกินขีด จำกัด จำนวนเต็มของมันได้

Mathematica, 127 ไบต์

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

อินพุต

[17]

เอาท์พุต

9999999999999999

นี่คือ 20 คำแรก

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

Haskell , 53 ไบต์

f รับและคืนค่าจำนวนเต็ม

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

ลองออนไลน์!

หมดเวลาไปกับ 17 ซึ่งสะดวกเกินกว่ากรณีทดสอบ รุ่นที่เร็วขึ้นใน 56 ไบต์:

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

ลองออนไลน์!

มันทำงานอย่างไร

• f สร้างทวีคูณทั้งหมดของ nแปลงเป็นสตริงกรองรายการที่มีรูปแบบที่ถูกต้องจากนั้นเลือกรายการแรก

• รุ่นเร็วขึ้นแทนที่จะใช้ว่าตัวเลขที่จำเป็นต้องมีรูปแบบ10^a-10^b, ,a>=1 a>b>=0เพื่อวัตถุประสงค์ในการเล่นกอล์ฟมันยังใช้ความจริงที่ว่าน้อยที่สุดaมีเพียงคน เดียวเท่านั้นที่bสามารถทำงานbได้

ทับทิม , 38 + 1 = 39 ไบต์

ใช้-pธง

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

-p ล้อมรอบโปรแกรมด้วย:

while gets
    ...
end
puts $_

gets$_เก็บผลใน evalใช้ในการแปลงเป็นตัวเลขเนื่องจากสั้นกว่า.to_iจากนั้นจะใช้แรงเดรัจฉานโดยเพิ่ม $ _ จนกระทั่งมันตรงกับ regex "#{}"กำลังแก้ไขการโพสต์มันสั้นกว่าการ.to_sโทรเพราะจะต้องมีการล้อมรอบ$_+=yการโทรเป็นที่จะต้องมีวงเล็บรอบในที่สุด$_ก็มีการพิมพ์

ลองออนไลน์!

ลองกรณีทดสอบทั้งหมด!

Dyalog APL, 34 ไบต์

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

dfns ซ้ำขึ้นอยู่กับเดนนิสแก้ปัญหาหลาม

C ++, 106 ไบต์

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

แบบฟอร์มรายละเอียด:

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

ลองออนไลน์!

Python 2 , 79 ไบต์

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

ลองออนไลน์!

คำอธิบายบาง พบที่เล็กที่สุดตามธรรมชาติของรูปแบบ10**n-10**bที่มีการn>b>=0แบ่งว่าการป้อนข้อมูล

บาง 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 ไบต์

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

ลองออนไลน์!

PHP , 52 ไบต์

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

ลองออนไลน์!

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}

ลองออนไลน์!

Python 3 , 62 ไบต์

ฟังก์ชันนี้ใช้จำนวนเต็มnและเริ่มต้นmเป็นศูนย์ จากนั้นมันจะลบศูนย์ทั้งหมดออกจากส่วนท้ายของmและตรวจสอบว่าผลลัพธ์มีเพียง 9 ตัวหรือmไม่ถ้ากลับมา ถ้าไม่ได้ก็จะเพิ่มnการmและการตรวจสอบอีกครั้ง ฯลฯ

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

ลองออนไลน์!

Java (OpenJDK 8) , 66 ไบต์ไม่สำลักในวันที่ 17

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

ลองออนไลน์!

นานกว่า @ KevinCruijssen โซลูชันแต่สามารถรองรับตัวเลขที่มีขนาดใหญ่กว่าเล็กน้อยได้ มันคำนวณตัวเลขผู้สมัครเช่น 10 ^ 6 - 10 ^ 3 = 999000 ความยาว 64- บิตยังคงเป็นขีด จำกัด โดยแบ่งเป็น n = 23

อาจจะเล่นกอล์ฟสักหน่อย แต่ใช้เวลานานเกินไปที่จะทำให้มันทำงาน ...

> <> , 35 ไบต์

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

ลองออนไลน์หรือดูได้ที่สนามเด็กเล่นปลา !

สมมติว่าอินพุตอยู่บนสแต็กแล้ว ทำงานโดยการมองหาตัวเลขของแบบฟอร์ม 10  - 10 ^ขด้วย <b (ใช่ว่าเป็นเครื่องหมายน้อยกว่า - มันจะใช้เวลาน้อยลงไบต์!) จนกว่าที่หารด้วยการป้อนข้อมูลแล้วพิมพ์ 10 ^ข  - 10 วิธีนี้เร็วกว่าวิธีบังคับเดรัจฉาน (ซึ่งจะยากใน> <> ต่อไป)

V , 19 14 ไบต์

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

ลองออนไลน์!

คำอธิบาย

é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 ไบต์

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>

ไม่ใช่วิธีที่สั้นที่สุด แต่เร็วเกินไป

Mathematica, 82 ไบต์

ใช้รูปแบบการส่งจากคำตอบของ @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)&

การป้อนข้อมูล:

[17]

เอาท์พุท:

9999999999999999

และเกี่ยวข้องกับการโต้แย้งในความคิดเห็นที่ @ Jenny_mathy ตอบด้วย@Phoenix ... RepeatedTiming[]แอปพลิเคชันที่ป้อน[17]ให้

{0.000518, 9999999999999999}

ดังนั้นครึ่งมิลลิวินาที ไปที่อินพุตที่ใหญ่กว่าเล็กน้อย[2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

น้อยกว่า 4 วินาที

ตารางทดสอบ: ในจำนวนเต็มบวก 30 รายการแรกผลลัพธ์คือ

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

คำอธิบาย: เวทมนตร์ที่นี่เท่านั้นคือตัววนซ้ำแบบกำหนดเอง ("ตัววนซ้ำ" ในความหมาย CS ไม่ใช่ความหมายของนายท่าน)

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

ซึ่งทำหน้าที่เกี่ยวกับตัวแปรโกลบอลxจำนวนผู้นำ "9" y, จำนวนการติดตาม "0" และdจำนวนหลักทั้งหมด เราต้องการวนซ้ำตามจำนวนหลักและสำหรับแต่ละตัวเลือกของตัวเลขให้เริ่มด้วย "0" และน้อยที่สุด "9" ดังนั้นสิ่งแรกที่รหัสทำคือเริ่มต้นdที่ 1 บังคับเป็นค่าที่ต้องการของ)xให้ 1 และy 0 ตัวทำซ้ำที่กำหนดเองตรวจสอบว่าสตริงของ "0" สามารถสั้นลง ถ้าเป็นเช่นนั้นสตริงของ "0" จะสั้นลงและเพิ่มสตริงของ "1" ต่อหนึ่ง หากไม่ใช่จะเป็นการเพิ่มจำนวนหลักตั้งค่าจำนวน "0" เป็นหนึ่งน้อยกว่าจำนวนหลักและตั้งค่าจำนวน "9" เป็น 1dy

Ti-Basic (TI-84 Plus CE), 48 41 ไบต์

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

อินพุตถูกป้อนPromptระหว่างโปรแกรม Ansการส่งออกจะถูกเก็บไว้ใน

คำอธิบาย:

พยายามตัวเลขของแบบฟอร์ม (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^mโดยที่ m + n = k เริ่มต้นที่ 1 และเพิ่มขึ้นและสำหรับแต่ละค่าของ k มันจะลอง m = 1, n = k -1; m = 2 n = k-2; ... m = k, n = 0; Xจนกว่าจะพบหลายของ

ใช้งานได้ถึง 16; 17 ให้ข้อผิดพลาดโดเมนเพราะremainder(สามารถรับเงินปันผลได้มากถึง 9999999999999 (13 เก้า) และ 17 ควรส่งออก 9999999999999999 (16 เก้า)

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 ไบต์

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

คำอธิบาย

{        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 ไบต์

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

ลองออนไลน์!

คำอธิบายบาง พบที่เล็กที่สุดตามธรรมชาติของรูปแบบ10**n-10**bที่มีการn>b>=0แบ่งว่าการป้อนข้อมูล

บาง 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 ไบต์

วิธีการดุร้ายกำลัง

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

ลองออนไลน์!

มันช้า แต่มันเล็กไป

วิธีที่มีประสิทธิภาพมากขึ้น:

41 + 2 (-pa) = 43 ไบต์

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

ลองออนไลน์!

มันทำงานได้ดีสำหรับการป้อนข้อมูลใด ๆ แต่มันเป็นรหัสอีกต่อไป