Описание задачи

Для каждого положительного целого числа nсуществует число, имеющее форму, 111...10...000которая делится на nто есть десятичное число, которое начинается со всех 1и заканчивается всеми 0. Это очень легко доказать: если мы возьмем набор n+1различных чисел в виде 111...111(все 1), то по крайней мере два из них дадут один и тот же остаток после деления на n(согласно принципу голубя). Разница между этими двумя числами будет кратна nи будет иметь желаемую форму. Ваша цель - написать программу, которая найдет этот номер.

Описание ввода

Целое положительное число.

Описание вывода

Число pв форме 111...10...000, такое что p ≡ 0 (mod n). Если вы найдете более одного - отобразите любой из них (необязательно самый маленький).

Заметки

Ваша программа должна дать ответ в разумные сроки. Что означает, что грубое принуждение не разрешено:

p = 0
while (p != 11..10.00 and p % n != 0)
    p++

И это не так:

do
    p = random_int()
while (p != 11..10.00 and p % n != 0)

Итерация по номерам в форме 11..10..00разрешена.

Ваша программа не должна обрабатывать произвольно большие входные данные - верхняя граница равна верхней границе вашего языка.

Пример выходов

2: 10
3: 1110
12: 11100
49: 1111111111111111111111111111111111111111110
102: 1111111111111111111111111111111111111111111111110

Mathematica, 29 байт

