-
编程实现从键盘输入一串字符串和一个字符，统计该字符串中指定字符出现的个数
2019-04-06 14:42:46/*编程实现从键盘输入一串字符串和一个字符，统计该字符串中指定字符出现的个数*/ #include<stdio.h> #include<string.h> main() { char str[100],c; int i=0,count=0; printf("请输入一个字符串：");...展开全文/*编程实现从键盘输入一串字符串和一个字符，统计该字符串中指定字符出现的个数*/ #include<stdio.h> #include<string.h> main() { char str[100],c; int i=0,count=0; printf("请输入一个字符串："); gets(str); printf("请输入指定的查找字符："); scanf("%c",&c); while(str[i]) /*该循环扫描/遍历字符数组*/ { if(str[i]==c) count++; i++; } printf("%d\n",count); }
-
算法训练 - 统计字符次数 输入一个字符串(长度在100以内)，统计其中数字字符出现的次数。
2020-10-06 20:27:34输入一个字符串(长度在100以内)，统计其中数字字符出现的次数。 例子 样例输入 Ab100cd200 样例输出 6 提示 请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。 所有代码放在同一个源文件中，...展开全文问题描述
输入一个字符串(长度在100以内)，统计其中数字字符出现的次数。
例子样例输入
Ab100cd200
样例输出
6
提示请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意: main函数需要返回0
注意: 只使用ANSI C/ANSI C++ 标准，不要调用依赖于编译环境或操作系统的特殊函数。
注意: 所有依赖的函数必须明确地在源文件中 #include ， 不能通过工程设置而省略常用头文件。
提交时，注意选择所期望的编译器类型。思路
只需要简单的判断条件即可。字符0-9在ASCII码中对应的为十进制数字48-57，因此设置条件判断即可。
#include <stdio.h> #include <string.h> int main() { char a[100]; gets(a); int num = 0; int i; for(i=0;i<strlen(a);i++) { if((int)a[i]>=48 && (int)a[i]<=57) num++; } printf("%d",num); return 0; }
-
嵩天老师-Python语言程序设计-Python123配套练习测验题目汇总整理
2019-08-03 15:36:08测验1：Python基本语法元素 知识点概要： 普遍认为Python语言诞生于1991年 ...字符串的正向递增和反向递减序号体系：正向是从左到右，0到n-1，反向是从右到左，-1到-n，举例str = "csdn" # str[0]就表示字符串c...展开全文测验1：Python基本语法元素
知识点概要：
- 普遍认为Python语言诞生于1991年
- Python语言中的缩进在程序中长度统一且强制使用，只要统一即可，不一定是4个空格（尽管这是惯例）
- IPO模型指：Input Process Output
- 字符串的正向递增和反向递减序号体系：正向是从左到右，0到n-1，反向是从右到左，-1到-n，举例
str = "csdn" #str[0]就表示字符串c, str[-1]表示"n"- Python的合法命名规则：命名包含字母，数字，下划线，但是首字符不能是数字
- Python中获得用户输入的方式为：input()
- Python中的保留字：type不是，是内置函数，def elif import 都是保留字
- Python的数据类型有整数、列表、字符串等，但是不包括实数，实数是数学概念，在Python中对应着浮点数
- 保留字if-elif-else用于表示分支结构，in用来进行成员判断
- print()格式化输出，控制浮点数的小数点后两位输出应为：print("{:.2f}".format(XX)) :.2f哪一个都不能少
编程测试：
- Hello World 的条件输出：获得用户输入的一个整数，参考该整数值，打印输出"Hello World"，要求：
如果输入值是0，直接输出"Hello World"
如果输入值大于0，以两个字符一行方式输出"Hello World"（空格也是字符）
如果输入值小于0，以垂直方式输出"Hello World"
# eval()函数可以将默认输入的字符串去掉双引号并进行表达式运算，如输入500+20，默认 #得到的输入为一个字符串“500+20”，但是使用eval()函数我们得到的是一个整型数字：520 Number = eval(input()) if Number == 0: print("Hello World") elif Number > 0: print("He\nll\no \nWo\nrl\nd") else: for c in "Hello World": print(c)- 数值运算：获得用户输入的一个字符串，格式如下：M OP N ，其中，M和N是任何数字，OP代表一种操作，表示为如下四种：+, -, *, /（加减乘除）根据OP，输出M OP N的运算结果，统一保存小数点后2位。
注意：M和OP、OP和N之间可以存在多个空格，不考虑输入错误情况。
print("{:.2f}".format(eval(input())))测验2：Python基本图形绘制
知识点概要：
- 正确引用turtle库的方式：
import turtle #t是别名,可以更换其他名称 import turtle as t from turtle import setup from turtle import *import setup from turtle是不正确的- turtle库是一个直观有趣的图形绘制函数库，最早成功应用于LOGO编程语言，turtle绘图体系以水平右侧为绝对方位的0度，turtle坐标系的原点****默认在屏幕正中间
turtle.circle(-90,90)表示绘制一个半径为90像素的弧形，圆心在小海龟当前行进的右侧
# circle(x,y)表示以x长度为半径，y为角度， #当前方向左侧x处为圆心画圆，其中x,y都可以是负数，相应取反 #当前方向是水平向右的，对应直角坐标系中的x轴正方向 #x为正，则圆心在y轴正方向上，y为正，逆时针画圆，圆弧角度为y #x为负则相反，圆心在y轴负方向上，y为正，顺时针画圆，圆弧角度为y- turtle.seth(to_angle)函数的作用是设置小海龟当前行进方向为to_angle，to_angle是角度的整数值
- turtle.fd(distance)函数的作用是向小海龟当前行进方向前进distance距离
- turtle.pensize(size)函数的作用是改变画笔的宽度为size像素
- turtle**.circle**()函数不能绘制椭圆形
- turtle.circle(x,y)函数绘制半圆，第二个参数y是180的奇数倍
- turtle.penup()的别名有turtle.pu(),turtle.up()
- turtle.colormode()的作用是设置画笔RGB颜色的表示模式
- turtle.width()和turtle.pensize()都可以用来设置画笔尺寸
- turtle.pendown()只是放下画笔，并不绘制任何内容
- 改变turtle画笔的运行方向有left()、right()和seth()函数，bk()只能后退，但是不改变方向
- turtle.done()用来停止画笔绘制，但绘图窗体不关闭，建议在每个turtle绘图最后增加turtle.done()
- 循环相关保留字是：for…in和while，def用于定义函数
编程测试：
- turtle八边形绘制：使用turtle库，绘制一个八边形
import turtle as t t.pensize(2) for i in range(8): t.fd(100) t.left(45)- turtle八角图形绘制：使用turtle库，绘制一个八角图形
import turtle as t t.pensize(2) for i in range(8): t.fd(150) t.left(135)测验3：基本数据类型
知识点概要：
- pow(x,0.5)能够计算x的平方根，计算负数的平方根将产生复数
- 字符串.strip()方法的功能是去掉字符串两侧指定的字符
- 字符串.split()方法的功能是按照指定字符分隔字符串为数组
- 字符串.repalce()方法的功能是替换字符串中特定字符
- +操作符用来连接两个字符串序列
- 字符串是一个连续的字符序列，使用\n可以实现打印字符信息的换行
val = pow(2,1000)
#返回val结果的长度值要使用 len(str(val)),因为整型没有len()方法，要通过str()函数
#将数字类型转换为字符串- 正确引用time库的方式如下：
import time from time import strftime from time import *- Python语言的整数类型表示：十进制（一般表示）二进制（0b或0B开头）八进制（0o或0O开头）十六进制（0x或0X开头）
- %运算符的意思是取余数
- 字符串切片操作：s[N:M]，从N到M，但是不包括M
name="Python语言程序设计课程" print(name[0],name[2:-2],name[-1]) #输出结果为：P thon语言程序设计 程print("{0:3}".format('PYTHON'))代码执行的结果是PYTHON，{0:3}表示输出的宽度是3，但是如果字符串长度超过3就以字符串长度显示
编程测试：
- 平方根格式化：获得用户输入的一个整数a，计算a的平方根，保留小数点后3位，并打印输出。输出结果采用宽度30个字符、右对齐输出、多余字符采用加号(+)填充，如果结果超过30个字符，则以结果宽度为准
a = eval(input()) print("{:+>30.3f}".format(a**0.5)) # +是填充字符 >是右对齐 30是宽度 .3f是保留小数点后3位 #若平凡根后是一个复数，复数的实部和虚部都是浮点数，.3f可以将实部和虚部分别取三位小数- 字符串分段组合：获得输入的一个字符串s，以字符减号(-)分割s，将其中首尾两段用加号(+)组合后输出
InputStr = input() strs = InputStr.split('-') print(strs[0]+'+'+strs[-1]) print("{}+{}".format(strs[0], strs[-1])) #s.split(k)以k为标记分割s，产生一个列表 #通过该题目，掌握split()方法的使用，注意：k可以是单字符，也可以是字符串测验4：程序的控制结构
知识点概要：
- for…in…中in的后面需要的是一个迭代类型（组合类型），{1;2;3;4;5}不是Python的有效数据类型
- range(x,y)
for i in range(0,2): print(i) #输出结果为：0 1- 程序的三种基本结构：顺序结构，循环结构和分支结构
- 循环是程序根据条件判断结果向后反复执行的一种运行方式，是一种程序的基本控制结构，条件循环和遍历循环结构都是基本的循环结构，死循环能够用于测试性能，形式上的死循环可以用break来退出，例如
x = 10 while True: x = x -1 if x == 1: breakp = -p #表示给p赋值为它的负数，Python中的=是赋值符号- 缩进表达层次关系，同时用来判断当前Python语句在分支结构中
- continue结束当次循环，但是不跳出循环
- random库中用于生产随机小数的函数是random()，而randint()/getrandbits()/randrange()都产生随机整数
- 程序错误是一个大的概念，不仅指代码运行错误，更代表功能逻辑错误。使用异常处理try-excepy，可以对程序的异常进行捕捉和处理，程序运行可能不会出错，但逻辑上可能会出错
编程测试：
- 四位玫瑰数：四位玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身
例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数
请输出所有4位数的四位玫瑰数，按照从小到大顺序，每个数字一行
#个人思路：求四位数的各个位数abcd for i in range(1000,10000): a = i%10 b = (i//10)%10 c = (i//100)%10 d = (i//1000)%10 if a**4 + b**4 + c**4 + d**4 == i: print(i) #参考答案：字符串+eval() s = "" for i in range(1000, 10000): t = str(i) if pow(eval(t[0]),4) + pow(eval(t[1]),4) + pow(eval(t[2]),4) + pow(eval(t[3]),4) == i : print(i)- 100以内素数之和：求100以内所有素数之和并输出
素数指从大于1，且仅能被1和自己整除的整数，提示：可以逐一判断100以内每个数是否为素数，然后求和
sum = 0 for i in range(2,100): isFlag = 1 #判断是否为素数 for j in range(2,i): #遍历2-i-1,看是否能被i整除 if i%j == 0: #被整除说明不是素数 isFlag = 0 break if isFlag == 1: sum += i print(sum) #参考答案：将判断是否为素数封装为一个函数，倾向于这种解题思路 def is_prime(n): for i in range(2,n): if n%i == 0: return False return True sum = 0 for i in range(2,100): if is_prime(i): sum += i print(sum)测验5：函数和代码复用
知识点概要：
- 函数作用：增强代码可读性、降低编程复杂度、复用代码，函数不能直接提高代码的执行速度
- 全局变量与局部变量：函数的参数一般为局部变量，函数内使用
global s表示变量s为全局变量 - 函数在调用前必须已经存在函数定义，否则无法执行，Python内置函数直接使用，不需要引用任何模块
- 模块内高耦合，模块间低耦合：高耦合的特点是复用较为困难，模块间关系应尽可能简单，模块之间耦合度低，尽可能合理划分功能块，功能块内部耦合度高
- 递归不会提高程序的执行效率，任何递归程序都可以通过堆栈或队列变为非递归程序
- 函数是一段具有特定功能的、可重用的语句组，可以看做是一段具有名字的程序，通过函数名来调用，同时不需要知道函数的内部实现原理，只需要知道调用方法（接口）即可
def func(*a,b):是错误的函数定义，*a表示可变参数，可变参数只能放在函数参数的最后，即def func(a,*b):- 函数可以包含0个或多个return语句
- 每个递归函数至少存在一个基例，但可能存在多个基例，基例表示不再进行递归，同时决定了递归的深度
编程测试：
- 随机密码生成：以整数17为随机数种子，获取用户输入整数N为长度，产生3个长度为N位的密码，密码的每位是一个数字。每个密码单独一行输出，产生密码采用random.randint()函数
import random def genpwd(length): a = 10**(length-1) b = 10**length - 1 return "{}".format(random.randint(a, b)) length = eval(input()) random.seed(17) for i in range(3): print(genpwd(length)) #思路类似，同样过了 def genpwd(length): high = 10**length low = 10**(length-1) return random.randrange(low,high)- 连续质数计算：获得用户输入数字N，计算并输出从N开始的5个质数，单行输出，质数间用逗号,分割。
注意：需要考虑用户输入的数字N可能是浮点数，应对输入取整数；最后一个输出后不用逗号
def prime(m): #判断是否为质数 for i in range(2,m): if m%i == 0: return False return True n = eval(input()) if n != int(n): #考虑输入为浮点数的情况 n = int(n) + 1 else: n = int(n) times = 0 #统计质数的次数 res = [] #存放输出结果 while times < 5: if prime(n): res.append(n) times += 1 n += 1 for i in res[:len(res)-1]: print(i,end=",") print(res[-1]) #最后一个不输出逗号 #参考答案 def prime(m): for i in range(2,m): if m % i == 0: return False return True #需要对输入小数情况进行判断，获取超过该输入的最小整数（这里没用floor()函数） n = eval(input()) n_ = int(n) n_ = n_+1 if n_ < n else n_ count = 5 #对输出格式进行判断，最后一个输出后不增加逗号（这里没用.join()方法） while count > 0: if prime(n_): if count > 1: print(n_, end=",") else: print(n_, end="") count -= 1 n_ += 1测验6：组合数据类型
知识点概要：
- 列表ls，
ls.append(x)表示只能向列表最后增加一个元素，如果x是一个列表，则该列表作为一个元素增加到ls中 - 集合“交并差补”四种运算分别对应的运算符是：
& | - ^ - 字典d，
d.values()返回的是dict_values类型，包括字典中的所有值，通常与for…in组合使用 - Python的元组类型：元组采用逗号和圆括号（可选）来表示，一旦创建就不能修改，一个元组可以作为另一个元祖的元素，可用多级索引获取信息，序列类型（元组、列表）中的元素都可以是不同类型
- 创建字典时，如果相同键对应不同值，字典采用最后一个"键值对"
d= {'a': 1, 'b': 2, 'b': '3'} print(d['b']) #输出结果：3- 集合与字典类型最外侧都用{}表示，不同在于集合类型元素是普通元素，字典类型元素是键值对。字典在程序设计中非常常用，因此直接采用{}默认生成一个空字典
- 对于字典d：
x in d表示判断x是否是字典d中的键，键是值的序号，也是字典中值的索引方式 - Python序列类型有：列表类型、元组类型、字符串类型（Python内置数据类型中没有数组类型）
- 组合数据类型能够将多个相同类型或不同类型的数据组织起来，通过单一的表示使数据操作更有序、更容易
- 组合数据类型可以分为3类：序列类型、集合类型和映射类型；
- Python的字符串、元组和列表类型都属于序列类型，序列类型总体上可以看成一维向量，如果其元素都是序列，则可被当作二维向量
- 对于序列s：
s.index(x)返回序列s中元素x第一次出现的序号，并不返回全部序号
编程测试：
- 数字不同数之和：获得用户输入的一个整数N，输出N中所出现不同数字的和
例如：用户输入 123123123，其中所出现的不同数字为：1、2、3，这几个数字和为6
#参考答案：字符串可以通过list()直接变成列表，或通过set()直接变成集合 n = input() ss = set(n) s = 0 for i in ss: s += eval(i) #s += int(i) #同样可以 print(s)- 人名最多数统计：给出了一个字符串，其中包含了含有重复的人名，请直接输出出现最多的人名
#先使用字典建立"姓名与出现次数"的关系，然后找出现次数最多数对应的姓名 s = '''双儿 洪七公 赵敏 赵敏 逍遥子 鳌拜 殷天正 金轮法王 乔峰 杨过 洪七公 郭靖 杨逍 鳌拜 殷天正 段誉 杨逍 慕容复 阿紫 慕容复 郭芙 乔峰 令狐冲 郭芙 金轮法王 小龙女 杨过 慕容复 梅超风 李莫愁 洪七公 张无忌 梅超风 杨逍 鳌拜 岳不群 黄药师 黄蓉 段誉 金轮法王 忽必烈 忽必烈 张三丰 乔峰 乔峰 阿紫 乔峰 金轮法王 袁冠南 张无忌 郭襄 黄蓉 李莫愁 赵敏 赵敏 郭芙 张三丰 乔峰 赵敏 梅超风 双儿 鳌拜 陈家洛 袁冠南 郭芙 郭芙 杨逍 赵敏 金轮法王 忽必烈 慕容复 张三丰 赵敏 杨逍 令狐冲 黄药师 袁冠南 杨逍 完颜洪烈 殷天正 李莫愁 阿紫 逍遥子 乔峰 逍遥子 完颜洪烈 郭芙 杨逍 张无忌 杨过 慕容复 逍遥子 虚竹 双儿 乔峰 郭芙 黄蓉 李莫愁 陈家洛 杨过 忽必烈 鳌拜 王语嫣 洪七公 韦小宝 阿朱 梅超风 段誉 岳灵珊 完颜洪烈 乔峰 段誉 杨过 杨过 慕容复 黄蓉 杨过 阿紫 杨逍 张三丰 张三丰 赵敏 张三丰 杨逍 黄蓉 金轮法王 郭襄 张三丰 令狐冲 赵敏 郭芙 韦小宝 黄药师 阿紫 韦小宝 金轮法王 杨逍 令狐冲 阿紫 洪七公 袁冠南 双儿 郭靖 鳌拜 谢逊 阿紫 郭襄 梅超风 张无忌 段誉 忽必烈 完颜洪烈 双儿 逍遥子 谢逊 完颜洪烈 殷天正 金轮法王 张三丰 双儿 郭襄 阿朱 郭襄 双儿 李莫愁 郭襄 忽必烈 金轮法王 张无忌 鳌拜 忽必烈 郭襄 令狐冲 谢逊 梅超风 殷天正 段誉 袁冠南 张三丰 王语嫣 阿紫 谢逊 杨过 郭靖 黄蓉 双儿 灭绝师太 段誉 张无忌 陈家洛 黄蓉 鳌拜 黄药师 逍遥子 忽必烈 赵敏 逍遥子 完颜洪烈 金轮法王 双儿 鳌拜 洪七公 郭芙 郭襄 赵敏''' names = s.split() d = {} for name in names: d[name] = d.get(name, 0) + 1 Maxkey = "" MaxValue = 0 for k in d: if d[k] > MaxValue: Maxkey = k MaxValue = d[k] print(Maxkey) #参考答案 ls = s.split() d = {} for i in ls: d[i] = d.get(i, 0) + 1 max_name, max_cnt = "", 0 for k in d: if d[k] > max_cnt: max_name, max_cnt = k, d[k] print(max_name)测验7：文件和数据格式化
知识点概要：
- 数据组织的纬度：一维数据采用线性方式组织，对应于数学中的数组和集合等概念；二维数据采用表格方式组织，对应于数学中的矩阵；高维数据由键值对类型的数据构成，采用对象方式组织，字典就用来表示高维数据，一般不用来表示一二纬数据
- Python对文件操作采用的统一步骤是：打开-操作-关闭（其中关闭可以省略）
- CSV文件格式是一种通用的、相对简单的文件格式，应用于程序之间转移表格数据，CSV文件的每一行是一维数据，可以使用Python中的列表类型表示，整个CSV文件是一个二维数据，一般来说，CSV文件都是文本文件，由相同的编码字符组成
- 二维列表切片
ls = [[1,2,3],[4,5,6],[7,8,9]]获取其中的元素5要使用：ls[1][1] - 文件可以包含任何内容，是数据的集合和抽象，是存储在辅助存储器上的数据序列，而函数或类才是程序的集合和抽象
- 打开文件后采用close()关闭文件是一个好习惯。如果不调用close()，当前Python程序完全运行退出时，该文件引用被释放，即程序退出时，相当于调用了close()，默认关闭
- Python文件的"+"打开模式，与r/w/a/x一同使用，在原功能基础上同时增加了读写功能，同时赋予文件的读写权限
- 同一个文件既可以用文本方式打卡，也可以用二进制方式打开
- 列表元素如果都是列表，其可能表示二维数据，如
[[1,2],[3,4],[5,6]]，如果列表元素不都是列表，则它表示一维数据 - Python文件读操作有：read()、readline()、readlines()，没有readtext()方法
编程测试：
- 文本的平均列数：打印输出附件文件的平均列数，计算方法如下：
（1）有效行指包含至少一个字符的行，不计算空行
（2）每行的列数为其有效字符数
（3）平均列数为有效行的列数平均值，采用四舍五入方式取整数进位
#for line in f 获取的line包含每行最后的换行符（\n），所以去掉该换行符再进行统计 f = open("latex.log", "r", encoding="utf-8") lines = 0 columns = 0 for line in f: line = line.strip("\n") if len(line): lines += 1 columns += len(line) print("{:.0f}".format(columns/lines)) f.close() #参考答案如下： f = open("latex.log") s, c = 0, 0 for line in f: line = line.strip("\n") if line == "": continue s += len(line) c += 1 print(round(s/c))-CSV格式清洗与转换：附件是一个CSV格式文件，提取数据进行如下格式转换：
（1）按行进行倒序排列
（2）每行数据倒序排列
（3）使用分号（;）代替逗号（,）分割数据，无空格
按照上述要求转换后将数据输出f = open("data.csv", "r", encoding="utf-8") txt = f.readlines() txt.reverse() #按行进行倒序排列 for line in txt: #line = line.strip("\n") #去除末尾换行符 #line = line.replace(" ","") #去空格 line = line.strip("\n").replace(" ", "") #ls = line.split(",") #ls = ls[::-1] ls = line.split(",")[::-1] #逗号分隔并将分隔后的元素倒序 print(";".join(ls)) #元素间插入分号 f.close() #参考答案（使用strip()方法去掉每行最后的回车，使用replace()去掉每行元素两侧的空格） f = open("data.csv") ls = f.readlines() ls = ls[::-1] lt = [] for item in ls: item = item.strip("\n") item = item.replace(" ", "") lt = item.split(",") lt = lt[::-1] print(";".join(lt)) f.close()测验8：程序设计方法学
知识点概要：
- 用户体验：编程只是手段，程序最终为人类服务，用户体验很重要，一个提醒进度的进度条、一个永不抛出异常的程序、一个快速的响应、一个漂亮的图标、一个合适尺寸的界面等都是用户体验的组成部分。总的来说，用户体验是一切能够提升程序用户感受的组成
- 计算思维是基于计算机的思维模式，计算机出现之前，由于没有快速计算装置，计算所反映的思维模式主要是数学思维，即通过公式来求解问题。当快速计算装置出现后，计算思维才真正形成
- 软件产品 = 程序功能 + 用户体验 ；产品不仅需要功能，更需要更好的用户体验。往往，产品都需要综合考虑技术功能和人文设计，这源于产品的商业特性。即，商业竞争要求产品不能只关心技术功能，更要关心用户易用和喜好需求
- os库：
os.system()可以启动进程执行程序 - 函数是自顶向下设计的关键元素，通过定义函数及其参数逐层开展程序设计
- os.path子库：
os.path.relpath(path)用来计算相对路径 - Python第三方库安装：使用pip命令、使用集成安装工具或访问UCI网站下载安装文件，请不要直接联系作者索要第三方库
- 计算思维的本质是：抽象和自动化
- os库是Python重要的标准库之一，提供了路径操作、进程管理等几百个函数功能，覆盖与操作系统、文件操作等相关的众多功能；os库适合所有操作系统
- 计算生态以竞争发展、相互依存和迅速更迭为特点，在开源项目间不存在顶层设计，以类自然界"适者生存"的方式形成技术演进路径
编程测试：
- 英文字符的鲁棒输入：获得用户的任何可能输入，将其中的英文字符进行打印输出，程序不出现错误
inputStr = input() for i in inputStr: if i.islower() or i.isupper(): print(i,end="") #参考答案：采用遍历字符的方式实现，通过约束字母表达到鲁棒效果 alpha = [] for i in range(26): alpha.append(chr(ord('a') + i)) alpha.append(chr(ord('A') + i)) s = input() for c in s: if c in alpha: print(c, end="")- 数字的鲁棒输入：获得用户输入的一个数字，可能是浮点数或复数，如果是整数仅接收十进制形式，且只能是数字。对输入数字进行平方运算，输出结果，要求：
1）无论用户输入何种内容，程序无错误
2）如果输入有误，请输出"输入有误"
number = input() try: #complex()和complex(eval())之间的比较 #将能够排除非数字类型的输入 if complex(number) == complex(eval(number)): print(eval(number) ** 2) except: print("输入有误") ''' 不能直接使用eval()，否则用户可以通过输入表达式（如100**2）输入数字 与要求不同（在实际应用中会带来安全隐患） '''测验9：Python计算生态纵览
知识点概要：
- Python网络爬虫方向第三方库有：Requests、Scrapy、pyspider
- Python数据可视化方向第三方库有：Mayavi、Matplotlib、Seaborn
- Python Web信息提取方向第三方库有：Beautiful Soup、Python-Goose、Re
- Python游戏开发第三方库有：Panda3D、cocos2d、PyGame
- Python数据分析方向第三方库有：Numpy、Pandas、Scipy
- Python图形用户界面方向(GUI)第三方库有：PyQt5、wxPython、PyGObject
- Python网站开发框架方向第三方库有：Django、Pyramid、Flask
- Python文本处理方向第三方库有：NLTK、python-docx、PyPDF2
- Python网络应用开发方向第三方库有：aip、MyQR、WeRobot
- aip是百度的人工智能功能Python访问接口
- Python人工智能方向第三方库有：TensorFlow、Scikit-learn、MXNet
- Vizard是虚拟现实第三方库
- pyovr是增强现实开发库
- redis-py是redis数据的Python访问接口
编程测试：
- 系统基本信息获取：获取系统的递归深度、当前执行文件路径、系统最大UNICODE编码值等3个信息，并打印输出；输出格式如下：
RECLIMIT:<深度>, EXEPATH:<文件路径>, UNICODE:<最大编码值>
提示：请在sys标准库中寻找上述功能
import sys print("RECLIMIT:{}, EXEPATH:{}, UNICODE:{}".format(sys.getrecursionlimit(), sys.executable, sys.maxunicode))- 二维数据表格输出：tabulate能够对二维数据进行表格输出，是Python优秀的第三方计算生态。编写程序，能够输出如下风格效果的表格数据
data = [ ["北京理工大学", "985", 2000], \ ["清华大学", "985", 3000], \ ["大连理工大学", "985", 4000], \ ["深圳大学", "211", 2000], \ ["沈阳大学", "省本", 2000], \ ] from tabulate import tabulate print(tabulate(data, tablefmt="grid"))期末测验
*编程测试：
- 无空隙回声输出：获得用户输入，去掉其中全部空格，将其他字符按收入顺序打印输出
print(input().replace(" ",""))- 文件关键行数：关键行指一个文件中包含的不重复行。关键行数指一个文件中包含的不重复行的数量。统计附件文件中关键行的数量
f = open("latex.log", "r", encoding="utf-8") d = {} for line in f: d[line] = d.get(line, 0) + 1 print("共{}关键行".format(len(d))) #参考答案：如果需要"去重"功能，请使用集合类型 f = open("latex.log") ls = f.readlines() s = set(ls) print("共{}关键行".format(len(s)))- 剩余两题与测验九重复，不重复记录
-
PTA46题(Java基础练习)
2019-10-03 20:40:597-1 写一个程序，输出你的姓名、年龄、所在学院、所在专业、所在班级 写一个程序，输出你的姓名、年龄、所在学院、所在专业、所在班级。 输出样例: 姓名：张三 年龄：20 所在学院：计算机学院 所在专业：计算机科学...展开全文Java作业练习（1）
这学期Java课的第一次作业嗷
(做完再删掉这句话)
我觉得可以7-1 写一个程序，输出你的姓名、年龄、所在学院、所在专业、所在班级
写一个程序，输出你的姓名、年龄、所在学院、所在专业、所在班级。
输出样例:
姓名：张三
年龄：20
所在学院：计算机学院
所在专业：计算机科学与技术
所在班级：1班import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); if (scanner.hasNext()) { String n, m1, m2; int old, m3; n = scanner.nextLine(); old = Integer.parseInt(scanner.nextLine()); m1 = scanner.nextLine(); m2 = scanner.nextLine(); m3 = Integer.parseInt(scanner.nextLine()); System.out.println("姓名：" + n + "\n" + "年龄：" + old + "\n" + "所在学院：" + m1 + "\n" + "所在专业：" + m2 + "\n" + "所在班级：" + m3 + "班"); }else { System.out.println("姓名：张三\n" + "年龄：20\n" + "所在学院：计算机学院\n" + "所在专业：计算机科学与技术\n" + "所在班级：1班"); } } }7-2 jmu-Java-02基本语法-05-浮点数的精确计算
输入若干对浮点数，对每对浮点数输出其精确的和与乘积。
以下输入样例为两对浮点数输入，实际上有可能有不定对数的浮点数需要输入计算。注1：直接使用double类型数据进行运算，无法得到精确值。
注2：输出时直接调用BigDecimal的toString方法。输入样例:
69.1 0.02
1.99 2.01输出样例:
69.12
1.382
4.00
3.9999import java.math.BigDecimal; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); BigDecimal a,b; while (scanner.hasNext()){ a = scanner.nextBigDecimal(); b = scanner.nextBigDecimal(); System.out.println(a.add(b)); System.out.println(a.multiply(b)); } } }7-3 jmu-Java-02基本语法-06-枚举
定义一个枚举类型Grade来表示考试的4个等级，值包含A,B,C,D,E
编写一个函数Grade getGrade(int score)将传递进来的score转化为枚举类型
score>=90 and <=100返回A，
score>=80 and <90 返回B，
score>=70 and <80 返回C，
score>=60 and <70返回D，
其他的返回E
main方法
输入分数后，调用getGrade函数返回相应的Grade，使用switch根据Grade，根据分数打印不同的评价：
Excellent Good Average Fair Poor
并且每输出一个评语后，要调用如下函数public static void printGradeInfo(Grade grade){ System.out.println("class name="+Grade.class); System.out.println("grade value="+grade); }输入样例:
90
80
70
60输出样例:
Excellent
class name=class Grade
grade value=A
Good
class name=class Grade
grade value=B
Average
class name=class Grade
grade value=C
Fair
class name=class Grade
grade value=Dimport java.util.Scanner; enum Grade{ A,B,C,D,E } public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int m; while (scanner.hasNext()){ m = scanner.nextInt(); printGradeInfo(getGrade(m)); } } public static Grade getGrade(int score){ if(score>=90&&score<=100){ System.out.println("Excellent"); return Grade.A; } else if(score>=80&&score<90){ System.out.println("Good"); return Grade.B; } else if(score>=70&&score<80){ System.out.println("Average"); return Grade.C; } else if(score>=60&&score<70){ System.out.println("Fair"); return Grade.D; } else { System.out.println("Poor"); return Grade.E; } } public static void printGradeInfo(Grade grade){ System.out.println("class name="+Grade.class); System.out.println("grade value="+grade); } }7-4 jmu-Java-02基本语法-07-大整数相加 (4 分)
有若干大整数，需要对其进行求和操作。
输入格式
每行输入一个字符串代表一个大整数，连续输入若干行，当某行字符为e或E时退出。输入样例:
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
e输出样例:
97967883730498271109594004638709798272918548148116
import java.math.BigDecimal; import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String n; BigDecimal bigDecimal,sum = BigDecimal.valueOf(0L); while (scanner.hasNext()){ n = scanner.nextLine(); if ("e".equals(n) || "E".equals(n)){ break; } bigDecimal = new BigDecimal(n); sum = sum.add(bigDecimal); } System.out.println(sum); } }7-5 testestjava
这是一个编程题模板。请在这里写题目描述。例如：本题目要求读入2个整数A和B，然后输出它们的和。
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。输出格式:
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。输入样例:
在这里给出一组输入。例如：
18 -299输出样例:
在这里给出相应的输出。例如：
-281import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String shuru = scanner.nextLine(); String n = scanner.nextLine(); String[] s = n.split(" "); System.out.println("在这里给出相应的输出。例如："); System.out.println(Integer.parseInt(s[0]) + Integer.parseInt(s[1])); } }7-6 字符串处理
编写一个程序，用户输入任意一个字符串，显示它的长度和第一个字符。
输入格式:
输入任意一个字符串。输出格式:
显示它的长度和第一个字符，其间用,分隔。输入样例:
abc 4567
输出样例:
8,a
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String strings = scanner.nextLine(); System.out.println(strings.length() + "," + strings.charAt(0)); } }7-7 十进制转十六进制
编写一个程序，提示用户输入0~15之间的一个整数，显示其对应的十六进制数。
输入格式:
输入一个0~15之间的整数。输出格式:
若输入的整数在0~15范围内，则输出对应的十六进制数。否则输出“Invalid input”。输入样例:
11
输出样例:
B
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); char m = 'A'; int n = scanner.nextInt(); if(n > 15) { System.out.println("Invalid input"); }else if (n >= 10 && n <= 15){ System.out.println((char) (m+n-10)); }else { System.out.println(n); } } }7-8 求最大值
本题目要求读入2个整数A和B，然后输出两个数的最大值。
输入格式:
输入在一行中给出2个绝对值不超过1000的整数A和B。输出格式:
对每一组输入，在一行中输出最大值。输入样例:
在这里给出一组输入。例如：18 -299
输出样例:
在这里给出相应的输出。例如：18
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int A = scanner.nextInt(); int B = scanner.nextInt(); if(A > B) System.out.println(A); else System.out.println(B); scanner.close(); } }7-9 jmu-java-01入门-基本输入
对输入的若干行（每行以空格或者多个空格）数字字符串求和并输出。
输入格式:
每行包含两个数字字符串，中间以一个或者多个空格分隔。输出格式:
输出两个数的和输入样例:
1 1
2 3
-100 100
-100 -100
10 0输出样例:
在这里给出相应的输出。例如：2
5
0
-200
10import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); while (scanner.hasNext()){ String s,a = "",b=""; int sum = 0; s = scanner.nextLine(); int i,j = 0; boolean f= false; for (i = 0; i < s.length(); i++) { if (s.charAt(i) != ' ') { a = a + s.charAt(i); f = true; }else if (f == true) { j = i; break; } } for (j = i; j < s.length(); j++) { if (s.charAt(j) != ' '){ b+=s.charAt(j); } } System.out.println(Integer.parseInt(a) + Integer.parseInt(b)); } } }7-10 编程题：统计符合条件元素的个数-hebust
统计1…n的闭区间中，能够被3整除元素的奇数和偶数的个数
输入格式:
输入值n的范围是 【1…1000】输出格式:
奇数个数,偶数个数输入样例:
5
输出样例:
1,0
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int a = 0,b = 0; for (int i = 1; i <= n; i++) { if (i % 3 == 0 && i % 2 == 0){ b++; } if (i % 3 == 0 && i % 2 != 0){ a++; } } System.out.println(a+","+b); } }7-11 编程题：判断闰年-hebust
根据输入的正整数y所代表的年份，计算输出该年份是否为闰年 闰年的判断标准：
能够被4整除且不能被100整除的年份
或者能够被400整除的年份
输入格式:
输入n取值范围是 【1…3000】输出格式:
是闰年，输出 yes非闰年，输出 no
输入样例:
在这里给出一组输入。例如：100
输出样例:
在这里给出相应的输出。例如：no
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int y = scanner.nextInt(); if (((y % 4 == 0 )&& (y % 100 != 0)) || y % 400 == 0) { System.out.println("yes"); } else { System.out.println("no"); } } }7-12 输出月份
分别用if、switch两种方法编写根据0～11的整数转换为十二月份的程序片断，假定数字0对应一月份。
输入格式:
每一行输入0~12之间的一个数字输出格式:
输出该数字对应的月份输入样例:
0
输出样例:
请输入月份：
2
三月份
请输入月份：
12
请重新输入月份import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); if (n >= 12){ System.out.println("请重新输入月份"); }else { String[] strings = {"一月份", "二月份", "三月份", "四月份", "五月份", "六月份", "七月份", "八月份", "九月份", "十月份", "十一月份", "十二月份"}; System.out.println(strings[n]); } } }7-13 点是否在圆内?
编写程序，提示用户输入一个点(x,y)，然后检查这个点是否在以原点(0,0)为圆心、半径为10的圆内。
输入格式:
输入任意一个点的x轴和y轴坐标值，且两个值之间空格分隔。输出格式:
若点在圆内，输出1，否则输出0。输入样例:
4 5
输出样例:
1
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int x = scanner.nextInt(); int y = scanner.nextInt(); if( x * x + y * y <= 100) { System.out.println("1"); } else { System.out.println("0"); } } }7-14 给出一个月的总天数
编写程序，提示用户输入月份和年份，然后显示这个月的天数。
输入格式:
输入任意符合范围（1月12月）的月份和（1900年9999年）年份，且两个值之间空格分隔。输出格式:
输出给定年份和月份的天数。输入样例:
2 2000
输出样例:
29
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int month = scanner.nextInt(); int year = scanner.nextInt(); int day = 0; if (month != 2) { switch (month) { case 1: case 3: case 5: case 7: case 8: case 10: case 12: day = 31; break; case 4: case 6: case 9: case 11: day = 30; } }else if (((year % 4 == 0) && (year % 100 != 0)) || year % 400 == 0) { day = 29; } else { day = 28; } System.out.println(day); } }7-15 程序改错题1
程序改错题。以下代码目标是实现从键盘输入1个整数x，然后根据x的值做不同的计算，输出结果。(程序有错，请改正后提交)
import java.util.Scanner;
public class Main {
public static void main(String args[]) {
Scanner in = new Scanner(System.in);
int x, j = 1;
x = in.nextInt();
switch (x) {
case 1:
j++;
case 2:
j++;
case 3:
j = x*j++;
case 4:
j= x + j++;
case 5:
j = x - j++;
default:
j = x;
}
System.out.println(j);
}
}输入格式:
输入整数x。输出格式:
输出值。输入样例:
5
输出样例:
4
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner in = new Scanner(System.in); int x, j = 1; x = in.nextInt(); switch (x) { case 1: j++;break; case 2: j++;break; case 3: j = x*j++;break; case 4: j= x + j++;break; case 5: j = x - j++;break; default: j = x;break; } System.out.println(j); } }7-16 根据和找到最大乘积
试求和为N，积为最大的两个整数数分别是多少。
从键盘中输入一个整数，它是另外两个整数的加法运算和，这样的两个整数的组合有很多种，请找出乘积最
大的一组数据。请注意输出两个整数以空格分割，按由小到大的顺序输出。
输入格式:
从键盘中输入一个整数输出格式:
在一行中输出两个整数，以空格分割，按由小到大的顺序输出。输入样例:
33
输出样例:
16 17
输入样例:
-51
输出样例:
-26 -25
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int a; a = scanner.nextInt(); if (a == 0){ System.out.println(-1+" "+1); }else { if (a % 2 == 0) { System.out.println(a / 2 + " " + a / 2); } else { System.out.println((a - 1) / 2 + " " + (a + 1) / 2); } } } }7-17 编程题：数据的规范化处理问题-hebust
在进行数据处理时，输入数据未经过滤，存在一些不符合要求的数据 要求编写数据处理程序，小于0的数据一律指定为0，大于100的数据一律指定为100
输入格式:
输入：所有元素占一行，元素之间使用空格分开，元素均为整数，范围【-300…300】输出格式:
输出：所有元素占一行，元素之间使用西文逗号分开，最后一个元素末尾保留西文逗号输入样例:
在这里给出一组输入。例如：-1 10 105
输出样例:
在这里给出相应的输出。例如：0,10,100,
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String[] strings = s.split(" "); for (int i = 0; i < strings.length; i++) { if (Integer.parseInt(strings[i]) < 0){ System.out.print(0+","); }else if (Integer.parseInt(strings[i]) > 100){ System.out.print(100+","); }else { System.out.print(strings[i]+","); } } } }7-18 编程题：复杂情况下的数据统计问题-hebust
复杂环境下的数据统计问题
进行数值统计的时候，可能会混入一些非数值的元素，下面请编程完成对输入序列进行求和统计并输出， 如果遇到非数值元素，则自动跳过，并在最终结果输出行之后另起一行，输出attention
输入格式:
单行输入，元素之间使用空格分开输出格式:
对元素所对应的整数进行求和并输出如果遇到非数值元素，则自动跳过，并在最终结果输出行之后另起一行，输出attention
输入样例a:
在这里给出一组输入。例如：1 2 3 4 5
输出样例a:
在这里给出相应的输出。例如：15
输入样例b:
在这里给出一组输入。例如：1 2 3 4 a 5
输出样例b:
在这里给出相应的输出。例如：15
attentionimport java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String[] strings = s.split(" "); int sum = 0; boolean f = false; for (int i = 0; i < strings.length; i++) { if (strings[i].charAt(0)=='-'){ sum += Integer.parseInt(strings[i]); }else if (strings[i].charAt(0)>='0' && strings[i].charAt(0) <= '9'){ try { sum += Integer.parseInt(strings[i]); }catch (Exception a){ f = true; continue; } }else { f = true; } } System.out.println(sum); if (f){ System.out.println("attention"); } } }7-19 二进制的前导的零
计算机内部用二进制来表达所有的值。一个十进制的数字，比如18，在一个32位的计算机内部被表达为00000000000000000000000000011000。可以看到，从左边数过来，在第一个1之前，有27个0。我们把这些0称作前导的零。
现在，你的任务是写一个程序，输入一个整数，输出在32位表达下它前导的零的个数。
输入格式:
一个整数，在32位的整数可以表达的范围内。输出格式:
一个整数，表达输入被表达为一个32位的二进制数时，在第一个1之前的0的数量。输入样例:
256
输出样例:
23
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); Integer a = scanner.nextInt(); if (a.equals(0)){ System.out.println(32); }else { String s = Integer.toBinaryString(a); System.out.println(32 - s.length()); } } }7-20 JAVA-水仙花数
水仙花数是指一个N位正整数（7≥N≥3），它的每个位上的数字的N次幂之和等于它本身。例如：153=13+53+33。 要求编写程序，计算所有N位水仙花数。
输入格式:
输入一个正整数N（3≤N≤7）。输出格式:
按递增顺序输出所有N位水仙花数，每个数字占一行。输入样例:
在这里给出一组输入。例如：3
输出样例:
在这里给出相应的输出。例如：153
370
371
407import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int i,j,a,b,c; for(i =100;i<1000;i++) { a=i/100; b=i%10; c=(i/10)%10; if(Math.pow(a,N) + (Math.pow(b,N)) + (Math.pow(c, N))==(i)) System.out.println(i); } } }7-21 JAVA-求整数序列中出现次数最多的数
要求统计一个整型序列中出现次数最多的整数及其出现次数。
输入格式:
在一行中给出序列中整数个数N（0<N≤1000），依次给出N个整数，每个整数占一行。输出格式:
在一行中输出出现次数最多的整数及其出现次数，数字间以空格分隔。题目保证这样的数字是唯一的。输入样例:
在这里给出一组输入。例如：10
3
2
-1
5
3
4
3
0
3
2输出样例:
在这里给出相应的输出。例如：3 4
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner (System.in); int n = scanner.nextInt(); int b = 0; int t = 0; int[] arr = new int[1000]; for (int i = 0; i < n; i++) { arr[i] = scanner.nextInt(); } for(int i = 0;i < n;i ++){ int c = 0; for(int j = 0;j < n;j ++){ if(arr[i] == arr[j]){ c ++; } } if(c > b){ t = arr[i]; b = c; } } System.out.println(t + " " + b); } }7-22 统计正数和负数的个数然后计算这些数的平均值
编写程序，输入未指定个数的整数，判断读入的正数有多少个，读入的负数有多少个，然后计算这些输入值得总和及平均值（不对0计数）。当输入为0时，表明程序结束。将平均值以double型数据显示。
输入格式:
输入在一行中给出一系列整数，其间以空格分隔。当读到0时，表示输入结束，该数字不要处输出格式:
在第一行中输出正整数的个数； 在第二行中输出负整数的个数； 在第三行中输出这些输入值的总和（不对0计数）； 在第四行中输出这些输入值的平均值（double型数据）。输入样例:
1 2 -1 3 0
输出样例:
3
1
5
1.25import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner in = new Scanner(System.in); String s = in.nextLine(); if (s.equals("0")){ return; } String[] s1 = s.split(" "); int[] o=new int[s1.length]; for (int i=0;i<s1.length;i++){ o[i]=Integer.valueOf(s1[i]); } double sum=0; int num1=0; int num2=0; for (int i=0;i<o.length;i++){ if (o[i]>0){ num1++; }else if (o[i]<0){ num2++; } sum+=o[i]; } System.out.println(num1); System.out.println(num2); int a=(int)sum; System.out.println(a); System.out.println(sum/(num1+num2)); } }7-23 分队列
班级第一次列队，通常老师会让同学按身高排成一列，然后1、2报数，喊到1的同学向前一步，就这样，队伍就变成两列了。假设现在一个班级有n个同学，并且他们已经按身高排成了一列，同学按身高从1到n编号，你能告诉我最后哪些编号的同学站在了第一列么?
输入格式:
输入一个正整数n，表示班级的人数。输出格式:
按顺序输出所有在第一列的同学对应的编号，每两个编号之间用一个空格隔开。输入样例:
11
输出样例:
1 3 5 7 9 11
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); for (int i = 1; i <= N; i++) { if (i == 1){ System.out.print(1); }else if(i % 2 != 0) { System.out.print(" " + i); } } } }7-24 累加器
请你实现一个累加器。输入n个非负整数，输出他们的和。 1<n<1000，而每个数则<10000。
输入格式:
输入包括两行。 第一行:包括一个整数n，表示总共有n个数。 第二行:包含n个整数。输出格式:
输出n个数的和。输入样例:
4
3 2 1 4输出样例:
10
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int sum = 0; for (int i = 0; i < N; i++) { int a = scanner.nextInt(); sum += a; } System.out.println(sum); } }7-25 我是升旗手
一年一度的升旗手选拔又要到了，学校要求每个班级选出一位同学做升旗手的候选人。因 为升旗手对身高有严格的要求，所以班主任决定选班级里个子最高的同学(如果两位同学 一样高，则选任意一位)。你能很快地给老师答案么?
输入格式:
输入包括两行。 第一行:包括一个整数n，表示班级里共有n位同学。 第二行:包含n个三位数，表示每一位同学的身高。输出格式:
输出身高最高的同学的身高。输入样例:
4
130 125 129 140输出样例:
140
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int max = 0; for (int i = 0; i < N; i++) { int a = scanner.nextInt(); if (a > max){ max = a ; } } System.out.println(max); } }7-26 兔子繁殖问题
已知有一对兔子，每个月可以生一对兔子，而小兔子一个月后又可以生一对小兔子(比如:2月份出生的小兔子4月份可以生育)。也就是说，兔子的对数为：第一个月1对，第二个月2对，第三个月3对，第四个月5对…假设兔子的生育期为两年，且不死。那么问题来了，你能说出每个月的兔子数么?
输入格式:
输入一个数n，表示第n个月，1<=n<=24。输出格式:
输出这个月兔子的数目。输入样例:
4
输出样例:
5
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); System.out.println(fun(n)); scanner.close(); } public static int fun(int n) { if (n == 0 || n == 1) { return 1; } else { return fun(n - 1) + fun(n - 2); } } }7-27 作品评分
全国中小学生Scratch作品大赛拉开了序幕。每个参赛选手可以通过网络直接上传作品。本次比赛人人可做评委。每个网络评委可以通过网络对每一件作品进行打分。评分系统也是请程序高手设计的，能自动去掉一个最高分和一个最低分，求出平均分。
输入格式:
输入数据包括两行: 第一行为n，表示n个评委，n>2。 第二行是n个评委的打分，分数之间有一个空格。打分是可以带有小数部分的。输出格式:
输出平均分，结果保留两位小数。输入样例:
6
10 9 8 7.9 9 9.5输出样例:
8.88
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String N = scanner.nextLine(); double max = 0; double min =11; double sum = 0; double sum1 = 0; if(N.equals("0")) { System.out.println("0"); } String s = scanner.nextLine(); String[] strings = s.split(" "); for(int i = 0; i < strings.length; i++) { if (max < Double.parseDouble(strings[i])) { max = Double.parseDouble(strings[i]); } else if (min > Double.parseDouble(strings[i])) { min = Double.parseDouble(strings[i]); } sum += Double.parseDouble(strings[i]); } sum1 = (sum - max - min) / (Integer.parseInt(N) - 2); System.out.println(String.format("%.2f", sum1)); } }7-28 369寝室
369寝室是比较特殊的寝室，因为别的寝室都住了四个人，而369寝室只有三个人。也因为这个原因，寝室里的三位同学感情特别好。但是，毕业在即，三位小伙伴马上要分别。为了在未来的某个日子可以见面，三位小伙伴有了一个约定，假设在未来的某一年，三位小伙伴的年龄的末尾正好出现3、6、9三个数，那么他们会再次相聚。
现在问题来了，假设今年三位小伙伴的年龄分别是x，y，z，那么，他们三人最早几年后可以相聚呢?
输入格式:
输入数据包括三个整数x，y，z，分别表示三位伙伴的年龄。输出格式:
如果小伙伴最早在n年后可以相见(不包括当前这一年)，那么请输出这个n；如果100年内都不存在这样的情况，输出:so sad!输入样例:
25 22 28
输出样例:
1
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); boolean sad; boolean situation1 ,situation2 ,situation3 ; while (scanner.hasNextInt()) { sad = false; int x = scanner.nextInt(); int y = scanner.nextInt(); int z = scanner.nextInt(); for(int i = 1; i <= 100; i++) { situation1 = false; situation2 = false; situation3 = false; if (i == 100) { sad = true; } if ((x + i) % 10 == 3 || (y + i) % 10 == 3 || (z + i) % 10 == 3) { situation1 = true; } if ((x + i) % 10 == 6 || (y + i) % 10 == 6 || (z + i) % 10 == 6) { situation2 = true; } if ((x + i) % 10 == 9 || (y + i) % 10 == 9 || (z + i) % 10 == 9) { situation3 = true; } if (situation1&&situation2&&situation3) { System.out.println(i); break; } } if(sad) { System.out.println("so sad!"); } } } }7-29 等腰直角三角形
等腰直角三角形是指一个角是直角，且两条直角边相等的三角形。这里我们输出直角边长为n的等腰直角三角形的格式如下所示: 比如n=1，则输出:
*n=2，输出:
* **n=3，输出:
* ** ***那么，你能用程序来实现么?
输入格式:
输入一个数n，表示三角形的边长。1<n<1000。输出格式:
输出对应的用*表示的等腰直角三角形。输入样例:
4
输出样例:
* ** *** ****import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); String s = "*"; for (int i = 1; i <= N; i++) { System.out.println(s); s+="*"; } } }7-30 画菱形
菱形是一种特殊的平行四边形，是四条边均相等的平行四边形。题目给出菱形的边长n，用*画出菱形。如n=1，输出:
*n=2，输出:
* *** *n=3，输出:
* *** ***** *** *那么，你能用程序来实现么?
输入格式:
输入菱形的边长n，1<n<100。输出格式:
输出对应的用*表示的菱形。输入样例:
4
输出样例:
* *** ***** ******* ***** *** *import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); for(int i = 0; i < n; i++) { for(int k = n - i - 1 ; k > 0 ; k--) { System.out.print(" "); } for (int j = 0;j <= 2 * i; j++) { System.out.print("*"); } System.out.println(); } n -= 1; for (int i = n; i > 0; i--) { for(int k = n - i +1; k > 0; k--) { System.out.print(" "); } for(int j = 0; j <= 2 * i - 2; j++) { System.out.print("*"); } System.out.println(); } } }7-31 666
中国人非常喜欢6这个数字，因为大家总爱说66大顺啊。数学狂人李某人喜欢把什么都数字化，于是她把顺利这个词也定义了数量级，6代表1级顺利，66代表2级顺利，666代表3级顺利，以此类推。你看，数学狂人的世界总是让人无法理解。今天，李某人决定将数学进行到底，现在她设前n级顺利的和是sn。
sn=6+66+666+…+66…66(n个6)。
假设你已经知道了数字n，那么，你能帮李某人求出sn么?
输入格式:
输入一个正整数n，n的范围是[0,10)。输出格式:
输出Sn的值。输入样例:
2
输出样例:
72
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); long sn = 0; long a = 6; for (int i = 0; i < N; i++) { sn += a; a = a*10 +6; } System.out.println(sn); } }7-32 倒顺数字串
输入正整数n，输出它的倒顺数字串。如n=6时，输出
1 2 3 4 5 6 5 4 3 2 1
输入格式:
输入一个正整数n，n的范围是[1,50]。输出格式:
n的倒顺数字串，每两个数字之间只用一个空格隔开。输入样例:
6
输出样例:
1 2 3 4 5 6 5 4 3 2 1
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); for(int i = 1; i < N; i++) { System.out.print(i + " "); } for(int i = N; i >= 1; i--) { if(i == 1) { System.out.print(i); }else { System.out.print(i + " "); } } } }7-33 空心字母金字塔
输入一个大写的英文字母，输出空心的字母金字塔。
输入格式:
一个大写英文字母。输出格式:
一个空心的大写英文字母金字塔，其中第1层的“A”在第1行的第40列，列从1开始计数。输入样例:
E
输出样例:
A B B C C D D EEEEEEEEEimport java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); String N = scanner.nextLine(); StringBuilder b = new StringBuilder(" "); String c = " "; int k = 1; for (char i = 'A'; i < N.charAt(0); i++) { System.out.print(b); if (i == 'A'){ System.out.println(i); }else { System.out.print(i); System.out.print(c); System.out.println(i); c += " "; } b.delete(0,1); k++; } System.out.print(b); for (int i = 0; i < 2*k -1; i++) { System.out.print(N); } } }7-34 上三角数字三角形
输入一个正整数n，输出具有n层的上三角数字三角形。
输入格式:
只有一个正整数n，1<=n<=100。输出格式:
一个上三角数字三角形，每个数字占四个字符位置。输入样例:
5
输出样例:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int k = 1; int t = n; for (int i = 0; i < n; i++) { for (int j = 0; j < t; j++) { System.out.printf("%4d",k); k++; } t--; System.out.println(); } } }7-35 又来一个上三角数字三角形
输入一个正整数n，输出具有n层的上三角数字三角形。
输入格式:
只有一个正整数n，1<=n<=100。输出格式:
一个上三角数字三角形，每个数字占四个字符位置。输入样例:
5
输出样例:
1 6 10 13 15 2 7 11 14 3 8 12 4 9 5import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int a = scanner.nextInt(); int k = 1; int t = a; int[][] map = new int[a][a]; for (int i = 0; i < a; i++) { for (int j = 0; j < t; j++) { map[j][i] = k; k++; } t--; } for (int i = 0; i < a; i++) { for (int j = 0; j < a; j++) { if (map[i][j] != 0){ System.out.printf("%4s",map[i][j]); } } System.out.println(); } } }7-36 组合找出最大值和最小值
从键盘输入0~9之内的4个整数，计算由这4个整数组合成的整数的最大值和最小值。若输入的不是整数则输出“number input error”若输入的整数不是0~9范围内则输出“Numerical range error”
输入格式:
从键盘输入0~9之内的4个整数，以空格分割输出格式:
对每一组输入，在一行中输出两个整数，最大值和最小值。输入样例:
1 5 9 3
输出样例:==
9531 1359
输入样例:
1 5 a 9
输出样例:
number input error
输入样例:
1 5 10 9
输出样例:
Numerical range error
import java.util.Arrays; import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String[] strings = s.split(" "); int[] a = new int[4]; for (int i = 0; i < strings.length; i++) { if (strings[i].charAt(0) < '0' || strings[i].charAt(0) > '9'){ System.out.println("number input error"); return; }else if (strings[i].length() != 1){ System.out.println("Numerical range error"); return; }else { a[i] = Integer.parseInt(strings[i]); } } Arrays.sort(a); String s1 = ""; for (int i = 3; i >= 0 ; i--) { s1 += a[i]; } String s2 = ""; for (int i = 0; i < 4; i++) { s2 += a[i]; } System.out.println(Integer.parseInt(s1)+" "+Integer.parseInt(s2)); } }7-37 古埃及探秘-金字塔
金字塔是继99乘法表决之后的一个经典图形排列题
题目要求：
要求用户可以自主控制塔身的层数， 完成如下金字体样式;
输入格式:
4输出格式:
* *** ***** *******输入样例:
在这里给出一组输入。例如：5
8输出样例:
在这里给出相应的输出。例如：* *** ***** ******* ********* * *** ***** ******* ********* *********** ************* ***************import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); String s = "*"; String b = " "; String[] strings = new String[N]; for (int i = 0; i < N; i++) { String s1 = ""; for (int j = 0; j < N - i -1; j++) { s1 += " "; } s1 += s; strings[i] = s1; System.out.println(s1); s+="**"; } } }7-38 图片旋转
二维图片由一个个像素点组成，目前灰度图像使用一个0-255之间的整数表示某个像素点的像素值。编程完成图片旋转控制程序。
本题目要求读入2个整数m和n（<=20），作为图片的长宽尺寸。输入1个整数r，作为旋转角度（只能输入90 180 -90中的一个，90表示图形向左旋转90度，-90表示图形向右旋转90度）。然后按照行列输入图片像素值，
输入格式:
第一行：2个整数m和n（<=20）
第二行：2个整数r（只能是90 180 -90中的一个，否则提示：angle data error
第三行以后：输入m行n列的整数数据，必须在0-255之间，否则提示：matrix data error
以上输入的都是整数，若有非整数的数据输入，统一提示：data type error输出格式:
按要求旋转后的图片矩阵数据输入样例:
在这里给出一组输入。例如：3 4
90
1 2 3 4
5 6 7 8
9 10 11 12输出样例:
在这里给出相应的输出。例如：4 8 12
3 7 11
2 6 10
1 5 9import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int m,n; m = scanner.nextInt(); n = scanner.nextInt(); int op = scanner.nextInt(); int[][] map = new int[m][n]; if (op == 90 || op == -90 || op == 180){ for (int i = 0; i < m; i++) { for (int j = 0; j < n; j++) { if (!scanner.hasNextInt()){ System.out.println("data type error"); return; } map[i][j] = scanner.nextInt(); if (map[i][j] < 0 || map[i][j] > 255){ System.out.println("matrix data error"); return; } } } }else { System.out.println("angle data error"); } if (op == 90){ for (int i = n-1; i >= 0; i--) { for (int j = 0; j < m; j++) { if (j == m-1){ System.out.print(map[j][i]); }else { System.out.print(map[j][i] + " "); } } System.out.println(); } }else if (op == -90){ for (int i = 0; i < n; i++) { for (int j = m-1; j >= 0; j--) { if (j == 0){ System.out.print(map[j][i]); }else { System.out.print(map[j][i] + " "); } } System.out.println(); } }else if (op == 180){ for (int i = m-1; i >= 0; i--) { for (int j = n-1; j >= 0; j--) { if (j == 0){ System.out.print(map[i][j]); }else { System.out.print(map[i][j] + " "); } } System.out.println(); } } } }7-39 IP地址转换
一个IP地址是用四个字节（每个字节8个位）的二进制码组成。请将32位二进制码表示的IP地址转换为十进制格式表示的IP地址输出。
输入格式:
输入在一行中给出32位二进制字符串。输出格式:
在一行中输出十进制格式的IP地址，其由4个十进制数组成（分别对应4个8位的二进制数），中间用“.”分隔开。输入样例:
在这里给出一组输入。例如：11001100100101000001010101110010
输出样例:
在这里给出相应的输出。例如：204.148.21.114
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); String s = scanner.nextLine(); String s1 = s.substring(0,8); String s2 = s.substring(8,16); String s3 = s.substring(16,24); String s4 = s.substring(24,32); System.out.println(BinToTen(s1)+"."+BinToTen(s2)+"."+BinToTen(s3)+"."+BinToTen(s4)); } private static int BinToTen(String s) { int sum = 0; for (int i = 7; i >= 0; i--) { if (s.charAt(i) == '1'){ sum = (int) (sum + Math.pow(2,7-i)); } } return sum; } }7-40 计算n位（3≤n≤7）水仙花数
水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯特朗数（Armstrong number）。 水仙花数是指一个 n 位数（n≥3 ），它的每个位上的数字的 n 次幂之和等于它本身（例如：1^3 + 5^3+ 3^3 = 153；14+64+34+44=1634）。要求编写程序，计算n位（3≤n≤7）水仙花数。
输入格式:
输入在一行中给出一个正整数n（3≤n≤7）。输出格式:
按递增顺序输出所有n位水仙花数，每个数字占一行。输入样例:
在这里给出一组输入。例如：3
输出样例:
在这里给出相应的输出。例如：153
370
371
407同20题7-41 按正整数的相反数字顺序输出
本题目要求输入一个正整数，按数字的相反顺序输出。
输入格式:
输入一个正整数。输出格式:
按输入正整数的数字相反顺序输出一个数字。输入样例:
5236
输出样例:
6325
import java.util.Scanner; public class Main { public static void main(String[] args) { int number,n=0; // System.out.println("请输入一个整数:"); Scanner scanner = new Scanner(System.in); number = scanner.nextInt(); // System.out.println("逆向输出："); while(number != 0){ System.out.print(number%10); number=number/10; } } }7-42 求质数
本题目要求输入一个大于等于2的正整数，求所有不大于该正整数的质数。
输入格式:
输入一个不小于2的正整数。输出格式:
对输入的正整数，输出不大于该正整数的质数。输入样例:
30
输出样例:
2 3 5 7 11 13 17 19 23 29
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int N = scanner.nextInt(); int m ; for(int n = 2; n <= N; n++) { m = 2; while(n % m != 0) m++; if(m == n) System.out.print(n + " "); } } }7-43 统计比指定元素大的个数-hebust
统计比指定元素大的个数
输入格式:
输入为2行，第一行为参照的整数元素，第二行为参与统计的整数元素，之间使用空格分割。输出格式:
输出为比指定的参照元素大的元素个数。输入样例:
在这里给出一组输入。例如：5
2 3 6 7 3 4 9 8输出样例:
在这里给出相应的输出。例如：4
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int max = scanner.nextInt(); int count = 0 ; while (scanner.hasNextInt()){ if (scanner.nextInt() > max){ count++; } } System.out.println(count); } }7-44 倒顺字母字符串-hebust
根据输入n的大小（1=<n<=26），输出相对应的倒顺字符串。
输入格式:
输入格式：5输出格式:
a b c d e d c b a输入样例:
在这里给出一组输入。例如：5
输出样例:
在这里给出相应的输出。例如：a b c d e d c b a
import java.util.Scanner; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); if (n == 1){ System.out.println('a'); return; } for (int i = 0; i < n; i++) { System.out.print((char) ('a' + i) + " "); } for (int i = n-2; i >= 0; i--) { if (i == 0){ System.out.print((char) ('a' + i)); }else { System.out.print((char) ('a' + i) + " "); } } } }7-45 jmu-java-m02-循环求和
输入一组数，将其中的奇数、偶数分别求和并输出
输入格式:
输入n，然后输入n个整数输出格式:
奇数和=x, 偶数和=y
其中x，y分别代表奇数和与偶数和。逗号(,)后面有一个空格。输入样例:
10
1 2 1 1 1 2 1 2 2 2输出样例:
奇数和=5, 偶数和=10
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); int ou = 0; int ji = 0; for (int i = 0; i < n; i++) { int a = scanner.nextInt(); if (a % 2 == 0){ ou += a; }else { ji +=a; } } System.out.println("奇数和="+ji + ", "+"偶数和="+ou); } }7-46 jmu-java-m02-不定循环拼接符合条件的字符串
输入一组字符串，直到碰到end为之。将其中字符串长度是3的倍数的字符串使用空格拼接起来，并输出
输入格式:
输入一组以空格或者回车换行分隔的字符串，最后一个字符串为end。输出格式:
将输入字符串中长度是3的倍数的字符串使用空格拼接起来。
注意：行尾有一个空格。输入样例:
a abc 123456 22 45jd 123456789 end
输出样例:
abc 123456 123456789
import java.util.Scanner; public class Main { public static void main(String args[]) { Scanner scanner = new Scanner(System.in); String t = ""; while (scanner.hasNext()){ String s = scanner.next(); if (s.equals("end")){ break; } if (s.length() % 3 == 0){ t+=s; t += " "; } } System.out.println(t); } }未完待续…
-
输入一个字符串，内有数字和非数字字符，打印字符串中所有连续的数字所组成的整数
2019-03-30 17:32:19输入一个字符串，内有数字和非数字字符。如A123X456Y7A，302ATB567BC，打印字符串中所有连续（指不含非数字字符）的数字所组成的整数。 代码 #include "stdio.h" #include "string.h" #... -
C语言：利用指针编写程序,从键盘输入一个字符串，删除该字符串的所有首部和尾部数字字符，输出修改后的字符...
2018-05-08 00:28:01利用指针编写程序,从键盘输入一个字符串,删除该字符串的所有首部和尾部数字字符,输出修改后的字符串以及该字符串的长度。 举例：输入的字符串为12abcd34,删除首部和尾部数字字符后字符串变成abcd,长度为4 分析与... -
键盘输入一段字符串（数字），然后按从小到大的顺序进行排序输出
2019-12-09 20:39:55例如：输入：8245061397，...参考代码1： package com.gx.demo; import java.util.Arrays; import java.util.Scanner; public class Test1 { public static void main(String[] args) { Scanner in = new Scann... -
《Python程序设计与算法基础教程（第二版）》江红 余青松 全部章节的课后习题，上机实践，课后答案，案例...
2019-09-25 22:11:191. 这本书对Python的知识点的描述很详细，而且排版看的很舒服. 2. 几个例题：假装自己从零开始学，将一些有代表性、有意思的例题抽取出来. 3. 还有自己对一部分课后复习题，全部课后上机实践题的解题思路 -
C语言
2019-12-18 23:01:5042.C语言是一种计算机高级语言。 43.C语言允许直接访问物理地址，能进行位操作。 44.C语言是结构化程序设计语言 45.c程序要通过编译，连接才能得到可执行的目标程序 46.用c语言编写程序，可以编写出任何类型的程序 ... -
将数字转变成字符串的方法
2019-07-06 16:34:31–toFixed（）表示将数字转换为字符串，在转换后的字符串中，小数点后保留指定num位的小数。 使用方法： let a = 15.56; a.toFixed(); //'16' a.toFixed(1); //'15.6' a.toFixed(2); //'15.56' a.toFixed(5); //... -
C语言中将字符串转换为数字
2020-11-06 11:51:44strtol() 将字符串转换为长整值，并报告不能被转换的所有剩余数字 strtoul() 将字符串转换为无符号长整型值，并报告不能被转换的所有剩余数字 （1）下面的实例演示了 atof() 函数的用法。 #inclu -
入门学习Linux常用必会60个命令实例详解doc/txt
2011-06-09 00:08:45hda1中的“1”代表hda的第一个硬盘分区 (partition)，hda2代表hda的第二主分区，第一个逻辑分区从hda5开始，依此类推。此外，可以直接检查 /var/log/messages文件，在该文件中可以找到计算机开机后系统已辨认出来的... -
输入一个字符串，内有数字和非数字字符... 302tab5876 将其中连续的数字作为一个整数，一次存放到一个数组中。
2019-08-05 18:44:10302tab5876 将其中连续的数字作为一个整数，一次存放到一个数组中。 #include <stdio.h> int main() { void search(char * parr, int * pnum); char arr[100], *parr; int num[30], *pnum;... -
C语言中将字符串转换为数字的方法
2017-04-27 00:01:44C语言提供了几个标准库函数，可以将字符串转换为任意类型(整型、长整型、浮点型等)的数字。以下是用atoi()函数将字符串转换为整数的一个例子： # include # include void main (void) ; void main (void) { int... -
Python语言程序设计基础（第二版）嵩天等课后习题答案
2018-04-28 11:52:19第一次博文 Time：2018年04月28日 星期六 11:37 二次补充 2018年05月02日 第一章 程序设计基本方法 P29 # 1.1字符串的拼接 str1 = input("请输入一个人的名字：") str2 = input("请... -
输入一个字符串，统计英文字母、空格、数字和其它字符的个数
2020-02-26 18:03:50#include <stdio.h> #include <windows.h> #include <conio.h>... //输入一个字符串，统计英文字母、空格、数字和其它字符的个数 char input[inputLen]; gets(input);//输入内容 c... -
从字符串中筛选出连续的数字，并将其放入另一个数组！
2012-12-02 18:58:12题目（摘自谭克强版C语言）： 输入一个字符串，内有数字和非数字字符，如a123x456as789x123，将其中连续的数字作为一个整数，依次存放到数组a中，例如存放123在a[0]中，并统计共有多少个这样的整数，并且输出。... -
JavaScript 50道 面试题
2019-10-17 16:12:39记录一些具有代表性的js面试题...1.下面代码的输出是什么？ function sayHi(){ console.log(name); console.log(age); let name = "Tom"; let age = 18; } sayHi(); A: Tom 和 undefined B: Tom 和 Re... -
Python内置函数
2019-05-10 15:10:36bin() 返回一个整数 int 或者长整数 long int 的二进制表示。 bin() 方法的语法: bin(x) 参数： x – int 或者 long int 数字 返回值： 字符串 实例： bin(10) '0b1010' bin(20) '0b10100' ... -
Qt 生成一个固定长度的随机字符串
2018-11-26 14:10:40使用Qt的qrand()可以生成一个随机的数字，比如说，要生成100以内的随机数，可以使用qrand()%100 来实现，那么如果要生成一个固定长度的随机字符串该怎么弄呢，其实原理很简单，就是事先准备好一个字符串数组，然后... -
Python 实例教程100例
2019-12-20 10:23:36Python 100例-01题目：输有1、2、3、4个数字，能组成多少个互不相同且无重复数字的三位数？ Python 100例-02题目:企业发放的奖金根据利润提成。 Python 100例-03题目：一个整数，它加上100和加上268后都是一个完全... -
（c语言）输入一串数字，输出字符串
2017-04-16 09:42:17#include #define N 100 int main() { long num = 0; long j = 0; int count = 0; char b; char a[N]; printf("输入一组数字："); scanf("%ld",&num); j = num; -
【C语言】输入一个字符串，内有数字和... 302tab5876将其中连续的数字作为一个整数，依次存放到一个数组a中。
2019-07-31 13:26:13将其中连续的数字作为一个整数，依次存放到一个数组a中。 例如，123放在a[0]，456放在a[1]，…。共有多少个整数，并输出这些数。 #include <stdio.h> #include <math.h> #define N 100 ... -
从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。
2018-01-01 17:36:03import java.io.BufferedReader;... * 从键盘输入一个不超过8位的正的十六进制数字符串，将它转换为正的十进制数后输出。 * 注：十六进制数中的10~15分别用大写的英文字母A、B、C、D、E、F表示。 */ public class M -
C 语言编程 经典例题一百道 37 输入一串数字进行排序（冒泡法）
2018-08-29 22:41:38方法一 #include <stdio.h> int main() { int a[10],b[1]; // b[ ] 用来暂时储存数据，作用是用来转换a[i]和a[i+1]的数据 int i,j; printf("请输入10个数:\n") ; for (i = 0 ; i ... -
将字符串中从第m个字符开始的n个字符复制到另一个字符串；字符串反序输出；用递归法将整数转换成字符串；...
2019-04-02 13:10:34一些C语言关于字符串的题目 -
输入一个字符串，统计其中数字字符出现的次数
2019-11-05 08:39:08输入一个字符串，统计其中数字字符出现的次数（题目来源：C语言程序设计 第三版） #include<stdio.h> int main() { char a[1000]; int i,n,m=0; printf("请输入正整数n的值：\n"); scanf("%d",&n); ... -
Python 入门&环境搭建&变量&数据类型
2019-09-16 18:36:07Python 是一种跨平台的计算机程序设计语言。 是一种面向对象的动态类型语言，最初被设计用于编写自动化脚本(shell)，随着版本的不断更新和语言新功能的添加，越来越多被用于独立的、大型项目的开发。 Python 应用... -
浦发银行 信息科技岗 大数据方向 面经
2018-08-09 23:00:31一、综合面 二、机试 三、专业面试 浦发面经 即兴演讲 上机测试 结构化面试 浦发银行大数据创新岗上海打卡 第一部分 综合面试 第二部分 专业面试 第三部分 上机考试（只有开发和测试岗需要，别的岗可选） 浦发... -
7-3 计算平均成绩
2019-03-27 12:45:20定N个学生的基本信息，包括学号（由5个数字组成的字符串）、姓名（长度小于10的不包含空白字符的非空字符串）和成绩（[0,100]区间内的整数），要求计算他们的平均成绩，并顺序输出平均线以下的学生名单。 输入格式：...
收藏数
317,656
精华内容
127,062