给你一个非负整数数组 nums 。如果存在一个数 x ，使得 nums 中恰好有 x 个元素 大于或者等于 x ，那么就称 nums 是一个 特殊数组 ，而 x 是该数组的 特征值 。
注意： x 不必 是 nums 的中的元素。
如果数组 nums 是一个 特殊数组 ，请返回它的特征值 x 。否则，返回 -1 。可以证明的是，如果 nums 是特殊数组，那么其特征值 x 是 唯一的 。
示例 1：
输入：nums = [3,5] 输出：2 解释：有 2 个元素（3 和 5）大于或等于 2 。
示例 2：
输入：nums = [0,0] 输出：-1 解释：没有满足题目要求的特殊数组，故而也不存在特征值 x 。 如果 x = 0，应该有 0 个元素 >= x，但实际有 2 个。 如果 x = 1，应该有 1 个元素 >= x，但实际有 0 个。 如果 x = 2，应该有 2 个元素 >= x，但实际有 0 个。 x 不能取更大的值，因为 nums 中只有两个元素。
示例 3：
输入：nums = [0,4,3,0,4] 输出：3 解释：有 3 个元素大于或等于 3 。
示例 4：
输入：nums = [3,6,7,7,0] 输出：-1
提示：
1 <= nums.length <= 100 0 <= nums[i] <= 1000代码实现
class Solution: def specialArray(self, nums: List[int]) -> int: nums.sort() import bisect re = -1 for i in range(1,nums[-1]+1): idx = bisect_left(nums, i) if len(nums)-idx==i: return i return -1 奇偶树如果一棵二叉树满足下述几个条件，则可以称为 奇偶树 ：
二叉树根节点所在层下标为 0 ，根的子节点所在层下标为 1 ，根的孙节点所在层下标为 2 ，依此类推。 偶数下标 层上的所有节点的值都是 奇 整数，从左到右按顺序 严格递增 奇数下标 层上的所有节点的值都是 偶 整数，从左到右按顺序 严格递减给你二叉树的根节点，如果二叉树为 奇偶树 ，则返回 true ，否则返回 false 。
示例 1：
输入：root = [1,10,4,3,null,7,9,12,8,6,null,null,2] 输出：true 解释：每一层的节点值分别是： 0 层：[1] 1 层：[10,4] 2 层：[3,7,9] 3 层：[12,8,6,2] 由于 0 层和 2 层上的节点值都是奇数且严格递增，而 1 层和 3 层上的节点值都是偶数且严格递减，因此这是一棵奇偶树。
示例 2：
输入：root = [5,4,2,3,3,7] 输出：false 解释：每一层的节点值分别是： 0 层：[5] 1 层：[4,2] 2 层：[3,3,7] 2 层上的节点值不满足严格递增的条件，所以这不是一棵奇偶树。
示例 3：
输入：root = [5,9,1,3,5,7] 输出：false 解释：1 层上的节点值应为偶数。
示例 4：
输入：root = [1] 输出：true
示例 5：
输入：root = [11,8,6,1,3,9,11,30,20,18,16,12,10,4,2,17] 输出：true
提示：
树中节点数在范围 [1, 105] 内 1 <= Node.val <= 106代码实现
# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def isEvenOddTree(self, root: TreeNode) -> bool: dic = {} def iters(root,i): if root: if i not in dic: if i%2==0: if root.val%2==1: dic[i] = [root.val] else: return False else: if root.val%2==0: dic[i] = [root.val] else: return False else: if i%2==0: if root.val%2==1 and dic[i].pop()<root.val: dic[i].append(root.val) else: return False else: if root.val%2==0 and dic[i].pop()>root.val: dic[i].append(root.val) else: return False a = iters(root.left,i+1) if a==False: return False b = iters(root.right,i+1) if b==False: return False return True return iters(root, 0) 可见点的最大数目给你一个点数组 points 和一个表示角度的整数 angle ，你的位置是 location ，其中 location = [posx, posy] 且 points[i] = [xi, yi] 都表示 X-Y 平面上的整数坐标。
最开始，你面向东方进行观测。你 不能 进行移动改变位置，但可以通过 自转 调整观测角度。换句话说，posx 和 posy 不能改变。你的视野范围的角度用 angle 表示， 这决定了你观测任意方向时可以多宽。设 d 为逆时针旋转的度数，那么你的视野就是角度范围 [d - angle/2, d + angle/2] 所指示的那片区域。 https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/10/04/angle.mp4
对于每个点，如果由该点、你的位置以及从你的位置直接向东的方向形成的角度 位于你的视野中 ，那么你就可以看到它。
同一个坐标上可以有多个点。你所在的位置也可能存在一些点，但不管你的怎么旋转，总是可以看到这些点。同时，点不会阻碍你看到其他点。
返回你能看到的点的最大数目。
示例 1：
输入：points = [[2,1],[2,2],[3,3]], angle = 90, location = [1,1] 输出：3 解释：阴影区域代表你的视野。在你的视野中，所有的点都清晰可见，尽管 [2,2] 和 [3,3]在同一条直线上，你仍然可以看到 [3,3] 。
示例 2：
输入：points = [[2,1],[2,2],[3,4],[1,1]], angle = 90, location = [1,1] 输出：4 解释：在你的视野中，所有的点都清晰可见，包括你所在位置的那个点。
示例 3：
输入：points = [[0,1],[2,1]], angle = 13, location = [1,1] 输出：1 解释：如图所示，你只能看到两点之一。
提示：
1 <= points.length <= 105 points[i].length == 2 location.length == 2 0 <= angle < 360 0 <= posx, posy, xi, yi <= 109代码实现
class Solution: def visiblePoints(self, points: List[List[int]], angle: int, location: List[int]) -> int: import numpy as np angles = [] temp = 0 for a,b in points: if a-location[0]==0 and b-location[1]==0: temp+=1 else: ag = np.rad2deg(np.arctan2(a-location[0],b-location[1])) angles.append((ag+360)%360) maxs = 0 x = sorted(angles) for i in range(len(x)): t = x[i]+angle if t<360: idx = bisect.bisect_right(x, t) maxs = max(maxs, idx-i+temp) else: idx = bisect_right(x, t%360) maxs = max(maxs, len(x)+idx-i+temp) return maxs 使整数变为 0 的最少操作次数给你一个整数 n，你需要重复执行多次下述操作将其转换为 0 ：
翻转 n 的二进制表示中最右侧位（第 0 位）。 如果第 (i-1) 位为 1 且从第 (i-2) 位到第 0 位都为 0，则翻转 n 的二进制表示中的第 i 位。返回将 n 转换为 0 的最小操作次数。
示例 1：
输入：n = 0 输出：0
示例 2：
输入：n = 3 输出：2 解释：3 的二进制表示为 “11” “11” -> “01” ，执行的是第 2 种操作，因为第 0 位为 1 。 “01” -> “00” ，执行的是第 1 种操作。
示例 3：
输入：n = 6 输出：4 解释：6 的二进制表示为 “110”. “110” -> “010” ，执行的是第 2 种操作，因为第 1 位为 1 ，第 0 到 0 位为 0 。 “010” -> “011” ，执行的是第 1 种操作。 “011” -> “001” ，执行的是第 2 种操作，因为第 0 位为 1 。 “001” -> “000” ，执行的是第 1 种操作。
示例 4：
输入：n = 9 输出：14
示例 5：
输入：n = 333 输出：393
提示：
0 <= n <= 109代码实现
class Solution: def minimumOneBitOperations(self, n: int) -> int: re = 0 while n: re^=n n>>=1 return re