# Sisyphus sequence

Sisyphus sequence
You are encouraged to solve this task according to the task description, using any language you may know.

The Sisyphus sequence is an infinite sequence of positive integers that was devised in 2022 by Eric Angelini and Carole Dubois.

The first term is 1. Subsequent terms are found by applying the following rule:

• If the previous term was even, then halve it.
• If the previous term was odd, then add the smallest prime number that has not yet been added.

1 is odd and so the second term is: 1 + 2 = 3, because 2 is the smallest prime not yet added.

3 is odd and so the third term is: 3 + 3 = 6, because 3 is the smallest prime not yet added.

6 is even and so the fourth term is : 6 ÷ 2 = 3, and so on.

Find and show on this page (in 10 lines of 10 terms), the first 100 terms of the sequence.

What are the 1,000th, 10,000th, 100,000th and 1,000,000th terms of the sequence and, in each case, what is the highest prime needed to reach them?

If it is difficult or impossible for your language or output device to meet all of these requirements, then just do what you reasonably can.

Stretch

What are the 10 millionth and 100 millionth terms and the highest prime needed to reach each one?

By the time the 100 millionth term is reached, which number(s) under 250:

• Have not yet occurred in the sequence.
• Have occurred the most times and their number of occurrences.

Extreme stretch

What is the number of the first term to equal 36?

This was originally set as a challenge by Neil Sloane who was worried by its non-appearance and found by Russ Cox.

References

## ALGOL 68

