历年笔试题目笔记

for(int i = 0; nums[i] != temp; i++)
{
    printf("%d", i);
}

int i = 0;
L1:
if(nums[i] != temp)
    goto L2;        // 条件跳转
else
    goto L3;        // 条件跳转
L2:

printf("%d", i);

goto L1;            // 强制跳转

L3:

for(num = N; arr[num] != item; num--)
	printf("%d", num);

int calculate_substr(char *A, char *B)
{
    int len_A = strlen(A);   //计算字符串A、B的长度
    int len_B = strlen(B);
    int substr_num = 0;      //A的子串数量
    if(lenA < len_B)
        return substr_num;
    for(int i = 0; i < len_A - len_B + 1; i++)
    {
        if(!memcmp(&A[i], B, len_B)) //指针也可以使用字符串引索
            substr_num++;
    }
    return substr_num;
}

int calculate_substr(char *A, char *B)
{
	int *start_pos = A;       //字符串A的起始搜索地址
    int len_B = strlen(B);    //计算字符串B的长度
    int substr_num = 0;       //A的子串数量
	while(start_pos = strstr(start_pos, B))
	{
		substr_num ++;
		start_pos ++;         //实际上可以加2，但是会使边界条件复杂化
	}
    return substr_num;
}

#define MAX_WORD_LEN  32
#define MAX_WORD_NUM  1024

#include <string.h>
#include <stdio.h>

typedef struct {
    char word[MAX_WORD_LEN];
    int show_times;
} word_t;

word_t library[MAX_WORD_NUM] = { 0 };

int search_word(char word[])
{
    for(int i = 0; i < MAX_WORD_NUM; i++)
    {
        if(library[i].show_times == 0)
        {
            return -1;
        } else if(!strcmp(library[i].word, word))
        {
            return i;
        }
    }
}

int count_word(char word[])
{
    int word_id = search_word(word);
    if(word_id > 0)
    {
        library[word_id].show_times++;
        return word_id;
    } else {
        for(int i = 0; i < MAX_WORD_NUM; i++)
        {
            if(library[i].show_times == 0)
            {
                strcpy(library[i], word);
                library[i].show_times = 1;
                return i;
            }
        }
        return -1
    }
}

int process_file(char path[])
{
    FILE *f = fopen(path, "r");
    if(f == NULL)
    {
        printf("open file: %s failed.\r\n", path);
        return -1;
    } else {
        char word[MAX_WORD_LEN] = { 0 };
        while(fgets(word, MAX_WORD_LEN, f))  //fgets函数当遇到换行符时会自动分割并返回word指针，遇到EOF时会返回NULL。
        {
            count_word(word);
            memset(word, 0x00, MAX_WORD_LEN);
        }
        return 0;
    }
}

// C语言的命令行参数中，第一个参数通常为可执行文件的路径，第二个参数开始才是命令行传入的参数
int main(int argc, char argv[])
{
    // load English file.
    if(!process_file(argv[1]))
        return -1;
    
    // A demostration of search a word "hello"
    char test_word[] = "hello";
    int index = search_word(test_word);
    if(index >= 0)
        printf("The show times of word %s is %d\r\n", test_word, library[index]);
    else
        printf("The show times of word %s is 0", test_word);
    return 0;
}

#include <stdio.h>

typedef struct{
    char name[16];
    int id;
    int score;
} student_t;

// 冒泡排序所用比较函数，值为学生a的分数减去学生b的分数
int compare(const student_t *a, const student_t *b)
{
    return a->score - b->score;
}

// 冒泡排序的实现，传入student_t数组和数组大小n，以及比较函数的指针
void bubble_sort(student_t s[], int n, int *cmp(const void* a, const void* b))
{
    // 执行n-1趟
    for(int trips = 0; trips < n - 1, trips++)
    {
        // 将元素s[i]和元素s[i+1]做对比，i从0到n - trips - 1
        for(int i = 0; i < n - trips - 1; i++)
        {
            if(cmp(&s[i], &s[i+1]) > 0)
            {
                student_t temp = s[i];   // 可以直接使用swap(&s[i], &s[i+1])
                s[i] = s[i+1];
                s[i+1] = temp;
            }
        }
    }
}

