32
\$\begingroup\$

J. E. Maxfield proved following theorem (see DOI: 10.2307/2688966):

If \$A\$ is any positive integer having \$m\$ digits, there exists a positive integer \$N\$ such that the first \$m\$ digits of \$N!\$ constitute the integer \$A\$.

Challenge

Your challenge is given some \$A \geqslant 1\$ find a corresponding \$N \geqslant 1\$.

Details

  • \$N!\$ represents the factorial \$N! = 1\cdot 2 \cdot 3\cdot \ldots \cdot N\$ of \$N\$.
  • The digits of \$A\$ in our case are understood to be in base \$10\$.
  • Your submission should work for arbitrary \$A\geqslant 1\$ given enough time and memory. Just using e.g. 32-bit types to represent integers is not sufficient.
  • You don't necessarily need to output the least possible \$N\$.

Examples

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

The least possible \$N\$ for each \$A\$ can be found in https://oeis.org/A076219

\$\endgroup\$
  • 26
    \$\begingroup\$ I... why did he prove that theorem? Did he just wake up one day and say "I shall solve this!" or did it serve a purpose? \$\endgroup\$ – Magic Octopus Urn Apr 25 at 19:53
  • 11
    \$\begingroup\$ @MagicOctopusUrn Never dealt with a number theorist before, have you? \$\endgroup\$ – Brady Gilg Apr 26 at 16:16
  • 2
    \$\begingroup\$ Here's the proof it anyone's interested. \$\endgroup\$ – Esolanging Fruit Apr 29 at 2:39

21 Answers 21

14
\$\begingroup\$

Python 2, 50 bytes

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

Try it online!

This is a variation of the 47-byte solution explained below, adjusted to return 1 for input '1'. (Namely, we add 1 to the full expression rather than the recursive call, and start counting from n==2 to remove one layer of depth, balancing the result out for all non-'1' inputs.)

Python 2, 45 bytes (maps 1 to True)

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

This is another variation, by @Jo King and @xnor, which takes input as a number and returns True for input 1. Some people think this is fair game, but I personally find it a little weird.

But it costs only 3 bytes to wrap the icky Boolean result in +(), giving us a shorter "nice" solution:

Python 2, 48 bytes

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

This is my previous solution, which returns 0 for input '1'. It would have been valid if the question concerned a non-negative N.

Python 2, 47 bytes (invalid)

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

Try it online!

Takes a string as input, like f('18').

The trick here is that x.find(y) == 0 precisely when x.startswith(y).

The and-expression will short circuit at `p`.find(a) with result 0 as soon as `p` starts with a; otherwise, it will evaluate to -~f(a,n+1,p*n), id est 1 + f(a,n+1,p*n).

The end result is 1 + (1 + (1 + (... + 0))), n layers deep, so n.

\$\endgroup\$
  • \$\begingroup\$ Nice solution by the way. I was working on the same method but calculating the factorial on each iteration; implementing your approach saved me a few bytes so +1 anyway. \$\endgroup\$ – Shaggy Apr 25 at 20:58
  • 1
    \$\begingroup\$ For your True-for-1 version, you can shorten the base case condition taking a as a number. \$\endgroup\$ – xnor Apr 27 at 3:40
  • \$\begingroup\$ @xnor I would have not thought of `` -ain-p ``, that's a neat trick :) \$\endgroup\$ – Lynn Apr 27 at 14:20
9
\$\begingroup\$

Brachylog, 3 5 bytes

ℕ₁ḟa₀

Try it online!

Takes input through its output variable, and outputs through its input variable. (The other way around, it just finds arbitrary prefixes of the input's factorial, which isn't quite as interesting.) Times out on the second-to-last test case on TIO, but does fine on the last one. I've been running it on 841 on my laptop for several minutes at the time of writing this, and it hasn't actually spit out an answer yet, but I have faith in it.

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

Since the only input ḟa₀ doesn't work for is 1, and 1 is a positive prefix of 1! = 1, 1|ḟa₀ works just as well.

Also, as of this edit, 841 has been running for nearly three hours and it still hasn't produced an output. I guess computing the factorial of every integer from 1 to 12745 isn't exactly fast.

\$\endgroup\$
  • 2
    \$\begingroup\$ The implementation of the factorial predicate in Brachylog is a bit convoluted so that it can be used both ways with acceptable efficiency. One could implement a much faster algorithm to compute the factorial, but it would be extremely slow running the other way (i.e. finding the original number from the factorial). \$\endgroup\$ – Fatalize Apr 26 at 9:28
  • \$\begingroup\$ Oh, cool! Looking at the source for it, I can't tell what all it's doing, but I can tell you put a lot of good thought into it. \$\endgroup\$ – Unrelated String Apr 26 at 9:37
7
\$\begingroup\$

C++ (gcc), 107 95 bytes, using -lgmp and -lgmpxx

Thanks to the people in the comments for pointing out some silly mishaps.

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

Try it online!

Computes \$n!\$ by multiplying \$(n-1)!\$ by \$n\$, then repeatedly divides it by \$10\$ until it is no longer greater than the passed integer. At this point, the loop terminates if the factorial equals the passed integer, or proceeds to the next \$n\$ otherwise.

\$\endgroup\$
  • \$\begingroup\$ You don't need to count flags anymore, so this is 107 bytes. \$\endgroup\$ – AdmBorkBork Apr 26 at 12:37
  • \$\begingroup\$ Why do you need the second semicolon before return? \$\endgroup\$ – Ruslan Apr 26 at 15:34
  • \$\begingroup\$ You could use a single character name for the function, save a couple of bytes. \$\endgroup\$ – Shaggy Apr 26 at 16:38
