笔试题练习（三）

 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;   
}