I'm surprised that this challenge isn't already here, as it's so obvious. (Or I'm surprised I couldn't find it and anybody will mark it as a duplicate.)


Given a non-negative integer \$n\$, calculate the sum of the first \$n\$ primes and output it.

Example #1

For \$n = 5\$, the first five primes are:

  • 2
  • 3
  • 5
  • 7
  • 11

The sum of these numbers is \$2 + 3 + 5 + 7 + 11 = 28\$, so the program has to output \$28\$.

Example #2

For \$n = 0\$, the "first zero" primes are none. And the sum of no numbers is - of course - \$0\$.


  • You may use built-ins, e.g., to check if a number is prime.
  • This is , so the lowest number of bytes in each language wins!

35 Answers 35


6502 machine code routine, 75 bytes

A0 01 84 FD 88 84 FE C4 02 F0 32 E6 FD A0 00 A5 FD C9 04 90 1F 85 64 B1 FB 85
65 A9 00 A2 08 06 64 2A C5 65 90 02 E5 65 CA D0 F4 C9 00 F0 DC C8 C4 FE D0 DB
A5 FD A4 FE 91 FB C8 D0 C8 A9 00 18 A8 C4 FE F0 05 71 FB C8 D0 F7 60

Expects a pointer to some temporary storage in $fb/$fc and the number of primes to sum up in $2. Returns the sum in A (the accu register).

Never did some prime checks in 6502 machine code, so here it finally comes ;)

Note this starts giving wrong results for inputs >= 14. This is because of overflow, the code works with the "natural" number range of the 8bit platform which is 0 - 255 for unsigned.

Commented disassembly

; function to sum the first n primes
; input:
;   $fb/$fc: pointer to a buffer for temporary storage of primes
;   $2:      number of primes to sum (n)
; output:
;   A:       sum of the first n primes
; clobbers:
;   $fd:     current number under primality test
;   $fe:     number of primes currently found
;   $64:     temporary numerator for modulo check
;   $65:     temporary divisor for modulo check
;   X, Y
A0 01       LDY #$01            ; init variable for ...
84 FD       STY $FD             ; next prime number to test
88          DEY                 ; init number of found primes
84 FE       STY $FE             ; store current number of found primes
C4 02       CPY $02             ; compare with requested number
F0 32       BEQ .sum            ; enough primes -> calculate their sum
E6 FD       INC $FD             ; check next prime number
A0 00       LDY #$00            ; start check against first prime number
A5 FD       LDA $FD             ; load current number to check
C9 04       CMP #$04            ; smaller than 4?
90 1F       BCC .isprime        ; is a prime (shortcut to get list started)
85 64       STA $64             ; store to temp as numerator
B1 FB       LDA ($FB),Y         ; load from prime number table
85 65       STA $65             ; store to temp as divisor
A9 00       LDA #$00            ; init modulo to 0
A2 08       LDX #$08            ; iterate over 8 bits
06 64       ASL $64             ; shift left numerator
2A          ROL A               ; shift carry into modulo
C5 65       CMP $65             ; compare with divisor
90 02       BCC .bitnext        ; smaller -> to next bit
E5 65       SBC $65             ; otherwise subtract divisor
CA          DEX                 ; next bit
D0 F4       BNE .bitloop
C9 00       CMP #$00            ; compare modulo with 0
F0 DC       BEQ .mainnext       ; equal? -> no prime number
C8          INY                 ; next index in prime number table
C4 FE       CPY $FE             ; checked against all prime numbers?
D0 DB       BNE .primecheckloop ; no -> check next
A5 FD       LDA $FD             ; prime found
A4 FE       LDY $FE             ; then store in table
91 FB       STA ($FB),Y
C8          INY                 ; increment number of primes found
D0 C8       BNE .mainloop       ; and repeat whole process
A9 00       LDA #$00            ; initialize sum to 0
18          CLC
A8          TAY                 ; start adding table from position 0
C4 FE       CPY $FE             ; whole table added?
F0 05       BEQ .done           ; yes -> we're done
71 FB       ADC ($FB),Y         ; add current entry
C8          INY                 ; increment index
D0 F7       BNE .sumloop        ; and repeat
60          RTS

Example C64 assembler program using the routine:

Online demo

Code in ca65 syntax:

.import primesum   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

linebuf:        .res    4               ; maximum length of a valid unsigned
                                        ; 8-bit number input
