每日一练 — 2022.01.08

---

一，按要求实现程序功能

1，程序简介

（1）定义一个函数prime判断某个整数是否为素数；
（2）然后从键盘输入一行字符串，将其中的连续数字依次提取出来形成一个列表。例如，字符串“ab12cd34fg67”按要求提取后形成列表[12,34,67]；
（3）将列表中的所有非素数改为0（要求用prime函数判断列表中的元素是否为素 数）；
（4）输出原始字符串及修改前、修改后的列表。 提示：可以用s.isdigit()判断s是否为数字字符（串）

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Sat Jan  8 08:21:14 2022
Function: 按要求实现程序功能
@author: 小梁aixj
"""
import math,re
def prime(num):
    flag = False
    if num > 1:
        for i in range(2, math.floor(math.sqrt(num))):
            if (num % i) == 0:
                flag = True
                break
    if flag:
        print(num, "不是素数")
    else:
        print(num, "是素数")
    return flag
s = input("请输入字符串：")
sList = re.findall(r'(\d+)', s)
sNum = [int(x) for x in sList]
y = lambda x: 0 if prime(x) else x
sNew = [y(x) for x in sNum]
print(sNum) 
print(sNew) 

3，运行结果

二，扰乱字符串

1，程序简介

使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：

1. 如果字符串的长度为 1 ，算法停止
2. 如果字符串的长度 > 1 ，执行下述步骤：

• 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
• 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
• 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。

给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s1 的扰乱字符串。如果是，返回 true ；否则，返回 false 。

示例 1：

• 输入：s1 = “great”, s2 = “rgeat”
• 输出：true
• 解释：s1 上可能发生的一种情形是：
  “great” --> “gr/eat” // 在一个随机下标处分割得到两个子字符串
  “gr/eat” --> “gr/eat” // 随机决定：「保持这两个子字符串的顺序不变」
  “gr/eat” --> “g/r / e/at” // 在子字符串上递归执行此算法。两个子字符串分别在随机下标处进行一轮分割
  “g/r / e/at” --> “r/g / e/at” // 随机决定：第一组「交换两个子字符串」，第二组「保持这两个子字符串的顺序不变」
  “r/g / e/at” --> “r/g / e/ a/t” // 继续递归执行此算法，将 “at” 分割得到 “a/t”
  “r/g / e/ a/t” --> “r/g / e/ a/t” // 随机决定：「保持这两个子字符串的顺序不变」
  算法终止，结果字符串和 s2 相同，都是 “rgeat”
  这是一种能够扰乱 s1 得到 s2 的情形，可以认为 s2 是 s1 的扰乱字符串，返回 true

示例 2：

• 输入：s1 = “abcde”, s2 = “caebd”
• 输出：false

示例 3：

• 输入：s1 = “a”, s2 = “a”
• 输出：true

提示：

• s1.length == s2.length
• 1 <= s1.length <= 30
• s1 和 s2 由小写英文字母组成

以下程序实现了这一功能，请你填补空白处内容：

class Solution(object):
	def isScramble(self, s1, s2, memo={}):
		if len(s1) != len(s2) or sorted(s1) != sorted(s2):
			return False
		if len(s1) <= len(s2) <= 1:
			return s1 == s2
		if s1 == s2:
			return True
		if (s1, s2) in memo:
			return memo[s1, s2]
		n = len(s1)
		for i in range(1, n):
			___________________________;
		memo[s1, s2] = False
		return False
# %%
s = Solution()
print(s.isScramble(s1 = "great", s2 = "rgeat"))

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Sat Jan  8 08:21:39 2022
Function: 扰乱字符串
@author: 小梁aixj
"""
class Solution(object):
    def isScramble(self, s1, s2, memo={}):
        if len(s1) != len(s2) or sorted(s1) != sorted(s2):
            return False
        if len(s1) <= len(s2) <= 1:
            return s1 == s2
        if s1 == s2:
            return True
        if (s1, s2) in memo:
            return memo[s1, s2]
        n = len(s1)
        for i in range(1, n):
            
            a = self.isScramble(s1[:i], s2[:i], memo) and self.isScramble(s1[i:], s2[i:], memo)
            if not a:
                b = self.isScramble(s1[:i], s2[-i:], memo) and self.isScramble(s1[i:], s2[:-i], memo)
            if a or b:
                memo[s1, s2] = True
                return True     
            
        memo[s1, s2] = False
        return False
# %%
s = Solution()
print(s.isScramble(s1 = "great", s2 = "rgeat"))#true
print(s.isScramble(s1 = "abcde", s2 =  "caebd"))#false

3，运行结果

三，验证二叉搜索树

1，程序简介

• 给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

有效 二叉搜索树定义如下：

• 节点的左子树只包含 小于 当前节点的数。
• 节点的右子树只包含 大于 当前节点的数。
• 所有左子树和右子树自身必须也是二叉搜索树。

示例 1：

• 输入：root = [2,1,3]
• 输出：true

示例 2：

• 输入：root = [5,1,4,null,null,3,6]
• 输出：false
• 解释：根节点的值是 5 ，但是右子节点的值是 4 。

提示：

• $树中节点数目范围在[1,10^4]内$
• $-2^{31}<=Node.val<=2^{31}-1$

2，程序代码

# -*- coding: utf-8 -*-
"""
Created on Sat Jan  8 08:22:04 2022
Function: 验证二叉搜索树
@author: 小梁aixj
"""
import sys
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
class List2Tree(object):
    def __init__(self, nums: list):
        self.nums = nums
        self.queue = []
        if len(nums) == 1:
            self.root = TreeNode(self.nums.pop(0))
        else:
            a = self.nums.pop(0)
            b = self.nums.pop(0)
            c = self.nums.pop(0)
            self.root = TreeNode(a)
            if b is not None:
                self.root.left = TreeNode(b)
            else:
                self.root.left = b
            if c is not None:
                self.root.right = TreeNode(c)
            else:
                self.root.right = c
            self.queue.append(self.root.left)
            self.queue.append(self.root.right)
    def convert(self):
        while len(self.nums) > 0 and len(self.queue)> 0:
            node = self.queue.pop(0)
            if node is not None:
                num= self.nums.pop(0)
                if num is not None:
                    node.left = TreeNode(num)
                else:
                    node.left = num
                if len(self.nums) > 0:
                    num = self.nums.pop(0)
                else:
                    num = None
                if num is not None:
                    node.right = TreeNode(num)
                else:
                    node.right = num
                self.queue.append(node.left)
                self.queue.append(node.right)
        return self.root
class Solution(object):
    def isValidBST(self, root):
        root = List2Tree(root).convert()
        return self.isVaild_helper(root, -sys.maxsize - 1, sys.maxsize)
    def isVaild_helper(self, root, minVal, maxVal):
        if root is None:
            return True
        if root.val >= maxVal or root.val <= minVal:
            return False
        return self.isVaild_helper(root.left, minVal, root.val) and self.isVaild_helper(root.right, root.val, maxVal)
# %%
s = Solution()
print(s.isValidBST([5,1,4,None,None,3,6]))#false
print(s.isValidBST([2,1,3]))#true

3，运行结果