JE Maxfield provou o seguinte teorema (ver DOI: 10.2307 / 2688966 ):

Se $A$ é qualquer número inteiro positivo com $m$ dígitos, existe um número inteiro positivo $N$ modo que os primeiros $m$ dígitos de $N!$constituem o número inteiro $A$ .

Desafio

$A \geqslant 1$$N \geqslant 1$

Detalhes

• $N!$representa o fatorial de .$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$$N$
• Os dígitos de no nosso caso são entendidos na base .$A$$10$
• Seu envio deve funcionar para arbitrário, com tempo e memória suficientes. Apenas o uso de tipos de 32 bits para representar números inteiros não é suficiente.$A\geqslant 1$
• Você não precisa necessariamente de saída menos possível .$N$

Exemplos

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

O mínimo possível de para cada pode ser encontrado em https://oeis.org/A076219$N$$A$

Python 2 , 50 bytes

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

Experimente online!

Essa é uma variação da solução de 47 bytes explicada abaixo, ajustada para retornar 1para entrada '1'. (Nomeadamente, adicionamos 1à expressão completa, e não à chamada recursiva, e começamos a contar n==2para remover uma camada de profundidade, equilibrando o resultado para todas as não '1'entradas.)

Python 2 , 45 bytes (mapeia 1 para True)

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

Essa é outra variação, de @Jo King e @xnor, que recebe a entrada como um número e retorna Truepara a entrada 1. Algumas pessoas pensam que é um jogo justo, mas eu pessoalmente acho um pouco estranho.

Mas custa apenas 3 bytes para agrupar o resultado booleano nojento +(), fornecendo uma solução "agradável" mais curta:

Python 2 , 48 bytes

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

Esta é a minha solução anterior, que retorna 0 para entrada '1'. Teria sido válido se a pergunta se referisse a um resultado não negativoN .

Python 2 , 47 bytes (inválido)

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

Experimente online!

Pega uma string como entrada, como f('18').

O truque aqui é que x.find(y) == 0 justamente quando x.startswith(y).

A andexpressão-entrará em curto `p`.find(a)com o resultado 0assim que `p`começar a; caso contrário, avaliará-~f(a,n+1,p*n) , id est 1 + f(a,n+1,p*n).

O resultado final é 1 + (1 + (1 + (... + 0))), ncamadas profundas, então n.

Braquilog , 3 5 bytes

ℕ₁ḟa₀

Experimente online!

Toma entrada através de sua variável de saída e sai através de sua variável de entrada. (Ao contrário, ele apenas encontra prefixos arbitrários do fatorial da entrada, o que não é tão interessante.) Tempo limite no penúltimo caso de teste no TIO, mas funciona bem no último . Eu o uso no 841 do meu laptop há vários minutos no momento em que escrevi isso, e ele ainda não deu uma resposta, mas tenho fé.

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

Desde a única entrada ḟa₀ que não funciona é 1 e 1 é um prefixo positivo de 1! = 1, 1|ḟa₀funciona tão bem.

Além disso, a partir desta edição, o 841 está em execução há quase três horas e ainda não produziu uma saída. Eu acho que calcular o fatorial de cada número inteiro de 1 a 12745 não é exatamente rápido.

C ++ (gcc) , 107 95 bytes, usando -lgmpe-lgmpxx

Obrigado às pessoas nos comentários por apontarem alguns percalços tolos.

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

Experimente online!

Calcula $n!$multiplicando $(n-1)!$por $n$ , em seguida, divide-o repetidamente por $10$ até que não seja maior que o número inteiro passado. Nesse ponto, o loop termina se o fatorial for igual ao número inteiro passado ou prosseguir para o próximo $n$ caso contrário.

Geléia , 8 bytes

1!w⁼1ʋ1#

Experimente online!

Pega um número inteiro e retorna um singleton.

05AB1E , 7 bytes

∞.Δ!IÅ?

Experimente online ou verifique quase todos os casos de teste (o 841tempo limite é excluído).

Explicação:

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

Pitão - 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

Experimente online .

JavaScript, 47 43 bytes

Saída como um BigInt.

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

Experimente Online!

Economizou alguns bytes adotando a abordagem de Lynn de "construir" o fatorial, em vez de calculá-la em cada iteração. Portanto, vote novamente a solução dela também se estiver votando nesta.

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

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

Experimente online!

Usa o System.Numerics.BigIntegerque requer uma usingdeclaração.

-1 byte graças a @ExpiredData!

Gelatina , 16 bytes

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

Experimente online!

Explicação

‘ɼ                | 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..*).../^$_/)}

Experimente online!

Explicação

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

Carvão , 16 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

⊞υ¹

Empurre 1para a lista vazia para que ela comece com um produto definido.

Ｗ⌕ＩΠυθ

Repita enquanto a entrada não puder ser encontrada no início do produto da lista ...

⊞υＬυ

... empurre o comprimento da lista para si mesmo.

Ｉ⊟υ

Imprima o último valor enviado para a lista.

Perl 5 -Mbigint -p , 25 bytes

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

Experimente online!

J , ²⁸ 22 bytes

-6 bytes graças ao FrownyFrog

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

Experimente online!

resposta original J , 28 bytes

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

Experimente online!

• >:@] ... x:@1começando com uma precisão estendida 1, continue aumentando enquanto ...
• -.@ não é o caso que ...
• {.@ o primeiro olmo é uma partida inicial de ...
• E.&":todas as correspondências de substring (após stringfying dos dois argumentos &":) da procura da entrada original em ...
• ! o fatorial do número que estamos incrementando

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

Experimente 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)

Experimente online!

-24 bytes graças a Jo King

-3 bytes graças a Chas Brown

Gelatina , 11 bytes

‘ɼµ®!Dw³’µ¿

Experimente online!

Limpo , 88 bytes

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

Experimente online!

Define $ :: Integer -> Integer .

Usa Data.Integernúmeros inteiros arbitrários de tamanho para E / S.

Wolfram Language (Mathematica) , 62 bytes

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

Experimente online!

Ruby , 40 bytes

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

Experimente online!

Ícone , 65 63 bytes

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

Experimente online!

Haskell, 89 bytes

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

Se alguém souber como ignorar a importação necessária, entre em contato.