Prime reciprocal sum

Prime reciprocal sum
You are encouraged to solve this task according to the task description, using any language you may know.

Generate the sequence of primes where each term is the smallest prime whose reciprocal can be added to the cumulative sum and remain smaller than 1.

E.G.

The cumulative reciprocal sum with zero terms is 0. The smallest prime whose reciprocal can be added to the sum without reaching or exceeding 1 is 2, so the first term is 2 and the new cumulative reciprocal sum is 1/2.

The smallest prime whose reciprocal can be added to the sum without reaching or exceeding 1 is 3. (2 would cause the cumulative reciprocal sum to reach 1.) So the next term is 3, and the new cumulative sum is 5/6.

and so on...

Task

• Find and display the first 10 terms of the sequence. (Or as many as reasonably supported by your language if it is less.) For any values with more than 40 digits, show the first and last 20 digits and the overall digit count.

If any of the tests for primality used in your program are probabilistic please so indicate.

Stretch

• Find and display the next 5 terms of the sequence. (Or as many as you have the patience for.) Show only the first and last 20 digits and the overall digit count.

See also

• OEIS:A075442 - Slowest-growing sequence of primes whose reciprocals sum to 1

Ada

Library: Simple components for Ada

with Ada.Text_IO;                 use Ada.Text_IO;

with Unbounded_Integers;          use Unbounded_Integers;
with Unbounded_Rationals;         use Unbounded_Rationals;
with Unbounded_Unsigneds;         use Unbounded_Unsigneds;
with Unbounded_Unsigneds.Primes;  use Unbounded_Unsigneds.Primes;

with Strings_Edit.Unbounded_Unsigned_Edit;
use  Strings_Edit.Unbounded_Unsigned_Edit;

with Strings_Edit.Unbounded_Rational_Edit;
use  Strings_Edit.Unbounded_Rational_Edit;

procedure Prime_Reciprocal_Sum is

   Count : Natural := 0;
   Sum   : Unbounded_Rational := Unbounded_Rationals.One / 2;
   P     : Unbounded_Unsigned := Unbounded_Unsigneds.Two;
   function "+" (N : Unbounded_Unsigned) return String is
      Result : constant String := Image (N);
   begin
      if Result'Length > 60 then
         return Result (1..20)                         &
                "..."                                  &
                Result (Result'Last - 19..Result'Last) &
                Integer'Image (Result'Length)          &
                " digits";
      else
         return Result;
      end if;
   end "+";
begin
   Put_Line ("2");
   while Count <= 13 loop
      P := Get_Mantissa (Ceiling (Invert (1 - Sum)));
      if Is_Even (P) then
         Add (P, 1);
      end if;
      loop
         if Is_Prime (P, 10) = Prime then
            Sum := Sum + Unbounded_Rationals.One / P;
            Put_Line (+P);
            Count := Count + 1;
            exit;
         end if;
         Add (P, 2);
      end loop;
   end loop;
end Prime_Reciprocal_Sum;

Output:

2
3
7
43
1811
654149
27082315109
153694141992520880899
337110658273917297268061074384231117039
84241975970641143191...13803869133407474043 76 digits
20300753813848234767...91313959045797597991 150 digits
20323705381471272842...21649394434192763213 297 digits
12748246592672078196...20708715953110886963 592 digits
46749025165138838243...65355869250350888941 1180 digits
11390125639471674628...31060548964273180103 2358 digits

ALGOL 68

Works with: ALGOL 68G version Any - tested with release 2.8.3.win32

Uses Algol 68G's LONG LONG INT which has programmer defined precision.
Re-uses code from the Arithmetic/Rational task, modified to use LONG LONG INT.
Also uses Miller-Rabin (probabilistic) primality testing.

Library: ALGOL 68-primes

BEGIN # find a sequence of primes whose members are the smallest prime whose #
      # reciprocal can be added to the sum or the reciprocals of the         #
      # previous primes and the sum remain below 1                           #

    PR precision 5000 PR                # set the precision of LONG LONG INT #
    PR read "primes.incl.a68" PR                   # include prime utilities #

    # iterative Greatest Common Divisor routine, returns the gcd of m and n  #
    PROC gcd = ( LONG LONG INT m, n )LONG LONG INT:
         BEGIN
            LONG LONG INT a := ABS m, b := ABS n;
            WHILE b /= 0 DO
                LONG LONG INT new a = b;
                b        := a MOD b;
                a        := new a
            OD;
            a
        END # gcd # ;

# code from the Arithmetic/Rational task modified to use LONG LONG INT       #
 MODE FRAC = STRUCT( LONG LONG INT num #erator#,  den #ominator# );

  PROC lcm = ( LONG LONG INT a, b )LONG LONG INT:    # least common multiple #
   a OVER gcd(a, b) * b;
 
  PRIO // = 9;                                 # higher then the ** operator #
  OP // = ( LONG LONG INT num, den )FRAC: (       # initialise and normalise #
   LONG LONG INT common = gcd( num, den );
   IF den < 0 THEN
     ( -num OVER common, -den OVER common )
   ELSE
     ( num OVER common, den OVER common )
   FI
 );
 
 OP + = (FRAC a, b)FRAC: (
   LONG LONG INT common = lcm( den OF a, den OF b );
   FRAC result := ( common OVER den OF a * num OF a + common OVER den OF b * num OF b, common );
   num OF result//den OF result
 );

 OP +:= = (REF FRAC a, FRAC b)REF FRAC: ( a := a + b );
 
# end code from the Arithmetic/Rational task modified to use LONG LONG INT   #

    # the sequence starts with the reciprocal of the first prime > 0, i.e. 2 #
    LONG LONG INT one = 1;
    FRAC sum := one // LONG LONG 2;
    print( ( " 1: 2", newline ) );

    # each succeeding prime is the next prime > the denominator of the sum   #
    # divided by the difference of the denominator and the numerator         #
    FOR i FROM 2 TO 15 DO
        LONG LONG INT next := IF num OF sum + 1 = den OF sum
                              THEN den OF sum + 1
                              ELSE ( den OF sum OVER ( den OF sum - num OF sum ) ) + 1
                              FI;
        IF NOT ODD next THEN next +:= 1 FI;
        WHILE NOT is probably prime( next ) DO next +:= 2 OD;
        print( ( whole( i, -2 ), ": " ) );
        STRING prime text = whole( next, 0 );
        IF INT digits = ( UPB prime text - LWB prime text ) + 1;
            digits <= 40
        THEN
            print( ( prime text ) )
        ELSE
            print( ( prime text[ : LWB prime text + 19 ], "..."
                   , prime text[ UPB prime text - 19 : ], "   "
                   , whole( digits, -6 ), " digits"
                   )
                 )
        FI;
        print( ( newline ) );
        sum +:= one // next
    OD

