您的位置：首页 > 其它

华科历年考研上机题整理

2017-03-12 20:29 513 查看

1、任意输入一串字符，将下标为奇数的小写字母转换为大写（编号从0开始，若该位置上不是字母，则不转换）。举例：若输入abc4Efg,则应输出aBc4EFg。(字符串数组)

#include<stdio.h>
#include<string.h>
#define MAX 20

void fun(char s[])
{
int i,len;
len=strlen(s);
for(i=1;i<len;i+=2)
{
if(s[i]>='a' && s[i]<='z')
{
s[i]-=32;
}
}
}

int main()
{
char str[MAX];
while(gets(str)!=NULL)
{
fun(str);
puts(str);
}
return 0;
}

[b]2、在半个中国象棋棋盘上,马在左下角(1，1)处,马走日字...而且只能往右走...不能向左...可上可下...求从起点到(m,n)处有几种不同的走法（注意：半个棋盘为5行9列）。（函数的递归调用）
[/b]

测试数据：

输入样例：

5 9

4 8

3 2

4 4

输出样例：

37

20

1

2

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

int cnt;

void dfs(int x,int y,int m,int n)//行：x，m  列：y，n
{
if(x==m&&y==n)
{
cnt++;
return;
}
else if(x<1||x>5||y<1||y>9)//棋盘为5行9列
{
return;
}
//只能向右y+，可上可下x+-
dfs(x-2,y+1,m,n);
dfs(x+2,y+1,m,n);
dfs(x+1,y+2,m,n);
dfs(x-1,y+2,m,n);
}

int main()
{
int m,n;
while(scanf("%d%d",&m,&n)!=EOF)
{
cnt=0;
dfs(1,1,m,n);
printf("%d\n",cnt);
}
return 0;
}

3、给定任意俩组字符串S1和S2，请编程输出他们间的最大相同子串。例如：S1=12abc78，S2=7bc2，则输出为：bc。(字符串数组)

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

void MaxSubString(char s1[],char s2[])//求两个字符串的最大相同子串函数
{
int i,j,m,n,len1,len2,start,maxlen,tmplen;
len1=strlen(s1);
len2=strlen(s2);
maxlen=0;
start=0;
for(i=0;i<len1;i++)//暴力求解
{
for(j=0;j<len2;j++)
{
tmplen=0;
if(s1[i]==s2[j])
{
tmplen++;
m=i+1;
n=j+1;
while(m<len1&&n<len2)
{
if(s1[m]==s2
)
tmplen++;
else
break;
m++;
n++;
}
if(tmplen>maxlen)
{
maxlen=tmplen;
start=i;
}
}
}
}
for(i=start;i<start+maxlen;i++)
{
printf("%c",s1[i]);
}
puts("");
}

int main()
{
char s1[101],s2[101];
while(scanf("%s%s",s1,s2)!=EOF)
{
MaxSubString(s1,s2);//求两个字符串的最大相同子串函数
}
return 0;
}

4、已知一颗二叉树S的前序遍历和中序遍历序列，请编程输出二叉树S的后续遍历序列。(二叉树，函数递归)

(举例：pred[]/先序：A、B、D、E、C、F、G；

inod[]/中序：D、B、E、A、C、G、F；

后序遍历序列是：D、E、B、G、F、C、A)

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

char pred[33],inod[33],post[33];
int len;
//int cnt;

void PostOrder(char pred[],int l1,int r1,char inod[],int l2,int r2)
{
int i;
if(l1<=r1)
{
//		post[cnt++]=pred[l1];//不能再这里赋值，要按后续遍历的顺序递归访问！！！
for(i=l2;i<=r2;i++)
{
if(inod[i]==pred[l1])
break;
}
PostOrder(pred,l1+1,l1+i-l2,inod,l2,i-1);//左
PostOrder(pred,l1+i-l2+1,r1,inod,i+1,r2);//右
//		post[cnt++]=pred[l1];//根(存储后序遍历结果)
printf("%c",pred[l1]);//根
}
}

int main()
{
int i;
while(scanf("%s%s",pred,inod)!=EOF)
{
len=strlen(pred);
//		cnt=0;
PostOrder(pred,0,len-1,inod,0,len-1);
puts("");
/*		for(i=0;i<len;i++)
{
printf("%c",post[i]);
}
puts("");*/
}
return 0;
}

