For WA12 try this:
9126492316491641269352615215701236589213658621356281376589216562319562396592381659862195621281E-190
100
#

Output must be:
0.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000009126

What is test #2?

The test case contains some unexpected symbols, I don't sure which one, but if you're trying read line by yourself, you're quite likely to get Output limit exceeded.

Just try below code to read from stdin

BufferedReader bis = new BufferedReader(new InputStreamReader(System.in));
String line = bis.readLine();

try
12.12.12
1
Not a floating point number

Test #10 contains some non utf-8 characters.
That could be the reason of panic if you use Go or Rust languages.

Take care of new line endings and make sure that the
second line is always read properly.
In my case the problem was that the second line was skipped because of wrong transition
in my FSM so the wrong line was read into N, so it printed more characters after the point than it should.

Hints for Java'ers who also hates problems like this and doesn't want to write automation-based solution.

new BigDecimal(line1) - it's almost cool, but you need some fixes before use constructor
1. Check for empty fraction case, e.g. "1.", "1.e2", "1.E2" - these are NANs according P1074 grammar, but OK according BigDecimal grammar (this is the only difference in grammars).
2. Fix big exponent to something smaller, for BigDecimal to be able to parse it
e.g. e1000000000000 => e1000
     e-1000000000000 => e-1000

Edited by author 09.02.2013 06:24

<input (replace 'S' with spaces!):>
S
1

34

10

-
1
-.
1
-.e0
1
-.1e
1
#123
1
--123
1
-1.e6
1
S4
4
12345678e-100000000000000000000000000000
10
0.0e10000000000000000000000
1
#



<output:>
Not a floating point number
34.0000000000
Not a floating point number
Not a floating point number
Not a floating point number
Not a floating point number
Not a floating point number
Not a floating point number
Not a floating point number
Not a floating point number
0.0000000000
0.0

Give me test#5? please!!! I tried all test from forum

On my PC it runs perfectly correct, the output is exactly the same(i have checked it using equals method so a mistake is impossible) but i get WA1 somehow. If somebody has an idea, please write it here.
BTW I know that the first test is the sample test because a simple program that prints sample output gets WA2.

PS here is my code if someone's interested: https://pastebin.com/SYiQTbMt

Edited by author 04.09.2017 23:49

Edited by author 04.09.2017 23:49

I have WA 7 and I don't understand what the problem is.
My tests:
// check(<input string #1>, <input string #2> as integer, <output string>)

      // tests from acm.timus
      check("10.23", 0, "10")
      check(".04", 1, "0.0")
      check("-0.051e0", 1, "0.0")
      check("1.1e30", 10, "1100000000000000000000000000000.0000000000")
      check("-1.1e-30", 1, "0.0")
      check("2468097632.1358642324268913e-2", 20, "24680976.32135864232426891300")
      check("e23", 3, "Not a floating point number")
      check("1 e3", 1, "Not a floating point number")

      // my tests
      check(" 1 e3", 1, "Not a floating point number")
      check("1e3", 1, "1000.0")
      // http://acm.timus.ru/forum/thread.aspx?id=26503&upd=634425663233423296
      // Posted by Igor Dex 1 Jun 2011 18:28
      // It is clear that we can't have leading spaces in case correct real number. But is it possible to have spaces after correct number till the end of the string?
      // Posted by AterLux 1 Jun 2011 23:05
      // No. Trailing as leading spaces not satisfy the syntactical description.
      check("   ", 1, "Not a floating point number")
      check(" ", 1, "Not a floating point number")
      check("-", 1, "Not a floating point number")
      check(" 1e3", 1, "Not a floating point number")
      check(" .1e3", 1, "Not a floating point number")
      check(".1e-3", 1, "0.0")
      check(" .1e-3 ", 1, "Not a floating point number")
      check(".1e-3 ", 1, "Not a floating point number")
      check(".0e-10000000000000000000", 1, "0.0")
      check(".0e+10000000000000000000", 1, "0.0")

      // int and uint tests
      check("10", 0, "10")
      check("10", 1, "10.0")
      check("-10", 1, "-10.0")
      check("+10", 1, "10.0")
      // simplefloat and usimplefloat tests
      check(".10", 1, "0.1")
      check("10.10", 1, "10.1")
      check("10.01", 1, "10.0")
      check("+.10", 1, "0.1")
      check("+10.10", 1, "10.1")
      check("+10.01", 1, "10.0")
      check("-.10", 1, "-0.1")
      check("-10.10", 1, "-10.1")
      check("-10.01", 1, "-10.0")
      // float tests
      check("10e0", 0, "10")
      check("10e-1", 1, "1.0")
      check("-10e+1", 1, "-100.0")
      check("+10e+3", 1, "10000.0")
      check(".10e-3", 1, "0.0")
      check("10.10e-1", 1, "1.0")
      check("10.01e-2", 1, "0.1")
      check("+.10e-10000", 1, "0.0")
      check("+10.10e-100", 1, "0.0")
      check("+10.01e1", 1, "100.1")
      check("-.10e1", 1, "-1.0")
      check("-10.10e-1", 1, "-1.0")
      check("-10.01e-2", 1, "-0.1")
      // "Not a floating point number" tests

      // But see http://acm.timus.ru/forum/thread.aspx?id=10235&upd=632909844439020000
      // Posted by Kopeliovitch Sergey (1) 30 Jul 2004 21:29
      // Segey say his progamm have AC with other answers, but right answers are
