Ouch, vscode! 😠

The company cloud has hundreds of machines and I need to get some idea of the hardware so I find dmidecode for the functionality and need to parse its structured output and generate A Python datastructure, or maybe JSON.

I decide to access a Linux cloud machine remotely using vscode, as normal and run dmidecode, cut-n-paste a sample of its output into regex101, I do my due diligance and have a VNC session into another machine in the cloud and run dmidecode there on a different machine, take a look, and cut-n-paste an extended section of the data into regex101, scroll to the top of regex101, and write exploratary regexps as I match sections of the dmidecode output. 

Matches start, but stop at the section of data copied from my VNC terminal? 

Regex101 prints grey dots for spaces and a grey line for tabs and it is then plain to see that the commands output is indented with tabs when copied from VNC, but spaces from vscode.

Piping the output and grepping for initial tabs and comparing it to grepping for initial spaces shows that the dmidecode command indents with tabs. A web search showed that vscode terminal has an issue with outputting tabs and silently changes them to spaces. Furthermore, this issue is closed!?!

Vscode. it's a nice tool 'n all; but lying about data is a no-no. I expect you to get the fundamentals right as a solid base then add from there. X, vi, gvim make me not even think to check that tabs are visible (and their handling modifiable), 

I wonder if other IDE's have this issue, lets start a list.

End.

The Kaprekar process

 

(Best viewed on larger screens)

What is it?

Given the number of digits to maintain, and a starting positive integer i with no more than that many digits, the repettitive process continues:

1. Form the integer i1 from the (zero-extended) digits of i sorted from largest digit to smallest.
2. Form the integer i2 from the (zero-extended) digits of i sorted from smallest digit to largest.
3. Form a new, replacement i by subtracting the smallest from the largest: i = i1 - i2.

If any new i has already been seen then this latest i is termed the Kaprekar constant formed from the initial i and digits

Details

Zero extension

If we have i = 21; digits = 4 then zero extension to the given number of digits means that if the integer is normally written with fewer digits then extra zeroes are added as padding to the right of the number to fill in the right number of digits. i of 21 is treated as 0021 the hundreds and thousands digits are given as zero.

When sorted, i1 = int('2100') and i2 = int('0012') resulting in a new i = 2100 - 12 = 2088

i = 21; digits = 4
print(f"Zero-extend {i = } by {digits = } gives: {i = :0{digits}}")

Zero-extend i = 21 by digits = 4 gives: i = 0021

Sort

If we consider the digits of a number as characters then the normal Python sort returns the digits from smallest to largest, i.e. for i2.

i_l2r = ''.join(sorted(f"{i:0{digits}}"))  # digits sorted Left-to-Right

print(f"{i = }\nZero-extended and sorted digits for i2:", i_l2r)

print("Those same digits reverse-sorted for i1:", i_l2r[::-1])

new_i = int(i_l2r[::-1]) - int(i_l2r)

print(f"{new_i = }")

i = 21
Zero-extended and sorted digits for i2: 0012
Those same digits reverse-sorted for i1: 2100
new_i = 2088

The kaprekar constant

An Indian mathematician, Kaprekar, found that with four digits, starting with any number produced either a final value of

• 0, Zero for starting numbers that were palindromes. For example if i = 1111 then i1 == i2 == 1111 and the new i = i1 - i2 = 0.
• Or 6174 for all other numbers of four or less digits.

6174 is known as the Kaprekar constant.

Exploring the Kaprekar process

Now some code to find constants for differing numbers of digits, as well as an indication of how many starting integers in the range of that many digits loop on a particular constant.

from collections import defaultdict
def kaprekar1(digits: int=4):
    "kaprekar function."
    base = 10
    konstant2nums = defaultdict(int)  # how many times the constant is seen
    for i in range(base**digits):     # All ints expressable in digits
        i_start = i
        seen = set()  # numbers produced by the process so far
        while i not in seen:
            seen.add(i)
            i_l2r = ''.join(sorted(f"{i:0{digits}}"))  # digits sorted L-to-R
            i = int(i_l2r[::-1]) - int(i_l2r)  # new i
        konstant2nums[i] += 1  # this constant i, seen one more time from this i_start
    return dict(konstant2nums)
kaprekar1(4)

{0: 10, 6174: 9990}

That show that we get the constant 0 ten times for i = 0, 1111, ..., 9999.

We get the Kaprekar constant of 6174 for all other starting, foru-digit numbers.

Two digits

kaprekar1(2)

{0: 10, 9: 26, 63: 22, 27: 26, 45: 14, 81: 2}

With two digits we get the obvious constant 0 and five others: 9, 27, 45, 63, 81

No longer interested in constant frequencies

I'm only really interested in the keys of the returned dict so:

def kaprekar2(digits: int=4):
    "kaprekar function."
    base = 10
    konstant2nums = defaultdict(int)  # how many times the constant is seen
    for i in range(base**digits):     # All ints expressable in digits
        i_start = i
        seen = set()  # numbers produced by the process so far
        while i not in seen:
            seen.add(i)
            i_l2r = ''.join(sorted(f"{i:0{digits}}"))  # digits sorted L-to-R
            i = int(i_l2r[::-1]) - int(i_l2r)  # new i
        konstant2nums[i] += 1  # this constant i, seen one more time from this i_start
    return sorted(konstant2nums)  # Just the keys
kaprekar2(2)

[0, 9, 27, 45, 63, 81]

Optimisations

The code takes a minute to produce kaprekar1(6), and looking at the code I chuck away what is seen for every i_start.
What if a later i_start has an i that visits something seen for a previous i_start?

In this next version I keep track of everything seen earlier in seen2 which automatically maps to the ending constant found for all numbers of seen

def kaprekar3(digits: int=4):
    "Optimised"
    konstants = set()
    seen2 = {}  # Maps iterated i to final constant across all initial i's
    for i in range(10**digits):
        i_start = i
        seen = set()
        while i not in seen and i not in seen2:  # Short-cut via earlier i_starts too.
            seen.add(i)
            i_l2r = ''.join(sorted(f"{i:0{digits}}"))
            i = int(i_l2r[::-1]) - int(i_l2r)
        if i in seen2:
            i = seen2[i]  # then this was its final constant
        for s in seen:
            seen2[s] = i  # Accumulate data from this i_start
        konstants.add(i)
    return sorted(konstants)
kaprekar3(2)

[0, 9]

Whoa! different results

kaprekar2(2) gave [0, 9, 27, 45, 63, 81] ?

Lets work through one of the extra results for the digits = 2 ones a bit more:

81 -> 81 - 18 = 63
63 -> 63 - 36 = 27
27 -> 72 - 27 = 45
45 -> 54 - 45 =  9

So kaprekar1 and 2 did not finish their reductions! All the extra results reduce to the 9 given in kaprekar3(2).

Results for more digits

for d in range(7):
    print()
    %time print(f"{d = }; {kaprekar3(d) = }")

d = 0; kaprekar3(d) = [0]
CPU times: total: 0 ns
Wall time: 0 ns

d = 1; kaprekar3(d) = [0]
CPU times: total: 0 ns
Wall time: 0 ns

d = 2; kaprekar3(d) = [0, 9]
CPU times: total: 0 ns
Wall time: 0 ns

d = 3; kaprekar3(d) = [0, 495]
CPU times: total: 0 ns
Wall time: 4.99 ms

d = 4; kaprekar3(d) = [0, 6174]
CPU times: total: 46.9 ms
Wall time: 50 ms

d = 5; kaprekar3(d) = [0, 53955, 63954, 74943]
CPU times: total: 438 ms
Wall time: 444 ms

d = 6; kaprekar3(d) = [0, 549945, 631764, 851742]
CPU times: total: 4.91 s
Wall time: 4.93 s

Lets check those digits = 5 multiple values don't collapse to other constants.

