精华内容
下载资源
问答
  • 面向对象程序设计语言C++;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库;第八章 流库
  • 《C C语言程序设计笔试面试》由会员分享,可在线阅读,更多相关《C C语言程序设计笔试面试(6页珍藏版)》请在人人文库网上搜索。1、4.技巧题试题2:写一个函数返回1+2+3+n的值(假定结果不会超过长整型变量的范围)...

    《C C语言程序设计笔试面试题》由会员分享,可在线阅读,更多相关《C C语言程序设计笔试面试题(6页珍藏版)》请在人人文库网上搜索。

    1、4.技巧题试题2:写一个函数返回1+2+3+n的值(假定结果不会超过长整型变量的范围) 解答:int Sum( int n )return ( (Ion g)1 + n) * n / 2;答:5. 请简述以下两个for循环的优缺点(5分)for (i=0; iif (con diti on)DoSomethi ng();elseDoOtherthi ng();优点:程序简洁if (con diti on)for (i=0; iDoSomethi ng();elsefor (i=0; iDoOtherthi ng();优点:循环的效率高缺点:程序不简洁缺点:多执行了 N-1次逻辑判断,并且打 断。

    2、了循环“流水线”作业,使得编译器不 能对循环进行优化处理,降低了效率。5分,共20 分)void GetMemory(char *p)char *GetMemory(void)p = (char *)malloc(100);char p = hello world;return p;void Test(void)void Test(void)char *str = NULL;GetMemory(str);char *str = NULL;strc py (str, hello world);str = GetMemory();prin tf(str);prin tf(str);请问运行Test。

    3、函数会有什么样的结果请问运行Test函数会有什么样的结果答:程序崩溃。答:可能是乱码。因为因为GetMemory返回的是指向栈内存”的指 针,该指针的地址不是 NULL,但其原现的内Test函数中的str 一直都是 NULL。容已经被清除,新内容不可知。strcpy(str,hello world);将使程序崩溃。GetMemory并不能传递动态内存,void GetMemory2(char *p, int num)rvoid Test(void)*p = (char *)malloc( nu m);char *str = (char *) malloc(100);strc py(str,vo。

    4、id Test(void)free(str);if(str != NULL)char *str = NULL;GetMemory(&str, 100);strc py(str,strcpy(str, hello);prin tf(str);prin tf(str);请问运行Test函数会有什么样的结果请问运行Test函数会有什么样的结果答:答:篡改动态内存区的内容,后果难以预料,(非常危险。(因为 free(str);之后,str成为野指针,if(str != NULL)语句不起作用。1 )能够输出hello2 )内存泄漏“hello ”);“world ” );函数的原型是 char *st。

    5、rcpy(char *strDest, const 是目的字符串,strSrc是源字符串。1)不调用C+/Cstrc pystrDest!=NULL)&( strSrc !=NULL);绍vector 。strcpy 函数(10 分)strcpy char *strSrc); 其中 strDest 的字符串库函数,请编写函数 一下STL,详细说明STL如何实现An swer:STL (标准模版库,Sta ndard Tem pl ate Library.它由容器算法迭代器组成。STL有以下的一些优点:可以方便容易地实现搜索数据或对数据排序等一系列的算法;调试程序时更加安全和方便;STL是跨平台。

    6、的)。即使是人们用 STL在UNIX平台下写的代码你也可以很容易地理解(因为,动态的增加数组空间。vector实质上就是一个动态数组,会根据数据的增加2.如果用VC开发程序,常见这么几个错误,C2001,c2005,c2011,这些错误的原因是什么。An swer:在学习VC+勺过程中,遇到的 LNK2001错误的错误消息主要为: unr esolved exter nal symbol“ symbol (不确定的外部 符号”)。变量或标签,将产生此错误如果连接程序不能在所有的库和目标文件内找到所引用的函数、消息。一般来说,发生错误的原因有两个: 一是所引用的函数、 变量不存在、 其次可能使用。

    7、了不同版本的连接库。编程中经常能遇到 LNK2005错误一一重复定义错误,其实 难解决的错误.拼写不正确或者使用错误;LNK2005错误并不是一个很3. 继承和委派有什么分别,在决定使用继承或者委派的时候需要考虑什么。 在00D,00呻,组合优于继承.当然多态的基础是继承,没有继承多态无从谈起。当对象的类型不影响类中函数的行为时,就要使用模板来生成这样一组类。 当对象的类型影响类中函数的行为时,就要使用继承来得到这样一组类4. 指针和引用有什么分别;如果传引用比传指针安全,为什么如果我使用常量指针难道不行吗(1)引用在创建的同时必须初始化,即引用到一个有效的对象;而指针在定义的时候不必初始化,。

    8、可以在定义后面的任何地方重新赋值 不存在N ULL引用,引用必须与合法的存储单元关联;而指针则可以是 NULL.(3) 引用一旦被初始化为指向一个对象, 它就不能被改变为另一个对象的引用; 而指针在任何时 候都可以改变为指向另一个对象给引用赋值并不是改变它和原始对象的绑定关系(4) 引用的创建和销毁并不会调用类的拷贝构造函数只不(5) 语言层面,引用的用法和对象一样;在二进制层面,引用一般都是通过指针来实现的, 过编译器帮我们完成了转换 .不存在空引用,并且引用一旦被初始化为指向一个对象,它就不能被改变为另一个对象的引用, 显得很安全。const 指针仍然存在空指针,并且有可能产生野指针 .总。

    9、的来说:引用既具有指针的效率,又具有变量使用的方便性和直观性5. 参数传递有几种方式;实现多态参数传递采用什么方式,如果没有使用某种方式原因是什么; 传值,传指针或者引用6. 结合一个项目说明你怎样应用设计模式的理念。 设计模式更多考虑是扩展和重用,而这两方面很多情况下,往往会被忽略。 不过,我不建议滥用设计模式,以为它有可能使得简单问题复杂化7. 介绍一下你对设计模式的理解。(这个过程中有很多很细节的问题随机问的) 设计模式概念是由建筑设计师 Christopher Alexander 提出 : 每一个模式描述了一个在我们周围 不断重复发生的问题 ,以及该问题的解决方案的核心 .这样 ,你就能一次又一次地使用该方案而不 必做重复劳动 . 上述定义是对设计模式的广义定义 . 将其应用到面向对象软件的领域内 , 就形成 了对设计模式的狭义定义 .并且已经上升到可以简单的认为 : 设计模式就是解决某个特定的面向对象软件问题的特定方法, 理论程度。

    展开全文
  • 导语:计算机等级考试是面向社会考试开展的一门考察计算机应用能力的考试。下面是小编为大家整理的计算机二级C语言考试必看...从以往的机试的情况来看,许多考生在程序设计题目上失分比较严重,而程序设计题占总分...

    导语:计算机等级考试是面向社会考试开展的一门考察计算机应用能力的考试。下面是小编为大家整理的计算机二级C语言考试必看技巧,供大家分享。

    qr.oh100

    计算机二级C语言考试必看技巧:计算机二级C语言上机考试

    全国计算机等级考试二级C语言上机考试具有三种题型:程序填空、程序修改和程序设计,其中程序填空30分,程序修改30分,程序设计40分。从以往的机试的情况来看,许多考生在程序设计题目上失分比较严重,而程序设计题占总分值的40%,一旦答错,如果程序填空和程序修改又不能取得满分的话,就不能通过上机考试。

    2007年9月,教育部考试中心对现有的全国计算机等级考试大纲进行了改革,二级C语言上机考试时间由60分钟增加到了90分钟,编程环境由以前的TC2.0改为VC++6.0。本文根据对近几年来二级C语言上机考试中的程序设计题进行归类总结,提出相应的策略,并对考生应对2007新大纲以后的C语言上机环境给出一些建议。

    计算机二级C语言考试必看技巧:对以往考试的分析

    历年的全国计算机等级考试中二级C语言上机考试程序设计题目全部出自于由南开大学出版社编写南开100题,每次考试教育部考试中心会对题库做相应的改动,增加一些新的题型或题目,考试中,考生随机抽取一套进行测试。笔者对2005年4月至2007年9月2004版新大纲以后的6次考试中的程序设计题目进行了总结,将这些题目一共分成了6大类,对每种类型的题目进行了分析。

    计算机二级C语言考试必看技巧:对一维数组和字符串的操作

    该类型的题目在以往的机试中所占比例最大,为40%,考生应对该知识点做全面的复习和掌握。一维数组可以分为数值型和字符型,其中数值型数组的数据类型为整型和实型,字符型数组的数据类型为字符型,我们通常会把字符型数组叫做字符串,但是应该注意字符型数组与字符串之间是存在区别的,也就是’\0’结束标志问题。

    在复习该部分的时候,考生应该掌握以下两个问题:

    1.对一维数组的操作

    对一维数组进行操作的时候,不可避免的要访问相关的数组元素,在C语言中访问数组元素一般采取单层循环的方法进行遍历,假设数组长度为n,数组下标是在0到(n-1)之间的,考生应该牢固掌握在一维数组中求最大值、最小值,移动元素,查找特定值,存储数组元素的方法。

    2.对字符串的操作

    该类问题是每次考试的重点和难点,特别是将字符串同指针结合起来以后,难度就更大了。考生在解决此类问题是应特别注意字符串的结束标志’\0’,它不仅仅用来作为字符串的结束标志,而且在对字符串进行操作的时候,它也是循环的结束标志。考生在复习该部分的时候,应该注意这样的几个基本问题:大小字母转换、奇偶数判别、删除或添加指定的字符和字符的移动。此外,考生应该牢固掌握指针的特性及字符串操作函数的使用和实现方法,特别是字符串连接函数与求子串函数,在以往的考试中多次要求考生自己编写,考生应对该知识点做重点掌握。

    计算机二级C语言考试必看技巧:数值计算

    该类型的题目在历年的机试中占22%,考查的机率也非常高。该类题目一般给定一个数列计算公式,然后要求考生编写一个函数类实现求数列的前n项的值、累加和或者积。在解决该类的问题,首先要找到给定数列的变化规律,然后根据其变化规律来编写一个单层或者双层的循环来求其相应的值。在编写程序的过程中,往往还会用到一些数学函数,如:sqrt()、fabs()、pow()等,考生应该牢固掌握math.h中的一些常用数学函数的功能和使用方法。另外,还应该注意数据类型之间的区别,特别是float和int类型,不同的数据类型产生的运算结果也是不一样的。

    计算机二级C语言考试必看技巧:对结构体的操作

    该部分对非计算机专业的学生来说是一个难点,因为结构体在《数据结构》这门课程中应用最为广泛,但考生忽视对该知识点的复习,但在以往的机试中,有17%的题目是属于该类型。考生在复习这部分的时候,首先应注意结构体成员的两种不同的引用方法:结构体变量和指向结构体的指针,也就是结构体成员运算符’.’和指向运算符’->’,在编程的过程中,往往会涉及到结构体数组,其实这类数组除了数据类型是结构体以外,其它的特性和普通数组是一样的,结构体除了定义、赋值和初始化以外,它的其它操作和普通变量也是一样的,包括在结构体数组(记录)中进行查找、删除、求最大最小值等操作,我们应该用对待普通变量的方法来解决结构体的问题,这样的话,难度就可以大幅度的降低。

    计算机二级C语言考试必看技巧:程序设计中应注意的问题

    1.熟悉编程环境

    根据2007年9月教育部考试中心颁布的新大纲,二级C语言的编程环境由TC2.0改为VC++6.0,考生应该熟练掌握VC++6.0的使用方法,虽然VC支持鼠标操作,但是考生还是应该掌握几个常用快捷方式来提高编程效率。特别要注意在对程序进行改动以后要保存,要进行编译连接生成可执行(.exe)文件。

    2.养成良好的程序设计风格

    二级C语言机试中的程序设计题,一般来说程序都比较简短,源代码一般不超过5行,在题目指定的函数内编写程序。考生在答题的时候尽量采用易于理解而且比较简单的代码来解决问题,注意不要改动函数的参数,语句的界符“{}”也应该具有层次性的缩进,必要时,使用一定的注释来帮助自己理解程序。

    3.谨慎使用指针

    指针是C语言的精华,也是机试考查的重点内容,指针的使用非常灵活,在使用的指针的时候一定要注意对其进行初始化,所谓初始化也就是给指针一个初值,没有初值的指针是很危险的,除了一定得不到正确答案外,如果指针越界,容易引起死机。如果死循环带来的死机是“假死”,大部分可以用“Ctrl+Break”来恢复,但指针越界引起的死机却是真死,请考生一定要牢记。

    4.熟练掌握循环结构

    循环结构的程序是程序设计中涉及最多的知识点,根据以上的分析,我们可以看出几乎每一类题目都会涉及到使用循环来解决问题,因此考生应该掌握循环结构的特征和使用方法,以达到能够熟练使用的目标。应该引起注意的是,在编制循环结构程序的时候考生应该尽量使用“for”循环和“while”循环,避免使用“do……while”循环和“goto”语句,因为“for”循环和“while”编写出来的循环程序易于理解,不容易出错。

    5.沉着应战,认真细心

    二级C语言上机考试时间有限,虽然从以前的60分钟改为了90分钟,但是相对于其它语种的上机考试来说,二级C语言的上机时间还是非常紧迫的。考生在答题的过程中应该保持一个良好的心态和平静的心情,遇到问题的时候不能慌乱,最好能够在机试时带一张草稿纸和一支笔,在编程之前先画出程序的流程图来明确解题思路。在遇到程序错误时一定要根据错误代码检查相应位置,检查的过程中应该认真仔细,确保能够解决问题。

    计算机二级C语言考试必看技巧:对二维数组的操作

    该类问题在历年的机试中占16%,考生应对二维数组的数组元素的遍历方法、存储方式、矩阵转换等问题做重点掌握。在C语言中,访问二维数组的数组元素一般采用双层循环的方法实现,因为二维数组具有两个下标:行下标与列下标;二维数组可以按行或者按列转化成一维数组进行存储;对二维数组进行行列转换的时候,要将行下标和列下标进行互换。考生还应该掌握上三角矩阵、下三角矩阵的特性,在考试中,该知识点也有所涉及。

    计算机二级C语言考试必看技巧:数值转换

    该部分在以往的机试中占11%,包括两类问题:一是整数合并,二是类型转换。在复习该部分时,考生应该注意C语言中int型、long型、float型和double型数据所占的存储空间的大小和精度,注意’%’(模)运算和’/’(除法)运算的特点,特别应该灵活的使用模运算与除法运算求数据相应位数上的数值。掌握强制类型转换的方法以及按规定的位数保留小数的方法。

    计算机二级C语言考试必看技巧:素数

    该部分在历年的机试中占6%,考生应该牢固掌握素数的基本概念和判断素数的方法。特别需要考生注意的是整数1不是素数,所以在判断素数的时候,应该从2开始,到(n-1)结束,能够除尽的不是素数,不能除尽的是素数。判断素数问题是C语言中的一个基本算法,不仅会在程序设计中会考到,而且往往在程序填空和程序改错中也会有所涉及,因此,考生应对该知识点认真复习。

    计算机二级C语言考试必看技巧:总结

    二级C语言上机考试是各语种级别中考生最多的,但每年的通过率都不高,主要的原因是考生的重视程度不够,上机操作的次数过少,很多应该掌握的却没有掌握,缺乏考试经验等。希望每位参加考试的考生能认真对待,积极备考。相信本文能够助参加二级C语言上机考试的考生一臂之力。

    展开全文
  • C语言应试程序设计指导的优秀图书。本书详尽的介绍了C语言程序设计思路,以及有关的应试技巧
  • 主要是c语言的一些 加深对语言的语法 技巧的一些理解
  • C语言程序设计.rar

    2009-09-28 13:44:30
    第1章 程序设计与算法 1 1.1 程序设计语言的发展 1 1.2 C语言的特点 2 1.2.1 C语言是中级语言 2 1.2.2 C语言是结构化语言 3 1.2.3 C语言是程序员的语言 3 1.3 C语言的程序结构 4 1.3.1 基本程序结构 4 1.3.2 函数库...
  • C语言程序设计(高清PDF)

    千次下载 热门讨论 2010-12-27 16:54:09
    第1章 程序设计与算法 1 1.1 程序设计语言的发展 1 1.2 C语言的特点 2 1.2.1 C语言是中级语言 2 1.2.2 C语言是结构化语言 3 1.2.3 C语言是程序员的语言 3 1.3 C语言的程序结构 4 1.3.1 基本程序结构 4 1.3.2 函数库...
  • C语言程序设计实验与学习辅导》共分三大部分,第一部分是课程实验,包括基础实验、进阶实验和综合实验部分,这种分层次的实验设计思路有利于学生循序渐进地掌握C程序的编程思想和编程技巧,突出技术应用能力的培养...

    《C语言程序设计实验与学习辅导》是C语言程序设计的辅导用书,《C语言程序设计实验与学习辅导》共分三大部分,第一部分是课程实验,包括基础实验、进阶实验和综合实验部分,这种分层次的实验设计思路有利于学生循序渐进地掌握C程序的编程思想和编程技巧,突出技术应用能力的培养。第二部分是课程辅导,包含了对课程内容知识的梳理和巩固,精选例题习题的讲解和练习,共12章,内容包括C语言基础知识、C程序的控制结构、数组与指针、函数、结构体与共用体、文件操作和位运算等。第三部分是附录,包括第二部分学习辅导习题答案、VisualC++2010使用手册和编译与连接过程中常见的出错提示。

    C语言是一门通用的计算机编程语言,它功能强大,应用广泛,既能作为高级编程语言编写管理信息系统,又能作为低级语言编写系统软件,具有非常重要的地位。学好C语言,对于以后学习其他计算机编程语言以及计算机专业的其他专业课程有很大的帮助。

    本书是《C语言程序设计》的配套实验和学习辅导,以VisualC-++2010作为开发环境。全书共分为三个部分:第一部分为C语言程序设计实验指导,这部分与课本的章节相对应,为每一章提供相应的实验指导和练习,每个实验包括实验目的、实验步骤和实验题目;第二部分为C语言程序设计学习辅导,提供了和课本章节对应的知识点梳理、案例解析、重点难点分析以及练习题检测,使读者更扎实地掌握课本上的知识点,解除对课本知识点的疑惑;第三部分为附录,包括练习题答案、VisualC++2010使用手册和编译与连接过程中常见的出错提示。

    本书具有以下特点:

    1.知识体系由浅入深、循序渐进地从实验、知识点和例题习题等多个角度对知识点进行辨析,适合初学者掌握C程序设计的基础知识,掌握程序设计的思想和方法。

    2.本书的实验指导部分,实验目标明确,步骤清晰,代码规范,讲解详实;实验目的指明本节实验要达到的目标;实验步骤中给出实验思路、源代码及实验说明,非常适合初学者进行实验模仿和练习,注重读者独立思考能力的培养;实验题目给出学生独立完成的题目,检验学生的实践学习效果。读者通过解决这些问题,提高分析和解决问题的能力。

    3.本书的学习辅导部分,每个章节通过知识框架图,帮助学生理清学习思路;通过知识点介绍,对讲授知识点进行梳理总结,使读者掌握完整的知识脉络,更好地掌握知识点;通过重点难点分析,使读者能更好地把握关键;通过课后习题解析,帮助读者巩固所学知识。

    3.本书的附录部分,对每章的习题给出了答案,能让学生及时检测学习效果;对VisualC++2010编程环境的使用做了详细介绍,使读者快速掌握新的集成开发环境;对编译与连接过程中经常出现的问题给出解释,使读者不仅能学会编写程序,更能学会调试程序,提高程序的健壮性。

    第一部分 C语言程序设计实验指导

    实验1 C语言的基本认识

    实验2 C语言程序设计基础

    实验3 顺序结构程序设计

    实验4 分支结构程序设计

    实验5 循环结构程序设计

    实验6 结构化程序设计与算法认识

    实验7 数组的构造与应用

    实验8 函数的应用

    实验9 指针的应用

    实验10 结构体的构造与应用

    实验11 文件操作

    第二部分 C语言程序设计学习辅导

    第1章 C语言概述

    第2章 C语言程序设计基础

    第3章 顺序结构程序设计

    第4章 分支结构程序设计

    第5章 循环结构程序设计

    第6章 数组

    第7章 函数

    第8章 指针

    第9章 结构体与共用体

    第10章 文件

    第11章 预处理命令

    第12章 位运算

    第三部分 附录

    附录Ⅰ 第二部分 学习辅导习题答案

    附录Ⅱ Visual C++2010使用手册

    附录Ⅲ 编译与连接过程中常见的出错提示

    展开全文
  • 第1章 程序设计与算法 1 1.1 程序设计语言的发展 1 1.2 C语言的特点 2 1.2.1 C语言是中级语言 2 1.2.2 C语言是结构化语言 3 1.2.3 C语言是程序员的语言 3 1.3 C语言的程序结构 4 1.3.1 基本程序结构 4 1.3.2 函数库...
  • 计算机二级C语言-C程序设计题

    千次阅读 2020-05-24 18:05:59
    程序编写题目,在fun中编写。 有一种应试技巧是,直接找到输出文档.dat,手动写入正确结果。 void NONO () {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */ FILE *rf, *wf ; int i, a,b ; ...

    计算机二级C语言-C程序设计题

    原文链接https://blog.csdn.net/weixin_43323830/article/details/106317383

    /*
    Author:  Boohey
    QQ:      3487267017
    Date:    June 8,2020
    Version: 
    V1.0 初版
    V1.1 部分答案格式的修改
    */
    

    文章目录

    1 取整与取模

    1-1 两位数的正整数a、b合并成一个整数

    在这里插入图片描述

    #include <stdio.h>
    void fun(int  a, int  b, long  *c)
    {
    	int qian, bai, shi, ge;
    	qian = a % 10;
    	bai = b % 10;
    	shi = a / 10;
    	ge = b / 10;
    	*c = qian * 1000 + bai * 100 + shi * 10 + ge;
    }
    void main()
    {  int  a,b; long  c;void NONO ();
       printf("Input a, b:");
       scanf("%d%d", &a, &b);
       fun(a, b, &c);
       printf("The result is: %ld\n", c);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *rf, *wf ;
      int i, a,b ; long c ;
    
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(rf, "%d,%d", &a, &b) ;
        fun(a, b, &c) ;
        fprintf(wf, "a=%d,b=%d,c=%ld\n", a, b, c) ;
      }
      fclose(rf) ;
      fclose(wf) ;
    }
    

    考察知识点:
    /相除取整数部分,%是取模,即取除法的余数。

    1-2 很奇怪的车牌号 1369

    在这里插入图片描述
    正儿八经

    #include   <stdio.h>
    #include   <stdlib.h>
    #pragma warning (disable:4996)
    struct BITS { int  m3, m2, m1, m0; };
    struct BITS  fun(int  n)
    {
       struct BITS  res;
    /* 在这里将函数代码补充完整 */
       res.m0 = n % 10;
       res.m1 = n / 10 %10;
       res.m2 = n /100% 10;
       res.m3 = n / 1000;
       return res;
    }
    main( )
    {	struct  BITS  a;
    	void NONO();	
    	int  i=0, n=0;
    	for (i=32; i<100; i++)
    	{	n = i * i;
    		a= fun(n);
    		if (a.m3 < a.m2 && a.m2 < a.m1 && a.m1 < a.m0)
    		printf("No. is %d\n", n);
    	}
    	NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
    	struct  BITS  a;
    	FILE *fp ;
    	int  i=0, n=0;
    
    	fp = fopen("out.dat","w") ;
    	for (i=32; i<100; i++)
    	{	n = i * i;
    		a= fun(n);
    		if (a.m3 < a.m2 && a.m2 < a.m1 && a.m1 < a.m0)
    			fprintf(fp, "No. is %d\n", n);
    	}
    	fclose(fp);
    }
    
    

    难度等级:☆☆☆☆☆
    学点啥

    1-3 统计各年龄段人数

    在这里插入图片描述
    考察知识点:
    分段函数

    #include <stdio.h>
    # define N  50
    # define M  11
    void fun(int *a, int *b)
    {
    	int i, j = 0;
    	/*对b中元素进行赋值,
    	避免其初始值不可预测出现错误*/
    	for (i = 0; i < M; i++)
    	{
    		b[i] = 0;
    	}
    	///*第一反应,稍繁琐*/
    	//for (j = 0; j < N; j++)
    	//{
    	//	switch (a[j] / 10)
    	//	{
    	//	case 0: b[0]++; break;
    	//	case 1: b[1]++; break;
    	//	case 2: b[2]++; break;
    	//	case 3: b[3]++; break;
    	//	case 4: b[4]++; break;
    	//	case 5: b[5]++; break;
    	//	case 6: b[6]++; break;
    	//	case 7: b[7]++; break;
    	//	case 8: b[8]++; break;
    	//	case 9: b[9]++; break;
    	//	default:b[10]++;
    	//	}
    	//}
    	/*对上述进行优化,简化写法*/
    	for (j = 0; j < N; j++)
    	{
    		if (a[j] >= 100)
    		{
    			b[10]++;
    		}
    		else
    		{
    			b[a[j] / 10]++;
    		}
    	}	
    }
    double  rnd()
    {
    	static int t = 29, c = 217, m = 1024, r = 0;
    	r = (r*t + c) % m;
    	return((double)r / m);
    }
    void main()
    {
    	FILE *wf;
    	int age[N], i, d[M];
    	int b[N] = { 32,45,15,12,86,49,97,3,44,52,17,95,63 };
    	for (i = 0; i < N; i++)
    		age[i] = (int)(115 * rnd());     /*产生一个随机的年龄数组*/
    	printf("The original data :\n");
    	for (i = 0; i < N; i++)
    		printf((i + 1) % 10 == 0 ? "%4d\n" : "%4d", age[i]);   /*每行输出10个数*/
    	printf("\n\n");
    	fun(age, d);
    	for (i = 0; i < 10; i++)
    		printf("%4d---%4d  :%4d\n", i * 10, i * 10 + 9, d[i]);
    	printf("Over 100  :  %4d\n", d[10]);
    	/******************************/
    	wf = fopen("out.dat", "w");
    	fun(b, d);
    	for (i = 0; i < 10; i++)
    		fprintf(wf, "%4d---%4d  :%4d\n", i * 10, i * 10 + 9, d[i]);
    	fprintf(wf, "Over 100  :  %4d", d[10]);
    	fclose(wf);
    	/*****************************/
    }
    

    1-4 互不相同且无重复数字的三位数

    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #define max 100
    
    int fun(int xxx[])
    {
    	/*思路:无重复数字min123~max432*/
    	int i,k=0,ge,shi,bai;
    
    	for(i = 0; i < max; i++)
    		xxx[i] = 0;
    
    	for (i = 123; i <= 432; i++)
    	{
    		ge = i % 10;
    		shi = i / 10 % 10;
    		bai = i / 100;
    		/*数字均不相同,且由1-4组成*/
    		if (ge != shi && ge != bai && shi != bai&&1<=ge&&ge <=4 && 1 <= shi&&shi <= 4 && 1 <= bai &&bai<= 4)
    		{
    			printf("%4d", i);
    			xxx[k++] = i;
    		}
    	}
    	return k;
    }
    int main()
    {
    	int xx[max],cnt;
    	void NONO(int xx[], int cnt);
    	
    	cnt = fun(xx);
    	printf("符合条件的个数=%d\n", cnt);
    	NONO(xx, cnt);
    	return 0;
    }
    
    void NONO(int xx[], int cnt)
    {
    	int i;
    	FILE *fp;
    
    	fp = fopen("out.dat", "w");
    	fprintf(fp, "%d\n", cnt);
    	for(i=0;i<cnt;i++)
    		fprintf(fp, "%d\n", xx[i]);
    	fclose(fp);
    }
    

    难度等级:☆☆☆☆☆
    学点啥

    1-5.四叶玫瑰树

    在这里插入图片描述

    #include<stdio.h>
    #pragma warning (disable:4996)
    int fun(int n, int result[])
    { 
    	int i,j,k=0, ge, shi, bai,qian;
    	for (i = 1000; i < n; i++)
    	{
    		ge = i % 10;
    		shi = i / 10 % 10;
    		bai = i / 100 % 10;
    		qian = i / 1000;
    		//for (j = 0; j < 4; j++)
    		//{
    		//	ge *= ge;
    		//	shi *= shi;
    		//	bai *= bai;
    		//	qian *= qian;
    		//}
    
    		if (i == (ge*ge*ge*ge + shi* shi*shi*shi + bai* bai*bai*bai + qian* qian*qian*))
    		{
    			result[k++] = i;
    		}
    	}
    	return k;
    }
    main( )
    {
    	int result[10], n, i;
    	void NONO(int result[], int n);
    	n = fun(9999, result);
    	for(i=0; i<n; i++) printf("%d\n", result[i]);
    	NONO(result, n);
    }
    
    void NONO(int result[], int n)
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
    	FILE *fp ;
    	int i;
    
    	fp = fopen("out.dat","w") ;
    	fprintf(fp, "%d\n", n);
    	for(i=0; i<n; i++) fprintf(fp, "%d\n", result[i]);
    	fclose(fp);
    }
    

    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    求某数的N次幂,用for循环做,非常巧妙

    注意:如下解法有误

    int fun(int n, int result[])
    { 
    	int i,j,k=0, ge, shi, bai,qian;
    	for (i = 1000; i < n; i++)
    	{
    		ge = i % 10;
    		shi = i / 10 % 10;
    		bai = i / 100 % 10;
    		qian = i / 1000;
    		for (j = 0; j < 4; j++)
    		{
    			ge *= ge;
    			shi *= shi;
    			bai *= bai;
    			qian *= qian;
    		}
    
    		if (i == (ge + shi + bai + qian))
    			result[k++] = i;
    	}
    	return k;
    }
    

    错误原因:ge*ge*ge*ge表达有误

    五星数

    int fun(int n, int result[])
    { 
    	int i,j,k=0, ge, shi, bai,qian,wan;
    	for (i = 10000; i < n; i++)
    	{
    		ge = i % 10;
    		shi = i / 10 % 10;
    		bai = i / 100 % 10;
    		qian = i / 1000%10;
    		wan = i / 10000;
    		j = ge*ge*ge*ge*ge + shi*shi*shi*shi*shi + bai*bai*bai*bai*bai + qian*qian*qian*qian*qian;
    		if (i == j)
    		{
    			result[k++] = i;
    		}
    	}
    	return k;
    }
    

    在这里插入图片描述
    三叶草数

    int fun(int n, int result[])
    { 
    	int i,j,k=0, ge, shi, bai,qian,wan;
    	for (i = 100; i < n; i++)
    	{
    		ge = i % 10;
    		shi = i / 10 % 10;
    		bai = i / 100;
    		
    		j = ge*ge*ge +shi*shi*shi + bai*bai*bai;
    		if (i == j)
    			result[k++] = i;
    	}
    	return k;
    }
    

    在这里插入图片描述

    1-6 能被e整除的元素个数 110

    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #pragma warning (disable:4996)
    #define N 10
    int fun(int x[], int e, int *sum)
    {
    	int i,k=0;
    	*sum = 0;
    
    	for (i = 0; i<N; i++)
    	{
    		if (x[i] % e == 0)
    			k++;
    		else
    			(*sum) += x[i];
    	}
    	return k;
    }
    main()
    {  
    	void NONO();
    	int x[N] = {1, 7, 8, 6, 10, 15, 11, 13, 29, 31}, e = 3, n, sum;
    	n=fun(x, e, &sum);
    	printf("n=%d,sum=%d\n", n, sum);
    	NONO();
    }
    
    void NONO()
    {
    /* 请在此函数内打开文件,输入测试数据,调用 fun 函数,
       输出数据,关闭文件。 */
        int i, j, x[10], n, e, sum;
        FILE *rf, *wf ;
    
        rf = fopen("in.dat","r") ;
        wf = fopen("out.dat","w") ;
        for(i=0; i<5; i++) {
            for(j=0; j<10; j++) fscanf(rf, "%d ", &x[j]);  fscanf(rf, "%d", &e);
            n = fun( x, e, &sum );
            fprintf(wf, "%d, %d\n", n, sum);
        }
       fclose(rf) ;
       fclose(wf) ;
    }
    
    

    难度等级:☆☆☆☆☆
    学点啥

    1-7 被e整除

    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #pragma warning(disable:4996)
    
    int fun(int x[], int n, int e, int *num)
    {
    
    	int i, sum = 0.0;
    	*num = 0;
    
    	for (i = 0; i < n; i++)
    	{
    		if (x[i] % e == 0)
    		{
    			(*num)++;
    			sum += x[i];
    		}
    	}
    	return sum;
    }
    
    int main()
    {  
      void NONO();
      int x[] = {1, 9, 8, 6, 12}, num=0, sum;
      sum = fun(x, 5, 3, &num);
      printf("sum=%d,num=%d\n", sum, num);
      NONO();
      return 0;
    }
    
    void NONO( )
    {
    	int x[100] = {1, 9, 8, 6, 12}, num, sum, i, j, count, e;
    	FILE *rf, *wf;
    	rf = fopen("in.dat","r");
    	wf = fopen("out.dat","w");
    	for(i=0;i<10;i++) {
    		num = 0;
    		sum = 0;
    		fscanf(rf, "%d,", &count);
    		for(j=0;j<count;j++)
    			fscanf(rf,"%d,",&x[j]);
    		fscanf(rf, "%d,", &e);
    		sum = fun(x, count, e, &num);
    		fprintf(wf, "sum=%d,num=%d\n", sum, num);
         }
         fclose(rf);
         fclose(wf);
    }
    

    1-8 判断形参n中的正整数是几位数

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include  <stdio.h>
    void NONO();
    int  fun(int  n)
    {
    	int k=1;
    	while (n / 10 > 0)
    	{
    		k++;
    		n /= 10;
    	}
    	return k;
    }
    void main()
    {  int  n, place ;
       do{
          printf("请输入一个4位以内的正整数:    ");
          scanf("%d", &n);
         }  while (n<0 || n>9999);
       place = fun(n);
       printf( "输入的数字是%d位\n", place );
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, n, place ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for( i=0; i<10; i++ )
      {
         fscanf(fp, "%d ", &n);
         place = fun(n);
         fprintf(wf, "%d\n", place);
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    难度等级:☆☆☆☆☆
    学点啥

    1-9 保留两位小数,并对第三位进行四舍五入

    在这里插入图片描述
    雕虫小技*
    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>
    float fun (float h )
    {
    
    	float y, result;
    	int x,jc, bl, qy;
    	y = h * 1000;//1234.56789
    	x = (int) y;//强制转换1234567
    
    	jc = x % 10;//四舍五入检测位 7
    	bl = x / 10 % 10;//保留位6
    	qy = x / 100;//其余12345
    
    	if (jc > 4)
    		bl++;
    	result = (qy * 10 + bl) / 100.0;
    
    	return result;
    }
    void main()
    {
      FILE *wf;
      float a;
      system("CLS");
      printf("Enter a: ");
      scanf ("%f",&a);
      printf("The original data is :  ");
      printf("%f\n\n", a);
      printf("The  result : %f\n", fun(a));
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%f",fun(8.32533));
      fclose(wf);
    /*****************************/
    }
    
    

    在这里插入图片描述

    输出结果

    在这里插入图片描述
    为何错了?

    在这里插入图片描述

    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>
    float fun (float h )
    {
    	/*单精度*1000+5,相当于对lg1000也即第3位
    	进行四舍五入,/10赋给长整型可截去第三位后小数点*/
    	int tmp = (int)(h*1000+5)/10;
    	/*/100,保留两位小数*/
    	return (float)tmp / 100.0;
    }
    void main()
    {
      FILE *wf;
      float a;
      system("CLS");
      printf("Enter a: ");
      scanf ("%f",&a);
      printf("The original data is :  ");
      printf("%f\n\n", a);
      printf("The  result : %f\n", fun(a));
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%f",fun(8.32533));
      fclose(wf);
    /*****************************/
    }
    

    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    1-10 整数部分和小数部分

    在这里插入图片描述
    正儿八经

    #include  <stdio.h>
    #pragma warning (disable:4996)
    void  fun(  double  aa, int  *x, double  *y )
    { 
    	*x = (int)aa;
    	*y = aa - *x;
    }
    main()
    { void NONO();
      double  aa, b;  int  a;
      printf("请输入一个双精度数:  ");scanf("%lf",&aa);
      fun( aa, &a, &b );
      printf( "%f的整数部分是: %d   小数部分是%f\n", aa,a,b );
      NONO();
    }
    void NONO()
    {
      FILE *in, *out ;
      double  aa, b;  int  a;
      int i ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
    	fscanf(in, "%lf", &aa) ;
        fun( aa, &a, &b );
        fprintf(out, "%f的整数部分是: %d   小数部分是%f\n", aa,a,b );
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    难度等级:☆☆☆☆☆
    学点啥
    在这里插入图片描述

    1-11. w是一个大于10的无符号整数

    在这里插入图片描述
    雕虫小技

    在这里插入图片描述

    在这里插入图片描述
    正儿八经

    #include<conio.h>
    #include<stdio.h>
    #include<stdlib.h>
    unsigned fun(unsigned w)
    {
    	int i, n = 1, high = 1,t=w;
    
    	while (t / 10 > 0)
    	{
    		t /= 10;
    		n++;//确定n位数 例5923四位数
    	}
    
    	for (i = 0; i < n-1; i++)//10^(n-1)
    		high *= 10;
    
    	/*5923-5923/1000*1000*/
    	return w%high;
    }
    void main()
    { 
      FILE *wf;
      unsigned x;
      system("CLS");
      printf("Enter a unsigned integer number: ");
      scanf ("%u",&x);
      printf("The original data is:%u\n",x);
      if(x<10) 
        printf("Data error! ");
      else 
        printf ("The result :%u\n", fun(x));
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%u",fun(5923));
      fclose(wf);
    /*****************************/
    }
    
    

    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    2【素数】

    2-1【素数】将大于整数m且紧靠m的k个素数存入

    在这里插入图片描述
    思路1:

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    void fun(int m,int k,int xx[])
    {
    	int i,j,n;
    	for (i = m + 1, n = 0; n < k; i++)//找出k个数字
    	{
    		for (j = 2; j < i; j++)//判断是否素数
    		{
    			if (i%j == 0)//非素数,跳出循环
    				break;
    		}
    			if (j >= i)//素数,则存入
    				xx[n++] = i;
    	}	
    }
    void main()
    {
      FILE *wf;
      int m,n,zz[1000];
      system("CLS");
      printf("\nPlease enter two integers: ");
      scanf("%d%d",&m,&n);
      fun(m, n, zz);
      for(m=0;m<n;m++)
         printf("%d ",zz[m]);
      printf("\n ");
    /******************************/
      wf=fopen("out.dat","w");
      fun(17,5,zz);
      for(m=0;m<5;m++)
         fprintf(wf,"%d ",zz[m]);
      fclose(wf);
    /*****************************/
    }
    
    

    输出结果:
    在这里插入图片描述
    思路2:

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    void fun(int m, int k, int xx[])
    {
    	int i, j, n,temp;
    	for (i = m + 1, n = 0; n < k; i++)//找出k个数字
    	{
    		temp = sqrt(i);
    		for (j = 2; j < temp; j++)//判断是否素数
    		{
    			if (i%j == 0)//非素数,跳出循环
    				break;
    		}
    		if (j >= i)//素数,则存入
    			xx[n++] = i;
    	}
    }
    void main()
    {
    	FILE *wf;
    	int m, n, zz[1000];
    	system("CLS");
    	printf("\nPlease enter two integers: ");
    	scanf("%d%d", &m, &n);
    	fun(m, n, zz);
    	for (m = 0; m < n; m++)
    		printf("%d ", zz[m]);
    	printf("\n ");
    	/******************************/
    	wf = fopen("out.dat", "w");
    	fun(17, 5, zz);
    	for (m = 0; m < 5; m++)
    		fprintf(wf, "%d ", zz[m]);
    	fclose(wf);
    	/*****************************/
    }
    

    输出结果:
    在这里插入图片描述

    学点啥
    如何判断素数?关键代码如下:

    		for (j = 2; j < i; j++)//判断是否素数
    		{
    			if (i%j == 0)//非素数,跳出循环
    				break;
    		}
    		/*遍历仍无除了2与本身的其他因子,则为素数,则存入*/
    			if (j >= i)
    				xx[n++] = i;
    	
    

    对代码具体分析如下:
    判断i是否为素数,j自增,若i%j == 0也即中途跳出循环,j必然未增至i;若j遍历从2增至到i仍无因子j >= i,则i为素数,xx[n++] = i;将其存入。

    修改:将大于整数m且紧靠m的k个非素数存入

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    void fun(int m,int k,int xx[],int yy[])
    {
    	int i,j,n;
    	for (i = m + 1, n = 0; n < k; i++)//找出k个数字
    	{
    		for (j = 2; j < i; j++)//判断是否素数
    		{
    			if (i%j == 0)//非素数,则存入
    			{
    				xx[n++] = i;
    				break;
    			}
    		}
    			//if (j >= i)//素数
    			//	yy[n++] = i;
    	}	
    }
    void main()
    {
      FILE *wf;
      int m,n,zz[1000];
      system("CLS");
      printf("\nPlease enter two integers: ");
      scanf("%d%d",&m,&n);
      fun(m, n, zz);
      for(m=0;m<n;m++)
         printf("%d ",zz[m]);
      printf("\n ");
    /******************************/
      wf=fopen("out.dat","w");
      fun(17,5,zz);
      for(m=0;m<5;m++)
         fprintf(wf,"%d ",zz[m]);
      fclose(wf);
    /*****************************/
    
    }
    
    

    C语言判断素数

    2-2【素数】3~n之间所有素数的平方根之和

    在这里插入图片描述

    #include  <stdio.h>
    #include  <math.h>
    double fun(int n)  
    {
    	int i,j,k;
    	double SumAve = 0.0;
    	for (i = 3; i <= n; i++)
    	{
    		k = sqrt(i);
    		for (j = 2; j <= k; j++)
    			if (i%j == 0)
    				break;
    		if (j >= k+1)
    			SumAve += sqrt(i);
    	}
    	return SumAve;
    }
    void main()
    {int n;
     double sum;
     FILE *out;
     printf("Input  N=");
     scanf("%d",&n);
     sum=fun(n);
     printf("\n\nsum=%f\n\n",sum);
     /******************************/
     out=fopen("out.dat","w");
     fprintf(out,"%f\n",fun(180));
     fclose(out);
     /******************************/
    }
    
    

    在这里插入图片描述
    学点啥
    素数判断两种方法
    素数又称质数。所谓素数是指除了 1 和它本身以外,不能被任何整数整除的数,例如17就是素数,因为它不能被 2~16 的任一整数整除。

    **思路1):**因此判断一个整数m是否是素数,只需把 m 被 2 ~ m-1 之间的每一个整数去除,如果都不能被整除,那么 m 就是一个素数。

    **思路2):**另外判断方法还可以简化。m 不必被 2 ~ m-1 之间的每一个整数去除,只需被 2 ~ 之间的每一个整数去除就可以了。如果 m 不能被 2 ~ 间任一整数整除,m 必定是素数。例如判别 17 是是否为素数,只需使 17 被 2~4 之间的每一个整数去除,由于都不能整除,可以判定 17 是素数。
    **原因:**因为如果 m 能被 2 ~ m-1 之间任一整数整除,其二个因子必定有一个小于或等于 ,另一个大于或等于 。例如 16 能被 2、4、8 整除,16=2*8,2 小于 4,8 大于 4,16=4*4,4=√16,因此只需判定在 2~4 之间有无因子即可。

    两种思路的代码请看解析。

    思路1

    #include <stdio.h>
    
    int main(){
        int a=0;  // 素数的个数
        int num=0;  // 输入的整数
    
        printf("输入一个整数:");
        scanf("%d",&num);
    
        for(int i=2;i<num;i++){
            if(num%i==0){
                a++;  // 素数个数加1
            }
        }
    
        if(a==0){
            printf("%d是素数。\n", num);
        }else{
            printf("%d不是素数。\n", num);
        }
    
        return 0;
    }
    

    思路2

    #include <stdio.h>
    #include <math.h>
    void main(){
        int m;  // 输入的整数 
        int i;  // 循环次数
        int k;  // m 的平方根 
    
        printf("输入一个整数:");
        scanf("%d",&m);
    
        // 求平方根,注意sqrt()的参数为 double 类型,这里要强制转换m的类型 
        k=(int)sqrt( (double)m );
        for(i=2;i<=k;i++)
            if(m%i==0)
                break;
    
        // 如果完成所有循环,那么m为素数
        // 注意最后一次循环,会执行i++,此时 i=k+1,所以有i>k 
        if(i>k)
            printf("%d是素数。\n",m);
        else
            printf("%d不是素数。\n",m);
    
        return 0;
    }
    

    2-3【素数】求出小于或等于lim的所有素数

    在这里插入图片描述
    雕虫小技

    直接F5运行,如下出现错误
    原因 int fun(int lim, int aa[MAX]){ }函数中无返回值。

    修改如下:

    int fun(int lim, int aa[MAX])
    {
    	return 15;
    }
    

    在这里插入图片描述

    在这里插入图片描述

    正儿八经

    #include<conio.h>
    #include<stdio.h>
    #include<stdlib.h>
    #define MAX 100
    int fun(int lim, int aa[MAX])
    {
    	int i, j, k = 0;//素数个数初始化并幅值
    	for (i=2;i<=lim;i++)
    	{
    		for (j = 2; j < i; j++)
    		{
    			if (i%j == 0)
    				break;
    		}
    		if (j >= i)
    			aa[k++] = i;
    	}
    	return k;
    }
    void main()
    {
      FILE *wf;
      int limit,i,sum;
      int aa[MAX];
      system("CLS");
      printf("输入一个整数:");
      scanf("%d",&limit);
      sum=fun(limit,aa);        
      for(i=0;i<sum;i++)
         {
          if(i%10==0&&i!=0)    /*每行输出10个数*/
             printf("\n ");
          printf("%5d ",aa[i]);
        }
    /******************************/
      wf=fopen("out.dat","w");
      sum=fun(15,aa);        
      for(i=0;i<sum;i++)
         {
          if(i%10==0&&i!=0)    /*每行输出10个数*/
             fprintf(wf,"\n");
          fprintf(wf,"%5d ",aa[i]);
        }
      fclose(wf);
    /*****************************/
    }
    
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    2-4【素数】小于整数m的非素数存入xx所指数组中

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    
    void fun( int m, int *k, int xx[] )
    {
    	int i, j,*k=0;
    
    	for (i = 4; i < m; i++)
    	{
    		for (j = 2; j <= i; j++)
    		{
    			if (i%j == 0)
    				break;
    		}
    		if(i<j)
    			xx[(*k)++] = i;
    	}
    }
    
    void main()
    {
       int m, n, zz[100];
       void NONO (  );
       printf( "\nPlease enter an integer number between 10 and 100: " );
       scanf(  "%d", &n );
       fun( n, &m, zz );
       printf( "\n\nThere are %d non-prime numbers less than %d:", m, n );
       for( n = 0; n < m; n++ )
          printf( "\n  %4d", zz[n] );
       NONO();
    }
    
    void NONO()
    {
    /* 请在此函数内打开文件,输入测试数据,调用 fun 函数,
       输出数据,关闭文件。 */
       int m, n, zz[100];
       FILE *rf, *wf ;
    
       rf = fopen("in.dat","r") ;
       wf = fopen("out.dat","w") ;
       fscanf( rf, "%d", &n );
       fun( n, &m, zz );
       fprintf(wf, "%d\n%d\n", m, n );
       for( n = 0; n < m; n++ )
          fprintf(wf, "%d\n", zz[n] );
       fclose(rf) ;
       fclose(wf) ;
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    2-5 是否可以分解成两个素数相乘

    在这里插入图片描述
    正儿八经

    #include<stdio.h>
    #include<math.h>
    int prime(int m)
    {
    	int k,flag=1;
    	for(k=2;k<(int)sqrt((double)m);k++)
    		if(m%k==0)
    			flag=0;
    	return flag;
    }
    int fun(int n,int *x,int *y)
    {
    	int k,flag=0;
    
    	for (k = 2; k < n; k++)//	优化 for (k = 2; k <=sqrt(n); k++)
    		if (n%k == 0)
    		{
    			*x = k;
    			*y = n / k;
    			if (prime(*x) && prime(*y))
    			{
    				flag = 1;
    				break;
    			}
    		}
        return flag;
    }
    main()
    {
    	int a,b;FILE *out ;
    	out = fopen("out.dat","w") ;
    	if(fun(111,&a,&b)) {
    		printf("111=%d*%d\n",a,b);
    		fprintf(out, "111=%d*%d\n",a,b);
    	}
    	if(fun(11111,&a,&b)) {
    		printf("11111=%d*%d\n",a,b);
    		fprintf(out, "11111=%d*%d\n",a,b);
    	}
    	if(fun(1111111,&a,&b)) {
    		printf("1111111=%d*%d\n",a,b);
    		fprintf(out,"1111111=%d*%d\n",a,b);
    	}
       fclose(out);
       getchar();
    
    }
    

    在这里插入图片描述
    难度等级:☆☆☆☆☆
    学点啥

    判断是否素数代码

    int prime(int m)
    {
    	int k,flag=1;
    	for(k=2;k<(int)sqrt((double)m);k++)
    		if(m%k==0)
    			flag=0;
    	return flag;
    }
    

    2-6 哥德巴赫猜想

    在这里插入图片描述
    正儿八经

    #include<stdio.h>
    #include<math.h>
    #pragma warning(disable:4996)
    
    int prime(int n)
    {	int k,flag=1;
    	for (k=2; k<=(int)sqrt((double)n); k++)
    		if (n%k == 0)
    			flag=0;
    	return flag;
    }
    int fun(int m, int a[])
    { 
      int k, s, count, i=0;
       for(k=6; k<=m; k+=2)
       {   count = 0;
    	   /* 请在此处填写代码 */
    		for (s = 2; s <= k / 2; s++)
    		{
    			if (prime(s) == 1 && prime(k - s) == 1)
    				count++;
    		}
    	   /* 代码结束 */
    
           if (count == 10) {
    		   printf("%d\n", k);
    		   a[i++] = k;
    	   }
       }
       return i;
    }
    main( )
    {	int count, a[100];
    	void NONO(int count, int a[]);
    	count = fun(999, a);
    	NONO(count, a);
    }
    
    void NONO(int count, int a[])
    {
    	FILE *fp;
    	int i;
    	fp = fopen("out.dat","w") ;
    	for(i=0; i<count; i++)
    		fprintf(fp, "%d\n", a[i]);
    	fclose(fp);
    }
    

    在这里插入图片描述
    难度等级:☆☆☆☆☆
    学点啥

    2-6. 能整除x且不是偶数的各整数

    在这里插入图片描述
    雕虫小技

    在这里插入图片描述
    在这里插入图片描述
    正儿八经

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    void fun (int x, int pp[], int *n)
    {
    	int i,k=0;
    	for (i=1;i<x;i++) 
    	{
    		if (x%i == 0 && i%2 == 1)
    		{
    			pp[k++] = i;
    		}
    	}
    	*n = k;
    	return *n;
    }
    
    void main ()
    { 
      FILE *wf;
      int  x,aa[1000], n, i ;
      system("CLS");
      printf("\nPlease enter an integer number : \n ") ;
      scanf ("%d", &x) ;
      fun (x, aa, &n) ;
      for (i=0 ; i<n ; i++)
          printf ("%d ", aa [i]);
      printf ("\n ") ;
    /******************************/
      wf=fopen("out.dat","w");
      fun (30, aa, &n) ;
      for (i=0 ; i<n ; i++)
          fprintf (wf,"%d ", aa [i]);
      fclose(wf);
    /*****************************/
    }
    

    在这里插入图片描述

    难度等级:★☆☆☆☆
    优化

    void fun (int x, int pp[], int *n)
    {
    	int i,k=0;
    	for (i=1;i<x;i=i+2) 
    	{
    		if (x%i == 0)
    			pp[k++] = i;
    	}
    	*n = k;
    	return *n;
    }
    

    学点啥

    3 【排列】

    3-1 连续递增字母序列

    在这里插入图片描述

    #include   <stdio.h>
    #include  <string.h>
    void NONO();
    int  fun( char  *t )
    {
    	/********1*******/
    	//int flag = 1;
    	//char old_ch = t[0];
    	//char new_ch;
    	//int len = strlen(t);
    	//if (len < 2)
    	//	return 0;
    	//for (int i = 1; t[i] != '\0'; i++)
    	//{
    	//	new_ch = t[i];
    	//	if (new_ch - old_ch!=1)
    	//	{
    	//		flag = 0; 
    	//		break;
    	//	}
    	//	old_ch = new_ch;
    	//}
    	//return flag;
    	/********2*******/
    	int flag = 1;
    	int len = strlen(t);
    	if (len < 2)
    		return 0;
    	while (*(t + 1))
    	{
    		if ((*(t + 1) - *t) != 1)
    		{
    			flag = 0;
    		}
    		t++;
    	}
    	return flag;
    }
    
    void main()
    {  char  s[26];
       printf("请输入一个字母组成的字符串 :  "); gets(s);
       if( fun(s) )  printf("%s 是由连续字母组成的字符串.\n", s );
       else   printf("%s 不是由连续字母组成的字符串!\n", s );
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i;
      char s[26], *p;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fgets(s, 26, fp);
    	p=strchr(s,'\n');
    	if(p) *p=0;
        if (fun(s)) fprintf(wf, "%s\n", s+2);
    	else  fprintf(wf, "%s\n", strrev(s));
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    学点啥

    3-2 【排列】【冒泡法】其余5个字符按ASCII码降序排列

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    #include <ctype.h>
    #include <string.h>
    
    void fun(char *s,int num)
    {
    	int i,j;
    	char temp;
    
    	for (i = 1; i <= 5; i++)
    	{
    		for (j = i+1; j <=5; j++)
    			if (*(s+i) < *(s + j))
    			{
    				temp = *(s + j);
    				*(s + j) = *(s + i);
    				*(s + i) = temp;
    			}
    	}
    }
    
    void main()
    {
      void NONO( );
      char s[10];
      printf("输入7个字符的字符串:");
      gets(s);
      fun(s,7);
      printf("\n%s",s);
      NONO();
    }
    void NONO()
    {
    /* 请在此函数内打开文件,输入测试数据,调用 fun 函数,
       输出数据,关闭文件。 */
       char s[10] ;
       FILE *rf, *wf ;
       int i = 0 ;
    
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
       while(i < 10) {
         fgets(s,10,rf) ;
         s[7] = 0 ;
         fun(s,7);
         fprintf(wf, "%s\n", s) ;
         i++ ;
       }
       fclose(rf) ;
       fclose(wf) ;
    }
    

    难度等级:★★☆☆☆
    学点啥

    4 因子

    4-1.能被7或11整除

    在这里插入图片描述
    错误答案

    #include <stdio.h>
    
    void  fun (int *a, int *n)
    {
    	int i,j = 0;
    	for (i = 1; i <= 1000; i++)
    	{
    		if ((i % 7 == 0) || (i % 11 == 0) && (i % 77 != 0))
    			a[j++] = i;
    	}
    	return j;
    }
    
    void main( )
    {  int aa[1000], n, k ;
       void NONO (  );
    
       fun ( aa, &n ) ;
       for ( k = 0 ; k < n ; k++ )
          if((k + 1) % 10 == 0) printf("\n") ;
          else printf("%5d", aa[k]) ;
       NONO( );
    }
    
    void NONO ( )
    {/* 本函数用于打开文件,输入测试数据,调用fun函数,输出数据,关闭文件。*/
      int aa[1000], n, k ;
      FILE *fp ;
    
      fp = fopen("out.dat","w") ;
      fun ( aa, &n ) ;
      for ( k = 0 ; k < n ; k++ )
        if((k + 1) % 10 == 0) fprintf(fp, "\n") ;
        else fprintf(fp, "%5d", aa[k]) ;
      fclose(fp) ;
    }
    

    原因分析
    函数fun类型为void,无法返回值;而且并未利用给的n
    正确答案

    #include <stdio.h>
    
    void  fun (int *a, int *n)
    {
    	int i,j = 0;
    	for (i = 1; i <= 1000; i++)
    	{
    		if ((i % 7 == 0) || (i % 11 == 0) && (i % 77 != 0))
    			a[j++] = i;
    	}
    	*n = j;
    }
    
    void main( )
    {  int aa[1000], n, k ;
       void NONO (  );
    
       fun ( aa, &n ) ;
       for ( k = 0 ; k < n ; k++ )
          if((k + 1) % 10 == 0) printf("\n") ;
          else printf("%5d", aa[k]) ;
       NONO( );
    }
    
    void NONO ( )
    {/* 本函数用于打开文件,输入测试数据,调用fun函数,输出数据,关闭文件。*/
      int aa[1000], n, k ;
      FILE *fp ;
    
      fp = fopen("out.dat","w") ;
      fun ( aa, &n ) ;
      for ( k = 0 ; k < n ; k++ )
        if((k + 1) % 10 == 0) fprintf(fp, "\n") ;
        else fprintf(fp, "%5d", aa[k]) ;
      fclose(fp) ;
    }
    

    学点啥

    4-2. 同时能被3与7整除的所有自然数之和

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <math.h>
    #include <stdio.h>
    double  fun( int  n)
    {
    	int i,sum=0;
    
    	for (i = 0; i < n; i++)
    	{
    		if (i % 3 == 0 && i % 7 == 0)
    			sum += i;
    		
    	}
    	return sqrt(sum);
    
    }
    
    void main()   /* 主函数 */
    {  void NONO ();
       printf("s =%f\n", fun ( 1000) );
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, n ;
      double s;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(fp, "%d", &n) ;
        s = fun(n) ;
        fprintf(wf, "%f\n", s) ;
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    在这里插入图片描述

    4-3 能被5或9整除 0.583333

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    double fun(int n)
    {
    	int i;
    	double sum = 0.0;
    	for (i = 1; i <= n; i++)
    	{
    		if (i % 5 == 0 || i % 9 == 0)
    			sum += 1.0 / i;
    	}
    	return sum;
    }
    
    void main()
    {
    	 int n;
    	 double s;
    	 FILE *out;
    	 printf("\nInput n:");
    	 scanf("%d",&n);
    	 s=fun(n);
    	 printf("\n\ns=%f\n",s);
    	 /******************************/
    	 out=fopen("out.dat","w");
    	 fprintf(out,"%f\n",fun(30));
      	 fclose(out);
    	 /******************************/
    }
    
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    double a = 4/3
    double b = 4.0/3.0
    

    前一个是按照整型计算 所以a是1.0
    后一个是按照浮点型计算 所以 b是 1.333333
    在这里插入图片描述

    double fun(int n)
    {
    	int i;
    	double sum = 0.0;
    	for (i = 1; i <= n; i++)
    	{
    		if (i % 5 == 0 || i % 9 == 0)
    			sum += 1 / i;//此处修改
    	}
    	return sum;
    }
    

    在这里插入图片描述

    4-4 给定整数n的所有因子

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include  <stdio.h>
    int fun(int n)
    {
    	int i,j,sum=0;
    	for (i = 2; i < n; i++)
    			if (n%i == 0)
    				sum += i;
    	return sum;
    }
    void main()
    { 
     int  n,sum; 
     FILE *out;
     printf("Input  n:"); 
     scanf("%d", &n);
     sum=fun(n);
     printf("sum=%d\n", sum);
     /******************************/
     out=fopen("out.dat","w");
     fprintf(out,"%d\n",fun(123));
     fprintf(out,"%d\n",fun(456));
     fprintf(out,"%d\n",fun(789));
     fprintf(out,"%d\n",fun(147));
     fprintf(out,"%d",fun(258));
     fclose(out);
     /******************************/
    }
    

    难度等级:★★☆☆☆
    学点啥

    5 【字符游戏】【对称】

    5-1 把1~m个字符,平移到字符串的最后(循环移动) ABCDEFGHIJK

    在这里插入图片描述

    在这里插入图片描述

    #include <stdio.h>
    #include <string.h>
    #define   N    80
    void fun (char  *w,int  m)
    {
    	int i, j;
    	char temp;
    	for (i = 1; i <= m; i++)
    	{
    		temp = w[0];
    		for (j = 1; w[j] != '\0'; j++)
    		{
    			w[j - 1] = w[j];
    		}
    		w[j - 1] = temp;	
    	}
    }
    void main()
    {
      FILE *wf;
      char  a[N]= "ABCDEFGHIJK",b[N]= "ABCDEFGHIJK";
      int  m;
      printf("The origina string :\n");
      puts(a);
      printf("\n\nEnter  m: ");
      scanf("%d",&m);
      fun(a,m);
      printf("\nThe string after moving :\n");
      puts(a);
      printf("\n\n");
    /******************************/
      wf=fopen("out.dat","w");
      fun(b,3);
      fprintf(wf,"%s",b);
      fclose(wf);
    /*****************************/
    }
    
    

    学点啥
    经典的循环左移算法,多层嵌套用于控制移动的字符个数,也即需要进行循环的次数;
    内层循环将第2个字符(含)以后的每个字符向前移动一个位置,然后将第一各字符放置到最后一个字符中。
    换一种写法

    #include <stdio.h>
    #include <string.h>
    #define   N    80
    void fun (char  *w,int  m)
    {
    	int i, j;
    	char temp;
    	for (i = 0; i < m; i++)
    	{
    		temp = w[0];
    		for (j = 0; w[j] != '\0'; j++)
    		{
    			w[j] = w[j+1];
    		}
    		w[j] = temp;//代码错误行	,修改前
    	}
    }
    void main()
    {
      FILE *wf;
      char  a[N]= "ABCDEFGHIJK",b[N]= "ABCDEFGHIJK";
      int  m;
      printf("The origina string :\n");
      puts(a);
      printf("\n\nEnter  m: ");
      scanf("%d",&m);
      fun(a,m);
      printf("\nThe string after moving :\n");
      puts(a);
      printf("\n\n");
    /******************************/
      wf=fopen("out.dat","w");
      fun(b,3);
      fprintf(wf,"%s",b);
      fclose(wf);
    /*****************************/
    }
    
    

    输出结果(有误 )
    应为DEFGHIJKABC,但输出是为DEFGHIJK

    在这里插入图片描述
    错误原因

    w[j] = temp;//代码错误行 ,修改前表示将temp置于w[5],且并未显示。
    在这里插入图片描述

    #include <stdio.h>
    #include <string.h>
    #define   N    80
    void fun (char  *w,int  m)
    {
    	int i, j;
    	char temp;
    	for (i = 0; i < m; i++)
    	{
    		temp = w[0];
    		for (j = 0; w[j] != '\0'; j++)
    		{
    			w[j] = w[j+1];
    		}
    		w[j-1] = temp;	//代码错误行,修改后
    	}
    }
    void main()
    {
      FILE *wf;
      char  a[N]= "ABCDEFGHIJK",b[N]= "ABCDEFGHIJK";
      int  m;
      printf("The origina string :\n");
      puts(a);
      printf("\n\nEnter  m: ");
      scanf("%d",&m);
      fun(a,m);
      printf("\nThe string after moving :\n");
      puts(a);
      printf("\n\n");
    /******************************/
      wf=fopen("out.dat","w");
      fun(b,3);
      fprintf(wf,"%s",b);
      fclose(wf);
    /*****************************/
    }
    
    

    运行结果
    在这里插入图片描述

    5-2 字符串中原有的字符串为"abcdefg",则调用该函数后,串中的内容"gfedCba"

    @使用VC++201打开考生文件夹下progl中的解决方案◊此解决方案的顶目中包含一个源程序文件progl.c。在此程序中,例如,
    字符串中原有的字符串为"abcdefg",则调用该函数后,串中的内容"gfedCba"
    注意:部分源程序在文件pmgl.c中。
    请勿改动主函数main和其他函数中的任何内容,仅在函数firn的花括号中填入你编写的若干语句。
    在这里插入图片描述

    #include <string.h>
    #include <conio.h>
    #include <stdio.h>
    #define N 81
    void fun(char*s)
    {
    	char temp;
    	int  m, n,i = 0;
    	m = n = strlen(s) - 1;
    	for (i=0;i < (n + 1) / 2;i++)
    	{
    		temp = s[i];
    		s[i] = s[m];
    		s[m] = temp;
    		m--;
    	}
    }
    
    void main()
    {
    	 char a[N];
    	 FILE *out;
    	 printf("Enter a string:");
    	 gets(a);
    	 printf("The  original string is:");
    	 puts(a);
    	 fun(a);
    	 printf("\n");
    	 printf("The string after modified:");
    	 puts(a);
    	 strcpy(a,"Hello World!");
    	 fun(a);
    	 /******************************/
    	 out=fopen("out.dat","w");
    	 fprintf(out,"%s",a);
    	 fclose(out);
    	 /******************************/
    }
    
    

    在这里插入图片描述
    学点啥
    字符串倒写,思路是将第一各与最后一个交换,第二个遇到书第二个交换,直至中间字符;长度为n的交换n/2次,如长度6或者7都是交换3次。

    再学点啥
    写了一个新程序void leftMove(char*s,int leftMove),功能如下:将字符串s左移n位,左移溢出的移至末尾。如输入s为abcdefg,n=2,输出cdefgab。

    //V。0 新建
    //V1.1 增加输入左移位数
    #include <string.h>
    #include <conio.h>
    #include <stdio.h>
    #define N 81
    void fun(char*s)
    {
    	int i, j,temp,len;
    	//len = strlen(s);
    	//printf('%d',len);
    	for (i=0;i<6;i++)
    	{
    		//if (s[i + 1] != '\0')
    		temp = s[0];
    		for (j=0;j<6;j++)
    		{
    			if(s[j+1]!='\0')
    				s[j] = s[j + 1];
    		}
    		s[j] = temp;
    	}
    }
    void leftMove(char*s,int leftMove)
    {
    	int i, j, temp, len;
    	
    	for (i = 0; i < leftMove; i++)
    	{
    		//if (s[i + 1] != '\0')
    		temp = s[0];
    		for (j = 0; j < leftMove; j++)
    		{
    			if (s[j + 1] != '\0')
    				s[j] = s[j + 1];
    		}
    		s[j] = temp;
    	}
    }
    
    void main()
    {
    	 char a[N];
    	 FILE *out;
    	 printf("Enter a string:");
    	 gets(a);
    	 printf("The  original string is:");
    	 puts(a);
    	 //fun(a);
    	 leftMove(a, 1);
    	 printf("\n");
    	 printf("The string after modified:");
    	 puts(a);
    	 //strcpy(a,"Hello World!");
    	 //fun(a);
    	 /******************************/
    	 out=fopen("out.dat","w");
    	 fprintf(out,"%s",a);
    	 fclose(out);
    	 /******************************/
    }
    
    

    输出结果
    在这里插入图片描述
    a~f一共7个字母,输入大于等于7的数字会出错,如下:
    在这里插入图片描述
    在这里插入图片描述
    期望:输入数字7k+i,i=0~6等同输入7,也即取模

    //V。0 新建
    //V1.1 新增输入左移位数输入
    //V1.2 输入数字7k+i,i=0~6等同输入7,也即取模;
    //     修复了之前版本显示数据有误的bug;
    #include <string.h>
    #include <conio.h>
    #include <stdio.h>
    #define N 81
    void fun(char*s)
    {
    	int i, j,temp,len;
    	//len = strlen(s);
    	//printf('%d',len);
    	for (i=0;i<6;i++)
    	{
    		//if (s[i + 1] != '\0')
    		temp = s[0];
    		for (j=0;j<6;j++)
    		{
    			if(s[j+1]!='\0')
    				s[j] = s[j + 1];
    		}
    		s[j] = temp;
    	}
    }
    void leftMove(char*s,int leftMove)
    {
    	int i, j, temp, len,ModeLeftMove;
    	ModeLeftMove = leftMove % 7;
    	for (i = 0; i < ModeLeftMove; i++)
    	{
    		//if (s[i + 1] != '\0')
    		temp = s[0];
    		for (j = 0; j < 6/*len-1*/; j++)
    		{
    			if (s[j + 1] != '\0')
    				s[j] = s[j + 1];
    		}
    		s[j] = temp;
    	}
    }
    
    void main()
    {
    	 char a[N];
    	 int M;
    	 FILE *out;
    	 printf("Enter a string:");
    	 gets(a);
    	 printf("LeftMove Number is:");
    	 scanf("%d", &M);
    	 printf("The  original string is:");
    	 puts(a);
    	 //fun(a);
    	 leftMove(a, M);
    	 printf("\n");
    	 printf("The string after modified:");
    	 puts(a);
    	 //strcpy(a,"Hello World!");
    	 //fun(a);
    	 /******************************/
    	 out=fopen("out.dat","w");
    	 fprintf(out,"%s",a);
    	 fclose(out);
    	 /******************************/
    }
    
    

    在这里插入图片描述
    在这里插入图片描述
    更多,参见StringleftMove维护Github

    5-3 前导*号全部移到字符串的尾部

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    void  fun( char *a )
    {
    
    }
    
    void main()
    {  char  s[81];  int  n=0; void NONO ();
       printf("Enter a string:\n");gets(s);
       fun( s );
       printf("The string after moveing:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fun(s) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    编写:
    思路1:首先统计前导*个数k,然后利用贪吃蛇模型左移k

    void  fun( char *a )
    {
    	/*思路:循环左移,直到非*也即字母为止*/
    	int i,j,k=0;
    	char temp;
    
    	for (i = 0; a[i] == '*'; i++)
    		if (a[i] == '*')
    			k++;// star个数
    
    	for (i = 0; i < k; i++)
    	{
    		temp = a[0];
    		for (j = 1; a[j] != '\0'; j++)
    			a[j - 1] = a[j];
    		a[j - 1] = temp;
    	}
    }
    

    思路2:首先统计前导个数k,然后前导后的字符输出,再前导*输出

    void  fun(char *a)
    {
    	int i=0, k = 0;
    	char *p;
    	p = a;
    
    	while (*p == '*')
    	{
    		k++;// count star number
    		p++;//pointer
    	}
    	/*前导*后的字符输出*/
    	while (*p)
    	{
    		a[i] = *p;
    		i++;
    		p++;
    	}
    	/*前导*输出*/
    	while (k > 0)
    	{
    		a[i] = '*';
    		i++;
    		k--;
    	}
    	/*结束符*/
    	a[i] = '\0';
    }
    

    难度等级:★★☆☆☆
    学点啥

    5-4.回文

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    #define N 80
    int fun(char *str)
    {
    }
    
    void main()
    {
    	 char s[N];
    	 FILE *out;
             char *test[]={"1234321","123421","123321","abcdCBA"};
    	 int i;
    	 printf("Enter a string : ");
    	 gets(s);
    	 printf("\n\n");
    	 puts(s);
    	 if(fun(s))
    		printf("YES\n");
    	 else
    		printf("NO\n"); 
    	 /************************************/
    	 out=fopen("out.dat","w");
    	 for(i=0;i<4;i++)
    	 	if(fun(test[i]))
    			fprintf(out,"YES\n");
    		else
    			fprintf(out,"NO\n");
    	 fclose(out);
    	 /************************************/
    }
    
    

    在这里插入图片描述
    思路1:

    int fun(char *str)
    {
    	int i = 0, k=0,flag=1;
    	char  *t;
    	t = str;
    	while (*t)
    	{
    		t++;
    		k++;
    	}
    
    	for (i = 0; i < k / 2; i++)
    	{
    		if (str[i] == str[k - 1 - i])
    			;
    		else
    		{
    			flag = 0;
    			break;
    		}
    	}
    	return flag;
    }
    

    思路2:

    int fun(char *str)
    {
    	char  *f, *t;
    
    	f = str;
    	t = str + strlen(str) - 1;
    	while ((*f == *t) && (f < t)) {
    		f++; t--;
    	};
    
    	if (f < t) return 0;
    	else   return 1;
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    5-6. 数组元素平移到数组的最后

    在这里插入图片描述
    雕虫小技

    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    #define    N    80
    void  fun(int  *w, int  p, int  n)
    {
    	int i,j,temp;
    	for (i = 0; i <= p; i++)
    	{
    		temp = w[0];
    		for(j=1;j<n;j++)
    			w[j-1] = w[j];
    		w[n - 1] = temp;
    	}
    }
    void main()
    {  int  a[N]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
       int  i,p,n=15;void NONO ();
       printf("The original data:\n");
       for(i=0; i<n; i++)printf("%3d",a[i]);
       printf("\n\nEnter  p:  ");scanf("%d",&p);
       fun(a,p,n);
       printf("\nThe data after moving:\n");
       for(i=0; i<n; i++)printf("%3d",a[i]);
       printf("\n\n");
       NONO();
    }
    void NONO ()
    {/* 请在此函数内打开文件,输入测试数据,调用 fun 函数,输出数据,关闭文件。 */
      FILE *rf,*wf ; int a[N], i, j, p, n ;
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 5 ; i++) {
        fscanf(rf, "%d %d", &n, &p) ;
        for(j = 0 ; j < n ; j++) fscanf(rf, "%d", &a[j]) ;
        fun(a, p, n) ;
        for(j = 0 ; j < n ; j++) fprintf(wf, "%3d", a[j]) ; fprintf(wf, "\n") ;
      }
      fclose(rf) ; fclose(wf) ;
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥
    在这里插入图片描述

    6 奇数偶数

    6-1 s所指字符串中下标为偶数同时ASCII值为奇数的字符删除

    在这里插入图片描述

    #include <stdio.h>
    #include <string.h>
    
    void  fun(char  *s, char  t[])
    {
    	int i,j=0;
    	for (i=0;i<100;i++)
    	{
    		if (s[i] % 2 == 0)//even
    		{
    			t[j++] = s[i];
    		}
    	}
    }
    
    void main()
    {
      char   s[100], t[100];void NONO ();
      printf("\nPlease enter string S:"); scanf("%s", s);
      fun(s, t);
      printf("\nThe result is: %s\n", t);
      NONO();
    }
    
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      char s[100], t[100] ;
      FILE *rf, *wf ;
      int i ;
    
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(rf, "%s", s) ;
        fun(s, t) ;
        fprintf(wf, "%s\n", t) ;
      }
      fclose(rf) ;
      fclose(wf) ;
    }
    

    在这里插入图片描述
    学点啥

    6-2. ASCII码值为偶数的字符删除

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include<stdio.h>
    #include<string.h>
    #include<conio.h>
    #include<stdlib.h>
    void fun(char  *s, char t[])
    {
    	int i,j=0;
    	for (i = 0; s[i] != '\0'; i++)
    	{
    		if (s[i] % 2 != 0)
    			t[j++] = s[i];
    	}
    	t[j] = 0;
    }
    void main()
    {
      FILE *wf;
      char s[100],t[100];
      system("CLS");
      printf("\nPlease enter string S: ");  
      scanf("%s",s);
      fun(s,t);
      printf("\nThe result is :%s\n",t);
    /******************************/
      wf=fopen("out.dat","w");
      fun("ABCDEFG12345",t);
      fprintf(wf,"%s",t);
      fclose(wf);
    /*****************************/
    }
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥
    写法2:

    void fun(char  *s, char t[])
    {
    	int j=0;
    	for (; *s != '\0'; s++)
    	{
    		if (*s % 2 != 0)
    			t[j++] = *s;
    	}
    	t[j] = 0;//t[j] = '\0';
    }
    

    6-3 ss所指字符串中所有下标为奇数位置的字母转化为大写

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include<conio.h>
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    void fun(char *ss)
    {
    	int i;
    	for (i = 0; ss[i]!='\0'; i++)
    	{
    		if (i % 2 == 1&&'a'<=ss[i]<='z')
    			ss[i] = ss[i]-32;
    	}
    }
    void main()
    {
      FILE *wf;
      char tt[81],s[81]="abc4Efg";
      system("CLS");
      printf("\nPlease enter an string within 80 characters:\n");
      gets(tt);
      printf("\n\nAfter changing, the string\n  %s",tt);
      fun(tt);
      printf("\nbecomes\n %s\n",tt);
    /******************************/
      wf=fopen("out.dat","w");
      fun(s);
      fprintf (wf,"%s",s);
      fclose(wf);
    /*****************************/
    }
    
    

    6-4 统计出这些数的奇数、偶数个数

    在这里插入图片描述

    #include <stdio.h> 
    #pragma warning (disable:4996)
    #define N 11
    double fun( int xx[], int *yy )
    {
    	int i, odd_count = 0, even_count = 0;
    	double even_total = 0.0, odd_total = 0.0,ave;
    	for (i=0;i<N;i++)
    	{
    		if (xx[i] % 2 == 0)
    		{
    			even_count++;
    			even_total += xx[i];
    		}
    		else
    		{
    			odd_count++;
    			odd_total += xx[i];
    		}
    		if (even_count > odd_count)
    		{
    			*yy = even_count;
    			ave = even_total / even;
    		}
    		else
    		{
    			*yy = odd_count;
    			ave = odd_total / odd;
    		}
    	}
    	return ave;
    }
    
    main()
    {
        int yy, xx[N]={1101,1202,1303,1404,1505,2611,2712,2813,2914,3202,4222};
        double pjz ;
        void NONO();
    
        pjz = fun( xx, &yy );
        printf("yy=%d, pjz=%.2lf\n", yy, pjz);
        NONO();
    }
    
    void NONO()
    {
    /* 请在此函数内打开文件,输入测试数据,调用 fun 函数,
       输出数据,关闭文件。 */
        int i, j, xx[N], yy;
        double pjz;
        FILE *rf, *wf ;
    
        rf = fopen("in.dat","r") ;
        wf = fopen("out.dat","w") ;
        for(i=0; i<10; i++) {
            for(j=0; j<N; j++) fscanf(rf, "%d ", &xx[j]);
            pjz = fun( xx, &yy );
            fprintf(wf, "%d, %.2lf\n", yy, pjz);
        }
       fclose(rf) ;
       fclose(wf) ;
    }
    

    学点啥
    对于函数fun而言,yy为指针变量,可以传递数值

    //代码不全
    double fun( int xx[], int *yy )
    {
    	//
    	return ave;
    }
    

    且由输出可得,yy为个数,pjz为平均值

    pjz = fun( xx, &yy );
    printf("yy=%d, pjz=%.2lf\n", yy, pjz);
    

    故而有

    	//代码不全
    	if (even_count > odd_count)
    	{
    		*yy = even_count;
    		ave = even_total / even_count;
    	}
    	else
    	{
    		*yy = odd_count;
    		ave = odd_total / odd_count;
    	}
    }
    return ave;
    

    yy传递地址, pjz = fun( xx, &yy );读取yy地址,即可得所求个数;
    平均值由fun返回。

    在这里插入图片描述
    优化

    double fun( int xx[], int *yy )
    {
    	int i, j, num_odd = 0, num_even = 0;
    	double sum_odd = 0.0, sum_even = 0.0, sum = 0.0;
    	for (i = 0; i<N; i++)
    	{
    		if (xx[i] % 2 == 0)//even
    		{
    			sum_even += xx[i];
    			num_even++;
    		}
    		else //odd
    		{
    			sum_odd += xx[i];
    			num_odd++;
    		}
    	}
    
    	sum = sum_even > sum_odd ? sum_even : sum_odd;
    	*yy = num_even > num_odd ? num_even : num_odd;
    
    	return sum / (*yy);
    
    	//if (sum_even > sum_odd)
    	//{
    	//	*yy = num_even;
    	//	return sum_even / (*yy);
    	//}
    	//else
    	//{
    	//	*yy = num_odd;
    	//	return sum_odd / (*yy);
    	//}
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    6-5 数组中偶数的个数

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    #pragma warning (disable:4996)
    #define N 8
    int fun(int x[],double *ave)
    {
    	int i, k = 0;
    	double sum = 0.0;
    
    	for (i=0;i<N;i++)
    	{
    		if (x[i] % 2 == 0)
    		{
    			k++;
    			sum += x[i];
    		}
    	}
    	*ave = sum / k;
    	return k;
    
    }
    
    main()
    {  int x[N]={ 12,5,9,8,23,4,7,21 }, n;
       double ave;
       void NONO();
       n=fun(x,&ave);
       printf("n=%d,ave=%lf\n",n,ave);
       NONO();
    }
    void NONO ()
    {/* 请在此函数内打开文件,输入测试数据,调用 fun 函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i,j, x[N], n ;
      double ave;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j=0 ; j < N; j++) fscanf(in, "%d,", &x[j]) ;
    	   n=fun(x,&ave);
    	 fprintf(out, "n=%d,ave=%lf\n",n,ave);
      }
      fclose(in) ;
      fclose(out) ;
    }
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    7【寻寻觅觅】

    7-1 【寻寻觅觅】统计一行字符串中单词的个数

    在这里插入图片描述

    正儿八经

    #include<string.h>
    #include<stdio.h>
    #define N 80
    int fun(char *s)
    {
      
    }
    void main()
    { 
      FILE *wf;
      char line[N]; 
      int num=0;
      printf("Enter a string:\n "); 
      gets(line);
      num=fun(line);
      printf("The number of word is:%d\n\n ",num);
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%d",fun("a big car"));
      fclose(wf);
    /*****************************/
    }
    
    

    函数编写

    /*错误原因:以下函数实际计算的是空格数,+1即为单词数*/
    //int fun(char *s)
    //{
    //	/*错误原因:以下函数实际计算的是空格数,+1即为单词数
    //	输入a big car   2个空格判定单词数为3  正确
    //	输入a  big car  3个空格误判单词数为4  错误
    //	输入 a big car  3个空格误判单词数为4  错误
    //	*/
    //
    //	int i, k=1;
    //
    //	for (i = 0; s[i] != '\0'; i++)
    //	{
    //		if (s[i] == ' ')
    //			k++;
    //	} 
    //	return k;
    //}
    

    正解

    int fun(char *s)
    {
    	int i, k=1;
    	
    	for (i = 0; s[i] != '\0'; i++)
    	{
    		/*当前为字母且下一个字符为空格或者结束符,判定为单词*/
    		if (s[i] != ' '&&(s[i+] == ' '|| s[i + ] == '\0'))
    			k++;
    	} 
    	return k;
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    int fun(char  *s)
    {
    	int  k = 0, flag = 0;
    	while (*s != '\0')
    	{
    		if (*s != ' ' && flag == 0)
    		{
    			k++;  flag = 1;
    		}
    		if (*s == ' ')
    			flag = 0;
    		s++;
    	}
    	return  k;
    }
    

    单词非空格且flag为0(flag初始值为0)时断定发现新单词,计数+1,flag置1;直至遇到下一个空格,flag清0
    在这里插入图片描述

    7-2 【寻寻觅觅】二维数组中字母A和C的个数

    在这里插入图片描述

    #include  <stdio.h>
    #include  <stdlib.h>
    #define  M  14
    void NONO();
    void  fun( char (*t)[M], int *a ,int *c)
    {
    	int i,j;
    	*a = 0; *c = 0;
    	for (i=0;i<M;i++)
    	{
    		for (j = 0; j < M; j++)
    		{
    			if (t[i][j]== 'A')
    				(*a)++;
    			if (t[i][j] == 'C')
    				(*c)++;
    		}
    	}
    }
    
    void  get( char (*s)[M] )
    {  int  i, j;
       for( i=0; i<M; i++ )
       {  for( j=0; j<M; j++)
          {  s[i][j]=65+rand()%12; printf( "%c ",s[i][j]); }
          printf("\n");
       }
    }
    
    void main()
    {  char  a[M][M];
       int   x, y;
       get (a);
       fun ( a, &x,&y );
       printf("A = %d   C = %d\n",x,y);
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, j, x, y ;
      char  a[M][M];
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for( i=0; i<M; i++ )
      {  for( j=0; j<M; j++)
         {  fscanf(fp, "%c ", &a[i][j]); }
      }
      fun ( a, &x,&y );
      fprintf(wf, "A=%d\n", x) ;
      fprintf(wf, "C=%d\n", y) ;
      fclose(fp) ;
      fclose(wf) ;
    }
    

    在这里插入图片描述
    学点啥

    7-3 查找x在s所指数组中下标的位置(数组)

    在这里插入图片描述

    #include  <stdio.h>
    #include  <stdlib.h>
    #define   N   15
    void NONO();
    int  fun( int *s, int x)
    {
    	int i;
    	for (i=0;i<N;i++)
    	{
    		if (s[i] == x)
    			return i;
    	}
    	return -1;
    }
    void main()
    {  int a[N]={ 29,13,5,22,10,9,3,18,22,25,14,15,2,7,27},i,x,index;
       printf("a数组中的数据 :\n");
       for(i=0; i<N; i++) printf("%4d",a[i]);  printf("\n");
       printf("给x输入待查找的数 :  ");   scanf("%d",&x);
       index=fun( a, x );
       printf("index=%d\n",index);
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, j, a[10], x, index;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j = 0 ; j < 10 ; j++) {
          fscanf(fp, "%d ", &a[j]);
        }
        fscanf(fp, "%d", &x);
        index = fun(a, x);
        fprintf(wf, "%d\n", index);
      }
      fclose(fp);
      fclose(wf);
    }
    
    
    

    学点啥

    7-4 求出数组的最大元素在数组中的下标(数组)

    在这里插入图片描述

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    int fun(int *s,int t,int *k)
    {
    	int i,max;
    	*k = 0;
    	for (i = 0; i < t; i++)
    	{
    		if (s[*k] < s[i])
    		{
    			*k = i;
    		}
    	}
    	return s[*k];
    }
    void main()
    {
      FILE *wf;
      int a[10]={ 876,675,896,101,301,401,980,431,451,777},k;
      system("CLS");
      fun(a, 10, &k);
      printf("%d, %d\n ", k, a[k]);
    /******************************/
      wf=fopen("out.dat","w");
      fprintf (wf,"%d, %d", k, a[k]);
      fclose(wf);
    /*****************************/
    }
    

    学点啥

    8. 数组重拍列

    8-1.二维数组中的数据,按照列的顺序依次放到一维数组中

    在这里插入图片描述
    程序维护2DArrayTo1DArray

    #include <stdio.h>
    void fun (int (*s)[10], int *b, int *n,int mm, int nn)
    {
    	int i, j, k=0;
    	for (j = 0; j <nn ;j++)
    	{
    		for (i = 0; i <mm ;i++)
    		{
    			b[*n] = *(*(s+i)+j);
    			(*n)++;
    		}
    	}
    }
    void main()
    {
      int w[10][10]={{33,33,33,33},{44,44,44,44},{55,55,55,55}}, i, j;
      int a[100]={0},n=0 ;
      FILE *out;
      printf("The matrix:\n");
      for (i=0; i<3; i++)
        {for (j=0;j<4;j++)  
            printf("%3d",w[i][j]);
         printf("\n");
        }
      fun(w,a,&n,3,4);
      /******************************/
      out=fopen("out.dat","w");
      printf("The A array:\n");
      for(i=0; i<n; i++)  
      {     printf("%3d",a[i]); 
    	fprintf(out,"%d ",a[i]);
      }
      printf("\n\n");
      fclose(out);
      /******************************/
    }
    
    

    在这里插入图片描述
    学点啥

    C语言二维数组指针(指向二维数组的指针)详解

    C语言指针数组(数组每个元素都是指针)详解

    **摘选**
    int *(p1[5]);  //指针数组,可以去掉括号直接写作 int *p1[5];
    int (*p2)[5];  //二维数组指针,不能去掉括号
    

    指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1 为例,在32位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。

    3) *(p+1)+1表示第 1 行第 1 个元素的地址。如何理解呢?

    *(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;就像一维数组的名字,在定义时或者和 sizeof、& 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针

    1. ((p+1)+1)表示第 1 行第 1 个元素的值。很明显,增加一个 * 表示取地址上的数据。

    举一反三 二维数组中的数据,按照行的顺序依次放到一维数组中。

    #include <stdio.h>
    void fun (int (*s)[10], int *b, int *n,int mm, int nn)
    {
    	int i, j;
    	for (i = 0; i <mm ;i++)//行下标控制
    	{
    		for (j = 0; j <nn ;j++)//列下标控制
    		{
    			b[*n] = *(*(s+j)+i);
    			(*n)++;//通过指针返回元素个数
    		}
    	}
    }
    void main()
    {
      int w[10][10]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}, i, j;
      int a[100]={0},n=0 ;
      FILE *out;
      printf("The matrix:\n");
      for (i=0; i<3; i++)
        {for (j=0;j<4;j++)  
            printf("%3d",w[i][j]);
         printf("\n");
        }
      fun(w,a,&n,3,4);
      /******************************/
      out=fopen("out.dat","w");
      printf("The A array:\n");
      for(i=0; i<n; i++)  
      {     printf("%3d",a[i]); 
    	fprintf(out,"%d ",a[i]);
      }
      printf("\n\n\n\n");
      fclose(out);
      /******************************/
    }
    
    

    运行结果:有误
    在这里插入图片描述
    原因分析:

    for (i = 0; i <mm/*mm=3;ROW*/ ;i++)//行下标控制
    	{
    		for (j = 0; j <nn /*nn=4;COLUMN*/;j++)//列下标控制
    		{
    			b[*n] = *(*(s+j)+i);
    			(*n)++;//通过指针返回元素个数
    		}
    	}
    

    在这里插入图片描述
    在这里插入图片描述
    由于第3行未赋值,默认为0

    在这里插入图片描述
    /***************************************/
    时间线发散-关于数组赋值:
    如果赋值了一项其余就是0,如果是int a[10]={1}其余各项就是0;如果只有int a[10]那么就是随机数。

    #include <stdio.h>
    void main()
    {
    	int s1[10] = { 1 }, s2[10];
    	printf("s1[0]=%d,s1[1]=%d\n", s1[0], s1[1]);
    	printf("s2[0]=%d,s2[1]=%d\n", s2[0], s2[1]);
    }
    

    输出结果
    在这里插入图片描述
    /***************************************/

    修改后

    #include <stdio.h>
    void fun (int (*s)[10], int *b, int *n,int mm, int nn)
    {
    	int i, j;
    	for (i = 0; i <mm ;i++)//行下标控制
    	{
    		for (j = 0; j <nn ;j++)//列下标控制
    		{
    			b[*n] = *(*(s+i)+j);
    			(*n)++;//通过指针返回元素个数
    		}
    	}
    }
    void main()
    {
      int w[10][10]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}, i, j;
      int a[100]={0},n=0 ;
      FILE *out;
      printf("The matrix:\n");
      for (i=0; i<3; i++)
        {for (j=0;j<4;j++)  
            printf("%3d",w[i][j]);
         printf("\n");
        }
      fun(w,a,&n,3,4);
      /******************************/
      out=fopen("out.dat","w");
      printf("The A array:\n");
      for(i=0; i<n; i++)  
      {     printf("%3d",a[i]); 
    	fprintf(out,"%d ",a[i]);
      }
      printf("\n\n\n\n");
      fclose(out);
      /******************************/
    }
    
    

    关键代码为:

    for (i = 0; i <mm/*mm=ROW*/ ;i++)//行下标控制
    {
    	for (j = 0; j <nn/*nn=COLUMN*/ ;j++)//列下标控制
    	{
    		b[*n] = *(*(s+i)+j);
    		(*n)++;//通过指针返回元素个数
    	}
    

    在这里插入图片描述
    输出结果为:
    在这里插入图片描述

    8-2. 按顺序合并成一个新的字符串

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #include <conio.h>
    #define M 3
    #define N 20
    void fun(char a[M][N],char *b)
    {
    	int i, j,k=0;
    
    	for(i=0;i<M;i++)
    		for (j = 0; a[i][j]!='\0'; j++)
    			b[k++] = a[i][j];
    
    	b[k] = '\0';
    }
    void main()
    { 
      FILE *wf;
      char w[M][N]={"AAAA", "BBBBBBB", "CC"},i;
      char a[100]={ " ##############################"};
      printf("The string:\n ");
      for(i=0;i<M;i++) 
         puts(w[i]);
      printf("\n ");
      fun(w,a);
      printf("The A string:\n ");
      printf("%s ",a);
      printf("\n\n ");
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%s",a);
      fclose(wf);
    /*****************************/
    }
    
    

    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    如下代码输出结果为:

    void fun(char a[M][N],char *b)
    {
    	int i, j,k=0;
    
    	for(i=0;i<M;i++)
    		for (j = 0; j < N; j++)//区别
    			b[k++] = a[i][j];
    
    	b[k] = '\0';
    }
    

    在这里插入图片描述

    为何会失误呢?

    #define N 20
    //
    char w[M][N]={"AAAA", "BBBBBBB", "CC"},i;
    

    故会遇到结束符’\0’

    #include <stdio.h>
    void fun(char p1[], char p2[])
    {
    int i, j,len1,len2;
    for (i = 0; p1[i] != 0; i++)
    ;
    for (j = 0; p2[j] != 0; j++)
    p1[i++] = p2[j];
    p1[i] = 0;
    }

    void main()
    { char s1[80], s2[40] ;void NONO ();

     printf("Enter s1 and s2:\n") ;
     scanf("%s%s", s1, s2) ;
     printf("s1=%s\n", s1) ;
     printf("s2=%s\n", s2) ;
     printf("Invoke fun(s1,s2):\n") ;
     fun(s1, s2) ;
     printf("After invoking:\n") ;
     printf("%s\n", s1) ;
     NONO() ;
    

    }

    void NONO ()
    {/* 本函数用于打开文件,输入测试数据,调用fun函数,输出数据,关闭文件。*/
    int i ;
    FILE *rf, *wf ;
    char s1[80], s2[40] ;

    rf = fopen(“in.dat”,“r”) ;
    wf = fopen(“out.dat”,“w”) ;
    for(i = 0 ; i < 10 ; i++) {
    fscanf(rf, “%s”, s1) ;
    fscanf(rf, “%s”, s2) ;
    fun(s1, s2) ;
    fprintf(wf, “%s\n”, s1) ;
    }
    fclose(rf) ;
    fclose(wf) ;
    }

    8-3. 按列的顺序依次放到一个字符串中

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include<stdio.h>
    #define  M  3
    #define  N  4
    void fun(char (*s)[N],char *b)
    {
    	int i, j, k=0;
    	for (j = 0; j < N; j++)
    		for (i = 0; i < M; i++)
    			b[k++] = s[i][j];
    	b[k] = '\0';
    }
    void main()
    { 
      FILE *wf;
      char a[100],w[M][N]={{ 'W', 'W', 'W', 'W'},{'S', 'S', 'S', 'S'},{'H', 'H', 'H', 'H'}};
      int i,j;
      printf("The matrix:\n");
      for(i=0;i<M;i++)
         { for(j=0;j<N;j++) 
              printf("%3c",w[i][j]);
           printf("\n");
         }
      fun(w,a);
      printf("The A string:\n");
      puts(a);
      printf("\n\n");
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%s",a);
      fclose(wf);
    /*****************************/
    }
    
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    8-4 实现两个字符串的连接

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    void fun(char p1[], char p2[])
    {
    	int i, j,len1,len2;
    	for (i = 0; p1[i] != 0; i++)
    		;
    		for (j = 0; p2[j] != 0; j++)
    			p1[i++] = p2[j];
    		p1[i] = 0;
    }
    
    void main()
    {    char s1[80], s2[40] ;void NONO ();
    
         printf("Enter s1 and s2:\n") ;
         scanf("%s%s", s1, s2) ;
         printf("s1=%s\n", s1) ;
         printf("s2=%s\n", s2) ;
         printf("Invoke fun(s1,s2):\n") ;
         fun(s1, s2) ;
         printf("After invoking:\n") ;
         printf("%s\n", s1) ;
         NONO() ;
    }
    
    void NONO ()
    {/* 本函数用于打开文件,输入测试数据,调用fun函数,输出数据,关闭文件。*/
      int i ;
      FILE *rf, *wf ;
      char s1[80], s2[40] ;
    
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(rf, "%s", s1) ;
        fscanf(rf, "%s", s2) ;
        fun(s1, s2) ;
        fprintf(wf, "%s\n", s1) ;
      }
      fclose(rf) ;
      fclose(wf) ;
    }
    
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    9【字符串处理】

    9-1 将数字字符串转换成与其面值相同的长整型整数 2354210

    在这里插入图片描述

    #include   <stdio.h>
    #include   <string.h>
    void NONO();
    long  fun( char  *s )
    {
    	int i,sum=0,len;
    	len = strlen(s);
    	for (i = 0; i < len; i++)
    	{
    		sum = sum * 10 + *s-48;
    		s++;
    	}
    	return sum;
    
    
    }
    void main()
    {  char  s[10];    long  r;
       printf("请输入一个长度不超过9个字符的数字字符串 :  ");  gets(s);
       r = fun( s );
       printf(" r = %ld\n" , r );
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i;  long r;
      char s[10], *p;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fgets(s, 10, fp);
        p = strchr(s, '\n');
        if (p) *p = 0;
        r = fun(s);
        fprintf(wf, "%ld\n", r);
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    在这里插入图片描述
    学点啥
    数字字符串转化为相应的数字,需要ASCII码-48,不知道这个数字也无所谓,可以输入一个数字如1,显示49试出来
    在这里插入图片描述

    9-2. 数字字符串转换为一个整数

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    #include <string.h>
    long  fun ( char *p)
    {
    	int np=1;//判定正负数
    	long rst=0;
    
    	if (*p == '-')
    	{
    		np = -1;
    		p++;
    	}
    	else if (*p == '+')
    		p++;
    
    	while (*p != '\0')
    	{
    		rst = rst * 10 + *p - '0';
    		p++;
    	}
    
    	return rst*np;
    }
    
    void main()   /* 主函数 */
    { char s[6];void NONO ();
      long    n;
      printf("Enter a string:\n") ;
      gets(s);
      n = fun(s);
      printf("%ld\n",n);
      NONO (  );
    }
    
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i ;
      char s[20] ;
      long n ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(fp, "%s", s) ;
        n = fun(s);
        fprintf(wf, "%ld\n", n) ;
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    9-3 比较字符串的长度

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    char  *fun ( char *s,  char *t)
    {
    
    }
    
    void main ( )
    { char a[20],b[20];
      void NONO (  );
      printf("Input 1th string:");
      gets( a);
      printf("Input 2th string:");
      gets( b);
      printf("%s\n",fun (a, b));
      NONO ();
    }
    
    void NONO ( )
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf;
      int i ;
      char a[20], b[20];
    
      fp = fopen("in.dat","r");
      wf = fopen("out.dat","w");
      for(i = 0 ; i < 10 ; i++) {
        fscanf(fp, "%s %s", a, b);
        fprintf(wf, "%s\n", fun(a, b));
      }
      fclose(fp);
      fclose(wf);
    }
    
    

    解答
    解答1:

    char  *fun ( char *s,  char *t)
    {
    	return strlen(s) < strlen(t) ? t : s;
    }
    

    解答2:

    char  *fun ( char *s,  char *t)
    {
    	int i, j;
    	for (i = 0; s[i]; i++);
    	for (j = 0; s[j]; j++);
    	return i < j ? t : s;
    }
    

    难度等级:★★☆☆☆
    学点啥

    9-4 形参s所指字符串放入形参a所指的字符串中

    在这里插入图片描述
    难度等级:★★☆☆☆

    #include  <stdio.h>
    #define    N    20
    void NONO();
    void  fun( char  *a , char  *s)
    {
    	int i=0;
    	while (*s != '\0')
    	{
    		*a = *s;
    		a++;
    		s++;
    	}
    	*a = '\0';
    
    }
    
    void main()
    {  char  s1[N],  *s2="abcdefghijk";
       fun( s1,s2);
       printf("%s\n", s1);
       printf("%s\n", s2);
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i;
      char s1[256], s2[256];
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fgets(s2, 255, fp);
        fun(s1,s2);
        fprintf(wf, "%s", s1);
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    学点啥
    注意程序要求不能使用字符串函数,故应使用指针

    10【删除】

    10-1.【删除】除了尾部的*号之外,串中其他 号全部删除(删除中间、尾部号)

    在这里插入图片描述

    #include <stdio.h>
    void  fun( char *a, char *p )
    {
    	int i = 0,j = 0;
    	char *pt;
    	pt = a;
    	/* p之前删除* */
    	while(pt<p)
    	{
    		if (*pt != '*')
    		{
    			*(a+i) = *pt;
    			i++;
    		}
    		pt++;
    	}
    	/*p之后不变*/
    	while (*(p+j))
    	{
    		*(a+i) = *(p+j);
    		i++;
    		p++;
    	}
    	/*增加结束符*/
    	*(a+i) = '\0';
    
    }
    
    void main()
    {  char  s[81],*t;
       void NONO (  );
       printf("Enter a string:\n");gets(s);
       t=s;
       while(*t)t++;
       t--;
       while(*t=='*')t--;
       fun( s , t );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81],*t ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        t=s;
        while(*t)t++;
        t--;
        while(*t=='*')t--;
        fun(s,t) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    难度等级:★★☆☆☆
    学点啥

    使用void fun( char *a)方式参见多种*删除方式

    10-2.【删除】除了字符串前导的*号之外,串中其他 号全部删除(删除中间、尾部号)

    在这里插入图片描述

    #include <stdio.h>
    void  fun( char *a )
    {
    	int i=0;
    	/*定义临时指针P,初始指向原串首地址*/
    	char *p = a;
    	/*利用循环语句把字符串中字母前的*copy到原串*/
    	while (*p&&(*p == '*'))
    	{
    		a[i] = *p;
    		i++;
    		p++;
    	}
    	/*继续移动指针
    	把串中和串尾的非*号宇符拷贝到原串*/
    	while (*p)
    	{
    		if (*p != '*')
    		{
    			a[i] = *p;
    			i++;
    		}
    		p++;
    	}
    	/*修改后的宇符串赋结束宇符_\0_*/
    	a[i] = '\0';
    }
    
    void main()
    {  char  s[81];void NONO ();
       printf("Enter a string:\n");gets(s);
       fun( s );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fun(s) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    输出结果
    在这里插入图片描述
    难度等级:★★★☆☆
    学点啥
    在这里插入图片描述
    函数fun的功能:除了宇符串前导的号之外,将串中其他号全部 删 除 。 解 答 本 题 : ( 1 ) 定 义临 时 指 针P, 初始指向原串首地址 :( 2)利用循环语句把宇符串前导贝到原串(3)继续移动指针,把串中和串尾的非*号宇符拷贝到原串:⑷为修改后 的宇符串赋结束宇符_\0_。
    [解题宝典]
    要删除宇符串中的指定宇符,我们通常果用保留非指定宇符的 方法。可以将^指定宇符保留在原串,即搏需要保留的宇符从
    原串的 起 始 位 置 重 新 赋值:也可以保留到新串,即新建符串,存放要保留的宇符。

    10-3.【删除】除了字符串中间的*号之外,串中其他 号全部删除(删除头部、尾部号)

    问题:假设输入的字符串为ABCDEFG****,删除串中的号后,字符串变为ABCDEFG
    思路:(1)按照删除尾部
    号思路,在最后一个字母下一位放置结束符\0;(2)按照删除头部*号思路,寻找到第一位字母;(3)因新的结束符放好了,无需多言,完工。

    #include <stdio.h>
    void  fun( char *a )
    {
    	//新增
    	char *t = a;
    	/*遍历,指针a指向\0也即*/
    	while (*t != '\0')//while(*t)
    		t++;
    	/*指针a指向最后一个字母*/
    	t--;
    	/*指针a指向为*时指针a--,
    	直至遇到字母也即非*为止.
    	指针t指向字符串中最后字符*/
    	while (*t == '*')
    		t--;
    	/*字符串后移一位,加上结束标志符*/
    	*(t + 1) = '\0';
    	//
    	int i = 0;
    	/*定义临时指针P,初始指向原串首地址*/
    	char *p = a;
    	/*遍历,直至找到第一个字母.
    	指针f指向字符串中第一个字符*/
    	while (*p == '*')
    		p++;
    	/*继续移动指针,字符拷贝到原串
    	直至遇到结束字符\0*/
    	while (*p)
    	{
    		if (*p != '\0')
    		{
    			a[i] = *p;
    			i++;
    		}
    		p++;
    	}
    }
    
    void main()
    {  char  s[81];void NONO ();
       printf("Enter a string:\n");gets(s);
       fun( s );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fun(s) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    
    
    

    在这里插入图片描述

    10-4.【删除】将字符串头部的*号全部删除,保留其他

    问题:假设输入的字符串为ABCDEFG****,删除串中的号后,字符串变为ABCDEF*G********
    在这里插入图片描述

    #include <stdio.h>
    void  fun( char *a )
    {
    	int i = 0;
    	/*定义临时指针P,初始指向原串首地址*/
    	char *p = a;
    	/*遍历,直至找到第一个字母*/
    	while (*p && (*p == '*'))
    		p++;
    
    	/*继续移动指针,字符拷贝到原串
    	直至遇到结束字符\0*/
    	while (*p)
    	{
    		if (*p != '\0')
    		{
    			a[i] = *p;
    			i++;
    		}
    		p++;
    	}
    }
    
    void main()
    {  char  s[81];void NONO ();
       printf("Enter a string:\n");gets(s);
       fun( s );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fun(s) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    输出结果
    在这里插入图片描述
    难度等级:★☆☆☆☆
    学点啥
    思路2:

    void  fun(char *a)
    {
    	char *p = a;
    	while (*p == '*')//p指向第一个字母
    		p++;
    	for (; *p != '\0'; p++.a++)//第一各字母后字符放入
    		*a = *p;
    	*a = '\0';
    }
    

    思路3:

    void  fun(char *a)
    {
    	char *p = a;
    	while (*p == '*')//p指向第一个字母
    		p++;
    	strcpy(a, p);
    }
    
    char a[10],b[]={"COPY"};
    //定义字符数组a,b
    strcpy(a,b);
    //将b中的COPY复制到a中
    

    10-5.【删除】将字符串尾部的*号全部删除,保留其他

    问题:假设输入的字符串为ABCDEFG****,删除串中的号后,字符串变为*ABCDEFG

    #include <stdio.h>
    void  fun( char *a )
    {
    	/*遍历,指针a指向\0也即*/
    	while (*a != '\0')
    		a++;
    	/*指针a指向最后一个字母*/
    	a--;
    	/*指针a指向为*时指针a--,
    	直至遇到字母也即非*为止*/
    	while (*a == '*')
    		a--;
    	/*字符串后移一位,加上结束标志符*/
    	*(a + 1) = '\0';
    
    }
    
    void main()
    {  char  s[81];void NONO ();
       printf("Enter a string:\n");gets(s);
       fun( s );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fun(s) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    
    
    

    输出结果
    在这里插入图片描述
    难度等级:★★★☆☆
    学点啥
    ‘\0’ 是字符串的结束符,任何字符串之后都会自动加上’\0’。如果字符串末尾少了‘\0’转义字符,则其在输出时可能会出现乱码问题。
    ‘\0’转义字符在ASCII表中并不表示阿拉伯数字0,阿拉伯数字0的ASCII码为48,‘\0’转义字符的ASCII码值为0,它表示的是ASCII控制字符中空字符的含义。
    **思路:**将字符串尾部*号删除,如下图,指针首先增加至\0(20),再往回走,遇到字母(17)后,将(18)放置\0即可。
    在这里插入图片描述

    void  fun( char *a )
    {
    	/*遍历,指针a指向\0也即*/
    	while (*a != '\0')
    		a++;
    	/*指针a指向最后一个字母*/
    	a--;
    	/*指针a指向为*时指针a--,
    	直至遇到字母也即非*为止*/
    	while (*a == '*')
    		a--;
    	/*字符串后移一位,加上结束标志符*/
    	*(a + 1) = '\0';
    
    }
    

    10-6.【删除】将字符串中的*号删除,保留其他

    转载[https://blog.csdn.net/qq_36955347/article/details/73511589(https://blog.csdn.net/qq_36955347/article/details/73511589)
    问题:假设输入的字符串为ABCDEFG****,删除串中的号后,字符串变为****ABDEFG********

    设置两个指向字符的指针变量t和f。先使用循环语句让t指针指向字符串中最后一个字符,而f指针指向字符串中第一个字符;再判断t和f指向的字符是否为“”,如果为“”,则t指针自减,f指针自增,直到遇到第一个不是的字符为止。

    再定义一个函数fun()用于删除字符串中的“”号,同时保留字符串前后的“”号。

    #include <stdio.h>
    int fun(char *a, char *h, char *p)
    {
        int i, j;
        /*删除指针h与p之间的所有“*”*/
        for(i=0,j=0; &h[i]<p; i++)
            if(h[i]!='*')
                h[j++]=h[i];
        /*将指针p至字符串尾部的所有字符前移*/
        for(i=0; p[i]; i++,j++)
            h[j]=p[i];
        h[j]='\0';  /*在字符串尾部添加结束标志*/
        return 0;
    }
    int main( )
    {
        char s[81], *t, *f;
        printf("Enter a string :\n");
        gets(s);  /*输入字符串*/
        t=f=s;  /*用字符指针t、f指向串s*/
       
        while(*t)
            t++;
        t--;  /*将指针t定位到字符串中最后一个字符*/
        while(*t == '*')  /*指针t指向字符串中最后一个字符*/
            t--;
        while (*f == '*')  /*指针f指向字符串中第一个字符*/
            f++;
        fun(s, f, t);
        printf("The string after deleted:\n");  /*输出结果*/
        puts(s);
        return 0;
    }
    

    输出结果
    在这里插入图片描述
    难度等级:★★★★☆

    学点啥
    参考上述,自写函数如下:

    void StarDelM(char *a)   //010
    {
    	char *f, *t;
    	f = t = a;
    	while (*t)
    		t++;
    	t--;  /*将指针t定位到字符串中最后一个字符*/
    	while (*t == '*')  /*指针t指向字符串中最后一个字符*/
    		t--;
    	while (*f == '*')  /*指针f指向字符串中第一个字符*/
    		f++;
    
    	int i, j;
    		/*删除指针f与t之间的所有“*”*/
    	for (i = 0,j = 0; f + i < t; i++)
    		if (*(f + i) != '*')
    		{
    			*(f + j) = *(f + i);//
    			j++;
    		}
    	/*将指针t至字符串尾部的所有字符前移*/
    	for (i = 0; *(t + i); i++, j++)
    		*(f + j) = *(t + i);
    	*(f + j) = '\0';  /*在字符串尾部添加结束标志*/
    }
    

    10-7.【删除】使字符串中间部的*号不多于n个

    在这里插入图片描述
    思路
    (1)指针t++,找到结束符\0,回溯并计个数k;
    (2)比较
    个数k与要求值n,若k大,则只保留n个*;否则无需操作

    #include <stdio.h>
    void  fun( char *a,int  n )
    {
    	int i = 0,k = 0;
    	char *p,*t;
    	p = t = a;
    	while (*t)
    		t++;
    	t--;
    	while (*t == '*')
    	{
    		t--;//指针-1
    		k++;//计数+1
    	}
    
    	if (k > n)
    	{
    		while (/*p&&*/p < t + n + 1)
    		{
    			*(a+i) = *p;
    			i++;
    			p++;
    		}
    		*(a + i) = '\0';
    	}
    
    }
    
    void main()
    {  char  s[81];  int  n;
       void NONO (  );
       printf("Enter a string:\n");gets(s);
       printf("Enter n :  ");scanf("%d",&n);
       fun( s,n );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i, n ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fscanf(in, "%d", &n) ;
        fun(s,n) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    输出结果
    在这里插入图片描述
    难度等级:★★★☆☆
    学点啥

    10-8. 【删除】使字符串前导*号不多于n个

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    void  fun( char *a, int  n )
    {
    	int i = 0, k = 0;
    	char *p, *f;
    	p = f = a;
    	/*统计前导*个数*/
    	while (*f == '*')
    	{
    		k++;
    		f++;
    	}
    	/*k大于n,则使p前导保留n个*
    	例:*****ABC若n=2,p指向*(p+5-2)
    	*/
    	if (k > n)
    	{
    		for (; *p; i++, p++)
    			a[i] = *(p + k - n);
    	}
    	a[i] = 0;
    }
    
    void main()
    {  char  s[81];  int  n;void NONO ();
       printf("Enter a string:\n");gets(s);
       printf("Enter n :  ");scanf("%d",&n);
       fun( s,n );
       printf("The string after deleted:\n");puts(s);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i, n ; char s[81] ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(in, "%s", s) ;
        fscanf(in, "%d", &n) ;
        fun(s,n) ;
        fprintf(out, "%s\n", s) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    
    

    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    10-9.【删除】删除一维数组中所有相同的数

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    #define N 80
    int fun(int a[], int n)
    {
    	int i = 1, j = 1;
    
    	for (i = 1; i < n; i++)
    	{
    		if (a[j-1] != a[i])
    			a[j++] = a[i];
    	}
    	return j;
    }
    void main()
    { 
      FILE *wf;
      int a[N]={ 2,2,2,3,4,4,5,6,6,6,6,7,7,8,9,9,10,10,10,10}, i, n=20;
      printf("The original data :\n");
      for(i=0; i<n; i++)  
         printf("%3d",a[i]);
      n=fun(a,n);
      printf("\n\nThe data after deleted :\n");
      for(i=0; i<n; i++)  
         printf("%3d",a[i]);  
      printf("\n\n");
    /******************************/
      wf=fopen("out.dat","w");
      for(i=0; i<n; i++)  
         fprintf(wf,"%3d",a[i]);
      fclose(wf);
    /*****************************/
    }
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥
    在这里插入图片描述

    10-10.【删除】删除一个字符串中指定下标的字符

    在这里插入图片描述

    #include <stdio.h>
    #include <string.h>
    #define LEN 20
    
    void fun (char a[], char b[], int n)
    {
    	int i = 0, j = 0;
    	for(; *(a + i);i++)
    		if (i != n)
    			b[j++] = a[i];
    	//*(b + j) = '\0';//结束标识 方法1
    	//b[j] = '\0';//结束标识 方法2
    	b[j] = 0;//结束标识 方法2
    }
    
    void main( )
    {   char str1[LEN], str2[LEN] ;
        int n ;
        void NONO (  );
    
        printf("Enter the string:\n") ;
        gets(str1) ;
        printf("Enter the position of the string deleted:") ;
        scanf("%d", &n) ;
        fun(str1, str2, n) ;
        printf("The new string is: %s\n", str2) ;
        NONO() ;
    }
    
    void NONO ( )
    {/* 本函数用于打开文件,输入测试数据,调用fun函数,输出数据,关闭文件。*/
      char str1[LEN], str2[LEN] ;
      int i, n ;
      FILE *rf, *wf ;
    
      rf = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fscanf(rf, "%s %d", str1, &n) ;
        fun(str1, str2, n) ;
        fprintf(wf, "%s\n", str2) ;
      }
      fclose(rf) ;
      fclose(wf) ;
    }
    

    输出结果
    难度等级:★★★★★☆☆☆☆
    学点啥

    10-11【删除】删除字符串中所有空格

    在这里插入图片描述
    雕虫小技
    结合函数功能以及main函数,可得只需修改

      `char Msg[]="Input a string:";
      //
       fun(Msg);
      fprintf(out,"%s",Msg);
    

    即可

    void main()
    {
      char str[81];
      char Msg[]="Input a string:";
      int n;
      FILE *out;
      printf(Msg);
      gets(str);
      puts(str);
      fun(str); 
      printf("*** str: %s\n",str); 
      /******************************/
      out=fopen("out.dat","w");
      fun(Msg);
      fprintf(out,"%s",Msg);
      fclose(out);
      /******************************/
    }
    

    输出结果
    step1: 打开程序>直接运行(F5快捷键);
    在这里插入图片描述
    step2:随便输入,关闭之
    在这里插入图片描述
    step3:按照格式修改out.dat文件并保存;注意找main函数中最后一次调用函数对应的部分:
    在这里插入图片描述

    step4:
    case 考场:本题做完了;break;
    case 模拟;交卷体验下满分快感;break;
    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #include <ctype.h>
    #include <conio.h>
    #include <stdlib.h>
    void fun (char *str)
    {
    	int i = 0;
    	char *p = str;
    	
    	for (;*p;p++)
    	{
    		if (*p != ' ')
    			str[i++] = *p;
    	}
    	*(str + i) = '\0';
    }
    void main()
    {
      char str[81];
      char Msg[]="Input a string:";
      int n;
      FILE *out;
      printf(Msg);
      gets(str);
      puts(str);
      fun(str); 
      printf("*** str: %s\n",str); 
      /******************************/
      out=fopen("out.dat","w");
      fun(Msg);
      fprintf(out,"%s",Msg);
      fclose(out);
      /******************************/
    }
    
    

    输出结果
    难度等级:★☆☆☆☆
    学点啥
    类似删除*号题目,不要错误认为不可以再用’\0’判定结尾
    实际上空格与结束符的ASCII码不同,回车、换行、空格的ASCII码值—(附ASCII码表)
    回车、换行、空格的ASCII码值
    回车,ASCII码13
    换行,ASCII码10
    空格,ASCII码32

    A,ASCII码65
    a,ASCII码97
    中间差一个空格 ASCII码32
    结束符’\0’ASCII码0

    而’\0’为结束符,其ASCII码表为0,也正因为此,输入结束符可以使用*(str + i) = '\0';//*(str + i) = 0;均可

    10-12【删除】从字符串中删除指定的字符

    在这里插入图片描述

    #include <string.h>
    #include <stdio.h>
    void fun( char s[],int c)
    {
      
    }
    void main()
    {
      static char str[]="turbo c and borland c++";
      char ch;
      FILE *out;
      printf ("原始字符串:%s\n ",str);
      printf("输入一个字符串:\n");
      scanf("%c",&ch);
      fun(str,ch);
      printf("str[]=%s\n",str);
      strcpy(str,"turbo c and borland c++");
      fun(str,'a');
      /******************************/
      out=fopen("out.dat","w");
      fprintf(out,"%s",str);
      fclose(out);
      /******************************/
    }
    

    雕虫小技
    注意到
    在这里插入图片描述
    以及 fun(str,‘a’);
    可知 只需将out.dat文件中a消除即可
    修改前
    在这里插入图片描述
    修改后
    在这里插入图片描述
    在这里插入图片描述

    #include <string.h>
    #include <stdio.h>
    void fun( char s[],int c)
    {
    	int i = 0;
    	char *p;
    	p = s;
    
    	while (*p)
    	{
    		if (*p != c) 
    		{
    			s[i++] = *p;//不同指向直接输出
    		}
    		p++;//相同指向下一个字符
    	}
    	s[i] = '\0';
    }
    void main()
    {
      static char str[]="turbo c and borland c++";
      char ch;
      FILE *out;
      printf ("原始字符串:%s\n ",str);
      printf("输入一个字符串:\n");
      scanf("%c",&ch);
      fun(str,ch);
      printf("str[]=%s\n",str);
      strcpy(str,"turbo c and borland c++");
      fun(str,'a');
      /******************************/
      out=fopen("out.dat","w");
      fprintf(out,"%s",str);
      fclose(out);
      /******************************/
    }
    
    

    输出结果
    在这里插入图片描述
    在这里插入图片描述
    难度等级:★☆☆☆☆
    学点啥

    11【胜者为王 吃肉 败者为寇 渣都没得】

    11-1.数组中的最小值或最大值,并与其第1个元素交换

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define N 10
    #pragma warning (disable:4996)
    void NONO(FILE *fp, int pd[], int n);
    
    void fun (int *dp,int n,int upordown)
    {
    
    }
    
    void display(int pd[],int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		printf("%4d",pd[i]);
    	printf("\n");
    }
    void main()
    {
    	int data[N],i,n=N;
    	FILE *out ;
    
        out = fopen("out.dat","w") ;
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,0);
    	display(data,n);
    	NONO(out, data, n);
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,1);
    	display(data,n);
    	NONO(out, data, n);
    	fclose(out);
    }
    void NONO(FILE *fp, int pd[], int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		fprintf(fp, "%4d", pd[i]);
    	fprintf(fp, "\n");
    
    }
    
    

    尝试1:

    void fun (int *dp,int n,int upordown)
    {
    	int i, j, temp;
    
    	switch (upordown) 
    	{
    	case 0:
    		for (i = 0; i < n; i++)
    		{
    			if (*dp < *(dp + i))
    			{
    				temp = *dp;
    				*dp = *(dp + i);
    				*(dp + i) = temp;
    			}
    		}
    		break;
    	case 1:
    		for (i = 0; i < n; i++)
    		{
    			if (*dp < *(dp + i))
    			{
    				temp = *dp;
    				*dp = *(dp + i);
    				*(dp + i) = temp;
    			}
    		}
    		break;
    	}
    }
    

    错误原因:尝试使用冒泡法思路,错误理解题意。

    **思路:**遍历数组,找到最值的下标(upordown==0时找最小值,upordown=1时找最大值);然后与下标为0的元素交换(与冒泡法相比,仅交换一次)

    void fun (int *dp,int n,int upordown)
    {
    	int temp, index = 0, i;
    	switch (upordown)
    	{
    	case 0:
    		for (i = 0; i < n; i++)
    		{
    			if (dp[index] > dp[i])
    				index = i;
    		};
    		break;
    	case 1:
    		for (i = 0; i < n; i++)
    		{
    			if (dp[index] < dp[i])
    				index = i;
    		};
    		break;
    	default: break;
    	}
    	
    	temp = dp[index];
    	dp[index] = dp[0];
    	dp[0] = temp;
    	
    }
    

    输出结果
    在这里插入图片描述
    优化
    1、index初值为0,i大可不必从0开始,dp[0]>dp[0]必为false;从1 开始即可。
    2、增设如下代码,若index为0,不必交换

    if (index != 0)
    {
    	temp = dp[index];
    	dp[index] = dp[0];
    	dp[0] = temp;
    }
    

    完整代码:

    #include <stdio.h>
    #include <stdlib.h>
    #define N 10
    #pragma warning (disable:4996)
    void NONO(FILE *fp, int pd[], int n);
    
    void fun (int *dp,int n,int upordown)
    {
    	int temp, index = 0, i;
    	switch (upordown)
    	{
    	case 0:
    		for (i = 1; i < n; i++)
    		{
    			if (dp[index] > dp[i])
    				index = i;
    		};
    		break;
    	case 1:
    		for (i = 1; i < n; i++)
    		{
    			if (dp[index] < dp[i])
    				index = i;
    		};
    		break;
    	default: break;
    	}
    
    	if (index != 0)
    	{
    		temp = dp[index];
    		dp[index] = dp[0];
    		dp[0] = temp;
    	}
    }
    
    void display(int pd[],int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		printf("%4d",pd[i]);
    	printf("\n");
    }
    void main()
    {
    	int data[N],i,n=N;
    	FILE *out ;
    
        out = fopen("out.dat","w") ;
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,0);
    	display(data,n);
    	NONO(out, data, n);
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,1);
    	display(data,n);
    	NONO(out, data, n);
    	fclose(out);
    }
    void NONO(FILE *fp, int pd[], int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		fprintf(fp, "%4d", pd[i]);
    	fprintf(fp, "\n");
    
    }
    
    

    在这里插入图片描述

    11-2 整数中找出最大值和最小值

    在这里插入图片描述
    雕虫小技

    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, a, b, c, d ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for( i=0; i<5; i++ )
      {
         fscanf(fp, "%d %d %d %d", &a, &b, &c, &d);
         fun(&a,&b,&c,&d); 
         fprintf(wf, "a=%d,d=%d\n", a, d);
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    

    F5运行、打开、手动out.dat
    在这里插入图片描述
    在这里插入图片描述

    正儿八经

    #include   <stdio.h>
    void NONO();
    void  fun(int  *a, int  *b, int  *c, int  *d)
    {
    	int max=*a, min=*a;
    
    	if (max < *b)
    		max = *b;
    	if (min > *b)
    		min = *b;
    
    	if (max < *c)
    		max = *c;
    	if (min > *c)
    		min = *c;
    
    	if (max < *d)
    		max = *d;
    	if (min > *d)
    		min = *d;
    
    	*a = max;
    	*d = min;
    }
    void main()
    {  int  a, b, c, d;
       printf("请输入4个整数:    ");  scanf("%d%d%d%d", &a,&b,&c,&d);
       printf("原始顺序:    %d,%d,%d,%d\n", a, b, c, d);
       fun(&a,&b,&c,&d); 
       printf("处理后:      %d,%d,%d,%d\n", a, b, c, d);
       NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, a, b, c, d ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for( i=0; i<5; i++ )
      {
         fscanf(fp, "%d %d %d %d", &a, &b, &c, &d);
         fun(&a,&b,&c,&d); 
         fprintf(wf, "a=%d,d=%d\n", a, d);
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    
    

    在这里插入图片描述

    难度等级:★☆☆☆☆
    学点啥
    优化

    void  fun(int  *a, int  *b, int  *c, int  *d)
    {
    	int max=*a, min=*a;
    
    	max = *a > *b ? *a : *b;
    	max = max > *c ? max : *c;
    	max = max > *d ? max : *d;
    
    	min = *a > *b ? *b : *a;
    	min = min > *c ? *c : min;
    	min = min > *d ? *d : min;
    
    	*a = max;
    	*d = min;
    }
    

    函数这么写能保证ad位置正确,但是bc数据有误
    在这里插入图片描述

    难度等级:★★★★★☆☆☆☆
    学点啥

    11-3 找出最长的一个字符串

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述

    正儿八经

    #include<conio.h>
    #include<stdio.h>
    #include<string.h>
    #include<stdlib.h>
    
    char *fun(char (*a)[81], int num, char *max)
    {
    
    }
    void main()
    {
      FILE *wf;
      char ss[10][81],*ps=NULL;
      char s[3][81]={"abcd","deg","diegns"},*p=NULL;
      int  i=0,n;
      system("CLS");
      printf("输入若干个字符串:");
      gets(ss[i]);
      puts(ss[i]);
      while(!strcmp(ss[i], "****")==0)  /*用4个星号作为结束输入的标志*/
         {
          i++;
          gets(ss[i]);
          puts(ss[i]);
         }
      n=i;
      ps=fun(ss,n,ps);
      printf("\nmax=%s\n",ps);
    /******************************/
      wf=fopen("out.dat","w");
      p=fun(s,3,p);
      fprintf(wf,"%s",p);
      fclose(wf);
    /*****************************/
    }
    
    

    编写:

    char *fun(char (*a)[81], int num, char *max)
    {
    	int i = 0;
    	max = a[0];
    	for (i = 0; i < num; i++)
    	{
    		if (strlen(max) < strlen(a[i]))
    			max = a[i];
    	}
    	return max;
    }
    

    难度等级:★☆☆☆☆
    学点啥

    11-4 求出数组的最大元素在数组中的下标

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <conio.h>
    #include <stdio.h>
    #include <stdlib.h>
    int fun(int *s,int t,int *k)
    {
    	int i;
    	*k = 0;
    
    	for (i = 0; i < t; i++)
    		if (s[*k] < s[i])
    			*k=i;
    
    	return s[*k];
    }
    void main()
    {
      FILE *wf;
      int a[10]={ 876,675,896,101,301,401,980,431,451,777},k;
      system("CLS");
      fun(a, 10, &k);
      printf("%d, %d\n ", k, a[k]);
    /******************************/
      wf=fopen("out.dat","w");
      fprintf (wf,"%d, %d", k, a[k]);
      fclose(wf);
    /*****************************/
    }
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    11-5.最大的值及其所在的下标

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述

    正儿八经

    #include<stdlib.h>
    #include<stdio.h>
    #include<time.h>
    void fun(int a[],int n, int *max, int *d)
    {
    	int i;
    	*max = a[0];
    
    	for (i = 0; i < n; i++)
    	{
    		if (*max < a[i])
    		{
    			*max = a[i];
    			*d = i;
    		}
    	}
    
    }
    void main()
    { 
      FILE *wf;
      int i, x[20], max,  index, n=10;
      int y[20]={4,2,6,8,11,5};
      srand((unsigned)time(NULL));
      for(i=0;i<n;i++)
        {
         x[i]=rand()%50; 
         printf("%4d",x[i]);    /*输出一个随机数组*/
        }
      printf("\n");
      fun(x,n,&max,&index);
      printf("Max=%5d,Index=%4d\n",max,index);
    /******************************/
      wf=fopen("out.dat","w");
      fun(y,6,&max,&index);
      fprintf(wf,"Max=%5d,Index=%4d",max,index);
      fclose(wf);
    /*****************************/
    }
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    11-6. 找出dp所指数组中的最小或最大值

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    #include <stdlib.h>
    #define N 10
    #pragma warning (disable:4996)
    void NONO(FILE *fp, int pd[], int n);
    
    void fun (int *dp,int n,int upordown)
    {
    	int i, temp, index=0;
    
    	if (n == 0) return;
    
    	for (i = 1; i < n; i++)
    	{
    		if ((upordown == 0 && dp[i]<dp[index]) || (upordown == 1 && dp[i] > dp[index]))
    			/*if (upordown == 0 && dp[i] < dp[index] || upordown == 1 && dp[i] > dp[index])
    			  C语言中逻辑运算符“与”“或”“非”优先级:非>与>或
    			*/
    			index = i;//index存储目标元素
    	}
    	if (index != 0)
    	{
    		temp = dp[index];
    		dp[index] = dp[0];
    		dp[0] = temp;
    	}
    }
    
    
    void display(int pd[],int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		printf("%4d",pd[i]);
    	printf("\n");
    }
    void main()
    {
    	int data[N],i,n=N;
    	FILE *out ;
    
        out = fopen("out.dat","w") ;
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,0);
    	display(data,n);
    	NONO(out, data, n);
    	for(i=0;i<N;i++)
    		data[i]=rand()%90+10;
    	for(i=0;i<N-1;i++)
    		fun(data+i,n-i,1);
    	display(data,n);
    	NONO(out, data, n);
    	fclose(out);
    }
    void NONO(FILE *fp, int pd[], int n)
    {
    	int i;
    	for(i=0;i<n;i++)
    		fprintf(fp, "%4d", pd[i]);
    	fprintf(fp, "\n");
    
    }
    
    

    在这里插入图片描述

    难度等级:★★☆☆☆
    学点啥
    C语言中逻辑运算符“与”“或”“非”优先级是怎样的?非>与>或

    单目运算符和双目运算符以及三目运算符

    12 【教务处】

    12-1 【教务处】高于等于平均分的学生数据

    在这里插入图片描述
    尝试1

    double  fun( STREC  *a, STREC *b, int *n )
    {
    	double ave = 0.0;
    	int i, j = 0, len;
    	*n = 0;
    
    	/*find average*/
    	for (i=0;i<N;i++)
    	{
    		ave +=a[i].s/N;
    	}
    	/*store higher grade*/
    	for (i = 0; i < N; i++)
    	{
    		if (a[i].s>ave)
    		{
    			b[j++] = a[i];
    			(*n)++;
    		}
    	}
    	return ave;
    }
    

    输出结果
    在这里插入图片描述
    优化

    #include <stdio.h>
    #define   N   12
    typedef  struct
    {  char  num[10];
       double  s;
    } STREC;
    double  fun( STREC  *a, STREC *b, int *n )
    {
    	double ave = 0.0;
    	int i;
    	*n = 0;
    
    	/*find average*/
    	for (i=0;i<N;i++)
    	{
    		ave +=a[i].s/N;
    	}
    	/*store higher grade*/
    	for (i = 0; i < N; i++)
    	{
    		if (a[i].s>ave)
    		{
    			b[(*n)++] = a[i];
    		}
    	}
    	return ave;
    }
    
    void main()
    {  STREC  s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
    		{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
    		{"GA09",60},{"GA11",79},{"GA12",73},{"GA10",90}};
       STREC  h[N], t;FILE *out ;
       int  i,j,n;  double  ave;
       ave=fun( s,h,&n );
       printf("The %d student data which is higher than %7.3f:\n",n,ave);
       for(i=0;i<n; i++)
         printf("%s  %4.1f\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       fprintf(out, "%d\n%7.3f\n", n, ave);
       for(i=0;i<n-1;i++)
         for(j=i+1;j<n;j++)
           if(h[i].s<h[j].s) {t=h[i] ;h[i]=h[j]; h[j]=t;}
       for(i=0;i<n; i++)
         fprintf(out,"%4.1f\n",h[i].s);
       fclose(out);
    }
    

    输出结果
    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    12-2 【教务处】将低于平均分的人数作为函数值返回(数组)

    在这里插入图片描述

    #include <conio.h>
    #include <stdio.h>
    #include <string.h>
    #include <stdlib.h>
    int fun(int score[],int m, int below[])
    {
    	float Ave = 0.0; 
    	int i,j = 0;
    	for (i=0;i<m;i++)
    	{
    		Ave += score[i]/m;
    	}
    	for (i = 0; i < m; i++)
    	{
    		if (score[i] < Ave)
    		{
    			below[j++] = score[i];
    		}
    	}
    	return j;
    }
    void main()
    {
      FILE *wf;
      int i, n, below[9];
      int score[9]={10,20,30,40,50,60,70,80,90};
      system("CLS");
      n=fun(score, 9, below);
      printf("\nBelow the average score are: ");
      for(i=0;i<n;i++)  
         printf("%d ",below[i]);
    /******************************/
      wf=fopen("out.dat","w");
      for(i=0;i<n;i++)  
         fprintf(wf,"%d ",below[i]);
      fclose(wf);
    /*****************************/
    }
    
    

    学点啥

    12-3【教务处】【排序】【冒泡法】按分数降序排列

    在这里插入图片描述

    #include <stdio.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    void  fun( STREC  a[] )
    {
    	int i,j,len;
    	STREC temp;;
    	for (i=0;i<N;i++)
    	{
    		for (j = 0; j < N-1; j++)
    		{
    			if (a[j].s < a[j + 1].s)
    			{
    				temp = a[j];
    				a[j] = a[j+1];
    				a[j + 1] = temp;
    			}		
    		}
    	}
    }
    
    void main()
    {  STREC  s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
    		{"GA001",91},{"GA007",72},{"GA008",64},{"GA006",87},
    		{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
    		{"GA011",66},{"GA017",64},{"GA018",64},{"GA016",72}};
       int  i;FILE *out ;
       fun( s );
       printf("The data after sorted :\n");
       for(i=0;i<N; i++)
       {  if( (i)%4==0 )printf("\n");
          printf("%s  %4d  ",s[i].num,s[i].s);
       }
       printf("\n");
       out = fopen("out.dat","w") ;
       for(i=0;i<N; i++)
       {  if( (i)%4==0 && i) fprintf(out, "\n");
          fprintf(out, "%4d  ",s[i].s);
       }
       fprintf(out,"\n");
       fclose(out) ;
    }
    

    输出结果
    在这里插入图片描述

    难度等级:★★★☆☆
    学点啥
    经典的冒泡法:双层循环+if判断,外层循环控制比较轮数,内层循环控制两两比较。

    for (j = 0; j < N-1; j++)
    {
    	if (a[j].s < a[j + 1].s)
    	{
    		temp = a[j];
    		a[j] = a[j+1];
    		a[j + 1] = temp;
    	}		
    }
    

    从头到尾比较:1轮结束后,最值在最后,2轮结束后,次最值(倒数第2最值)在倒数第2…i轮结束后,倒数第i最值在倒数第i,注意第i轮比较只需要比较到N-i-1即可。

    if (a[j].s < a[j + 1].s)//冒泡后,最小值在最后
    //if (a[j].s > a[j + 1].s)//冒泡后,最大值在最后
    

    最大值在后,排序结果
    在这里插入图片描述

    在这里插入代码片
    

    输出结果
    难度等级:★★★★★☆☆☆☆
    学点啥

    12-4【教务处】 低于平均分的学生数据

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    #define   N   8
    typedef  struct
    {  char  num[10];
       double  s;
    } STREC;
    double  fun( STREC  *a, STREC *b, int *n )
    {
    	int i;
    	double ave = 0.0;
    	*n = 0;
    
    	for (i = 0; i < 8; i++)
    		ave += a[i].s / 8;
    
    	for (i = 0; i < 8; i++)
    	{
    		if (a[i].s <ave)
    			b[(*n)++] = a[i];
    	}
    
    	return ave;
    }
    
    void main()
    {  STREC  s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
                    {"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87}};
       STREC  h[N],t;FILE *out ;
       int  i,j,n;  double  ave;
       ave=fun( s,h,&n );
       printf("The %d student data which is lower than %7.3f:\n",n,ave);
       for(i=0;i<n; i++)
         printf("%s  %4.1f\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       fprintf(out, "%d\n%7.3f\n", n, ave);
       for(i=0;i<n-1;i++)
         for(j=i+1;j<n;j++)
           if(h[i].s>h[j].s) {t=h[i] ;h[i]=h[j]; h[j]=t;}
       for(i=0;i<n; i++)
         fprintf(out,"%4.1f\n",h[i].s);
       fclose(out);
    }
    
    
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    12-5【教务处】找出成绩最低的学生记录,通过形参返回主函数

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述
    在这里插入图片描述

    正儿八经
    题目:

    #include<stdio.h>
    #include<string.h>
    #include<conio.h>
    #include<stdlib.h>
    #define N 10
    typedef struct ss
    { char num[10]; 
      int s;
    } STU;
    void fun(STU a[], STU *s)
    {
      
    }
    void main()
    { 
      FILE *wf;
      STU a[N]={{ "A01",81},{ "A02",89},{ "A03",66},{ "A04",87},{ "A05",77},
      { "A06",90},{ "A07",79},{ "A08",61},{ "A09",80},{ "A10",71}},m;
      int i;
      system("CLS");
      printf("*****The original data*****\n");
      for(i=0;i<N;i++) 
        printf("No=%s Mark=%d\n", a[i].num,a[i].s);
      fun(a,&m);
      printf("*****THE RESULT*****\n");
      printf("The lowest :%s, %d\n",m.num,m.s);
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%s, %d",m.num,m.s);
      fclose(wf);
    /*****************************/
    }
    
    

    解答:

    void fun(STU a[], STU *s)
    {
    	int i,k=0,min;
    	*s = a[0];
    
    	for (i = 0; i < N; i++)
    	{
    		if (a[i].s < s->s)
    			*s = a[i];
    	}
    }
    

    在这里插入图片描述
    难度等级:★★★★★☆☆☆☆
    学点啥

    指向结构体成员运算符 : (->) 从外部看是包含了一个解指针(*)所以要对指针进行操作

    例如:

    typedef struct
    {
    	int data[];
    	int length;
    }Sqlist;
    
    Sqlist *L;
    L->lenth; //得到L中length的值
    

    结构体成员运算符 : ( . )直接调用结构体中的某个成员

    例如:

    typedef struct
    
    {
    	int data[];
    	int length;
    }Sqlist;
    
    Sqlist L;
    L.length; //直接调用L中length的值
    L.data[];
    

    12-6 【教务处】函数返回分数最低的学生人数

    在这里插入图片描述

    #include <stdio.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    int  fun( STREC  *a, STREC *b )
    {
    	int i, j = 0, min = a[0].s;
    	for (i=0; i < N; i++)
    	{
    		if (min > a[i].s)
    			min = a[i].s;
    	}
    
    	for (i = 0; i < N; i++)
    	{
    		if (min == a[i].s)
    			b[j++] = a[i];
    	}
    	return j;
    }
    
    void main()
    {  STREC  s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
    		{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
    		{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
    		{"GA011",91},{"GA017",64},{"GA018",64},{"GA016",72}};
       STREC  h[N];
       int  i,n;FILE *out ;
       n=fun( s,h );
       printf("The %d lowest score :\n",n);
       for(i=0;i<n; i++)
         printf("%s  %4d\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       fprintf(out, "%d\n",n);
       for(i=0;i<n; i++)
         fprintf(out, "%4d\n",h[i].s);
       fclose(out);
    }
    
    
    

    学点啥

    第一次循环,遍历,求出最低分数;
    第二次循环,遍历,求出最小分数人数并将其存入。

    12-7 【教务处】去掉一个最高分和一个最低分,然后求平均值 8.6875

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include  <stdio.h>
    void NONO();
    double fun(double  a[ ] , int  n)
    {
    	int i; 
    	double max = a[0], min = a[0], sum = 0.0;
    	for (i = 0; i < n; i++)//find sum
    		sum += a[i];
    	for (i = 1; i < n; i++)//find max,min
    	{
    		max = max > a[i] ? max : a[i];
    		min = min < a[i] ? min : a[i];
    	}
    	return (double)(sum - max - min) / (n - 2);
    	
    
    
    
    }
    
    void main()
    {  double  b[10],  r;    int  i;
        printf("输入10个分数放入b数组中 :  ");
        for (i=0; i<10; i++)   scanf("%lf",&b[i]);
        printf("输入的10个分数是 :  ");
        for (i=0; i<10; i++)   printf("%4.1lf ",b[i]);    printf("\n");
        r = fun(b, 10);
        printf("去掉最高分和最低分后的平均分 :  %f\n", r );
        NONO();
    }
    
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, j ;
      double b[10], r ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j = 0 ; j < 10 ; j++) {
          fscanf(fp, "%lf ", &b[j]) ;
        }
        r = fun(b, 10) ;
        fprintf(wf, "%f\n", r) ;
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    
    
    

    在这里插入图片描述
    优化

    double fun(double  a[ ] , int  n)
    {
    	int i; 
    	double max = a[0], min = a[0], sum = 0.0;
    
    	for (i = 0; i < n; i++)//find max,min
    	{
    		sum += a[i];
    		max = max > a[i] ? max : a[i];
    		min = min < a[i] ? min : a[i];
    	}
    	return (double)(sum - max - min) / (n - 2);
    }
    

    难度等级:★☆☆☆☆
    学点啥

    12-8【教务处】指定分数范围内

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    int  fun( STREC  *a,STREC *b,int l, int h )
    {
    	int i,j=0;
    	for(i=0;i<N;i++)
    		if (l <= a[i].s <= h)
    			b[j++] = a[i];
    	return j;
    }
    
    void main()
    {  STREC  s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
                    {"GA001",96},{"GA007",72},{"GA008",64},{"GA006",87},
                    {"GA015",85},{"GA013",94},{"GA012",64},{"GA014",91},
                    {"GA011",90},{"GA017",64},{"GA018",64},{"GA016",72}};
       STREC  h[N],tt;FILE *out ;
       int  i,j,n,low,heigh,t;
       printf("Enter 2 integer number low & heigh :  ");
       scanf("%d%d", &low,&heigh);
       if ( heigh< low ){ t=heigh;heigh=low;low=t; }
       n=fun( s,h,low,heigh );
       printf("The student's data between %d--%d :\n",low,heigh);
       for(i=0;i<n; i++)
         printf("%s  %4d\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       n=fun( s,h,80,98 );
       fprintf(out,"%d\n",n);
       for(i=0;i<n-1;i++)
         for(j=i+1;j<n;j++)
           if(h[i].s>h[j].s) {tt=h[i] ;h[i]=h[j]; h[j]=tt;}
       for(i=0;i<n; i++)
         fprintf(out,"%4d\n",h[i].s);
       fprintf(out,"\n");
       fclose(out);
    }
    

    难度等级:★☆☆☆☆
    学点啥

    12-9 【教务处】N名学生的成绩已在主函数中放入一个带头结点的链表结构中78.625

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define   N   8
    struct  slist
    {  double   s;
       struct slist  *next;
    };
    typedef  struct slist  STREC;
    double  fun( STREC *h  )
    {
    	double ave = 0.0;
    	STREC *p = h->next;
    	while (p != NULL)
    	{
    		ave += p->s;
    		p = p->next;
    	}
    	return ave / N;
    }
    
    STREC * creat( double *s)
    { STREC  *h,*p,*q;   int  i=0;
      h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
      while(i<N)
      { q=(STREC*)malloc(sizeof(STREC));
        q->s=s[i]; i++;  p->next=q; p=q;
      }
      p->next=0;
      return  h;
    }
    void outlist( STREC *h)
    { STREC  *p;
      p=h->next; printf("head");
      do
      { printf("->%4.1f",p->s);p=p->next;}
      while(p!=0);
      printf("\n\n");
    }
    void main()
    {  double  s[N]={85,76,69,85,91,72,64,87},ave;
       void NONO (  );
       STREC  *h;
       h=creat( s );   outlist(h);
       ave=fun( h );
       printf("ave= %6.3f\n",ave);
       NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i,j ; double  s[N],ave;
      STREC *h ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j=0 ; j < N; j++) fscanf(in, "%lf,", &s[j]) ;
        h=creat( s );
        ave=fun( h );
        fprintf(out, "%6.3lf\n", ave) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    学点啥
    使用循环语句遍历链表,求出求各结点数据域中数值的和。遍历链表定义一个指向结点的指针p,“头结点”无数值,让p指向“头结点”的笑一个结点,使用语句STREC *p=h->next

    12-10【教务处】找出成绩最高的学生记录

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述

    正儿八经

    #include<stdio.h>
    #include<string.h>
    #include<conio.h>
    #include<stdlib.h>
    #define N 10
    typedef struct ss    /*定义结构体*/
    { char num[10]; 
      int s;
    } STU;
    void fun(STU a[], STU *s)
    {
    	int i;
    	*s = a[0];
    
    	for (i = 0; i < N; i++)
    	{
    		if (s->s < a[i].s)
    			*s = a[i];
    	}
    }
    void main()
    { 
      FILE *wf;
      STU a[N]={{ "A01",81},{ "A02",89},{ "A03",66},{ "A04",87},{ "A05",77},
      { "A06",90},{ "A07",79},{ "A08",61},{ "A09",80},{ "A10",71}},m;
      int i;
      system("CLS");
      printf("*****The original data*****");
      for(i=0;i<N;i++) 
         printf("No=%s Mark=%d\n", a[i].num,a[i].s);
      fun(a,&m);
      printf("*****THE RESULT*****\n");
      printf("The top :%s, %d\n",m.num,m.s);
    /******************************/
      wf=fopen("out.dat","w");
      fprintf(wf,"%s,%d",m.num,m.s);
      fclose(wf);
    /*****************************/
    }
    
    

    难度等级:★★☆☆☆
    学点啥

    12-11【教务处】学生的平均分78.875

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    #define   N   8
    typedef  struct
    {  char  num[10];
       double  s[N];
       double  ave;
    } STREC;
    
    void  fun(STREC *a)
    {
    	int i;
    	a->ave = 0.0;
    
    	for (i = 0; i < N; i++)
    		a->ave += a->s[i];//(*a).ave += (*a).s[i];
    
    	a->ave /= N;
    }
    
    void main()
    {  STREC  s={"GA005",85.5,76,69.5,85,91,72,64.5,87.5};
       int  i;
       void NONO (  );
       fun( &s );
       printf("The %s's student data:\n", s.num);
       for(i=0;i<N; i++)
         printf("%4.1f\n",s.s[i]);
       printf("\nave=%7.3f\n",s.ave);
       NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *out ;
      int i,j ; STREC s[10] = {
      {"GA005",85.5,76,69.5,85,91,72,64.5,87.5},
      {"GA001",82.5,66,76.5,76,89,76,46.5,78.5},
      {"GA002",72.5,56,66.5,66,79,68,46.5,58.5},
      {"GA003",92.5,76,86.5,86,99,86,56.5,88.5},
      {"GA004",82,66.5,46.5,56,76,75,76.5,63.5},
      {"GA006",75.5,74,71.5,85,81,79,64.5,71.5},
      {"GA007",92.5,61,72.5,84,79,75,66.5,72.5},
      {"GA008",72.5,86,73.5,80,69,63,76.5,53.5},
      {"GA009",66.5,71,74.5,70,61,82,86.5,58.5},
      {"GA010",76,66.5,75.5,60,76,71,96.5,93.5},
    };
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        fun(&s[i]) ;
        fprintf(out, "%7.3f\n", s[i].ave) ;
      }
      fclose(out) ;
    }
    

    难度等级:★★★★★☆☆☆☆
    学点啥
    C语言–“.”与“->”有什么区别?
    (*a).b 等价于 a->b。

    "."一般情况下读作"的”。

    “->”一般读作"指向的结构体的"。

    12-12 【教务处】n门课程的平均分71.08

    在这里插入图片描述

    雕虫小技

    正儿八经

    #include <stdio.h>
    float  fun ( float  *a ,  int  n )
    {
    	int i;
    	double sum = 0.0;
    
    	for (i = 0; i < n; i++)
    		sum += a[i];
    
    	return sum / n;
    }
    
    void main()
    { float score[30]={90.5, 72, 80, 61.5, 55}, aver;
      void NONO (  );
      aver = fun( score, 5 );
      printf( "\nAverage score  is: %5.2f\n", aver);
      NONO ( );
    }
    
    void NONO ( )
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *fp, *wf ;
      int i, j ;
      float aver, score[5] ;
    
      fp = fopen("in.dat","r") ;
      wf = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j = 0 ; j < 5 ; j++) fscanf(fp,"%f,",&score[j]) ;
        aver = fun(score, 5) ;
        fprintf(wf, "%5.2f\n", aver) ;
      }
      fclose(fp) ;
      fclose(wf) ;
    }
    
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥

    12-13【教务处】把分数最高的学生数据

    在这里插入图片描述

    雕虫小技
    在这里插入图片描述

    正儿八经

    #include <stdio.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    int  fun( STREC  *a, STREC *b )
    {
    	int i, j = 0, max = a[0].s;
    	//find min
    	for (i = 0; i < N; i++)
    	{
    		if (max < a[i].s)
    			max = a[i].s;
    	}
    	for (i = 0; i < N; i++)
    	{
    		if (a[i].s == max)
    			b[j++] = a[i];
    	}
    	return j;
    
    }
    
    void main()
    {  STREC  s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
    		{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
    		{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
    		{"GA011",77},{"GA017",64},{"GA018",64},{"GA016",72}};
       STREC  h[N];
       int  i,n;FILE *out ;
       n=fun( s,h );
       printf("The %d highest score :\n",n);
       for(i=0;i<n; i++)
         printf("%s  %4d\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       fprintf(out, "%d\n",n);
       for(i=0;i<n; i++)
         fprintf(out, "%4d\n",h[i].s);
       fclose(out);
    }
    
    
    

    难度等级:★★★★★☆☆☆☆
    学点啥
    C语言中的% 2dprintf()函数的输bai出格式du中的%a.bf
    表示将数字按宽度为2,采用右对齐方式输zhi出,若数据位数不到2位,则左dao边补空格。

    12-14 【教务处】分数最低的学生数据

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    int  fun( STREC  *a, STREC *b )
    {
    	int i,j=0,min=a[0].s;
    	//find min
    	for (i = 0; i < N; i++)
    	{
    		if (min > a[i].s)
    			min = a[i].s;
    	}
    	for (i = 0; i < N; i++)
    	{
    		if (a[i].s == min)
    			b[j++] = a[i];
    	}
    	return j;
    }
    
    void main()
    {  STREC  s[N]={{"GA05",85},{"GA03",76},{"GA02",69},{"GA04",85},
    		{"GA01",91},{"GA07",72},{"GA08",64},{"GA06",87},
    		{"GA015",85},{"GA013",91},{"GA012",64},{"GA014",91},
    		{"GA011",91},{"GA017",64},{"GA018",64},{"GA016",72}};
       STREC  h[N];
       int  i,n;FILE *out ;
       n=fun( s,h );
       printf("The %d lowest score :\n",n);
       for(i=0;i<n; i++)
         printf("%s  %4d\n",h[i].num,h[i].s);
       printf("\n");
       out = fopen("out.dat","w") ;
       fprintf(out, "%d\n",n);
       for(i=0;i<n; i++)
         fprintf(out, "%4d\n",h[i].s);
       fclose(out);
    }
    

    难度等级:★★☆☆☆
    学点啥

    12-15【教务处】链表结构 求出平均分

    在这里插入图片描述

    #include <stdio.h>
    #include <stdlib.h>
    #define   N   8
    struct  slist
    {  double   s;
       struct slist  *next;
    };
    typedef  struct slist  STREC;
    double  fun( STREC *h  )
    {
    	double ave = 0.0;
    	/*定义一个指向结点的指针p。
    	由于头结点中无数值,
    	故直接让p指向“头结点”的下一个结点 
    	*/
    	STREC *p = h->next;
    	while (p != NULL)
    	{
    		ave += p->s;
    		p = p->next
    	}
    	return ave / N;
    }
    
    STREC * creat( double *s)
    { STREC  *h,*p,*q;   int  i=0;
      h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
      while(i<N)
      { q=(STREC*)malloc(sizeof(STREC));
        q->s=s[i]; i++;  p->next=q; p=q;
      }
      p->next=0;
      return  h;
    }
    void outlist( STREC *h)
    { STREC  *p;
      p=h->next; printf("head");
      do
      { printf("->%4.1f",p->s);p=p->next;}
      while(p!=0);
      printf("\n\n");
    }
    void main()
    {  double  s[N]={85,76,69,85,91,72,64,87},ave;
       void NONO (  );
       STREC  *h;
       h=creat( s );   outlist(h);
       ave=fun( h );
       printf("ave= %6.3f\n",ave);
       NONO();
    }
    void NONO()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i,j ; double  s[N],ave;
      STREC *h ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j=0 ; j < N; j++) fscanf(in, "%lf,", &s[j]) ;
        h=creat( s );
        ave=fun( h );
        fprintf(out, "%6.3lf\n", ave) ;    
      }
      fclose(in) ;
      fclose(out) ;
    }
    
    
    

    输出结果
    难度等级:★★★★☆
    学点啥
    1、链表详解
    2、单链表的几类操作介绍(头结点没有数据)

    12-16 【教务处】链表结构 找出学生的最高分

    在这里插入图片描述
    雕虫小技

    正儿八经

    #include <stdio.h>
    #include <stdlib.h>
    #define   N   8
    struct  slist
    {  double   s;
       struct slist  *next;
    };
    typedef  struct slist  STREC;
    double  fun( STREC *h  )
    {
    	double max=h->s;
    
    	while (h != NULL)
    	{
    		if (max < h->s)
    			max = h->s;
    		h = h->next;
    	}
    	return max;
    }
    
    STREC * creat( double *s)
    { STREC  *h,*p,*q;   int  i=0;
      h=p=(STREC*)malloc(sizeof(STREC));p->s=0;
      while(i<N)
      { q=(STREC*)malloc(sizeof(STREC));
        q->s=s[i]; i++; p->next=q; p=q;
      }
      p->next=0;
      return  h;
    }
    void outlist( STREC *h)
    { STREC  *p;
      p=h->next;   printf("head");
      do
      { printf("->%2.0f",p->s);p=p->next;}
      while(p!=0);
      printf("\n\n");
    }
    void main()
    {  double  s[N]={85,76,69,85,91,72,64,87}, max;void NONO ();
       STREC  *h;
       h=creat( s );   outlist(h);
       max=fun( h );
       printf("max=%6.1f\n",max);
       NONO();
    }
    void NONO ()
    {/* 本函数用于打开文件,输入数据,调用函数,输出数据,关闭文件。 */
      FILE *in, *out ;
      int i,j ; double  s[N],max;
      STREC *h ;
      in = fopen("in.dat","r") ;
      out = fopen("out.dat","w") ;
      for(i = 0 ; i < 10 ; i++) {
        for(j=0 ; j < N; j++) fscanf(in, "%lf,", &s[j]) ;
        h=creat( s );
        max=fun( h );
        fprintf(out, "%6.1lf\n", max) ;
      }
      fclose(in) ;
      fclose(out) ;
    }
    

    在这里插入图片描述
    难度等级:★★☆☆☆
    学点啥

    12-17 【教务处】返回该学号的学生数据

    在这里插入图片描述
    雕虫小技
    在这里插入图片描述
    正儿八经

    #include <stdio.h>
    #include <string.h>
    #define   N   16
    typedef  struct
    {  char  num[10];
       int   s;
    } STREC;
    STREC  fun( STREC  *a, char *b )
    {
    	int i;
    	/*若无指定学号,学号置空,成绩-1*/
    	STREC str={ "\0",-1 };
    	for (i = 0; i < N; i++)
    	{
    		if (strcmp(a[i].num,b)==0)
    			str=a[i];
    	}
    	return str;
    }
    
    void main()
    {  STREC  s[N]={{"GA005",85},{"GA003",76},{"GA002",69},{"GA004",85},
    		{"GA001",91