#include<iostream>
#include<algorithm>
#include<stdio.h>
#include<map>
#include<math.h>
#include<string.h>
#include<queue>
#include<vector>
#include<set>
#define LL long long
#define exp 1e-9
#define MAXN 1000010
#define N 3333
using namespace std;

typedef struct BTNode{
char data;
BTNode *lchild;
BTNode *rchild;
}BTNode;

void postorder(BTNode *bt)
{
if(bt!=NULL)
{
postorder(bt->lchild);
postorder(bt->rchild);
cout<<bt->data;
}
}

BTNode *CreateBT(char pre[],char in[],int l1,int r1,int l2,int r2)
{
BTNode *s;
int i;
if(l1>r1) return NULL;
s=(BTNode *)malloc(sizeof(BTNode));
s->lchild=NULL;
s->rchild=NULL;
for(i=l2;i<=r2;++i)
{
if(in[i]==pre[l1])
break;
}
s->data=in[i];
s->lchild=CreateBT(pre,in,l1+1,l1+i-l2,l2,i-1);
s->rchild=CreateBT(pre,in,l1+i-l2+1,r1,i+1,r2);
return s;
}

int main( )
{
//	freopen("D:\\in.txt","r",stdin);
char pre[33],in[33],post[33];
BTNode *bt;
int len;
while(scanf("%s%s",pre+1,in+1)!=EOF)
{
len=strlen(pre+1);
bt=CreateBT(pre,in,1,len,1,len);
postorder(bt);
puts("");
}
return 0;
}

5、打印出所有的“水仙花数”，所谓“水仙花数”是指一个3位数，其各位数字立方和等于该数本身。(举例：153=1*1*1+3*3*3+5*5*5)（多层循环）

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

int main()
{
int i,j,k;
for(i=1;i<=9;i++)
{
for(j=0;j<=9;j++)
{
for(k=0;k<=9;k++)
{
if(i*100+j*10+k==i*i*i+j*j*j+k*k*k)
printf("%d ",i*100+j*10+k);
}
}
}
puts("");
return 0;
}

6、求数列s(n)=s(n-1)+s(n-2)的第n项的值。其中s(1)=s(2)=1。要求任意给定n,输出s(n)(递推基础)

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

int f[33];

void init()
{
int i;
f[1]=f[2]=1;
for(i=3;i<=30;i++)
{
f[i]=f[i-1]+f[i-2];
}
}

int main()
{
int n;
init();
while(scanf("%d",&n)!=EOF)
{
printf("%d\n",f
);
}
return 0;
}

7、按要求输出：在三位整数（100至999）中寻找符合条件的整数并依次从小到大存入数组中；他既是完全平方数，又是两位数字相同，例如144，676等（多位数字的分离，注意与第5题比较）

#include<stdio.h>
#include<string.h>
#include<math.h>

int main()
{
int i,j,k,tmp,s;
for(i=1;i<=9;i++)
{
for(j=0;j<=9;j++)
{
for(k=0;k<=9;k++)
{
if(i==j&&i!=k || i==k&&i!=j || j==k&&i!=j)
{
s=i*100+j*10+k;
tmp=sqrt(s);
if(tmp*tmp==s)
{
printf("%d ",s);
}
}
}
}
}
puts("");
return 0;
}

[b][b]8、在一个整形数组a中既有负数又有正数，编写一个算法将a中所有负数移到整数之前，要求其时间复杂度为O(n)，n为数组长度，并且只使用常数个辅助空间。（辅助空间的使用，数组元素的选择性保留）
[/b][/b]

1、简单版本的解法：[b]假设数组中没有0元素[/b]

#include<stdio.h>
#include<string.h>
#include<math.h>

int main()
{
int a[9]={1,2,3,4,-1,1,-2,-1,-4};
int i=-1;
int j=sizeof(a)/sizeof(int);
int tmp;
while(i<j)
{
while(a[++i] < 0);
while(a[--j] > 0);
if(i<j)
{
tmp=a[i];
a[i]=a[j];
a[j]=tmp;
}
}
j=sizeof(a)/sizeof(int);
for(i=0;i<j;i++)
{
printf("%d ",a[i]);
}
puts("");
return 0;
}