// 二分查找，返回值为score的学生的index。但是只能查找到一个为score的学生
int binary_search(student_t s[], int n, int score)
{
    int l_index = 0, r_index = n - 1;
    while(l_index <= r_index)
    {
        int mid = (l_index + r_index) / 2;
        if(s[mid].score == score)
            return mid;
        else if(s[mid].score > score)
            l_index = mid + 1;
        else
            r_index = mid - 1;
    }
    return -1;
}

// 查找所有分数为score的学生，假设caller负责调用free函数
student_t *search_score(student_t s[], int n, int score, int* result_nums)
{
    int index = binary_search(s, n, socre);
    int l_index = index, r_index = index;
    *result_nums = 0;
    if(index < 0)
        return NULL;
    while(l_index > 0 && s[l_index - 1].score == score)
        l_index --;
    while(r_index < n - 1 && s[r_index + 1].score == score)
        r_index ++;
    *result_nums = r_index - l_index + 1;
    student_t *result = malloc(sizeof(student_t) * (*result_nums));
    memcpy(result, &s[l_index], sizeof(student_t) * (*result_nums));
    return result;
}

int main()
{
    int n = 100; // 给定学生数量
    int score = 89; // 目标分数
    // 假设题中所给学生数据由create_student_info提供。
    student_t *s_list = create_student_info(n);
    bubble_sort(s_list, n, compare);
	
    int result_nums = 0;
    student_t *result = search_score(s_list, n, score, &result_nums);
    for(int i = 0; i < result_nums; i++)
    {
        printf("name: %s, id: %d, score: %d", 
            (result + i) -> name, (result + i) -> id, (result + i) -> score);
    }
    return 0;
}

#include <stdio.h>
#include <time.h>

typedef struct node {
    int id;
    struct node* next;
} node_t;

int get_rand()
{
    return rand()%10;
}

// 传入链表和目标id；使用含头结点的链表
void move_node_to_head(node_t* nodelist, int id)
{
    node_t* pre = NULL;
    node_t* cur = *nodelist;

    // find target
    while(cur -> next && cur -> id != id)
    {
        pre = cur;
        cur = cur -> next;
    }

    // move node to head;
    if(cur -> id == id)
    {
        pre -> next = cur -> next;
        cur -> next = nodelist -> next;
        nodelist -> next = cur;
        return;
    } else {
        // 移动失败，在合法调用时也不存在该情况。
        return;
    }
}

node_t* create_list()
{
    node_t* head = calloc(sizeof(node_t), 1);
    node_t* curr = head;
    for(int i = 1; i <= 10; i++)
    {
        curr -> next = calloc(sizeof(node_t), 1);
        curr = curr -> next;
        curr -> id = i;
    }
    return head;
}

// 递归free链表
void destory_list(node_t* list)
{
    if(list != NULL)
    {
        destory_list(list -> next);
        free(list);
    }
}

int main()
{
    //设置随机数种子
    srand(time());
	
    int m = abs(rand());
	
    node_t* list = create_list();
	
    for(int i = 0; i < m; i++)
    {
        move_node_to_head(list, get_rand());
    }
	
    destory_list(list);
	
    return 0;
}

// 辗转相除法求最大公倍数，要求a 必须大于等于 b
int gcd(int a, int b)
{
    int mod = a % b;
    if(mod)
        return gcd(b, mod);
    else
        return b;
}

// 求两个数的最小公倍数
int lcm(int a, int b)
{
    if(a > b)
        return b * gcd(a, b);
    else
        return a * gcd(b, a);
}

// 求数组的最小公倍数，要求n>=2。
int LCM(int array[], int n)
{
    if(n < 2)
        return -1;

    // 先求前两个数的lcm
    int current_lcm = lcm(array[0], array[1]);

    // 求第三个数开始的lcm
    for(int i = 2; i < n; i++)
    {
        current_lcm = lcm(array[i], current_lcm);
    }
    return current_lcm;
}

