一：前言：
emmmm，最近报了蓝桥杯的比赛嘛，python那组的，本以为要花300RMB，但是呢，学校居然给报销~~~~~~（真好~），老师也给了我鼓励（说省三有手就行。。( ˘•ω•˘ )），既然报了，那就
稍稍用点心吧。。咕咕咕。。。于是就有了这篇文章，记录一下自己的学习进程。
二：竞赛题：
1.麦森数：
题目描述
形如 2^P 的素数称为麦森数，这时 P 一定也是个素数。但反过来不一定，即如果 是个素数，2^P-1 不一定也是素数。到 1998 年底，人们已找到了 37个麦森数。最大的一个是，它有 909526 位。麦森数有许多重要应用，它与完全数密切相关。
任务：从文件中输入 P（1000<P<3.1 * 10^6），计算 2P-1的位数和最后 500位数字（用十进制高精度数表示）
输入描述
输入一个整数 P（1000<P<3.1 * 10^6）
输出描述
输出 11行。
第 1 行：十进制高精度数 2^P-1的位数。
第 2-11 行：十进制高精度数 2^P-1 的最后 500位数字。（每行输出 50位，共输出 10行，不足 500位时高位补 0 ）
输入输出样例
示例 1
输入
1279
输出
386 00000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000 00000000000000104079321946643990819252403273640855 38615262247266704805319112350403608059673360298012 23944173232418484242161395428100779138356624832346 49081399066056773207629241295093892203457731833496 61583550472959420547689811211693677147548478866962 50138443826029173234888531116082853841658502825560 46662248318909188018470682222031405210266984354887 32958028878050869736186900714720710555703168729087
运行限制
- 最大运行时间：1s
- 最大运行内存: 128M
解题过程的问题：
1.不知道如何限制每行输出的字符个数
2.不知道如何才能取出最后面的500位数字
3.不知道如何减少运算量
4.输出位数的方法比较恶心
参考答案
import math
P = int(input())
x = pow(2,P)-1
print(int(math.log10(2)*P)+1) #这里的标准答案非常恶心，这个公式很难想，需要一定是数学基础，就是说一个数的位数可以由lg(x)+1得到然后把2^p带进去（来自数学大佬的解说）
x =x % pow(10,500) #将数字减小，否则后面的取余运算的时间会比较大，为什么要这样减小？
l = []
for i in range(500):
i = l.append(x%10)
x = x//10
for i in range(499,-1,-1):
print(l[i],end = "")
if i % 50 ==0: #控制每行输出50位
print("")
2.门牌制作：
小蓝要为一条街的住户制作门牌号。
这条街一共有 2020 位住户，门牌号从 1 到 2020 编号。
小蓝制作门牌的方法是先制作 0 到 9 这几个数字字符，最后根据需要将字符粘贴到门牌上，例如门牌 1017 需要依次粘贴字符 1、0、1、7，即需要 1 个字符 0，2 个字符 1，1 个字符 7。
请问要制作所有的 1 到 2020 号门牌，总共需要多少个字符 2？
result = 0
for i in range(1,2021)
x = list(str(i)) //list ->将元组或字符串转换为列表，把i转化成字符串，用count进行统计
b = x.count('2') //count统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
result += b
print(b)
3.寻找2020
小蓝有一个数字矩阵，里面只包含数字 0 和 2。小蓝很喜欢 2020，他想找到这个数字矩阵中有多少个 2020 。小蓝只关注三种构成 2020 的方式：
• 同一行里面连续四个字符从左到右构成 2020。
• 同一列里面连续四个字符从上到下构成 2020。
• 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。
• 在一条从左上到右下的斜线上连续四个字符，从左上到右下构成 2020。 例如，对于下面的矩阵：
220000
000000
002202
000000
000022
002020
一共有 5 个 2020。其中 1 个是在同一行里的，1 个是在同一列里的，3个是斜线上的。 小蓝的矩阵比上面的矩阵要大，由于太大了，他只好将这个矩阵放在了一个文件里面，在试题目录下有一个文件 2020.txt，里面给出了小蓝的矩阵。 请帮助小蓝确定在他的矩阵中有多少个 2020。
求解过程中只需要区分好行列之间的关系即可，无思维含量
content = []
with open('2020.txt') as fp: #打开文件的方式
for line in fp.readlines(): #readlines() 方法用于读取所有行(直到结束符 EOF)并返回列表，该列表可以由 Python 的 for... in ... 结构进行处理。
content.append(list(line.strip())) # strip() 方法用于移除字符串头尾指定的字符（默认为空格或换行符）或字符序列，如果不这样会自动换行
row = len(line) #一横排有多少
col = len(content) #一竖排有多少
sum = 0
#横排遍历
for i in range(col):
for j in range(row - 3):
if content[i][j] == "2" and content[i][j+1] == "0" and content[i][j+2] == "2" and content[i][j+3] == "0":
sum +=1
#竖排遍历
for i in range(row-3):
for j in range(col):
if content[i][j] == "2" and content[i+1][j] == "0" and content[i+2][j] == "2" and content[i+3][j] == "0":
sum +=1
#斜向遍历
for i in range(row-3):
for j in range(col-3):
if content[i][j]=="2" and content[i+1][j+1]=="0" and content[i+2][j+2]=="2" and content[i+3][j+3]=="0":
sum+=1
print(sum)
4.跑步锻炼
【问题描述】
小蓝每天都锻炼身体。
正常情况下，小蓝每天跑1千米。如果某天是周一或者月初(1日)，为了激励自己，小蓝要跑2千米。如果同时是周一或月初，小蓝也是跑2千米。
小蓝跑步已经坚持了很长时间，从2000年1月1日周六（含）到2020年10月1日周四(含)。请问这段时间小蓝总共跑步多少千米?
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。
sum_ = 0 j = 1 s = 0 month = [0,31,28,31,30,31,30,31,31,30,31,30,31] a = 2000 while a < 2020: j = 1 if a%4 == 0: month[2] = 29 while j<=12: if (sum_ +6)%7 != 1: s = s+1 sum_ += month[j] j = j + 1 if month[2] == 29: month[2] = 28 a = a + 1 month[2] = 29 b = 1 while b<=9: if (sum_ +6)%7 != 1: s = s+1 sum_ += month[b] b = b+1 sum_+= 1 s +=1 d = (sum_ - 2 + 6) / 7 z = sum_+ s +d print(int(z))
5.单词分析
小蓝正在学习一门神奇的语言，这门语言中的单词都是由小写英文字母组成，有些单词很长，远远超过正常英文单词的长度。
小蓝学了很长时间也记不住一些单词，他准备不再完全记忆这些单词，而是根据单词中哪个字母出现得最多来分辨单词。
现在，请你帮助小蓝，给了一个单词后，帮助他找到出现最多的字母和这个字母出现的次数。
【输入格式】
输入一行包含一个单词，单词只由小写英文字母组成。
【输出格式】
输出两行，第一行包含一个英文字母，表示单词中出现得最多的字母是哪个。
如果有多个字母出现的次数相等，输出字典序最小的那个。
第二行包含一个整数，表示出现得最多的那个字母在单词中出现的次数。
【样例输入】
lanqiao
【样例输出】
a
2
【样例输入】
longlonglongistoolong
【样例输出】
o
6
【评测用例规模与约定】
对于所有的评测用例，输入的单词长度不超过 1000。
words = input()
a = []
for i in words: //遍历单词
a.append(words.count(i)) //将单词出现次数放入列表
print(words[a.index(max(a))]) //通过index方法返回查找对象的索引位置
print(max(a))
6.数列求值
【问题描述】
给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求第 20190324 项的最后 4 位数字。
【答案提交】
这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个 4 位整数（提示：答案的千位不为 0），在提交答案时只填写这个整数，填写多余的内容将无法得分。
n = 20190324
a = [1,1,1]
for i in range(n-3):
c = a[i] + a[i+1] + a[i+2]
a.append(c%10000) #注意，直接将C添加至列表中，导致运算量过大会导致内存错误报错MemoryError：涉及到了读取、保存、写入，内存不够用了,且后取余五位不会影响结果
b = str(a[-1])
#此方法为错误的因为到了20190323之后（i+2）将溢出数组故：
N = 20190324
l = [1,1,1]
for i in range(3,20190324):
x = l[i-1]+l[i-2]+l[i-3]
l.append(x%10000)
print(l[-1])
7.年号字串
【问题描述】
小明用字母 A 对应数字 1， B 对应 2，以此类推，用 Z 对应 26。对于 27以上的数字，小明用两位或更长位的字符串来对应，例如 AA 对应 27， AB 对应 28， AZ 对应 52， LQ 对应 329。请问 2019 对应的字符串是什么？
思路：这题考的是进制转换，
直接手算就行了，数据为2019又不大：
如AA：
27%26=1 ->对应A
27//26=1
1%26=1 ->对应A 所以27(10进制)转换为26进制为AA
（329）LQ同理：
329%26=17 ->对应Q
329//26=12
12%26=12 ->对应L，所以329(10进制)转换为26进制为LQ
题目要求的2019同理：
2019%26=17 ->对应Q
2019//26=77
77%26=25 ->对应Y
77//26=2
2%26=2 ->对应B，所以2019(10进制)转26进制为BYQ
8.数的分解
【问题描述】
把 2019 分解成 3 个各不相同的正整数之和，并且要求每个正整数都不包含数字 2 和 4，一共有多少种不同的分解方法？
注意交换 3 个整数的顺序被视为同一种方法，例如 1000+1001+18 和 1001+1000+18 被视为同一种。
两个没注意到的点
- 正整数不包括0
- 3个不同的数(看题很重要)
所以审题~~~~~~~很重要啊
#思路：2019分解成3个不同的数。为了简化运算，我们把2019分解到 x，y，z三个数中
#不包含2和4，那么通过if判断，将数字转成字符串，然后通过遍历字符串的方式排查2和4
#其中 x最大值为2019 // 3 (673)
count = 0
for x in range(673):
x = x +1
for y in range(x+1,1346):
if '2' not in str(y) and '4' not in str(y) and '2'not in str(x) and '4' not in str(x):
z = 2019 - x - y
if z > y and '2' not in str(z) and '4' not in str(z):
count += 1
print(count)
#2021/4/17 重做一遍后发现有很多细节上的错误，比如第二个循环写成了(675,1265),第三个循环没有判断等等，所以必须得用一些自己可以手算的例子进行判断程序是否正确
9.等差数列
【问题描述】
数学老师给小明出了一道等差数列求和的题目。但是粗心的小明忘记了一部分的数列，只记得其中N个整数。
现在给出这N个整数，小明想知道包含这N个整数的最短的等差数列有几项?
【输入格式】
输入的第一行包含一个整数N。
第二行包含N个整数Ai,Ag,… ,Ax。(注意A1~Ax并不一定是按等差数列中的顺序给出)
【输出格式】
输出一个整数表示答案。
【样例输入】
5
2 6 4 10 20
【样例输出】
10
【样例说明】
包含2、6、4、10、20的最短的等差数列是2、4、6、8、10、12、14、16、18、20。
思路：1.对数据进行排序，使用列表进行存储
2：前项减后项。记录公差，算出最小公差
3：最大项-最小项+1 = 项数
n = int(input()) s = 100000 demo = list(map(int,input().split())) # map(function, iterable, ...)function -- 函数 iterable -- 一个或多个序列 demo.sort() for i in range(1,len(demo)): cha = int(demo[i] - demo[i-1]) if s > cha: s = cha count = int(max(demo) - min(demo)/s + 1) print(count)
1、split()函数
语法：str.split(str=””,num=string.count(str))[n]
参数说明：
str： 表示为分隔符，默认为空格，但是不能为空(”)。若字符串中没有分隔符，则把整个字符串作为列表的一个元素
num：表示分割次数。如果存在参数num，则仅分隔成 num+1 个子字符串，并且每一个子字符串可以赋给新的变量
[n]： 表示选取第n个分片
注意：当使用空格作为分隔符时，对于中间为空的项会自动忽略
>>> u = "www.doiido.com.cn"
#使用默认分隔符
>>> print u.split()
['www.doiido.com.cn']
#以"."为分隔符
>>> print u.split('.')
['www', 'doiido', 'com', 'cn']
#分割0次
>>> print u.split('.',0)
['www.doiido.com.cn']
#分割一次
>>> print u.split('.',1)
['www', 'doiido.com.cn']
#分割两次
>>> print u.split('.',2)
['www', 'doiido', 'com.cn']
#分割两次，并取序列为1的项
>>> print u.split('.',2)[1]
doiido
#分割最多次（实际与不加num参数相同）
>>> print u.split('.',-1)
['www', 'doiido', 'com', 'cn']
#分割两次，并把分割后的三个部分保存到三个文件
>>> u1,u2,u3 = u.split('.',2)
>>> print u1
www
>>> print u2
doiido
>>> print u3
com.cn
10.进制转换
问题描述
给定n个十六进制正整数，输出它们对应的八进制数。
输入格式
输入的第一行为一个正整数n （1<=n<=10）。
接下来n行，每行一个由0-9、大写字母A~F组成的字符串，表示要转换的十六进制正整数，每个十六进制数长度不超过100000。
输出格式
输出n行，每行为输入对应的八进制正整数。
【注意】
输入的十六进制数不会有前导0，比如012A。
输出的八进制数也不能有前导0。
样例输入
2
39
123ABC
样例输出
71
4435274
【提示】
先将十六进制数转换成某进制数，再由某进制数转换成八进制。
n = int(input())
l = []
for i in range(n):
if n<=10:
s = input()
if len(s) < 100000:
res_1 = int(s,16) #这里的int(s,16)代表把16进制的S转化成10进制
res_2 = oct(res_1)#这里的OCT代表把一个整数转化为八进制
l.append(res_2)
for i in l:
print(i[2:])#这里的[2:]是代表结果从第三位开始输出
'''本题目可以将输入的16进制数转化为某进制，再将某进制转化为8进制，
于是我在这里拓展一下进制转化的一些方法：
在python中二进制用0b加相应数字来表示，8进制用0o加相应数字来表示，16进制用0x加相应数字来表示。即：
#其他进制转换二进制#
>>> bin(2) #十进制转换二进制#
'0b10'
>>> bin(0o10) #八进制转换二进制#
'0b1000'
>>> bin(0xf) #十六进制转换二进制#
'0b1111'
#其他进制转换为八进制#
>>> oct(0b101)
'0o5'
>>> oct(0xf)
'0o17'
>>> oct(0o123)
'0o123'
#其他进制转换为十六进制#
>>> hex(0o10)
'0x8'
>>> hex(3)
'0x3'
>>> hex(0b111)
'0x7'
'''
'''
#其他进制转换为十进制#
>>> int(0o10)
8
>>> int(0xf)
15
>>> int(0b10)
2
'''
原文链接：https://blog.csdn.net/Harry______/article/details/109142479
11.特殊回文数：
输入一个正整数n， 编程求所有这样的五位和六位十进制数，满足各位数字之和等于n 。
989989
998899
a = int(input())
sum = 0
for i in range(10000,1000000):
i = str(i)
if i == i[::i]
for j in i :
sum += j
if a == sum:
print(i)
else:
sum = 0
补充：
print(a[-1]) ###取最后一个元素
[5]
print(a[:-1]) ### 除了最后一个取全部
[ 1 2 3 4 ]
print(a[::-1]) ### 取从后向前（相反）的元素
[ 5 4 3 2 1 ]
print(a[2::-1]) ### 取从下标为2的元素翻转读取
[ 3 2 1 ]
12.杨辉三角：
杨辉三角形又称Pascal三角形，它的第i+1行是(a+b)i的展开式的系数。
它的一个重要性质是：三角形中的每个数字等于它两肩上的数字相加。
给出n，输出它的前n行。
输入包含一个数n。
1 1
1 2 1
1 3 3 1
#前两行的数固定
#取最后一行去计算下一行
a = int(input())
num = []
nums = [1]
for x in range(a):
for z in range(x+1)：
if z==0 or z==x:
num.append(1)
else:
num.append(nums[z-1] + nums[z])
[print(i,end = ' ') for i in num]
print()
nums = []
[nums.append(i) for i in num]
num = []
13字母图形
利用字母可以组成一些美丽的图形，下面给出了一个例子：
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
这是一个5行7列的图形，请找出这个图形的规律，并输出一个n行m列的图形。
BABCDEF
CBABCDE
DCBABCD
EDCBABC
a,b = map(int,input().split())
z = 'A'
for x in range(1,b):
z = z + chr(65+x)
print(z)
for x in range(1,a+1):
z = chr(65+x) + z
z=z[0:b]
print(z)
n = 32
i = 0
[print("{0:05b}".format(i)) for i in range(n)]
关于format：
相对基本格式化输出采用‘%’的方法，format()功能更强大，该函数把字符串当成一个模板，通过传入的参数进行格式化，并且使用大括号‘{}’作为特殊字符代替‘%’
'{0}, {1}, {2}'.format('a', 'b', 'c')
'a, b, c'
'{}, {}, {}'.format('a', 'b', 'c') # 3.1+版本支持
'a, b, c'
'{2}, {1}, {0}'.format('a', 'b', 'c')
'c, b, a'
'{2}, {1}, {0}'.format(*'abc') # 可打乱顺序
'c, b, a'
'{0}{1}{0}'.format('abra', 'cad') # 可重复
'abracadabra'
14Fibonacci数列
Fibonacci数列的递推公式为：Fn=Fn-1+Fn-2，其中F1=F2=1。
当n比较大时，Fn也非常大，现在我们想知道，Fn除以10007的余数是多少。
输入格式
输入包含一个整数n。
输出格式
输出一行，包含一个整数，表示Fn除以10007的余数。
说明：在本题中，答案是要求Fn除以10007的余数，因此我们***只要能算出这个余数即可***，而不需要先计算出Fn的准确值，再将计算的结果除以10007取余数，直接计算余数往往比先算出原数再取余简单。
样例输入
10
样例输出
55
样例输入
22
样例输出
7704
数据规模与约定
1 <= n <= 1,000,000
#此题解题的步骤不难，但是容易出现超时和内存占用过大，必须简化算法 n = int(input()) res1, res2 = 1, 1 for i in range(3, n+1): res1, res2 = res2 % 10007, (res1 + res2) % 10007 #res1=res2%10007 res2=(res1+res2)%10007 print(res2)
同样同种类型题：
n = int(input()) sum = int(n*(n+1)/2) #使用数列求和的办法 print(sum)
统计 python 列表中每种相同元素出现的次数：
import collections
lst = ['Albatross', 'Albatross', 'Yellow_breasted_Chat', 'Albatross', 'Yellow_breasted_Chat', 'Yellow_breasted_Chat',
'Cuckoo', 'Cuckoo', 'Cuckoo', 'Cuckoo']
dic = collections.Counter(lst)
# Counter({'Cuckoo': 4, 'Albatross': 3, 'Yellow_breasted_Chat': 3})
print(dic)
for key in dic:
print(key, dic[key]) # key是元素,dic[key]是元素出现的次数
15.日志统计
小明维护着一个程序员论坛。现在他收集了一份”点赞”日志，日志共有N行。其中每一行的格式是：
ts id
表示在ts时刻编号id的帖子收到一个”赞”。
现在小明想统计有哪些帖子曾经是”热帖”。如果一个帖子曾在任意一个长度为D的时间段内收到不少于K个赞，小明就认为这个帖子曾是”热帖”。
具体来说，如果存在某个时刻T满足该帖在[T, T+D)这段时间内(注意是左闭右开区间)收到不少于K个赞，该帖就曾是”热帖”。
给定日志，请你帮助小明统计出所有曾是”热帖”的帖子编号。
【输入格式】
第一行包含三个整数N、D和K。
以下N行每行一条日志，包含两个整数ts和id。
对于50%的数据，1 <= K <= N <= 1000
对于100%的数据，1 <= K <= N <= 100000 0 <= ts <= 100000 0 <= id <= 100000
【输出格式】
按从小到大的顺序输出热帖id。每个id一行。
【输入样例】
7 10 2
0 1
0 10
10 10
10 1
9 1
100 3
100 3
【输出样例】
1
3
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms
方法是“尺取法” 尺取法：顾名思义，像尺子一样取一段，借用挑战书上面的话说，尺取法通常是对数组保存一对下标，即所选取的区间的左右端点，然后根据实际情况不断地推进区间左右端点以得出答案。尺取法比直接暴力枚举区间效率高很多，尤其是数据量大的时候，所以说尺取法是一种高效的枚举区间的方法，是一种技巧，一般用于求取有一定限制的区间个数或最短的区间等等。当然任何技巧都存在其不足的地方，有些情况下尺取法不可行，无法得出正确答案，所以要先判断是否可以使用尺取法再进行计算。
N,D,K = map(int,input().split())
a = {}
for i in range(N):
ts,id = map(int,input().split()
if id not in a:
a[id] = {}
q = (ts//10)*10 #取整数，再乘回来，可以得到区间，比较核心
m = (q,q+D)
if m not in a[id]:
a[id][m]=1
else:
a[id][m] +=1
#print(a)
res = []
for key,value in a.items(): #遍历字典，，背~~
for inkey in value.values():
if inkey>=K:
res.append(key)
for i in range(len(res)):
print(res[i])
16 .日期问题
问题描述：
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。
给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
输入格式：
一个日期，格式是”AA/BB/CC”。 (0 <= A, B, C <= 9)
输出格式：
输出若干个不相同的日期，每个日期一行，格式是”yyyy-MM-dd”。多个日期按从早到晚排列。
样例输入
02/03/04
***样例输出 ***
2002-03-04
2004-02-03
2004-03-02
a,b,c = map(str ,input().split("/"))
month = [1,3,5,7,8,10,12]
month_one = [4,6,9,11]
#1.闰年2月 2.大小月
def years(x):
if x%4 ==0 and x%100 == 0 or x%400 ==0:
return True
def year(y):
if y>=60 and y<=99:
y =y+1900
if 0<=y<=59:
y = y+2000
return y
gg = year(int(a)) #判断年份在哪个地方
gg_c = year(int(c))
#如果是闰年
if years(gg) and 1<=int(b)<=12:
if int(b) in month:
if int(c)<=31:
print(str(gg)+'-'+b +'-'+c)
elif int(b) in month_one:
if int(c)<=30:
print(str(gg)+'-'+b +'-'+c)
else:
if int(c)<=29:
print(str(gg)+'-'+b +'-'+c)
#若不是
else:
if int(b) in month:
if int(c)<=31:
print(str(gg)+'-'+b +'-'+c)
elif int(b) in month_one:
if int(c)<=30:
print(str(gg)+'-'+b +'-'+c)
else:
if int(c)<=28 and 1<=int(b)<=12:
print(str(gg)+'-'+b +'-'+c)
同理对其他两种情况，因为没有优化代码，所以太垃圾了，接下来只需对相应的A,B,C改动就行了
17.生日蜡烛
【问题描述】：某君从某年开始每年都举办一次生日party，并且每次都要吹熄与年龄相同根数的蜡烛。现在算起来，他一共吹熄了236根蜡烛。请问，他从多少岁开始过生日party的？请填写他开始过生日party的年龄数。 注意：你提交的应该是一个整数，不要填写任何多余的内容或说明性文字。
#方法一：暴力枚举,由题可看出是等差数列，但是不知道首项和An
for i in range(100):
for j in range(100):
if((i+j)*(j-i+1)/2 == 236):#（首项+末项）/2*项数
print(i,j-i+1)
#方法二：求和公式na1 + n(n-1)*d/2 通过先求出n(n-1)/2 在和236相减相除得到一个整
#数以保证数据合理
for i in range(1,100):
t = i*(i-1)/2
x = (236-t)%i
if(x == 0):
print((236-t)/i)
18.移动距离：
移动距离
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。其楼房的编号为1,2,3…
当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …..
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离（不能斜线方向移动）
输入为3个整数w m n，空格分开，都在1到10000范围内
w为排号宽度，m,n为待计算的楼号。
要求输出一个整数，表示m n 两楼间最短移动距离。
例如：
用户输入：
6 8 2
则，程序应该输出：
4
再例如：
用户输入：
4 7 20
则，程序应该输出：
5
资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms
#根据样例可以发现，从横或者从竖着数移动距离都是一样的
w,m,n = map(int,input().split())
#算出从1到m,n共经历多少行
hamg_m = 0
hang_n = 0
if m%w ==0:
hang_m = m/w
else:
hang_m = m//w+1
if n%w ==0:
hang_n = n/w
else:
hang_n = n//w+1
#算出从1到m,n共经历多少列
lie_m = 0
lie_n = 0
if(hang_m%2 == 0):
lie_m = w*hang_m-m+1
else:
lie_m = w-(w*hang_m-m)
if(hang_n%2 == 0):
lie_n = w*hang_n-n+1
else:
lie_n = w-(w*hang_n-n)
#print(hang_m,lie_m,hang_n,lie_n)
print(int(abs(hang_n-hang_m)+abs(lie_n-lie_m)))