convbuf:        .res    3               ; 3 BCD digits for unsigned 8-bit
                                        ; number conversion
primebuf:       .res    $100            ; buffer for primesum function

prompt:         .byte   "> ", $0
errmsg:         .byte   "Error parsing number, try again.", $d, $0

                lda     #$17            ; set upper/lower mode
                sta     $d018

                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #4
                jsr     readline

                lda     linebuf         ; empty line?
                beq     input           ; try again

                lda     #<linebuf       ; convert input to int8
                ldy     #>linebuf
                jsr     touint8
                bcc     numok           ; successful -> start processing
                lda     #<errmsg        ; else show error message and repeat
                ldy     #>errmsg
                jsr     $ab1e
                bcs     input

                sta     $2
                lda     #<primebuf
                sta     $fb
                lda     #>primebuf
                sta     $fc
                jsr     primesum        ; call function to sum primes
                tax                     ; and ...
                lda     #$0             ; 
                jmp     $bdcd           ; .. print result

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key

; parse / convert uint8 number using a BCD representation and double-dabble
.proc touint8
                sta     $fb
                sty     $fc
                ldy     #$0
                sty     convbuf
                sty     convbuf+1
                sty     convbuf+2
scanloop:       lda     ($fb),y
                beq     copy
                cmp     #$20
                beq     scanloop
                cmp     #$30
                bcc     error
                cmp     #$3a
                bcs     error
                bcc     scanloop
error:          sec
copy:           dey
                bmi     error
                ldx     #$2
copyloop:       lda     ($fb),y
                cmp     #$30
                bcc     copynext
                cmp     #$3a
                bcs     copynext
                sbc     #$30
                sta     convbuf,x
copynext:       dey
                bpl     copyloop
                lda     #$0
                sta     $fb
                ldx     #$8
loop:           lsr     convbuf
                lda     convbuf+1
                bcc     skipbit1
                ora     #$10
skipbit1:       lsr     a
                sta     convbuf+1
                lda     convbuf+2
                bcc     skipbit2
                ora     #$10
skipbit2:       lsr     a
                sta     convbuf+2
                ror     $fb
                beq     done
                lda     convbuf
                cmp     #$8
                bmi     nosub1
                sbc     #$3
                sta     convbuf
nosub1:         lda     convbuf+1
                cmp     #$8
                bmi     nosub2
                sbc     #$3
                sta     convbuf+1
nosub2:         lda     convbuf+2
                cmp     #$8
                bmi     loop
                sbc     #$3
                sta     convbuf+2
                bcs     loop
done:           lda     $fb
  • 4
    \$\begingroup\$ I enjoy this so much more than the constant stream of golfing languages (I may or may not be wearing a MOS 6502 t-shirt today). \$\endgroup\$
    – Matt Lacey
    Aug 8, 2018 at 1:55
  • 1
    \$\begingroup\$ @MattLacey thanks :) I'm just too lazy to learn all these languages ... and doing some puzzles in 6502 code feels kind of "natural" because saving space is actually a standard programming practice on that chip :) \$\endgroup\$ Aug 8, 2018 at 6:01
  • \$\begingroup\$ I need to buy a MOS 6502 T-Shirt. \$\endgroup\$
    – Titus
    Aug 8, 2018 at 11:52

Python 2, 49 bytes

f=lambda n,t=1,p=1:n and p%t*t+f(n-p%t,t+1,p*t*t)

Uses Wilson's theorem, (as introduced to the site by xnor, I believe here)

Try it online!

The function f is recursive, with an initial input of n and a tail when n reaches zero, yielding that zero (due to the logical and); n is decremented whenever t, a test number which increments with every call to f, is prime. The prime test is then whether \$(n-1)!\ \equiv\ -1 \pmod n\$ for which we keep a track of a square of the factorial in p.

  • \$\begingroup\$ I was adapting one of Lynn's common helper functions and achieved the exact same thing. \$\endgroup\$
    – Mr. Xcoder
    Aug 7, 2018 at 8:14
  • \$\begingroup\$ ...ah so the theorem was introduced to the site by xnor. Good reference post, thanks! \$\endgroup\$ Aug 7, 2018 at 8:30

Jelly, 4 bytes

My first Jelly program


Try it online!

  • 2
    \$\begingroup\$ Nice, note that ÆN€S would also do it. \$\endgroup\$ Aug 7, 2018 at 12:33

