Дж. Максфилд доказал следующую теорему (см. DOI: 10.2307 / 2688966 ):

Если $A$ является любым положительным целым числом, имеющим $m$ цифр, существует такое положительное целое число $N$ , что первые $m$ цифр $N!$представляют собой целое число $A$ .

Вызов

Вашему вызову дан некоторый найдите соответствующий .$A \geqslant 1$$N \geqslant 1$

Детали

• $N!$представляет факториал из .$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$$N$
• В нашем случае цифры понимаются как основание .$A$$10$
• Ваша заявка должна работать для произвольного$A\geqslant 1$ учитывая достаточно времени и памяти. Простого использования, например, 32-битных типов для представления целых чисел недостаточно.
• Вам не обязательно нужно вывести наименьшее возможное .$N$

Примеры

A            N
1            1
2            2
3            9
4            8
5            7
6            3
7            6
9           96
12           5
16          89
17          69
18          76
19          63
24           4
72           6
841      12745
206591378  314

Наименьшее возможное для каждого можно найти по адресу https://oeis.org/A076219.$N$$A$

Python 2 , 50 байт

f=lambda a,n=2,p=1:(`p`.find(a)and f(a,n+1,p*n))+1

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

Это вариация 47-байтового решения, описанного ниже, с поправкой на возврат 1для ввода '1'. (А именно, мы добавляем 1к полному выражению, а не к рекурсивному вызову, и начинаем считать, n==2чтобы удалить один слой глубины, балансируя результат для всех не '1'входных данных.)

Python 2 , 45 байт (карты 1 в True)

f=lambda a,n=2,p=1:`-a`in`-p`or-~f(a,n+1,p*n)

Это еще один вариант, @Jo King и @xnor, который принимает входные данные как число и возвращает их Trueдля ввода 1. Некоторые люди думают это честная игра, но я лично нахожу ее немного странной.

Но для обтекания результата icky Boolean требуется всего 3 байта +(), что дает нам более короткое «хорошее» решение:

Python 2 , 48 байт

f=lambda a,n=2,p=1:+(`-a`in`-p`)or-~f(a,n+1,p*n)

Это мое предыдущее решение, которое возвращает 0для ввода '1'. Это было бы справедливо, если бы вопрос касался неотрицательногоN .

Python 2 , 47 байт (неверно)

f=lambda a,n=1,p=1:`p`.find(a)and-~f(a,n+1,p*n)

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

Принимает строку в качестве ввода, например f('18') .

Хитрость в том, что x.find(y) == 0именно когдаx.startswith(y) .

and-Expression будет короткое замыкание на `p`.find(a)с результатом , 0как только `p`начинается с a; в противном случае он будет оцениваться -~f(a,n+1,p*n), то есть1 + f(a,n+1,p*n) .

Конечный результат 1 + (1 + (1 + (... + 0))), nслои глубокие, так n.

Брахилог , 3 5 байт

ℕ₁ḟa₀

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

Принимает ввод через свою выходную переменную и выводит через свою входную переменную. (С другой стороны, он просто находит произвольные префиксы факториала входных данных, что не так интересно.) Время ожидания второго контрольного примера на TIO, но хорошо на последнем . На момент написания этой статьи я запускал его на 841 на своем ноутбуке в течение нескольких минут, и он пока не выдал ответ, но я в это верю.

         The (implicit) output variable
   a₀    is a prefix of
  ḟ      the factorial of
         the (implicit) input variable
ℕ₁       which is a positive integer.

Поскольку единственный вход ḟa₀не работает для 1, а 1 является положительным префиксом 1! = 1,1|ḟa₀ работает так же хорошо.

Кроме того, на момент этого редактирования 841 работал почти три часа и до сих пор не дал результатов. Я предполагаю, что вычисление факториала каждого целого числа от 1 до 12745 не совсем быстрое.

C ++ (gcc) , 107 95 байт, используя-lgmp и-lgmpxx

Спасибо людям в комментариях за указание на некоторые глупые ошибки.

#import<gmpxx.h>
auto f(auto A){mpz_class n,x=1,z;for(;z!=A;)for(z=x*=++n;z>A;z/=10);return n;}

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

Вычисляет $n!$умножением $(n-1)!$по $n$ , затем многократно делит его на $10$ пока оно не станет больше, чем переданное целое число. В этот момент цикл завершается, если факториал равен переданному целому числу или переходит к следующему $n$ противном случае.

Желе , 8 байт

1!w⁼1ʋ1#

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

Принимает целое число и возвращает синглтон.

05AB1E , 7 байтов

∞.Δ!IÅ?

Попробуйте онлайн или проверьте почти все тестовые случаи ( 841время ожидания исключено).

