JE Maxfield demostró el siguiente teorema (ver DOI: 10.2307 / 2688966 ):

Si $A$ es un entero positivo que tiene $m$ dígitos, existe un entero positivo $N$ tal que los primeros $m$ dígitos de $N!$constituyen el entero $A$ .

Reto

Su desafío se le da un poco de $A \geqslant 1$ encontrar un $N \geqslant 1$ .

Detalles

• $N!$representa el factorial$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$ de$N$ .
• Los dígitos de $A$ en nuestro caso se entienden en la base $10$ .
• Su envío debe funcionar para $A\geqslant 1$ dado suficiente tiempo y memoria. Simplemente usar, por ejemplo, tipos de 32 bits para representar enteros no es suficiente.
• No necesariamente necesita generar la N mínima posible .$N$

Ejemplos

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

El $N$ menos posible para cada $A$ se puede encontrar en https://oeis.org/A076219

Python 2 , 50 bytes

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

Pruébalo en línea!

Esta es una variación de la solución de 47 bytes explicada a continuación, ajustada para devolver la 1entrada '1'. (Es decir, agregamos 1a la expresión completa en lugar de la llamada recursiva, y comenzamos a contar n==2para eliminar una capa de profundidad, equilibrando el resultado para todas las no '1'entradas).

Python 2 , 45 bytes (asigna 1 a True)

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

Esta es otra variación, de @Jo King y @xnor, que toma la entrada como un número y devuelve la Trueentrada 1. Algunas personas piensan que este es un juego justo, pero personalmente lo encuentro un poco extraño.

Pero cuesta solo 3 bytes envolver el resultado booleano repugnante +(), dándonos una solución "agradable" más corta:

Python 2 , 48 bytes

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

Esta es mi solución anterior, que regresa 0como entrada '1'. Hubiera sido válido si la pregunta se refería a un no negativoN .

Python 2 , 47 bytes (inválido)

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

Pruébalo en línea!

Toma una cadena como entrada, como f('18').

El truco aquí es x.find(y) == 0precisamente cuando x.startswith(y).

La andexpresión-cortocircuitará `p`.find(a)con el resultado 0tan pronto como `p`comience con a; de lo contrario, se evaluará a -~f(a,n+1,p*n), id est 1 + f(a,n+1,p*n).

El resultado final es 1 + (1 + (1 + (... + 0))), ncapas profundas, así n.

Brachylog , 3 5 bytes

ℕ₁ḟa₀

Pruébalo en línea!

Toma entrada a través de su variable de salida y emite a través de su variable de entrada. (Al revés, solo encuentra prefijos arbitrarios del factorial de entrada, que no es tan interesante). Se agota el tiempo del último al último caso de prueba en TIO, pero funciona bien en el último . Lo he estado ejecutando en 841 en mi computadora portátil durante varios minutos al momento de escribir esto, y aún no ha escupido una respuesta, pero tengo fe en ello.

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

¡Ya que la única entrada ḟa₀no funciona es 1, y 1 es un prefijo positivo de 1! = 1, 1|ḟa₀funciona igual de bien.

Además, a partir de esta edición, 841 ha estado funcionando durante casi tres horas y todavía no ha producido una salida. Supongo que calcular el factorial de cada número entero de 1 a 12745 no es exactamente rápido.

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

Gracias a la gente en los comentarios por señalar algunos percances tontos.

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

Pruébalo en línea!

Computamultiplicandopor , luego lo divide repetidamente por hasta que ya no sea mayor que el entero pasado. En este punto, el ciclo termina si el factorial es igual al entero pasado, o de lo contrario pasa al siguiente .$n!$$(n-1)!$$n$$10$$n$

Jalea , 8 bytes

1!w⁼1ʋ1#

Pruébalo en línea!

Toma un número entero y devuelve un singleton.

05AB1E , 7 bytes

∞.Δ!IÅ?

Pruébelo en línea o verifique -casi- todos los casos de prueba (se 841agota el tiempo, por lo que está excluido).

Explicación:

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

Pruébalo en línea .

JavaScript, 47 43 bytes

Salida como un BigInt.

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

¡Pruébelo en línea!

Ahorró unos pocos bytes al adoptar el enfoque de Lynn de "construir" el factorial en lugar de calcularlo en cada iteración, así que por favor vote su solución también si está votando esta.

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

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

Pruébalo en línea!

Usos System.Numerics.BigIntegerque requieren una usingdeclaración.

-1 byte gracias a @ExpiredData!

Jalea , 16 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Explicación

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

Carbón , 16 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

⊞υ¹

Empuje 1a la lista vacía para que comience con un producto definido.

Ｗ⌕ＩΠυθ

Repita mientras no se puede encontrar la entrada al principio del producto de la lista ...

⊞υＬυ

... empuje la longitud de la lista a sí misma.

Ｉ⊟υ

Imprima el último valor empujado a la lista.

Perl 5 -Mbigint -p , 25 bytes

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

Pruébalo en línea!

J , ²⁸ 22 bytes

-6 bytes gracias a FrownyFrog

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

Pruébalo en línea!

respuesta original J , 28 bytes

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

Pruébalo en línea!

• >:@] ... x:@1comenzando con una precisión extendida 1, siga incrementándola mientras ...
• -.@ no es el caso de que ...
• {.@ el primer olmo es un partido inicial de ...
• E.&":todas las coincidencias de subcadenas (después de seleccionar ambos argumentos &":) de la búsqueda de la entrada original en ...
• ! el factorial del 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));}

Pruébalo en línea!

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)

Pruébalo en línea!

-24 bytes gracias a Jo King

-3 bytes gracias a Chas Brown

Jalea , 11 bytes

‘ɼµ®!Dw³’µ¿

Pruébalo en línea!

Limpio , 88 bytes

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

Pruébalo en línea!

Define $ :: Integer -> Integer.

Utiliza Data.Integerenteros de tamaño arbitrario para IO.

Wolfram Language (Mathematica) , 62 bytes

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

Pruébalo en línea!

Rubí , 40 bytes.

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

Pruébalo en línea!

Icono , 65 63 bytes

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

Pruébalo en línea!

Haskell, 89 bytes

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

Si alguien sabe cómo omitir la importación requerida, avíseme.