【Leetcode】 top100 round2 直接开背版

25 K个一组翻转数组

给你链表的头节点 head ,每 k 个节点一组进行翻转,请你返回修改后的链表。

k 是一个正整数,它的值小于或等于链表的长度。如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

思路:先按k个分段,标记段头段尾,写一个翻转k个节点的链表的函数,传回新的段头段尾,完成到下一段的切换;

class Solution(object):def reverseKGroup(self, head, k):""":type head: ListNode:type k: int:rtype: ListNode"""if head.next==None or k==1: return headp = ListNode(0)  #创建一个虚拟的头结点# p.next = headold_head, left, right = p, head, headwhile right:for _ in range(k-1):right = right.nextif not right: return p.next     old_tail = right.nextnew_head, new_tail = self.reverse(left, right)old_head.next = new_headnew_tail.next = old_tailold_head, left, right = new_tail, old_tail, old_tailreturn p.nextdef reverse(self, head, tail):pre, cur = head, head.nextwhile pre != tail:cur.next, cur, pre = pre, cur.next, cur  #必须同步更新,不然更改指向后无法切换到下一结点(或者用一个新结点记录)return pre, head   # 新头和新尾
138 随机链表的复制

给你一个长度为 n 的链表,每个节点包含一个额外增加的随机指针 random ,该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成,其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点,并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。返回复制链表的头节点。你的代码  接受原链表的头节点 head 作为传入参数。

思路一:一次遍历节点,在当前节点后创建一个相同的节点,完成next指针的复制;

          再次遍历节点,完成random指针的复制,复制节点(当前节点下一结点)的随机指针指向当前节点随机指针的下一结点(复制的随机节点),p.next.random = p.random.next

          最后遍历分离两链表;

class Solution(object):def copyRandomList(self, head):""":type head: Node:rtype: Node"""if not head:return Nonep = headwhile p:                 # 插入复制的新结点p.next = Node(p.val, p.next, None)p = p.next.nextp = headwhile p:                 # 设置random指针if p.random: p.next.random = p.random.nextp = p.next.nextp = headnew_head = Node(0)q = new_headwhile p:                 # 分离两链表q.next = p.nextq = q.nextp.next = q.next      # 不直接用p.next.next是因为要恢复原链表p = p.nextreturn new_head.next

思路二:一次遍历用hashmap存放{当前节点:复制节点};

              再次遍历复制next/random指针;

class Solution(object):def copyRandomList(self, head):""":type head: Node:rtype: Node"""if not head:return Nonehash = {}p = headwhile p:# hash[p] = Node(p.val, p.next, p.random)  next和random需要下一轮指定,因为此时结点还未完全创建hash[p] = Node(p.val)p = p.nextp = headwhile p:if p.next: hash[p].next = hash[p.next]if p.random: hash[p].random = hash[p.random]p = p.nextreturn hash[head]
148 排序链表

给你链表的头结点 head ,请将其按 升序 排列并返回 排序后的链表 。

思路一:冒泡排序—偷懒的方法是直接改变节点的值

class Solution(object):def sortList(self, head):""":type head: ListNode:rtype: ListNode"""if head is None or head.next is None:return headhead0 = ListNode(0)head0.next = headtail = Nonewhile head0.next != tail:pre, cur, nxt = head0, head0.next, head0.next.nextwhile nxt != tail:                   # 一次冒泡将当前最大值移到末尾if cur.val > nxt.val:pre.next, cur.next, nxt.next = nxt, nxt.next, curpre, nxt = nxt, cur.nextelse:pre, cur, nxt = pre.next, cur.next, nxt.nexttail = curreturn head0.next# 只能通过25/30,一个巨长的案例会超出时间限制;

思路二:归并排序—时间复杂度下降到O(nlogn)

class Solution:def sortList(self, head: Optional[ListNode]) -> Optional[ListNode]:def merge(head1, head2):dummy = ListNode(0)p = dummywhile head1 and head2:if head1.val<head2.val:p.next = head1p, head1 = p.next, head1.nextelse:p.next = head2p, head2 = p.next, head2.nextif head1: p.next = head1elif head2: p.next = head2return dummy.nextdef mergeSort(head):if not (head and head.next): return headslow, fast = head, head.nextwhile fast and fast.next:slow = slow.nextfast = fast.next.nextslow_head, fast_head = head, slow.nextslow.next = None    # 断开连接return merge(mergeSort(slow_head), mergeSort(fast_head))return mergeSort(head)
23 合并K个升序链表

