题目
一、单选题
B: h(K)=1;
C: h(K)=K mod N;
D: h(K)=(K+rand(N)) mod N, rand(N)返回0到N-1的整数
A: 堆排序 B：插入排序
C: 冒泡排序 D:快速排序
A: CISC计算机比RISC计算机指令多
B: 在指令格式中，采用扩展操作码设计方案的目的是为了保持指令字长不变而增加寻址空间
C:增加流水线段数理论上可以提高CPU频率
D:冯诺依曼体系结构的主要特征是存储程序的工作方式
A:CPU B: Cache C:RAM D:ROM
A:DECBA B:DCEBA C:ECDBA D:ABCDE
A：汇编 B:C语言 C:VB D:以上全可以
A：static成员变量在对象构造时候生成
B: static成员函数在对象成员函数中无法调用
C: 虚成员函数不可能是static成员函数
D: static成员函数不能访问static成员变量
A: 从就绪变为运行 B:从运行变为就绪
C: 从运行变为阻塞 D:从阻塞变为就绪
Int f(unsigned int n)
{
If(n==0||n==1)
Return 1;
Else
Return n*f(n-1);
}
A: O(1) B:O(n) C:O(N*N) D:O(n!)
A:18 B:24 C:21 D；不可能
直接进行计算，奇数减1除2，偶数直接除以2，2013>1006>503>251>125>62>31>15>7>3>1
再反过来计算从1到2013的次数，为18次
- #include <stdio.h>
- #include <stdlib.h>
- #define FINAL 2013
- #define MAX 25
- typedef struct num {
- int d, time;
- } num;
- typedef struct queue {
- int front, rear, count;
- num data[10000000];
- } queue;
- void enQueue(queue *q, num d)
- {
- q->data[q->rear ++] = d;
- q->count ++;
- }
- num deQueue(queue *q)
- {
- num res;
- res = q->data[q->front ++];
- q->count --;
- return res;
- }
- int main(void)
- {
- int flag = 0;
- num bt, one, two, s;
- bt.d = 2;
- bt.time = 1;
- queue *q = (queue *)malloc(sizeof(queue));
- q->front = q->rear = q->count = 0;
- enQueue(q, bt);
- while (q->count > 0) {
- s = deQueue(q);
- if (s.d == FINAL) {
- flag = 1;
- printf("%d\n", s.time);
- break;
- }
- one.d = s.d + 1;
- one.time = s.time + 1;
- if (one.d <= FINAL && one.time <= MAX) {
- enQueue(q, one);
- }
- two.d = s.d * 2;
- two.time = s.time + 1;
- if (two.d <= FINAL && two.time <= MAX) {
- enQueue(q, two);
- }
- printf("%d\n", q->count);
- }
- if (flag == 0)
- printf("不可能!\n");
- return 0;
- }
* 程序功能：n从1开始，每个操作可以选择对n加1或者对n加倍。若想获得整数2013，最少需要多少个操作。
* 输入：整数n,
输出：按上述操作获得n需要的操作个数
* 思路：从输入的整数n开始，若n为奇数，则减1，操作次数加1；否则n减半，操作次数加1.
* 测试例子：op(2013)
* 测试输出：18
* 创 建：2014/3/30
************************************************************************/
#include<cassert>
int op(int n)
{
assert( n>0 );
int time = 0;
if(1 == n)
time = 0;
else
{
if( n & 0x1 == 1)//n是奇数
{
n = n-1;
time += 1;//操作次数+1
}
time += op( n >> 1 ) ;//加上除2后的操作次数
time += 1 ; //除2，操作次数+1
}
return time;
}
/************************************************************************
* 程序功能：n从1开始，每个操作可以选择对n加1或者对n加倍。若想获得整数2013，最少需要多少个操作。
* 输入：整数FINAL,
输出：按上述操作获得n需要的操作个数
* 思路：1、一个新数据结构num,num.d表示当前到达的数，num.time表示到达数的操作次数；辅助结构：队列
2、声明两个变量num one,two,初始数均为2，对应的操作次数为1；
3、one.d加1，one.time加1，当one.d<=FINAL时one进栈，否则输出；
two.d*2，two.time加1，当two.d<=FINAL时two进栈，否则输出；
4、当队列非空时出队列，转入3。
* 测试例子：op(2013)
* 测试输出：18
* 创 建：2014/3/30
************************************************************************/
/******************模拟栈******************/
typedef struct num {
int d;
int time;
} num;
typedef struct queue {
int front, rear, count;
num data[10000000];
} queue;
void enQueue(queue *q, num d)
{
q->data[q->rear ++] = d;
q->count ++;
}
num deQueue(queue *q)
{
num res;
res = q->data[q->front ++];
q->count --;
return res;
}
/*************************************/
void op2 (int FINAL)
{
assert(FINAL>1);
int flag = 0; //结束标志，flag=1,表示增长到输入数FINAL
num bt, one, two, s;
bt.d = 2;//起点从数2开始
bt.time = 1; //2变成1仅需要操作一次
queue *q = (queue *)malloc(sizeof(queue));
q->front = q->rear = q->count = 0;
enQueue(q, bt);
while (q->count > 0)
{
s = deQueue(q);
if (s.d == FINAL)
{ //到达输入的整数FINAL
flag = 1;
printf("%d\n", s.time);
break;
}
one.d = s.d + 1;
one.time = s.time + 1;
if (one.d <= FINAL )
enQueue(q, one);
two.d = s.d * 2;
two.time = s.time + 1;
if (two.d <= FINAL )
enQueue(q, two);
// printf("%d\n", q->count);
}
if (flag == 0)
{
printf("不可能!\n");
}
}
A: n B: n+1 C: n-1 D:n+边数
Int foo(int x)
{
Return x&-x;
}
A： 0 B: 1 C:2 D:4
A: O(n),O(n) B:O(n),O(1) C:O(1),O(n) D:O(n),O(n)
Struct A
{
int a;
short b;
int c;
char d;
};
Struct B
{
int a;
short b;
char c;
int d;
};
A: 16,16 B:13,12 C:16,12 D:11,16
A: 颜色全相同 B:颜色全不相同C:颜色不完全相同 D:颜色无红色
A: 每张牌出现在n个位置上的概率相等
B: 每张牌出现在n个位置上的概率独立
C: 任何连续位置上的两张牌的内容独立
D: n张牌的任何两个不同排列出现的概率相等
* 程序功能：n个数存入数组，模拟洗牌
* 输入：整数数组arr[],数组大小N
输出：一次洗牌操作
* 创 建：2014/3/30
* 说 明：此实现依据《STL源码剖析》random_shuffle的实现
* 思 路：每次迭代中arr[i]与arr[0]~arr[i]的一个随机数交换
* 测 试：int a[]={1,2,3,4,5,6,7};
int N=sizeof(a)/sizeof(a[0]);
shuffleArray_STL(a,N);
************************************************************************/
void shuffleArray_STL(int arr[],int N)//《STL源码剖析》random_shuffle的C++实现
{
int i, loc, tmp;
time_t t;
srand((unsigned int)time(&t));
// 洗牌算法
for (i = 1; i < N; i ++) {
loc = rand() % (i + 1); //或者加上 if( loc != i )
tmp = arr[loc];
arr[loc] = arr[i];
arr[i] = tmp;
}
for (i = 0; i < N; i ++)
printf("%d ", arr[i]);
printf("\n");
}
/************************************************************************
* 程序功能：n个数存入数组，模拟洗牌
* 输入：整数数组arr[],数组大小N
输出：一次洗牌操作
* 创 建：2014/3/30
* 说 明：此实现依据《算法导论》5.3节的均匀随机排列，每个排列出现的概率1/n!
* 思 路：每次迭代中arr[i]与arr[i]~arr[N-1]的一个随机数交换,这样第i次迭代后，arr[i]保持不变
int a[]={1,2,3,4,5,6,7};
int N=sizeof(a)/sizeof(a[0]);
shuffleArray_introductionOfAlgorithms(a,N);
************************************************************************/
int rand_ab(int a,int b)//均匀随机生成[a,b]内的一个数
{
time_t t;
srand((unsigned int)time(&t));
return ( a + rand() % ( b-a+1 ) );
}
void shuffleArray_introductionOfAlgorithms(int arr[],int N)
{
int i, loc, tmp;
time_t t;
srand((unsigned int)time(&t));
// 洗牌算法
for (i = 0; i < N; i ++) {
loc = rand_ab(i,N-1); //arr[i]<---->arr[i]~arr[N-1],第i次迭代后，arr[i]保持不变
tmp = arr[loc];
arr[loc] = arr[i];
arr[i] = tmp;
}
for (i = 0; i < N; i ++)
printf("%d ", arr[i]);
printf("\n");
}
A: 10 B:11 C:14: D:15
答案共14种
分析：题目意思是说旋转后相同的颜色排布算一种。相当于棋子没有区别，只有位置的相对关系。
设两种颜色为黑白
全黑1种+全白1种=2
1黑5白（1种）+1白5黑（1种）=2种
2黑4白(2个黑的可以紧挨着，2个黑的中间隔1个棋子，两个黑的中间隔2个棋子）共3种
4黑2白同2黑4白对称：3种
3黑3白：3个黑的连在一起（1种），3个黑的任意两个之间不相邻（1种），3个黑的有两个挨着，另外一个与这两个棋子都不相邻（2种）
共4种
特别是另外一个与这两个棋子都不相邻的情况，有两种，刚开始以为是对称的算一种了，而实际上是两种，因为这种通过旋转是转不到一样的。
所以总共有2+2+3+3+4=14种
A: O(n) B:O(d) C:O(logn) D:(nlogn)
二、多选题
X和y是全局变量，初始为0。以下哪一个是r1和r2的可能值：
A: r1=1,r2=1
B: r1=1,r2=0
C:r1=0,r2=0
D:r1=0,r2=1
A: 通过就绪和运行的进程数来反映
B: 通过TOP命令查看
C: 通过uptime查看
D: Load:2.5,1.3,1.1表示系统的负载压力在逐渐变小
A: 快速排序的平均时间复杂度O(nlogn),最坏O(N^2)
B:堆排序平均时间复杂度O(nlogn)，最坏O(nlogn)
C:冒泡排序平均时间复杂度O(n^2),最坏O(n^2)
D:归并排序的平均时间复杂度O(nlogn),最坏O(n^2)
A:rand_3 B:rand_21 C:rand_23 D:rand_49
填空和问答
出现缓存直接命中的次数为：（），最后缓存即将淘汰的是（）
hash(key) = key % N
分析：一次划分中，某方可以有1人，另一方有4人或某方有2人，另一人有3人。
要使任意两个人之间有一场红方对蓝方和蓝方对红方的比赛，假设5个同学为A,B,C,D,E，相当有有向图的5个节点，任意两个节点间有两个方向的边连接。
即总的节点关系有(5个节点中选取两个节点)A(5,2)=5*4=20个关系。
而一次比赛（一次划分）能够生成的关系(一方两人一方三人的划分)c(2,1)*c(3,1)=2*3=6或者（一方四人一方一人的划分)c(4,1)*(c(1,1)=4*1=4,
所以一场比赛(一次划分)最多生成的关系次数为6
所以需要20/6=3.33..即至少需要4场比赛
扩展：此题亦可求至多需要多少场比赛，才能使得任意两个人之间有一场红方对蓝方和蓝方对红方的比赛？
需要20/4=5
对问题的补充：
其他题目：
写一个程序, 要求功能：求出用1，2，5这三个数不同个数组合的和为100的组合个数。
如：100个1是一个组合，5个1加19个5是一个组合。。。。 请用C++语言写。
方法一三个for循环
方法二：转载自：http://blog.csdn.net/yuucyf/article/details/6679149
由题知：假设X为1的个数，Y为2的个数，Z为5的个数，那么满足X+2*Y+5*Z = 100
所以X+5*Z = 100 - 2*Y，很明显X+5*Z是一个偶数，并且Z是<=20的，那么对Z做循环
Z=0, X=100,98,...,0
Z=1,X=95,93,...,1
Z=2,X=90,88,...0
.
.
.
Z=19,X=5,3,1
Z=20,X=0
所以结果只要求出100以内的偶数，95以内的奇数...最后是5以内的奇数再加一次就行了
对于一个奇数N求0到N之间的奇数个数为N/2+1，同样的偶数个数为N/2+1
代码如下：
- int Sum_Combination1(int nSum)
- {
- int nCnt = 0;
- for (int i32I = 0; i32I <= nSum; i32I += 5)
- {
- nCnt += (i32I + 2)/2;
- }
- return nCnt;
- }
将二叉树的两个孩子换位置，即左变右，右变左。不能用递规
解决方案：
1）根结点入队列
2）取队首元素并出列，并将该元素左右儿子进行交换
3）如果队列不为空则跳到步骤2
#include <cstdio> #include <cstring> #include <cstdlib> #include <queue> using namespace std; struct tree{ tree *right; tree *left; }*list; void solve(tree *list){ queue <tree*> Q; Q.push(list); while(!Q.empty()){ tree *tmp = Q.front(); Q.pop(); swap(tmp->right, tmp->left); if(tmp->right != NULL) Q.push(tmp->right); if(tmp->left != NULL) Q.push(tmp->left); } }
38头牛中选出3头跑得最快的，使用一个每次只能供6头比赛的场地，要求用最快的方法
解决方案：
38只取6只一组，6*6，取前3名，得3*6+2=20，用了6次
20只取5只一组，取前3名，得到3*4=12，用了4次
12只分两组取前3名，得3*2=6，用了2次
最后再加1次
累计13次
O(logn)求Fibonacci数列
解决方案：
（转）
下面介绍一种时间复杂度是O(logn)的方法。在介绍这种方法之前，先介绍一个数学公式：
{f(n), f(n-1), f(n-1), f(n-2)} ={1, 1, 1,0}n-1
(注：{f(n+1), f(n), f(n), f(n-1)}表示一个矩阵。在矩阵中第一行第一列是f(n+1)，第一行第二列是f(n)，第二行第一列是f(n)，第二行第二列是f(n-1)。)即：
[ f(n), f(n-1)
f(n-1), f(n-2)] =
有了这个公式，要求得f(n)，我们只需要求得矩阵{1, 1, 1,0}的n-1次方，因为矩阵{1, 1, 1,0}的n-1次方的结果的第一行第一列就是f(n)。这个数学公式用数学归纳法不难证明。感兴趣的朋友不妨自己证明一下。
现在的问题转换为求矩阵{1, 1, 1, 0}的乘方。如果简单第从0开始循环，n次方将需要n次运算，并不比前面的方法要快。但我们可以考虑乘方的如下性质：
/ an/2*an/2 n为偶数时
an=
\ a(n-1)/2*a(n-1)/2 n为奇数时
要求得n次方，我们先求得n/2次方，再把n/2的结果平方一下。如果把求n次方的问题看成一个大问题，把求n/2看成一个较小的问题。这种把大问题分解成一个或多个小问题的思路我们称之为分治法。这样求n次方就只需要logn次运算了。
实现这种方式时，首先需要定义一个2×2的矩阵，并且定义好矩阵的乘法以及乘方运算。当这些运算定义好了之后，剩下的事情就变得非常简单。完整的实现代码如下所示。
/************************************************************************
* 程序功能：O(logn)求Fibonacci数列
* 思 路：下面介绍一种时间复杂度是O(logn)的方法。在介绍这种方法之前，先介绍一个数学公式：
{f(n), f(n-1), f(n-1), f(n-2)} ={1, 1, 1,0}n-1
(注：{f(n+1), f(n), f(n), f(n-1)}表示一个矩阵。在矩阵中第一行第一列是f(n+1)，第一行第二列是f(n)，第二行第一列是f(n)，第二行第二列是f(n-1)。)
有了这个公式，要求得f(n)，我们只需要求得矩阵{1, 1, 1,0}的n-1次方，因为矩阵{1, 1, 1,0}的n-1次方的结果的第一行第一列就是f(n)。
这个数学公式用数学归纳法不难证明。感兴趣的朋友不妨自己证明一下。
现在的问题转换为求矩阵{1, 1, 1, 0}的乘方。如果简单第从0开始循环，n次方将需要n次运算，并不比前面的方法要快。但我们可以考虑乘方的如下性质：
/ an/2*an/2 n为偶数时
an=
\ a(n-1)/2*a(n-1)/2 n为奇数时
要求得n次方，我们先求得n/2次方，再把n/2的结果平方一下。如果把求n次方的问题看成一个大问题，
把求n/2看成一个较小的问题。这种把大问题分解成一个或多个小问题的思路我们称之为分治法。这样求n次方就只需要logn次运算了。
* 输 入：待求的第n个斐波那契数
* 输 出：第第n个斐波那契数
* 说 明：第n个数： 1 2 3 4 5 6 7 8 ...
斐波那契： 1 2 3 5 8 13
* 调 用：cout<<matrixpower(6).m_00<<endl;
************************************************************************/
struct matrix2by2{
matrix2by2(
long m00 = 0,
long m01 = 0,
long m10 = 0,
long m11 = 0
)
:m_00(m00), m_01(m01), m_10(m10), m_11(m11){}
long m_00;
long m_01;
long m_10;
long m_11;
};
matrix2by2 matrixmultiply(const matrix2by2 &a, const matrix2by2 &b){
return matrix2by2(
a.m_00 * b.m_00 + a.m_01 * b.m_10,
a.m_00 * b.m_01 + a.m_01 * b.m_11,
a.m_10 * b.m_00 + a.m_11 * b.m_10,
a.m_10 * b.m_01 + a.m_11 * b.m_11
);
}
matrix2by2 matrixpower(int n){
matrix2by2 matrix;
if(n == 1)
matrix = matrix2by2(1, 1, 1, 0);
else if(n % 2 == 0){
matrix = matrixpower(n/2);
matrix = matrixmultiply(matrix, matrix);
}
else if(n % 2 == 1){
matrix = matrixpower((n-1)/2);
matrix = matrixmultiply(matrix, matrix);
matrix = matrixmultiply(matrix, matrix2by2(1, 1, 1, 0));
}
return matrix;
}
//更简明的实现
// * 调 用：cout<<power(6).a[0][0]<<endl;
struct matrix //定义2*2的矩阵
{
int a[2][2];
matrix(int aa,int b,int c,int d)
{
a[0][0] = aa;
a[0][1] = b;
a[1][0] = c;
a[1][1] = d;
}
matrix(){};
};
matrix mul(matrix& x,matrix& y) // 矩阵乘法 x = x*y
{
return matrix(x.a[0][0]*y.a[0][0] + x.a[0][1]*y.a[1][0],
x.a[0][0]*y.a[0][1] + x.a[0][1]*y.a[1][1],
x.a[1][0]*y.a[0][0] + x.a[1][1]*y.a[1][0],
x.a[1][0]*y.a[0][1] + x.a[1][1]*y.a[1][1] );
}
matrix power(int n){
matrix mat;
if(n == 1)
mat = matrix(1, 1, 1, 0);
else if(n % 2 == 0){
mat = power(n/2);
mat = mul(mat, mat);
}
else if(n % 2 == 1){
mat = power((n-1)/2);
mat = mul(mat, mat);
mat = mul(mat, matrix(1, 1, 1, 0));
}
return mat;
}
//非递归实现
// * 调 用：cout<<power2(6).a[0][0]<<endl;
matrix power2(int n)
{
//非递归代码：
if(n == 1)
return matrix(1, 1, 1, 0);
matrix result ;
matrix base (1,1,1,0);
bool flag=false;
if(n&1) flag=true;
n = n >> 1;
result = base;
while(n)
{
base = mul(base, base);
if( (n&1) && (n != 1) )
{
base = mul(result, base);
}
n = n >> 1;
}
if(true == flag)
result = mul(result, base);
else
result = base;
return result;
}
To speed up data access , we build cache system. In one system , The L1 cache access time is 5 ns , the L2 cache access time is 50 ns and the memory access time is 400 ns. The L1 cache miss rate is 50% , the L2 cache miss rate is 10%. The average data access time of this system is:(5 Points)
自己的答案：
average data access time=P1*5+(1-P1)*[P2*(5+50)+(1-P2)*(5+50+400)]
其中，P1=50%,P2=(1-10%)
定义一个二进制数字串的“长度”为从最右侧开始算起连续1的个数（说明，如果最右侧为0，则长度为0，如果最右侧为1，则开始数连续的1的个数作为长度）。例如length(100011)=2,length(100000)=0,请分析一个随机的N位字串的“长度”的期望值是多少
注意这个长度是从最右侧算起的，比如length(111011)=2,即使，字符串左边出现更长的长度
解答：
长度： 0 1 2 3 4 ... n-1 n
概率 P0 P1 P2 ..... P(n-1) Pn
求P0，只需要从右到左的第1个位置为0即可，即P0=2^(n-1)/2^n
求P1,只需要从右到左的第1个位置为1,第2个位置为0即可，即P1=2^(n-2)/2^n
同理可求其他的概率
期望值E=0*P0+1*P1+2*P2+...n*Pn
以下题目转载自：http://blog.csdn.net/zhanglei0107/article/details/11856777
某公司的销售专家需要拜访商家，假设本市总共有M家商家，某公司派了N位销售专家来拜访本市的商家。假设专家之间互不通信，每位专家随机选择K个商家。如果有多位专家拜访了一个商家，我们称之为拜访碰撞。问发生拜访碰撞的概率是多少?
特别情况：当K=1时
有3种规格的糖果，分别为每包6颗，每包9颗，每包140颗，如果需要8颗的话，就要对糖果进行拆包。当所需的糖果数字N>=某个数量时
，糖果便不需要进行拆包，问N的值为多少
分析6=3*2,9=3*3，6和9均为3的倍数，而任意因子个2和3的组合可以组成2,3,4,5,6,7..（即>=2的任意整数），所以
6和9的组合可以表示>=6的3的倍数。而140%3=2（取模运算).。所以140+6=146可以用6,9,140的组合表示。
即可以表示>=146（即140+3*n,n>=2)对3求模余2的所有的数，所有数对3求模要么余0（已经可以表示3的倍数），要么余1，要么余2(余2的>=146的数已经可以表示)
要对3求模余1可以使140翻倍至280。280对3求模便余1，说明140的2倍已经可以表示对3求模余1的数。那么280+3*n的组合(3n>=6)便可以表示
(即>=286的数),这样所有的数已经可以表示。是不是答案就是286呢，答曰不是的。
因为285可以被3整除，284对3求模余2且>146，所有284便是答案
此题的解法用了取模的思想。所有的整数数对某个数k取模要么为0，1,2,3，...k-1。只要能覆盖着k种情况，便可以表示所有的整数
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
