Quote from: bigvito19 on October 03, 2021, 05:19:13 PM

I tested it and tried it, I kinda wish you could do that with the addresses.

You could but it wouldn't really make sense. It only makes sense when you do this with private keys. But if I can find a way to "jump" between private keys that are more "natural looking" (see close to the end of this post for this expiration) e.g. if I could find terms to get from something like 1101001001 to e.g. 1101001100 instead of each time incrementing by 1, I could make a more efficient search algorithm than the one Bitcrack is currently doing (linear search).

Quote from: PawGo on Today at 03:44:42 PM

Quote from: NotATether on October 03, 2021, 06:36:01 AM

It also supports analyzing the probability of a sequence of bits occurring in multiple positions, but be warned that that increasing the number of positions to estimate together, uses a lot of memory (A LOT!).

By the way, maybe that could be interesting for you: https://www.geeksforgeeks.org/longest-common-substring-binary-representation-two-numbers/

In fact, I have already implemented this in another (private) script of mine. The results were that groups of 1, 2 and 3 zero and one bits were the most common, followed by groups of 4-8 zeros and ones, then everything else longer than that.

If you generate a bunch of random PKs and count how many sequences of 1, 2, 3, etc zero & one bits they have, then compute their mean (call this sample_mean), you can actually use the result to calculate the average standard deviation between the mean and any private key you throw at it - could be a puzzle key, could be someone's random address private key, anything. Call the sequence counts of this testing privkey groups_testingPK_count. Then the avg. std. deviation is just sqrt(mean(variance[sample_mean, groups_testingPK_count])).

Lower (closer to zero in absolute value) is better, because it means keys start to look more like this:

10001101110010011100

Instead of this:

10101010101010101010

Or even this:

11111111111111111111

Quote from: a.a on Today at 03:50:46 PM

I have a conjecture:
The longest amount of consecutive 1 or 0 is sqrt(bits). So sqrt(120) = 10,95. So probably we can skip all numbes which have more than 11 consecutive 1 and 0.

In my testing, sequences of greater than 11 zeros or ones only occurred maximum once in an entire sample of 1000 256-bit random numbers.