Ermitteln Sie bei einer positiven Ganzzahl das kleinste positive Ganzzahl-Vielfache, dh einen Lauf von 9, gefolgt von einem optionalen Lauf von 0. Mit anderen Worten, ermitteln Sie das kleinste positive Ganzzahl-Vielfache, das mit dem regulären Ausdruck übereinstimmt /^9+0*$/.

Wenn zum Beispiel die angegebene positive Ganzzahl 2 ist, wird 90 zurückgegeben, da 90 ein positives ganzzahliges Vielfaches von 2 ist und das kleinste ist, mit dem der reguläre Ausdruck übereinstimmt /^9+0*$/.

Testfälle:

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

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

Jelly , 13 11 Bytes

ṚḌ‘DS=ḍ@ð1#

Probieren Sie es online!

Wie es funktioniert

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

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

Probieren Sie es online!

Python 2 , 51 Bytes

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

Probieren Sie es online!

JavaScript (ES6), 47 43 42 Byte

-4 Byte dank @Arnauld
-1 Byte dank @Luke

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

Tests

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

Rekursive Lösung (schlägt für 7, 13 und 14 fehl), 38 Byte

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

Genannt wie f(5)(). Erreicht die max Call - Stack Größe in Chrome und Firefox für n=7, n=13und 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 Bytes

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

Brute-Forcing - dauert ewig für x = 17.

Probieren Sie es online!

Java 8, 61 57 Bytes

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

-4 Bytes (und schnellere Ausführung) dank @JollyJoker .

Erläuterung:

Probieren Sie es hier aus.

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 Bytes

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

Probieren Sie es online!

Brachylog , 16 Bytes

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

Probieren Sie es online!

Das ist ziemlich langsam

Erläuterung

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

0[+D9Û0«_#

Probieren Sie es online!

Die Eingabe wird immer wieder zu 0 addiert, bis das Ergebnis abzüglich der führenden 9 gleich 0 ist.

RProgN 2 , 18 Bytes

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

Erklärt

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.

Probieren Sie es online!

Mathematik , 71 Bytes

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

Probieren Sie es online!

Keine sehr interessante Brute-Force-Lösung, aber sie schlägt die andere Mathematica-Antwort, bei der einige clevere Tricks zum Einsatz kommen.

Der einzige Vorteil, den Mathematica in Bezug auf diese Herausforderung hat, ist die Tatsache, StringMatchQdass eine vollständige Übereinstimmung erforderlich ist, sodass ich dies 9+0*eher tun kann als ^9+0*$.

Batch, 175 Bytes

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

Übernimmt die Eingabe für STDIN. Keine Brute-Force-Lösung, sondern basiert in der Tat auf meiner Antwort auf Fraction auf die exakte Dezimalzahl, sodass es für 17, 19 usw. funktioniert, die sonst ohnehin die Ganzzahlgrenze überschreiten würden.

Mathematica, 127 Bytes

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

Eingang

[17]

Ausgabe

9999999999999999

Hier sind die ersten 20 Begriffe

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

Haskell , 53 Bytes

f nimmt und gibt eine ganze Zahl zurück.

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

Probieren Sie es online!

Dies ist eine Zeitüberschreitung von 17, was praktisch jenseits der Testfälle liegt. Eine schnellere Version in 56 Bytes:

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

Probieren Sie es online!

Wie es funktioniert

• fgeneriert alle Vielfachen von n, konvertiert jedes in einen String, filtert diejenigen mit dem richtigen Format heraus und nimmt dann das erste.

• Die schnellere Version verwendet stattdessen , dass die erforderlichen Zahlen der Form sind 10^a-10^b, a>=1, a>b>=0. Für Golfzwecke wird auch die Tatsache ausgenutzt, dass für das Minimum anur eines arbeiten b kann, wodurch es ermöglicht wird, das bs in der etwas kürzeren "falschen" Reihenfolge zu erzeugen .

Ruby , 38 + 1 = 39 Bytes

Verwendet -pFlagge.

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

-p umgibt das Programm mit:

while gets
    ...
end
puts $_

getsspeichert sein Ergebnis in $_. evalwird verwendet, um es in eine Zahl umzuwandeln, da es kürzer ist als .to_i, dann wird rohe Gewalt angewendet, die $ _ inkrementiert, bis es mit dem regulären Ausdruck übereinstimmt. "#{}"Wenn es sich um eine String-Interpolation handelt, ist sie kürzer als ein .to_sAufruf, da dies Klammern erfordern würde $_+=y. Schließlich $_wird gedruckt.

Probieren Sie es online!

Probieren Sie alle Testfälle aus!

Dyalog APL, 34 Bytes

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

Rekursives dfns, basierend auf Dennis 'Python-Lösung .

C ++, 106 Bytes

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

Ausführliches Formular:

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

Probieren Sie es online!

Python 2 , 79 Bytes

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

Probieren Sie es online!

Einige Erklärungen Es findet die kleinste natürliche Formen 10**n-10**bmit , n>b>=0dass teilt die Eingabe.

Einige 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 Bytes

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

Probieren Sie es online!

PHP , 52 Bytes

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

Probieren Sie es 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}

