Dado un entero positivo, encuentre su múltiplo entero positivo más pequeño, que es una corrida de 9 seguido de una corrida opcional de 0. En otras palabras, encuentre su múltiplo entero positivo más pequeño que coincida con la expresión regular /^9+0*$/.

Por ejemplo, si el entero positivo dado es 2, entonces devuelve 90, ya que 90 es un múltiplo entero positivo de 2 y es el más pequeño que coincide con la expresión regular /^9+0*$/.

Casos de prueba:

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

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

Jalea , 13 11 bytes

ṚḌ‘DS=ḍ@ð1#

Pruébalo en línea!

Cómo funciona

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

Pruébalo en línea!

Python 2 , 51 bytes

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

Pruébalo en línea!

JavaScript (ES6), 47 43 42 bytes

-4 bytes gracias a @Arnauld
-1 byte gracias a @Luke

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

Pruebas

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

Solución recursiva (falla para 7, 13 y 14), 38 bytes

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

Llamado así f(5)(). Alcanza el tamaño máximo de pila de llamadas en Chrome y Firefox para n=7, n=13y 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}

Fuerza bruta: toma una eternidad para x = 17.

Pruébalo en línea!

Java 8, 61 57 bytes

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

-4 bytes (y una ejecución más rápida) gracias a @JollyJoker .

Explicación:

Pruébalo aquí

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)

Pruébalo en línea!

Brachylog , 16 bytes

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

Pruébalo en línea!

Esto es bastante lento

Explicación

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

Pruébalo en línea!

Simplemente sigue agregando la entrada a 0, hasta que el resultado menos los 9 iniciales iguales es igual a 0.

RProgN 2 , 18 bytes

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

Explicado

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.

Pruébalo en línea!

Matemáticas , 71 bytes

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

Pruébalo en línea!

No es una solución de fuerza bruta muy interesante, pero supera la otra respuesta de Mathematica, que utiliza algunos trucos ingeniosos.

La única cualidad que tiene Mathematica con respecto a este desafío es el hecho de que StringMatchQrequiere una coincidencia completa, por lo que puedo hacerlo en 9+0*lugar de hacerlo ^9+0*$.

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

Toma entrada en STDIN. No es una solución de fuerza bruta, sino que de hecho se basa en mi respuesta a la fracción al decimal exacto, por lo que funcionará para 17, 19, etc., que de lo contrario superaría su límite de todos modos.

Mathematica, 127 bytes

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

Entrada

[17]

Salida

9999999999999999

Aquí están los primeros 20 términos

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

Haskell , 53 bytes

f toma y devuelve un entero.

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

Pruébalo en línea!

Esto agota el tiempo para 17, que convenientemente está más allá de los casos de prueba. Una versión más rápida en 56 bytes:

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

Pruébalo en línea!

Cómo funciona

• f genera todos los múltiplos de n , convierte cada uno en una cadena, filtra aquellos con el formato correcto y luego toma el primero.

• La versión más rápida que en su lugar utiliza los números requeridos son de la forma 10^a-10^b, a>=1, a>b>=0. Para fines de golf, también utiliza el hecho de que, para el mínimo a, solo uno b puede funcionar, lo que le permite generar el bs en el orden "incorrecto" un poco más corto.

Ruby , 38 + 1 = 39 bytes

Usa -pbandera.

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

-p rodea el programa con:

while gets
    ...
end
puts $_

getsalmacena su resultado en $_. evalse usa para convertirlo en un número, ya que es más corto que .to_i, luego se usa la fuerza bruta, incrementando $ _ hasta que coincida con la expresión regular. "#{}"está interpolando, es más corto que una .to_sllamada, ya que eso requeriría paréntesis $_+=y. Finalmente,$_ está impreso.

Pruébalo en línea!

¡Pruebe todos los casos de prueba!

Dyalog APL, 34 bytes

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

Dfns recursivos, basados ​​en la solución Python de Dennis .

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

Forma detallada:

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

¡PRUÉBALO en línea!

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