05AB1E, 3 bytes


Try it online.


Åp     # List of the first N primes (N being the implicit input)
       #  i.e. 5 → [2,3,5,7,11]
  O    # Sum of that list
       #  i.e. [2,3,5,7,11] → 28

Java 8, 89 bytes

n->{int r=0,i=2,t,x;for(;n>0;r+=t>1?t+0*n--:0)for(t=i++,x=2;x<t;t=t%x++<1?0:t);return r;}

Try it online.


n->{               // Method with integer as both parameter and return-type
  int r=0,         //  Result-sum, starting at 0
      i=2,         //  Prime-integer, starting at 2
      t,x;         //  Temp integers
  for(;n>0         //  Loop as long as `n` is still larger than 0
      ;            //    After every iteration:
       r+=t>1?     //     If `t` is larger than 1 (which means `t` is a prime):
           t       //      Increase `r` by `t`
           +0*n--  //      And decrease `n` by 1
          :        //     Else:
           0)      //      Both `r` and `n` remain the same
    for(t=i++,     //   Set `t` to the current `i`, and increase `i` by 1 afterwards
        x=2;       //   Set `x` to 2
        x<t;       //   Loop as long as `x` is still smaller than `t`
      t=t%x++<1?   //    If `t` is divisible by `x`:
         0         //     Set `t` to 0
        :          //    Else:
         t);       //     `t` remains the same
                   //   If `t` is still the same after this loop, it means it's a prime
  return r;}       //  Return the result-sum

Perl 6, 31 bytes

{sum grep(&is-prime,2..*)[^$_]}

Try it online!

The is-prime built-in is unfortunately long.


J, 8 bytes


Try it online!


Brachylog, 8 7 bytes


Try it online!

Saved 1 byte thanks to @sundar.