#include <string.h>

int insert_str(char a[], const char b[], int pos)
{
    // 先计算字符串a、b的长度
    int a_len = strlen(a);
    int b_len = strlen(b);

    // 将a字符串的pos位后的字符串后移，由于目标内存和源内存可能存在内存区域重合，故只可使用 `memmove` 而不可使用 `strcpy` 。
    memmove(a + pos + strlen(b) * sizeof(char), a + pos, strlen(b) * sizeof(char));
    // 将字符串b拷贝到字符串a的指定位置
    memcpy(b, a + pos, strlen(b) * sizeof(char));
    return 0;
}

for(int i = 0; i < 100; i++)
{
	a[i] = rand() % 100 + 1;
	for(j = 0; j < i; j++)
		if(a[i] == a[j])
			i--;
}

int tag[100] = { 0 };
for(int i = 0; i < 100; i++)
{
	a[i] = rand() % 100 + 1;
	if(tag[a[i]] == 1)
		i--;
	else
		tag[a[i]] = 1;
}

for(int i = 0; i < n; i++)
{
	a[i] = i + 1;
	for(int j = 0; j < 100; j++)
		swap(&a[rand()%100], &a[rand()%100]);
}

int compare(int *a, int *b)
    return a - b;

float calc_mid_num(int array[], int n)
{
    qsort(array, sizeof(int), n, compare);
    if(n == 0)
        return -1;
    if(n % 2)
        return array[n/2];
    else
        return (array[n/2] + array[(n/2) - 1]);
}

typedef struct student {
    int score;
    int age;
    int height;
} student_t;

int compare(student_t *a, student_t *b)
{
    if(a -> score != b -> score)
    {
        return a -> score - b -> score;
    } else if(a -> age != b -> age)
    {
        return a -> age - b -> age;
    } else {
        return a -> height - b -> height;
    }
}

int bubble_sort(student_t s[], int n, int (*cmp)(student_t *a, student_t *b))
{
    // 比较n-1趟
    for(int trips = 0; trips < n - 1; trips ++)
    {
        // 进行该趟的冒泡排序，将第i号引索元素和其后元素做对比，排序区间为 i \in [0, n - trips - 2]
        for(int i = 0; i < n - trips - 1; i ++)
        {
            if(cmp(&s[i], &s[i + 1]))
                swap(&s[i], &s[i + 1])
        }
    }
    return 0;
}

int sort_student(student_t s[], int n)
{
    return bubble_sort(s, n, compare);
}

// 删除字符串str的第pos位开始的长度为len的子串，pos从0计数，删除内容包含pos位
char * del_substr(char *str, int pos, int len)
{
    int str_len = strlen(str);
    if(pos > str_len)
    {
        return str;
    } else if(pos + len >= str_len) {
        memset(str, 0x00, str_len - pos);
        return str;
    } else {
        memset(str, 0x00, len);
        memmove(str + pos, str + pos + len, str_len - pos - len);
        memset(str + str_len - len, 0x00, len);
        return str;
    }
}

typedef struct node
{
    int id;
    struct node* next;
} node_t;

// 无头结点的链表转置
node_t* reverse(node_t * const list)
{
    node_t *prev = NULL;
    node_t *curr = list;
    while(curr) {
        // 暂存下一节点
        node_t *next = curr -> next;
        // 将链表指针方向转置
        curr -> next = prev;
        // 移动窗口
        prev = curr;
        curr = next;
    }
    return prev;
}

