刷题问题集合

发表于 | 分类于 | | 阅读次数 |
字数统计 4,490 | 阅读时长 18

学的比较杂，忘得比较快。好记性不如烂键盘。

机试题

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

Question；

1
2
3
4
5
6
7
8
9
10
11
12
13
题目描述
计算字符串最后一个单词的长度，单词以空格隔开。 
输入描述:
一行字符串，非空，长度小于5000。
输出描述:
整数N，最后一个单词的长度。
示例1
输入
hello world
输出
5

Solution:

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

strip()

usage: strip()方法用于移除字符串头尾指定的字符（默认为空格) 

1
2
3
4
5
6
7
8
9
str = "0000000     Runoob  0000000"; 
print str.strip( '0' );  # 去除首尾字符 0
//输出
     Runoob  
str2 = "   Runoob      ";   # 去除首尾空格
print str2.strip();
//输出  
Runoob

split()

split()通过指定分隔符对字符串进行切片，如果参数num有指定值，则仅分隔 num 个子字符串.
usage； str.split(str=””, num=string.count(str))
str – 分隔符，默认为所有的空字符，包括空格、换行(\n)、制表符(\t)等。
num – 分割次数。

1
2
3
4
5
6
7
8
str = "Line1-abcdef \nLine2-abc \nLine4-abcd";
print str.split( );
print str.split(' ', 1 );
//输出  
['Line1-abcdef', 'Line2-abc', 'Line4-abcd']
['Line1-abcdef', '\nLine2-abc \nLine4-abcd']

len()

len() 方法返回对象（字符、列表、元组等）长度或项目个数。
uasge: len(s)

1
2
3
>>>str = "runoob"
>>> len(str)             # 字符串长度
6

计算字符串个数

Question：

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

Solution:

1
2
3
4
5
6
7
8
9
10
11
 #-*-coding:utf-8-*-
str ="nhrwlbcc8m7c5hih9mhalw98k0322wf2jjm47kk3ntm9snfrflzzundn7d608usy049asxalzjk7izj6amcqhr8uubc04g52mcjboj2fmge2l6iarizfu4yve5o4i3srf5zgqbg82ckcotdeqp760mc9gzei5dzk5gj9x9yj05o3hle0ii64krkkp5i7blh7nbu3gu5vgi2scyn4yqx3z4vcjbyzhnqkh887izotjkg2l0mit0k14vyn39 t"
N = str[-1]
str = str[:-1].strip()
counter=0
for i in str:
    if N == i:
        counter = counter+1
print(counter)

最优的Solution:

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

lower()

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

count()

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

1
2
3
4
5
6
7
8
9
10
str="www.runoob.com"
sub='o'
print ("str.count('o') : ", str.count(sub))
sub='run'
print ("str.count('run', 0, 10) : ", str.count(sub,0,10))
//输出  
str.count('o') :  3
str.count('run', 0, 10) :  1

sub – 搜索的子字符串
start – 字符串开始搜索的位置。默认为第一个字符,第一个字符索引值为0。
end – 字符串中结束搜索的位置。字符中第一个字符的索引为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
33
34
35
36
37
38
39
40
41
42
43
44
题目描述
明明想在学校中请一些同学一起做一项问卷调查，为了实验的客观性，他先用计算机生成了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

Solution:

1
2
3
4
5
6
7
8
9
10
import random
n = range(65)
inputArray = []
outputArray = []
for i in n:
    inputArray.append(random.randint(1,1000))
for j in inputArray:
    if j not in outputArray:
        outputArray.append(j)
print(sorted(outputArray))

牛逼解法：

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

randint()

使用了 random 模块的 randint() 函数来生成随机数

1
使用方法为:random.randint(1,1000)

if的另外一种使用方法：

1
2
3
非的关系：
if j not in outputArray:
        outputArray.append(j)

sort() & sorted()

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

多个变量赋值

1
a,res=int(input()),set()

