【算法练习】--- HDU-2010---2019

2010-水仙花数

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 214233    Accepted Submission(s): 60703

Problem Description

春天是鲜花的季节，水仙花就是其中最迷人的代表，数学上有个水仙花数，他是这样定义的：
“水仙花数”是指一个三位数，它的各位数字的立方和等于其本身，比如：153=1^3+5^3+3^3。
现在要求输出所有在m和n范围内的水仙花数。

Input

输入数据有多组，每组占一行，包括两个整数m和n（100<=m<=n<=999）。

Output

对于每个测试实例，要求输出所有在给定范围内的水仙花数，就是说，输出的水仙花数必须大于等于m,并且小于等于n，如果有多个，则要求从小到大排列在一行内输出，之间用一个空格隔开;
如果给定的范围内不存在水仙花数，则输出no;
每个测试实例的输出占一行。

Sample Input

100 120
300 380

Sample Output

no
370 371

解题思路

水仙花数问题，没有难点。在输出格式上栽了几次，直接输出最后一个数后面不能再有空格了，所以要判断一下。

AC代码

#include<stdio.h>
void swap(int *x, int *y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}
int main()
{
    int m = 0;
    int n = 0;
    while (EOF != scanf("%d%d", &m, &n))
    {
        int g = 0;
        int s = 0;
        int b = 0;
        int count = 0;
        if (m > n)
        {
            swap(&m, &n);
        }
        for (int i = m; i <= n; i++)
        {
            g = i % 10;
            b = i / 100;
            s = (i - g - (100 * b)) / 10;
            if (g*g*g + s*s*s + b*b*b == i)
            {
                if (count == 0)
                {
                    printf("%d", i);
                    count++;
                }
                else 
                {
                    printf(" %d", i);
                    count++;
                }

            }
        }
        if (count == 0)
        {
            printf("no");
        }
        printf("\n");
    }
    return 0;
}

2011-多项式求和

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 87273    Accepted Submission(s): 49760

Problem Description

多项式的描述如下：
1 - 1/2 + 1/3 - 1/4 + 1/5 - 1/6 + …
现在请你求出该多项式的前n项的和。

Input

