python编程练习之二

2017-滴滴出行- 末尾为0的个数

题目描述:

输入一个正整数n,求n!(即阶乘)末尾有多少个0？ 比如: n = 10; n! = 3628800,所以答案为2;

输入描述:

输入为一行，n(1 ≤ n ≤ 1000)

输出描述:

输出一个整数,即题目所求

示例1：

- 输入:
10
- 输出:
2

解法一：计算num的阶乘，统计结果中末尾有多少个0

缺点：数值过大会溢出，且效率低下

代码实现如下：

#!user/bin/env python
# coding:utf-8
"""
file:       jiecheng
date:       2017 - 08 - 30  22:22
author:     fang
version:    1.0
desc:
"""

def mult(num1, num2):
return num1 * num2

def main():
num = input()
num = int(num)
aws = str(reduce(mult, range(1, num + 1)))
print aws.count("0")

main()

实现方法二

分析：N！能产生0的质数组合只能是2 * 5，即当对N!进行质因数分解之后，N!末尾0的个数M取决于2的个数X和5的个数Y的最小值，即M = min（X,Y）。又因为能被2整除的数出现的频率比能被5整除的数高得多，且出现一个5的时,最少会同时出现一个2，所以M = Y。即得出Y的值就可以得到N!末尾0的个数。计算Y最直接的方法，就是计算机1…N的因式分解中5的个数，然后求和。

代码实现：

#!user/bin/env python
#coding:utf-8
"""
file:       zero_count.py
date:       2017 - 08 - 31  22:38
author:     fang
version:    1.0
desc:
"""
def zero_count(num):
count = 0
for i in range(1, num + 1):
j = i
while j % 5 == 0:
count += 1
j /= 5
return count

def main():
num = input("num:")
print zero_count(num)

main()

我并不完美,但我一直走在追求完美的道路上，那么还有没有更简洁的方法呢？

试想，Y还能怎么样得到？

举个例子吧 ，25的阶乘中，总共有6个五，其中5,10,15,20各贡献一个，25贡献两个；或者说，5,10,15,20，25各贡献一个，25又额外贡献了 一个，即5的倍数各贡献一个5, 25的倍数又各贡献一个5,即Y=[25/5] + [25/25]。同理，125中，5的倍数各贡献一个5,25的倍数各贡献一个5,125的倍数也各贡献一个5，所以Y=[125/5] + [125/25] + [125/125],所以可得公式：

Y = [N/5] + [N/5^2] + [N/5^3] + …

代码实现：

#!user/bin/env python
#coding:utf-8
"""
file:       zero_count
date:       2017 - 08 - 31  22:55
author:     fang
version:    1.0
desc:
"""
def zero_count(num):
count = 0
while num != 0:
count = count + num / 5
num = num / 5
return count

def main():
num = input("num:")
print zero_count(num)

main()

(2017-猪八戒网-数串)

题目描述：

设有n个正整数，将他们连接成一排，组成一个最大的多位整数。 如:n=3时，3个整数13,312,343,连成的最大整数为34331213。 如:n=4时,4个整数7,13,4,246连接成的最大整数为7424613。

输入描述:

有多组测试样例，每组测试样例包含两行，第一行为一个整数N（N<=100），第二行包含N个数(每个数不超过1000，空格分开)。

输出描述:

每组数据输出一个表示最大的整数。

示例1:

- 输入
2
12 123
4
7 13 4 246
- 输出
12312
7424613

解法一：先来个低级算法垫底，直接利用sorted（）进行排序，再将列表中的字符串链接起来即可

缺点：存在bug

代码实现如下：

#!user/bin/env python
# coding:utf-8
"""
file:       connect
date:       2017 - 08 - 30  22:44
author:     fang
version:    1.0
desc:
"""

def cmp(list_in):
l = sorted(list_in)
return l[::-1]

def main():
user_input = raw_input()
user_input = user_input.split(" ")
print "".join(cmp(user_input))

main()

思路二：两个方向:a.先组合，后排序，b.先排序，后组合

但是要注意：A=’321’，B=’32’，按照标准的字符串比较规则因为A>B，所以A+B > B+A ，而实际上’32132’ < ’32321’。 所以，自定义一种字符串的比较规则：即如果A+B>B+A,则我们认为A>B。

接下来我们用两种规则分别实现，先来规则a

先把整数化成字符串，然后再比较a+b和b+a，如果a+b>b+a，就把a排在b的前面，反之则把a排在b的后面。

我们需要自定义一种字符串的比较规则：

如果A+B>B+A,则我们认为A>B。

