华为机试题目

发表于 | 分类于 |

2018/11/26 20:38

开始刷华为机试题目，共108道，加油鸭~

记录一下自己的找工作心路历程，希望明年可以拿offer拿到手软~~

华为机试在线测试

字符串最后一个单词的长度

1
2
3
4
5
6
7
8
9
10
11
12
题目描述
计算字符串最后一个单词的长度，单词以空格隔开。 

输入描述:
一行字符串，非空，长度小于5000。

输出描述:
整数N，最后一个单词的长度。

示例
输入  hello world
输出  5

python代码： 

1
2
str = input().strip().split()
print(len(str[-1]))

计算字符个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
写出一个程序，接受一个由字母和数字组成的字符串，和一个字符，然后输出输入字符串中含有该字符的个数。不区分大小写。

输入描述:
输入一个有字母和数字以及空格组成的字符串，和一个字符。

输出描述:
输出输入字符串中含有该字符的个数。

示例1
输入
ABCDEF A
输出
1

python代码: 

1
2
3
a=input().lower()
b=input().lower()
print(a.count(b))

lower()

lower() 方法转换字符串中所有大写字符为小写。
增加本题的鲁棒性。

count()

count() 方法用于统计字符串里某个字符出现的次数。可选参数为在字符串搜索的开始与结束位置。
str.count(sub, start= 0,end=len(string))

明明的随机数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
题目描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了N个1到1000之间的随机整数（N≤1000），对于其中重复的数字，只保留一个，把其余相同的数去掉，不同的数对应着不同的学生的学号。然后再把这些数从小到大排序，按照排好的顺序去找同学做调查。请你协助明明完成“去重”与“排序”的工作。

Input Param 
     n               输入随机数的个数     
 inputArray      n个随机整数组成的数组 
Return Value
     OutputArray    输出处理后的随机整数
注：测试用例保证输入参数的正确性，答题者无需验证。测试用例不止一组。

输入描述:
输入多行，先输入随机整数的个数，再输入相应个数的整数

输出描述:
返回多行，处理后的结果

示例1
输入
11
10
20
40
32
67
40
20
89
300
400
15
输出
10
15
20
32
40
67
89
300
400

代码：

1
2
3
4
5
6
7
8
9
10
while True:
    try:
        a=int(input())
        res=set()
        for i in range(a):
            res.add(int(input()))
        for i in sorted(res):
            print(i)
    except:
        break

分析：之前自己编的时候总是有问题，需要注意：题目中说测试用例不止一组，所以要加while True:只有有数据来就运行它，还要加 try-except，避免出现问题，成为死循环（在机试环境下试了，不加这两个，就不能通过），所以要注意！！！！

sort和sorted的区别

sort是应用在list上的方法，sorted可以对所有可迭代的对象进行排序操作。
list的sort方法返回的是对已经存在的列表进行操作，而内建函数sorted方法返回的是一个新的list，而不是在原来的基础上进行的操作。
例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
>>> a=[1,2,5,3,9,4,6,8,7,0,12]
>>> a.sort()
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12]

>>> a=[1,2,5,3,9,4,6,8,7,0,12]
>>> sorted(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12]
>>> a
[1, 2, 5, 3, 9, 4, 6, 8, 7, 0, 12]

区别：
对于一个无序的列表a，调用a.sort()，对a进行排序后返回a，sort()函数修改待排序的列表内容。
而对于同样一个无序的列表a，调用sorted(a)，对a进行排序后返回一个新的列表，而对a不产生影响。

字符串分隔

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
题目描述
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 

输入描述:
连续输入字符串(输入2次,每个字符串长度小于100)

输出描述:
输出到长度为8的新字符串数组

示例1
输入
abc
123456789
输出
abc00000
12345678
90000000

自己写的没通过的代码： 

1
2
3
4
5
6
7
8
9
10
11
s = str(input())
k = []
if len(s) < 8:
    k.append(s + '0' * (8 - len(s)))
