Equal prime and composite sums

Equal prime and composite sums
You are encouraged to solve this task according to the task description, using any language you may know.

Suppose we have a sequence of prime sums, where each term P_n is the sum of the first n primes.

P = (2), (2 + 3), (2 + 3 + 5), (2 + 3 + 5 + 7), (2 + 3 + 5 + 7 + 11), ...

P = 2, 5, 10, 17, 28, etc.

Further; suppose we have a sequence of composite sums, where each term C_m is the sum of the first m composites.

C = (4), (4 + 6), (4 + 6 + 8), (4 + 6 + 8 + 9), (4 + 6 + 8 + 9 + 10), ...

C = 4, 10, 18, 27, 37, etc.

Notice that the third term of P; P₃ (10) is equal to the second term of C; C₂ (10);

Task

• Find and display the indices (n, m) and value of at least the first 6 terms of the sequence of numbers that are both the sum of the first n primes and the first m composites.

See also

• OEIS:A007504 - Sum of the first n primes
• OEIS:A053767 - Sum of first n composite numbers
• OEIS:A294174 - Numbers that can be expressed both as the sum of first primes and as the sum of first composites

Ada

-- Rosetta Code Task written in Ada
-- Equal prime and composite sums
-- https://rosettacode.org/wiki/Equal_prime_and_composite_sums
-- August 2024, R. B. E.
-- Translated from the Lua solution (mostly)
-- Using GNAT Big Integers, GNAT version 14.1, MacOS 14.6.1, M1 chip

pragma Ada_2022;
with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;
with Ada.Numerics.Big_Numbers.Big_Integers; use Ada.Numerics.Big_Numbers.Big_Integers;

procedure Equal_Prime_and_Composite_Sums is

  function Is_Prime (N : in Big_Integer) return Boolean is
    Big_0 : Big_Natural := To_Big_Integer (0);
    Big_2 : Big_Natural := To_Big_Integer (2);
    Big_3 : Big_Natural := To_Big_Integer (3);
    Big_Temp : Big_Natural := To_Big_Integer (5);
  begin
    if N < Big_2 then
      return False;
    end if;
    if N mod Big_2 = Big_0 then
      return N = Big_2;
    end if;
    if N mod Big_3 = Big_0 then
      return N = Big_3;
    end if;
    while Big_Temp * Big_Temp <= N loop
      if N mod Big_Temp = Big_0 then
        return False;
      end if;
      Big_Temp := Big_Temp + Big_2;
      if N mod Big_Temp = Big_0 then
        return False;
      end if;
      Big_Temp := Big_Temp + 4;
    end loop;
    return True;
  end Is_Prime;

  Limit : constant Natural := 8;
  Count : Natural := 0;
  N : Big_Integer := 2;
  M : Big_Integer := 1;
  sumP : Big_Integer := 5;
  sumC : Big_Integer := 4;
  numP : Big_Integer := 3;
  numC : Big_Integer := 4;

begin
  Put_Line (( "           sum    primes composites" ));
  OUTER: loop
    if (sumC > sumP) then
      LOOP2: loop
        numP := numP + To_Big_Integer (2);
        exit LOOP2 when Is_Prime (numP);
      end loop LOOP2;
      sumP := sumP + numP;
      N := N + To_Big_Integer (1);
    end if;
    if (sumP > sumC) then
      LOOP3: loop
        numC := numC + To_Big_Integer (1);
        exit LOOP3 when not Is_Prime (numC);
      end loop LOOP3;
      sumC := sumC + numC;
      M := M + To_Big_Integer (1);
    end if;
    if (sumP = sumC) then
      Put (To_String (Arg => sumP, Width => 14));
      Put (To_String (Arg => N, Width => 10));
      Put (To_String (Arg => M, Width => 11));
      New_Line;
      Count := Count + 1;
      if Count < Limit then
        LOOP4: loop
          numC := numC + To_Big_Integer (1);
          exit LOOP4 when not Is_Prime (numC);
        end loop LOOP4;
        sumC := sumC + numC;
        M := M + To_Big_Integer (1);
      end if;
    end if;
    exit OUTER when Count >= Limit;
  end loop OUTER;
end Equal_Prime_and_Composite_Sums;

Output:

           sum    primes composites
            10         3          2
          1988        33         51
         14697        80        147
         83292       175        361
       1503397       660       1582
      18859052      2143       5699
      93952013      4556      12821
   89171409882    118785     403341

ALGOL 68

