首页 > 编程语言 >实验3 C语言函数应用编程

实验3 C语言函数应用编程

时间:2024-04-23 17:57:44浏览次数:22  
标签:10 return 函数 int 编程 long C语言 char include

task1.c

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <time.h>
 4 #include <windows.h>
 5 #define N 80
 6 
 7 void print_text(int line, int col, char text[]);  // 函数声明 
 8 void print_spaces(int n);  // 函数声明 
 9 void print_blank_lines(int n); // 函数声明 
10 
11 int main() {
12     int line, col, i;
13     char text[N] = "hi, April~";
14     
15     srand(time(0)); // 以当前系统时间作为随机种子
16     
17     for(i = 1; i <= 10; ++i) {
18         line = rand() % 25;
19         col =  rand() % 80;
20         print_text(line, col, text);
21         Sleep(1000);  // 暂停1000ms
22     }
23     
24     return 0; 
25 }
26 
27 // 打印n个空格 
28 void print_spaces(int n) {
29     int i;
30     
31     for(i = 1; i <= n; ++i)
32         printf(" ");
33 }
34 
35 // 打印n行空白行
36 void print_blank_lines(int n) {
37     int i;
38     
39     for(i = 1; i <= n; ++i)
40         printf("\n");
41  } 
42 
43 // 在第line行第col列打印一段文本 
44 void print_text(int line, int col, char text[]) {
45     print_blank_lines(line-1);      // 打印(line-1)行空行 
46     print_spaces(col-1);            // 打印(col-1)列空格
47     printf("%s", text);         // 在第line行、col列输出text中字符串
48 }

 

功能是每隔1s在命令行随机位置打印一串指定文字

task2_1.c

 1 // 利用局部static变量的特性,计算阶乘
 2 
 3 #include <stdio.h>
 4 long long fac(int n); // 函数声明
 5 
 6 int main() {
 7     int i, n;
 8 
 9     printf("Enter n: ");
10     scanf("%d", &n);
11 
12     for (i = 1; i <= n; ++i)
13         printf("%d! = %lld\n", i, fac(i));
14     return 0;
15 }
16 
17 // 函数定义
18 long long fac(int n) {
19     static long long p = 1;
20     printf("p = %lld\n", p);
21     p = p * n;
22 
23     return p;
24 }

 

task2_2.c

 1 // 练习:局部static变量特性
 2 
 3 #include <stdio.h>
 4 int func(int, int);        // 函数声明
 5 
 6 int main() {
 7     int k = 4, m = 1, p1, p2;
 8 
 9     p1 = func(k, m);    // 函数调用
10     p2 = func(k, m);    // 函数调用
11     printf("%d, %d\n", p1, p2);
12     return 0;
13 }
14 
15 // 函数定义
16 int func(int a, int b) {
17     static int m = 0, i = 2;
18 
19     i += m + 1;
20     m = i + a + b;
21 
22     return m;
23 }

局部static变量只在第一次被调用时进行初始化

task3.c

 1 #include <stdio.h>
 2 long long func(int n); // 函数声明
 3 
 4 int main() {
 5     int n;
 6     long long f;
 7 
 8     while (scanf("%d", &n) != EOF) {
 9         f = func(n); // 函数调用
10         printf("n = %d, f = %lld\n", n, f);
11     }
12     return 0;
13 }
14 
15 // 函数定义
16 long long func(int n){
17     if(n==0)
18     {
19         return 0;
20     }
21     else
22     {
23         return 2*func(n-1)+1;
24     }
25 }

task4_1.c

 1 #include <stdio.h>
 2 int func1(int n, int m);
 3 int func2(int n, int m);
 4 int main() {
 5     int n, m;
 6 
 7     while(scanf("%d%d", &n, &m) != EOF)
 8         printf("n = %d, m = %d, ans = %d\n", n, m, func1(n, m));
 9     return 0;
10 }
11 
12 // 函数定义
13 int func1(int n, int m){
14     int i,result=1;
15     if(m==n || m==0)
16     {
17         return 1;
18     }
19     for(i=1;i<=m;i++)
20     {
21         result*=(n-i+1)/i;
22     }
23     return result;
24 }
25 
26 int func2(int n, int m){
27     if(m==n || m==0)
28     {
29         return 1;
30     }
31     else if(m>n)
32     {
33         return 0;
34     }
35     else
36     {
37         return func2(n-1,m)+func2(n-1,m-1);
38     }
39 }

task4_2.c

 1 #include <stdio.h>
 2 int func1(int n, int m);
 3 int func2(int n, int m);
 4 int main() {
 5     int n, m;
 6 
 7     while(scanf("%d%d", &n, &m) != EOF)
 8         printf("n = %d, m = %d, ans = %d\n", n, m, func2(n, m));
 9     return 0;
10 }
11 
12 // 函数定义
13 int func1(int n, int m){
14     int i,result=1;
15     if(m==n || m==0)
16     {
17         return 1;
18     }
19     for(i=1;i<=m;i++)
20     {
21         result*=(n-i+1)/i;
22     }
23     return result;
24 }
25 
26 int func2(int n, int m){
27     if(m==n || m==0)
28     {
29         return 1;
30     }
31     else if(m>n)
32     {
33         return 0;
34     }
35     else
36     {
37         return func2(n-1,m)+func2(n-1,m-1);
38     }
39 }

