代码改变世界

MTK笔试面试题集锦

2012-08-23 14:47  javaspring  阅读(636)  评论(0)  编辑  收藏  举报

1，若有  unsigned char *p1; 

  unsigned long *p2;

  p1=(unsigned char *)0x1000; 

  p2=(unsigned long *)0x2000; 

请问  p1+5=();p2+5=()

上面的p1与p2指向两个十六进制地址，所以：

p1+5=(unsignedchar *)0x1101;

p2+5=(unsignedchar *)0x2005；

下面介绍一下计算机进制之间转换的方法：

一、二进制转换十进制
例：二进制 “1101100”
1101100 ←二进制数
6543210 ←排位方法

例如二进制换算十进制的算法:
1*26 + 1*25 + 0*24 + 1*23 + 1* 22+ 0*21 + 0*20
↑ ↑
说明：2代表进制，后面的数是次方（从右往左数，以0开始）
=64+32+0+8+4+0+0
=108

二、二进制换算八进制
例：二进制的“10110111011”
换八进制时，从右到左，三位一组，不够补0，即成了：
010 110 111 011
然后每组中的3个数分别对应4、2、1的状态，然后将为状态为1的相加，如：
010 = 2
110 = 4+2 = 6
111 = 4+2+1 = 7
011 = 2+1 = 3
结果为：2673

三、二进制转换十六进制
十六进制换二进制的方法也类似，只要每组4位，分别对应8、4、2、1就行了，如分解为：
0101 1011 1011
运算为：
0101 = 4+1 = 5
1011 = 8+2+1 = 11（由于10为A，所以11即B）
1011 = 8+2+1 = 11（由于10为A，所以11即B）
结果为：5BB

四、二进制数转换为十进制数
二进制数第0位的权值是2的0次方，第1位的权值是2的1次方……
所以，设有一个二进制数：0110 0100，转换为10进制为：
计算： 0 * 20 + 0 * 21 + 1 * 22 + 0 * 23+ 0 * 24 + 1 * 25 + 1 * 26 + 0 * 27= 100

五、八进制数转换为十进制数
八进制就是逢8进1。
八进制数采用 0～7这八数来表达一个数。
八进制数第0位的权值为8的0次方，第1位权值为8的1次方，第2位权值为8的2次方……
所以，设有一个八进制数：1507，转换为十进制为：
计算： 7 * 80 + 0 * 81 + 5 * 82 + 1 * 83= 839
结果是，八进制数 1507 转换成十进制数为 839
六、十六进制转换十进制
例：2AF5换算成10进制
直接计算就是： 5 * 160 + F * 161 + A * 162 + 2 *163 = 10997
(别忘了，在上面的计算中，A表示10，而F表示15)、
现在可以看出，所有进制换算成10进制，关键在于各自的权值不同。
假设有人问你，十进数 1234 为什么是一千二百三十四？你尽可以给他这么一个算式： 1234 = 1 * 103 + 2 * 102 + 3 * 101+ 4 * 100

2，用一个表达式得出整型变量a是否为2 的整数次幂，不能用循环，表达式最终值是布尔型；

((x&(x-1))==0)&&(x!=0);

关于这道题请参加本博文中的C位运算符-经典应用总结一文，中又详细的介绍

3，已知一链表（pHead指向表头），此链表的节点的结构为：

  typedef struct Link 

  {

  int data; 

  struct Link *next; 

  } Link; 

  链表中是可能有环（即链尾next指针可能指向链表任意节点，不一定大于NULL），编写函数统计链表节点数目，返回节点数目；

 函数原型：  int CountLinkNodes(Link*pHead) 

思路:1. 用两个指针p1,p2指向头节点,p1每次走一步,p2每次走两步,若果p2为空，说明无环，否则直到p1==p2结束循环;

2.如果无环，则输出len，有环则先计算环的长度;

3.再计算进入环之前的结点个数，最后的len就是所求；

完整实现代码：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef struct Link  { 
  int data;  
  struct Link *next;  
} Link;  

int CountLinkNodes(Link *pHead){
   assert(pHead!=NULL);
   int len = 0;
   Link* p1 = pHead->next;
   Link* p2 = pHead->next;
   while(p2){
	   p2 = p2->next;
	   len++;
	   if(!p2)
		   break;
	   p2 = p2->next;
	   len++;
	   p1 = p1->next;
	   if(p1==p2){
		   break;
	   }
   }
if(p2){
	p2 = p2->next;
	len=1;
   while(p2!=p1){
	   p2=p2->next;
	   len++;
   }
   p1 = pHead->next;
   while(p2!=p1){
	   p2 = p2->next;
	   p1 = p1->next;
	   len++;
   }
}
   return len;
}

