Consecutive Composite Numbers

Question

Challenge

Generate \$n-1\$ consecutive composite numbers using this prime gap formula

$$n!+2,n!+3,...,n!+n$$

Input

An integer \$n\$ such that \$3 \leq n \leq 50 \$.

Output

Sequence of \$n-1\$ consecutive composite numbers.

Example

Input

Output

8
9

Rules

Output should be in integer format.

Test Cases

For \$n > 20\$, the results are very BIG integers (greater than 64-bits) and will most likely require a language that natively supports large numbers or a 3rd party library to handle them.

n	\$n-1\$ consecutive composites
3	8 9
5	122 123 124 125
21	51090942171709440002 51090942171709440003 51090942171709440004 51090942171709440005 51090942171709440006 51090942171709440007 51090942171709440008 51090942171709440009 51090942171709440010 51090942171709440011 51090942171709440012 51090942171709440013 51090942171709440014 51090942171709440015 51090942171709440016 51090942171709440017 51090942171709440018 51090942171709440019 51090942171709440020 51090942171709440021

Your last comment makes me wonder: if supporting large integers is a strict requirement (which doesn't sound like a good idea), it should be explicitly mentioned in the challenge. — Arnauld, Commented Jan 18 at 0:00
Please note that "making the challenge trickier by requiring a bignum" is one example of unnecessary fluff and therefore discouraged. Check out the fifth rule on this challenge (which is the implicit default on this site). — Bubbler, Commented Jan 18 at 0:06
So, to be clear: do answers need to support arbiitrarily large integers, or is it acceptable if the results become inexact for large inputs due floating-point issues or maximum representable values? Voting to close until clarified — Luis Mendo, Commented Jan 18 at 11:54
Actually I read the OEIS gap size wrong. oeis.org/A204665 is for gaps of size 52. So the following 50 numbers after 19609 are composite. — qwr, Commented Jan 18 at 20:15
It would be appreciated if a clarification could be made to answer Luis Mendo's question regarding whether infinite precision is required or if submissions are allowed to become inexact due to language limitations. — hyperneutrino, Commented May 4 at 6:46

Tbw · Accepted Answer · 2024-01-18 17:48:44Z

5

APL(Dyalog Unicode), 5 bytes ^SBCS

1↓⍳+!

Try it on APLgolf!

A tacit function that takes an integer on the right and returns an array of n-1 composite numbers.

Explanation

    ! ⍝ factorial
   +  ⍝ plus
  ⍳   ⍝ range
1↓    ⍝ drop the first

There are actually two other permutations of these five characters that produce the same result. See if you can find them. ;)

6 bytes, outputs full numbers under \$10^{34}\$

⍕1↓⍳+!

Try it! This requires adding (⎕FR⎕PP)←1287 34 to the header to set the float and printing precision.

edited Jan 18 at 17:48

answered Jan 18 at 0:43

Tbw

2,1812 silver badges27 bronze badges

1

\$\begingroup\$ How many digits can Dyalog display. I attempted this in APL+WIN and like your answer it defaults to E notation for large numbers. That being the case with a 17 digit limit I could not display the true series as all results were the same for the 21 example i.e. 5.109094217170944E19 5.109094217170944E19 etc \$\endgroup\$
– Graham
Commented Jan 18 at 11:13
\$\begingroup\$ To get an exact answer in Dyalog, you need to have (⎕FR⎕PP)←1287 34 in the header and use ⍕. I'll probably add this as 6 byte solution (usually, defining system variables like ⎕IO← is not counted in bytes). \$\endgroup\$
– Tbw
Commented Jan 18 at 17:40

Add a comment |

Albert.Lang · Accepted Answer · 2024-01-19 13:45:36Z

5

Python, 51 bytes

f=lambda n:range((n<2or(f(n-1).stop-n)*n)-~n)[1-n:]

Attempt This Online!

Returns a range object.

Original Python, 56 bytes

f=lambda n:[n*([*f(n-1),3][0]-2)+j+2for j in range(n-1)]

Attempt This Online!

edited Jan 19 at 13:45

answered Jan 19 at 7:10

Albert.Lang

4,5745 silver badges22 bronze badges

Add a comment |

emanresu A · Accepted Answer · 2024-01-18 01:13:20Z