Using a "generous" estimate of the number of primes required to reach the sequence element 100 000 000 (see the Wren sample).
Note that a sieve size of 1 000 000 000 is not possible with Algol 68G (so you'll need to use another compiler), though a sieve size of 100 000 000 is allowed - specify e.g.: `-heap 768M` on the command line. It took in the region of 2-3 minutes for Algol 68G to find the elements up to 10 000 000 on a Windows 11 laptop.
This sample also shows first the positions of 1..100 in the sequence - apart from the values which don't appear up to element 100 000 000, some of them are quite a long way into the sequence before they appear.

```BEGIN # generate elements of the Sysiphus Sequence: see OEIS A350877         #

# returns the largest element in a                                       #
OP   MAX = ( []INT a )INT:
IF LWB a >UPB a THEN 0
ELSE
INT result := a[ LWB a ];
FOR i FROM LWB a + 1 TO UPB a DO
IF result < a[ i ] THEN result := a[ i ] FI
OD;
result
FI # MAX # ;
# sieve the primes                                                       #
INT sieve max = 1 000 000 000; ### CHANGE TO E.G.: 100 000 000 FOR ALGOL 68G ###
BOOL is odd  := TRUE;
[ sieve max ]BOOL sieve; FOR i TO UPB sieve DO sieve[ i ] := is odd; is odd := NOT is odd OD;
sieve[ 1 ] := FALSE;
sieve[ 2 ] := TRUE;
FOR s FROM 3 BY 2 TO ENTIER sqrt( sieve max ) DO
IF sieve[ s ] THEN
FOR p FROM s * s BY s TO sieve max DO sieve[ p ] := FALSE OD
FI
OD;
[ 1 : 250 ]INT pos;                # positions of 1..250 in the sequence #
[ 1 : 250 ]INT occurs;            # occurances of 1..250 in the sequence #
FOR i TO UPB pos DO pos[ i ] := occurs[ i ] := 0 OD;
INT max count = sieve max OVER 10;            # highest element required #
INT s               := 1;            # the first element is defined as 1 #
INT count           := 1;               # count of elements found so far #
print( ( "Sysiphus sequence - first 100 elements:", newline ) );
print( ( whole( s, -4 ) ) );
pos[ s ]            := count;
INT next to show    := 1000;          # next power-of-10 element to show #
INT last used prime := 0;                   # latest prime from the list #
INT p pos           := 0;                # current position in the sieve #
WHILE count < max count DO
# calculate the next element                                         #
IF NOT ODD s THEN
# the previous element was even - halve it                       #
s OVERAB 2
ELSE
# the previous element was odd: add the next prime from the list #
WHILE p pos +:= 1;
NOT sieve[ p pos ]
DO SKIP OD;
s +:= ( last used prime := p pos )
FI;
count +:= 1;
IF count <= 100 THEN            # have one of the first 100 elements #
print( ( whole( s, -4 ) ) );
IF count MOD 10 = 0 THEN print( ( newline ) ) FI;
IF count = 100      THEN print( ( newline ) ) FI
ELIF count = next to show THEN
# reached a power of ten count                                   #
print( ( "sequence element ", whole( count, -10 )
, " is ", whole( s, -10 )
, ", highest used prime is ", whole( last used prime, -10 )
, newline
)
);
next to show *:= 10
FI;
IF s < UPB pos THEN
IF pos[ s ] = 0 THEN
# have the first appearence of s in the sequence             #
pos[ s ] := count
FI;
occurs[ s ] +:= 1
FI
OD;
print( ( newline ) );
print( ( "Integers in 1..", whole( UPB pos, 0 )
, " not found in the sequence up to element ", whole( max count, 0 )
, ":", newline
)
);
FOR i TO UPB pos DO
IF pos[ i ] = 0 THEN print( ( " ", whole( i, 0 ) ) ) FI
OD;
print( ( newline ) );
INT max occurs = MAX occurs;
print( ( "Integers in 1..", whole( UPB pos, 0 )
, " that occur most often ( ", whole( max occurs, 0 )
, " times ) up to element ", whole( max count, 0 )
, ":", newline
)
);
FOR i TO UPB occurs DO
IF occurs[ i ] = max occurs THEN print( ( " ", whole( i, 0 ) ) ) FI
OD;
print( ( newline, newline ) );
print( ( "Position in the sequence of 1..100 up to element ", whole( max count, 0 )
, ":", newline
)
);
FOR i TO 100 DO
print( ( IF pos[ i ] = 0 THEN " unknown" ELSE whole( pos[ i ], -8 ) FI ) );
IF i MOD 8 = 0 THEN print( ( newline ) ) FI
OD
END```
Output:
```Sysiphus sequence - first 100 elements:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

sequence element       1000 is        990, highest used prime is       2273
sequence element      10000 is      24975, highest used prime is      30713
sequence element     100000 is     265781, highest used prime is     392111
sequence element    1000000 is    8820834, highest used prime is    4761697
sequence element   10000000 is   41369713, highest used prime is   55900829
sequence element  100000000 is 1179614168, highest used prime is  640692323

Integers in 1..250 not found in the sequence up to element 100000000:
36 72 97 107 115 127 144 167 194 211 214 230 232 250
Integers in 1..250 that occur most often ( 7 times ) up to element 100000000:
7 14 28

Position in the sequence of 1..100 up to element 100000000:
1       7       2       6      71       3      25       5
22      70      30      13     345      24      27      16
161      21     148      69      32      29      51      43
1154     344  161336      23      34      26      48     737
156     160      36 unknown      63     147      38      68
234      31      40      28      53      50     126      42
639    1153      58     343      73  161335      88     111
108      33     135  614667     192      47      65     736
60     155     454     159     186      35      97 unknown
78      62    2340     146     143      37   24841      67
476     233     433   10579     140      39     359     169
85      52      80      49     195     125     166      41
unknown     638     204    1152
```

Using Algol 68G with max sieve set to 100 000 000 (sequence elements up to 10 000 000) is as above, except for the missing elements and counts of occurrences (and obviously, the line showing the 100 000 000th element is not present):

```Integers in 1..250 not found in the sequence up to element 10000000:
36 72 97 107 115 127 144 167 194 211 214 223 230 232 250
Integers in 1..250 that occur most often ( 6 times ) up to element 10000000:
3 57 65 85 114 125 130 170 228
```

## C++

Library: Primesieve
```#include <algorithm>
#include <iomanip>
#include <iostream>

#include <primesieve.hpp>

class sisyphus_iterator {
public:
uint64_t next() {
uint64_t n = next_;
if (next_ % 2 == 0) {
next_ /= 2;
} else {
prime_ = pi_.next_prime();
next_ += prime_;
}
return n;
}
uint64_t prime() const { return prime_; }

private:
primesieve::iterator pi_;
uint64_t next_ = 1;
uint64_t prime_ = 0;
};

int main() {
std::cout.imbue(std::locale(""));
sisyphus_iterator si;
int found[250] = {};
std::cout << "The first 100 members of the Sisyphus sequence are:\n";
uint64_t count = 1;
const uint64_t limit = 100000000;
for (uint64_t n = 1000; n <= limit; ++count) {
uint64_t next = si.next();
if (next < 250)
++found[next];
if (count <= 100) {
std::cout << std::setw(3) << next << (count % 10 == 0 ? '\n' : ' ');
if (count == 100)
std::cout << '\n';
} else if (count == n) {
std::cout << std::setw(11) << n << "th member is " << std::setw(13)
<< next << " and highest prime needed is "
<< std::setw(11) << si.prime() << '\n';
n *= 10;
}
}
auto f = [&found](int n) {
bool first = true;
for (int i = 1; i < 250; ++i) {
if (found[i] == n) {
if (first)
first = false;
else
std::cout << ", ";
std::cout << i;
}
}
};
std::cout << "\nThese numbers under 250 do not occur in the first " << limit
<< " terms:\n";
f(0);
int max = *std::max_element(std::begin(found), std::end(found));
std::cout << "\n\nThese numbers under 250 occur the most in the first "
<< limit << " terms:\n";
f(max);
std::cout << " all occur " << max << " times.\n\n";
for (;; ++count) {
uint64_t next = si.next();
if (next == 36) {
std::cout << count << "th member is " << 36
<< " and highest prime needed is " << si.prime() << '\n';
break;
}
}
}
```
Output:
```The first 100 members of the Sisyphus sequence are:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

1,000th member is           990 and highest prime needed is       2,273
10,000th member is        24,975 and highest prime needed is      30,727
100,000th member is       265,781 and highest prime needed is     392,113
1,000,000th member is     8,820,834 and highest prime needed is   4,761,697
10,000,000th member is    41,369,713 and highest prime needed is  55,900,837
100,000,000th member is 1,179,614,168 and highest prime needed is 640,692,323

These numbers under 250 do not occur in the first 100,000,000 terms:
36, 72, 97, 107, 115, 127, 144, 167, 194, 211, 214, 230, 232

These numbers under 250 occur the most in the first 100,000,000 terms:
7, 14, 28 all occur 7 times.

77,534,485,877th member is 36 and highest prime needed is 677,121,348,413
```

## EasyLang

```func 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
.
prim = 1
proc nextprim . .
repeat
prim += 1
until isprim prim = 1
.
.
numfmt 0 4
n = 1
write n
for i = 2 to 100
if n mod 2 <> 0
nextprim
n += prim
else
n /= 2
.
write n
if i mod 10 = 0
print ""
.
.```

## J

Simplistic implementation:

```sisyphuseq=: {{
r=.  1
P=: _1
while. y>#r do. p=. {:P
if. 2|N=. {:r do.
P=: P, p=. 1+p
r=. r,N+p:p
else.
P=: P, p
r=. r,-:N
end.
end.
}}
```

```   seq=: sisyphuseq 1e6
10 10\$seq   NB. first 100 members of sequence
1   3  6   3  8   4   2   1   8  4
2   1 12   6  3  16   8   4   2  1
18   9 28  14  7  30  15  44  22 11
42  21 58  29 70  35  78  39  86 43
96  48 24  12  6   3  62  31  92 46
23  90 45 116 58  29 102  51 130 65
148  74 37 126 63 160  80  40  20 10
5 106 53 156 78  39 146  73 182 91
204 102 51 178 89 220 110  55 192 96
48  24 12   6  3 142  71 220 110 55
x:(,. (seq {~ <:),. P p:@{~ <:) 1e3 1e4 1e5 1e6  NB. nth elements of sequence and corresponding largest prime used
1000     990    2273
10000   24975   30713
100000  265781  392111
1000000 8820834 4761697
```

## Java

Using a segmented prime iterator enables the extreme stretch task to be completed in approximately 70 minutes without using any external libraries.

```import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public final class SisyphusSequence {

public static void main(String[] args) {
final long limit = 100_000_000;
SisyphusIterator iterator = new SisyphusIterator(1_000_000_000_000L);
System.out.println("The first 100 members of the Sisyphus sequence are:");
int[] found = new int[250];
long next = 0;
long count = 0;
int target = 1_000;

while ( target <= limit ) {
count += 1;
next = iterator.next();
if ( next < 250 ) {
found[(int) next]++;
}
if ( count <= 100 ) {
System.out.print(String.format("%3d%s", next, ( count % 10 == 0 ? "\n" : " ")));
if ( count == 100 ) {
System.out.println();
}
} else if ( count == target ) {
target *= 10;
System.out.println(String.format("%11d%s%11d%s%10d",
target, "th member is ", next, " and highest prime needed is ", iterator.getPrime()));
}
}

display(found, 0, target, "These numbers under 250 occur the most in the first ", "");

final int max = Arrays.stream(found).max().orElseThrow();
display(found, max, target,
"These numbers under 250 occur the most in the first ", "all occur " + max + " times");

while ( next != 36 ) {
count += 1;
next = iterator.next();
}
System.out.println();
System.out.println(count + "th member is " + next + " and highest prime needed is " + iterator.getPrime());
}

private static void display(int[] found, int search, int target, String prefix, String suffix) {
System.out.println();
System.out.println(prefix + target + " terms:");
for ( int i = 1; i < found.length; i++ ) {
if ( found[i] == search ) {
System.out.print(i + "  ");
}
}
System.out.println(suffix);
}

}

final class SisyphusIterator {

public SisyphusIterator(long limit) {
previous = 2;
prime = 0;
primeIterator = new SegmentedPrimeIterator(limit);
}

public long next() {
if ( ( previous & 1 ) == 0 ) {
previous >>= 1;
} else {
prime = primeIterator.next();
previous += prime;
}
return previous;
}

public long getPrime() {
return prime;
}

private long previous;
private long prime;
private SegmentedPrimeIterator primeIterator;

}

final class SegmentedPrimeIterator {

public SegmentedPrimeIterator(long limit) {
squareRoot = (int) Math.sqrt(limit);
high = squareRoot;
smallSieve(squareRoot);
}

public long next() {
if ( index == primes.size() ) {
index = 0;
segmentedSieve();
}
return primes.get(index++);
}

private void segmentedSieve() {
low += squareRoot;
high += squareRoot;

boolean[] markedPrime = new boolean[squareRoot];
Arrays.fill(markedPrime, true);

for ( int i = 0; i < smallPrimes.size(); i++ ) {
long lowLimit = ( low / smallPrimes.get(i) ) * smallPrimes.get(i);
if ( lowLimit < low ) {
lowLimit += smallPrimes.get(i);
}

for ( long j = lowLimit; j < high; j += smallPrimes.get(i) ) {
markedPrime[(int) ( j - low )] = false;
}
}

primes.clear();
for ( long i = low; i < high; i++ ) {
if ( markedPrime[(int) ( i - low )] ) {
}
}
}

private void smallSieve(int squareRoot) {
boolean[] markedPrime = new boolean[squareRoot + 1];
Arrays.fill(markedPrime, true);

for ( int p = 2; p * p <= squareRoot; p++ ) {
if ( markedPrime[p] ) {
for ( int i = p * p; i <= squareRoot; i += p ) {
markedPrime[i] = false;
}
}
}

for ( int p = 2; p <= squareRoot; p++ ) {
if ( markedPrime[p] ) {
}
}
}

private int index, squareRoot;
private long low, high;
private List<Long> primes = new ArrayList<Long>();
private List<Long> smallPrimes = new ArrayList<Long>();

}
```
Output:
```The first 100 members of the Sisyphus sequence are:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

1000th member is         990 and highest prime needed is       2273
10000th member is       24975 and highest prime needed is      30713
100000th member is      265781 and highest prime needed is     392111
1000000th member is     8820834 and highest prime needed is    4761697
10000000th member is    41369713 and highest prime needed is   55900829
100000000th member is  1179614168 and highest prime needed is  640692323

These numbers under 250 occur the most in the first 1000000000 terms:
36  72  97  107  115  127  144  167  194  211  214  230  232

These numbers under 250 occur the most in the first 1000000000 terms:
7  14  28  all occur 7 times

77534485877th member is 36 and highest prime needed is 677121348413
```

## jq

Works with: jq

The following program follows the Wren entry in using a prime sieve, but the primeSieve function is quite slow for large sieves. Since calling task(N) with N equal to 1e7 is sufficient to achieve the primary tasks, larger values of N have not been tried.

The following program also works with gojq, the Go implementation of jq, but the memory requirements become increasingly extravagent as the sieve size increases. For example, the "peak memory footprint" for task(1e4) was approximately 1.66 GB on one machine.

Generic Functions

```# The def of _nwise can be omitted if using the C implementation of jq.
def _nwise(\$n):
def n: if length <= \$n then . else .[0:\$n] , (.[\$n:] | n) end;
n;

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

# tabular print
def tprint(columns; wide):
reduce _nwise(columns) as \$row ("";
. + (\$row|map(lpad(wide)) | join(" ")) + "\n" );

# Input:  a positive integer
# Output: an array, \$a, of length .+1 such that
#         \$a[\$i] is \$i if \$i is prime, and false otherwise.
def primeSieve:
# erase(i) sets .[i*j] to false for integral j > 1
def erase(\$i):
if .[\$i] then
reduce (range(2*\$i; length; \$i)) as \$j (.; .[\$j] = false)
else .
end;
(. + 1) as \$n
| ((\$n|sqrt) / 2) as \$s
| [null, null, range(2; \$n)]
| reduce (2, 1 + (2 * range(1; \$s))) as \$i (.; erase(\$i)) ;```

```# \$limit is the target number of Sisyphus numbers to find and should be at least 100
((7 * \$limit) | primeSieve | map(select(.))) as \$primes
| { under250: [0, 1],
sisyphus: [1],
prev: 1,
nextPrimeIndex: 0,
specific: 1000,
count:1 }
| while(.count <= \$limit;
.emit = null
| if .prev % 2 == 0 then .next = .prev/2
else .next = .prev + \$primes[.nextPrimeIndex]
| .nextPrimeIndex += 1
end
| .count += 1
| if .count <= 100 then .sisyphus += [.next] else . end
| if .next < 250 then .under250[.next] += 1 else . end
| if .count == 100
then .emit = "The first 100 members of the Sisyphus sequence are:\n" + (.sisyphus | tprint(10;3))
elif .count == .specific
then \$primes[.nextPrimeIndex-1] as \$prime
| .specific *= 10
else .
end
| .prev = .next )
# The results:
| select(.emit).emit,
if .count == \$limit
then .under250 as \$u
| [range(1;250) | select( \$u[.] == null)] as \$notFound
| (\$u|max) as \$max
| [range(1;250) | select(\$u[.] == \$max)] as \$maxFound
| "\nThese numbers under 250 do not occur in the first \(.count) terms:",
"  \(\$notFound)",
"\nThese numbers under 250 occur the most in the first \(.count) terms:",
"  \(\$maxFound) all occur \(\$max) times."
else empty
end;

Output:
```The first 100 members of the Sisyphus sequence are:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

1000th member is:        990 and highest prime needed:       2273
10000th member is:      24975 and highest prime needed:      30713
100000th member is:     265781 and highest prime needed:     392111
1000000th member is:    8820834 and highest prime needed:    4761697
10000000th member is:   41369713 and highest prime needed:   55900829

These numbers under 250 do not occur in the first 10000000 terms:
[36,72,97,107,115,127,144,167,194,211,214,223,230,232]

These numbers under 250 occur the most in the first 10000000 terms:
[3,57,65,85,114,125,130,170,228] all occur 6 times.
```

## Julia

```using Counters, Formatting, Primes

struct Sisyphus end

function Base.iterate(s::Sisyphus, state = (0, 0))
n, p = state
if n == 0
return (1, 0), (1, 0)
else
if isodd(n)
p = nextprime(p + 1)
n += p
else
n ÷= 2
end
return (n, p), (n, p)
end
end

function test_sisyphus()
coun = Counter{Int}()
println("The first 100 members of the Sisyphus sequence are:")
for (i, (n, p)) in enumerate(Sisyphus())
if n < 250
coun[n] += 1
end
if i < 101
print(rpad(n, 4), i % 10 == 0 ? "\n" : "")
elseif i in [1000, 10000, 100_000, 1_000_000, 10_000_000, 100_000_000]
print(
rpad("\n\$(format(i, commas = true))th number:", 22),
"Highest prime needed: ",
format(p, commas = true),
)
end
if i == 100_000_000
println(
"\n\nThese numbers under 250 do not occur in the first 100,000,000 terms:",
)
println("    ", filter(j -> !haskey(coun, j), 1:249), "\n")
sorteds = sort!([(p, coun[p]) for p in coun], by = last)
maxtimes = sorteds[end][2]
println(
"These numbers under 250 occur the most (\$maxtimes times) in the first 100,000,000 terms:",
)
println("    ", map(first, filter(p -> p[2] == maxtimes, sorteds)))
elseif n == 36
println("\nLocating the first entry in the sequence with value 36:")
println(
"    The sequence position: ",
format(i, commas = true),
" has value \$n using prime ",
format(p, commas = true),
)
break
end
end
end

test_sisyphus()
```
Output:
```The first 100 members of the Sisyphus sequence are:
1   3   6   3   8   4   2   1   8   4
2   1   12  6   3   16  8   4   2   1
18  9   28  14  7   30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12  6   3   62  31  92  46
23  90  45  116 58  29  102 51  130 65
148 74  37  126 63  160 80  40  20  10
5   106 53  156 78  39  146 73  182 91
204 102 51  178 89  220 110 55  192 96
48  24  12  6   3   142 71  220 110 55

1,000th number:       990           Highest prime needed: 2,273
10,000th number:      24,975        Highest prime needed: 30,713
100,000th number:     265,781       Highest prime needed: 392,111
1,000,000th number:   8,820,834     Highest prime needed: 4,761,697
10,000,000th number:  41,369,713    Highest prime needed: 55,900,829
100,000,000th number: 1,179,614,168 Highest prime needed: 640,692,323

These numbers under 250 do not occur in the first 100,000,000 terms:
[36, 72, 97, 107, 115, 127, 144, 167, 194, 211, 214, 230, 232]

These numbers under 250 occur the most (7 times) in the first 100,000,000 terms:
[28, 7, 14]

Locating the first entry in the sequence with value 36:
The sequence position: 77,534,485,877 has value 36 using prime 677,121,348,413
```

## Nim

```import std/[bitops, math, strformat, strutils, tables]

# Sieve which uses only one bit for odd integers.
type Sieve = object
data: seq[byte]

func `[]`(sieve: Sieve; idx: Positive): bool =
## Return value of 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)

func `[]=`(sieve: var Sieve; idx: Positive; val: bool) =
## Set value of element at index "idx".
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)

