23741011 241957 125 4.262390641893804677
23741094 241958 83 4.2623906840148624298
23741153 241959 59 4.2623907261358162657
23741480 241960 327 4.2623907682561892329
23741530 241961 50 4.2623908103764733823
23741690 241962 160 4.2623908524964742028
23741798 241963 108 4.2623908946162831768
23741883 241964 85 4.2623909367359411604
23741980 241965 97 4.2623909788554277256
23742158 241966 178 4.2623910209745980993#include <iostream>
#include <iomanip>
int main() {
int series[1000000]; //we can change this later if we need more computingness.
series[0] = 1;
int series_length = 1;
int length_arith_prog = 3;
double sum = 1.0;
int n = 2;
std::cout << std::setprecision(20);
for (;;n++) {
int found = 0;
for (int i=0; i < series_length && found == 0; i++) {
int members_arith_prog = 0;
int debug = (n - series[i])%length_arith_prog;
if (!((n - series[i])%length_arith_prog)) { //if between these two numbers it is possible to have an arithmetic progression of the specified length
int common_diff = (n - series[i])/length_arith_prog;
for (int j=1; j < length_arith_prog; j++) {
/* for (int k=i+1; k < series_length; k++) { //we only want to test numbers larger than the one we're currently examining.
if (series[k] == series[i] + j*common_diff) {
members_arith_prog++;
}
}*/
int mid=((i+1)+(series_length-1))/2; //the +1 and -1 cancel, they're just there to remind me.
int high = series_length;
int low = i+1;
int value = series[i] + j*common_diff;
while (low < high) {
mid = low + ((high - low) / 2); // Note: not (low + high) / 2 !!
if (series[mid] < value) {
low = mid + 1;
} else {
high = mid;
}
}
if ((low < series_length) && (series[low] == value)) {
members_arith_prog++;
}
}
}
if (members_arith_prog+1 == length_arith_prog) { //found a arithmetic progression!
found = 1;
}
}
if (found == 0) {
series[series_length] = n;
int deriv = series[series_length] - series[series_length-1];
series_length++;
sum += (1.0/n);
std::cout << n << " " << series_length << " " << std::setw(5) << deriv << " " << sum << std::endl;
}
}
}
tasg(n,m)
Func
Local s
Local i
Local j
Local k
{1,2,...,n}->s
For i, n+1, m
For j, 1, i/n
For k, 1, n
If product(i-k*j-s) =/= 0
goto Y
EndFor
Goto N
Lbl Y
EndFor
{s,i}->s
Lbl N
EndFor
s
EndFunc
This is what I have thus far plotted against the harmonic series. From the bottom up are all of the well behaved progression values (chaotic ones sum up to less than expected, and therefore the algorithm used to generate them is flawed.)
We are probably dealing with the difference between divergent and convergent series, so it's unsurprising how slowly everything seems to converge. I kinda want to try, just for kicks, a very large progression value and plot it against the harmonic series, when I'm done with these current jobs.
From bottom, 2, 4, 6, 10, 12, 16, 18, harmonic
I'm currently running these until they reach 1 million terms.
Here's some numerical results.
==> results-k2.txt <==
48626849 90110 1 3.0047502371298553392
48626851 90111 2 3.0047502576946252262
48626852 90112 1 3.0047502782593946691
==> results-k4.txt <==
3417967 524286 1 6.9855757435193490679
3417968 524287 1 6.9855760360908414341
3417969 524288 1 6.9855763286622485353
==> results-k6.txt <==
2323521 834442 1 9.4759921775889957019
2323522 834443 1 9.4759926079701148893
2323523 834444 1 9.4759930383510493357
==> results-k10.txt <==
1395678 873659 1 11.675478284103704141
1395679 873660 1 11.675479000600835988
1395681 873661 2 11.675479717096941101
==> results-k12.txt <==
461429 314551 1 11.501411429098064687
461430 314552 1 11.501413596274018047
461431 314553 1 11.50141576344527472
==> results-k16.txt <==
404982 321368 1 12.059011402079701014
404983 321369 1 12.059013871319150368
404984 321370 1 12.059016340552503266
==> results-k18.txt <==
391782 315668 1 12.218301410935204387
391783 315669 1 12.218303963368565945
391784 315670 1 12.218306515795413603I'd try running your code, but I'm not sure what language it's in, nor what I'd need to run it.
I have the need for this algorithm in practice. Suppose you have the rotation notation <angle1>. That means: "First rotate around the X axis by angle1 degrees, then around the Y axis by angle2 degrees, and finally around the Z axis by angle3 degrees." Also assume that you can apply any amount of such rotations in succession. For example, you could first apply the rotation <0>, then <15> and then <5>. It is, in fact, possible to create from any amount of such successive rotations one single <angle1> triplet which produces the exact same transformation as all those successive rotations. In other words, any amount of successive rotation triplets can be collapsed into one. However, I don't know how this is done.
Half the time it will last 1 round. So would that not be the expected number of rounds?
n avg
100 15
1000 50
10000 150
100000 515
1000000 1270
10000000 5016
#!/usr/bin/python
import random
totalRolls = 0
for i in xrange(0, 1000):
if i % 10 == 0:
print i
aCount = 0
bCount = 0
numRolls = 0
curBase = 1
while numRolls == 0 or bCount < curBase:
if random.random() > .5:
aCount += 1
if aCount == curBase:
curBase += 2
else:
bCount += 1
numRolls += 1
totalRolls += numRolls
print totalRolls / 1000.0
import random
Total = 0
Highest = 0
for i in range(1,10000):
Heads = 0
Tails = 0
Rounds = 0
while Heads <= Tails and Rounds<100000000:
Rounds += 1
if random.randint(0,1) == 1:
Heads += 1
else:
Tails += 1
Total += Rounds
if Rounds > Highest:
Highest = Rounds
print i
print Rounds
print Total/i
print Total/10000.0
print Highest
.5+2(.5)^2+3(.5)^3+4(.5)^4+...=SUM(1,INF,x(.5)^x) I had to find a formula for summing this (arithmetic geometric series): For an infinte series a + (a+d)r + (a+2d)r^2 + (a+3d)r^3... S=a/(1-r)+dr/(1-r)^2 a=0 d=1 r=.5 So S=2
