2022-08-31-度小满笔试-后端研发-100左右
给一年的三分之二，扫个尾
总分120
15个单选/多选 4 = 60 分
三个编程 320=60
第一个暴力就能过，不知道怎么优化一下？？？
第二个dp直接暴力存储每个位置上所有可能的情况。。。空间上只存储了一行
第三个最难但是没debug一遍过的，有干扰信息。
make your choice
package main import "fmt" func main() { var a[]int b:=make([]int,0) if a==nil{ fmt.Println("a is nil") }else { fmt.Println("a is not nil") } if b==nil{ fmt.Println("b is nil") }else { fmt.Println("b is not nil") } }
输出：
a is nil b is not nil
- 输出什么？-4
a
因为返回了void说明不是构造函数
import java.io.*;
public class test
{
public static void main (String[] args) throws java.lang.Exception
{
config c=new config();
System.out.println(c.n);
}
}
class config{
String n="a ";
void config(){
this.n+="b";
}
}路由器转发IP数据包时不能修改哪个字段？？？-4
源IP、目的IP、偏移量、TTLMySQL只有满足什么联接条件才会包含在查询结果中？ -4
左联接、右联接、全链接、内联接如何开启一个线程（不记得了）
start才是真开启，run还是原线程（选错成run了-4）
...
class call{
@
...
};
callable塞 futuretask里
FutureTask ta = new call...;
ta.run();
ta.start();多选，哪个对
StringBuffer 创建的字符串是可变的
StringBuffer 可以通过capacity() 返回字符串长度
String创建的字符串是不可变的
StringBuilder创建的字符串是不可变的一个程序里有80%时间在做IO，20%在做CPU计算，现在有两个这样的程序在多线/进程下运行，CPU的利用率为？
20、48.8、59、36
别人猜的：
2个 ，20% + (1-20%)20% = 36%
三个 ，36% + (1-36%)20% = 48.8%
破坏死锁必要条件里比较容易实现的是 A
A. 破坏请求和保持
B. 破坏互斥
C. 破坏环路等待
D. 破坏不剥夺输出
package main
import "fmt"
func main() {
s:=[]string{"a","b","c","d","e"}
slice:=s[2:3:3]
slice=append(slice,"k");
fmt.Println(slice)
}c k
编程
// 度小满 2023校招 后端研发工程师在线考试 - 正式考试阶段
// 编程题|20.0分1/3
// 好的子数组的数量
// 时间限制： 3000MS
// 内存限制： 589824KB
// 题目描述：
// 现在一个数组被定义为好的，如果该数组中的最大值是最小值的k倍。
// 现在给你一个数组，你的任务是计算有多少个子数组是好的。
// 其中，子数组定义为原数组中一段连续的数组。
// 例如：[4, 3, 2, 7]有以下几个子数组：
// [4], [4, 3], [4, 3, 2], [4, 3, 2, 7], [3], [3, 2], [3, 2, 7], [2], [2, 7], [7]
// 当k = 2时，答案为1，只有[4, 3, 2]是好数组，它的最大值是4，最小值是2，满足题意。
// 1<= n, k <= 1000
// 对于全体数据都保证数组中的数字在[1, 1e9]范围内
// 输入描述
// 第一行是一个正整数n, k，表示数组长度为n，好数组中最大值是最小值的k倍。
// 第二行是n个以空格分开的正整数。依次表示这个数组中的数字。
// 输出描述
// 一行一个非负整数，表示这个数组有几个子数组是好的。
// 样例输入
// 4 2
// 4 3 2 7
// 样例输出
// 1
// 提示
// 输入样例2
// 4 3
// 3 9 3 9
// 输出样例2
// 6
// 输入样例3
// 2 1
// 2 2
// 输出样例
// 3
// 100% 20'
#include <iostream>
#include <vector>
using namespace std;
int main()
{
int n, k;
cin >> n >> k;
vector<int> a(n);
unsigned long ans = 0;
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
for (int i = 0; i < n; i++)
{
int maxV = a[i], minV = a[i];
for (int j = i; j < n; j++)
{
maxV = max(maxV, a[j]);
minV = min(minV, a[j]);
if (maxV == minV * k)
{
// ans += n - j;
// break;
ans+=1;
}
}
}
cout<<ans;
return 0;
}
// 2. 路径
// 时间限制： 3000MS
// 内存限制： 589824KB
// 题目描述：
// 现在有一个n行m列的网格图。每个格子上有一个数字，为 +k 或者 -k。
// 初始你在位于左上方的第一行第一列，你的目标是走到位于右下方的第n行第m列。
// 现在限制你每一步只能向下或者向右走。显然，你有很多种实现目标的方法。
// 现在，我们定义路径的权值和为你选定的路径上所有格子上的数字的加和。
// 我们的问题是，你能否选出一条合适的路径，使得你获得恰好为x的权值和。
// 1 <= n, m <= 10
// 对全体数据保证：1 <= T <= 5, 0 <= k <= 10, 0 <= x <= 1000000
// 输入描述
// 第一行一个正整数T，表示总共有T组数据。
// 对于每组数据：
// 第一行给出四个自然数n, m, k, x，以空格分开，表示给出的网格图是n行m列的，其中仅有+k和-k两种数字，所希望你获得的权值和为x。
// 接下来将依次给出n行，每行m个整数，表示网格中的数字。
// 输出描述
// 对每一组数据输出一行yes或no表示答案，共输出T行。
// 样例输入
// 3
// 2 4 1 2
// -1 -1 1 -1
// -1 -1 -1 -1
// 1 2 1 1
// 1 -1
// 1 3 9 9
// 9 -9 9
// 样例输出
// no
// no
// yes
// 提示
// 该样例***三组数据。
// 第一组中，通过不同的路径可以组合出-3或者-5。两者均和2不同。因此是no。
// 第二组中，仅存在一种路径，其答案为0。和所要求的1不同，因此是no。
// 第三组中，仅存在一种路径，其答案为9。和所要求的9相同。因此是yes
// 100% 20' 23min
#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;
int main()
{
int t, n, m, k, x;
cin >> t;
while (t--)
{
cin >> n >> m >> k >> x;
vector<vector<int>> a(n, vector<int>(m));
vector<unordered_set<int>> s(m);
for (int i = 0; i < n; i++)
{
for (int j = 0; j < m; j++)
{
cin >> a[i][j];
}
if (i == 0)
{
s[0].insert(a[0][0]);
for (int q = 1; q < m; q++)
{
int od = *s[q-1].begin();
s[q].insert(a[0][q] + od);
s[q].erase(od);
}
}
}
for (int i = 1; i < n; i++)
{
int od = *s[0].begin();
s[0].insert(a[i][0] + od);
s[0].erase(od);
for (int j = 1; j < m; j++)
{
unordered_set<int> usj;
for (auto &d : s[j])
usj.insert(d + a[i][j]);
for (auto &d : s[j - 1])
usj.insert(d + a[i][j]);
s[j] = move(usj);
}
}
if (s[m - 1].count(x))
cout << "yes\n";
else
cout << "no\n";
}
return 0;
}
// exDNA
// 时间限制： 3000MS
// 内存限制： 589824KB
// 题目描述：
// 科学家在外星球发现了一种全新的生物，该种生物的遗传物质与DNA类似，被称为exDNA。
// 与DNA类似，exDNA由9种碱基对依次连接而成，将这9种碱基对分别编号为1至9，则一段exDNA链可以写成一个字符串，例如：
// 137****476294518......
// 进一步研究发现，如果exDNA中存在两个相邻的1号碱基对，则该段exDNA的表征将出现问题。因此科学家将exDNA分为两类：正常exDNA和错误exDNA。正常exDNA中不含相邻的1号碱基对，错误exDNA包含至少一处相邻的1号碱基对。形式化地，设exDNA长度为n，第i个碱基对编号为ai，则当存在一个i使ai=ai+1=1(1≤i≤n-1)时，该exDNA为错误exDNA，反之为正常exDNA。
// 例如12445，2414183，1都是正常exDNA；11244，52112，67113都是错误exDNA。
// 更进一步的研究发现，exDNA在复制时可能产生复制错误，表现为相邻的两个碱基对交换位置，例如12345复制后可能得到13245。由于发生错误的可能性很低，可以认为一段exDNA在复制时至多只会发生一次复制错误。在至多产生一次复制错误的条件下，如果一段exDNA复制后得到的一定是正常exDNA，则称其为安全exDNA；如果复制后可能得到错误exDNA，则称其为不安全exDNA。
// 例如12445，1，123123都是安全exDNA，2414183，1214，311都是不安全exDNA。
// 请编写一个程序，计算有多少种不同的长度为n的安全exDNA链，结果对1000000007取模。
// 输入描述
// 输入一行，包含一个整数n，其中1≤n≤100000，表示exDNA链的长度。
// 输出描述
// 输出一行，包含一个整数，表示长度为n的安全exDNA链的种类数。
// 答案对1000000007取模。
// 样例输入
// 3
// 样例输出
// 704
// 提示
// 长度为3的exDNA链有93=729种，其中111，1x1，x11，11x (2≤x≤9)共25种为不安全exDNA。
// 一次性过 31min 100%
// 题目最后的提示有很强的干扰性。。。
#include <iostream>
#include <vector>
#include <unordered_set>
using namespace std;
int main()
{
int n;cin>>n;
if(n==1){cout<<"9";return 0;}
else if(n==2){cout<<80; return 0;}
unsigned long ans=0,errn=0;
const unsigned long e = 1000000007;
for(int i=0;i<n;i++){
ans = ans*9%e;
}
// 111 11x 1x1 x11
// xxx xx1 x1x 1xx
vector<vector<unsigned long>> dp(n+1,vector<unsigned long>(4,0LL));
dp[3][0]=8*8*8;
dp[3][1]=8*8*1;
dp[3][2]=8*1*8;
dp[3][3]=1*8*8;
for(int i=4;i<=n;i++){
dp[i][0]=(dp[i-1][0]+dp[i-1][3])*8%e;
dp[i][1]=(dp[i-1][0]+dp[i-1][3])%e;
dp[i][2]=dp[i-1][1]*8%e;
dp[i][3]=dp[i-1][2]*8%e;
}
cout<<(dp[n][0]+dp[n][1]+dp[n][2]+dp[n][3])%e;
return 0;
}#度小满校招##度小满##度小满笔试##23届秋招##23届秋招笔面经#
类似资料：