//Update: Now Segey have WA #1 and WA #12 and didn't have AC.
      check("10.", 1, "Not a floating point number")
      check("10.0e", 1, "Not a floating point number")
      check("10.e", 1, "Not a floating point number")

      //
      check("1E1 1", 1, "Not a floating point number")
      check("-+3", 1, "Not a floating point number")
      check("+", 1, "Not a floating point number")
      check("-", 1, "Not a floating point number")
      check(" ", 1, "Not a floating point number")
      check("-10.01ee", 1, "Not a floating point number")
      check("12.e10", 1, "Not a floating point number")
      check("-.e10", 1, "Not a floating point number")
      check("1e", 1, "Not a floating point number")
      check("e1", 1, "Not a floating point number")
      check("e", 1, "Not a floating point number")
      check("se-1", 1, "Not a floating point number")
      check("+e", 1, "Not a floating point number")
      check("-e1", 1, "Not a floating point number")
      check(".e4", 1, "Not a floating point number")
      check("0.", 1, "Not a floating point number")
      check("1e", 1, "Not a floating point number")
      check("0x123", 1, "Not a floating point number")
      check("1E2.1", 1, "Not a floating point number")
      check("-1E2.1", 1, "Not a floating point number")
      check("1E2.1e2", 1, "Not a floating point number")
      check("1e00-1", 0, "Not a floating point number")
      // # tests
      check("1#", 1, "Not a floating point number")
      check("#1", 1, "Not a floating point number")
      check("# 1", 1, "Not a floating point number")
      check("1 #", 1, "Not a floating point number")
      // big power test
      check("1e10", 1, "10000000000.0")
      check("1e10", 0, "10000000000")
      check("-1e10", 0, "-10000000000")
      check("1e-10", 0, "0")
      check("0e+10", 0, "0")
      check("0e+100", 0, "0")
      check("0e+10000000000000000000", 0, "0")
      check("0e-10000000000000000000", 0, "0")
      check("0e10000000000000000000", 0, "0")
      check("1e000000000000000000000000000000000000000000000000000000000000000000000000000000", 0, "1")
      check("1e000000000000000000000000000000000000000000000000000000000000000000000000000001", 0, "10")
      check("1e-000000000000000000000000000000000000000000000000000000000000000000000000000001", 0, "0")
      check("234565432452433e-10000000000000000000", 0, "0")
      check("-234565432452433e-10000000000000000000", 0, "0")

      // An integral part of a number should be non-empty.
      check(".1e+0", 1, "0.1")
      check("-.1e+0", 1, "-0.1")
      // There shouldn't be leading zeroes in a non-zero integral part of a number.
      // A zero integral part of a number should consist of an only zero.
      check("00000.1e+0", 1, "0.1")
      check("-00000.1e+0", 1, "-0.1")
      check("00001.1e+0", 1, "1.1")
      check("-00001.1e+0", 1, "-1.1")
      check("00001.1", 1, "1.1")
      check("-00001.1", 1, "-1.1")
      check("00001.1", 0, "1")
      check("-00001.1", 0, "-1")
      // A fractional part of a number should contain exactly N symbols.
      check("00001.1", 0, "1")
      check("00001.1", 3, "1.100")
      check("-00001.1", 1, "-1.1")
      // There shouldn't be a sign "+" before a positive number.
      check("+00001.1", 0, "1")
      check("+1.1", 0, "1")
      check("+1.1", 3, "1.100")
      check("+1.1e+1", 1, "11.0")
      // You shouldn't round off a number.
      check("+1.5e+1", 1, "15.0")
      check("+1.06", 1, "1.0")
      check("+1.6e-1", 1, "0.1")

