C/C++程序题（1-5）

于 2016-03-26 19:38:08 发布
阅读量773 收藏 3
点赞数
CC 4.0 BY-SA版权
分类专栏： C/C++程序题
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/a6ds5s/article/details/50988457
本文介绍了几种实用的字符串和数字处理方法，包括字符串字母转换、查找整数中的重复子序列、字符串乘法运算、删除重复子串及实现约瑟夫环问题。提供了详细的C++代码实现。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

1.    

 给定一个字符串，把字符串内的字母转换成该字母的下一个字母，a换成b，z换成a，Z换成A，如aBf转换成bCg，字符串内的其他字符不改变，给定函数，编写函数

void  Stringchang（const  char*inpu,char*output）

其中input是输入字符串，output是输出字符串。

#include <iostream>
using namespace std;

void Stringchange(const char* input,char* output)
{
	int i,n=strlen(input);
	char s;
	for(i=0;i<n;i++)
	{
		if(input[i]>='a'&&input[i]<'z')
			s=input[i]+1;
		else if(input[i]=='z'||input[i]=='Z')
			s=input[i]-25;
		else if(input[i]>='A'&&input[i]<'Z')
			s=input[i]+1;
		else
			s=input[i];
		output[i]=s;
	}
	output[n]='\0';
}

void main()
{
	char* input=new char[100];
	char* output=new char[100];
	cin.getline(input,100);
	Stringchange(input,output);
	cout<<output<<endl;
	delete []input;
	delete []output;
}


注：定义的字符指针使用前要分配内存空间。'a'指的是a的ASCII码。


2.

  求一个整型数字中有没有相同的部分，例如12386123这个整型数字中相同的部分是123，相同的部分至少应该是2位数，如果有相同部分返回1，如果没有则返回0。方法是先将整型数字转换到数组中，再判断。

函数为  int same（int num）

其中num是输入的整型数字。

#include <iostream>  
using namespace std;  
  
int same(int num)  
{  
    int n[100],i=0;  
    while(num)  
    {  
        n[i]=num%10;//倒序存储  
        num=num/10;  
        i++;  
    }  
    n[i]='\0';  
    for(int j=0;j<i-1;j++)  
        for(int t=2;j+t<i-1;t++)  
        {  
        if(n[j]==n[j+t]&&n[j+1]==n[j+t+1]) return 1;  
        }  
return 0;  
}  
  
void main()  
{  
    int num;  
    cin>>num;  
    int m=same(num);  
    cout<<m<<endl;  
} 

#include <iostream>
using namespace std;

int same(int num)
{
	int* str=new int[100];
	int m=0;
	while(num>0)
	{
		str[m]=num%10;
		num=num/10;
		m++;
	}
	str[m]='\0';
	for(int i=0;i<m-3;i++)
	{
		for(int j=i+2;j<m-1;j++)
		{
			if(str[i]==str[j]&&str[i+1]==str[j+1])
				return 1;
		}
	}
	return 0;
	delete []str;
}

void main()
{
	int num;
	cin>>num;
	int l=same(num);
	cout<<l<<endl;
}


注：将int型转为int数组（循环对个位数取值）；寻找相同数时先指定两位相邻数，再一一同后面的两两相邻数相对比。(测试用例不要超出int的表示范围)



3.

求两个字符串的乘积，结果存到字符串中，例如字符串一中存的“657891”，字符串二中存的“521”，分别将字符串中的字符转换成整型数字，进行计算后，再转换成字符类型存储起来。

函数为  void mul（char *input1，int n，char *input2, intm，char *output）

其中input1和input2是输入，n是input1的长度，n2是input2的长度。Output是输出。

#include <iostream>  
#include <cmath>  
  
using namespace std;  
  
void mul(char *input1,int n,char *input2,int m,char *output)  
{  
    int ip1=0,ip2=0,ni=n,mi=m;  
    int op;  
    int k=0;  
      
    for(int i=0;i<n;i++)  
    {  
        ip1=ip1+(input1[i]-'0')*pow(10.0,--ni);  
    }  
  
    for(int i=0;i<m;i++)  
    {  
        ip2=ip2+(input2[i]-'0')*pow(10.0,--mi);  
    }  
    op=ip1*ip2;  
    if(op==0)  
    {  
        output[0]='0';  
        output[1]='\0';  
        return;  
    }  
  
    while(op>0)  
    {  
        output[k]=op%10+'0';  
        op=op/10;  
        k++;  
    }                        //得到的output数组里的数字是倒序  
    output[k]='\0';  
    for(int i=0;i<k/2;i++)//数组的前后字符交换  
    {  
        char ind;  
        ind=output[i];  
        output[i]=output[k-1-i];  
        output[k-1-i]=ind;  
    }  
      
  
}  
  
void main()  
{  
    char pt1[100],pt2[100],opt[100];  
    cin>>pt1;  
    cin>>pt2;  
    int n=strlen(pt1);  
    int m=strlen(pt2);  
    mul(pt1,n,pt2,m,opt);  
    cout<<opt<<endl;  
}
注：将字符串每个字符型数字-'0'，变为整型再乘上相应位数，最后相加，变为整型数字。进行相乘后，再取每个整型数字变为char型（+'0'），最后交换字符顺序。



4.

子串，只要是原串中有相同的子串就删掉，不管有多少个都删除，返回子串个数。
输入字符串为：123abc12de234fg1hi34j123k，子串为：123
则输出为：abc12de234fg1hi34jk 2