Python允许你同时为多个变量赋值。例如：

1
a = b = c = 1

以上实例，创建一个整型对象，值为1，三个变量被分配到相同的内存空间上。也可以为多个对象指定多个变量。例如：

1
a, b, c = 1, 2, "john"

以上实例，两个整型对象1和2的分配给变量 a 和 b，字符串对象 “john” 分配给变量 c。

set()

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等

1
2
3
4
5
6
7
8
9
10
>>>x = set('runoob')
>>> y = set('google')
>>> x, y
(set(['b', 'r', 'u', 'o', 'n']), set(['e', 'o', 'g', 'l']))   # 重复的被删除
>>> x & y         # 交集
set(['o'])
>>> x | y         # 并集
set(['b', 'e', 'g', 'l', 'o', 'n', 'r', 'u'])
>>> x - y         # 差集
set(['r', 'b', 'u', 'n'])

Python 装饰器

from某乎：

1
内裤可以用来遮羞，但是到了冬天它没法为我们防风御寒，聪明的人们发明了长裤。长裤就类似于装饰器，在不影响内裤作用的前提下，给我们身子提供了保暖的功效。

装饰器本质上是一个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
15
16
17
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去掉就可以，只需要用编辑器全局查找然后删除即可。

字符串分隔

Q:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
题目描述
•连续输入字符串，请按长度为8拆分每个字符串后输出到新的字符串数组； 
•长度不是8整数倍的字符串请在后面补数字0，空字符串不处理。 
输入描述:
连续输入字符串(输入2次,每个字符串长度小于100)
输出描述:
输出到长度为8的新字符串数组
示例1
输入
abc
123456789
输出
abc00000
12345678
90000000

S:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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)

input和raw_input的区别

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

进制转换

Q:

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

S:

1
2
3
4
5
6
7
8
while True:
    try:
        print(int(input(),16))
    except:
        break
注意:注意处理异常，会使用try:except；
处理多组输入：while True

Python进制函数

在python中没有char型，只有字符串类型，这样我们可能将char型转换为整型时极不方便，但是python已经提供了这些转换的内置函数。
python 中除了整型，其他进制的只能用字符串来表示：

任意进制–>十进制;int()

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

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

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

质数因子

Q:

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
题目描述
功能:输入一个正整数，按照从小到大的顺序输出它的所有质数的因子（如180的质数因子为2 2 3 3 5 ）
最后一个数后面也要有空格
详细描述：
函数接口说明：
public String getResult(long ulDataInput)
输入参数：
long ulDataInput：输入的正整数
返回值：
String
输入描述:
输入一个long型整数
输出描述:
按照从小到大的顺序输出它的所有质数的因子，以空格隔开。最后一个数后面也要有空格。
示例1
输入
180
输出
2 2 3 3 5

Solution：
这个问题的意思，其实就是让你把输入的整数因式分解，只不过因子必须都是质数
例如：180 = 2 2 3 3 5；90 = 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) + " ")

range()

函数语法：range(start, stop[, step])

参数说明：
start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5） 是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5） 等价于 range(0, 5, 1)

xrange()

函数说明：用法与range完全相同，所不同的是生成的不是一个数组，而是一个生成器。
要生成很大的数字序列的时候，用xrange会比range性能优很多。
range会直接生成一个list对象，而xrange则不会直接生成一个list，而是每次调用返回其中的一个值。
所以xrange做循环的性能比range好，尤其是返回很大的时候，尽量用xrange吧，除非你是要返回一个列表。

取近似值

Q:

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

S:

1
2
3
4
5
a = float(input())
if (a - int(a))>=0.5:
    print(int(a)+1)
else:
    print(int(a))

float(input())

输入一个浮点型

int（）

int（）默认向下取整

向上取整函数math.ceil()

1
2
3
4
import math
math.ceil(3.2)
输出：3

向下取整函数math.floor()

1
2
import math
math.floor( x )

