《数组与指针程序设计》——小组作业（21-32）

最新推荐文章于 2024-09-11 22:21:12 发布
最新推荐文章于 2024-09-11 22:21:12 发布
阅读量656 收藏 3
点赞数
分类专栏： 作业 文章标签： c语言 开发语言 c++ 程序设计 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_59697980/article/details/121365202
版权

21. 输入一串字符统计其中大写字母、小写字母、数字的个数，输出结果。

#include <iostream>

using namespace std;

void BookStr (string str);

int main (void)
{
    string str;
    cout << "Please input a string: " << endl;
    cin >> str;

    BookStr (str);

    system ("pause");
    return 0;
}

void
BookStr (string str)
{
    int CntLow = 0;
    int CntUpp = 0;
    int CntNum = 0;

    const char *p = NULL;
    p = str.c_str ();

    while (*p != '\0')
    {
        if (*p >= 'a' && *p <= 'z')
        {
            CntLow ++;
        }
        else if (*p >= 'A' && *p <= 'Z')
        {
            CntUpp ++;
        }
        else if (*p >= '0' && *p <= '9')
        {
            CntNum ++;
        }

        p ++;
    }

    printf ("The string has %d numbers. \n", CntNum);
    printf ("The string has %d lowercase. \n", CntLow);
    printf ("The string has %d uppercase. \n", CntUpp);
}

22.输入两个3阶方阵，计算两个方阵之差，以数学表示方式输出。

#include <iostream>

using namespace std;

#define ROW 3
#define COL 3

int **Create (void);
void Input (int **p);
int **Subtract (int **p, int **q);
void Output (int **p);

int main (void)
{
    int **matrix1 = Create ();
    printf ("Please input numbers in first %d x %d matrix: \n", ROW, COL);
    Input (matrix1);
    printf ("\n");

    int **matrix2 = Create ();
    printf ("Please input numbers in second %d x %d matrix: \n", ROW, COL);
    Input (matrix2);
    printf ("\n");

    printf ("The difference between the two matrices is: \n");

    int **submatrix = Subtract (matrix1, matrix2);

    Output (submatrix);

    free (matrix1);
    free (matrix2);
    free (submatrix);

    system ("pause");
    return 0;
}

int
**Create (void)
{
    int **matrix = (int **)malloc (sizeof (int *) * ROW);

    for (int i = 0; i < COL; i ++)
    {
        matrix[i] = (int *)malloc (sizeof (int) * COL);
    }

    return matrix;
}

void
Input (int **p)
{
    for (int i = 0; i < ROW; i ++)
    {
        for (int j = 0; j < COL; j ++)
        {
            cin >> *(*(p + i) + j);
        }
    }
}

int
**Subtract (int **p, int **q)
{
    int **submatrix = (int **)malloc (sizeof (int *) * ROW);

    for (int i = 0; i < ROW; i ++)
    {
        submatrix[i] = (int *)malloc (sizeof (int) * COL);

        for (int j = 0; j < COL; j ++)
        {
            *(*(submatrix + i) + j) = *(*(p + i) + j) - *(*(q + i) + j);
        }
    }

    return submatrix;
}

void
Output (int **p)
{
    for (int i = 0; i < ROW; i ++)
    {
        for (int j = 0; j < COL; j ++)
        {
            printf ("%d ", *(*(p + i) + j));
        }

        printf ("\n");
    }
}

23.编程输出1000（测试用20）个数组元素的前10个最大的数。

#include <iostream>

using namespace std;

#define MAXN 1000

void MySwap (int *p1, int *p2);
void MySort (int *array, int begin, int end, int size);
void MyQuickSort (int *array, int begin, int end);
void MyPrint (int *array, int size);

int main (void)
{
    int nums[MAXN];
    int *p = NULL;

    printf ("Please input %d number: \n", MAXN);
    for (p = nums; p < nums + MAXN; p ++)
    {
        cin >> *p;
    }

    int size;
    cout << "Please enter how many numbers you need: " << endl;
    cin >> size;

    MySort (nums, 0, MAXN - 1, size);
    MyQuickSort (nums, MAXN - size, MAXN - 1);

    MyPrint (nums, size);

    system ("pause");
    return 0;
}

