python笔试题

知识点：

1. if name == 'main’的意思是：当.py文件被直接运行时，if name == 'main’之下的代码块将被运行；当.py文件以模块形式被导入时，if name == 'main’之下的代码块不被运行。
2. python xxx.py，直接运行xxx.py文件；python -m xxx.py，把xxx.py当做模块运行；python xxx.py=python -m xxx
3. main.py文件是一个包或者目录的入口程序。不管是用python package还是用python -m package运行，main.py文件总是被执行。

例题

1.求x的n次方：
方法一：位运算+循环

class Solution:
    def myPow(self, x, n):
        if n == 0:
            return 1
        elif n < 0:
            x = 1/x
            n = -n
        ans = 1.0
        while n > 0:
            if n&1 :
                ans *= x
            x *= x
            n >>= 1
        return ans

递归

class Solution:
    def myPow(self, x, n):
        if n < 0:
            return self.myPow(1/x,-n)
        if n == 0:
            return 1
        if n == 2:
            return x*x
        return self.myPow(self.myPow(x,n/2),2) 
        if not n%2 else x * self.myPow(self.myPow(x,n//2),2)

2.100以内奇数的和：

sum = 0
for i in range(0, 100):
    if i%2 == 1 
        sum +=1
print(sum)

3.二维数组查找：
在一个二维数组中（每个一维数组的长度相同），每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。

class Solution:
    # array 二维列表
    def Find(self, target, array):
        # write code here
        find = False
        rows = len(array)
        columns = len(array[0])
        row=0
        column=columns-1
        while row<rows and column>=0:
            if(array[row][column]==target):
                find = True
                break
            elif(array[row][column]>target):
                column-=1
            else:
                row+=1
        return find

4.替换空格:
请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

class Solution:
    # s 源字符串
    def replaceSpace(self, s):
        s = list(s)
        count=len(s)
        for i in range(0,count):
            if s[i]==' ':
                s[i]='%20'
        return ''.join(s)

5.从尾到头打印链表：
输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

class Solution:
    # 返回从尾部到头部的列表值序列，例如[1,2,3]
    def printListFromTailToHead(self, listNode):
        l = []
        head = listNode
        while head:
            l.insert(0, head.val)
            head = head.next
        return l

6.重建二叉树：
输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

class Solution:
    # 返回构造的TreeNode根节点
    def reConstructBinaryTree(self, pre, tin):
        if len(pre) == 0:
            return None
        val = pre[0]
        for i in range(0, len(tin)):
            if tin[i] == val:
                break
        root = TreeNode(val)
        root.left = self.reConstructBinaryTree(pre[1:1+i], tin[:i])
        root.right = self.reConstructBinaryTree(pre[1+i:], tin[i+1:])
        return root

7.数字幂的比较：
给出两个数字x和y，请比较x^y 和 y^x的大小，如果前者大于后者，输出">",小于输出"<",等于则输出"="。

x=input("please input x:")
y=input("please input y:")
int_x=int(x)
int_y=int(y)
int_x>=1
int_y<=10**9
if int_x**int_y > int_y**int_x:
    print(">")
elif int_x**int_y < int_y**int_x:
    print("<")
else:
    print("=")

8.序列最小化：
有一个长度为N的序列。一开始，这个序列是1, 2, 3,… n - 1, n的一个排列。每次选择序列中k个连续的数字，然后用这k个数字中最小的数字替换这k个数字中的每个数字。我们希望进行了若干次操作后，序列中的每个数字都相等。请你找出需要操作的最少次数。

import sys
import math
n, k = [int(x) for x in sys.stdin.readline().split()]
print(int(math.ceil((n-1)/(k-1))))

9.艰难抉择：
给出一个含有n个数字的序列a1,a2,a3,…an，可以进行以下操作：
一次操作定义为对这个序列的每个数字进行以下两种改变之一：
ai ÷ 2
ai × 3

每一次的操作中，必须保证至少有一个数字是第1种改变；并且经过每次操作后，每一个数字都必须是整数。牛牛得知，每进行一次操作，他就可以得到一颗西瓜糖，但是由于孱弱的数学功底，他不知道何时该对某一个数字进行第一种还是第二种改变，这使得他十分纠结，于是他找来了睿智的你，希望你帮他计算出，他最多可以得到多少颗西瓜糖。

from math import log
  
listNum = input()
listInfo = input().split()
list2 = []
for i in listInfo:
    i = int(i)
    if i%2 == 0:
        list2.append(i)
if len(list2) == 0:
    print("0")
else:
    a = 0
    for j in list2:
        result = j & (j-1)
        if result != 0:
            while True:
                if j%2 == 0:
                    a=a+1
                    j=j//2 
                else:
                    break
        else:
            c = log(j,2)          
            a = a + int(c)
    print(a)