def swtSwb(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
gwsL = general.random_int_list(1, 9, n) #个位数——生成一个存储个位数数字的一个长度n的列表
swsL = general.random_int_list(1, 9, n) #十位数——生成一个存储十位数数字的一个长度n的列表
#获得首尾同首尾补的乘数与被乘数的题的列表；以及获得得数列表
#首尾相同的两位数用个位数列表gwsL的数，首尾互补的两位数用十位数列表swsL的数
for i in range(n):
#随机数等于0首尾同的数在“×”前面，随机数等于1首尾补的数在“×”后面
if random.randint(0, 1) == 0:
ystL.append(
str(swsL[i] * 10 + swsL[i]) + '×' +
str((10 - gwsL[i]) * 10 + gwsL[i]))
else:
ystL.append(
str((10 - gwsL[i]) * 10 + gwsL[i]) + '×' +
str(swsL[i] * 10 + swsL[i]))
dsL.append(
str((swsL[i] * 10 + swsL[i]) * ((10 - gwsL[i]) * 10 + gwsL[i])))
tk.append(ystL)
tk.append(dsL)
return tk
def twSOn(n):
#参数n为题数
dsL = [] #得数列表
ystL = [] #运算题列表11-12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bjsL = general.random_int_list(11, 99, n) #被减数的两位数列表
jsL = general.random_int_list(1, 9, n) #减数的一位数列表
#获得题与答案
for i in range(n):
dsL.append(str(bjsL[i] - jsL[i]))
ystL.append(str(bjsL[i]) + '-' + str(jsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def foAFo(n):
#参数n为题数
dsL = [] #得数列表
ystL = [] #运算题列表11+12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bjsL = general.random_int_list(1000, 9999, n) #被加数的四位数列表
jsL = general.random_int_list(1000, 9999, n) #加数的四位数列表
#获得题与答案
for i in range(n):
dsL.append(str(bjsL[i] + jsL[i]))
ystL.append(str(bjsL[i]) + '+' + str(jsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def thThMul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标0得数列表ds；下标1为题；
bcsL = general.random_int_list(100, 999, n) #三位数列表，有n个三位数
csL = general.random_int_list(100, 999, n) #三位数列表，有n个三位数
#获得题与答案
for i in range(n):
dsL.append(str(bcsL[i] * csL[i]))
ystL.append(str(bcsL[i]) + '×' + str(csL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def twMTw(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标0得数列表ds；下标1为题；
bcsL = general.random_int_list(10, 99, n) #十位数——生成一个存储十位数数字的一个长度n的列表
csL = general.random_int_list(10, 99, n) #个位数——生成一个存储个位数数字的一个长度n的列表
#获得题与答案
for i in range(n):
dsL.append(str(bcsL[i] * csL[i]))
ystL.append(str(bcsL[i]) + '×' + str(csL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def eTNMul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
gwsL = general.random_int_list(11, 19, n) #被乘数列表——生成一个存储11~19范围内的一个长度n的列表
swsL = general.random_int_list(11, 19, n) #乘数列表——生成一个存储11~19范围内的一个长度n的列表
#获得两个11~19的数相乘的列表；以及获得得数列表
for i in range(n):
ystL.append(str(gwsL[i]) + '×' + str(swsL[i]))
dsL.append(str(gwsL[i] * swsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def mul100_110(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bcsL = general.random_int_list(100, 110, n) #被乘数列表——生成一个存储100~110范围内的一个长度n的列表
csL = general.random_int_list(100, 110, n) #乘数列表——生成一个存储100~110范围内的一个长度n的列表
#获得两个接近接近100的数相乘的列表；以及获得得数列表
for i in range(n):
ystL.append(str(bcsL[i]) + '×' + str(csL[i]))
dsL.append(str(bcsL[i] * csL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def jj200Mul(n):
print("思考何为接近200的数，什么范围的数更适合这个方法")
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bcsL = general.random_int_list(180, 220, n) #被乘数列表——生成一个存储180~220范围内的一个长度n的列表
csL = general.random_int_list(180, 220, n) #乘数列表——生成一个存储180~220范围内的一个长度n的列表
#获得两个接近接近200的数相乘的列表；以及获得得数列表
for i in range(n):
ystL.append(str(bcsL[i]) + '×' + str(csL[i]))
dsL.append(str(bcsL[i] * csL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def jj50Mul(n):
print("思考何为接近50的数，什么范围的数更适合这个方法")
print("试行接近50的数的范围为30~70")
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
gwsL = general.random_int_list(30, 70, n) #被乘数列表——生成一个存储30~70范围内的一个长度n的列表
swsL = general.random_int_list(30, 70, n) #乘数列表——生成一个存储30~70范围内的一个长度n的列表
#获得两个接近接近50的数相乘的列表；以及获得得数列表
for i in range(n):
ystL.append(str(gwsL[i]) + '×' + str(swsL[i]))
dsL.append(str(gwsL[i] * swsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def w1LwMul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
gwsL = general.random_int_list(1, 9,
n) #乘数的十位数——生成一个存储尾数为1的两位数的十位数字的一个长度n的列表
swsL = general.random_int_list(1, 9,
n) #被乘数的十位数——生成一个存储尾数为1的两位数十位数数字的一个长度n的列表
#获得两个尾数为1的两位数列表；以及获得得数列表
for i in range(n):
ystL.append(str(gwsL[i] * 10 + 1) + '×' + str(swsL[i] * 10 + 1))
dsL.append(str((gwsL[i] * 10 + 1) * (swsL[i] * 10 + 1)))
tk.append(ystL)
tk.append(dsL)
return tk
def foATh(n):
#参数n为题数
dsL = [] #得数列表
ystL = [] #运算题列表11+12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bjsL = general.random_int_list(1000, 9999, n) #被加数的三位数列表
jsL = general.random_int_list(100, 999, n) #加数的两位数列表
#获得题与答案
for i in range(n):
#随机数等于0更高位数的在“+”前面，随机数等于1更高位数的在“+”后面
if random.randint(0, 1) == 0:
ystL.append(str(bjsL[i]) + '+' + str(jsL[i]))
else:
ystL.append(str(jsL[i]) + '+' + str(bjsL[i]))
dsL.append(str(bjsL[i] + jsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def gtsb(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
gwsL = general.random_int_list(0, 9, n) #个位数——生成一个存储个位数数字的一个长度n的列表
swsL = general.random_int_list(1, 9, n) #十位数——生成一个存储十位数数字的一个长度n的列表
#获得个位相同十位互补的乘数与被乘数的题的列表；以及获得得数列表
for i in range(n):
dsL.append(
str((swsL[i] * 10 + gwsL[i]) * ((10 - swsL[i]) * 10 + gwsL[i])))
ystL.append(
str(swsL[i] * 10 + gwsL[i]) + '×' +
str((10 - swsL[i]) * 10 + gwsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def thTwMul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标0得数列表ds；下标1为题；
thL = general.random_int_list(100, 999, n) #三位数列表，有n个三位数
twL = general.random_int_list(10, 99, n) #两位数列表，有n个两位数
#获得题与答案
for i in range(n):
#随机数等于0数三位数“×”前面，随机数等于1两位数在“×”后面
if random.randint(0, 1) == 0:
ystL.append(str(thL[i]) + '×' + str(twL[i]))
else:
ystL.append(str(twL[i]) + '×' + str(thL[i]))
dsL.append(str(thL[i] * twL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def foSFo(n):
#参数n为题数
dsL = [] #得数列表
ystL = [] #运算题列表11-12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bjsL = general.random_int_list(1000, 9999, n) #被减数的三位数列表
jsL = general.random_int_list(1000, 9999, n) #减数的三位数列表
#获得题与答案
for i in range(n):
if bjsL[i] > jsL[i]:
dsL.append(str(bjsL[i] - jsL[i]))
ystL.append(str(bjsL[i]) + '-' + str(jsL[i]))
else:
dsL.append(str(jsL[i] - bjsL[i]))
ystL.append(str(jsL[i]) + '-' + str(bjsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def swxt(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
swsL = general.random_int_list(1, 9, n) #十位数——生成一个存储十位数数字的一个长度n的列表
gwsL = general.random_int_list(0, 9, n) #个位数——生成一个存储个位数数字的一个长度n的列表
#获得十位相同的两位数的乘数与被乘数的题的列表；以及获得得数列表
for i in range(n):
dsL.append(
str((swsL[i] * 10 + random.randint(0, 9)) *
(swsL[i] * 10 + random.randint(0, 9))))
ystL.append(
str((swsL[i] * 10 + random.randint(0, 9))) + '×' +
str(swsL[i] * 10 + random.randint(0, 9)))
tk.append(ystL)
tk.append(dsL)
return tk
def n999Mul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
bcsL = general.random_int_list(10, 99, n / 4) + general.random_int_list(
100, 999, n / 4
) + general.random_int_list(1000, 9999, n / 4) + general.random_int_list(
10000, 99999, n / 4
) #四位数以内任意数，该任意数等分成4份其中一份是两位数任意数、一份三位数任意数、一份四位数任意数、一份五位数任意数——生成以上任意数的一个长度n的列表
#获得任意数乘999的计算题列表；以及获得得数列表
for i in range(n):
#随机数等于0数999“×”前面，随机数等于1任意数在“×”后面
if random.randint(0, 1) == 0:
ystL.append(str(bcsL[i]) + '×' + str(999))
else:
ystL.append(str(999) + '×' + str(bcsL[i]))
dsL.append(str(999 * bcsL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
def th11Mul(n):
#参数n为题数也就是乘数与被乘数的个数
dsL = [] #得数列表
ystL = [] #运算题列表11*12
tk = [] #题库列表输出列表，下标1得数列表ds；下标0为题；
thDigL = general.random_int_list(100, 999, n) #三位数列表
#获得三位数乘11的计算题列表；以及获得得数列表
for i in range(n):
#随机数等于0数11“×”前面，随机数等于1三位数在“×”后面
if random.randint(0, 1) == 0:
ystL.append(str(thDigL[i]) + '×' + str(11))
else:
ystL.append(str(11) + '×' + str(thDigL[i]))
dsL.append(str(11 * thDigL[i]))
tk.append(ystL)
tk.append(dsL)
return tk
