藍橋杯習題

    藍橋杯練習系統習題加答案，總共分為6部分，90%習題使用C語言解答，部分使用C++或者Java。大部分習題為搜尋參考或者別人提供所得，不足之處在所難免，懇請批評指正（預計200多題，習題僅供學習交流）

目錄

藍橋杯練習系統評測資料

演算法訓練（PartF-10題）

/*
演算法訓練 數對

問題描述
　　編寫一個程式，該程式從使用者讀入一個整數，然後列出所有的數對，每個數對的乘積即為該數。
　　輸入格式：輸入只有一行，即一個整數。
　　輸出格式：輸出有若干行，每一行是一個乘法式子。（注意：運算子號與數字之間有一個空格）
　　輸入輸出樣例
樣例輸入
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\n",i,num/i,num);
        }
    }
    
    return ;
}

main()
{
    int num;
    
    scanf("%d",&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\n");
    }
    else
    {
        printf("no\n");
    }
    
}

main()
{
    int num;
    
    scanf("%d",&num);
    getResult(num);
    
    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\n",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; 
}
 

/*
演算法訓練 黑色星期五

問題描述
　　有些西方人比較迷信，如果某個月的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\n",times);
    return ;
} 

main()
{
    int year;

    scanf("%d",&year);
    printBlackFridayTimes(year);
    
    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\n",i+1);
            return 0;
        }
    }
    printf("0\n");
    
    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\n",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;
}
*/

/*
演算法訓練 最大體積

問題描述
　　每個物品有一定的體積（廢話），不同的物品組合，裝入揹包會戰用一定的總體積。假如每個物品有無限件可用，那麼有些體積是永遠也裝不出來的。為了儘量裝滿揹包，附中的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\n");
        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\n",i);
                  return 0;
              }
          }
          printf("0\n");
          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
*/

/*
演算法訓練 貌似化學

問題描述
　　現在有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
*/
#include <cstdio>
#include <cstring>
#define INF 214748326
double a[10][10];
double b[10][10];
double c[10];
int min=INF;
int ansx,ansy,ansz,ansk;
int trunc(double x){
    if ((int)(x+0.5)>(int)x) return (int)x+1;
    return (int)x;
}
int main(){
    scanf("%lf%lf%lf",&a[1][4],&a[2][4],&a[3][4]);
    scanf("%lf%lf%lf%lf%lf%lf%lf%lf%lf",&a[1][1],&a[2][1],&a[3][1],&a

[1][2],&a[2][2],&a[3][2],&a[1][3],&a[2][3],&a[3][3]);
    memcpy(b,a,sizeof(a));
    for (int k=1;k<=10000;k++){
        for (int i=1;i<=3;i++) a[i][4]*=k;
        for (int i=1;i<3;i++){
            for (int j=i+1;j<=3;j++){
                double t=1;
                if (a[j][i]!=0) t=a[i][i]/a[j][i];
                a[j][i]=0;
                for (int k=i+1;k<=4;k++){
                    a[j][k]=t*a[j][k]-a[i][k];
                }
            }
        }
        memset(c,0,sizeof(c));
        c[3]=a[3][4]/a[3][3];
        for (int i=2;i>0;i--){
            double tot=0;
            for (int j=i+1;j<=3;j++){
                tot+=a[i][j]*c[j];
            }
            c[i]=(a[i][4]-tot)/a[i][i];
        }
        int x=trunc(c[1]);
        int y=trunc(c[2]);
        int z=trunc(c[3]);
        if (b[1][1]*x+b[1][2]*y+b[1][3]*z==b[1][4]*k
         && b[2][1]*x+b[2][2]*y+b[2][3]*z==b[2][4]*k
         && b[3][1]*x+b[3][2]*y+b[3][3]*z==b[3][4]*k){
                                                      if (min>x+y+z){
                                                                     

ansx=x;
                                                                     

ansy=y;
                                                                     

ansz=z;
                                                                     

ansk=k;
                                                                     

min=z+y+z;
                                                      }
         }
         memcpy(a,b,sizeof(a));
    }
    if (ansx==0 && ansy==0 && ansz==0) printf("NONE");else
    printf("%d %d %d %d\n",ansx,ansy,ansz,ansk);
    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;
 }

/*
演算法訓練 明明的隨機數

問題描述
　　明明想在學校中請一些同學一起做一項問卷調查，為了實驗的客觀性，他先用計算機生成了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\n",lenth);
    for(i=0;i<lenth;i++)
    {
        printf("%d ",array[i]);
    }
    printf("\n");
    
    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;
}