MT1001-1031（语言基础：基本输入输出）（py）

原创已于 2025-06-15 00:01:06 修改 · 918 阅读

15 ·

CC 4.0 BY-SA版权

文章标签：

#python #算法

于 2025-06-14 23:59:28 首次发布

MT1001 程序设计入门

欢迎来到程序设计的世界，请编写一个简单程序，输出2行字符，第一行为“This is my first program!”，第二行为“Coding is fun!”

格式

输入格式：无

输出格式：第一行为“This is my first program!”，第二行为“Coding is fun!”

样例 1

输入：无

输出：This is my first program!

Coding is fun!

#print("This is my first program!")
#print("Coding is fun!")
print("This is my first program!\nCoding is fun!")

MT1002 输入和输出整型数据

请编写一个简单程序，用户输入一个整数存储在变量中，并输出在屏幕上。

格式
        输入格式：一个整型数据
        输出格式：输出You entered:刚才输入的整型数据
样例 1
        输入：3
        输出：You entered:3

n=input()
m=int(n)
print(f"You entered:{n}")

MT1003 整数运算

请编写一个简单程序，用户输入2个整型数据存储在变量中，并输出他们的和与差。

格式
        输入格式：2个整型数据，用逗号分隔
        输出格式：输出分两行，分别输出他们的和与差
样例 1
        输入：3,5
        输出：3+5=8
         3-5=-2

input_str = input()
parts = input_str.split(',')
n = int(parts[0].strip())
m = int(parts[1].strip())
print(f"{n}+{m}={n+m}\n{n}-{m}={n-m}")

MT1004 求余

请编写一个简单程序，用户输入2组整型数据存储在变量中，并输出两组数相除的余数。（不考虑除数为0）

格式
        输入格式：输入2组整型数据，用空格分隔
输出格式：
        输出分两行，分别输出两组数相除的余数
样例 1
        输入：8 2
-9 7
        输出： 8%2=0
-9%7=-2

import math
a=input()
b=input()
c,d=map(int,a.split())
m,n=map(int,b.split())
rem1=int(math.fmod(c,d))
rem2=int(math.fmod(m,n))
print(f"{c}%{d}={rem1}\n{m}%{n}={rem2}")

MT1005 输入和输出实型数据

请编写一个简单程序，用户输入一个float型数据和一个double型数据，存储在变量中，并输出在屏幕上。

