JE Maxfield đã chứng minh định lý sau (xem DOI: 10.2307 / 2688966 ):

Nếu là bất kỳ số nguyên dương nào có chữ số, tồn tại số nguyên dương sao cho các chữ số đầu tiên củatạo thành số nguyên .$A$$m$$N$$m$$N!$$A$

Thử thách

Thử thách của bạn được đưa ra một số tìm thấy tương ứng .$A \geqslant 1$$N \geqslant 1$

Chi tiết

• $N!$đại diện cho nhân tố của .$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$$N$
• Các chữ số của trong trường hợp của chúng tôi được hiểu là ở cơ sở .$A$$10$
• Việc gửi của bạn phải hoạt động đối với tùy ý khi có đủ thời gian và bộ nhớ. Chỉ sử dụng các loại 32 bit để biểu diễn số nguyên là không đủ.$A\geqslant 1$
• Bạn không nhất thiết phải xuất ra ít nhất có thể .$N$

Ví dụ

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

ít nhất có thể có cho mỗi có thể được tìm thấy trong https://oeis.org/A076219$N$$A$

Python 2 , 50 byte

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

Hãy thử trực tuyến!

Đây là một biến thể của giải pháp 47 byte được giải thích bên dưới, được điều chỉnh để trả về 1đầu vào '1'. (Cụ thể, chúng tôi thêm 1vào biểu thức đầy đủ thay vì cuộc gọi đệ quy và bắt đầu đếm từ n==2để loại bỏ một lớp độ sâu, cân bằng kết quả cho tất cả các '1'đầu vào không .)

Python 2 , 45 byte (ánh xạ từ 1 đến True)

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

Đây là một biến thể khác, bởi @Jo King và @xnor, lấy đầu vào là một số và trả về Truecho đầu vào 1. Một số người nghĩ rằng đây là trò chơi công bằng, nhưng cá nhân tôi thấy nó hơi kỳ lạ.

Nhưng chỉ tốn 3 byte để bọc kết quả Boolean icky +(), mang đến cho chúng tôi một giải pháp "đẹp" ngắn hơn:

Python 2 , 48 byte

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

Đây là giải pháp trước đây của tôi, trả về 0đầu vào '1'. Nó sẽ có giá trị nếu câu hỏi liên quan đến không phủ địnhN .

Python 2 , 47 byte (không hợp lệ)

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

Hãy thử trực tuyến!

Lấy một chuỗi làm đầu vào, như f('18').

Bí quyết ở đây là x.find(y) == 0chính xác khi nào x.startswith(y).

Sự andức chế sẽ ngắn mạch `p`.find(a)với kết quả 0ngay khi `p`bắt đầu a; nếu không, nó sẽ đánh giá -~f(a,n+1,p*n), id est 1 + f(a,n+1,p*n).

Kết quả cuối cùng là 1 + (1 + (1 + (... + 0))), nlớp sâu, vì vậy n.

Brachylog , 3 5 byte

ℕ₁ḟa₀

Hãy thử trực tuyến!

Đưa đầu vào thông qua biến đầu ra của nó và đầu ra thông qua biến đầu vào của nó. (Một cách khác xung quanh, nó chỉ tìm thấy các tiền tố độc đoán của của đầu vào giai thừa, mà không phải là khá thú vị.) Lần ra vào trường hợp thử nghiệm thứ hai-to-cuối cùng trên TIO, nhưng không tốt trên người cuối cùng . Tôi đã chạy nó trên 841 trên máy tính xách tay của tôi trong vài phút tại thời điểm viết bài này và nó chưa thực sự đưa ra câu trả lời, nhưng tôi có niềm tin vào nó.

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

Vì đầu vào duy nhất ḟa₀không hoạt động cho 1 và 1 là tiền tố dương của 1! = 1, 1|ḟa₀hoạt động tốt như vậy.

Ngoài ra, kể từ lần chỉnh sửa này, 841 đã chạy được gần ba giờ và nó vẫn chưa tạo được đầu ra. Tôi đoán tính toán giai thừa của mọi số nguyên từ 1 đến 12745 không chính xác nhanh.