def test_multiple_results(kaprekar_func, digits=4):
    print(f"TESTING {kaprekar_func.__name__}({digits}) KONSTANTS", end='')
    stated_konstants = kaprekar_func(digits)
    konstants = set(stated_konstants)
    for i in stated_konstants:
        i_start = i
        seen = set()
        # Reduce, visibly
        print(f"\n  Reduce konstant {i}:")
        while i not in seen:
            seen.add(i)
            i_l2r = ''.join(sorted(f"{i:0{digits}}"))
            i_new = (i1:=int(i_l2r[::-1])) - (i2:=int(i_l2r))
            print(f"    {i:0{digits}} -> {i1:0{digits}} - {i2:0{digits}} = {i_new:0{digits}}")
            i = i_new
        if not seen.intersection(konstants):
            print("  ERROR! A new constant produced?!?")
        elif i in konstants:
            if i != i_start:
                print("  NOTE OK. One of the reduction intermediates occurs in the original konstants.")
            else:
                print("  NOTE OK. Reduces to itself.")
        elif seen.intersection(konstants):
            print("  NOTE OK. One of the reduction intermediates occurs in the original konstants.")
        else:
            print("  ERROR! A new constant produced!")
test_multiple_results(kaprekar3, 5)

TESTING kaprekar3(5) KONSTANTS
  Reduce konstant 0:
    00000 -> 00000 - 00000 = 00000
  NOTE OK. Reduces to itself.

  Reduce konstant 53955:
    53955 -> 95553 - 35559 = 59994
    59994 -> 99954 - 45999 = 53955
  NOTE OK. Reduces to itself.

  Reduce konstant 63954:
    63954 -> 96543 - 34569 = 61974
    61974 -> 97641 - 14679 = 82962
    82962 -> 98622 - 22689 = 75933
    75933 -> 97533 - 33579 = 63954
  NOTE OK. Reduces to itself.

  Reduce konstant 74943:
    74943 -> 97443 - 34479 = 62964
    62964 -> 96642 - 24669 = 71973
    71973 -> 97731 - 13779 = 83952
    83952 -> 98532 - 23589 = 74943
  NOTE OK. Reduces to itself.

test_multiple_results(kaprekar3, 6)

TESTING kaprekar3(6) KONSTANTS
  Reduce konstant 0:
    000000 -> 000000 - 000000 = 000000
  NOTE OK. Reduces to itself.

  Reduce konstant 549945:
    549945 -> 995544 - 445599 = 549945
  NOTE OK. Reduces to itself.

  Reduce konstant 631764:
    631764 -> 766431 - 134667 = 631764
  NOTE OK. Reduces to itself.

  Reduce konstant 851742:
    851742 -> 875421 - 124578 = 750843
    750843 -> 875430 - 034578 = 840852
    840852 -> 885420 - 024588 = 860832
    860832 -> 886320 - 023688 = 862632
    862632 -> 866322 - 223668 = 642654
    642654 -> 665442 - 244566 = 420876
    420876 -> 876420 - 024678 = 851742
  NOTE OK. Reduces to itself.

The konstants from kaprekar3 are legit.

END.

Riffing on triplet sum to a target

 

(Best viewed on a larger screen).

There's a task that goes:

Given a list of integers and a target integer, return all "normalised" triplets of numbers from that list that sum to the target value.
Normalised triplets are a tuple of three values in sorted order, i.e. (t0, t1, t2) where t0 <= t1 <= t2.

First, simple, thoughts

A straight-forward implementation might be to:

1. Generate all triplets from the numbers.
2. Filter out those that sum to the target

from itertools import combinations

numbers = [2, 0, 1, 3]

print(f"{numbers = }")

print(f"{list(combinations(numbers, 3)) = }")

print(f"{sorted(numbers) = }")

print(f"{list(combinations(sorted(numbers), 3)) = }")

numbers = [2, 0, 1, 3]
list(combinations(numbers, 3)) = [(2, 0, 1), (2, 0, 3), (2, 1, 3), (0, 1, 3)]
sorted(numbers) = [0, 1, 2, 3]
list(combinations(sorted(numbers), 3)) = [(0, 1, 2), (0, 1, 3), (0, 2, 3), (1, 2, 3)]

