Учитывая положительное целое число, найдите его наименьшее положительное целое число, которое является серией 9, за которой следует необязательный прогон 0. Другими словами, найдите его наименьшее положительное целое число, которому соответствует регулярное выражение /^9+0*$/.

Например, если заданное положительное целое число равно 2, верните 90, так как 90 является положительным целым числом, кратным 2 и является наименьшим, которому соответствует регулярное выражение /^9+0*$/ .

Тестовые случаи:

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=13и 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`) }
}

Рубин , 36 байт

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

Брутфорсинг - вечность для х = 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)

Попробуйте онлайн!

Брахилог , 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используется грубая сила, увеличивая $ _, пока оно не совпадет с регулярным выражением. "#{}"Строковая интерполяция, она короче, чем .to_sвызов, так как для этого потребуются парантезы $_+=y. В заключение,$_ печатается.

Попробуйте онлайн!

Попробуйте все тестовые случаи!

Дьялог АПЛ, 34 байта

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

Рекурсивные dfns, основанные на решении Python Денниса .

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, байт: 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 ^a  - 10 ^b , с a <b (да, это знак меньше, чем - байт занимает меньше!), Пока это не делится на ввод, затем выведите 10 ^b  - 10 ^a . Это намного быстрее, чем метод грубой силы (который в любом случае будет трудным в> <>).

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, а не M'ma)

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» на 1.dy

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-ed во время программы; выход сохраняется в Ans.

Объяснение:

Пытается числа вида (10 ⁿ ) (10 ^m -1) = 10 ^k -10 ^m , где m + n = k начинается с 1 и увеличивается, и для каждого значения k он пытается m = 1, n = k -1; т = 2, п = к-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]

Попробуйте онлайн!

Он хорошо работает для любого ввода, но это более длинный код.