END

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043       76 digits
11: 20300753813848234767...91313959045797597991      150 digits
12: 20323705381471272842...21649394434192763213      297 digits
13: 12748246592672078196...20708715953110886963      592 digits
14: 46749025165138838243...65355869250350888941     1180 digits
15: 11390125639471674628...31060548964273180103     2358 digits

C

Library: GMP

Translation of: Wren

#include <stdio.h>
#include <stdbool.h>
#include <string.h>
#include <gmp.h>

void abbreviate(char a[], const char *s) {
    size_t len = strlen(s);
    if (len < 40) {
        strcpy(a, s);
        return;
    }
    strncpy(a, s, 20);
    strcpy(a + 20, "...");
    strncpy(a + 23, s + len - 20, 21);
}

int main() {
    mpq_t q, r, s, u;
    mpz_t p, t;
    int count = 0, limit = 16;
    size_t len;
    bool isInteger;
    char *ps, a[44];
    mpq_inits(q, r, s, u, NULL);
    mpq_set_ui(u, 1, 1);
    mpz_inits(p, t, NULL);
    printf("First %d elements of the sequence:\n", limit);
    while (count < limit) {
        mpq_sub(q, u, s);
        mpq_inv(q, q);
        mpq_get_den(t, q);
        isInteger = !mpz_cmp_ui(t, 1);
        mpz_set_q(p, q);
        if (!isInteger) mpz_add_ui(p, p, 1);
        mpz_nextprime(p, p);
        ++count;
        ps = mpz_get_str(NULL, 10, p);
        len = strlen(ps);
        if (len <= 40) {
            printf("%2d: %s\n", count, ps);
        } else {
            abbreviate(a, ps);
            printf("%2d: %s (digits: %ld)\n", count, a, len);
        }
        mpq_set_z(r, p);
        mpq_inv(r, r);
        mpq_add(s, s, r);
    }
    mpq_clears(q, r, s, u, NULL);
    mpz_clears(p, t, NULL);
    return 0;
}

Output:

First 16 elements of the sequence:
 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (digits: 76)
11: 20300753813848234767...91313959045797597991 (digits: 150)
12: 20323705381471272842...21649394434192763213 (digits: 297)
13: 12748246592672078196...20708715953110886963 (digits: 592)
14: 46749025165138838243...65355869250350888941 (digits: 1180)
15: 11390125639471674628...31060548964273180103 (digits: 2358)
16: 36961763505630520555...02467094377885929191 (digits: 4711)

C#

Uses the IsProbablyPrime extension to BigInteger from the Miller-Rabin primality test task in C#.

using System.Numerics;
using System.Security.Cryptography;

Console.WriteLine(2);
BigInteger n = 1;
BigInteger d = 2;

while (true)
{
    var p = (d / n) | 1;

    while (!p.IsProbablePrime(10))
    {
        p += 2;
    }

    var s = p.ToString();

    if (s.Length < 40)
        Console.WriteLine(s);
    else
        Console.WriteLine($"{s[..19]}..{s[^19 ..]} ({s.Length} digits)");

    (n, d) = (p * n - d, p * d);
    var g = BigInteger.GreatestCommonDivisor(n, d);
    (n, d) = (n / g, d / g);
}

Output:

2
3
7
43
1811
654149
27082315109
153694141992520880899
337110658273917297268061074384231117039
8424197597064114319..3803869133407474043 (76 digits)
2030075381384823476..1313959045797597991 (150 digits)
2032370538147127284..1649394434192763213 (297 digits)
1274824659267207819..0708715953110886963 (592 digits)
4674902516513883824..5355869250350888941 (1180 digits)

FreeBASIC

Library: GMP

' version 01-11-2024
' compile with: fbc -s console

' mpz_nextprime calls mpz_probab_prime_p to check for prime.
' For GMP versions up to and including 6.1.2, this function performed reps Miller-Rabin tests.
' This is replaced with the Baillie-PSW primality test.

#Include Once "gmp.bi"
#Include Once "crt\stdio.bi"

#Ifndef mpq_numref
    #Define mpq_numref(Q) (@(Q)->_mp_num)
    #Define mpq_denref(Q) (@(Q)->_mp_den)
#EndIf

#Define prec 10000

Const As UInteger limit = 16

Dim As UInteger k
Dim As ZString Ptr gmp_str : gmp_str = Allocate(prec)

Dim As Mpz_ptr sum, prime, t1
prime = Allocate(Len(__Mpz_struct)) : Mpz_init(prime)
t1    = Allocate(Len(__Mpz_struct)) : Mpz_init(t1)

Dim As mpf_ptr f1, f2
f1 = Allocate(Len(__Mpf_struct)) : Mpf_init2(f1, prec * 4)
f2 = Allocate(Len(__Mpf_struct)) : Mpf_init2(f2, prec * 4)

Dim As mpq_ptr q1, q2
q1 = Allocate(Len(__Mpq_struct)) : Mpq_init(q1)
q2 = Allocate(Len(__Mpq_struct)) : Mpq_init(q2)

Print " Slowest-growing sequence of primes whose reciprocals sum to 1. The first "; Str(limit); " primes"

mpq_set_ui(q1, 1, 1)
prime = mpq_denref(q1)

For k = 1 To limit

    mpz_nextprime(prime, prime)
    Mpz_get_str(gmp_str, 10, prime)
    Print Using "###: "; k;
    If Len(*gmp_str) > 40 Then
        Print Left(*gmp_str, 20) & "..." & Right(*gmp_str, 20) & " (digit= " & Str(Len(*gmp_str)) & ")"
    Else
        Print *gmp_str
    End If
    mpf_set_q(f2, q1)
    mpf_add(f1, f1, f2)
    mpf_ui_sub(f2, 1, f1)
    mpq_set_f(q2, f2)
    mpz_Swap (mpq_numref(q2), mpq_denref(q2))
    mpz_set_q(prime, q2)

Next

fflush(stdout)
prime = NULL
mpz_clears(prime, t1, NULL)
mpf_clears(f1, f2, NULL)
mpq_clears(q1, q2, NULL)
DeAllocate(gmp_str)


' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End