void createList(Link** L,int n,int pos){
	*L=(Link*)malloc(sizeof(Link));
	Link* r = (*L);
	for(int i=n;i>0;--i){
		Link* p = (Link*)malloc(sizeof(Link));
		p->data = i;
		r->next = p;
		r = p;
	}
	Link* p =(*L);
	if(!pos)
		r->next = NULL;
	else{
	    for(;pos>0;--pos)
	     	p = p->next;
	    r->next =p;
	}
}
int main(){
	Link* L = NULL;
	createList(&L,8,3);
	int res = CountLinkNodes(L);
	printf("%d\n",res);
	Link* p=L;
	for(res;res>0;--res){
		Link* temp = p->next;
		free(p);
		p = temp;
	}
}

4，求组合数：求n个数中K个数的组合，假设函数原型为  intcombination （int n,int k ）,其中  n 的范围为  1 ……n, 

  例如：combination（5 ，3 ）  要求输出：543、542 、541 、531 、532 、521 、432 、431 、421 、321 如果输出时有用到数组，其空间需要在开始动态分配好，结束时释放。

本题解法较多，大家可以参看

http://hi.baidu.com/%D7%D4%D3%C9%B5%C6%CB%FE/blog/item/d6310e6e2ffb2edd80cb4a48.html

一文已经介绍得很详细了。

下面我们介绍回溯法：

采用回溯法找问题的解，将找到的组合以从小到大顺序存于a[0]，a[1]，…，a[r-1]中，组合的元素满足以下性质：
（1） a[i+1]>a[i]，后一个数字比前一个大；
（2） a[i]-i<=n-r+1。
按回溯法的思想，找解过程可以叙述如下：
首先放弃组合数个数为r的条件，候选组合从只有一个数字1开始。因该候选解满足除问题规模之外的全部条件，扩大其规模，并使其满足上述条件（1），候选组合改为1，2。继续这一过程，得到候选组合1，2，3。该候选解满足包括问题规模在内的全部条件，因而是一个解。在该解的基础上，选下一个候选解，因a[2]上的3调整为4，以及以后调整为5都满足问题的全部要求，得到解1，2，4和1，2，5。由于对5不能再作调整，就要从a[2]回溯到a[1]，这时，a[1]=2，可以调整为3，并向前试探，得到解1，3，4。重复上述向前试探和向后回溯，直至要从a[0]再回溯时，说明已经找完问题的全部解。按上述思想写成程序如下：

#include <iostream>
using namespace std;

void combination(int n,int k)
{   int i,j;
   i=0;
   int* a = new int[k];
   a[i]=1;
   do {
      if (a[i]-i<=n-k+1){
		  if (i==k-1){
		     for (j=0;j<k;j++)
               printf("%4d",a[j]);
         printf("\n");
         a[i]++;
         continue;
		  }
		  i++;
		  a[i] = a[i-1]+1;
      }
      else
      {   if (i==0){
		  delete[] a;
            return ;
	  }
         a[--i]++;
      }
   }   while (true);
}

void main()
{   combination(5,3);
}

5，一个人口调查人员已知某家门牌号码，打电话询问该家三个女儿年龄。已知信息：三个相乘为72，三个相加为门牌号，最大女儿喜欢谈钢琴。问三个女儿各自年龄。

解答：穷举所有的相乘为72的可能，因为门牌号已经知道，已经可以求出解了，但是这里给出第三个条件，必有两个解的相加的门牌号一样，这里为6，6，2和8,3,3，从最后一个条件得出解为8,3,3

6，小鹿和小婷是姐妹，小娜和小齐是姐妹。下面四句话中  如果说的是自己的姐妹，则为真话；如果说的不是自己的姐妹就为假话。

  坐在钢琴边上的女孩说：“拿长笛的是小娜”；

  拿长笛的说：“拉小提琴的是小齐”；

  拉小提琴的说：“拿口琴的是小鹿”；

  拿口琴的说：“拿长笛的不是小齐”。

  区分她们四个人。

这道题一直没找到解法，如果哪位同学找到了答案记到留言，谢谢！

7，桌面上有23个硬币，其中10个正面朝上，现在要将你眼睛蒙住，将这些硬币分为两组，(假设硬币的正反,面手指是摸不出来的)，要求每组中正面朝上的硬币数量相同。请你用最好的方法进行分组。

将其分为一堆10个、另一堆13个，然后将10个那一堆所有的硬币翻转就可以了，两边的就一样多了。

8，A和B两个人在一月份首次去健身房时认识，A 在一月份第一个星期的星期一去了健身房，然后每隔四天去一次(即第五天去)，而B每隔三天去一次(即第四天去)。一月份A 和B只相遇了一次，即首次认识的那天。请问，

A 和B是在一月份31天中的哪天认识的？

设为x日相遇，则有x+5n=x+4m第二次相遇所以有x+5n>31才能满足条件。

