I know that there's at least one DS Castlevania run published with a Lua encode...Language: Luafunction popcount(x) local counter = 0 while x>0 do x = x - AND(x,-x) counter = counter + 1 end return counter end function showCaught() local startAddress = 0xD2F7 local caught = 0 for i=0,18 do caught = caught + popcount(memory.readbyte(startAddress+i)) end gui.text(140,130,caught) end gui.register(showCaught)
The last problem reminded me of one that I dreamed up a while ago. 1) Find a difference equation for q such that the sum sum( f(qi, qi-qi-1, i) ) is minimized for an arbitrary function f. In the sum, i ranges from 1 to N and you may assume that q0 and qN are both given so that the problem is well-posed. (Hint: Take your partial derivatives carefully!) 2) Introduce a symbol (if you haven't already done so) that will make your solution to (1) instantly familiar to any physicist or mathematician with a background in calculus of variations. 3) Apply your solution to the function f=2qi - (qi-qi-1)^2 subject to the boundary conditions q0=0, qN=0, and N=11. What physical problem is this analogous to?
mark all vertices as not visited
enqueue root
mark root as visited
while queue not empty do
dequeue the vertex v
for each (v,w) in the graph do
if w is not visited then
enqueue w
mark w as visited
end
end
end
Honestly, I'm not very sure about what this does, but it doesn't look like a BFS. Also, any optimization problem can be turned into a collection of decision ones multiplying the complexity by O(log d), where d is the max amount of turns it takes to finish. You can turn your problem into "can I finish the game using d steps?" and binary search on d. This is just meant to give you some thoughts about botting it if you intend to do this again, I give no guarantee that backtracking can be used to help. It's just something to think about.Language: Luamap[0][initial]={{}} map[1][final]={{}} local depth=0 while not(incommon(map[0],map[1])) do for i=0,47 do if map[depth%2][i] and #map[depth%2][i][1]==math.floor(depth/2) then for j=0,3 do local destination=graph[i][j] map[depth%2][destination]={} local temp=table.copy2(map[depth%2][i]) for k=1,#temp do table.insert(temp[k],#temp[k]*(1-depth%2)+1, destination*(1-depth%2)+i*(depth%2)) map[depth%2][destination][#map[depth%2][destination]+1]=table.copy(temp[k]) temp=table.copy2(map[depth%2][i]) end end end end depth=depth+1 end
Yes, it is a very rudimentary form of dynamic programming (I don't consider myself a programmer and I never pass up an opportunity to emphasize that). As such, it's virtually certain that this run is not perfect. If I could execute my program to a search depth of 80 (not possible!), it would theoretically be perfect. This run was made by setting the depth to 1 and the breadth to 2, but if this is somehow accepted, I would like to improve it by increasing the depth to 3 and the breadth to 4 or so. To produce this run, I left my computer on overnight and even then it was only able to complete relatively small chunks (roughly 30 levels) at a time and it became very hot. I can improve it (maybe by 10 minutes or so), but it will require doing just three levels at a time and working on it for about a month before stitching all the movies together.
Suggestion: Use a change of variables that rotates the axes by an angle of 45º
However, to use a change of variables, we need to know x and y in terms of u and v. Fortunately, any rotation matrix is orthonormal and its inverse is simply its transpose:
In order to do the variable change, we need to evaluate the absolute value of the determinant of the Jacobian matrix and multiply it by integrand:
The function to be integrated, in this new coordinate system becomes:
Now, for the hardest part when working with multiple integrals, finding its bounds. For this, we use a geometric argument. In the xy-system, the domain of integration is the square [0,1] x [0,1]. In the uv-system, it's still a square, but it's rotated so that the u-axis cuts its diagonal, having positive orientation from u=0 to u=sqrt(2) (the length of the diagonal). Using analytic geometry, we can see that the square's sides are determined by the lines of equations:
v = u
v = -u
v = sqrt(2) - u
v = -sqrt(2) + u
Now, the order of integration, we need to specify it so that we can apply Fubini's theorem and iterate the integral. Integrating on u first allows us to express the entire region in one integral, but the integrand won't have an elementary primitive, so we're screwed. Then, let's try integrating on v first.
For this, we separate the rotated square into two regions, one from 0<u<sqrt(2)/2 and the other from sqrt(2)/2<u<sqrt(2). In the first one, keeping u fixed, we see that the smallest v is on the line v = -u and the largest on v=u. For the second one, still keeping u fixed, the smallest v = -sqrt(2) + u and the largest v = sqrt(2) - u. Thus, we sum the integrals on those two regions to obtain:
Anyone up for it now?
I could solve the die-case by independently examining 6 different random variables: Xi = 1 when the die says i, 0 otherwise. Would my confidence interval for throwing a 1 be any different if 12 dice throws are either each side twice, or one twice and six ten times? My guess for P(X=1) is 1/6 in both cases, but would a high amount of sixes make me any more or less confident about that guess? I don't think so, but as always I may be wrong.
Quote: Now I do this again, 100 times, getting 10 heads. x_m still 0.1 sigma_m = sqrt( ( 90*0.1^2 + 10*0.9^2) / 100*101) = 0.02985 I'm getting 77.6% instead of 68.27, though with summands like (90 choose 45)/56 * x^56 rounding errors are bound to be problematic. I'll try again tomorrow with a proper math library. Any hope of having this as a neat formula in OOCalc went out the window, anyway. :/
Does it even make sense to model a probability as gauss/normal distributed, ignoring the known boundaries of [0, 1]?
Here's a virtual experiment using an RNG to simulate 100 coin tosses and to evaluate the 90% certainty with five samples. Since five is a small quantity, I used the value in a table for finite amounts of testing, which I have in hands now. I can pass it to you if you want, but with a computer you can do a large amount of tests so that the value for infinite measures is good enough. In practice, to obtain better approximation, it's usually better to increase the size of the sample than to increase the amount of observations.Language: C++#include <stdio> #include <math> #include <stdlib> #include <time> int v[100]; double x[5]; int main(){ double fav,mean,sigmaM; srand(time(NULL)); for (int i=0; i<5; i++){ for (int j=0; j<100; j++) v[j]=rand()%2; fav=0; for (int j=0; j<100; j++){ if (v[j]==0) fav+=(1.0/100); } x[i]=fav; } mean=0; for (int i=0; i<5; i++) mean+=x[i]; mean/=5; sigmaM=0; for (int i=0; i<5; i++) sigmaM+=pow(x[i]-mean,2); sigmaM/=(5*4); sigmaM=sqrt(sigmaM); printf("%lf +- %lf\n",mean,2.13*sigmaM); getchar(); return 0; }
p4wn3r wrote: RingRush wrote: 1. Get a level 0 bad clone (involves the classic cloning glitch, resetting at the exact right time...there is more on this on plenty of sites). Do you have a vbm getting this bad clone? I tried many times, but couldn't get a lvl0 bad clone on VBA-rr no matter which frame I reset. In Pokémon Crystal, it is around (well popularly believed to be) after the word 'POWER.' is written (after the full stop), did you try resetting around there? http://www.youtube.com/watch?v=BIz1RAg25yM