输入数据由2行组成，首先是一个正整数m（m<100），表示测试实例的个数，第二行包含m个正整数，对于每一个整数(不妨设为n,n<1000），求该多项式的前n项的和。

Output

对于每个测试实例n，要求输出多项式前n项的和。每个测试实例的输出占一行，结果保留2位小数。

Sample Input

2
1 2

Sample Output

1.00
0.50

AC代码

#include<stdio.h>
int main()
{
    int m = 0;
    int n = 0;
    while (EOF != scanf("%d", &m))
    {
        for (int i = 0; i < m; i++)
        {
            scanf("%d", &n);
            double sum = 0.0;
            for (int j = 1; j <= n; j++)
            {
                if (j % 2)
                {
                    sum += 1.0 / j;

                }
                else
                {
                    sum -= 1.0 / j;
                }
            }
            printf("%.2lf\n", sum);
        }
    }
    return 0;
}

2012-素数判定

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 153370    Accepted Submission(s): 54026

Problem Description

对于表达式n^2+n+41，当n在（x,y）范围内取整数值时（包括x,y）(-39<=x < y<=50)，判定该表达式的值是否都为素数。

Input

输入数据有多组，每组占一行，由两个整数x，y组成，当x=0,y=0时，表示输入结束，该行不做处理。

Output

对于每个给定范围内的取值，如果表达式的值都为素数，则输出”OK”,否则请输出“Sorry”,每组输出占一行。

Sample Input

0 1
0 0

Sample Output

OK

AC代码

#include<stdio.h>  
#include<math.h>
void swap(int *x, int *y)
{
    int tmp = *x;
    *x = *y;
    *y = tmp;
}
int main()
{
    int x = 0;
    int y = 0;
    while (EOF != scanf("%d%d", &x, &y))
    {
        if ((0 == x) && (0 == y))
        {
            break;
        }
        if (x > y)
        {
            swap(&x, &y);
        }
        int count = 0;
        for (int i = x; i <= y; i++)
        {
            int s = i * i + i + 41;
            for (int j = 2; j < sqrt(s); j++)
            {
                if (s % j == 0)
                {
                    count++;
                }
            }
        }
        if (0 == count)
        {
            printf("OK\n");
        }
        else
        {
            printf("Sorry\n");
        }
    }
    return 0;
}

2013-蟠桃记

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 70925    Accepted Submission(s): 52754

Problem Description

喜欢西游记的同学肯定都知道悟空偷吃蟠桃的故事，你们一定都觉得这猴子太闹腾了，其实你们是有所不知：悟空是在研究一个数学问题！
什么问题？他研究的问题是蟠桃一共有多少个！
不过，到最后，他还是没能解决这个难题，呵呵^-^
当时的情况是这样的：
第一天悟空吃掉桃子总数一半多一个，第二天又将剩下的桃子吃掉一半多一个，以后每天吃掉前一天剩下的一半多一个，到第n天准备吃的时候只剩下一个桃子。聪明的你，请帮悟空算一下，他第一天开始吃的时候桃子一共有多少个呢？

Input

输入数据有多组，每组占一行，包含一个正整数n（1 < n<30），表示只剩下一个桃子的时候是在第n天发生的。

Output

对于每组输入数据，输出第一天开始吃的时候桃子的总数，每个测试实例占一行。

Sample Input

2
4

Sample Output

4
22

AC代码

#include<stdio.h>
int peach(int n)
{
    if (n == 1)
    {
        return 1;
    }
    else
    {
        return 2 * (peach(n - 1) + 1);
    }
}
int main()
{
    int n = 0;
    while (EOF != scanf("%d", &n))
    {
        printf("%d\n", peach(n));
    }
    return 0;
}

2014-青年歌手大奖赛_评委会打分

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 96541    Accepted Submission(s): 47796

Problem Description

青年歌手大奖赛中，评委会给参赛选手打分。选手得分规则为去掉一个最高分和一个最低分，然后计算平均得分，请编程输出某选手的得分。

Input

输入数据有多组，每组占一行，每行的第一个数是n(2

AC代码

#include <stdio.h>
#define MAX 100
int main()
{
    int n = 0;
    int a[MAX] = { 0 };
    while (EOF != scanf("%d", &n))
    {
        double sum = 0.0;
        double average = 0;
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &a[i]);
        }

        for (int i = 0; i < n - 1; i++)
            for (int j = i + 1; j < n; j++)
            {
                if (a[i] > a[j])
                {
                    int temp = a[i];
                    a[i] = a[j];
                    a[j] = temp;
                }
            }

        for (int i = 1; i < n - 1; i++)
        {
            sum += a[i];
        }

        average = sum / (n - 2);

        printf("%.2lf\n", average);
    }
    return 0;
}

2015-偶数求和

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 97324    Accepted Submission(s): 40708

Problem Description

有一个长度为n(n<=100)的数列，该数列定义为从2开始的递增有序偶数，现在要求你按照顺序每m个数求出一个平均值，如果最后不足m个，则以实际数量求平均值。编程输出该平均值序列。

Input

输入数据有多组，每组占一行，包含两个正整数n和m，n和m的含义如上所述。

Output

对于每组输入数据，输出一个平均值序列，每组输出占一行。

Sample Input

3 2
4 2

Sample Output

3 6
3 7

AC代码

#include<stdio.h>  
int main()
{
    int n = 0;
    int m = 0;
    while (EOF != scanf("%d%d", &n, &m))
    {
        int count = 0;
        int sum = 0;
        for (int i = 2; i <= n * 2; i += 2)
        {
            sum += i;
            count++;
            if (count == m && (i != n * 2))
            {
                printf("%d ", sum / count);
                count -= m;
                sum = 0;
            }
        }
        if (sum == 0 && count == 0) continue;
        printf("%d\n", sum / count);
    }
}

2016-数据的交换输出

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 115646    Accepted Submission(s): 43061

Problem Description

输入n(n<100)个数，找出其中最小的数，将它与最前面的数交换后输出这些数。

Input