func initSieve(lim: Positive): Sieve =
## Initialize a sieve from 2 to "lim".
result.data = newSeq[byte]((lim + 16) shr 4)
result[1] = true
for n in countup(3, sqrt(lim.toFloat).int, 2):
if not result[n]:
for k in countup(n * n, lim, 2 * n):
result[k] = true

func isPrime(sieve: Sieve; n: int): bool =
## Return true if "n" is prime.
result = if (n and 1) == 0: n == 2 else: not sieve[n]

let sieve = initSieve(700_000_000)

func nextPrime(sieve: Sieve; n: int): int =
## Return next prime greater than "n".
result = n
while true:
inc result
if sieve.isPrime(result):
return

var p = 0                     # Current prime (none for now).
var count = 0                 # Count of elements in sequence.
var n = 1                     # Last element of sequence.
var counts: CountTable[int]   # Count of occurrences for value < 250.
echo "First 100 terms of the Sisyphus sequence:"

while count < 100_000_000:

# Process current number.
inc count
if count <= 100:
stdout.write &"{n:3}"
stdout.write if count mod 10 == 0: '\n' else: ' '
if count == 100: echo()
elif count in [1_000, 10_000, 100_000, 1_000_000, 10_000_000, 100_000_000]:
echo &"The {insertSep(\$count)}th term is {insertSep(\$n)} " &
&"and the highest prime needed is {insertSep(\$p)}."