Output:

 Slowest-growing sequence of primes whose reciprocals sum to 1. The first 16 primes
  1: 2
  2: 3
  3: 7
  4: 43
  5: 1811
  6: 654149
  7: 27082315109
  8: 153694141992520880899
  9: 337110658273917297268061074384231117039
 10: 84241975970641143191...13803869133407474043 (digit= 76)
 11: 20300753813848234767...91313959045797597991 (digit= 150)
 12: 20323705381471272842...21649394434192763213 (digit= 297)
 13: 12748246592672078196...20708715953110886963 (digit= 592)
 14: 46749025165138838243...65355869250350888941 (digit= 1180)
 15: 11390125639471674628...31060548964273180103 (digit= 2358)
 16: 36961763505630520555...02467094377885929191 (digit= 4711)

FutureBasic

Using FutureBasic 7.0.37

FB GMP/MPFR frameworks and headers (external link)

// ------------------------------------------------------------
//  Prime reciprocal sum
//
//  Using FutureBasic 7.0.37
//  November 2025, R.W.
//
// ------------------------------------------------------------

include "gmp.incl"

CFTimeInterval tim, elapsed

// ------------------------------------------------------------
// Global GMP objects and state
// ------------------------------------------------------------
mpz_t mb                 // unused, but kept from template
mpz_t gPZ                // current prime term
mpz_t gNumZ, gDenZ       // numerator, denominator of q
mpz_t gQuotZ             // floor(num/den) temp

mpq_t gSumQ              // cumulative sum of reciprocals
mpq_t gQ                 // q = 1 / (1 - gSumQ)
mpq_t gR                 // r = 1 / p
long gN                  // how many terms have been obtained

// -----------------------------------------------------------
//  Helper: Abbreviate big numeric CFString: head...tail
// -----------------------------------------------------------
local fn AbbrevString( s as CFStringRef, head as int, ¬
  tail as int ) as CFStringRef
  
  if s == 0 then RETURN @""
  CFStringRef a, b, out
  int nLen
  nLen = len( s )
  if nLen <= head + tail then RETURN s
  a   = left( s, head )
  b   = right( s, tail )
  out = @""
  out = concat( a, @"...", b )
end fn = out

// -----------------------------------------------------------
// Helper: Convert mpz_t to CFString
// -----------------------------------------------------------
local fn mpz_to_CFString( m as mpz_t ) as CFStringRef
  CFStringRef result = @""
  result = fn mpz_cf2( m )  // FB wrapper mpz_t→CFString base 10
end fn = result

// -----------------------------------------------------------
// Helper: returns elapsed time in CFStringRef
// -----------------------------------------------------------
local fn timeElapsed( et as CFTimeInterval ) as CFStringRef
  CFStringRef pline
  if et < 1
    pline = fn StringWithFormat( @"%.3f ms", et * 1000 )
  else
    pline = fn StringWithFormat( @"%.3f secs", et )
  end if
end fn = pline

// ------------------------------------------------------------
//  Next_PR_Term
//  Compute and print the next term in the sequence
//  Uses and updates global gSumQ, gPZ, gN
// ------------------------------------------------------------
void local fn Next_PR_Term
  CFStringRef sVal, sAbbrev, pline
  long        digits
  tim = fn CACurrentMediaTime
  fn mpq_set_ui( gQ, 1, 1 )       // gQ = 1
  fn mpq_sub( gQ, gQ, gSumQ )     // gQ = 1 - gSumQ
  fn mpq_inv( gQ, gQ )            // gQ = 1 / (1 - gSumQ)
  fn mpq_get_num( gNumZ, gQ )     // get q numerator & denominator
  
  fn mpq_get_den( gDenZ, gQ )
  // Decide whether q is integer or not
  if fn mpz_cmp_ui( gDenZ, 1 ) == 0
    // q is an integer: p0 = q
    fn mpz_set( gPZ, gNumZ )
  else
    // q is not integer: p0 = floor(q) + 1 = ceil(q) for positive q
    fn mpz_fdiv_q( gQuotZ, gNumZ, gDenZ )   // floor(num/den)
    fn mpz_add_ui( gPZ, gQuotZ, 1 )         // ceil(q)
  end if
  // Replace p0 by the next prime ≥ p0
  fn mpz_nextprime( gPZ, gPZ )
  // Increment index and print value
  gN++
  sVal   = fn mpz_to_CFString( gPZ )
  digits = len( sVal )
  if digits <= 41
    // Small enough: print full value
    printf @"%2ld: %@", gN, sVal
  else
    pline = @""
    elapsed = fn CACurrentMediaTime - tim
    // Abbreviated: first 20, last 20, plus digit count
    sAbbrev = fn AbbrevString( sVal, 20, 20 )
    pline = fn StringWithFormat(@"%2ld: %@ (digits: %ld)", gN, sAbbrev, digits)
    print pline;
    if digits > 600    // print time
      print @" ";fn timeElapsed( elapsed)
    else
      print @
    end if
  end if
  // Update cumulative sum: gSumQ += 1 / gPZ
  fn mpq_set_z( gR, gPZ )   // gR = p
  fn mpq_inv( gR, gR )      // gR = 1/p
  fn mpq_add( gSumQ, gSumQ, gR )
end fn

// ------------------------------------------------------------
//  More_PR
//  Show the next group when [Next] is clicked
//  Next 5 Prime reciprocal sum
// ------------------------------------------------------------
void local fn More_PR
  long i, max
  // Rosetta requirement, next 5
  max = 5
  if gN < 16
    print @"Next 5 Prime reciprocal sum:\n"
  end if
  i = 0
  while i < max
    fn Next_PR_Term
    i++
  wend
  if i < 6 then button 2, NO
end fn

// ------------------------------------------------------------
//  Main — compute the first 10 Prime reciprocal sum
//  Sequence: smallest prime p_n such that
//            sum_{k<=n} (1/p_k) < 1
// ------------------------------------------------------------
local fn Main
  long k
  
  // Initialize global mpz / mpq only once
  fn mpz_init( mb )
  fn mpz_init( gPZ )
  fn mpz_init( gNumZ )
  fn mpz_init( gDenZ )
  fn mpz_init( gQuotZ )
  
  fn mpq_init( gSumQ )
  fn mpq_init( gQ )
  fn mpq_init( gR )
  
  // gSumQ = 0
  fn mpq_set_ui( gSumQ, 0, 1 )
  gN = 0
  
  print @"\nThe first 10 Prime reciprocal sum:\n"
  tim = fn CACurrentMediaTime
  
  k = 0
  while k < 10
    fn Next_PR_Term
    k++
  wend
  
  elapsed = fn CACurrentMediaTime - tim
  print @"\nElapsed Time: "; fn timeElapsed( elapsed )
  print @"\nClick [Next] for the next group.\n"
