笔试题练习（三）

1， 两个一样的杯子,分别装着同体积的茶水和牛奶,然后茶水取一瓢到牛奶杯里,搅匀后从牛奶杯里取一瓢到茶水杯里,问牛奶杯里茶水多还是茶水杯里牛奶多？（华为）

答：体积不变，是一样多。 假设茶水有1000单位，牛奶也一样是1000单位。无论他倒多少次，假设最后茶水杯里有X单位的牛奶，那么茶水杯里的茶水就是（1000-X）。所以牛奶杯里的茶水就是X单位。所以是一样多的。

2， 有10个硬币外形无差别,知道其中一个硬币重量比较轻,要在天秤上怎么样只称两次不用砝码就找出那个假的?

答：第一次：5个分为一组 找到轻的那组

第二次：在有问题那组里任意选4个 两个一组再称。
1）如天平平衡，那么没有选的那个有问题。
2）如不平衡，可以知道轻的那一边有问题，只有2个，拿起其中一个，另一边也取一个，如现在平衡，那么拿起的那一个有问题， 如不平衡没取的那个就是。

3，从1－99999之间，求出所有满足以下条件的数x：1、x是完全平方数；2、x有两位数相同。如：121＝11*11，且它有两位数相同，故它满足条件。

/* ********************************************************************** */
/*  Author:phinecos   Date:2009-05-20                                                                     
/*********************************************************************** */
#include  < iostream >
#include  < map >
#include  < string >
using   namespace  std;

struct  node
{
     int  value;
     int  count;
};

bool  isOk( int  num)
{
     int  i,tmp;
     bool  result  =   false ;
    map < int ,  int >  numMap;

     // 初始化
     for  (i  =   0 ; i <   10 ;  ++ i)
    {
        numMap[i]  =   0 ;
    }
     // 剥离数位
     while  (num  !=   0 )
    {
        tmp  =  num % 10 ;
         ++ numMap[tmp];
        num  /=   10 ;
    }
     // 判断是否仅有一个数位有个
     int  count  =   0 ;
    map < int , int > ::iterator iter;
     for  (iter  =  numMap.begin(); iter  !=  numMap.end();  ++ iter)
    {
         if  (iter -> second  ==   2 )
        {
             ++ count;
        }
    }
     if  (count  ==   1 )
    { // 仅有位出现次
        result  =   true ;
    }
     return  result;
}
int  main( int  argc,  char *  argv[]) 
{ 
     for  ( int  i = 1 ; i  <=   316 ;  ++ i)
    {
         if  (isOk(i * i))
        {
            cout  <<  i * i  << endl;
        }
    }
     return   0 ; 
} 

4，题目：网球中心共有100个网球场，每个单位可以来申请1到100的场地，申请的场地编号必须是连续的，如果场地已经被其他单位占用，就不能再次使用，而且单位在使用完场地后必须归还。请设计一个完整的系统。

#include  < iostream >
#include  < vector >
#include  < string >
using   namespace  std;