# Update count table.
if n < 250: counts.inc(n)

# Find next term of the sequence.
if (n and 1) == 0:
n = n shr 1
else:
p = sieve.nextPrime(p)
inc n, p

echo()
echo "Numbers under 250 which don’t occur in the first 100_000_000 terms:"
for n in 1..249:
if n notin counts:
stdout.write "  ", n
echo '\n'

echo "Numbers under 250 which occur the most in the first 100_000_000 terms:"
counts.sort()
let largest = counts.largest[1]
for (n, count) in counts.pairs:
if count == largest:
stdout.write "  ", n
else:
# No more value with the largest number of occurrences.
echo()
break
```
Output:
```First 100 terms of the Sisyphus sequence:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

The 1_000th term is 990 and the highest prime needed is 2_273.
The 10_000th term is 24_975 and the highest prime needed is 30_713.
The 100_000th term is 265_781 and the highest prime needed is 392_111.
The 1_000_000th term is 8_820_834 and the highest prime needed is 4_761_697.
The 10_000_000th term is 41_369_713 and the highest prime needed is 55_900_829.
The 100_000_000th term is 1_179_614_168 and the highest prime needed is 640_692_323.

Numbers under 250 which don’t occur in the first 100_000_000 terms:
36  72  97  107  115  127  144  167  194  211  214  230  232