6
\$\begingroup\$

Jelly, 8 bytes

1!w⁼1ʋ1#

Try it online!

Takes an integer and returns a singleton.

\$\endgroup\$
6
\$\begingroup\$

05AB1E, 7 bytes

∞.Δ!IÅ?

Try it online or verify -almost- all test cases (841 times out, so is excluded).

Explanation:

∞.Δ      # 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)
\$\endgroup\$
2
\$\begingroup\$

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

Try it online.

\$\endgroup\$
2
\$\begingroup\$

JavaScript, 47 43 bytes

Output as a BigInt.

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

Try It Online!

Saved a few bytes by taking Lynn's approach of "building" the factorial rather than calculating it on each iteration so please upvote her solution as well if you're upvoting this one.

\$\endgroup\$
  • \$\begingroup\$ Sadly, _Ês bU}f1 in Japt doesn't work \$\endgroup\$ – Embodiment of Ignorance Apr 25 at 21:12
  • \$\begingroup\$ @EmbodimentofIgnorance, yeah, I had that too. You could remove the space after s. \$\endgroup\$ – Shaggy Apr 25 at 21:13
  • \$\begingroup\$ @EmbodimentofIgnorance, you could also remove the 1 if 0 can be returned for n=1. \$\endgroup\$ – Shaggy Apr 25 at 21:45
  • \$\begingroup\$ 3 bytes less: x=i=1n;f=n=>`${x*=++i}`.search(n)?f(n):i \$\endgroup\$ – vrugtehagel May 2 at 16:08
  • \$\begingroup\$ @vrugtehagel, that wouldn't be reusable. \$\endgroup\$ – Shaggy May 2 at 20:12
2
\$\begingroup\$

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

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

Try it online!

Uses System.Numerics.BigInteger which requires a using statement.

-1 byte thanks to @ExpiredData!

\$\endgroup\$
1
\$\begingroup\$

Jelly, 16 bytes

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

Try it online!

Explanation

‘ɼ                | 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
\$\endgroup\$
1
\$\begingroup\$

Perl 6, 23 bytes

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

Try it online!

Explanation

{                     }  # 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
\$\endgroup\$
1
\$\begingroup\$

Charcoal, 16 bytes

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

Try it online! Link is to verbose version of code. Explanation:

⊞υ¹

Push 1 to the empty list so that it starts off with a defined product.

W⌕IΠυθ

Repeat while the input cannot be found at the beginning of the product of the list...

⊞υLυ

... push the length of the list to itself.

I⊟υ

Print the last value pushed to the list.

\$\endgroup\$
1
\$\begingroup\$

Perl 5 -Mbigint -p, 25 bytes

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

Try it online!

\$\endgroup\$
1
\$\begingroup\$

J, 28 22 bytes

-6 bytes thanks to FrownyFrog

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

Try it online!

original answer J, 28 bytes

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

Try it online!

  • >:@] ... x:@1 starting with an extended precision 1, keep incrementing it while...
  • -.@ its not the case that...
  • {.@ the first elm is a starting match of...
  • E.&": all the substring matches (after stringfying both arguments &":) of searching for the original input in...
  • ! the factorial of the number we're incrementing
\$\endgroup\$
  • \$\begingroup\$ (]+1-0{(E.&":!))^:_&1x \$\endgroup\$ – FrownyFrog Apr 26 at 14:07
  • \$\begingroup\$ I love that use of "fixed point" to avoid the traditional while. \$\endgroup\$ – Jonah Apr 26 at 14:15
1
\$\begingroup\$

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

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Suggest strstr(b=mpz_get_str(0,10,_),a)-b;mpz_mul(_,_,n))mpz_add_ui(n,n,1) instead of b=mpz_get_str(0,10,_),strstr(b,a)-b;mpz_add_ui(n,n,1),mpz_mul(_,_,n)) \$\endgroup\$ – ceilingcat Apr 26 at 22:07
1
\$\begingroup\$

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)

Try it online!

-24 bytes thanks to Jo King

-3 bytes thanks to Chas Brown

\$\endgroup\$
  • \$\begingroup\$ @JoKing nice, thanks \$\endgroup\$ – HyperNeutrino Apr 26 at 1:13
  • \$\begingroup\$ 61 bytes \$\endgroup\$ – Chas Brown Apr 26 at 8:17
  • \$\begingroup\$ @ChasBrown thanks \$\endgroup\$ – HyperNeutrino Apr 26 at 17:43
  • \$\begingroup\$ I think the f= that you've got in the header is supposed to count towards your bit count. \$\endgroup\$ – mypetlion May 1 at 22:20
  • \$\begingroup\$ @mypetlion You are correct; thanks for catching that. \$\endgroup\$ – HyperNeutrino May 1 at 22:33
0
\$\begingroup\$

Jelly, 11 bytes

‘ɼµ®!Dw³’µ¿

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Clean, 88 bytes

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

Try it online!

Defines $ :: Integer -> Integer.

Uses Data.Integer's arbitrary size integers for IO.

\$\endgroup\$
0
\$\begingroup\$

Wolfram Language (Mathematica), 62 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Ruby, 40 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Icon, 65 63 bytes

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

Try it online!

\$\endgroup\$
0
\$\begingroup\$

Haskell, 89 bytes

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

If anyone knows how to bypass the required import, let me know.

\$\endgroup\$
  • \$\begingroup\$ It seems that you output \$N!\$ and not \$N\$ as required. \$\endgroup\$ – flawr May 3 at 21:49

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.