2、数组中有0元素（暂无）：

9、编写一个C函数，输入一个二叉树的根节点，返回这棵树中所有值大于0的节点值之和，如果根为空，返回0.

二叉树的链式存储结构对应的C语言的节点类型定义如下：

Typedef struct node{

ElemType data;

struct node *lchild;

struct node *rchild;

}BTree;

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

typedef int ElemType;

typedef struct node{
ElemType data;
struct node *lchild;
struct node *rchild;
}BTree;

int Sum(BTree *bt)
{
if(bt==NULL)
return 0;
else
{
if(bt->data>0)
return bt->data + Sum(bt->lchild) + Sum(bt->rchild);
else
return 0 + Sum(bt->lchild) + Sum(bt->rchild);
}
}

void InsertBT(BTree *&bt,int x)
{
BTree *p,*pre;
p=pre=bt;
if(bt==NULL)
{
bt=(BTree *)malloc(sizeof(BTree));
bt->data=x;
bt->lchild=NULL;
bt->rchild=NULL;
}
else
{
while(p)
{
if(p->data>x)
{
pre=p;
p=p->lchild;
}
else
{
pre=p;
p=p->rchild;
}
}
p=(BTree *)malloc(sizeof(BTree));
p->data=x;
p->lchild=NULL;
p->rchild=NULL;
if(pre->data>x)
{
pre->lchild=p;
}
else
{
pre->rchild=p;
}
}
}

int main()
{
int a[111];
int i,n;
while(scanf("%d",&n)!=EOF)
{
BTree *bt=NULL;
for(i=1;i<=n;i++)
{
scanf("%d",&a[i]);
}
for(i=1;i<=n;i++)
{
InsertBT(bt,a[i]);
}
printf("%d\n",Sum(bt));
}
return 0;
}

10、A是一个长度为N的整形数组，其中可能包含重复的元素，例如A={1,2,2,3,2,1,3,2}，删除数组中相同的元素后得到{1,2,3}，

a) 如果数组没有排序，写一个C语言函数，输入参数为数组首地址和长度，删除其中重复的元素，返回删除后的数组的长度。

b) 上述函数的时间复杂度为多少，以删除前的数组长度N表示。

c) 如果数组A已经排好序，设计并写出一个C语言函数完成a)中的工作，要求时间复杂度是O(N) 。

（待续）

11、写一个C语言函数将一颗二叉树用层序遍历列出所有节点，即先列出根节点，再从左向右列出深度为1的节点的值，然后再左向右列出深度为2的节点的值，如此继续。数的节点类型TREENODE包含一个整型值Value和俩个指针：LeftChild和RightChild。可以使用的函数（不限于）包括MaleEmptyQueue (QUEUE *q),

EnQueue (QUEUE *q,TREENODE *tn)

DeQueue(QUEUE *q,TREENODE *tn) , IsEmpty (QUEUE *q) , DisposeQueue (QUEUE *q)。

（待续）

12、假设以下关于堆栈的库函数已经给出，unsigned char is empty ();检查堆栈是否为空，如果是，返回1；否则返回0. void push (char element);把一个char型的数据element 推入栈顶。

Char pop (); 弹出栈顶的char型数据。

（1）利用这些库函数设计一个C语言的函数unsignedchar isBalanced (char *string) ,来检查字符串string 中的括号（），[]，{}是否平衡，如果平衡，该函数返回1，否则返回0.

（2）你所设计的函数时间复杂性是多少（假定字符串string 长度为n）？

（待续）

13、在一棵高度为O(logn)的二叉排序树的结点上存储着浮点数，请用C语言写一个函数来计算一棵树上界于任意俩个浮点数x1和x2 (x1<x2)之间的结点数。说明你的算法的计算复杂度，算法计算复杂度越低越好。

（待续）

14、编写算法实现顺序表的逆置，即利用原表的存储空间将线性表（a1，a2，……，an）逆置为（an，……，a2，a1）。

