常考，但不会的题，多敲几遍死记硬背

原创 已于 2024-09-10 09:10:20 修改 · 470 阅读 · 5 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
数据结构

当前文章被收录于：

数据结构
25 篇文章 0 人学习
订阅专栏 查看详情
于 2024-03-27 21:39:24 首次发布
本文介绍了几个编程练习，包括分数运算、链表操作、高斯消元法、约瑟夫环问题、统计单词个数以及n个数取k个数的排列，展示了基础算法的实现过程。

1.法雷序列

照着敲的一遍

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct fraction{
    int fz,fm;
    struct fraction *next;
}fra;
void divide(fra *a,fra *b,int n)
{
    if(a->fm+b->fm>n)
        return ;
    fra *temp=(fra *)malloc(sizeof(fra));
    temp->fz=a->fz+b->fz;
    temp->fm=a->fm+b->fm;
    a->next=temp;
    temp->next=b;
    divide(a,temp,n);
    divide(temp,b,n);
}
int main() {
    int n;
    scanf("%d",&n);
    fra *head=(fra *)malloc(sizeof(fra));
    head->fz=0,head->fm=1;
    fra *tail=(fra *)malloc(sizeof(fra));
    tail->fz=1,tail->fm=1;
    head->next=tail;
    tail->next=NULL;
    divide(head,tail,n);
    fra *p=head->next;
    while(p!=NULL)
    {
        printf("%d/%d ",p->fz,p->fm);
        p=p->next;
    }
    return 0;
}

自己尝试敲的一遍

void divide(fra *a,fra *b,int n)
{
    fra *temp=(fra *)malloc(sizeof(fra));
    a->next=temp;
    temp->next=b;
    divide(a,temp,n);
    divide(temp,b,n);
}
int main()
{
    int n;
    scanf("%d",&n);
    fra *head=(fra *)malloc(sizeof(fra));
    head->fz=0,head->fm=1;
    fra *tail=(fra *)malloc(sizeof(fra));
    tial->fz=1,tail->fm=1;
    divide(head,tail,n);
    fra *p=head->next;
    while(p!=NULL)
    {
        printf("%d/%d",p->fz,p->fm);
        p=p->next;
    }
    return 0;
}

对比一下，70%相似度

继续自己开敲

#include<stdio.h>
#include<stdlib.h>
typedef struct fraction{
    int fz,fm;
    struct fraction *next;
}fra;
void divide(fra *a,fra *b,int n)
{
    if(a->fm+b->fm>n)
        return;
    fra *temp=(fra *)malloc(sizeof(fra));
    temp->fz=a->fz+b->fz;
    temp->fm=a->fm+b->fm;
    a->next=temp;
    temp->next=b;
    divide(a,temp,n);
    divide(temp,b,n);
}
int main()
{
    int n;
    scanf("%d",&n);
    fra *head=(fra *)malloc(sizeof(fra));
    head->fz=0,head->fm=1;
    fra *tail=(fra *)malloc(sizeof(fra));
    tail->fz=1,tail->fm=1;
    head->next=tail;
    tail->next=NULL;
    divide(head,tail,n);
    fra *p=head->next;
    while(p!=NULL)
    {
        printf("%d/%d",p->fz,p->fm);
        p=p->next;
    }
    return 0;
}

完美，成功复刻，再多看两眼。过两个小时重温一下

2.高斯消元法

照着敲一遍

void deduce(float a[N][N])
{
    int i,j,k;
    float coeff;
    for(k=0;k<N;k++){
        for(i=k+1,i<N;i++){
            coeff=a[i][k]/a[k][k];
            for(j=k;j<N;j++){
                a[i][j]=a[k][j]*coeff-a[i][j];
            }
        }
    }
}

自己敲一遍,口诀：i循环里i在前，j循环里j在后且全勤；

void deduce(float a[N][N])
{
    int i,j,k;
    float coeff;
    for(int k=0;k<N;k++){
        for(int i=k+1;i<N;i++){
            coeff=a[i][k]/a[k][k];
            for(int j=k;j<N;j++){
                a[i][j]=a[k][j]*coeff-a[i][j];
            }
        }
    }
}

3.约瑟夫问题

照着敲一遍

int josephus(int n,int m,int start)
{
    int dead[n];
    for(int i=0;i<n;i++)
        dead[i]=0;
    int index=start-1;
    for(int i=0;i<n-1;i++){
        int count=0;
        while(count<m){
            if(!dead[index])
                count++;
            if(count<m)
                index=(index+1)%n;
        }
        dead[index]=1;
        printf("%d",index+1);
    }
    for(int i=0;i<n;i++){
        if(!dead[i])
            return i+1;
    }
    return -1;
}

