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

1.    

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

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

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

#include <iostream>  
 using namespace std;  
  
void Stringchang(const char *input,char *output)  
{  
    for(int i=0;i<100;i++)  
    {  
        output[i]='\0';  
        if (input[i]=='\0') break;  
        else  
        {  
            if((input[i]>='a'&&input[i]<='z')||(input[i]>='A'&&input[i]<='Z')) output[i]=input[i]+1;  
            else output[i]=input[i];  
        }  
    }  
}  
void main()  
 {  
     char *input=new char[100];  
     char *output=new char[100];  
     cin>>input;  
     Stringchang(input,output);  
     cout<<output<<endl;  
     delete input,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;  
} 

注：将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.

删除子串，只要是原串中有相同的子串就删掉，不管有多少个，返回子串个数

#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（建立链表的方式不同）