15、编程解决“八皇后问题”：即在一个8*8的矩形格子中排放8个皇后，要满足的条件包括：任意两个皇后都不能在同一行、同一列，也不能在同一条对角线（斜率等于1或-1）。

要求编程给出所有第一行第一列有皇后的解。

（注：解的输出用8个数字表示，如：基本解{1,5,8,6,3,7,2,4}其中‘1’代表第一行第一列即（1,1）处有皇后、‘5’代表（2,5）处有皇后……‘4’代表（8,4）处有皇后。）

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

int c[9];
int cnt;
int n;

void dfs(int r)
{
int i,j,ok;
if(r==n+1)
{
cnt++;
for(i=1;i<n;i++)
{
printf("%d,",c[i]);
}
printf("%d\n",c
);
return;
}
for(i=2;i<=n;i++)//列
{
c[r]=i;//第r行放第i列
ok=1;
for(j=1;j<r;j++)//枚举前面r-1行放的情况
{
if(c[r]==c[j]||c[r]-c[j]==r-j||c[r]-c[j]==j-r)
{
ok=0;
break;
}
}
if(ok)
dfs(r+1);
}
}

int main()
{
scanf("%d",&n);
c[1]=1;//第一行第一列已放好
cnt=0;
dfs(2);//从第二行开始放
printf("%d\n",cnt);
return 0;
}

16、问题描述：已知n个人（以编号1,2,3,...,n分别表示）围坐在一张圆桌周围，从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。

输入数据

每行包含3个正整数n,k,m，3个正整数均可以使用32-bit integer来表示。

输出要求

对于每个测试用例，你应当输出一行，依次输出出列人员人员编号，以空格间隔。

输入样例

3 2 20

9 1 5

输出样例

3 2 1

5 1 7 4 3 6 9 2 8

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

int out[22],order[22];
int n,k,m,cnt;

int main()
{
int i,t;
while(scanf("%d%d%d",&n,&m,&k)!=EOF)
{
m--;
memset(out,0,sizeof(out));
t=0;//当前报的数
cnt=0;//出队的人数
for(i=m;;i=(i+1)%n)
{
if(!out[i])
{
t++;
if(t==k)
{
out[i]=1;
cnt++;
order[cnt]=i+1;
if(cnt==n)
break;
t=0;
}
}
}
for(i=1;i<=cnt;i++)
{
printf("%d ",order[i]);
}
puts("");
}
return 0;
}

数学递推法求解约瑟夫问题：一圈共有N个人，开始报数，报到M的人自杀，然后重新开始报数，问最后自杀的人是谁？

问题变为（N-1）个人，报到为（M-1）的人自杀，问题规模减小了。这样一直进行下去，最后剩下编号为0的人。用函数表示：

F(1)=0

当有2个人的时候（N=2），报道（M-1）的人自杀，最后自杀的人是谁？应该是在只有一个人时，报数时得到的最后自杀的序号加上M，因为报到M-1的人已经自杀，只剩下2个人，另一个自杀者就是最后自杀者，用函数表示：

F(2)=F(1)+M

可以得到递推公式：

F(i)=F(i-1)+M

因为可能会超出总人数范围，所以要求模

F(i)=(F(i-1)+M)%i

有了递推公式就可以在O（N）时间求出结果（结果为F（N）+1）。

17、魔方阵，古代又称“纵横图”，是指组成元素为自然数1、2…n的平方的n×n的方阵，其中每个元素值都不相等，且每行、每列以及主、副对角线上各n个元素之和都相等。

如3×3的魔方阵：

　　

8 1 6 =15

　3 5 7 =15

　4 9 2 =15

|| || ||

15 15 15 15（对角线）

魔方阵的排列规律(奇数阵)：

1.将1放在第一行中间一列。

2.从2开始直到n×n止各数依次按下列规则存放：每一个数存放的行比前一个数的行数减1，列数加1。

3.如果上一个数的行数为1，则下一个数的行数为n，列数加1。如果上一个数的列数的n时，下一个数的列数为1，行数减1。

4.如果按上面的规则确定的位置上已有数，或上一个数是第一行第n列时，则把下一个数放在上一个数的下面。

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

int m[33][33];
int n;

