The series of increasing prime numbers begins: 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, ...

The task applies a filter to the series returning groups of successive primes, (s'primes), that differ from the next by a given value or values.

Example 1: Specifying that the difference between s'primes be 2 leads to the groups:

(3, 5), (5, 7), (11, 13), (17, 19), (29, 31), ...

(Known as Twin primes or Prime pairs)

Example 2: Specifying more than one difference between s'primes leads to groups of size one greater than the number of differences. Differences of 2, 4 leads to the groups:

(5, 7, 11), (11, 13, 17), (17, 19, 23), (41, 43, 47), .... 

In the first group 7 is two more than 5 and 11 is four more than 7; as well as 5, 7, and 11 being successive primes.
Differences are checked in the order of the values given, (differences of 4, 2 would give different groups entirely).

Task

 In each case use a list of primes less than 1_000_000
 For the following Differences show the first and last group, as well as the number of groups found:
 Differences of 2.
 Differences of 1.
 Differences of 2, 2.
 Differences of 2, 4.
 Differences of 4, 2.
 Differences of 6, 4, 2.
 Show output here.

Note: Generation of a list of primes is a secondary aspect of the task. Use of a built in function, well known library, or importing/use of prime generators from other Rosetta Code tasks is encouraged.

references
https://pdfs.semanticscholar.org/78a1/7349819304863ae061df88dbcb26b4908f03.pdf
https://www.primepuzzles.net/puzzles/puzz_011.htm
https://matheplanet.de/matheplanet/nuke/html/viewtopic.php?topic=232720&start=0
private fun sieve(limit: Int): Array<Int> {
    val primes = mutableListOf<Int>()
    primes.add(2)
    val c = BooleanArray(limit + 1) // composite = true
    // no need to process even numbers > 2
    var p = 3
    while (true) {
        val p2 = p * p
        if (p2 > limit) {
            break
        }
        var i = p2
        while (i <= limit) {
            c[i] = true
            i += 2 * p
        }
        do {
            p += 2
        } while (c[p])
    }
    var i = 3
    while (i <= limit) {
        if (!c[i]) {
            primes.add(i)
        }
        i += 2
    }
    return primes.toTypedArray()
}
 
private fun successivePrimes(primes: Array<Int>, diffs: Array<Int>): List<List<Int>> {
    val results = mutableListOf<List<Int>>()
    val dl = diffs.size
    outer@ for (i in 0 until primes.size - dl) {
        val group = IntArray(dl + 1)
        group[0] = primes[i]
        for (j in i until i + dl) {
            if (primes[j + 1] - primes[j] != diffs[j - i]) {
                continue@outer
            }
            group[j - i + 1] = primes[j + 1]
        }
        results.add(group.toList())
    }
    return results
}
 
fun main() {
    val primes = sieve(999999)
    val diffsList = arrayOf(
        arrayOf(2),
        arrayOf(1),
        arrayOf(2, 2),
        arrayOf(2, 4),
        arrayOf(4, 2),
        arrayOf(6, 4, 2)
    )
    println("For primes less than 1,000,000:-\n")
    for (diffs in diffsList) {
        println("  For differences of ${diffs.contentToString()} ->")
        val sp = successivePrimes(primes, diffs)
        if (sp.isEmpty()) {
            println("    No groups found")
            continue
        }
        println("    First group   = ${sp[0].toTypedArray().contentToString()}")
        println("    Last group    = ${sp[sp.size - 1].toTypedArray().contentToString()}")
        println("    Number found  = ${sp.size}")
        println()
    }
}