给你一个链表数组,每个链表都已经按升序排列。请你将所有链表合并到一个升序链表中,返回合并后的链表。

思路一:两两合并直至成为一个链表—自底向上;

              将链表二分,先完成左侧排序,再完成右侧排序,然后两侧合并—自顶向下;

class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:def merge(head1, head2):dummy = ListNode(0)p = dummywhile head1 and head2:if head1.val<head2.val:p.next = head1p, head1 = p.next, head1.nextelse:p.next = head2p, head2 = p.next, head2.nextif head1: p.next = head1elif head2: p.next = head2return dummy.nextn = len(lists)if n==0: return Noneelif n==1: return lists[0]else:left = self.mergeKLists(lists[:n//2])right = self.mergeKLists(lists[n//2:])return merge(left, right)

思路二:在比较k个链表未合并的节点值时可以利用堆排序来找到当前的最小值,而不是全部遍历;甚至于将全部节点入堆;

import heapq
class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:# 需要设定节点比较,否则在堆化时会报错# 也可以只取node.val构造堆,然后根据pop出的值构造新节点即可,这种方法需要在初始化时将全部节点入堆setattr(ListNode, "__lt__", lambda a, b: a.val < b.val)tmp = [head for head in lists if head]   # 头结点入堆heapq.heapify(tmp)dummy = ListNode(0)p = dummywhile tmp:node = heapq.heappop(tmp)if node.next: heapq.heappush(tmp, node.next)p.next = nodep = p.nextreturn dummy.next# 全部节点入堆
import heapq
class Solution:def mergeKLists(self, lists: List[Optional[ListNode]]) -> Optional[ListNode]:tmp = []for head in lists:while head:tmp.append(head.val)head = head.nextheapq.heapify(tmp)dummy = ListNode(0)p = dummywhile tmp:val = heapq.heappop(tmp)p.next = ListNode(val)p = p.nextreturn dummy.next
146 LRU缓存

请你设计并实现一个满足  LRU (最近最少使用) 缓存 约束的数据结构。

实现 LRUCache 类:

  • LRUCache(int capacity) 以 正整数 作为容量 capacity 初始化 LRU 缓存
  • int get(int key) 如果关键字 key 存在于缓存中,则返回关键字的值,否则返回 -1 。
  • void put(int key, int value) 如果关键字 key 已经存在,则变更其数据值 value ;如果不存在,则向缓存中插入该组 key-value 。如果插入操作导致关键字数量超过 capacity ,则应该 逐出 最久未使用的关键字。

函数 get 和 put 必须以 O(1) 的平均时间复杂度运行。

考察:双向链表+哈希           在python中可以使用OrderedDict( )

# 有序字典
class LRUCache:def __init__(self, capacity: int):self.capacity = capacityself.lru = collections.OrderedDict()def get(self, key: int) -> int:if key in self.lru:self.lru.move_to_end(key)return self.lru[key]return -1def put(self, key: int, value: int) -> None:if self.get(key) == -1 and len(self.lru) == self.capacity:self.lru.popitem(last=False)self.lru[key] = value# 双向链表+哈希
class LRUCache:def __init__(self, capacity):self.cache = dict()self.head = DLinkedNode()  # 使用伪头部和伪尾部节点  self.tail = DLinkedNode()self.head.next = self.tailself.tail.prev = self.headself.capacity = capacityself.size = 0def get(self, key):if key not in self.cache: return -1node = self.cache[key]      # 如果key存在,先通过哈希表定位,再移到头部self.moveToHead(node)return node.valuedef put(self, key, value):if key not in self.cache:node = DLinkedNode(key, value)   # 如果key不存在,创建一个新的节点 self.cache[key] = node        #  添加进哈希表self.addToHead(node)         # 添加至双向链表的头部self.size += 1if self.size > self.capacity:removed = self.removeTail()  # 如果超出容量,删除双向链表的尾部节点self.cache.pop(removed.key)  # 删除哈希表中对应的项self.size -= 1else:node = self.cache[key]    # 如果key存在,先通过哈希表定位,再修改value,并移到头部node.value = valueself.moveToHead(node)def addToHead(self, node):node.prev = self.headnode.next = self.head.nextself.head.next.prev = nodeself.head.next = nodedef removeNode(self, node):node.prev.next = node.nextnode.next.prev = node.prevdef moveToHead(self, node):self.removeNode(node)self.addToHead(node)def removeTail(self):node = self.tail.prevself.removeNode(node)return node
236 二叉树的最近公共祖先

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

百度百科中最近公共祖先的定义为:“对于有根树 T 的两个节点 p、q,最近公共祖先表示为一个节点 x,满足 x 是 p、q 的祖先且 x 的深度尽可能大(一个节点也可以是它自己的祖先)。”

三种情况:p是q的最近公共祖先;q是p的最近公共祖先;p和q位于某个节点node的左右子树中,node为p和q的最近公共祖先;

即判断node是否为p,node是否为q,然后切换到node.left/node.right;

class Solution:def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':if root==p or root==q or root==None: return rootleft=self.lowestCommonAncestor(root.left,p,q)right=self.lowestCommonAncestor(root.right,p,q)if left and right:return rootif left and right==None:return leftif right and left==None:return right
124 二叉树的最大路径和

二叉树中的 路径 被定义为一条节点序列,序列中每对相邻节点之间都存在一条边。同一个节点在一条路径序列中 至多出现一次 。该路径 至少包含一个 节点,且不一定经过根节点。路径和 是路径中各节点值的总和。

给你一个二叉树的根节点 root ,返回其 最大路径和 。

含有当前节点的最大路径和=left+right+node.val

当前节点能给其父节点提供的最大路径和=max(left, right)+node.val  若该值为负则清零

class Solution:def maxPathSum(self, root: Optional[TreeNode]) -> int:global max_sum max_sum = float('-inf')def partPathSum(node):if node is None:return 0left = partPathSum(node.left)   # 左侧最大路径right = partPathSum(node.right) # 右侧最大路径global max_summax_sum = max(max_sum, node.val+left+right)  # 当前节点的最大路径return max(node.val+max(left, right), 0)     # 单侧的最大路径(负数归零)partPathSum(root)return max_sum
208 实现前缀树

Trie(发音类似 "try")或者说 前缀树 是一种树形数据结构,用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景,例如自动补完和拼写检查。

请你实现 Trie 类:

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中,返回 true(即,在检索之前已经插入);否则,返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ,返回 true ;否则,返回 false 。

前缀树中一个父节点会对应多个子节点,且涉及到查找——hashmap

class TrieNode:def __init__(self):self.child = {}self.end = Falseclass Trie:def __init__(self):self.root = TrieNode()   # 虚拟根节点def insert(self, word: str) -> None:node = self.rootfor strr in word:if strr not in node.child:node.child[strr] = TrieNode()node = node.child[strr]node.end = Truedef search(self, word: str) -> bool:node = self.rootfor strr in word:if strr not in node.child:return Falsenode = node.child[strr]return node.enddef startsWith(self, prefix: str) -> bool:node = self.rootfor strr in prefix:if strr not in node.child:return Falseelse:node = node.child[strr]return True
4 寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。算法的时间复杂度应该为 O(log (m+n)) 。

不断以二分的方式剔除不可能为中位数的值;

class Solution:def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:def getKthElement(k):index1, index2 = 0, 0while True:# 特殊情况if index1 == m:return nums2[index2 + k - 1]if index2 == n:return nums1[index1 + k - 1]if k == 1:return min(nums1[index1], nums2[index2])# 正常情况newIndex1 = min(index1 + k // 2 - 1, m - 1)        # 防止越界newIndex2 = min(index2 + k // 2 - 1, n - 1)pivot1, pivot2 = nums1[newIndex1], nums2[newIndex2]if pivot1 <= pivot2:k -= newIndex1 - index1 + 1index1 = newIndex1 + 1else:k -= newIndex2 - index2 + 1index2 = newIndex2 + 1m, n = len(nums1), len(nums2)totalLength = m + nif totalLength % 2 == 1:return getKthElement((totalLength + 1) // 2)else:return (getKthElement(totalLength // 2) + getKthElement(totalLength // 2 + 1)) / 2.
84 柱状图中的最大矩形

给定 n 个非负整数,用来表示柱状图中各个柱子的高度。每个柱子彼此相邻,且宽度为 1 。求在该柱状图中,能够勾勒出来的矩形的最大面积。

class Solution:def largestRectangleArea(self, heights: List[int]) -> int:n = len(heights)left, right = [-1]*n, [n]*nstack = []for i in range(n):while stack and heights[stack[-1]] >= heights[i]: # 找到val的左界stack.pop()if stack: left[i] = stack[-1]stack.append(i)print(left)stack = []for i in range(n-1, -1, -1):         while stack and heights[stack[-1]] >= heights[i]: # 找到val的右界stack.pop()if stack: right[i] = stack[-1]stack.append(i)print(right)out = 0for i in range(n):ans = heights[i]*(right[i]-left[i]-1)out = max(ans, out)return out
堆 215/347/295

【Leetcode】top 100 堆-CSDN博客

32 最长有效括号

给你一个只包含 '(' 和 ')' 的字符串,找出最长有效(格式正确且连续)括号子串的长度。

方法一:动态规划:dp[i]代表长度为i的字符串的最长有效括号子串的长度

当s[i] = '('时,不考虑有效情况;

当s[i] = ')'时,若dp[i-1]=k且s[i-k-1]='(',dp[i]=dp[i-1]+2

                      如果此时能与dp[i-k-2]连接起来,dp[i]=dp[i-1]+2+dp[i-k-2]

class Solution:def longestValidParentheses(self, s: str) -> int:n = len(s)dp = [0]*nmaxlen = 0for i in range(n):if s[i] == '(': continueelse:if i-dp[i-1]-1>=0 and s[i-dp[i-1]-1]=='(':   # 需要下标i-dp[i-1]-1有效if i-dp[i-1]-2>=0:                       # 需要下标i-dp[i-1]-2有效dp[i]=dp[i-1]+2+dp[i-dp[i-1]-2]else:dp[i] = dp[i-1]+2maxlen = max(maxlen, dp[i])return maxlen

方法二:栈来判断匹配是否成功,开辟数组记录匹配成功的括号,最后统计连续的最长长度;

class Solution:def longestValidParentheses(self, s: str) -> int:stack, tmp = [], [0]*len(s)for i, strr in enumerate(s):if strr=='(': stack.append(i)else:if stack and s[stack[-1]]=='(':tmp[i], tmp[stack[-1]] = 1, 1stack.pop()length, maxlen = 0, 0for num in tmp:if num: length += numelse:maxlen = max(maxlen, length)length = 0maxlen = max(maxlen, length)return maxlen
5 最长回文子串

给你一个字符串 s,找到 s 中最长的回文子串。如果字符串的反序与原始字符串相同,则该字符串称为回文字符串。

方法一:直接模拟  一次遍历以当前字符为回文中心进行扩展,更新最长回文子串;

方法二:动态规划  区间dp

dp[i][j]代表s[i:j+1]的字符串的回文情况,最长回文子串选择记录起始点和长度

状态转移:当s[i]==s[j]时且dp[i+1][j-1]为回文子串时,dp[i][j]也为回文子串;

因为dp[i][j]状态依赖于dp[i+1][j-1],所以需要从下往上/从左往右遍历来更新dp;

class Solution:def longestPalindrome(self, s: str) -> str:n = len(s)dp = [[False]*n for _ in range(n)]start, maxlen = 0, 1for i in range (n-1,-1,-1):for j in range (i, n):      # 注意j的范围# 奇长度的回文串中心if j==i: dp[i][j] = True  #i=0/j=0仍为False# 偶长度的回文串中心elif j==i+1: if s[i]==s[j]: dp[i][j] = True# 长度扩展else:if s[i]==s[j] and dp[i+1][j-1]: dp[i][j] = Trueif dp[i][j]:              # 更新起点和长度if j-i+1>maxlen:maxlen = j-i+1start = ireturn s[start:start+maxlen]

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/news/835170.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

车载电子电器架构 —— 应用软件开发(上)

车载电子电器架构 —— 应用软件开发(上) 我是穿拖鞋的汉子,魔都中坚持长期主义的汽车电子工程师。 老规矩,分享一段喜欢的文字,避免自己成为高知识低文化的工程师: 屏蔽力是信息过载时代一个人的特殊竞争力,任何消耗你的人和事,多看一眼都是你的不对。非必要不费力证明…

学习记录:AUTOSAR R20-11的阅读记录(五)【CP(5.11-5.19)】完

接上回&#xff1a;学习记录&#xff1a;AUTOSAR R20-11的阅读记录&#xff08;四&#xff09;【CP&#xff08;5.6-5.10&#xff09;】 五、CP 11、General&#xff08;4个&#xff09; 5.11 File Name 说明 1 AUTOSAR_EXP_ LayeredSoftwareArchitecture.pdf 描述了AUTO…

【HMWeb】HTML使用Leaflet实现本地离线地图Gis应用

下载Leaflet 官网下载&#xff1a;https://leafletjs.com/reference.html CSDN&#xff1a;https://download.csdn.net/download/hmxm6/89291989 选择版本号 添加html文件 加入代码 <!DOCTYPE html> <html lang"en"> <head><meta charset&qu…

记一次DNS故障导致用户无法充值的问题(下)

上一篇说到DNS故障导致无法充值&#xff0c;后来我们通过拨测发现业务域名的解析目标地址被解析到了【127.0.0.1】IP。 1、联系阿里云厂商&#xff0c;通过沟通&#xff0c;阿里云反馈我们的域名被XX省通管单位封禁了&#xff0c;导致解析到了不正确的地址。 2、为了解决用户问…

【hackmyvm】 Animetronic靶机

靶机测试 arp-scanporturl枚举exiftool套中套passwordsudo 提权 arp-scan arp-scan 检测局域网中活动的主机 192.168.9.203 靶机IP地址port 通过nmap扫描&#xff0c;获取目标主机的端口信息 ┌──(root㉿kali)-[/usr/share/seclists] └─# nmap -sT -sV -O 192.16…

如何在JavaScript/Vue中获取当前时间并格式化输出(精确到时分秒)

如何在JavaScript/Vue中获取当前时间并格式化输出&#xff08;精确到时分秒&#xff09; 不只是树&#xff0c;人也是一样&#xff0c;在不确定中生活的人&#xff0c;能比较经得起生活的考验&#xff0c;会锻炼出一颗独立自主的心。在不确定中&#xff0c;就能学会把很少的养分…

CTF例题和知识点

[ACTF2020 新生赛]Include 打开靶机发现一个超链接&#xff0c;点击之后出现一段话 “Can you find out the flag?” 查看源码注入&#xff0c;无果 仔细看url&#xff0c;发现有flag.php 根据题目提示&#xff0c;该题应该是文件包含漏洞&#xff0c;因此可以判断出此题是PH…

基于SpringBoot的全国风景区WebGIS按省展示实践

目录 前言 一、全国风景区信息介绍 1、全国范围内数据分布 2、全国风景区分布 3、PostGIS空间关联查询 二、后台查询的设计与实现 1、Model和Mapper层 2、业务层和控制层设计 三、WebGIS可视化 1、省份范围可视化 2、省级风景区可视化展示 3、成果展示 总结 前…

P9420 [蓝桥杯 2023 国 B] 子 2023 / 双子数

蓝桥杯2023国B A、B题 A题 分析 dp问题 根据子序列&#xff1a;2&#xff0c;20&#xff0c;202&#xff0c;2023分为4个状态&#xff1b; 当前数字为2时&#xff0c;处于dp[0]&#xff0c;或者和dp[1]结合成dp[2]&#xff1b; 当前数字为0时&#xff0c;和dp[0]结合成dp[…

keil5软件安装教程(MDKv5.39)

keil5软件安装分为三部分&#xff1a; 目录 1.安装mdk 2.激活mdk 3.安装STM32芯片包 1.安装mdk 安装包链接&#xff1a;链接&#xff1a;https://pan.baidu.com/s/1PZoGhzI5Y19ROv7xe9QJKA?pwdgt3s 提取码&#xff1a;gt3s 1、下载keil5的压缩包并解压&#xff0c;鼠…

buuctf-misc题目练习三

荷兰宽带数据泄露 BIN 文件&#xff0c;也称为二进制文件&#xff0c;是一种压缩文件格式&#xff0c;可以 包含图像和视频等信息 , 并被许多应用程序用于各种目的。 RouterPassView是一个找回路由器密码的工具。 大多数现代路由器允许备份到一个文件路由器的配置&#xff0c…

CDGA|电子行业数据治理六大痛点及突围之道

CDGA|电子行业数据治理六大痛点及突围之道 随着信息技术的迅猛发展&#xff0c;电子行业对数据的需求和依赖日益增强。然而&#xff0c;数据治理作为确保数据质量、安全性及有效利用的关键环节&#xff0c;在电子行业中却面临着一系列痛点。本文将深入探讨电子行业数据治理的六…

CTFHUB-技能树-Web题-RCE(远程代码执行)-文件包含

CTFHUB-技能树-Web题-RCE&#xff08;远程代码执行&#xff09; 文件包含 文章目录 CTFHUB-技能树-Web题-RCE&#xff08;远程代码执行&#xff09;文件包含解题方法1:![在这里插入图片描述](https://img-blog.csdnimg.cn/direct/71f7355b3c124dfe8cdf1c95e6991553.png#pic_ce…

【Java基础】Maven继承

1. 前言 Maven 在设计时&#xff0c;借鉴了 Java 面向对象中的继承思想&#xff0c;提出了 POM 继承思想。 2. Maven继承 当一个项目包含多个模块时&#xff0c;可以在该项目中再创建一个父模块&#xff0c;并在其 POM 中声明依赖&#xff0c;其他模块的 POM 可通过继承父模…

4D 成像毫米波雷达:新型传感器助力自动驾驶

1 感知是自动驾驶的首要环节&#xff0c;高性能传感器必不可少 感知环节负责对侦测、识别、跟踪目标&#xff0c;是自动驾驶实现的第一步。自动驾驶的实现&#xff0c;首先要能够准确理解驾驶环境信息&#xff0c;需要对交通主体、交通信号、环境物体等信息进行有效捕捉&#x…

热爱电子值得做的电子制作实验

加我zkhengyang&#xff0c;进嵌入式音频系统研究开发交流答疑群(课题组) AM/FM收音机散件制作&#xff0c;磁带随声听散件&#xff0c;黑白电视机散件制作&#xff0c;功放散件制作&#xff0c;闪光灯散件制作&#xff0c;声控灯散件&#xff0c;等等&#xff0c;可提高动手能…

MultiBoot 和 QuickBoot

目录 MultiBoot简介MultiBoot 实现方式设置 bitstream 属性使用 ICAPE2 原语WBSTAR 寄存器定义 MultiBoot 工作流程生成mcs固化文件 Tcl 指令Fallback状态寄存器MultiBoot 正常加载状态看门狗1超时状态看门狗2超时状态CRC 错误和无 DESYNC 命令IDCODE 错误状态CRC 错误状态 Wat…

17 【Aseprite 作图】参考图和颜色

参考图 Aseprite 作图&#xff0c;“打开 - 一张参考图”&#xff0c;再把参考图拉到右边&#xff0c;就可以得到参考图和缩略图 取消选区 通过“选择 - 取消选择”&#xff0c;可以 取消选区 复制参考图的颜色 打开参考图后&#xff0c;参考图的调色板就会出现参考图所有的…

202466读书笔记|《一天一首古诗词》——借问梅花何处落,风吹一夜满关山

202466读书笔记|《一天一首古诗词》——借问梅花何处落&#xff0c;风吹一夜满关山 上册下册 《一天一首古诗词》作者李锡琴&#xff0c;蛮早前加入书架的已购买书籍&#xff0c;这次刚好有点时间&#xff0c;利用起来读完。 赏析没有细看&#xff0c;只读了诗词部分&#xff0…

Java数组的应用---选择排序(Select Sort)

一、需求&#xff1a;选择排序(Select Sort)&#xff0c;进行升序显示 在一组排列中把最大的数取出来放在一个新的列表里&#xff0c;再删去&#xff0c;在取最大的数出来&#xff0c;依次类推直到取到最后一个数字 二、定义一个无序的一维数组&#xff0c;并输出数组 程序运…