elif len(s)==8:
    k.append(s)
else:
    k.append(s[0:7])
    k.append(s[8:]+ '0' * (8 - len(s[8:])))
for i in k:
    print(i)

网上的正确代码： 

1
2
3
4
5
6
7
8
9
10
11
12
def pirnt8(line):
    if len(line) < = 8:
        print(line+"0"*(8-len(line)))
    else:
        while len(line) > 8:
            print(line[:8])
            line = line[8:]
        print(line + "0"*(8-len(line)))
a = input()
b = input()
pirnt8(a)
pirnt8(b)

分析：自己的思路和答案是一样的，而且都用到了关键的一步，就是右侧补零，line+"0"*(8-len(line))，自己的问题出在，题目没审清楚，说的是输入两次，所以我的框架就是错的，而且哪怕是输入一次也是错的，因为字符串的长度有可能是大于16的。

zfill函数

在网上找末尾补零的时候，找到了这个函数，可以自动给字符串前面补零（zfill=zero fill的缩写）。 

1
2
3
n = "123"
s = n.zfill(5)
assert s == '00123'

raw_input()和input()区别

raw_input()只有python2.7版本可以用的，python3里面已经把raw_input()给去掉了，在 Python 3 内，将 raw_input() 重命名为 input()；

字符的时候可以用raw_input()，当然不怕麻烦也可以用input()手动加’’
int类型的时候最好用input().

python装饰器

今天我看廖雪峰官方网站的时候，看到过这个，当时感觉没看懂，刚在洒哥哥博客看到，就搬运一下，好像和这道题没关系~~

装饰器本质上是一个Python函数，可以让其他函数在不需要做任何代码变动的前提下增加额外功能，装饰器的返回值也是一个函数对象，需求的场景：插入日志、性能测试、事务处理、缓存、权限校验。

例子：
比如写了很多个简单的函数，你想知道在运行的时候哪些函数在执行，只是想要很简单的在执行完毕之前给它打印一句“start”，应该是这样： 

1
2
3
def func_name(arg):
    print 'Start func_name'
    sentences

这样做是没有错，但是有想过没，难道想给每一个函数后面都加上那么一句吗？等运行完再一个个的删掉print不觉得麻烦吗？一个不麻烦，十个，一百个呢。

装饰器可以这么来：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def log(func):
    def wrapper(*arg,**kw):
        print 'Start %s' % func
        return func(*arg,**kw)
    return wrapper
@log
def func_a(arg):
    pass
@log
def fun_b(arg):
    pass
@log
def fun_c(arg):
    pass

其中，log函数就是装饰器，把装饰器写好后给需要装饰的函数前面加上@log就可以，装饰器节省了代码量，并且在函数不需要装饰的时候直接把@log去掉就可以，只需要用编辑器全局查找然后删除即可。

进制转换

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
写出一个程序，接受一个十六进制的数值字符串，输出该数值的十进制字符串。（多组同时输入 ）

输入描述:
输入一个十六进制的数值字符串。

输出描述:
输出该数值的十进制字符串。

示例1
输入
0xA
输出
10
1
2
3
4
5
while True:
    try:
        print(int(input(),16))
    except:
        break

注意：题中说多组输入，要用try不然不能通过.

python间的进制转换

任意进制->十进制int()

可以将二进制，八进制，十六进制转换成十进制整型：

1
2
3
4
5
6
>>> int('1111', 2)
15
>>> int('f', 16)
15
>>> int('17', 8)
15

整型–>字符；chr()
1
2
chr(90)
输出:'Z'
字符–>整型:ord()
1
2
ord('Z')
输出：90
十进制–>十六进制:hex()
1
2
hex(255)
输出：'0xff'
十进制–>二进制：bin()
1
2
bin(255)
输出：'0b11111111'

质数因子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）
最后一个数后面也要有空格

