单选题
- 有土豆，萝卜各一筐，土豆有 240 个，萝卜有 313 个，把这两筐平均分给一些小朋友，一直土豆分到最后余 2 个，萝卜分到最后还余 7 个，求最多有多少个小朋友参加分水果？
- 14
- 17
- 28
- 34
题解：求（240-2=238）和（313-7=306）的最大公约数即可。
- 下面有关java内存模型的描述，说法错误的是？
- JMM通过控制主内存与每个线程的本地内存之间的交互，来为java程序员提供内存可见性保证
- “synchronized” — 保证在块开始时都同步主内存的值到工作内存，而块结束时将变量同步回主内存
- “volatile” — 保证修饰后在对变量读写前都会与主内存更新。
- 如果在一个线程构造了一个不可变对象之后（对象仅包含final字段），就可以保证了这个对象被其他线程正确的查看。
- 题解：volatile只保证可见性，不保证原子性，C正确。final只是指向不变，但是指向的值有可能变，所以依然不是线程安
- int A[3][2]={1,2,3,4,5,6};则A[2][1]和*(*(A+1)+1)的值分别是（）
- 6和4
- 5和2
- 4和6
- 2和5
- 题解：A[2][1]=6。 * A为指向头结点的指针，即A[0][0]=1；* (A+1)为行+1，即A[0][1]=2；* ( *(A+1)+1)为在A[0][1]的基础上列再+1，即A[1][1]=4。
- 如下关于进程的描述不正确的是（）
- 进程在退出时会自动关闭自己打开的所有文件
- 进程在退出时会自动关闭自己打开的网络链接
- 进程在退出时会自动销毁自己创建的所有线程
- 进程在退出时会自动销毁自己打开的共享内存
- 题解：共享内存销毁了，会对其他正在使用这段内存的进程造成破坏
- 某指令流水线由 5 段组成，各段所需要的时间分别是：t、3t、t、2t、t。问如果连续执行 10 条指令，则吞吐率是多少 ?
- 0.1428/t
- 0.2041/t
- 0.2857/t
- 0.3333/t
题解：吞吐率公式：吞吐率 = 指令条数 / 流水线时间
流水线时间公式：流水线时间 = 一条指令所需时间+（指令条数-1）* 时间最长的指令的一段
- 下列哪一个不属于关系数据库的特点？
- 数据冗余度小
- 多用户访问
- 数据独立性高
- 数据共享性好
题解：关系数据库的特点 > 1）数据集中控制 2）数据独立性高 3）数据共享性好 4）数据冗余度小。5）数据结构。6）统一的数据保护功能。
7.下列哪一条是顺序存储结构的优点是（）。 - 插入运算方便
- 删除运算方便
- 可方便地用于各种逻辑结构的存储表示
- 存储密度大
- 下面有关JSP内置对象的描述，说法错误的是？
- session对象：session对象指的是客户端与服务器的一次会话，从客户连到服务器的一个WebApplication开始，直到客户端与服务器断开连接为止
- request对象：客户端的请求信息被封装在request对象中，通过它才能了解到客户的需求，然后做出响应
- application对象：多个application对象实现了用户间数据的共享，可存放全局变量
- response对象：response对象包含了响应客户请求的有关信息
题解：application对象是共享的，多个用户共享一个，以此实现数据共享和通信。
- 设A,B,C为三个事件，且A,B相互独立，则以下结论中不正确的
- 若PC=1，则AC与BC也独立.
- 若PC=1，则A并C与B也独立.
- 若PC=0，则A并C与B也独立.
- 若C属于B，则A与C也独立.
题解：独立需要P(AC)=P(A)*P( C) 假设P：A,B,C均不为0，而A，B相交
且P(AB)=P(A)P(B),C为B中不与A相交的部分（C=B-A∩B），那么明显P(AC)=0!=P(A)P( C)
- 下面不是面向对象的基本原则的是？
- 单一职责原则（Single-Resposibility Principle）
- 开放封闭原则（Open-Closed principle）
- 抽象类原则（Abstract-Class principle）
- 依赖倒置原则（Dependecy-Inversion Principle）
- 接口隔离原则（Interface-Segregation Principle）
题解：面向对象的五大基本原则
单一职责原则（SRP）
开放封闭原则（OCP）
里氏替换原则（LSP）
依赖倒置原则（DIP）
接口隔离原则（ISP）
- 对于序列（ 12 ， 13 ， 11 ， 18 ， 60 ， 15 ， 7 ， 19 ， 25 ， 100 ），用筛选法建堆，必须从值为 ________ 的数据开始建初始堆。
- 100
- 12
- 60
- 15
题解：有n个元素的序列，若使用筛选法建堆，则从位置为n/2取下整的元素开始建堆
- 若在一分页存储管理系统中，某作业的页表如下所示。已知页面大小为 1024 字节，则逻辑地址 3000 对应的物理地址为（ ）
- 7072
- 1976
- 3000
- 3059
题解：页面大小1024.逻辑地址3000。所以3000/1024=2 也就是页号，由表可知是2号页表，对应的实际的内存地址1号块。
页表内的偏移量是3000%1024=952。因为块大小和页的大小相等，所以实际的物理地址是1*1024+952=1976
- 下面有关java classloader说法错误的是?
- Java默认提供的三个ClassLoader是BootStrap ClassLoader，Extension ClassLoader，App ClassLoader
- ClassLoader使用的是双亲委托模型来搜索类的
- JVM在判定两个class是否相同时，只用判断类名相同即可，和类加载器无关
- ClassLoader就是用来动态加载class文件到内存当中用的
题解： JVM在判定两个class是否相同时，不仅要判断两个类名是否相同，而且要判断是否由同一个类加载器实例加载的。
14.某盒中有 5 件产品，其中 2 件次品 . 现随机地从中 2 件，则 2 件中次品数的均值是（ ） - 1/5
- 4/5
- 3/5
- 3/10
题解：
- 采用计数排序算法对数组A={1,0,3,1,0,1}进行排序，则辅助数组C的长度值为（）
- 4
- 7
- 5
- 6
题解：辅助数组的范围要涵盖待排序列中所有的值，长度取决于待排序列中最大值和最小值，数组A中最小值是0，最大值是3，所以辅助数组C应该是从0到3，长度为4。
- TELNET工作于( )
- 网络层
- 传输层
- 会话层
- 表示层
- 应用层
题解：
- 一个递归算法必须包括（）
- 递归部分
- 终止条件和递归部分
- 迭代部分
- 终止条件和迭代部分
- 若要求在 O( nlog2n ) 的时间内完成对数组的排序，且要求排序是稳定的，则可选择的 排序方法是（ ）
- 快速排序
- 堆排序
- 归并排序
- 直接插入排序
- 以下程序的运行结果是
public class Increment{
public static void main(String args[]) {
int a;
a = 6;
System.out.print(a);
System.out.print(a++);
System.out.print(a);
}
}
- 666
- 667
- 677
- 676
题解：a++很好记的，表示先用后+，而++a表示先+后用。看+在前在后，也决定第一步。
- 若对n阶对称矩阵A(下标从1,1开始）以行序为主序方式将其下三角形的元素(包括主对角线上所有元素)依次存放于一维数组B[1…(n(n+1))/2]中,则在B中确定aij (i<j)的位置k的关系为()
- i*(i-1)/2+j
- j*(j-1)/2+i
- i*(i+1)/2+j
- j*(j+1)/2+i
题解：将对称矩阵中的n^2个元压缩存储在n(n+1)/2个元素的一维数组中，以行序为主序存储其下三角（包括对角线）中的元，假设一维数组sa[n(n+1)/2]作为n阶对称矩阵A的存储结构，则sa[k]和矩阵元素a[i,j]之间存在着一一对应的关系：
当i>=j时，k=i(i-1)/2+j-1;
当i<j时， k=j(j-1)/2+i-1;
编程题
-
牛家庄幼儿园为庆祝61儿童节举办庆祝活动,庆祝活动中有一个节目是小朋友们围成一个圆圈跳舞。牛老师挑选出n个小朋友参与跳舞节目,已知每个小朋友的身高h_i。为了让舞蹈看起来和谐,牛老师需要让跳舞的圆圈队形中相邻小朋友的身高差的最大值最小,牛老师犯了难,希望你能帮帮他。
如样例所示:
当圆圈队伍按照100,98,103,105顺时针排列的时候最大身高差为5,其他排列不会得到更优的解
输入描述：
输入包括两行,第一行为一个正整数n(3 ≤ n ≤ 20)
第二行为n个整数h_i(80 ≤ h_i ≤ 140),表示每个小朋友的身高。
示例1
输入
4
100 103 98 105
输出
5
来自 追梦者_AIer
import java.util.Arrays;
import java.util.Scanner;
/*
* 考虑我们已经将身高升序排序了,然后对于前k个小朋友组成队形的身高差的最大值的最小值为f(k),
* 并且第k个和第(k-1)个小朋友是相邻的。现在我们加入第(k+1)个小朋友,
* 考虑到第(k + 1)个小朋友身高是大于等于前面的小朋友,
* 插入队形之后,第(k + 1)个小朋友一定与两个小朋友相邻,
* 所以当我们将第(k + 1)个小朋友插入到第k个和第(k - 1)个小朋友中间可以得到f(k + 1)
* 的下界一定是max(f(k), h[k] - k[k - 2]),
* 我们又注意到这样插入之后第(k + 1)个和第k个小朋友还是相邻的,于是这样可以一直推广下去。
* 考虑最初3个小朋友的时候这样也是可行的, 于是问题变成了求max(h[i] - h[i - 2])。
*/
public class Main {
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int N = in.nextInt();
int[] num = new int[N];
for(int i = 0 ; i < N ; i++){
num[i] = in.nextInt();
}
Arrays.sort(num);
int min = 0;
for(int i = 2 ; i < N ; i++){
min = Math.max(min,num[i]-num[i-2]);
}
System.out.print(min);
in.close();
}
}
-
有一条无限长的纸带,分割成一系列的格子,最开始所有格子初始是白色。现在在一个格子上放上一个萌萌的机器人(放上的这个格子也会被染红),机器人一旦走到某个格子上,就会把这个格子涂成红色。现在给出一个整数n,机器人现在会在纸带上走n步。每一步,机器人都会向左或者向右走一个格子,两种情况概率相等。机器人做出的所有随机选择都是独立的。现在需要计算出最后纸带上红色格子的期望值。
输入描述:
输入包括一个整数n(0 ≤ n ≤ 500),即机器人行走的步数。
输出描述:
输出一个实数,表示红色格子的期望个数,保留一位小数。
示例1
输入
4
输出
3.4
//思路：利用三维数组
// dp[i%2][j][k]表示走了i步之后恰好有j个红色格子，并且此时机器人正好在第k个红色格子上的概率。时间复杂度O(n^3)
// 只使用i%2的原因是，现在只和前一个情况有关
import java.text.DecimalFormat;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
int maxn = 500+5;
double[][][] dp = new double[2][maxn][maxn];
Scanner in = new Scanner(System.in);
int n = in.nextInt(); // 走的步数
double ans = 0;
dp[0][1][0] = 1.0; // 第0步，有一个红格子，在第0个红格子上,的概率为1
for(int i=1;i<=n;i++){
int cur = i%2; // 0,1,0,1...
int old = 1-(i%2);
for(int j=1;j<=i;j++) // 现在是第n次，则第n-1次最多是有n个格子
for(int k=0;k<j;k++)
dp[cur][j][k]=0; // 前前次的结果设为0
//
for(int j=1;j<=i;j++){
// 第i步的红色格子数目至多为i个
for(int k=0;k<j;k++){
//
if(dp[old][j][k]>0){
// 往右走
int pos1 = j; // 现在有的格子数
int pos2 = k+1; // 现在的位置是在k+1
if(pos1==pos2) // 在有边界的条件，接下来右边会多一个空格的可能。k=j-1时。
++pos1; // 多一个空格
dp[cur][pos1][pos2]+=0.5*dp[old][j][k];
// 往左走
int pos3 = j;
int pos4 = k-1;
if(pos4==-1){
// 边界条件，在位置-1的时候
pos3++; // 格子数增加1
pos4++; // 把-1的那个格子记为第0个格子~
}
dp[cur][pos3][pos4]+=0.5*dp[old][j][k];
}
}
}
}
// 知道概率以后求期望
for(int i=1;i<=n+1;i++){
// 走n步，至多有n+1个格子
for(int j=0;j<i;j++){
// 在第j个格子上
ans+=i*dp[n%2][i][j];
}
}
DecimalFormat f = new DecimalFormat("0.0");
System.out.print(f.format(ans));
}
}
-
牛牛在农场饲养了n只奶牛,依次编号为0到n-1, 牛牛的好朋友羊羊帮牛牛照看着农场.有一天羊羊看到农场中逃走了k只奶牛,但是他只会告诉牛牛逃走的k只奶牛的编号之和能被n整除。你现在需要帮牛牛计算有多少种不同的逃走的奶牛群。因为结果可能很大,输出结果对1,000,000,007取模。
例如n = 7 k = 4:
7只奶牛依次编号为0到6, 逃走了4只
编号和为7的有:{0, 1, 2, 4}
编号和为14的有:{0, 3, 5, 6}, {1, 2, 5, 6}, {1, 3, 4, 6},{2, 3, 4, 5}
4只牛的编号和不会大于18,所以输出5.
输入描述:
输入包括一行,两个整数n和k(1 ≤ n ≤ 1000),(1 ≤ k ≤ 50),以空格分割。
输出描述:
输出一个整数表示题设所求的种数。
示例1
输入
7 4
输出
5
import java.util.Scanner;
public class Main {
private static final int mod = 1000_000_007;
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int k = sc.nextInt();
System.out.println(escapeFarm(n, k));
}
/**
* 从0~n-1的n个数中，取出k个
* @param n n个数
* @param k 取出k个
* @return 组合数
*/
public static int escapeFarm(int n, int k) {
int[][] dp = new int[k+1][n]; //状态转移矩阵
//初始赋值 ,i = 0时， 存在1个数，选出0个，余n为0,选出1个，余n为0，有1个
dp[0][0] = dp[1][0] = 1;
for (int i = 1; i < n; i++) {
//i 从1到n-1，算到n-1即为0~n-1中，选出k个数，其和余n为0
// for (int j = 1; j <= Math.min(i+1, k); j++) { //最少选1个数，最多选k个数
for (int j = Math.min(i+1, k); j > 0; j--) {
//这个地方必须要倒序，因为j与j-1的值相关，即计算j时，j-1的值不能改变
for (int l = 0; l < n; l++) {
dp[j][l] =(dp[j][l] + dp[j-1][(l-i+n)%n])%mod;
}
}
}
return dp[k][0];
}
}