task5.c

 1 #include <stdio.h>
 2 
 3 void hanoi(unsigned int n, char from, char temp, char to, int* m);
 4 void moveplate(unsigned int n, char from, char to, int* m);
 5 int main()
 6 {
 7     unsigned int n;
 8     while (scanf_s("%u", &n) != EOF)
 9     {
10         int m = 0;
11         hanoi(n, 'A', 'B', 'C', &m);
12         printf("\n一共移动了%d次.\n\n", m);
13     }
14     return 0;
15 }
16 
17 void hanoi(unsigned int n, char from, char temp, char to, int* m)
18 {
19     if (n == 1)
20         moveplate(n, from, to, m);
21     else
22     {
23         hanoi(n - 1, from, to, temp, m);
24         moveplate(n, from, to, m);
25         hanoi(n - 1, temp, from, to, m);
26     }
27 }
28 void moveplate(unsigned int n, char from, char to, int* m)
29 {
30     printf("%u:%c --> %c\n", n, from, to);
31     ++(*m);
32 }

 

task6.c

 1 #include <stdio.h>
 2 #include <math.h>
 3 long func(long s);   // 函数声明
 4 
 5 int main() {
 6 
 7     long s, t;
 8 
 9     printf("Enter a number: ");
10     while (scanf("%ld", &s) != EOF) {
11         t = func(s); // 函数调用
12         printf("new number is: %ld\n\n", t);
13         printf("Enter a number: ");
14     }
15     return 0;
16 }
17 
18 // 函数定义
19 long func(long s){
20     int ans=0,t=1,i;
21     while((s) != 0)
22     {
23         if((s%10)%2)
24         {
25             ans+=t*(s%10);
26             t*=10;
27         }
28         s/=10;
29     }
30     return ans;
31 }

 

标签:10,return,函数,int,编程,long,C语言,char,include
From: https://www.cnblogs.com/1262438226qqcom/p/18150501

相关文章

  • C#异步编程
    既然有了多线程为什么还需要异步   异步并不意味者多线程,单线程同样可以异步异步默认借助线程池   多线程经常阻塞,二异步要求不阻塞多线程与异步的使用场景不同  多线程:       适合CPU密集型操作 适合长期运行任务线程的创建与开销较大......
  • 并发编程(ReentrantReadWriteLock)
    ReentrantReadWriteLock是一个可重入读写锁,内部提供了读锁和写锁的单独实现。其中读锁用于只读操作,可被多个线程共享;写锁用于写操作,只能互斥访问ReentrantReadWriteLock尤其适合读多写少的应用场景读多写少:在一些业务场景中,大部分只是读数据,写数据很少,如果这种场景下依然使用......
  • 深度解读《深度探索C++对象模型》之C++虚函数实现分析(一)
    接下来我将持续更新“深度解读《深度探索C++对象模型》”系列,敬请期待,欢迎关注!也可以关注公众号:iShare爱分享,自动获得推文和全部的文章列表。假如有这样的一段代码,代码中定义了一个Object类,类中有一个成员函数print,通过以下的两种调用方式调用:Objectb;Object*p=newObjec......
  • 并发编程(ReentrantLock)
    ReentrantLock是独占锁,每次只能有一个线程能获取到锁(支持重入)。其他未获取锁的线程会放入的CLH队列中,等待当前线程唤醒;主要分为公平锁和非公平锁,由内部类FairSync和NoFairSync来实现。主要的区别在于非公平锁每次都会尝试竞争,竞争不到锁才会放入到CLH队列中NonfairSync类......
  • 软件开发与创新实践——结对编程
    实验目的本次学习的任务是通过两人结对编程(一个人Coding,一个人审核)的方式,来体会团队合作的过程。本次实验由我和2230232共同完成。编程题目小学老师要每周给同学出300道四则运算练习题。–这个程序有很多种实现方式:C/C++C#/VB.net/JavaExcelUnixShellEmacs/Powershell/......
  • 软件开发与创新——结对编程
    本次结对编程作业由我和学号2252406的同学一起编写一、题目:小学老师要求出300道四则运算练习题要求:两个运算符,都是100以内的数字,答案在0-1000之间。拓展功能:有除法时计算的结果保留两位小数,避免除0错误,回答错误的题目存到“错题本.txt”文件中,方便后续查看及改正。300道题全部......
  • 第二节 函数的求导法则
    第二节函数的求导法则一、函数的和、差、积、商的求导法则定理1如果函数\(u=u(x)及v=v(x)\)都在点x具有导数,那么它们的和、差、积、商(除分母为零的点外)都在点x具有导数,且(1)\(\Large[u(x)±v(x)]'=u'(x)\pmv'(x)\);(2)\(\Large[u(x)v(x)]'=u'(x)v(x)+u(x)v'(x)......
  • day20-并发编程(下)
    1.多进程开发进程是计算机中资源分配的最小单元;一个进程中可以有多个线程,同一个进程中的线程共享资源;进程与进程之间则是相互隔离。Python中通过多进程可以利用CPU的多核优势,计算密集型操作适用于多进程。1.1进程介绍importmultiprocessingdeftask(): passif__name......
  • 异步编程模型
    本文内容异步编程提升响应能力异步方法易于编写异步方法的运行机制API异步方法显示另外6个通过使用异步编程,你可以避免性能瓶颈并增强应用程序的总体响应能力。但是,编写异步应用程序的传统技术可能比较复杂,使它们难以编写、调试和维护。C#支持简化的方法,即异步编程,它......
  • HIVE使用java生成自定义(UDF)函数,并在hive命令中使用
      创建一个maven项目(不要用springboot)  引入依赖<!--添加hive依赖--><dependency><groupId>org.apache.hive</groupId><artifactId>hive-exec</artifactId><version>3.1.1</versio......