自己敲

int func(int n,int m,int start)
{
    int dead[n]={0};
    int index=start-1;
    int count=0;
    while(count<m){
        if(!dead[index])
            count++;    
        if(count<m)
            index=(index+1)%m;
    }
    dead[index]=1;
    printf("%d",index+1);
    for(int i=0;i<n;i++)
        if(!dead[i])
            return i+1;
    return -1;
}

掉个for循环。。真纯背了，代码逻辑都不看，汗流浃背了

int func(int n,int m,int start)
{
    int dead[n]={0};
    int index=start-1;
    for(int i=0;i<n-1;i++)
    {
        int count=0;
        while(count<m)
        {
            if(!dead[index])
                count++;
            if(count<m)
                index=(index+1)%n;
        }
        dead[index]=1;
        printf("%d",index+1);
    }
    for(int i=0;i<n;i++)
        if(!dead[i])
            return i+1;
    return -1;
}

4.统计单词个数

实际就是strtok的用法不熟练，思路很好理解，照着敲一遍

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<string.h>
#define MAX_WORDS 1000
#define MAX_LEN 10
typedef struct{
    char word[MAX_LEN+1];
    int cnt;
}Word;
int main()
{
    char text[MAX_WORDS];
    Word words[MAX_WORDS];
    int wordcnt=0;
    gets(text);
    char *token=strtok(text," ,.!?;\n");
    while(token!=NULL&&wordcnt<MAX_WORDS){
        for(int i=0;token[i];i++)
            token[i]=tolower(token[i]);
        int found=0;
        for(int i=0;i<wordcnt;i++)
        if(strcmp(words[i].word,token)==0){
            words[i].cnt++;
            found=1;
            break;
        }
        if(!found){
            strcpy(words[wordcnt].word,token);
            words[wordcnt].cnt=1;
            wordcnt++;
        }
        token=strtok(NULL," ,.!?\n");
    }
    for(int i=0;i<wordcnt;i++)
        printf("%s:%d\n",words[i].word,words[i].cnt);
}

