文章目录
- 7.公式法计算pi值的python代码在mac里
- 数据可视化代码记得添加进入系列文章
- C语言和Python的数据结构学习源码要尽快整完
- Octave源码记得添加进入系列文章
前言
随着科学技术的发展、大数据时代信息的更新速度加快，掌握一项基本的编程思维能力和一定的计算机基础成为时代的趋势，因此练习编程成为普遍现象。本文收集了部分的习题及解法，希望对大家有帮助。
提示：这是一个有趣的编程引入题
引入
大家学过Python的话应该知道“天天向上的力量”这个经典的入门编程题，而这道题对博主本人也很有意义，因为这是博主上大学的第一门编程语言讲授课的讲解题目，而刚好这道题也反映出IT行业的一个时刻保持学习状态的特点，在此，博主以这道题为开头、以乔帮主的一句“Stay hungry, stay foolish”与大家共勉
# 一年365天，以第1天的能力为基数，记为1.0，当好好学习时能力值相比前一天提高1%，当没有学习时能力值相比前一天下降1%。问：每天努力和每天放任，一年下来的能力值相差多少
a = pow((1+0.01), 365)
b = pow((1-0.01), 365)
print("天天向上的力量：{:.5f}, 天天向下的力量：{:.5f}".format(a, b))
print("一年下来两者相差：%.10f" % (a-b))
print("================================================================")
# 一年365天，以第1天的能力为基数，记为1.0，当好好学习时能力值相比前一天提高1%，当没有学习时能力值相比前一天下降1%。问：每天努力和每天放任，一年下来的能力值相差多少
a = pow((1+0.01), 365)
b = pow((1-0.01), 365)
print("天天向上的力量：{:.5f}, 天天向下的力量：{:.5f}".format(a, b))
print("一年下来两者相差：%.10f" % (a-b))
print("================================================================")
# 一年365天，一周5个工作日，如果每个工作日都很努力，就可以提高1%，仅在周末放松一下，能力值下降1%，问：效果如何
dayfactor = eval(input("请输入每天努力or放纵的因子:"))
dayup = 1.00
for i in range(365):
if i % 7 in [6, 0]:
dayup = dayup * (1 - dayfactor)
else:
dayup = dayup * (1 + dayfactor)
print("向上5天向下2天后一年下累积能力值:{:.2f}".format(dayup))
print("================================================================")
# 每周工作5天，休息2天，休息日水平下降0.01，问：工作日要努力到什么程度，一年后的水平才与每天努力1%取得的效果一样呢
def dayUp(df):
dayup = 1.0
for i in range(365):
if i % 7 in [0, 6]:
dayup = dayup * (1 - 0.01)
else:
dayup = dayup * (1 + df)
return dayup
dayfactor = 0.01
while(dayUp(dayfactor) < 37.78):
dayfactor += 0.001
print("每天努力的参数是：{:.3f}".format(dayfactor))
print("================================================================")
# 天天向上续。以7天为周期，连续学习3天能力值不变，从第4天开始至第7天每天能力增长为前一天的1%。如果7天中有1天间断学习，则周期从头开始算。请编写程序回答，如果初始能力值为1，连续学习365天后能力值是多少？
dayup = 1
dayfactor = 0.01
i = 362
dayup = pow((dayup + dayfactor), i)
print("坚持365天下来的力量是:{:.3f}".format(dayup))
print("================================================================")
# 天天向上续。采用上题的能力增长模型，如果能力初始值为1，固定每10天休息1天，365天后能力值是多少？如果每15天休息1天呢？
def dayUp(days):
dayup = 1.0
dayfactor = 0.01
i = (365 % 10) - 3
dayup = pow((dayup + dayfactor), (days - 4) * 36) * pow((dayup + dayfactor), i)
return dayup
print("当 days=10 时，能力模型的力量是：{}".format(dayUp(10)))
print("当 days=15 时，能力模型的力量是：{}".format(dayUp(15)))
print("================================================================")
提示：部分习题有Python和C两种编程，但有些只有其中之一。解法不唯一，欢迎在评论区交流
题目合集
1.统计不同字符的个数
n = input("请输入一行字符:")
a = b = c = d = 0
for i in n:
if ord('a')<=ord(i)<=ord('z') or ord('A')<=ord(i)<=ord('Z'):
a = a + 1
elif ord('0') <= ord(i) <= ord('9'):
b = b + 1
elif ord(i) == ord(' '):
c = c + 1
else:
d = d + 1
print("这一行字符中字母的数量是：{},数字的数量是：{},空格数量是：{},其他字符的数量是：{}。".format(a, b, c, d))
// 按顺序读取键盘上的输入，遇到字符#时停止，并输出空格、字母e和i出现的次数。
#include<stdio.h>
int main()
{
int num_space, num_e, num_i;
char a = 0;
printf("请输入一串字符串：\n");
for(;;scanf("%c", &a))
{
if(a == 35)
break;
else if(a == 32)
num_space++;
else if(a == 101)
num_e++;
else if(a == 105)
num_i++;
}
printf("空格、字母e和i出现的次数分别为：%d, %d, %d\n", num_space, num_e,num_i);
return 0;
}
2.求两个整数的最大公约数，最小公倍数
# Python:
def get_greatest_common_divisor_V2(a,b):
big=max(a,b)
small=min(a,b)
if big%small==0:
return small
return get_greatest_common_divisor_V2(big%small,small)
i = get_greatest_common_divisor_V2(4, 10)
print("两数的最大公约数是：{}".format(i))
print("两数的最小公倍数是：{}".format(4 * 10 / i))
C_code:
#include <stdio.h>
int main()
{
int a,b,c,e,f,g;
printf("请输入两个正数:");
scanf("%d%d",&a,&b);
e=a;
f=b;
c=a%b;
while(c!=0)
{
a=b;
b=c;
c=a%b;
}
g=e*f/b;
printf("最大公约数是 %d\n最小公倍数是 %d\n",b,g);
return 0;
}
3.逆序输出
# Python:
#递归实现字符串翻转
import sys
sys.setrecursionlimit(2000)
def reverse(s):
if s == '':
return s
else:
return reverse(s[1:]) + s[0]
aa = input("请输入一个字符串：")
print(reverse(aa))
# Python:
# 最小最大数分别放置首尾
data = list(map(eval,input("请输入一组数据，各数之间用英文中的逗号分隔:").split(",")))
print(data)
min_L = data.index(min(data)) #找到最小数据的索引序号
if min_L != 0:
data[0], data[min_L] = data[min_L], data[0]
max_L = data.index(max(data))
if max_L != len(data)-1:
data.append(data.pop(max_L)) #先踢出最大值，再将它追加到序列末尾
print(data)
C_code:
/* 反序输出三位数 */
#include<stdio.h>
int main()
{
int i;
printf("请输入一个三位数：");
scanf("%d", &i);
printf("您所输入的三位数的反序是：\n");
while(i)
{
printf("%d", i%10);
i /= 10;
}
return 0;
}
/* 通过字符指针的传递，执行被调函数，将主函数中字符串的字符逆序存放 */
#include<stdio.h>
int main()
{
char str[20];
void sub(char*, int);
gets(str);
sub(str, strlen(str));
puts(str);
return 0;
}
void sub(char*p1, int n)
{
char *p2=p1+n-1, temp;
while(p1<p2)
{
temp=*p1;
*p1++=*p2;
*p2--=temp;
}
}
4.进制转换(以十进制转其他进制为例)
# Python:
# 十进制转二进制
print("(Into binary)Please type an integer:")
a = int(input())
print(bin(a))
# 十进制转八进制
print("(Into octal)Please type an integer:")
b = int(input())
print(oct(b))
# 十进制转十六进制
print("(Into hexadecimal)Please type an integrate:")
c = int(input())
print(hex(c))
// C:
#include<stdio.h>
void convert(int x, int y)
{
if(x > 0)
{
convert(x/y, y);
if(y!=16)
printf("%d", x % y);
else
printf("%x", x % y); // 以十六进制输出
}
}
int main()
{
int x, y;//输入要转换的数值和转化进制数
printf("请输入要转换的十进制整数： ");
scanf("%d", &x);
printf("请输入要转换的进制： ");
scanf("%d", &y);
convert(x,y);
return 0;
}
5.输出三位数中的水仙花数
题目描述：水仙花数是指一个n位数 (n≥3)，它的每个位上的数字的n次幂之和等于它本身。例如：153是一个“水仙花数”，因为 153 是个 3位数，而13+53+3**3==153。要求输出三位数中的所有水仙花数
for i in range(100,1000):
a = i // 100 #百位数
b = i // 10 % 10
c = i % 10
if a**3 + b**3 + c**3 == i:
print(i)
#include<stdio.h>
#include<math.h>
int main()
{
int i,sum;
printf("水仙花数有：");
for(i=100;i<1000;i++)
{
sum=(i/100)*(i/100)*(i/100)+(i%100/10)*(i%100/10)*(i%100/10)+(i%100%10)*(i%100%10)*(i%100%10);
if(i==sum)
{
printf("%d\n",sum);
}
}
return 0;
}
6.素数
# 函数调用判断素数
def prime(x):
t=True
for i in range(2,x):
if x % i == 0:
t = False
break
return t
for x in range(200, 1001):
if prime(x):
print(x, end=' ')
7.回文数判断
题目描述:
回文数判断。设n是一任意自然数，如果n的各位数字反向排列所得自然数与n相同，则n被称为回文数。从键盘上输入一个5位数字，请编写程序这个数是不是回文数
# 1、字符串判断
x = input("请输入一个整数：")
if x==x[::-1]:
print("是回文数。")
else:
print("不是回文数。")
# 2、颠倒数据后判断
x = int(input("请输入一个整数："))
if x < 0 or (x % 10 == 0 and x != 0):
print("不是回文数。")
elif not x // 10:
print("是回文数。")
else:
hou = 0
while (x > hou):
hou = hou * 10 + x % 10
x //= 10
if x == hou or x == (hou // 10):
print("是回文数。")
else:
print("不是回文数。")
8.闰年判断
//输入某年某月某日，判断这一天是这一年的第几天？
#include<stdio.h>
//判断闰年函数
int isLeapYear(int year)
{
//闰年，能被4整除但不能被100整除，或能被400整除
if((year%4==0 && year%100!=0) || year%400==0)
{
return 1;
}
return 0;
}
//计算某年某月某日是第几天
int calculateDays(int year,int month,int day)
{
int i; //循环变量
int days=0; //存放总天数
//存放平年每个月的天数，有效下标从1开始
int days_of_month[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
for(i=1;i<month;i++)
{
days=days+days_of_month[i];//计算包含全部月份的天数
}
days=days+day; //加上不全月份的天数
//如果是闰年且包含全部2月份
if(isLeapYear(year) && month>=3)
{
days=days+1; //天数+1，因为2月份多一天
}
return days;
}
int main()
{
int year,month,day;
printf("请依次输入年，月，日，用空格隔开:\n");
scanf("%d %d %d",&year,&month,&day);
printf("这一天是这一年的第%d天",calculateDays(year,month,day));
return 0;
}
9.公式法计算 π 值
sum = 0
i = 1
t = 1 #第i项
while abs(t) > 1e-6:
t = (-1)**(i+1)/(2*i-1) #(-1)**(i+1),第i项的符号(分子)
sum += t
i += 1
print("{0:.5f}".format(4*sum))
print('%.5f' % (4*sum))
from random import random
from math import sqrt
from time import perf_counter
DARTS = 1000
hits = 0.0
start = perf_counter()
for i in range(1, DARTS+1):
x, y = random(), random()
dist = sqrt(x ** 2 + y ** 2)
if dist <= 1.0:
hits = hits + 1
pi = 4 * (hits / DARTS)
end = perf_counter()
print("pi的值是:{:.2f}".format(pi))
print("运行时间是：{:.5f}s".format(end - start))
//公式法求pi的近似值
#include<stdio.h>
#include<math.h>
int main()
{
int i=0;
int n=1;
double sum=1.0, pi=0.0, sign=1;
while(fabs(sum) >= 1e-6)
{
pi+=sum;
n+=2;
sign=-sign;
sum=sign/n;
i++;
}
pi=pi*4;
printf("pi的值是：%10.8f", pi);
return 0;
}
10.求一元二次方的根（c语言）
//求一元二次方程的根，并考虑 判别式大于0、等于0、小于0的情况
#include<stdio.h>
#include<math.h>
int main()
{
double a, b, c, x1, x2, d,x3 ,x0;
printf("输入方程的三个系数:");
scanf_s("%lf %lf %lf", &a, &b, &c);
if (a != 0)
{
d = sqrt(b * b - 4 * a * c);
if (d == 0)
{
x0 = (-b) / (2 * a);
printf("%.2lf\n", x0);
}
else if(d>0)
{
x1 = (-b + d) / (2 * a);
x2 = (-b - d) / (2 * a);
printf("%.2lf %.2lf\n", x1, x2);
}
else
printf("x无解");
}
else
{
x3 = -c / b;
printf("%.2lf\n", x3);
}
return 0;
}
11.求某分数数列前20项之和 （C语言）
#include <stdio.h>
#include <stdlib.h>
int main()
{
double a,b,temp; //a为分母，b为分子，temp保存前一项的分子
double sum=0;
int i;
a=2;
b=1;
for(i=0;i<20;i++)
{
sum+=a/b;
temp=a; //先保存前一项的分子
a+=b; //修改分子
b=temp; //修改分母（等于前一项分子)
}
printf("Sum is %6.4lf\n",sum);
return 0;
}
12.累加、阶乘计算
递归实现
# 定义一个函数 sum_numbers
# 能够接收一个 num 的整数参数
# 计算1 + 2 + 3 ...... + num的结果
def sum_numbers(num):
if num == 1:
return 1
temp = sum_numbers(num - 1)
return num + temp
result = sum_numbers(1)
print(result)
//定义函数运用递归计算n的阶乘
#include<stdio.h>
int main()
{
int fun(int);
int n;
printf("请输入数值：");
scanf("%d", &n);
if(n<0)
printf("输入错误！请重新输入");
else
printf("%d! = %d", n, fun(n));
return 0;
}
int fun(int n)
{
if(n<=1)
return 1;
else
return n*fun(n-1);
}
一般算法
// 用循环求1!+2!+3!+…+10!
#include<stdio.h>
#include<math.h>
int main()
{
int i;
int j;
int sum=0;
for(i=1;i<=10;i++)
{
j*=i;
sum+=j;
}
printf("1!+2!+3!+…+10!的和为：%d", sum);
return 0;
}
// 调用静态局部变量，计算5以内各数的阶乘
#include<stdio.h>
int main()
{
int fact(int);
int i;
for(i=1;i<6;i++)
printf("%d! = %d\n", i, fact(i));
return 0;
}
int fact(int n)
{
static int f=1;
f=f*n;
return f;
}
13.输出数字对自由组合（C语言）
//输出所有由数字“1”“2”“3”组成的三位数
#include<stdio.h>
int main()
{
int i, j, k;
printf("由数字1、2、3组成的三位数是：\n");
for(i = 1;i <= 3;i++)
{
j = 1;
while(j <= 3)
{
k = 1;
do
{
if(i != k && i != j && j != k)
{
printf("%d%d%d ", i, j, k);
}
k++;
}while(k <= 3);
j++;
}
}
return 0;
}
补充：Python随机选取某序列中的元素
import random
veg=['apple','pear','peach','orange','fish','苹果']
print(random.choice(veg))
14.斐波那楔数列前n项和
"""列表输出斐波那楔数列"""
f = [1, 1]
sum = 2
n = eval(input("请输入项数n: "))
for i in range(2, n+1):
f.append(f[i-1] + f[i-2])
sum += f[i-1] + f[i-2]
print("%d项的斐波那楔数列为:" % (n+1), f)
print("\n该数列的前%d项和为: %d" % (n+1, sum))
//求斐波那楔数列前n项和
//输入n，输入前n项，以及前n项和//
#include <stdio.h>
int main()
{
int n, i, t;
int sum = 0, flag = 2; //flag为换行标记
int a1 = 1, a2 = 1; //前两项先列出来
printf("请输入所需要的项数：");
scanf("%d", &n);
printf("%d %d ", a1, a2);
for (i = 3; i <= n; i++) //从第三项开始
{
t = a1 + a2;
printf("%d ", t);
sum = sum + t;
a1 = a2; //注意这里的写法，赋值，产生新的a1、a2
a2 = t;
flag++;
if (flag % 5 == 0) //原本想每5个输出一行，但是我之前先输出了a1、a2
printf("\n"); //导致第一行有7个，并不能完成每5行输出的任务
//放在这里让大家解决，感觉会麻烦一点
}
printf("\n\n前%d项和为:%d\n", n, sum+2); //注意这里的sum需要加上初值的2
return 0;
}
15.数组/列表、元组、字典的创建及操作
Python代码：
提示：此仅包括一维和二维，DL中涉及三维到四维的张量，详见Jupyter
(1)列表
①一维数组的基本操作
#列表可定义不同类型的数据，并且索引值是从0开始计数
name_list =['hello python','larissa','Alex',520,True]
#1取值与取索引
print(name_list[2])
print(name_list.index(520))
#2修改 or 替换 列表中的数据
"""
name_list[0] = "hello world"
print(name_list)
"""
#3增加
"""append 是在列表最后增添数据
insert 是在列表的指定位置插入数据
extend 用于在某一列表后拼接另一列表"""
"""name_list.append('1')
print(name_list)
print(len(name_list))
name_list.insert(2,'1')
print(name_list)
print(len(name_list))
another_list = ['1','2','3']
name_list.extend(another_list)
print(name_list)"""
#4删除
"""remove 可删除列表中指定数据
pop 在不传递数据的索引之前默认删除列表最后一个数据，在传递索引值后可删除索引值对应的数据
clear 可以清空列表的所有数据
del关键字本质上是将一个变量从内存中删除"""
"""name_list.remove(520)
print(name_list)
name_list.pop(2)
print(name_list)
name_list.clear()
print(name_list)
str = "nihao"
del str
print(str)"""
#5统计
"""len可统计列表中元素的个数
count可统计某一数据出现的次数"""
"""print(len(name_list))
name_list.append(520)
print(name_list.count(520))"""
#6排序
"""sort()升序
sort(reverse=True)降序
reverse()逆序/反序"""
str_list = ["wangwu","lisi","zhangsan"]
num_list = [1,3,9,5]
"""str_list.sort()
num_list.sort(reverse=True)
num_list.reverse()
print(num_list)"""
②二维数组的创建及基本操作
"""创建二维数组"""
#1.一维复制法
a = [[]] * 3
a[0].append(1)
a[1].append(2)
a[2].append(3)
print(id(a[0]))
print(id(a[1]))
print(a)
b = [[] for i in range(3)]
b[0].append(1)
b[1].append(2)
b[2].append(3)
print(id(b[0]))
print(id(b[1]))
print(b)
#2.直接创建法
a1 = [[1, 2, 3], [1, 2, 3], [1, 2, 3]]
print(a1)
#3.numpy库调用
import numpy as np
a2 = np.zeros((3, 3))
print(a2)
# 列表推导式：
# # [表达式 for 变量 in 列表]
# # [out_exp_res for out_exp in input_list]
names = ["Alex", "Bob", "Clara", "Davie", "Eve"]
new = [name.upper() for name in names if len(names) > 3]
print(new)
# #0-100 中可以被2整除的数作为一个列表
num = [i for i in range(100) if i % 2 == 0]
print(num)
# 遍历列表
s2 = ['name', 'num', 'score']
s3 = ['Alex', 1001, 91.5]
for index, val in enumerate(s2):
print(index, '(index)', val, '(value)')
for i, j in zip(s2, s3):
print(i, '->', j)
(2)元组
①基本操作
#元组不可修改
info_tuple = ("zhangsan",54,"wangwu","wangwu")
print(type(info_tuple))
#01取值与取索引
print(info_tuple[1])
print(info_tuple.index("zhangsan"))
#02计算某个数据出现的次数
print(info_tuple.count("wangwu"))
②拓展操作
# 元组只包含一个元素时，需要在元素后面添加一个逗号，否则括号会被当做运算符使用
tup1 = (1)
print(tup1)
print(type(tup1))
tup2 = (1,)
print(tup2)
print(type(tup2))
(3)字典
①基本操作
#键（key）是索引，必须是字符串、数字、元组，且唯一；值（value）是数据，不一定唯一。字典无序
info_dict = {"name":"张三",
"age":18,
"gender":"boy"}
#01取值
print(info_dict["name"])
#02增加 and 修改
info_dict["height"] = 1.75
"""当键（key）在字典中不存在时，会增加键值对"""
info_dict["name"] = "李四"
"""当键（key）在字典中存在时，会修改原来的值"""
#03删除
info_dict.pop("gender")
#04统计键值对的数量
print(len(info_dict))
#05合并字典
"""注意，当被合并的字典中出现原已存在的键值对时，会覆盖原来的值"""
temp_dict = {"age":20,
"country":"China"}
info_dict.update(temp_dict)
#06清空字典
info_dict.clear()
print(info_dict)
②拓展操作
# 遍历字典
s1 = {'name':'Alex', 'num':1001, 'score':91.5}
for k,v in s1.items():
print(k, '->', v)
(4)集合
#创建一个集合可以使用 {} 和 函数set([, 1 argument])，集合是一个无序且不重复的组成（即集合具有去重复的作用）
x = {'as', 'ee', 1}
y = set('orange')
print(type(x), type(y))
print(y)
C语言：
(1)输入与输出
//利用指针法实现对数组元素的输入和输出
#include<stdio.h>
//使用指针引用一维数组
//int main()
//{
// int a[5], *p=a, i;
// printf("请输入五维行向量：\n");
// for(i=0;i<5;i++)
// scanf("%d", &a[i]);
// printf("输出向量：\n");
// for(i=0;i<5;i++)
// printf("%d ", *(p++));
//
// return 0;
//}
//使用指针引用二维数组
int main()
{
int a[3][4]={11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22}, i, j;
int *p=a;
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
printf("%d ", *(p+i*4+j)); //(p+i*4+j)表示第i行第j列的元素地址
printf("\n");
}
return 0;
}
// a --二维数组名，首元素地址，第0行地址
// a[0], *(a+0), &a --第0行0列元素a[0][0]的地址
// a+1, &a[1] --第1行的地址
// a[1], *(a+1) --第1行0列元素a[1][0]的地址
// a[1]+2, *(a+1)+2， &a[1][2] --第1行2列元素a[1][2]的地址
// *(a[1]+2), *(*(a+1)+2)，a[1][2] --第1行2列元素a[1][2]的值
(2)二维数组转置:
#include<stdio.h>
int main()
{
void sub(int b[][3]);
int a[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
int i, j;
printf("转置前的数组为：\n");
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
printf("%d ", a[i][j]);
printf("\n");
}
sub(a);
printf("转置后的数组为：\n");
for(i=0;i<3;i++)
{
for(j=0;j<3;j++)
printf("%d ", a[i][j]);
printf("\n");
}
return 0;
}
void sub(int b[][3])
{
int i, j, t;
for(i=0;i<3;i++)
for(j=0;j<i;j++)
{
t=b[i][j];
b[i][j]=b[j][i];
b[j][i]=t;
}
}
(3)二维数组找最小数
//现有int整型数组 a[3][4]={{12, 21, 34, 32}, {28, 10, 17, 43}, {19, 54, 38, 27}}，找出数组中数值最小的元素
#include<stdio.h>
int main()
{
int i, j, c, b;
int a[3][4]={{12, 21, 34, 32}, {28, 10, 17, 43}, {19, 54, 38, 27}};
int min=a[0][0];
for(i=0;i<3;i++)
{
for(j=0;j<4;j++)
{
if (a[i][j]<min)
{
min=a[i][j];
c=i;
b=j;
}
}
}
printf("数组中最小的元素是%d行%d列的%d\n", c+1, b+1, a[c][b]);
return 0;
}
(4)二维数组找鞍点：
/*找出二维数组的鞍点，及其值为所在行中最大、所在列中最小的元素
注：一个二维数组中也可能没有鞍点*/
#include<stdio.h>
int main()
{
int a[3][4];
int i, j, k, maxj, max;
int sum;
printf("请输入一个3x4矩阵（数字间用空格隔开）:");
for(i=0;i<3;i++)
for(j=0;j<4;j++)
scanf("%d", &a[i][j]);
for(i=0;i<3;i++)
{
max = a[i][0];
maxj = 0;
for(j=0;j<4;j++)
if(a[i][j]>max)
{
max = a[i][j];
maxj = j;
}
for(k=0;k<3;k++)
if(max>a[k][maxj])
break;
if(k>=3)
{
printf("该二维数组的鞍点为：a[%d][%d]=%d", i, maxj, max);
break;
}
}
if(i>=3)
printf("该二维数组没有鞍点。");
return 0;
}
(5)二维数组相乘
//求二维矩阵相乘的值
#include<stdio.h>
int main()
{
int a[2][3], b[3][2], c[2][2];
int i, j, k;
printf("请输入一个2x3矩阵a：\n");
for(i=0;i<2;i++)
{
for(j=0;j<3;j++)
scanf("%d", &a[i][j]);
}
printf("请输入一个3x2矩阵b：\n");
for(i=0;i<3;i++)
{
for(j=0;j<2;j++)
scanf("%d", &b[i][j]);
}
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
{
c[i][j]=0;
for(k=0;k<3;k++)
c[i][j]+=a[i][k]*b[k][j];
}
}
printf("矩阵a和矩阵b相乘的结果是：\n"); //矩阵c的值
for(i=0;i<2;i++)
{
for(j=0;j<2;j++)
printf("%d ", c[i][j]);
printf("\n");
}
return 0;
}
16.额外补充
Python
(1)指定缺省参数的默认值
def print_info(name, title, gender=True):
"""
:param title: 职位
:param name: 班上同学的姓名
:param gender: True 是男生，False 是女生
"""
gender_text = "男生"
if not gender:
gender_text = "女生"
print("[%s]%s 是 %s" % (title, name, gender_text))
print_info("小明","班长",)
print_info("猪妹","科代表",False)
(2)多值参数求和
def sum_num(*args):
num = 0
print(args)
for n in args:
num += n
return num
result = sum_num(1,2,3,4,5)
print(result)
(3)多值参数_字典与元组的拆包
def demo(*args, **kwargs):
print(args)
print(kwargs)
gl_tuple = (1,2,3,4)
gl_dict = {"name":"小明"}
#使用拆包语法时
demo(*gl_tuple, **gl_dict)
#不使用拆包语法时
demo(1,2,3,4, name = "小明")
(4)使用不定长参数
# 使用不定长参数，其中，*表示元组，** 表示定义参数为字典
def printme(*arg, **args):
print(arg)
print(args)
printme(1,2, a=2, b=3)
(5)时间函数
f = lambda x, y : x + y
f(1, 3)
def vfunc(a, *b):
print(type(b))
for i in b:
a += i
return a
vfunc(1, 2, 3, 4, 5)
from datetime import *
today = datetime.utcnow()
today
(6)文本进度条更新
import time
scale = 10
print("----执行开始----")
for i in range(scale + 1):
a, b = "**" * i, "··" * (scale - i)
c = (i / scale) * 100
print("%{:^3.0f}[{}->{}]".format(c, a, b))
time.sleep(0.3)
print("----执行结束----")
#单行更新文本进度条
import time
scale = 50
print("执行开始".center(scale // 2, '-'))
t = time.perf_counter()
for i in range(scale + 1):
a = '*' * i
b = '·' * (scale - i)
c = (i / scale) * 100
print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c, a, b, t), end=' ')
time.sleep(0.05)
print("\n" + "执行结束".center(scale // 2, '-'))
(7)try检测
try:
alp = "huadudadhjhagdhbx"
index = eval(input("请输入一个整数："))
print(alp[index])
except NameError:
print("输入错误，请重新输入")
except IndexError:
print("索引值超出范围，请重新输入")
else:
print("没有发生异常")
finally:
print("程序执行完毕")
(8)CSV文件的读写
fo = open("/Users/mac/Desktop/picture2016.csv", "r")
ls = []
for line in fo:
line = line.replace("\n", "")
ls.append(line.split(","))
print(ls)
fo.close()
(9)田字格的输出
#田字格的输出
n = eval(input("请输入一个奇数："))
a = "— "
b = "┼"
c = "|"
d = " "
m = n // 2
for i in range(n):
if i in [0,m,n-1]:
print("{0}{1}{0}{1}{0}".format(b, a*(m-1)))
else:
print("{0}{1}{0}{1}{0}".format(c, d*2*(m-1)))
C语言
自定义数据类型
（1）变量类型(按作用域划分)
#include<stdio.h>
int z; //全局变量，静态存储区
int main()
{
int sub();
int i; //局部变量
for(i=0;i<3;i++)
sub();
return 0;
}
int sub()
{
int x=0; //自动变量，动态存储区，可用关键字auto声明
static int y; //静态局部变量，静态存储区，在程序执行过程中占据固定的存储单元，直到程序执行完毕才被释放
++x;
++y;
++z;
printf("x=%d, y=%d, z=%d\n", x, y, z);
}
（2）结构体
详见数据结构学习代码
#include<stdio.h>
int main()
{
float sum;
struct Student
{
char num[5];
char name[20];
char sex;
int age;
float score;
};
struct Student stu1 = {"1001", "lin", 'M', 19, 94.5}, stu2;
stu2 = stu1;
stu2.age = 20;
stu2.score = 88;
printf("请输入第二个学生的学号：\n");
scanf("%s", stu2.num);
printf("请输入第二个学生的姓名：\n");
scanf("%s", stu2.name);
sum = stu1.score + stu2.score;
printf("\nnum name sex age score \n");
printf("%s %s %c %d %.1f\n",
stu1.num, stu1.name, stu1.sex, stu1.age, stu1.score);
printf("\nnum name sex age score \n");
printf("%s %s %c %d %.1f\n",
stu2.num, stu2.name, stu2.sex, stu2.age, stu2.score);
printf("\n总分为：%.1f\n", sum);
return 0;
}
（3）共用体
//定义并初始化结构体数组 boy[5]，用于表示5个学生实体。输出5名学生的各项属性，计算总成绩、平均分和不及格人数,并显示不及格学生人数
#include<stdio.h>
int main()
{
struct Stu
{
int num;
char name[20];
char sex;
float score;
}boy[]={
{1, "李海", 'M', 94.5},
{2, "李好", 'M', 89.7},
{3, "李勉", 'M', 87.0},
{4, "李茶", 'M', 56.3},
{5, "李莎", 'M', 55.1},
};
int i, c=0;
float ave, sum=0;
printf("num name sex score\n");
for(i=0;i<5;i++)
printf("%-9d%-16s%-7c%.1f\n",
boy[i].num, boy[i].name, boy[i].sex, boy[i].score);
for(i=0;i<5;i++)
{
sum+=boy[i].score;
if(boy[i].score<60)
{
c+=1;
printf("不及格学生：%s\n", boy[i].name);
}
}
ave = sum/5;
printf("总成绩为：%.1f\n", sum);
printf("平均分为：%.2f\n", ave);
printf("不及格学生人数为：%d\n", c);
return 0;
}
（4）枚举变量
//定义枚举变量表示信号灯，并根据变量的不同取值，显示相应信息
#include<stdio.h>
int main()
{
enum lights
{
red,
yellow,
green
}lamp;
for(lamp=red;lamp<=green;lamp++)
switch(lamp)
{
case 0: printf("红灯禁停\n");break;
case 1: printf("黄灯慢行\n");break;
case 2: printf("绿灯通行\n");break;
default:break;
}
return 0;
}
Python面向对象
（1）类的声明
①常规方法
class Dog():#类的声明
def move(self):
print("提示：你的小可爱正在前往......")
def attack(self):
print("提示：你的小可爱会咬人......")
def info(self): #实例方法，定义该类的特征信息函数
print(self) #打印对象的储存地址
print("%s 的生命力是：%d" % (self.name, self.hp, self))
print("%s 的攻击力是：%d" % (self.name, self.atk))
jinmao = Dog() #声明符合该类特征的某一对象，记住此语句一定要放在所有具体定义的属性语句前，否则会报错
hashiqi = Dog()
#赋予具体属性
jinmao.name = "小二"
jinmao.hp = 450
jinmao.atk = 250
hashiqi.name = "五筒"
hashiqi.hp = 550
hashiqi.atk = 350
jinmao.move()
jinmao.attack()
jinmao.info()
hashiqi.info()
# print("%s 的生命力是：%d" % (jinmao.name, jinmao.hp))
# print("%s 的攻击力是：%d" % (jinmao.name, jinmao.atk))
②魔法方法
class Dog():
def move():
print("提示：你的小可爱活泼好动......")
def attack():
print("提示：你的小可爱会咬人......")
def __init__(self, name, hp, atck, armor): #魔法函数，可将用户逐步定义的步骤自动归类到一个函数内，则用户只需传入实参即可定义对象属性
self.name = name
self.hp = hp
self.atck = atck
self.armor = armor
def info(self):
print("%s 的生命力：%d" % (self.name, self.hp))
print("%s 的攻击力：%d" % (self.name, self.atck))
print("%s 的护甲值：%d" % (self.name, self.armor))
def __str__(self):
return self.name #在打印对象时，即print(self)，返回的是某个字符串而不是对象存储地址
jinmao = Dog("小暖", 2000, 450, 400)
hashiqi = Dog("小二货", 3000, 350, 300)
Dog.move()
Dog.attack()
jinmao.info()
hashiqi.info()
print(jinmao)
print(hashiqi)
print(id(jinmao.name))
print(id(hashiqi.name))
（2）类的继承
# 父类
class Dog():
def __init__(self):
self.name = "Dog dad"
def skill(self):
print("bite people")
class Dog2():
def __init__(self):
self.name = "Dog mom"
def skill(self):
print("bite dog")
def skill2(self):
print("wag tail")
# 子类
class Son(Dog2, Dog): # 在多类继承时，若有重复和不同的属性，则优先继承第一个类别
def __init__(self): # 在内部修改具体属性
self.name = "Dog son"
def skill(self):
print("lick people")
# def dad_skill(self): # 第一种方法：在子类中通过调用父类的函数名来实现对父类属性的调用
# Dog.__init__(self)
# Dog.skill(self)
def dad_skill(self):
super().skill()
def mom_skill(self):
super().skill2()
jinmao = Son()
print(jinmao.name)
jinmao.skill()
jinmao.dad_skill()
jinmao.mom_skill()
# jinmao.skill2
（3）类的多态
class Dog():
def __init__(self):
self.name = "Dog dad"
def skill(self):
print("Bite people")
class son1():
def skill(self):
print("Bite man")
class son2():
def skill(self):
print("Bite woman")
class son3():
def skill(self):
print("Bite child")
son1 = son1()
son2 = son2()
son3 = son3()
son1.skill()
son2.skill()
son3.skill()
(4)迭代器和生成器
# 创建迭代器用 iter()，取其索引可用 next()，迭代器可记住其每一次遍历的位置
names = ["Alex", "Bob", "Clara", "Davie", "Eve"]
it = iter(names)
print(next(it))
print(next(it))
print(next(it))
# 生成器及 函数yield和函数return间的区别
#yield是暂停函数，return是结束函数； 即yield返回值后继续执行函数体内代码，return返回值后不再执行函数体内代码；
#yield返回的是一个迭代器（yield本身是生成器-生成器是用来生成迭代器的）；return返回的是正常可迭代对象（list,set,dict等具有实际内存地址的存储对象）
def gen_num(data):
if data > 10:
for i in range(data):
yield i
else:
return data
g1 = gen_num(5)
for num in g1:
print(num)
print("传入参数5，返回类型：", type(gen_num(5)))
g2 = gen_num(12)
for num in g2:
print(num)
print("传入参数12，返回类型：", type(gen_num(12)))
C语言结构化过渡到面向对象
详见C语言版数据结构源码
777
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