#include<iostream>
#include<cstring>
using namespace std;
int fun(char* str,char* str1,char* output)
{
	int n=strlen(str);
	int m=strlen(str1);
	int k=0,j=0,i;
	char tem[100];
	for(i=0;i<n-m+1;i++)
	{
		if(str[i]==str1[0])
		{
			strncpy(tem,&str[i],m);
			tem[m]='\0';
			if(strcmp(tem,str1)==0)
			{
				k++;
				i=i+m-1;
				continue;
			}
		}
		output[j++]=str[i];
	}
	for(int l=0;l<m;l++)
		output[j++]=str[i++];
	return k;
}

void main()
{
	char str[100],str1[100],output[100];
	cin.getline(str,100);
	cin.getline(str1,100);
	int k=fun(str,str1,output);
	cout<<output<<' '<<k<<endl;
}


#include <iostream>  
#include <string>  
  
using namespace std;  
  
int deletesub(string str,string sub,int n)  
{  
    int num=0;  
    while(1)  
    {  
        int m=str.find(sub);  
        if(m<0) return num;  
        else   
        {  
            str.erase(m,n);  
            num++;  
        }  
    }  
}  
  
void main()  
{  
    string str,sub;  
    getline(cin,str);  
    cin>>str;//getline(cin,str);  
    cin>>sub;//getline(cin,sub);  
    int n=sub.size();  
    int num=deletesub(str,sub,n);  
    cout<<num<<endl;  
}
注：string类的使用。string::size()返回的是字节数（字母数字占一个字节，汉字占两个），也可用string::length();

string类的find()原型如下：
（1）size_t find (const string& str, size_t pos = 0) const;  //查找对象--string类对象，pos为开始查找的索引位置默认为0
（2）size_t find (const char* s, size_t pos = 0) const; //查找对象--字符串
（3）size_t find (const char* s, size_t pos, size_t n) const;  //查找对象--字符串的前n个字符
（4）size_t find (char c, size_t pos = 0) const;  //查找对象--字符
结果：找到 -- 返回 第一个字符的索引
没找到--返回   string::npos，其值等于-1
string类型的erase()的原型如下：
（1）string& erase ( size_t pos = 0, size_t n = npos );
（2）iterator erase ( iterator position );
（3）iterator erase ( iterator first, iterator last );
也就是说有三种用法：
（1）erase(pos,n); 删除从pos开始的n个字符，比如erase(0,1)就是删除第一个字符
（2）erase(position);删除position处的一个字符(position是个string类型的迭代器)
（3）erase(first,last);删除从first到last之间的字符（first和last都是迭代器）



5.

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

#include <iostream>  
using namespace std;  
  
typedef struct _node{  
    int num;  
    _node *next;  
}node;  
  
node *creat(int n)//建立n个元素的循环链表  
{  
    node *p,*q,*head=NULL;  
    for(int i=1;i<n;i++)  
    {  
        p=new node;  
        p->num=i;  
        if(i==1)  
        {  
            head=p;  
        }  
        else  
        {  
            q->next=p;//p为present  
        }  
        q=p;//q存取的是上一个值previous  
    }  
    q->next=head;  
    return q;  
      
}  
  
int main()  
{  
    int n,k,m;//n为总人数,k为第一个报数的人,m为出列者喊到的数  
    cin>>n>>k>>m;  
    node *q,*pre;  
    q=creat(n);  
    pre=q;     //  
    q=q->next; //pre永远是q的上一个节点  
    for(int i=1;i<k;i++)//将q移至开始报数点k  
    {  
        pre=q;  
        q=q->next;  
    }  
    while(q->next!=q)  
    {  
        for(int i=1;i<m;i++)//将q移至出列点m  
        {  
            pre=q;  
            q=q->next;  
        }  
        cout<<q->num<<"->";//打印当前出列点  
        pre->next=q->next;  
        delete q;//delete和free函数一样，只是在堆内存管理结构  
        q=pre->next;//中将指针指向的内容标记为可被重新分配。  
    }  
    cout<<q->num<<endl;  
    delete q;  
    return 0;  
  
}

注：node *creat()建立循环列表，函数返回值指向单向时的最后一个节点。
整个程序分为3个步骤：
第一步：建立一个有n个元素的循环链表，链表是从n的编号开始的。再通过next转到1号节点。
第二步：是从链表的表头数到第 k 个值。
第三步：从 k 的后面开始输入 m 个值，删除该值，继续开始数，继续删，直到剩下一个元素，输出该元素，结束。
另一种解法：http://www.cnblogs.com/iuices/archive/2011/11/07/2240325.html（建立链表的方式不同）

#include<iostream>
using namespace std;

struct node     //typedef struct _node
{               //{
	int num;    //     int num;
	node* next; //     struct _node* next;
};              //}node;

node* creat(int n)
{
	node *p,*q,*head;
	p=new node;
	p->num=1;
	head=p;
	for(int i=2;i<=n;i++)
	{
		q=new node;
		q->num=i;
		p->next=q;
		p=q;
	}
	p->next=head;
	return head;
}

void link_process(node* head,int k,int m)
{
	node *p=head,*temp;
	while(p->num!=k)
		p=p->next;
	while(p->next!=p)
	{
		for(int i=0;i<m-1;i++)
		{
			temp=p;
			p=p->next;
		}
		cout<<p->num<<endl;
		temp->next=p->next;
		delete p;
		p=temp->next;
	}
	cout<<p->num<<endl;
}

void main()
{
	int n,k,m;
	cin>>n>>k>>m;
	node *head=creat(n);
	link_process(head,k,m);
}







评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值