Olumlu bir tamsayı verildiğinde, en az pozitif tamsayıyı 9 ve daha sonra isteğe bağlı bir 0 dönüşü olan çoklu tamsayı olarak bulun /^9+0*$/.

Örneğin, verilen pozitif tamsayı 2 ise, 90 döndürün, çünkü 90 pozitif 2 tamsayıdır ve regex tarafından eşleşen en küçüktür /^9+0*$/.

Test durumları:

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

Bu kod golfü . Bayt cinsinden en kısa cevap kazanır. Standart boşluklar uygulanır.

Jöle , 13 11 bayt

ṚḌ‘DS=ḍ@ð1#

Çevrimiçi deneyin!

Nasıl çalışır

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

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

Çevrimiçi deneyin!

Python 2 , 51 bayt

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

Çevrimiçi deneyin!

JavaScript (ES6), 47 43 42 bayt

@Arnauld -1 bayt sayesinde @Luke sayesinde -4 bayt

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

Testler

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

Özyinelemeli çözüm (7, 13 ve 14 için başarısız), 38 bayt

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

Gibi denir f(5)(). İçin Chrome ve Firefox'ta maksimum çağrı yığını boyuta ulaştığında n=7, n=13ve 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 bayt

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

Brute-zorlama - sonsuza kadar x = 17 sürer.

Çevrimiçi deneyin!

Java 8, 61 57 bayt

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

@JollyJoker sayesinde -4 bayt (ve daha hızlı işlem) .

Açıklama:

Burada dene.

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 bayt

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

Çevrimiçi deneyin!

Brachylog , 16 bayt

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

Çevrimiçi deneyin!

Bu oldukça yavaş

açıklama

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