Probieren Sie es online!

Python 3 , 62 Bytes

Diese Funktion nimmt eine ganze Zahl nund initialisiert mauf Null. Dann werden alle Nullen an den Enden von entfernt mund geprüft, ob das Ergebnis nur 9 enthält, und es wird zurückgegeben, mwenn dies der Fall ist. Falls nicht, fügt sie nan mund überprüft erneut, usw.

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

Probieren Sie es online!

Java (OpenJDK 8) , 66 Bytes, drosselt nicht auf 17

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

Probieren Sie es online!

Länger als die Lösung von @ KevinCruijssen , kann jedoch etwas größere Zahlen verarbeiten. Es berechnet die Kandidatenzahlen wie 10 ^ 6 - 10 ^ 3 = 999000. 64-Bit-Longs sind immer noch die Obergrenze und brechen für n = 23.

Kann wahrscheinlich ein bisschen golfen werden, aber es hat schon zu lange gedauert, bis es funktioniert ...

> <> , 35 Bytes

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

Probieren Sie es online aus oder schauen Sie es sich auf dem Fischspielplatz an !

Angenommen, die Eingabe befindet sich bereits auf dem Stapel. Suchen Sie nach Zahlen der Form 10 ^a  - 10 ^b , wobei a <b (ja, das ist ein Zeichen weniger als - es dauert weniger Bytes!), Bis dies durch die Eingabe teilbar ist, und drucken Sie dann 10 ^b  - 10 ^a . Dies ist viel schneller als die Brute-Force-Methode (die in> <> ohnehin schwierig wäre).

V , 19-14 Bytes

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

Probieren Sie es online!

Erläuterung

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

Nicht die kürzeste Annäherung, aber sie ist schnell böse.

Mathematica, 82 Bytes

Unter Verwendung des Einreichungsmusters von @Jenny_mathys Antwort ...

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

Eingang:

[17]

Ausgabe:

9999999999999999

Und relativ zu dem Argument in Kommentaren bei @ Jenny_mathys Antwort mit @Phoenix ... RepeatedTiming[]der Anwendung auf den Eingang [17]gibt

{0.000518, 9999999999999999}

also eine halbe Millisekunde. Sich zu einem etwas größeren Eingang [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

etwas unter 4 Sekunden.

Testtabelle: Bei den ersten 30 positiven ganzen Zahlen sind die Ergebnisse

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

Erläuterung: Die einzige Magie hier ist der benutzerdefinierte Iterator ("Iterator" im CS-Sinne, nicht der M'ma-Sinn).

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

Dies wirkt sich auf die globalen Variablen x, die Anzahl der führenden "9" y, die Anzahl der nachfolgenden "0" und ddie Gesamtzahl der Ziffern aus. Wir möchten die Anzahl der Stellen durchlaufen und für jede Wahl der Anzahl der Stellen mit den meisten "0" und den geringsten "9" beginnen. Daher initialisiert der Code zuerst dauf 1, erzwingt x1 und y0. Der benutzerdefinierte Iterator überprüft, ob die Zeichenfolge der "0" gekürzt werden kann. In diesem Fall wird die Zeichenfolge von "0" um eins gekürzt und die Zeichenfolge von "1" um eins erhöht. Ist dies nicht der Fall, wird die Anzahl der Stellen erhöht, die Anzahl der "0" auf eins weniger als die Anzahl der Stellen gesetzt und die Anzahl der "9" auf 1 gesetzt.dist der gewünschte Wert von y.)

Ti-Basic (TI-84 Plus CE), 48 bis 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

Die Eingabe erfolgt Promptwährend des Programms; Die Ausgabe wird in gespeichert Ans.

Erläuterung:

Versucht Zahlen der Form (10 ⁿ ) (10 ^m –1) = 10 ^k –10 ^m , wobei m + n = k bei 1 beginnt und zunimmt, und für jeden Wert von k wird versucht, m ​​= 1, n = k -1; m = 2, n = k - 2; ... m = k, n = 0; bis es ein Vielfaches von findet X.

Dies funktioniert bis zu 16; 17 gibt einen Domänenfehler aus, da remainder(nur Dividenden bis zu 9999999999999 (13 Neunen) akzeptiert werden und 17 9999999999999999 (16 Neunen) ausgeben sollte.

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

Erläuterung

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

Probieren Sie es online!

Einige Erklärungen Es findet die kleinste natürliche Formen 10**n-10**bmit , n>b>=0dass teilt die Eingabe.

Einige 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-Methode

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

Probieren Sie es online!

Es ist langsam, aber winzig.

Effizientere Methode:

41 + 2 (-pa) = 43 Bytes

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

Probieren Sie es online!

Es funktioniert gut für jede Eingabe, aber es ist längerer Code.