void mofang(int n)
{
int i,j,pi,pj,cnt;
i=1;
j=n/2+1;
m[i][j]=1;
cnt=2;
while(cnt<=n*n)
{
pi=i;
pj=j;
i--;
if(i==0)
i=n;
j++;
if(j==n+1)
j=1;
if(m[i][j]!=0 || pi==1&&pj==n)
{
i=pi+1;
j=pj;
}
m[i][j]=cnt;
cnt++;
}
for(i=1;i<=n;i++)
{
for(j=1;j<=n;j++)
{
printf("%4d ",m[i][j]);
}
puts("");
}
}

int main()
{
//	freopen("D:\\in.txt","r",stdin);
while(scanf("%d",&n)!=EOF)
{
memset(m,0,sizeof(m));
mofang(n);
}
return 0;
}

18、数独

Sample Input

Sample Output

#include<iostream>
#include<algorithm>
#include<cmath>
#include<cstring>
#include<queue>
#include<cstdio>
#include<queue>
#define LL long long
#define MAXN 1000010
#define EPS 1e-9
using namespace std;
int g[11][11],r[11][11],c[11][11],cb[11][11];
char m[11][11];
int fg;
void dfs(int k)
{
if(k==81)
{
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
printf("%d",g[i][j]);
}
printf("\n");
}
fg=1;
}
int row=k/9;
int col=k%9;
if(g[row][col])
{
dfs(k+1);
}
else
{
int num=row/3*3+col/3;
for(int i=1;i<=9;i++)
{
if(!r[row][i]&&!c[col][i]&&!cb[num][i])
{
r[row][i]=1;
c[col][i]=1;
cb[num][i]=1;
g[row][col]=i;
dfs(k+1);
if(fg)
return;
r[row][i]=0;
c[col][i]=0;
cb[num][i]=0;
g[row][col]=0;
}
}
}
}
int main()
{

int t;
//freopen("in.txt","r",stdin);
scanf("%d",&t);
while(t--)
{
memset(g,0,sizeof(g));
memset(c,0,sizeof(c));
memset(r,0,sizeof(r));
memset(cb,0,sizeof(cb));
for(int i=0;i<9;i++)
{
cin>>m[i];
for(int j=0;j<9;j++)
{
g[i][j]=m[i][j]-'0';
if(g[i][j])
{
int num=i/3*3+j/3;
cb[num][g[i][j]]=1;
c[j][g[i][j]]=1;
r[i][g[i][j]]=1;

}
}
}
fg=0;
dfs(0);
}
return 0;
}

19、素数环

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

int n;
int num[18],vis[18];

int isprime(int x)
{
int i,k;
k=sqrt(x);
for(i=2;i<=k;i++)
{
if(x%i==0)
return 0;
}
return 1;
}

void dfs(int sp)
{
int i,j;
if(sp==n+1)
{
if(isprime(num
+num[1]))
{
for(j=1;j<=n;j++)
{
printf("%d ",num[j]);
}
puts("");
}
return;
}
else
{
for(i=2;i<=n;i++)
{
if(!vis[i]&&isprime(i+num[sp-1]))
{
num[sp]=i;
vis[i]=1;
dfs(sp+1);
vis[i]=0;
num[sp]=0;
}
}
}
}

int main()
{
//	freopen("D:\\in.txt","r",stdin);
while(scanf("%d",&n)!=EOF)
{
memset(vis,0,sizeof(vis));
memset(num,0,sizeof(num));
num[1]=1;
vis[1]=1;
dfs(2);
}
return 0;
}

20、汉诺塔

#include <stdio.h>

void move (char a,char b)
{
printf("%c-->%c\n",a,b);
}

void hanuoi(int n,char one ,char two,char three)
{
if (n==1)
move (one,three);
else
{
hanuoi(n-1,one,three,two);
move(one,three);
hanuoi(n-1,two,one,three);
}
}

void main()
{
int n;
printf ("please input the number of disks:");
scanf("%d",&n);
printf("The process of moving disks is listed below\n");
hanuoi(n,'A','B','C');
}

21、题目：将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

程序分析：对n进行分解质因数，应先找到一个最小的质数k，然后按下述步骤完成：

(1)如果这个质数恰等于n，则说明分解质因数的过程已经结束，打印出即可。

