JE Maxfield ha dimostrato il seguente teorema (vedi DOI: 10.2307 / 2688966 ):

Se $A$ è un numero intero positivo con $m$ cifre, esiste un numero intero positivo $N$ tale che le prime $m$ cifre di $N!$ costituisce l'intero $A$ .

Sfida

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

Dettagli

$N!$ rappresenta la fattoriale di . $N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N$ $N$
Le cifre di nel nostro caso sono comprese nella base . $A$ $10$
Il tuo invio dovrebbe funzionare per arbitrario con tempo e memoria sufficienti. Il solo utilizzo di tipi a 32 bit per rappresentare numeri interi non è sufficiente. $A\geqslant 1$
Non è necessariamente necessario produrre il meno possibile . $N$

Esempi

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

La meno possibile per ogni è disponibile in https://oeis.org/A076219 $N$ $A$

— flawr
fonte

26

Io ... perché ha dimostrato quel teorema? Si è appena svegliato un giorno e ha detto "Lo risolverò!" o ha avuto uno scopo?

— Magic Octopus Urn

11

@MagicOctopusUrn Non hai mai avuto a che fare con un teorico dei numeri prima, vero?

— Brady Gilg,

2

Ecco la prova che interessa a chiunque.

— Esolanging Fruit

14

Python 2 , 50 byte

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

Provalo online!

Questa è una variazione della soluzione a 47 byte spiegata di seguito, regolata per tornare 1per l'input '1'. (Vale a dire, aggiungiamo1 all'espressione completa anziché alla chiamata ricorsiva e iniziamo a contare da n==2per rimuovere uno strato di profondità, bilanciando il risultato per tutti i non '1'input.)

Python 2 , 45 byte (mappe da 1 a `True` )

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

Questa è un'altra variante, di @Jo King e @xnor, che accetta input come numero e restituisce Trueinput1 . Alcune persone pensano che sia un gioco corretto, ma personalmente lo trovo un po 'strano.

Ma costa solo 3 byte per racchiudere il risultato booleano icky +(), dandoci una soluzione "piacevole" più breve:

Python 2 , 48 byte

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

Questa è la mia soluzione precedente, che ritorna 0per l'input '1'. Sarebbe stato valido se la domanda riguardasse un aspetto non negativoN .

Python 2 , 47 byte (non valido)
f=lambda a,n=1,p=1:`p`.find(a)and-~f(a,n+1,p*n)
Provalo online!

Prende una stringa come input, come f('18') .

Il trucco qui è che x.find(y) == 0proprio quandox.startswith(y) .

L' andespressione cortocircuiterà `p`.find(a)con il risultato 0non appena `p`inizia con a; in caso contrario, valuterà -~f(a,n+1,p*n), id est 1 + f(a,n+1,p*n).

Il risultato finale è 1 + (1 + (1 + (... + 0))), nstrati profondi, quindi n.

— Lynn
fonte

Bella soluzione a proposito. Stavo lavorando sullo stesso metodo ma calcolando il fattoriale su ogni iterazione; l'implementazione del tuo approccio mi ha fatto risparmiare qualche byte, +1comunque.

— Shaggy

1

Per la tua versione True-for-1, puoi abbreviare la condizione del caso base prendendo acome numero.

— xnor

@xnor non avrei pensato a `` -ain -p'', è un trucco pulito :)

— Lynn,

Se la dimostrazione è ancora valida se N è limitato a valori pari, questa soluzione da 45 byte genererà sempre un numero.

— negativo sette

9

Brachylog , 3 5 byte

ℕ₁ḟa₀

Provalo online!

Prende l'input attraverso la sua variabile di output e l'output attraverso la sua variabile di input. (Al contrario, trova solo prefissi arbitrari del fattoriale dell'input, il che non è altrettanto interessante.) Scade il penultimo test case su TIO, ma va bene sull'ultimo . L'ho eseguito su 841 sul mio laptop per diversi minuti al momento della stesura di questo, e in realtà non ha ancora emesso una risposta, ma ho fiducia in esso.

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

Poiché l'unico input per cui ḟa₀non funziona è 1, e 1 è un prefisso positivo di 1! = 1, 1|ḟa₀funziona altrettanto bene.

Inoltre, a partire da questa modifica, 841 è in esecuzione da quasi tre ore e non ha ancora prodotto un output. Immagino che calcolare il fattoriale di ogni numero intero da 1 a 12745 non sia esattamente veloce.

— Stringa non correlata
fonte

2

L'implementazione del predicato fattoriale in Brachylog è un po 'contorta in modo che possa essere utilizzata in entrambi i modi con efficienza accettabile. Si potrebbe implementare un algoritmo molto più veloce per calcolare il fattoriale, ma sarebbe estremamente lento correre dall'altra parte (cioè trovare il numero originale dal fattoriale).

— Fatalizza il

Oh, fico! Osservando la fonte, non posso dire cosa sta facendo, ma posso dirti che ci hai pensato molto.

— Corda non correlata il

7

C ++ (gcc) , 107 95 byte, usando `-lgmp`e`-lgmpxx`

Grazie alle persone nei commenti per aver segnalato alcune sciocche disavventure.

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

Provalo online!

Calcola $n!$ moltiplicando $(n-1)!$ per $n$ , quindi lo divide ripetutamente per $10$ fino a quando non è più grande dell'intero passato. A questo punto, il ciclo termina se il fattoriale è uguale all'intero passato o procede alla $n$ successiva in caso contrario.

— Neil A.
fonte

Non è più necessario contare i flag, quindi si tratta di 107byte.

— AdmBorkBork,

Perché hai bisogno del secondo punto e virgola prima return?

— Ruslan,

È possibile utilizzare un nome di singolo carattere per la funzione, salvare un paio di byte.

— Shaggy,

6

Gelatina , 8 byte

1!w⁼1ʋ1#

Provalo online!

Prende un numero intero e restituisce un singleton.

— Erik the Outgolfer
fonte

6

05AB1E , 7 byte

∞.Δ!IÅ?

Provalo online o verifica quasi tutti i casi di test ( 841timeout, quindi è escluso).

Spiegazione:

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

2

Pyth - 8 byte

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

Provalo online .

— Maltysen
fonte

2

JavaScript, 47 43 byte

Output come BigInt.

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

Provalo online!

Hai salvato qualche byte adottando l'approccio di Lynn di "costruire" il fattoriale piuttosto che calcolarlo su ogni iterazione, quindi per favore vota anche la sua soluzione se stai votando questo.

— ispido
fonte

Purtroppo, _Ês bU}f1in Japt non funziona