~l        Create a list of length input
  ṗᵐ      Each element of the list must be prime
    ≠     All elements must be distinct
     ≜    Find values that match those constraints
      +   Sum
  • \$\begingroup\$ ~lṗᵐ≠≜+ seems to work, for 7 bytes (Also, I'm curious why it gives output 2*input+1 if run without the labeling.) \$\endgroup\$
    – Sundar R
    Aug 7, 2018 at 8:59
  • 2
    \$\begingroup\$ @sundar I checked using the debugger and found why: it doesn't choose values for the primes, but it still knows that every single one must be in [2,+inf) obviously. Therefore, it knows that the sum of 5 primes (if the input is 5) must be at least 10, and it partially knows that because the elements must be different, they can't all be 2 so it's at least 11. TL;DR implementation of implicit labellization isn't strong enough. \$\endgroup\$
    – Fatalize
    Aug 7, 2018 at 9:16
  • \$\begingroup\$ That's very interesting. I like how the reason is not some quirk of syntax or random accident of implementation, but something that makes sense based on the constraints. Thanks for checking it out! \$\endgroup\$
    – Sundar R
    Aug 8, 2018 at 14:57

Husk, 4 bytes


Try it online!

Generates the İnfinite list of prime numbers, and computes the sum of the first \$N\$ (Σ↑)

  • \$\begingroup\$ I believe it's İnteger sequence, İ€ is finite. \$\endgroup\$ Aug 8, 2018 at 23:56

Attache, 10 bytes


Try it online!

ho hum


Retina, 41 bytes



Try it online! I wanted to keep adding 1 until I had found n primes but I couldn't work out how to do that in Retina so I resorted to a nested loop. Explanation:


Start with 1.


Loop n times.


Make a copy of the previous value, and increment it.


Keep incrementing it while it's composite. (The ) closes the outer loop.)


Delete the original 1.


Sum and convert to decimal.


MATL, 4 bytes


Try it online!


       % Implicit input: 5
:      % Range: [1, 2, 3, 4, 5]
 Yq    % The n'th primes: [2, 3, 5, 7, 11]
   s   % Sum: 28

PHP, 66 bytes

using my own prime function again ...


Run as pipe with -nr or try it online.


for(;$k<$argn;      # while counter < argument
    $i-1||              # 3. if divisor is 1 (e.g. $n is prime)
        $s+=$n              # add $n to sum
        +!++$k              # and increment counter
    for($i=++$n;        # 1. increment $n
        --$i&&$n%$i;);  # 2. find largest divisor of $n smaller than $n:
echo$s;             # print sum
  • \$\begingroup\$ same length, one variable less: for(;$argn;$i-1||$s+=$n+!$argn--)for($i=++$n;--$i&&$n%$i;);echo$s; \$\endgroup\$
    – Titus
    Nov 16, 2018 at 15:27

Haskell, 48 bytes

sum.(`take`[p|p<-[2..],all((>0).mod p)[2..p-1]])

Try it online!

Note: \p-> all((>0).mod p)[2..p-1] is not a valid prime check, since it is True for \$0,1\$ as well. But we can work around that by beginning with \$2\$, so in this case it suffices.


C (gcc), 70 bytes

f(n,i,j,s){s=0;for(i=2;n;i++)for(j=2;j/i?s+=i,n--,0:i%j++;);return s;}

Try it online!

  • \$\begingroup\$ Suggest n=s instead of return s \$\endgroup\$
    – ceilingcat
    Aug 14, 2018 at 21:57

C, C++, D : 147 142 bytes

int p(int a){if(a<4)return 1;for(int i=2;i<a;++i)if(!(a%i))return 0;return 1;}int f(int n){int c=0,v=1;while(n)if(p(++v)){c+=v;--n;}return c;}

5 bytes optimization for C and C++ :

-2 bytes thanks to Zacharý

#define R return
int p(int a){if(a<4)R 1;for(int i=2;i<a;++i)if(!(a%i))R 0;R 1;}int f(int n){int c=0,v=1;while(n)if(p(++v))c+=v,--n;R c;}

p tests if a number is a prime, f sums the n first numbers

Code used to test :

C/C++ :

for (int i = 0; i < 10; ++i)
    printf("%d => %d\n", i, f(i));

D Optimized answer by Zacharý, 133 131 bytes

D has a golfy template system

T p(T)(T a){if(a<4)return 1;for(T i=2;i<a;)if(!(a%i++))return 0;return 1;}T f(T)(T n){T c,v=1;while(n)if(p(++v))c+=v,--n;return c;}
  • 1
    \$\begingroup\$ T p(T)(T a){if(a<4)return 1;for(T i=2;i<a;)if(!(a%i++))return 0;return 1;}T f(T)(T n){T c,v=1;while(n)if(p(++v)){c+=v;--n;}return c;}. Also, the C/C++/D can be int p(int a){if(a<4)return 1;for(int i=2;i<a;++i)if(!(a%i))return 0;return 1;}int f(int n){int c=0,v=1;while(n)if(p(++v)){c+=v;--n;}return c;} (same with the C/C++ optimization, just adjusting the algorithm abit) \$\endgroup\$
    – Adalynn
    Nov 10, 2018 at 2:32
  • \$\begingroup\$ Maybe for all the answers, you could use comma to make {c+=v;--n;} be c+=v,--n;? \$\endgroup\$
    – Adalynn
    Nov 12, 2018 at 15:07
  • \$\begingroup\$ Here's another one for D (and possibly for C/C++ as well, if reverted back to ints): T p(T)(T a){T r=1,i=2;for(;i<a;)r=a%i++?r:0;return r;}T f(T)(T n){T c,v=1;while(n)if(p(++v))c+=v,--n;return c;} \$\endgroup\$
    – Adalynn
    Nov 12, 2018 at 16:18
  • \$\begingroup\$ Suggest a>3&i<a instead of i<a and remove if(a<4)... \$\endgroup\$
    – ceilingcat
    Nov 20, 2018 at 17:17

Japt -x, 11 bytes


Try it online!

Saved several bytes thanks to a new language feature.


;@      }hA    :Get the first n numbers in the sequence:
     a         : Get the smallest number
      °X       : Which is greater than the previous result
  _j}          : And is prime
               :Implicitly output the sum

JavaScript (ES6), 55 bytes


Try it online!


Stax, 6 bytes


Run and debug it