Edited by author 29.03.2017 22:42

Edited by author 29.03.2017 22:47

Edited by author 30.03.2017 00:56

in  more languages  "3."  or "0.E+6"  numbers are legal.
but for there are not, i.e.
input:
3.
1
0.E6
3
#
output:
Not a floating point number
Not a floating point number

Edited by author 02.01.2017 21:42

my program calculate:

Input:
======================================
String str = "10.23\n" +
               "0\n" +

               ".04\n" +
               "1\n" +

               "-0.051e0\n" +
               "1\n" +

               "1.1e30\n" +
               "10\n" +

               "-1.1E-30\n" +
               "1\n" +

               "2468097632.1358642324268913e-2\n" +
               "20\n" +

               "e23\n" +
               "3\n" +

               "1 e3\n" +
               "1\n" +

               "-7293874219874982174982174987321e-18446744073709551616\n" +
               "10\n" +

               "#1234\n" +
               "3\n" +

               " 12.0\n" +
               "3\n" +

               "2E-1\n" +
               "3\n" +

               "-\n" +
               "2\n" +

               ".e1\n" +
               "2\n" +

               "#";
======================================

Output:
======================================
10
0.0
0.0
1100000000000000000000000000000.0000000000
0.0
24680976.32135864232426891300
Not a floating point number
Not a floating point number
0.0000000000
Not a floating point number
Not a floating point number
0.200
Not a floating point number
Not a floating point number
======================================

It's correct.

why wrong test-12?

Hey guys any hints here? All examples from forum works on my program but this one
exceeds. I guess it's because more than 200 characters are written, but I cannot find any test case that will require less written characters but the output will have more length

Can anyone give me a test? I have WA#2 and my solution passes all the tests from discussions.

At least tell me if i read correctly:

int n;
string num;
while (getline(cin, num))
{
    if (num.length() == 1 && num[0] == '#') break;
    (cin >> n).ignore();
}

Edited by author 08.09.2016 13:00

Please check the 12-th test. I and others thinks that our solutions are correct, but they are WA on 12...

Maybe anyone can give a little hint?

Edited by author 03.08.2006 16:49

I got AC when add:

if (Regex.Match(val, "[\\+\\-]?([0-9]*\\.)?[0-9]+([eE]?[\\+\\-]?[0-9]+)?", RegexOptions.Singleline).Value != val)
{
Console.WriteLine("Not a floating point number");
}

Got AC

if you WA #9
try this

0.00000000000e10
5
0.00000000001e10
5

import re
fl = re.compile('[+-]?[1234567890]*\.[1234567890]*([Ee][+-]?[1234567890]+)?')
lf = re.compile('[+-]?[1234567890]+([Ee][+-]?[1234567890]+)?')
nums = []
while True:
    first = input()
    if first == '#':
        break
    nums.append((first, int(input())))
for num in nums:
    num0 = num[0]
    if not (re.fullmatch(fl, num0) or re.fullmatch(lf, num0)):
        print('Not a floating point number')
        continue
    try:
        e_pos = num0.index('e')
        exp = int(num0[e_pos + 1:])
        num0 = num0[:e_pos]
    except:
        try:
            e_pos = num0.index('E')
            exp = int(num0[e_pos + 1:])
            num0 = num0[:e_pos]
        except:
            exp = 0
    pm = num0[0]
    if pm in ['+', '-']:
        num0 = num0[1:]
    else:
        pm = '+'
    if pm == '+':
        pm = ''
    if exp > 0:
        num0 += '0' * exp
    elif exp < 0:
        num0 = '0' * (-exp) + num0
    try:
        dot_pos = num0.index('.')
    except:
        dot_pos = len(num)
        num0 += '.'
    new_dot_pos = dot_pos + exp
    num0 = num0[:dot_pos] + num0[dot_pos + 1:]
    num0 = num0[:new_dot_pos] + '.' + num0[new_dot_pos:]
    while num0.startswith('0'):
        num0 = num0[1:]
    if num0.startswith('.'):
        num0 = '0' + num0
    num0 += '0' * num[1]
    num0 = num0[:num0.index('.') + num[1] + 1]
    if num0.endswith('.'):
        num0 = num0[:-1]
    print(num0)

bool checkstrtod(char s[])
{
    char *end;
    strtod(s,&end);
    return int(end-s)==strlen(s);
}

http://www.cplusplus.com/reference/cstdlib/strtod/