Uma nota sobre N!

32

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

A1N1

Detalhes

  • N!representa o fatorial de .N!=123NN
  • Os dígitos de no nosso caso são entendidos na base .A10
  • 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.A1
  • 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/A076219NA

flawr
fonte
26
Eu ... por que ele provou esse teorema? Ele acabou de acordar um dia e dizer: "Vou resolver isso!" ou serviu a um propósito?
Magic Octopus Urn
11
@MagicOctopusUrn Nunca lidou com um teórico dos números antes, não é?
Brady Gilg
2
Aqui está a prova de que alguém está interessado.
Esolanging Fruit

Respostas:

14

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.

Lynn
fonte
Bela solução, a propósito. Eu estava trabalhando no mesmo método, mas calculando o fatorial em cada iteração; implementar sua abordagem me salvou alguns bytes de +1qualquer maneira.
Shaggy
1
Para a sua versão True-for-1, você pode reduzir a condição do caso base usando aum número.
xnor 27/04
@xnor eu não teria pensado em `` -ain -p'', isso é um truque legal :)
Lynn
Se a prova ainda for válida se N estiver restrito a valores pares, esta solução de 45 bytes sempre produzirá um número.
negativo sete
9

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.

String não relacionada
fonte
2
A implementação do predicado fatorial no Brachylog é um pouco complicada para que possa ser usada nos dois sentidos com eficiência aceitável. Pode-se implementar um algoritmo muito mais rápido para calcular o fatorial, mas seria extremamente lento para o outro lado (ou seja, encontrar o número original do fatorial).
Fatalize
Oh fixe! Olhando a fonte, não sei dizer o que está fazendo, mas posso dizer que você pensa muito nisso.
String não relacionada
7

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

Neil A.
fonte
Você não precisa mais contar sinalizadores, portanto são 107bytes.
AdmBorkBork 26/04
Por que você precisa do segundo ponto e vírgula antes return?
Ruslan
Você pode usar um nome de caractere único para a função, salvar alguns bytes.
Shaggy
6

Geléia , 8 bytes

1!w⁼1ʋ1#

Experimente online!

Pega um número inteiro e retorna um singleton.

Erik, o Outgolfer
fonte
2

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 .

Maltysen
fonte
2

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.

Shaggy
fonte
Infelizmente, _Ês bU}f1em Japt não funciona
Modalidade de Ignorância
@EmbodimentofIgnorance, sim, eu tinha isso também. Você pode remover o espaço depois s.
Shaggy
@EmbodimentofIgnorance, você também pode remover o 1if 0pode ser retornado para n=1.
Shaggy
3 bytes menos:x=i=1n;f=n=>`${x*=++i}`.search(n)?f(n):i
vrugtehagel
@vrugtehagel, isso não seria reutilizável.
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;}

Experimente online!

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

-1 byte graças a @ExpiredData!

dana
fonte
1
69 + 22
Dados expirados
1

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
Nick Kennedy
fonte
1

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
Brincadeira
fonte
1

Carvão , 16 bytes

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

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.

W⌕IΠυθ

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

⊞υLυ

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

I⊟υ

Imprima o último valor enviado para a lista.

Neil
fonte
1

J , 28 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
Jonah
fonte
(]+1-0{(E.&":!))^:_&1x
FrownyFrog
Eu amo esse uso de "ponto fixo" para evitar o tempo tradicional.
Jonah
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));}

Experimente online!

LambdaBeta
fonte
Sugerir em strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1)vez 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)

Experimente online!

-24 bytes graças a Jo King

-3 bytes graças a Chas Brown

HyperNeutrino
fonte
@JoKing nice, thanks
HyperNeutrino
61 bytes
Chas Brown
@ChasBrown thanks
HyperNeutrino
Eu acho f=que o que você tem no cabeçalho deve contar para a sua contagem de bits.
mypetlion
@mypetlion Você está correto; obrigado por entender isso.
HyperNeutrino
0

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.

Furioso
fonte
0

Ícone , 65 63 bytes

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

Experimente online!

Galen Ivanov
fonte
0

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.

Mega Man
fonte
Parece que você produz N! e não Ncomo requerido.
flawr