⌊10^(9EulerPhi@#)/9⌋10^#&

Код Мартина Бюттнера .

На входе nэто выводит число с 9*ϕ(n)единицами, за которыми следуют nнули, где ϕнаходится функция Эйлера . С помощью функции phiэто можно выразить в Python как

lambda n:'1'*9*phi(n)+'0'*n

Было бы достаточно использовать факториал n!вместо ϕ(n), но для печати, что многие из них не имеют разумного времени выполнения.

Утверждение: 9*ϕ(n) единицы, за которыми следуют nнули, кратны n.

Доказательство: Во- первых, давайте докажем это для случая, nне является кратным 2, 3или 5. Мы покажем, что число, состоящее из ϕ(n)единиц, кратно `n.

Количество из kних равно (10^k-1)/9. Так nкак не является кратным 3, это кратно nстолько, сколько 10^k-1является фактором n, или эквивалентно, если 10^k = 1 (mod n). Обратите внимание, что эта формулировка делает очевидным, что если kработает для числа единиц, то так же, как любой кратный k.

Таким образом, мы ищем kбыть кратна порядка из kв мультипликативной группе по модулю п . По теореме Лагранжа , любой такой порядок является делителем размера группы. Поскольку элементами группы являются числа от, 1к nкоторым относительно простые числа n, ее размер является функцией Эйлера ϕ(n) . Итак, мы показали 10^ϕ(n) = 1 (mod n), что число сделанных из ϕ(n)них кратно `n.

Теперь давайте рассмотрим потенциальные факторы 3в n. Мы знаем, что 10^ϕ(n)-1это кратно n, но (10^ϕ(n)-1)/9не может быть. Но, (10^(9*ϕ(n))-1)/9является кратным, 9потому что он состоит из 9*ϕ(n)единиц, поэтому сумма его цифр кратна 9. И мы отметили, что умножение показателя степени kна константу сохраняет делимость.

Теперь, если nесть факторы 2's' и 5's', нам нужно добавить нули в конец вывода. Это более чем достаточно, чтобы использовать nнули (на самом деле log_2(n)будет делать). Таким образом, если наш вход nразделен на n = 2^a * 5^b * m, достаточно иметь 9*ϕ(m)кратные единицы n, умноженные 10^nна кратные 2^a * 5^b. И, так nкак кратно m, достаточно использовать 9*ϕ(n)их. Таким образом, это работает, чтобы иметь 9*ϕ(n)единицы после nнулей.

Python 2, 44 байта

f=lambda n,j=1:j/9*j*(j/9*j%n<1)or f(n,j*10)

Когда jэто степень 10, такая как 1000, деление по полу j/9дает число, состоящее из 1, как 111. Таким образом, j/9*jдает 1, за которым следует такое же число 0, как 111000.

Функция рекурсивно проверяет числа этой формы, пробуя все более высокие степени 10, пока мы не найдем число, кратное желаемому числу.

Pyth, 11 байт

.W%HQsjZ`TT

Тестирование

По сути, он просто ставит 1 впереди и 0 снова и снова, пока число не делится на вход.

Объяснение:

.W%HQsjZ`TT
                Implicit: Q = eval(input()), T = 10
.W              while loop:
  %HQ           while the current value mod Q is not zero
      jZ`T      Join the string "10" with the current value as the separator.
     s          Convert that to an integer.
          T     Starting value 10.

Haskell, 51 байт

\k->[b|a<-[1..],b<-[div(10^a)9*10^a],b`mod`k<1]!!0

Используя подход xnor. Ними спасла байт!

CJam, 28 25 19 байтов

Сохранено 6 байтов с наблюдением xnor, что нам нужно только взглянуть на числа в форме .1n0n

ri:X,:)Asfe*{iX%!}=

Проверьте это здесь.

объяснение

ri:X    e# Read input, convert to integer, store in X.
,:)     e# Get range [1 ... X].
As      e# Push "10". 
fe*     e# For each N in the range, repeat the characters in "10" that many times,
        e# so we get ["10" "1100" "111000" ...].
{iX%!}= e# Select the first element from the list which is divided by X.

Mathematica, 140 55 байт

NestWhile["1"<>#<>"0"&,"1",FromDigits@#~Mod~x>0&/.x->#]

Многие байты удалены благодаря трюку xnor 1 ^ n0 ^ n.

Минимальное значение, 140 156 байт. Это дает наименьшее возможное решение.

NestWhile["1"<>#&,ToString[10^(Length@NestWhileList[If[EvenQ@#,If[10~Mod~#>0,#/2,#/10],#/5]&,#,Divisors@#~ContainsAny~{2, 5}&],FromDigits@#~Mod~m>0&/.m->#]&

Он вычисляет, сколько нулей требуется, затем проверяет все возможные значения, 1пока он не заработает. Он может выводить число без 0, но это можно исправить, добавив <>"0"право перед финалом &.

Haskell, 37 байт

f n=[d|d<-"10",i<-[1..n*9],gcd n i<2]

Это использует тот факт, что он работает, чтобы иметь 9*phi(n)те, где phiесть функция Эйлера. Здесь он реализован с использованием gcdи фильтрации, производя одну цифру для каждого iотносительно простого значения , которое находится в диапазоне 1и 9*n. Также достаточно использовать это множество нулей.

JavaScript (ES6), 65 байт

Редактирование 2 байт сохраненного ТНХ @Neil

Это работает в пределах числового типа javascript, с 17 значащими цифрами. (Так довольно ограничено)

a=>{for(n='';!(m=n+=1)[17];)for(;!(m+=0)[17];)if(!(m%a))return+m}  

Меньше гольфа

function (a) {
    for (n = ''; !(m = n += '1')[17]; )
        for (; !(m += '0')[17]; )
            if (!(m % a))
                 return +m;
}

Perl 5, 26 байт

включает байт для -n( -M5.01бесплатно)

($.="1$.0")%$_?redo:say$.

Sage, 33 байта

lambda n:'1'*9*euler_phi(n)+'0'*n

Это использует метод xnor, чтобы произвести вывод.

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

до н.э., 58 байт

define f(n){for(x=1;m=10^x/9*10^x;++x)if(m%n==0)return m;}

Пример результатов

200: 111000
201: 111111111111111111111111111111111000000000000000000000000000000000
202: 11110000
203: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000
204: 111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000
205: 1111100000
206: 11111111111111111111111111111111110000000000000000000000000000000000
207: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
208: 111111000000
209: 111111111111111111000000000000000000
210: 111111000000
211: 111111111111111111111111111111000000000000000000000000000000
212: 11111111111110000000000000
213: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
214: 1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000
215: 111111111111111111111000000000000000000000
216: 111111111111111111111111111000000000000000000000000000
217: 111111111111111111111111111111000000000000000000000000000000
218: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
219: 111111111111111111111111000000000000000000000000

постоянный ток, 27 байт

Odsm[O*lmdO*sm+O*dln%0<f]sf

Это определяет функцию, fкоторая ожидает свой аргумент в переменной n. Чтобы использовать его в качестве программы, ?sn lfx pдля чтения из стандартного ввода, вызова функции и вывода результата в стандартный вывод. Переменная mи вершина стека должны быть сброшены до 10 (путем повторения Odsm), прежде чем их fможно будет использовать повторно.

Полученные результаты:

200: 111000
201: 111111111111111111111111111111111000000000000000000000000000000000
202: 11110000
203: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000
204: 111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000
205: 1111100000
206: 11111111111111111111111111111111110000000000000000000000000000000000
207: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
208: 111111000000
209: 111111111111111111000000000000000000
210: 111111000000
211: 111111111111111111111111111111000000000000000000000000000000
212: 11111111111110000000000000
213: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
214: 1111111111111111111111111111111111111111111111111111100000000000000000000000000000000000000000000000000000
215: 111111111111111111111000000000000000000000
216: 111111111111111111111111111000000000000000000000000000
217: 111111111111111111111111111111000000000000000000000000000000
218: 111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
219: 111111111111111111111111000000000000000000000000