1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

import java.math.BigInteger;
import java.util.ArrayList;

public class Moser {
    // Für m < 341.550.071.728.321
    public static boolean isPrime(long m) {
    int[] p17 = {2, 3, 5, 7, 11, 13, 17};
    for (int i=0; i<p17.length; i++) {
      int a = p17[i];      
              if (m == a) {
                   return true;
              }
      BigInteger A = new BigInteger(""+a);      
      long b = A.modPow(new BigInteger(""+(m-1)), new BigInteger(""+m)).longValue();      
      if (b != 1) {
        return false;
      }
    }      
    return true;
  }
    
    
    public static void main(String[] args) {
        int targetK = 4;
        
        ArrayList<Long> primes = new ArrayList<Long>();   
        boolean found = false;
        long example = -1;
        for (long n = 2; n < Long.MAX_VALUE; n++) {
            if (isPrime(n)) {
                primes.add(n);
            }
            // Alle Primzahlen kleiner als n sind bekannt
            int k = 0;
            int skip = 0;
            for (int s = 1; s < n; s++) { // s ist die Länge der aktuellen Sequenz
                for (int p = primes.size()-(skip + 1); p >= s-1; p--) {
                    long sum = 0;
                    for (int i = 0; i < s; i++) {
                        sum += primes.get(p-i);
                    }
                    if (sum < n) {
                      break;
                    }
                    if (sum == n) {
                        k++;
                        skip = s;
                        break;
                    }
                }
                if (k == targetK) {
                    example = n;
                    found = true;
                    break;
                }
            }
            if (found) {
                break;
            }
        }
        
        System.out.println("Found example for f^-1(k=" + targetK + ") = " + example);
    }
}					

1:
2:
3:
4:
5:
6:
7:
8:
9:

   tSummand= record
               StartIndex, // bei großen Zahlen  Startzahl
               EndIndex,   // bei großen Zahlen  Endzahl
               Summe  : Int64Longint;
              {Falls wenige Summanden sprich großen Zahlen, also ab weniger als 1000 }
               Pufferindex : integer;
               RingpufferDiffenzen : array Of integer;//length= Anzahl Summanden)
             end;
   Summanden = array of TSummand;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:

Ablauf:
Felder der Summandenzahl 1..1000 initialisieren.
maxSumZahl = 1000;
Startzahl S = 2+3
  wiederhole
   k = 0
   sumAnz = 2;
   wiederhole
     //ich klappere alle summandenfelder ab.
     with Summanden[SumAnz] do
     Ist S >= Summe dann
       Falls S = Summe dann 
         erhoehe k
       // solange nach größerer Primzahlsuchen bis Summe goeszer s wird 
       wiederhole 
         np = Nextprim(Endwert)
         summe = summe - Startwert+np
         dec(Startwert,RingpufferDiffenzen[Pufferindex]);
         RingpufferDiffenzen[Pufferindex] := np-Endwert;
         inc(Pufferindex);
         IF Pufferindex >= SumAnz then
           Pufferindex := 0;
       bis Summe >S; // =S kann es nicht sein. 
     inc(sumAnz);
   bis sumAnz >= maxSumZahl;
  S = NextPrim(S);
bis SNT // SanktNimmerleinsTag					

1:
2:
3:
4:
5:

   tkleinerSummand= record
                     StartIndex,
                     EndIndex: Dword;
                     Summe  : Int64;
                     end; // 16 Byte					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

   tGroßerSummand= record
                     StartWert,
                     EndWert, 
                     Summe  : Int64;
                     PufferStartPos: ^byte;//oder  Array of byte
                     PufferIndex   :^byte;
                     end; // = 3*8+2*4= 32 Byte 
   Ringpuffer = array [0..1000*1001 div 2] of byte; // Speichert die Differenzen zwischen den Primzahlen dies ist viel kompakter statt der Primzahlen selbst ~0,5 Mb 
Bei 2 Summanden zeigt PufferStartPos auf Ringpuffer[0] PufferIndex geht von 0..0( Summandenzahl-2 )
Bei 3 Summanden zeigt PufferStartPos auf Ringpuffer[1] PufferIndex geht von 0..1
Bei 4 Summanden zeigt PufferStartPos auf Ringpuffer[3] PufferIndex geht von 0..2 
Bei 5 Summanden zeigt PufferStartPos auf Ringpuffer[6] PufferIndex geht von 0..3					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:

   k  kleinste Zahl
   6  729
   7  105
   8  225
   9  405
  10  59049
  11  315
  12  531441
  13  3645
  14  2025
  15  945
  16  43046721
  17  1575
  18  ---
  19  2835
  20  18225
  21  295245
  22  ---
  23  3465
  24  50625
  25  2657205