笔试题：单例模式、找整数的二进制中1的个数（from nowcoder）

1. 请设计一个类，该类在同一个进程中只能有一个实例，且该实例允许外部访问。

分析：
设计模式中的单例

C++的设计模式——单例模式：
单例模式也称单子模式、单件模式，通过单例模式可以保证系统中只有一个类只有一个实例，并提供一个访问它的全局访问指针，该实例被所有程序模块共享。
对于系统中的某些类来说,只有一个实例很重要，比如一个打印机可以有多个打印任务，但是只有一个正在工作的任务，一个系统只能有一个窗口管理器或文件系统。

单例模式的要点有三个：

1. 单例类只能有一个实例
2. 它必须自行创建这个实例
3. 它必须自行向整个系统提供这个实例

从具体实现角度来说,就是以下三点:

1. 一个类只允许创建唯一的对象
2. 禁止在类的外部创建对象：私有化构造函数：将构造函数声明为private或protected
3. 类的内部维护唯一对象：静态成员变量
4. 提供访问单例对象的方法：静态成员函数，返回在类内部唯一构造的实例

创建方式：
饿汉式：单例对象无论用或不用，程序启动即创建。
懒汉式：单例对象在用的时候再创建，不用即销毁。

单例模式的优点:

1. 在内存中只有一个对象,节省内存空间
2. 避免频繁的创建销毁对象,可以提高性能
3. 避免对共享资源的多重占用
4. 可以全局访问

懒汉式单例：加锁的经典懒汉实现（以时间换空间，可能会有线程安全，异常安全等问题）？？？
来源

class singleton
{
protected:
    singleton()
    {
        pthread_mutex_init(&mutex);
    }
private:
    static singleton* p;
public:
    static pthread_mutex_t mutex;
    static singleton* initance();
};

pthread_mutex_t singleton::mutex;
singleton* singleton::p = NULL;
singleton* singleton::initance()
{
    if (p == NULL)
    {
        pthread_mutex_lock(&mutex);
        if (p == NULL)
            p = new singleton();
        pthread_mutex_unlock(&mutex);
    }
    return p;
}

饿汉式单例：线程安全，不用加锁（以空间换时间，因为一开始就创建了实例，所以每次用到的之后直接返回就好了。）？？？

class singleton
{
protected:
    singleton()
    {
    }
private:
    static singleton* p;
public:
    static singleton* initance();
};

singleton* singleton::p = new singleton;
singleton* singleton::initance()
{
    return p;
}

2. 编写一个函数，求一个数的二进制表示中的1位的个数，例如9的二进制表示为1001，1位的个数为2

方法一：

int CountNum1(int x)
{
    int count = 0;
    while(x)
    {
        x &= (x-1);
        count++;
    }
     
    return count;
}

方法二：

int NumberOf1(int n)
{
    int count = 0;
    while(n)
    {
        if(n & 1)
        	count ++;
        n = n >> 1;
    }

    return count;
}

3. 已知某次聚会敏感词有N个人参加，这N个人来自26个地区，现在将26个地区使用数字0-25表示，使用整数数组Locations存储这N个人的地区, 请返回一个bool值, True代表所有人的地区全都不同，False代表存在相同地区。要求：不能使用额外的存储结构

4. 编写一个函数，实现字符串ASrcStr以Delimiter为分隔符第AIndex项的子串

#-*- coding:utf-8 -*-
 
# 实现字符串ASrcStr以Delimiter为分隔符第AIndex项的子串。
 
def split_str(ASrcStr,Delimiter,AIndex):
    result = ASrcStr.split(Delimiter)
    return result[AIndex]
 
if __name__ == "__main__":
    print(split_str("fadjfjaldjfkl2j3k4j3k2lrj","j",2))

5. 一个只包含0和1的阵列，找到1的组的个数，每个组的定义是横向和纵向相邻的值都为1，如图中一共有4个组，用不同颜色的框分割（可以参见不同粗细勾画起来的框）

#include <iostream>
#include <vector>
using namespace std;
 
bool dfs(int m,int n,vector<vector<int> > &matrix);
void clear(int m,int n,vector<vector<int> > &matrix);
int main()
{
    vector<vector<int> > matrix(3);
 
    matrix[0].push_back (1);
    matrix[0].push_back (0);
    matrix[0].push_back (0);
    matrix[1].push_back (0);
    matrix[1].push_back (1);
    matrix[1].push_back (1);
    matrix[2].push_back (0);
    matrix[2].push_back (1);
    matrix[2].push_back (1);
    int cnt=0;
    for(int i=0;i<matrix.size();++i)
    {
        for(int j=0;j<matrix[i].size();++j)
        {
         if(dfs(i,j,matrix))
             cnt++;
        }
    }
    cout<<cnt<<endl;
    return 0;
}
 
bool dfs(int m,int n,vector<vector<int> > &matrix)
{
    if(matrix[m][n]==1)
    {
         clear(m,n,matrix);
         return true;
    }
    else 
        return false;
}
 
void clear(int m,int n,vector<vector<int> > &matrix)
{
 if(m<matrix.size()&&m>=0&&n<matrix.size()&&n>=0)
    {
    if(matrix[m][n]==1)
    {
         matrix[m][n]=0;
         clear(m-1,n,matrix);
         clear(m+1,n,matrix);
         clear(m,n-1,matrix);
         clear(m,n+1,matrix);
    }
 }
}