end fn

// ------------------------------------------------------------
//  Dialog handler
// ------------------------------------------------------------
void local fn DoDialog( ev as long, tag as long, wnd as long, obj as CFTypeRef )
  select ( ev )
    case _btnClick
      select ( tag )
        case 2
          fn More_PR
      end select
      
    case _windowShouldClose
      // Clear any GMP objects we initialised
      fn mpz_clear( mb )
      fn mpz_clear( gPZ )
      fn mpz_clear( gNumZ )
      fn mpz_clear( gDenZ )
      fn mpz_clear( gQuotZ )
      fn mpq_clear( gSumQ )
      fn mpq_clear( gQ )
      fn mpq_clear( gR )
      end
  end select
end fn

on dialog fn DoDialog

// ------------------------------------------------------------
//  UI setup and kickoff
// ------------------------------------------------------------
window 1, @"Prime reciprocal sum", (0,0,620,500)
button 2, YES,, @"Next", (500,20,100,20),,, 1

fn Main

HandleEvents
//

Output:

The first 10 Prime reciprocal sum:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (digits: 76)

Elapsed Time: 0.357 ms

Click [Next] for the next group.

Next 5 Prime reciprocal sum:

11: 20300753813848234767...91313959045797597991 (digits: 150)
12: 20323705381471272842...21649394434192763213 (digits: 297)
13: 12748246592672078196...20708715953110886963 (digits: 592)
14: 46749025165138838243...65355869250350888941 (digits: 1180) 119.136 ms
15: 11390125639471674628...31060548964273180103 (digits: 2358) 6.462 secs

J

Given:

