Dato un numero intero positivo, trova il suo multiplo intero più piccolo positivo che è una corsa di 9 seguito da una corsa facoltativa di 0. In altre parole, trova il suo multiplo intero positivo più piccolo che corrisponde al regex /^9+0*$/.

Ad esempio, se il numero intero positivo dato è 2, quindi restituisce 90, poiché 90 è un multiplo intero positivo di 2 ed è il più piccolo a cui corrisponde il regex /^9+0*$/.

Casi test:

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

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

Gelatina , 13 11 byte

ṚḌ‘DS=ḍ@ð1#

Provalo online!

Come funziona

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

Provalo 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

Provalo online!

JavaScript (ES6), 47 43 42 byte

-4 byte grazie a @Arnauld
-1 byte grazie a @Luke

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

test

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

Soluzione ricorsiva (non riuscita per 7, 13 e 14), 38 byte

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

Chiamato come f(5)(). Raggiunge la dimensione dello stack di chiamata massimo in Chrome e Firefox per n=7, n=13e 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`) }
}

Rubino , 36 byte

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

Forza bruta: impiega un'eternità per x = 17.

Provalo online!

Java 8, 61 57 byte

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

-4 byte (ed esecuzione più veloce) grazie a @JollyJoker .

Spiegazione:

Provalo qui.

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)

Provalo online!

Brachylog , 16 byte

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

Provalo online!

Questo è piuttosto lento

Spiegazione

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

Provalo online!

Continua solo ad aggiungere l'input a 0, fino a quando il risultato meno il 9 iniziale è uguale a 0.

RProgN 2 , 18 byte

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

spiegato

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.

Provalo online!

Matematica , 71 byte

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

Provalo online!

Soluzione di forza bruta non molto interessante, ma batte l'altra risposta di Mathematica, che utilizza alcuni trucchi intelligenti.

L'unica qualità che riscatta Mathematica riguardo a questa sfida è il fatto che StringMatchQrichiede una corrispondenza completa, quindi posso fare 9+0*piuttosto che ^9+0*$.

Lotto, 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%

Accetta input su STDIN. Non una soluzione di forza bruta ma in realtà basata sulla mia risposta a Frazione con esatto decimale, quindi funzionerà per 17, 19, ecc. Che altrimenti supererebbe comunque il suo limite intero.

Mathematica, 127 byte

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

Ingresso

[17]

Produzione

9999999999999999

ecco i primi 20 termini

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

Haskell , 53 byte

f accetta e restituisce un numero intero.

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

Provalo online!

Questo è scaduto per 17, che è convenientemente appena oltre i casi di test. Una versione più veloce in 56 byte:

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

Provalo online!

Come funziona

• fgenera tutti i multipli di n, li converte in una stringa, filtra quelli con il formato giusto, quindi prende il primo.

• La versione più veloce utilizza invece che i numeri richiesti sono della forma 10^a-10^b, a>=1, a>b>=0. Ai fini del golf, utilizza anche il fatto che per il minimo asolo uno b può funzionare, il che gli consente di generare le bs nell'ordine "sbagliato" leggermente più breve.

Rubino , 38 + 1 = 39 byte

Usa la -pbandiera.

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

-p circonda il programma con:

while gets
    ...
end
puts $_

getsmemorizza il suo risultato in $_. evalviene utilizzato per convertirlo in un numero, poiché è più breve di .to_i, quindi viene utilizzata la forza bruta, incrementando $ _ fino a quando non corrisponde al regex. "#{}"è l'interpolazione di striatura, è più breve di una .to_schiamata in quanto ciò richiederebbe delle parentesi $_+=y. Finalmente,$_ viene stampato.

Provalo online!

Prova tutti i casi di test!

Dyalog APL, 34 byte

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

Dns ricorsivi, basati sulla soluzione Python di 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;}

Modulo dettagliato:

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

Provalo 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

Provalo online!

Alcune spiegazioni Trova la più piccola forma naturale 10**n-10**bcon n>b>=0quella che divide l'input.

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

Provalo online!

PHP , 52 byte

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

Provalo online!

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}

Provalo online!

Python 3 , 62 byte

Questa funzione accetta un numero intero ne si inizializza ma zero. Quindi rimuove tutti gli zeri dalle estremità di me verifica se il risultato contiene solo 9, restituendo mse lo fa. In caso contrario, si aggiunge nalla me controlla di nuovo, ecc

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

Provalo online!

Java (OpenJDK 8) , 66 byte, non si strozza su 17

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

Provalo online!

Più di @ KevinCruijssen soluzione ma può gestire numeri leggermente più grandi. Calcola i numeri dei candidati come 10 ^ 6 - 10 ^ 3 = 999000. I long a 64 bit sono ancora il limite, superando n = 23.

Probabilmente può essere giocato un po 'a golf ma già ci è voluto troppo tempo per farlo funzionare ...

> <> , 35 byte

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

Provalo online o guardalo nel parco giochi per pesci !

Presuppone che l'input sia già nello stack. Funziona cercando i numeri del modulo 10 ^a  - 10 ^b , con un <b (sì, è un segno meno di - richiede meno byte!) Fino a quando non è divisibile per l'input, quindi stampa 10 ^b  - 10 ^a . Questo è molto più veloce del metodo della forza bruta (che sarebbe difficile in> <> comunque).

V , 19 14 byte

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

Provalo online!

Spiegazione

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

Non è l'approccio più breve, ma è malvagio in fretta.

Mathematica, 82 byte

Utilizzando lo schema di presentazione dalla risposta di @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)&

Ingresso:

[17]

Produzione:

9999999999999999

E rispetto alla tesi nei commenti a @ risposta di Jenny_mathy con @Phoenix ... RepeatedTiming[]di applicazione all'ingresso [17]dà

{0.000518, 9999999999999999}

quindi mezzo millisecondo. Andando ad un ingresso leggermente più grande, [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

un po 'meno di 4 secondi.

Tabella dei test: sui primi 30 numeri interi positivi, i risultati sono

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

Spiegazione: l'unica magia qui è l'iteratore personalizzato ("iteratore" nel senso CS, non nel senso M'ma)

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

che agisce sulle variabili globali x, il numero di "9" s iniziali y, il numero di "0" s finali e dil numero totale di cifre. Desideriamo scorrere il numero di cifre e, per ciascuna scelta del numero di cifre, iniziare con il maggior numero di "0" e il minimo di "9". Quindi la prima cosa che il codice fa è inizializzare da 1, forzando xa 1 ed è il valore desiderato di .)y a 0. L'iteratore personalizzato verifica che la stringa di "0" s possa essere abbreviata. In tal caso, accorcia la stringa di "0" di uno e aumenta la stringa di "1" di uno. In caso contrario, aumenta il numero di cifre, imposta il numero di "0" s su uno in meno rispetto al numero di cifre e imposta il numero di "9" s su 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

L'ingresso è Prompt-ed durante il programma; l'output è archiviato in Ans.

Spiegazione:

Cerca i numeri del modulo (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^m , dove m + n = k inizia da 1 e aumenta e per ogni valore di k prova m = 1, n = k -1; m = 2, n = k-2; ... m = k, n = 0; fino a quando non trova un multiplo di X.

Funziona fino a 16; 17 dà un errore di dominio perché remainder(può accettare solo dividendi fino a 9999999999999 (13 nove) e 17 dovrebbe produrre 999999999999999999 (16 nove).

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

Spiegazione

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

Provalo online!

Alcune spiegazioni Trova la più piccola forma naturale 10**n-10**bcon n>b>=0quella che divide l'input.

Alcuni 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

Metodo della forza bruta

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

Provalo online!

È lento, ma è minuscolo.

Metodo più efficiente:

41 + 2 (-pa) = 43 byte

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

Provalo online!

Funziona bene per qualsiasi input, ma è un codice più lungo.