— Incarnazione dell'ignoranza il

@EmbodimentofIgnorance, sì, l'ho avuto anch'io. È possibile rimuovere lo spazio dopo s.

— Shaggy

@EmbodimentofIgnorance, è inoltre possibile rimuovere 1if per cui è 0possibile restituire n=1.

— Shaggy,

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

— vrugtehagel

@vrugtehagel, non sarebbe riutilizzabile.

— Shaggy

2

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

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

Provalo online!

Usi System.Numerics.BigIntegerche richiedono una usingdichiarazione.

-1 byte grazie a @ExpiredData!

— dana
fonte

1

69 + 22

— Dati scaduti il

1

Gelatina , 16 byte

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

Provalo online!

Spiegazione

‘ɼ                | 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 byte

{+([\*](1..*).../^$_/)}

Provalo online!

Spiegazione

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

1

Carbone , 16 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

⊞υ¹

Spingere 1nell'elenco vuoto in modo che inizi con un prodotto definito.

Ｗ⌕ＩΠυθ

Ripeti finché non è possibile trovare l'input all'inizio del prodotto dell'elenco ...

⊞υＬυ

... spingi la lunghezza della lista su se stessa.

Ｉ⊟υ

Stampa l'ultimo valore inserito nell'elenco.

— Neil
fonte

1

Perl 5 `-Mbigint -p` , 25 byte

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

Provalo online!

— Xcali
fonte

1

J , ²⁸ 22 byte

-6 byte grazie a FrownyFrog

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

Provalo online!

risposta originale J , 28 byte

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

Provalo online!

>:@] ... x:@1 a partire da una precisione estesa 1 , continua ad incrementarlo mentre ...
-.@ non è il caso che ...
{.@ il primo olmo è una partita iniziale di ...
E.&": tutte le sottostringhe corrispondono (dopo aver inserito in stringa entrambi gli argomenti &": ) alla ricerca dell'input originale in ...
! il fattoriale del numero che stiamo incrementando

— Giona
fonte

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

— FrownyFrog,

Adoro l'uso del "punto fisso" per evitare il tradizionale.

— Giona il

1

C (gcc) -lgmp, 161 byte

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

Provalo online!

— LambdaBeta
fonte

Suggerisci strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1)invece dib=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n))

— ceilingcat il

1

Python 3 , 63 byte

f=lambda x,a=2,b=1:str(b).find(str(x))==0and a-1or f(x,a+1,b*a)

Provalo online!

-24 byte grazie a Jo King

-3 byte grazie a Chas Brown

— HyperNeutrino
fonte

@JoKing nice, thanks

— HyperNeutrino

61 byte

— Chas Brown,

@ChasBrown ringraziamenti

— HyperNeutrino il

Penso che f=ciò che hai nell'intestazione dovrebbe contare per il tuo conteggio dei bit.

— mypetlion

@mypetlion Hai ragione; grazie per averlo colto.

— HyperNeutrino

0

Gelatina , 11 byte

‘ɼµ®!Dw³’µ¿

Provalo online!

— HyperNeutrino
fonte

0

Pulito , 88 byte

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

Provalo online!

Definisce $ :: Integer -> Integer.

Utilizza Data.Integernumeri interi di dimensioni arbitrarie per IO.

— Οurous
fonte

0

Wolfram Language (Mathematica) , 62 byte

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

Provalo online!

— J42161217
fonte

0

Rubino , 40 byte

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

Provalo online!

— GB
fonte

0

Icona , 65 63 byte

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

Provalo online!

— Galen Ivanov
fonte

0

Haskell, 89 byte

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

Se qualcuno sa come bypassare l'importazione richiesta, fammelo sapere.

— Mega Man
fonte

Sembra che tu abbia emesso

N!

$N!$ e non

N

$N$ come richiesto.

— flawr

Una nota su N!

Sfida

Dettagli

Esempi

Python 2 , 50 byte

Python 2 , 45 byte (mappe da 1 a True )

Python 2 , 48 byte

Python 2 , 47 byte (non valido)

Brachylog , 3 5 byte

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

Gelatina , 8 byte

05AB1E , 7 byte

Pyth - 8 byte

JavaScript, 47 43 byte

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

Gelatina , 16 byte

Spiegazione

Perl 6 , 23 byte

Spiegazione

Carbone , 16 byte

Perl 5 -Mbigint -p , 25 byte

J , 28 22 byte

risposta originale J , 28 byte

C (gcc) -lgmp, 161 byte

Python 3 , 63 byte

Gelatina , 11 byte

Pulito , 88 byte

Wolfram Language (Mathematica) , 62 byte

Rubino , 40 byte

Icona , 65 63 byte

Haskell, 89 byte

Python 2 , 45 byte (mappe da 1 a `True` )

C ++ (gcc) , 107 95 byte, usando `-lgmp`e`-lgmpxx`

Perl 5 `-Mbigint -p` , 25 byte

J , ²⁸ 22 byte