Translation of: XPL0 – With a coup[le of tweaks

BEGIN # find n and m where the sums of the first n primes and first m         #
      # composites where the sums are equal                                   #

    MODE INTEGER = LONG INT;                        # size of INT MODE to use #
    OP   ROOT    = ( LONG INT n )LONG INT: ENTIER long sqrt( n );
    # alternative ROOT operators for different sizes of integer would be      #
    # needed in general, but not for this task, e.g.:                         #
CO  OP   ROOT    = (      INT n )INT:      ENTIER      sqrt( n );            CO

 
    PROC is prime = ( INTEGER n )BOOL:           # returns TRUE if n is prime #
         IF   n <= 2 THEN n = 2
         ELIF NOT ODD n THEN FALSE
         ELSE BOOL prime := TRUE;
              INTEGER  i := 1;
              INTEGER  r := ROOT n;
              WHILE ( i +:= 2 ) <= r AND prime DO prime := n MOD i /= 0 OD;
              prime
         FI # is prime # ;

    BEGIN
        INT     count := 0;
        INTEGER n := 2, m := 1, sum p := 5, sum c := 4, num p := 3, num c := 4;
        print( ( "             sum    primes composites", newline ) );
        WHILE IF sum c > sum p THEN
                  WHILE NOT is prime( num p +:= 2 ) DO SKIP OD;
                  sum p +:= num p;
                  n     +:= 1
              FI;
              IF sum p > sum c THEN
                  WHILE is prime( num c +:= 1 ) DO SKIP OD;
                  sum c +:= num c;
                  m     +:= 1
              FI;
              IF sum p = sum c THEN
                  print( ( whole( sum p, -16 ), whole( n, -10 ), whole( m, -11 ), newline ) );
                  count +:= 1;
                  IF count < 8 THEN
                      WHILE is prime( num c +:= 1 ) DO SKIP OD;
                      sum c +:= num c;
                      m     +:= 1
                  FI
              FI;
              count < 8
        DO SKIP OD
    END
END

Output:

             sum    primes composites
              10         3          2
            1988        33         51
           14697        80        147
           83292       175        361
         1503397       660       1582
        18859052      2143       5699
        93952013      4556      12821
     89171409882    118785     403341

BASIC

BASIC256

Translation of: FreeBASIC

#include "isprime.kbs"

i = 0
IndN = 1 : IndM = 1
NumP = 2 : NumC = 4
SumP = 2 : SumC = 4
print "      sum  prime sum  composite sum"
while True
	if SumC > SumP then
		do
			NumP += 1
		until isPrime(NumP)
		SumP += NumP
		IndN += 1
	end if
	if SumP > SumC then
		do
			NumC += 1
		until not isPrime(NumC)
		SumC += NumC
		IndM += 1
	end if
	if SumP = SumC then
		print rjust(string(SumP),9); " - "; rjust(string(IndN),8); " - ";rjust(string(IndM),8)
		i += 1
		if i >= 7 then exit while  #valor mayor tarda MUUCHO
		do
			NumC += 1
		until not isPrime(NumC)
		SumC += NumC
		IndM += 1
	end if
end while

FreeBASIC

Translation of: XPL0

#include "isprime.bas"

Dim As Integer i = 0
Dim As Integer IndN = 1, IndM = 1
Dim As Integer NumP = 2, NumC = 4
Dim As Integer SumP = 2, SumC = 4
Print "               sum    prime sum     composite sum"
Do
    If SumC > SumP Then
        Do
            NumP += 1 
        Loop Until isPrime(NumP)
        SumP += NumP
        IndN += 1
    End If
    If SumP > SumC Then
        Do 
            NumC += 1 
        Loop Until Not isPrime(NumC)
        SumC += NumC
        IndM += 1
    End If
    If SumP = SumC Then
        Print Using "##,###,###,###,### - ##,###,###  - ##,###,###"; SumP; IndN; IndM
        i += 1
        If i >= 9 Then Exit Do
        Do
            NumC += 1
        Loop Until Not isPrime(NumC)
        SumC += NumC
        IndM += 1
    End If
Loop

Output:

               sum    prime sum     composite sum
                10 -          3  -          2
             1,988 -         33  -         51
            14,697 -         80  -        147
            83,292 -        175  -        361
         1,503,397 -        660  -      1,582
        18,859,052 -      2,143  -      5,699
        93,952,013 -      4,556  -     12,821
    89,171,409,882 -    118,785  -    403,341
 9,646,383,703,961 -  1,131,142  -  4,229,425

Gambas

Translation of: FreeBASIC

'Use "isprime.bas"

Public Sub Main() 
  
  Dim i As Integer = 0 
  Dim IndN As Integer = 1 
  Dim IndM As Integer = 1 
  Dim NumP As Integer = 2 
  Dim NumC As Integer = 4 
  Dim SumP As Long = 2 
  Dim SumC As Long = 4 

  Print "               sum    prime sum    composite sum" 
  Do 
    If SumC > SumP Then 
      Do 
        NumP += 1  
      Loop Until isPrime(NumP) 
      SumP += NumP 
      IndN += 1 
    End If 
    If SumP > SumC Then 
      Do  
        NumC += 1  
      Loop Until Not isPrime(NumC) 
      SumC += NumC 
      IndM += 1 
    End If 
    If SumP = SumC Then 
      Print Format$(Str$(SumP), "##,###,###,###,###"); " - ";
      Print Format$(Str$(IndN), "##,###,###"); " - ";
      Print Format$(Str$(IndM), "##,###,###")
      i += 1 
      If i >= 9 Then Break
      Do 
        NumC += 1 
      Loop Until Not isPrime(NumC) 
      SumC += NumC 
      IndM += 1 
    End If 
  Loop
  
End

Output:

Similar to FreeBASIC entry.

PureBasic

Translation of: FreeBASIC

;XIncludeFile "isprime.pb"

OpenConsole()
Define.d IndN, IndM, NumP, NumC, SumP, SumC
i.i = 0
IndN = 1
IndM = 1
NumP = 2
NumC = 4
SumP = 2
SumC = 4
PrintN("           sum  prime sum  composite sum")
While #True
  If SumC > SumP:
    Repeat
      NumP + 1 
    Until isPrime(NumP)
    SumP + NumP
    IndN + 1
  EndIf
  If SumP > SumC:
    Repeat
      NumC + 1 
    Until Not isPrime(NumC)
    SumC + NumC
    IndM + 1
  EndIf
  If SumP = SumC:
    PrintN(RSet(Str(SumP),14) + " - " + RSet(Str(IndN),8) + " - " + RSet(Str(IndM),8))
    i + 1
    If i >= 9:
      Break
    EndIf
    Repeat
      NumC + 1
    Until Not isPrime(NumC)
    SumC + NumC
    IndM + 1
  EndIf
Wend

PrintN(#CRLF$ + "Press ENTER to exit"): Input()
CloseConsole()

Output:

Same as FreeBASIC entry.

Yabasic

Translation of: FreeBASIC

//import isprime

i = 0
IndN = 1 : IndM = 1
NumP = 2 : NumC = 4
SumP = 2 : SumC = 4
print "               sum    prime sum     composite sum"
do
  if SumC > SumP then
    repeat
      NumP = NumP + 1
    until isPrime(NumP)
    SumP = SumP + NumP
    IndN = IndN + 1
  fi
  if SumP > SumC then
    repeat
      NumC = NumC + 1
    until not isPrime(NumC)
    SumC = SumC + NumC
    IndM = IndM + 1
  fi
  if SumP = SumC then
    print SumP using ("##,###,###,###,###"), " - ", IndN using ("##,###,###"), " - ", IndM using ("##,###,###")
    i = i + 1
    if i >= 9  break
    repeat
      NumC = NumC + 1
    until not isPrime(NumC)
    SumC = SumC + NumC
    IndM = IndM + 1
  fi
loop
print
end

C++

Library: Primesieve

#include <primesieve.hpp>

#include <chrono>
#include <iomanip>
#include <iostream>
#include <locale>

class composite_iterator {
public:
    composite_iterator();
    uint64_t next_composite();

private:
    uint64_t composite;
    uint64_t prime;
    primesieve::iterator pi;
};

composite_iterator::composite_iterator() {
    composite = prime = pi.next_prime();
    for (; composite == prime; ++composite)
        prime = pi.next_prime();
}

uint64_t composite_iterator::next_composite() {
    uint64_t result = composite;
    while (++composite == prime)
        prime = pi.next_prime();
    return result;
}

int main() {
    std::cout.imbue(std::locale(""));
    auto start = std::chrono::high_resolution_clock::now();
    composite_iterator ci;
    primesieve::iterator pi;
    uint64_t prime_sum = pi.next_prime();
    uint64_t composite_sum = ci.next_composite();
    uint64_t prime_index = 1, composite_index = 1;
    std::cout << "Sum                   | Prime Index  | Composite Index\n";
    std::cout << "------------------------------------------------------\n";
    for (int count = 0; count < 11;) {
        if (prime_sum == composite_sum) {
            std::cout << std::right << std::setw(21) << prime_sum << " | "
                      << std::setw(12) << prime_index << " | " << std::setw(15)
                      << composite_index << '\n';
            composite_sum += ci.next_composite();
            prime_sum += pi.next_prime();
            ++prime_index;
            ++composite_index;
            ++count;
        } else if (prime_sum < composite_sum) {
            prime_sum += pi.next_prime();
            ++prime_index;
        } else {
            composite_sum += ci.next_composite();
            ++composite_index;
        }
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> duration(end - start);
    std::cout << "\nElapsed time: " << duration.count() << " seconds\n";
}

Output:

Sum                   | Prime Index  | Composite Index
------------------------------------------------------
                   10 |            3 |               2
                1,988 |           33 |              51
               14,697 |           80 |             147
               83,292 |          175 |             361
            1,503,397 |          660 |           1,582
           18,859,052 |        2,143 |           5,699
           93,952,013 |        4,556 |          12,821
       89,171,409,882 |      118,785 |         403,341
    9,646,383,703,961 |    1,131,142 |       4,229,425
  209,456,854,921,713 |    5,012,372 |      19,786,181
3,950,430,820,867,201 |   20,840,220 |      86,192,660

Elapsed time: 0.330966 seconds

Delphi

Works with: Delphi version 6.0

Library: SysUtils,StdCtrls

Makes extensive use of the Delphi Prime-Generator Object

procedure PrimeCompositeSums(Memo: TMemo);
{Find places where the prime and composite sums match}
var Sieve: TPrimeSieve;
var I,P,C,Count: integer;
var CSumArray,PSumArray: TInt64DynArray;
var CSum,PSum: int64;
var S: string;
begin
Sieve:=TPrimeSieve.Create;
try
{Build 10 million primes}
Sieve.Intialize(10000000);
{Build arrays of Prime and Composite sums}
SetLength(CSumArray,0);
SetLength(PSumArray,0);
CSum:=0; PSum:=0;
for I:=2 to Sieve.Count-1 do
 if Sieve.Flags[I] then
	begin
	PSum:=PSum+I;
	SetLength(PSumArray,Length(PSumArray)+1);
	PSumArray[High(PSumArray)]:=PSum;
	end
 else
	begin
	CSum:=CSum+I;
	SetLength(CSumArray,Length(CSumArray)+1);
	CSumArray[High(CSumArray)]:=CSum;
	end;
Memo.Lines.Add('Sum                   | Prime Index  | Composite Index');
Memo.Lines.Add('------------------------------------------------------');
P:=0;C:=0;
Count:=0;
{Traverse the prime and composite sum looking for places they match}
while true do
	begin
	if PSumArray[P]=CSumArray[C] then
		begin
		Inc(Count);
		Memo.Lines.Add(Format('%d %19.0n | %12d | %15d',[Count,PSumArray[P]+0.0,P+1,C+1]));
		if Count>=8 then break;
		end;
	{Increment the index of array that is behind}
	if PSumArray[P]<CSumArray[C] then Inc(P)
	else Inc(C);
	end;
finally Sieve.Free; end;
end;

Output:

Sum                   | Prime Index  | Composite Index
------------------------------------------------------
1                  10 |            3 |               2
2               1,988 |           33 |              51
3              14,697 |           80 |             147
4              83,292 |          175 |             361
5           1,503,397 |          660 |            1582
6          18,859,052 |         2143 |            5699
7          93,952,013 |         4556 |           12821
8      89,171,409,882 |       118785 |          403341
Elapsed Time: 761.859 ms.

EasyLang

Translation of: FreeBASIC

fastfunc isprim num .
   if num mod 2 = 0 and num > 2
      return 0
   .
   i = 3
   while i <= sqrt num
      if num mod i = 0
         return 0
      .
      i += 2
   .
   return 1
.
indN = 1 ; indM = 2
numP = 2 ; numC = 4
sumP = 2 ; sumC = 4
# 
numfmt 0 11
print "        sum     primes composites"
repeat
   if sumC > sumP
      repeat
         numP += 1
         until isprim numP = 1
      .
      sumP += numP
      indN += 1
   .
   if sumP > sumC
      repeat
         numC += 1
         until isprim numC = 0
      .
      sumC += numC
      indM += 1
   .
   if sumP = sumC
      print sumP & indN & indM
      cnt += 1
      if cnt < 8
         repeat
            numC += 1
            until isprim numC = 0
         .
         sumC += numC
         indM += 1
      .
   .
   until cnt >= 8
.

F#

This task uses Extensible Prime Generator (F#)

// Equal prime and composite sums. Nigel Galloway: March 3rd., 2022
let fN(g:seq<int64>)=let g=(g|>Seq.scan(fun(_,n,i) g->(g,n+g,i+1))(0,0L,0)|>Seq.skip 1).GetEnumerator() in (fun()->g.MoveNext()|>ignore; g.Current)
let fG n g=let rec fG a b=seq{match a,b with ((_,p,_),(_,c,_)) when p<c->yield! fG(n()) b |((_,p,_),(_,c,_)) when p>c->yield! fG a (g()) |_->yield(a,b); yield! fG(n())(g())} in fG(n())(g()) 
fG(fN(primes64()))(fN(primes64()|>Seq.pairwise|>Seq.collect(fun(n,g)->[1L+n..g-1L])))|>Seq.take 11|>Seq.iter(fun((n,i,g),(e,_,l))->printfn $"Primes up to %d{n} at position %d{g} and composites up to %d{e} at position %d{l} sum to %d{i}.")

Output:

Primes up to 5 at position 3 and composites up to 6 at position 2 sum to 10.
Primes up to 137 at position 33 and composites up to 72 at position 51 sum to 1988.
Primes up to 409 at position 80 and composites up to 190 at position 147 sum to 14697.
Primes up to 1039 at position 175 and composites up to 448 at position 361 sum to 83292.
Primes up to 4937 at position 660 and composites up to 1868 at position 1582 sum to 1503397.
Primes up to 18787 at position 2143 and composites up to 6544 at position 5699 sum to 18859052.
Primes up to 43753 at position 4556 and composites up to 14522 at position 12821 sum to 93952013.
Primes up to 1565929 at position 118785 and composites up to 440305 at position 403341 sum to 89171409882.
Primes up to 17662763 at position 1131142 and composites up to 4548502 at position 4229425 sum to 9646383703961.
Primes up to 86254457 at position 5012372 and composites up to 21123471 at position 19786181 sum to 209456854921713.
Primes up to 390180569 at position 20840220 and composites up to 91491160 at position 86192660 sum to 3950430820867201.

Go

Translation of: Wren

Library: Go-rcu

package main

import (
    "fmt"
    "log"
    "rcu"
    "sort"
)

func ord(n int) string {
    if n < 0 {
        log.Fatal("Argument must be a non-negative integer.")
    }
    m := n % 100
    if m >= 4 && m <= 20 {
        return fmt.Sprintf("%sth", rcu.Commatize(n))
    }
    m %= 10
    suffix := "th"
    if m == 1 {
        suffix = "st"
    } else if m == 2 {
        suffix = "nd"
    } else if m == 3 {
        suffix = "rd"
    }
    return fmt.Sprintf("%s%s", rcu.Commatize(n), suffix)
}

func main() {
    limit := int(4 * 1e8)
    c := rcu.PrimeSieve(limit-1, true)
    var compSums []int
    var primeSums []int
    csum := 0
    psum := 0
    for i := 2; i < limit; i++ {
        if c[i] {
            csum += i
            compSums = append(compSums, csum)
        } else {
            psum += i
            primeSums = append(primeSums, psum)
        }
    }

    for i := 0; i < len(primeSums); i++ {
        ix := sort.SearchInts(compSums, primeSums[i])
        if ix < len(compSums) && compSums[ix] == primeSums[i] {
            cps := rcu.Commatize(primeSums[i])
            fmt.Printf("%21s - %12s prime sum, %12s composite sum\n", cps, ord(i+1), ord(ix+1))
        }
    }
}

Output:

                   10 -          3rd prime sum,          2nd composite sum
                1,988 -         33rd prime sum,         51st composite sum
               14,697 -         80th prime sum,        147th composite sum
               83,292 -        175th prime sum,        361st composite sum
            1,503,397 -        660th prime sum,      1,582nd composite sum
           18,859,052 -      2,143rd prime sum,      5,699th composite sum
           93,952,013 -      4,556th prime sum,     12,821st composite sum
       89,171,409,882 -    118,785th prime sum,    403,341st composite sum
    9,646,383,703,961 -  1,131,142nd prime sum,  4,229,425th composite sum
  209,456,854,921,713 -  5,012,372nd prime sum, 19,786,181st composite sum
3,950,430,820,867,201 - 20,840,220th prime sum, 86,192,660th composite sum

J

Brute force seems fast enough for this task

Pn=: +/\ pn=: p: i.1e6 NB. first million primes pn and their running sum Pn
Cn=: +/\(4+i.{:pn)-.pn NB. running sum of composites starting at 4 and excluding those primes
both=: Pn(e.#[)Cn NB. numbers in both sequences

   both,.(Pn i.both),.Cn i.both NB. values, Pn index m, Cn index n
         10      2      1
       1988     32     50
      14697     79    146
      83292    174    360
    1503397    659   1581
   18859052   2142   5698
   93952013   4555  12820
89171409882 118784 403340

Java

import java.util.BitSet;
import java.util.Objects;

public final class EqualPrimeAndCompositeSums {

	public static void main(String[] aArgs) {		
	    PrimeIterator primeIterator = new PrimeIterator();
	    CompositeIterator compositeIterator = new CompositeIterator();
	    long primeSum = primeIterator.next();
	    long compositeSum = compositeIterator.next();
	    int primeIndex = 1;
	    int compositeIndex = 1;
	    
	    System.out.println("Sum           | Prime Index  | Composite Index");
	    System.out.println("----------------------------------------------");
	    int count = 0;
	    while ( count < 8 ) {
	        if ( primeSum == compositeSum ) {
	        	System.out.println(String.format("%13d%s%12d%s%15d",
	        		primeSum, " | ", primeIndex, " | ", compositeIndex));
	        	
	        	primeSum += primeIterator.next();
	            primeIndex += 1;	
	            compositeSum += compositeIterator.next();
	            compositeIndex += 1;	                        
	            count += 1;
	        } else if ( primeSum < compositeSum ) {
	            primeSum += primeIterator.next();
	            primeIndex += 1;
	        } else {
	            compositeSum += compositeIterator.next();
	            compositeIndex += 1;
	        }
	    }
	}	
	
	private static class CompositeIterator {
		
		public CompositeIterator() {
			primeIterator = new PrimeIterator();
			prime = primeIterator.next();
			composite = prime;
			while ( composite == prime ) {
				prime = primeIterator.next();
				composite += 1;
			}
		}
		
		public int next() {
		    final int result = composite;
		    while ( ++composite == prime ) {
		        prime = primeIterator.next();        
		    }
		    return result;
		}
		
		public int prime, composite;
		private PrimeIterator primeIterator;
		
	}
	
	private static class PrimeIterator {
		
		public PrimeIterator() {
			if ( Objects.isNull(sieve) ) {
				listPrimeNumbers(10_000_000);
			}			
		}
		
		public int next() {
			if ( lastPrime < sieve.cardinality() ) {
				lastPrime = sieve.nextSetBit(lastPrime + 1);
			} else {
				do {
					lastPrime += 2;
				}
				while ( ! isPrime(lastPrime) );				
			}			
			return lastPrime;
		}
		
		private static boolean isPrime(int aCandidate) {
			for ( int i = 2; i <= Math.sqrt(aCandidate); i = sieve.nextSetBit(i + 1) ) {
				if ( aCandidate % i == 0 ) {
					return false;
				}
			}
			return true;
		}
		
		private static void listPrimeNumbers(int aN) {
			sieve = new BitSet(aN + 1);
			sieve.set(2, aN + 1);
			for ( int i = 2; i <= Math.sqrt(aN); i = sieve.nextSetBit(i + 1) ) {
				for ( int j = i * i; j <= aN; j = j + i ) {
					sieve.clear(j);
				}
			}
		}
		
		private int lastPrime;
		private static BitSet sieve;		
		
	}	

}

Output:

Sum           | Prime Index  | Composite Index
----------------------------------------------
           10 |            3 |               2
         1988 |           33 |              51
        14697 |           80 |             147
        83292 |          175 |             361
      1503397 |          660 |            1582
     18859052 |         2143 |            5699
     93952013 |         4556 |           12821
  89171409882 |       118785 |          403341

jq

Works with: jq

Works with gojq, the Go implementation of jq

See Erdős-primes#jq for a suitable definition of `is_prime` as used here.

The program given in this entry requires foreknowledge of the appropriate size of the (virtual) Eratosthenes sieve.

def lpad($len): tostring | ($len - length) as $l | (" " * $l)[:$l] +.;

def task($sievesize):
  {compSums:[],
   primeSums:[],
   csum:0,
   psum:0 }
  | reduce range(2; $sievesize) as $i (.;
      if $i|is_prime
      then .psum += $i
      | .primeSums += [.psum]
      else .csum += $i
      | .compSums += [ .csum ]
      end)
  | range(0; .primeSums|length) as $i
  | .primeSums[$i] as $ps
  | (.compSums | index( $ps )) as $ix
  | select($ix >= 0)
  | "\($ps|lpad(21)) - \($i+1|lpad(21)) prime sum, \($ix+1|lpad(12)) composite sum"
;

task(1E5)

Output:

                   10 -                     3 prime sum,            2 composite sum
                 1988 -                    33 prime sum,           51 composite sum
                14697 -                    80 prime sum,          147 composite sum
                83292 -                   175 prime sum,          361 composite sum
              1503397 -                   660 prime sum,         1582 composite sum
             18859052 -                  2143 prime sum,         5699 composite sum
             93952013 -                  4556 prime sum,        12821 composite sum

Julia

using Primes

function getsequencematches(N, masksize = 1_000_000_000)
    pmask = primesmask(masksize)
    found, psum, csum, pindex, cindex, pcount, ccount = 0, 2, 4, 2, 4, 1, 1
    incrementpsum() = (pindex += 1; if pmask[pindex] psum += pindex; pcount += 1 end)
    incrementcsum() = (cindex += 1; if !pmask[cindex] csum += cindex; ccount += 1 end)
    while found < N
        while psum < csum
            pindex >= masksize && return
            incrementpsum()
        end
        if psum == csum
            println("Primes up to $pindex at position $pcount and composites up to $cindex at position $ccount sum to $psum.")
            found += 1
            while psum == csum
                incrementpsum()
                incrementcsum()
            end
        end
        while csum < psum
            incrementcsum()
        end
    end
end

@time getsequencematches(11)

Output:

Primes up to 5 at position 3 and composites up to 6 at position 2 sum to 10.
Primes up to 137 at position 33 and composites up to 72 at position 51 sum to 1988.
Primes up to 409 at position 80 and composites up to 190 at position 147 sum to 14697.
Primes up to 1039 at position 175 and composites up to 448 at position 361 sum to 83292.
Primes up to 4937 at position 660 and composites up to 1868 at position 1582 sum to 1503397.
Primes up to 18787 at position 2143 and composites up to 6544 at position 5699 sum to 18859052.
Primes up to 43753 at position 4556 and composites up to 14522 at position 12821 sum to 93952013.
Primes up to 1565929 at position 118785 and composites up to 440305 at position 403341 sum to 89171409882.
Primes up to 17662763 at position 1131142 and composites up to 4548502 at position 4229425 sum to 9646383703961.
Primes up to 86254457 at position 5012372 and composites up to 21123471 at position 19786181 sum to 209456854921713.
Primes up to 390180569 at position 20840220 and composites up to 91491160 at position 86192660 sum to 3950430820867201.
 44.526876 seconds (1.09 G allocations: 16.546 GiB, 3.13% gc time)

Mathematica /Wolfram Language

$HistoryLength = 1;
ub = 10^8;
ps = Prime[Range[PrimePi[ub]]];
cs = Complement[Range[2, ub], ps];
cps = Accumulate[ps];
ccs = Accumulate[cs];
indices = Intersection[cps, ccs];
poss = {FirstPosition[cps, #], FirstPosition[ccs, #]} & /@ indices;
TableForm[MapThread[Prepend, {Flatten /@ poss, indices}], 
 TableHeadings -> {None, {"Sum", "Prime Index", "Composite Index"}}, 
 TableAlignments -> Right]

Output:

Sum	Prime Index	Composite Index
10		3		2
1988		33		51
14697		80		147
83292		175		361
1503397		660		1582
18859052	2143		5699
93952013	4556		12821
89171409882	118785		403341
9646383703961	1131142		4229425
209456854921713	5012372		19786181

Lua

Translation of: XPL0 – with a couple of tweaks

do --[[ find n and m where the sums of the first n primes and first m
        composites where the sums are equal
   --]]

    local function isPrime( n )         -- returns TRUE if n is prime
         if   n <= 2 then return n == 2
         elseif n % 2 == 0 then return false
         else local prime, i, r = true, 1, math.floor( math.sqrt( n ) )
              repeat
                  i = i + 2
                  if i <= r then
                       prime = n % i ~= 0
                  end
              until i > r or not prime
              return prime
         end
    end

    local  count, n, m, sumP, sumC, numP, numC = 0, 2, 1, 5, 4, 3, 4
    io.write( "           sum    primes composites\n" )

    repeat
        if sumC > sumP then
            repeat numP = numP + 2 until isPrime( numP )
            sumP = sumP + numP
            n    = n + 1
        end
        if sumP > sumC then
            repeat numC = numC + 1 until not isPrime( numC )
            sumC = sumC + numC
            m    = m + 1
        end
        if sumP == sumC then
            io.write( string.format( "%14d", sumP ), string.format( "%10d", n ), string.format( "%11d", m ), "\n" )
            count = count + 1;
            if count < 8 then
                repeat numC = numC + 1 until not isPrime( numC )
                sumC = sumC + numC
                m    = m + 1
            end
        end
    until count >= 8
end

Output:

           sum    primes composites
            10         3          2
          1988        33         51
         14697        80        147
         83292       175        361
       1503397       660       1582
      18859052      2143       5699
      93952013      4556      12821
   89171409882    118785     403341

Nim

We use a sieve of Erathostenes for odd integers, each boolean being represented as a single bit.

import std/[bitops, math, monotimes, strformat, strutils, times]

type Sieve = object
  data: seq[byte]

proc `[]`(sieve: Sieve; idx: Positive): bool =
  ## Return the sieve element at index "idx".
  let idx = idx shr 1
  let iByte = idx shr 3
  let iBit = idx and 7
  result = sieve.data[iByte].testBit(iBit)

proc `[]=`(sieve: var Sieve; idx: Positive; val: bool) =
  ## Set the sieve element at index "idx" with value "val".
  let idx = idx shr 1
  let iByte = idx shr 3
  let iBit = idx and 7
  if val: sieve.data[iByte].setBit(iBit)
  else: sieve.data[iByte].clearBit(iBit)

proc newSieve(lim: Positive): Sieve =
  ## Create a sieve with maximum index "lim".
  result.data = newSeq[byte]((lim + 16) shr 4)

const Limit = 400_000_000

let t0 = getMonoTime()

# Fill the sieve.
var composite = newSieve(Limit)
for n in countup(3, sqrt(Limit.toFloat).int, 2):
  if not composite[n]:
    for k in countup(n * n, Limit - 1, 2 * n):
      composite[k] = true

proc isPrime(n: Positive): bool =
  ## Return true is "n" is prime.
  assert n >= 2
  if (n and 1) == 0: return n == 2
  result = not composite[n]

proc updatePrime(np, ip, psum: var int) =
  ## Find the next prime number and update "np", "ip" and "psum".
  inc np, 1
  while np <= Limit and not np.isPrime:
    inc np
  inc ip
  inc psum, np

proc updateComposite(nc, ic, csum: var int) =
  ## Find the next composite number and update "nc", "ic" and "csum".
  inc nc, 1
  while nc <= Limit and nc.isPrime:
    inc nc
  inc ic
  inc csum, nc

echo "          Sum         |   Prime Index   | Composite Index "
echo "──────────────────────────────────────────────────────────"

var np = 2      # Current prime.
var nc = 4      # Current composite.
var ip, ic = 1  # Ranks of current prime and composite.
var psum = np   # Current sum of prime numbers.
var csum = nc   # Current sum of composite numbers.

while true:
  if psum == csum:
    echo &"{insertSep($psum):>21} | {insertSep($ip):>15} | {insertSep($ic):>15}"
    updatePrime(np, ip, psum)
    updateComposite(nc, ic, csum)
  elif psum < csum:
    updatePrime(np, ip, psum)
  else:
    updateComposite(nc, ic, csum)
  if np > Limit or nc > Limit:
    break

echo()
let dt = toParts(getMonoTime() - t0)
echo &"Elapsed time: {dt[Seconds]}.{dt[Milliseconds]} s"

Output:

          Sum         |   Prime Index   | Composite Index 
──────────────────────────────────────────────────────────
                   10 |               3 |               2
                1_988 |              33 |              51
               14_697 |              80 |             147
               83_292 |             175 |             361
            1_503_397 |             660 |           1_582
           18_859_052 |           2_143 |           5_699
           93_952_013 |           4_556 |          12_821
       89_171_409_882 |         118_785 |         403_341
    9_646_383_703_961 |       1_131_142 |       4_229_425
  209_456_854_921_713 |       5_012_372 |      19_786_181
3_950_430_820_867_201 |      20_840_220 |      86_192_660

Elapsed time: 2.891 s

PascalABC.NET

Translation of: Lua

function isPrime(n: integer): boolean;
begin
  if (n mod 2 = 0) and (n > 2) then 
  begin
    result := false;
    exit
  end;
  var i := 3;
  while i <= sqrt(n) do
  begin
    if n mod i = 0 then 
    begin
      result := false;
      exit;
    end;
    i += 2;
  end;
  result := true;
end;

begin
  var count := 0; var n := 2; var m := 1; 
  var sumP: int64 := 5; var sumC: int64 := 4; 
  var numP := 3; var numC := 4;
  writeln( '            sum    primes  composites');
  
  repeat
    if sumC > sumP then 
    begin
      repeat numP += 2 until isPrime(numP);
      sumP += numP; 
      n += 1;
    end;
    if sumP > sumC then 
    begin
      repeat numC += 1 until not isPrime(numC);
      sumC += numC;
      m += 1;
    end;
    if sumP = sumC then 
    begin
      writeln(sumP:15, n:10, m:12);
      count += 1;
      repeat numC += 1 until not isPrime(numC);
      sumC += numC;
      m += 1;
    end
  until count >= 10
end.

Output:

            sum    primes  composites
             10         3           2
           1988        33          51
          14697        80         147
          83292       175         361
        1503397       660        1582
       18859052      2143        5699
       93952013      4556       12821
    89171409882    118785      403341
  9646383703961   1131142     4229425
209456854921713   5012372    19786181

Perl

Not especially fast, but minimal memory usage.

Library: ntheory

use strict;
use warnings;
use feature <say state>;
use ntheory <is_prime next_prime>;

sub comma  { reverse ((reverse shift) =~ s/(.{3})/$1,/gr) =~ s/^,//r }
sub suffix { my($d) = $_[0] =~ /(.)$/; $d == 1 ? 'st' : $d == 2 ? 'nd' : $d == 3 ? 'rd' : 'th' }

sub prime_sum {
    state $s = state $p = 2; state $i = 1;
    if ($i < (my $n = shift) ) { do { $s += $p = next_prime($p) } until ++$i == $n }
    $s
}

sub composite_sum {
    state $s = state $c = 4; state $i = 1;
    if ($i < (my $n = shift) ) { do { 1 until ! is_prime(++$c); $s += $c } until ++$i == $n }
    $s
}

my $ci++;
for my $pi (1 .. 5_012_372) {
    next if prime_sum($pi) < composite_sum($ci);
    printf( "%20s - %11s prime sum, %12s composite sum\n",
        comma(prime_sum $pi), comma($pi).suffix($pi), comma($ci).suffix($ci))
        and next if prime_sum($pi) == composite_sum($ci);
    $ci++;
    redo
}

Output:

                  10 -         3rd prime sum,          2nd composite sum
               1,988 -        33rd prime sum,         51st composite sum
              14,697 -        80th prime sum,        147th composite sum
              83,292 -       175th prime sum,        361st composite sum
           1,503,397 -       660th prime sum,      1,582nd composite sum
          18,859,052 -     2,143rd prime sum,      5,699th composite sum
          93,952,013 -     4,556th prime sum,     12,821st composite sum
      89,171,409,882 -   118,785th prime sum,    403,341st composite sum
   9,646,383,703,961 - 1,131,142nd prime sum,  4,229,425th composite sum
 209,456,854,921,713 - 5,012,372nd prime sum, 19,786,181st composite sum

Phix

with javascript_semantics 
atom t0 = time()
atom ps = 2,  -- current prime sum
     cs = 4   -- current composite sum
integer psn = 1, npi = 1,  -- (see below)
        csn = 1, nci = 3, nc = 4, ncp = 5,
        found = 0
constant limit = iff(platform()=JS?10:11)
while found<limit do
    integer c = compare(ps,cs) -- {-1,0,+1}
    if c=0 then
        printf(1,"%,21d - %,10d%s prime sum, %,10d%s composite sum   (%s)\n",
                 {ps, psn, ord(psn), csn, ord(csn), elapsed(time()-t0)})
        found += 1
    end if
    if c<=0 then
        psn += 1    -- prime sum number
        npi += 1    -- next prime index
        ps += get_prime(npi)
    end if
    if c>=0 then
        csn += 1    -- composite sum number
        nc += 1     -- next composite?
        if nc=ncp then  -- "", erm no
            nci += 1    -- next prime index
            ncp = get_prime(nci)
            nc += 1 -- next composite (even!)
        end if
        cs += nc
    end if
end while

Output:

                   10 -          3rd prime sum,          2nd composite sum   (0s)
                1,988 -         33rd prime sum,         51st composite sum   (0.2s)
               14,697 -         80th prime sum,        147th composite sum   (0.2s)
               83,292 -        175th prime sum,        361st composite sum   (0.2s)
            1,503,397 -        660th prime sum,      1,582nd composite sum   (0.2s)
           18,859,052 -      2,143rd prime sum,      5,699th composite sum   (0.2s)
           93,952,013 -      4,556th prime sum,     12,821st composite sum   (0.2s)
       89,171,409,882 -    118,785th prime sum,    403,341st composite sum   (0.3s)
    9,646,383,703,961 -  1,131,142nd prime sum,  4,229,425th composite sum   (1.3s)
  209,456,854,921,713 -  5,012,372nd prime sum, 19,786,181st composite sum   (5.2s)
3,950,430,820,867,201 - 20,840,220th prime sum, 86,192,660th composite sum   (22.4s)

The next value in the series is beyond an 80 bit float, and I suspect this is one of those sort of tasks where gmp, or perhaps I should rather say over a billion invocations of the Phix interface to it, might not shine quite so brightly.

Python

# equal_prime_comp_sums.py by Xing216
import math
import numpy
def prime_composites(upto=50000):
    nums = numpy.arange(2,upto+1)
    primes=numpy.arange(3,upto+1,2)
    isprime=numpy.ones((upto-1)//2,dtype=bool)
    for factor in primes[:int(math.sqrt(upto))//2]:
        if isprime[(factor-2)//2]: isprime[(factor*3-2)//2::factor]=0
    primes = numpy.insert(primes[isprime],0,2)
    intersect = nums[numpy.in1d(nums, primes)]
    mask1 = numpy.searchsorted(nums,intersect)
    composites = numpy.delete(nums,mask1)
    return primes, composites
primes, composites = prime_composites()
cum_primes = numpy.cumsum(primes)
cum_composites = numpy.cumsum(composites)
print("Sum        | Prime Index | Composite Index")
print("------------------------------------------")
for idx, num in enumerate(cum_primes):
    if num in cum_composites:
        print(f"{num:10,} | {idx+1:11,} | {numpy.where(cum_composites == num)[0][0]+1:15,}")

Output:

Sum        | Prime Index | Composite Index
------------------------------------------
        10 |           3 |               2
     1,988 |          33 |              51
    14,697 |          80 |             147
    83,292 |         175 |             361
 1,503,397 |         660 |           1,582
18,859,052 |       2,143 |           5,699
93,952,013 |       4,556 |          12,821

Quackery

isprime is defined at Primality by trial division#Quackery.

  [ swap number$
    tuck size -
    space swap of
    swap join echo$ ]         is r-echo      ( n n --> $ )

  [ stack ]                   is primecount  (     --> s )
  [ stack ]                   is recentprime (     --> s )
  [ stack ]                   is primesum    (     --> s )
  [ stack ]                   is compcount   (     --> s )
  [ stack ]                   is recentcomp  (     --> s )
  [ stack ]                   is compsum     (     --> s )

  [ recentprime take
    [ 1+ dup isprime iff
        [ 1 primecount tally
          dup recentprime put
          primesum tally ]
        done
     again ] ]                is nextprime   (     -->   )

  [ recentcomp take
    [ 1+ dup isprime not iff
        [ 1 compcount tally
          dup recentcomp put
          compsum tally ]
        done
     again ] ]                is nextcomp    (     -->   )

  1 primecount  put
  2 recentprime put
  2 primesum    put
  1 compcount   put
  4 recentcomp  put
  4 compsum     put
  []
  [ primesum share
    compsum  share
    2dup > iff
      [ 2drop nextcomp ]
      again
    < iff nextprime again
    compsum    share
    primecount share
    compcount  share
    join join nested join
    dup size 7 < while
    nextcomp
    nextprime
    again ]
   primecount  release
   recentprime release
   primesum    release
   compcount   release
   recentcomp  release
   compsum     release
   say "        sum      prime  composite" cr
   witheach
     [ witheach
         [ 11 r-echo ]
       cr ]

Output:

        sum      prime  composite
         10          3          2
       1988         33         51
      14697         80        147
      83292        175        361
    1503397        660       1582
   18859052       2143       5699
   93952013       4556      12821

Raku

Let it run until I got bored and killed it. Time is total accumulated seconds since program start.

use Lingua::EN::Numbers:ver<2.8.2+>;

my $prime-sum =     [\+] (2..*).grep:  *.is-prime;
my $composite-sum = [\+] (2..*).grep: !*.is-prime;

my $c-index = 0;

for ^∞ -> $p-index {
    next if $prime-sum[$p-index] < $composite-sum[$c-index];
    printf( "%20s - %11s prime sum, %12s composite sum   %5.2f seconds\n",
      $prime-sum[$p-index].&comma, ordinal-digit($p-index + 1, :u, :c),
      ordinal-digit($c-index + 1, :u, :c), now - INIT now )
      and next if $prime-sum[$p-index] == $composite-sum[$c-index];
    ++$c-index;
    redo;
};

Output:

                  10 -         3ʳᵈ prime sum,          2ⁿᵈ composite sum    0.01 seconds
               1,988 -        33ʳᵈ prime sum,         51ˢᵗ composite sum    0.01 seconds
              14,697 -        80ᵗʰ prime sum,        147ᵗʰ composite sum    0.02 seconds
              83,292 -       175ᵗʰ prime sum,        361ˢᵗ composite sum    0.03 seconds
           1,503,397 -       660ᵗʰ prime sum,      1,582ⁿᵈ composite sum    0.04 seconds
          18,859,052 -     2,143ʳᵈ prime sum,      5,699ᵗʰ composite sum    0.08 seconds
          93,952,013 -     4,556ᵗʰ prime sum,     12,821ˢᵗ composite sum    0.14 seconds
      89,171,409,882 -   118,785ᵗʰ prime sum,    403,341ˢᵗ composite sum    4.23 seconds
   9,646,383,703,961 - 1,131,142ⁿᵈ prime sum,  4,229,425ᵗʰ composite sum   76.23 seconds
 209,456,854,921,713 - 5,012,372ⁿᵈ prime sum, 19,786,181ˢᵗ composite sum  968.26 seconds
^C

Sidef

func f(n) {

    var (
        p = 2, sp = p,
        c = 4, sc = c,
    )

    var res = []

    while (res.len < n) {
        if (sc == sp) {
            res << [sp, c.composite_count, p.prime_count]
            sc += c.next_composite!
        }
        while (sp < sc) {
            sp += p.next_prime!
        }
        while (sc < sp) {
            sc += c.next_composite!
        }
    }

    return res
}

f(8).each_2d {|n, ci, pi|
    printf("%12s = %-9s = %s\n", n, "P(#{pi})", "C(#{ci})")
}

Output:

          10 = P(3)      = C(2)
        1988 = P(33)     = C(51)
       14697 = P(80)     = C(147)
       83292 = P(175)    = C(361)
     1503397 = P(660)    = C(1582)
    18859052 = P(2143)   = C(5699)
    93952013 = P(4556)   = C(12821)
 89171409882 = P(118785) = C(403341)

(takes ~6 seconds)

Wren

Takes around 2 minutes, which is respectable for Wren, but uses a lot of memory.

import "./math" for Int
import "./sort" for Find
import "./fmt" for Fmt

var limit = 4 * 1e8
var c = Int.primeSieve(limit - 1, false)
var compSums = []
var primeSums = []
var csum = 0
var psum = 0
for (i in 2...limit) {
    if (c[i]) {
        csum = csum + i
        compSums.add(csum)
    } else {
        psum = psum + i
        primeSums.add(psum)
    }
}

for (i in 0...primeSums.count) {
    var ix
    if ((ix = Find.first(compSums, primeSums[i])) >= 0) {
        Fmt.print("$,21d - $,12r prime sum, $,12r composite sum", primeSums[i], i+1, ix+1)
    }
}

Output:

                   10 -          3rd prime sum,          2nd composite sum
                1,988 -         33rd prime sum,         51st composite sum
               14,697 -         80th prime sum,        147th composite sum
               83,292 -        175th prime sum,        361st composite sum
            1,503,397 -        660th prime sum,      1,582nd composite sum
           18,859,052 -      2,143rd prime sum,      5,699th composite sum
           93,952,013 -      4,556th prime sum,     12,821st composite sum
       89,171,409,882 -    118,785th prime sum,    403,341st composite sum
    9,646,383,703,961 -  1,131,142nd prime sum,  4,229,425th composite sum
  209,456,854,921,713 -  5,012,372nd prime sum, 19,786,181st composite sum
3,950,430,820,867,201 - 20,840,220th prime sum, 86,192,660th composite sum

XPL0

func IsPrime(N);        \Return 'true' if N is prime
int  N, I;
[if N <= 2 then return N = 2;
if (N&1) = 0 then \even >2\ return false;
for I:= 3 to sqrt(N) do
    [if rem(N/I) = 0 then return false;
    I:= I+1;
    ];
return true;
];

int Cnt, N, M, SumP, SumC, NumP, NumC;
[Cnt:= 0;
N:= 1;  M:= 1;
NumP:= 2;  NumC:= 4;
SumP:= 2;  SumC:= 4;
Format(8, 0);
Text(0, "     sum     prime  composit
");
loop    [if SumC > SumP then
            [repeat NumP:= NumP+1 until IsPrime(NumP);
            SumP:= SumP + NumP;
            N:= N+1;
            ];
        if SumP > SumC then
            [repeat NumC:= NumC+1 until not IsPrime(NumC);
            SumC:= SumC + NumC;
            M:= M+1;
            ];
        if SumP = SumC then
            [RlOut(0, float(SumP));
            RlOut(0, float(N));
            RlOut(0, float(M));  CrLf(0);
            Cnt:= Cnt+1;
            if Cnt >= 6 then quit;
            repeat NumC:= NumC+1 until not IsPrime(NumC);
            SumC:= SumC + NumC;
            M:= M+1;
            ];
        ];
]

Output:

     sum     prime  composit
      10       3       2
    1988      33      51
   14697      80     147
   83292     175     361
 1503397     660    1582
18859052    2143    5699