Numbers under 250 which occur the most in the first 100_000_000 terms:
7  28  14
```

## Pascal

### Free Pascal

```program Sisyphus;
{\$IFDEF FPC}
{\$MODE DELPHI}{\$Coperators ON}{\$Optimization ON}
{\$ENDIF}
{\$IFDEF WINDOWS}
{\$APPTYPE CONSOLE}
{\$ENDIF}
uses
sysutils,
primsieve;// https://rosettacode.org/wiki/Extensible_prime_generator#Pascal

function CommatizeUint64(num:Uint64):AnsiString;
var
fromIdx,toIdx :Int32;
Begin
str(num,result);
fromIdx := length(result);
toIdx := fromIdx-1;
if toIdx < 3 then
exit;

toIdx := 4*(toIdx DIV 3)+toIdx MOD 3 +1 ;
setlength(result,toIdx);
repeat
result[toIdx]   := result[FromIdx];
result[toIdx-1] := result[FromIdx-1];
result[toIdx-2] := result[FromIdx-2];
result[toIdx-3] := ',';
dec(toIdx,4);
dec(FromIdx,3);
until FromIdx<=3;
end;

procedure OutOne(n,count: Uint64);
Begin
write(n:5);
If count mod 10 = 0 then
writeln;
end;

procedure OutRes(n,count,p:Uint64);
Begin
writeln(CommatizeUint64(n):15, ' found after ',CommatizeUint64(count):12,' iterations: Max prime ',CommatizeUint64(p):12);
end;

