(why waste time coding an algorithm (or cpu time executing it) to calculate a value that is already known?)

I would avoid the standard floating-point based algorithms because they might yield a result whose uncertainty happened to straddle a x.xx5 boundary, which I’d need to correct and/or check for explicitly, complicating things beyond what a quick test of basic programming ability ought to require.

If a linear search were deemed too inefficient, I’d probably escalate to integer bisection to find the right N in N*0.01-0.005.

(No, actually my FIRST first instinct would be
10 PRINT “2.16″
given that the program takes no input anyway and I already know the correct output).

Another difference is ‘learnt’ vs ‘understanding’, I remember for one of my Engineering Degree examinations, I had a brain freeze and forgot all the important equations (Mathematical Modelling and Analysis of Mechanical Systems). Lucky for me I understood the topic enough to derive the equations from first principles.

Further, to add being a ‘Girl’ is logically irrelevant!

PS apologies about my grammar, English is only my third language. I only learnt to read/write English in two weeks.

Sure I learnt about LASER theory and built radio’s when I was only seven BUT I thats only because I had learnt to do that.

So the real question is not what you how to solve, its how you solve what you don’t know.

When I was a freshman engineer at Cornell, our CS100 course required solving a problem just like this for homework.

What do you call someone who can write a program to solve for the roots of some basic equations?

(a) “Senior Developer
(b) Freshman Engineer.

SHEESH. I’m a GIRL and I could do that when I was frickin’ SEVENTEEN.

here is the RootFinder Class:

public class RootFinder
{
private double _x0 = 100;

public void CalculateRoot(double Px)
{
if (Math.Round(EvaluateSolution(Px), 4) == 0) {
Console.WriteLine(string.Format(“Solution :{0}”, Px));
return;
}

object _x0 = Px – ((Px * Math.Log(Px) – Math.Pow(Px, 2) + 3) / (Math.Log(Px) – 2 * Px + 1));
Console.WriteLine(string.Format(“Xn+1 :{0}”, _x0));

CalculateRoot(_x0);
}

private double EvaluateSolution(double Px)
{
//To do: Use Maths Parser to pass evalution function as a parameter
return (Px * Math.Log(Px)) – (Px * Px) + 3;
}
}

and inside a console:

class SolverOutput
{

void Main()
{
string tmpStr;
RootFinder fx = new RootFinder();

Console.WriteLine(“Please enter an intial guess”);
tmpStr = Console.ReadLine;

if (IsNumeric(tmpStr.ToString)) {
fx.CalculateRoot(Convert.ToDouble(tmpStr));
}

Console.ReadLine();
}
}

test it out, only takes around a few iterations to solve.

@main.cpp contents:

#include
#include

using namespace std;

/**
* Takes a double and returns and int that has been rounded to the given precision
* eg. 115.165, 2 returns 11517
*
* @return int
*/
int round( double number, int precision ){

double returned = pow( 10.0, precision );
returned *= number;

if( (returned + 0.5) >= (int(returned) + 1) ){
return int(returned + 1.0);
}else{
return int(returned);
}

}

int main(){

double x;
double y;
const double precision = 2;
const double step = pow( 10.0, precision * -1 );

for( x = 0.0; x < 1000; x += step ){

y = x * log(x) – x*x + 3;

if( round(y, precision) == 0 ){
cout << x << " " << y << " Solved" << endl;
}

}

return 1;

}

Compile in shell with g++:

$ g++ -Wall -O3 -o Solver main.cpp
$ time ./Solver
2.16 -0.00216624 Solved

real 0m0.012s
user 0m0.010s
sys 0m0.000s

Criticisms and improvements are very welcomed. Anyone know of a good place for more little problems like this? Had been eying http://www.springer.com/computer/theoretical+computer+science/foundations+of+computations/book/978-0-387-30770-1 for some time, but haven't gotten around to buying it yet.

Nice article, btw :-).

That did the trick, the Newton–Raphson method solved it really fast. e.g when I put an initial guess of 6, it converges in 4 iterations. Naturally a better guess like 3 does it in 3 iterations.

Your right about having the derivative, thankfully apart from my Log vs Ln mistake my derivate (calculated on the back of mail envelope) was correct :)