算法-蓝桥杯习题（二）

蓝桥杯习题

蓝桥杯练习系统习题加答案更新新地址（已更新200左右习题）

http://blog.csdn.net/rodestillfaraway 

---

目录

算法训练（详见 算法-蓝桥杯习题（一））Go

算法训练（详见 算法-蓝桥杯习题（二））Go

算法提高（waiting...）

历届试题（详见 算法-蓝桥杯习题（六））Go

历届试题（详见 算法-蓝桥杯习题（七））Go

---

蓝桥杯练习系统评测数据

链接：

http://pan.baidu.com/s/1mhophTQ

密码: m2pa

---

算法训练（111题）

 

/*
算法训练 明明的随机数

问题描述
　　明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤100），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。
输入格式
　　输入有2行，第1行为1个正整数，表示所生成的随机数的个数：
　　N
　　第2行有N个用空格隔开的正整数，为所产生的随机数。
输出格式
　　输出也是2行，第1行为1个正整数M，表示不相同的随机数的个数。第2行为M个用空格隔开的正整数，为从小到大排好序的不相同的随机数。
样例输入
10
20 40 32 67 40 20 89 300 400 15
样例输出
8
15 20 32 40 67 89 300 400
题目来源
　　计13李震摘编自NOIP06PJ01
*/
#include <stdio.h>
#define MaxSize 100+5

