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$ 的 $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

尽可能少的 $N$ 每个 $A$ 可以在https://oeis.org/A076219中找到

— 瑕疵
source

26

我...他为什么证明这个定理？他只是醒了一天，说：“我会解决这个问题！” 还是有目的？

— 魔术章鱼缸

11

@MagicOctopusUrn以前从未与数字理论家打过交道，对吗？

— Brady Gilg

2

这是任何人感兴趣的证明。

— 硕果累累

14

Python 2，50个字节

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

在线尝试！

这是下面说明的47字节解决方案的一种变体，已调整为返回1input '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作为input 1。有人认为这是公平的游戏，但我个人觉得有些奇怪。

但是，只需要3个字节即可将icky布尔结果包装在中+()，从而为我们提供了一个更短的“不错”的解决方案：

Python 2，48个字节

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

这是我先前的解决方案，返回0input '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)id est 1 + f(a,n+1,p*n)。

最终结果是1 + (1 + (1 + (... + 0)))，n层深，所以n。

— 林恩
source

好的解决方案。我正在使用相同的方法，但是每次迭代都计算阶乘。+1无论如何，实施您的方法可以节省一些时间。

— 毛茸茸的

1

对于True-for-1版本，您可以将基本情况以a数字形式缩短。

— xnor

@xnor我不会想到“ -ain -p”，这是一个巧妙的技巧：）

— Lynn

如果在N限制为偶数的情况下证明仍然成立，则此45字节的解决方案将始终输出数字。

— 负

9

Brachylog，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的每个整数的阶乘不是十分快。

— 不相关的字符串
source

2

Brachylog中阶乘谓词的实现有些复杂，因此可以以可接受的效率同时使用两种方式。一个人可以实现一个更快的算法来计算阶乘，但是以另一种方式运行（即从阶乘中找到原始数）会非常慢。

— 致命

哦，太酷了！从源头上看，我不知道它在做什么，但是我可以告诉你，它投入了很多思想。

— 不相关的字符串

7

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$ 。

— 尼尔·A。
source

您不再需要计数标志，因此这是107字节。

— AdmBorkBork

为什么之前需要第二个分号return？

— Ruslan

您可以为该函数使用单个字符名称，并节省几个字节。

— 毛茸茸的

6

果冻，8字节

1!w⁼1ʋ1#

在线尝试！

取一个整数并返回单例。

— 暴民埃里克
source

6

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)

— 凯文·克鲁伊森
source

2

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

在线尝试。

— 马尔蒂森
source

2

JavaScript，47岁 43字节

输出为BigInt。

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

在线尝试！

采用Lynn的“构建”阶乘方法而不是在每次迭代中进行计算，从而节省了一些字节，因此，如果您赞成这一解决方案，请也对她的解决方案予以支持。

— 毛茸茸
source

可悲的是，_Ês bU}f1在Japt中不起作用

— 无知的体现

@EmbodimentofIgnorance，是的，我也有。您可以在之后删除空格s。

— 毛茸茸的

@EmbodimentofIgnorance，您还可以删除可以返回的1if 。0n=1

— 毛茸茸的

少3个字节：x=i=1n;f=n=>`${x*=++i}`.search(n)?f(n):i

— vrugtehagel

@vrugtehagel，那将是不可重用的。

— 毛茸茸的

2

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！

— 达娜
source

1

69 + 22

— 过期的数据

1

果冻，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

— 尼克·肯尼迪
source

1

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

— 乔·金
source

1

木炭，16字节

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

在线尝试！链接是详细版本的代码。说明：

⊞υ¹

推1送到空白列表，以便从定义的产品开始。

Ｗ⌕ＩΠυθ

重复输入，但在列表产品的开头找不到输入时...

⊞υＬυ

...将列表的长度推到自身。

Ｉ⊟υ

打印上次推送到列表的值。

— 尼尔
source

1

Perl 5，25 `-Mbigint -p`个字节

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

在线尝试！

— Xcali
source

1

J，²⁸ 22字节

-6字节归功于FrownyFrog

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

在线尝试！

原始答案J，28字节

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

在线尝试！

>:@] ... x:@1 从更高的精度开始 1保持同时不断增加...
-.@ 并非如此...
{.@ 第一榆树是...的首场比赛
E.&":&":在...中搜索原始输入的所有子字符串匹配项（在对两个参数进行字符串匹配之后）
! 我们要递增的阶乘

— 约拿
source

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

— FrownyFrog

我喜欢使用“定点”来避免传统的使用。

— 约拿

1

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

在线尝试！

— LambdaBeta
source

建议strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1)而不是b=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n))

— ceilingcat

1

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字节，感谢Jo King

-3字节，感谢Chas Brown

— 超中微子
source

@JoKing好的，谢谢

— HyperNeutrino

61个字节

— Chas Brown

@ChasBrown谢谢

— HyperNeutrino

我认为f=您在标头中获得的应该计入您的位数。

— mypetlion

@mypetlion你是正确的；感谢您抓住这一点。

— HyperNeutrino

0

果冻，11字节

‘ɼµ®!Dw³’µ¿

在线尝试！

— 超中微子
source

0

干净，88字节

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

在线尝试！

定义 $ :: Integer -> Integer。

Data.Integer对IO 使用的任意大小整数。

— 巨大
source

0

Wolfram语言（Mathematica），62字节

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

在线尝试！

— J42161217
source

0

红宝石，40字节

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

在线尝试！

— 国标
source

0

图标，65 63字节

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

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

0

Haskell，89个字节

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

如果有人知道如何绕过所需的导入，请告诉我。

— 洛克人
source

看来你输出

N!

$N!$ 并不是

N

$N$ 按要求。

— flawr

关于N的注解！

挑战

细节

例子

Python 2，50个字节

Python 2，45个字节（将1映射到 True）

Python 2，48个字节

Python 2，47个字节（无效）

Brachylog，3 5字节

C ++（gcc）， 107 95字节，使用-lgmp和-lgmpxx

果冻，8字节

05AB1E，7 个字节

Pyth-8个字节

JavaScript，47岁 43字节

C＃（.NET Core），69 + 22 = 91字节

果冻，16字节

说明

Perl 6、23个字节

说明

木炭，16字节

Perl 5，25 -Mbigint -p个字节

J，28 22字节

原始答案J，28字节

C（gcc） -lgmp，161个字节

Python 3，63字节

果冻，11字节

干净，88字节

Wolfram语言（Mathematica），62字节

红宝石，40字节

图标，65 63字节

Haskell，89个字节

Python 2，45个字节（将1映射到 `True`）

C ++（gcc）， 107 95字节，使用`-lgmp`和`-lgmpxx`

Perl 5，25 `-Mbigint -p`个字节

J，²⁸ 22字节