/*
1. 计算二项式系数（15’）
给定 n, m <= 40，计算二项式系数 C(n, m) = n!/(m!(n-m)!)。保证结果在整型（int）范围内。
int binomial_coefficient(int n, int m){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
int min(int a, int b) {
int m = a < b ? a : b;
return m;
}
int binomial_coefficient_0(int n, int m) { // 按照阶乘展开公式直接计算
long double ans = 1;
for (int i = 0; i < m; i++) {
ans = ans * (n - i);
ans = ans / (m - i);
} // 乘以最大数后，立即除以最大数，缓解溢出风险
return ans; // 隐式强制转换
}
int binomial_coefficient_1(int n, int m) { // 按照二项式公式递归计算，调用函数时间开销大
if (m == 0 || n == m)
return 1; // C(n, 0) == c(n, n) == 1
return binomial_coefficient_1(n - 1, m - 1) + binomial_coefficient_1(n - 1, m);
// C(n, m) = C(n-1, m-1) + C(n-1, m)
}
int binomial_coefficient_2(int n, int m) { // 按照二项式公式递推计算，开辟数组空间开销大
int C[n + 1][m + 1];
for (int i = 0; i <= n; i++)
for (int j = 0; j <= min(i, m); j++) {
if (j == i || j == 0)
C[i][j] = 1; // C(n, 0) == c(n, n) == 1
else
C[i][j] = C[i - 1][j - 1] + C[i - 1][j]; // C(n, m) = C(n-1, m-1) + C(n-1, m)
}
return C[n][m];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
printf("%d\n", binomial_coefficient_0(n, m));
printf("%d\n", binomial_coefficient_1(n, m));
printf("%d\n", binomial_coefficient_2(n, m));
system("pause");
return 0;
}
/*
2. 给定一个从小到大排序的链表，向链表中插入一个新的值，要求插入后的链表仍
然是有序的。（15’）
Definition for singly-linked list.
struct ListNode {
int val;
struct ListNode *next;
};
// Insert a value into the ordered linked list, returns the head of the new linked list
struct ListNode* Insert(struct ListNode* head, int new_value){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
struct ListNode {
int val;
struct ListNode* next;
};
struct ListNode* Insert(struct ListNode* head, int new_value) {
if (head == NULL) { // 如果给定的链表本身为空，则返回该新结点
struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode)); // 分配空间
new_node->val = new_value; // 赋值
new_node->next = NULL; // 初始化
return new_node; // 返回该头结点
}
else if (head->val >= new_value) { // 如果新值一开始就比头结点更小，则放到链头
struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode)); // 分配空间
new_node->val = new_value; // 赋值
new_node->next = head; // 链接到旧的头结点
return new_node; // 返回新的头结点
}
else if (head->next == NULL) { // 如果扫描到链表尾部还没找到可插入位置，就放到链尾
struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode)); // 分配空间
new_node->val = new_value; // 赋值
new_node->next = NULL; // 初始化
head->next = new_node; // 与上一个结点相连
return head; // 返回到上一级递归函数调用
}
else if ((head->next)->val >= new_value) { // 扫描到可插入位置
struct ListNode* new_node = (struct ListNode*)malloc(sizeof(struct ListNode)); // 分配空间
new_node->val = new_value; // 赋值
new_node->next = head->next; // 链接到下一结点
head->next = new_node; // 链接到上一结点
return head; // 返回到上一级递归函数调用
}
Insert(head->next, new_value); // 递归遍历整个链表
return head; // 返回头结点
}
int main() {
printf("Please enter the number of node(s): \n");
int n;
scanf("%d", &n);
struct ListNode NodeSet[n];
printf("Now please enter the value of your %d node(s) in ascending order: \n", n);
for (int i = 0; i < n - 1; i++) {
int value;
scanf("%d", &value);
NodeSet[i].val = value;
NodeSet[i].next = &NodeSet[i + 1];
}
int value;
scanf("%d", &value);
NodeSet[n - 1].val = value;
NodeSet[n - 1].next = NULL;
printf("Now please enter the new value: \n");
int new_value;
struct ListNode* head;
scanf("%d", &new_value);
head = Insert(&NodeSet[0], new_value);
printf("Now this is your new linked list: \n");
while (head) {
printf("%d ", head->val);
head = head->next;
}
putchar('\n');
system("pause");
return 0;
}
/*
3. 给定两个从小到大排序的数组，把它们合并成一个数组，保持从小到大的顺序。（20’）
int* MergeArray(int* list1, int size1, int* list2, int size2, int* return_size){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
int* MergeArray(int* list1, int size1, int* list2, int size2, int* return_size) {
*return_size = size1 + size2;
int* list_merge = (int*)malloc(sizeof(int) * (*return_size));
int ptr_merge = 0, ptr_list1 = 0, ptr_list2 = 0; // 指向每个数组的当前操作位
while (ptr_list1 < size1 && ptr_list2 < size2) { // 处理需要比较大小的部分
if (list1[ptr_list1] <= list2[ptr_list2]) { // 如果是第一个数组的元素比较小
list_merge[ptr_merge] = list1[ptr_list1];
ptr_list1++;
ptr_merge++;
}
else { // 如果是第二个数组的元素比较小
list_merge[ptr_merge] = list2[ptr_list2];
ptr_list2++;
ptr_merge++;
}
}
while (ptr_list1 < size1) { // 如果第一个数组仍有剩余部分
list_merge[ptr_merge] = list1[ptr_list1];
ptr_list1++;
ptr_merge++;
}
while (ptr_list2 < size1) { // 如果第一个数组仍有剩余部分
list_merge[ptr_merge] = list2[ptr_list2];
ptr_list2++;
ptr_merge++;
}
return list_merge; // 返回数组地址
}
int main() {
printf("Please enter the size of your first array: \n");
int size1;
scanf("%d", &size1);
int list1[size1];
printf("Now please enter your first array's %d element(s) in ascending order: \n", size1);
for (int i = 0; i < size1; i++)
scanf("%d", &list1[i]);
printf("Please enter the size of your second array: \n");
int size2;
scanf("%d", &size2);
int list2[size2];
printf("Now please enter your second array's %d element(s) in ascending order: \n", size2);
for (int i = 0; i < size2; i++)
scanf("%d", &list2[i]);
int size_merge = 0;
int* list_merge = MergeArray(list1, size1, list2, size2, &size_merge);
printf("There is your merged array with %d element(s): \n", size_merge);
for (int i = 0; i < size_merge; i++)
printf("%d ", list_merge[i]);
putchar('\n');
free(list_merge);
system("pause");
return 0;
}
/*
4. 给定一个大小为 n*n 的矩阵，计算矩阵的行列式。（20’）
double Determinant(int n , int** matrix){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
double SubDeterminant_0(int n, int i, int** matrix); // 余子式重整
double Determinant_0(int n, int** matrix); // 行列式按第一行展开
double Determinant_1(int n, int** matrix); // 高斯消元法
int main() {
printf("Please enter the size of your matrix: \n");
int n;
scanf("%d", &n);
int matrix[n][n];
printf("Now please enter the element(s) of your matrix: \n");
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
scanf("%d", &matrix[i][j]);
printf("The determinant of your matrix is : \n%lE\n", Determinant_0(n, (int**)matrix));
printf("The determinant of your matrix is : \n%lE\n", Determinant_1(n, (int**)matrix));
system("pause");
return 0;
}
double Determinant_0(int n, int** matrix) { // 行列式按第一行展开
int(*array)[n] = (int(*)[n])matrix; // 将类型名从二重指针转换为二级数组，便于访问
if (n == 1)
return array[0][0];
else {
double sum = 0, sub_det;
for (int i = 0; i < n; i++) { // 将行列式按第一行展开
sub_det = SubDeterminant_0(n, i, matrix); // 计算每一列的余子式
sum += pow(-1, i) * sub_det * array[0][i]; // 累加代数余子式
}
return sum;
}
}
double SubDeterminant_0(int n, int i, int** matrix) {
int(*sub_matrix)[n - 1] = (int(*)[n - 1]) malloc(sizeof(int) * (n - 1) * (n - 1));
int(*array)[n] = (int(*)[n])matrix;
for (int j = 0; j < n - 1; j++) { // 重新整合余子式对应的矩阵，便于用Determinant_0()来计算
for (int m = 0; m < n - 1; m++) {
if (m < i)
sub_matrix[j][m] = array[j + 1][m];
else
sub_matrix[j][m] = array[j + 1][m + 1];
}
}
double sub_det = Determinant_0(n - 1, (int**)sub_matrix); // 继续执行下一级行列式展开
free(sub_matrix); // 释放空间
return sub_det;
}
double Determinant_1(int n, int** matrix) { // 高斯消元法
int(*array)[n] = (int(*)[n])matrix; // 将类型名从二重指针转换为二级数组，便于访问
double gauss[n][n];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
gauss[i][j] = array[i][j]; // 拷贝数据，避免对原数据修改
for (int diagonal = 0; diagonal < n; diagonal++) {
if (gauss[diagonal][diagonal] == 0) { // 如果当前对角线元素的值为 0
int row;
for (row = diagonal + 1; row < n; row++) // 则从对角线向下搜索直到找到非零数
if (gauss[row][diagonal] != 0)
break;
if (row == n) // 如果仍然搜索不到非零数
return 0; // 则该行列式为 0
for (int col = diagonal; col < n; col++)
gauss[diagonal][col] += gauss[row][col]; // 将该非零数所在的行，叠加到对角线元素所在的行，使对角线元素不为零
} // 保证对角线元素的值非零，用于之后的消元
for (int row = diagonal + 1; row < n; row++) {
double ratio = -1 * (gauss[row][diagonal] / gauss[diagonal][diagonal]); // 计算比例
for (int col = diagonal; col < n; col++)
gauss[row][col] += ratio * gauss[diagonal][col]; // 消元，将 diagonal列 中的对角线以下元素全部清零
} // 转化为上三角行列式
}
double det = 1.0;
for (int i = 0; i < n; i++)
det *= gauss[i][i]; // 上三角行列式的值等于对角线元素的乘积
return det;
}
/*
5. 给定两个字符串 a 和 b，判断 a 是否是 b 的子串。例如，当 a=”to”,
b=”cryptography”，a 是 b 的子串；当 a=”red”, b=”read”时，a 不是 b 的子串。（20’）
Given two strings a and b, decide if a is a substring of b.
bool IsSubstring(char* a, char* b){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#define MAX_LEN 1000
bool IsSubstring(char* a, char* b) {
int len_a = strlen(a), len_b = strlen(b);
for (int i = 0; i <= len_b - len_a; i++)
if (strncmp(a, b + i, len_a) == 0)
return true;
return false;
}
int main() {
char a[MAX_LEN], b[MAX_LEN];
printf("Please enter string a: \n");
scanf("%s", a);
printf("Now please enter string b: \n");
scanf("%s", b);
bool judge = IsSubstring(a, b);
if (judge)
printf("string a is a substring of b.\n");
else
printf("string a is NOT a substring of b.\n");
system("pause");
return 0;
}
/*
3. 给定两个从小到大排序的数组，把它们合并成一个数组，保持从小到大的顺序。（20’）
int* MergeArray(int* list1, int size1, int* list2, int size2, int* return_size){
//write your code here
}
*/
#include <stdio.h>
#include <stdlib.h>
void Move_Hanoi(int n, char A, char B, char C) { // 原版汉诺塔
if (n == 1)
printf("%c -> %c\n", A, C);
else {
Move_Hanoi(n - 1, A, C, B); // 把上层 n-1 个圆盘从 A 移动到 B
printf("%c -> %c\n", A, C); // 把最底的第 n 个圆盘从 A 移动到 C
Move_Hanoi(n - 1, B, A, C); // 把剩余的 n-1 个圆盘从 B 移动到 C
}
}
void Hanoi(int n) {
char A = 'A', B = 'B', C = 'C';
if (n == 1)
printf("A -> B\n");
else if (n == 2)
printf("A -> B\n"
"A -> C\n");
else if (n & 2 == 1) {
Move_Hanoi(n - 1, A, B, C); // 把上层 n-1 个圆盘从 A 移动到 C
printf("A -> B\n"); // 把最底的第 n 个圆盘(n为奇数) 从 A 移动到 B
Move_Hanoi(n - 2, C, B, A); // 把剩余的 n-2 个圆盘从 C 移回到 A， 其中第 n-1 个圆盘(偶数)仍留在 C
Hanoi(n - 2); // 开始下一次判断
}
else {
Move_Hanoi(n - 1, A, C, B); // 把上层 n-1 个圆盘从 A 移动到 B
printf("A -> C\n"); // 把最底的第 n 个圆盘(n为偶数) 从 A 移动到 C
Move_Hanoi(n - 2, B, C, A); // 把剩余的 n-2 个圆盘从 B 移回到 A， 其中第 n-1 个圆盘(奇数)仍留在 B
Hanoi(n - 2); // 开始下一次判断
}
}
int main() {
printf("Please enter the size of your Hanoi: \n");
int n;
scanf("%d", &n);
printf("There is the movement of your Hanoi: \n");
Hanoi(n);
system("pause");
return 0;
}
浙公网安备 33010602011771号