r{|6m|+ Unpacked program, implicit input
r       0-based range
 {  m   Map:
  |6      n-th prime (0-based)
     |+ Sum
        Implicit output

APL (Dyalog Unicode), 7 + 9 = 16 bytes


Try it online!

9 additional bytes to import the pco (and every other) Dfn: ⎕CY'dfns'


      ⍳ ⍝ Generate the range from 1 to the argument
     ∘  ⍝ Compose
  pco   ⍝ P-colon (p:); without a left argument, it generates the first <right_arg> primes.
+/      ⍝ Sum
  • \$\begingroup\$ Don't you have to add yet another byte? import X (newline) X.something() in python is counted with the newline. \$\endgroup\$
    – Adalynn
    Aug 14, 2018 at 22:06

Ruby, 22 + 7 = 29 bytes

Run with ruby -rprime (+7)


Pari/GP, 20 bytes


Try it online!


JAEL, 5 bytes


Explanation (generated automatically):

./jael --explain '#&kȦ'

Ȧ => .a!


#     ,                 repeat (p1) times:
 &                              push number of iterations of this loop
  k                             push nth prime
   .                            push the value under the tape head
    a                           push p1 + p2
     !                          write p1 to the tape head
       ␄                print machine state

Reticular, 52 40 bytes


Try it online!


Fun fact: Reticular does not count 2 as a prime number, so the instruction @P which gives the \$n\$-th prime in reality gives the \$(n+1)\$-th prime and due to this we have to add the first prime 2 manually.

in           # Read input and convert to int
dQ2j;o_      # Check if input is 0. If so, output and exit
1-2~d:^=     # Subtract 1 from input and save it as  `^`
[d@P~1-]     # Duplicate the top of the stack (call it k)
               and push the k-th prime. Finally swap the two top items
               in the stack and subtract 1.
               Stack before: [k]
               Stack after: [k-1, k-th prime]
:^`*         # Repeat the above a `^` number of times. 
               Stack before: [n]
               Stack after: [0, 3, 5, ...,  n-th prime, 2]
[+]:^`1+*    # Add the two top items in the stack a
               total of (`^`+1) number of times
o;           # Output the sum and exit.

Vyxal, 2 bytes, s


Try it!


ʁ  # Range from 0 to input
ǎ  # Map to a_th prime

At last, sum with s flag

Disclaimer: my first Vyxal answer

  • \$\begingroup\$ There's a bounty coming your way in around 48 hours! \$\endgroup\$
    – lyxal
    Apr 16, 2021 at 5:25
  • \$\begingroup\$ @user many thanks for the bounty!!!! \$\endgroup\$
    – Wasif
    Apr 16, 2021 at 12:04
  • \$\begingroup\$ s flag is cheaty :( \$\endgroup\$
    – rak1507
    Apr 16, 2021 at 12:28

Python 2, 63 59 56 51 bytes

f=lambda n:n and prime(n)+f(n-1)
from sympy import*

Try it online!


  • -5 bytes, thanks to Jonathan Allan

Without libs:

Python 2, 83 bytes

while n:
 if all(x%i for i in range(2,x)):n-=1;s+=x
print s

Try it online!

  • \$\begingroup\$ f=lambda n:n and prime(n)+f(n-1) saves five (it might be golfable further too) \$\endgroup\$ Aug 7, 2018 at 7:24

Pyke, 4 bytes


Try it here!

~p   -   prime_numbers
  >  -  first_n(^, input)
   s - sum(^)

CJam, 21 bytes


0{{T1+:Tmp!}gT}li*]:+ Original code

 {            }li*    Repeat n times
  {        }          Block
   T                  Get variable T | stack: T
    1+                Add one | Stack: T+1 
      :T              Store in variable T | Stack: T+1
        mp!           Is T not prime?     | Stack: !(isprime(T))
            g         Do while condition at top of stack is true, pop condition
             T        Push T onto the stack | Stack: Primes so far
0                 ]   Make everything on stack into an array, starting with 0 (to not throw error if n = 0)| Stack: array with 0 and all primes up to n
                   :+ Add everything in array

Try it online!


F#, 111 bytes

let f n=Seq.initInfinite id|>Seq.filter(fun p->p>1&&Seq.exists(fun x->p%x=0){2..p-1}|>not)|>Seq.take n|>Seq.sum

Try it online!

Seq.initInfinite creates an infinitely-long sequence with a generator function which takes, as a parameter, the item index. In this case the generator function is just the identity function id.

Seq.filter selects only the numbers created by the infinite sequence that are prime.

Seq.take takes the first n elements in that sequence.

And finally, Seq.sum sums them up.


cQuents, 3 bytes


Try it online!


;    sum of first n terms for input n
 pz  each term is the next prime after the previous term
  • \$\begingroup\$ Note current version uses Z instead of z \$\endgroup\$
    – Stephen
    Feb 1, 2019 at 4:50

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.