用c语言输出两个随机的数组
时间: 2024-05-06 20:16:24 浏览: 5
以下是一个示例代码,可以输出两个长度为10的随机数组:
```c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main() {
int arr1[10], arr2[10];
int i;
// 设置随机数种子
srand(time(NULL));
printf("Array 1: ");
for (i = 0; i < 10; i++) {
arr1[i] = rand() % 100; // 生成 0~99 的随机数
printf("%d ", arr1[i]);
}
printf("\nArray 2: ");
for (i = 0; i < 10; i++) {
arr2[i] = rand() % 100; // 生成 0~99 的随机数
printf("%d ", arr2[i]);
}
return 0;
}
```
运行结果可能如下:
```
Array 1: 40 94 26 74 72 22 29 40 68 70
Array 2: 81 87 94 9 39 90 36 80 75 89
```
相关问题
C语言两个二维数组相乘
以下是C语言中两个二维数组相乘的代码实现:
```c
#include <stdio.h>
#include <stdlib.h>
typedef struct TwoDArray {
int rows;
int columns;
int **elements;
} TwoDArray, *TwoDArrayPtr;
// 初始化二维数组
void initTwoDArray(TwoDArrayPtr array, int rows, int columns) {
array->rows = rows;
array->columns = columns;
array->elements = (int **)malloc(rows * sizeof(int *));
for (int i = 0; i < rows; i++) {
array->elements[i] = (int *)malloc(columns * sizeof(int));
}
}
// 释放二维数组
void freeTwoDArray(TwoDArrayPtr array) {
for (int i = 0; i < array->rows; i++) {
free(array->elements[i]);
}
free(array->elements);
}
// 随机赋值
void randomAssign(TwoDArrayPtr array) {
for (int i = 0; i < array->rows; i++) {
for (int j = 0; j < array->columns; j++) {
array->elements[i][j] = rand() % 10;
}
}
}
// 打印二维数组
void printTwoDArray(TwoDArrayPtr array) {
for (int i = 0; i < array->rows; i++) {
for (int j = 0; j < array->columns; j++) {
printf("%d ", array->elements[i][j]);
}
printf("\n");
}
}
// 二维数组相乘
TwoDArrayPtr multiplyTwoDArray(TwoDArrayPtr array1, TwoDArrayPtr array2) {
if (array1->columns != array2->rows) {
printf("Error: The number of columns in the first array must be equal to the number of rows in the second array.\n");
return NULL;
}
TwoDArrayPtr result = (TwoDArrayPtr)malloc(sizeof(TwoDArray));
initTwoDArray(result, array1->rows, array2->columns);
for (int i = 0; i < array1->rows; i++) {
for (int j = 0; j < array2->columns; j++) {
int sum = 0;
for (int k = 0; k < array1->columns; k++) {
sum += array1->elements[i][k] * array2->elements[k][j];
}
result->elements[i][j] = sum;
}
}
return result;
}
// 测试代码
void test() {
TwoDArray array1, array2, *result;
initTwoDArray(&array1, 2, 3);
initTwoDArray(&array2, 3, 2);
randomAssign(&array1);
randomAssign(&array2);
printf("Array1:\n");
printTwoDArray(&array1);
printf("Array2:\n");
printTwoDArray(&array2);
result = multiplyTwoDArray(&array1, &array2);
if (result != NULL) {
printf("Result:\n");
printTwoDArray(result);
freeTwoDArray(result);
}
freeTwoDArray(&array1);
freeTwoDArray(&array2);
}
// 主函数
int main() {
test();
return 0;
}
```
c语言随机产生一个数组,用任意两种排序方法进行排序,输出原始数组和排序后结果
好的,下面是一个示例代码,其中使用了冒泡排序和快速排序两种算法:
```c
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// 生成随机数组
void generate_array(int arr[], int n) {
int i;
srand(time(NULL));
for (i = 0; i < n; i++) {
arr[i] = rand() % 100;
}
}
// 冒泡排序
void bubble_sort(int arr[], int n) {
int i, j, temp;
for (i = 0; i < n - 1; i++) {
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j+1]) {
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
// 快速排序
void quick_sort(int arr[], int left, int right) {
if (left >= right) {
return;
}
int i = left, j = right;
int pivot = arr[left];
while (i < j) {
while (i < j && arr[j] >= pivot) {
j--;
}
arr[i] = arr[j];
while (i < j && arr[i] <= pivot) {
i++;
}
arr[j] = arr[i];
}
arr[i] = pivot;
quick_sort(arr, left, i - 1);
quick_sort(arr, i + 1, right);
}
// 输出数组元素
void print_array(int arr[], int n) {
int i;
for (i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[10];
int n = sizeof(arr) / sizeof(arr[0]);
generate_array(arr, n);
printf("Original array:\n");
print_array(arr, n);
bubble_sort(arr, n);
printf("After bubble sort:\n");
print_array(arr, n);
generate_array(arr, n); // 重新生成随机数组
printf("Original array:\n");
print_array(arr, n);
quick_sort(arr, 0, n - 1);
printf("After quick sort:\n");
print_array(arr, n);
return 0;
}
```
输出结果类似于:
```
Original array:
75 77 61 18 31 39 22 39 68 58
After bubble sort:
18 22 31 39 39 58 61 68 75 77
Original array:
6 99 49 41 6 41 25 23 47 29
After quick sort:
6 6 23 25 29 41 41 47 49 99
```