/* ********************************************************************** */
/*  Author:phinecos    Date:2009-05-20                                                                      */
/* ********************************************************************** */
struct  TennisCourt
{ // 网球场
     int  serialNum; // 编号
     bool  bOccupied; // 是否被占用
     string  Owner; // 占用者
};
// 网球中心
class  TennisCenter
{
public :
    TennisCenter();
     void  print() const ;
     bool  requestCourts( int  num,  const   char *  requester,vector < int >&  alloctedCourts); // 请求num块场地,若分配成功，则返回分配的场地的编号
     bool  returnCourts( const   char *  returner,  const  vector < int >&  alloctedCourts); // 归还连续编号的场地
     int  getEmpytCourts() const ;
protected :
     void  init();
     void  allocateCourts( int  begin,  int  end,  const   char *  requester);
     bool  IsValidOwner( int  begin,  int  end,  const   char *  returner);
     void  freeCourts( int  begin,  int  end);
private :
    vector < TennisCourt >  courts; // 场地
     int  nEmptyCourt; // 空余的场地
     static   const   int  MAX_CAPACITY  =   100 ; // 场地最大数目
};
TennisCenter::TennisCenter()
{
     this -> init();
}
void  TennisCenter::init()
{
    nEmptyCourt  =  MAX_CAPACITY; // 空余块场地
    courts.resize(MAX_CAPACITY);
     for  ( int  i  =   0 ; i  <  MAX_CAPACITY;  ++ i)
    {
        courts[i].serialNum  =  i + 1 ;
        courts[i].bOccupied  =   false ;
        courts[i].Owner  =   "" ;
    }
}
void  TennisCenter::print() const
{
    vector < TennisCourt > ::const_iterator iter;
     for  (iter  =  courts.begin(); iter  !=  courts.end();  ++ iter)
    {
        cout  <<  iter -> serialNum  <<   ' /t '  ;
         if (iter -> bOccupied)
            cout <<  iter -> Owner  <<   ' /t ' ;
        cout  << endl;
    }
}
void  TennisCenter::allocateCourts( int  begin,  int  end,  const   char *  requester)
{
     for  ( int  i  =  begin;i  <  end;  ++ i)
    {
        courts[i].bOccupied  =   true ;
        courts[i].Owner  =  requester;
         -- this -> nEmptyCourt; // 剩余场地递减
    }
}
bool  TennisCenter::IsValidOwner( int  begin,  int  end,  const   char *  returner)
{ // 是否是合法拥有者
     for  ( int  i  =  begin;i  <=  end;  ++ i)
    {
         if  (courts[i].Owner.compare(returner)  !=   0 )
        {
             return   false ;
        }
    }
     return   true ;
}
void  TennisCenter::freeCourts( int  begin,  int  end)
{
     for  ( int  i  =  begin;i  <=  end;  ++ i)
    {
        courts[i].bOccupied  =   false ;
        courts[i].Owner  =   "" ;
         ++ this -> nEmptyCourt; // 剩余场地递增
    }
}
bool  TennisCenter::requestCourts( int  num,  const   char *  requester, vector < int >&  alloctedCourts)
{ // 请求num块场地,若分配成功，则返回true,输出参数中保存分配的场地的编号,否则返回false
    cout  <<   " 剩余 "   <<   this -> nEmptyCourt  <<   " 块场地 "   << endl;
    alloctedCourts.clear();
     bool  result  =   false ;
     if  (num  >   this -> nEmptyCourt) // 剩余场地不够，不需再查看
         return   false ;

     // 剩余场地数目够，看是否有足够连续多的场地满足用户请求
     int  i,j,k;
     for  (i  =   0 ; i  <  MAX_CAPACITY;  ++ i)
    {
         for  (j  =  i,k  =   0 ; j  <  MAX_CAPACITY  &&  k <  num;  ++ j, ++ k)
        {
             if  (courts[j].bOccupied  ==   true )
            { // 有被占用，未能连续
                 break ;
            }
        }
         if  (k  ==  num)
        { // 有连续num个空场地,分配给请求者
             this -> allocateCourts(i,i + num,requester);
             for  (k  =  i; k  <  i + num;  ++ k)
            {
                alloctedCourts.push_back(k + 1 );
            }
            result  =   true ;
             break ;
        }
    }
     return  result;
}
bool  TennisCenter::returnCourts( const   char *  returner,  const  vector < int >&  alloctedCourts)
{ // 归还连续编号的场地
     int  begin  =  alloctedCourts[ 0 ] - 1 ;
     int  end  =  alloctedCourts[alloctedCourts.size() - 1 ] - 1 ;
     if  ( ! this -> IsValidOwner(begin, end, returner))
    { // 非法持有者不能归还
         return   false ;
    }
     this -> freeCourts(begin, end);
     return   true ;

}
int  TennisCenter::getEmpytCourts() const
{
     return   this -> nEmptyCourt;
}
void  showAllocatedCourts( const  vector < int >&  courts)
{
    vector < int > ::const_iterator iter;
     for  (iter  =  courts.begin(); iter  !=  courts.end();  ++ iter)
    {
        cout  <<   * iter  <<  endl;
    }
}
int  main( int  argc,  char *  argv[]) 
{
    TennisCenter tennisCenter;
    vector < int >  allocatedCourts;
     bool  result  =  tennisCenter.requestCourts( 30 , " 张三 " ,allocatedCourts);
     if  (result)
    {
        showAllocatedCourts(allocatedCourts);
    }
     else
    {
        cout  <<   " 无足够的场地分配 "   <<  endl;
    }
    cout  <<   " 归还前:  "   <<  tennisCenter.getEmpytCourts()  <<  endl;
    tennisCenter.print();
    tennisCenter.returnCourts( " 张三 " ,allocatedCourts);
    cout  <<   " 归还后:  "   <<  tennisCenter.getEmpytCourts()  <<  endl;
    tennisCenter.print();
    cout  << endl  <<  endl;
     if  (tennisCenter.requestCourts( 60 , " 李四 " ,allocatedCourts))
    {
        showAllocatedCourts(allocatedCourts);
    }
     else
    {
        cout  <<   " 无足够的场地分配 "   <<  endl;
    }
    cout  << endl  <<  endl;
    cout  <<   " 归还前:  "   <<  tennisCenter.getEmpytCourts()  <<  endl;
    tennisCenter.print();
    tennisCenter.returnCourts( " 李四 " ,allocatedCourts);
    cout  <<   " 归还后:  "   <<  tennisCenter.getEmpytCourts()  <<  endl;
     if  (result  =  tennisCenter.requestCourts( 20 , " 王五 " ,allocatedCourts))
    {
        showAllocatedCourts(allocatedCourts);
    }
     else
    {
        cout  <<   " 无足够的场地分配 "   <<  endl;
    }
    cout  <<   " 王五还未归还. " <<  endl;
    tennisCenter.print();
     return   0 ; 
}