procedure CheckSmall;
var
CntOccurence : array[0..255] of byte;
n,count,p,limit : Uint64;
begin
InitPrime;
writeln('The first 100 members of the Sisyphus sequence');
fillchar(CntOccurence,SizeOf(CntOccurence),#0);
n := 1;
count := 1;
Limit := 1000;
CntOccurence[n] := 1;

repeat
if count <= 100 then
Begin
OutOne(n,count);
if count = 100 then
writeln;
end;

if n AND 1 = 0 then
n := n shr 1
else
begin
p := nextprime;
n += p;
end;
count+= 1;
iF n < 255 then
inc(CntOccurence[n]);

if (count = Limit) then
Begin
OutRes(n,count,p);
Limit *= 10;
end;
until Limit > 100*1000*1000;

p := 0;// maximum
For n := 1 to 250 do
begin
if CntOccurence[n] = 0 then
write(n:4);
if p < CntOccurence[n] then
p := CntOccurence[n];
end;
Writeln;

writeln(#10,'Mostly found numbers below 250 after ',CommatizeUint64(count),' iterations');
For n := 1 to 250 do
if CntOccurence[n] = p then
write(n:4);
Writeln(' found ',p,' times');
end;

procedure Check;
var
n,count,target,p : Uint64;
begin
InitPrime;
n := 1;
count := 1;
Target := 36;
repeat
if n AND 1 = 0 then
n := n shr 1
else
begin
p := nextprime;
n += p;
end;
count+= 1;
if (n = target) then
Begin
OutRes(n,count,p);
BREAK;
end;
until false;
end;

BEGIN
CheckSmall;
writeln;
CHECK;
end.
```
@Home Ryzen 5600G 3.6 Ghz:
``` The first 100 members of the Sisyphus sequence
1    3    6    3    8    4    2    1    8    4
2    1   12    6    3   16    8    4    2    1
18    9   28   14    7   30   15   44   22   11
42   21   58   29   70   35   78   39   86   43
96   48   24   12    6    3   62   31   92   46
23   90   45  116   58   29  102   51  130   65
148   74   37  126   63  160   80   40   20   10
5  106   53  156   78   39  146   73  182   91
204  102   51  178   89  220  110   55  192   96
48   24   12    6    3  142   71  220  110   55

990 found after        1,000 iterations: Max prime        2,273
24,975 found after       10,000 iterations: Max prime       30,713
265,781 found after      100,000 iterations: Max prime      392,111
8,820,834 found after    1,000,000 iterations: Max prime    4,761,697
41,369,713 found after   10,000,000 iterations: Max prime   55,900,829
1,179,614,168 found after  100,000,000 iterations: Max prime  640,692,323

36  72  97 107 115 127 144 167 194 211 214 230 232

Mostly found numbers below 250 after 100,000,000 iterations
7  14  28 found 7 times
--0.63 s
36 found after 77,534,485,877 iterations: Max prime 677,121,348,413

real    16m20.573s
```

## Perl

Library: ntheory
```use strict;
use warnings;
use feature 'say';

use ntheory 'next_prime';
use List::Util <any max>;
use integer;

sub comma { reverse ((reverse shift) =~ s/.{3}\K/,/gr) =~ s/^,//r }
sub table { my \$t = 10 * (my \$c = 1 + length max @_); ( sprintf( ('%'.\$c.'d')x@_, @_) ) =~ s/.{1,\$t}\K/\n/gr }

my (\$exp1, \$exp2, \$limit1, \$limit2) = (3, 8, 100, 250);
my (\$n, \$s0, \$s1, \$p, @S1, %S, %S2) = (1, 1, 0, 1, 1);
my @Nth = map { 10**\$_ } \$exp1..\$exp2;

do {
\$n++;
\$s1 = (0 == \$s0%2) ? \$s0/2 : \$s0 + (\$p = next_prime(\$p));
push @S1, \$s1 if  \$n <= \$limit1;
\$S2{\$s1}++    if \$s1 <= \$limit2;
(\$S{\$n}{'value'} = \$s1 and \$S{\$n}{'prime'} = \$p) if any { \$_ == \$n } @Nth;
\$s0 = \$s1;
} until \$n == \$Nth[-1];

say 'The first 100 members of the Sisyphus sequence are:';
say table @S1;

printf "%12sth member is: %13s with prime: %11s\n", comma(\$_), comma(\$S{\$_}{value}), comma(\$S{\$_}{prime}) for @Nth;

printf "\nNumbers under \$limit2 that do not occur in the first %s terms:\n", comma \$Nth[-1];
say join ' ', grep { ! defined \$S2{\$_} } 1..\$limit2;

my \$max = max values %S2;
printf "\nNumbers under \$limit2 occur the most (\$max times) in the first %s terms:\n", comma \$Nth[-1];
say join ' ', sort { \$a <=> \$b } grep { \$S2{\$_} == \$max } keys %S2;
```
Output:
```The first 100 members of the Sisyphus sequence are:
1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

1,000th member is:           990 with prime:       2,273
10,000th member is:        24,975 with prime:      30,713
100,000th member is:       265,781 with prime:     392,111
1,000,000th member is:     8,820,834 with prime:   4,761,697
10,000,000th member is:    41,369,713 with prime:  55,900,829
100,000,000th member is: 1,179,614,168 with prime: 640,692,323

Numbers under 250 that do not occur in the first 100,000,000 terms:
36 72 97 107 115 127 144 167 194 211 214 230 232

Numbers under 250 occur the most (7 times) in the first 100,000,000 terms:
7 14 28
```

## Phix

```atom t0 = time()
constant limit = 1e8
sequence sisyphus = {1},
under250 = reinstate(repeat(0,250),1,1)
integer np = 0, specific = 1000, count = 1, m
atom next = 1
while true do
if even(next) then
next /= 2
else
np += 1
next += get_prime(np)
end if
if next <= 250 then under250[next] += 1 end if
count += 1
if count <= 100 then
sisyphus &= next
if count == 100 then
printf(1,"The first 100 members of the Sisyphus sequence are:\n%s\n",
{join_by(sisyphus,1,10,"  ",fmt:="%3d")})
end if
elsif count == specific then
printf(1,"%,13d%s member is: %,13d and highest prime needed: %,11d\n",
{count, ord(count), next, get_prime(np)})
if count == limit then m = largest(under250,true); exit end if
specific *= 10
end if
end while
printf(1,"\nThese numbers under 250 do not occur in the first %,d terms:\n",count)
printf(1,"  %v\n",{find_all(0,under250)})
printf(1,"\nThese numbers under 250 occur the most in the first %,d terms:\n",count)
printf(1,"  %v all occur %d times.\n",{find_all(m,under250),m})
?elapsed(time()-t0)
```
Output:
```The first 100 members of the Sisyphus sequence are:
1    3    6    3    8    4    2    1    8    4
2    1   12    6    3   16    8    4    2    1
18    9   28   14    7   30   15   44   22   11
42   21   58   29   70   35   78   39   86   43
96   48   24   12    6    3   62   31   92   46
23   90   45  116   58   29  102   51  130   65
148   74   37  126   63  160   80   40   20   10
5  106   53  156   78   39  146   73  182   91
204  102   51  178   89  220  110   55  192   96
48   24   12    6    3  142   71  220  110   55

1,000th member is:           990 and highest prime needed:       2,273
10,000th member is:        24,975 and highest prime needed:      30,713
100,000th member is:       265,781 and highest prime needed:     392,111
1,000,000th member is:     8,820,834 and highest prime needed:   4,761,697
10,000,000th member is:    41,369,713 and highest prime needed:  55,900,829
100,000,000th member is: 1,179,614,168 and highest prime needed: 640,692,323

These numbers under 250 do not occur in the first 100,000,000 terms:
{36,72,97,107,115,127,144,167,194,211,214,230,232}

These numbers under 250 occur the most in the first 100,000,000 terms:
{7,14,28} all occur 7 times.
"12.8s"
```

### Extreme stretch

Translation of: Python

I found a suitable prebuilt 64-bit windows dll in the pascal bindings of primesieve (version 7.7, dated 31/12/21), so gave it a try:

```without js
include builtins/primesieve.e -- (can provide if desired, ask me on either my or this tasks talk page)
requires(WINDOWS)
requires(64,true)
atom t0 = time(), t1 = time()+1
integer np = 0, count = 1, p
atom next = 1
while next!=36 do
if even(next) then
next /= 2
else
p = primesieve_next_prime()
next += p
end if
count += 1
if time()>t1 then
atom cpc = (count/77_534_485_877)*100,
ppc = (p/677_121_348_413)*100
progress("count: %,d (%2.2f%%)  p: %,d (%2.2f%%)\r",{count,cpc,p,ppc})
t1 = time()+1
end if
end while
progress("")
printf(1,"%,d%s member is: %,d and highest prime needed: %,d\n",
{count, ord(count), next, p})
?elapsed(time()-t0)
```
Output:
```77,534,485,877th member is: 36 and highest prime needed: 677,121,348,413
"1 hour, 53 minutes and 46s"
```

Timings on an i3-2120 3.3GHz dual core. Memory use was just 9MB, about 0.1% of what I have.

## Python

Library: primesieve
```from collections import Counter
from itertools import islice
from typing import Iterable
from typing import Iterator
from typing import Tuple
from typing import TypeVar

import primesieve

def primes() -> Iterator[int]:
it = primesieve.Iterator()
while True:
yield it.next_prime()

def sisyphus() -> Iterator[Tuple[int, int]]:
prime = primes()
n = 1
p = 0
yield n, p

while True:
if n % 2:
p = next(prime)
n = n + p
else:
n = n // 2
yield n, p

def consume(it: Iterator[Tuple[int, int]], n) -> Tuple[int, int]:
next(islice(it, n - 1, n - 1), None)
return next(it)

T = TypeVar("T")

def batched(it: Iterable[T], n: int) -> Iterable[Tuple[T, ...]]:
_it = iter(it)
batch = tuple(islice(_it, n))
while batch:
yield batch
batch = tuple(islice(_it, n))

if __name__ == "__main__":
it = sisyphus()
first_100 = list(islice(it, 100))
print("The first 100 members of the Sisyphus sequence are:")
for row in batched(first_100, 10):
print("  ".join(str(n).rjust(3) for n, _ in row))

print("")

for interval in [10**x for x in range(3, 9)]:
n, prime = consume(it, interval - (interval // 10))
print(f"{interval:11,}th number: {n:13,}   highest prime needed: {prime:11,}")

print("")

sisyphus_lt_250 = Counter(n for n, _ in islice(sisyphus(), 10**8) if n < 250)
print("These numbers under 250 do not occur in the first 100,000,000 terms:")
print(" ", [n for n in range(1, 250) if n not in sisyphus_lt_250])
print("")

most_common = sisyphus_lt_250.most_common(1)[0][1]
print("These numbers under 250 occur the most in the first 100,000,000 terms:")
print(
f"  {[n for n, c in sisyphus_lt_250.items() if c == most_common]} "
f"all occur {most_common} times."
)
```
Output:
```The first 100 members of the Sisyphus sequence are:
1    3    6    3    8    4    2    1    8    4
2    1   12    6    3   16    8    4    2    1
18    9   28   14    7   30   15   44   22   11
42   21   58   29   70   35   78   39   86   43
96   48   24   12    6    3   62   31   92   46
23   90   45  116   58   29  102   51  130   65
148   74   37  126   63  160   80   40   20   10
5  106   53  156   78   39  146   73  182   91
204  102   51  178   89  220  110   55  192   96
48   24   12    6    3  142   71  220  110   55

1,000th number:           990   highest prime needed:       2,273
10,000th number:        24,975   highest prime needed:      30,713
100,000th number:       265,781   highest prime needed:     392,111
1,000,000th number:     8,820,834   highest prime needed:   4,761,697
10,000,000th number:    41,369,713   highest prime needed:  55,900,829
100,000,000th number: 1,179,614,168   highest prime needed: 640,692,323

These numbers under 250 do not occur in the first 100,000,000 terms:
[36, 72, 97, 107, 115, 127, 144, 167, 194, 211, 214, 230, 232]

These numbers under 250 occur the most in the first 100,000,000 terms:
[28, 14, 7] all occur 7 times.
```

### Extreme stretch

Using Python bindings for the primesieve C++ library and PyPy 3.9 instead of CPython (PyPy is nearly twice as fast up to s(100,000,000)), this completed in about 1 hour and 53 minutes on a AMD Ryzen 5 1500X. Memory usage was minimal thanks to `primesieve.Iterator()`.

```import primesieve

def sisyphus36():
primes = primesieve.Iterator()
n = 1
p = 0
i = 1

while True:
i += 1
if n % 2:
p = primes.next_prime()
n = n + p
else:
n = n // 2

if n == 36:
print(f"{i:,}, {n:,}, {p:,}")
break

if __name__ == "__main__":
sisyphus36()
```
Output:
```\$ time pypy3.9 sisyphus_36.py
77,534,485,877, 36, 677,121,348,413

real	113m2.636s
user	112m56.973s
sys	0m0.060s
```

## Raku

```use Math::Primesieve;
use Lingua::EN::Numbers;

my (\$exp1, \$exp2, \$limit1, \$limit2)  = 3, 8, 100, 250;
my (\$n, \$s0, \$s1, \$p, @S1, %S) =  1, 1, Any, Any, 1;
my \$iterator = Math::Primesieve::iterator.new;
my @Nth = (\$exp1..\$exp2)».exp(10);
my \$S2 = BagHash.new;

repeat {
\$n++;
\$s1 = \$s0 %% 2 ?? \$s0 div 2 !! \$s0 + (\$p = \$iterator.next);
@S1.push: \$s1 if  \$n ≤ \$limit1;
\$S2.add:  \$s1 if \$s1 ≤ \$limit2;
%S{\$n}{'value', 'prime'} = \$s1, \$p if \$n ∈ @Nth;
\$s0 = \$s1;
} until \$n == @Nth[*-1];

say "The first \$limit1 members of the Sisyphus sequence are:";
say @S1.batch(10)».fmt('%4d').join("\n") ~ "\n";
printf "%12sth member is: %13s with prime: %11s\n", (\$_, %S{\$_}{'value'}, %S{\$_}{'prime'})».&comma for @Nth;
say "\nNumbers under \$limit2 that do not occur in the first {comma @Nth[*-1]} terms:";
say (1..\$limit2).grep: * ∉ \$S2.keys;
say "\nNumbers under \$limit2 that occur the most ({\$S2.values.max} times) in the first {comma @Nth[*-1]} terms:";
say \$S2.keys.grep({ \$S2{\$_} == \$S2.values.max}).sort;
```
Output:
```The first 100 members of the Sisyphus sequence are:
1    3    6    3    8    4    2    1    8    4
2    1   12    6    3   16    8    4    2    1
18    9   28   14    7   30   15   44   22   11
42   21   58   29   70   35   78   39   86   43
96   48   24   12    6    3   62   31   92   46
23   90   45  116   58   29  102   51  130   65
148   74   37  126   63  160   80   40   20   10
5  106   53  156   78   39  146   73  182   91
204  102   51  178   89  220  110   55  192   96
48   24   12    6    3  142   71  220  110   55

1,000th member is:           990 with prime:       2,273
10,000th member is:        24,975 with prime:      30,713
100,000th member is:       265,781 with prime:     392,111
1,000,000th member is:     8,820,834 with prime:   4,761,697
10,000,000th member is:    41,369,713 with prime:  55,900,829
100,000,000th member is: 1,179,614,168 with prime: 640,692,323

Numbers under 250 that do not occur in the first 100,000,000 terms:
36 72 97 107 115 127 144 167 194 211 214 230 232

Numbers under 250 that occur the most (7 times) in the first 100,000,000 terms:
7 14 28
```

## RPL

This is a very slow version (15 minutes to get the 10,000th term on a HP-50g) , but I'm not sure to have enough memory to generate a large enough sieve to find the millionth term in a reasonable amount of time. Anyway, even the first requirement (displaying 10 lines of 10 items) is out of range with a 22-character screen.

```≪ 1 CF
IF DUP 0 < THEN 1 SF NEG END    @ A negative argument requires the sequence to be stored then displayed
0 { 1 } → n cnt seq
≪ 2 1
WHILE 'cnt' INCR n < REPEAT
IF DUP 2 MOD THEN OVER + SWAP NEXTPRIME SWAP ELSE 2 / END
IF 1 FS? THEN 'seq' OVER STO+ END
END
IF 1 FS? THEN DROP2 seq ELSE SWAP PREVPRIME R→C END
≫ ≫ 'SISYPH' STO
```
```-100 SISYPH
1000 SISYPH
10000 SISYPH
```
Output:
```3: {1 3 6 3 8 4 2 1 8 4 2 1 12 6 3 16 8 4 2 1 18 9 28 14 7 30 15 44 22 11 42 21 58 29 70 35 78 39 86 43 96 48 24 12 6 3 62 31 92 46 23 90 45 116 58 29 102 51 130 65 148 74 37 126 63 160 80 40 20 10 5 106 53 156 78 39 146 73 182 91 204 102 51 178 89 220 110 55 192 96 48 24 12 6 3 142 71 220 110 55 }
2: (990.,2273.)
1: (24975.,30713.)
```

## Ruby

```require 'prime'

prime_gen = Prime.each
cur_prime = nil
sisyphi   = Enumerator.produce(1) {|n| n.even? ? n/2 : n += (cur_prime = prime_gen.next)}

sisyphi.first(100).each_slice(10){|s| puts "%4d"*s.size % s }

puts
prime_gen.rewind
counter = Hash.new(0)
count_until = 250
idx   = 1000
limit = 100_000_000
sisyphi.with_index(1) do |n, i|
counter[n] += 1 if n < count_until
if i == idx then
puts "element %11d is %11d, with prime %11d" % [i, n, cur_prime]
break if idx >= limit
idx *= 10
end
end

puts "\nThese numbers under #{count_until} do not occur in the first #{limit} terms:"
puts ((1...count_until).to_a - counter.keys).join ", "

freq, nums = counter.group_by{|k, v| v}.max
puts "\nThese numbers under #{count_until} occur most frequent (#{freq} times) in the first #{limit} terms:"
puts nums.map(&:first).sort.join(", ")
```
Output:
```   1   3   6   3   8   4   2   1   8   4
2   1  12   6   3  16   8   4   2   1
18   9  28  14   7  30  15  44  22  11
42  21  58  29  70  35  78  39  86  43
96  48  24  12   6   3  62  31  92  46
23  90  45 116  58  29 102  51 130  65
148  74  37 126  63 160  80  40  20  10
5 106  53 156  78  39 146  73 182  91
204 102  51 178  89 220 110  55 192  96
48  24  12   6   3 142  71 220 110  55

element        1000 is         990, with prime        2273
element       10000 is       24975, with prime       30713
element      100000 is      265781, with prime      392111
element     1000000 is     8820834, with prime     4761697
element    10000000 is    41369713, with prime    55900829
element   100000000 is  1179614168, with prime   640692323

These numbers under 250 do not occur in the first 100000000 terms:
36, 72, 97, 107, 115, 127, 144, 167, 194, 211, 214, 230, 232

These numbers under 250 occur most frequent (7 times) in the first 100000000 terms:
7, 14, 28
```

## Wren

Library: Wren-math
Library: Wren-fmt

No option here but to use a sieve as relying on the 'nextPrime' method would be far too slow to achieve the stretch goal in a reasonable time using Wren. Sieve limit found by experimentation.

Extreme stretch not attempted and out of reasonable reach for Wren-CLI.

```import "./math" for Int, Nums
import "./fmt" for Fmt

var limit = 1e8
var primes = Int.primeSieve(7 * limit)
var under250 = List.filled(250, 0)
var sisyphus = [1]
under250[1] = 1
var prev = 1
var nextPrimeIndex = 0
var specific = 1000
var count = 1
while (true) {
var next
if (prev % 2 == 0) {
next = prev / 2
} else {
next = prev + primes[nextPrimeIndex]
nextPrimeIndex = nextPrimeIndex + 1
}
count = count + 1
if (next < 250) under250[next] = under250[next] + 1
if (count == 100) {
System.print("The first 100 members of the Sisyphus sequence are:")
Fmt.tprint("\$3d ", sisyphus, 10)
System.print()
} else if (count == specific) {
var prime = primes[nextPrimeIndex-1]
Fmt.print("\$,13r member is: \$,13d and highest prime needed: \$,11d", count, next, prime)
if (count == limit) {
var notFound = (1..249).where { |i| under250[i] == 0 }.toList
var max = Nums.max(under250)
var maxFound = (1..249).where { |i| under250[i] == max }.toList
Fmt.print("\nThese numbers under 250 do not occur in the first \$,d terms:", count)
Fmt.print("  \$n", notFound)
Fmt.print("\nThese numbers under 250 occur the most in the first \$,d terms:", count)
Fmt.print("  \$n all occur \$d times.", maxFound, max)
return
}
specific = 10 * specific
}
prev = next
}
```
Output:
```The first 100 members of the Sisyphus sequence are:
1    3    6    3    8    4    2    1    8    4
2    1   12    6    3   16    8    4    2    1
18    9   28   14    7   30   15   44   22   11
42   21   58   29   70   35   78   39   86   43
96   48   24   12    6    3   62   31   92   46
23   90   45  116   58   29  102   51  130   65
148   74   37  126   63  160   80   40   20   10
5  106   53  156   78   39  146   73  182   91
204  102   51  178   89  220  110   55  192   96
48   24   12    6    3  142   71  220  110   55

1,000th member is:           990 and highest prime needed:       2,273
10,000th member is:        24,975 and highest prime needed:      30,713
100,000th member is:       265,781 and highest prime needed:     392,111
1,000,000th member is:     8,820,834 and highest prime needed:   4,761,697
10,000,000th member is:    41,369,713 and highest prime needed:  55,900,829
100,000,000th member is: 1,179,614,168 and highest prime needed: 640,692,323

These numbers under 250 do not occur in the first 100,000,000 terms:
[36, 72, 97, 107, 115, 127, 144, 167, 194, 211, 214, 230, 232]

These numbers under 250 occur the most in the first 100,000,000 terms:
[7, 14, 28] all occur 7 times.
```

### Extreme Stretch

Library: Wren-psieve

The above module provides Wren bindings for the very fast C++ library primesieve, used by several other languages for this task, though we need to use a special executable (written in C) to run it at the present time - it cannot be run under Wren-CLI.

The following script manages to find the first occurrence of the number 36 in the sequence in about 2 hours 54 minutes which (relative to Phix) is much quicker than one would normally expect. This is probably due to the heavy lifting (i.e. the prime generation) being done here in both cases by C++ though this will tempered by the need to convert unsigned 64-bit integers to doubles (Wren's only numeric type) for each prime generated.

```import "./psieve" for Primes
import "./fmt" for Fmt

var it = Primes.iter()
var n = 1
var count = 1
var prime
var target = 36
while (true) {
if (n % 2 == 1) {
prime = it.next
n = n + prime
} else {
n = n / 2
}
count = count + 1
if (n == target) {
Fmt.print("\$,r member is: \$d and highest prime needed: \$,d", count, target, prime)
return
}
}
```
Output:
```77,534,485,877th member is: 36 and highest prime needed: 677,121,348,413
```