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

— falla
fuente

26

Yo ... ¿por qué demostró ese teorema? ¿Se despertó un día y dijo: "Resolveré esto!" o sirvió un propósito?

— Urna mágica de pulpo

11

@MagicOctopusUrn Nunca antes trataste con un teórico de números, ¿verdad?

— Brady Gilg

2

Aquí está la prueba de que alguien está interesado.

— Esolanging Fruit

14

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.

— Lynn
fuente

Buena solución por cierto. Estaba trabajando en el mismo método pero calculando el factorial en cada iteración; implementar su enfoque me ahorró unos pocos bytes, de +1todos modos.

— Shaggy

1

Para su versión True-for-1, puede acortar la condición del caso base tomando acomo número.

— XNOR

@xnor No hubiera pensado en `` -aen -p'', es un buen truco :)

— Lynn

Si la prueba aún se mantiene si N está restringido a valores pares, entonces esta solución de 45 bytes siempre generará un número.

— siete negativo

9

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.

— Cadena no relacionada
fuente

2

La implementación del predicado factorial en Brachylog es un poco complicada para que pueda usarse en ambos sentidos con una eficiencia aceptable. Se podría implementar un algoritmo mucho más rápido para calcular el factorial, pero sería extremadamente lento al contrario (es decir, encontrar el número original del factorial).

— Fatalize

Oh genial! Mirando la fuente para ello, no puedo decir qué está haciendo todo, pero puedo decir que hayas pensado mucho en ello.

— Cadena no relacionada

7

C ++ (gcc) , 107 95 bytes, usando `-lgmp`y`-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$

— Neil A.
fuente

Ya no necesita contar banderas, por lo que se trata de 107bytes.

— AdmBorkBork

¿Por qué necesitas el segundo punto y coma antes return?

— Ruslan

Puede usar un solo nombre de carácter para la función, guardar un par de bytes.

— Shaggy

6

Jalea , 8 bytes

1!w⁼1ʋ1#

Pruébalo en línea!

Toma un número entero y devuelve un singleton.

— Erik el Outgolfer
fuente

6

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)

— Kevin Cruijssen
fuente

2

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 .

— Maltysen
fuente

2

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.

— Lanudo
fuente

Lamentablemente, _Ês bU}f1en Japt no funciona

— Encarnación de la ignorancia

@EmbodimentofIgnorance, sí, yo también tuve eso. Podrías eliminar el espacio después s.

— Shaggy

@EmbodimentofIgnorance, también puede eliminar el 1if 0para devolverlo n=1.

— Shaggy

3 bytes menos:x=i=1n;f=n=>`${x*=++i}`.search(n)?f(n):i

— vrugtehagel

@vrugtehagel, eso no sería reutilizable.

— Shaggy

2

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!

— dana
fuente

1

69 + 22

— Datos

1

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

— Nick Kennedy
fuente

1

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

— Jo King
fuente

1

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.

— Neil
fuente

1

Perl 5 `-Mbigint -p` , 25 bytes

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

Pruébalo en línea!

— Xcali
fuente

1

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

— Jonás
fuente

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

— FrownyFrog

Me encanta el uso del "punto fijo" para evitar el tiempo tradicional.

— Jonás

1

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!

— LambdaBeta
fuente

Sugerir en strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1)lugar deb=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n))

— ceilingcat

1

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

— Hiperneutrino
fuente

@JoKing agradable, gracias

— HyperNeutrino

61 bytes

— Chas Brown

@ChasBrown gracias

— HyperNeutrino

Creo f=que se supone que lo que tienes en el encabezado cuenta para tu conteo de bits.

— mypetlion

@mypetlion Tienes razón; gracias por atrapar eso

— HyperNeutrino

0

Jalea , 11 bytes

‘ɼµ®!Dw³’µ¿

Pruébalo en línea!

— Hiperneutrino
fuente

0

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.

— Οurous
fuente

0

Wolfram Language (Mathematica) , 62 bytes

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

Pruébalo en línea!

— J42161217
fuente

0

Rubí , 40 bytes.

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

Pruébalo en línea!

— GB
fuente

0

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!

— Galen Ivanov
fuente

0

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.

— Mega Man
fuente

Parece que sacasy no como se requiere.

N!

$N!$

N

$N$

— falla

Una nota sobre N!

Reto

Detalles

Ejemplos

Python 2 , 50 bytes

Python 2 , 45 bytes (asigna 1 a True)

Python 2 , 48 bytes

Python 2 , 47 bytes (inválido)

Brachylog , 3 5 bytes

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

Jalea , 8 bytes

05AB1E , 7 bytes

Pyth - 8 bytes

JavaScript, 47 43 bytes

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

Jalea , 16 bytes

Explicación

Perl 6 , 23 bytes

Explicación

Carbón , 16 bytes

Perl 5 -Mbigint -p , 25 bytes

J , 28 22 bytes

respuesta original J , 28 bytes

C (gcc) -lgmp, 161 bytes

Python 3 , 63 bytes

Jalea , 11 bytes

Limpio , 88 bytes

Wolfram Language (Mathematica) , 62 bytes

Rubí , 40 bytes.

Icono , 65 63 bytes

Haskell, 89 bytes

Python 2 , 45 bytes (asigna 1 a `True`)

C ++ (gcc) , 107 95 bytes, usando `-lgmp`y`-lgmpxx`

Perl 5 `-Mbigint -p` , 25 bytes

J , ²⁸ 22 bytes