格式
        输入格式：第一个是float型数据，第二个是double型数据，用空格分隔
        输出格式：输出You entered:… and …(…处依序输出刚才输入的数据），第一个float型数据保留2位小数，第二个double型数据保留3位小数
样例 1
        输入：3.1234 4.5
        输出：You entered:3.12 and 4.500

a=input()
c,b=map(float,a.split())
print(f"You entered:{c:.2f} and {b:.3f}")

MT1006 实型数运算

请编写一个简单程序，用户输入2个实型数据存储在变量中，并输出他们的乘积与商。（本题不考虑除数为0的情况）

格式
        输入格式：2个实型数据，用空格分隔
        输出格式：输出分两行，分别输出他们的乘积与商
样例 1
        输入：3.1 4.2
        输出：3.100000*4.200000=13.020000
                 3.100000/4.200000=0.738095

n=input()
a,b=map(float,n.split())
print(f"{a:.6f}*{b:.6f}={a*b:.6f}\n{a:.6f}/{b:.6f}={a/b:.6f}")

MT1007 平均分

输入一名学生的C++、python和C语言成绩，输出总分和和平均分。不考虑不合理的输入或是溢出等特殊情况。

格式
        输入格式：输入为实型，空格分隔
        输出格式：输出为实型，保留6位小数
样例 1
        输入：95 87.5 66
        输出：248.500000
82.833333

n=input()
a,b,c=map(float,n.split())
x=a+b+c
y=x/3
print(f"{x:.6f}\n{y:.6f}")

MT1008 圆球等的相关计算

请编写一个简单程序，输入半径和高，输出圆周长，圆面积，球面积，球体积，圆柱体积。(PI = 3.1415926)

格式
        输入格式：输入为double型
        输出格式：分行输出，保留2位小数
样例 1
        输入：1.5 3
        输出：9.42
7.07
28.27
14.14
21.21

PI=3.1415926
n=input()
a,b=map(float,n.split())
c=2*PI*a
s=PI*a*a
q=4*PI*a*a
S=(4*PI*a*a*a)/3
v=PI*a*a*b
print(f"{c:.2f}\n{s:.2f}\n{q:.2f}\n{S:.2f}\n{v:.2f}")

MT1009 公式计算

格式
        输入格式：输入为整型x,a，空格分隔
        输出格式：输出为实型，保留2位小数
样例 1
        输入：1 1
        输出：0.75

n=input()
x,a=map(int,n.split())
z=(a+x)/(4*a)
b=(a*x+z)/2
print(f"{b:.2f}")

MT1010 输入和输出字符型数据

请编写一个简单程序，用户输入2个的字符型数据存储在变量中，并分别以字符形式和整数形式输出在屏幕上。

格式
        输入格式：2个的字符型数据，用逗号分隔
        输出格式：输出两行The ASCII code of… is … (…处依次输出刚才输入的数据字符形式和整数形式）
样例 1
        输入：A,B
        输出：The ASCII code of A is 65
The ASCII code of B is 66

n=input()
a,b=map(str,n.split(','))
print(f"The ASCII code of {a} is {ord(a)}\nThe ASCII code of {b} is {ord(b)}")

MT1011 字符和整数

输出X、65的字符、十进制数据形式。

格式
        输入格式：无
        输出格式：输出字符、十进制整数，空格分隔
样例 1
        输入：无
        输出：X 88

A 65

print(f"X {ord('X')}\nA {ord('A')}")

MT1012 各种类型长

请编写一个简单程序，输出int、float、double和char的大小。

格式
        输入格式：无
        输出格式：输出分4行，分别输出int、float、double和char的大小
样例 1
        输入：无
        输出：Size of int: 4 bytes
Size of float: 4 bytes
Size of double: 8 bytes
Size of char: 1 byte

import struct
print(f"Size of int: {struct.calcsize('i')} bytes")
print(f"Size of float: {struct.calcsize('f')} bytes")
print(f"Size of double: {struct.calcsize('d')} bytes")
print(f"Size of char: {struct.calcsize('c')} byte")

MT1013 关键字long

请编写一个简单程序，输出int、long int、long long int、double和long double的大小。

格式
输入格式：无
输出格式：输出分5行，分别输出int、long int、long long int、double和long double的大小
样例 1
输入：无
输出：Size of int = 4 bytes
Size of long int = 8 bytes
Size of long long int = 8 bytes
Size of double = 8 bytes
Size of long double = 16 bytes

import struct
print(f"Size of int = {struct.calcsize('i')} bytes")
print(f"Size of long int = {struct.calcsize('l')} bytes")
print(f"Size of long long int = {struct.calcsize('q')} bytes")
print(f"Size of double = {struct.calcsize('d')} bytes")
print(f"Size of long double = {struct.calcsize('d')*2} bytes")

MT1014 日期

编写一个程序，以月/日/年（mm/dd/yyyy）的形式输入日期（其中月，日为1-2位整数，年为1-4位整数），然后以yyyymmdd的形式显示（其中月，日为2位整数，年为4位整数）。不考虑不合理的输入或是溢出等特殊情况。

格式
输入格式：输入为整型
输出格式：输出为整型
样例 1
输入：4/1/2019
输出：20190401

n=input()
m,d,y=n.split('/')
print(f"{y.zfill(4)}{m.zfill(2)}{d.zfill(2)}")

MT1015输入分隔符

输入“a=22,b=b,c=14,d=d”给变量a、b、c、d，然后再输出他们。

格式
        输入格式：a=22,b=b,c=14,d=d
        输出格式：空格分隔
样例 1
        输入：a=22,b=b,c=14,d=d
        输出：22 b 14 d

n=input()
m=n.split(',')
a=b=c=d=None
for i in m:
    key,value=i.split('=')
    if key=='a':
        a=value
    if key=='b':
        b=value
    if key=='c':
        c=value
    if key=='d':
        d=value
print(f"{a} {b} {c} {d}")

MT1016 宽度与对齐

输出455、-123、987654，宽度为5，分别左对齐和右对齐

格式
        输入格式：无
        输出格式：输出为整型，空格分隔。每个数的输出占一行
样例 1
        输入：无
        输出：455 455
         -123 -123
987654 987654

numbers = [455, -123, 987654]
for num in numbers:
    left_aligned = f"{num:<5d}"
    right_aligned = f"{num:>5d}"
    print(f"{left_aligned} {right_aligned}")

MT1017 左右对齐

输出3.1415926、22.3456，宽度为14，精度为6，分别左对齐和右对齐。

格式
        输入格式：无
        输出格式：输出为实型，空格分隔。每个数的输出占一行。
样例 1
        输入：无
        输出：3.141593 3.141593
22.345600 22.345600

n=[3.1415926,22.3456]
for i in n:
    left_aligned=f"{i:<14.6f}"
    right_aligned=f"{i:>14.6f}"
    print(f"{left_aligned} {right_aligned}")

MT1018 输入宽度

输入123456789给变量𝑎1、𝑎2、𝑎3a1、a2、a3，宽度为3，然后输出𝑎1、𝑎2、𝑎3a1、a2、a3，空格分隔。

格式

输入格式：123456789

输出格式：输出为整型，空格分隔。

样例 1

输入：123456789

输出：123 456 789

n="123456789"
a1=n[0:3]
a2=n[3:6]
a3=n[6:9]
print(f"{a1:3} {a2:3} {a3:3}")

MT1019 宽度精度

输出18.16054、17.676767，宽度和精度由输入决定，右对齐。

格式
        输入格式：输入为宽度和精度整型，空格分隔。
        输出格式：输出为实型，空格分隔。
样例 1
        输入：6 3
        输出：18.161 17.677

n=input()
a,b=map(int,n.split())
numbers = [18.16054, 17.676767]
for num in numbers:
    formatted = f"{num:>{a}.{b}f}"
    print(formatted, end=' ')
print()

MT1020 %s格式符

输入字符串，然后输出前3个字符，要求占6列，右对齐。

格式
        输入格式：输入字符串
        输出格式：输出字符串
样例 1
        输入：Wendy
        输出：Wen

n=input()
m=n[0:3]
print(f"{m:>6s}")

MT1021 %f格式符

输入一个实数，第一次按实型输出；第二次保留2位小数输出；第三次保留3位小数但最小列宽8列输出，空格分隔。

格式
        输入格式：输入实型
        输出格式：输出实型，空格分隔。
样例 1
        输入：31331.14345435
        输出：31331.143454 31331.14 31331.143

num = float(input())
print("%f" %num,"%.2f" %num,"%8.3f" %num)

MT1022 小数、指数

输出3.1415926、12345678.123456789的小数、指数形式。

格式
        输入格式：无
        输出格式：输出为实型，空格分隔
样例 1
        输入：无
        输出：3.141593 3.141593e+000
        12345678.123457 1.234568e+007

num1 = 3.1415926
num2 = 12345678.123456789
def format_three_digit_exponent(num, precision=6):
    std_format = f"{num:.{precision}e}"
    mantissa, exponent = std_format.split('e')
    sign = exponent[0]
    exp_value = int(exponent[1:])
    formatted_exp = f"{sign}{abs(exp_value):03d}"
    return f"{mantissa}e{formatted_exp}"
print(f"{num1:.6f} {format_three_digit_exponent(num1)}")
print(f"{num2:.6f} {format_three_digit_exponent(num2)}")

MT1023 进制乱炖

输入一个正整数，输出它的十进制形式、八进制形式、十六进制形式（小写）、无符号的十进制形式，空格分隔。

格式
        输入格式：输入整型，空格分隔。
        输出格式：输出整型，空格分隔。
样例 1
        输入：33
        输出：33 41 21 33

n=int(input())
print(f"{n:d} {n:o} {n:x} {n:d}")

MT1024 进制形式

分别输出128、456789的十进制、八进制、十六进制（字母大写）数据形式。

格式
        输入格式：无
        输出格式：输出为整型，空格分隔
        样例 1
        输入：无
        输出：128 200 80
                        456789 1574125 6F855

n=128
m=456789
print(f"{n} {n:o} {n:X}")
print(f"{m} {m:o} {m:X}")

MT1025 八、十六进制

输出202、117、70、130的十进制、八进制、十六进制数据形式，结果为0ddddd或0Xddddd。

格式
        输入格式：无
        输出格式：输出为整型，空格分隔。每个数的输出占一行。
样例 1
        输入：无
        输出：202 0312 0XCA
117 0165 0X75
70 0106 0X46
130 0202 0X82

a,b,c,d=202,117,70,130
print(f"{a} 0{a:o} 0X{a:X}\n{b} 0{b:o} 0X{b:X}\n{c} 0{c:o} 0X{c:X}\n{d} 0{d:o} 0X{d:X}")

MT1026 合并

已知a、b、c是一个十进制数的百位、十位、个位，求这个十进制数。

格式
        输入格式：输入为正整型a、b、c，空格分隔
        输出格式：输出为整型
样例 1
        输入：1 3 4
        输出：134

a,b,c=input().split()
print(f"{a}{b}{c}")

MT1027 整数逆序

编写一个程序，要求输入一个两位数的数字，然后逆序输出数字。不考虑不合理的输入或是溢出等特殊情况。

格式
输入格式：输入正整数
输出格式：输出为逆序后的字符串
样例 1
输入：28
输出：82

print(input()[::-1])

MT1028 四位数逆序

将一个四位数正整数（如1278）逆序（如8721）输出。不考虑负数等特殊情况。

格式
        输入格式：输入为整型
        输出格式：输出为逆序后的字符串
样例 1
        输入：1234
        输出：4321

print(input()[::-1])

MT1029 位数

编写一个程序，计算一个数字包含多少位数。您可以假定该数字不超过四位数。本题不考虑负数或者其他特殊情况。

格式
        输入格式：输入为整型
        输出格式：输出为整型
样例 1
        输入：87
        输出：2

import math
n=int(input())
if n==0:
    print(1)
else:
    print(len(str(abs(n))))

MT1030 最大公约数

请编写一个简单程序，输入2个整数，输出他们的最大公约数。不考虑负数，0或者其他特殊情况。

格式
        输入格式：输入为整型，空格分隔
        输出格式：输出为整型
样例1
        样例 1输入：3 5
        输出：1

import math
x=list(map(int,input().split()))
result = x[0]
for num in x[1:]:
    result = math.gcd(result, num)
print(result)

MT1031 最简分数

编写一个程序，输入一个分数，然后输出它的最简分数。不考虑负数，0或者其他特殊情况。

格式
        输入格式：输入为整型
        输出格式：输出为整型
样例 1
        输入：3/6
        输出：1/2

import math
fraction = input()
numerator, denominator = map(int, fraction.split('/'))
    # 检查分母是否为零
if denominator == 0:
    print("错误：分母不能为零")
else:
    gcd_value = math.gcd(numerator, denominator)
    simplified_num = numerator // gcd_value
    simplified_den = denominator // gcd_value
    if simplified_den < 0:
        simplified_num = -simplified_num
        simplified_den = -simplified_den
    if simplified_den == 1:
        print(simplified_num)
    else:
        print(f"{simplified_num}/{simplified_den}")

时间：2025.6.14

不爱学习的大学生