3-5-1 顺序查找

以下程序的功能是输入一个正整数n（1＜n≤10），再输入n个整数，将它们存入数组a中，再输入1个数x，然后在数组中查找x，如果找到，输出相应的最小下标，否则，输出“Not Found”。

#include <stdio.h>
int main(int argc, char const* argv[])
{
    int i, index, n, x, a[10];
    scanf("%d", &n);
    for (i = 0; i < n; i++)
        scanf("%d",&a[i]);//①
    scanf("%d", &x);
    getchar();//②
    for (i = 0; i < n; i++)
        if (a[i] == x) 
        {
            index = i;
            break;//③
        }
    if (index != -1)
        printf("%d\n", index);
    else
        printf("Not Found\n");
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

3-5-2 计算二维数组第一列元素之和

从键盘输入一个4行4列的二维数组元素，求第一列元素之和

#include <stdio.h>
#include <math.h>
int main()
{
    int i,j;//①
    int a[4][4], sum;
    sum =0;//②
    for (i = 0; i < 4; i++)
        for (j = 0; j < 4; j++)
            scanf("%d", &a[i][j]);
    for (i = 0; i < 4; i++)
        sum += a[i][0];//③
    printf("%d\n", sum);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3-5-3 判断方阵对称

输入一个正整数 n (1≤n≤10)和n 阶方阵a的元素，如果方阵a中的所有元素都沿主对角线对称，输出“Yes”, 否则，输出“No”。主对角线为从矩阵的左上角至右下角的连线，方阵a中的所有元素都沿主对角线对称指对所有i, k，a[i][k]和a[k][i]相等。

#include <stdio.h>
int main(void)
{
    int found, i, k, n;
    int a[10][10];
    scanf("%d", &n);
    for (i = 0; i < n; i++)
        for (k = 0; k < n; k++)
            scanf("%d", &a[i][k]);

    found = 1;
    for (i = 0; i < n; i++) {
        for (k = 0; k < i; k++) {
            if (a[i][k] != a[k][i]) {//①
                found = 0;//②
                break;
            }
        }
        if (found == 0) {//③
            break;
        }
    }
    if (found != 0) {
        printf("Yes\n");
    }
    else {
        printf("No\n");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

3-6-1 输出整数k 的所有质因子

输出一个整数k (2≤k≤5000)的所有质因子（即所有为素数的因子）。例如，若输入整数：2310，则应输出：2. 3. 5. 7. 11。

int fun(int n )
{
    for(int i = 2;i<=sqrt(n);i++)
    {
        if(n%i == 0)
            return 0;
    }
    return 1;
}
1
2
3
4
5
6
7
8
9

3-7-1 去掉最大值和最小值

申请一个10个单元的整型数组，输入10个整数，去掉一个最大值和一个最小值后，剩下的8个数求和

输入格式:
输入10个整数，空格分隔

输出格式:
去掉最大值和最小值后，求剩下8个数的和

#include<stdio.h>
int main()
{
    int arr[10] = {0};
    int sum = 0;
    for(int i = 0;i<10;i++)
    {
        scanf("%d",&arr[i]);
        sum += arr[i];
    }
    int max = arr[0],min = arr[0];
    for(int i = 1;i<10;i++)
    {
        if(arr[i]>max)
            max = arr[i];
        if(arr[i]<min)
            min = arr[i];
    }
    sum -= max+min;
    printf("%d",sum);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

3-7-2 合并数组

已知两个升序数组，将它们合并成一个升序数组并输出。例如：数组array1={3,6,13,35,54}，数组array2={14,19,26,32}，
合并为新的数组array={3,6,13,14,19,26,32,35,54}。

输入格式:
输入两行升序整数，当每行输入0时，表示输入结束。每行整数的个数1<=N<=10。

输出格式:
输出合并后的升序数组。（最后一个数据后有一个空格）

#include<stdio.h>
int main()
{
    int a1[12] = { 0 };
    int a2[12] = { 0 };
    int i = 0;
    int count = 0;
    while (1)
    {
        scanf("%d", &a1[i]);
        if (a1[i] == 0)
        {
            break;
        }
        else
        {
            i++;
            count++;
        }

    }
    i = 0;
    while (1)
    {
        scanf("%d", &a2[i]);
        if (a2[i] == 0)
        {
            break;
        }
        else
        {
            i++;
            count++;
        }

    }
    int arr[21] = { 0 };
    int j = 0,k = 0;
    i = 0;
    while (a1[i] || a2[j])
    {
        if (a1[i] > a2[j])
        {
            if (a2[j] == 0)
                arr[k++] = a1[i++];
            else
                arr[k++] = a2[j++];
        }
        if (a1[i] < a2[j])
        {
            if (a1[i] == 0)
                arr[k++] =a2[j++];
            else
                arr[k++] = a1[i++];
        }

   }
    k = 0;
   for(;k<count;k++)
    {
        printf("%d ", arr[k]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

3-7-3 对了几题（单选题）

编写程序，判断用户的单选题答对了几题。
说明:
1–以十个判断题为例，用户提交的答案应该是长度为十的字符串，如：“ABCDDCBACD”，字符的位置代表了题号，选择项当然是字符集[‘A’,‘B’,‘C’,‘D’']之一。
2–标准答案是一个长整数（8个字节，64个二进制位），长整数的二进制存储中，用两个二进制位来对应一个答案：00-A,01-B,10-C,11-D，一个长整数可标记32个题目的答案。如228的整数机内表示的最低八位是11 10 01 00，它表示前四题的答案依次是ABCD。

输入格式:
输入内容有二行：
第一行，用户提交的答题选项：每个字符代表一个选项（ABCD之一），字符串的长度表示题目数量（范围在【5，32】内）。
第二行，一个用二进制位来表示标准答案的长整数（注意，不是字符串）。

输出格式:
输出用户单选题回答正确数量（多少题与标准答案相同）。

#include<stdio.h>
int main()
{
    char a[40];
    scanf("%s",a);
    long long int b = 0;
    scanf("%lld",&b);
    int i = 0,count = 0;
    for(;a[i]>='A'&&a[i]<='D';i++)
    {
        count++;
    }
    int k = 0,yes= 0;
    while (k <= i)
    {
        if ((b & 3) == (a[k] - 'A'))
            yes++;
        b >>= 2;
        k++;
    }
    printf("%d", yes);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3-7-4 肿瘤面积

任务描述
在一个正方形的灰度图片上，肿瘤是一块矩形的区域，肿瘤的边缘所在的像素点在图片中用0表示。其它肿瘤内和肿瘤外的点都用255表示。现在要求你编写一个程序，计算肿瘤内部的像素点的个数（不包括肿瘤边缘上的点）。已知肿瘤的边缘平行于图像的边缘。

输入格式:
只有一个测试样例。第一行有一个整数n，表示正方形图像的边长。其后n行每行有n个整数，取值为0或255。整数之间用一个空格隔开。已知n不大于1000。

输出格式:
输出一行，该行包含一个整数，为要求的肿瘤内的像素点的个数。

#include<stdio.h>

int main()
{
    int n = 0;
    int arr[1000][1000] = {0};
    scanf("%d",&n);
    int f1 = 0,f2 = 0,t1,t2,t3,t4;
    for(int i = 0;i<n;i++)
    {
        for(int j = 0;j<n;j++)
        {
            scanf("%d",&arr[i][j]);
            if(f1==0&&arr[i][j] == 0)
            {
                t1 = i;
                t2 = j;
                f1 = 1;
            }
        }
    }
    for(int i = n-1;i>=0;i--)
    {
        for(int j = n-1;j>=0;j--)
        {
            if(f2==0&&arr[i][j] == 0)
            {
                t3 = i;
                t4 = j;
                f2 = 1;
                break;
            }
        }
    }
    int count = 0;
    for(int i = t1;i<=t3;i++)
    {
        for(int j = t2;j<=t4;j++)
        {
            if(arr[i][j])
            {
                count++;
            }
        }
    }
    printf("%d",count);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48