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);
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