taskfmt=: {{
  if. 40<#t=. ":y do.
    d=. ":#t
    (20{.t),'..',(_20{.t),' (',d,' digits)'
  else.
    t
  end.
}}@>

The task and stretch could be:

   taskfmt (, 4 p:1%1-+/@:%)^:(15)i.0
2                                                       
3                                                       
7                                                       
43                                                      
1811                                                    
654149                                                  
27082315109                                             
153694141992520880899                                   
337110658273917297268061074384231117039                 
84241975970641143191..13803869133407474043 (76 digits)  
20300753813848234767..91313959045797597991 (150 digits) 
20323705381471272842..21649394434192763213 (297 digits) 
12748246592672078196..20708715953110886963 (592 digits) 
46749025165138838243..65355869250350888941 (1180 digits)
11390125639471674628..31060548964273180103 (2358 digits)

Here, +/@:% is the sum of reciprocals, so 1%1-+/@:% is the reciprocal of the amount remaining, and 4 p:1%1-+/@:% is the smallest prime which is larger than that value.

Tested in J9.4

Java

The Java nextProbablePrime() method guarantees that it never skips over prime numbers and the probability of the number returned by this method not being prime is less than 1 / (2^100), which is approximately 1 / (10^30).

import java.math.BigInteger;

public final class PrimeReciprocalSum {

	public static void main(String[] args) {
		BigRational sum = BigRational.ZERO;
		int count = 0;
		
		while ( count < 15 ) {
			BigInteger minimumValue = BigRational.ONE.subtract(sum).inverse().ceiling();
			BigInteger prime = minimumValue.nextProbablePrime();			
			sum = sum.add( new BigRational(BigInteger.ONE, prime) );
			count += 1;
			System.out.println(String.format("%2s%s%s", count, ": ", compress(prime, 20)));
		}
	}
	
	private static String compress(BigInteger number, int size) {
		String digits = number.toString();
		final int length = digits.length();
		if ( length <= 2 * size )  {
			return digits;
		}		
		return digits.substring(0, size) + " ... " 
			+ digits.substring(length - size) + " (" + length + " digits)";
	}

}

final class BigRational {
	
	public BigRational(BigInteger aNumer, BigInteger aDenom) {
		numer = aNumer;
		denom = aDenom;
		
    	BigInteger gcd = numer.gcd(denom);	    	
    	numer = numer.divide(gcd);
    	denom = denom.divide(gcd);
    }

	public BigRational add(BigRational other) {
		BigInteger num = numer.multiply(other.denom).add(other.numer.multiply(denom));
		BigInteger den = denom.multiply(other.denom);			
		return new BigRational(num, den);
	}
	
	public BigRational subtract(BigRational other) {
		BigInteger num = numer.multiply(other.denom).subtract(denom.multiply(other.numer));
		BigInteger den = denom.multiply(other.denom);
		return new BigRational(num, den);
	}

	public BigRational inverse() {
		return new BigRational(denom, numer);
	}
	
	public BigInteger ceiling() {
		BigInteger[] pair = numer.divideAndRemainder(denom);
		return pair[1].equals(BigInteger.ZERO) ? pair[0] : pair[0].add(BigInteger.ONE);
	}	

	public static final BigRational ZERO = new BigRational(BigInteger.ZERO, BigInteger.ONE);
	public static final BigRational ONE = new BigRational(BigInteger.ONE, BigInteger.ONE);
		
	private BigInteger numer;
	private BigInteger denom;
	
}

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191 ... 13803869133407474043 (76 digits)
11: 20300753813848234767 ... 91313959045797597991 (150 digits)
12: 20323705381471272842 ... 21649394434192763213 (297 digits)
13: 12748246592672078196 ... 20708715953110886963 (592 digits)
14: 46749025165138838243 ... 65355869250350888941 (1180 digits)
15: 11390125639471674628 ... 31060548964273180103 (2358 digits)

jq

Works with jq, the C implementation of jq (*)

Works with gojq, the Go implementation of jq (**)

(*) Using the two programs presented here, the C implementation cannot get beyond the 7th prime in the series because it lacks support for both "big integers" and "big floats".

(**) The `nextPrime` algorithm effectively prevents the Go implementation from generating more than eight primes in the sequence.

gojq does support infinite-precision integer arithmetic, which in principle should allow the first program, which uses rational number arithmetic, to proceed indefinitely but for the slowness of `nextPrime`.

Using rational.jq

The "rational" module referenced here is available at Category:jq/rational.jq.

include "rational" {search:"."};  # see above

# itrunc/0 attempts to compute the "trunc" of the input number in such
# a way that gojq will recognize the result as an integer, while
# leveraging the support that both the C and Go implementations have
# for integer literals.
# It is mainly intended for numbers for which the tostring value does NOT contain an exponent.
# The details are complicated because the goal is to provide portability between jq implementations.
# 
# Input: a number or a string matching ^[0-9]+([.][0-9]*)$
# Output: as specified by the implementation.
def itrunc:
  if type == "number" and . < 0 then - ((-.) | itrunc)
  else . as $in
  | tostring as $s
  | ($s | test("[Ee]")) as $exp
  | ($s | test("[.]")) as $decimal
  | if ($exp|not) and ($decimal|not) then $s | tonumber # do not simply return $in
    elif ($exp|not) and $decimal then $s | sub("[.].*";"") | tonumber
    else trunc
    | tostring
    | if test("[Ee]")
      then if $exp then "itrunc cannot be used on \($in)" | error end
      else tonumber
      end
    end
  end;

# rtrunc is like trunc but for Rational numbers, though the input may be
# either a number or a Rational.
def rtrunc:
  if type == "number" then r(itrunc;1)
  elif 0 == .n or (0 < .n and .n < .d) then r(0;1)
  elif 0 < .n or (.n % .d == 0) then .d as $d | r(.n | idivide($d); 1)
  else rminus( r( - .n; .d) | rtrunc | rminus; 1)
  end;

def is_prime:
  . as $n
  | if ($n < 2)         then false
    elif ($n % 2 == 0)  then $n == 2
    elif ($n % 3 == 0)  then $n == 3
    elif ($n % 5 == 0)  then $n == 5
    elif ($n % 7 == 0)  then $n == 7
    elif ($n % 11 == 0) then $n == 11
    elif ($n % 13 == 0) then $n == 13
    elif ($n % 17 == 0) then $n == 17
    elif ($n % 19 == 0) then $n == 19
    else sqrt as $s
    | 23
    | until( . > $s or ($n % . == 0); . + 2)
    | . > $s
    end;

# Input: any number
# Output: the next prime
def nextPrime:
  if . < 2 then 2
  else itrunc  # for gojq (to ensure result is a Go integer)
  | (if .%2 == 1 then .+2 else .+1 end) as $n
  | first( range($n; infinite; 2) | select(is_prime))
  end;

# Input: a Rational
# Output: an integer
def rnextPrime:
  if rlessthan(r(2;1)) then 2
  else rtrunc
  | .n
  | nextPrime
  end ;
  
def synopsis:
  tostring as $i
  | ($i|length) as $n
  | if $n > 40
    then "\($i[:20]) ... \($i[20:])    (\($n))"
    else $i
    end;

def prs_sequence:
  r(1;1) as $one
  | {p: 0, s: r(0;1)}
  | recurse( 
      .emit = null
      | .count += 1
      | .p = (rminus($one; .s) | rinv | rnextPrime)
      | .s = radd(.s; r(1; .p))
      | .emit = .p )
  | select(.emit).emit ;

16 as $n
| "First \($n) elements of the sequence:", 
  limit($n; prs_sequence)

Output:

The following output was generated using gojq.

First 16 elements of the sequence:
2
3
7
43
1811
654149
27082315109
153694141992520880899
(execution terminated)

Using floats

The program is essentially as above, except that the directive for including the "rational" module can be omitted, and the `prs_sequence` function is replaced by the following definition:

def prs_sequence:
  {p: 0, s: 0}
  | recurse( 
      .emit = null
      | .count += 1
      | .p = ((1 / (1 - .s)) | nextPrime)
      | .s += (1 / .p)
      | if .s >= 1 then "Insufficient precision to proceed"|error end
      | .emit = .p )
  | select(.emit).emit;

"First 16 elements of the sequence:"
2
3
7
43
1811
654149
27082315109
(program halted)

Julia

""" rosettacode.org/wiki/Prime_reciprocal_sum """

using Primes
using ResumableFunctions

""" Abbreviate a large string by showing beginning / end and number of chars """
function abbreviate(s; ds = "digits", t = 40, x = (t - 1) ÷ 2)
    wid = length(s)
    return wid < t ? s : s[begin:begin+x] * ".." * s[end-x:end] * " ($wid $ds)"
end

@resumable function generate_oeis75442()
    psum = big"0" // big"1"
    while true
        n = BigInt(ceil(big"1" // (1 - psum)))
        while true 
            n = nextprime(n + 1)
            if psum + 1 // n < 1
                psum += 1 // n
                @yield n
                break
            end
        end
    end
end

for (i, n) in enumerate(Iterators.take(generate_oeis75442(), 17))
    println(lpad(i, 2), ": ", abbreviate(string(n)))
end

Output:

 1: 2   
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)
15: 11390125639471674628..31060548964273180103 (2358 digits)
16: 36961763505630520555..02467094377885929191 (4711 digits)
17: 21043364724798439508..14594683820359204509 (9418 digits)

Mathematica / Wolfram Language

next[primeList_] := Append[primeList, NextPrime[Ceiling[1 / (1 - Total[1 / primeList])]]];

format[n_] := With[{s = ToString[n]}, If[StringLength[s] <= 40, s,
    StringForm["``...`` (`` digits)", StringTake[s, 20], StringTake[s, -20], StringLength[s]]]];

Map[format, NestList[next, {2}, 14][[All, -1]]] // TableForm

Output:

2
3
7
43
1811
654149
27082315109
153694141992520880899
337110658273917297268061074384231117039
84241975970641143191...13803869133407474043 (76 digits)
20300753813848234767...91313959045797597991 (150 digits)
20323705381471272842...21649394434192763213 (297 digits)
12748246592672078196...20708715953110886963 (592 digits)
46749025165138838243...65355869250350888941 (1180 digits)
11390125639471674628...31060548964273180103 (2358 digits)

Nim

Library: bignum

import std/strformat
import bignum

iterator a075442(): Int =
  let One = newRat(1)
  var sum = newRat(0)
  var p = newInt(0)
  while true:
    let q = reciprocal(One - sum)
    p = nextPrime(if q.isInt: q.num else: q.toInt + 1)
    yield p
    sum += newRat(1, p)

func compressed(str: string; size: int): string =
  ## Return a compressed value for long strings of digits.
  if str.len <= 2 * size: str
  else: &"{str[0..<size]}...{str[^size..^1]} ({str.len} digits)"

var count = 0
for p in a075442():
  inc count
  echo &"{count:2}: {compressed($p, 20)}"
  if count == 15: break

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (76 digits)
11: 20300753813848234767...91313959045797597991 (150 digits)
12: 20323705381471272842...21649394434192763213 (297 digits)
13: 12748246592672078196...20708715953110886963 (592 digits)
14: 46749025165138838243...65355869250350888941 (1180 digits)
15: 11390125639471674628...31060548964273180103 (2358 digits)

PARI/GP

\p5000
x=1.; v=vector(15, n, p=if(n<3, prime(n), nextprime(1/x)); x-=1/p; p);
firstandlast(n, first=20, last=first)=my(d=digits(n)); Str(strjoin(d[1..first]), "...", strjoin(d[#d-last+1..#d]))
v[1..10]
apply(firstandlast, v[11..15])

Output:

%1 = [2, 3, 7, 43, 1811, 654149, 27082315109, 153694141992520880899, 337110658273917297268061074384231117039, 8424197597064114319193772925959967322398440121059128471513803869133407474043]
%2 = ["20300753813848234767...91313959045797597991", "20323705381471272842...21649394434192763213", "12748246592672078196...20708715953110886963", "46749025165138838243...65355869250350888941", "11390125639471674628...31060548964273180103"]

Pascal

Free Pascal

Most time consuming is finding the next prime.
Now pre-sieving with the primes til 65535, to reduce tests.
That is the same as checking all numbers in sieve as divisible by the small primes.Since the prime are in big distance in that region, that's an improvement.

program primeRezSum;
{$IFDEF FPC}  {$MODE DELPHI}{$Optimization ON,ALL} {$ENDIF}
{$IFDEF WINDOWS}{$APPTYPE CONSOLE}{$ENDIF}
uses
  sysutils,
  gmp;
const
  PrimeCount =   6542;
  PRIMEMAXVAL = 65535;
  SIEVESIZE = 65536;
type
  Tsieveprime = record
                  prime,
                  offset : Uint16;
                end;
  tSievePrimes = array[0..PrimeCount-1] of Tsieveprime;
  tSieve       = array[0..SIEVESIZE-1] of byte;
var
  s : AnsiString;
  MyPrimes : tSievePrimes;
  sieve : tSieve;
procedure OutStr(const s: AnsiString);
var
  myString : AnsiString;
  l : Integer;
begin
  myString := copy(s,1,length(s));
  l :=length(pChar(@s[1]));
  setlength(myString,l);
  IF l< 41 then
    writeln(myString)
  else
  begin
    myString[20]:= #0;
    myString[21]:= #0;
    writeln(pChar(@myString[1]),'...',pChar(@myString[l-19]),' (',l:6,' digits)');
  end;
end;

function InitPrimes:Uint32;
var
  f : extended;
  idx,p,pr_cnt : Uint32;
Begin
  fillchar(sieve,Sizeof(sieve),#0);
  pr_cnt := 0;
  p := 2;
  f := 1.0;
  repeat
     while Sieve[p]<> 0 do
       inc(p);
     MyPrimes[pr_cnt].prime := p;
     f := f*(p-1)/p;
     inc(pr_cnt);
     idx := p*p;
     if idx > PRIMEMAXVAL then
       Break;
     repeat
       sieve[idx] := 1;
       inc(idx,p);
     until idx > high(sieve);
     inc(p);
  until sqr(p)>PRIMEMAXVAL;

  while (pr_cnt<= High(MyPrimes)) AND (p<PRIMEMAXVAL)  do
  begin
    while Sieve[p]<> 0 do
      inc(p);
    MyPrimes[pr_cnt].prime := p;
    f := f*(p-1)/p;
    inc(p);
    inc(pr_cnt);
  end;
  Writeln ('reducing factor ',f:10:8);
  result := pr_cnt-1;
end;

procedure DoSieveOffsetInit(var tmp:mpz_t);
var
  dummy :mpz_t;
  i,j,p : Uint32;
Begin
  mpz_init(dummy);
  for i := 0 to High(MyPrimes) do
    with MyPrimes[i] do
    Begin
      if prime = 0 then  Begin  writeln(i);halt;end;
      offset := prime-mpz_tdiv_q_ui(dummy,tmp,prime);
    end;
  mpz_set(dummy,tmp);
  repeat
    //one sieve
    fillchar(sieve,Sizeof(sieve),#0);
    //sieve
    For i := 0 to High(MyPrimes) do
    begin
      with MyPrimes[i] do
      begin
        p := prime;
        j := offset;
      end;
      repeat
        sieve[j] := 1;
        j += p;
      until j >= SIEVESIZE;
      MyPrimes[i].offset := j-SIEVESIZE;
    end;

    j := 0;
    For i := 0 to High(sieve) do
    begin
//  function mpz_probab_prime_p(var n: mpz_t; reps: longint): longint;1 = prime
      if (sieve[i]= 0) then
      begin
        mpz_add_ui(dummy,dummy,i-j);
        j := i;
        if (mpz_probab_prime_p(dummy,1) >0)  then
        begin
          mpz_set(tmp,dummy);
          mpz_clear(dummy);
          EXIT;
        end;
      end;
    end;
  until false;
end;

var
  nominator,denominator,tmp,tmpDemP,p : mpz_t;
  T1,T0:Int64;
  cnt : NativeUint;
begin
  InitPrimes;
  setlength(s,100000);
  cnt := 1;
  mpz_init(nominator);
  mpz_init(tmp);
  mpz_init(tmpDemP);
  mpz_init_set_ui(denominator,1);
  mpz_init_set_ui(p,1);

  repeat
    mpz_set(tmpDemP,p);
    T0 := GetTickCount64;
    if cnt > 9 then
      DoSieveOffsetInit(p)
    else
      mpz_nextprime(p,p);
    T1 := GetTickCount64;
    write(cnt:3,'  ',T1-T0,' ms ,delta ');
    mpz_sub(tmpDemP,p,tmpDemP);
    mpz_get_str(pChar(@s[1]),10, tmpDemP); OutStr(s);
    mpz_get_str(pChar(@s[1]),10, p); OutStr(s);
    if cnt >=15 then
      Break;
    repeat
      mpz_mul(tmp,nominator,p);
      mpz_add(tmp,tmp,denominator);
      mpz_mul(tmpDemP,denominator,p);
      if mpz_cmp(tmp,tmpDemP)< 0 then
        BREAK;
      mpz_add_ui(p,p,1);
    until false;
    mpz_set(nominator,tmp);
    mpz_mul(denominator,denominator,p);

    //next smallest possible number denominator/delta
    mpz_sub(tmp,denominator,nominator);
    mpz_fdiv_q(p,denominator,tmp);

    inc(cnt);
  until cnt> 17;
end.

@TIO.RUN:

reducing factor 0.05041709
  1  0 ms ,delta 1
2
  2  0 ms ,delta 1
3
  3  0 ms ,delta 1
7
  4  0 ms ,delta 1
43
  5  0 ms ,delta 5
1811
  6  0 ms ,delta 16
654149
  7  0 ms ,delta 5
27082315109
  8  0 ms ,delta 71
153694141992520880899
  9  1 ms ,delta 14
337110658273917297268061074384231117039
 10  1 ms ,delta 350
8424197597064114319...13803869133407474043 (    76 digits)
 11  1 ms ,delta 203
2030075381384823476...91313959045797597991 (   150 digits)
 12  3 ms ,delta 33
2032370538147127284...21649394434192763213 (   297 digits)
 13  69 ms ,delta 348
1274824659267207819...20708715953110886963 (   592 digits)
 14  234 ms ,delta 192
4674902516513883824...65355869250350888941 (  1180 digits)
 15  20391 ms ,delta 3510
1139012563947167462...31060548964273180103 (  2358 digits)

Real time: 21.024 s User time: 20.768 s Sys. time: 0.067 s CPU share: 99.10 %

@home (4.4Ghz 5600G  ) modified with primes up to 1E6 ( Uint16-> Uint32 )
     78498    999979 reducing factor 0.04059798
...
 15  10015 ms ,delta 3510  // first guess than searching for next prime 
1139012563947167462...31060548964273180103 (  2358 digits)
   1731172    999979
 16  110030 ms ,delta 6493
3696176350563052055...02467094377885929191 (  4711 digits)
 17 5098268 ms ,delta 55552 // first guess than searching for next prime 
2104336472479843950...14594683820359204509 (  9418 digits)

Perl

use strict; use warnings; use feature 'state';
use Math::AnyNum <next_prime ceil>;

sub abbr { my $d=shift; my $l = length $d; $l < 41 ? $d : substr($d,0,20) . '..' . substr($d,-20) . " ($l digits)" }

sub succ_prime {
    state $sum = 0;
    my $next = next_prime ceil( 1 / (1-$sum) );
    $sum += 1/$next;
    $next
}

printf "%2d: %s\n", $_, abbr succ_prime for 1..14;

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)

Phix

The Julia entry took over 4 hours to get the 17th on this box, so I just went with "keep it all under 10s"...
(As others have alluded, it is all about getting the next prime. Even should you land on one straightaway, it still takes quite some time to prove an n-thousand digit number is probably prime - the standard prime tests are only deterministic to 3,317,044,064,679,887,385,961,981 but at least the 9th and later results agree with others on this page.

with javascript_semantics
constant limit = iff(platform()=JS?12:14)
include mpfr.e
mpq {q, r, s, u} = mpq_inits(4,{0,0,0,1})
mpz {p, t} = mpz_inits(2)
printf(1,"First %d elements of the sequence:\n", limit);
for count=1 to limit do
    mpq_sub(q, u, s)
    mpq_inv(q, q)
    mpq_get_den(t, q)
    mpz_set_q(p, q)
    if mpz_cmp_si(t, 1) then mpz_add_si(p, p, 1) end if
    mpz_nextprime(p, p)
    printf(1,"%2d: %s\n", {count, mpz_get_short_str(p)})
    mpq_set_z(r, p)
    mpq_inv(r, r)
    mpq_add(s, s, r)
end for

Output:

First 14 elements of the sequence:
 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (76 digits)
11: 20300753813848234767...91313959045797597991 (150 digits)
12: 20323705381471272842...21649394434192763213 (297 digits)
13: 12748246592672078196...20708715953110886963 (592 digits)
14: 46749025165138838243...65355869250350888941 (1,180 digits)

If you've really got nothing better to do, you can also get, in 10 mins on 64-bit, thrice that on 32-bit:

15: 11390125639471674628...31060548964273180103 (digits: 2358)
16: 36961763505630520555...02467094377885929191 (digits: 4711)

Pluto

Translation of: Wren

Library: Pluto-bignum

Library: Pluto-fmt

Run time 1 minute 36 seconds on my machine (core i7).

require "bignum"
local fmt = require "fmt"

mpz.init()
local p, q, r
local s = bigrat.of(0)
local count = 0
local limit = 16
fmt.print("First %d elements of the sequence:", limit)
while count < limit do
    q = (bigrat.of(1) - s):inverse()
    if q:isint() then
        p = q:tobigint()
    else
        p = q:tobigint() + 1
    end
    p = mpz.nextprime(p)
    count += 1
    local ps = mpz.tostring(p)
    fmt.write("%2d: %s", count, fmt.abridge(ps, 20))
    if #ps > 40 then
        fmt.print(" (digits: %d)", #ps)
    else
        print()
    end
    r = bigrat.of(p):inverse()
    s += r
end

Output:

First 16 elements of the sequence:
 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (digits: 76)
11: 20300753813848234767...91313959045797597991 (digits: 150)
12: 20323705381471272842...21649394434192763213 (digits: 297)
13: 12748246592672078196...20708715953110886963 (digits: 592)
14: 46749025165138838243...65355869250350888941 (digits: 1180)
15: 11390125639471674628...31060548964273180103 (digits: 2358)
16: 36961763505630520555...02467094377885929191 (digits: 4711)

Python

''' rosettacode.org/wiki/Prime_reciprocal_sum '''
from fractions import Fraction
from sympy import nextprime


def abbreviated(bigstr, label="digits", maxlen=40, j=20):
    ''' Abbreviate string by showing beginning / end and number of chars '''
    wid = len(bigstr)
    return bigstr if wid <= maxlen else bigstr[:j] + '..' + bigstr[-j:] + f' ({wid} {label})'


def ceil(rat):
    ''' ceil function for Fractions '''
    return rat.numerator if rat.denominator == 1 else rat.numerator // rat.denominator + 1


psum = Fraction(0, 1)
for i in range(1, 15):  # get first 14 in sequence
    next_in_seq = nextprime(ceil(Fraction(1, 1 - psum)))
    psum += Fraction(1, next_in_seq)
    print(f'{i:2}:', abbreviated(str(next_in_seq)))

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)

Raku

The sixteenth is very slow to emerge. Didn't bother trying for the seventeenth. OEIS only lists the first fourteen values.

sub abbr ($_) { .chars < 41 ?? $_ !! .substr(0,20) ~ '..' ~ .substr(*-20) ~ " ({.chars} digits)" }

sub next-prime {
    state $sum = 0;
    my $next = ((1 / (1 - $sum)).ceiling+1..*).hyper(:2batch).grep(&is-prime)[0];
    $sum += FatRat.new(1,$next);
    $next;
}

printf "%2d: %s\n", $_, abbr next-prime for 1..15;

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)
15: 11390125639471674628..31060548964273180103 (2358 digits)
16: 36961763505630520555..02467094377885929191 (4711 digits)

RPL

Limited floating-point precision prevents from finding the correct 7th term. Program starts with a non-empty sequence to avoid the ∑LIST calculation bug that occurs when the input list has less than two items.

Works with: HP version 49g

≪ {2 3} 
   1 4 START 1 OVER INV ∑LIST - INV →NUM IP NEXTPRIME + NEXT
≫ '∑INVPR' STO

Output:

1: {2 3 7 43 1811 654149} 

Rust

Translation of: Julia

use num_bigint::{BigInt, Sign};
use num_prime::{nt_funcs::next_prime, PrimalityTestConfig};
use num_rational::BigRational;
use num_traits::{Inv, One};

/// Abbreviate a large string by showing beginning / end and number of chars
fn abbreviate(st: String) -> String {
    const MAX_WIDTH: usize = 40;
    let w = st.len();
    if w < MAX_WIDTH {
        return st;
    }
    let s = st.as_str();
    let x = (MAX_WIDTH + 1) / 2;
    return String::new() + &s[..x] + ".." + &s[w - x..] + &format!(" ({} digits)", w);
}

fn oeis75442(wanted: usize) {
    let mut prime_sum = BigRational::new(BigInt::ZERO, BigInt::one());
    let config = PrimalityTestConfig::default();
    let one = BigRational::from(BigInt::one());
    for i in 1..=wanted {
        let mut n = (one.clone() - prime_sum.clone())
            .inv()
            .ceil()
            .numer()
            .to_owned();
        loop {
            n = BigInt::from_biguint(
                Sign::Plus,
                next_prime(&(BigInt::from(n).to_biguint().unwrap()), Some(config)).unwrap(),
            );
            let m = BigRational::from(n.clone()).inv();
            if prime_sum.clone() + m.clone() < one {
                prime_sum += m;
                println!("{:2} : {}", i, abbreviate(n.to_string()));
                break;
            }
        }
    }
}

fn main() {
    oeis75442(17);
}

Output:

 1 : 2
 2 : 3
 3 : 7
 4 : 43
 5 : 1811
 6 : 654149
 7 : 27082315109
 8 : 153694141992520880899
 9 : 337110658273917297268061074384231117039
10 : 84241975970641143191..13803869133407474043 (76 digits)
11 : 20300753813848234767..91313959045797597991 (150 digits)
12 : 20323705381471272842..21649394434192763213 (297 digits)
13 : 12748246592672078196..20708715953110886963 (592 digits)
14 : 46749025165138838243..65355869250350888941 (1180 digits)
15 : 11390125639471674628..31060548964273180103 (2358 digits)
16 : 36961763505630520555..02467094377885929191 (4711 digits)
17 : 21043364724798439508..14594683820359204509 (9418 digits)

Sidef

var A075442 = Enumerator({|callback|
    var sum = 0
    loop {
        var p = next_prime(ceil(1/(1-sum)))
        sum += 1/p
        callback(p)
    }
})

A075442.first(15).each_kv {|k,n|
    var s = Str(n)
    s = "#{s.first(20)}..#{s.last(20)} (#{s.len} digits)" if (s.len > 50)
    say "#{'%2d' % k+1}: #{s}"
}

Output:

 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191..13803869133407474043 (76 digits)
11: 20300753813848234767..91313959045797597991 (150 digits)
12: 20323705381471272842..21649394434192763213 (297 digits)
13: 12748246592672078196..20708715953110886963 (592 digits)
14: 46749025165138838243..65355869250350888941 (1180 digits)
15: 11390125639471674628..31060548964273180103 (2358 digits)

Uiua

No bigints, so this is as far as we can take it.

1 [] ▽=⊣⊸⊸°/×↘2⇡ 1000000
⊙◌⇌◌⍢(⨬(⋅⊙⊙⋅|⊙˜⊂-)◡>⊃⋅⋅(˜÷1)⊙⊙∘⊙⊙°⊂|>₀⋅⋅⧻)

Output:

[2 3 7 43 1811 654149]

Wren

Library: Wren-gmp

Library: Wren-fmt

Even with GMP takes about 4½ minutes to find the first 16.

GMP’s mpz_nextprime function (which Wren is calling under the hood) uses a probabilistic algorithm to identify primes but, in practice, the chance of a composite number passing is extremely small and should be nil for numbers less than 2^64.

import "./gmp" for Mpz, Mpq
import "./fmt" for Fmt

var q = Mpq.new()
var p = Mpz.new()
var r = Mpq.new()
var s = Mpq.new()
var count = 0
var limit = 16
Fmt.print("First $d elements of the sequence:", limit)
while (count < limit) {
     q.set(Mpq.one.sub(s)).inv
     var isInteger = (q.den == Mpz.one)
     if (isInteger) p.set(q.toMpz) else p.set(q.toMpz.inc)
     p.nextPrime(p)
     count = count + 1
     var ps = p.toString
     Fmt.write("$2d: $20a", count, p)
     if (ps.count > 40) {
        Fmt.print(" (digits: $d)", ps.count)
     } else {
        System.print()
     }
     r.set(p).inv
     s.add(r)
}

Output:

First 16 elements of the sequence:
 1: 2
 2: 3
 3: 7
 4: 43
 5: 1811
 6: 654149
 7: 27082315109
 8: 153694141992520880899
 9: 337110658273917297268061074384231117039
10: 84241975970641143191...13803869133407474043 (digits: 76)
11: 20300753813848234767...91313959045797597991 (digits: 150)
12: 20323705381471272842...21649394434192763213 (digits: 297)
13: 12748246592672078196...20708715953110886963 (digits: 592)
14: 46749025165138838243...65355869250350888941 (digits: 1180)
15: 11390125639471674628...31060548964273180103 (digits: 2358)
16: 36961763505630520555...02467094377885929191 (digits: 4711)