We see that the sorted numbers produce normalised triplets

def triplet_sum1(numbers: list[int], target: int) -> list[tuple[int]]:

    "triplet-sum by filtering all triplet combinations"

    return [triplet for triplet in combinations(sorted(numbers), 3)

            if sum(triplet) == target]

# %%

def tests1(funcs, args=None):

    if args is None:

        args = [([2, 0, 1, 3], 4),

                ([0,1,3,2,4,5,6], 11),

                ([0,1,2], 6),

                ([0,1,2], 3),

                ([0,1,2], 1),

                ([0,1], 2),

                ([0,1], 1),

                ([0], 0),

                ([], 99),

                ]

    seperator, indent = ('---\n', '  ') if len(funcs) > 1 else ('', '')

    lines = []

    for numbers, target in args:

        line = ''

        for func in funcs:

            line += f"{indent}{func.__name__}({numbers}, {target}) = "

            try:

                answer = func(numbers, target)

                line += str(answer)

            except Exception as ex:

                line += str(ex)

            line += '\n'

        lines.append(line)

    print(seperator.join(lines))

tests1([triplet_sum1])

triplet_sum1([2, 0, 1, 3], 4) = [(0, 1, 3)]
triplet_sum1([0, 1, 3, 2, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
triplet_sum1([0, 1, 2], 6) = []
triplet_sum1([0, 1, 2], 3) = [(0, 1, 2)]
triplet_sum1([0, 1, 2], 1) = []
triplet_sum1([0, 1], 2) = []
triplet_sum1([0, 1], 1) = []
triplet_sum1([0], 0) = []
triplet_sum1([], 99) = []

The above looks correct and triplet_sum1 is neat and small.

But that combinations can take a long time even if most of its terms are to be filtered out

%time triplet_sum1(list(range(666)), 6)

CPU times: total: 6.59 s
Wall time: 6.58 s

[(0, 1, 5), (0, 2, 4), (1, 2, 3)]

Explicit, short-circuited, combinations

If we generate our own triples we should be able to short circuit them if they cannot sum to the target.

Let's generate triples from numbers.

numbers = [0, 10, 20, 30]  #

numbers.sort()

for i, item in enumerate(numbers):

    for j, jtem in enumerate(numbers[i+1:], start=i+1):  # from left of item

        for k, ktem in enumerate(numbers[j+1:], start=j+1):  # from left of jtem

            print(f"{(i,j,k) = }; {(item, jtem, ktem) = }; {sum([item, jtem, ktem]) = }")

(i,j,k) = (0, 1, 2); (item, jtem, ktem) = (0, 10, 20); sum([item, jtem, ktem]) = 30
(i,j,k) = (0, 1, 3); (item, jtem, ktem) = (0, 10, 30); sum([item, jtem, ktem]) = 40
(i,j,k) = (0, 2, 3); (item, jtem, ktem) = (0, 20, 30); sum([item, jtem, ktem]) = 50
(i,j,k) = (1, 2, 3); (item, jtem, ktem) = (10, 20, 30); sum([item, jtem, ktem]) = 60

Because numbers is sorted, and the triples are produced in this sorted order then, the sum of the triples will never decrease.

We can create the sum with less additions by using partial sums:

numbers = [0, 10, 20, 30]  #

numbers.sort()

for i, item in enumerate(numbers):

    # isum == item, omitted

    for j, jtem in enumerate(numbers[i+1:], i+1):

        jsum = item + jtem  # partial sum from item to jtem

        for k, ktem in enumerate(numbers[j+1:], j+1):

            ksum = jsum + ktem  # sum to ktem

            print(f"{(item, jtem, ktem) = }; {ksum = }")

(item, jtem, ktem) = (0, 10, 20); ksum = 30
(item, jtem, ktem) = (0, 10, 30); ksum = 40
(item, jtem, ktem) = (0, 20, 30); ksum = 50
(item, jtem, ktem) = (10, 20, 30); ksum = 60

Those (partial) sums never decrease either so if any of the partial sums are more than the target then its whole for-loop can be skipped.

numbers = sorted(range(0, 100, 10))

target = 30

print(f"{numbers = }\n{target = }\n")

for i, item in enumerate(numbers):

    print(f"# iloop {(item,) = }")

    isum = item

    if isum <= target:

        for j, jtem in enumerate(numbers[i+1:], i+1):

            print(f"  # jloop {(item, jtem) = }")

            jsum = isum + jtem

            if jsum <= target:

                for k, ktem in enumerate(numbers[j+1:], j+1):

                    print(f"    # kloop {(item, jtem, ktem) = }")

                    ksum = jsum + ktem

                    if ksum == target:

                        print('    ANSWER:', (item, jtem, ktem))

                    elif ksum > target:

                        break

            else:

                break # Skip as jsum > target

    else:

        break # Skip as item > target

numbers = [0, 10, 20, 30, 40, 50, 60, 70, 80, 90]
target = 30

# iloop (item,) = (0,)
  # jloop (item, jtem) = (0, 10)
    # kloop (item, jtem, ktem) = (0, 10, 20)
    ANSWER: (0, 10, 20)
    # kloop (item, jtem, ktem) = (0, 10, 30)
  # jloop (item, jtem) = (0, 20)
    # kloop (item, jtem, ktem) = (0, 20, 30)
  # jloop (item, jtem) = (0, 30)
    # kloop (item, jtem, ktem) = (0, 30, 40)
  # jloop (item, jtem) = (0, 40)
# iloop (item,) = (10,)
  # jloop (item, jtem) = (10, 20)
    # kloop (item, jtem, ktem) = (10, 20, 30)
  # jloop (item, jtem) = (10, 30)
# iloop (item,) = (20,)
  # jloop (item, jtem) = (20, 30)
# iloop (item,) = (30,)
  # jloop (item, jtem) = (30, 40)
# iloop (item,) = (40,)

Look for the breaking out of inner loops when the (partial) sums exceed target.

We now get our second implementation:

def triplet_sum2(numbers: list[int], target: int) -> list[tuple[int]]:

    "Triplet-sum with explicit, short-circuited combinations generator."

    numbers.sort()

    answers = []

   

    for i, item in enumerate(numbers):

        isum = item

        if isum <= target:

            for j, jtem in enumerate(numbers[i+1:], i+1):

                jsum = isum + jtem

                if jsum <= target:

                    for k, ktem in enumerate(numbers[j+1:], j+1):

                        ksum = jsum + ktem

                        if ksum == target:

                            answers.append((item, jtem, ktem))

                        elif ksum > target:

                            break

                else:

                    break # Skip as jsum > target

        else:

            break # Skip as item > target

   

    return answers

tests1([triplet_sum1, triplet_sum2])

  triplet_sum1([2, 0, 1, 3], 4) = [(0, 1, 3)]
  triplet_sum2([2, 0, 1, 3], 4) = [(0, 1, 3)]
---
  triplet_sum1([0, 1, 3, 2, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
  triplet_sum2([0, 1, 3, 2, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
---
  triplet_sum1([0, 1, 2], 6) = []
  triplet_sum2([0, 1, 2], 6) = []
---
  triplet_sum1([0, 1, 2], 3) = [(0, 1, 2)]
  triplet_sum2([0, 1, 2], 3) = [(0, 1, 2)]
---
  triplet_sum1([0, 1, 2], 1) = []
  triplet_sum2([0, 1, 2], 1) = []
---
  triplet_sum1([0, 1], 2) = []
  triplet_sum2([0, 1], 2) = []
---
  triplet_sum1([0, 1], 1) = []
  triplet_sum2([0, 1], 1) = []
---
  triplet_sum1([0], 0) = []
  triplet_sum2([0], 0) = []
---
  triplet_sum1([], 99) = []
  triplet_sum2([], 99) = []

Check the timings:

%time triplet_sum1(list(range(666)), 6)

%time triplet_sum2(list(range(666)), 6)

CPU times: total: 6.59 s
Wall time: 6.6 s
CPU times: total: 0 ns
Wall time: 0 ns

[(0, 1, 5), (0, 2, 4), (1, 2, 3)]

lets try timing multiple runs of ttriplet_sum2 as it is so fast:

%timeit triplet_sum2(list(range(666)), 6)

29.7 µs ± 89.1 ns per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

So that's microseconds vs seconds.

Space - the final frontier

Looking again at triplet_sum2, I see that after the necessary sorting; many sliced copies of the numbers list are created in both enumerations.

We could use islice to stop those copies.

from itertools import islice

def triplet_sum3(numbers: list[int], target: int) -> list[tuple[int]]:

    "Triplet-sum with short-circuited combinations and less copying of numbers."

    numbers.sort()

    answers = []

   

    for i, item in enumerate(numbers):

        isum = item

        if isum <= target:

            for j, jtem in enumerate(islice(numbers, i+1, None), i+1):

                jsum = isum + jtem

                if jsum <= target:

                    for k, ktem in enumerate(islice(numbers, j+1, None), j+1):

                        ksum = jsum + ktem

                        if ksum == target:

                            answers.append((item, jtem, ktem))

                        elif ksum > target:

                            break

                else:

                    break # Skip as jsum > target

        else:

            break # Skip as item > target

   

    return answers

%timeit triplet_sum3(list(range(666)), 6)

13.9 µs ± 34.3 ns per loop (mean ± std. dev. of 7 runs, 100,000 loops each)

Hmmm, even faster than triplet_sum2 as it does not have to create extra list slices.

Lets see if it tests the same:

tests1([triplet_sum2, triplet_sum3])

  triplet_sum2([2, 0, 1, 3], 4) = [(0, 1, 3)]
  triplet_sum3([0, 1, 2, 3], 4) = [(0, 1, 3)]
---
  triplet_sum2([0, 1, 3, 2, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
  triplet_sum3([0, 1, 2, 3, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
---
  triplet_sum2([0, 1, 2], 6) = []
  triplet_sum3([0, 1, 2], 6) = []
---
  triplet_sum2([0, 1, 2], 3) = [(0, 1, 2)]
  triplet_sum3([0, 1, 2], 3) = [(0, 1, 2)]
---
  triplet_sum2([0, 1, 2], 1) = []
  triplet_sum3([0, 1, 2], 1) = []
---
  triplet_sum2([0, 1], 2) = []
  triplet_sum3([0, 1], 2) = []
---
  triplet_sum2([0, 1], 1) = []
  triplet_sum3([0, 1], 1) = []
---
  triplet_sum2([0], 0) = []
  triplet_sum3([0], 0) = []
---
  triplet_sum2([], 99) = []
  triplet_sum3([], 99) = []

Pairs, triplets, quads, ... Prancing Pointers

The indices i, j, k are fixed at three variables for generating triplets, and rely on a nesting of a static three for-loops. If I used an array of all these indices in order, called indices I could have a pointer called incrementing that indexed which of these indices to increment at any time.

Similarly I could keep isum, jsum, ksum the (partial) summs of the elements of numbers pointed to by indices, in its own array called accum - short for accumulator.

Last but not least, I will use an argument n_tuple defaulting to 3 to sum triples, 4 to sum quads, ...

def triplet_sum4(numbers: list[int], target: int, n_tuple: int=3) \

        -> list[tuple[int]]:

    """

    Generate triplets from numbers that sum to target in sorted order.

    Indexes the sorted numbers without otherwise copying them.

    n_tuple=3 for triplets, 2 for pairs, etc, for any +ve int

    """

    numbers.sort()

    n_len = len(numbers)

    answers = []

    indices = [-1] * n_tuple  # indices for triples; indices[0] must be -1

    incrementing = 0          # index to increment at any time

    accum = [None] * n_tuple  # (partial) sums in accumulator

    while True:

        indices[incrementing] += 1

        if indices[incrementing] >= n_len:

            # maxed out this index so go back one

            incrementing -= 1

            if incrementing < 0:

                break

            continue  # continue incrementing 'outer' index

        if incrementing < n_tuple - 1:

            indices[incrementing+1] = indices[incrementing]

            acc = accum[incrementing] = numbers[indices[incrementing]] + (

                                    0 if incrementing == 0

                                    else accum[incrementing - 1])

            if acc > target:

                # maxed out this index so go back one

                incrementing -= 1

                if incrementing < 0:

                    break

                continue

            incrementing += 1  # next index

        elif incrementing == n_tuple - 1:

            # updated last index

            acc = numbers[indices[incrementing]] + (

                    0 if incrementing == 0

                    else accum[incrementing - 1])

            if acc == target:

                answers.append(tuple(numbers[i] for i in indices))

    return answers

You can see why I mention prancing pointers.

Lets check it works for triplets.

tests1([triplet_sum3, triplet_sum4])

  triplet_sum3([2, 0, 1, 3], 4) = [(0, 1, 3)]
  triplet_sum4([0, 1, 2, 3], 4) = [(0, 1, 3)]
---
  triplet_sum3([0, 1, 3, 2, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
  triplet_sum4([0, 1, 2, 3, 4, 5, 6], 11) = [(0, 5, 6), (1, 4, 6), (2, 3, 6), (2, 4, 5)]
---
  triplet_sum3([0, 1, 2], 6) = []
  triplet_sum4([0, 1, 2], 6) = []
---
  triplet_sum3([0, 1, 2], 3) = [(0, 1, 2)]
  triplet_sum4([0, 1, 2], 3) = [(0, 1, 2)]
---
  triplet_sum3([0, 1, 2], 1) = []
  triplet_sum4([0, 1, 2], 1) = []
---
  triplet_sum3([0, 1], 2) = []
  triplet_sum4([0, 1], 2) = []
---
  triplet_sum3([0, 1], 1) = []
  triplet_sum4([0, 1], 1) = []
---
  triplet_sum3([0], 0) = []
  triplet_sum4([0], 0) = []
---
  triplet_sum3([], 99) = []
  triplet_sum4([], 99) = []

Can it reject unnecessary triplets?

%timeit triplet_sum4(list(range(666)), 6)

1.42 ms ± 8.19 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

This time its milliseconds instead of the seconds of triplet_sum1, but not as fast as the microseconds of triplet_sum3.

Versatility

Lets try other than triplets with this new for-loop-less algorithm.

def test_tuples():

    args = [([0,1,2,3,4], 5, 2),

            ([0,1,2,3,4,5,6], 5, 2),

            ([0,1,2,3,4,5,6], 5, 3),

            ([0,1,2,3,4,5,6], 5, 4),

        ]

    func = triplet_sum4

    help(func)

    for arg in args:

            print(f"  {func.__name__}{arg} =", end=' ')

            try:

                answer = func(*arg)

                print(answer)

            except Exception as ex:

                print(ex)

test_tuples()

Help on function triplet_sum4 in module __main__:

triplet_sum4(numbers: list[int], target: int, n_tuple: int = 3) -> list[tuple[int]]
    Generate triplets from numbers that sum to target in sorted order.
    Indexes the sorted numbers without otherwise copying them.
    
    n_tuple=3 for triplets, 2 for pairs, etc, for any +ve int

  triplet_sum4([0, 1, 2, 3, 4], 5, 2) = [(1, 4), (2, 3)]
  triplet_sum4([0, 1, 2, 3, 4, 5, 6], 5, 2) = [(0, 5), (1, 4), (2, 3)]
  triplet_sum4([0, 1, 2, 3, 4, 5, 6], 5, 3) = [(0, 1, 4), (0, 2, 3)]
  triplet_sum4([0, 1, 2, 3, 4, 5, 6], 5, 4) = []

END.