Calculate the sum of the first n prime numbers

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\$$.

Rules

• 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!

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
.primesum:
A0 01       LDY #$01 ; init variable for ... 84 FD STY$FD             ; next prime number to test
88          DEY                 ; init number of found primes
.mainloop:
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
.mainnext:
E6 FD       INC $FD ; check next prime number A0 00 LDY #$00            ; start check against first prime number
.primecheckloop:
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 .bitloop: 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
.bitnext:
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
.isprime:
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 .sum: A9 00 LDA #$00            ; initialize sum to 0
18          CLC
A8          TAY                 ; start adding table from position 0
.sumloop:
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
.done:
60          RTS


Example C64 assembler program using the routine:

Online demo

Code in ca65 syntax:

.import primesum   ; link with routine above

.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 .bss 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

.data
prompt:         .byte   "> ", $0 errmsg: .byte "Error parsing number, try again.",$d, $0 .code lda #$17            ; set upper/lower mode
sta     $d018 input: lda #<prompt ; display prompt ldy #>prompt jsr$ab1e

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

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 numok: 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
dex
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 .endproc ; 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 iny cmp #$20
beq     scanloop
cmp     #$30 bcc error cmp #$3a
bcs     error
bcc     scanloop
error:          sec
rts
copy:           dey
bmi     error
ldx     #$2 copyloop: lda ($fb),y
cmp     #$30 bcc copynext cmp #$3a
bcs     copynext
sec
sbc     #$30 sta convbuf,x dex 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 dex 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
clc
rts
.endproc

• 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). Commented Aug 8, 2018 at 1:55
• @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 :) Commented Aug 8, 2018 at 6:01
• I need to buy a MOS 6502 T-Shirt. Commented 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.

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

Jelly, 4 bytes

My first Jelly program

RÆNS


Try it online!

• Nice, note that ÆN€S would also do it. Commented Aug 7, 2018 at 12:33

Java 8, 89 78 bytes

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


Try it online.

Explanation:

n->{               // Method with integer as both parameter and return-type
int r=0,         //  Result-sum, starting at 0
i=2,         //  Iteration-integer, starting at 2
t,p;         //  Temp integers
for(;n>0         //  Loop as long as n is still larger than 0:
;            //    After every iteration:
r+=t<2?     //     If t is 1 (which means p is a prime):
p       //      Increase r by p
+0*n--  //      And decrease n by 1
:        //     Else:
0)      //      Both r and n remain the same
for(p=t=i++;   //   Set both p and t to the current i,
//   and increase i by 1 afterwards with i++
p%--t>0;); //   Decrease t by 1 before every iteration with --t,
//   and continue looping as long as p is NOT divisible by t
return r;}       //  Return the result-sum


05AB1E, 3 bytes

ÅpO


Try it online.

Explanation:

Å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


Perl 6, 31 bytes

{sum grep(&is-prime,2..*)[^$_]}  Try it online! The is-prime built-in is unfortunately long. J, 8 bytes 1#.p:@i.  Try it online! Brachylog, 8 7 bytes ~lṗᵐ≠≜+  Try it online! Saved 1 byte thanks to @sundar. Explanation ~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  • ~lṗᵐ≠≜+ seems to work, for 7 bytes (Also, I'm curious why it gives output 2*input+1 if run without the labeling.) Commented Aug 7, 2018 at 8:59 • @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. Commented Aug 7, 2018 at 9:16 • 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! Commented Aug 8, 2018 at 14:57 Husk, 4 bytes Σ↑İp  Try it online! Generates the İnfinite list of prime numbers, and computes the sum of the first $N$ (Σ↑) • I believe it's İnteger sequence, İ€ is finite. Commented Aug 8, 2018 at 23:56 Attache, 10 bytes Sum@Primes  Try it online! ho hum Retina, 41 bytes K_ "$+"{%"_
)/¶(__+)\1+$/+$
_
^_

_


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:

K_