void
MySwap (int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

void
MySort (int *array, int begin, int end, int size)
{
    int temp = *(array + begin);

    int left = begin, right = end;
    while (left < right)
    {
        while (right > left && *(array + right) >= temp)
        {
            right --;
        }

        MySwap (array + left, array + right);

        while (right > left && *(array + left) < temp)
        {
            left ++;
        }

        MySwap (array + left, array + right);
    }


    int len = end - right + 1;

    if (len == size)
    {
        return;
    }
    else if (len > size)
    {
        MySort (array, right + 1, end, size);
    }
    else
    {
        MySort (array, begin, right - 1, size - len);
    }
}

void
MyQuickSort (int *array, int begin, int end)
{
    int i, j;

    if (begin < end)
    {
        i = begin + 1;
        j = end;

        while (i < j)
        {
            if (array[i] > array[begin])
            {
                MySwap (array + i, array + j);

                j --;
            }
            else
            {
                i ++;
            }
        }

        if (array[i] >= array[begin])
        {
            i --;
        }

        MySwap (array + begin, array + i);

        MyQuickSort (array, begin, i);
        MyQuickSort (array, j, end);
    }
}

void
MyPrint (int *array, int size)
{
    int *p = NULL;

    printf ("The numbers that you need: \n");

    for (p = array + MAXN - 1; p > array + MAXN - 1 - size; p --)
    {
        printf ("%d ", *p);
    }

    printf ("\n");
}

24.输入两个二维矩阵（阶数自定），求其乘积并输出。

#include <iostream>
#include <stdlib.h>

using namespace std;

int **Create (int row, int col);
void MyInput (int **p, int row, int col);
int **Multiply (int **p, int row1, int col1, int **q, int row2, int col2);
void Initialize (int **p, int row, int col);
void MyPrint (int **p, int row, int col);

int main (void)
{
    int row1, col1;
    cout << "Please input the first matrix row & col: " << endl;
    scanf ("%d%d", &row1, &col1);

    int **matrix1 = Create (row1, col1);
    MyInput (matrix1, row1, col1);

    int row2, col2;
    cout << "Please input the second matrix row & col: " << endl;
    cin >> row2 >> col2;

    int **matrix2 = Create (row2, col2);
    MyInput (matrix2, row2, col2);

    int **mulMatrix = Multiply (matrix1, row1, col1, matrix2, row2, col2);

    printf ("The result is: \n");
    MyPrint (mulMatrix, row1, col2);

    free (matrix1);
    free (matrix2);
    free (mulMatrix);

    system ("pause");
    return 0;
}

int **Create (int row, int col)
{
    int **matrix = (int **)malloc (sizeof (int *) * row);

    for (int i = 0; i < col; i ++)
    {
        matrix[i] = (int *)malloc (sizeof (int) * col);
    }

    return matrix;
}

void
MyInput (int **p, int row, int col)
{
    printf ("Please input numbers in %d x %d matirx: \n", row, col);

    for (int i = 0; i < row; i ++)
    {
        for (int j = 0; j < col; j ++)
        {
            scanf ("%d", (p + i) + j);
        }
    }
}

void
Initialize (int **p, int row, int col)
{
    for (int i = 0; i < row; i ++)
    {
        for (int j = 0; j < col; j ++)
        {
            *(*(p + i) + j) = 0;
        }
    }
}

int
**Multiply (int **p, int row1, int col1, int **q, int row2, int col2)
{
    int **mulMatrix = Create (row1, col2);
    Initialize (mulMatrix, row1, col2);

    for (int i = 0; i < row1; i ++)
    {
        for (int j = 0; j < col2; j ++)
        {
            for (int k  = 0; k < row2; k ++)
            {
                mulMatrix[i][j] += (p[i][k] * q[k][j]);
            }
        }
    }

    return mulMatrix;
}

void
MyPrint (int **p, int row, int col)
{
    for (int i = 0; i < row; i ++)
    {
        for (int j = 0; j < col; j ++)
        {
            printf ("%4d ", *(*(p + i) + j));
        }

        printf ("\n");
    }
}

25.输入一0、1组成的二进制字符串（不超过32位），将其转换为无符号整型，并输出10进制的值。

#include <iostream>

using namespace std;

#define MAXN 32
#define BIN 2

int MyPow (int num, int n);
int MyStrlen (char *str);
unsigned int BinToDec (char *str);

int main (void)
{
    char Bin[MAXN];

    printf("Please input Bin (< %d): ", MAXN);
    cin.getline (Bin, MAXN);

    printf ("The Bin: %s to Dec: %u \n", Bin, BinToDec (Bin));

    system ("pause");
    return 0;
}

int
MyPow (int num, int n)
{
    int iRes = 1;

    for (int i = 0; i < n; i ++)
    {
        iRes *= num;
    }

    return iRes;
}

int
MyStrlen (char *str)
{
    if (str == NULL)
    {
        return -1;
    }

    int returnSize = 0;

    while (*str != '\0')
    {
        returnSize ++;
        *str ++;
    }

    return returnSize;
}


unsigned int
BinToDec (char *str)
{
    int len = MyStrlen (str);
    unsigned int iAns = 0;

    char *p = NULL;
    p = str + len - 1;

    while (p - str >= 0)
    {
        if (*p >= '0' && *p <= '1')
        {
            iAns += (*p - '0') * MyPow (BIN, len - (p - str) - 1);
        }


        p --;
    }

    return iAns;
}

26.输入10个英文的国名，按升序排序输出。

#include <iostream>

using namespace std;

#define MAXN 10

int main (void)
{
    string contry[MAXN];

    printf ("Please input %d contry name: \n", MAXN);
    for (int i = 0; i < MAXN; i ++)
    {
        cin >> contry[i];
    }

    for (int i = 0; i < MAXN - -1; i ++)
    {
		for(int j = i + 1; j < MAXN; j ++)
		{
			if (contry[j] < contry[i])
			{
				contry[i].swap(contry[j]);
			}
		}
	}

	printf ("After sort: \n");

	for (int i = 0; i < MAXN; i ++)
    {
		cout << contry[i] << endl;
	}

	system ("pause");
    return 0;
}

27.用随机函数（自查功能和用法）生成20个数存放到数组中并按降序排序，从键盘输入一个数，完成在数组中的二分查找。

#include <iostream>
#include <ctime>

using namespace std;

void MySwap (int *p1, int *p2);
void MyQuickSort (int *array, int begin, int end);
int BinarySearch (int *p, int target, int begin, int end);
int *GetRandomArray (int numsSize);
void MyPrint (int *p, int numsSize);

int main (void)
{
    int numsSize;
    cout << "How mang randon numbers do you need? " << endl;
    cin >> numsSize;

    int *returnNums = GetRandomArray (numsSize);

    MyPrint (returnNums, numsSize);

    printf ("\n");

    int target;
    cout << "Please input teh target number: " << endl;
    cin >> target;

    printf ("\n");

    printf ("After sort: \n");
    MyQuickSort (returnNums, 0, numsSize - 1);

    MyPrint (returnNums, numsSize);

    printf ("\n");

    int iPos = BinarySearch (returnNums, target, 0, numsSize - 1);

    if (iPos == -1)
    {
        printf ("Not found! \n");
    }
    else
    {
        printf ("The target located in %d \n", iPos);
    }

    system ("pause");
    return 0;
}

void
MySwap (int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

int
*GetRandomArray (int numsSize)
{
    int *returnNums = new int [numsSize];

    for (int i = 0; i < numsSize; i ++)
    {
        *(returnNums + i) = i;
    }

    for (int j = numsSize - 1; j >= 1; j --)
    {
        MySwap (returnNums + j, returnNums + (rand() % j));
    }

    return returnNums;
}

void
MyQuickSort (int *array, int begin, int end)
{
    int i, j;

    if (begin < end)
    {
        i = begin + 1;
        j = end;

        while (i < j)
        {
            if (array[i] > array[begin])
            {
                MySwap (array + i, array + j);

                j --;
            }
            else
            {
                i ++;
            }
        }

        if (array[i] >= array[begin])
        {
            i --;
        }

        MySwap (array + begin, array + i);

        MyQuickSort (array, begin, i);
        MyQuickSort (array, j, end);
    }
}

int
BinarySearch (int *p, int target, int begin, int end)
{
    int left = begin, right = end;

    while (left <= right)
    {
        int mid = left + (right - left) / 2;

        if (*(p + mid) > target)
        {
            right = mid - 1;
        }
        else if (*(p + mid) < target)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
    }

    return -1;
}

void
MyPrint (int *p, int numsSize)
{
    int *q = NULL;

    for (q = p; q < p + numsSize; q ++)
    {
        printf ("%d ", *q);
    }
}

 28.定义一个20个元素的数组，给出19个数，排序。输入一个数将其插入到数组中，插入后数组依然有序.

#include <iostream>

using namespace std;

#define MAXN 20

void MySwap (int *p1, int *p2);
void Insert (int *array, int size, int target);
void MyQuickSort (int *array, int begin, int end);
void MyPrint (int *array, int numsSize);

int main (void)
{
    int array[MAXN];

    printf ("Please input %d numbers: \n", MAXN - 1);

    for (int *p = array; p < array + MAXN - 1; p ++)
    {
        cin >> *p;
    }

    printf ("\n");

    printf ("After sorting \n");
    MyQuickSort (array, 0, MAXN - 2);
    MyPrint (array, MAXN - 1);

    printf ("\n");

    int target;
    printf ("Please set target: \n");
    cin >> array[MAXN - 1];
    target = array[MAXN - 1];

    Insert (array, MAXN, target);

    MyPrint (array, MAXN);

    printf ("\n");

    system ("pause");
    return 0;
}

void
MySwap (int *p1, int *p2)
{
    int temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}

void
Insert (int *array, int size, int target)
{
    for (int i = 0; i < size - 1; i ++)
    {
        int iCur = *(array + i);
        int iNex = *(array + i + 1);

        if (iCur <= target && iNex >= target)
        {
            int *p = array + size - 1;
            int *q = p - 1;

            while (q != array + i)
            {
                MySwap (q --, p --);
            }

            return;
        }

    }
}

void
MyQuickSort (int *array, int begin, int end)
{
    int i, j;

    if (begin < end)
    {
        i = begin + 1;
        j = end;

        while (i < j)
        {
            if (array[i] > array[begin])
            {
                MySwap (array + i, array + j);

                j --;
            }
            else
            {
                i ++;
            }
        }

        if (array[i] >= array[begin])
        {
            i --;
        }

        MySwap (array + begin, array + i);

        MyQuickSort (array, begin, i);
        MyQuickSort (array, j, end);
    }
}

void
MyPrint (int *array, int numsSize)
{
    int *p = NULL;

    for (p = array; p < array + numsSize; p ++)
    {
        printf ("%d ", *p);
    }
}

29. 输入一个字符串，将其倒序存放到原数组。

#include <iostream>

using namespace std;

int MyStrlen (char *str);
void MySwap (char *p1, char *p2);
void ReverseStr (char *str);

int main (void)
{
    char str[80];
    cout << "Please input string (< 80): " << endl;
    cin.getline (str, 80);

    ReverseStr (str);

    cout << "The result is " << str << endl;

    system ("pause");
    return 0;
}

int
MyStrlen (char *str)
{
    if (str == NULL)
    {
        return -1;
    }

    int returnSize = 0;

    while (*str != '\0')
    {
        returnSize ++;
        *str ++;
    }

    return returnSize;
}

void
MySwap (char *p1, char *p2)
{
    char temp = *p1;
    *p1 = *p2;
    *p2 = temp;
}


void
ReverseStr (char *str)
{
    int len = MyStrlen (str);

    char *p = NULL;
    char *q = NULL;

    p = str;
    q = str + len - 1;

    while (p < q)
    {
        MySwap (p ++, q --);
    }
}

30.定义20个元素的整型数组并赋初值。输入一个数，如果该数在数组中存在，则删除该数，其后的每个数前移一位，最后补0。

#include <iostream>

using namespace std;

#define MAXN 20

int main (void)
{
    int array[MAXN];

    for (int *p = array; p < array + MAXN; p ++)
    {
        *p = p - array;

        printf ("%d ", *p);
    }

    int target;
    cout << '\n' << "Input number that you want to delete: " << endl;
    cin >> target;

    for (int i = 0; i < MAXN; i ++)
    {
        if (array[i] == target)
        {
            while (i < MAXN)
            {
                if (i < MAXN - 1)
                {
                    array[i] = array[i + 1];

                    printf ("%d ", array[i]);
                }
                else
                {
                    array[i] = 0;

                    printf ("%d ", array[i]);
                }

                i ++;
            }
        }
        else
        {
            printf ("%d ", array[i]);
        }
    }

    system ("pause");
    return 0;
}

31.统计一个字符串中每个数字（‘0’~‘9’）字符的个数。

#include <iostream>

using namespace std;

int main (void)
{
    char str[80];
    int book[10] = {0};

    cout << "Please input string (< 80): " << endl;
    cin.getline (str, 80);

    char *p = NULL;
    p = str;

    while (*p != '0')
    {
        if (*p >= '0' && *p <= '9')
        {
            book[*p - '0'] ++;
        }

        p ++;
    }

    for (int j = 0; j < 10; j ++)
    {
        printf ("The number %d appear %d time(s) !\n", j, book[j]);
    }

    system ("pause");
    return 0;
}

32.在一个字符串中查找第一个子串，并输出第一个子串的下标。        

 如：This  is  a  test message! 为字符串，子串为：is          

则输出为2。        

不能用系统的字符串函数实现！）

#include <iostream>

using namespace std;

#define MAXN 80

typedef struct
{
    char date[MAXN];
    int length;
}
MyString;

int MyStrlen (char *str);
void GetNext (MyString str, int *next);
int KMP (MyString str1, MyString str2);

int main (void)
{
    MyString str1;

    printf ("Please input main-string (< %d): \n", MAXN);
    cin.getline (str1.date, MAXN);

    str1.length = MyStrlen (str1.date);

    printf ("\n");

    MyString str2;

    printf ("Please input sub-string (< %d): \n", MAXN);
    cin.getline (str2.date, MAXN);

    str2.length = MyStrlen (str2.date);

    printf ("\n");

    int iPos = KMP (str1, str2);

    if (iPos == -1)
    {
        printf ("Not found! \n");
    }
    else
    {
        printf ("Located in %d \n", iPos);
    }

    system ("pause");
    return 0;
}

int
MyStrlen (char *str)
{
    if (str == NULL)
    {
        return -1;
    }

    int returnSize = 0;

    while (*str != '\0')
    {
        returnSize ++;
        *str ++;
    }

    return returnSize;
}


void
GetNext (MyString str, int *next)
{
    int i = 0, j = -1;

    next[i] = -1;

    while (i < str.length)
    {
        if (j == -1 || str.date[i] == str.date[j])
        {
            i ++;
            j ++;

            if (str.date[i] != str.date[j])
            {
                next[i] = j;
            }
            else
            {
                next[i] = next[j];
            }
        }
        else
        {
            j = next[j];
        }
    }
}

int
KMP (MyString str1, MyString str2)
{
    int next[MAXN];
    GetNext (str2, next);

    int i = 0, j = 0;
    while (i < str1.length && j < str2.length)
    {
        if (j == -1 || str1.date[i] == str2.date[j])
        {
            i ++;
            j ++;
        }
        else
        {
            j = next[j];
        }
    }

    if (j >= str2.length)
    {
        return i - str2.length;
    }
    else
    {
        return -1;
    }
}

C++程序设计——关于世界杯足球赛比赛规则.doc
06-13
综上所述，这个C++程序设计项目涵盖了面向对象编程的核心要素，包括类、继承、多态性，以及如何利用这些概念来模拟实际世界中的复杂系统，如世界杯足球赛的竞赛规则。同时，也展示了C++语言中的基本语法、数据类型、...
计算机技术基础课程设计-图书馆管理系统C程序课程设计.doc
06-23
在这个项目中，学生需要综合运用所学的C语言编程技能，如变量、控制结构、函数、数组、指针等，来实现一个具有实际应用价值的系统。 设计目的： 1. 提高独立思考能力：在设计过程中，学生需要自己分析问题，设计...
以前写的C语言的小程序（八）（供学习C语言初期的练习和参考）用函数调用求一组数的平均数（用数组）用冒泡排序将10个整数按从大到小排列 在一个数组中插入一个数按从小到大排列 从键盘输入20个整数，输出和
qq_42455308的博客
03-12 892
供初学者练习和参考使用，代码直接可以运行，这里我就不贴出结果截图了，可以自己运行看看。 1.用函数调用求一组数的平均数（用数组） #include <stdio.h> int average(int a[],int n) { int i,sum=0; float ave; for(i=0;i<n;i++) sum=sum+a[i]; ave=sum/n; printf...
计算两个矩阵乘积（两种方式实现）（C语言）
qq_41519304的博客
04-20 3万+
题目描述 计算两个矩阵的乘积，第一个是 2 * 3,第二个是 3 * 2 输入 输入为两个矩阵，其中一个为 2 * 3 的矩阵，另一个为 3 * 2 的矩阵 输出 一个 2 * 2 的矩阵（每一个数字后都跟一个空格） 样例输入 1 2 3 3 4 5 6 7 8 9 10 11 样例输出 52 58 100 112 矩阵乘法定义 方法一 （循环实现）： int i,j,k; int matr...
C语言 用随机函数生成20个数存放到数组中并按降序排序，从键盘输入一个数，完成在数组中的二分查找。
weixin_68748476的博客
05-10 3649
1.调用随机函数并写入数组 2.冒泡排序法进行排序 3.二分查找（两数的中间项等于两数之和/2） #include<stdio.h> #include<stdlib.h> #include<time.h> int main() { srand(time(0)); int s[20]; int i,j,k,a=0,b=19; for(i=0;i<20;i++){//调用随机函数并写入数组s int a=rand(); s[i]=a; }
输出2个3阶矩阵乘积C语言,c语言矩阵相乘
weixin_29258297的博客
05-18 525
该楼层疑似违规已被系统折叠隐藏此楼查看此楼程序清单#include&nbspint&nbspmain(void){&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbsp&nbspchar&nbsp&nbsp&nbsp&nbspa[2][3];&nbsp&...
从1000个数中选择出10个最大的数
iteye_16142的博客
04-01 2489
我这个是数量小，如果数量大些有什么办法还没想到 [code="java"] public static Set getTop100(int[] inputArray) { TreeSet top100 = new TreeSet(); for (int i = 0; i < inputArray.length; i++) { if (top100.size() < 10)...
C语言程序设计——结构体
最新发布
2301_79638883的博客
09-11 1282
认为C语言中的结构体概念相当简单，所以我只是粗略地浏览了一下。然而，当我深入学习数据结构时，我发现结构体的应用无处不在，这让我感到困惑。很多代码因为我对结构体的理解不够深入而变得难以理解。因此，我不得不重新审视结构体，并深入学习。我总结了一些关键点，希望这些总结对大家有所帮助。
Microsoft.NET 框架程序设计 —— 基元类型、引用类型与值类型
夜飞鼠的专栏
05-23 1045
本文讨论.NET 框架开发人员经常遇到的各种数据类型。熟悉这些类型的不同行为对于一个开发人员来说至关重要。当我刚开始接触.NET框架时，就没有完全理解基元类型、引用类型和值类型之间的一些差别。这种模糊的认识甚至无意间导致了一些难以査找的bug以及性能问题。我希望通过本章的解释，能够帮助大家在提升代码效率的同时避免我曾遇到的一些麻烦。
《程序设计基础》课内实践教学——Visual C++2010环境与调试
"2021程序设计基础 课内实践教学设计方案，由北京警察学院网络安全保卫系的副教授范晓明设计，针对2021级网络安全与执法1、2班的《程序设计基础》课程。教学内容涵盖了C语言的基础结构和实践操作，包括C程序的运行...
C语言中一维数组的定义，初始化，遍历循环赋值、按要求插入、删除、换位，十进制转换成n进制
TTTSEP9TH2244的博客
04-14 1万+
为大家介绍一维数组的定初始化方法、一维数组中数据的输入和输出方法、一维数组有关的程序和算法、数组处理大量数据时的优越性 一、理解数组的概念利用数组存放数据有何特点 二、一维数组的定初始化方法 在 C 中，可以逐个初始化数组，也可以使用一个初始化语句，如下所示： double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0}; 如果省略掉了数组的大小，数组的大小则为初始化时元素的个数。因此，如果： double balance[] = {1000.0, 2.0, 3.4
两个N阶方阵的乘积
sinat_43009982的博客
12-12 8282
求两个n阶方阵的乘积C=AB 具体算法如下： #define n 自然数； MATRIXMLT(float A[][n],float B[][n],float [][n]); { int i,j,k; for(i=0;i&lt;n;i++) for(j=0;j&lt;n;j++) { C[i][j]=0; for(k=0;k&lt;n;k++) C[i][j]=C[i...
提高篇十六将项目1 - 数组大折腾（创建20个元素的整型数组，为数组中的前10个元素赋初值，然后通过键盘输入后10个元素的值）
xiaochenxiaoren的博客
03-26 2923
【项目1 - 数组大折腾】 （1）创建一个有20个元素的整型数组，通过初始化，为数组中的前10个元素赋初值，然后通过键盘输入后10个元素的值，从前往后（从第0个到第19个）输出数组中元素的值，每5个元素换一行。
实验4.1对任意一个一维数组，从中找出数组元素的最大值和最小值并输出 。 要求： 1）数组有10个元素； 2）使用scanf函数实现数组元素的输入，输入前给出必要的提示信息； 3）输出时，首先输出数组
weixin_44589540的博客
02-14 2万+
/*SY4.1 题目描述 对任意一个一维数组，从中找出数组元素的最大值和最小值并输出 。 要求： 1）数组有10个元素； 2）使用scanf函数实现数组元素的输入，输入前给出必要的提示信息； 3）输出时，首先输出数组的十个元素，然后输出其最大值和最小值。 样例输入 1 2 3 4 5 6 7 8 9 0 样例输出 a[0]=1 a[1]=2 a[2]=3 a[3]=4 a[4]=5 a[5]=6...
编程输入10个数，找出其中的最大值及其所在的数组下标位置。
热门推荐
sammwang的博客
03-15 5万+
#include &amp;amp;amp;amp;lt;stdio.h&amp;amp;amp;amp;gt; int main(void){ //编程输入10个数，找出其中的最大值及其所在的数组下标位置。 int a[10],i,max,k; for(i=0;i&amp;amp;amp;amp;lt;10;i++){ scanf(&amp;amp;amp;quot;%d&amp;amp;amp;quot;,&amp;amp;amp;amp;amp
随机产生20个正整数存入数组a中，且每个数均在1000-9999之间（包含1000和9999）。对数组进行排序，要求按每个数的后三位的大小进行升序排列，然后取出满足此条件的前10个数放入数组b中，如果
vaercly的专栏
07-31 2133
int a[20] = {0}; int b[10] = {0}; for (int i = 0; i < 20; i++) { a[i] = arc4random() % 9000 + 1000; printf("%d ", a[i]); if ((i + 1) % 5 == 0) { printf("\n"
冒泡排序 - 随机生成数组并对其排序
MisterPan
03-20 6109
给定一个指定的长度，生成该长度的一个随机数组，并用冒泡排序法进行排序。 代码如下： import java.util.Scanner; public class SortArray { public static void main(String[] args) { //此处可添加输入异常捕获，输入一个数n，并创建长度为n的整形数组 System.out.print
二进制转换
xiaziqiqi的博客
11-17 1121
练习7 7-3 二进制数转十进制数 (22 分) 输入仅由0和1构成的正的二进制数（不超过32位）, 以换行符结束。输出该数对应的十进制数。 输入格式: 输入仅由0和1构成的二进制数。 输出格式: 输出相应的十进制数。 输入样例: 在这里给出一组输入。例如： 101100 结尾无空行 输出样例: 在这里给出相应的输出。例如： 44 结尾无空行 作者 陈晓梅 单位 广东外语外贸大学 代码长度限制 16 KB 时间限制 400 ms 内存限制 64 MB C
实现一个数制转换工具
laplaya的博客
11-27 7394
实现一个数制转换工具，实现二进制与十进制，十进制与十六进制的互相转换
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神秘的企鹅

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值