(2)如果n<>k，但n能被k整除，则应打印出k的值，并用n除以k的商,作为新的正整数n,

　重复执行第一步。

(3)如果n不能被k整除，则用k+1作为k的值,重复执行第一步。

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

void fenjie(int n)
{
int i;
printf("%d=",n);
for(i=2;i<=n;i++)
{
while(n!=i)
{
if(n%i==0)
{
printf("%d*",i);
n/=i;
}
else
break;
}
}
printf("%d\n",n);
}

int main()
{
//	freopen("D:\\in.txt","r",stdin);
int n;
while(scanf("%d",&n)!=EOF)
{
fenjie(n);
}
return 0;
}

22、骑士游行问题

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int n1,n2,cnt;
int xx[30],yy[30];
int visit[30][30];
int dir[8][2]={{2,1},{1,2},{-1,2},{-2,1},{-2,-1},{-1,-2},{1,-2},{2,-1}};
//static int dx[8] = {2, 1, -1, -2, -2, -1, 1, 2};
//static int dy[8] = { 1, 2, 2, 1, -1, -2, -2, -1};
int go(int x,int y)
{
if(1<=x&&x<=n1&&1<=y&&y<=n2)
return 1;
return 0;
}
void dfs(int x,int y,int num)
{
int i,xxx,yyy;
xx[num]=x;
yy[num]=y;
if(num==n1*n2)
{
cnt++;
for(i=1;i<=num;i++)
{
printf("(%d,%d)",xx[i],yy[i]);
}
puts("");
return;
}
for(i=0;i<8;i++)
{
xxx=x+dir[i][0];
yyy=y+dir[i][1];
if(go(xxx,yyy)&&!visit[xxx][yyy])
{
visit[xxx][yyy]=1;
dfs(xxx,yyy,num+1);
visit[xxx][yyy]=0;
}
}
}

int main()
{
while(scanf("%d%d",&n1,&n2)!=EOF)
{
memset(visit,0,sizeof(visit));
visit[1][1]=1;
dfs(1,1,1);
printf("cnt=%d\n",cnt);
}
return 0;
}

23、蛤跳河

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
int n1,n2,cnt,minx;
int xx[30],yy[30];
int visit[30][30];
int m[30][30];
int dir[4][2]={{0,1},{0,-1},{-1,0},{1,0}};
int pathx[66][66],pathy[66][66];
int go(int x,int y)
{
if(1<=x&&x<=n1&&1<=y&&y<=n2)
return 1;
return 0;
}
void dfs(int x,int y,int num)
{
int i,xxx,yyy;
xx[num]=x;
yy[num]=y;
if(x==n1 && y==n2)
{
cnt++;
pathx[cnt][0]=num;
if(minx>num)
minx=num;
for(i=1;i<=num;i++)
{
//			printf("(%d,%d)",xx[i],yy[i]);
pathx[cnt][i]=xx[i];
pathy[cnt][i]=yy[i];
}
//		puts("");
return;
}
for(i=0;i<8;i++)
{
xxx=x+dir[i][0];
yyy=y+dir[i][1];
if(go(xxx,yyy)&&!visit[xxx][yyy]&&!m[xxx][yyy])
{
visit[xxx][yyy]=1;
dfs(xxx,yyy,num+1);
visit[xxx][yyy]=0;
}
}
}

int main()
{
int i,j;
while(scanf("%d%d",&n1,&n2)!=EOF)
{
memset(visit,0,sizeof(visit));
memset(m,0,sizeof(m));
visit[1][1]=1;
m[3][1]=m[3][2]=m[3][4]=m[3][5]=1;
minx=999999;
cnt=0;
dfs(1,1,1);
printf("总共有cnt=%d种跳法\n最短距离为%d\n最短距离的跳法如下：\n",cnt,minx);
for(i=1;i<=cnt;i++)
{
if(pathx[i][0]==minx)
{
for(j=1;j<=minx;j++)
{
printf("(%d,%d)",pathx[i][j],pathy[i][j]);
}
puts("");
}
}
}
return 0;
}

24、大数阶乘

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

int n,wei,tmp,cy;
int a[9999];

