【今日头条测试开发笔试】部分题目总结

选择题单选和多选，都不太难，

两个我觉得容易出错，平时记忆不太深的有：

1.TCP连接中，客户端向服务器端发送FIN后，服务器端进入状态：

A.CLOSE_WAIT
B.LAST_ACK
C.TIME_WAIT
D.SYN_RCVD

应该选A

2.c++中初始化数组为0，下面哪些正确：

A.int sum[100]={0};
B.int sum[100]memset(sum,0,sizeof(int)*100);
C.int sum[100]memset(sum,0,sizeof(sum));
D.static int sum[100];

这个题很细节，ABCD正确，
参考链接
A和D：全局变量和静态变量初始化时会自动被设置为0。如果们声明全局变量，那么他在运行前会变成全0。

int arr[1024];
int main(void)
{}

B和C：关于memset初始化与赋值问题
memset是C/C++提供的函数初始化函数，在C中头文件是<string.h>。在此强调一下，可以用memset给一个数组初始化为0、-1或一个很大的数，但是不要用memset函数来赋具体的值。因为：

void *memset(void *s, int ch, size_t n);
memset是将从地址s开始，字节长度为n的内存全部赋值为ch（注意是每一个字节都赋值为ch）
char B[20]; memset(B, 1, sizeof(B));
因此，memset(内存地址，1，字节数)这句的意思是要把内存空间的值设置为0x01。对于char型数组B，正好是每个元素占一个字节，所以这样赋值就是将数组B中所有的元素都赋值为1，没有问题。
int C[20]; memset(C, 1, sizeof(C));
但是对于int型数组C，每个元素占四个字节。也就是说将数组C中的每个元素赋值成0x01010101，对应的十进制就是16843009。

对于0的情况：

假如要改为1呢？

这里的16843009是怎么来的呢？

根据1的原码，利用#include<bitset> 和 cout<<bitset<8>(sum3[i])<< ' ';
得到输出：

由于int是4字节的，此时memset仅仅填充了最后1个字节，而前面的数字没有被改变，也就是说将数组C中的每个元素赋值成101010100000001，对应的十进制就是16843009。

printf("%x",sum3[i]);

查看真实结果：

注意，参考网址：
默认值只能设为0，且只有在初始化时，才能设为0（sum[100]={0};这么写就是错的）；

3.java中得到结果：

（原题问得更复杂一些，例如Integer a=128;int b=128;a.equals(b)是否成立）

class  A
{public static void main(String[] args) {Integer a = 128, b = 128;System.out.println(a == b);Integer c = 127, d = 127;System.out.println(c == d);}
}

我们知道java的==是地址意义上的绝对等于，参考网址点此我就不详细说了，讲讲结论:

包装对象的数值比较，不能简单的使用==，虽然-128到127之间的数字可以，但是这个范围之外还是需要使用equals比较。
前面提到，有些场景会进行自动拆装箱，同时也说过，由于自动拆箱，如果包装类对象为null，那么自动拆箱时就有可能抛出NPE。
如果一个for循环中有大量拆装箱操作，会浪费很多资源。

算法部分：

算法题也很细节，测试用例非常到位（和其他厂的一比较真的觉得很用心了，当然也会难一些）

1.简单变换

给出mmm个数组A,BA,BA,B长度nnn，如果A能通过变换变成B，就返回YES，否则返回NO。
这个变换是：A的某个区间A[l,r]A[l,r]A[l,r]加上某个数K能等于B，其中K≥1,1≤l≤r≤nK\geq 1,1\leq l\leq r\leq nK≥1,1≤l≤r≤n
其中1≤n≤1061 \leq n\leq10^61≤n≤106
例如：
输入：

2
5
1 1 1 1 1
1 2 1 3 1
6
3 3 2 4 0 1
3 5 4 6 2 1

输出：

NO
YES

思路：每个条件都不能放过！！！

1≤n≤1061 \leq n\leq10^61≤n≤106，
A的某个区间A[l,r]A[l,r]A[l,r]，
某个数K，
K≥1,1≤l≤r≤nK\geq 1,1\leq l\leq r\leq nK≥1,1≤l≤r≤n

我100%100\%100%通过的代码：