B：1 日，5 日，9 日，13 日，17 日，21 日，25 日，29 日；A：7 日，12 日，17 日，22 日，27 日。因此，A和B相遇于1 月17 日。

9，A、B、C三人参加了一个体育运动，包括M 个项目，每个项目的第一、二、三名分别可获得X 、Y、Z积分。

其中B得了百米跑第一名。比赛结束，A 得分22，B和C均为9 。请问，M 值为多少，跳高第二名是谁？

分析：考虑三个得的总分，有方程：

M(p1+p2+p3)=22+9+9=40,①

又 p1+p2+p3≥1+2+3=6，②

∴6M≤M(p1+p2+p3)=40，从而M≤6.

由题设知至少有百米和跳高两个项目，从而M≥2，

又M|40，所以M可取2、4、5.

考虑M=2，则只有跳高和百米，而B百米第一，但总分仅9分，故必有：9≥p1+p3,∴≤8，这样A不可能得22分.

若M=4，由B可知：9≥p1+3p3，又p3≥1，所以p1≤6,若p1≤5，那么四项最多得20分，A就不可能得22分，故p1=6.

∵4（p1+p2+p3）=40,∴p2+p3=4.

故有：p2=3,p3=1,A最多得三个第一，一个第二，一共得分3×6+3=21＜22，矛盾.

若M=5，这时由5(p1+p2+p3)=40，得：

p1+p2+p3=8.若p3≥2，则：

p1+p2+p3≥4+3+2=9，矛盾，故p3=1.

又p1必须大于或等于5,否则,A五次最高只能得20分,与题设矛盾,所以p1≥5.

若p1≥6，则p2+p3≤2，这也与题设矛盾，∴p1=5，p2+p3=3，即p2=2，p3=1.

A=22=4×5+2.

故A得了四个第一，一个第二；

B=9=5+4×1，

故B得了一个第一，四个第三；

C=9=4×2+1，

故C得了四个第二，一个第三.

10，对一个英文句子加密。要求句子中的字母用该字母在26位字母表后的第三个字母来代替，例如def，在加密后显示为ghi。如为其他字符则不变。请写出具体分析过程及程序实现代码。(写出流程图也有部分加分)

（1）判断输入字符ch是否是字母，大写还是小写？（A-Z）或（a-z）;

（3）是字母，则将ch +=3；

（4）如果是大写字母，且ch> 'Z'，则ch + 'A' - 'Z'；否则，如果是小写字母，且ch > 'z'，则ch + 'a' - 'z'；

（5）输出ch。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void Encrypt(char* a,char* b){
	int len = strlen(a);
      for(int i=0;i<len;i++){
           if(a[i]<='z'&&a[i]>='a') {
                 b[i]=(a[i]+3-('a'))%26+('a');
           }
           else if((a[i]<='Z'&&a[i]>='A'))
           {
                 b[i]=(a[i]+3-('A'))%26+('A');
           }
      }
}
void main(){
	char* a = "def";
	char* b = (char*)malloc(sizeof(a));
	memset(b,0,sizeof(b));
	Encrypt(a,b);
	printf("%s\n",b);
	free(b);
}

11请用程序来实现一个复数类Complex，要包含.h 和.cpp文件。Complex类要能实现以下功能：

Complex comp1(2,3); 
  Complex comp2(comp1); 
  Complex comp3(3,4); 
  comp1+comp 3;  
  comp1=comp3;  
  printf( “ comp1==comp3:%s ” ,comp1==comp3?true:false);  
  printf( “ comp2==comp3:%s ” ,comp2==comp3?true:false);  
Complex.h:
#include<iostream>
class Complex{
public:
	Complex(){};
	Complex(float r,float i):real(r),imag(i){};
	Complex(Complex &cpx):real(cpx.real),imag(cpx.imag){};
	Complex operator+(const Complex &c2);
	Complex& operator=(const Complex &c2);
	bool operator==(const Complex &c2);
	~Complex(){};
private:
	float real,imag;
}
Complex.cpp
#include "Complex.h"
Complex::Complex(){}
Complex::~Complex(){}
Complex::Complex(float r,float i):real(r),imag(i){}
Complex::Complex(Complex &cpx):real(cpx.real),imag(cpx.imag){}
Complex Complex::operator+(const Complex &c2){
	return Complex(real+c2.real,imag+c2.imag);
}
Complex& Complex::operator=(const Complex &c2){
	real = c2.real;
	imag = c2.imag;
	return *this;
}
bool Complex::operator==(const Complex &c2){
	return(real==c2.real&&imag==c2.imag);
}

12给了一个一维数组，N个数，判断其中是否有重复的数，并返回这个数的值

可以分别有以及bitmap实现：

