记录详情

Compile Error

foo.c: In function 'main':
foo.c:20:1: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
 ^
foo.c:20:2: error: stray '\275' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
  ^
foo.c:20:3: error: stray '\206' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
   ^
foo.c:20:4: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
    ^
foo.c:20:5: error: stray '\275' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
     ^
foo.c:20:6: error: stray '\277' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
      ^
foo.c:20:7: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
       ^
foo.c:20:8: error: stray '\224' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
        ^
foo.c:20:9: error: stray '\250' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
         ^
foo.c:20:10: error: stray '\351' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
          ^
foo.c:20:11: error: stray '\200' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
           ^
foo.c:20:12: error: stray '\222' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
            ^
foo.c:20:13: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
             ^
foo.c:20:14: error: stray '\275' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
              ^
foo.c:20:15: error: stray '\222' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
               ^
foo.c:20:16: error: stray '\346' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                ^
foo.c:20:17: error: stray '\227' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                 ^
foo.c:20:18: error: stray '\266' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                  ^
foo.c:20:19: error: stray '\357' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                   ^
foo.c:20:20: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                    ^
foo.c:20:21: error: stray '\214' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                     ^
foo.c:20:33: error: 'n' undeclared (first use in this function)
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                 ^
foo.c:20:33: note: each undeclared identifier is reported only once for each function it appears in
foo.c:20:61: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                             ^
foo.c:20:62: error: stray '\211' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                              ^
foo.c:20:63: error: stray '\215' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                               ^
foo.c:20:64: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                ^
foo.c:20:65: error: stray '\220' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                 ^
foo.c:20:66: error: stray '\216' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                  ^
foo.c:20:67: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                   ^
foo.c:20:68: error: stray '\270' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                    ^
foo.c:20:69: error: stray '\244' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                     ^
foo.c:20:70: error: stray '\351' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                      ^
foo.c:20:71: error: stray '\241' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                       ^
foo.c:20:72: error: stray '\271' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                        ^
foo.c:20:73: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                         ^
foo.c:20:74: error: stray '\234' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                          ^
foo.c:20:75: error: stray '\250' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                           ^
foo.c:20:76: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                            ^
foo.c:20:77: error: stray '\277' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                             ^
foo.c:20:78: error: stray '\233' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                              ^
foo.c:20:79: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                               ^
foo.c:20:80: error: stray '\241' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                ^
foo.c:20:81: error: stray '\214' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                 ^
foo.c:20:82: error: stray '\351' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                  ^
foo.c:20:83: error: stray '\200' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                   ^
foo.c:20:84: error: stray '\222' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                    ^
foo.c:20:85: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                     ^
foo.c:20:86: error: stray '\275' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                      ^
foo.c:20:87: error: stray '\222' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                       ^
foo.c:20:88: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                        ^
foo.c:20:89: error: stray '\232' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                         ^
foo.c:20:90: error: stray '\204' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                          ^
foo.c:20:91: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                           ^
foo.c:20:92: error: stray '\277' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                            ^
foo.c:20:93: error: stray '\207' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                             ^
foo.c:20:94: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                              ^
foo.c:20:95: error: stray '\250' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                               ^
foo.c:20:96: error: stray '\213' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                ^
foo.c:20:97: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                 ^
foo.c:20:98: error: stray '\270' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                  ^
foo.c:20:99: error: stray '\255' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                   ^
foo.c:20:100: error: stray '\357' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                    ^
foo.c:20:101: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                     ^
foo.c:20:102: error: stray '\214' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                      ^
foo.c:20:103: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                       ^
foo.c:20:104: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                        ^
foo.c:20:105: error: stray '\232' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                         ^
foo.c:20:106: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                          ^
foo.c:20:107: error: stray '\207' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                           ^
foo.c:20:108: error: stray '\272' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                            ^
foo.c:20:109: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                             ^
foo.c:20:110: error: stray '\216' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                              ^
foo.c:20:111: error: stray '\260' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                               ^
foo.c:20:112: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                ^
foo.c:20:113: error: stray '\256' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                 ^
foo.c:20:114: error: stray '\270' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                  ^
foo.c:20:115: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                   ^
foo.c:20:116: error: stray '\244' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                    ^
foo.c:20:117: error: stray '\232' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                     ^
foo.c:20:118: error: stray '\351' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                      ^
foo.c:20:119: error: stray '\207' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                       ^
foo.c:20:120: error: stray '\215' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                        ^
foo.c:20:121: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                         ^
foo.c:20:122: error: stray '\244' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                          ^
foo.c:20:123: error: stray '\215' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                           ^
foo.c:20:124: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                            ^
foo.c:20:125: error: stray '\256' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                             ^
foo.c:20:126: error: stray '\241' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                              ^
foo.c:20:127: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                               ^
foo.c:20:128: error: stray '\256' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                ^
foo.c:20:129: error: stray '\227' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                 ^
foo.c:20:130: error: stray '\357' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                  ^
foo.c:20:131: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                   ^
foo.c:20:132: error: stray '\214' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                    ^
foo.c:20:133: error: stray '\346' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                     ^
foo.c:20:134: error: stray '\225' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                      ^
foo.c:20:135: error: stray '\210' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                       ^
foo.c:20:136: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                        ^
foo.c:20:137: error: stray '\216' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                         ^
foo.c:20:138: error: stray '\207' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                          ^
foo.c:20:139: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                           ^
foo.c:20:140: error: stray '\276' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                            ^
foo.c:20:141: error: stray '\210' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                             ^
foo.c:20:142: error: stray '\344' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                              ^
foo.c:20:143: error: stray '\275' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                               ^
foo.c:20:144: error: stray '\216' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                ^
foo.c:20:145: error: stray '\357' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                 ^
foo.c:20:146: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                  ^
foo.c:20:147: error: stray '\210' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                   ^
foo.c:20:148: error: stray '\346' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                    ^
foo.c:20:149: error: stray '\257' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                     ^
foo.c:20:150: error: stray '\224' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                      ^
foo.c:20:151: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                       ^
foo.c:20:152: error: stray '\246' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                        ^
foo.c:20:153: error: stray '\202' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                         ^
foo.c:20:154: error: stray '\351' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                          ^
foo.c:20:155: error: stray '\207' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                           ^
foo.c:20:156: error: stray '\215' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                            ^
foo.c:20:157: error: stray '\345' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                             ^
foo.c:20:158: error: stray '\244' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                              ^
foo.c:20:159: error: stray '\215' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                               ^
foo.c:20:160: error: stray '\350' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                ^
foo.c:20:161: error: stray '\256' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                 ^
foo.c:20:162: error: stray '\241' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                  ^
foo.c:20:163: error: stray '\347' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                   ^
foo.c:20:164: error: stray '\256' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                    ^
foo.c:20:165: error: stray '\227' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                     ^
foo.c:20:166: error: expected ';' before 'Fibonacci'
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                      ^~~~~~~~~
foo.c:20:210: error: stray '\357' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                  ^
foo.c:20:211: error: stray '\274' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                   ^
foo.c:20:212: error: stray '\211' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                    ^
foo.c:20:213: error: stray '\343' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                     ^
foo.c:20:214: error: stray '\200' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                      ^
foo.c:20:215: error: stray '\202' in program
 但使用递归时,Fibonacci( n - 1 ) + Fibonacci( n - 2 )前后两项在进行递归的过程中,会出现许多重复计算,效率很低(比如重复计算Fibonacci( n - 3 ), Fibonacci( n - 4 )..... )。
                                                                                                                                                                                                                       ^
foo.c:22:1: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
 ^
foo.c:22:2: error: stray '\217' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
  ^
foo.c:22:3: error: stray '\257' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
   ^
foo.c:22:4: error: stray '\350' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
    ^
foo.c:22:5: error: stray '\200' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
     ^
foo.c:22:6: error: stray '\203' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
      ^
foo.c:22:7: error: stray '\350' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
       ^
foo.c:22:8: error: stray '\231' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
        ^
foo.c:22:9: error: stray '\221' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
         ^
foo.c:22:10: error: stray '\344' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
          ^
foo.c:22:11: error: stray '\275' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
           ^
foo.c:22:12: error: stray '\277' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
            ^
foo.c:22:13: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
             ^
foo.c:22:14: error: stray '\224' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
              ^
foo.c:22:15: error: stray '\250' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
               ^
foo.c:22:16: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                ^
foo.c:22:17: error: stray '\276' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                 ^
foo.c:22:18: error: stray '\252' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                  ^
foo.c:22:19: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                   ^
foo.c:22:20: error: stray '\216' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                    ^
foo.c:22:21: error: stray '\257' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                     ^
foo.c:22:22: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                      ^
foo.c:22:23: error: stray '\256' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                       ^
foo.c:22:24: error: stray '\236' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                        ^
foo.c:22:25: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                         ^
foo.c:22:26: error: stray '\216' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                          ^
foo.c:22:27: error: stray '\260' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                           ^
foo.c:22:28: error: stray '\357' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                            ^
foo.c:22:29: error: stray '\274' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                             ^
foo.c:22:30: error: stray '\214' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                              ^
foo.c:22:31: error: stray '\344' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                               ^
foo.c:22:32: error: stray '\273' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                ^
foo.c:22:33: error: stray '\216' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                 ^
foo.c:22:34: error: stray '\344' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                  ^
foo.c:22:35: error: stray '\270' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                   ^
foo.c:22:36: error: stray '\213' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                    ^
foo.c:22:37: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                     ^
foo.c:22:38: error: stray '\276' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                      ^
foo.c:22:39: error: stray '\200' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                       ^
foo.c:22:40: error: stray '\344' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                        ^
foo.c:22:41: error: stray '\270' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                         ^
foo.c:22:42: error: stray '\212' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                          ^
foo.c:22:43: error: stray '\350' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                           ^
foo.c:22:44: error: stray '\256' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                            ^
foo.c:22:45: error: stray '\241' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                             ^
foo.c:22:46: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                              ^
foo.c:22:47: error: stray '\256' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                               ^
foo.c:22:48: error: stray '\227' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                ^
foo.c:22:49: error: stray '\343' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                 ^
foo.c:22:50: error: stray '\200' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                  ^
foo.c:22:51: error: stray '\202' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                   ^
foo.c:22:52: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                    ^
foo.c:22:53: error: stray '\215' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                     ^
foo.c:22:54: error: stray '\263' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                      ^
foo.c:22:55: error: stray '\351' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                       ^
foo.c:22:56: error: stray '\200' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                        ^
foo.c:22:57: error: stray '\232' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                         ^
foo.c:22:58: error: stray '\350' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                          ^
foo.c:22:59: error: stray '\277' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                           ^
foo.c:22:60: error: stray '\207' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                            ^
foo.c:22:73: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                         ^
foo.c:22:74: error: stray '\276' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                          ^
foo.c:22:75: error: stray '\227' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                           ^
foo.c:22:76: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                            ^
foo.c:22:77: error: stray '\210' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                             ^
foo.c:22:78: error: stray '\260' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                              ^
foo.c:22:85: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                     ^
foo.c:22:86: error: stray '\206' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                      ^
foo.c:22:87: error: stray '\215' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                       ^
foo.c:22:88: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                        ^
foo.c:22:89: error: stray '\224' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                         ^
foo.c:22:90: error: stray '\261' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                          ^
foo.c:22:102: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                      ^
foo.c:22:103: error: stray '\276' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                       ^
foo.c:22:104: error: stray '\227' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                        ^
foo.c:22:105: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                         ^
foo.c:22:106: error: stray '\210' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                          ^
foo.c:22:107: error: stray '\260' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                           ^
foo.c:22:116: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                    ^
foo.c:22:117: error: stray '\233' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                     ^
foo.c:22:118: error: stray '\264' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                      ^
foo.c:22:119: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                       ^
foo.c:22:120: error: stray '\210' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                        ^
foo.c:22:121: error: stray '\260' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                         ^
foo.c:22:122: error: stray '\350' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                          ^
foo.c:22:123: error: stray '\256' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                           ^
foo.c:22:124: error: stray '\241' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                            ^
foo.c:22:125: error: stray '\347' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                             ^
foo.c:22:126: error: stray '\256' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                              ^
foo.c:22:127: error: stray '\227' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                               ^
foo.c:22:128: error: stray '\345' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                                ^
foo.c:22:129: error: stray '\207' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                                 ^
foo.c:22:130: error: stray '\272' in program
 可考虑使用循环实现,从下往上计算。即通过f(0) + f(1) 得到f(2), 再由f(2) + f(1)得到f(3)....直到计算出f(n)
                                                                                                                                  ^
[Hydro](https://hydro.ac)提供评测服务

信息

递交者
类型
自测
题目
A2-2 循环结构入门:斐波拉契数列
语言
C
递交时间
2021-08-15 19:29:56
评测时间
2021-08-15 19:29:56
评测机
分数
0
总耗时
0ms
峰值内存
0 Bytes