详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String

输入描述:
输入一个long型整数

输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。

示例1
输入
180
输出
2 2 3 3 5
1
2
3
4
5
6
7
a,res=int(input()),[]
for i in range(2,a//2+1):
    while a%i==0:
        a=a/i
        res.append(i)

print(" ".join(map(str, res)) + " " if res else str(a) + " ")

注意：输入的是整数，必须int(input())

python算数运算符

+加
-减
*乘
/除
%取模 - 求余
**幂，返回a的b次幂
//取整除 - 返回商的整数部分（向下取整） 

1
2
3
4
>>> 9//2
 4
>>> -9//2
-5

取近似值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
写出一个程序，接受一个正浮点数值，输出该数值的近似整数值。如果小数点后数值大于等于5,向上取整；小于5，则向下取整。

输入描述:
输入一个正浮点数值

输出描述:
输出该数值的近似整数值

示例1
输入
5.5
输出
6
1
2
3
4
5
a=float(input())
if (a-int(a))>=0.5:
    print(int(a)+1)
else:
    print(int(a))

合并表记录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
题目描述
数据表记录包含表索引和数值，请对表索引相同的记录进行合并，即将相同索引的数值进行求和运算，输出按照key值升序进行输出。

输入描述:
先输入键值对的个数
然后输入成对的index和value值，以空格隔开

输出描述:
输出合并后的键值对（多行）

示例1
输入
4
0 1
0 2
1 2
3 4
输出
0 3
1 2
3 4
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
while True:
    try:
        res=dict()
        num=int(input())
        for i in range(num):
            dict_input=input().split()
            if int(dict_input[0]) in res:
                res[int(dict_input[0])]+=int(dict_input[1])
            else:
                res[int(dict_input[0])]=int(dict_input[1])
        res_list=sorted(res)
        for i in res_list:
            print(i,res[int(i)])
    except:
        break

注意：.split()默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等，此处如果写成.split(‘ ‘)就会不不通过，原因应该是输入的类型可能两个数字之间隔得是空字符，都有可能。

使用collections.defaultdict类（了解内容）

defaultdict是Python内建dict类的一个子类，第一个参数为default_factory属性提供初始值，默认为None。它覆盖一个方法并添加一个可写实例变量。它的其他功能与dict相同，但会为一个不存在的键提供默认值，从而避免KeyError异常。之前例子的实现如下： 

1
2
3
4
5
6
7
>>> from collections import defaultdict
>>> count = defaultdict(int)
>>> for fruit in bag:
...     count[fruit] += 1
...
>>> count
defaultdict(<class 'int'>, {'apple': 3, 'orange': 1, 'cherry': 2, 'blueberry': 1})

提取不重复的整数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
输入一个int型整数，按照从右向左的阅读顺序，返回一个不含重复数字的新的整数。

输入描述:
输入一个int型整数

输出描述:
按照从右向左的阅读顺序，返回一个不含重复数字的新的整数

示例1
输入
9876673
输出
37689
1
2
3
4
5
result=""
for i in input()[::-1]:
    if i not in result:
        result+=i
print(result)

注意：input()[::-1]是把输入取反

sort和sorted

对于一个无序的列表a，调用a.sort()，对a进行排序后返回a，sort()函数修改待排序的列表内容。

而对于同样一个无序的列表a，调用sorted(a)，对a进行排序后返回一个新的列表，而对a不产生影响。

字符个数统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。

输入描述:
输入N个字符，字符在ACSII码范围内。

输出描述:
输出范围在(0~127)字符的个数。

示例1
输入
abc
输出
3
1
print (len(set([i for i in input() if ord(i) in range(128)])))

注意：不同字符！！！
这里面用到了列表生成器！！

数字颠倒

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
题目描述
描述：
输入一个整数，将这个整数以字符串的形式逆序输出
程序不考虑负数的情况，若数字含有0，则逆序形式也含有0，如输入为100，则输出为001

输入描述:
输入一个int整数

输出描述:
将这个整数以字符串的形式逆序输出

示例1
输入
1516000
输出
0006151
1
print(input()[::-1])

步长为-1，表示为可迭代对象进行反转!!

字符串反转

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：

输入描述:
输入N个字符

输出描述:
输出该字符串反转后的字符串

示例1
输入
abcd
输出
dcba
1
print(input()[::-1])

句子逆序

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
题目描述
将一个英文语句以单词为单位逆序排放。例如“I am a boy”，逆序排放后为“boy a am I”
所有单词之间用一个空格隔开，语句中除了英文字母外，不再包含其他字符

接口说明
/**
 * 反转句子
 * 
 * @param sentence 原句子
 * @return 反转后的句子
 */
public String reverse(String sentence);

输入描述:
将一个英文语句以单词为单位逆序排放。

输出描述:
得到逆序的句子

示例1
输入
I am a boy
输出
boy a am I
1
print(' '.join(input().split()[::-1]))

分析：由split把句子拆分为几个字符串，然后又由[::-1]进行逆序，最后通过join在每个单词之间加空格。

str >>>list

.split()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
str1 = "12345"  
list1 = list(str1)  
print list1  
  
str2 = "123 sjhid dhi"  
list2 = str2.split() #or list2 = str2.split(" ")  
print list2  
  
str3 = "www.google.com"  
list3 = str3.split(".")  
print list3  
输出为：  
[python] view plain copy
['1', '2', '3', '4', '5']  
['123', 'sjhid', 'dhi']  
['www', 'google', 'com']

list >>>str

‘’.join()

1
2
3
4
5
6
7
8
9
10
11
str4 = "".join(list3)  
print str4  
str5 = ".".join(list3)  
print str5  
str6 = " ".join(list3)  
print str6  
输出为：
[python] view plain copy
wwwgooglecom  
www.google.com  
www google com

字串的连接最长路径查找

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
题目描述
给定n个字符串，请对n个字符串按照字典序排列。

输入描述:
输入第一行为一个正整数n(1≤n≤1000),下面n行为n个字符串(字符串长度≤100),字符串中只含有大小写字母。

输出描述:
数据输出n行，输出结果为按照字典序排列的字符串。

示例1
输入
9
cap
to
cat
card
two
too
up
boat
boot
输出
boat
boot
cap
card
cat
to
too
two
up
1
2
3
4
5
6
a=int(input())
string=[]
for i in range(a):
    string.append(input())
for str in sorted(string):
    print(str)

求int型正整数在内存中存储时1的个数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。

输入描述:
 输入一个整数（int类型）

输出描述:
 这个数转换成2进制后，输出1的个数

示例1
输入
5
输出
2
1
print(str(bin(int(input()))).count("1"))

count()方法

count() 方法用于统计字符串里某个字符出现的次数。 

1
str.count(sub, start= 0,end=len(string))
  • sub – 搜索的子字符串
  • start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
  • end – 字符串中结束搜索的位置。字符中第一个字符的索引为 0。默认为字符串的最后一个位置。

Python 质数判断

一个大于1的自然数，除了1和它本身外，不能被其他自然数（质数）整除（2, 3, 5, 7等），换句话说就是该数除了1和它本身以外不再有其他的因数。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# Python 程序用于检测用户输入的数字是否为质数
 
# 用户输入数字
num = int(input("请输入一个数字: "))
 
# 质数大于 1
if num > 1:
   # 查看因子
   for i in range(2,num):
       if (num % i) == 0:
           print(num,"不是质数")
           print(i,"乘于",num//i,"是",num)
           break
   else:
       print(num,"是质数")
       
# 如果输入的数字小于或等于 1，不是质数
else:
   print(num,"不是质数")

背包问题

参考1
参考2

最经典的背包问题可以描述为：

有n个物品，每个物品的重量为w[i]，每个物品的价值为v[i]。现在有一个背包，它所能容纳的重量为W，问：当你面对这么多有价值的物品时，你的背包所能带走的最大价值是多少？

思路：每个物品无非是装入背包或者不装入背包，那么就一个一个物品陆续放入背包中。

我们用c[i][w]表示处理到第i 个物品时背包容量为w下所能装下的最大价值。关键的状态转移方程如下：


购物单 （有点小问题！！）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
题目描述
王强今天很开心，公司发给N元的年终奖。王强决定把年终奖用于购物，他把想买的物品分为两类：主件与附件，附件是从属于某个主件的，下表就是一些主件与附件的例子：

主件  附件
电脑  打印机，扫描仪
书柜  图书
书桌  台灯，文具
工作椅 无

如果要买归类为附件的物品，必须先买该附件所属的主件。每个主件可以有 0 个、 1 个或 2 个附件。附件不再有从属于自己的附件。王强想买的东西很多，为了不超出预算，他把每件物品规定了一个重要度，分为 5 等：用整数 1 ~ 5 表示，第5等最重要。他还从因特网上查到了每件物品的价格（都是 10 元的整数倍）。他希望在不超过 N 元（可以等于 N 元）的前提下，使每件物品的价格与重要度的乘积的总和最大。

设第 j 件物品的价格为 v[j] ，重要度为 w[j] ，共选中了 k 件物品，编号依次为 j 1 ， j 2 ，……， j k ，则所求的总和为：
v[j 1 ]*w[j 1 ]+v[j 2 ]*w[j 2 ]+ … +v[j k ]*w[j k ] 。（其中 * 为乘号）
    
请你帮助王强设计一个满足要求的购物单。

输入描述:
输入的第 1 行，为两个正整数，用一个空格隔开：N m
（其中 N （ <32000 ）表示总钱数， m （ <60 ）为希望购买物品的个数。）

从第2行到第 m+1 行，第 j 行给出了编号为 j-1 的物品的基本数据，每行有 3 个非负整数 v p q（其中 v 表示该物品的价格（ v<10000 ）， p 表示该物品的重要度（ 1 ~ 5 ）， q 表示该物品是主件还是附件。如果 q=0 ，表示该物品为主件，如果 q>0 ，表示该物品为附件， q 是所属主件的编号）
 
输出描述:
 输出文件只有一个正整数，为不超过总钱数的物品的价格与重要度乘积的总和的最大值（ <200000 ）。

示例1
输入
1000 5
800 2 0
400 5 1
300 5 1
400 3 0
500 2 0
输出
2200
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
n,m = map(int,input().split())
prices = [0]*m
degree = [0]*m
depend = [0]*m            #在这里记录的主件下标是从1开始的
 
for i in range(m):
    prices[i],degree[i],depend[i] = map(int,input().split())
result = [[0]*(n+1) for i in range(m+1)]
 
for i in range(1,m+1):            #选择商品
    for j in range(10,n+1,10):    #价格（10的整数）
        if depend[i-1] == 0:      #如果为主件
            if prices[i-1] <= j:                 
                result[i][j] = max(result[i-1][j],result[i-1][j-prices[i-1]] + prices[i-1]*degree[i-1])
        elif prices[i-1] + prices[depend[i-1]-1] <= j: #如果为配件，钱比配件大；然后比较加与不加谁大（空出主件＋该配件的钱，然后加上主件和配件与重要度的乘积）
            result[i][j] = max(result[i-1][j],result[i-1][j-prices[i-1]-prices[depend[i-1]-1]] + prices[i-1]*degree[i-1]+prices[depend[i-1]-1]*degree[depend[i-1]-1])
print(result[m][int(n/10)*10])     #n可能非10的倍数

注意：
① 对于prices = [0]*m，提前定好prices这个list的大小，后面就可以直接赋值，如果不这样写，写成’prices=[]’也可以，不过后面就得用append();

② ‘result = [[0](n+1) for i in range(m+1)]’，相当于生成m+1个[0](n+1)这样的零列表，也就是生成[m+1,n+1]这样的零矩阵，result表示的是最后要输出的值（物品的价格与重要度的乘积）；其中，result[1][10]开始取值的；

③ i和j分别表示商品和价格的遍历，这两个for循环位置可以换；它们两个只要固定一个，判断另一个就好，比如：固定i，表示固定了这一件商品，先判断主件还是附件，在判断能不能买得起，买得
起的情况下，买和不买哪一个的result大，这样的流程依次遍历；

④ 如果是附件，他的处理方式是：必须要买主件才能买附件，所以，如果买，则要减去主件和附件的prices，并加上主件和附件的result值；

⑤应该注意的一点是：此时的i和j表示的就是当前的商品和价格，但是prices、depend、degree这三个数组是从0开始的，所以标号为i-1；

⑥如果为附件时，prices[i-1]表示的是当前附件的价格，prices[depend[i-1]-1]表示的是附件对应主件的价格，depend[i-1]表示当前附件所对应的主件的编号，因为prices从0开始，因此要减一。

坐标移动

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
题目描述
开发一个坐标计算工具， A表示向左移动，D表示向右移动，W表示向上移动，S表示向下移动。从（0,0）点开始移动，从输入字符串里面读取一些坐标，并将最终输入结果输出到输出文件里面。
输入：
合法坐标为A(或者D或者W或者S) + 数字（两位以内）坐标之间以;分隔。
非法坐标点需要进行丢弃。如AA10;  A1A;  $%$;  YAD; 等。

下面是一个简单的例子 如：
A10;S20;W10;D30;X;A1A;B10A11;;A10;
处理过程：
起点（0,0）+ A10 = （-10,0）
+   S20   =  (-10,-20)
+   W10  =  (-10,-10)
+   D30  =  (20,-10)
+   x    =  无效
+   A1A   =  无效
+   B10A11   =  无效
+  一个空 不影响
+   A10  =  (10,-10)
 
结果 （10， -10）

输入描述:
一行字符串

输出描述:
最终坐标，以,分隔

示例1
输入
A10;S20;W10;D30;X;A1A;B10A11;;A10;
输出
10,-10

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
def check(string):
    if string == '':
        return False
    t = list(string)
    start = t.pop(0)
    if start in ['A', 'W', 'D', 'S'] and ''.join(t).isdigit():
            return True
    return False

def doA(a, init=[0, 0]):
    init[0] -= a

def doD(d, init=[0, 0]):
    init[0] += d

def doW(w, init=[0, 0]):
    init[1] += w

def doS(s, init=[0, 0]):
    init[1] -= s

while True:
    try:
        init = [0, 0]
        res = list()
        strings = input().strip(';').split(';')
        for i in strings:
            if check(i):
                res.append(i)
        for i in res:
            i = list(i)
            x = i.pop(0)
            i = int(''.join(i))
            if x == 'A':
                doA(i, init)
            elif x == 'D':
                doD(i, init)
            elif x == 'W':
                doW(i, init)
            elif x == 'S':
                doS(i, init)

        print('{0},{1}'.format(init[0], init[1]))
    except:
        break

注意：pop（0）方法后，列表中的元素就不包含这一项了，相当于被弹出了；
init[0]表示横坐标, init[1]表示纵坐标；

list pop()方法

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。
语法：
list.pop([index=-1])
参数：
obj – 可选参数，要移除列表元素的索引值，不能超过列表总长度，默认为 index=-1，删除最后一个列表值。

代码中用的是i=i.pop(0)，表示返回第一个元素，例如：i=[‘A’,’1’,’0’],返回的是A;

isalnum()方法

Python isalnum() 方法检测字符串是否由字母和数字组成.
语法：str.isalnum()
返回值：
如果 string 至少有一个字符并且所有字符都是字母或数字则返回 True,否则返回 False.

isdigit()方法

Python isdigit() 方法检测字符串是否只由数字组成。
语法：str.isdigit()
返回值：如果字符串只包含数字则返回 True 否则返回 False。

strip()方法

例如：s为字符串，rm为要删除的字符序列

s.strip(rm) 删除s字符串中开头、结尾处，位于 rm删除序列的字符

s.lstrip(rm) 删除s字符串中开头处，位于 rm删除序列的字符

s.rstrip(rm) 删除s字符串中结尾处，位于 rm删除序列的字符

注意：

  1. 当rm为空时，默认删除空白符（包括’\n’, ‘\r’, ‘\t’, ‘ ‘)
  2. 这里的rm删除序列是只要边（开头或结尾）上的字符在删除序列内，就删除掉。
  3. 只有在两边才能删除！！！！

list

注意：split（）方法是对字符串进行分割，返回的是一个list，而且默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。

format ()格式化函数

基本语法是通过 {} 和 : 来代替以前的 % 。
format 函数可以接受不限个参数，位置可以不按顺序。 

1
2
3
4
5
6
7
8
>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

数字格式化方法
详细介绍

识别有效的IP地址和掩码并进行分类统计

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
题目描述
请解析IP地址和对应的掩码，进行分类识别。要求按照A/B/C/D/E类地址归类，不合法的地址和掩码单独归类。

所有的IP地址划分为 A,B,C,D,E五类

A类地址1.0.0.0~126.255.255.255;

B类地址128.0.0.0~191.255.255.255;

C类地址192.0.0.0~223.255.255.255;

D类地址224.0.0.0~239.255.255.255；

E类地址240.0.0.0~255.255.255.255

私网IP范围是：

10.0.0.0～10.255.255.255

172.16.0.0～172.31.255.255

192.168.0.0～192.168.255.255

子网掩码为前面是连续的1，然后全是0。（例如：255.255.255.32就是一个非法的掩码）
本题暂时默认以0开头的IP地址是合法的，比如0.1.1.2，是合法地址

输入描述:
多行字符串。每行一个IP地址和掩码，用~隔开。

输出描述:
统计A、B、C、D、E、错误IP地址或错误掩码、私有IP的个数，之间以空格隔开。

示例1
输入
10.70.44.68~255.254.255.0
1.0.0.1~255.0.0.0
192.168.0.2~255.255.255.0
19..0.~255.255.255.0
输出
1 0 1 0 0 2 1

该程序通过率60%：将（ # IP合法的前提下计数）这一块内容中的条件判断写全就100%通过了（还是没想通，先这样记住吧）；

分析：是因为当a=127时，不应该等于B类，如果不写全，会判错；
if…elif的判断是从上到下的，满足一个条件后，就不会再判断其他的条件了。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
A, B, C, D, E, F, G = 0, 0, 0, 0, 0, 0, 0
res = list()
while True:
    try:
        inputs = input()
        if inputs is '':
            # print('{A} {B} {C} {D} {E} {F}'.format(**locals()))
            break
        [IP, MASK] = inputs.split('~')
        res.append([IP, MASK])
    except:
        break

for [ip, mask] in res:
    ip = ip.split('.')
    mask = mask.split('.')
    # IP错误
    if '' in ip:
        F += 1
        continue
    else:
        a = int(ip[0])
        b = int(ip[1])
        c = int(ip[2])
        d = int(ip[3])
        if not (0 <= a <= 255 and 0 <= b <= 255 and 0 <= c <= 255 and 0 <= d <= 255):
            F += 1
            continue
        elif (a, b, c, d) == (0, 0, 0, 0) or (a, b, c, d) == (255, 255, 255, 255):
            F += 1
            continue
        elif a == 0:
            continue
        else:
            # 掩码错误
            if '' in mask or mask == ['255', '255', '255', '255']:
                F += 1
                continue
            else:
                tmp = list()
                for i in mask:
                    i = bin(int(i)).lstrip('0b') or '0'
                    if len(i) != 8:
                        i = '0'*(8 - len(i)) + i
                    tmp.append(i)
                # mask = tmp
                if '01' in ''.join(tmp):
                    F += 1
                    continue
        # IP合法的前提下计数
        if 1 <= a <= 126:
            A += 1
            if a == 10:
                G += 1
        elif 128 <= a <= 191:
            B += 1
            if a == 172 and 16 <= b <= 31:
                G += 1
        elif 192<=a <= 223:
            C += 1
            if a == 192 and b == 168:
                G += 1
        elif 224<=a <= 239:
            D += 1
        elif 240<=a<=255:
            E += 1

print('{A} {B} {C} {D} {E} {F} {G}'.format(**locals()))

locals() 函数

locals() 函数会以字典类型返回当前位置的全部局部变量。
对于函数, 方法, lambda 函式, 类, 以及实现了 call 方法的类实例, 它都返回 True。

语法 : locals()
返回值 : 返回字典类型的局部变量。

实例：

1
2
3
4
5
6
7
>>>def runoob(arg):    # 两个局部变量：arg、z
...     z = 1
...     print (locals())
... 
>>> runoob(4)
{'z': 1, 'arg': 4}      # 返回一个名字/值对的字典
>>>

.format(**locals())

利用 locals() 函数结合 string 对象的format方法可以用于高效创建格式化字符串，例如：

1
2
3
4
5
6
7
8
9
def fun(a, b):
  x = 20
  y = 30
  sum = x + y
  prod = x * y
  formatStr = '{x} + {y} = {sum}; {x} * {y} = {prod}.'
  print(formatStr.format(**locals()))

# print: '20 + 30 = 50; 20 * 30 = 600.'

**locals() 将根据 formatStr 中位于括号内的变量名实现映射解包操作。

bin()函数

bin() 返回一个整数 int 或者长整数 long int 的二进制表示。
注意：返回的是一个字符串；

例如：

1
2
3
4
>>>bin(10)
'0b1010'
>>> bin(20)
'0b10100'

简单错误记录

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
题目描述
开发一个简单错误记录功能小模块，能够记录出错的代码所在的文件名称和行号。

处理： 
1、 记录最多8条错误记录，循环记录，对相同的错误记录（净文件名称和行号完全匹配）只记录一条，错误计数增加；
2、 超过16个字符的文件名称，只记录文件的最后有效16个字符；
3、 输入的文件可能带路径，记录文件名称不能带路径。

输入描述:
一行或多行字符串。每行包括带路径文件名称，行号，以空格隔开。

输出描述:
将所有的记录统计并将结果输出，格式：文件名 代码行数 数目，一个空格隔开，如：

示例1
输入
E:\V1R2\product\fpgadrive.c   1325
输出
fpgadrive.c 1325 1
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
res = dict()
f_res = list()
while True:
    try:
        strings = input()
        if strings == '' or strings == '\n':
            break
        [fpath, line] = strings.split(' ')
        fname = fpath.split('\\')[-1]
        if len(fname) > 16:
            fname = fname[-16:]
        fnames = fname + ' ' + line
        if fnames in res:
            res[fnames] += 1
        else:
            res[fnames] = 1
            f_res.append(fnames)

    except:
        break

for i in f_res[-8:]:
    print('{0} {1}'.format(i, res[i]))

注意：要加try…except，否则会不通过。
注意：其中的res=dict()，定义了一个空的字典（用来存储key-value），目的是用来计算这种错误出现的次数的。

python转义字符

1
2
3
4
\   (在行尾时) 续行符
\\  反斜杠符号
\'  单引号
\"  双引号

###