// 翻转链表list的第start节点到第end节点的部分，使用带头结点的链表。
// start和end从1开始计算。
node_t* partical_reverse(node_t* const list, int start, int end)
{
    // 假设传入链表以及对应的start、end如下：
    // | 1 | -> ··· -> | a | -> | b | -> ··· -> | c | -> | d | -> ··· -> | e | -> NULL
    //   ↑                        ↑               ↑
    // list                     start            end
    // 则定义如下关系的指针：
    // | 1 | -> ··· -> | a | -> | b | -> ··· -> | c | -> | d | -> ··· -> | e | -> NULL
    //   ↑               ↑        ↑               ↑        ↑
    // list            prev     front            rear    after
    node_t *curr = list, *prev = NULL, *front = NULL, *rear = NULL, *after = NULL;

    // 随后获取上述指针的值，curr当作遍历指针
    int i = 0;
    while(curr)
    {
        // index从1开始
        i++;
        if(i == start - 1)
            prev = curr;
        if(i == start)
            front = curr;
        if(i == end)
            rear = curr;
        if(i == end + 1)
            after = curr;
        curr = curr -> next;
    }
    // 其中 prev 和 after 可能为 NULL 。

    // 截断 front 到 rear 的部分。
    rear -> next = NULL;
    reverse(front);

    // 拼回去
    front -> next = after;
    // 注意prev可能为null
    if(prev == NULL)
    {
        return rear;
    } else {
        prev -> next = rear;
        return list;
    }
}

void main()
{
	int a[] = { 1, 7, 12, 15 };
	int *p1 = a, *p2 = p1++;
	*p1 += *p2++;
	printf("%d %d", *p1, *p2);
}

void main()
{
	int a[] = { 1, 7, 12, 15 };
	int *p1 = a;
	*p2 = p1++;    // 此时p1指向a[1]，p2指向a[0]
	*p1 += *p2++;  // a[1] += *p，p++
	printf("%d %d", *p1, *p2);
}

typedef struct
{
    int age;
    int score;
} student_t;

int main()
{
    student_t stu;
    student_t *p = &stu;
    *p.age = 23;
    return 0;
}

(*p).age = 23;

long var = (long)(float_value + 0.5);

long var = round(float_value);

void encrypt(char *str, char *key)
{
	int offset = atoi(key);  // atoi为stdlib.h中定义的将字符串转为整形的一个方法。
	offset %= 256;           // 保证offset范围为[0, 255]
	while(*str != '\0')
	{
		if('A' <= *str && *str <= 'Z')
		{
			// 此时为大写字符
			*str = (*str + offset) % 'A';
		} else if('a' <= *str && *str <= 'z'){
			// 此时为小写字符
			*str = (*str + offset) % 'a';
		}
		str++;
	}
}

double calculate(int n)
{
	// 直接计算第一项
	double sum = 1;
	// 每一项的阶乘分母
	double mul = 1;
	for(int i = 1; i <= n; i++)
	{
		mul *= i;
		double t = pow(-1, i) * pow(x, i) / mul;
		sum += t;
	}
	return sum;
}

for(int i = 12; i < 999; i++)
{
	t = 0;
	for(x = 0; x < 10; x++)
		f[x] = 0;
	for(j = 345; j < 9999; j++)
	{
		__________;
		s[0] = a;
		s[1] = b;
		s[2] = c;
		for(x = 0; x < 3; x++)
		{
			y = s[x];
			__________ {
				int t = y % 10;
				f[t] ++;
				__________;
			}
			for(x = 0; x < 10; x++)
			{
				if(__________)
					t++;
			}
			__________;
			__________;
		}
	}
}

int low = ___;
int high = ___;
do{
    i = low;
    _______;
    _______;
    do{
        _______;
        _______;
        _______;
    } while(___);
    _______;
    if(i == k)
        return ___;
    if(i > k)
        _______;
    if(i < k)
        _______;
} while(low < high);
return _______;

int low = 0;
int high = n - 1;
do{
    i = low;
    j = high;
    pivot = array[i];
    do{
        while(array[j--] > pivot);
        while(array[i++] < pivot);
        swap(&array[j], &array[i]);
    } while(i < j);
    array[i] = array[high];
    if(i == k)
        return array[i];
    if(i > k)
        high = i - 1;
    if(i < k)
        high = i + 1;
} while(low < high);
return a[low];