0[+D9Û0«_#

Çevrimiçi deneyin!

9 eksi 0'a eşit olana kadar girişi sadece 0'a eklemeye devam ediyor.

RProgN 2,18 bayt

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

Açıklaması

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.

Çevrimiçi deneyin!

Matematik , 71 bayt

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

Çevrimiçi deneyin!

Çok zorlayıcı kaba kuvvet çözümü değil, ama bazı akıllıca numaralar kullanan diğer Mathematica cevabını geçiyor.

Mathematica bu meydan açısından sahip bir kurtarıcı kalite gerçektir StringMatchQYapabileceğim böylece, tam bir eşleşme gerektirir 9+0*yerine ^9+0*$.

Toplu iş, 175 bayt

@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'de girişi ele alır. Kaba bir güç çözümü değil, ancak Kesir’in tam ondalık basamağa verdiğim cevabına dayanarak aslında 17, 19, vb. İçin tamsayı sınırını aşacaktı.

Mathematica, 127 bayt

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

Giriş

[17]

Çıktı

9999999999999999

işte ilk 20 terim

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

Haskell , 53 bayt

f bir tamsayı alır ve döndürür.

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

Çevrimiçi deneyin!

Bu, uygun bir şekilde test durumlarının hemen ötesinde olan 17 için zaman aşımına uğradı. 56 baytta daha hızlı bir sürüm:

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

Çevrimiçi deneyin!

Nasıl çalışır

• fhepsinin katlarını oluşturur n, her birini dizeye dönüştürür, doğru biçime sahip olanları filtreler, sonra ilkini alır.

• Daha hızlı versiyonu yerine gerekli numaralar formda oldukları kullanır 10^a-10^b, a>=1, a>b>=0. Golf amacıyla, en azına göre a, sadece biraz daha kısa "yanlış" sırayla s üretmesine olanak tanıyan sadece birisinin b çalışabileceği gerçeğini kullanır b.

Ruby , 38 + 1 = 39 bayt

-pBayrak kullanır .

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

-p programı çevreleyen:

while gets
    ...
end
puts $_

getssonucunu saklar $_. evalbir sayıya dönüştürmek için kullanılır, kısa olduğundan .to_i, kaba kuvvet kullanılır, regex ile eşleşene kadar $ _ artar. "#{}"enterpolasyondur, .to_setrafta parantez gerektiren bir çağrıdan daha kısadır $_+=y. Sonunda, $_yazdırılır.

Çevrimiçi deneyin!

Tüm test durumlarını deneyin!

Dyalog APL, 34 bayt

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

Özyinelemiş dfns, Dennis'in Python çözümüne dayanıyor .

C ++, 106 bayt

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

Detaylı Form:

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

Çevrimiçi olarak YTL!

Python 2,79 bayt

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

Çevrimiçi deneyin!

Bazı açıklamalar Bu formun en küçük doğal bağlantı bulur 10**n-10**bile n>b>=0o böler girdi.

Bazı 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 bayt

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

Çevrimiçi deneyin!

PHP , 52 bayt

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

Çevrimiçi deneyin!

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

Çevrimiçi deneyin!

Python 3 , 62 bayt

Bu fonksiyon bir tamsayı alır nve msıfıra başlar. Sonra tüm sıfırları uçlarından kaldırır mve sonucun sadece 9'lar içerip içermediğini kontrol eder, eğer varsa döndürür m. Değilse, bu ekler niçin mve kontroller tekrar vs.

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

Çevrimiçi deneyin!

Java (OpenJDK 8) , 66 bayt, 17'de boğulmaz

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

Çevrimiçi deneyin!

@ KevinCruijssen'in çözümünden daha uzun ancak biraz daha büyük sayıları idare edebiliyor. 10 ^ 6 - 10 ^ 3 = 999000 gibi aday sayılarını hesaplar. 64-bit uzunluğunun hala sınırı vardır, n = 23.

Muhtemelen biraz golf oynayabilir, ancak çalışmasını sağlamak için çok uzun sürdü ...

> <> , 35 bayt

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

Çevrimiçi deneyin ya da balık oyun alanında izleyin !

Girişin zaten yığında olduğunu varsayar. 10 ^a  - 10 ^b formundaki sayıları arayarak çalışır , <b (evet, işaretten daha az olur - bu, bayt tarafından bölünene kadar daha az bayt alır!), Ardından girişe bölünene kadar 10 ^b  - 10 ^a basar . Bu kaba kuvvet yönteminden çok daha hızlıdır (ki yine de> <> da zor olurdu).

V , 19 14 bayt

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

Çevrimiçi deneyin!

açıklama

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

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>

En kısa yaklaşım değil, ancak hızlı kötü.

Mathematica, 82 bayt

@Jenny_mathy 'nin cevabından gönderim kalıbını kullanarak ...

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

Giriş:

[17]

Çıktı:

9999999999999999

Ve ile Jenny_mathy cevabı @ de yorumlardaki argüman göreli @Phoenix ... RepeatedTiming[]girişine uygulamanın [17]verir

{0.000518, 9999999999999999}

bu yüzden yarım milisaniye. Bir biraz daha büyük girişine gidiyor [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

4 saniyenin altında bir bit.

Test tablosu: İlk 30 pozitif tamsayıda sonuçları

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

Açıklama: Buradaki tek sihir özel yineleyicidir (CS anlamında "yineleyici", M'ma anlamında değil)

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

küresel değişkenlere etki eden x, öncü "9" s ysayısı, "0" s dsayısını ve toplam basamak sayısını gösterir. Basamak sayısında yineleme yapmak istiyoruz ve her basamak basamağı seçimi için en çok "0" ve en az "9" ile başlıyoruz. Böylece, kodun yaptığı ilk şey d1'e, x1'e ve y0'a zorlayarak başlatılır . Özel yineleyici, "0" s dizesinin kısaltılabildiğini kontrol eder. Öyleyse, "0" s dizesini bir kısaltır ve "1" s dizesini bir artırır. Değilse, basamak sayısını artırır, "0" s sayısını basamak sayısından bire daha az ayarlar ve "9" s sayısını 1'e ayarlar.d istenen değerdir y.)

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

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

PromptProgram boyunca giriş -ed; çıkış saklanır Ans.

Açıklama:

Form numaralarını (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^{m olarak} dener, burada m + n = k 1'de başlar ve artar ve k'nin her değeri için m = 1, n = k dener. 1; m = 2, n = K-2; ... m = k, n = 0; bir çoğunu bulana kadar X.

Bu 16'ya kadar çalışır; 17 remainder(, yalnızca 999999999999999'a (13 dokuz) kadar olan temettüleri kabul edebildiği için bir alan hatası verir ve 17'si 9999999999999999 (16 adet) vermelidir.

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 bayt

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

açıklama

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

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

Çevrimiçi deneyin!

Bazı açıklamalar Bu formun en küçük doğal bağlantı bulur 10**n-10**bile n>b>=0o böler girdi.

Bazı 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 bayt

Kaba kuvvet yöntemi

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

Çevrimiçi deneyin!

Yavaş ama küçük.

Daha Verimli Yöntem:

41 + 2 (-pa) = 43 bayt

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

Çevrimiçi deneyin!

Herhangi bir giriş için iyi çalışıyor, ancak daha uzun kod.