数的识别

被封禁言

1. #include <iostream>
   
2. 
   
3. template<typename ftype>
   
4. ftype pow(ftype f, int n)
   
5. {
   
6.     if (n > 0)
   
7.     {
   
8.         if (n & 1)
   
9.             return pow(f * f, n >> 1) * f;
   
10.         else
    
11.             return pow(f * f, n >> 1);
    
12.     }
    
13.     else
    
14.     {
    
15.         if (n < 0)
    
16.             return pow(1.0f / f, -n);
    
17.         else
    
18.             return 1;
    
19.     }
    
20. }
    
21. 
    
22. template<typename ftype>
    
23. bool num(const char * str, ftype & d)
    
24. {
    
25.     enum state
    
26.     {
    
27.         s_init,
    
28.         s_fail,
    
29.         s_wait_dot,
    
30.         s_wait_num,
    
31.         s_wait_num2,
    
32.         s_wait_num3,
    
33.         s_wait_num4,
    
34.         s_wait_num5,
    
35.         s_wait_num6,
    
36.         s_wait_num7,
    
37.         s_wait_e,
    
38.         s_ready_n1,
    
39.         s_ready_n2,
    
40.         s_finish,
    
41.     };
    
42. 
    
43.     int n;
    
44.     ftype i, f;
    
45.     state s = s_init;
    
46.     char * x = const_cast<char *>(str);
    
47.     for (; *x && s != s_fail && s != s_finish; x++)
    
48.     {
    
49.         switch (s)
    
50.         {
    
51.         case s_init:
    
52.             {
    
53.                 if (*x != ' ')
    
54.                 {
    
55.                     if (*x >= '1' && *x <= '9')
    
56.                     {
    
57.                         f = *x - '0';
    
58.                         s = s_wait_num;
    
59.                     }
    
60.                     else
    
61.                     {
    
62.                         if (*x == '0')
    
63.                         {
    
64.                             s = s_wait_dot;
    
65.                         }
    
66.                         else
    
67.                         {
    
68.                             if (*x == '.')
    
69.                                 s = s_wait_num2;
    
70.                             else
    
71.                                 s = s_fail;
    
72.                         }
    
73.                     }
    
74.                 }
    
75.             }
    
76.             break;
    
77.         case s_wait_dot:
    
78.             {
    
79.                 if(*x == '.')
    
80.                 {
    
81.                     i = 1.0f;
    
82.                     s = s_wait_num2;
    
83.                 }
    
84.                 else
    
85.                 {
    
86.                     s = s_finish;
    
87.                 }
    
88.             }
    
89.             break;
    
90.         case s_wait_num:
    
91.             {
    
92.                 if (*x >= '0' && *x <= '9')
    
93.                 {
    
94.                     f = f * 10 + (*x - '0');
    
95.                     s = s_wait_num3;
    
96.                 }
    
97.                 else
    
98.                 {
    
99.                     if (*x == '.')
    
100.                     {
     
101.                         i = 1.0f;
     
102.                         s = s_wait_num4;
     
103.                     }
     
104.                     else
     
105.                     {
     
106.                         if (*x == 'e' || *x == 'E')
     
107.                         {
     
108.                             s = s_wait_num5;
     
109.                         }
     
110.                         else
     
111.                         {
     
112.                             s = s_finish;
     
113.                         }
     
114.                     }
     
115.                 }
     
116.             }
     
117.             break;
     
118.         case s_wait_num2:
     
119.             {
     
120.                 if (*x >= '0' && *x <= '9')
     
121.                 {
     
122.                     i = i / 10;
     
123.                     f = f + i * (*x - '0');
     
124.                     s = s_wait_e;
     
125.                 }
     
126.                 else
     
127.                 {
     
128.                     s = s_fail;
     
129.                 }
     
130.             }
     
131.             break;
     
132.         case s_wait_num3:
     
133.             {
     
134.                 if (*x >= '0' && *x <= '9')
     
135.                 {
     
136.                     f = f * 10 + (*x - '0');
     
137.                 }
     
138.                 else
     
139.                 {
     
140.                     if (*x == '.')
     
141.                     {
     
142.                         i = 1.0f;
     
143.                         s = s_wait_num2;
     
144.                     }
     
145.                     else
     
146.                     {
     
147.                         if (*x == 'e' || *x == 'E')
     
148.                         {
     
149.                             s = s_wait_num5;
     
150.                         }
     
151.                         else
     
152.                         {
     
153.                             s = s_finish;
     
154.                         }
     
155.                     }
     
156.                 }
     
157.             }
     
158.             break;
     
159.         case s_wait_num4:
     
160.             {
     
161.                 if (*x >= '0' && *x <= '9')
     
162.                 {
     
163.                     i = i / 10;
     
164.                     f = f + i * (*x - '0');
     
165.                     s = s_wait_e;
     
166.                 }
     
167.                 else
     
168.                 {
     
169.                     s = s_fail;
     
170.                 }
     
171.             }
     
172.             break;
     
173.         case s_wait_e:
     
174.             {
     
175.                 if (*x >= '0' && *x <= '9')
     
176.                 {
     
177.                     i = i / 10;
     
178.                     f = f + i * (*x - '0');
     
179.                 }
     
180.                 else
     
181.                 {
     
182.                     if (*x == 'e' || *x == 'E')
     
183.                     {
     
184.                         s = s_wait_num5;
     
185.                     }
     
186.                     else
     
187.                     {
     
188.                         s = s_finish;
     
189.                     }
     
190.                 }
     
191.             }
     
192.             break;
     
193.         case s_wait_num5:
     
194.             {
     
195.                 if (*x >= '1' && *x <= '9')
     
196.                 {
     
197.                     n = *x - '0';
     
198.                     s = s_ready_n1;
     
199.                 }
     
200.                 else
     
201.                 {
     
202.                     if (*x == '-')
     
203.                     {
     
204.                         s = s_wait_num6;
     
205.                     }
     
206.                     else if (*x == '+')
     
207.                     {
     
208.                         s = s_wait_num7;
     
209.                     }
     
210.                     else
     
211.                     {
     
212.                         s = s_fail;
     
213.                     }
     
214.                 }
     
215.             }
     
216.             break;
     
217.         case s_wait_num6:
     
218.             {
     
219.                 if (*x >= '1' && *x <= '9')
     
220.                 {
     
221.                     n = - (*x - '0');
     
222.                     s = s_ready_n2;
     
223.                 }
     
224.                 else
     
225.                 {
     
226.                     s = s_fail;
     
227.                 }
     
228.             }
     
229.             break;
     
230.         case s_wait_num7:
     
231.             {
     
232.                 if (*x >= '1' && *x <= '9')
     
233.                 {
     
234.                     n = *x - '0';
     
235.                     s = s_ready_n1;
     
236.                 }
     
237.                 else
     
238.                 {
     
239.                     s = s_fail;
     
240.                 }
     
241.             }
     
242.             break;
     
243.         case s_ready_n1:
     
244.             {
     
245.                 if (*x >= '0' && *x <= '9')
     
246.                 {
     
247.                     n = n * 10 + (*x - '0');
     
248.                 }
     
249.                 else
     
250.                 {
     
251.                     s = s_finish;
     
252.                 }
     
253.             }
     
254.             break;
     
255.         case s_ready_n2:
     
256.             {
     
257.                 if (*x >= '0' && *x <= '9')
     
258.                 {
     
259.                     n = n * 10 - (*x - '0');
     
260.                 }
     
261.                 else
     
262.                 {
     
263.                     s = s_finish;
     
264.                 }
     
265.             }
     
266.             break;
     
267.         default:
     
268.             {
     
269.                 s = s_fail;
     
270.             }
     
271.             break;
     
272.         }
     
273.     }
     
274. 
     
275.     state a[] = {
     
276.         s_wait_dot,
     
277.         s_wait_num,
     
278.         s_wait_num3,
     
279.         s_wait_e,
     
280.         s_ready_n1,
     
281.         s_ready_n2,
     
282.         s_finish,
     
283.     };
     
284. 
     
285.     for (int j = 0; j < sizeof(a) / sizeof(a[0]); j++)
     
286.         if (a[j] == s) {
     
287.             if (s == s_ready_n1 || s == s_ready_n2)
     
288.                 d = f * pow(10.0f, n);
     
289.             else
     
290.                 d = f;
     
291.             return true;
     
292.         }
     
293.     return false;
     
294. }
     
295. 
     
296. int main()
     
297. {
     
298.     char buff[2048];
     
299.     std::cin >> buff;
     
300. 
     
301.     double f;
     
302.     if (num(buff, f))
     
303.     {
     
304.         std::cout << f << std::endl;
     
305.     }
     
306.     return 0;
     
307. }

复制代码

fml224

前排支持，，，

被封禁言

米和饭 发表于 2013-8-3 15:35
呵呵，你被刷下来了。。。看来竞争很激烈。。。

我看这三天这么快  所以我也来凑凑热闹

屎加豆

呵呵，你被刷下来了。。。看来竞争很激烈。。。