4

Vyxal, 4 bytes

Ḣ?¡+

Try it Online!

Ḣ    # range(2, n+1)
   + # + 
 ?¡  # n!

answered Jan 18 at 1:13

emanresu A

44.2k5 gold badges100 silver badges240 bronze badges

\$\begingroup\$ 3 bytes # Vyxal Ṫ, 3 bytes ``` Ḣ?¡ ``` Try it Online! \$\endgroup\$
– pacman256
Commented Jan 18 at 6:20

Add a comment |

Alt Shift X · Accepted Answer · 2024-01-18 04:05:10Z

4

Funge-98, 29 bytes

"HTMI"4(&:F2+v
\I_@#:-2\I.: <

Try it online!

answered Jan 18 at 4:05

Alt Shift X

3011 silver badge4 bronze badges

Add a comment |

Joao-3 · Accepted Answer · 2024-07-30 13:58:14Z

4

Desmos, 15 bytes

f(n)=[2...n]+n!

Try it in Desmos!

The simplest a solution can get, to be honest.

edited Jul 30 at 13:58

answered Jan 18 at 14:45

Joao-3

1,4484 silver badges18 bronze badges

\$\begingroup\$ Nice creativity using desmos! \$\endgroup\$
– vengy
Commented Jan 18 at 14:53
\$\begingroup\$ @vengy Desmos is literally math notation, so it's very good for challenges like this. \$\endgroup\$
– Joao-3
Commented Jan 18 at 14:59
1

\$\begingroup\$ Does not work for n=1, but it's probably unreasonable to expect all answers to output nothing for that case. \$\endgroup\$
– Tbw
Commented Jan 18 at 18:08
\$\begingroup\$ @Tbw n=1 is now not a valid input \$\endgroup\$
– Joao-3
Commented Jan 18 at 21:36
\$\begingroup\$ Another issue with this is that the numbers get inaccurate for large n due to floating point inaccuracies. As an example, n=21 gives a list of all 51090942171709460000. It is unclear whether or not OP is fine with such inaccuracies, but if not, this answer would technically be invalid. \$\endgroup\$
– Aiden Chow
Commented Jan 23 at 8:00

Add a comment |

Jonathan Allan · Accepted Answer · 2024-01-18 10:37:49Z

3

Jelly, 3 bytes

Ḋ+!

Try it online!

A monadic Link that accepts a positive integer, \$n\$, and yields a list of the \$n-1\$ consecutive integers.

How?

Ḋ+! - Link: integer, n
Ḋ   - dequeue {n}      -> [2, 3, 4, ..., n]
  ! - {n} factorial    -> n!
 +  - add (vectorises) -> [2+n!, 3+n!, 4+n!, ..., n+n!]

answered Jan 18 at 10:37

Jonathan Allan

110k7 gold badges65 silver badges282 bronze badges

Add a comment |

Kevin Cruijssen · Accepted Answer · 2024-01-18 07:55:35Z

3

05AB1E, 5 bytes

L¦¤!+

Try it online or verify all test cases.

Explanation:

L      # Push a list in the range [1, (implicit) input]
 ¦     # Remove the first value to make the range [2,input]
  ¤    # Push the last item (without popping the list): the input
   !   # Take its factorial
    +  # Add it to each value in the list
       # (after which this list is output implicitly as result)

answered Jan 18 at 7:55

Kevin Cruijssen

131k13 gold badges144 silver badges384 bronze badges

1

\$\begingroup\$ L¦DP+ also works for the same byte count. \$\endgroup\$
– Neil
Commented Jan 18 at 10:04

Add a comment |

Kevin Cruijssen · Accepted Answer · 2024-01-18 07:59:10Z

3

MathGolf, 5 bytes

╒╞\!+

Try it online.

Explanation:

╒      # Push a list in the range [1, (implicit) input]
 ╞     # Remove the first value to make the range [2,input]
  \    # Swap to push the (implicit) input
   !   # Take its factorial
    +  # Add it to each value in the list
       # (after which the entire stack is output implicitly as result)

answered Jan 18 at 7:59

Kevin Cruijssen

131k13 gold badges144 silver badges384 bronze badges

Add a comment |

l4m2 · Accepted Answer · 2024-01-18 10:43:50Z

3

JavaScript (Node.js), 52 51 47 46 45 44 bytes

f=(n,i=n)=>--n&&f(n,g=i*n)>console.log(n-~g)

Try it online!

-1 byte from Arnauld/tsh

JavaScript (Node.js), 38 bytes by Mukundan314

f=(n,i=n)=>--n?[...f(n,g=i*n),n-~g]:[]

Try it online!

edited Jan 18 at 10:43

answered Jan 18 at 0:35

l4m2

28.5k2 gold badges25 silver badges104 bronze badges

\$\begingroup\$ Comparing BigInts with Numbers is fine, so you can just do i>0. \$\endgroup\$
– Arnauld
Commented Jan 18 at 1:14
\$\begingroup\$ Maybe you need apply above comment again: f=(n,i=n)=>--n&&f(n,g=i*n)>console.log(n-~g) \$\endgroup\$
– tsh
Commented Jan 18 at 9:56
\$\begingroup\$ 38 bytes by returning a list instead of outputting to console \$\endgroup\$
– Mukundan314
Commented Jan 18 at 10:23

Add a comment |

Fmbalbuena · Accepted Answer · 2024-01-18 17:55:17Z

3

Jelly, 4 bytes

RḊ+!

Try it online!

Port of Vyxal answer.

-1 byte thanks to @emanresu A

Explanation:

RḊ+!⁡‎‎⁪⁡⁪⁠⁪⁡⁪‏⁠‎⁪⁡⁪⁠⁪⁢⁪‏‏⁡⁠⁡‌⁢‎⁪⁪⁠‎⁪⁡⁪⁠⁪⁣⁪‏⁠‎⁪⁡⁪⁠⁪⁤⁪‏‏⁡⁠⁡‌
RḊ    # ‎⁡[2 .. n]
  +!  # ‎⁢+ n!
💎

Created with the help of Luminespire.

edited Jan 18 at 17:55

answered Jan 18 at 2:23

Fmbalbuena

4,2631 gold badge10 silver badges52 bronze badges

\$\begingroup\$ 4 \$\endgroup\$
– emanresu A
Commented Jan 18 at 10:09

Add a comment |

Arnauld · Accepted Answer · 2024-01-17 23:53:31Z

2

JavaScript (V8), 46 bytes

Prints the results in reverse order.

n=>{for(p=i=n;--i;)p*=i;while(--n)print(p-~n)}

Try it online!

JavaScript (ES11), 52 bytes

With BigInts.

n=>{for(p=i=n;--i;)p*=i;while(--n)console.log(p-~n)}

Try it online!

answered Jan 17 at 23:53

Arnauld

198k20 gold badges179 silver badges650 bronze badges

\$\begingroup\$ 51 bytes for the ES11 version by using a out argument \$\endgroup\$
– Mukundan314
Commented Jan 18 at 10:34

Add a comment |

Bubbler · Accepted Answer · 2024-01-18 00:12:53Z

2

J, 7 bytes

!-<:$i:

Attempt This Online!

Returns the list of numbers in reverse order. When given a bigint, outputs the exact numbers in bigint.

!-<:$i:    input: n, a positive integer
     i:    [-n, -n+1, ..., n]
  <:       n-1
    $      take first n-1 items from the list, i.e. [-n, ..., -2]
!          n!
 -         n! - each item of [-n, ..., -2]
           == [n!+n, n!+n-1, ..., n!+2]

J, 8 bytes

!+-.{.i:

Attempt This Online!

Returns the list of numbers in the order given.

!+-.{.i:    input: n, a positive integer
      i:    [-n, -n+1, ..., n]
  -.        1-n
    {.      since 1-n is negative, take n-1 items from the end;
            [2, ..., n]
!+          add n! to each item of the list

answered Jan 18 at 0:12

Bubbler

78.4k5 gold badges149 silver badges469 bronze badges

\$\begingroup\$ I'm new to this site...and I always notice these "languages" generate really short code bytes. Are they specifically designed for code golf and how do they minimize the code so much? Thanks. \$\endgroup\$
– vengy
Commented Jan 18 at 0:17
1

\$\begingroup\$ @vengy J is not a "golflang" (language created for golf); it just happens to be short quite a lot of the time. Jelly, Vyxal, and 05AB1E are some examples of often-used golflangs, all of which minimize code by utilizing all 256 byte values (as opposed to printable ASCII) loaded with built-in functions, among other things. Jelly specifically was inspired by J, and the other two are stack-based. \$\endgroup\$
– Bubbler
Commented Jan 18 at 0:31

Add a comment |

chunes · Accepted Answer · 2024-01-18 08:39:38Z

2

Uiua ^SBCS, 9 bytes

↘1+/×.+1⇡

Try it!

answered Jan 18 at 8:39

chunes

26.8k3 gold badges24 silver badges53 bronze badges

1

\$\begingroup\$ Seems there are many ways \$\endgroup\$
– Tbw
Commented Jan 18 at 22:17

Add a comment |

Kjetil S · Accepted Answer · 2024-01-18 16:14:00Z

2

Perl 5, 41 bytes

sub{@a=1..pop;$"='*';map$_+1+eval"@a",@a}

Try it online!

edited Jan 18 at 16:14

answered Jan 17 at 23:37

Kjetil S

6,12110 silver badges22 bronze badges

Add a comment |

camelCasedSnivy · Accepted Answer · 2024-01-19 04:19:20Z

2

dc, 56 54 bytes

[dlf*sf1-d0!=q]sq1sf?d1-sm[dlf2++p0=m1+dlm!=e]selqxlex

Try it online!

This solution isn't the most optimized, you could probably use less registers than I did here.

edited Jan 19 at 4:19

answered Jan 18 at 15:39

camelCasedSnivy

3214 bronze badges

Add a comment |

Gábor Fekete · Accepted Answer · 2024-01-19 11:59:19Z

2

Python 3.8 (pre-release), 69 62 bytes

lambda n:[i-~math.factorial(n)for i in range(1,n)]
import math

Try it online!

Edit: changed math.prod to math.factorial, thanks to @l4m2

edited Jan 19 at 11:59

answered Jan 18 at 13:53

Gábor Fekete

3,4671 gold badge9 silver badges19 bronze badges

\$\begingroup\$ If you're going to be importing math, then you might as well use math.factorial \$\endgroup\$
– qwr
Commented Jan 18 at 19:52
\$\begingroup\$ can you show me a shorter solution using math.factorial ? \$\endgroup\$
– Gábor Fekete
Commented Jan 19 at 8:40
2

\$\begingroup\$ 62 \$\endgroup\$
– l4m2
Commented Jan 19 at 11:31
\$\begingroup\$ No for-loop needed. Cf. @Albert.Lang's answer. \$\endgroup\$
– loopy walt
Commented Jan 19 at 13:55

Add a comment |

z.. · Accepted Answer · 2024-02-01 10:58:53Z

2

Google Sheets, 32 bytes

=SORT(FACT(A1)+SEQUENCE(A1-1)+1)

answered Feb 1 at 10:58

z..

1,2411 gold badge1 silver badge11 bronze badges

Add a comment |

MaroonSphinx · Accepted Answer · 2024-07-31 05:27:54Z

2

Haskell, 29 bytes

f n=map(product[2..n]+)[2..n]

Try it online

edited Jul 31 at 5:27

answered Jul 31 at 2:06

MaroonSphinx

713 bronze badges

1

\$\begingroup\$ Welcome to Code Golf, and nice first answer! You might want to add a Try it online link so others can test your code. \$\endgroup\$
– emanresu A
Commented Jul 31 at 3:08

Add a comment |

vengy · Accepted Answer · 2024-01-17 23:49:20Z

1

C (gcc), 170 bytes

Using The GNU Multiple Precision Arithmetic Library

f(n){mpz_t f,t;mpz_init(f);mpz_init(t);mpz_set_ui(f,1);for(int i=1;i<=n;mpz_mul_ui(f,f,i++));for(int i=2;i<=n;mpz_add_ui(t,f,i),mpz_out_str(stdout,10,t),puts(""),i++);}

Try it online!

edited Jan 17 at 23:49

answered Jan 17 at 23:10

vengy

2,2797 silver badges30 bronze badges

\$\begingroup\$ I think you must include both #includes in source unfortunately \$\endgroup\$
– AZTECCO
Commented Jan 18 at 5:50
2

\$\begingroup\$ 150 bytes \$\endgroup\$
– ceilingcat
Commented Jan 18 at 7:51

Add a comment |

138 Aspen · Accepted Answer · 2024-01-18 02:18:44Z

1

Scala 3, 55 bytes

n=>{val a=(1 to n).map(BigInt(_));a.map(_+1+a.product)}

Attempt This Online!

answered Jan 18 at 2:18

138 Aspen

6,6271 gold badge4 silver badges13 bronze badges

Add a comment |

alephalpha · Accepted Answer · 2024-01-18 09:24:17Z

1

PARI/GP, 15 bytes

n->[n!+2..n!+n]

Attempt This Online!

answered Jan 18 at 9:24

alephalpha

50k7 gold badges68 silver badges182 bronze badges

Add a comment |

ZaMoC · Accepted Answer · 2024-01-18 09:44:33Z

1

Wolfram Language (Mathematica), 13 bytes

#!+2~Range~#&

Try it online!

answered Jan 18 at 9:44

ZaMoC

24.9k2 gold badges30 silver badges81 bronze badges

\$\begingroup\$ does wolfram alpha have a similar formula? thanks \$\endgroup\$
– vengy
Commented Jan 18 at 12:05
\$\begingroup\$ @vengy you can use something like 21!+k for k=2..21 \$\endgroup\$
– ZaMoC
Commented Jan 18 at 15:27
\$\begingroup\$ That example worked nicely. Thanks! \$\endgroup\$
– vengy
Commented Jan 18 at 15:44
\$\begingroup\$ Actually this works too: 21!+k,k=2..21 \$\endgroup\$
– vengy
Commented Jan 18 at 15:55
\$\begingroup\$ @vengy or 21!+{2..21} \$\endgroup\$
– ZaMoC
Commented Jan 18 at 16:25

| Show 3 more comments

Neil · Accepted Answer · 2024-01-18 10:00:52Z

1

Retina, 43 bytes

.+
*
v`__+
$.&$*
L$`\d+
$$.($&*_$=
%~`^
.+¶

Try it online! Outputs the numbers in descending order. Explanation:

.+
*

Convert n to unary.

v`__+
$.&$*

Create an expression n*...*3*2* that evaluates to n! in unary.

L$`\d+
$$.($&*_$=

For each integer in that expression, create an expression that adds i and converts to decimal.

%~`^
.+¶

Evaluate each resulting expression.

answered Jan 18 at 10:00

Neil

177k12 gold badges74 silver badges281 bronze badges

Add a comment |

Neil · Accepted Answer · 2024-01-18 14:41:45Z

Charcoal, 11 bytes

≔…·²ＮθＩ⁺θΠθ

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

≔…·²Ｎθ

Create a list from 2 up to n inclusive.

Ｉ⁺θΠθ

Vectorised add the list to its product.

Of course, the given formula is just an existence proof and there are usually lower runs. For instance, the LCM is readily proven to produce a run:

Ｎθ≔…·²θηＷ⌈﹪±θη≧⁺ιθＩ⁺θη

Try it online! Link is to verbose version of code. Or more efficiently:

Ｎθ≔…·²θηＦη≔⌊Φ×⊖ηθ¬﹪κιθＩ⁺θη

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

Kevin Cruijssen · Accepted Answer · 2024-01-19 07:56:18Z

Java 10, 134 131 bytes

n->{var f=n.ONE;int N=n.intValue(),i=N;for(;i>1;)f=f.multiply(n.valueOf(i--));for(;i++<N;)System.out.println(f.add(n.valueOf(i)));}

-3 bytes thanks to @ceilingcat.

Input as a BigInteger, outputs on separated lines to STDOUT.

Try it online.

Explanation:

n->{                            // Method with BigInteger as parameter and no return:
  var f=n.ONE;                  //  Start `f` with BigInteger 1
  int N=n.intValue(),           //  Set `N` to the input-BigInteger as integer
  i=N;for(;i>1;)                //  Loop `i` in the range [N,1):
    f=f.multiply(n.valueOf(i)); //   Multiply `f` by `i`
  for(;i++<N;)                  //  Loop `i` again, this time in the range (1,N]:
    System.out.println(         //   Print with trailing newline:
      f.add(n.valueOf(i)));}    //    `f` + `i`

Bubbler · Accepted Answer · 2024-01-21 23:43:47Z

Labyrinth, 30 bytes

?:}  @\!
 (:{+ ""
*; :=;;
#(;)

Try it online!

Introducing "small-loop-oriented programming" ;)

?    program start; take n from stdin
     let's say n = 4
     [ 4 | ]

:}   run in the order of :(:}
(:   : dup               [ 4 4 | ]
     ( decrement         [ 4 3 | ]
     : dup               [ 4 3 3 | ]
     } move to aux.stack [ 4 3 | 3 ]
     loop until the top is 0 after `decrement`
     [ 4 3 2 1 0 | 1 2 3 ]

*;   run in the order of ;*#(
#(   ; drop         [ 4 3 2 1 | 1 2 3 ]
     * mul          [ 4 3 2 | 1 2 3 ]
     # stack height [ 4 3 2 3 | 1 2 3 ]
     ( decrement    [ 4 3 2 2 | 1 2 3 ]
     loop until the top is 0 after `decrement`, i.e. stack height is 1
     [ 24 0 | 1 2 3 ]

;)   drop 0, and increment the factorial
     [ 25 | 1 2 3 ]

{+   run in the order of :=+{
:=   : dup                 [ 25 25 | 1 2 3 ]
     = swap the tops       [ 25 1 | 25 2 3 ]
     + add                 [ 26 | 25 2 3 ]
     { move from aux.stack [ 26 25 | 2 3 ]
     loop until the top is 0 after `swap the tops`
     [ 26 27 28 25 0 | 25 ]

;;   drop twice [ 26 27 28 | 25 ]

\!   run in the order of ""!\  (" is no-op)
""   ! pop and print as num
     \ print a newline
     loop until the top is zero, i.e. there is nothing left to print

@    end the program

Shaggy · Accepted Answer · 2024-07-30 22:00:16Z

1

Japt, 6 bytes

ò2È+UÊ

Try it here

answered Jul 30 at 22:00

Shaggy

43.5k4 gold badges36 silver badges94 bronze badges

Add a comment |

bb94 · Accepted Answer · 2024-07-31 06:17:36Z

1

Raku (Perl 6) (rakudo), 19 bytes

{2..$_ X+[*] 1..$_}

Attempt This Online!

answered Jul 31 at 6:17

bb94

3,70814 silver badges19 bronze badges

Add a comment |

Consecutive Composite Numbers

Challenge

Example

Rules

Test Cases

28 Answers 28

APL(Dyalog Unicode), 5 bytes SBCS

Explanation

6 bytes, outputs full numbers under \$10^{34}\$

Python, 51 bytes

Original Python, 56 bytes

Vyxal, 4 bytes

Funge-98, 29 bytes

Desmos, 15 bytes

Jelly, 3 bytes

How?

05AB1E, 5 bytes

MathGolf, 5 bytes

JavaScript (Node.js), 52 51 47 46 45 44 bytes

JavaScript (Node.js), 38 bytes by Mukundan314

Jelly, 4 bytes

JavaScript (V8), 46 bytes

JavaScript (ES11), 52 bytes

J, 7 bytes

J, 8 bytes

Uiua SBCS, 9 bytes

Perl 5, 41 bytes

dc, 56 54 bytes

Python 3.8 (pre-release), 69 62 bytes

Google Sheets, 32 bytes

Haskell, 29 bytes

C (gcc), 170 bytes

Scala 3, 55 bytes

PARI/GP, 15 bytes

Wolfram Language (Mathematica), 13 bytes

Retina, 43 bytes

Charcoal, 11 bytes

Java 10, 134 131 bytes

Labyrinth, 30 bytes

Japt, 6 bytes

Raku (Perl 6) (rakudo), 19 bytes

Your Answer

Sign up or log in

Post as a guest

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

Linked

Related

Hot Network Questions

APL(Dyalog Unicode), 5 bytes ^SBCS

Uiua ^SBCS, 9 bytes

Not the answer you're looking for? Browse other questions tagged
code-golf
math
number-theory
or ask your own question.