python数据分析题目

1. 查找list中某元素全部出现的位置索引

my_list = [1, 0, 3, 5, 0, 0]
print([i for i, v in enumerate(my_list) if v == 0])

2. 填充数组

牛妹给了牛牛一个长度为 nnn 的下标从000开始的正整型数组 aaa ，粗心的牛牛不小心把其中的一些数字删除了。

假如aia_{i}ai被删除了，则ai=0a_{i}=0ai=0。对于所有被删除的数字，牛牛必须选择一个正整数填充上。现在牛牛想知道有多少种填充方案使得：

• a0≤a1≤...≤an−1a_{0} \leq a_{1} \leq...\leq a_{n-1}a0≤a1≤...≤an−1 且对于所有的0≤i≤n−10 \leq i \leq n-10≤i≤n−1满足1≤ai≤k1 \leq a_{i} \leq k1≤ai≤k 。

函数传入一个下标从000开始的数组 aaa 和一个正整数 kkk ，请返回合法的填充方案数对 109+710^9+7109+7取模的值,保证不存在方案数为0的数据。

链接：https://www.nowcoder.com/questionTerminal/3e34d9ed0bbc4db68b6fbca20a62926d?mutiTagIds=2678&page=1&onlyReference=false
来源：牛客网

#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param a int整型一维数组 
# @param k int整型 
# @return int整型
#
class Solution:
    def FillArray(self, a: List[int], k: int) -> int:
        # write code here
        mod = 10 ** 9 + 7
        n = len(a)
        dp = [[0] * (k + 1) for _ in range(n + 1)] #n+1 * k+1
 
        # 填充迭代表，用于记录
        # 第一行用于表示常数时表示的个数为1，是为了35行的代码能与是连续0的情况保持一致而使用的
        for j in range(0, k + 1):
            dp[0][j] = 1
        for j in range(1, k + 1):
            dp[1][j] = j
        for i in range(2, n + 1):
            for j in range(1, k + 1):
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j]
 
        ans = 1
        num = 0  # 对连续0计数
        start = 1  # 左边界值
        i = 0
        while (i < n):
            if a[i] == 0:
                num += 1
                i += 1
            else:
                ans = ans * dp[num][a[i] - start + 1]#num是连续0的个数，即空位个数，
                     #a[i] - start + 1是取值范围长度，即填充的范围在start和a[i]之间
                     #最后的ans是每一段空位之间的方案个数累乘
                start = a[i]
                num = 0
                i += 1
        # 处理最后一次如果不是常数结尾的情况
        if num!=0:
            ans = ans * dp[num][k - start + 1]
 
 
        return ans % mod

3. 最大值

有一个只由字符'1'到'9'组成的长度为 �n 的字符串 �s ，现在可以截取其中一段长度为 �k 的子串并且将该子串当作十进制的正整数，如对于子串"123"，其对应的十进制数字就是123123 。

如果想让这个正整数尽可能的大的话，问该正整数最大能是多少。

函数传入一个长度为 �n 的字符串 �s 和一个正整数 �k ，请你返回答案

class Solution:
    def maxValue(self , s , k ):
        # write code here
        n=len(s)
        ss=[]
        for i in range(len(s)):
            ss.append(int(s[i:i+1]))
        if k==1:
            return max(ss)
        else:
            start=max(ss[:-k+1])
            pos=[i for i, v in enumerate(ss) if v == start] #position
            numlist=[]
            for i in range(len(pos)):
                numlist.append(int(s[pos[i]:pos[i]+k]))
            maxnum=max(numlist)
            return maxnum

4. 修剪叶子

有一棵有�n个节点的二叉树，其根节点为����root。修剪规则如下:

1.修剪掉当前二叉树的叶子节点，但是不能直接删除叶子节点

2.只能修剪叶子节点的父节点，修剪了父节点之后，叶子节点也会对应删掉

3.如果想在留下尽可能多的节点前提下，修剪掉所有的叶子节点。请你返回修剪后的二叉树。

有如下二叉树:

链接：https://www.nowcoder.com/questionTerminal/39b559fb84864bde93eccd6e87312650
来源：牛客网

递归写不好 写的3次遍历 
1:    所有的叶节点值改为2
2:    所有叶节点的父节点值改为3
3:    所有值为3点节点改为None


# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param root TreeNode类 
# @return TreeNode类
#
class Solution:
    def pruneLeaves(self , root ):
        # write code here
 
        def find(tree):
            if not tree.right and not tree.left:
                tree.val = 2 
            if tree.right:
                find(tree.right)
            if tree.left:
                find(tree.left)
 
        find(root)
 
        def find2(tree):
            if tree.right:
                if tree.right.val == 2:
                    tree.val = 3 
                else:
                    find2(tree.right)
            if tree.left:
                if tree.left.val == 2:
                    tree.val = 3 
                else:
                    find2(tree.left)
 
        find2(root) 
 
        def find3(tree):
            if tree.right:
                if tree.right.val != 1:
                    tree.right = None 
                else:
                    find3(tree.right) 
            if tree.left:
                if tree.left.val != 1:
                    tree.left = None 
                else:
                    find3(tree.left) 
        find3(root) 
        if root.val == 2&nbs***bsp;root.val == 3:
            return None 
        return root

链接：https://www.nowcoder.com/questionTerminal/39b559fb84864bde93eccd6e87312650
来源：牛客网

class Solution():
    def findpath(self, node):
        if node is None:
            return None
        if node.left is None and node.right is not None:
            if node.right.left is None and node.right.right is None:
                return
        if node.right is None and node.left is not None:
            if node.left.left is None and node.left.right is None:
                return
        if node.left is not None and node.right is not None:
            if (node.left.left is None and node.left.right is None)&nbs***bsp;(node.right.left is None and node.right.right is None):
                return
        root = TreeNode(node.val)
        root.left = self.findpath(node.left)
        root.right = self.findpath(node.right)
        return root

算法

1. 判断素数

import math 
 
def isPrime(n): 
  if n <= 1: 
  return False
  for i in range(2, int(math.sqrt(n)) + 1): 
  if n % i == 0: 
    return False
  return True

不用math

def isPrime(n): 
  if n <= 1: 
    return False
  i = 2
  while i*i <= n: 
    if n % i == 0: 
      return False
    i += 1
  return True
或者
def isPrime(n): 
  if n <= 1: 
    return False
  if n == 2: 
    return True
  if n % 2 == 0: 
    return False
  i = 3
  while i * i <= n: 
    if n % i == 0: 
      return False
    i += 2
  return True

2. 漫展奖励

某次漫展，已知有n个打卡点，每个打卡点的活动需要 m_i 分钟完成，完成后获得奖励点 r_i，已经打卡过的点不能再去。

需要在规定 m 分钟内完成，尽可能多的收获奖励点，求获得最多的奖励点数。

链接：https://www.nowcoder.com/questionTerminal/d021479c25634b1ab56a32323461d970
来源：牛客网

n, m = map(int, input().strip().split())
ms, rs = [], []
for _ in range(n):
    mi, ri = map(int, input().strip().split())
    ms.append(mi)
    rs.append(ri)
maxScore = 0
dp = [[0]*(m + 1) for _ in range(n)]
for i in range(n):
    for j in range(m + 1):
        if j >= ms[i]:
            dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - ms[i]] + rs[i])     # 能看的情况下，选择看与不看中收益大的策略
        else:
            dp[i][j] = dp[i - 1][j]      # 时间受限，第i个展看不了
print(dp[-1][-1])

01背包问题的模板，dp[i][j]表示在剩余时间为j分钟的情况下，考虑漫展0~i的最大奖励点，那么它有两种情况进行状态转移。

(1) 如果已经不够时间去漫展i进行打卡，则有dp[i][j] = dp[i-1][j]，这个展不去了。

(2) 否则可以选择去与不去，如果去则应该加上这个展的奖励点，dp[i][j] = dp[i - 1][j-mi]+ri，否则与情况(1)相同，应该选择这两种策略中能让奖励点更多的策略：

3. 最大回文字符串

链接：https://www.nowcoder.com/questionTerminal/d16829f1d3e04deda2acabf969d1db69
来源：牛客网

s1 = input()
t = ''
def hw(str1):
    if str1 == str1[::-1]: #str1翻转
        return True
    else:
        return False
 
for i in range(1,len(s1)+1):
    for j in range(len(s1)):
        s2 = s1[j:j+i]
        if hw(s2):
            if len(t) < len(s2):
                t = s2
print(t)