Pruébalo en línea!

Algunas explicaciones Encuentra la forma natural más pequeña 10**n-10**bcon la n>b>=0que divide la entrada.

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

Pruébalo en línea!

PHP , 52 bytes

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

Pruébalo en línea!

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}

Pruébalo en línea!

Python 3 , 62 bytes

Esta función toma un número entero ny se inicializa ma cero. Luego, elimina todos los ceros de los extremos my comprueba si el resultado solo contiene 9, y devuelve msi lo tiene. Si no, se añade na my comprueba de nuevo, etc.

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

Pruébalo en línea!

Java (OpenJDK 8) , 66 bytes, no se ahoga en 17

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

Pruébalo en línea!

Más largo que la solución de @ KevinCruijssen pero puede manejar números ligeramente más grandes. Calcula los números candidatos como 10 ^ 6 - 10 ^ 3 = 999000. Los largos de 64 bits siguen siendo el límite, rompiendo para n = 23.

Probablemente se pueda jugar un poco al golf, pero ya tardó demasiado en hacerlo funcionar ...

> <> , 35 bytes

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

Pruébelo en línea o mírelo en el parque de peces !

Asume que la entrada ya está en la pila. Funciona buscando números de la forma 10 ^a  - 10 ^b , con a <b (sí, eso es un signo menor que, ¡toma menos bytes!) Hasta que sea divisible por la entrada, luego imprime 10 ^b  - 10 ^a . Esto es mucho más rápido que el método de fuerza bruta (que sería difícil en> <> de todos modos).

V , 19 14 bytes

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

Pruébalo en línea!

Explicación

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

No es el enfoque más corto, pero es muy rápido.

Mathematica, 82 bytes

Usando el patrón de envío de la respuesta de @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)&

Entrada:

[17]

Salida:

9999999999999999

Y en relación con el argumento en los comentarios en la respuesta de @ Jenny_mathy con @ Phoenix ... RepeatedTiming[]de la aplicación a la entrada [17]da

{0.000518, 9999999999999999}

entonces medio milisegundo. Yendo a una entrada un poco más grande [2003]:

{3.78, 99999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999}

un poco menos de 4 segundos.

Tabla de prueba: en los primeros 30 enteros positivos, los resultados son

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

Explicación: La única magia aquí es el iterador personalizado ("iterador" en el sentido CS, no el sentido M'ma)

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

que actúa sobre las variables globales x, el número de "9" iniciales y, el número de "0" finales y del número total de dígitos. Deseamos iterar a través del número de dígitos y, para cada elección de número de dígitos, comenzar con la mayoría de los "0" y los menos "9". Por lo tanto, lo primero que hace el código es inicializar da 1, forzar xa 1 yy a 0. El iterador personalizado comprueba que la cadena de "0" se puede acortar. Si es así, acorta la cadena de "0" por uno y aumenta la cadena de "1" por uno. De lo contrario, incrementa el número de dígitos, establece el número de "0" en uno menos que el número de dígitos y establece el número de "9" en 1.des el valor deseado de 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

La entrada se Promptedita durante el programa; salida se almacena en Ans.

Explicación:

Intenta números de la forma (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^m , donde m + n = k comienza en 1 y aumenta, y para cada valor de k, intenta m = 1, n = k -1; m = 2, n = k-2; ... m = k, n = 0; hasta que encuentre un múltiplo de X.

Esto funciona hasta 16; 17 da un error de dominio porque remainder(solo puede aceptar dividendos hasta 9999999999999 (13 nueves), y 17 debería generar 9999999999999999 (16 nueves).

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

Explicación

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

Pruébalo en línea!

Algunas explicaciones Encuentra la forma natural más pequeña10**n-10**bcon la n>b>=0que divide la entrada.

Algunos 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

Método de fuerza bruta

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

Pruébalo en línea!

Es lento, pero es pequeño.

Método más eficiente:

41 + 2 (-pa) = 43 bytes

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

Pruébalo en línea!

Funciona bien para cualquier entrada, pero es un código más largo.