"$+"{  Loop n times. $
$%"_  Make a copy of the previous value, and increment it. )/¶(__+)\1+$/+$_  Keep incrementing it while it's composite. (The ) closes the outer loop.) ^_  Delete the original 1. _  Sum and convert to decimal. MATL, 4 bytes :Yqs  Try it online! Explanation:  % Implicit input: 5 : % Range: [1, 2, 3, 4, 5] Yq % The n'th primes: [2, 3, 5, 7, 11] s % Sum: 28  Ruby, 22 + 7 = 29 bytes Run with ruby -rprime (+7) ->n{Prime.take(n).sum}  PHP, 66 bytes using my own prime function again ... for(;$k<$argn;$i-1||$s+=$n+!++$k)for($i=++$n;--$i&&$n%$i;);echo$s;  Run as pipe with -nr or try it online. breakdown 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

• same length, one variable less: for(;$argn;$i-1||$s+=$n+!$argn--)for($i=++$n;--$i&&$n%$i;);echo$s; Commented 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. Pari/GP, 20 bytes n->vecsum(primes(n))  Try it online! 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! • Suggest n=s instead of return s Commented 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;}  • 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) Commented Nov 10, 2018 at 2:32 • Maybe for all the answers, you could use comma to make {c+=v;--n;} be c+=v,--n;? Commented Nov 12, 2018 at 15:07 • 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;} Commented Nov 12, 2018 at 16:18 • Suggest a>3&i<a instead of i<a and remove if(a<4)... Commented Nov 20, 2018 at 17:17 Japt-x, 11 bytes ;@_j}a°X}hA  Try it online! Saved several bytes thanks to a new language feature. Explanation: ;@ }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  Factor + math.primes math.unicode, 14 bytes [ nprimes Σ ]  Try it online! Explanation: It's a quotation (anonymous function) that takes an integer as input and leaves an integer as output. • nprimes Obtain a list of the first n primes. • Σ Sum the list. D, 106 bytes T f(T)(T n){T p(T a){T b=1;for(T i=2;i<a;)b*=a%i++;return b;}T c,v=1;while(n)if(p(++v))c+=v,--n;return c;}  Try it online! Based on my previous revisions to HatsuPointerKun's C++ answer. JavaScript (ES6), 55 bytes f=(k,n=2)=>k&&(g=d=>n%--d?g(d):d<2&&k--&&n)(n)+f(k,n+1)  Try it online! Stax, 6 bytes ê☺Γ☼èY  Run and debug it Explanation: 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 +/pco∘⍳  Try it online! 9 additional bytes to import the pco (and every other) Dfn: ⎕CY'dfns' How: +/pco∘⍳ ⍳ ⍝ 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  • Don't you have to add yet another byte? import X (newline) X.something() in python is counted with the newline. Commented Aug 14, 2018 at 22:06 JAEL, 5 bytes #&kȦ  Explanation (generated automatically): ./jael --explain '#&kȦ' ORIGINAL CODE: #&kȦ EXPANDING EXPLANATION: Ȧ => .a! EXPANDED CODE: #&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 indQ2j;o_1-2~d:^=[d@P~1-]:^*[+]:^1+*o;  Try it online! Explanation 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! Explanation ʁ # Range from 0 to input ǎ # Map to a_th prime  At last, sum with s flag Disclaimer: my first Vyxal answer • There's a bounty coming your way in around 48 hours! Commented Apr 16, 2021 at 5:25 • @user many thanks for the bounty!!!! Commented Apr 16, 2021 at 12:04 • s flag is cheaty :( Commented Apr 16, 2021 at 12:28 Pyt, 3 bytes řᵽƩ  Try it online! ř implicit input (n); creates array of [1,2,...,n] ᵽ gets the kth prime for each item k in the array Ʃ sums the array; implicit print  Arturo, 38 bytes $[n][sum take select 2..n*n=>prime? n]


Try it

Japt-x, 8 5 bytes

Èj}jU


Try it

Èj}jU     :Implicit input of integer U
È         :Function taking an integer as argument
j        :  Is prime?
}       :End function
jU     :First U integers >=0 that return true
:Implicit output of sum of resulting array