[2018大华软件创新挑战赛] 模拟赛1~4题总结

题目	输入	输出	限制	示例
node_buffer定义了一个用于存储int型数据的缓冲器，请实现其声明的所有成员方法，并满足如下要求： 1.除非调用pop_front，否则push_back成功的数据节点不可移除； 2.不可添加给定之外的数据成员和成员方法；	输入的第一行指定用例数量T； 用例的第一行输入指定队列的最大节点数K； 用例的第二行输入指定插入的节点数量M； 用例的第三行输入指定插入的节点数值，使用空格隔开； 用例的第四行输入指定移除的节点数量N；	node_buffer中剩余的节点数据值，使用空格隔开；	K > 0	class node_buffer { public: // 构造函数 // 参数: max_size 指定缓冲的最大节点数 node_buffer(int max_size); // 析构函数 ~node_buffer(); // 从队尾插入一个数据节点 // 参数：i 待插入节点 // 返回值：true 插入成功 // false 插入失败，表示数据节点个数达到最大值 bool push_back(int i); // 从队首移除一个数据节点 // 返回值：true 移除成功 // false 移除失败，表示数据节点个数为0 bool pop_front(); // 获取队首节点值，不移除数据 int front(); // 获取队尾节点值，不移除数据 int back(); // 获取数据节点数量 // 返回值：数据节点数量 int size(); private: int* m_queue; int m_max_size; int m_front; int m_back; int m_size; }; Input: 1 8 9 1 2 3 4 5 6 7 8 9 4 Output: 5 6 7 8
网络上有一台流媒体服务器S和一台客户端C，S向C发送流媒体数据。 1、S的发送速率为M； 2、C有一个缓冲区B，最大值大小为X，B接收来自S的流媒体，C处理B中的数据并清理，B的处理速度为N。 3、为保证C处理的效率，当缓冲区大小超过80%时，C发送停止命令给S，S将停止向C发送数据。 4、当缓冲区大小小于60%时，C向S发送重启发送数据命令，S向C发送数据。 5、题中所有单位都是基本单位。 请设计一个函数handle_data_func，用来处理缓冲区B,并计算C第一次向S发送重启发送数据命令的时间T0及每次发送重启命令的的时间间隔T1。 注意：输出默认保留两位小数	输入的第一行指定用例数量T； 用例的第二行输入速率M、N； 用例的第三行输入缓冲区大小X；	客户端C第一次向服务端S发送重启发送数据命令的时间及时间间隔。	不考虑网络上的延时。	int handle_data_func(int M,int N,int X,int &T1) input: 1 2 1 10 output: 10.00 4.00
有一种特殊的正整数（int类型），将数分为两侧，每侧至少有一位数，两侧的每个数字相加相等，请写出判断的方法用来检测是否这种数。 比如：1236,可以拆分为123和6。	输入的第一行指定用例数量T； 用例的第二行输入正整数；	输出是否为特殊的正整数		bool is_magicnum(int number) intput: 2 1232145 4543622 output: 1 1
某股票操盘手账户里有N支股票，股价互不等，分别为v1,v2...vn;每支股票的持有股数为m1,m2...mn。现在操盘手要回笼资金需要卖出股票，假设卖出价格即为当前股价，请问能回笼多少种不同的资金量。比如：两支股票，股价分别为10、11,数量为1、2，则能回笼0、10、11、22、21、32，总共6种资金量	输入的第一行指定用例数量T； 用例的第一行输入股票种类n； 用例的第二行输入股票的价格，以空格隔开； 用例的第三行输入股票的数量，已空格隔开；	输出不同资金量的个数	1<=n<=10 1<=v<=20 1<=m<=6	Input: 1 2 10 11 1 2 Output: 6

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

---

第一题：

#include "iostream"
#include "algorithm"
#include "vector"

using namespace std;

class node_buffer
{
public:
        // 构造函数
        // 参数: max_size 指定缓冲的最大节点数
        node_buffer(int max_size)
        {
                m_queue = (int*)malloc(sizeof(int)*max_size);
                m_max_size = max_size;
                m_front = 0;
                m_size = 0;
                m_back = -1;
        }
 
        // 析构函数
        ~node_buffer()
        {
                m_front = 0;
                m_size = 0;
                m_back = -1;
                free(m_queue);
        }
 
        // 从队尾插入一个数据节点
        // 参数：i 待插入节点
        // 返回值：true 插入成功
        //        false 插入失败，表示数据节点个数达到最大值
        bool push_back(int i)
        {
                if(m_size >= m_max_size) return false;
                m_queue[++m_back%m_max_size] = i;
                m_back %= m_max_size;
                m_size++;
                return true;
        }
 
        // 从队首移除一个数据节点
        // 返回值：true 移除成功
        //         false 移除失败，表示数据节点个数为0
        bool pop_front()
        {
                if(m_size<=0) return false;
                m_front = (m_front+1) % m_max_size;
                m_size--;
                return true;
        }
 
        // 获取队首节点值，不移除数据
        int front()
        {
                return m_queue[m_front];
        }

        // 获取队尾节点值，不移除数据
        int back()
        {
                return m_queue[m_back];
        }

        // 获取数据节点数量
        // 返回值：数据节点数量
        int size()
        {
                return m_size;
        }

        // 显示所有存在数据
        bool show()
        {
                for(int i = m_front; i <= m_back; i++) cout << m_queue[i] << " ";
                cout << endl;
        }

private:
        int* m_queue;
        int  m_max_size;
        int  m_front;
        int  m_back;
        int  m_size;
};

int main()
{
        int t;
        cin >> t;

        while(t--)
        {
                int max_size;
                cin >> max_size;//输入指定队列的最大节点数K

                int push_num;
                cin >> push_num;//输入指定插入的节点数量M

                node_buffer queue(max_size);
                vector<int> data(push_num,0);
                for(int i=0; i<push_num; i++) cin >> data[i];//输入指定插入的节点数值，使用空格隔开

                if (push_num > max_size) push_num = max_size;
                for(int i=0; i<push_num; i++) queue.push_back(data[i]);

                int pop_num;
                cin >> pop_num;//输入指定移除的节点数量N

                if(pop_num > queue.size()) pop_num = queue.size();
                for(int i=0; i<pop_num; i++) queue.pop_front();

                queue.show();
        }
        return 0;
}

 

---

第二题：

#include <cstdio>

double handle_data_func(double M,double N,double X,double &T1)
{
        double v = M - N;
        double T0;
        T0 = (0.8 * X)/v + (0.2 * X)/N;
        T1 = (0.2 * X)/v + (0.2 * X)/N;
        return T0;
}
    
int main()
{
        int t;
        scanf("%d",&t);
        double m, n, x;
        double T0,T1;
        while(t--)
        {
                scanf("%lf %lf",&m,&n);
                scanf("%lf",&x);
                T0 = handle_data_func(m, n, x, T1);
                printf("%.2f 
",T0);
                printf("%.2f 
",T1);
        }
        return 0;
}

 

---

第三题：

#include <stdio.h>
#include <stdbool.h>

bool is_magicnum(int number)
{
        char arr[10] = {};
        int j = 0;
        int sumi = 0;
        int sumj = 0;

        while(number)
        {
                arr[j++] = number%10;
                number /= 10;
        }
        j--;

        for(int i=0; i<=j; )
        {
                if(sumi >= sumj)
                {
                        sumj += arr[j--];
                }
                else if(sumi < sumj)
                {
                        sumi += arr[i++];
                }
        }
        if(sumi == sumj)
        {
                return true;
        }
        else
        {
                return false;
        }
}

int main()
{
        int t;
        scanf("%d",&t);

        int num[t];
        for(int i=0; i < t; i++)
        {
                scanf("%d",&num[i]);
        }
        for(int i=0; i < t; i++)
        {
                printf("%d
",is_magicnum(num[i]));
        }
        return 0;
}

 

---

第四题：

#include <stdio.h>

int result[100000];
int count;

void combination(int* arr,int i,int cnt)
{
        if(i >= cnt)
        {
                int sum = 0;
                for(int j=0; j<cnt; j++)
                {
                        sum += arr[j];
                }
                for(int j=0; j<count; j++)
                {
                        if(sum == result[j]) return;
                }
                result[count++] = sum;
                return;
        }

        int temp = arr[i];
        arr[i] = 0;
        combination(arr,i+1,cnt);
        arr[i] = temp;
        combination(arr,i+1,cnt);
}

int main()
{
        int t = 0;
        scanf("%d",&t);
        while(t--)
        {
                int n = 0;
                scanf("%d",&n);

                int val[n];
                for(int i=0; i<n; i++)
                {
                        scanf("%d",&val[i]);
                }

                int num[n];
                int cnt = 0;
                for(int i=0; i<n; i++)
                {
                        scanf("%d",&num[i]);
                        cnt += num[i];
                }

                int arr[n*cnt];
                cnt = 0;
                for(int i=0; i<n; i++)
                {
                        for(int j=0; j<num[i]; j++)
                        {
                                arr[cnt++] = val[i];
                        }
                }
                printf("
");
                combination(arr,0,cnt);
                printf("%d 
",count);
        }
}

 

 

---

 

实现效果：