void jiecheng(int n)
{
int i,j;
wei=1;
tmp=1;
cy=0;
a[1]=1;
for(i=2;i<=n;i++)
{
for(j=1;j<=wei;j++)
{
tmp=a[j]*i+cy;
a[j]=tmp%10;
cy=tmp/10;
}
while(cy)
{
a[++wei]=cy%10;
cy/=10;
}
}
for(i=wei;i>=1;i--)
printf("%d",a[i]);
puts("");
}

int main()
{
while(scanf("%d",&n)!=EOF)
{
jiecheng(n);
}
return 0;
}

25、超素数

超素数就是这样的数,比如2333，2是素数，23是素数，233是素数，2333是素数，找出所有的四位超素数。每行输出六个，数之间空格隔开。（我的做法是先开个10000的数组，找出每个是素数的数组值为1,否则为0，对于每个四位数，分别看这几位是否都是素数即可,注意1不是素数）

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

int a[10010];

int isprim(int x)
{
int i,k;
k=sqrt(x);
for(i=2;i<=k;i++)
{
if(x%i==0)
return 0;
}
return 1;
}

void init()
{
int i;
memset(a,0,sizeof(a));
for(i=2;i<=9999;i++)
{
if(isprim(i))
{
a[i]=1;
}
}
}

int isSuperPrim(int x)
{
int n1,n2,n3,n4;
n1=x/1000;
n2=x/100;
n3=x/10;
n4=x;
return (a[n1]&a[n2]&a[n3]&a[n4]);
}

int main()
{
int i,cnt;
init();
cnt=0;
for(i=1000;i<10000;i++)
{
if(isSuperPrim(i))
{
cnt++;
if(cnt!=6)
{
printf("%d ",i);
}
else
{
printf("%d\n",i);
cnt=0;
}
}
}
return 0;
}

26、两个二进制数加减乘除，short型的，十六位，比如101 100 +，输出1001，也可把前几位0输出。

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

int BinaryToDec(char ch[],int n)
{
int sum,flag,i;
sum = 0;
flag = 1;
for(i=n-1; i>=0; i--)
{
sum += flag * (ch[i]-'0');
flag *= 2;
}
return sum;
}
void getResult(int a,int b,char op)
{
char ch[100];
int result;
switch (op)
{
case '+':
result =  a + b;
break;
case '-':
result =  a - b;
break;
case '*':
result =  a * b;
break;
case '/':
result =  a / b;
break;
default :
return ;
}

itoa(result,ch,2);
printf("%s\n",ch);
}
int main()
{
char ch1[100],ch2[100],oper;
int num1,num2;
while(scanf("%s %s %c",ch1,ch2,&oper) != EOF)
{
num1 = BinaryToDec(ch1,strlen(ch1));
num2 = BinaryToDec(ch2,strlen(ch2));
getResult(num1,num2,oper);
}
return 0;
}

27、回旋矩阵：  如5的回旋矩阵是

1 2 3  4 5

16  17  18 19 6

15  24 25 20 7

14  23  22  21  8
13 12 11  10 9
输入一个n，求他的回旋矩阵。

#include<stdio.h>
int main()
{
int size,s;
int matrix[100][100]={0};
int c;
int d=1;
int i,j,m,n,l;
while(1)
{
printf("请输入回旋矩阵大小(1-100)：");
scanf("%d",&size);
s=size;
for( i=0;i<size;i++)
{
for( j=i;j<size;j++)
{
matrix[i][j]=d;
d++;
if(j==size-1)
{
for( m=i+1;m<size;m++)
{
matrix[m][j]=d;
d++;
if(m==size-1)
{
for( n=size-2;n>=i;n--)
{
matrix[m]
=d;
d++;
if(n==i)
{
for( l=size-2;l>=i+1;l--)
{
matrix[l]
=d;
d++;
}
}
}

}
}

}
}
size--;
}
for(int p=0;p<s;p++)
{
for(int q=0;q<s;q++)
{
printf("%3d",matrix[p][q]);
if(q==s-1)
printf("\n");
}
}
d=1;
printf("输入1继续，输入0退出：");
scanf("%d",&c);
if(c==1)continue;
if(c==0)break;
}
return 0;
}

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航