方法一：从第一个数开始遍历与后面的每个数比较有重复的就输出，时间复杂度O（n2）；

#include <stdio.h>
int duplicate(int* a,int n){
	for(int i=0;i<n;i++)
		for(int j=i+1;j<n;j++)
			if(a[i]==a[j])
				return a[i];
	return 0;
}
int main(){
	int a[10]={1,2,3,4,5,6,7,7,8,9};
	int res = duplicate(a,10);
	printf("%d\n",res);
}

方法二：类似于计数排序，用一个数组来统计每个数出现的次数，如果是大于2就输出,时间复杂度O（n）,空间复杂度O（n）;

#include <stdio.h>
#include<limits>
#include<stdlib.h>
#include<string.h>

int max(int* a,int n){
	int max = INT_MIN;
	for(int i=0;i<n;++i)
		if(a[i]>max)
			max = a[i];
	return max;
}
int duplicate(int* a,int n){
	 int len = (max(a,n)+1);
	 int* count = (int*)malloc(len*sizeof(int));
	 memset(count,0,sizeof(*count)*len);
	 for(int i=0;i<n;++i){
		 if(count[a[i]]>=1){
			 free(count);
			 return a[i];
		 }
		++count[a[i]];
	 }
	 free(count);
	 return 0;
}

int main(){
	int a[10]={1,2,3,4,5,6,7,7,8,9};
	int res = duplicate(a,10);
	printf("%d\n",res);
}

方法三：用bitmap来实现，将相应的位置1，如果遇到相应的位已经是一了说明前面已经存在该数了就输出，时间复杂度O（n）,空间复杂度O(n);

#include <stdio.h>
#include <limits.h>
#include <stdlib.h>
#include<string.h>

#define SHIFT 5           
#define MASK 0x1F
#define DIGITS 32


int max(int* a,int n){
	int max = INT_MIN;
	for(int i=0;i<n;++i)
		if(a[i]>max)
			max = a[i];
	return max;
}
 //将?逻?辑-位?置?为an的Ì?二t进?制?位?置?为a1
void set(int* a,int n) {
    a[n>>SHIFT]=a[n>>SHIFT]|(1<<(n&MASK));     //n>>SHIFT右®¨°移°?5位?相¨¤当Ì¡À于®¨²除y以°?32求¨®算?字Á?节¨²位?置?，ê?n&MASK相¨¤当Ì¡À于®¨²对?32取¨?余®¨¤即¡ä求¨®位?位?置?，ê?
}                                              
int test(int * a ,int n)
{
    return a[n>>SHIFT] & (1<<(n&MASK));        //测a试º?逻?辑-位?置?为an的Ì?二t进?制?位?是º?否¤?为a1 
}
void clear(int* a,int n)
{
    a[n>>SHIFT]=a[n>>SHIFT]&(~(1<<(n&MASK)));   //将?逻?辑-位?置?为an的Ì?二t进?制?位?置?0，ê?原-理¤¨ª同ª?set操¨´作Á¡Â 
}
int duplicate(int* a,int n){
	 int len = max(a,n)/DIGITS+1;
	 int* c = (int*)malloc(len*sizeof(int));
	 memset(c,0,sizeof(*a)*len);
	 for(int i=0;i<n;++i){
		 if(test(c,a[i])){
			 free(c);
			 return a[i];
		 }
		set(c,a[i]);
	 }
	 free(c);
	 return 0;
}

int main(){
	int a[10]={1,2,3,4,5,6,7,7,8,9};
	int res = duplicate(a,10);
	printf("%d\n",res);
}

方法四：如果N个数都是小于N的，将每个a[i]归为，即归到a[i]归到i位上，最后遍历，遇到没有归为的数说明有重复，输出；

#include <iostream>
#include <algorithm>
using namespace std;

int duplicate(int* arr,int n){
     for(int i=0;i<n;++i) { 
         while(arr[i]!=i) 
         { 
             if(arr[arr[i]]==arr[i])
                 return arr[i]; 
			 swap(arr[arr[i]],arr[i]);
         } 
     } 
     return 0;
}

int main(){
	int a[10]={1,2,3,4,5,6,7,8,1,0};
	int res = duplicate(a,10);
	printf("%d\n",res);
}

13 copy和=的区别：

区别在于：复制构造函数是去完成对未初始化的存储区的初始化，而赋值操作符则是处理一个已经存在的对象。对一个对象赋值，当它一次出现时，它将调用复制构造函数，以后每次出现，都调用赋值操作符。

新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。这在很多情况下都可能发生，最常见的情况是将新对象显示地初始化为现有的对象。例如，假设motto是一个String对象，则下面4种声明都将调用复制构造函数：
String ditto(motto);
　　String metoo = motto;
　　String also = String(motto);
　　String *pString = new String(motto);