Una nota sobre N!


32

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 A1 encontrar un N1 .

Detalles

  • N!representa el factorialN!=123N deN .
  • Los dígitos de A en nuestro caso se entienden en la base 10 .
  • Su envío debe funcionar para A1 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


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

Respuestas:


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.


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.


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 -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!(n1)!n10n


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



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 .


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.


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


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

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

1

Carbón , 16 bytes

⊞υ¹W⌕IΠυθ⊞υLυI⊟υ

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.

W⌕IΠυθ

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

⊞υLυ

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

I⊟υ

Imprima el último valor empujado a la lista.



1

J , 28 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

(]+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!


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



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.





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.


Parece que sacasy no como se requiere. N!N
falla
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.