输入数据有多组，每组占一行，每行的开始是一个整数n，表示这个测试实例的数值的个数，跟着就是n个整数。n=0表示输入的结束，不做处理。

Output

对于每组输入数据，输出交换后的数列，每组输出占一行。

Sample Input

4 2 1 3 4
5 5 4 3 2 1
0

Sample Output

1 2 3 4
1 4 3 2 5

AC代码

#include<stdio.h>
int main()
{
    int n = 0;
    int arr[100] = { 0 };
    int min = 0;
    while (scanf("%d", &n) != EOF)
    {
        if (n == 0)
        {
            break;
        }
        for (int i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        min = arr[0];
        int k = 0;
        for (int i = 0; i<n; i++)
        {
            if (arr[i] < min)
            {
                k = i;
                min = arr[k];
            }
        }
        if (min != arr[0])
        {
            int t = arr[k]; 
            arr[k] = arr[0]; 
            arr[0] = t;
        }
        for (int i = 0; i<n; i++)
            if (i == 0)
                printf("%d", arr[i]);
            else
                printf(" %d", arr[i]);
        printf("\n");
    }
    return 0;
}

2017-字符串统计

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 90180    Accepted Submission(s): 49425

Problem Description

对于给定的一个字符串，统计其中数字字符出现的次数。

Input

输入数据有多行，第一行是一个整数n，表示测试实例的个数，后面跟着n行，每行包括一个由字母和数字组成的字符串。

Output

对于每个测试实例，输出该串中数值的个数，每个输出占一行。

Sample Input

2
asdfasdf123123asdfasdf
asdf111111111asdfasdfasdf

Sample Output

6
9

AC代码

#include<stdio.h>  
int main()
{
    int n = 0;
    char s;
    while (EOF != scanf("%d", &n))
    {
        getchar();
        for (int i = 0; i < n; ++i)
        {
            int count = 0;
            while ((s = getchar()) != '\n')
            {
                if (s <= '9' && s >= '0')
                {
                    count++;
                }
            }
            printf("%d\n", count);
        }
    }
    return 0;
}

2018-母牛的故事

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 92970    Accepted Submission(s): 45869

Problem Description

有一头母牛，它每年年初生一头小母牛。每头小母牛从第四个年头开始，每年年初也生一头小母牛。请编程实现在第n年的时候，共有多少头母牛？

Input

输入数据由多个测试实例组成，每个测试实例占一行，包括一个整数n(0

AC代码

#include<stdio.h>
int fun(int n)
{
    if (n <= 4)
    {
        return n;
    }
    return fun(n - 1) + fun(n - 3);
}
int main()
{
    int n = 0;
    while (EOF != scanf("%d", &n))
    {
        if (n == 0)
        {
            break;
        }
        printf("%d\n", fun(n));
    }
    return 0;
}

2019-数列有序!

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 97707    Accepted Submission(s): 40875

Problem Description

有n(n<=100)个整数，已经按照从小到大顺序排列好，现在另外给一个整数x，请将该数插入到序列中，并使新的序列仍然有序。

Input

输入数据包含多个测试实例，每组数据由两行组成，第一行是n和m，第二行是已经有序的n个数的数列。n和m同时为0标示输入数据的结束，本行不做处理。

Output

对于每个测试实例，输出插入新的元素后的数列。

Sample Input

3 3
1 2 4
0 0

Sample Output

1 2 3 4

AC代码

#include<stdio.h>  
int main()
{
    int n = 0; 
    int m = 0; 
    int arr[101] = { 0 };
    int i = 0;
    while (scanf("%d%d", &n, &m) != EOF)
    {
        if (n == 0 && m == 0) 
        {
            break;
        }
        for (i = 0; i < n; i++)
        {
            scanf("%d", &arr[i]);
        }
        for (i = 0; i < n; i++)
        {
            if (m > arr[i])
            {
                printf("%d ", arr[i]);
            }
        }
        printf("%d", m);
        for (i = 0; i < n; i++)
        {
            if (m <= arr[i])
            printf(" %d", arr[i]);
        }
        printf("\n");
    }
    return 0;
}