且可以证明：如果A+B>=B+A,B+C>=C+B,则一定有：A+C>=C+A。

这样一来，程序就很简单了。分3步：

（1）先把n个数字转换成字符串存储；

（2）按照自定义的规则把n个字符串从大到小排序；

（3）依次输出这些字符串。

代码如下

#!user/bin/env python
#coding:utf-8
"""
file:       sort
date:       2017 - 08 - 31  22:59
author:     fang
version:    1.0
desc:
"""

def main():
user_input = raw_input("请至少输入两个数字，用空格隔开:")
user_input = user_input.split(" ")
length = len(user_input)
for i in range(0, length - 1):
for j in range(0, length - i - 1):
if user_input[j] + user_input[j + 1] < user_input[j + 1] + user_input[j]:
user_input[j], user_input[j + 1] = user_input[j + 1], user_input[j]
user_output = "".join(user_input)
print user_input
print user_output

main()

测试，为了方便观察，将排序后的列表打印出来了，这一串数字几乎包含了所有笔者想到的规则，如有考虑不周的地方，欢迎评论区留言，一起探讨学习

这里笔者用的是冒泡排序，读者若有兴趣可采用插入排序、希尔排序等方法实现



b方法这里就不赘述了，读者有兴趣可以思考实现方法，这里提供思路：即先进行组合，再比较大小。

三，“回文串”

题目描述

“回文串”是一个正读和反读都一样的字符串，比如“level”或者“noon”等等就是回文串。花花非常喜欢这种拥有对称美的回文串，生日的时候她得到两个礼物分别是字符串A和字符串B。现在她非常好奇有没有办法将字符串B插入字符串A使产生的字符串是一个回文串。你接受花花的请求，帮助她寻找有多少种插入办法可以使新串是一个回文串。如果字符串B插入的位置不同就考虑为不一样的办法。

例如：

A = “aba”，B = “b”。这里有4种把B插入A的办法：

在A的第一个字母之前: “baba” 不是回文

在第一个字母‘a’之后: “abba” 是回文

在字母‘b’之后: “abba” 是回文

在第二个字母’a’之后 “abab” 不是回文

所以满足条件的答案为2

输入描述:

每组输入数据共两行。

第一行为字符串A

第二行为字符串B

字符串长度均小于100且只包含小写字母

输出描述:

输出一个数字，表示把字符串B插入字符串A之后构成一个回文串的方法数

示例1

- 输入
aba
b

- 输出
2

#!user/bin/env python
# coding:utf-8
"""
file:       huiwen
date:       2017 - 08 - 30  23:10
author:     fang
version:    1.0
desc:
"""
def is_hui(s):
le = len(s) - 1
# for i in s:
for i in range(0, le):
if i > le / 2:
break
elif s[i] != s[le]:
return False
le -= 1

return True

def ins(str1, str2):
cont = 0
# stra = [i for i in str1]
for tmp in str2:
for i in range(0, len(str1) + 1):
stra = [a for a in str1]
stra.insert(i, tmp)
s = "".join(stra)
# print s
if is_hui(s):
#print s
cont += 1
return cont

def main():
str1 = raw_input("str1:")
str2 = raw_input("str2:")
print ins(str1, str2)

main()

由于笔者题意理解有偏差，故上述代码存在bug，下面进行修正

先说说思路：令字符串str2依次插入str1的各个位置，判断新组成的字符串是否满足回文串

好了，代码实现：

#!user/bin/env python
# coding:utf-8
"""
file:       echo
date:       2017 - 08 - 31  23:42
author:     fang
version:    1.0
desc:
"""

def is_hui(s):  # 判断是否回文串，是则返回true
le = len(s) - 1
for i in range(0, len(s)):
if i > le / 2:
break
elif s[i] != s[le]:
return False
le -= 1
return True

def main():
str1 = raw_input("str1:")
str2 = raw_input("str2:")
count = 0
str3 = [j for j in str1]
for i in range(0, len(str1) + 1):
str4 = list(str3)
str4.insert(i, str2)
str5 = "".join(str4)
if is_hui(str5):
#print str5
count += 1
print count

main()

notes

str4 = list(str3) 和 str4 = str3 的区别：str4 = str3这种赋值方式，相当于此列表的一个引用，并没有复制str3指向的列表，改变str4的同时str3也会改变；list()是列表构造函数，它会在传入的数列基础上新建列表。

八大排序算法之——冒泡排序：

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。

def bubble_sort(lists):     # 冒泡排序
count = len(lists)
for i in range(0, count):
for j in range(i + 1, count):
if lists[i] > lists[j]:
lists[i], lists[j] = lists[j], lists[i]
return lists