C ++ (gcc) , 107 95 byte, sử dụng -lgmpvà-lgmpxx

Cảm ơn những người trong các ý kiến ​​đã chỉ ra một số rủi ro ngớ ngẩn.

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

Hãy thử trực tuyến!

Tính $n!$bằng cách nhân $(n-1)!$cho $n$ , sau đó liên tục chia nó cho $10$ cho đến khi nó không còn lớn hơn số nguyên đã truyền. Tại thời điểm này, vòng lặp chấm dứt nếu giai thừa bằng số nguyên đã qua hoặc tiến hành $n$ tiếp theo .

Thạch , 8 byte

1!w⁼1ʋ1#

Hãy thử trực tuyến!

Lấy một số nguyên và trả về một singleton.

05AB1E , 7 byte

∞.Δ!IÅ?

Dùng thử trực tuyến hoặc xác minh tối đa - tất cả các trường hợp thử nghiệm ( 841hết thời gian, vì vậy được loại trừ).

Giải trình:

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

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

Hãy thử trực tuyến .

JavaScript, 47 43 byte

Đầu ra dưới dạng BigInt.

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

Dùng thử trực tuyến!

Đã lưu một vài byte bằng cách sử dụng phương pháp "xây dựng" giai thừa của Lynn thay vì tính toán nó trên mỗi lần lặp, vì vậy hãy nâng cao giải pháp của cô ấy nếu bạn nâng cao giải pháp này.

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

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

Hãy thử trực tuyến!

Sử dụng System.Numerics.BigIntegermà yêu cầu một usingtuyên bố.

-1 byte nhờ @ExpiredData!

Thạch , 16 byte

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

Hãy thử trực tuyến!

Giải trình

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

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

Hãy thử trực tuyến!

Giải trình

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

Than , 16 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

⊞υ¹

Nhấn 1vào danh sách trống để nó bắt đầu với một sản phẩm được xác định.

Ｗ⌕ＩΠυθ

Lặp lại trong khi đầu vào không thể được tìm thấy ở đầu sản phẩm của danh sách ...

⊞υＬυ

... đẩy chiều dài của danh sách lên chính nó.

Ｉ⊟υ

In giá trị cuối cùng được đẩy vào danh sách.

Perl 5 -Mbigint -p , 25 byte

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

Hãy thử trực tuyến!

J , ²⁸ 22 byte

-6 byte nhờ FrownyFrog

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

Hãy thử trực tuyến!

câu trả lời gốc J , 28 byte

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

Hãy thử trực tuyến!

• >:@] ... x:@1 bắt đầu với độ chính xác mở rộng 1 , tiếp tục tăng nó trong khi ...
• -.@ không phải là trường hợp mà ...
• {.@ cây du đầu tiên là trận đấu bắt đầu của ...
• E.&": tất cả các chuỗi con khớp (sau khi xâu chuỗi cả hai đối số &": ) của việc tìm kiếm đầu vào ban đầu trong ...
• ! giai thừa của số chúng ta đang tăng

C (gcc) -lgmp, 161 byte

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

Hãy thử trực tuyến!

Python 3 , 63 byte

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

Hãy thử trực tuyến!

-24 byte nhờ Jo King

-3 byte nhờ Chas Brown

Thạch , 11 byte

‘ɼµ®!Dw³’µ¿

Hãy thử trực tuyến!

Sạch , 88 byte

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

Hãy thử trực tuyến!

Xác định $ :: Integer -> Integer .

Sử dụng Data.Integersố nguyên kích thước tùy ý cho IO.

Ngôn ngữ Wolfram (Mathicala) , 62 byte

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

Hãy thử trực tuyến!

Ruby , 40 byte

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

Hãy thử trực tuyến!

Biểu tượng , 65 63 byte

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

Hãy thử trực tuyến!

Haskell, 89 byte

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

Nếu bất cứ ai biết làm thế nào để bỏ qua việc nhập khẩu cần thiết, hãy cho tôi biết.