Topic: Bitcoin puzzle transaction ~32 BTC prize to who solves it - page 188. (Read 230740 times)
Is your script supposed to show the speed while running for #30? how long should it take to find?
The second day I watch what james5000 writes and it's very funny to me)
It's especially funny to see how other people support him)
I don’t want to offend anyone, but I get the impression that you didn’t study mathematics at school, your teacher should be very ashamed.
The method suggested by james5000 would require you to try more than 2^65 combinations to solve a 66 bit key.
It is impossible to go through such a number of combinations in a month, or even in a year!
Please learn to count before you write like this, you look very stupid.
I didn't mean to offend anyone, I'm sorry if I hurt your feelings, I just had to tell you that you are doing nonsense, I wish you all success!
It's especially funny to see how other people support him)
I don’t want to offend anyone, but I get the impression that you didn’t study mathematics at school, your teacher should be very ashamed.
The method suggested by james5000 would require you to try more than 2^65 combinations to solve a 66 bit key.
It is impossible to go through such a number of combinations in a month, or even in a year!
Please learn to count before you write like this, you look very stupid.
I didn't mean to offend anyone, I'm sorry if I hurt your feelings, I just had to tell you that you are doing nonsense, I wish you all success!
lmfao
As there are more than 2^65 possibilities for 66 bits, even though I'm skipping intervals.
For example:
Between the initial key and the second key, 2^33 keys are skipped, then 2^32, 2^31, and so on...
I believe you don't even need to calculate it to see that it's less than 2^65.
The second day I watch what james5000 writes and it's very funny to me)
It's especially funny to see how other people support him)
I don’t want to offend anyone, but I get the impression that you didn’t study mathematics at school, your teacher should be very ashamed.
The method suggested by james5000 would require you to try more than 2^65 combinations to solve a 66 bit key.
It is impossible to go through such a number of combinations in a month, or even in a year!
Please learn to count before you write like this, you look very stupid.
I didn't mean to offend anyone, I'm sorry if I hurt your feelings, I just had to tell you that you are doing nonsense, I wish you all success!
It's especially funny to see how other people support him)
I don’t want to offend anyone, but I get the impression that you didn’t study mathematics at school, your teacher should be very ashamed.
The method suggested by james5000 would require you to try more than 2^65 combinations to solve a 66 bit key.
It is impossible to go through such a number of combinations in a month, or even in a year!
Please learn to count before you write like this, you look very stupid.
I didn't mean to offend anyone, I'm sorry if I hurt your feelings, I just had to tell you that you are doing nonsense, I wish you all success!
I humbly request partnership with albertobsd to use multi-threading in this method in C++. If the creator of bitcrack could assist with the CUDA version I'm developing, we could potentially achieve speeds of 200-300Mk/s.
As promised, here is the basic outline of the project.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
I tried to substitute data from lower bit ranges.
20 bits in less than a minute.
I can't find 30 bits for half an hour already.
I understand that you need to know the exact number of digits 1?
I apologize for the mistake. In the getArray function in utils.py, it's already fixed. Please ensure that the hash160 target has been set.
This code indeed needs improvement to be faster. This is just for proof of concept.
My C++ CUDA version on a GTX 1650 4GB runs at 250,000 per second, solving puzzle 30 in 2.5 to 3 minutes.
But since I'm quite new to GPU programming, I haven't been able to harness the full power of the graphics card yet.
As promised, here is the basic outline of the project.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
I tried to substitute data from lower bit ranges.
20 bits in less than a minute.
I can't find 30 bits for half an hour already.
I understand that you need to know the exact number of digits 1?
When finishing a larger group of these groups (the group size will be the quantity of bits set to 0), the incremented value rises by a power of 2 - 1 (2^14 + 3) - (2^13 + 3) - (2^12 + 3).... (2^14 + 7) - (2^13 + 7) .... (2^14 + 15) - (2^13 + 15).
Or to simplify, when the numbers become too large, we can add the point equivalent to the power of 2 to the increment value (3 + 1 = 4 or 2^2), then subtract one point (2^2 - 1 = 3) - (2^3 - 1 = 7) - (2^4 - 1 = 15)...
In this example, it might not seem necessary, but when the increment value is 2047, we don't need to add the point 2047; instead, we add the point 2^11 and subtract one point.
This way, we only need an array of points the size of the key for use in operations.
So, at most, for each key, we will perform a maximum of 3 operations: two additions and one subtraction.
Or to simplify, when the numbers become too large, we can add the point equivalent to the power of 2 to the increment value (3 + 1 = 4 or 2^2), then subtract one point (2^2 - 1 = 3) - (2^3 - 1 = 7) - (2^4 - 1 = 15)...
In this example, it might not seem necessary, but when the increment value is 2047, we don't need to add the point 2047; instead, we add the point 2^11 and subtract one point.
This way, we only need an array of points the size of the key for use in operations.
So, at most, for each key, we will perform a maximum of 3 operations: two additions and one subtraction.
As promised, here is the basic outline of the project.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
https://github.com/Jamerson1000/million-python.git
I am currently working with C++ for CUDA, and I will soon post it on GitHub.
Yes, as I mentioned, it's going to get interesting. 
Knowing that each point on the secp256k1 curve has its value, let's speed up a bit and jump to the 'magic formula' of powers. For example:
The generator point is the private key 2^0, which is 1.
The next point is 2^1, which is 2.
2^2 = 4
2^3 = 8
...
...
And so on, right?
If you have a private key A and add a private key B, you get a private key C. Similarly, if you have a point A and add a point B, you get a point C.
If we analyze the difference between one key and another, we obtain the beautiful pattern below:
If we observe (I believe you've already noticed
), we can see that they are powers of 2 with a slight variation in each new group (which happens when the leftmost bit advances by one digit).
Now, what happens if you generate the public key from the initial key and add the point 2^14? You will have exactly the point equivalent to the next key's point, without needing scalar multiplication. So, we can follow the decreasing pattern:
Add 2^13 to the current point
Add 2^12 to the current point
Add 2^11 to the current point
Add 2^10 to the current point
...
...
After adding the point 2^0 to the resulting point, we will reach the end of a group. The next group will start with:
Add 2^14 to the current point and add point 1 = (2^14 + 1) = 16385.
Knowing that each point on the secp256k1 curve has its value, let's speed up a bit and jump to the 'magic formula' of powers. For example:
The generator point is the private key 2^0, which is 1.
The next point is 2^1, which is 2.
2^2 = 4
2^3 = 8
...
...
And so on, right?
If you have a private key A and add a private key B, you get a private key C. Similarly, if you have a point A and add a point B, you get a point C.
If we analyze the difference between one key and another, we obtain the beautiful pattern below:
Code:
16384
8192
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
16385
8192
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
8193
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
4097
2048
1024
512
256
128
64
32
16
8
4
2
1
2049
1024
512
256
128
64
32
16
8
4
2
1
1025
512
256
128
64
32
16
8
4
2
1
513
256
128
64
32
16
8
4
2
1
257
128
64
32
16
8
4
2
1
8192
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
16385
8192
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
8193
4096
2048
1024
512
256
128
64
32
16
8
4
2
1
4097
2048
1024
512
256
128
64
32
16
8
4
2
1
2049
1024
512
256
128
64
32
16
8
4
2
1
1025
512
256
128
64
32
16
8
4
2
1
513
256
128
64
32
16
8
4
2
1
257
128
64
32
16
8
4
2
1
If we observe (I believe you've already noticed
), we can see that they are powers of 2 with a slight variation in each new group (which happens when the leftmost bit advances by one digit).Now, what happens if you generate the public key from the initial key and add the point 2^14? You will have exactly the point equivalent to the next key's point, without needing scalar multiplication. So, we can follow the decreasing pattern:
Add 2^13 to the current point
Add 2^12 to the current point
Add 2^11 to the current point
Add 2^10 to the current point
...
...
After adding the point 2^0 to the resulting point, we will reach the end of a group. The next group will start with:
Add 2^14 to the current point and add point 1 = (2^14 + 1) = 16385.
Enter the number of bits you want to search: 66
Enter the percentage of zeros you want: 43.5
Enter the percentage of ones you want: 56.5
Binary Key: 100000000000000000000000000000111111111111111111111111111111111111 Hex Key: 20000000fffffffff
Binary Key: 100000000000000000000000000001011111111111111111111111111111111111 Hex Key: 200000017ffffffff
Binary Key: 100000000000000000000000000001101111111111111111111111111111111111 Hex Key: 20000001bffffffff
Binary Key: 100000000000000000000000000001110111111111111111111111111111111111 Hex Key: 20000001dffffffff
Binary Key: 100000000000000000000000000001111011111111111111111111111111111111 Hex Key: 20000001effffffff
Binary Key: 100000000000000000000000000001111101111111111111111111111111111111 Hex Key: 20000001f7fffffff
Binary Key: 100000000000000000000000000001111110111111111111111111111111111111 Hex Key: 20000001fbfffffff
Binary Key: 100000000000000000000000000001111111011111111111111111111111111111 Hex Key: 20000001fdfffffff
Jump is working, but we need a significant amount of computational power for it. For instance, as I input a combination of 43.5% and 56.5%, we will have to try numerous such combinations. In addition to these combinations, we will also need to try the inverse combinations of all those. Completing just one combination can take up a substantial amount of time. In short, this is also a highly time-consuming process. but still considerable..
Enter the percentage of zeros you want: 43.5
Enter the percentage of ones you want: 56.5
Binary Key: 100000000000000000000000000000111111111111111111111111111111111111 Hex Key: 20000000fffffffff
Binary Key: 100000000000000000000000000001011111111111111111111111111111111111 Hex Key: 200000017ffffffff
Binary Key: 100000000000000000000000000001101111111111111111111111111111111111 Hex Key: 20000001bffffffff
Binary Key: 100000000000000000000000000001110111111111111111111111111111111111 Hex Key: 20000001dffffffff
Binary Key: 100000000000000000000000000001111011111111111111111111111111111111 Hex Key: 20000001effffffff
Binary Key: 100000000000000000000000000001111101111111111111111111111111111111 Hex Key: 20000001f7fffffff
Binary Key: 100000000000000000000000000001111110111111111111111111111111111111 Hex Key: 20000001fbfffffff
Binary Key: 100000000000000000000000000001111111011111111111111111111111111111 Hex Key: 20000001fdfffffff
Jump is working, but we need a significant amount of computational power for it. For instance, as I input a combination of 43.5% and 56.5%, we will have to try numerous such combinations. In addition to these combinations, we will also need to try the inverse combinations of all those. Completing just one combination can take up a substantial amount of time. In short, this is also a highly time-consuming process. but still considerable..
The problem isn't guessing a random number, it's narrowing down the search range to more probable keys. Thank you for posting the percentages; this way we can see that after 54, none have fewer than 40% of bits as 1 or 0, nor more than 60%. I believe we can accept this as a fact.
This means that perhaps you have gained some benefit from my post, which is why the saying "knowledge increases by sharing" is mentioned. Well, if you hold this viewpoint and it might indeed be true, in a 66-bit key, if we allocate zeros between 40 to 60 % and ones also between 40 to 60 % , we can significantly reduce the boundary of the search space. Yes, this statement holds a considerable amount of credibility 👍 👍
Understanding the concept of the idea, let's move on to the code. This algorithm magically skips all combinations that don't meet the rules without needing to be verified or even "seen".
As an example, let's use puzzle 30 because it's smaller.
Only keys with 16 bits set to 1 and 14 bits set to 0 will be processed.
The keys will be:
This way, we can visualize the jumps from one key to another.
As mentioned by the friend above, using this approach would require performing scalar multiplication for each key. However, let's continue because (believe me) it's going to get interesting!
As an example, let's use puzzle 30 because it's smaller.
Only keys with 16 bits set to 1 and 14 bits set to 0 will be processed.
Code:
def getArray(ones, zeros):
# the first bit is always 1.
string = '1'
array = list(string)
while len(array) < (zeros + ones):
if array.count("0") < zeros:
array.append("0")
elif array.count("1") < ones:
array.append("1")
return array
key_size = 30
ones = 16
# init a key in array of bits with 16 ones and 14 zeros
startKey = getArray(ones, key_size - ones)
while True:
print("".join(startKey))
i = key_size - 2
while i >= 0 and startKey[i] >= startKey[i + 1]:
i -= 1
if i < 0:
break
j = key_size - 1
while j > i and startKey[j] <= startKey[i]:
j -= 1
temp = startKey[i]
startKey[i] = startKey[j]
startKey[j] = temp
left = i + 1
right = key_size - 1
while left < right:
temp = startKey[left]
startKey[left] = startKey[right]
startKey[right] = temp
left += 1
right -= 1
# the first bit is always 1.
string = '1'
array = list(string)
while len(array) < (zeros + ones):
if array.count("0") < zeros:
array.append("0")
elif array.count("1") < ones:
array.append("1")
return array
key_size = 30
ones = 16
# init a key in array of bits with 16 ones and 14 zeros
startKey = getArray(ones, key_size - ones)
while True:
print("".join(startKey))
i = key_size - 2
while i >= 0 and startKey[i] >= startKey[i + 1]:
i -= 1
if i < 0:
break
j = key_size - 1
while j > i and startKey[j] <= startKey[i]:
j -= 1
temp = startKey[i]
startKey[i] = startKey[j]
startKey[j] = temp
left = i + 1
right = key_size - 1
while left < right:
temp = startKey[left]
startKey[left] = startKey[right]
startKey[right] = temp
left += 1
right -= 1
The keys will be:
Code:
100000000000000111111111111111 0x20007fff
100000000000001011111111111111 0x2000bfff
100000000000001101111111111111 0x2000dfff
100000000000001110111111111111 0x2000efff
100000000000001111011111111111 0x2000f7ff
100000000000001111101111111111 0x2000fbff
100000000000001111110111111111 0x2000fdff
100000000000001111111011111111 0x2000feff
100000000000001111111101111111 0x2000ff7f
100000000000001111111110111111 0x2000ffbf
100000000000001111111111011111 0x2000ffdf
100000000000001111111111101111 0x2000ffef
100000000000001111111111110111 0x2000fff7
100000000000001111111111111011 0x2000fffb
100000000000001111111111111101 0x2000fffd
100000000000001111111111111110 0x2000fffe
100000000000010011111111111111 0x20013fff
100000000000010101111111111111 0x20015fff
100000000000010110111111111111 0x20016fff
100000000000010111011111111111 0x200177ff
100000000000010111101111111111 0x20017bff
100000000000010111110111111111 0x20017dff
100000000000010111111011111111 0x20017eff
100000000000010111111101111111 0x20017f7f
100000000000010111111110111111 0x20017fbf
100000000000010111111111011111 0x20017fdf
100000000000010111111111101111 0x20017fef
100000000000010111111111110111 0x20017ff7
100000000000010111111111111011 0x20017ffb
100000000000010111111111111101 0x20017ffd
100000000000010111111111111110 0x20017ffe
100000000000011001111111111111 0x20019fff
100000000000011010111111111111 0x2001afff
100000000000011011011111111111 0x2001b7ff
100000000000011011101111111111 0x2001bbff
100000000000011011110111111111 0x2001bdff
100000000000011011111011111111 0x2001beff
100000000000011011111101111111 0x2001bf7f
100000000000011011111110111111 0x2001bfbf
100000000000011011111111011111 0x2001bfdf
100000000000011011111111101111 0x2001bfef
100000000000011011111111110111 0x2001bff7
100000000000011011111111111011 0x2001bffb
100000000000011011111111111101 0x2001bffd
100000000000011011111111111110 0x2001bffe
100000000000011100111111111111 0x2001cfff
100000000000011101011111111111 0x2001d7ff
100000000000011101101111111111 0x2001dbff
100000000000011101110111111111 0x2001ddff
100000000000011101111011111111 0x2001deff
100000000000011101111101111111 0x2001df7f
100000000000011101111110111111 0x2001dfbf
100000000000011101111111011111 0x2001dfdf
100000000000011101111111101111 0x2001dfef
100000000000011101111111110111 0x2001dff7
100000000000011101111111111011 0x2001dffb
100000000000011101111111111101 0x2001dffd
100000000000011101111111111110 0x2001dffe
100000000000011110011111111111 0x2001e7ff
100000000000011110101111111111 0x2001ebff
100000000000011110110111111111 0x2001edff
100000000000011110111011111111 0x2001eeff
100000000000011110111101111111 0x2001ef7f
100000000000011110111110111111 0x2001efbf
100000000000011110111111011111 0x2001efdf
100000000000011110111111101111 0x2001efef
100000000000011110111111110111 0x2001eff7
100000000000011110111111111011 0x2001effb
100000000000011110111111111101 0x2001effd
100000000000011110111111111110 0x2001effe
100000000000011111001111111111 0x2001f3ff
100000000000011111010111111111 0x2001f5ff
100000000000011111011011111111 0x2001f6ff
100000000000011111011101111111 0x2001f77f
100000000000011111011110111111 0x2001f7bf
100000000000011111011111011111 0x2001f7df
100000000000011111011111101111 0x2001f7ef
100000000000011111011111110111 0x2001f7f7
100000000000011111011111111011 0x2001f7fb
100000000000011111011111111101 0x2001f7fd
100000000000011111011111111110 0x2001f7fe
100000000000011111100111111111 0x2001f9ff
100000000000011111101011111111 0x2001faff
100000000000011111101101111111 0x2001fb7f
100000000000011111101110111111 0x2001fbbf
100000000000011111101111011111 0x2001fbdf
100000000000011111101111101111 0x2001fbef
100000000000011111101111110111 0x2001fbf7
100000000000011111101111111011 0x2001fbfb
100000000000011111101111111101 0x2001fbfd
100000000000011111101111111110 0x2001fbfe
100000000000011111110011111111 0x2001fcff
100000000000011111110101111111 0x2001fd7f
100000000000011111110110111111 0x2001fdbf
100000000000011111110111011111 0x2001fddf
100000000000011111110111101111 0x2001fdef
100000000000011111110111110111 0x2001fdf7
100000000000011111110111111011 0x2001fdfb
100000000000011111110111111101 0x2001fdfd
100000000000011111110111111110 0x2001fdfe
.....
.....
.....
100000000000001011111111111111 0x2000bfff
100000000000001101111111111111 0x2000dfff
100000000000001110111111111111 0x2000efff
100000000000001111011111111111 0x2000f7ff
100000000000001111101111111111 0x2000fbff
100000000000001111110111111111 0x2000fdff
100000000000001111111011111111 0x2000feff
100000000000001111111101111111 0x2000ff7f
100000000000001111111110111111 0x2000ffbf
100000000000001111111111011111 0x2000ffdf
100000000000001111111111101111 0x2000ffef
100000000000001111111111110111 0x2000fff7
100000000000001111111111111011 0x2000fffb
100000000000001111111111111101 0x2000fffd
100000000000001111111111111110 0x2000fffe
100000000000010011111111111111 0x20013fff
100000000000010101111111111111 0x20015fff
100000000000010110111111111111 0x20016fff
100000000000010111011111111111 0x200177ff
100000000000010111101111111111 0x20017bff
100000000000010111110111111111 0x20017dff
100000000000010111111011111111 0x20017eff
100000000000010111111101111111 0x20017f7f
100000000000010111111110111111 0x20017fbf
100000000000010111111111011111 0x20017fdf
100000000000010111111111101111 0x20017fef
100000000000010111111111110111 0x20017ff7
100000000000010111111111111011 0x20017ffb
100000000000010111111111111101 0x20017ffd
100000000000010111111111111110 0x20017ffe
100000000000011001111111111111 0x20019fff
100000000000011010111111111111 0x2001afff
100000000000011011011111111111 0x2001b7ff
100000000000011011101111111111 0x2001bbff
100000000000011011110111111111 0x2001bdff
100000000000011011111011111111 0x2001beff
100000000000011011111101111111 0x2001bf7f
100000000000011011111110111111 0x2001bfbf
100000000000011011111111011111 0x2001bfdf
100000000000011011111111101111 0x2001bfef
100000000000011011111111110111 0x2001bff7
100000000000011011111111111011 0x2001bffb
100000000000011011111111111101 0x2001bffd
100000000000011011111111111110 0x2001bffe
100000000000011100111111111111 0x2001cfff
100000000000011101011111111111 0x2001d7ff
100000000000011101101111111111 0x2001dbff
100000000000011101110111111111 0x2001ddff
100000000000011101111011111111 0x2001deff
100000000000011101111101111111 0x2001df7f
100000000000011101111110111111 0x2001dfbf
100000000000011101111111011111 0x2001dfdf
100000000000011101111111101111 0x2001dfef
100000000000011101111111110111 0x2001dff7
100000000000011101111111111011 0x2001dffb
100000000000011101111111111101 0x2001dffd
100000000000011101111111111110 0x2001dffe
100000000000011110011111111111 0x2001e7ff
100000000000011110101111111111 0x2001ebff
100000000000011110110111111111 0x2001edff
100000000000011110111011111111 0x2001eeff
100000000000011110111101111111 0x2001ef7f
100000000000011110111110111111 0x2001efbf
100000000000011110111111011111 0x2001efdf
100000000000011110111111101111 0x2001efef
100000000000011110111111110111 0x2001eff7
100000000000011110111111111011 0x2001effb
100000000000011110111111111101 0x2001effd
100000000000011110111111111110 0x2001effe
100000000000011111001111111111 0x2001f3ff
100000000000011111010111111111 0x2001f5ff
100000000000011111011011111111 0x2001f6ff
100000000000011111011101111111 0x2001f77f
100000000000011111011110111111 0x2001f7bf
100000000000011111011111011111 0x2001f7df
100000000000011111011111101111 0x2001f7ef
100000000000011111011111110111 0x2001f7f7
100000000000011111011111111011 0x2001f7fb
100000000000011111011111111101 0x2001f7fd
100000000000011111011111111110 0x2001f7fe
100000000000011111100111111111 0x2001f9ff
100000000000011111101011111111 0x2001faff
100000000000011111101101111111 0x2001fb7f
100000000000011111101110111111 0x2001fbbf
100000000000011111101111011111 0x2001fbdf
100000000000011111101111101111 0x2001fbef
100000000000011111101111110111 0x2001fbf7
100000000000011111101111111011 0x2001fbfb
100000000000011111101111111101 0x2001fbfd
100000000000011111101111111110 0x2001fbfe
100000000000011111110011111111 0x2001fcff
100000000000011111110101111111 0x2001fd7f
100000000000011111110110111111 0x2001fdbf
100000000000011111110111011111 0x2001fddf
100000000000011111110111101111 0x2001fdef
100000000000011111110111110111 0x2001fdf7
100000000000011111110111111011 0x2001fdfb
100000000000011111110111111101 0x2001fdfd
100000000000011111110111111110 0x2001fdfe
.....
.....
.....
This way, we can visualize the jumps from one key to another.
As mentioned by the friend above, using this approach would require performing scalar multiplication for each key. However, let's continue because (believe me) it's going to get interesting!
The method is good as idea but you will lose significant amount of speed because you need to do scalar multiplication for each key, the secp256k1 sequential tricks will not work here.
So the new question will be arises, Is it worth to lose that much of speed to avoid that amount of keys?
So the new question will be arises, Is it worth to lose that much of speed to avoid that amount of keys?
I also faced this issue, so I played the data analyst role and analyzed the data haha (sorry for the joke).
The answer is no, we don't need to perform scalar multiplication for all the keys. This part is a bit more complex and was the most challenging, but everyone will understand.
I apologize a million times. I didn't mention that the goal is not to find the private key directly, but to find the public key through point addition and subtraction on the curve, as we know that working this way is faster.
The method is good as idea but you will lose significant amount of speed because you need to do scalar multiplication for each key, the secp256k1 sequential tricks will not work here.
So the new question will be arises, Is it worth to lose that much of speed to avoid that amount of keys?
So the new question will be arises, Is it worth to lose that much of speed to avoid that amount of keys?
james5000 Your reduction method makes sense and I agree the private key will conform to the similar ratio of 1 and 0 in binary but what I don't understand is how your app searches, is your app reducing the ranges then search every address in that? or does it only search keys that conform to the binary ratio? For example can you put a start and end range and then it skips keys that don't conform? When are you planning to release your app even just the CPU version?
I'm dedicating today to organizing everything into a cleaner project and making it available on GitHub so that they can use and/or contribute.
james5000 Your reduction method makes sense and I agree the private key will conform to the similar ratio of 1 and 0 in binary but what I don't understand is how your app searches, is your app reducing the ranges then search every address in that? or does it only search keys that conform to the binary ratio? For example can you put a start and end range and then it skips keys that don't conform? When are you planning to release your app even just the CPU version?
Puzzle: 1 Zeros: 0 Ones: 1 Percent 0: 0.00% Percent 1: 100.00% Decimal: 1 | Binary: 1
Puzzle: 2 Zeros: 0 Ones: 2 Percent 0: 0.00% Percent 1: 100.00% Decimal: 3 | Binary: 11
Puzzle: 3 Zeros: 0 Ones: 3 Percent 0: 0.00% Percent 1: 100.00% Decimal: 7 | Binary: 111
Puzzle: 4 Zeros: 3 Ones: 1 Percent 0: 75.00% Percent 1: 25.00% Decimal: 8 | Binary: 1000
Puzzle: 5 Zeros: 2 Ones: 3 Percent 0: 40.00% Percent 1: 60.00% Decimal: 21 | Binary: 10101
Puzzle: 6 Zeros: 3 Ones: 3 Percent 0: 50.00% Percent 1: 50.00% Decimal: 49 | Binary: 110001
Puzzle: 7 Zeros: 4 Ones: 3 Percent 0: 57.14% Percent 1: 42.86% Decimal: 76 | Binary: 1001100
Puzzle: 8 Zeros: 5 Ones: 3 Percent 0: 62.50% Percent 1: 37.50% Decimal: 224 | Binary: 11100000
Puzzle: 9 Zeros: 3 Ones: 6 Percent 0: 33.33% Percent 1: 66.67% Decimal: 467 | Binary: 111010011
Puzzle: 10 Zeros: 8 Ones: 2 Percent 0: 80.00% Percent 1: 20.00% Decimal: 514 | Binary: 1000000010
Puzzle: 11 Zeros: 7 Ones: 4 Percent 0: 63.64% Percent 1: 36.36% Decimal: 1155 | Binary: 10010000011
Puzzle: 12 Zeros: 4 Ones: 8 Percent 0: 33.33% Percent 1: 66.67% Decimal: 2683 | Binary: 101001111011
Puzzle: 13 Zeros: 9 Ones: 4 Percent 0: 69.23% Percent 1: 30.77% Decimal: 5216 | Binary: 1010001100000
Puzzle: 14 Zeros: 9 Ones: 5 Percent 0: 64.29% Percent 1: 35.71% Decimal: 10544 | Binary: 10100100110000
Puzzle: 15 Zeros: 6 Ones: 9 Percent 0: 40.00% Percent 1: 60.00% Decimal: 26867 | Binary: 110100011110011
Puzzle: 16 Zeros: 8 Ones: 8 Percent 0: 50.00% Percent 1: 50.00% Decimal: 51510 | Binary: 1100100100110110
Puzzle: 17 Zeros: 6 Ones: 11 Percent 0: 35.29% Percent 1: 64.71% Decimal: 95823 | Binary: 10111011001001111
Puzzle: 18 Zeros: 12 Ones: 6 Percent 0: 66.67% Percent 1: 33.33% Decimal: 198669 | Binary: 110000100000001101
Puzzle: 19 Zeros: 7 Ones: 12 Percent 0: 36.84% Percent 1: 63.16% Decimal: 357535 | Binary: 1010111010010011111
Puzzle: 20 Zeros: 10 Ones: 10 Percent 0: 50.00% Percent 1: 50.00% Decimal: 863317 | Binary: 11010010110001010101
Puzzle: 21 Zeros: 10 Ones: 11 Percent 0: 47.62% Percent 1: 52.38% Decimal: 1811764 | Binary: 110111010010100110100
Puzzle: 22 Zeros: 10 Ones: 12 Percent 0: 45.45% Percent 1: 54.55% Decimal: 3007503 | Binary: 1011011110010000001111
Puzzle: 23 Zeros: 11 Ones: 12 Percent 0: 47.83% Percent 1: 52.17% Decimal: 5598802 | Binary: 10101010110111001010010
Puzzle: 24 Zeros: 15 Ones: 9 Percent 0: 62.50% Percent 1: 37.50% Decimal: 14428676 | Binary: 110111000010101000000100
Puzzle: 25 Zeros: 8 Ones: 17 Percent 0: 32.00% Percent 1: 68.00% Decimal: 33185509 | Binary: 1111110100101111011100101
Puzzle: 26 Zeros: 15 Ones: 11 Percent 0: 57.69% Percent 1: 42.31% Decimal: 54538862 | Binary: 11010000000011001001101110
Puzzle: 27 Zeros: 13 Ones: 14 Percent 0: 48.15% Percent 1: 51.85% Decimal: 111949941 | Binary: 110101011000011100001110101
Puzzle: 28 Zeros: 14 Ones: 14 Percent 0: 50.00% Percent 1: 50.00% Decimal: 227634408 | Binary: 1101100100010110110011101000
Puzzle: 29 Zeros: 13 Ones: 16 Percent 0: 44.83% Percent 1: 55.17% Decimal: 400708894 | Binary: 10111111000100101010100011110
Puzzle: 30 Zeros: 14 Ones: 16 Percent 0: 46.67% Percent 1: 53.33% Decimal: 1033162084 | Binary: 111101100101001100110101100100
Puzzle: 31 Zeros: 10 Ones: 21 Percent 0: 32.26% Percent 1: 67.74% Decimal: 2102388551 | Binary: 1111101010011111110011101000111
Puzzle: 32 Zeros: 17 Ones: 15 Percent 0: 53.12% Percent 1: 46.88% Decimal: 3093472814 | Binary: 10111000011000101010011000101110
Puzzle: 33 Zeros: 17 Ones: 16 Percent 0: 51.52% Percent 1: 48.48% Decimal: 7137437912 | Binary: 110101001011011001010100011011000
Puzzle: 34 Zeros: 18 Ones: 16 Percent 0: 52.94% Percent 1: 47.06% Decimal: 14133072157 | Binary: 1101001010011001011001000100011101
Puzzle: 35 Zeros: 20 Ones: 15 Percent 0: 57.14% Percent 1: 42.86% Decimal: 20112871792 | Binary: 10010101110110100100001000101110000
Puzzle: 36 Zeros: 19 Ones: 17 Percent 0: 52.78% Percent 1: 47.22% Decimal: 42387769980 | Binary: 100111011110100000100000101001111100
Puzzle: 37 Zeros: 15 Ones: 22 Percent 0: 40.54% Percent 1: 59.46% Decimal: 100251560595 | Binary: 1011101010111011101010110101010010011
Puzzle: 38 Zeros: 21 Ones: 17 Percent 0: 55.26% Percent 1: 44.74% Decimal: 146971536592 | Binary: 10001000111000001011111010110011010000
Puzzle: 39 Zeros: 19 Ones: 20 Percent 0: 48.72% Percent 1: 51.28% Decimal: 323724968937 | Binary: 100101101011111100000110000001111101001
Puzzle: 40 Zeros: 18 Ones: 22 Percent 0: 45.00% Percent 1: 55.00% Decimal: 1003651412950 | Binary: 1110100110101110010010010011001111010110
Puzzle: 41 Zeros: 20 Ones: 21 Percent 0: 48.78% Percent 1: 51.22% Decimal: 1458252205147 | Binary: 10101001110000110100110101100110001011011
Puzzle: 42 Zeros: 23 Ones: 19 Percent 0: 54.76% Percent 1: 45.24% Decimal: 2895374552463 | Binary: 101010001000100001110001011000110110001111
Puzzle: 43 Zeros: 19 Ones: 24 Percent 0: 44.19% Percent 1: 55.81% Decimal: 7409811047825 | Binary: 1101011110100111011001001111100010110010001
Puzzle: 44 Zeros: 22 Ones: 22 Percent 0: 50.00% Percent 1: 50.00% Decimal: 15404761757071 | Binary: 11100000001010110011010110100011010110001111
Puzzle: 45 Zeros: 26 Ones: 19 Percent 0: 57.78% Percent 1: 42.22% Decimal: 19996463086597 | Binary: 100100010111111001010000101000011110000000101
Puzzle: 46 Zeros: 27 Ones: 19 Percent 0: 58.70% Percent 1: 41.30% Decimal: 51408670348612 | Binary: 1011101100000110000011100010001101010101000100
Puzzle: 47 Zeros: 23 Ones: 24 Percent 0: 48.94% Percent 1: 51.06% Decimal: 119666659114170 | Binary: 11011001101011000010000101101010011110010111010
Puzzle: 48 Zeros: 17 Ones: 31 Percent 0: 35.42% Percent 1: 64.58% Decimal: 191206974700443 | Binary: 101011011110011011010111110011100011101110011011
Puzzle: 49 Zeros: 24 Ones: 25 Percent 0: 48.98% Percent 1: 51.02% Decimal: 409118905032525 | Binary: 1011101000001011101101011000000010101111101001101
Puzzle: 50 Zeros: 26 Ones: 24 Percent 0: 52.00% Percent 1: 48.00% Decimal: 611140496167764 | Binary: 10001010111101010000111100001011101001001101010100
Puzzle: 51 Zeros: 32 Ones: 19 Percent 0: 62.75% Percent 1: 37.25% Decimal: 2058769515153876 | Binary: 111010100000111000010100001101000000000100111010100
Puzzle: 52 Zeros: 22 Ones: 30 Percent 0: 42.31% Percent 1: 57.69% Decimal: 4216495639600700 | Binary: 1110111110101110000101100100110010111001111000111100
Puzzle: 53 Zeros: 29 Ones: 24 Percent 0: 54.72% Percent 1: 45.28% Decimal: 6763683971478124 | Binary: 11000000001111000100011100100011111100011001001101100
Puzzle: 54 Zeros: 22 Ones: 32 Percent 0: 40.74% Percent 1: 59.26% Decimal: 9974455244496707 | Binary: 100011011011111011011011010101101011010001111101000011
Puzzle: 55 Zeros: 24 Ones: 31 Percent 0: 43.64% Percent 1: 56.36% Decimal: 30045390491869460 | Binary: 1101010101111100001111110011011011001111110000100010100
Puzzle: 56 Zeros: 22 Ones: 34 Percent 0: 39.29% Percent 1: 60.71% Decimal: 44218742292676575 | Binary: 10011101000110001011011000111010110001001111111111011111
Puzzle: 57 Zeros: 28 Ones: 29 Percent 0: 49.12% Percent 1: 50.88% Decimal: 138245758910846492 | Binary: 111101011001001011100100100000111100101011101011000011100
Puzzle: 58 Zeros: 33 Ones: 25 Percent 0: 56.90% Percent 1: 43.10% Decimal: 199976667976342049 | Binary: 1011000110011101011011100001010010000110001001101000100001
Puzzle: 59 Zeros: 26 Ones: 33 Percent 0: 44.07% Percent 1: 55.93% Decimal: 525070384258266191 | Binary: 11101001001011011001011101110000111110010101011010001001111
Puzzle: 60 Zeros: 28 Ones: 32 Percent 0: 46.67% Percent 1: 53.33% Decimal: 1135041350219496382 | Binary: 111111000000011110100001100000100101001101100111101110111110
Puzzle: 61 Zeros: 32 Ones: 29 Percent 0: 52.46% Percent 1: 47.54% Decimal: 1425787542618654982 | Binary: 1001111001001011010100011011101000010111101100100100100000110
Puzzle: 62 Zeros: 28 Ones: 34 Percent 0: 45.16% Percent 1: 54.84% Decimal: 3908372542507822062 | Binary: 11011000111101010101000001111010110110000100011010101111101110
Puzzle: 63 Zeros: 27 Ones: 36 Percent 0: 42.86% Percent 1: 57.14% Decimal: 8993229949524469768 | Binary: 111110011001110010111101111110110101100110011110110100000001000
Puzzle: 64 Zeros: 34 Ones: 30 Percent 0: 53.12% Percent 1: 46.88% Decimal: 17799667357578236628 | Binary: 1111011100000101000111110010011110110000100100010001001011010100
Puzzle: 65 Zeros: 36 Ones: 29 Percent 0: 55.38% Percent 1: 44.62% Decimal: 30568377312064202855 | Binary: 11010100000111000101100010011010100000101101100100110100001100111
The most challenging task in the world is to guess a random number
your calculations are taking into account all possible combinations of puzzle 66
Yes, i know that you are skipping some patters etc, lets to say that with that we can remove 66% of the whole keys, that reduce the 9.94% to some 3% and that is only for those keys with 33 bits in one "1" i am not considering all other combinations that you suggets like 32 bits in "1", 34 bits in "1" etc...
i mean just proof matematiically that you only need to test only 0.000085477 % of keys and i am going to belive you...
Numbers speak by itselfs
I sent an inbox, we can talk about it and I can show you why I exclude so many keys, The BSGS algorithm seems interesting to me, the speed is incredible
your calculations are taking into account all possible combinations of puzzle 66
Yes, i know that you are skipping some patters etc, lets to say that with that we can remove 66% of the whole keys, that reduce the 9.94% to some 3% and that is only for those keys with 33 bits in one "1" i am not considering all other combinations that you suggets like 32 bits in "1", 34 bits in "1" etc...
i mean just proof matematiically that you only need to test only 0.000085477 % of keys and i am going to belive you...
Numbers speak by itselfs
Jump to: