找工过程中碰到的笔试面试题整理（1）

前段时间忙论文，现在终于有空写几篇文章了。

接下来的几篇文章将陆续整理自己在笔试和面试中见到的典型题目，有些签了保密协议的就不透露了。

题目大多是自己笔完面完后自己总结的，可能不是最好的方法，也难免有错误，有问题的话请留言告知。3Q

先来一个。

找出最大的一些数，前nums个最大的。

这个题出现的次数还是挺多的，不过大部分都是讲讲思路。基本用快排的思想就行了.

 

                  
                    
 
                      
                      
                     代码 
                     
 
                      
                     
                       

                      
                        
                      
                         1 
                      
                        void
                      
                         find_n_most(
                      
                        int
                      
                        *
                      
                         pa,
                      
                        int
                      
                         start,
                      
                        int
                      
                         end,
                      
                        int
                      
                         nums)

                      
                         2 
                      
                        

                      
                         3 
                      
                        {

                      
                         4 
                      
                        

                      
                         5 
                      
                         
                      
                        if
                      
                        (start
                      
                        >=
                      
                        end
                      
                        -
                      
                        1
                      
                        )

                      
                         6 
                      
                        

                      
                         7 
                      
                         
                      
                        return
                      
                        ;

                      
                         8 
                      
                        

                      
                         9 
                      
                         
                      
                        int
                      
                         i
                      
                        =
                      
                        start;

                      
                        10 
                      
                        

                      
                        11 
                      
                         
                      
                        for
                      
                        (
                      
                        int
                      
                         j
                      
                        =
                      
                        start
                      
                        +
                      
                        1
                      
                        ;j
                      
                        <
                      
                        end;j
                      
                        ++
                      
                        )

                      
                        12 
                      
                        

                      
                        13 
                      
                         {

                      
                        14 
                      
                        

                      
                        15 
                      
                         
                      
                        if
                      
                        (pa[j]
                      
                        >
                      
                        pa[start])

                      
                        16 
                      
                        

                      
                        17 
                      
                         swap(pa[j],pa[
                      
                        ++
                      
                        i]);

                      
                        18 
                      
                        

                      
                        19 
                      
                         }

                      
                        20 
                      
                        

                      
                        21 
                      
                         swap(pa[start],pa[i]);

                      
                        22 
                      
                        

                      
                        23 
                      
                         
                      
                        if
                      
                        (i
                      
                        ==
                      
                        nums
                      
                        -
                      
                        1
                      
                        ||
                      
                        i
                      
                        ==
                      
                        nums)

                      
                        24 
                      
                        

                      
                        25 
                      
                         
                      
                        return
                      
                        ;

                      
                        26 
                      
                        

                      
                        27 
                      
                         
                      
                        if
                      
                        (i
                      
                        >
                      
                        nums)

                      
                        28 
                      
                        

                      
                        29 
                      
                         find_n_most(pa,start,i,nums);

                      
                        30 
                      
                        

                      
                        31 
                      
                         
                      
                        else
                      
                        

                      
                        32 
                      
                        

                      
                        33 
                      
                         find_n_most(pa,i
                      
                        +
                      
                        1
                      
                        ,end,nums);

                      
                        34 
                      
                        

                      
                        35 
                      
                        

                      
                        36 
                      
                        }

                      
                        37 
                      
                         
                     
                       
 
                     
 
                    

 




 


                 
                   



                  
                    
上述算法过后，前面nums个数就是所要求的了，注意这个只要求找到前nums个最大的，并不要求排序。


                  
                    
再来一个：


                  
                    
求循环小数的循环体，给两个整数a，b，求a/b的循环小数的循环体字符串，如果不是循环小数则输出空串。


                  
                    
思路：


                  
                    

                      每次将商追加到结果字符串，记录余数，当余数重复出现时，则从重复的位置开始到最后这一段的商字符串即为循环体。 
                    


                  
                    
 
                     
 
                       
                       
                      代码 
                      
 
                       
                      
                        

                       
                         
                       
                          1 
                       
                         string
                       
                          get_circle_digits(unsigned 
                       
                         int
                       
                          k,unsigned 
                       
                         int
                       
                          j)

                       
                          2 
                       
                         

                       
                          3 
                       
                         {

                       
                          4 
                       
                         

                       
                          5 
                       
                          
                       
                         if
                       
                         (k
                       
                         %
                       
                         j
                       
                         ==
                       
                         0
                       
                         )

                       
                          6 
                       
                         

                       
                          7 
                       
                          
                       
                         return
                       
                          
                       
                         ""
                       
                         ;

                       
                          8 
                       
                         

                       
                          9 
                       
                          
                       
                         int
                       
                          quotient;

                       
                         10 
                       
                         

                       
                         11 
                       
                          
                       
                         string
                       
                          quotient_result
                       
                         =
                       
                         ""
                       
                         ;

                       
                         12 
                       
                         

                       
                         13 
                       
                          vector
                       
                         <
                       
                         int
                       
                         >
                       
                          remainders;

                       
                         14 
                       
                         

                       
                         15 
                       
                          
                       
                         int
                       
                          remainder 
                       
                         =
                       
                          k
                       
                         %
                       
                         j;

                       
                         16 
                       
                         

                       
                         17 
                       
                          remainders.push_back(remainder);

                       
                         18 
                       
                         

                       
                         19 
                       
                          
                       
                         while
                       
                         (
                       
                         true
                       
                         )

                       
                         20 
                       
                         

                       
                         21 
                       
                          {

                       
                         22 
                       
                         

                       
                         23 
                       
                          quotient 
                       
                         =
                       
                          remainder
                       
                         *
                       
                         10
                       
                         /
                       
                         j;

                       
                         24 
                       
                         

                       
                         25 
                       
                          remainder 
                       
                         =
                       
                          remainder
                       
                         *
                       
                         10
                       
                         %
                       
                         j;

                       
                         26 
                       
                         

                       
                         27 
                       
                          
                       
                         if
                       
                         (remainder
                       
                         ==
                       
                         0
                       
                         )

                       
                         28 
                       
                         

                       
                         29 
                       
                          
                       
                         return
                       
                          
                       
                         ""
                       
                         ;

                       
                         30 
                       
                         

                       
                         31 
                       
                          quotient_result.append(
                       
                         1
                       
                         ,quotient
                       
                         +
                       
                         '
                       
                         0
                       
                         '
                       
                         );

                       
                         32 
                       
                         

                       
                         33 
                       
                          
                       
                         if
                       
                         (find(remainders.begin(),remainders.end(),remainder)
                       
                         !=
                       
                         remainders.end())

                       
                         34 
                       
                         

                       
                         35 
                       
                          {

                       
                         36 
                       
                         

                       
                         37 
                       
                          
                       
                         return
                       
                          quotient_result.substr(find(remainders.begin(),remainders.end(),remainder)
                       
                         -
                       
                         remainders.begin());

                       
                         38 
                       
                         

                       
                         39 
                       
                          }

                       
                         40 
                       
                         

                       
                         41 
                       
                          remainders.push_back(remainder);

                       
                         42 
                       
                         

                       
                         43 
                       
                          }

                       
                         44 
                       
                         

                       
                         45 
                       
                         }
                      
                        
 
                      
 
                     
 
                     
 
 
                    


                  
                    

                      测试例子： 
                    


                  
                    

                      get_circle_digits(70,11); 
                    


                  
                    

                      get_circle_digits(7,1); 
                    


                  
                    

                      get_circle_digits(1,121); 
                    


                  
                    

                      get_circle_digits(102,9990); 
                    


                  
                    

                      get_circle_digits(1,9); 
                    


                  
                    

                      get_circle_digits(112,999);