JE Maxfieldは定理に従って証明しました（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$表します！= 1 ⋅ 2 ⋅ 3 ⋅ ... ⋅ Nの$N$。
• この場合の$A$の数字は、$10$を基数とするものと理解されています。
• 提出は任意のAで機能するはずです$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

各Aの最小の$N$はhttps://oeis.org/A076219にあります$A$

Python 2, 50 bytes

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

Try it online!

This is a variation of the 47-byte solution explained below, adjusted to return 1 for input '1'. (Namely, we add 1 to the full expression rather than the recursive call, and start counting from n==2 to remove one layer of depth, balancing the result out for all non-'1' inputs.)

Python 2, 45 bytes (maps 1 to True)

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

This is another variation, by @Jo King and @xnor, which takes input as a number and returns True for input 1. Some people think this is fair game, but I personally find it a little weird.

But it costs only 3 bytes to wrap the icky Boolean result in +(), giving us a shorter "nice" solution:

Python 2, 48 bytes

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

This is my previous solution, which returns 0 for input '1'. It would have been valid if the question concerned a non-negative N.

Python 2, 47 bytes (invalid)

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

Try it online!

Takes a string as input, like f('18').

The trick here is that x.find(y) == 0 precisely when x.startswith(y).

The and-expression will short circuit at `p`.find(a) with result 0 as soon as `p` starts with a; otherwise, it will evaluate to -~f(a,n+1,p*n), id est 1 + f(a,n+1,p*n).

The end result is 1 + (1 + (1 + (... + 0))), n layers deep, so n.

Brachylog, 3 5 bytes

ℕ₁ḟa₀

Try it online!

Takes input through its output variable, and outputs through its input variable. (The other way around, it just finds arbitrary prefixes of the input's factorial, which isn't quite as interesting.) Times out on the second-to-last test case on TIO, but does fine on the last one. I've been running it on 841 on my laptop for several minutes at the time of writing this, and it hasn't actually spit out an answer yet, but I have faith in it.

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

Since the only input ḟa₀ doesn't work for is 1, and 1 is a positive prefix of 1! = 1, 1|ḟa₀ works just as well.

Also, as of this edit, 841 has been running for nearly three hours and it still hasn't produced an output. I guess computing the factorial of every integer from 1 to 12745 isn't exactly fast.

C++ (gcc), 107 95 bytes, using -lgmp and -lgmpxx

Thanks to the people in the comments for pointing out some silly mishaps.

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

Try it online!

Computes $n!$ by multiplying $(n-1)!$ by $n$, then repeatedly divides it by $10$ until it is no longer greater than the passed integer. At this point, the loop terminates if the factorial equals the passed integer, or proceeds to the next $n$ otherwise.

Jelly, 8 bytes

1!w⁼1ʋ1#

Try it online!

Takes an integer and returns a singleton.

05AB1E, 7 bytes

∞.Δ!IÅ?

Try it online or verify -almost- all test cases (841 times out, so is excluded).

Explanation:

∞.Δ      # 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 bytes

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

Try it online.

JavaScript, 47 43 bytes

Output as a BigInt.

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

Try It Online!

Saved a few bytes by taking Lynn's approach of "building" the factorial rather than calculating it on each iteration so please upvote her solution as well if you're upvoting this one.

C# (.NET Core), 69 + 22 = 91 bytes

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

Try it online!

Uses System.Numerics.BigInteger which requires a using statement.

-1 byte thanks to @ExpiredData!

Jelly, 16 bytes

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

Try it online!

Explanation

‘ɼ                | 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 bytes

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

Try it online!

Explanation

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

Charcoal, 16 bytes

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

Try it online! Link is to verbose version of code. Explanation:

⊞υ¹

Push 1 to the empty list so that it starts off with a defined product.

Ｗ⌕ＩΠυθ

Repeat while the input cannot be found at the beginning of the product of the list...

⊞υＬυ

... push the length of the list to itself.

Ｉ⊟υ

Print the last value pushed to the list.

Perl 5 -Mbigint -p, 25 bytes

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

Try it online!

J, ²⁸ 22 bytes

-6 bytes thanks to FrownyFrog

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

Try it online!

original answer J, 28 bytes

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

Try it online!

• >:@] ... x:@1 starting with an extended precision 1, keep incrementing it while...
• -.@ its not the case that...
• {.@ the first elm is a starting match of...
• E.&": all the substring matches (after stringfying both arguments &":) of searching for the original input in...
• ! the factorial of the number we're incrementing

C (gcc) -lgmp, 161 bytes

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

Try it online!

Python 3, 63 bytes

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

Try it online!

-24 bytes thanks to Jo King

-3 bytes thanks to Chas Brown

Jelly, 11 bytes

‘ɼµ®!Dw³’µ¿

Try it online!

Clean, 88 bytes

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

Try it online!

Defines $ :: Integer -> Integer.

Uses Data.Integer's arbitrary size integers for IO.

Wolfram Language (Mathematica), 62 bytes

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

Try it online!

Ruby, 40 bytes

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

Try it online!

Icon, 65 63 bytes

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

Try it online!

Haskell, 89 bytes

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

If anyone knows how to bypass the required import, let me know.