四舍五入函数round()

1
2
3
4
5
6
a=3.25;b=3.75
round(a);round(b)
输出：
3.0
4.0

合并表记录

Q:

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

Solution:

1
2
3
4
5
6
7
8
9
10
11
12
13
from collections import defaultdict
while True:
    try:
 
        a,dd=int(input()),defaultdict(int)
        for i in range(a):
            key,val=map(int,input().split())
            dd[key]+=val
        for i in sorted(dd.keys()):
            print(str(i)+" "+str(dd[i]))
 
    except:
        break

提取不重复数

Q:

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

Solution: 

1
2
3
4
5
6
7
8
9
10
import math
a = list(input())[::-1]
c = list(set(a))
c.sort(key=a.index)
sum = 0
b = len(c)-1
for i in c:
    sum = sum + int(i)*pow(10,b)
    b = b-1
print(sum)

Python翻转字符串(reverse string)

最简单的方法，将步长设置为-1

pow() 方法返回 xy（x的y次方） 的值

math 模块 pow() 方法的语法:
import math
math.pow( x, y )
内置的方法：pow(x,y)

按照特定=顺序排序

c.sort(key=a.index)

字符个数统计

Q:

1
2
3
4
5
6
7
8
9
10
编写一个函数，计算字符串中含有的不同字符的个数。字符在ACSII码范围内(0~127)。不在范围内的不作统计。
输入描述:
输入N个字符，字符在ACSII码范围内。
输出描述:
输出范围在(0~127)字符的个数。
示例1
输入
abc
输出
3

Soulution:

1
2
3
4
5
a,res= (set(input()),[])
for i in a:
    if(ord(i)>=0 and ord(i)<=127):
        res.append(i)
print(len(res))

字符–>整型:ord()
1
2
3
ord('Z')
输出：90

字符串反转

Q：

1
2
3
4
5
6
7
8
9
10
11
写出一个程序，接受一个字符串，然后输出该字符串反转后的字符串。例如：
输入描述:
输入N个字符
输出描述:
输出该字符串反转后的字符串
示例1
输入
abcd
输出
dcba

Solution:

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

[::-1]

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

数字反转

Q:

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

Solution:

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

句子逆序

Q:

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
题目描述
将一个英文语句以单词为单位逆序排放。例如“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

Solution:

1
print(" ".join(input().split()[::-1]))

越做越有感觉，能用一行代码完成的绝不写两行

str >>>list

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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

1
2
3
4
5
6
7
8
9
10
11
12
13
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

join()

列表和元组转换为字符串则必须依靠join函数
join() 方法用于将序列中的元素以指定的字符连接生成一个新的字符串
语法：
join()方法语法:str.join(sequence)
参数：
sequence – 要连接的元素序列
返回值:
返回通过指定字符连接序列中元素后生成的新字符串
实例:
以下实例展示了join()的使用方法：

1
2
3
4
5
str = "-";
seq = ("a", "b", "c");# 字符串序列
print(str.join( seq ))
以上实例输出结果如下：
a-b-c

字符串的连接最长路径查找

Q:

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
题目描述
给定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

Solution；

1
2
3
a, strings = int(input()),[]
for i in range(a):strings.append(input())
for str in sorted(strings): print(str)

range()

老生常谈,注意其多行输入的方法

sorted()

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

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

Q:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
题目描述
输入一个int型的正整数，计算出该int型数据在内存中存储时1的个数。
输入描述:
 输入一个整数（int类型）
输出描述:
 这个数转换成2进制后，输出1的个数
示例1
输入
5
输出
2

Solution:

1
print(str(bin(int(input()))).count("1"))

操作越来骚，Python大法好。

bin()

十进制转二进制

count()

统计字符串中出现特定符号的个数
本题即将输入的int型整数转为二进制，再转换为字符串统计“1”出现的个数

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,"不是质数")

谢谢你请我吃糖果！