#include <stdio.h>
#include <stdlib.h>int main()
{int t =0;scanf("%d",&t);int n=0;int i=0;for(i=0; i<t; i++){scanf("%d",&n);int j=0;int a[100000];int b[100000];for(j=0; j<n; j++){scanf("%d",&a[j]);}int flag=0;int k=0;int can_change=1;int save=0;//区间必须连续for(j=0; j<n; j++){scanf("%d",&b[j]);if(a[j]!=b[j] && flag==1){if(b[j]-a[j]!=k){can_change=-1;flag=2;}if(j!=save+1){can_change=-1;flag=2;}else if(j==save+1){save=j;}}if(a[j]!=b[j] && flag==0){k=b[j]-a[j]; //算出k的值flag=1;save=j;if(k<0){can_change=-1;flag=2;}}}if(can_change==-1){printf("NO\n");}else{printf("YES\n");}}
}

2.优惠券

思路：
快排（O(NlogN)O(NlogN)O(NlogN)），二分查找(logNlogNlogN)。
所以这里很细节，如果不用二分查找，根本不能通过啊……然而很简单的二分查找我忘记了，但是复杂的快排我倒是记住了，杯具额,30%通过≈\approx≈没通过……

快排思路：点击访问
二分查找不大于某个数的思路：
首先当前序列有序，
得到中间坐标mid，查看中间坐标mid的值，

如果目标值大于a[mid]a[mid]a[mid]的值，则从a[mid]a[mid]a[mid]找到该数组结尾，
如果目标值小于a[mid]a[mid]a[mid]的值，则从a[0]a[0]a[0]找到a[mid]a[mid]a[mid]
并且注意不要遗漏mid左右的值（特别当mid为奇数和偶数时），所以要将(mid−1)(mid-1)(mid−1)

int find_val(int a[],int s,int e,int cost)
{int mid=e/2;int max=0;while(s<=e){mid=(s+e)/2;int midVal=a[mid];if(midVal<=cost){max=midVal; //目前所能找到的最大值s=mid+1; //mid前都是小于cost的，所以从mid开始找}else if(midVal>cost){e=mid-1;  //mid后都是大于cost的，所以从开头找到mid就结束。}printf("max:%d  midVal:%d a[mid]:%d\n",max,midVal,a[mid]);}
}

递归写法：

#include <stdio.h>
#include <stdlib.h>int find_val(int a[],int s,int e,int cost)
{int mid=e/2;mid=(s+e)/2;int midVal=a[mid];int max=a[s];if(midVal<=cost){max=midVal;s=mid+1;}else if(midVal>cost){e=mid-1;}printf("max:%d  midVal:%d a[mid]:%d\n",max,midVal,a[mid]);if(s<e){max=find_val(a,s,e,cost);}return max; //注意保存最大值
}int main()
{int a[13]= {10,21,33,45,55,64,73,83,94,105,113,122,131};int s=0,e=13;int mid=e/2;int key=52;printf("%d",find_val(a,s,e,key));}

总的代码：

#include <stdio.h>
#include <stdlib.h>void print(int a[])
{int i=0;while(a[i]){printf("%d ",a[i]);i++;}printf("\n");
}void quick_sort(int s,int e,int a[])
{if (s<e){int i=s,j=e;int tmp=a[i];while(i<j){while(i<j && a[j]>=tmp){j--;}if(i<j && a[j]<tmp){a[i]=a[j];}while(i<j && a[i]<=tmp){i++;}if(i<j && a[i]>tmp){a[j]=a[i];}}a[i]=tmp;quick_sort(s,i-1,a);quick_sort(i+1,e,a);}
}
//最大但是不能相等，普通方法
int findMaxTicket(int a[],int cost)
{int i=0;int max=0;while(a[i]){if(a[i]>max && a[i]<=cost){max=a[i];}i++;}return max;
}
//二分查找
int find_val(int a[],int s,int e,int cost)
{int mid=e/2;int max=0;while(s<=e){mid=(s+e)/2;int midVal=a[mid];if(midVal<=cost){max=midVal;s=mid+1;}else if(midVal>cost){e=mid-1;}//printf("max:%d  midVal:%d a[mid]:%d\n",max,midVal,a[mid]);}return max;
}int cheap[1000000];
int cost[1000000];
int main()
{int n,m;scanf("%d %d",&n,&m);int i=0;for(i=0; i<n; i++){scanf("%d",&cheap[i]);}for(i=0; i<m; i++){scanf("%d",&cost[i]);}quick_sort(0,n-1,cheap);//quick_sort(0,m-1,cost);int sum=0;for(i=0; i<m; i++){int discount=cost[i]-find_val(cheap,0,n-1,cost[i]);sum=discount+sum;}printf("%d",sum);return 0;
}

由于排序后二分查找，速度就快很多了。

3.折木棒：

思路：

实际上最少的折断次数取决于木棒的右边，而且尽量取平均
例如：

1 4 1
由于右边是1，所以木棒只能变成：1 1 1 1 1
折了3次。

例如:

3 4 13 9 5
由于右边是5，所以是：
3 4 13 4 5 5
3 4 3 3 3 4 4 5 5                 13->1 4 4 4 尽量取平均得到3 3 3 4
3 1 3 3 3 3 4 4 5 5
1 1 1 1 3 3 3 3 4 4 5 5

但是下面的情况：

3 4 16 9 5
则可以
3 4 4 4 4 4 5 5

参考网址：点此访问

代码：

#include <iostream>
#include<vector>
#include<stack>
using namespace std;int breakNum(vector<int>& nums)
{int ans = 0;stack<int> st;for (int i = nums.size() - 1; i >= 0; i--){if (!st.empty() && st.top() < nums[i]){int t = (nums[i] - 1) / st.top(); //切断次数ans += t;st.push(nums[i] / (t + 1)); //求解最靠近左边的值continue;}st.push(nums[i]);}return ans;
}int main()
{int a[5]={3,4,16,9,5};vector<int> nums(a,a+5);int ans=breakNum(nums);cout <<'\n'<<ans << '\n'<<endl;return 0;
}