Объяснение:

∞.Δ      # Find the first positive integer which is truthy for:
   !     #  Get the factorial of the current integer
    IÅ?  #  And check if it starts with the input
         # (after which the result is output implicitly)

Pyth - 8 байт

f!x`.!Tz

f              filter. With no second arg, it searches 1.. for first truthy
 !             logical not, here it checks for zero
  x    z       indexof. z is input as string
   `           string repr
    .!T        Factorial of lambda var

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

JavaScript, 47 43 байта

Вывод как BigInt.

n=>(g=x=>`${x}`.search(n)?g(x*++i):i)(i=1n)

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

Сохраните несколько байтов, приняв подход Линн «строить» факториал, а не вычислять его на каждой итерации, поэтому, пожалуйста, также проголосуйте за ее решение, если вы голосуете против этого.

C # (.NET Core) , 69 + 22 = 91 байт

a=>{var n=a/a;for(var b=n;!(b+"").StartsWith(a+"");b*=++n);return n;}

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

Использует System.Numerics.BigIntegerкоторый требует usingутверждения.

-1 байт благодаря @ExpiredData!

Желе , 16 байт

‘ɼ!³;D®ß⁼Lḣ@¥¥/?

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

объяснение

‘ɼ                | Increment the register (initially 0)
  !               | Factorial
   ³;             | Prepend the input
     D            | Convert to decimal digits
        ⁼   ¥¥/?  | If the input diguts are equal to...
         Lḣ@      | The same number of diguts from the head of the factorial
      ®           | Return the register
       ß          | Otherwise run the link again

Perl 6 , 23 байта

{+([\*](1..*).../^$_/)}

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

объяснение

{                     }  # Anonymous code block
   [\*](1..*)            # From the infinite list of factorials
             ...         # Take up to the first element
                /^$_/    # That starts with the input
 +(                  )   # And return the length of the sequence

Древесный уголь , 16 байт

⊞υ¹Ｗ⌕ＩΠυθ⊞υＬυＩ⊟υ

Попробуйте онлайн! Ссылка на подробную версию кода. Объяснение:

⊞υ¹

Нажмите 1на пустой список, чтобы он начинался с определенного продукта.

Ｗ⌕ＩΠυθ

Повторите, пока вход не может быть найден в начале произведения списка ...

⊞υＬυ

... подтолкнуть длину списка к себе.

Ｉ⊟υ

Выведите последнее значение, помещенное в список.

Perl 5 -Mbigint -p , 25 байт

1while($.*=++$\)!~/^$_/}{

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

J , ²⁸ 22 байта

-6 байт благодаря FrownyFrog

(]+1-0{(E.&":!))^:_&1x

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

оригинальный ответ J , 28 байт

>:@]^:(-.@{.@E.&":!)^:_ x:@1

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

• >:@] ... x:@1 начиная с повышенной точности 1 , продолжайте увеличивать его, пока ...
• -.@ дело не в том, что ...
• {.@ первый вяз - стартовый матч ...
• E.&":все подстроки совпадают (после строкового определения обоих аргументов &":) поиска исходного ввода в ...
• ! факториал числа, которое мы увеличиваем

C (gcc) -lgmp, 161 байт

#include"gmp.h"
f(a,n,_,b)char*a,*b;mpz_t n,_;{for(mpz_init_set_si(n,1),mpz_init_set(_,n);b=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n));}

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

Python 3 , 63 байта

f=lambda x,a=2,b=1:str(b).find(str(x))==0and a-1or f(x,a+1,b*a)

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

-24 байта благодаря Джо Кингу

-3 байта благодаря Часу Брауну

Желе , 11 байт

‘ɼµ®!Dw³’µ¿

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

Чисто , 88 байт

import StdEnv,Data.Integer,Text
$a=hd[n\\n<-[a/a..]|startsWith(""<+a)(""<+prod[one..n])]

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

Определяет $ :: Integer -> Integer.

Использует Data.Integerпроизвольные целые числа размера для ввода-вывода.

Wolfram Language (Mathematica) , 62 байта

(b=1;While[⌊b!/10^((i=IntegerLength)[b!]-i@#)⌋!=#,b++];b)&

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

Рубин , 40 байт

->n{a=b=1;a*=b+=1until"%d"%a=~/^#{n}/;b}

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

Icon , 65 63 байта

procedure f(a);p:=1;every n:=seq()&1=find(a,p*:=n)&return n;end

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

Haskell, 89 байт

import Data.List
a x=head$filter(isPrefixOf$show x)$((show.product.(\x->[1..x]))<$>[1..])

Если кто-нибудь знает, как обойти требуемый импорт, дайте мне знать.