网龙笔试2019春招

网龙开发工程师笔试题:
一.编程题：
1.给定数量不限的硬币，币值为25分、10分、5分和1分，编写代码计算n分有多少种表示法：
//本题采用动态规划算法（类似于0-1背包问题）
思路为：
1.将面值用coins[4]={1,5,10,25}存储
2.用i表示n分钱的表示可以用到的面值，比如i=0表示表示n分钱只能用到1分的面值，i为2时表示能够用参与组合的硬币面值有1分和2分；
3. j表示总共的面额。
4. dp[i][j]表示参与组合成j分的硬币种类为i+1种时的表示法。
5. 子问题为当前规划到第i行，即面额为coins[i]的硬币是否被用于组合。当不用于组合时（即j<coins[i]）表示法有dp[i][j]=dp[i-1][j];当参与组合时表示法有dp[i][ j-coin[i] ]+dp[i-1][j]种。

i\j	0	1	2	3	4	5	6	7	8	9	10	…
0	1	1	1	1	1	1	1	1	1	1	1
1	1	1	1	1	1	2	2	2	2	2	3
2	1	1	1	1	1	2	2	2	2	2	4
3	1	1	1	1	1	2	2	2	2	2	4

#include <iostream>
#include <stdio.h>
using namespace std;
int ways(int n){
int coins[4]={1,5,10,25};
int dp[4][n+1];
int i=0,j=0;
for(;i<4;i++){
    dp[i][0]=1;//第0列初始化，表示总额为0时只有所有系数都为0一种表示
}
for(j=1;j<n+1;j++){
    dp[0][j]=1;//表示当只用面值为1的硬币表示时只有一种方法
}
for(i=1;i<4;i++){
    for(j=1;j<n+1;j++){
        if(j>=coins[i]){
            dp[i][j]=dp[i-1][j]+dp[i][j-coins[i]];
        }
        else dp[i][j]=dp[i-1][j];
    }
}
return dp[3][n];
}
int main()
{
int n;
scanf("%d",&n);
printf("%d",ways(n));
}

优化存储空间，使用一维数组：

int ways(int n){
int coins[4]={1,5,10,25};
int dp[n+1]={1};
for(int i=0;i<4;i++){
    for(int j=1;j<n+1;j++){
        if(j>=coins[i]){
            dp[j]=dp[j]+dp[j-coins[i]];
        }
    }
}
return dp[n];
}

2.给定一个整数数组和一个目标值，找出数组中和为目标值的两个数。
你可以假设每个输入只对应一种答案，且同样的元素不能被重复利用。
示例:
给定 nums = [2, 7, 11, 15], target = 9
因为 nums[0] + nums[1] = 2 + 7 = 9
所以返回 [0, 1]

#include <iostream>
#include <stdio.h>
using namespace std;
void fun(int nums[],int target,int two[]){
     int n=sizeof(nums);
   //  printf("%d\n",n);
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            if(nums[i]+nums[j]==target){
                two[0]=i;
                two[1]=j;
                break;
            }
        }
    }
 }
int main()
{
    int n;
    scanf("%d",&n);
    int nums[n];
    for(int i=0;i<n;i++){
        scanf("%d",&nums[i]);
        printf("%d ",nums[i]);
    }
    int target;
    scanf("%d",&target);
    int two[2]={0};
    fun(nums,target,two);
    printf("\n[%d,%d]",two[0],two[1]);
    return 0;
}

二：选择
1.TCP怎么处理失败的连接？
发出一个RST段重置目的端的传输计时器表示复位，用来关闭连接。
情况有：
1.服务器端口未打开
2.请求超时（客户端有超时时间设定）
3.提前关闭（如只读前几个字节）
4.一个已关闭的socket上收到数据时

2.线程与进程：
1.进程：子进程是父进程的复制品，子进程获得父进程数据空间、堆和栈的复制品。
2.线程：可以与同进程的其他线程共享数据，但拥有自己的栈空间，拥有独立的执行序列。
3.相同点两者都可以提高程序的并发度，提高程序运行效率和响应时间。
4.进程同步的方法有：
*临界区（对多线程的串行化来访问公共资源，进程内的线程同步，用户同步方式）
*互斥量（跨进程同步，信号量的以种特殊形式,最大资源数为1）
*信号量包含互斥量
*管程
*消息传递原语send（），receive（）
5.内存分配：
C++中内存分为五个区：栈，堆，自由存储区，全局（静态）存储区，常量存储区
*栈：编译器自动分配，放局部变量（声明在函数中，不提前分配空间，函数调用结束系统自动回收）>函数参数（实参（定义时分配地址）和形参（调用才分配空间））等
*堆：有new分配内存块，程序员释放
*全局（静态）存储区：全局变量（整个工程文件内都有效），静态变量（从定义到程序运行结束一直存在，不会消失）
*常量存储区：这是一块特殊存储区，里边存放常量（比如“123456”字符串），不允许修改。

6.死锁
死锁产生的原因：
系统资源不足，顺序推进不当
产生的必要条件：
1.互斥：资源独占且排他
2.不剥夺：
3.请求与保持：进程每次申请它所需一部分资源
4.循环等待

7.排序算法的稳定性：
稳定：冒泡On^2,
插入（有已排好序列），On^2
基数排序:桶排序，d*（r+n）；长度*（个数+基数）
归并排序：nlogn

不稳定：选择（有交换），On^2
快速（枢纽），Onlogn
希尔（步长），n^1.3
堆排序:nlogn

8.SOLID面向对象编程：
S single单一责任原则：一个类只做一种类型责任
O open开放封闭原则：拓展开放，修改封闭
L lis 里氏代替原则：子类实例能够替换任何超类实例
I interface 接口分离原则：不强迫用户依赖他们不使用的接口
D dependence：依赖倒置原则：高层不依赖底层，都依赖抽象；抽象不依赖细节

9.函数式编程：
1.函数编程语言最重要的基础是λ演算，λ演算之通用在于，任何一个可计算函数都能用这种形式来表达和求值。
2.是结构化编程，强调将计算过程分解成可复用的函数。
3.是声明式编程的一种。
4.将计算过程抽象成表达式求值，表达式由纯数学函数构成，是第一类对象且没有语义上可观察的函数副作用；

补充：所谓函数副作用是指，当调用函数时，被调用函数除了返回函数值之外，还对主调用函数产生附加的影响。例如，调用函数时在被调用函数内部：
·修改全局量的值；
·修改主调用函数中声明的变量的值(一般通过指针参数实现)。

区别：
面相对象：关心组件的封装、结合与协作；
函数式编程：关心结构的映射（输入输出）与数值处理流程。
区别：
1.命令式编程:主要思想是关注计算机执行的步骤，即一步一步告诉计算机先做什么再做什么。
2.声明式编程：声明式编程是以数据结构的形式来表达程序执行的逻辑。它的主要思想是告诉计算机应该做什么，但不指定具体要怎么做,即注重结果，不注重过程。