void printArray(int array[],int lenth)
{
    int i;
    
    printf("%d
",lenth);
    for(i=0;i<lenth;i++)
    {
        printf("%d ",array[i]);
    }
    printf("
");
    
    return ;
} 

void sortArray(int array[],int lenth)
{
    int i,j;
    
    for(i=0;i<lenth;i++)
    {
        for(j=lenth-1;j>i;j--)
        {
            if(array[j]<array[j-1])
            {
                int temp;
                temp=array[j];
                array[j]=array[j-1];
                array[j-1]=temp;
            }
        }
    }
    
    return ;
} 

main()
{
    int N,m,i,j;
    int array[MaxSize];
    
    scanf("%d",&N);
    m=N;
    for(i=0;i<m;i++)
    {
        scanf("%d",&array[i]);
        for(j=0;j<i;j++)
        {
            if(array[i]==array[j])
            {
                i--;
                m--;
                continue;
            }
        }
    }
    
    sortArray(array,m);
    
    printArray(array,m);
    
    return 0;
}

/*
算法训练 字符串的展开

　　在初赛普及组的“阅读程序写结果”的问题中，我们曾给出一个字符串展开的例子：如果在输入的字符串中，含有类似于“d-h”或者“4-8”的字串，我们就把它当作一种简写，输出时，用连续递增的字母获数字串替代其中的减号，即，将上面两个子串分别输出为“defgh”和“45678”。在本题中，我们通过增加一些参数的设置，使字符串的展开更为灵活。具体约定如下：
　　(1) 遇到下面的情况需要做字符串的展开：在输入的字符串中，出现了减号“-”，减号两侧同为小写字母或同为数字，且按照ASCII码的顺序，减号右边的字符严格大于左边的字符。
　　(2) 参数p1：展开方式。p1=1时，对于字母子串，填充小写字母；p1=2时，对于字母子串，填充大写字母。这两种情况下数字子串的填充方式相同。p1=3时，不论是字母子串还是数字字串，都用与要填充的字母个数相同的星号“*”来填充。
　　(3) 参数p2：填充字符的重复个数。p2=k表示同一个字符要连续填充k个。例如，当p2=3时，子串“d-h”应扩展为“deeefffgggh”。减号两边的字符不变。
　　(4) 参数p3：是否改为逆序：p3=1表示维持原来顺序，p3=2表示采用逆序输出，注意这时候仍然不包括减号两端的字符。例如当p1=1、p2=2、p3=2时，子串“d-h”应扩展为“dggffeeh”。
　　(5) 如果减号右边的字符恰好是左边字符的后继，只删除中间的减号，例如：“d-e”应输出为“de”，“3-4”应输出为“34”。如果减号右边的字符按照ASCII码的顺序小于或等于左边字符，输出时，要保留中间的减号，例如：“d-d”应输出为“d-d”，“3-1”应输出为“3-1”。
输入格式
　　输入包括两行：
　　第1行为用空格隔开的3个正整数，一次表示参数p1，p2，p3。
　　第2行为一行字符串，仅由数字、小写字母和减号“-”组成。行首和行末均无空格。
输出格式
　　输出只有一行，为展开后的字符串。
输入输出样例1
输入格式
输出格式
1 2 1
abcs-w1234-9s-4zz
abcsttuuvvw1234556677889s-4zz
输入输出样例2
输入格式
输出格式
2 3 2
a-d-d
aCCCBBBd-d
输入输出样例3
输入格式
输出格式
3 4 2
di-jkstra2-6
dijkstra2************6
数据规模和约定
　　40%的数据满足：字符串长度不超过5
　　100%的数据满足：1<=p1<=3，1<=p2<=8，1<=p3<=2。字符串长度不超过100
*/
#include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 void fill(char a)
 {
 }
 int main()
 {
     char s[120]={0};
     memset(s,0,sizeof(s));
     int p1,p2,p3,i,j,k;
     scanf("%d%d%d",&p1,&p2,&p3);
     scanf("%s",s);
     for(i=0;i<strlen(s);i++)
     {
         if(s[i]=='-')
         {
             if(s[i-1]>='a' && s[i-1]<='z' && s[i+1]>='a' && s[i+1]<='z' && s[i+1]>s[i-1]
             || s[i-1]>='0' && s[i-1]<='9' && s[i+1]>='0' && s[i+1]<='9' && s[i+1]>s[i-1])
             {
                 if(p1==3)
                 {
                     for(j=1;j<=p2*(s[i+1]-s[i-1]-1);j++)
                     {
                         printf("*");
                     }
                 }
                 else
                 {
                     if(s[i-1]>='0' && s[i-1]<='9' && s[i+1]>='0' && s[i+1]<='9')
                     {
                         if(p3==1)
                         {
                             for(j=s[i-1]+1;j<=s[i+1]-1;j++)
                             {
                                 for(k=1;k<=p2;k++)
                                 {
                                     printf("%c",j);
                                 }
                             }
                         }
                         else
                         {
                             for(j=s[i+1]-1;j>=s[i-1]+1;j--)
                             {
                                 for(k=1;k<=p2;k++)
                                 {
                                     printf("%c",j);
                                 }
                             }
                         }
                     }
                     else
                     {
                         if(p3==1)
                         {
                             for(j=s[i-1]+1;j<=s[i+1]-1;j++)
                             {
                                 for(k=1;k<=p2;k++)
                                 {
                                     printf("%c",p1==1?j:j-32);
                                 }
                             }
                         }
                         else
                         {
                             for(j=s[i+1]-1;j>=s[i-1]+1;j--)
                             {
                                 for(k=1;k<=p2;k++)
                                 {
                                     printf("%c",p1==1?j:j-32);
                                 }
                             }
                         }
                     }
                 }
             }
             else
             {
                 printf("%c",s[i]);
             }
         }
         else
         {
             printf("%c",s[i]);
         }
     }
     return 0;
 }

/*
算法训练 貌似化学

问题描述
　　现在有a,b,c三种原料，如果他们按x:y:z混合，就能产生一种神奇的物品d。
　　当然不一定只产生一份d，但a,b,c的最简比一定是x:y:z
　　现在给你3种可供选择的物品:
　　每个物品都是由a,b,c以一定比例组合成的，求出最少的物品数，使得他们能凑出整数个d物品（这里的最少是指三者个数的总和最少）
输入格式
　　第一行三个整数，表示d的配比（x,y,z）
　　接下来三行，表示三种物品的配比，每行三个整数（<=10000）。
输出格式
　　四个整数，分别表示在最少物品总数的前提下a,b,c,d的个数（d是由a,b,c配得的）
　　目标答案<=10000
　　如果不存在满足条件的方案，输出NONE
样例输入
3 4 5
1 2 3
3 7 1
2 1 2
样例输出
8 1 5 7
*/

/*
算法训练 最大体积

问题描述
　　每个物品有一定的体积（废话），不同的物品组合，装入背包会战用一定的总体积。假如每个物品有无限件可用，那么有些体积是永远也装不出来的。为了尽量装满背包，附中的OIER想要研究一下物品不能装出的最大体积。题目保证有解，如果是有限解，保证不超过2，000，000，000
　　如果是无限解，则输出0
输入格式
　　第一行一个整数n（n<=10），表示物品的件数
　　第2行到N+1行: 每件物品的体积(1<= <=500)
输出格式
　　一个整数ans，表示不能用这些物品得到的最大体积。
样例输入
3
3
6
10
样例输出
17
*/
#include <stdio.h>
int n;
int a[510];
int f[100001];
void swap(int *a,int *b)
{
   int c;
   c=*a;
   *a=*b;
   *b=c;
}
int gcd(int a,int b)
{
    if(a>b)
      swap(&a,&b);
    if(a==0)
      return b;
    return gcd(b%a,a);
}
int main()
{
    int i,j,t;
    scanf("%d",&n);
    for(i=1;i<=n;i++)
        scanf("%d",&a[i]);
    t=a[1];
    for(i=2;i<=n;i++)
        t=gcd(t,a[i]);
    if(t!=1)
    {
        printf("0
");
        return 0;
    }
    else
    {
          f[0]=1;
          for(i=1;i<=n;i++)
          {
              for(j=a[i];j<=65536;j++)
                  f[j] |= f[j-a[i]];
          }
          for(i=65536;i>=0;i--)
          {
              if(!f[i])
              {
                  printf("%d
",i);
                  return 0;
              }
          }
          printf("0
");
          return 0;
    }
}

/*
算法训练 9-7链表数据求和操作

　　读入10个复数，建立对应链表，然后求所有复数的和。
样例输入
1 2
1 3
4 5
2 3
3 1
2 1
4 2
2 2
3 3
1 1
样例输出
23+23i
*/
#include <stdio.h>

main()
{
    int i,j,k,time=10,m=0,n=0;
    
    for(k=0;k<time;k++)
    {
        scanf("%d%d",&i,&j);
        m+=i;
        n+=j;
    }
    
    printf("%d+%di
",m,n);
    
    return 0;
}
/*
#include <stdio.h>
#include <malloc.h>
typedef struct linknode
{
    int x;
    int y;
    struct linknode *next;
}node;

int main()
{
node *begin=(node *)malloc(sizeof(node));
node *q=begin,*p;
int m=0,n=0;
scanf("%d%d",&q->x,&q->y);
int i;
for(i=1;i<10;i++)
{
    p=(node *)malloc(sizeof(node));
    scanf("%d%d",&p->x,&p->y);
    q->next=p;
    q=p;
}
p->next=NULL;
while(begin!=NULL)
{

   m+=begin->x;    
   n+=begin->y;
   begin=begin->next;    
}
printf("%d+%di",m,n);
    return 0;
}
*/

/*
 算法训练 6-3判定字符位置
 
 返回给定字符串s中元音字母的首次出现位置。英语元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五个。
　　若字符串中没有元音字母，则返回0。
　　只考虑小写的情况。
样例输入
and
样例输出
1
*/
#include <stdio.h>
#include <string.h>
#define MaxSize 1000

main()
{
    char str[MaxSize];
    int lenth,i;
    
    gets(str);
    lenth=strlen(str);
    
    for(i=0;i<lenth;i++)
    {
        if(str[i]=='a'||str[i]=='e'||str[i]=='i'||str[i]=='o'||str[i]=='u')
        {
            printf("%d
",i+1);
            return 0;

        }
    }
    printf("0
");
    
    return 0;
}

/*
算法训练 黑色星期五

问题描述
　　有些西方人比较迷信，如果某个月的13号正好是星期五，他们就会觉得不太吉利，用古人的说法，就是“诸事不宜”。请你编写一个程序，统计出在某个特定的年份中，出现了多少次既是13号又是星期五的情形，以帮助你的迷信朋友解决难题。
　　说明：（1）一年有365天，闰年有366天，所谓闰年，即能被4整除且不能被100整除的年份，或是既能被100整除也能被400整除的年份；（2）已知1998年1月1日是星期四，用户输入的年份肯定大于或等于1998年。
　　输入格式：输入只有一行，即某个特定的年份（大于或等于1998年）。
　　输出格式：输出只有一行，即在这一年中，出现了多少次既是13号又是星期五的情形。
　　输入输出样例
样例输入
1998
样例输出
3
*/
#include <stdio.h>

int getWeekOfFirstDay(int year)
{
    //已知1998年1月1日是星期四
    int i=1998,week=3;
    int days=0;
    
    for(i=1998;i<year;i++)
    {
        if(i%400==0||(i%4==0&&i%100!=0))
        days+=366;
        else
        days+=365;
    }
    
    return (days+week)%7;
}

void printBlackFridayTimes(int year)
{
    int day[2][12]={{31,28,31,30,31,30,31,31,30,31,30},{31,29,31,30,31,30,31,31,30,31,30}};
    int week=getWeekOfFirstDay(year),flag=year%400==0||(year%4==0&&year%100!=0)?1:0;
    int times=0,i,days=0;
    
    //遍历12个月 
    for(i=0;i<12;i++)
    {
        //判断每个月13号是否是黑色星期五 
        if((days+12+week)%7==4)
        times++;
        
        days+=day[flag][i]; 
    }
    
    printf("%d
",times);
    return ;
} 

main()
{
    int year;

    scanf("%d",&year);
    printBlackFridayTimes(year);
    
    return 0;
}

/*
算法训练 阿尔法乘积

问题描述
　　计算一个整数的阿尔法乘积。对于一个整数x来说，它的阿尔法乘积是这样来计算的：如果x是一个个位数，那么它的阿尔法乘积就是它本身；否则的话，x的阿尔法乘积就等于它的各位非0的数字相乘所得到的那个整数的阿尔法乘积。例如：4018224312的阿尔法乘积等于8，它是按照以下的步骤来计算的：
　　4018224312 → 4*1*8*2*2*4*3*1*2 → 3072 → 3*7*2 → 42 → 4*2 → 8
　　编写一个程序，输入一个正整数（该整数不会超过6,000,000），输出它的阿尔法乘积。
　　输入格式：输入只有一行，即一个正整数。
　　输出格式：输出相应的阿尔法乘积。
　　输入输出样例
样例输入
4018224312
样例输出
8
*/
#include <stdio.h>

void getResult(long long int num)
{
    long long  int n=1;
    int i;
    
    //出口设计
    if(num<10)
    {
        printf("%I64d
",num);
        
        return ;
    }
    
    //相似设计
    do
    {
        i=num%10;
        num/=10;
        if(i)
        {
            n*=i;
        }
    }
    while(num);
    
    //递归调用 
    getResult(n);
    
}

main()
{
    long long int num;
    
    scanf("%I64d",&num);
    getResult(num);
    
    return 0; 
}

/*
算法训练 完数

问题描述
　　一个数如果恰好等于它的因子之和，这个数就称为“完数”。例如，6的因子为1、2、3，而6＝1＋2＋3，因此6就是“完数”。又如，28的因子为1、2、4、7、14，而28＝1＋2＋4＋7＋14，因此28也是“完数”。编写一个程序，判断用户输入的一个数是否为“完数”。
　　输入格式：输入只有一行，即一个整数。
　　输出格式：输出只有一行，如果该数为完数，输出yes，否则输出no。
　　输入输出样例
样例输入
6
样例输出
yes
*/
#include <stdio.h>

void getResult(int num)
{
    int i,sum=0;
    
    for(i=1;i<num;i++)
    {
        if(num%i==0)
        {
            sum+=i;
        }
    }
    
    if(sum==num)
    {
        printf("yes
");
    }
    else
    {
        printf("no
");
    }
    
}

main()
{
    int num;
    
    scanf("%d",&num);
    getResult(num);
    
    return 0;
}

/*
算法训练 数对

问题描述
　　编写一个程序，该程序从用户读入一个整数，然后列出所有的数对，每个数对的乘积即为该数。
　　输入格式：输入只有一行，即一个整数。
　　输出格式：输出有若干行，每一行是一个乘法式子。（注意：运算符号与数字之间有一个空格）
　　输入输出样例
样例输入
32
样例输出
1 * 32 = 32
2 * 16 = 32
4 * 8 = 32
8 * 4 = 32
16 * 2 = 32
32 * 1 = 32
*/
#include <stdio.h>

void getResult(int num)
{
    int i;
    
    for(i=1;i<=num;i++)
    {
        if(num%i==0)
        {
            printf("%d * %d = %d
",i,num/i,num);
        }
    }
    
    return ;
}

main()
{
    int num;
    
    scanf("%d",&num);
    
    getResult(num);
    
    return 0;
}

/*
算法训练 整除问题

问题描述
　　编写一个程序，输入三个正整数min、max和factor，然后对于min到max之间的每一个整数（包括min和max），如果它能被factor整除，就把它打印出来。
　　输入格式：输入只有一行，包括三个整数min、max和factor。
　　输出格式：输出只有一行，包括若干个整数。
　　输入输出样例
样例输入
1 10 3
样例输出
3 6 9
*/
#include <stdio.h>

void getResult(int min,int max,int factor)
{
    int i;
    
    for(i=min;i<=max;i++)
    {
        if(i%factor==0)
        {
            printf("%d ",i);
        }
    }
    printf("
");
    
    return ;
}

main()
{
    int min,max,factor;
    
    scanf("%d%d%d",&min,&max,&factor);
    getResult(min,max,factor);
    
    return 0;
}

/*
算法训练 薪水计算

问题描述
　　编写一个程序，计算员工的周薪。薪水的计算是以小时为单位，如果在一周的时间内，员工工作的时间不超过40 个小时，那么他/她的总收入等于工作时间乘以每小时的薪水。如果员工工作的时间在40 到50 个小时之间，那么对于前40 个小时，仍按常规方法计算；而对于剩余的超额部分，每小时的薪水按1.5 倍计算。如果员工工作的时间超过了50 个小时，那么对于前40 个小时，仍按常规方法计算；对于40～50 个小时之间的部分，每小时的薪水按1.5 倍计算；而对于超出50 个小时的部分，每小时的薪水按2 倍计算。请编写一个程序，输入员工的工作时间和每小时的薪水，然后计算并显示他/她应该得到的周薪。
　　输入格式：输入只有一行，包括一个整数和一个实数，分别表示工作时间和每小时薪水。
　　输出格式：输出只有一个实数，表示周薪，保留小数点后2位。
　　输入输出样例
样例输入
40 50
样例输出
2000.00
*/
#include <stdio.h>

main()
{
    int time;
    float money,sum;
    
    scanf("%d%f",&time,&money);
    if(time<=40)
    {
        sum=time*money;
        printf("%.2f
",sum);
    }
    else
    {
        time-=40;
        if(time<=10)
        {
            sum=time*money*1.5+40*money;
            printf("%.2f
",sum);
        }
        else
        {
            time-=10;
            sum=time*money*2+10*money*1.5+40*money;
            printf("%.2f
",sum);
        }
    }
    
    return 0;
}

/*
算法训练 数位分离

问题描述
　　编写一个程序，输入一个1000 以内的正整数，然后把这个整数的每一位数字都分离出来，并逐一地显示。
　　输入格式：输入只有一行，即一个1000以内的正整数。
　　输出格式：输出只有一行，即该整数的每一位数字，之间用空格隔开。
　　输入输出样例
样例输入
769
样例输出
7 6 9
*/
#include <stdio.h>

void getResult(int num)
{
    //出口 
    if(num<10)
    {
        printf("%d ",num);
        return ;
    }
    //递归 
    getResult(num/10);
    
    printf("%d ",num%10);
}

main()
{
    int n;
    
    scanf("%d",&n);
    getResult(n);
    printf("
"); 
    
    return 0;
}

/*
算法训练 Hello World!

描述
　　本题定义本学期作业题的输出格式，请认真阅读。
　　如无特殊说明，开头无空格，间隔符为1个空格，答案最后必须输出换行符("
")。
输入格式
　　无
输出格式
　　Hello World!
*/
#include <stdio.h>

main()
{
    printf("Hello World!
");
    
    return 0;
}

/*
算法训练 新生舞会

问题描述
　　新生舞会开始了。n名新生每人有三个属性：姓名、学号、性别。其中，姓名用长度不超过20的仅由大小写字母构成的字符串表示，学号用长度不超过10的仅由数字构成的字符串表示，性别用一个大写字符‘F’或‘M’表示。任意两人的姓名、学号均互不相同。换言之，每个人可被其姓名或学号唯一确定。给出m对两人的信息（姓名或学号），判断他们是否能共舞。两人能共舞的充要条件为两人性别相异。
输入格式
　　第一行一个整数n（2<=n<=1000），表示学生人数。接下来的n行每行依次包含一名新生的姓名、学号、性别，分别用一个空格隔开。
　　之后的一行是一个整数m(1<=m<=1000)，表示询问的数目。接着的m行每行包含两个信息（姓名或学号），保证两个信息不属于同一人，中间用一个空格隔开。
输出格式
　　对于每个询问输出一行，如果两人可以共舞，输出一个大写字母‘Y’，否则输出一个大写字母‘N’。
样例输入
4
John 10 M
Jack 11 M
Kate 20 F
Jim 21 M
3
John 11
20 Jack
Jim Jack
样例输出
N
Y
N

提示
可以把名字和学号都当成字符串处理。可以按以下流程实现。

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

struct tstudent
{
char name[21];
char num[21];
char sex;
};

void readdata(tstudent student[], int n)
{
输入N个学生的信息
}

int findstudent(tstudent student[], int n, char* data)
{
if (data == NULL) return -1;

判断是否有某个学生的学号或名字等于data，如果有，函数返回该学生在student数组中的序号，否则返回-1
}

void solve(tstudent student[], int n, int m)
{
char x[21], y[21];
for (int i=0; i<m; i++) {
输入两个人的信息X、Y。通过调用findstudent函数判断这两个人能否成为舞伴
}
}

int main()
{
int n, m;
tstudent student[1010];

cin>>n;

readdata(student, n);
cin>>m;
solve(student, n, m);
}
*/
#include <stdio.h>
#include <string.h>
#define MaxSize 1000+5

typedef struct
{
    char name[21];
    char num[21];
    char sex;
}tstudent;

void readdata(tstudent student[], int n)
{
    int i;
    //输入N个学生的信息
    for(i=0;i<n;i++)
    {
        scanf("%s %s %c",student[i].name,student[i].num,&student[i].sex);
    }
}

int findstudent(tstudent student[], int n, char* data)
{
    int i;
    
    if (data == NULL) 
    {
        return -1;
    }
    //判断是否有某个学生的学号或名字等于data，如果有，函数返回该学生在student数组中的序号，否则返回-
    for(i=0;i<n;i++)
    {
        if(!strcmp(data,student[i].name)||!strcmp(data,student[i].num))
        return i;
    }
    
    return -1;
}

void solve(tstudent student[], int n, int m)
{
    char x[21], y[21];
    int i,a,b;
    
    for (i=0; i<m; i++) 
    {
        //输入两个人的信息X、Y。通过调用findstudent函数判断这两个人能否成为舞伴
        scanf("%s %s",x,y);
        if((a=findstudent(student,n,x))!=-1&&(b=findstudent(student,n,y))!=-1)
        {
            if(student[a].sex!=student[b].sex)
            printf("Y
");
            else
            printf("N
");
        }
        else
        {
            printf("N
");
        }
    }
}

int main()
{
    int n, m;
    tstudent student[MaxSize];
    
    scanf("%d",&n);
    readdata(student, n);
    
    scanf("%d",&m);
    solve(student, n, m);
    
    return ;
}

/*
算法训练 反置数

问题描述
　　一个整数的“反置数”指的是把该整数的每一位数字的顺序颠倒过来所得到的另一个整数。如果一个整数的末尾是以0结尾，那么在它的反置数当中，这些0就被省略掉了。比如说，1245的反置数是5421，而1200的反置数是21。请编写一个程序，输入两个整数，然后计算这两个整数的反置数之和sum，然后再把sum的反置数打印出来。要求：由于在本题中需要多次去计算一个整数的反置数，因此必须把这部分代码抽象为一个函数的形式。
　　输入格式：输入只有一行，包括两个整数，中间用空格隔开。
　　输出格式：输出只有一行，即相应的结果。
　　输入输出样例
样例输入
435 754
样例输出
199
*/
#include <stdio.h>
#include <math.h>

int getTheNumber(int num)
{
    int number=1,i,j=1,flag=0;
    
    if(!num)
    return 0;
    
    while(num)
    {
        i=num%10;
        if(i||flag)
        {
            if(!flag)
            {
                number=i;
            }
            else
            {
                number=number*10+i;
            }
            flag=1;
        }
        num/=10;
    }
    
    return number;
}

main()
{
    int n,m;
    
    scanf("%d%d",&n,&m);
    
    printf("%d
",getTheNumber(getTheNumber(n)+getTheNumber(m)));
    
    return 0;
}

/*
算法训练 字符删除

问题描述
　　编写一个程序，先输入一个字符串str（长度不超过20），再输入单独的一个字符ch，然后程序会把字符串str当中出现的所有的ch字符都删掉，从而得到一个新的字符串str2，然后把这个字符串打印出来。
　　输入格式：输入有两行，第一行是一个字符串（内部没有空格），第二行是一个字符。
　　输出格式：经过处理以后的字符串。
　　输入输出样例
样例输入
123-45-678
-
样例输出
12345678
*/
#include <stdio.h>
#include <string.h>
#define MaxSize 20+5

void printResult(char str[],char ch)
{
    int i;
    for(i=0;i<strlen(str);i++)
    {
        if(str[i]!=ch)
        {
            printf("%c",str[i]);
        }
    }
    printf("
");
}

main()
{
    char ch,str[MaxSize];
    
    //if(scanf("%s %c",str,&ch)!=EOF)
    if(gets(str)!=NULL)
    {
        scanf("%c",&ch);
        printResult(str,ch);
    }
    
    return 0;
}

/*
算法训练 字串统计

问题描述
　　给定一个长度为n的字符串S，还有一个数字L，统计长度大于等于L的出现次数最多的子串（不同的出现可以相交），如果有多个，输出最长的，如果仍然有多个，输出第一次出现最早的。
输入格式
　　第一行一个数字L。
　　第二行是字符串S。
　　L大于0，且不超过S的长度。
输出格式
　　一行，题目要求的字符串。

　　输入样例1：
　　4
　　bbaabbaaaaa

　　输出样例1：
　　bbaa

　　输入样例2：
　　2
　　bbaabbaaaaa

　　输出样例2：
　　aa
数据规模和约定
　　n<=60
　　S中所有字符都是小写英文字母。

　　提示
　　枚举所有可能的子串，统计出现次数，找出符合条件的那个
*/
#include<stdio.h>
#include<string.h>
char b[60][60];
int c[60];
int main()
{
    int l,i1,max=1,now=0,maxn=1,i2,weizhi=0,i3,i4,weizhi1,changdu1=-1;
    
    char a[10000];
    scanf("%d",&l);
    getchar();
    gets(a);
    int n=strlen(a);
    
    for(i1=n;i1>=l;i1--)//长度 
    {
        weizhi=0;
         for(i3=0;i3<n-i1;i3++)
                c[i3]=0;
        for(i2=0;i2<n;i2++)//开始位置 
        {
            if(i2+i1>n) 
              break;
            int ok=1;      
           

            for(i3=0;i3<weizhi;i3++)//b的位置 
            {     int ko=1;
                  for(i4=0;i4<i1;i4++)    
                   {  
                         if(b[i3][i4]!=a[i2+i4])
                             ko=0;
                             
                      }
                      if(ko)
                        {  ok=0;
                           c[i3]++;
                        if(c[i3]>max)
                           {max=c[i3];
                            changdu1=i1;
                            weizhi1=i2;
                           }
                        break;
                     }
            
            }
            
            if(ok)
            {
                for(i4=0;i4<i1;i4++)
                {
                    b[weizhi][i4]=a[i2+i4];
                }
                c[weizhi]=1;
                weizhi++;
            }
            
            
        }
        
    
        
    }

    for(i1=weizhi1;i1<weizhi1+changdu1;i1++)
      printf("%c",a[i1]);
      printf("
");
    return 0;
}

/*
算法训练 进制转换

问题描述
　　编写一个程序，输入一个二进制的字符串（长度不超过32），然后计算出相应的十进制整数，并把它打印出来。
　　输入格式：输入为一个字符串，每个字符都是’0’或’1’，字符串的长度不超过32。
　　输出格式：输出一个整数。
　　输入输出样例
样例输入
1101
样例输出
13
*/
#include <stdio.h>
#include <math.h>
#include <string.h>
#define MaxSize 32

void print2Return10(char str[])
{
    long long int num=0;
    int lenth=strlen(str),i;
    
    for(i=0;i<lenth;i++)
    {
        if(str[i]!='0')
        {
            num+=pow(2,lenth-i-1);
        }
    }
    
    printf("%lld
",num);
    
    return ;
}

main()
{
    char str[MaxSize];
    
    gets(str);
    print2Return10(str);
    
    return 0;
}

/*
算法训练 阶乘

问题描述
　　一个整数n的阶乘可以写成n!，它表示从1到n这n个整数的乘积。阶乘的增长速度非常快，例如，13!就已经比较大了，已经无法存放在一个整型变量中；而35!就更大了，它已经无法存放在一个浮点型变量中。因此，当n比较大时，去计算n!是非常困难的。幸运的是，在本题中，我们的任务不是去计算n!，而是去计算n!最右边的那个非0的数字是多少。例如，5! = 1*2*3*4*5 = 120，因此5!最右边的那个非0的数字是2。再如：7! = 5040，因此7!最右边的那个非0的数字是4。请编写一个程序，输入一个整数n(n<=100)，然后输出n! 最右边的那个非0的数字是多少。
　　输入格式：输入只有一个整数n。
　　输出格式：输出只有一个整数，即n! 最右边的那个非0的数字。
　　输入输出样例
样例输入
6
样例输出
2
*/
#include<stdio.h>

int main(void)
{
    int n;
    int i;
    int sum=1;
    scanf("%d",&n);

    for(i=n;i>=1;i--)
    {
        sum = sum*i;
        while(sum%10==0)
            sum=sum/10;
        if(sum/100>0)
            sum=sum%100;
    }

    printf("%d",sum%10);
    
    return 0;
}

/*
算法训练 输出米字形

根据输入的正整数n (1　　米字形由一个(2n-1)*(2n-1)的矩阵组成，矩阵包含从大写A开始的n个字母
　　例如:n=3时，包含A,B,C；n=4时，包含A,B,C,D。
　　矩阵的正中间为n个字母中字典序最大的那个，从这个字母开始，沿着西北、正北、东北、正西、正东、西南、正南、东南八个方向各有一条由大写字母组成的直线。并且直线上的字母按字典序依次减小，直到大写字母A。
　　矩阵的其它位置用英文句号．填充。

　　样例输入一
　　3

　　样例输出一
　　Ａ．Ａ．Ａ
　　．ＢＢＢ．
　　ＡＢＣＢＡ
　　．ＢＢＢ．
　　Ａ．Ａ．Ａ

　　样例输入二
　　4

　　样例输出二
　　Ａ．．Ａ．．Ａ
　　．Ｂ．Ｂ．Ｂ．
　　．．ＣＣＣ．．
　　ＡＢＣＤＣＢＡ
　　．．ＣＣＣ．．
　　．Ｂ．Ｂ．Ｂ．
　　Ａ．．Ａ．．Ａ
*/
#include <stdio.h>
int main()
{
    int n,i,j,k,t;
    scanf("%d",&n);
    char a[2*n-1][2*n-1];
    for(i=0;i<2*n-1;i++)
    for(j=0;j<2*n-1;j++)
    a[i][j]=0;
    k=n;
    
    for(i=0;i<n-1;i++) //行数 
    {
        k--;  //k为字符间隔 
        t=i;
        for(j=1;j<=3;j++)
        {
          a[i][t]='A'+i;
          t+=k;
        }
    }
    for(i=0;i<n;i++)    //中间一行 
    {
        a[n-1][i]='A'+i;
        a[n-1][2*n-2-i]='A'+i;
    }
    for(i=0;i<=n-2;i++)   //填补句号 
    for(j=0;j<2*n-1;j++)
    {
        if(a[i][j]==0)
        a[i][j]='.';
    }
    
    for(i=0;i<=n-2;i++)    //翻转 
    for(j=0;j<2*n-1;j++)
    a[2*n-2-i][j]=a[i][j];
    
    for(i=0;i<2*n-1;i++)
    {
    for(j=0;j<2*n-1;j++)
    printf("%c",a[i][j]);
    printf("
"); 
    }

    
    return 0;
}

/*
算法训练 整数平均值

编写函数，求包含n个元素的整数数组中元素的平均值。要求在函数内部使用指针操纵数组元素，其中n个整数从键盘输入，输出为其平均值。　　样例输入: （输入格式说明：5为输入数据的个数，3 4 0 0 2 是以空格隔开的5个整数）
　　5
　　3 4 0 0 2
样例输出
1
样例输入
7
3 2 7 5 2 9 1
样例输出
4
*/
#include <stdio.h>
int main()
{
int n,i,j,sum=0;
scanf("%d",&n);
for(i=0;i<n;i++)
{
scanf("%d",&j);
sum+=j;
}
printf("%d",sum/n);
return 0;
}

/*
算法训练 确定元音字母位置

输入一个字符串，编写程序输出该字符串中元音字母的首次出现位置，如果没有元音字母输出0。英语元音字母只有‘a’、‘e’、‘i’、‘o’、‘u’五个。
样例输入
hello
样例输出
2
样例输入
apple
样例输出
1
样例输入
pmp
样例输出
0
*/
#include <stdio.h>
#include <string.h>
char s[1000]={0};
int isyuanyin(char a)
{
switch(a)
{
case 'a':return 1;
case 'e':return 1;
case 'i':return 1;
case 'o':return 1;
case 'u':return 1;
}
return 0;
}
int main()
{
int l,i,num=0;
scanf("%s",s);
l=strlen(s);
for(i=0;i<l;i++)
if(isyuanyin(s[i]))
{
num=i+1;break;
}
printf("%d",num);
return 0;
}

/*
算法训练 斜率计算

　　输入两个点的坐标，即p1 = (x1, y1)和p2=(x2, y2)，求过这两个点的直线的斜率。如果斜率为无穷大输出“INF”。
样例输入
1 2
2 4
样例输出
2
样例输入
1 2
1 4
样例输出
INF
样例输入
1 2
3 2
样例输出
0
*/
#include <stdio.h>
int main(){
  int a,b,c,d;
  scanf("%d %d",&a,&b);
  scanf("%d %d",&c,&d);
  if(a==c)
      printf("INF
");
  else 
      printf("%d
",(b-d)/(a-c));

  return 0;
}

/*
算法训练 十进制数转八进制数

　　编写函数把一个十进制数输出其对应的八进制数。
样例输入
9274
样例输出
22072
*/
#include<stdio.h>
int main()
{
    int r;
    scanf("%d",&r);
    printf("%o",r);
    return 0;
}

/*
算法训练 筛选号码

问题描述
　　有n个人围成一圈，顺序排号（编号为1到n）。从第1个人开始报数(从1到3报数)，凡报到3的人退出圈子。从下一个人开始继续报数，直到剩下最后一个人，游戏结束。
　　问最后留下的是原来第几号的那位。
　　举个例子，8个人围成一圈：
　　1 2 3 4 5 6 7 8
　　第1次报数之后，3退出，剩下：
　　1 2 4 5 6 7 8    （现在从4开始报数）
　　第2次报数之后，6退出，剩下：
　　1 2 4 5 7 8     （现在从7开始报数）
　　第3次报数之后，1退出，剩下：
　　2 4 5 7 8     （现在从2开始报数）
　　第4次报数之后，5退出，剩下：
　　2 4 7 8     （现在从7开始报数）
　　第5次报数之后，2退出，剩下：
　　4 7 8     （现在从4开始报数）
　　第6次报数之后，8退出，剩下：
　　4 7     （现在从4开始报数）
　　最后一次报数之后，4退出，剩下：
　　7.
　　所以，最后留下来的人编号是7。
输入格式
　　一个正整数n，(1<n<10000)
输出格式
　　一个正整数，最后留下来的那个人的编号。
样例输入
8
样例输出
7
数据规模和约定
　　对于100%的数据，1<n<10000。
*/
#include <stdio.h> 
#include <malloc.h> 
typedef struct form{ 
    int num; 
    int date; 
    struct form *link;} 
del; 
del *creat(int n){ 
int i; 
del *head,*p1,*p2; 
head=(del *)malloc(sizeof(del)); 
p1=(del *)malloc(sizeof(del)); 
head->link=p1; 
for(i=1;i<=n-2;i++){p2=(del *)malloc(sizeof(del)); 
p1->link=p2; 
p1=p2;} 
p1->link=head; 
return(head); 
} 
void dateop(del *h,int n){ 
    del *p; 
    int i,j=1; 
    p=h; 
    for(i=1;i<=n;i++){ 
    p->num=i; 
    p->date=j;j++; 
    if(j==4) j=1; 
    p=p->link;} 
} 
int deal(del *h,int n){ 
    del *k; 
    int s; 
    int count,j=1,i; 
    count=n; 
    k=h; 
    while(count!=1){ 
    if(j==3&&k->date!=0) {k->date=0;count--;} 
k=k->link; 
    j++; 
    if(k->date==0) j--; 
if(j==4) j=1; 
    } 
    k=h; 
    for(i=1;i<=n;i++){ 
    if(k->date!=0) {s=k->num;break;} 
    k=k->link;} 
    return(s);} 
int main(){ 
    int x; 
    int i; 
    del *p; 
    scanf("%d",&x); 
    p=creat(x); 
    dateop(p,x); 
    x=deal(p,x); 
    for(i=1;i<x;i++){ 
    p=p->link;} 
    printf("%d",p->num); 
return 0; 
}

/*
算法训练 连接字符串

　编程将两个字符串连接起来。例如country与side相连接成为countryside。
　　输入两行，每行一个字符串（只包含小写字母，长度不超过100）；输出一行一个字符串。
样例输入
country
side
样例输出
countryside
*/
#include<stdio.h>
#include<string.h>
int main()
{
    char s1[202],s2[202];
    scanf("%s",s1);
    scanf("%s",s2);
    strcat(s1,s2);
    printf("%s",s1);
    printf("
");
    return 0;
}

/*
算法训练 统计字符次数

　　输入一个字符串(长度在100以内)，统计其中数字字符出现的次数。
样例输入
Ab100cd200
样例输出
6
*/
#include<stdio.h>
int main()
{
    char a[101];
    int i=0,s=0;
    gets(a);
    for(i=0;*(a+i)!='';i++)
    {
        if(*(a+i)>=48&&*(a+i)<=57)
        s++;
    }
    printf("%d",s);
return 0;
}

/*
算法训练 成绩的等级输出

　　输入一个百分制的成绩t后，按下式输出它的等级。等级为：90~100为A，80~89为B，70~79为C，60~69为D，0~59为E。
样例输入
98
样例输出
A
*/
#include<stdio.h>
int main()
{
    int t;
    scanf("%d",&t);
    
    if(t>=90 && t<=100)
    printf("A
");
    
    if(t>=80 && t<=89)
    printf("B
");
    
    if(t>=70 && t<=79)
    printf("C
");
    
    if(t>=60 && t<=69)
    printf("D
");
    
    if(t<60)
    printf("E
");
    return 0;
}

/*
算法训练 比较字符串

　编程实现两个字符串s1和s2的字典序比较。（保证每一个字符串不是另一个的前缀，且长度在100以内）。若s1和s2相等，输出0；若它们不相等，则指出其第一个不同字符的ASCII码的差值：如果s1>s2，则差值为正；如果s1<s2，则差值为负。
样例输入
java basic
样例输出
8
*/
#include<stdio.h>
#include<string.h>
int min(int a,int b)
{
return a>b?b:a;
}
int main()
{
char a[1000];
char b[1000];
scanf("%s",a);
scanf("%s",b);
int k=min(strlen(a),strlen(b)),i1;
int ok=1;
for(i1=0;i1<k;i1++)
{       if(a[i1]!=b[i1])
        {   printf("%d
",a[i1]-b[i1]);
            ok=0;
             break;
         }
}
if(ok==1)
if(strlen(a)==strlen(b))
    printf("0
");
else if(strlen(a)>strlen(b))
     printf("%d
",a[i1]);
 else 
    printf("%d
",b[i1]);
return 0;  
}

 33333333333

33333333333333

3333333333333

/*
算法训练 最长字符串  
时间限制：1.0s   内存限制：512.0MB
       
　　求出5个字符串中最长的字符串。每个字符串长度在100以内，且全为小写字母。
样例输入
one two three four five
样例输出
three
*/
#include<stdio.h>
#include<string.h>
int main()
{
    char str[5][100];
    int len[5];
    int i,j,t,max;
    max=0;
    for(i=0;i<5;i++)
    {
        scanf("%s",str[i]);
        len[i]=strlen(str[i]);
        if(len[i]>max)
        {
            max=len[i];
            t=i;
        }    
    }
    puts(str[t]);
    return 0;
}

/*
  算法训练 字符串逆序  
时间限制：1.0s   内存限制：512.0MB
       
　　输入一个字符串，长度在100以内，按相反次序输出其中的所有字符。
样例输入
tsinghua
样例输出
auhgnist
*/
#include <stdio.h>
#include <string.h>
#define MaxSize 100

int main()
{
    char str[MaxSize];
    int lenth;
    
    gets(str);
    lenth=strlen(str);
    while(lenth--)
    {
        putchar(str[lenth]);
    }
    printf("
");
    
    return 0;
}

/*
  算法训练 判定数字  
时间限制：1.0s   内存限制：512.0MB
       
　　编写函数，判断某个给定字符是否为数字。
样例输入
9
样例输出
yes
*/
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]) 
{
    char x;
    scanf("%c",&x);
    if('0'<=x&&x<='9')
    {
        printf("yes");
    }
    else
    {
        printf("no");
    }
    return 0;
}

/*
  算法训练 最大值与最小值的计算  
时间限制：1.0s   内存限制：512.0MB
       
　　输入11个整数，计算它们的最大值和最小值。
样例输入
0 1 2 3 4 5 6 7 8 9 10
样例输出
10 0
*/
#include<stdio.h>
int main()
{
    int n;
    int a[11],i1,max=-234234,min=93759347;
    for(i1=0;i1<11;i1++)
    {
        scanf("%d",&a[i1]);
        if(max<a[i1])
          max=a[i1];
        if(min>a[i1])
           min=a[i1];
    }
    printf("%d %d
",max,min);
    
    return 0;
}