9.1

Cris Koch  [:)] 
("\''/").___..--''"`-._
   `9_ 9  )   `-.  (     ).`-.__.`)
   (_Y_.)'  ._   )  `._ `. ``-..-'
 _..`--'_..-_/  /--'_.' .'
(il).-''  ((i).'  ((!.-'


Tim Peeters, David Molnar, Joe B, Bryan J Cannon, Stan Ponca,
Juha Saukkola, Michael J D Dufour, Al Zimmermann, J.B. Gill,
Sean R. Sandquist, Derek Bosch, Bret Bryan, John, John Gowland,
Gerami F. Havewala, Andy Juell, Al Stanger, Kirk Bresniker,
Stephen Kloder, Desmond Tynan, Mario Klingemann


Matthew Prins
The 1.9 times the fourth root of 9.1 equals approximately
3.30000007.  Thus, the answer is 9.1.


Alex Fink
The small decimal sought, found by brute force alone, is 9.1.
(9.1)^(1/4) * 1.9, evaluated to 20 decimal places, is
3.3000000695661830689.  Also somewhat close to a round number is
(5.6)^(1/4) * 6.5, which is 9.999087376.

Don Woods
Obviously, it's not hard to solve your "small decimals" challenge by
exhaustive search.  But as it happens, the first thought I had was to
consider 9.x, and clearly the best choice for x would be 1, so I put
9.1 into my calculator program and came out with 3.29999.  So then I
set the calculator to maintain 20 digits of precision, and found it
was actually 3.300000069...  Wow!

Roger Phillips:
Found using this Unix bc program:
scale=20
for (a = 0; a <= 9; ++a) for (b = 0; b <= 9; ++b) {
  z = (b + a / 10) * sqrt(sqrt(a + b / 10))
  if (z - 3.3 < 0.1) if (z - 3.3 > -0.1) { a + b / 10; z }
}
of which the output is:
9.10000000000000000000
3.30000006956618306890

Anjanesh Lekshminarayanan
I was unable to solve this mathematicaly but it was
defintely easy to find out the answer using a basic
program.
 9.1           1.9           3.3
sqrt(9.1) = 3.0166206257996712172516764424594
sqrt(3.0166206257996712172516764424594) =
1.7368421418769384573225458676063
1.7368421418769384573225458676063 x 1.9 =
3.300000069566183068912837148452

From : Sudipta Das
The other such small decimal is 9.1
sqrt(sqrt(9.1)) *1.9 = 3.300000695
and is nearer to 3.3 than sqrt(sqrt(1.3)) * 3.1

Mark Michell
It's not too hard to find the answer 9.1
I always wonder with this sort of apparent coincidence. It could be
* just one of those 1 in a million (for that is about how close it is) 
chances. Even to say that is a potentially deep statement.
* we have somehow tapped into a space which has at least a million members, 
and so finding one example this close is quite reasonable. After all, in 
this space, we would expect about one example of such an event. If, for 
example there were 10000 functions we could apply to each of these 100 (or 
so) simple fractions, then one of the million answers will be very close to 
something. How many such functions are there?
* there is a deeper reason for it. Right now, I'm stumped on that one. 
Ramanujan would have had something to say about it, I'm sure.

Hello
I must say, it took me some guessing and checking before I started to
realize a sort of a pattern.  So I do admit, I used some guessing and
checking in the beginning, but only to test the pattern.  This is what I
picked up:
I noticed that by manipulating the first digit, every time it was increased,
the result for the first step (finding the fourth root) increased, at the
same time the result of the reverse also increased.  So the key here was to
find a balance and be able to come up with a result close each other.  The
best way I saw to do this, since I was trying to keep the second multiplier
(the result from the reverse) low, was to keep the second digit as a 1.  At
this time I determined, that having a 9 as the first digit before the . gave
me what I was looking for.
So to make it short and simple, I wish to submit an answer of 9.1, which
inputed into the equation, it returns a result of 3.30000007
I hope my approach and thinking to this problem was correct... hopefully it
is  [:)] only time will tell...
Sincerely,
JLRamirez
San Antonio, TX 11th Grade High School Student

i believe the answer is 9.1, which evaluates to 3.30000007. 
fwiw, here's the code that did all the work:
#include <math.h>
int main(int argc, char* argv[])
{
   double target, bestResult, bestX, error, bestError, result, whole, frac, x;
   target = 3.3;
   bestError = 10; // or some other large number
   for (x = 0; x < 10; x += 0.1)
   {
      frac = modf(x, &whole);
      result = pow(x, 0.25) * (frac * 10 + whole * 0.1);
      error = fabs(result - target);
      if (error < bestError)
      {
         bestX = x;
         bestResult = result;
         bestError = error;
      }
   }
   printf("x = %f evaluates to %f\n", bestX, bestResult);
   return 0;
}
mike kurtinitis