自己尝试敲一遍(洗个澡出来全忘完了,随再照着敲一遍）

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define MAX_WORD 1000
#define MAX_LEN 10
typedef struct{
    char words[MAX_LEN+1];
    int cnt;
}WORD;
int main()
{
    char text[MAX_WORD];
    gets(text);
    WORD word[MAX_WORD];
    int wordcnt=0;
    char *token=strtok(text," ,.!?\n");
    while(token!=NULL&&wordcnt<MAX_WORD)
    {
        for(int i=0;token[i];i++)
            token[i]=tolower(token[i]);
        int found=0;
        for(int i=0;i<wordcnt;i++){
            if(strcmp(word[i].words,token)==0){
                word[i].cnt++;
                found=1;
                break;
            }
        }
        if(!found){
            strcpy(word[wordcnt].words,token);
            word[wordcnt].cnt=1;
            wordcnt++;
        }
        token=strtok(NULL," ,.!?\n");
    }
    for(int i=0;i<wordcnt;i++)
        printf("%s:%d\n",word[i].words,word[i].cnt);
}

真的自己敲一遍了

//节约时间 省略头文件及预定义

int main()
{
    char text[1000];
    gets(str);
    WORD w[1000];
    int wordcnt=0;
    char *token=strtok(text," ,.!?\n");
    while(token!=NULL&&wordcnt<1000)
    {
        for(int i=0;token[i];i++)
            token[i]=tolower(token[i]);
        int fount=0;
        for(int i=0;i<wordcnt;i++)
            if(strcmp(w[i].words,token)==0)
            {
                w[i].cnt++;
                found=1;
                break;        //欧克 ，这遍忘了加这个break了
            }
        if(!found)
        {
            strcpy(w[wordcnt].words,token);
            w[wordcnt]=1;
            wordcnt++;
        }
        token=strtok(NULL," ,.!?\n");
    }
    for(int i=0;i<wordcnt;i++)
        printf("%s:%d",w[i].words,w[i].cnt);
}

5.n个数取k个数，求排列

照着敲

#include<stdio.h>
void func(int n,int k,int start,int depth,int a[])
{
    if(depth==k){
        for(int i=0;i<k;i++)
            printf("%d",a[i]);
        printf("\n");
        return ;
    }
    for(int i=start;i<=n;i++){
        a[depth]=i;
        func(n,k,i+1,depth+1,a);
    }
}
int main()
{
    int n=5,k=2;
    int a[k];
    func(n,k,1,0,a);
    return 0;
}

试图背下来，自己敲一遍,（敲不下来一点）

void func(int n,int k,int start,int depth,int a[])
{
    if(depth==k)
    {
        for(int i=0;i<k;i++)
            printf("%d",a[i]);
        printf("\n");
        return ;
    }
    for(int i=start;i<=n;i++)
    {
        a[depth]=i;
        func(n,k,i+1,depth+1,a);
    }
}
//GGGG全是抄的

看两眼，再试一遍,拿下了家人们

void func(int n,int k,int start,int depth,int a[])
{
    if(depth==k)
    {
        for(int i=0;i<k;i++)
            printf("%d",a[i]);
        printf("\n");
        return ;
    }
    for(int i=start;i<=n;i++)
    {
        a[depth]=i;
        func(n,k,start+1,depth+1,a);
    }
}

6.分数除法，有循环节输出循环节

有点复杂在的，还涉及了memmove，一脸懵啊家人们，真考到就拣点分吧，纯背

int main()
{
    int N,D;
    scanf("%d/%d",&N,&D);
    if(N%D==0){
        char *res=malloc(sizeof(char)*20);
        sprintf(res,"%d",N/D);
        return 0;
    }
    char *res=malloc(sizeof(char)*100);
    int len=0;
    if((N<0)^(D<0))
        res[len++]='-';
    N=abs(N);
    D=abs(D);
    sprintf(res+len,"%d",N/D);
    len=strlen(res);
    int r=N%D;
    if(r==0)
        return res;
    res[len++]='.';
    int remain[10000];
    memset(remain,-1,sizeof(remain));
    while(r!=0){
        if(remain[r]!=-1){
            int start=remain[r];
            int end=len;
            res=(char *)realloc(res,(len+3)*sizeof(char));
            memmove(res+start+1,res+start,end-start);
            res[start]='(';
            res[end+1]=')';
            res[end+2]='\0';
            return 0;
        }
        remain[r]=len;
        r*=10;
        res[len++]='0'+(r/D);
        r%=D;
    }
    return 0;
}

7.链表冒泡排序

确实可以偷鸡，就是不交换实际节点，只交换节点值

void BubbleSort(LNode *head)
{
    int flag, temp;
    LNode *ptr, *lptr = NULL;  // 初始化指针 ptr 和 lptr
    if (head == NULL)  // 如果头结点为空，直接返回
        return;
    do {
        flag = 0;  // 标志，如果某次遍历没有发生交换，则说明已经有序
        ptr = head;  // 指针 ptr 指向链表头结点
        while(ptr->next != lptr) {  // 遍历链表，直到lptr为止
            if(ptr->data > ptr->next->data) {  // 如果当前节点的值大于下一个节点的值
                temp = ptr->data;  // 交换两个节点的数据
                ptr->data = ptr->next->data;
                ptr->next->data = temp;
                flag = 1;  // 标记发生了交换
            }
            ptr = ptr->next;  // 指针移动到下一个节点
        }
        lptr = ptr;  // lptr 指向最后一次发生交换的位置
    } while (flag);  // 如果本轮遍历发生了交换，则继续下一轮
    /* 此处实现的是冒泡排序算法，每次遍历时将最大值冒泡到末尾
       lptr 每次记录最后一次交换的位置，减少无效遍历
       flag 标识是否发生交换，若本轮未发生交换，说明数组已经有序
    */
}

回顾结束

标签
#c语言
C++语言实现法雷序列
12-22
使用C++语言实现的法雷序列，对任意给定的一个自然数n（10≤n≤1000），将分母≤n的不可约的真分数按照升序排列，并且在第一个分数前面加上数0/1，在最后一个分数后面加上数1/1；不需要使用SQL容器
C++写的源代码 法雷序列求解
08-04
这是一个用C++写的源代码 实现法雷序列的求解 里面包括 排序 求质数算法
法雷数列-欧拉函数
YCH1035235541的专栏
06-30 3546
一、法雷数列 法雷数列：对任意给定的一个自然数n，将分母小于等于n的不可约的真分数按升序排列，并且在第一个分数之前加上0/1，在最后一个分数之后加上1/1，这个序列称为n级法雷数列，以Fn表示。如F5为：1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5。 那么我们怎么求得法雷数列呢？我们可以总结出法雷数列的性质如下： 给你一个数n（比如5），则法雷数列的
法雷（法里）序列
aomen8092的博客
08-18 1536
定义： 　　对任意给定的一个自然数n，将分母小于等于n的不可约的真分数按升序排列，并且在第一个分数之前加上0/1，在最后一个分数之后加上1/1，这个序列称为n级法雷数列，即法雷数列是0和1之间最简分数升序排列的数列，所以n级法雷数列的个数即为 满足 1 <= a < b <= n && gcd( a , b ) == 1 的二元组( a , b )的数...
用链表生成法雷序列C语言
qq_62760348的博客
11-30 902
然后在链表中找该分数的位置，使用辅助指针，从链表头开始遍历，如果大于此时的数则往下走，如果小于则放这个数前面。生成分数用双重循环，分母从2到n,分子从1到i-1;生成的分数要判断能不能约分，如果不能约分则放进链表；n阶法雷序列是把所有不可约分的分数j/i(0<i≤n;0≤j≤i)递增排序的序列。用链表实现，基本思路，先把0/1,1/1插入链表的头和尾。如3阶法雷序列0/1 1/3 1/2 2/3 1/1。
【USACO 2.1.2】法雷序列
Gregory99174的博客
06-14 439
【问题描述】 对任意给定的一个自然数 n(n<=160), 将分母小于等于 n 的不可约的真分数按上升的次序排序 , 并且在第一个分数前加上 0/1, 而在最后一个分数后加上 1/1, 这个序列称为 n 级法雷序列 , 以 Fn 表示 . 例如 ,F8 为 : 0/1,1/8,1/7,1/6,1/5,1/4,2/7,1/3,3/8,2/5,3/7,1/2,4/7,3/5...
【数论】法雷数列
The Slow Need To Start Eearly
05-22 1676
【数论】法雷数列 F2 = {1/2} F3 = {1/3, 1/2, 2/3} F4 = {1/4, 1/3, 1/2, 2/3, 3/4} F5 = {1/5, 1/4, 1/3, 2/5, 1/2, 3/5, 2/3, 3/4, 4/5}
2024Android面试心得：斩获3个大厂offer后，大厂常考知识点 & 面试技巧出炉
2401_83739434的博客
03-27 1132
面试题集可以帮助你查漏补缺，有方向有针对性的学习，为之后进大厂做准备。但是如果你仅仅是看一遍，而不去学习和深究。那么这份面试题对你的帮助会很有限。最终还是要靠资深技术水平说话。网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。建议先制定学习计划，根据学习计划把知识点关联起来，形成一个系统化的知识体系。学习方向很容易规划，但是如果只通过碎片化的学习，对自己的提升是很慢的。
2024Android面试心得：斩获3个大厂offer后，大厂常考知识点 & 面试技巧出炉，等你来拿！
2401_87022349的博客
09-06 1337
加入社区》https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0简单的事了，我们需要一个真正身经百战的架构师才能讲解透彻其中蕴含的深理。[外链图片转存中…(img-EkYro4T1-1725608576342)][外链图片转存中…(img-oPuFk3L2-1725608576342)]
2020Android面试心得：斩获3个大厂offer后，大厂常考知识点 & 面试技巧出炉，等你来拿！
weixin_44339238的博客
01-27 556
历时一个半月，斩获3个大厂offer（京东、新浪、滴滴），这里进行下简单的总结，希望能帮助到大家。 总体来说，面试一般都是基于你的简历来进行的，一般先考察你的基础，然后考察你知识体系的完备程度，接着会考察你的极限，最后还会考察一些软技能，比如你的学习能力、协作能力、沟通能力、分析解决未知问题的能力、抗压能力等。 个人心得 凡事预则立，不预则废。 准备周期 面试之前，最好先系统的复习一下基础知识，然后再复盘下自己的项目经历，把亮点都发掘出来。复习周期个人建议是三个月到半年，时间不宜太久，久了就容..
2020Android面试心得：斩获3个大厂offer后，大厂常考知识点 & 面试技巧出炉
m0_66144765的博客
01-28 2345
复习计划的制定和进度的把控也很重要，可以参考别人的学习计划去学习，再根据自己的实际情况去做适当的调整。 复习技巧 我一直认为学习没有捷径可言。我信奉"好记性不如烂笔头"，也信奉"书读百遍其义自见"。 一定要去实践。对于程序员而言，不单单是死记硬背，我们有更好的方式去学习，比如写demo去验证，比如学习源码的过程中，一定要自己去翻看源码，多翻几遍看熟了再说。 学习笔记我认为很重要，不仅要记笔记，还要写心得体会，文字笔记、画图、总结等，方式很多，但是一定要自己认真去做，不要太相信自己的记忆，只有反复记忆，加深理
法雷序列链表算法
12-10
用链表（带头结点）实现法雷序列，不能使用STL容器，重要代码在LinkNode*p=first->link; LinkNode*current=first->link; /*file<mole<<"/"<deno<<" "<link->mole<<"/"<link->deno;*/ while (p->link!= NULL){ if (p->deno + p->link->deno <= n) { LinkNode*q=new LinkNode; q->mole = p->mole + p->link->mole; //分子相加 q->deno = p->deno + p->link->deno; //分母相加 q->link = p->link; p->link = q; } else p=p->link; }
数据结构法雷序列实现思路
12-01
实现思路：循环在first指针（0/1）与尾指针（1/1）间插入可插入的分数，直到头尾指针相遇结束。 步骤一：定义新结构体（分数节点） 步骤二：在first后利用p2/q2=(p1+p3)/(q2+q3)循环插入新结点，直到不能插入为止 步骤三：后移first=first->link，重复步骤二，当头尾指针相遇结束 步骤四：将数据输出到文件中
法雷序列的生成
11-18
数据结构课程老师要求的单链表表示法勒序列的生成代码
2021工资翻倍指南：Android面经，历时一个半月，斩获3个大厂offer
1
12-12 597
历时一个半月，斩获3个大厂offer（京东、新浪、滴滴），这里进行下简单的总结，希望能帮助到大家。 总体来说，面试一般都是基于你的简历来进行的，一般先考察你的基础，然后考察你知识体系的完备程度，接着会考察你的极限，最后还会考察一些软技能，比如你的学习能力、协作能力、沟通能力、分析解决未知问题的能力、抗压能力等。 个人心得 凡事预则立，不预则废。 准备周期 面试之前，最好先系统的复习一下基础知识，然后再复盘下自己的项目经历，把亮点都发掘出来。复习周期个人建议是三个月到半年，时间不宜太久，久了就容易懈怠或者
27 跨考心理学｜普心别死记
最新发布
liangaidushu的博客
09-13 257
老师讲得特别扎实，不会只念 PPT，而是把复杂的理论拆成小故事 —— 比如讲 “遗忘曲线” 时，会结合我们背单词的经历，说清 “为什么要及时复习”；讲到 “情绪理论”，会举 “看到蛇先害怕还是先跑” 的例子，帮你理解不同理论的区别。刚开始我总想着死记硬背，把 “感觉知觉的区别”“记忆的分类” 硬往脑子里塞，结果背了忘、忘了背，还特别容易混淆。比如 “注意的品质”“问题解决的影响因素” 这些高频考点，会反复强调 “这个地方容易出简答题”“选择题常考区分”，后期背诵时我就盯着这些重点背，效率直接拉满。
2021Android面经，历时一个半月，斩获3个大厂offer
Androidbye的博客
02-05 441
历时一个半月，斩获3个大厂offer（京东、新浪、滴滴），这里进行下简单的总结，希望能帮助到大家。 总体来说，面试一般都是基于你的简历来进行的，一般先考察你的基础，然后考察你知识体系的完备程度，接着会考察你的极限，最后还会考察一些软技能，比如你的学习能力、协作能力、沟通能力、分析解决未知问题的能力、抗压能力等。 个人心得 凡事预则立，不预则废。 准备周期 面试之前，最好先系统的复习一下基础知识，然后再复盘下自己的项目经历，把亮点都发掘出来。复习周期个人建议是三个月到半年，时间不宜太久，久了就容易懈
上海电力大学计算机考研（840数据结构）经验分享
m0_73693599的博客
04-11 2841
我是23年上岸上海电力大学计算机专硕，由于有不少朋友都私信我问上岸的经验，想要做的笔记和院校真题，所以我建了一个群，在里面免费回答大家的备考问题，想了解的朋友们可以加群了解一下。学习c语言( 上电专业课编程题较多，所以要必要掌握)，推荐浙大温凯老师，从b站边看视频，边敲代码，尤其注重指针那一块的知识，是重难点。再补充一点个人情况，本人是一名跨考生，本科期间只学过c语言（大学的课程，不用我说什么，大家都懂的），专业课基本上算是零基础。不断默写这道算法题，找到类似的算法题，多总结，多默写，直到掌握为止。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值