├── .gitignore ├── Stub ├── sql.stub ├── problem.stub ├── readmeStub.md ├── link.stub ├── tree.stub └── class.stub ├── util └── util.go ├── Math ├── 0292.nim-game │ └── main.go ├── 1025.divisor-game 除数博弈 │ └── main.go ├── 0877.stone-game 石头游戏 │ └── main.go ├── Sqrt ✅ 0319.bulb-switcher 灯泡开关 │ └── main.go ├── 0258.add-digits 各位相加 │ └── main.go ├── 0007.reverse-integer │ └── main.go ├── 1281.subtract-the-product-and-sum-of-digits-of-an-integer │ └── main.go ├── Cnt # LCP 11. 期望个数统计 │ └── main.go ├── 0066.plus-one 加一 │ └── main.go ├── 1313.decompress-run-length-encoded-list │ └── main.go ├── 0263.ugly-number 丑数 │ └── main.go ├── 0268.missing-number 丢失的数字 │ └── main.go ├── ✅ 2169.count-operations-to-obtain-zero 得到 0 的操作数 │ └── main.go ├── 0453.minimum-moves-to-equal-array-elements 最小操作次数使数组元素相等 │ └── main.go ├── 1403.minimum-subsequence-in-non-increasing-order │ └── main.go ├── 0492.construct-the-rectangle 构造矩形 │ └── main.go ├── 1266.minimum-time-visiting-all-points │ └── main.go ├── 0470.implement-rand10-using-rand7 用 Rand7() 实现 Rand10() │ └── main.go ├── ✅ 0537.complex-number-multiplication 复数乘法 │ └── main.go └── 0165.compare-version-numbers 比较版本号 │ └── main.go ├── readme.md ├── Sql ├── 1142.user-activity-for-the-past-30-days-ii 平均会话次数 │ └── 1.sql ├── 0627.swap-salary 变更性别 │ └── 1.sql ├── 1683.invalid-tweets 无效推文 │ └── 1.sql ├── 0182.duplicate-emails 找重复邮箱 │ └── 1.sql ├── 1303.find-the-team-size 团队人数 │ └── 1.sql ├── 0584.find-customer-referee 用户的推荐人 │ └── 1.sql ├── 0595.big-countries 大的国家 │ └── 1.sql ├── 1148.article-views-i 浏览过自己文章的作者 │ └── 1.sql ├── 0511.game-play-analysis-i 首次登陆的时间 │ └── 1.sql ├── 0610.triangle-judgement 判断三角形 │ └── 1.sql ├── 1069.product-sales-analysis-ii 产品的销售总额 │ └── 1.sql ├── 0596.classes-more-than-5-students 超过5名学生的课 │ └── 1.sql ├── 1517.find-users-with-valid-e-mails 邮箱正则 │ └── 1.sql ├── 1757.recyclable-and-low-fat-products 可回收且低脂的产品 │ └── 1.sql ├── 1350.students-with-invalid-departments 不存在院校的学生 │ └── 1.sql ├── 1667.fix-names-in-a-table 修复名字 │ └── 1.sql ├── 1729.find-followers-count 关注数 │ └── 1.sql ├── 1393.capital-gainloss 资本损益 │ └── 1.sql ├── 0175.combine-two-tables 给所有人加上地址 │ └── 1.sql ├── 0620.not-boring-movies 有趣的电影 │ └── 1.sql ├── 1068.product-sales-analysis-i 产品的年份和价格 │ └── 1.sql ├── 1445.apples-oranges 销量差 │ └── 1.sql ├── 1149.article-views-ii 一天浏览过两篇文章的人 │ └── 1.sql ├── 1421.npv-queries 连表 │ └── 1.sql ├── 0196.delete-duplicate-emails 删除重复邮箱 │ └── 1.sql ├── 0577.employee-bonus 员工奖金 │ └── 1.sql ├── 0613.shortest-distance-in-a-line 直线上的最近距离 │ └── 1.sql ├── 0586.customer-placing-the-largest-number-of-orders 订单最多的客户 │ └── 1.sql ├── 1527.patients-with-a-condition 患病患者 │ └── 1.sql ├── 1741.find-total-time-spent-by-each-employee 员工花费时间 │ └── 1.sql ├── 1308.running-total-for-different-genders 男女的累积分数 │ └── 1.sql ├── 0176.second-highest-salary 找第二名 Null 也返回 │ └── 1.sql ├── 0619.biggest-single-number 最出现一次的最大数字 │ └── 1.sql ├── 1821.find-customers-with-positive-revenue-this-year 正收入 │ └── 1.sql ├── 1045.customers-who-bought-all-products 买下所有产品的客户 │ └── 1.sql ├── 1378.replace-employee-id-with-the-unique-identifier 使用uuid替换id │ └── 1.sql ├── 1050.actors-and-directors-who-cooperated-at-least-three-times 合作至少三次的演员和导员 │ └── 1.sql ├── 1113.reported-posts 不同的报告记录 │ └── 1.sql ├── 1173.immediate-food-delivery-i 当天配送率 │ └── 1.sql ├── 0578.get-highest-answer-rate-question 回答率最高的问题 │ └── 1.sql ├── 1407.top-travellers 旅行距离排名 │ └── 1.sql ├── 1789.primary-department-for-each-employee 员工的主要部门 │ └── 1.sql ├── 1126.active-businesses 活跃的业务 │ └── 1.sql ├── 1661.average-time-of-process-per-machine 平均运行时间 │ └── 1.sql ├── 0607.sales-person 销售员 │ └── 1.sql ├── 1076.project-employees-ii 员工最多的项目 销售额最高的销售者 │ └── 1.sql ├── 1112.highest-grade-for-each-student 最高分数的学科 │ └── 1.sql ├── 1693.daily-leads-and-partners 统计 │ └── 1.sql ├── 0197.rising-temperature 温度相比昨天是上升的 │ └── 1.sql ├── 1322.ads-performance 广告效果统计 │ └── 1.sql ├── 1485.group-sold-products-by-the-date group聚合 │ └── 1.sql ├── 0181.employees-earning-more-than-their-managers 超过经理收入的员工 │ └── 1.sql ├── 0626.exchange-seats 换座位 │ └── 1.sql ├── 1587.bank-account-summary-ii 余大于10000的用户 │ └── 1.sql ├── 1211.queries-quality-and-percentage │ └── 1.sql ├── 0580.count-student-number-in-departments 各专业学生人数 │ └── 1.sql ├── 0585.investments-in-2016 2016年的投资 │ └── 1.sql ├── 0608.tree-node 树节点 │ └── 1.sql ├── 0574.winning-candidate 当选者 │ └── 1.sql ├── 1809.ad-free-sessions 没有展示广告的会话 │ └── 1.sql ├── 1070.product-sales-analysis-iii 第一年的价格 │ └── 1.sql ├── 1075.project-employees-i 项目的平均年限 │ └── 1.sql ├── 1715.count-apples-and-oranges 统计 │ └── 1.sql ├── 1777.products-price-for-each-store 每家商店价格 │ └── 1.sql ├── 1082.sales-analysis-i 销售额最高的销售者 │ └── 1.sql ├── 1565.unique-orders-and-customers-per-month 月订单数和顾客数 │ └── 1.sql ├── 0178.rank-scores 稠密排行 │ └── 1.sql ├── 1158.market-analysis-i 统计2019年订单总数 │ └── 1.sql ├── 1633.percentage-of-users-attended-a-contest 注册率 │ └── 1.sql ├── 1327.list-the-products-ordered-in-a-period 指定日期总数 │ └── 1.sql ├── 1355.activity-participants 去除第一和倒数第一 │ └── 1.sql ├── 1495.friendly-movies-streamed-last-month 儿童适宜的电影 │ └── 1.sql ├── 1831.maximum-transaction-each-day 每天最大交易 │ └── 1.sql ├── 1098.unpopular-books 过去一年少于十本的书 │ └── 1.sql ├── 1141.user-activity-for-the-past-30-days-i 近30天活跃数 │ └── 1.sql ├── 1270.all-people-report-to-the-given-manager 递归查询 │ └── 1.sql ├── 1543.fix-product-name-format 格式化 │ └── 1.sql ├── 0183.customers-who-never-order 从不订购的客户 │ └── 1.sql ├── 1571.warehouse-manager 计算立方 │ └── 1.sql ├── 1107.new-users-daily-count 每日新用户 │ └── 1.sql ├── 0603.consecutive-available-seats 连续空余座位 │ └── 1.sql ├── 0571.find-median-given-frequency-of-numbers 频率数字的中位数 │ └── 1.sql ├── 1204.last-person-to-fit-in-the-elevator 最后进入电梯 │ └── 1.sql ├── 1581.customer-who-visited-but-did-not-make-any-transactions 进店未交易 │ └── 1.sql ├── 0177.nth-highest-salary 找第N名 Null 也返回 │ └── 1.sql ├── 1285.find-the-start-and-end-number-of-continuous-ranges 区间次数 │ └── 1.sql ├── 1613.find-the-missing-ids 缺失的id │ └── 1.sql ├── 0612.shortest-distance-in-a-plane 平面上的最近距离 │ └── 1.sql ├── 1369.get-the-second-most-recent-activity 倒数第二次活动 │ └── 1.sql ├── 1083.sales-analysis-ii 买 S8 却没有 iPhone 的买家 │ └── 1.sql ├── 1795.rearrange-products-table 商品价格合并 │ └── 1.sql ├── 0569.median-employee-salary 每个公司薪酬中位数 │ └── 1.sql ├── 0534.game-play-analysis-iii 每人每天累积多少时长 │ └── 1.sql ├── 1174.immediate-food-delivery-ii 首日即时配送订单 │ └── 1.sql ├── 1077.project-employees-iii 项目经济最丰富的员工 │ └── 1.sql ├── 0602.friend-requests-ii-who-has-the-most-friends 谁有最多的好友 │ └── 1.sql ├── 1747.leetflex-banned-accounts 应被禁止的账户 │ └── 1.sql ├── 1398.customers-who-bought-products-a-and-b-but-not-c 买AB不买C │ └── 1.sql ├── 1459.rectangles-area 组合成矩形 │ └── 1.sql ├── 1709.biggest-window-between-visits 日期缺失 │ └── 1.sql ├── 1501.countries-you-can-safely-invest-in 通话时长高于平均 │ └── 1.sql ├── 1731.the-number-of-employees-which-report-to-each-employee 每位经理有多少下属 │ └── 1.sql ├── 1193.monthly-transactions-i 统计 │ └── 1.sql ├── 1241.number-of-comments-per-post 查询评论数 │ └── 1.sql ├── 1767.find-the-subtasks-that-did-not-execute 找到未执行的子任务 │ └── 1.sql ├── 0550.game-play-analysis-iv 首日后隔天登录玩家的比率 │ └── 1.sql ├── 0614.second-degree-follower 二级关注者 │ └── 1.sql ├── 1511.customer-order-frequency 六七月消费大于等于100 │ └── 1.sql ├── 1677.products-worth-over-invoices 统计 │ └── 1.sql ├── 1132.reported-posts-ii 垃圾清除率 │ └── 1.sql ├── 1321.restaurant-growth 最近七天平均值 │ └── 1.sql ├── 1084.sales-analysis-iii 只在春季销售的产品 │ └── 1.sql ├── 0597.friend-requests-i-overall-acceptance-rate 好友申请总体通过率 │ └── 1.sql ├── 1251.average-selling-price │ └── 1.sql ├── 1280.students-and-examinations 学生各科测试次数 │ └── 1.sql ├── 1294.weather-type-in-each-country 11月份的天气 │ └── 1.sql ├── 0601.human-traffic-of-stadium 人流量 │ └── 1.sql ├── 1264.page-recommendations 推荐朋友喜欢的页面 │ └── 1.sql ├── 1549.the-most-recent-orders-for-each-product 产品最新订单 │ └── 1.sql ├── 1097.game-play-analysis-v 第二天留存率 │ └── 1.sql ├── 1341.movie-rating 评论数和评分数统计 │ └── 1.sql ├── 0512.game-play-analysis-ii 首次登陆的设备名称 │ └── 1.sql ├── 1623.all-valid-triplets-that-can-represent-a-country 三个学校组合不同的代表队 │ └── 1.sql └── 0262.trips-and-users 非禁止用户取消率 │ └── 1.sql ├── Sort ├── 面试题 17.14. 最小K个数 │ └── main.go ├── 0912.sort-an-array 排序数组 │ └── main.go ├── 1984.minimum-difference-between-highest-and-lowest-of-k-scores 学生分数的最小差值 │ └── main.go └── 0179.largest-number 最大数 │ └── main.go ├── Bit ├── xor │ ├── 0136.single-number.go │ ├── 0693.binary-number-with-alternating-bits.go │ ├── 0389.find-the-difference.go │ ├── 0268.missing-number.go │ ├── 0371.sum-of-two-integers.go │ └── 0810.chalkboard-xor-gamemain.go ├── Brian Kernighan │ ├── 0191.number-of-1-bits.go │ ├── 0201.bitwise-and-of-numbers-range.go │ ├── 0461.hamming-distance.go │ ├── 0266.palindrome-permutation.go │ ├── 0338.counting-bits.go │ └── 0477.total-hamming-distance.go ├── perm │ ├── 0326.power-of-three.go │ ├── 0342.power-of-four.go │ ├── 0231.power-of-two.go │ └── 0869.reordered-power-of-2.go ├── shift │ ├── 0201.bitwise-and-of-numbers-range.go │ └── 0868.binary-gapmain.go ├── base │ ├── 0168.excel-sheet-column-titleExcel.go │ └── 0405.convert-a-number-to-hexadecimal.go ├── calculate │ └── 1689.partitioning-into-minimum-number-of-deci-binary-numbers-.go └── subset │ ├── sub-1&subset.go │ ├── 0078.subsets.go │ └── 0784.letter-case-permutationmain.go ├── DP ├── single (x) │ ├── pre │ │ ├── 1480.running-sum-of-1d-array 数组前缀和 │ │ │ └── main.go │ │ ├── 0525.contiguous-array 连续数组 │ │ │ └── main.go │ │ ├── 0523.continuous-subarray-sum 连续子数组和 K的倍数 │ │ │ └── main.go │ │ └── 0303.range-sum-query-immutable 区域和检索 - 数组不可变 │ │ │ └── main.go │ ├── section │ │ └── 0053.maximum-subarray 最大子数组和 │ │ │ └── main.go │ ├── incr │ │ ├── 0121.best-time-to-buy-and-sell-stock 买卖股票的最佳时机 │ │ │ └── main.go │ │ └── 5881.maximum-difference-between-increasing-elements 增量元素之间的最大差值 │ │ │ └── main.go │ ├── 0070.climbing-stairs 爬楼梯 │ │ └── main.go │ ├── 0509.fibonacci-number 斐波那契数 │ │ └── main.go │ └── 2171.removing-minimum-number-of-magic-beans 拿出最少数目的魔法豆 │ │ └── main.go ├── 0279.perfect-squares 完全平方数 │ └── main.go ├── path (x,y) │ ├── 0119.pascals-triangle-ii 杨辉三角 II │ │ └── main.go │ └── 0118.pascals-triangle 杨辉三角 │ │ └── main.go ├── 0650.2-keys-keyboard 只有两个键的键盘 │ └── main.go ├── string │ ├── single │ │ ├── 0005.longest-palindromic-substring 最长回文 Press │ │ │ └── main.go │ │ ├── 0091.decode-ways 解码方法 Press │ │ │ └── main.go │ │ └── 0005.longest-palindromic-substring 最长回文 │ │ │ └── main.go │ └── double │ │ ├── 0010.regular-expression-matching .*正则匹配 Right DFS │ │ └── main.go │ │ └── 0115.distinct-subsequences 不同的子序列 Press │ │ └── main.go ├── bit │ └── 0526.beautiful-arrangementmain.go └── min │ └── 0322.coin-change 零钱兑换 │ └── main.go ├── Enum ├── 1389.create-target-array-in-the-given-order 按既定顺序创建目标数组 │ └── main.go ├── 0121.best-time-to-buy-and-sell-stock 买卖股票的最佳时机 │ └── main.go ├── 0171.excel-sheet-column-number Excel 表列序号 │ └── main.go ├── 1295.find-numbers-with-even-number-of-digits 统计位数为偶数的数字 │ └── main.go ├── 0058.length-of-last-word 最后一个单词的长度 │ └── main.go ├── 0122.best-time-to-buy-and-sell-stock-ii 买卖股票的最佳时机 II │ └── main.go ├── 2177.find-three-consecutive-integers-that-sum-to-a-given-number 找到和为给定整数的三个连续整数 │ └── main.go ├── 1672.richest-customer-wealth 最富有客户的资产总量 │ └── main.go ├── ✅ 0088.merge-sorted-array 合并两个有序数组 │ └── main.go ├── 5875.final-value-of-variable-after-performing-operations 执行操作后的变量值 │ └── main.go ├── ✅ 1446.consecutive-characters 连续字符 │ └── main.go ├── 1503.last-moment-before-all-ants-fall-out-of-a-plank 所有蚂蚁掉下来前的最后一刻 │ └── main.go ├── 1646.get-maximum-in-generated-array 获取生成数组中的最大值 │ └── main.go ├── 0014.longest-common-prefix 最长公共前缀 │ └── main.go ├── ✅ 0747.largest-number-at-least-twice-of-others │ └── main.go ├── 2178.maximum-split-of-positive-even-integers 拆分成最多数目的偶整数之和 │ └── main.go ├── ✅ 2022.convert-1d-array-into-2d-array │ └── main.go ├── 0125.valid-palindrome 验证回文串 │ └── main.go ├── 1213.intersection-of-three-sorted-arrays 三个有序数组的交集 │ └── main.go └── 0038.count-and-say 外观数列 │ └── main.go ├── Offer ├── 面试题 01.01. 判定字符是否唯一 │ └── main.go ├── 面试题 01.04. 回文排列 │ └── main.go ├── 面试题 01.02. 判定是否互为字符重排 │ └── main.go ├── 面试题 17.04. 消失的数字 │ └── main.go ├── 剑指 Offer II 032. 有效的变位词 │ └── main.go ├── 剑指 Offer II 119. 最长连续序列 │ └── main.go ├── 剑指 Offer II 075. 数组相对排序 │ └── main.go ├── 面试题 17.10. 主要元素 (Moore 投票) │ └── main.go ├── 剑指 Offer 50. 第一个只出现一次的字符 │ └── main.go └── 面试题 16.15. 珠玑妙算 │ └── main.go ├── BinarySearch ├── basics │ ├── 0278.first-bad-version.go │ └── 1009.complement-of-base-10-integermain.go ├── readme.md └── rotate │ ├── 0153.find-minimum-in-rotated-sorted-array.go │ └── 0154.find-minimum-in-rotated-sorted-array-iiII.go ├── Array ├── 1470.shuffle-the-arraymain.go └── 6158.shifting-letters-iimain.go ├── LinkedList ├── 0237.delete-node-in-a-linked-list 删除节点 │ └── main.go ├── 0876.middle-of-the-linked-list 中间节点 │ └── main.go ├── 0206.reverse-linked-list 反转链表 │ └── main.go ├── 剑指 Offer 22. 链表中倒数第k个节点 │ └── main.go ├── 0141.linked-list-cycle 是否有环 │ └── main.go ├── 1290.convert-binary-number-in-a-linked-list-to-integer 二进制链表的值 │ └── main.go ├── 剑指 Offer II 023. 两个链表的第一个重合节点 │ └── main.go ├── 0160.intersection-of-two-linked-lists 相交起始点 │ └── main.go ├── (Swap) 0024.swap-nodes-in-pairs 两两交换节点 │ └── main.go ├── 0086.partition-list 小于X的靠左 │ └── main.go ├── 0083.remove-duplicates-from-sorted-list 删除重复多余元素 │ └── main.go ├── 1721.swapping-nodes-in-a-linked-list 交换镜像节点 │ └── main.go ├── 0061.rotate-list 拼接链表 │ └── main.go ├── 1669.merge-in-between-linked-lists │ └── main.go ├── 0142.linked-list-cycle-ii 环的起点 │ └── main.go ├── 0817.linked-list-components 链表组件 │ └── main.go ├── 1474.delete-n-nodes-after-m-nodes-of-a-linked-list 删除m节点后移动n节点 │ └── main.go └── 0082.remove-duplicates-from-sorted-list-ii 删除重复全部元素 │ └── main.go ├── TwoPointer ├── 0027.remove-element 移除元素 │ └── main.go ├── 1099.two-sum-less-than-k 小于 K 的两数之和 │ └── main.go ├── 0167.two-sum-ii-input-array-is-sortedII-.go ├── 0424.longest-repeating-character-replacement 替换后的最长重复字符 │ └── main.go ├── 0080.remove-duplicates-from-sorted-array-ii 删除有序数组中的重复项 II │ └── main.go ├── 1790.check-if-one-string-swap-can-make-strings-equal 仅执行一次字符串交换能否使两个字符串相等 │ └── main.go ├── 0524.longest-word-in-dictionary-through-deleting 通过删除字母匹配到字典里最长单词 │ └── main.go ├── Jump ✅ 0003.longest-substring-without-repeating-characters 无重复字符的最长子串 │ └── main.go ├── 0042.trapping-rain-water 接雨水 │ └── main.go └── 1455.check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentencemain.go ├── Hash ├── where │ ├── 0217.contains-duplicate 出现重复.go │ ├── 1133.largest-unique-number 最大的唯一数.go │ ├── 1394.find-lucky-integer-in-an-array 找出数组中的幸运数.go │ ├── 1119.remove-vowels-from-a-string 删去字符串中的元音.go │ ├── 1346.check-if-n-and-its-double-exist 是否存在两倍数.go │ └── 0359.logger-rate-limiter 相同消息截流.go ├── inter │ ├── 0771.jewels-and-stones 两数组 val 交集数.go │ ├── 0350.intersection-of-two-arrays-ii 两数组 val 交集.go │ └── 0349.intersection-of-two-arrays 两数组 val 交集 & 取唯一.go ├── comb │ ├── 1512.number-of-good-pairs 好数对的数目：i < j & a[i] == a[j].go │ ├── 0001.two-sum 两数之和.go │ ├── 2006.count-number-of-pairs-with-absolute-difference-k 差的绝对值为 K 的数对总数.go │ ├── 0930.binary-subarrays-with-sum 和为 goal 的二元子数组.go │ ├── 1128.number-of-equivalent-domino-pairs 组合相同的总数.go │ └── 1711.count-good-meals 大餐总数.go ├── perm │ ├── 0266.palindrome-permutation 有效回文.go │ ├── 1426.counting-elements 存在后置元素的元素个数.go │ ├── 0575.distribute-candies 得到最多类型的糖果.go │ ├── 0383.ransom-note 全排列 == 子排列.go │ ├── 0242.valid-anagram 有效的异位词.go │ ├── 0409.longest-palindrome 最长回文串.go │ ├── 0447.number-of-boomerangs 回旋镖的数量.go │ ├── 0128.longest-consecutive-sequence 最长递增.go │ ├── 1460.make-two-arrays-equal-by-reversing-sub-arrays 无限翻转子数组 使两个数组相等.go │ └── 1189.maximum-number-of-balloons 气球的最大数量.go ├── cnt │ ├── 0169.majority-element.go │ └── 0760.find-anagram-mappings.go ├── score │ ├── 1941.check-if-all-characters-have-equal-number-of-occurrences 检查是否所有字符出现次数相同.go │ ├── 1796.second-largest-digit-in-a-string 字符串中第二大的数字.go │ └── 1636.sort-array-by-increasing-frequency 按照频率将数组升序排序 🤚 权重.go ├── window │ ├── 0219.contains-duplicate-ii 两个重复元素距离小于等于K.go │ ├── 0961.n-repeated-element-in-size-2n-array 2N 中重复 N 次的元素.go │ ├── 0246.strobogrammatic-number 中心对称数.go │ ├── 0139.word-break 单词拆分.go │ └── 1624.largest-substring-between-two-equal-characters 两个相同字符之间的最长子字符串.go ├── state │ ├── 1748.sum-of-unique-elements 唯一元素的和.go │ ├── 0442.find-all-duplicates-in-an-array 数组中 重复的数.go │ ├── 0448.find-all-numbers-disappeared-in-an-array 等值数组中 消失的数.go │ └── 0041.first-missing-positive 缺失的第一个正数 Replace.go ├── mirror │ └── 0205.isomorphic-strings 同构字符串.go ├── vector │ └── 0049.group-anagrams 字母异位词分组.go ├── group │ └── 2176.count-equal-and-divisible-pairs-in-an-array 统计数组中相等且可以被整除的数对.go └── sort │ └── 1331.rank-transform-of-an-array 数组序号转换.go ├── Templates └── math │ ├── quick_pow.go │ └── quick_mul.go ├── Stack ├── 1598.crawler-log-folder 文件夹操作日志搜集器 │ └── main.go ├── 0856.score-of-parentheses 括号的分数 │ └── main.go ├── 1221.split-a-string-in-balanced-strings 分割平衡字符串 │ └── main.go ├── 1544.make-the-string-great 整理字符串 │ └── main.go ├── 0921.minimum-add-to-make-parentheses-valid 使括号有效的最少添加 │ └── main.go ├── 1003.check-if-word-is-valid-after-substitutions 检查替换后的词是否有效 │ └── main.go ├── ✅ 1614.maximum-nesting-depth-of-the-parentheses │ └── main.go ├── Cnt ✅ 0495.teemo-attacking 中毒时间统计 │ └── main.go ├── 0020.valid-parentheses 有效(){}[]括号 │ └── main.go ├── 1475.final-prices-with-a-special-discount-in-a-shopmain.go ├── 0946.validate-stack-sequences 验证栈序列 │ └── main.go ├── 0402.remove-k-digits 移掉K位数字后最小 │ └── main.go ├── 0739.daily-temperatures 能观测到更高温度的天数 │ └── main.go ├── 0844.backspace-string-compare 比较含退格的字符串 │ └── main.go ├── 0456.132-pattern 132模式 │ └── main.go └── 0503.next-greater-element-ii 下一个更大的值 │ └── main.go ├── 1619.mean-of-array-after-removing-some-elementsmain.go ├── 1985.find-the-kth-largest-integer-in-the-arraymain.go ├── Graph ├── 0657.robot-return-to-origin 机器人能否返回原点 │ └── main.go ├── Path ✅ 1436.destination-city 旅行终点站 │ └── main.go ├── Graph 0997.find-the-town-judge 找到小镇的法官 │ └── main.go └── LCP.07. 传递信息 │ └── main.go ├── Sum └── 0454.4sum-ii 四数相加 II │ └── main.go ├── Greedy ├── array │ ├── 0055.jump-game.go │ ├── 0045.jump-game-ii.go │ ├── 0134.gas-station.go │ └── 0334.increasing-triplet-subsequence.go ├── string │ ├── 1147.longest-chunked-palindrome-decomposition*.go │ └── 0678.valid-parenthesis-string.go ├── 0011.container-with-most-watermain.go ├── 0455.assign-cookiesmain.go └── 0670.maximum-swapmain.go ├── Matrix ├── (Border) ✅ 0598.range-addition-ii 范围求和 II │ └── main.go ├── (Order) 0074.search-a-2d-matrix 搜索二维矩阵 │ └── main.go └── 0311.sparse-matrix-multiplication 稀疏矩阵的乘法 │ └── main.go ├── 0215.kth-largest-element-in-an-arraymain.go ├── Tree ├── Postorder │ ├── sum │ │ └── 0222.count-complete-tree-nodes 完全二叉树的节点个数 │ │ │ └── main.go │ ├── depth │ │ ├── 0104.maximum-depth-of-binary-tree 二叉树的最大深度 │ │ │ └── main.go │ │ └── 0559.maximum-depth-of-n-ary-tree N 叉树的最大深度 │ │ │ └── main.go │ ├── ordinary │ │ └── 0814.binary-tree-pruning 二叉树剪枝 │ │ │ └── main.go │ ├── origin │ │ ├── 0590.n-ary-tree-postorder-traversal N 叉树的后序遍历 DFS │ │ │ └── main.go │ │ └── 0145.binary-tree-postorder-traversal 二叉树的后序遍历 │ │ │ └── main.go │ └── ancestor │ │ └── 0235.lowest-common-ancestor-of-a-binary-search-tree 二叉搜索树的最近公共祖先 │ │ └── main.go ├── Deep First Search │ ├── ordinary │ │ ├── 0100.same-tree 相同二叉树 │ │ │ └── main.go │ │ ├── 0226.invert-binary-tree 翻转二叉树 │ │ │ └── main.go │ │ ├── 0965.univalued-binary-tree 单值二叉树 │ │ │ └── main.go │ │ ├── 0617.merge-two-binary-trees 合并二叉树 │ │ │ └── main.go │ │ └── 0101.symmetric-tree 对称二叉树 │ │ │ └── main.go │ ├── ring │ │ └── 1490.clone-n-ary-tree 克隆 N 叉树 │ │ │ └── main.go │ └── leaf │ │ └── 0404.sum-of-left-leaves 左叶子之和 │ │ └── main.go ├── TBT │ ├── 0998.maximum-binary-tree-ii 最大二叉树 II 🎆 │ │ └── main.go │ ├── 1560.most-visited-sector-in-a-circular-track 二叉树的最近公共祖先 III │ │ └── main.go │ └── 0156.binary-tree-upside-down 上下翻转二叉树 🎆 │ │ └── main.go ├── Binary Search Tree │ └── 0700.search-in-a-binary-search-tree 搜索 │ │ └── main.go ├── Catalan │ └── 0096.unique-binary-search-trees 不同的二叉搜索树 ❌ │ │ └── main.go ├── Preorder │ ├── origin │ │ ├── 0589.n-ary-tree-preorder-traversal N 叉树的前序遍历 │ │ │ └── main.go │ │ └── 0144.binary-tree-preorder-traversal 二叉树的前序遍历 │ │ │ └── main.go │ └── ordinary │ │ └── 0199.binary-tree-right-side-view 二叉树的右视图 │ │ └── main.go ├── Inorder │ ├── origin │ │ └── 0094.binary-tree-inorder-traversal 二叉树的中序遍历 │ │ │ └── main.go │ └── order │ │ └── 0230.kth-smallest-element-in-a-bst 第K小的元素 │ │ └── main.go └── Struct │ └── inorder │ └── 0108.convert-sorted-array-to-binary-search-tree 将有序数组转换为二叉搜索树 │ └── main.go ├── Search ├── 0026.remove-duplicates-from-sorted-array 删除有序数组中的重复项 │ └── main.go ├── 0011.container-with-most-water 盛最多水的容器 │ └── main.go ├── Offer 53 - I. 在排序数组中查找数字 I │ └── main.go └── 1894.find-the-student-that-will-replace-the-chalk 找到需要补充粉笔的学生编号 │ └── main.go ├── Divide └── 面试题 08.03. 魔术索引 │ └── main.go ├── NumberTheory ├── pow │ └── 0050.powx-n.go └── 0762.prime-number-of-set-bits-in-binary-representationmain.go ├── Trie ├── ✅ 0386.lexicographical-numbers 字典序排数 DFS │ └── main.go └── ✅ 0386.lexicographical-numbers 字典序排数 FOR │ └── main.go ├── Design ├── 1656.design-an-ordered-stream 设计有序流 │ └── main.go └── 0170.two-sum-iii-data-structure-design 两数之和 III - 数据结构设计 │ └── main.go ├── 0672.bulb-switcher-iimain.go ├── HashRolling ├── diff │ └── 1698.number-of-distinct-substrings-in-a-string 字符串的不同子字符串个数 │ │ └── main.go └── both │ └── 1392.longest-happy-prefix 最长快乐前缀 │ └── main.go ├── Backtrack └── subset │ └── 0078.subsets.go └── Union └── 0056.merge-intervals 合并区间 └── main.go /.gitignore: -------------------------------------------------------------------------------- 1 | /.idea 2 | all.json 3 | 4 | -------------------------------------------------------------------------------- /Stub/sql.stub: -------------------------------------------------------------------------------- 1 | # Link: @DummyLink 2 | 3 | -------------------------------------------------------------------------------- /Stub/problem.stub: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // @DummyLink 4 | 5 | -------------------------------------------------------------------------------- /util/util.go: -------------------------------------------------------------------------------- 1 | package util 2 | 3 | /** 4 | 5 | 0 1 2 3 4 5 6 7 8 6 | 7 | 8 | */ 9 | -------------------------------------------------------------------------------- /Math/0292.nim-game/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func canWinNim(n int) bool { 4 | return n%4 != 0 5 | } 6 | -------------------------------------------------------------------------------- /Math/1025.divisor-game 除数博弈/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/divisor-game 4 | -------------------------------------------------------------------------------- /readme.md: -------------------------------------------------------------------------------- 1 | # LeetCode `1150/2792` 2 | 3 | [![](https://img.shields.io/badge/Language-Go-%2300ADD8)](https://golang.org/) 4 | -------------------------------------------------------------------------------- /Stub/readmeStub.md: -------------------------------------------------------------------------------- 1 | # LeetCode `1150/2792` 2 | 3 | [![](https://img.shields.io/badge/Language-Go-%2300ADD8)](https://golang.org/) 4 | -------------------------------------------------------------------------------- /Sql/1142.user-activity-for-the-past-30-days-ii 平均会话次数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/user-activity-for-the-past-30-days-ii 2 | 3 | -------------------------------------------------------------------------------- /Stub/link.stub: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // @DummyLink 9 | 10 | -------------------------------------------------------------------------------- /Sql/0627.swap-salary 变更性别/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/swap-salary 2 | 3 | UPDATE `salary` 4 | SET `sex` = IF(`sex` = 'f', 'm', 'f') -------------------------------------------------------------------------------- /Sort/面试题 17.14. 最小K个数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func smallestK(arr []int, k int) []int { 6 | sort.Ints(arr) 7 | return arr[:k] 8 | } 9 | -------------------------------------------------------------------------------- /Sql/1683.invalid-tweets 无效推文/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/invalid-tweets 2 | 3 | SELECT `tweet_id` 4 | FROM `tweets` 5 | WHERE CHAR_LENGTH(`content`) > 15 -------------------------------------------------------------------------------- /Stub/tree.stub: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | // @DummyLink 10 | 11 | -------------------------------------------------------------------------------- /Math/0877.stone-game 石头游戏/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/stone-game 4 | 5 | func stoneGame(piles []int) bool { 6 | return true 7 | } 8 | -------------------------------------------------------------------------------- /Sql/0182.duplicate-emails 找重复邮箱/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/duplicate-emails 2 | 3 | SELECT `email` 4 | FROM `person` 5 | GROUP BY `email` 6 | HAVING 1 < COUNT(`email`) -------------------------------------------------------------------------------- /Math/Sqrt ✅ 0319.bulb-switcher 灯泡开关/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math" 4 | 5 | func bulbSwitch(n int) int { 6 | return int(math.Sqrt(float64(n))) // 完全平方数 约数为奇数，灯泡亮，其他为成对出现 7 | } 8 | -------------------------------------------------------------------------------- /Sql/1303.find-the-team-size 团队人数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-the-team-size 2 | 3 | SELECT `employee_id`, COUNT(*) OVER (PARTITION BY `team_id`) `team_size` 4 | FROM `employee` 5 | -------------------------------------------------------------------------------- /Sql/0584.find-customer-referee 用户的推荐人/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-customer-referee 2 | 3 | 4 | SELECT `name` 5 | FROM `customer` 6 | WHERE `referee_id` != 2 7 | OR `referee_id` IS NULL -------------------------------------------------------------------------------- /Sql/0595.big-countries 大的国家/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/big-countries 2 | 3 | SELECT `name`, `population`, `area` 4 | FROM `world` 5 | WHERE `area` > 3000000 6 | OR `population` > 25000000 -------------------------------------------------------------------------------- /Sql/1148.article-views-i 浏览过自己文章的作者/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/article-views-i 2 | 3 | SELECT DISTINCT `author_id` `id` 4 | FROM `views` 5 | WHERE `viewer_id` = `author_id` 6 | ORDER BY `author_id` -------------------------------------------------------------------------------- /Math/0258.add-digits 各位相加/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/add-digits 4 | 5 | // ❓ 各位相加 6 | // ⚠️ 数根 7 | 8 | func addDigits(num int) int { 9 | return (num-1)%9 + 1 10 | } 11 | -------------------------------------------------------------------------------- /Sql/0511.game-play-analysis-i 首次登陆的时间/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/game-play-analysis-i 2 | 3 | SELECT `player_id`, 4 | MIN(`event_date`) `first_login` 5 | FROM `activity` 6 | GROUP BY `player_id` -------------------------------------------------------------------------------- /Sql/0610.triangle-judgement 判断三角形/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/triangle-judgement 2 | 3 | SELECT *, IF(`x` + `y` > `z` AND `x` + `z` > `y` AND `y` + `z` > `x`, "yes", "no") `triangle` 4 | FROM `triangle` -------------------------------------------------------------------------------- /Sql/1069.product-sales-analysis-ii 产品的销售总额/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/product-sales-analysis-ii 2 | 3 | SELECT `product_id`, SUM(`quantity`) `total_quantity` 4 | FROM `sales` 5 | GROUP BY `product_id` -------------------------------------------------------------------------------- /Sql/0596.classes-more-than-5-students 超过5名学生的课/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/classes-more-than-5-students 2 | 3 | SELECT `class` 4 | FROM `courses` 5 | GROUP BY `class` 6 | HAVING COUNT(DISTINCT `student`) >= 5 -------------------------------------------------------------------------------- /Sql/1517.find-users-with-valid-e-mails 邮箱正则/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-users-with-valid-e-mails 2 | 3 | SELECT * 4 | FROM `users` 5 | WHERE `mail` REGEXP '^[a-zA-Z][a-zA-Z0-9\_\.\-]*@leetcode\.com$' -------------------------------------------------------------------------------- /Sql/1757.recyclable-and-low-fat-products 可回收且低脂的产品/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/recyclable-and-low-fat-products 2 | 3 | SELECT `product_id` 4 | FROM `products` 5 | WHERE `low_fats` = 'Y' 6 | AND `recyclable` = 'Y' -------------------------------------------------------------------------------- /Sql/1350.students-with-invalid-departments 不存在院校的学生/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/students-with-invalid-departments 2 | 3 | SELECT `id`, `name` 4 | FROM `students` 5 | WHERE `department_id` NOT IN (SELECT `id` FROM `departments`) -------------------------------------------------------------------------------- /Sql/1667.fix-names-in-a-table 修复名字/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/fix-names-in-a-table 2 | 3 | SELECT `user_id`, 4 | CONCAT(UPPER(LEFT(`name`, 1)), LOWER(SUBSTR(`name`, 2))) `name` 5 | FROM `users` 6 | ORDER BY `user_id` -------------------------------------------------------------------------------- /Sql/1729.find-followers-count 关注数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-followers-count 2 | 3 | SELECT `user_id`, COUNT(`follower_id`) `followers_count` 4 | FROM `followers` 5 | GROUP BY `user_id` 6 | ORDER BY `user_id` 7 | 8 | -------------------------------------------------------------------------------- /Stub/class.stub: -------------------------------------------------------------------------------- 1 | 2 | 3 | ## @DummyClass 4 | | Title | cn | Difficulty | Solution | Algorithm 5 | | --------------------- | --------------------------------- | ----------- |--------- | --------- -------------------------------------------------------------------------------- /Sql/1393.capital-gainloss 资本损益/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/capital-gainloss 2 | 3 | SELECT `stock_name`, 4 | SUM(IF(`operation` = 'Buy', -`price`, `price`)) `capital_gain_loss` 5 | FROM `stocks` 6 | GROUP BY `stock_name`; -------------------------------------------------------------------------------- /Sql/0175.combine-two-tables 给所有人加上地址/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/combine-two-tables 2 | 3 | SELECT `firstname`, `lastname`, `city`, `state` 4 | FROM `person` 5 | LEFT JOIN `address` ON `person`.`personid` = `address`.`personid` -------------------------------------------------------------------------------- /Sql/0620.not-boring-movies 有趣的电影/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/not-boring-movies 2 | 3 | SELECT `id`, `movie`, `description`, `rating` 4 | FROM `cinema` 5 | WHERE `description` != 'boring' 6 | AND `id` % 2 = 1 7 | ORDER BY `rating` DESC -------------------------------------------------------------------------------- /Sql/1068.product-sales-analysis-i 产品的年份和价格/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/product-sales-analysis-i 2 | 3 | SELECT `product_name`, `year`, `price` 4 | FROM `sales` 5 | JOIN `product` ON `sales`.`product_id` = `product`.`product_id` -------------------------------------------------------------------------------- /Sql/1445.apples-oranges 销量差/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/apples-oranges 2 | 3 | SELECT `sale_date`, 4 | SUM(IF(`fruit` = `apples`, `sold_num`, -`sold_num`)) `diff` 5 | FROM `sales` 6 | GROUP BY `sale_date` 7 | ORDER BY `sale_date` -------------------------------------------------------------------------------- /Math/0007.reverse-integer/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func reverse(x int) int { 4 | var y int 5 | for x != 0 { 6 | y = y*10 + x%10 7 | if y < -1<<31 || 1<<31-1 < y { 8 | return 0 9 | } 10 | x /= 10 11 | } 12 | return y 13 | } 14 | -------------------------------------------------------------------------------- /Sql/1149.article-views-ii 一天浏览过两篇文章的人/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/article-views-ii 2 | 3 | SELECT DISTINCT `viewer_id` `id` 4 | FROM `views` 5 | GROUP BY `viewer_id`, `view_date` 6 | HAVING 1 < COUNT(DISTINCT `article_id`) 7 | ORDER BY `id` -------------------------------------------------------------------------------- /Sql/1421.npv-queries 连表/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/npv-queries 2 | 3 | SELECT `q`.`id`, 4 | `q`.`year`, 5 | IFNULL(`npv`, 0) `npv` 6 | FROM `queries` `q` 7 | LEFT JOIN 8 | `npv` `n` USING (`id`, `year`) 9 | -------------------------------------------------------------------------------- /Sql/0196.delete-duplicate-emails 删除重复邮箱/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/delete-duplicate-emails 2 | 3 | DELETE `p2` 4 | FROM `person` `p1` 5 | JOIN `person` `p2` 6 | WHERE `p1`.`email` = `p2`.`email` 7 | AND `p1`.`id` < `p2`.`id` -------------------------------------------------------------------------------- /Sql/0577.employee-bonus 员工奖金/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/employee-bonus 2 | 3 | SELECT `name`, `bonus` 4 | FROM `employee` 5 | LEFT JOIN `bonus` ON `employee`.`empid` = `bonus`.`empid` 6 | WHERE `bonus`.`bonus` < 1000 7 | OR `bonus` IS NULL -------------------------------------------------------------------------------- /Sql/0613.shortest-distance-in-a-line 直线上的最近距离/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/shortest-distance-in-a-line 2 | 3 | SELECT MIN(ABS(`p1`.`x` - `p2`.`x`)) `shortest` 4 | FROM `point` `p1` 5 | JOIN `point` `p2` ON `p1`.`x` != `p2`.`x`; 6 | -------------------------------------------------------------------------------- /Bit/xor/0136.single-number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/single-number 4 | 5 | func singleNumber(nums []int) int { 6 | var numUnique int 7 | for _, num := range nums { 8 | numUnique ^= num 9 | } 10 | return numUnique 11 | } 12 | -------------------------------------------------------------------------------- /Sql/0586.customer-placing-the-largest-number-of-orders 订单最多的客户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customer-placing-the-largest-number-of-orders 2 | 3 | SELECT `customer_number` 4 | FROM `orders` 5 | GROUP BY `customer_number` 6 | ORDER BY COUNT(*) DESC 7 | LIMIT 1 -------------------------------------------------------------------------------- /Sql/1527.patients-with-a-condition 患病患者/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/patients-with-a-condition 2 | 3 | # Write your MySQL query statement below 4 | 5 | SELECT * 6 | FROM `patients` 7 | WHERE `conditions` LIKE 'DIAB1%' 8 | OR `conditions` LIKE '% DIAB1%' -------------------------------------------------------------------------------- /Sql/1741.find-total-time-spent-by-each-employee 员工花费时间/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-total-time-spent-by-each-employee 2 | 3 | SELECT `event_day` `day`, `emp_id`, SUM(`out_time` - `in_time`) `total_time` 4 | FROM `employees` 5 | GROUP BY `day`, `emp_id` -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0191.number-of-1-bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/number-of-1-bits/ 4 | 5 | func hammingWeight(num uint32) int { 6 | cnt := 0 7 | for 0 < num { 8 | num &= num - 1 9 | cnt++ 10 | } 11 | return cnt 12 | } 13 | -------------------------------------------------------------------------------- /Sql/1308.running-total-for-different-genders 男女的累积分数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/running-total-for-different-genders 2 | 3 | SELECT `gender`, 4 | `day`, 5 | SUM(`score_points`) OVER (PARTITION BY `gender` ORDER BY `day`) `total` 6 | FROM `scores`; -------------------------------------------------------------------------------- /Sql/0176.second-highest-salary 找第二名 Null 也返回/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/second-highest-salary 2 | 3 | SELECT ( 4 | SELECT DISTINCT `salary` 5 | FROM `employee` 6 | ORDER BY `salary` DESC 7 | LIMIT 1,1) `secondhighestsalary` -------------------------------------------------------------------------------- /Sql/0619.biggest-single-number 最出现一次的最大数字/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/biggest-single-number 2 | 3 | SELECT (SELECT `num` 4 | FROM `my_numbers` 5 | GROUP BY `num` 6 | HAVING COUNT(*) = 1 7 | ORDER BY `num` DESC 8 | LIMIT 1) `num` -------------------------------------------------------------------------------- /Sql/1821.find-customers-with-positive-revenue-this-year 正收入/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-customers-with-positive-revenue-this-year 2 | 3 | SELECT `customer_id` 4 | FROM `customers` 5 | WHERE `year` = 2021 6 | GROUP BY `customer_id` 7 | HAVING SUM(`revenue`) > 0 -------------------------------------------------------------------------------- /DP/single (x)/pre/1480.running-sum-of-1d-array 数组前缀和/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/running-sum-of-1d-array 4 | 5 | func runningSum(nums []int) []int { 6 | for i := range nums[1:] { 7 | nums[i+1] += nums[i] 8 | } 9 | return nums 10 | } 11 | -------------------------------------------------------------------------------- /Math/1281.subtract-the-product-and-sum-of-digits-of-an-integer/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func subtractProductAndSum(n int) int { 4 | x, y := 1, 0 5 | for 0 < n { 6 | carry := n % 10 7 | n /= 10 8 | x *= carry 9 | y += carry 10 | } 11 | return x - y 12 | } 13 | -------------------------------------------------------------------------------- /Sql/1045.customers-who-bought-all-products 买下所有产品的客户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customers-who-bought-all-products 2 | 3 | SELECT `customer_id` 4 | FROM `customer` 5 | GROUP BY `customer_id` 6 | HAVING COUNT(DISTINCT `product_key`) = (SELECT COUNT(*) `cc` FROM `product`) -------------------------------------------------------------------------------- /Bit/xor/0693.binary-number-with-alternating-bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/binary-number-with-alternating-bits 4 | 5 | func hasAlternatingBits(n int) bool { 6 | // 全部变1 7 | n = n ^ (n >> 1) 8 | // 全部进位成功 只剩1个1 9 | return n&(n+1) == 0 10 | } 11 | -------------------------------------------------------------------------------- /Sql/1378.replace-employee-id-with-the-unique-identifier 使用uuid替换id/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/replace-employee-id-with-the-unique-identifier 2 | 3 | SELECT `unique_id`, `name` 4 | FROM `employeeuni` 5 | RIGHT JOIN `employees` ON `employees`.`id` = `employeeuni`.`id` -------------------------------------------------------------------------------- /Math/Cnt # LCP 11. 期望个数统计/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/qi-wang-ge-shu-tong-ji/ 4 | 5 | func expectNumber(scores []int) int { 6 | m := map[int]struct{}{} 7 | for i := range scores { 8 | m[scores[i]] = struct{}{} 9 | } 10 | return len(m) 11 | } 12 | -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0201.bitwise-and-of-numbers-range.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/bitwise-and-of-numbers-range 4 | 5 | // 范围与 6 | func rangeBitwiseAnd(lo int, hi int) int { 7 | for lo < hi { // TODO 按位与 快速缩进 8 | hi &= hi - 1 9 | } 10 | return hi 11 | } 12 | -------------------------------------------------------------------------------- /Bit/perm/0326.power-of-three.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func isPowerOfThree(n int) bool { 4 | for 1 < n && n%3 == 0 { 5 | n /= 3 6 | } 7 | return n == 1 8 | } 9 | 10 | func isPowerOfThree(n int) bool { 11 | return 0 < n && 0b1000101010001101011001111011011%n == 0 // TODO 约数 12 | } 13 | -------------------------------------------------------------------------------- /Sql/1050.actors-and-directors-who-cooperated-at-least-three-times 合作至少三次的演员和导员/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/actors-and-directors-who-cooperated-at-least-three-times 2 | 3 | SELECT `actor_id`, `director_id` 4 | FROM `actordirector` 5 | GROUP BY `actor_id`, `director_id` 6 | HAVING COUNT(*) >= 3 -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0461.hamming-distance.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/hamming-distance 4 | 5 | func hammingDistance(x int, y int) int { 6 | num := x ^ y // TODO 两数 位差 7 | var cnt int 8 | for 0 < num { 9 | num &= num - 1 10 | cnt++ 11 | } 12 | return cnt 13 | } 14 | -------------------------------------------------------------------------------- /Enum/1389.create-target-array-in-the-given-order 按既定顺序创建目标数组/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func createTargetArray(nums []int, index []int) []int { 4 | var res = make([]int, len(nums)) 5 | for k, i := range index { 6 | copy(res[i+1:], res[i:]) 7 | res[i] = nums[k] 8 | } 9 | return res 10 | } 11 | -------------------------------------------------------------------------------- /Sql/1113.reported-posts 不同的报告记录/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/reported-posts 2 | 3 | SELECT `extra` "report_reason", COUNT(DISTINCT `post_id`) "report_count" 4 | FROM `actions` 5 | WHERE `action_date` = '2019-07-04' 6 | AND `action` = 'report' 7 | AND `extra` IS NOT NULL 8 | GROUP BY `extra` -------------------------------------------------------------------------------- /Sql/1173.immediate-food-delivery-i 当天配送率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/immediate-food-delivery-i 2 | 3 | SELECT ROUND( 4 | SUM(IF(`order_date` = `customer_pref_delivery_date`, 1, 0)) / 5 | COUNT(*) * 100, 2) `immediate_percentage` 6 | FROM `delivery` -------------------------------------------------------------------------------- /Enum/0121.best-time-to-buy-and-sell-stock 买卖股票的最佳时机/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxProfit(prices []int) int { 4 | min, max := 1<<63-1, 0 5 | for _, v := range prices { 6 | if v < min { 7 | min = v 8 | } 9 | if max < v-min { 10 | max = v - min 11 | } 12 | } 13 | return max 14 | } 15 | -------------------------------------------------------------------------------- /Math/0066.plus-one 加一/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func plusOne(digits []int) []int { 4 | var i = len(digits) - 1 5 | for 0 <= i && digits[i] == 9 { 6 | digits[i] = 0 7 | i-- 8 | } 9 | if i == -1 { 10 | return append([]int{1}, digits...) 11 | } 12 | digits[i] += 1 13 | return digits 14 | } 15 | -------------------------------------------------------------------------------- /Sql/0578.get-highest-answer-rate-question 回答率最高的问题/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/get-highest-answer-rate-question 2 | 3 | SELECT `question_id` `survey_log` 4 | FROM `survey_log` 5 | GROUP BY `question_id` 6 | ORDER BY SUM(IF(`action` = 'answer', 1, 0)) / SUM(IF(`action` = 'show', 1, 0)) DESC 7 | LIMIT 1 -------------------------------------------------------------------------------- /Sql/1407.top-travellers 旅行距离排名/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/top-travellers 2 | 3 | SELECT `name`, IFNULL(SUM(`distance`), 0) `travelled_distance` 4 | FROM `users` 5 | LEFT JOIN `rides` ON `users`.`id` = `rides`.`user_id` 6 | GROUP BY `name` 7 | ORDER BY `travelled_distance` DESC, `name`; 8 | -------------------------------------------------------------------------------- /Sql/1789.primary-department-for-each-employee 员工的主要部门/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/primary-department-for-each-employee 2 | 3 | SELECT DISTINCT `employee_id`, 4 | FIRST_VALUE(`department_id`) OVER (PARTITION BY `employee_id` ORDER BY `primary_flag`) `department_id` 5 | FROM `employee` -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0266.palindrome-permutation.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/palindrome-permutation 4 | 5 | func canPermutePalindrome(s string) bool { 6 | var bit int 7 | for i := range s { 8 | bit ^= 1 << (s[i] - 'a') // TODO 计算奇偶 9 | } 10 | return bit&(bit-1) == 0 11 | } 12 | -------------------------------------------------------------------------------- /Offer/面试题 01.01. 判定字符是否唯一/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/is-unique-lcci/ 4 | 5 | func isUnique(astr string) bool { 6 | m := map[byte]int{} 7 | for i := range astr { 8 | m[astr[i]]++ 9 | if 1 < m[astr[i]] { 10 | return false 11 | } 12 | } 13 | return true 14 | } 15 | -------------------------------------------------------------------------------- /Sql/1126.active-businesses 活跃的业务/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/active-businesses 2 | 3 | SELECT `business_id` 4 | FROM (SELECT *, 5 | AVG(`occurences`) OVER (PARTITION BY `event_type`) `a` 6 | FROM `events`) `t` 7 | WHERE `occurences` > `a` 8 | GROUP BY `business_id` 9 | HAVING COUNT(*) > 1 -------------------------------------------------------------------------------- /Sql/1661.average-time-of-process-per-machine 平均运行时间/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/average-time-of-process-per-machine 2 | 3 | SELECT `machine_id`, 4 | ROUND(SUM(IF(`activity_type` = 'end', `timestamp`, -`timestamp`)) / COUNT(*) * 2, 3) `processing_time` 5 | FROM `activity` 6 | GROUP BY `machine_id` -------------------------------------------------------------------------------- /BinarySearch/basics/0278.first-bad-version.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/first-bad-version 6 | 7 | func firstBadVersion(hi int) int { 8 | return sort.Search(hi+1, isBadVersion) // TODO 9 | } 10 | 11 | func isBadVersion(n int) bool { 12 | return n == 1 13 | } 14 | -------------------------------------------------------------------------------- /Sql/0607.sales-person 销售员/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/sales-person 2 | 3 | SELECT DISTINCT `name` 4 | FROM `salesperson` 5 | WHERE `sales_id` NOT IN (SELECT `sales_id` 6 | FROM `orders` 7 | WHERE `com_id` = (SELECT `com_id` FROM `company` WHERE `name` = 'RED')) -------------------------------------------------------------------------------- /Sql/1076.project-employees-ii 员工最多的项目 销售额最高的销售者/1.sql: -------------------------------------------------------------------------------- 1 | # Title: Project Employees II 2 | # Link: https://leetcode.cn/problems/project-employees-ii 3 | 4 | WITH `tmp` AS (SELECT `project_id`, COUNT(*) `c` FROM `project` GROUP BY `project_id`) 5 | SELECT `project_id` 6 | FROM `tmp` 7 | WHERE `c` = (SELECT MAX(`c`) FROM `tmp`); -------------------------------------------------------------------------------- /Sql/1112.highest-grade-for-each-student 最高分数的学科/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/highest-grade-for-each-student 2 | 3 | SELECT `student_id`, `course_id`, `grade` 4 | FROM (SELECT *, ROW_NUMBER() OVER (PARTITION BY `student_id` ORDER BY `grade` DESC,`course_id`) `r` 5 | FROM `enrollments`) `t` 6 | WHERE `r` = 1 -------------------------------------------------------------------------------- /Enum/0171.excel-sheet-column-number Excel 表列序号/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/excel-sheet-column-number 4 | 5 | func titleToNumber(columnTitle string) int { 6 | var res int 7 | for i := range columnTitle { 8 | res = res*26 + int(columnTitle[i]-'@') 9 | } 10 | return res 11 | } 12 | -------------------------------------------------------------------------------- /Sql/1693.daily-leads-and-partners 统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/daily-leads-and-partners 2 | 3 | SELECT `date_id`, 4 | `make_name`, 5 | COUNT(DISTINCT `lead_id`) `unique_leads`, 6 | COUNT(DISTINCT `partner_id`) `unique_partners` 7 | FROM `dailysales` 8 | GROUP BY `date_id`, `make_name` 9 | -------------------------------------------------------------------------------- /Enum/1295.find-numbers-with-even-number-of-digits 统计位数为偶数的数字/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func findNumbers(nums []int) int { 4 | var res int 5 | for _, v := range nums { 6 | cur := 0 7 | for 0 < v { 8 | v /= 10 9 | cur++ 10 | } 11 | if cur%2 == 0 { 12 | res++ 13 | } 14 | } 15 | return res 16 | } 17 | -------------------------------------------------------------------------------- /Math/1313.decompress-run-length-encoded-list/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func decompressRLElist(nums []int) []int { 4 | var res []int 5 | l := len(nums) 6 | i := 0 7 | for i < l { 8 | for 0 < nums[i] { 9 | nums[i] -= 1 10 | res = append(res, nums[i+1]) 11 | } 12 | i += 2 13 | } 14 | return res 15 | } 16 | -------------------------------------------------------------------------------- /Sql/0197.rising-temperature 温度相比昨天是上升的/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/rising-temperature 2 | 3 | SELECT `w2`.`id` `id` 4 | FROM `weather` `w2` 5 | JOIN `weather` `w1` 6 | ON DATEDIFF(`w2`.`recorddate`, `w1`.`recorddate`) = 1 7 | AND `w1`.`temperature` < `w2`.`temperature` -------------------------------------------------------------------------------- /Sql/1322.ads-performance 广告效果统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/ads-performance 2 | 3 | SELECT `ad_id`, 4 | ROUND(IFNULL(SUM(`action` = 'Clicked') / 5 | (SUM(`action` = 'Clicked') + SUM(`action` = 'Viewed')) * 100, 0), 2) `ctr` 6 | FROM `ads` 7 | GROUP BY `ad_id` 8 | ORDER BY `ctr` DESC, `ad_id` -------------------------------------------------------------------------------- /Sql/1485.group-sold-products-by-the-date group聚合/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/group-sold-products-by-the-date 2 | 3 | SELECT `sell_date`, 4 | COUNT(DISTINCT `product`) `num_sold`, 5 | GROUP_CONCAT(DISTINCT `product`) `products` 6 | FROM `activities` 7 | GROUP BY `sell_date` 8 | ORDER BY `sell_date` -------------------------------------------------------------------------------- /Enum/0058.length-of-last-word 最后一个单词的长度/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/length-of-last-word 4 | 5 | func lengthOfLastWord(s string) { 6 | var res int 7 | i := len(s) - 1 8 | for s[i] == ' ' { 9 | i-- 10 | } 11 | for 0 <= i && s[i] != ' ' { 12 | res++ 13 | i-- 14 | } 15 | return 16 | } 17 | -------------------------------------------------------------------------------- /Sql/0181.employees-earning-more-than-their-managers 超过经理收入的员工/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/employees-earning-more-than-their-managers 2 | 3 | SELECT `e1`.`name` `employee` 4 | FROM `employee` AS `e1` 5 | LEFT JOIN `employee` AS `e2` ON `e1`.`managerid` = `e2`.`id` 6 | WHERE `e2`.`salary` < `e1`.`salary` -------------------------------------------------------------------------------- /Sql/0626.exchange-seats 换座位/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/exchange-seats 2 | 3 | SELECT ROW_NUMBER() OVER (ORDER BY (`id` + 1 - 2 * POWER(0, `id` % 2))) `id`, 4 | `student` 5 | FROM `seat` 6 | 7 | 8 | 9 | SELECT IF(`id` % 2 = 0, `id` - 1, `id` + 1) `id` 10 | `student` 11 | FROM `order` BY id ASC; 12 | -------------------------------------------------------------------------------- /Array/1470.shuffle-the-arraymain.go: -------------------------------------------------------------------------------- 1 | package Array 2 | 3 | // https://leetcode.cn/problems/shuffle-the-array 4 | 5 | func shuffle(nums []int, n int) []int { 6 | var res = make([]int, 0, n*2) 7 | for idx, num := range nums[:n] { 8 | res = append(res, num) 9 | res = append(res, nums[n+idx]) 10 | 11 | } 12 | return res 13 | } 14 | -------------------------------------------------------------------------------- /Enum/0122.best-time-to-buy-and-sell-stock-ii 买卖股票的最佳时机 II/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func maxProfit(prices []int) int { 4 | cur := prices[0] 5 | res := 0 6 | l := len(prices) 7 | for i := 1; i < l; i++ { 8 | if cur < prices[i] { 9 | res += prices[i] - cur 10 | } 11 | cur = prices[i] 12 | } 13 | return res 14 | } 15 | -------------------------------------------------------------------------------- /Sql/1587.bank-account-summary-ii 余大于10000的用户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/bank-account-summary-ii 2 | 3 | 4 | SELECT `name`, 5 | SUM(`amount`) `balance` 6 | FROM `users`, 7 | `transactions` 8 | WHERE `users`.`account` = `transactions`.`account` 9 | GROUP BY `name` 10 | HAVING SUM(`amount`) > 10000; 11 | 12 | 13 | -------------------------------------------------------------------------------- /Sql/1211.queries-quality-and-percentage/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/queries-quality-and-percentage 2 | 3 | SELECT `query_name`, 4 | ROUND(AVG(`rating` / `position`), 2) `quality`, 5 | ROUND(SUM(IF(`rating` < 3, 1, 0)) * 100 / COUNT(*), 2) `poor_query_percentage` 6 | FROM `queries` 7 | GROUP BY `query_name` -------------------------------------------------------------------------------- /Bit/xor/0389.find-the-difference.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-the-difference 4 | 5 | // ❓ 找出 x 6 | // ⚠️ s = t + 随机byte(x) 7 | 8 | func findTheDifferenceXor(s string, t string) byte { 9 | // 异或抵消 10 | var sum byte 11 | for i := range s { 12 | sum ^= s[i] ^ t[i] 13 | } 14 | return sum ^ t[len(t)-1] 15 | } 16 | -------------------------------------------------------------------------------- /Sql/0580.count-student-number-in-departments 各专业学生人数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/count-student-number-in-departments 2 | 3 | SELECT `dept_name`, COUNT(`student_id`) `student_number` 4 | FROM `department` `d` 5 | LEFT JOIN `student` `s` ON `d`.`dept_id` = `s`.`dept_id` 6 | GROUP BY `dept_name` 7 | ORDER BY `student_number` DESC -------------------------------------------------------------------------------- /Sql/0585.investments-in-2016 2016年的投资/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/investments-in-2016 2 | 3 | SELECT ROUND(SUM(`tiv_2016`), 2) `tiv_2016` 4 | FROM (SELECT *, 5 | COUNT(*) OVER ( PARTITION BY `tiv_2015`) `y`, 6 | COUNT(*) OVER ( PARTITION BY `lat`,`lon`) `p` 7 | FROM `insurance`) `t` 8 | WHERE `y` > 1 && `p` = 1 -------------------------------------------------------------------------------- /Sql/0608.tree-node 树节点/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/tree-node 2 | 3 | SELECT DISTINCT `t1`.`id`, 4 | IF(`t1`.`p_id` IS NULL, 'Root', 5 | IF(`t2`.`id` IS NOT NULL, 'Inner', 'Leaf')) `type` 6 | FROM `tree` AS `t1` 7 | LEFT JOIN `tree` AS `t2` 8 | ON `t1`.`id` = `t2`.`p_id` -------------------------------------------------------------------------------- /LinkedList/0237.delete-node-in-a-linked-list 删除节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/delete-node-in-a-linked-list 9 | 10 | func deleteNode(node *ListNode) { 11 | //*node = *node.Next 12 | node.Val = node.Next.Val 13 | node.Next = node.Next.Next 14 | } 15 | -------------------------------------------------------------------------------- /Math/0263.ugly-number 丑数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/ugly-number 4 | 5 | var factors = []int{2, 3, 5} 6 | 7 | func isUgly(n int) bool { 8 | if n <= 0 { 9 | return false 10 | } 11 | for i := range factors { 12 | for n%factors[i] == 0 { 13 | n /= factors[i] 14 | } 15 | } 16 | 17 | return n == 1 18 | } 19 | -------------------------------------------------------------------------------- /Math/0268.missing-number 丢失的数字/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/missing-number 4 | 5 | // ❓ 丢失的数字 6 | 7 | func missingNumber(nums []int) int { 8 | numsL := len(nums) 9 | numsL = numsL * (numsL + 1) / 2 // 等差数列 10 | var sum int 11 | for _, num := range nums { 12 | sum += num 13 | } 14 | return numsL - sum 15 | } 16 | -------------------------------------------------------------------------------- /Math/✅ 2169.count-operations-to-obtain-zero 得到 0 的操作数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/count-operations-to-obtain-zero 4 | 5 | // ❓ 得到 0 的操作数 6 | 7 | func countOperations(num1, num2 int) int { 8 | var cnt int 9 | for 0 < num1 { 10 | cnt += num2 / num1 11 | num1, num2 = num2%num1, num1 12 | } 13 | return cnt 14 | } 15 | -------------------------------------------------------------------------------- /Sql/0574.winning-candidate 当选者/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/winning-candidate 2 | 3 | SELECT `name` 4 | FROM ( 5 | SELECT `candidateid` 6 | FROM `vote` 7 | GROUP BY `candidateid` 8 | ORDER BY COUNT(`candidateid`) DESC 9 | LIMIT 1) `t` 10 | JOIN `candidate` ON `candidate`.`id` = `candidateid` -------------------------------------------------------------------------------- /TwoPointer/0027.remove-element 移除元素/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/remove-element/ 4 | 5 | func removeElement(nums []int, val int) int { 6 | var l = 0 7 | var r = len(nums) - 1 8 | for l <= r { 9 | if nums[l] != val { 10 | l++ 11 | } else { 12 | nums[l] = nums[r] 13 | r-- 14 | } 15 | } 16 | return l 17 | } 18 | -------------------------------------------------------------------------------- /Bit/shift/0201.bitwise-and-of-numbers-range.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/bitwise-and-of-numbers-range 4 | 5 | func rangeBitwiseAnd(lo int, hi int) int { 6 | shift := 0 7 | for lo < hi { 8 | // TODO 共同前缀 9 | // 11101010 10 | // 11101111 11 | lo, hi = lo>>1, hi>>1 12 | shift++ 13 | } 14 | return lo << shift // TODO 15 | } 16 | -------------------------------------------------------------------------------- /Offer/面试题 01.04. 回文排列/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/palindrome-permutation-lcci/ 4 | 5 | func canPermutePalindrome(s string) bool { 6 | m := map[byte]int{} 7 | for i := range s { 8 | m[s[i]]++ 9 | } 10 | var cnt int 11 | for b := range m { 12 | if m[b]%2 == 1 { 13 | cnt++ 14 | } 15 | } 16 | return cnt <= 1 17 | } 18 | -------------------------------------------------------------------------------- /BinarySearch/readme.md: -------------------------------------------------------------------------------- 1 | # 有序 2 | 3 | # 左右边界 4 | 5 | # lo < hi 6 | 7 | - lo == hi 8 | 9 | # lo <= hi 10 | 11 | - lo + 1 == hi 12 | 13 | # check 14 | 15 | - 有序验证 16 | 17 | # left ~ right 18 | 19 | - 上下区间搜索 20 | 21 | # origin 22 | 23 | - 二维 优化成 一维 24 | 25 | # rotate 26 | 27 | - 最小值位置 28 | - `重复性 3 3 1 3` 29 | - target 搜索 30 | - 区间判断 31 | 32 | 33 | -------------------------------------------------------------------------------- /Bit/xor/0268.missing-number.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/missing-number 4 | 5 | // ❓ 丢失的数字 6 | // ⚠️ 0 ~ numsL 丢失了一个数字 7 | func missingNumber(nums []int) int { 8 | numsL := len(nums) 9 | var num int 10 | 11 | for idx := 0; idx < numsL; idx++ { 12 | num ^= idx 13 | num ^= nums[idx] // case: 0 14 | } 15 | return num ^ numsL 16 | } 17 | -------------------------------------------------------------------------------- /Sql/1809.ad-free-sessions 没有展示广告的会话/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/ad-free-sessions 2 | 3 | SELECT `session_id` 4 | FROM `playback` 5 | WHERE `session_id` NOT IN ( 6 | SELECT DISTINCT `session_id` 7 | FROM `playback` `p` 8 | JOIN `ads` `a` ON `p`.`customer_id` = `a`.`customer_id` 9 | WHERE `timestamp` BETWEEN `start_time` AND `end_time`) -------------------------------------------------------------------------------- /Hash/where/0217.contains-duplicate 出现重复.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/contains-duplicate 4 | 5 | // ❓ 出现重复 6 | 7 | func containsDuplicate(nums []int) bool { 8 | var numMpCnt = map[int]int{} 9 | for _, num := range nums { 10 | if 0 < numMpCnt[num] { 11 | return true 12 | } 13 | numMpCnt[num] += 1 14 | } 15 | return false 16 | } 17 | -------------------------------------------------------------------------------- /Sql/1070.product-sales-analysis-iii 第一年的价格/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/product-sales-analysis-iii 2 | 3 | 4 | SELECT `product_id`, `year` `first_year`, `quantity`, `price` 5 | FROM `sales` 6 | WHERE (`product_id`, `year`) IN (SELECT `product_id`, MIN(`year`) 7 | FROM `sales` 8 | GROUP BY `product_id`); -------------------------------------------------------------------------------- /Sql/1075.project-employees-i 项目的平均年限/1.sql: -------------------------------------------------------------------------------- 1 | # Title: Project Employees I 2 | # Link: https://leetcode.cn/problems/project-employees-i 3 | 4 | SELECT `project_id`, ROUND(AVG(`experience_years`), 2) `average_years` 5 | FROM `project` AS `p` 6 | INNER JOIN `employee` AS `e` 7 | ON `p`.`employee_id` = `e`.`employee_id` 8 | GROUP BY `project_id`; -------------------------------------------------------------------------------- /Sql/1715.count-apples-and-oranges 统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/count-apples-and-oranges 2 | 3 | 4 | SELECT SUM(`b`.`apple_count` + IFNULL(`c`.`apple_count`, 0)) `apple_count`, 5 | SUM(`b`.`orange_count` + IFNULL(`c`.`orange_count`, 0)) `orange_count` 6 | FROM `boxes` `b` 7 | LEFT JOIN `chests` `c` ON `b`.`chest_id` = `c`.`chest_id` -------------------------------------------------------------------------------- /Sql/1777.products-price-for-each-store 每家商店价格/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/products-price-for-each-store 2 | 3 | SELECT `product_id`, 4 | SUM(IF(`store` = 'store1', `price`, NULL)) `store1`, 5 | SUM(IF(`store` = 'store2', `price`, NULL)) `store2`, 6 | SUM(IF(`store` = 'store3', `price`, NULL)) `store3` 7 | FROM `products` 8 | GROUP BY `product_id`; -------------------------------------------------------------------------------- /Sql/1082.sales-analysis-i 销售额最高的销售者/1.sql: -------------------------------------------------------------------------------- 1 | # Title: Sales Analysis I 2 | # Link: https://leetcode.cn/problems/sales-analysis-i 3 | 4 | SELECT `seller_id` 5 | FROM ( 6 | SELECT `seller_id`, DENSE_RANK() OVER (ORDER BY `total` DESC) `n` 7 | FROM ( 8 | SELECT `seller_id`, SUM(`price`) `total` FROM `sales` GROUP BY `seller_id`) `t1`) `t2` 9 | WHERE `n` = 1 -------------------------------------------------------------------------------- /Sql/1565.unique-orders-and-customers-per-month 月订单数和顾客数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/unique-orders-and-customers-per-month 2 | 3 | SELECT LEFT(`o`.`order_date`, 7) `month`, 4 | COUNT(`order_id`) `order_count`, 5 | COUNT(DISTINCT `customer_id`) `customer_count` 6 | FROM `orders` `o` 7 | WHERE `o`.`invoice` > 20 8 | GROUP BY LEFT(`o`.`order_date`, 7); -------------------------------------------------------------------------------- /Bit/base/0168.excel-sheet-column-titleExcel.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/excel-sheet-column-title 4 | 5 | func convertToTitle(num int) string { 6 | var lo = 7 7 | var buf = make([]byte, lo) // TODO 节省反转 8 | for 0 < num { 9 | num-- // TODO 修正偏移 10 | lo-- 11 | buf[lo] = byte(num%26 + 'A') 12 | num /= 26 13 | } 14 | return string(buf[lo:]) 15 | } 16 | -------------------------------------------------------------------------------- /Sql/0178.rank-scores 稠密排行/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/rank-scores 2 | 3 | SELECT `score`, 4 | @`rank` := @`rank` + (@`pre` != (@`pre` := `score`)) `rank` 5 | FROM `scores`, 6 | (SELECT @`pre` := -1, @`rank` := 0) `tmp` 7 | ORDER BY `score` DESC; 8 | 9 | # 10 | 11 | SELECT `score`, 12 | DENSE_RANK() OVER (ORDER BY `score` DESC) `rank` 13 | FROM `scores` -------------------------------------------------------------------------------- /Sql/1158.market-analysis-i 统计2019年订单总数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/market-analysis-i 2 | 3 | 4 | SELECT `u`.`user_id` `buyer_id`, 5 | `join_date`, 6 | COUNT(`order_id`) `orders_in_2019` 7 | FROM `users` `u` 8 | LEFT JOIN `orders` `o` ON `u`.`user_id` = `o`.`buyer_id` AND `order_date` BETWEEN '2019-01-01' AND '2019-12-31' 9 | GROUP BY `user_id` -------------------------------------------------------------------------------- /Sql/1633.percentage-of-users-attended-a-contest 注册率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/percentage-of-users-attended-a-contest 2 | 3 | 4 | SELECT `contest_id`, 5 | ROUND(COUNT(DISTINCT `r`.`user_id`) / COUNT(DISTINCT `u`.`user_id`) * 100, 2) `percentage` 6 | FROM `register` `r` 7 | JOIN `users` `u` 8 | GROUP BY `contest_id` 9 | ORDER BY `percentage` DESC, `contest_id` -------------------------------------------------------------------------------- /Templates/math/quick_pow.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func pow(x float64, n int) float64 { 4 | if x == 1.0 || n == 0 { 5 | return 1.0 6 | } 7 | var res = 1.0 8 | var y = n 9 | if n < 0 { 10 | y = -y 11 | } 12 | for 0 < y { 13 | if y&1 == 1 { 14 | res *= x 15 | } 16 | x *= x 17 | y >>= 1 18 | } 19 | if n < 0 { 20 | return 1.0 / res 21 | } 22 | return res 23 | } 24 | -------------------------------------------------------------------------------- /Enum/2177.find-three-consecutive-integers-that-sum-to-a-given-number 找到和为给定整数的三个连续整数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-three-consecutive-integers-that-sum-to-a-given-number 4 | 5 | // ❓ 找到和为给定整数的三个连续整数 6 | 7 | func sumOfThree(num int64) []int64 { 8 | if num%3 != 0 { 9 | return nil 10 | } 11 | num /= 3 12 | return []int64{num - 1, num, num + 1} 13 | } 14 | -------------------------------------------------------------------------------- /Sql/1327.list-the-products-ordered-in-a-period 指定日期总数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/list-the-products-ordered-in-a-period 2 | 3 | SELECT `product_name`, SUM(`unit`) `unit` 4 | FROM `products` `p` 5 | JOIN `orders` `o` 6 | ON `p`.`product_id` = `o`.`product_id` 7 | WHERE LEFT(`order_date`, 7) = '2020-02' 8 | GROUP BY `product_name` 9 | HAVING SUM(`unit`) >= 100; -------------------------------------------------------------------------------- /Sql/1355.activity-participants 去除第一和倒数第一/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/activity-participants 2 | 3 | 4 | SELECT `activity` 5 | FROM (SELECT `activity`, 6 | DENSE_RANK() OVER (ORDER BY COUNT(*)) `r1`, 7 | DENSE_RANK() OVER (ORDER BY COUNT(*) DESC) `r2` 8 | FROM `friends` 9 | GROUP BY `activity`) `t` 10 | WHERE `r1` != 1 11 | AND `r2` != 1 -------------------------------------------------------------------------------- /Sql/1495.friendly-movies-streamed-last-month 儿童适宜的电影/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/friendly-movies-streamed-last-month 2 | 3 | SELECT DISTINCT `title` 4 | FROM `tvprogram` `t` 5 | LEFT JOIN `content` `c` ON `t`.`content_id` = `c`.`content_id` 6 | WHERE LEFT(`t`.`program_date`, 7) = '2020-06' 7 | AND `c`.`kids_content` = 'Y' 8 | AND `c`.`content_type` = 'Movies'; 9 | -------------------------------------------------------------------------------- /Sql/1831.maximum-transaction-each-day 每天最大交易/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/maximum-transaction-each-day 2 | 3 | 4 | SELECT `transaction_id` 5 | FROM ( 6 | SELECT `transaction_id`, 7 | RANK() OVER (PARTITION BY LEFT(`day`, 10) ORDER BY `amount` DESC) `r` 8 | FROM `transactions` 9 | ORDER BY `transaction_id` 10 | ) `t` 11 | WHERE `r` = 1 -------------------------------------------------------------------------------- /Enum/1672.richest-customer-wealth 最富有客户的资产总量/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/richest-customer-wealth 4 | 5 | func maximumWealth(accounts [][]int) int { 6 | var max int 7 | for _, account := range accounts { 8 | var cur int 9 | for _, v := range account { 10 | cur += v 11 | } 12 | if max < cur { 13 | max = cur 14 | } 15 | } 16 | return max 17 | } 18 | -------------------------------------------------------------------------------- /Math/0453.minimum-moves-to-equal-array-elements 最小操作次数使数组元素相等/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/minimum-moves-to-equal-array-elements 4 | 5 | func minMoves(nums []int) int { 6 | var min = nums[0] 7 | var sum = nums[0] 8 | for _, num := range nums[1:] { 9 | if num < min { 10 | min = num 11 | } 12 | sum += num 13 | } 14 | return sum - min*len(nums) 15 | } 16 | -------------------------------------------------------------------------------- /Stack/1598.crawler-log-folder 文件夹操作日志搜集器/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/crawler-log-folder 4 | 5 | func minOperations(logs []string) int { 6 | res := 0 7 | for i := range logs { 8 | switch logs[i][:2] { 9 | case "..": // -1 10 | if 0 < res { 11 | res-- 12 | } 13 | case "./": // 忽略 14 | default: 15 | res++ 16 | } 17 | } 18 | return res 19 | } 20 | -------------------------------------------------------------------------------- /1619.mean-of-array-after-removing-some-elementsmain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/mean-of-array-after-removing-some-elements 6 | 7 | func trimMean(arr []int) float64 { 8 | sort.Ints(arr) 9 | arrL := len(arr) 10 | sum := 0 11 | for _, x := range arr[arrL/20 : 19*arrL/20] { 12 | sum += x 13 | } 14 | return float64(sum*10) / float64(arrL*9) 15 | } 16 | -------------------------------------------------------------------------------- /Bit/perm/0342.power-of-four.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/power-of-four 4 | 5 | // ❓ 4的幂 6 | 7 | func isPowerOfFour(n int) bool { 8 | return 0 < n && n&(n-1) == 0 && n&0b10101010101010101010101010101010 == 0 9 | } 10 | 11 | func isPowerOfFour(n int) bool { 12 | return 0 < n && n&(n-1) == 0 && n%3 == 1 // TODO 13 | // ✅ 1 4 16 64 256 14 | // ❌ n%4== 8 32 128 512 15 | } 16 | -------------------------------------------------------------------------------- /Sql/1098.unpopular-books 过去一年少于十本的书/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/unpopular-books 2 | 3 | 4 | SELECT `b`.`book_id`, `b`.`name` 5 | FROM `books` `b` 6 | LEFT JOIN `orders` `o` ON `b`.`book_id` = `o`.`book_id` 7 | AND '2018-06-23' <= `o`.`dispatch_date` 8 | WHERE `b`.`available_from` < '2019-05-23' 9 | GROUP BY `b`.`book_id` 10 | HAVING IFNULL(SUM(`o`.`quantity`), 0) < 10 -------------------------------------------------------------------------------- /Stack/0856.score-of-parentheses 括号的分数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/score-of-parentheses 4 | 5 | func scoreOfParentheses(s string) int { 6 | var res, level int 7 | for i, v := range s { 8 | if v == '(' { 9 | level++ 10 | } else { 11 | if s[i-1] == '(' { // 抵消计算层级 12 | res += 1 << (level - 1) 13 | } 14 | level-- 15 | } 16 | } 17 | return res 18 | } 19 | -------------------------------------------------------------------------------- /1985.find-the-kth-largest-integer-in-the-arraymain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/find-the-kth-largest-integer-in-the-array 6 | 7 | func kthLargestNumber(nums []string, k int) string { 8 | sort.Slice(nums, func(i, j int) bool { 9 | return len(nums[j]) < len(nums[i]) || len(nums[j]) == len(nums[i]) && nums[j] < nums[i] 10 | }) 11 | return nums[k-1] 12 | } 13 | -------------------------------------------------------------------------------- /Graph/0657.robot-return-to-origin 机器人能否返回原点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/robot-return-to-origin 4 | 5 | func judgeCircle(moves string) bool { 6 | x, y := 0, 0 7 | for i := range moves { 8 | switch moves[i] { 9 | case 'U': 10 | y-- 11 | case 'D': 12 | y++ 13 | case 'L': 14 | x-- 15 | case 'R': 16 | x++ 17 | } 18 | } 19 | return x == 0 && y == 0 20 | } 21 | -------------------------------------------------------------------------------- /Hash/inter/0771.jewels-and-stones 两数组 val 交集数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/jewels-and-stones/ 4 | 5 | // ❓ 两数组 val 交集数 6 | func numJewelsInStones(j string, s string) int { 7 | var chMpCnt = map[byte]int{} 8 | for i := range j { 9 | chMpCnt[j[i]] = 1 10 | } 11 | 12 | var cntInter int 13 | for i := range s { 14 | cntInter += chMpCnt[s[i]] 15 | } 16 | return cntInter 17 | } 18 | -------------------------------------------------------------------------------- /Sql/1141.user-activity-for-the-past-30-days-i 近30天活跃数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/user-activity-for-the-past-30-days-i 2 | 3 | 4 | SELECT IFNULL( 5 | ROUND( 6 | COUNT(DISTINCT `session_id`) / COUNT(DISTINCT `user_id`), 7 | 2), 8 | 0) `average_sessions_per_user` 9 | FROM `activity` 10 | WHERE '2019-06-27' < `activity_date` -------------------------------------------------------------------------------- /Sql/1270.all-people-report-to-the-given-manager 递归查询/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/all-people-report-to-the-given-manager 2 | 3 | SELECT `e1`.`employee_id` 4 | FROM `employees` `e1` 5 | JOIN `employees` `e2` ON `e1`.`manager_id` = `e2`.`employee_id` 6 | JOIN `employees` `e3` ON `e2`.`manager_id` = `e3`.`employee_id` 7 | WHERE `e1`.`employee_id` != 1 8 | AND `e3`.`manager_id` = 1 9 | -------------------------------------------------------------------------------- /Sql/1543.fix-product-name-format 格式化/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/fix-product-name-format 2 | 3 | 4 | SELECT LOWER(TRIM(`product_name`)) `product_name`, 5 | LEFT(`sale_date`, 7) `sale_date`, 6 | COUNT(*) `total` 7 | FROM `sales` 8 | GROUP BY LOWER(TRIM(`product_name`)), LEFT(`sale_date`, 7) 9 | ORDER BY LOWER(TRIM(`product_name`)), LEFT(`sale_date`, 7) 10 | -------------------------------------------------------------------------------- /Stack/1221.split-a-string-in-balanced-strings 分割平衡字符串/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/split-a-string-in-balanced-strings 4 | 5 | func balancedStringSplit(s string) int { 6 | var cnt int 7 | var res int 8 | for i := range s { 9 | if s[i] == 'L' { 10 | cnt++ 11 | } else { 12 | cnt-- 13 | } 14 | if cnt == 0 { 15 | res++ 16 | } 17 | } 18 | return res 19 | } 20 | -------------------------------------------------------------------------------- /Sum/0454.4sum-ii 四数相加 II/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/4sum-ii 4 | 5 | func fourSumCount(a, b, c, d []int) int { 6 | var res int 7 | countAB := map[int]int{} 8 | for i := range a { 9 | for j := range b { 10 | countAB[a[i]+b[j]]++ 11 | } 12 | } 13 | for i := range c { 14 | for j := range d { 15 | res += countAB[-c[i]-d[j]] 16 | } 17 | } 18 | return res 19 | } 20 | -------------------------------------------------------------------------------- /Bit/calculate/1689.partitioning-into-minimum-number-of-deci-binary-numbers-.go: -------------------------------------------------------------------------------- 1 | package add 2 | 3 | // https://leetcode.cn/problems/partitioning-into-minimum-number-of-deci-binary-numbers 4 | 5 | // 123 => 111 011 001 => 3 6 | 7 | func minPartitions(str string) int { 8 | var max byte = 0 9 | for i := range str { 10 | if max < str[i] { 11 | max = str[i] 12 | } 13 | } 14 | return int(max - '0') 15 | } 16 | -------------------------------------------------------------------------------- /Sql/0183.customers-who-never-order 从不订购的客户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customers-who-never-order 2 | 3 | SELECT `customers`.`name` `customers` 4 | FROM `customers` 5 | LEFT JOIN `orders` ON `customers`.`id` = `orders`.`customerid` 6 | WHERE `orders`.`customerid` IS NULL; 7 | 8 | # 9 | 10 | SELECT `name` `customers` 11 | FROM `customers` 12 | WHERE `id` NOT IN (SELECT `customerid` FROM `orders`) -------------------------------------------------------------------------------- /Sql/1571.warehouse-manager 计算立方/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/warehouse-manager 2 | 3 | 4 | SELECT `w`.`name` `warehouse_name`, 5 | SUM(`w`.`units` * `p`.`width` * `p`.`length` * `p`.`height`) `volume` 6 | FROM `warehouse` `w` 7 | JOIN 8 | `products` `p` 9 | ON `w`.`product_id` = `p`.`product_id` 10 | GROUP BY `w`.`name`; 11 | -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0338.counting-bits.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/counting-bits 4 | 5 | func countBits(numMax int) []int { 6 | var bits []int 7 | for num := 0; num <= numMax; num++ { 8 | bits = append(bits, bk(num)) 9 | } 10 | return bits 11 | } 12 | 13 | func bk(num int) int { 14 | var cnt int 15 | for 0 < num { 16 | num &= num - 1 17 | cnt++ 18 | } 19 | return cnt 20 | } 21 | -------------------------------------------------------------------------------- /Greedy/array/0055.jump-game.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/jump-game 4 | 5 | func canJump(nums []int) bool { 6 | var idxFar int 7 | for idx := range nums { 8 | if idxFar < idx { // TODO 跳不过 9 | return false 10 | } 11 | idxFar = max(idxFar, idx+nums[idx]) 12 | } 13 | return true 14 | } 15 | 16 | func max(x, y int) int { 17 | if x < y { 18 | return y 19 | } 20 | return x 21 | } 22 | -------------------------------------------------------------------------------- /LinkedList/0876.middle-of-the-linked-list 中间节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/middle-of-the-linked-list 9 | 10 | func middleNode(head *ListNode) *ListNode { 11 | var fast, slow = head, head 12 | for fast != nil && fast.Next != nil { 13 | slow = slow.Next 14 | fast = fast.Next.Next 15 | } 16 | return slow 17 | } 18 | -------------------------------------------------------------------------------- /Offer/面试题 01.02. 判定是否互为字符重排/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/check-permutation-lcci/ 4 | 5 | func CheckPermutation(s1 string, s2 string) bool { 6 | m := map[byte]int{} 7 | for i := range s1 { 8 | m[s1[i]]++ 9 | } 10 | 11 | for i := range s2 { 12 | m[s2[i]]-- 13 | } 14 | 15 | for b := range m { 16 | if m[b] != 0 { 17 | return false 18 | } 19 | } 20 | return true 21 | } 22 | -------------------------------------------------------------------------------- /Sql/1107.new-users-daily-count 每日新用户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/new-users-daily-count 2 | 3 | 4 | SELECT `activity_date` `login_date`, COUNT(*) `user_count` 5 | FROM ( 6 | SELECT `user_id`, MIN(`activity_date`) `activity_date` 7 | FROM `traffic` 8 | WHERE `activity` = 'login' 9 | GROUP BY `user_id`) `t` 10 | WHERE '2019-03-31' < `activity_date` 11 | GROUP BY `login_date -------------------------------------------------------------------------------- /Stack/1544.make-the-string-great 整理字符串/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/make-the-string-great 4 | 5 | func makeGood(s string) string { 6 | var res []byte 7 | for i := range s { 8 | top := len(res) - 1 9 | if -1 < top && (s[i]-32 == res[top] || s[i]+32 == res[top]) { 10 | res = res[:top] 11 | } else { 12 | res = append(res, s[i]) 13 | } 14 | } 15 | return string(res) 16 | } 17 | -------------------------------------------------------------------------------- /BinarySearch/basics/1009.complement-of-base-10-integermain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/complement-of-base-10-integer 4 | 5 | func bitwiseComplement(n int) int { 6 | lo, hi := 1, 31 // TODO 7 | for lo < hi { 8 | mid := int(uint(lo+hi) >> 1) 9 | numCur := 1 << mid 10 | if numCur <= n { 11 | lo = mid + 1 12 | } else { 13 | hi = mid 14 | } 15 | } 16 | return 1< 1 10 | GROUP BY `seat_id` 11 | -------------------------------------------------------------------------------- /0215.kth-largest-element-in-an-arraymain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/kth-largest-element-in-an-array 4 | 5 | func findKthLargest(nums []int, k int) int { 6 | var cnts [20001]int 7 | for _, num := range nums { 8 | cnts[num+10000]++ 9 | } 10 | 11 | n := len(nums) - k 12 | for num, cnt := range cnts { 13 | n -= cnt 14 | if n < 0 { 15 | return num - 10000 16 | } 17 | } 18 | return -1 19 | } 20 | -------------------------------------------------------------------------------- /Sql/0571.find-median-given-frequency-of-numbers 频率数字的中位数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-median-given-frequency-of-numbers 2 | 3 | 4 | SELECT AVG(`number`) `median` 5 | FROM (SELECT *, 6 | SUM(`frequency`) OVER (ORDER BY `number` ASC) `n1`, 7 | SUM(`frequency`) OVER (ORDER BY `number` DESC) `n2` 8 | FROM `numbers`) `t` 9 | WHERE `n1` BETWEEN `n2` - `frequency` AND `n2` + `frequency`; 10 | -------------------------------------------------------------------------------- /Sql/1204.last-person-to-fit-in-the-elevator 最后进入电梯/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/last-person-to-fit-in-the-elevator 2 | 3 | 4 | SELECT `a`.`person_name` 5 | FROM ( 6 | SELECT `person_name`, @`pre` := @`pre` + `weight` `weight` 7 | FROM `queue`, 8 | (SELECT @`pre` := 0) `tmp` 9 | ORDER BY `turn` 10 | ) `a` 11 | WHERE `a`.`weight` <= 1000 12 | ORDER BY `a`.`weight` DESC 13 | LIMIT 1 -------------------------------------------------------------------------------- /Tree/Postorder/sum/0222.count-complete-tree-nodes 完全二叉树的节点个数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/count-complete-tree-nodes/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 完全二叉树的节点个数 12 | 13 | func countNodes(root *TreeNode) int { 14 | if root == nil { 15 | return 0 16 | } 17 | return countNodes(root.Left) + countNodes(root.Right) + 1 18 | } 19 | -------------------------------------------------------------------------------- /Bit/Brian Kernighan/0477.total-hamming-distance.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/total-hamming-distance 4 | 5 | func totalHammingDistance(nums []int) int { 6 | var cntTot int 7 | numsL := len(nums) 8 | 9 | for idx := 0; idx < 30; idx++ { 10 | var cnt int 11 | for _, num := range nums { 12 | cnt += num >> idx & 1 13 | } 14 | cntTot += cnt * (numsL - cnt) // TODO 组合数 15 | } 16 | return cntTot 17 | } 18 | -------------------------------------------------------------------------------- /Bit/subset/sub-1&subset.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "fmt" 4 | 5 | func main() { 6 | subset := 0b00100101 7 | /** TODO 8 | 00100100 9 | 00100001 10 | 00100000 11 | 00000101 12 | 00000100 13 | 00000001 14 | 00000000 15 | */ 16 | sub := subset 17 | for { 18 | if sub == 0 { 19 | break 20 | } 21 | sub = (sub - 1) & subset 22 | fmt.Printf("%08b\n", sub) 23 | if sub == subset { 24 | break 25 | } 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /DP/single (x)/section/0053.maximum-subarray 最大子数组和/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-subarray 4 | 5 | // 前缀 6 | // f(n) = f(n) + f(n-1) 7 | func maxSubArray(f []int) int { 8 | sumMax := f[0] 9 | fL := len(f) 10 | for i := 1; i < fL; i++ { 11 | if 0 < f[i-1] { // 有所贡献 12 | f[i] += f[i-1] // 保证子数组最大 13 | } 14 | if sumMax < f[i] { 15 | sumMax = f[i] 16 | } 17 | } 18 | return sumMax 19 | } 20 | -------------------------------------------------------------------------------- /Hash/comb/0001.two-sum 两数之和.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/two-sum/ 4 | 5 | // ❓ 两数之和 6 | 7 | func twoSum(nums []int, target int) []int { 8 | var numMpIdx = map[int]int{} 9 | for idxRaw, numRaw := range nums { 10 | numHash := target - numRaw 11 | idxHash, ok := numMpIdx[numHash] 12 | if ok { 13 | return []int{idxHash, idxRaw} 14 | } 15 | numMpIdx[numRaw] = idxRaw 16 | } 17 | return nil 18 | } 19 | -------------------------------------------------------------------------------- /Hash/perm/0266.palindrome-permutation 有效回文.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/palindrome-permutation 4 | 5 | // ❓ 有效回文 6 | 7 | func canPermutePalindrome(s string) bool { 8 | chMpCnt := map[byte]int{} 9 | for i := range s { 10 | chMpCnt[s[i]]++ 11 | } 12 | 13 | // 奇数 14 | var odd = 0 15 | for _, cnt := range chMpCnt { 16 | if cnt%2 == 1 { 17 | odd++ 18 | } 19 | } 20 | 21 | return odd <= 1 22 | } 23 | -------------------------------------------------------------------------------- /Hash/perm/1426.counting-elements 存在后置元素的元素个数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/counting-elements 4 | 5 | // ❓ 存在后置元素的元素个数 6 | 7 | func countElements(arr []int) int { 8 | numMpCnt := map[int]int{} 9 | for _, num := range arr { 10 | numMpCnt[num]++ 11 | } 12 | 13 | var cnt int 14 | for num := range numMpCnt { 15 | if 0 < numMpCnt[num+1] { 16 | cnt += numMpCnt[num] 17 | } 18 | } 19 | return cnt 20 | } 21 | -------------------------------------------------------------------------------- /Search/0026.remove-duplicates-from-sorted-array 删除有序数组中的重复项/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/remove-duplicates-from-sorted-array/submissions/ 4 | 5 | func removeDuplicates(nums []int) int { 6 | l, top := 1, len(nums)-1 7 | if top <= 0 { 8 | return top + 1 9 | } 10 | for i := 0; i < top; i++ { 11 | if nums[i] != nums[i+1] { 12 | nums[l] = nums[i+1] 13 | l++ 14 | } 15 | } 16 | return l 17 | } 18 | -------------------------------------------------------------------------------- /Bit/shift/0868.binary-gapmain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/binary-gap 4 | 5 | func binaryGap(n int) int { 6 | var idx int 7 | var last = -1 8 | var dist int 9 | for n != 0 { 10 | if n&1 == 1 { 11 | if last != -1 { 12 | distCur := idx - last 13 | if dist < distCur { 14 | dist = distCur 15 | } 16 | } 17 | last = idx 18 | } 19 | n >>= 1 20 | idx++ 21 | } 22 | return dist 23 | } 24 | -------------------------------------------------------------------------------- /DP/single (x)/incr/0121.best-time-to-buy-and-sell-stock 买卖股票的最佳时机/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/best-time-to-buy-and-sell-stock 4 | 5 | func maxProfit(prices []int) int { 6 | var minBuy, maxSale = 1<<63 - 1, 0 7 | for _, price := range prices { 8 | if price < minBuy { 9 | minBuy = price 10 | } 11 | if maxSale < price-minBuy { 12 | maxSale = price - minBuy 13 | } 14 | } 15 | return maxSale 16 | } 17 | -------------------------------------------------------------------------------- /Enum/5875.final-value-of-variable-after-performing-operations 执行操作后的变量值/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/final-value-of-variable-after-performing-operations 4 | 5 | func finalValueAfterOperations(operations []string) int { 6 | var res int 7 | for i := range operations { 8 | if operations[i][1] == '+' { 9 | res++ 10 | } else if operations[i][1] == '-' { 11 | res-- 12 | } 13 | } 14 | return res 15 | } 16 | -------------------------------------------------------------------------------- /Hash/where/1133.largest-unique-number 最大的唯一数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/largest-unique-number 4 | 5 | // ❓ 最大的唯一值 6 | 7 | func largestUniqueNumber(nums []int) int { 8 | // 计数 9 | numMpCnt := [1001]int{} 10 | for _, num := range nums { 11 | numMpCnt[num]++ 12 | } 13 | 14 | // 倒序 15 | for num := 1000; 0 <= num; num-- { 16 | if numMpCnt[num] == 1 { 17 | return num 18 | } 19 | } 20 | return -1 21 | } 22 | -------------------------------------------------------------------------------- /Sql/1581.customer-who-visited-but-did-not-make-any-transactions 进店未交易/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customer-who-visited-but-did-not-make-any-transactions 2 | 3 | SELECT `v`.`customer_id`, 4 | COUNT(DISTINCT `v`.`visit_id`) `count_no_trans` 5 | FROM `visits` `v` 6 | LEFT JOIN `transactions` `t` ON `v`.`visit_id` = `t`.`visit_id` 7 | WHERE `t`.`visit_id` IS NULL 8 | GROUP BY `v`.`customer_id` 9 | 10 | -------------------------------------------------------------------------------- /Bit/xor/0810.chalkboard-xor-gamemain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/chalkboard-xor-game 4 | 5 | // 删除一个数值后为0 == 失败 6 | 7 | func xorGame(nums []int) bool { 8 | if len(nums)%2 == 0 { 9 | // 0 0 0 1 = 1 10 | // 0 1 1 1 = 1 11 | // TODO 偶数长度，奇数1 必定挑出一个0，使之继续为奇数1，即不为0 12 | return true 13 | } 14 | xor := 0 15 | for _, num := range nums { // TODO 整体为0，擦掉任何数都将不为0 16 | xor ^= num 17 | } 18 | return xor == 0 19 | } 20 | -------------------------------------------------------------------------------- /Hash/cnt/0169.majority-element.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/majority-element 4 | 5 | // 超过一半的数 6 | 7 | func majorityElement(nums []int) int { 8 | var numMode, cnt int 9 | for _, num := range nums { 10 | if numMode == num { 11 | cnt++ 12 | } else { 13 | // TODO BM 14 | if cnt == 0 { 15 | numMode = num 16 | cnt = 1 17 | } else { 18 | cnt-- 19 | } 20 | } 21 | } 22 | return numMode 23 | } 24 | -------------------------------------------------------------------------------- /LinkedList/剑指 Offer 22. 链表中倒数第k个节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/lian-biao-zhong-dao-shu-di-kge-jie-dian-lcof/ 4 | 5 | type ListNode struct { 6 | Val int 7 | Next *ListNode 8 | } 9 | 10 | func getKthFromEnd(head *ListNode, k int) *ListNode { 11 | s, f := head, head 12 | for 0 < k { 13 | f = f.Next 14 | k-- 15 | } 16 | 17 | for f != nil { 18 | s = s.Next 19 | f = f.Next 20 | } 21 | return s 22 | } 23 | -------------------------------------------------------------------------------- /Math/1403.minimum-subsequence-in-non-increasing-order/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | func minSubsequence(nums []int) []int { 6 | var res []int 7 | sort.Ints(nums) 8 | sum := 0 9 | for _, n := range nums { 10 | sum += n 11 | } 12 | counter := 0 13 | i := len(nums) 14 | half := sum / 2 15 | 16 | for counter <= half { 17 | i-- 18 | counter += nums[i] 19 | res = append(res, nums[i]) 20 | } 21 | return res 22 | } 23 | -------------------------------------------------------------------------------- /Offer/面试题 17.04. 消失的数字/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/missing-number-lcci/ 4 | 5 | func missingNumber(nums []int) int { 6 | n := len(nums) 7 | x := n + 1 8 | nums = append(nums, n) 9 | for i := range nums { 10 | k := nums[i] % x 11 | nums[k] += x 12 | } 13 | 14 | for i := range nums { 15 | if nums[i] < x { // n 也存在了 16 | return i 17 | } 18 | } 19 | return n // 当1-N 都存在，包括加入的n 刚好返回n 是正常答案 20 | } 21 | -------------------------------------------------------------------------------- /Sql/0177.nth-highest-salary 找第N名 Null 也返回/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/nth-highest-salary 2 | 3 | CREATE FUNCTION getNthHighestSalary(`n` INT) RETURNS INT 4 | BEGIN 5 | SET `n` := `n` - 1; 6 | RETURN ( 7 | SELECT ( 8 | SELECT DISTINCT `salary` 9 | FROM `employee` 10 | ORDER BY `salary` DESC 11 | LIMIT `n`,1) `nthhighestsalary` 12 | ); 13 | END -------------------------------------------------------------------------------- /DP/path (x,y)/0119.pascals-triangle-ii 杨辉三角 II/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/pascals-triangle-ii 4 | 5 | // 压缩 6 | // f(i)(j) = f(i-1)(j-1) + f(i-1)(j) 7 | func getRow(rowIndex int) []int { 8 | numRows := rowIndex + 1 9 | var f = make([]int, numRows) 10 | for i := 0; i < numRows; i++ { 11 | f[0] = 1 12 | f[i] = 1 13 | for j := i - 1; 0 < j; j-- { 14 | f[j] = f[j-1] + f[j] 15 | } 16 | } 17 | return f 18 | } 19 | -------------------------------------------------------------------------------- /Enum/✅ 1446.consecutive-characters 连续字符/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/consecutive-characters 4 | 5 | func maxPower(s string) int { 6 | l := len(s) 7 | var cnt = 1 8 | var max int 9 | for i := 1; i < l; i++ { 10 | if s[i-1] == s[i] { 11 | cnt++ 12 | } else { 13 | if max < cnt { 14 | max = cnt 15 | } 16 | cnt = 1 17 | } 18 | } 19 | if max < cnt { 20 | max = cnt 21 | } 22 | return max 23 | } 24 | -------------------------------------------------------------------------------- /Hash/comb/2006.count-number-of-pairs-with-absolute-difference-k 差的绝对值为 K 的数对总数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/count-number-of-pairs-with-absolute-difference-k 4 | 5 | // ❓ 差为K的数对总数 6 | 7 | func countKDifference(nums []int, k int) int { 8 | numMpCnt := map[int]int{} 9 | var cntDiff int 10 | for _, num := range nums { 11 | cntDiff += numMpCnt[num-k] + numMpCnt[num+k] 12 | numMpCnt[num]++ 13 | } 14 | return cntDiff 15 | } 16 | -------------------------------------------------------------------------------- /Hash/score/1941.check-if-all-characters-have-equal-number-of-occurrences 检查是否所有字符出现次数相同.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/check-if-all-characters-have-equal-number-of-occurrences 4 | 5 | func areOccurrencesEqual(s string) bool { 6 | m := map[byte]int{} 7 | base := s[0] 8 | for i := range s { 9 | m[s[i]]++ 10 | } 11 | for k := range m { 12 | if m[k] != m[base] { 13 | return false 14 | } 15 | } 16 | return true 17 | } 18 | -------------------------------------------------------------------------------- /Sql/1285.find-the-start-and-end-number-of-continuous-ranges 区间次数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-the-start-and-end-number-of-continuous-ranges 2 | 3 | SELECT MIN(`log_id`) `start_id`, 4 | MAX(`log_id`) `end_id` 5 | FROM ( 6 | SELECT DISTINCT `log_id`, 7 | `log_id` - ROW_NUMBER() OVER ( ORDER BY `log_id` ASC ) `r` 8 | FROM `logs` 9 | ) `t` 10 | GROUP BY `r` 11 | ORDER BY `start_id` 12 | -------------------------------------------------------------------------------- /Sql/1613.find-the-missing-ids 缺失的id/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-the-missing-ids 2 | 3 | WITH RECURSIVE `num`(`n`) AS ( 4 | SELECT 1 `a` 5 | UNION ALL 6 | SELECT `n` + 1 7 | FROM `num` 8 | WHERE `n` < 100 9 | ) 10 | SELECT `n` `ids` 11 | FROM `num` 12 | WHERE `n` NOT IN ( 13 | SELECT `customer_id` 14 | FROM `customers` 15 | ) 16 | AND `n` <= ( 17 | SELECT MAX(`customer_id`) 18 | FROM `customers` 19 | ) -------------------------------------------------------------------------------- /Templates/math/quick_mul.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func mul(x, y int) int { 4 | var numRes int 5 | var cnt int 6 | // 符号转换 7 | if x < 0 { 8 | cnt++ 9 | x = -x 10 | } 11 | if y < 0 { 12 | cnt++ 13 | y = -y 14 | } 15 | 16 | for 0 < y { 17 | // 按位相加 18 | if 1 == y&1 { 19 | numRes += x 20 | } 21 | // 减少位 22 | y >>= 1 23 | // 翻倍 24 | x <<= 1 25 | } 26 | if cnt%2 == 1 { 27 | return -numRes 28 | } 29 | return numRes 30 | } 31 | -------------------------------------------------------------------------------- /Bit/perm/0231.power-of-two.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/power-of-two 4 | 5 | // ❓ 2的幂 6 | 7 | func isPowerOfTwo(n int) bool { 8 | // 1<<31 的约数 9 | return 0 < n && 1<<31%n == 0 // TODO 10 | } 11 | 12 | func isPowerOfTwo(n int) bool { 13 | return 0 < n && n&(n-1) == 0 // TODO 消除最低有效位 14 | } 15 | 16 | func isPowerOfTwo(n int) bool { 17 | // 000010000 18 | // 111101111 + 1 19 | return 0 < n && n&-n == n // TODO 最后有效位 20 | } 21 | -------------------------------------------------------------------------------- /Hash/window/0219.contains-duplicate-ii 两个重复元素距离小于等于K.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/contains-duplicate-ii 4 | 5 | // ❓ 是否存在两个重复元素距离小于等于K 6 | 7 | func containsNearbyDuplicate(nums []int, k int) bool { 8 | var numMpIdx = map[int]int{} 9 | for idxCur, num := range nums { 10 | idxPre, ok := numMpIdx[num] 11 | if ok && idxCur-idxPre <= k { 12 | return true 13 | } 14 | numMpIdx[num] = idxCur 15 | } 16 | return false 17 | } 18 | -------------------------------------------------------------------------------- /LinkedList/0141.linked-list-cycle 是否有环/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/linked-list-cycle 9 | 10 | func hasCycle(head *ListNode) bool { 11 | slow, fast := head, head 12 | for fast != nil && fast.Next != nil { 13 | slow = slow.Next 14 | fast = fast.Next.Next 15 | if slow == fast { // 相遇时 在环内 16 | return true 17 | } 18 | } 19 | return false 20 | } 21 | -------------------------------------------------------------------------------- /Offer/剑指 Offer II 032. 有效的变位词/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/dKk3P7/ 4 | 5 | func isAnagram(s string, t string) bool { 6 | if s == t || len(s) != len(t) { 7 | return false 8 | } 9 | m := map[byte]int{} 10 | for i := range s { 11 | m[s[i]]++ 12 | } 13 | 14 | for i := range t { 15 | m[t[i]]-- 16 | } 17 | 18 | for b := range m { 19 | if m[b] != 0 { 20 | return false 21 | } 22 | } 23 | return true 24 | } 25 | -------------------------------------------------------------------------------- /Sql/0612.shortest-distance-in-a-plane 平面上的最近距离/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/shortest-distance-in-a-plane 2 | 3 | SELECT ROUND(SQRT(MIN((POW(`p1`.`x` - `p2`.`x`, 2) + POW(`p1`.`y` - `p2`.`y`, 2)))), 2) `shortest` 4 | FROM `point_2d` `p1` 5 | JOIN 6 | `point_2d` `p2` ON (`p1`.`x` != `p2`.`x` AND `p1`.`y` = `p2`.`y`) 7 | OR (`p1`.`x` != `p2`.`x` AND `p1`.`y` != `p2`.`y`) 8 | OR (`p1`.`x` = `p2`.`x` AND `p1`.`y` != `p2`.`y`) 9 | -------------------------------------------------------------------------------- /Tree/Deep First Search/ordinary/0100.same-tree 相同二叉树/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/same-tree/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 相同二叉树 12 | 13 | func isSameTree(p *TreeNode, q *TreeNode) bool { 14 | if p == nil || q == nil { 15 | return p == q 16 | } 17 | return isSameTree(p.Left, q.Left) && p.Val == q.Val && isSameTree(p.Right, q.Right) 18 | } 19 | -------------------------------------------------------------------------------- /Graph/Graph 0997.find-the-town-judge 找到小镇的法官/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-the-town-judge 4 | 5 | func findJudge(n int, trust [][]int) int { 6 | out := map[int]int{} 7 | in := map[int]int{} 8 | for i := range trust { 9 | out[trust[i][0]]++ // 出度 10 | in[trust[i][1]]++ // 入度 11 | } 12 | 13 | for i := 1; i <= n; i++ { 14 | if out[i] == 0 && in[i] == n-1 { 15 | return i 16 | } 17 | } 18 | 19 | return -1 20 | } 21 | -------------------------------------------------------------------------------- /Enum/1503.last-moment-before-all-ants-fall-out-of-a-plank 所有蚂蚁掉下来前的最后一刻/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/last-moment-before-all-ants-fall-out-of-a-plank 4 | 5 | func getLastMoment(n int, left []int, right []int) int { 6 | var max int 7 | for _, v := range left { 8 | if max < v { 9 | max = v 10 | } 11 | } 12 | 13 | for _, v := range right { 14 | if max < n-v { 15 | max = n - v 16 | } 17 | } 18 | 19 | return max 20 | } 21 | -------------------------------------------------------------------------------- /Hash/cnt/0760.find-anagram-mappings.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-anagram-mappings 4 | 5 | // ❓ 找出 A里面元素，在B里的索引值 6 | 7 | func anagramMappings(A []int, B []int) []int { 8 | // B 的位置 9 | var numMpIdx = map[int]int{} 10 | for idx, num := range B { 11 | numMpIdx[num] = idx 12 | } 13 | 14 | // TODO 索引值 15 | var idxesA []int 16 | for _, num := range A { 17 | idxesA = append(idxesA, numMpIdx[num]) 18 | } 19 | return idxesA 20 | } 21 | -------------------------------------------------------------------------------- /Sort/0912.sort-an-array 排序数组/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/sort-an-array 4 | 5 | // ❓ 计数排序 6 | 7 | func sortArray(nums []int) []int { 8 | numMpCnt := [100001]int{} 9 | 10 | for _, num := range nums { 11 | numMpCnt[num+50000]++ 12 | } 13 | 14 | var numsSort []int 15 | for num, cnt := range numMpCnt { 16 | for i := 0; i < cnt; i++ { 17 | numsSort = append(numsSort, num-50000) 18 | } 19 | } 20 | return numsSort 21 | } 22 | -------------------------------------------------------------------------------- /Sql/1369.get-the-second-most-recent-activity 倒数第二次活动/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/get-the-second-most-recent-activity 2 | 3 | SELECT `username`, `activity`, `startdate`, `enddate` 4 | FROM (SELECT *, 5 | RANK() OVER (PARTITION BY `username` ORDER BY `startdate` DESC) `r`, 6 | COUNT(*) OVER (PARTITION BY `username`) `count` 7 | FROM `useractivity`) `t` 8 | WHERE `r` = 2 9 | OR `count` = 1; 10 | 11 | -------------------------------------------------------------------------------- /DP/path (x,y)/0118.pascals-triangle 杨辉三角/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/pascals-triangle 4 | 5 | // 二维 6 | // f(i)(j) = f(i-1)(j-1) + f(i-1)(j) 7 | func generate(numRows int) [][]int { 8 | var f = make([][]int, numRows) 9 | for i := 0; i < numRows; i++ { 10 | f[i] = make([]int, i+1) 11 | f[i][0] = 1 12 | f[i][i] = 1 13 | for j := 1; j < i; j++ { 14 | f[i][j] = f[i-1][j-1] + f[i-1][j] 15 | } 16 | } 17 | 18 | return f 19 | } 20 | -------------------------------------------------------------------------------- /Greedy/string/1147.longest-chunked-palindrome-decomposition*.go: -------------------------------------------------------------------------------- 1 | package string 2 | 3 | // https://leetcode.cn/problems/longest-chunked-palindrome-decomposition 4 | 5 | func longestDecomposition(text string) int { 6 | textL := len(text) 7 | if textL <= 1 { 8 | return textL 9 | } 10 | 11 | // TODO 贪心 12 | for i := 1; i < textL; i++ { 13 | if text[:i] == text[textL-i:] { 14 | return 2 + longestDecomposition(text[i:textL-i]) 15 | } 16 | } 17 | return 1 18 | } 19 | -------------------------------------------------------------------------------- /Sql/1083.sales-analysis-ii 买 S8 却没有 iPhone 的买家/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/sales-analysis-ii 2 | 3 | SELECT `buyer_id` 4 | FROM (SELECT `buyer_id`, 5 | IF(`p`.`product_name` = 'S8', 1, 0) `s8`, 6 | IF(`p`.`product_name` = 'iPhone', 1, 0) `ip` 7 | FROM `sales` `s` 8 | JOIN `product` `p` ON `s`.`product_id` = `p`.`product_id`) `t` 9 | GROUP BY `buyer_id` 10 | HAVING 0 < SUM(`ip`) 11 | AND SUM(`s8`) = 0 -------------------------------------------------------------------------------- /Sql/1795.rearrange-products-table 商品价格合并/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/rearrange-products-table 2 | 3 | SELECT `product_id`, 'store1' `store`, `store1` `price` 4 | FROM `products` 5 | WHERE `store1` IS NOT NULL 6 | UNION ALL 7 | SELECT `product_id`, 'store2' `store`, `store2` `price` 8 | FROM `products` 9 | WHERE `store2` IS NOT NULL 10 | UNION ALL 11 | SELECT `product_id`, 'store3' `store`, `store3` `price` 12 | FROM `products` 13 | WHERE `store3` IS NOT NULL 14 | -------------------------------------------------------------------------------- /TwoPointer/1099.two-sum-less-than-k 小于 K 的两数之和/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/two-sum-less-than-k 6 | 7 | func twoSumLessThanK(nums []int, k int) int { 8 | sort.Ints(nums) 9 | l, r := 0, len(nums)-1 10 | var max = -1 11 | for l < r { 12 | cur := nums[l] + nums[r] 13 | if cur < k { 14 | if max < cur { 15 | max = cur 16 | } 17 | l++ 18 | } else { 19 | r-- 20 | } 21 | } 22 | return max 23 | } 24 | -------------------------------------------------------------------------------- /Sql/0569.median-employee-salary 每个公司薪酬中位数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/median-employee-salary 2 | 3 | SELECT `id`, `company`, `salary` 4 | FROM (SELECT `id`, 5 | `company`, 6 | `salary`, 7 | ROW_NUMBER() OVER (PARTITION BY `company` ORDER BY `salary`) `rank`, 8 | COUNT(*) OVER (PARTITION BY `company`) `count` 9 | FROM `employee`) `t` 10 | WHERE `rank` BETWEEN `count` / 2 AND `count` / 2 + 1 -------------------------------------------------------------------------------- /Stack/1003.check-if-word-is-valid-after-substitutions 检查替换后的词是否有效/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/check-if-word-is-valid-after-substitutions 4 | 5 | func isValid(s string) bool { 6 | var stack []byte 7 | for i := range s { 8 | l := len(stack) 9 | if s[i] == 'c' && 1 < l && stack[l-2] == 'a' && stack[l-1] == 'b' { 10 | stack = stack[:l-2] 11 | } else { 12 | stack = append(stack, s[i]) 13 | } 14 | } 15 | return 0 == len(stack) 16 | } 17 | -------------------------------------------------------------------------------- /Stack/✅ 1614.maximum-nesting-depth-of-the-parentheses/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-nesting-depth-of-the-parentheses 4 | 5 | // ❓ 括号的最大嵌套深度 6 | 7 | func maxDepth(s string) int { 8 | var cnt int 9 | var cntMax int 10 | for i := range s { 11 | ch := s[i] 12 | if ch == ')' { 13 | cnt-- 14 | } else if ch == '(' { 15 | cnt++ 16 | if cntMax < cnt { 17 | cntMax = cnt 18 | } 19 | } 20 | } 21 | return cntMax 22 | } 23 | -------------------------------------------------------------------------------- /Hash/perm/0575.distribute-candies 得到最多类型的糖果.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/distribute-candies 4 | 5 | // ❓ 得到最多类型的糖果 6 | 7 | func distributeCandies(candy []int) int { 8 | candyL := len(candy) 9 | typMp := map[int]struct{}{} 10 | for _, typ := range candy { 11 | typMp[typ] = struct{}{} // 类型数 12 | } 13 | 14 | typMpL := len(typMp) 15 | if candyL/2 < typMpL { // 类型数超过 一半，每样一颗 16 | return candyL / 2 17 | } 18 | return typMpL // 小于一半 最多typMpL 19 | } 20 | -------------------------------------------------------------------------------- /Hash/window/0961.n-repeated-element-in-size-2n-array 2N 中重复 N 次的元素.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/n-repeated-element-in-size-2n-array 4 | 5 | // ❓ 2N 中重复 N 次的元素 6 | // ⚠️ 必定存在[n,n+4] 内有2个重复元素 7 | 8 | func repeatedNTimes(nums []int) int { 9 | numsL := len(nums) 10 | for step := 1; step <= 3; step++ { 11 | for i := 0; i < numsL-step; i++ { 12 | if nums[i] == nums[i+step] { 13 | return nums[i] 14 | } 15 | } 16 | } 17 | 18 | return -1 19 | } 20 | -------------------------------------------------------------------------------- /Sql/0534.game-play-analysis-iii 每人每天累积多少时长/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/game-play-analysis-iii 2 | 3 | SELECT `a1`.`player_id` `player_id`, 4 | `a1`.`event_date` `event_date`, 5 | SUM(`a2`.`games_played`) `games_played_so_far` 6 | FROM `activity` `a2` 7 | JOIN 8 | `activity` `a1` 9 | ON `a1`.`player_id` = `a2`.`player_id` 10 | AND `a2`.`event_date` <= `a1`.`event_date` 11 | GROUP BY `a1`.`player_id`, `a1`.`event_date` -------------------------------------------------------------------------------- /Sql/1174.immediate-food-delivery-ii 首日即时配送订单/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/immediate-food-delivery-ii 2 | 3 | SELECT ROUND( 4 | SUM(`order_date` = `customer_pref_delivery_date`) * 100 / 5 | COUNT(*), 6 | 2 7 | ) `immediate_percentage` 8 | FROM `delivery` 9 | WHERE (`customer_id`, `order_date`) IN ( 10 | SELECT `customer_id`, MIN(`order_date`) 11 | FROM `delivery` 12 | GROUP BY `customer_id` 13 | ) -------------------------------------------------------------------------------- /DP/single (x)/0070.climbing-stairs 爬楼梯/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/climbing-stairs 4 | 5 | // 一维 6 | // f(n) = f(n-1) + f(n-2) 7 | 8 | func climbStairs(n int) int { 9 | f := make([]int, n+1) 10 | f[0] = 1 11 | f[1] = 1 12 | for i := 2; i <= n; i++ { 13 | f[i] = f[i-2] + f[i-1] 14 | } 15 | return f[n] 16 | } 17 | 18 | func climbStairs_(n int) int { 19 | x, y := 1, 1 20 | for 1 <= n { 21 | y, x = x+y, y 22 | n-- 23 | } 24 | return x 25 | } 26 | -------------------------------------------------------------------------------- /Enum/1646.get-maximum-in-generated-array 获取生成数组中的最大值/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/get-maximum-in-generated-array 4 | 5 | func getMaximumGenerated(n int) int { 6 | var res int 7 | if n == 0 { 8 | return res 9 | } 10 | nums := make([]int, n+1) 11 | nums[1] = 1 12 | for i := 2; i <= n; i++ { 13 | nums[i] = nums[i/2] + i%2*nums[i/2+1] 14 | } 15 | for _, v := range nums { 16 | if res < v { 17 | res = v 18 | } 19 | } 20 | return res 21 | } 22 | -------------------------------------------------------------------------------- /Hash/where/1394.find-lucky-integer-in-an-array 找出数组中的幸运数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-lucky-integer-in-an-array 4 | 5 | // ❓ 出现次数cnt等于值num的最大值 6 | // ⚠️ 1 <= arr[i] <= 500 7 | func findLucky(arr []int) int { 8 | // 计数 9 | numMpCnt := [501]int{} 10 | for _, num := range arr { 11 | numMpCnt[num]++ 12 | } 13 | 14 | // 倒序 15 | for num := 500; 0 < num; num-- { 16 | if numMpCnt[num] == num { 17 | return num 18 | } 19 | } 20 | return -1 21 | } 22 | -------------------------------------------------------------------------------- /Sql/1077.project-employees-iii 项目经济最丰富的员工/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/project-employees-iii 2 | 3 | SELECT `project_id`, `employee_id` 4 | FROM (SELECT `project_id`, 5 | `p`.`employee_id`, 6 | RANK() OVER (PARTITION BY `project_id` ORDER BY `experience_years` DESC) `r` 7 | FROM `project` `p` 8 | INNER JOIN `employee` `e` 9 | ON `p`.`employee_id` = `e`.`employee_id`) `a` 10 | WHERE `r` = 1; -------------------------------------------------------------------------------- /BinarySearch/rotate/0153.find-minimum-in-rotated-sorted-array.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array 4 | 5 | func findMin(nums []int) int { 6 | lo, hi := 0, len(nums)-1 7 | for lo < hi { 8 | mid := int(uint(lo+hi) >> 1) 9 | if nums[hi] <= nums[mid] { 10 | // lo ~ mid 是旋转序列，旋转肯定偏大 11 | lo = mid + 1 12 | } else if nums[mid] < nums[hi] { 13 | // mid ~ hi 是正常序列 14 | hi = mid 15 | } 16 | } 17 | return nums[lo] 18 | } 19 | -------------------------------------------------------------------------------- /DP/single (x)/0509.fibonacci-number 斐波那契数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/fibonacci-number 4 | 5 | // f(n) = f(n-1) + f(n-2) 6 | func climbStairs(n int) int { 7 | f := make([]int, n+1) 8 | f[0] = 0 9 | f[1] = 1 10 | for i := 2; i <= n; i++ { 11 | f[i] = f[i-1] + f[i-2] 12 | } 13 | return f[n] 14 | } 15 | 16 | // 压缩 17 | func fib(n int) int { 18 | var x, y = 0, 1 19 | for 1 <= n { 20 | y, x = (x+y)%1000000007, y 21 | n-- 22 | } 23 | return x 24 | } 25 | -------------------------------------------------------------------------------- /LinkedList/1290.convert-binary-number-in-a-linked-list-to-integer 二进制链表的值/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | //Title: Convert Binary Number in a Linked List to Integer 9 | // https://leetcode.cn/problems/convert-binary-number-in-a-linked-list-to-integer 10 | 11 | func getDecimalValue(head *ListNode) int { 12 | var i int 13 | for head != nil { 14 | i = i<<1 + head.Val 15 | head = head.Next 16 | } 17 | return i 18 | } 19 | -------------------------------------------------------------------------------- /Search/0011.container-with-most-water 盛最多水的容器/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/container-with-most-water/ 4 | 5 | func maxArea(height []int) int { 6 | var cur, max, l int 7 | r := len(height) - 1 8 | for l < r { 9 | if height[l] < height[r] { //最小高度乘以宽度，并且移动一位 10 | cur = height[l] * (r - l) 11 | l++ 12 | } else { 13 | cur = height[r] * (r - l) 14 | r-- 15 | } 16 | if max < cur { 17 | max = cur 18 | } 19 | 20 | } 21 | return max 22 | } 23 | -------------------------------------------------------------------------------- /Tree/Deep First Search/ordinary/0226.invert-binary-tree 翻转二叉树/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/invert-binary-tree/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 翻转二叉树 12 | 13 | func invertTree(root *TreeNode) *TreeNode { 14 | if root == nil { 15 | return nil 16 | } 17 | root.Left, root.Right = root.Right, root.Left 18 | invertTree(root.Left) 19 | invertTree(root.Right) 20 | return root 21 | } 22 | -------------------------------------------------------------------------------- /Hash/state/1748.sum-of-unique-elements 唯一元素的和.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/sum-of-unique-elements 4 | 5 | // ❓ 所有唯一元素的和 6 | 7 | func sumOfUnique(nums []int) int { 8 | var numMpCnt = map[int]int{} 9 | var sumUnique int 10 | for _, num := range nums { 11 | if numMpCnt[num] == 0 { 12 | sumUnique += num 13 | numMpCnt[num] = 1 14 | } else if numMpCnt[num] == 1 { 15 | sumUnique -= num 16 | numMpCnt[num] = 2 17 | } 18 | } 19 | return sumUnique 20 | } 21 | -------------------------------------------------------------------------------- /Sql/0602.friend-requests-ii-who-has-the-most-friends 谁有最多的好友/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/friend-requests-ii-who-has-the-most-friends 2 | 3 | SELECT `id`, SUM(`n`) `num` 4 | FROM (SELECT `accepter_id` `id`, COUNT(*) `n` 5 | FROM `request_accepted` 6 | GROUP BY `accepter_id` 7 | UNION ALL 8 | SELECT `requester_id` `id`, COUNT(*) `n` 9 | FROM `request_accepted` 10 | GROUP BY `requester_id`) `t` 11 | GROUP BY `id` 12 | ORDER BY `num` DESC 13 | LIMIT 1; 14 | -------------------------------------------------------------------------------- /DP/0650.2-keys-keyboard 只有两个键的键盘/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/2-keys-keyboard 4 | 5 | func minSteps(n int) int { 6 | f := make([]int, n+1) 7 | for i := 2; i <= n; i++ { 8 | f[i] = 1<<31 - 1 9 | for j := 1; j*j <= i; j++ { 10 | if i%j == 0 { 11 | f[i] = min(f[i], f[j]+i/j) 12 | f[i] = min(f[i], f[i/j]+j) 13 | } 14 | } 15 | } 16 | return f[n] 17 | } 18 | 19 | func min(a, b int) int { 20 | if a < b { 21 | return a 22 | } 23 | return b 24 | } 25 | -------------------------------------------------------------------------------- /LinkedList/剑指 Offer II 023. 两个链表的第一个重合节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/3u1WK4/ 9 | 10 | func getIntersectionNode(headA, headB *ListNode) *ListNode { 11 | a := headA 12 | b := headB 13 | for a != b { 14 | if a != nil { 15 | a = a.Next 16 | } else { 17 | a = headB 18 | } 19 | 20 | if b != nil { 21 | b = b.Next 22 | } else { 23 | b = headA 24 | } 25 | } 26 | return b 27 | } 28 | -------------------------------------------------------------------------------- /Offer/剑指 Offer II 119. 最长连续序列/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-consecutive-sequence 4 | 5 | func longestConsecutive(nums []int) int { 6 | m := map[int]bool{} 7 | for i := range nums { 8 | m[nums[i]] = true 9 | } 10 | 11 | var res, cur int 12 | for num := range m { 13 | if !m[num-1] { 14 | cur = 0 15 | for m[num] { 16 | cur++ 17 | num++ 18 | } 19 | if res < cur { 20 | res = cur 21 | } 22 | 23 | } 24 | } 25 | return res 26 | } 27 | -------------------------------------------------------------------------------- /Sql/1747.leetflex-banned-accounts 应被禁止的账户/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/leetflex-banned-accounts 2 | 3 | SELECT DISTINCT `l1`.`account_id` 4 | FROM `loginfo` `l1` 5 | JOIN `loginfo` `l2` 6 | ON `l1`.`account_id` = `l2`.`account_id` 7 | AND `l1`.`ip_address` <> `l2`.`ip_address` 8 | AND ((`l1`.`login` BETWEEN `l2`.`login` AND `l2`.`logout`) 9 | OR (`l1`.`logout` BETWEEN `l2`.`login` AND `l2`.`logout`)) 10 | -------------------------------------------------------------------------------- /TwoPointer/0167.two-sum-ii-input-array-is-sortedII-.go: -------------------------------------------------------------------------------- 1 | package TwoPointer 2 | 3 | // https://leetcode.cn/problems/two-sum-ii-input-array-is-sorted 4 | 5 | // two pointer 6 | func twoSum(nums []int, target int) []int { 7 | lo, hi := 0, len(nums)-1 8 | for lo < hi { 9 | sum := nums[lo] + nums[hi] 10 | if sum == target { 11 | return []int{lo + 1, hi + 1} 12 | } else if sum < target { 13 | lo++ 14 | } else if target < sum { 15 | hi-- 16 | } 17 | } 18 | return []int{-1, -1} 19 | } 20 | -------------------------------------------------------------------------------- /TwoPointer/0424.longest-repeating-character-replacement 替换后的最长重复字符/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-repeating-character-replacement 4 | 5 | func characterReplacement(s string, k int) int { 6 | n := len(s) 7 | l := 0 8 | m := map[byte]int{} 9 | var max int 10 | for r := range s { 11 | m[s[r]]++ 12 | cur := m[s[r]] 13 | if max < cur { 14 | max = cur 15 | } 16 | if k < r-l+1-max { 17 | m[s[l]]-- 18 | l++ 19 | } 20 | } 21 | return n - l 22 | } 23 | -------------------------------------------------------------------------------- /Divide/面试题 08.03. 魔术索引/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/magic-index-lcci/ 4 | 5 | func findMagicIndex(nums []int) int { 6 | var dfs func(lo, hi int) int 7 | dfs = func(lo, hi int) int { 8 | if hi < lo { 9 | return -1 10 | } 11 | mid := int(uint(lo+hi) >> 1) 12 | left := dfs(lo, mid-1) 13 | if left != -1 { 14 | return left 15 | } else if nums[mid] == mid { 16 | return mid 17 | } 18 | return dfs(mid+1, hi) 19 | } 20 | return dfs(0, len(nums)-1) 21 | } 22 | -------------------------------------------------------------------------------- /Enum/0014.longest-common-prefix 最长公共前缀/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-common-prefix/ 4 | 5 | // 1:00 6 | func longestCommonPrefix(strs []string) string { 7 | if len(strs) == 0 { 8 | return "" 9 | } 10 | 11 | var l1 = len(strs) 12 | var l2 = len(strs[0]) 13 | for i := 0; i < l2; i++ { 14 | for j := 1; j < l1; j++ { 15 | if i == len(strs[j]) || strs[j][i] != strs[0][i] { 16 | return strs[0][:i] 17 | } 18 | } 19 | } 20 | 21 | return strs[0] 22 | } 23 | -------------------------------------------------------------------------------- /Enum/✅ 0747.largest-number-at-least-twice-of-others/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/largest-number-at-least-twice-of-others 4 | 5 | // ❓ 至少是其他数字两倍的最大数 6 | 7 | func dominantIndex(nums []int) int { 8 | var max1, max2, idx int 9 | for i, num := range nums { 10 | if max1 < num { 11 | max2 = max1 12 | max1 = num 13 | idx = i 14 | } else if max2 < num { 15 | max2 = num 16 | } 17 | } 18 | 19 | if max2*2 <= max1 { 20 | return idx 21 | } 22 | return -1 23 | } 24 | -------------------------------------------------------------------------------- /Hash/perm/0383.ransom-note 全排列 == 子排列.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/ransom-note 4 | 5 | // ❓ 从magazine组合成ransomNote 6 | 7 | func canConstruct(ransomNote string, magazine string) bool { 8 | chMpCnt := map[byte]int{} 9 | for i := range magazine { 10 | ch := magazine[i] 11 | chMpCnt[ch]++ 12 | } 13 | 14 | for i := range ransomNote { 15 | ch := ransomNote[i] 16 | if chMpCnt[ch] == 0 { 17 | return false 18 | } 19 | chMpCnt[ch]-- 20 | } 21 | return true 22 | } 23 | -------------------------------------------------------------------------------- /Hash/score/1796.second-largest-digit-in-a-string 字符串中第二大的数字.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/second-largest-digit-in-a-string 4 | 5 | func secondHighest(s string) int { 6 | var first, second = -1, -1 7 | for i := range s { 8 | if '0' <= s[i] && s[i] <= '9' { 9 | num := int(s[i] - '0') 10 | if first < num { 11 | second = first 12 | first = num 13 | } else if num < first && second < num { 14 | second = num 15 | } 16 | } 17 | } 18 | return second 19 | } 20 | -------------------------------------------------------------------------------- /Search/Offer 53 - I. 在排序数组中查找数字 I/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/zai-pai-xu-shu-zu-zhong-cha-zhao-shu-zi-lcof/ 4 | func search(nums []int, target int) int { 5 | return s(nums, target+1) - s(nums, target) 6 | } 7 | 8 | func s(nums []int, target int) int { 9 | l, r := 0, len(nums) 10 | for l < r { 11 | mid := l + (r-l)/2 12 | cur := nums[mid] 13 | if target <= cur { 14 | r = mid 15 | } else if cur < target { 16 | l = mid + 1 17 | } 18 | } 19 | return r 20 | } 21 | -------------------------------------------------------------------------------- /Sql/1398.customers-who-bought-products-a-and-b-but-not-c 买AB不买C/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customers-who-bought-products-a-and-b-but-not-c 2 | 3 | SELECT `c`.`customer_id`, 4 | `c`.`customer_name` 5 | FROM `orders` `o` 6 | LEFT JOIN `customers` `c` ON `o`.`customer_id` = `c`.`customer_id` 7 | GROUP BY `c`.`customer_id` 8 | HAVING SUM(`product_name` = 'A') * SUM(`product_name` = 'B') > 0 9 | AND SUM(`product_name` = 'C') = 0 10 | ORDER BY `c`.`customer_id` 11 | -------------------------------------------------------------------------------- /Tree/Deep First Search/ring/1490.clone-n-ary-tree 克隆 N 叉树/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/clone-n-ary-tree 4 | 5 | type Node struct { 6 | Val int 7 | Children []*Node 8 | } 9 | 10 | // ❓ 克隆 N 叉树 11 | 12 | func cloneTree(root *Node) *Node { 13 | if root == nil { 14 | return nil 15 | } 16 | 17 | var node = &Node{Val: root.Val} 18 | for _, child := range root.Children { 19 | node.Children = append(node.Children, cloneTree(child)) 20 | } 21 | return node 22 | } 23 | -------------------------------------------------------------------------------- /Hash/where/1119.remove-vowels-from-a-string 删去字符串中的元音.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/remove-vowels-from-a-string 4 | 5 | // ❓ 移除元音字符 6 | 7 | func removeVowels(str string) string { 8 | //strL := len(str) 9 | var strBuf []byte 10 | for i := range str { 11 | // 元音跳过 12 | if str[i] == 'a' || str[i] == 'e' || str[i] == 'i' || str[i] == 'o' || str[i] == 'u' { 13 | continue 14 | } else { 15 | strBuf = append(strBuf, str[i]) 16 | } 17 | } 18 | return string(strBuf) 19 | } 20 | -------------------------------------------------------------------------------- /Hash/where/1346.check-if-n-and-its-double-exist 是否存在两倍数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/check-if-n-and-its-double-exist 4 | 5 | // ❓ 是否存在两倍数 6 | 7 | func checkIfExist(arr []int) bool { 8 | numMpCnt := map[int]int{} 9 | for _, num := range arr { 10 | numMpCnt[num]++ 11 | } 12 | 13 | for num := range numMpCnt { 14 | if 0 < numMpCnt[num*2] { 15 | // 0的时候 0*2 = 0 16 | if num != 0 || 2 <= numMpCnt[num] { 17 | return true 18 | } 19 | } 20 | } 21 | return false 22 | } 23 | -------------------------------------------------------------------------------- /Math/0492.construct-the-rectangle 构造矩形/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/construct-the-rectangle 4 | 5 | func constructRectangle(area int) []int { 6 | if area == 1 { 7 | return []int{1, 1} 8 | } 9 | l, r := 1, area 10 | for l < r { 11 | mid := (l + r) >> 1 12 | cur := mid * mid 13 | if cur <= area { // sqrt 14 | l = mid + 1 15 | } else { 16 | r = mid 17 | } 18 | } 19 | 20 | l-- 21 | for 0 < area%l { 22 | l-- 23 | } 24 | return []int{area / l, l} 25 | } 26 | -------------------------------------------------------------------------------- /Sql/1459.rectangles-area 组合成矩形/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/rectangles-area 2 | 3 | 4 | SELECT `a`.`id` `p1`, 5 | `b`.`id` `p2`, 6 | ABS((`a`.`x_value` - `b`.`x_value`) * (`a`.`y_value` - `b`.`y_value`)) `area` 7 | FROM `points` `a` 8 | JOIN `points` `b` 9 | WHERE `a`.`id` < `b`.`id` 10 | HAVING `area` > 0 11 | ORDER BY `area` DESC, `p1`, `p2`; 12 | -------------------------------------------------------------------------------- /Stack/Cnt ✅ 0495.teemo-attacking 中毒时间统计/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/teemo-attacking 4 | 5 | func findPoisonedDuration(timeSeries []int, duration int) int { 6 | var cntMax int 7 | timeL := len(timeSeries) 8 | top := timeL - 1 9 | cntMax = timeL * duration // 最多中毒时间 10 | for i := top; 0 < i; i-- { 11 | cntCur := timeSeries[i] - timeSeries[i-1] // 差值 12 | if cntCur < duration { 13 | cntMax -= duration 14 | cntMax += cntCur 15 | } 16 | } 17 | return cntMax 18 | } 19 | -------------------------------------------------------------------------------- /Sql/1709.biggest-window-between-visits 日期缺失/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/biggest-window-between-visits 2 | 3 | 4 | SELECT `user_id`, MAX(`diff`) `biggest_window` 5 | FROM ( 6 | SELECT `user_id`, 7 | DATEDIFF( 8 | LEAD(`visit_date`, 1, '2021-01-01') OVER (PARTITION BY `user_id` ORDER BY `visit_date`), 9 | `visit_date` 10 | ) `diff` 11 | FROM `uservisits` 12 | ) `tmp` 13 | GROUP BY `user_id` 14 | 15 | -------------------------------------------------------------------------------- /Hash/perm/0242.valid-anagram 有效的异位词.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/valid-anagram 4 | 5 | // ❓ 有效的异位词 6 | 7 | func isAnagram(s string, t string) bool { 8 | if len(s) != len(t) { 9 | return false 10 | } 11 | chMpCnt := [26]int{} 12 | for i := range s { 13 | chMpCnt[s[i]-'a']++ 14 | chMpCnt[t[i]-'a']-- 15 | } 16 | 17 | for _, cnt := range chMpCnt { 18 | if cnt != 0 { 19 | return false 20 | } 21 | } 22 | return true 23 | } 24 | 25 | // ❌ 通过字母 code 总和 求差，比如 bc 与 ad 相等， 却不是异位词 26 | -------------------------------------------------------------------------------- /Matrix/(Order) 0074.search-a-2d-matrix 搜索二维矩阵/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/search-a-2d-matrix 4 | 5 | func searchMatrix(matrix [][]int, target int) bool { 6 | l1 := len(matrix) 7 | l2 := len(matrix[0]) 8 | l, r := 0, l1*l2 9 | for l < r { 10 | mid := l + (r-l)/2 11 | num := matrix[mid/l2][mid%l2] 12 | if num < target { 13 | l = mid + 1 14 | } else if target < num { 15 | r = mid 16 | } else if target == num { 17 | return true 18 | } 19 | } 20 | return false 21 | } 22 | -------------------------------------------------------------------------------- /Tree/TBT/0998.maximum-binary-tree-ii 最大二叉树 II 🎆/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-binary-tree-ii 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 最大二叉树 II 12 | // ⚠️ 因为添加在末端，添加的值一定在右子树 13 | 14 | func insertIntoMaxTree(root *TreeNode, val int) *TreeNode { 15 | if root == nil || root.Val < val { 16 | return &TreeNode{Left: root, Val: val} 17 | } 18 | root.Right = insertIntoMaxTree(root.Right, val) 19 | return root 20 | } 21 | -------------------------------------------------------------------------------- /Greedy/0011.container-with-most-watermain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/container-with-most-water 4 | 5 | func maxArea(height []int) int { 6 | var cur, max int 7 | lo, hi := 0, len(height)-1 8 | for lo < hi { 9 | dist := hi - lo 10 | if height[lo] < height[hi] { // TODO 以小的为隔板 11 | cur = height[lo] * dist 12 | lo++ 13 | } else { 14 | cur = height[hi] * dist 15 | hi-- 16 | } 17 | 18 | // TODO 贪心 19 | if max < cur { 20 | max = cur 21 | } 22 | } 23 | return max 24 | } 25 | -------------------------------------------------------------------------------- /Hash/inter/0350.intersection-of-two-arrays-ii 两数组 val 交集.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/intersection-of-two-arrays-ii 4 | 5 | // ❓ 两数组 val 交集 6 | 7 | func intersect(nums1 []int, nums2 []int) []int { 8 | numMpCnt := map[int]int{} 9 | for _, num := range nums1 { 10 | numMpCnt[num]++ 11 | } 12 | 13 | var numsInter []int 14 | for _, num := range nums2 { 15 | if 0 < numMpCnt[num] { 16 | numsInter = append(numsInter, num) 17 | numMpCnt[num]-- 18 | } 19 | } 20 | return numsInter 21 | } 22 | -------------------------------------------------------------------------------- /Math/1266.minimum-time-visiting-all-points/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | func minTimeToVisitAllPoints(points [][]int) int { 4 | var res int 5 | l := len(points) 6 | for i := 1; i < l; i++ { 7 | x := abs(points[i][0] - points[i-1][0]) 8 | y := abs(points[i][1] - points[i-1][1]) 9 | res += max(x, y) 10 | } 11 | return res 12 | } 13 | 14 | func abs(a int) int { 15 | if a < 0 { 16 | a = -a 17 | } 18 | return a 19 | } 20 | 21 | func max(a, b int) int { 22 | if a < b { 23 | return b 24 | } 25 | return a 26 | } 27 | -------------------------------------------------------------------------------- /NumberTheory/pow/0050.powx-n.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/powx-n 4 | 5 | // ❓ 实现 Pow(x, n) 6 | 7 | func myPow(num float64, pow int) float64 { 8 | var numRes float64 = 1 9 | // 负指数幂 10 | var minus bool 11 | if pow < 0 { 12 | minus = true 13 | pow = -pow 14 | } 15 | 16 | for 0 < pow { 17 | // 快速幂 18 | if pow&1 == 1 { 19 | numRes *= num 20 | } 21 | num *= num 22 | pow >>= 1 23 | } 24 | 25 | // 负数倒数 26 | if minus { 27 | return 1 / numRes 28 | } 29 | return numRes 30 | } 31 | -------------------------------------------------------------------------------- /Offer/剑指 Offer II 075. 数组相对排序/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/0H97ZC/ 4 | 5 | func relativeSortArray(arr1 []int, arr2 []int) []int { 6 | m := [1001]int{} 7 | for i := range arr1 { 8 | m[arr1[i]]++ 9 | } 10 | 11 | var res []int 12 | for i := range arr2 { 13 | for 0 < m[arr2[i]] { 14 | res = append(res, arr2[i]) 15 | m[arr2[i]]-- 16 | } 17 | } 18 | 19 | for i := range m { 20 | for 0 < m[i] { 21 | res = append(res, i) 22 | m[i]-- 23 | } 24 | } 25 | return res 26 | } 27 | -------------------------------------------------------------------------------- /Sql/1501.countries-you-can-safely-invest-in 通话时长高于平均/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/countries-you-can-safely-invest-in 2 | 3 | 4 | SELECT `country`.`name` `country` 5 | FROM `calls` 6 | JOIN 7 | `person` 8 | JOIN 9 | `country` 10 | WHERE (`calls`.`caller_id` = `id` OR `calls`.`callee_id` = `id`) 11 | AND `country`.`country_code` = LEFT(`person`.`phone_number`, 3) 12 | GROUP BY `country`.`country_code` 13 | HAVING AVG(`calls`.`duration`) > (SELECT AVG(`calls`.`duration`) FROM `calls`); 14 | -------------------------------------------------------------------------------- /Sql/1731.the-number-of-employees-which-report-to-each-employee 每位经理有多少下属/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/the-number-of-employees-which-report-to-each-employee 2 | 3 | SELECT `e1`.`reports_to` `employee_id`, 4 | `e2`.`name`, 5 | COUNT(`e1`.`reports_to`) `reports_count`, 6 | ROUND(AVG(`e1`.`age`)) `average_age` 7 | FROM `employees` `e1` 8 | JOIN `employees` `e2` ON `e1`.`reports_to` = `e2`.`employee_id` 9 | GROUP BY `e1`.`reports_to`, `e2`.`name` 10 | ORDER BY `e1`.`reports_to` -------------------------------------------------------------------------------- /TwoPointer/0080.remove-duplicates-from-sorted-array-ii 删除有序数组中的重复项 II/main.go: -------------------------------------------------------------------------------- 1 | package _080_remove_duplicates_from_sorted_array_ii_删除有序数组中的重复项_II 2 | 3 | // https://leetcode.cn/problems/remove-duplicates-from-sorted-array-ii 4 | 5 | func removeDuplicates(nums []int) int { 6 | l1 := len(nums) 7 | if l1 <= 2 { 8 | return l1 9 | } 10 | var slow, fast = 2, 2 11 | 12 | for fast < l1 { 13 | if nums[slow-2] != nums[fast] { 14 | nums[slow] = nums[fast] 15 | slow++ 16 | } 17 | fast++ 18 | } 19 | return slow 20 | } 21 | -------------------------------------------------------------------------------- /Greedy/0455.assign-cookiesmain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/assign-cookies 6 | 7 | func findContentChildren(greed, size []int) int { 8 | sort.Ints(greed) 9 | sort.Ints(size) 10 | var cnt int 11 | gL, sL := len(greed), len(size) 12 | for idxG, idxS := 0, 0; idxG < gL && idxS < sL; idxG++ { 13 | for idxS < sL && size[idxS] < greed[idxG] { 14 | idxS++ // TODO 贪心 15 | } 16 | if idxS < sL { // TODO 分配 17 | cnt++ 18 | idxS++ 19 | } 20 | } 21 | return cnt 22 | } 23 | -------------------------------------------------------------------------------- /Greedy/array/0045.jump-game-ii.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/jump-game-ii 4 | 5 | func jump(nums []int) int { 6 | var steps, idxCur, idxFar int 7 | top := len(nums) - 1 8 | for idx := 0; idx < top; idx++ { 9 | idxFar = max(idxFar, idx+nums[idx]) // TODO 最远 10 | if idxCur == idx { // TODO 必须跳跃,最后一次不需要跳跃 11 | idxCur = idxFar 12 | steps++ 13 | } 14 | } 15 | return steps 16 | } 17 | 18 | func max(x, y int) int { 19 | if x < y { 20 | return y 21 | } 22 | return x 23 | } 24 | -------------------------------------------------------------------------------- /Hash/perm/0409.longest-palindrome 最长回文串.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-palindrome 4 | 5 | // ❓ 能排列为最长的回文串 6 | 7 | func longestPalindrome(s string) int { 8 | chMpCnt := map[byte]int{} 9 | for i := range s { 10 | ch := s[i] - 'a' 11 | chMpCnt[ch]++ 12 | } 13 | 14 | var cntLongest = len(s) 15 | var odd = 0 16 | for _, cnt := range chMpCnt { 17 | if cnt%2 == 1 { 18 | odd++ 19 | } 20 | } 21 | 22 | if 0 < odd { 23 | return cntLongest - odd + 1 24 | } 25 | return cntLongest 26 | } 27 | -------------------------------------------------------------------------------- /Hash/score/1636.sort-array-by-increasing-frequency 按照频率将数组升序排序 🤚 权重.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/sort-array-by-increasing-frequency 6 | 7 | func frequencySort(nums []int) []int { 8 | m := map[int]int{} 9 | for i := range nums { 10 | m[nums[i]]++ 11 | } 12 | 13 | for i := range nums { 14 | nums[i] = 201*m[nums[i]] - nums[i] + 100 15 | } 16 | 17 | sort.Ints(nums) 18 | 19 | for i := range nums { 20 | nums[i] = -(nums[i] % 201) + 100 21 | } 22 | return nums 23 | } 24 | -------------------------------------------------------------------------------- /LinkedList/0160.intersection-of-two-linked-lists 相交起始点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/intersection-of-two-linked-lists 9 | 10 | func getIntersectionNode(headA, headB *ListNode) *ListNode { 11 | a, b := headA, headB 12 | for a != b { 13 | if a == nil { 14 | a = headB 15 | } else { 16 | a = a.Next 17 | } 18 | 19 | if b == nil { 20 | b = headA 21 | } else { 22 | b = b.Next 23 | } 24 | } 25 | return a 26 | } 27 | -------------------------------------------------------------------------------- /Sql/1193.monthly-transactions-i 统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/monthly-transactions-i 2 | 3 | 4 | SELECT DATE_FORMAT(`trans_date`, '%Y-%m') `month`, 5 | `country`, 6 | COUNT(*) `trans_count`, 7 | COUNT(IF(`state` = 'approved', 1, NULL)) `approved_count`, 8 | SUM(`amount`) `trans_total_amount`, 9 | SUM(IF(`state` = 'approved', `amount`, 0)) `approved_total_amount` 10 | FROM `transactions` 11 | GROUP BY `month`, `country` -------------------------------------------------------------------------------- /Tree/Deep First Search/ordinary/0965.univalued-binary-tree 单值二叉树/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/univalued-binary-tree/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 单值二叉树 12 | 13 | func isUnivalTree(root *TreeNode) bool { 14 | var num = root.Val 15 | var dfs func(node *TreeNode) bool 16 | dfs = func(node *TreeNode) bool { 17 | return node == nil || node.Val == num && dfs(node.Left) && dfs(node.Right) 18 | } 19 | return dfs(root) 20 | } 21 | -------------------------------------------------------------------------------- /Tree/Postorder/depth/0104.maximum-depth-of-binary-tree 二叉树的最大深度/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-depth-of-binary-tree/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 二叉树的最大深度 12 | 13 | func maxDepth(root *TreeNode) int { 14 | if root == nil { 15 | return 0 16 | } 17 | return max(maxDepth(root.Left), maxDepth(root.Right)) + 1 18 | } 19 | 20 | func max(a int, b int) int { 21 | if a < b { 22 | return b 23 | } 24 | return a 25 | } 26 | -------------------------------------------------------------------------------- /LinkedList/(Swap) 0024.swap-nodes-in-pairs 两两交换节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/swap-nodes-in-pairs 9 | 10 | func swapPairs(head *ListNode) *ListNode { 11 | zero := &ListNode{Next: head} 12 | prev := zero 13 | for head != nil && head.Next != nil { 14 | l := head 15 | r := head.Next 16 | 17 | prev.Next = r 18 | l.Next = r.Next 19 | r.Next = l 20 | 21 | prev = l 22 | head = prev.Next 23 | } 24 | return zero.Next 25 | } 26 | -------------------------------------------------------------------------------- /Matrix/0311.sparse-matrix-multiplication 稀疏矩阵的乘法/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/sparse-matrix-multiplication 4 | 5 | func multiply(mat1 [][]int, mat2 [][]int) [][]int { 6 | l1 := len(mat2) 7 | l2 := len(mat2[0]) 8 | 9 | var res = make([][]int, 0, len(mat1)) 10 | for i := range mat1 { 11 | for j := 0; j < l2; j++ { 12 | var cur int 13 | for k := 0; k < l1; k++ { 14 | cur += mat1[i][k] * mat2[k][j] // 行列相乘 后相加 15 | } 16 | res[i] = append(res[i], cur) 17 | } 18 | } 19 | return res 20 | } 21 | -------------------------------------------------------------------------------- /Trie/✅ 0386.lexicographical-numbers 字典序排数 DFS/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/lexicographical-numbers 4 | 5 | // ❓ 字典序排数 6 | // ⚠️ 乘以10进入下层 除以10返回上层 7 | 8 | func lexicalOrder(n int) []int { 9 | var numsOrder []int 10 | var dfs func(num int) 11 | dfs = func(num int) { 12 | if n < num { 13 | return 14 | } 15 | numsOrder = append(numsOrder, num) 16 | for i := 0; i < 10; i++ { 17 | dfs(num*10 + i) 18 | } 19 | } 20 | for i := 1; i < 10; i++ { 21 | dfs(i) 22 | } 23 | return numsOrder 24 | } 25 | -------------------------------------------------------------------------------- /Bit/subset/0078.subsets.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/subsets 4 | 5 | func subsets(nums []int) [][]int { 6 | var subsetNums [][]int 7 | numsL := len(nums) 8 | subsetMax := 1 << numsL 9 | for subset := 0; subset < subsetMax; subset++ { // 总共 0 ~ 1<>idx&1 == 1 { // used 13 | numsCur = append(numsCur, nums[idx]) 14 | } 15 | } 16 | subsetNums = append(subsetNums, numsCur) 17 | } 18 | return subsetNums 19 | } 20 | -------------------------------------------------------------------------------- /Hash/window/0246.strobogrammatic-number 中心对称数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/strobogrammatic-number 4 | 5 | // ❓ 中心对称数 6 | 7 | func isStrobogrammatic(num string) bool { 8 | chMpCh := map[byte]byte{'6': '9', '9': '6', '8': '8', '0': '0', '1': '1'} 9 | 10 | left, right := 0, len(num)-1 11 | for left <= right { 12 | chLeft := num[left] 13 | chRight := num[right] 14 | if chMpCh[chLeft] != chRight || chMpCh[chLeft] == 0 { 15 | return false 16 | } 17 | left++ 18 | right-- 19 | } 20 | return true 21 | } 22 | -------------------------------------------------------------------------------- /Sql/1241.number-of-comments-per-post 查询评论数/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/number-of-comments-per-post 2 | 3 | SELECT `post_id`, COUNT(`sub_id`) `number_of_comments` 4 | FROM ( 5 | SELECT DISTINCT `post`.`sub_id` `post_id`, `sub`.`sub_id` `sub_id` 6 | FROM `submissions` `post` 7 | LEFT JOIN `submissions` `sub` 8 | ON `post`.`sub_id` = `sub`.`parent_id` 9 | WHERE `post`.`parent_id` IS NULL 10 | ) `t` 11 | GROUP BY `post_id` 12 | ORDER BY `post_id` 13 | -------------------------------------------------------------------------------- /Stack/0020.valid-parentheses 有效(){}[]括号/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/valid-parentheses/ 4 | 5 | func isValid(s string) bool { 6 | m := map[rune]rune{ 7 | '{': '}', 8 | '[': ']', 9 | '(': ')', 10 | } 11 | var stack []rune 12 | for _, v := range s { 13 | if mirror, ok := m[v]; ok { 14 | stack = append(stack, mirror) 15 | } else if 0 < len(stack) && stack[len(stack)-1] == v { 16 | stack = stack[:len(stack)-1] 17 | } else { 18 | return false 19 | } 20 | } 21 | return len(stack) == 0 22 | } 23 | -------------------------------------------------------------------------------- /Tree/Binary Search Tree/0700.search-in-a-binary-search-tree 搜索/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/search-in-a-binary-search-tree/ 4 | 5 | // ❓ 二叉搜索树中的搜索 6 | 7 | type TreeNode struct { 8 | Val int 9 | Left *TreeNode 10 | Right *TreeNode 11 | } 12 | 13 | func searchBST(root *TreeNode, val int) *TreeNode { 14 | for root != nil { 15 | if val < root.Val { 16 | root = root.Left 17 | } else if root.Val < val { 18 | root = root.Right 19 | } else { 20 | return root 21 | } 22 | } 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /Hash/where/0359.logger-rate-limiter 相同消息截流.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/logger-rate-limiter 4 | 5 | // ❓相同消息截流 6 | 7 | type Logger struct { 8 | msgMpTime map[string]int 9 | } 10 | 11 | func Constructor() Logger { 12 | return Logger{msgMpTime: make(map[string]int)} 13 | } 14 | 15 | func (l *Logger) ShouldPrintMessage(timestamp int, message string) bool { 16 | // 还在截流期 17 | if timestamp < l.msgMpTime[message] { 18 | return false 19 | } 20 | // 10秒 21 | l.msgMpTime[message] = timestamp + 10 22 | return true 23 | } 24 | -------------------------------------------------------------------------------- /Sql/1767.find-the-subtasks-that-did-not-execute 找到未执行的子任务/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/find-the-subtasks-that-did-not-execute 2 | 3 | WITH RECURSIVE `t`(`task_id`, `subtask_id`) AS ( 4 | SELECT `task_id`, `subtasks_count` 5 | FROM `tasks` 6 | UNION ALL 7 | SELECT `task_id`, `subtask_id` - 1 8 | FROM `t` 9 | WHERE `subtask_id` - 1 > 0 10 | ) 11 | 12 | SELECT * 13 | FROM `t` 14 | LEFT JOIN `executed` USING (`task_id`, `subtask_id`) 15 | WHERE `executed`.`subtask_id` IS NULL 16 | ORDER BY `task_id`, `subtask_id` -------------------------------------------------------------------------------- /TwoPointer/1790.check-if-one-string-swap-can-make-strings-equal 仅执行一次字符串交换能否使两个字符串相等/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/check-if-one-string-swap-can-make-strings-equal 4 | 5 | func areAlmostEqual(s1 string, s2 string) bool { 6 | var first, second, flag byte 7 | for k := range s1 { 8 | if s2[k] != s1[k] { 9 | flag++ 10 | if first == 0 { 11 | first, second = s1[k], s2[k] 12 | } else if first != s2[k] || second != s1[k] || 2 < flag { 13 | return false 14 | } 15 | } 16 | } 17 | return flag != 1 18 | } 19 | -------------------------------------------------------------------------------- /DP/single (x)/2171.removing-minimum-number-of-magic-beans 拿出最少数目的魔法豆/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/removing-minimum-number-of-magic-beans 6 | 7 | // 📚 8 | func minimumRemoval(beans []int) int64 { 9 | beansL := len(beans) 10 | sort.Ints(beans) 11 | var preSum, numMax int 12 | for idx, num := range beans { 13 | preSum += num 14 | numCur := (beansL - idx) * num // 剩余豆子，idx~beansL 留下， 15 | if numMax < numCur { 16 | numMax = numCur 17 | } 18 | } 19 | return int64(preSum - numMax) 20 | } 21 | -------------------------------------------------------------------------------- /Sql/0550.game-play-analysis-iv 首日后隔天登录玩家的比率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/game-play-analysis-iv 2 | 3 | SELECT ROUND( 4 | COUNT(`a2`.`player_id`) / COUNT(`a1`.`player_id`), 5 | 2) `fraction` 6 | FROM ( 7 | SELECT `player_id`, MIN(`event_date`) `event_date` 8 | FROM `activity` 9 | GROUP BY `player_id`) `a1` 10 | LEFT JOIN `activity` `a2` 11 | ON `a1`.`player_id` = `a2`.`player_id` 12 | AND DATEDIFF(`a2`.`event_date`, `a1`.`event_date`) = 1; -------------------------------------------------------------------------------- /Sql/0614.second-degree-follower 二级关注者/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/second-degree-follower 2 | 3 | SELECT `followee` `follower`, 4 | COUNT(DISTINCT `follower`) `num` 5 | FROM `follow` 6 | WHERE `followee` IN (SELECT `follower` FROM `follow`) 7 | GROUP BY `followee` 8 | ORDER BY `followee` 9 | 10 | 11 | 12 | SELECT `followee` `follower`, 13 | COUNT(DISTINCT `follower`) `num` 14 | FROM `follow` 15 | WHERE `followee` IN (SELECT `follower` FROM `follow`) 16 | GROUP BY `followee` 17 | ORDER BY `followee` -------------------------------------------------------------------------------- /Sql/1511.customer-order-frequency 六七月消费大于等于100/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/customer-order-frequency 2 | 3 | SELECT `c`.`customer_id`, `c`.`name` 4 | FROM `customers` `c` 5 | JOIN `orders` `o` ON `o`.`customer_id` = `c`.`customer_id` 6 | JOIN `product` `p` ON `p`.`product_id` = `o`.`product_id` 7 | GROUP BY `c`.`customer_id`, `c`.`name` 8 | HAVING SUM(IF(LEFT(`o`.`order_date`, 7) = '2020-06', `p`.`price` * `o`.`quantity`, 0)) >= 100 9 | AND SUM(IF(LEFT(`o`.`order_date`, 7) = '2020-07', `p`.`price` * `o`.`quantity`, 0)) >= 100; -------------------------------------------------------------------------------- /Sql/1677.products-worth-over-invoices 统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/products-worth-over-invoices 2 | 3 | SELECT `p`.`name` `name`, 4 | IFNULL(SUM(`i`.`rest`), 0) `rest`, 5 | IFNULL(SUM(`i`.`paid`), 0) `paid`, 6 | IFNULL(SUM(`i`.`canceled`), 0) `canceled`, 7 | IFNULL(SUM(`i`.`refunded`), 0) `refunded` 8 | FROM `product` `p` 9 | LEFT JOIN `invoice` `i` 10 | ON `p`.`product_id` = `i`.`product_id` 11 | GROUP BY `p`.`product_id` 12 | ORDER BY `p`.`name` -------------------------------------------------------------------------------- /Stack/1475.final-prices-with-a-special-discount-in-a-shopmain.go: -------------------------------------------------------------------------------- 1 | package Stack 2 | 3 | // https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop 4 | 5 | func finalPrices(prices []int) []int { 6 | pL := len(prices) 7 | nums := make([]int, pL) 8 | stack := []int{0} 9 | for idx := pL - 1; 0 <= idx; idx-- { 10 | p := prices[idx] 11 | for 1 < len(stack) && p < stack[len(stack)-1] { 12 | stack = stack[:len(stack)-1] 13 | } 14 | nums[idx] = p - stack[len(stack)-1] 15 | stack = append(stack, p) 16 | } 17 | return nums 18 | } 19 | -------------------------------------------------------------------------------- /Greedy/string/0678.valid-parenthesis-string.go: -------------------------------------------------------------------------------- 1 | package string 2 | 3 | // https://leetcode.cn/problems/valid-parenthesis-string 4 | 5 | func checkValidString(s string) bool { 6 | min, max := 0, 0 7 | for _, ch := range s { 8 | if ch == '(' { 9 | min++ 10 | max++ 11 | } else if ch == ')' { 12 | if 0 < min { 13 | min-- 14 | } 15 | max-- 16 | if max < 0 { 17 | return false 18 | } 19 | // TODO 贪心 20 | } else if ch == '*' { 21 | if 0 < min { 22 | min-- 23 | } 24 | max++ 25 | } 26 | } 27 | return min == 0 28 | } 29 | -------------------------------------------------------------------------------- /Hash/inter/0349.intersection-of-two-arrays 两数组 val 交集 & 取唯一.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/intersection-of-two-arrays 4 | 5 | // ❓ 相对交集 val 取唯一值 6 | 7 | func intersection(nums1 []int, nums2 []int) []int { 8 | var numMp = map[int]struct{}{} 9 | for _, num := range nums1 { 10 | numMp[num] = struct{}{} 11 | } 12 | 13 | var numsInter []int 14 | for _, num := range nums2 { 15 | _, ok := numMp[num] 16 | if ok { 17 | numsInter = append(numsInter, num) 18 | delete(numMp, num) 19 | } 20 | } 21 | return numsInter 22 | } 23 | -------------------------------------------------------------------------------- /Sql/1132.reported-posts-ii 垃圾清除率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/reported-posts-ii 2 | 3 | SELECT ROUND(AVG(`proportion`) * 100, 2) `average_daily_percent` 4 | FROM ( 5 | SELECT `a`.`action_date`, 6 | COUNT(DISTINCT `r`.`post_id`) / COUNT(DISTINCT `a`.`post_id`) `proportion` 7 | FROM `actions` `a` 8 | LEFT JOIN `removals` `r` 9 | ON `a`.`post_id` = `r`.`post_id` 10 | WHERE `extra` = 'spam' 11 | GROUP BY `a`.`action_date` 12 | ) `a`; 13 | -------------------------------------------------------------------------------- /Enum/2178.maximum-split-of-positive-even-integers 拆分成最多数目的偶整数之和/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-split-of-positive-even-integers 4 | 5 | // ❓ 拆分成最多数目的偶整数之和 6 | 7 | func maximumEvenSplit(n int64) []int64 { 8 | var nums []int64 9 | if n%2 == 1 { 10 | return nil 11 | } 12 | nums = append(nums, 2) 13 | n -= 2 14 | for 0 < n { 15 | top := len(nums) - 1 16 | if n <= nums[top] { 17 | nums[top] += n 18 | return nums 19 | } 20 | nums = append(nums, nums[top]+2) 21 | n -= nums[top+1] 22 | } 23 | return nums 24 | } 25 | -------------------------------------------------------------------------------- /Enum/✅ 2022.convert-1d-array-into-2d-array/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/convert-1d-array-into-2d-array 4 | 5 | func construct2DArray(original []int, m int, n int) [][]int { 6 | oriL := len(original) 7 | if m*n != oriL { 8 | return nil 9 | } 10 | var groupsNums = make([][]int, m) 11 | for i := range groupsNums { 12 | groupsNums[i] = make([]int, n) 13 | } 14 | for idx, num := range original { 15 | idxGroup := idx / n 16 | idxNum := idx % n 17 | groupsNums[idxGroup][idxNum] = num 18 | } 19 | return groupsNums 20 | } 21 | -------------------------------------------------------------------------------- /Graph/LCP.07. 传递信息/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/chuan-di-xin-xi/ 4 | 5 | func numWays(n int, relation [][]int, k int) int { 6 | graph := make([][]int, n) 7 | for _, v := range relation { 8 | graph[v[0]] = append(graph[v[0]], v[1]) 9 | } 10 | 11 | var res int 12 | var dfs func(x, step int) 13 | dfs = func(x, step int) { 14 | if k == step { 15 | if x == n-1 { 16 | res++ 17 | } 18 | return 19 | } 20 | for _, v := range graph[x] { 21 | dfs(v, step+1) 22 | } 23 | } 24 | dfs(0, 0) 25 | return res 26 | } 27 | -------------------------------------------------------------------------------- /LinkedList/0086.partition-list 小于X的靠左/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/partition-list 9 | 10 | func partition(head *ListNode, x int) *ListNode { 11 | l, r := &ListNode{}, &ListNode{} 12 | lh, rh := l, r 13 | for head != nil { 14 | if head.Val < x { 15 | l.Next = head 16 | l = l.Next 17 | } else { 18 | r.Next = head 19 | r = r.Next 20 | } 21 | head = head.Next 22 | } 23 | 24 | r.Next = nil 25 | l.Next = rh.Next 26 | return lh.Next 27 | } 28 | -------------------------------------------------------------------------------- /Tree/Catalan/0096.unique-binary-search-trees 不同的二叉搜索树 ❌/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/unique-binary-search-trees/ 4 | 5 | // ❓ 不同的二叉搜索树 6 | 7 | func numTrees(n int) int { 8 | catalan := 1 9 | for i := 0; i < n; i++ { 10 | catalan = catalan * 2 * (2*i + 1) / (i + 2) 11 | } 12 | return catalan 13 | } 14 | 15 | func numTrees_DP(n int) int { 16 | f := make([]int, n+1) 17 | f[0], f[1] = 1, 1 18 | for i := 2; i <= n; i++ { 19 | for j := 1; j <= i; j++ { 20 | f[i] += f[j-1] * f[i-j] 21 | } 22 | } 23 | return f[n] 24 | } 25 | -------------------------------------------------------------------------------- /Tree/Deep First Search/ordinary/0617.merge-two-binary-trees 合并二叉树/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/merge-two-binary-trees/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 合并二叉树 12 | 13 | func mergeTrees(r1 *TreeNode, r2 *TreeNode) *TreeNode { 14 | if r1 == nil { 15 | return r2 16 | } else if r2 == nil { 17 | return r1 18 | } 19 | r1.Val = r1.Val + r2.Val 20 | r1.Left = mergeTrees(r1.Left, r2.Left) 21 | r1.Right = mergeTrees(r1.Right, r2.Right) 22 | return r1 23 | } 24 | -------------------------------------------------------------------------------- /Tree/Postorder/ordinary/0814.binary-tree-pruning 二叉树剪枝/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/binary-tree-pruning/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 二叉树剪枝 12 | // ⚠️ 逐渐移除叶节点0 13 | 14 | func pruneTree(root *TreeNode) *TreeNode { 15 | if root == nil { 16 | return nil 17 | } 18 | root.Left = pruneTree(root.Left) 19 | root.Right = pruneTree(root.Right) 20 | if root.Left == nil && root.Right == nil && root.Val == 0 { 21 | return nil 22 | } 23 | return root 24 | } 25 | -------------------------------------------------------------------------------- /Enum/0125.valid-palindrome 验证回文串/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/valid-palindrome 4 | 5 | func isPalindrome(s string) bool { 6 | l1 := len(s) 7 | b := make([]byte, 0, l1) 8 | for i := 0; i < l1; i++ { 9 | ch := s[i] 10 | if 'a' <= ch && ch <= 'z' || '0' <= ch && ch <= '9' { 11 | b = append(b, ch) 12 | } else if 'A' <= ch && ch <= 'Z' { 13 | b = append(b, ch+32) 14 | } 15 | } 16 | 17 | l2 := len(b) 18 | for i := 0; i < l2/2; i++ { 19 | if b[i] != b[l2-i-1] { 20 | return false 21 | } 22 | } 23 | return true 24 | } 25 | -------------------------------------------------------------------------------- /Hash/state/0442.find-all-duplicates-in-an-array 数组中 重复的数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-all-duplicates-in-an-array 4 | 5 | // ❓ 找出 1 <= nums[i] <= numsL 数组中出现2次的元素 6 | 7 | func findDuplicates(nums []int) []int { 8 | numsL := len(nums) + 1 9 | var numsDuplicate []int 10 | for _, num := range nums { 11 | // 索引位置 12 | idx := (num - 1) % numsL 13 | if nums[idx]/numsL == 1 { 14 | // 已出现过 15 | numsDuplicate = append(numsDuplicate, idx+1) 16 | } 17 | nums[idx] += numsL // 标记 min = n + 1 18 | } 19 | return numsDuplicate 20 | } 21 | -------------------------------------------------------------------------------- /LinkedList/0083.remove-duplicates-from-sorted-list 删除重复多余元素/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/remove-duplicates-from-sorted-list 9 | 10 | func deleteDuplicates(head *ListNode) *ListNode { 11 | zero := &ListNode{Next: head} 12 | cur := zero 13 | for cur.Next != nil && cur.Next.Next != nil { 14 | if cur.Next.Val == cur.Next.Next.Val { // 出现相同 15 | cur.Next = cur.Next.Next // 去掉前一个 16 | } else { 17 | cur = cur.Next 18 | } 19 | } 20 | return zero.Next 21 | } 22 | -------------------------------------------------------------------------------- /Search/1894.find-the-student-that-will-replace-the-chalk 找到需要补充粉笔的学生编号/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-the-student-that-will-replace-the-chalk 4 | 5 | func chalkReplacer(chalk []int, k int) int { 6 | r := len(chalk) 7 | for i := 1; i < r; i++ { 8 | chalk[i] += chalk[i-1] 9 | } 10 | 11 | k %= chalk[r-1] 12 | k += 1 13 | var l = 0 14 | var mid int 15 | for l < r { 16 | mid = l + (r-l)/2 17 | if chalk[mid] < k { 18 | l = mid + 1 19 | } else if k <= chalk[mid] { 20 | r = mid - 1 21 | } 22 | } 23 | return l 24 | } 25 | -------------------------------------------------------------------------------- /TwoPointer/0524.longest-word-in-dictionary-through-deleting 通过删除字母匹配到字典里最长单词/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-word-in-dictionary-through-deleting 4 | 5 | func findLongestWord(s string, dictionary []string) string { 6 | var res string 7 | for _, d := range dictionary { 8 | i := 0 9 | for j := range s { 10 | if d[i] == s[j] { 11 | i++ 12 | if i == len(d) { 13 | if len(res) < i || len(res) == i && d < res { 14 | res = d 15 | } 16 | break 17 | } 18 | } 19 | } 20 | } 21 | return res 22 | } 23 | -------------------------------------------------------------------------------- /Array/6158.shifting-letters-iimain.go: -------------------------------------------------------------------------------- 1 | package Array 2 | 3 | // https://leetcode.cn/problems/shifting-letters-ii 4 | 5 | func shiftingLetters(s string, shifts [][]int) string { 6 | sL := len(s) 7 | diff := make([]int, sL+1) 8 | for _, shift := range shifts { 9 | shift[2] = shift[2]<<1 - 1 10 | diff[shift[0]] += shift[2] 11 | diff[shift[1]+1] -= shift[2] 12 | } 13 | 14 | buf := []byte(s) 15 | var offset int 16 | for i := range buf { 17 | offset = (diff[i]+offset)%26 + 26 18 | buf[i] = (buf[i]-'a'+byte(offset))%26 + 'a' 19 | } 20 | return string(buf) 21 | } 22 | -------------------------------------------------------------------------------- /BinarySearch/rotate/0154.find-minimum-in-rotated-sorted-array-iiII.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-minimum-in-rotated-sorted-array-ii 4 | 5 | func findMin(nums []int) int { 6 | lo, hi := 0, len(nums)-1 7 | for lo < hi { 8 | mid := int(uint(lo+hi) >> 1) 9 | if nums[hi] < nums[mid] { 10 | // lo ~ mid 是旋转序列，旋转肯定偏大 11 | lo = mid + 1 12 | } else if nums[mid] < nums[hi] { 13 | // mid ~ hi 是正常序列 14 | hi = mid 15 | } else if nums[hi] == nums[mid] { 16 | // 重复元素处理 3 3 1 3 17 | hi-- 18 | } 19 | } 20 | return nums[lo] 21 | } 22 | -------------------------------------------------------------------------------- /DP/single (x)/incr/5881.maximum-difference-between-increasing-elements 增量元素之间的最大差值/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-difference-between-increasing-elements 4 | 5 | func maximumDifference(nums []int) int { 6 | min := nums[0] 7 | numsL := len(nums) 8 | var numDiffMax = -1 9 | for i := 1; i < numsL; i++ { 10 | if nums[i] < min { 11 | min = nums[i] 12 | } else if min < nums[i] { 13 | numDiff := nums[i] - min 14 | if numDiffMax < numDiff { 15 | numDiffMax = numDiff 16 | } 17 | } 18 | } 19 | return numDiffMax 20 | } 21 | -------------------------------------------------------------------------------- /Design/1656.design-an-ordered-stream 设计有序流/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/design-an-ordered-stream 4 | 5 | type OrderedStream struct { 6 | m []string 7 | ptr int 8 | } 9 | 10 | func Constructor(n int) OrderedStream { 11 | return OrderedStream{ 12 | m: make([]string, n+1), 13 | } 14 | } 15 | 16 | func (os *OrderedStream) Insert(idKey int, value string) []string { 17 | os.m[idKey-1] = value 18 | var res []string 19 | for os.m[os.ptr] != "" { 20 | res = append(res, os.m[os.ptr]) 21 | os.ptr++ 22 | } 23 | 24 | return res 25 | } 26 | -------------------------------------------------------------------------------- /Hash/comb/0930.binary-subarrays-with-sum 和为 goal 的二元子数组.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/binary-subarrays-with-sum 4 | 5 | // ❓ 和为 goal 的二元子数组 6 | // ⚠️ 1 0 0 1 0 0 0 0 1 0 0 0 1 7 | // 0 1 1 1 2 2 2 2 2 3 3 3 3 4 8 | 9 | func numSubarraysWithSum(nums []int, goal int) int { 10 | var cnt, sum int 11 | sumMpCnt := map[int]int{} 12 | for _, num := range nums { 13 | sumMpCnt[sum]++ // 0 14 | sum += num 15 | // 实际在寻找前置零的个数，cnt = N（前置零） + 1（自身） 16 | cnt += sumMpCnt[sum-goal] // 前缀和 sum[j] - goal = sum[i] 只包含自身的组合 17 | } 18 | return cnt 19 | } 20 | -------------------------------------------------------------------------------- /Hash/perm/0447.number-of-boomerangs 回旋镖的数量.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/number-of-boomerangs 4 | 5 | func numberOfBoomerangs(points [][]int) int { 6 | var cntRes int 7 | for _, p := range points { 8 | distMpCnt := map[int]int{} 9 | for _, q := range points { 10 | // p 到 q 的距离 11 | dist := (p[0]-q[0])*(p[0]-q[0]) + (p[1]-q[1])*(p[1]-q[1]) 12 | cntRes += distMpCnt[dist] * 2 13 | distMpCnt[dist]++ 14 | } 15 | 16 | //for _, cnt := range distMpCnt { 17 | // cntRes += cnt * (cnt - 1) 18 | //} 19 | } 20 | return cntRes 21 | } 22 | -------------------------------------------------------------------------------- /Stack/0946.validate-stack-sequences 验证栈序列/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/validate-stack-sequences 4 | 5 | // pushed = [1,2,3,4,5], popped = [4,5,3,2,1] 6 | func validateStackSequences(pushed []int, popped []int) bool { 7 | stack := []int{} 8 | 9 | c := 0 // popped 计数器 10 | for i := range pushed { 11 | stack = append(stack, pushed[i]) // 一直进栈 12 | for 0 < len(stack) && stack[len(stack)-1] == popped[c] { // 相等就出栈 13 | c++ 14 | stack = stack[:len(stack)-1] 15 | } 16 | } 17 | return c == len(pushed) 18 | } 19 | -------------------------------------------------------------------------------- /0672.bulb-switcher-iimain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/bulb-switcher-ii 4 | 5 | func flipLights(n int, presses int) int { 6 | if presses == 0 { 7 | return 1 8 | } 9 | if n == 1 { 10 | return 2 11 | } 12 | if n == 2 { 13 | if presses == 1 { // 00 01 10 10 14 | return 3 15 | } else { 16 | return 4 17 | } 18 | } 19 | // 3 <= n 20 | if presses == 1 { // 000 010 101 100 21 | return 4 22 | } else if presses == 2 { // 010 101 100 000 110 001 111 23 | return 7 24 | } else { // 3 <= presses 011 25 | return 8 26 | } 27 | 28 | } 29 | -------------------------------------------------------------------------------- /Hash/state/0448.find-all-numbers-disappeared-in-an-array 等值数组中 消失的数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-all-numbers-disappeared-in-an-array 4 | 5 | // ❓ 等值数组中 消失的数 6 | 7 | func findDisappearedNumbers(nums []int) []int { 8 | var numsDis []int 9 | numsL := len(nums) 10 | for _, num := range nums { 11 | // 索引标记 12 | idx := (num - 1) % numsL 13 | nums[idx] += numsL 14 | } 15 | 16 | for num, numState := range nums { 17 | if numState <= numsL { 18 | // 代表数字不存在 19 | numsDis = append(numsDis, num+1) 20 | } 21 | } 22 | return numsDis 23 | } 24 | -------------------------------------------------------------------------------- /LinkedList/1721.swapping-nodes-in-a-linked-list 交换镜像节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/swapping-nodes-in-a-linked-list 9 | 10 | func swapNodes(head *ListNode, k int) *ListNode { 11 | var slow, fast, left = head, head, head 12 | for 1 < k { 13 | fast = fast.Next 14 | k-- 15 | } 16 | 17 | left = fast 18 | 19 | for fast.Next != nil { 20 | slow = slow.Next 21 | fast = fast.Next 22 | } 23 | 24 | left.Val, slow.Val = slow.Val, left.Val 25 | 26 | return head 27 | } 28 | -------------------------------------------------------------------------------- /Offer/面试题 17.10. 主要元素 (Moore 投票)/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/find-majority-element-lcci/ 4 | 5 | func majorityElement(nums []int) int { 6 | l1 := len(nums) 7 | candidate := -1 8 | cnt := 0 9 | for _, num := range nums { 10 | if cnt == 0 { 11 | candidate = num 12 | } 13 | if num == candidate { 14 | cnt++ 15 | } else { 16 | cnt-- 17 | } 18 | } 19 | cnt = 0 20 | for _, num := range nums { 21 | if num == candidate { 22 | cnt++ 23 | } 24 | } 25 | if l1 < cnt*2 { 26 | return candidate 27 | } 28 | return -1 29 | } 30 | -------------------------------------------------------------------------------- /Tree/Postorder/depth/0559.maximum-depth-of-n-ary-tree N 叉树的最大深度/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-depth-of-n-ary-tree/ 4 | 5 | type Node struct { 6 | Val int 7 | Children []*Node 8 | } 9 | 10 | // ❓ N 叉树的最大深度 11 | 12 | func maxDepth(root *Node) int { 13 | if root == nil { 14 | return 0 15 | } 16 | var dep int 17 | for _, child := range root.Children { 18 | dep = max(dep, maxDepth(child)) 19 | } 20 | 21 | return dep + 1 22 | } 23 | 24 | func max(a, b int) int { 25 | if a < b { 26 | return b 27 | } 28 | return a 29 | } 30 | -------------------------------------------------------------------------------- /DP/single (x)/pre/0525.contiguous-array 连续数组/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/contiguous-array 4 | 5 | func findMaxLength(nums []int) int { 6 | cntMpIdx := map[int]int{0: -1} 7 | var cnt, distMax int 8 | for i, num := range nums { 9 | if num == 1 { 10 | cnt++ 11 | } else { 12 | cnt-- 13 | } 14 | // 前缀溢出1的个数 15 | 16 | idx, ok := cntMpIdx[cnt] 17 | if ok { 18 | distCur := i - idx 19 | if distMax < distCur { 20 | distMax = distCur 21 | } 22 | } else { 23 | cntMpIdx[cnt] = i 24 | } 25 | } 26 | return distMax 27 | } 28 | -------------------------------------------------------------------------------- /DP/string/single/0005.longest-palindromic-substring 最长回文 Press/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-palindromic-substring 4 | 5 | // f[l][r] = f[l+1][r-1] 6 | 7 | // ❓ 最长回文 8 | // ⚠️ 压缩外循环 9 | 10 | func longestPalindrome(s string) string { 11 | sL := len(s) 12 | f := make([]bool, sL) 13 | 14 | var lo, hi int 15 | for r := 0; r < sL; r++ { 16 | for l := 0; l < r; l++ { 17 | f[l] = s[l] == s[r] && (r-l <= 2 || f[l+1]) 18 | if f[l] && hi-lo < r-l { 19 | hi = r 20 | lo = l 21 | } 22 | } 23 | } 24 | return s[lo : hi+1] 25 | } 26 | -------------------------------------------------------------------------------- /Greedy/array/0134.gas-station.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/gas-station 4 | 5 | func canCompleteCircuit(gas []int, cost []int) int { 6 | gasL := len(gas) 7 | idx := 0 8 | for idx < gasL { 9 | var steps = 0 10 | var cnt = 0 11 | for steps < gasL { 12 | idxCur := (idx + steps) % gasL // TODO 环 13 | cnt += gas[idxCur] - cost[idxCur] // 油量 14 | if cnt < 0 { 15 | break 16 | } 17 | steps++ 18 | } 19 | 20 | if steps == gasL { 21 | return idx 22 | } 23 | 24 | // TODO 剪枝 25 | idx += steps + 1 26 | } 27 | return -1 28 | } 29 | -------------------------------------------------------------------------------- /Hash/mirror/0205.isomorphic-strings 同构字符串.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/isomorphic-strings 4 | 5 | // ❓ 同构字符串 6 | 7 | func isIsomorphic(s string, t string) bool { 8 | // 双向绑定 9 | ch1MpCh2 := map[byte]byte{} 10 | ch2MpCh1 := map[byte]byte{} 11 | sL := len(s) 12 | for i := 0; i < sL; i++ { 13 | ch1 := s[i] 14 | ch2 := t[i] 15 | 16 | if ch1MpCh2[ch1] != 0 && ch1MpCh2[ch1] != ch2 || ch2MpCh1[ch2] != 0 && ch2MpCh1[ch2] != ch1 { 17 | return false 18 | } 19 | ch1MpCh2[ch1] = ch2 20 | ch2MpCh1[ch2] = ch1 21 | } 22 | 23 | return true 24 | } 25 | -------------------------------------------------------------------------------- /Tree/Preorder/origin/0589.n-ary-tree-preorder-traversal N 叉树的前序遍历/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/n-ary-tree-preorder-traversal/ 4 | 5 | type Node struct { 6 | Val int 7 | Children []*Node 8 | } 9 | 10 | // ❓ N 叉树的前序遍历 11 | 12 | func preorder(root *Node) []int { 13 | var nums []int 14 | var dfs func(node *Node) 15 | dfs = func(node *Node) { 16 | if node == nil { 17 | return 18 | } 19 | nums = append(nums, node.Val) 20 | for _, child := range node.Children { 21 | dfs(child) 22 | } 23 | } 24 | dfs(root) 25 | return nums 26 | } 27 | -------------------------------------------------------------------------------- /Bit/base/0405.convert-a-number-to-hexadecimal.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/convert-a-number-to-hexadecimal 4 | 5 | func toHex(num int) string { 6 | if num == 0 { 7 | return "0" 8 | } 9 | var buf []byte 10 | for idx := 28; 0 <= idx; idx -= 4 { 11 | numHex := byte(num >> idx & 0xf) // TODO 取有效位 12 | if numHex == 0 && len(buf) == 0 { // TODO 为0忽略 13 | continue 14 | } 15 | if numHex <= 9 { 16 | buf = append(buf, numHex+'0') 17 | } else if 10 <= numHex { 18 | buf = append(buf, numHex+'a'-10) 19 | } 20 | } 21 | return string(buf) 22 | } 23 | -------------------------------------------------------------------------------- /DP/bit/0526.beautiful-arrangementmain.go: -------------------------------------------------------------------------------- 1 | package bit 2 | 3 | import "math/bits" 4 | 5 | // https://leetcode.cn/problems/beautiful-arrangement 6 | 7 | func countArrangement(n int) int { 8 | f := make([]int, 1<>(idx-1)&1 == 0 { 15 | continue 16 | } 17 | if num%idx != 0 && idx%num != 0 { 18 | continue 19 | } 20 | f[subset] += f[subset^1<<(idx-1)] // TODO 21 | } 22 | } 23 | return f[1<= 25, 'Hot', 'Warm')) `weather_type` 6 | FROM ( 7 | SELECT `country_name`, 8 | AVG(`weather_state`) `weather_state_avg` 9 | FROM `countries` `c` 10 | JOIN `weather` `w` 11 | ON `c`.`country_id` = `w`.`country_id` 12 | WHERE LEFT(`day`, 7) = '2019-11' 13 | GROUP BY `country_name`) `t` -------------------------------------------------------------------------------- /Stack/0456.132-pattern 132模式/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/132-pattern 4 | 5 | // 3,1,4,2 6 | // i j k i最大 k次大 7 | func find132pattern(nums []int) bool { 8 | var stack []int 9 | var k = -1 << 63 10 | var i = len(nums) - 1 11 | for -1 < i { 12 | if nums[i] < k { // 小于上次 pop的值 13 | return true 14 | } 15 | top := len(stack) - 1 16 | for -1 < top && stack[top] < nums[i] { // 递减栈 栈顶 = j 上一次 pop = k 17 | k = stack[top] 18 | stack = stack[:top] 19 | top-- 20 | } 21 | stack = append(stack, nums[i]) // 栈顶j 必比 k 大 22 | i-- 23 | } 24 | return false 25 | } 26 | -------------------------------------------------------------------------------- /Hash/comb/1128.number-of-equivalent-domino-pairs 组合相同的总数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/number-of-equivalent-domino-pairs 4 | 5 | // ❓ 组合相同的数量 6 | // ⚠️ 一个组只有2个数字 7 | 8 | func numEquivDominoPairs(d [][]int) int { 9 | combMpCnt := map[int]int{} 10 | var cntEquiv int 11 | for i := range d { 12 | if d[i][0] < d[i][1] { 13 | d[i][0], d[i][1] = d[i][1], d[i][0] 14 | } 15 | comb := d[i][0]*10 + d[i][1] 16 | //cnt += combMpCnt[comb] 17 | combMpCnt[comb]++ 18 | } 19 | 20 | for _, cnt := range combMpCnt { 21 | cntEquiv += cnt * (cnt - 1) / 2 22 | } 23 | return cntEquiv 24 | } 25 | -------------------------------------------------------------------------------- /Hash/perm/0128.longest-consecutive-sequence 最长递增.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-consecutive-sequence 4 | 5 | // ❓ 最长递增序列 6 | 7 | func longestConsecutive(nums []int) int { 8 | numMpBool := map[int]bool{} 9 | for _, num := range nums { 10 | numMpBool[num] = true 11 | } 12 | 13 | var cntLongest int 14 | for num := range numMpBool { 15 | if !numMpBool[num-1] { 16 | cnt := 1 17 | num += 1 18 | for numMpBool[num] { 19 | num++ 20 | cnt++ 21 | } 22 | if cntLongest < cnt { 23 | cntLongest = cnt 24 | } 25 | } 26 | } 27 | return cntLongest 28 | } 29 | -------------------------------------------------------------------------------- /Sql/0601.human-traffic-of-stadium 人流量/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/human-traffic-of-stadium 2 | 3 | WITH `countt` AS (SELECT `id`, 4 | COUNT(*) OVER (PARTITION BY `rn` ORDER BY `rn` ) `counter` 5 | FROM (SELECT `id`, 6 | `id` - ROW_NUMBER() OVER (ORDER BY `id`) `rn` 7 | FROM `stadium` 8 | WHERE `people` >= 100) `rowt`) 9 | SELECT `s`.* 10 | FROM `stadium` `s` 11 | JOIN `countt` ON 12 | `s`.`id` = `countt`.`id` 13 | WHERE `countt`.`counter` > 2 14 | ORDER BY `s`.`visit_date`; -------------------------------------------------------------------------------- /Sql/1264.page-recommendations 推荐朋友喜欢的页面/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/page-recommendations 2 | 3 | SELECT DISTINCT `page_id` `recommended_page` 4 | FROM `likes` 5 | WHERE `user_id` IN ( 6 | SELECT ( 7 | CASE 8 | WHEN `user1_id` = 1 THEN `user2_id` 9 | WHEN `user2_id` = 1 THEN `user1_id` 10 | END 11 | ) `user_id` 12 | FROM `friendship` 13 | WHERE `user1_id` = 1 14 | OR `user2_id` = 1 15 | ) 16 | AND `page_id` NOT IN ( 17 | SELECT `page_id` 18 | FROM `likes` 19 | WHERE `user_id` = 1 20 | ) -------------------------------------------------------------------------------- /Sql/1549.the-most-recent-orders-for-each-product 产品最新订单/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/the-most-recent-orders-for-each-product 2 | 3 | SELECT `product_name`, `p`.`product_id`, `order_id`, `order_date` 4 | FROM `products` `p` 5 | JOIN 6 | (SELECT `o`.`product_id`, 7 | `o`.`order_id`, 8 | `o`.`order_date`, 9 | RANK() OVER (PARTITION BY `o`.`product_id` ORDER BY `o`.`order_date` DESC) `r` 10 | FROM `orders` `o`) `t` ON `p`.`product_id` = `t`.`product_id` 11 | WHERE `r` = 1 12 | ORDER BY `p`.`product_name`, `p`.`product_id`, `t`.`order_id`; 13 | -------------------------------------------------------------------------------- /Hash/perm/1460.make-two-arrays-equal-by-reversing-sub-arrays 无限翻转子数组 使两个数组相等.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/make-two-arrays-equal-by-reversing-sub-arrays 4 | 5 | // ❓ 无限翻转子数组 使两个数组相等 6 | 7 | func canBeEqual(target []int, arr []int) bool { 8 | targetL := len(target) 9 | arrL := len(arr) 10 | if targetL != arrL { 11 | return false 12 | } 13 | numMpCnt := map[int]int{} 14 | for i := 0; i < targetL; i++ { 15 | numMpCnt[target[i]]++ 16 | numMpCnt[arr[i]]-- 17 | } 18 | 19 | for i := range numMpCnt { 20 | if numMpCnt[i] != 0 { 21 | return false 22 | } 23 | } 24 | return true 25 | } 26 | -------------------------------------------------------------------------------- /Math/0470.implement-rand10-using-rand7 用 Rand7() 实现 Rand10()/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "math/rand" 4 | 5 | // https://leetcode.cn/problems/implement-rand10-using-rand7 6 | 7 | func rand10() int { 8 | var sum int 9 | for { 10 | sum = (rand7()-1)*7 + rand7() 11 | if sum <= 40 { 12 | return sum%10 + 1 13 | } 14 | 15 | sum -= 40 16 | sum = (sum-1)*7 + rand7() 17 | if sum <= 60 { 18 | return sum%10 + 1 19 | } 20 | 21 | sum -= 60 22 | sum = (sum-1)*7 + rand7() 23 | if sum <= 20 { 24 | return sum%10 + 1 25 | } 26 | } 27 | } 28 | 29 | func rand7() int { 30 | return rand.Intn(7) 31 | } 32 | -------------------------------------------------------------------------------- /Sql/1097.game-play-analysis-v 第二天留存率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/game-play-analysis-v 2 | 3 | SELECT `first_day` `install_dt`, 4 | COUNT(DISTINCT `player_id`) `installs`, 5 | ROUND( 6 | (SUM(IF(DATEDIFF(`event_date`, `first_day`) = 1, 1, 0))) / (COUNT(DISTINCT `player_id`)), 2 7 | ) `day1_retention` 8 | FROM ( 9 | SELECT `player_id`, 10 | `event_date`, 11 | MIN(`event_date`) OVER (PARTITION BY `player_id`) `first_day` 12 | FROM `activity` 13 | ) `a` 14 | GROUP BY `first_day` 15 | -------------------------------------------------------------------------------- /Union/0056.merge-intervals 合并区间/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/merge-intervals 6 | 7 | func merge(intervals [][]int) [][]int { 8 | sort.Slice(intervals, func(i, j int) bool { 9 | return intervals[i][0] < intervals[j][0] 10 | }) 11 | var res [][]int 12 | var cur = intervals[0] 13 | for _, interval := range intervals[1:] { 14 | if interval[0] <= cur[1] { 15 | if cur[1] < interval[1] { 16 | cur[1] = interval[1] 17 | } 18 | } else { 19 | res = append(res, cur) 20 | cur = interval 21 | } 22 | } 23 | res = append(res, cur) 24 | return res 25 | } 26 | -------------------------------------------------------------------------------- /Bit/perm/0869.reordered-power-of-2.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/reordered-power-of-2 4 | 5 | func countDigits(numDec int) [10]int { 6 | // 统计总数 7 | var numMpCnt [10]int 8 | for 0 < numDec { 9 | numMpCnt[numDec%10]++ 10 | numDec /= 10 11 | } 12 | return numMpCnt 13 | } 14 | 15 | var vecMpBool = map[[10]int]bool{} 16 | 17 | func init() { 18 | for num := 1; num <= 1e9; num <<= 1 { 19 | // 2的幂 每数位的数字总数 vector 20 | vec := countDigits(num) 21 | vecMpBool[vec] = true 22 | } 23 | } 24 | 25 | func reorderedPowerOf2(n int) bool { 26 | vec := countDigits(n) 27 | return vecMpBool[vec] 28 | } 29 | -------------------------------------------------------------------------------- /DP/string/single/0005.longest-palindromic-substring 最长回文/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-palindromic-substring 4 | 5 | // f[l][r] = f[l+1][r-1] 6 | 7 | // ❓ 最长回文 8 | func longestPalindrome(s string) string { 9 | sL := len(s) 10 | f := make([][]bool, sL) 11 | for i := range f { 12 | f[i] = make([]bool, sL) 13 | } 14 | 15 | var lo, hi int 16 | for r := 0; r < sL; r++ { 17 | for l := 0; l < r; l++ { 18 | f[l][r] = s[l] == s[r] && (r-l <= 2 || f[l+1][r-1]) 19 | if f[l][r] && hi-lo < r-l { 20 | hi = r 21 | lo = l 22 | } 23 | } 24 | } 25 | return s[lo : hi+1] 26 | } 27 | -------------------------------------------------------------------------------- /Greedy/array/0334.increasing-triplet-subsequence.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/increasing-triplet-subsequence 4 | 5 | func increasingTriplet(nums []int) bool { 6 | numsL := len(nums) 7 | if numsL < 3 { 8 | return false 9 | } 10 | 11 | first, second := nums[0], 1<<31-1 12 | for i := 1; i < numsL; i++ { 13 | num := nums[i] 14 | if second < num { 15 | // TODO 比第二个大 构成 三元组 16 | return true 17 | } else if first < num { 18 | // TODO 比第一个大 构成 二元组 19 | second = num 20 | } else if num < first { 21 | // TODO 比第零个大 构成 一元组 22 | first = num 23 | } 24 | } 25 | return false 26 | } 27 | -------------------------------------------------------------------------------- /Hash/perm/1189.maximum-number-of-balloons 气球的最大数量.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/maximum-number-of-balloons 4 | 5 | // ❓ 气球的最大数量 6 | 7 | func maxNumberOfBalloons(text string) int { 8 | chMpCnt := map[byte]int{} 9 | for i := range text { 10 | chMpCnt[text[i]]++ 11 | } 12 | 13 | chMpCntBalloon := map[byte]int{ 14 | 'a': 1, 15 | 'b': 1, 16 | 'n': 1, 17 | 'o': 2, 18 | 'l': 2, 19 | } 20 | 21 | var cntMax = 1<<63 - 1 22 | for ch := range chMpCntBalloon { 23 | cnt := chMpCnt[ch] / chMpCntBalloon[ch] 24 | if cnt < cntMax { 25 | cntMax = cnt 26 | } 27 | } 28 | return cntMax 29 | } 30 | -------------------------------------------------------------------------------- /Hash/vector/0049.group-anagrams 字母异位词分组.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/group-anagrams 4 | 5 | // ❓ 异位词分组 6 | 7 | func groupAnagrams(strs []string) [][]string { 8 | vectorMpStrings := map[[26]int][]string{} 9 | for _, str := range strs { 10 | var vector [26]int 11 | for j := range str { 12 | ch := str[j] - 'a' 13 | vector[ch]++ 14 | } 15 | vectorMpStrings[vector] = append(vectorMpStrings[vector], str) 16 | } 17 | var vectorsStrings [][]string 18 | for _, strings := range vectorMpStrings { 19 | vectorsStrings = append(vectorsStrings, strings) 20 | } 21 | return vectorsStrings 22 | } 23 | -------------------------------------------------------------------------------- /Offer/面试题 16.15. 珠玑妙算/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/master-mind-lcci/ 4 | 5 | func masterMind(solution string, guess string) []int { 6 | var res = make([]int, 2) 7 | m := map[byte]int{} 8 | for i := range solution { 9 | if solution[i] == guess[i] { 10 | res[0]++ 11 | } else { 12 | m[solution[i]]++ 13 | m[guess[i]]-- 14 | } 15 | } 16 | var cnt int 17 | //for i := range m { 18 | // if 0 < m[i] { 19 | // cnt += m[i] 20 | // } 21 | //} 22 | 23 | for i := range m { 24 | if m[i] < 0 { 25 | cnt -= m[i] 26 | } 27 | } 28 | res[1] = 4 - cnt - res[0] 29 | return res 30 | } 31 | -------------------------------------------------------------------------------- /Sql/1341.movie-rating 评论数和评分数统计/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/movie-rating 2 | 3 | (SELECT `name` `results` 4 | FROM `users` `u` 5 | JOIN `movie_rating` `mr` 6 | ON `u`.`user_id` = `mr`.`user_id` 7 | GROUP BY `u`.`user_id` 8 | ORDER BY COUNT(*) DESC, `name` 9 | LIMIT 1) 10 | UNION 11 | (SELECT `title` `results` 12 | FROM `movies` `m` 13 | JOIN `movie_rating` `mr` 14 | ON `m`.`movie_id` = `mr`.`movie_id` 15 | WHERE LEFT(`created_at`, 7) = '2020-02' 16 | GROUP BY `m`.`movie_id` 17 | ORDER BY AVG(`rating`) DESC, `title` 18 | LIMIT 1); -------------------------------------------------------------------------------- /Tree/TBT/1560.most-visited-sector-in-a-circular-track 二叉树的最近公共祖先 III/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-tree-iii/ 4 | 5 | type Node struct { 6 | Val int 7 | Left *Node 8 | Right *Node 9 | Parent *Node 10 | } 11 | 12 | // ❓ 二叉树的最近公共祖先 III 13 | 14 | func lowestCommonAncestor(p *Node, q *Node) *Node { 15 | var nodeMp = map[*Node]struct{}{} 16 | for p != nil { 17 | nodeMp[p] = struct{}{} 18 | p = p.Parent 19 | } 20 | 21 | for q != nil { 22 | _, ok := nodeMp[q] 23 | if ok { 24 | return q 25 | } 26 | q = q.Parent 27 | } 28 | return nil 29 | } 30 | -------------------------------------------------------------------------------- /Math/✅ 0537.complex-number-multiplication 复数乘法/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "fmt" 5 | "strconv" 6 | "strings" 7 | ) 8 | 9 | // https://leetcode.cn/proble乘法ex-number-multiplication 10 | 11 | // ❓ 复数乘法 12 | func parse(num string) (real, imag int) { 13 | i := strings.IndexByte(num, '+') 14 | real, _ = strconv.Atoi(num[:i]) 15 | imag, _ = strconv.Atoi(num[i+1 : len(num)-1]) 16 | return 17 | } 18 | 19 | func complexNumberMultiply(num1, num2 string) string { 20 | real1, imag1 := parse(num1) 21 | real2, imag2 := parse(num2) 22 | return fmt.Sprintf("%d+%di", real1*real2-imag1*imag2, real1*imag2+imag1*real2) 23 | } 24 | -------------------------------------------------------------------------------- /Tree/Inorder/order/0230.kth-smallest-element-in-a-bst 第K小的元素/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/kth-smallest-element-in-a-bst/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 二叉搜索树中第K小的元素 12 | 13 | func kthSmallest(root *TreeNode, k int) int { 14 | var num int 15 | var dfs func(node *TreeNode) 16 | dfs = func(node *TreeNode) { 17 | if node == nil { 18 | return 19 | } 20 | dfs(node.Left) 21 | k-- 22 | if k == 0 { 23 | num = node.Val 24 | return 25 | } 26 | dfs(node.Right) 27 | } 28 | dfs(root) 29 | return num 30 | } 31 | -------------------------------------------------------------------------------- /TwoPointer/1455.check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentencemain.go: -------------------------------------------------------------------------------- 1 | package TwoPointer 2 | 3 | // https://leetcode.cn/problems/check-if-a-word-occurs-as-a-prefix-of-any-word-in-a-sentence 4 | 5 | func isPrefixOfWord(sentence string, searchWord string) int { 6 | sL := len(sentence) 7 | wL := len(searchWord) 8 | cnt := 0 9 | for idx := 0; idx < sL; idx++ { 10 | idxLeft := idx 11 | for idx < sL && sentence[idx] != ' ' { 12 | idx++ 13 | } 14 | cnt++ 15 | idxRight := idxLeft + wL 16 | if idxRight <= sL && sentence[idxLeft:idxRight] == searchWord { 17 | return cnt 18 | } 19 | } 20 | return -1 21 | } 22 | -------------------------------------------------------------------------------- /Design/0170.two-sum-iii-data-structure-design 两数之和 III - 数据结构设计/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/two-sum-iii-data-structure-design 4 | 5 | type TwoSum struct { 6 | nums map[int]int 7 | } 8 | 9 | func Constructor() TwoSum { 10 | return TwoSum{ 11 | nums: map[int]int{}, 12 | } 13 | } 14 | 15 | func (ts *TwoSum) Add(num int) { 16 | ts.nums[num]++ 17 | } 18 | 19 | func (ts *TwoSum) Find(target int) bool { 20 | for num, cnt := range ts.nums { 21 | if 0 < ts.nums[target-num] { 22 | // 0 23 | if target != 2*num || cnt == 2 { 24 | return true 25 | } 26 | } 27 | } 28 | return false 29 | } 30 | -------------------------------------------------------------------------------- /Hash/group/2176.count-equal-and-divisible-pairs-in-an-array 统计数组中相等且可以被整除的数对.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/count-equal-and-divisible-pairs-in-an-array 4 | 5 | // ❓ 统计数组中相等且可以被整除的数对 6 | 7 | func countPairs(nums []int, k int) int { 8 | numMpIdxes := map[int][]int{} 9 | for idx, num := range nums { 10 | numMpIdxes[num] = append(numMpIdxes[num], idx) 11 | } 12 | var cntRes int 13 | for _, idxes := range numMpIdxes { 14 | for i, idx := range idxes { 15 | for _, idx2 := range idxes[i+1:] { 16 | if (idx*idx2)%k == 0 { 17 | cntRes++ 18 | } 19 | } 20 | } 21 | } 22 | return cntRes 23 | } 24 | -------------------------------------------------------------------------------- /Hash/sort/1331.rank-transform-of-an-array 数组序号转换.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "sort" 4 | 5 | // https://leetcode.cn/problems/rank-transform-of-an-array 6 | 7 | // ❓ 数组序号转换 8 | 9 | func arrayRankTransform(arr []int) []int { 10 | arrL := len(arr) 11 | arrSorted := make([]int, arrL) 12 | copy(arrSorted, arr) 13 | sort.Ints(arrSorted) 14 | 15 | numMpCnt := map[int]int{} 16 | cnt := 0 17 | // 排名 18 | for _, num := range arrSorted { 19 | if numMpCnt[num] == 0 { 20 | cnt++ 21 | } 22 | numMpCnt[num] = cnt 23 | } 24 | 25 | // 设置序号 26 | for i := range arr { 27 | arr[i] = numMpCnt[arr[i]] 28 | } 29 | return arr 30 | } 31 | -------------------------------------------------------------------------------- /Enum/1213.intersection-of-three-sorted-arrays 三个有序数组的交集/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/intersection-of-three-sorted-arrays 4 | 5 | func arraysIntersection(arr1 []int, arr2 []int, arr3 []int) []int { 6 | l1, l2, l3 := len(arr1), len(arr2), len(arr3) 7 | var i, j, k int 8 | var res []int 9 | for i < l1 && j < l2 && k < l3 { 10 | if arr1[i] == arr2[j] && arr2[j] == arr3[k] { 11 | res = append(res, arr1[i]) 12 | i++ 13 | j++ 14 | k++ 15 | } else if arr1[i] < arr2[k] { 16 | i++ 17 | } else if arr2[j] < arr3[k] { 18 | j++ 19 | } else { 20 | k++ 21 | } 22 | } 23 | return res 24 | } 25 | -------------------------------------------------------------------------------- /HashRolling/both/1392.longest-happy-prefix 最长快乐前缀/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/longest-happy-prefix 4 | 5 | // ❓ 最长快乐前缀 6 | 7 | const base uint = 131 8 | 9 | func longestPrefix(s string) string { 10 | // 自身不参与计算 11 | sTop := len(s) - 1 12 | var hashLeft, hashRight, mul uint = 0, 0, 1 13 | var idx = -1 14 | for i := 0; i < sTop; i++ { 15 | bitLeftLo := uint(s[i]) 16 | bitRightHi := uint(s[sTop-i]) 17 | hashLeft = hashLeft*base + bitLeftLo 18 | hashRight = bitRightHi*mul + hashRight 19 | if hashLeft == hashRight { 20 | idx = i 21 | } 22 | mul *= base 23 | } 24 | return s[:idx+1] 25 | } 26 | -------------------------------------------------------------------------------- /LinkedList/0061.rotate-list 拼接链表/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/rotate-list 9 | 10 | func rotateRight(head *ListNode, k int) *ListNode { 11 | if head == nil || head.Next == nil || k == 0 { 12 | return head 13 | } 14 | 15 | //tail 16 | var n = 1 17 | tail := head 18 | for tail.Next != nil { 19 | tail = tail.Next 20 | n++ 21 | } 22 | 23 | k = n - k%n 24 | 25 | tail.Next = head // 环 26 | 27 | for 1 < k { 28 | head = head.Next 29 | k-- 30 | } 31 | 32 | res := head.Next 33 | head.Next = nil // 断 34 | return res 35 | } 36 | -------------------------------------------------------------------------------- /Sql/0512.game-play-analysis-ii 首次登陆的设备名称/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/game-play-analysis-ii 2 | 3 | SELECT `player_id`, `device_id` 4 | FROM `activity` 5 | WHERE (`player_id`, `event_date`) IN (SELECT `player_id`, MIN(`event_date`) 6 | FROM `activity` 7 | GROUP BY `player_id`); 8 | 9 | # 10 | 11 | SELECT `player_id`, `device_id` 12 | FROM (SELECT `player_id`, 13 | `device_id`, 14 | `event_date`, 15 | MIN(`event_date`) OVER (PARTITION BY `player_id` ) `m` 16 | FROM `activity`) `t` 17 | WHERE `m` = `event_date` 18 | -------------------------------------------------------------------------------- /Sql/1623.all-valid-triplets-that-can-represent-a-country 三个学校组合不同的代表队/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/all-valid-triplets-that-can-represent-a-country 2 | 3 | SELECT `a`.`student_name` `member_a`, 4 | `b`.`student_name` `member_b`, 5 | `c`.`student_name` `member_c` 6 | FROM `schoola` `a`, 7 | `schoolb` `b`, 8 | `schoolc` `c` 9 | WHERE `a`.`student_id` != `b`.`student_id` 10 | AND `b`.`student_id` != `c`.`student_id` 11 | AND `a`.`student_id` != `c`.`student_id` 12 | AND `a`.`student_name` != `b`.`student_name` 13 | AND `b`.`student_name` != `c`.`student_name` 14 | AND `a`.`student_name` != `c`.`student_name` -------------------------------------------------------------------------------- /Tree/Postorder/ancestor/0235.lowest-common-ancestor-of-a-binary-search-tree 二叉搜索树的最近公共祖先/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/lowest-common-ancestor-of-a-binary-search-tree/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 二叉搜索树的最近公共祖先 12 | 13 | func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode { 14 | for { 15 | if p.Val < root.Val && q.Val < root.Val { 16 | root = root.Left 17 | } else if root.Val < p.Val && root.Val < q.Val { 18 | root = root.Right 19 | } else { 20 | // p q 分别位于左右子树 或者当前节点 21 | return root 22 | } 23 | } 24 | } 25 | -------------------------------------------------------------------------------- /Greedy/0670.maximum-swapmain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | // https://leetcode.cn/problems/maximum-swap 6 | 7 | func maximumSwap(num int) int { 8 | buf := []byte(strconv.Itoa(num)) 9 | bufL := len(buf) 10 | idxMax, idxLo, idxHi := bufL-1, -1, -1 11 | for idx := bufL - 1; 0 <= idx; idx-- { 12 | if buf[idxMax] < buf[idx] { 13 | idxMax = idx 14 | } else if buf[idx] < buf[idxMax] { // TODO 贪心，大数位有更小的数 15 | idxLo, idxHi = idx, idxMax 16 | } 17 | } 18 | if idxLo == -1 { 19 | return num 20 | } 21 | 22 | buf[idxLo], buf[idxHi] = buf[idxHi], buf[idxLo] 23 | num, _ = strconv.Atoi(string(buf)) 24 | return num 25 | } 26 | -------------------------------------------------------------------------------- /LinkedList/1669.merge-in-between-linked-lists/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/merge-in-between-linked-lists 9 | 10 | func mergeInBetween(list1 *ListNode, a int, b int, list2 *ListNode) *ListNode { 11 | var res = list1 12 | b -= a + 2 // 从0 开始，并且是下一个 13 | for 1 < a { 14 | list1 = list1.Next 15 | a-- 16 | } 17 | l := list1 18 | 19 | for 0 < b { 20 | list1 = list1.Next 21 | b-- 22 | } 23 | r := list1 24 | 25 | l.Next = list2 26 | for list2.Next != nil { 27 | list2 = list2.Next 28 | } 29 | list2.Next = r 30 | return res 31 | } 32 | -------------------------------------------------------------------------------- /Sort/0179.largest-number 最大数/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import ( 4 | "sort" 5 | "strconv" 6 | ) 7 | 8 | // https://leetcode.cn/problems/largest-number 9 | 10 | func largestNumber(nums []int) string { 11 | sort.Slice(nums, func(i, j int) bool { 12 | x, y := nums[i], nums[j] 13 | sx, sy := 10, 10 14 | for sx <= x { 15 | sx *= 10 16 | } 17 | 18 | for sy <= y { 19 | sy *= 10 20 | } 21 | 22 | return sx*y+x < sy*x+y 23 | }) 24 | if nums[0] == 0 { 25 | return "0" 26 | } 27 | 28 | var res []byte 29 | for _, num := range nums { 30 | res = append(res, strconv.Itoa(num)...) 31 | } 32 | 33 | return string(res) 34 | } 35 | -------------------------------------------------------------------------------- /Tree/TBT/0156.binary-tree-upside-down 上下翻转二叉树 🎆/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/binary-tree-upside-down/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 上下翻转二叉树 12 | func upsideDownBinaryTree(root *TreeNode) *TreeNode { 13 | var pre, left, right *TreeNode 14 | 15 | for root != nil { 16 | left = root.Left // 下一次循环 17 | 18 | root.Left = right // ⚠️ 上一次右节点 变成 当前节点的左节点 19 | right = root.Right // 下一次循环 20 | 21 | root.Right = pre // ⚠️ 上一次根节点 变成 当前节点的右节点 22 | pre = root // 下一次循环 23 | root = left // 下一次循环 24 | } 25 | return pre 26 | } 27 | -------------------------------------------------------------------------------- /DP/single (x)/pre/0303.range-sum-query-immutable 区域和检索 - 数组不可变/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/range-sum-query-immutable 4 | 5 | // 前缀 6 | 7 | type NumArray struct { 8 | nums []int 9 | } 10 | 11 | func Constructor(nums []int) NumArray { 12 | var numsL = len(nums) 13 | var preSum = make([]int, numsL) 14 | preSum[0] = nums[0] 15 | for i := 1; i < numsL; i++ { 16 | preSum[i] = preSum[i-1] + nums[i] 17 | } 18 | return NumArray{nums: preSum} 19 | } 20 | 21 | func (n *NumArray) SumRange(left int, right int) int { 22 | if 0 == left { 23 | return n.nums[right] 24 | } 25 | return n.nums[right] - n.nums[left-1] 26 | } 27 | -------------------------------------------------------------------------------- /Hash/state/0041.first-missing-positive 缺失的第一个正数 Replace.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/first-missing-positive/ 4 | 5 | func firstMissingPositive(nums []int) int { 6 | numsL := len(nums) 7 | for idx := 0; idx < numsL; idx++ { 8 | for 0 < nums[idx] && nums[idx] <= numsL { 9 | // 正数范围 10 | // 置换出来 可能也是正数，继续循环 11 | if nums[nums[idx]-1] == nums[idx] { 12 | // 对应位置是合法的 13 | break 14 | } 15 | nums[nums[idx]-1], nums[idx] = nums[idx], nums[nums[idx]-1] 16 | } 17 | } 18 | for idx := 0; idx < numsL; idx++ { 19 | if nums[idx] != idx+1 { 20 | return idx + 1 21 | } 22 | } 23 | return numsL + 1 24 | } 25 | -------------------------------------------------------------------------------- /Hash/window/1624.largest-substring-between-two-equal-characters 两个相同字符之间的最长子字符串.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/largest-substring-between-two-equal-characters 4 | 5 | // ❓ 两个相同字符之间的最长子字符串 6 | 7 | func maxLengthBetweenEqualCharacters(str string) int { 8 | chMpIdx := map[byte]int{} 9 | var maxL = -1 10 | 11 | for idxCur := range str { 12 | chCur := str[idxCur] 13 | idxPre, ok := chMpIdx[chCur] 14 | if ok { 15 | // 存在时计算 16 | curL := idxCur - idxPre + 1 17 | if maxL < curL { 18 | maxL = curL 19 | } 20 | } else { 21 | // 不存在存储 22 | chMpIdx[chCur] = idxCur 23 | } 24 | } 25 | return maxL 26 | } 27 | -------------------------------------------------------------------------------- /Math/0165.compare-version-numbers 比较版本号/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/compare-version-numbers 4 | 5 | func compareVersion(version1 string, version2 string) int { 6 | l1 := len(version1) 7 | l2 := len(version2) 8 | var i, j int 9 | for i < l1 || j < l2 { 10 | var x, y int 11 | for i < l1 && version1[i] != '.' { 12 | x = x*10 + int(version1[i]-'0') 13 | i++ 14 | } 15 | i++ 16 | 17 | for j < l2 && version2[j] != '.' { 18 | y = y*10 + int(version2[j]-'0') 19 | j++ 20 | } 21 | j++ 22 | if x < y { 23 | return 1 24 | } else if y < x { 25 | return -1 26 | } 27 | } 28 | return 0 29 | } 30 | -------------------------------------------------------------------------------- /Sql/0262.trips-and-users 非禁止用户取消率/1.sql: -------------------------------------------------------------------------------- 1 | # Link: https://leetcode.cn/problems/trips-and-users 2 | 3 | SELECT `t`.`request_at` `day`, 4 | ROUND( 5 | SUM(IF(`t`.`status` = 'completed', 0, 1)) / COUNT(`t`.`status`), 6 | 2) `cancellation rate` 7 | FROM `trips` `t` 8 | JOIN 9 | `users` `u1` 10 | JOIN 11 | `users` `u2` 12 | ON `t`.`client_id` = `u1`.`users_id` 13 | AND `u1`.`banned` = 'No' 14 | AND `t`.`driver_id` = `u2`.`users_id` 15 | AND `u2`.`banned` = 'No' 16 | AND `t`.`request_at` BETWEEN '2013-10-01' AND '2013-10-03' 17 | GROUP BY `t`.`request_at` -------------------------------------------------------------------------------- /Stack/0503.next-greater-element-ii 下一个更大的值/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/next-greater-element-ii 4 | 5 | func nextGreaterElements(nums []int) []int { 6 | n := len(nums) 7 | nums = append(nums, nums[:n-1]...) 8 | var stack []int 9 | for i, v := range nums { 10 | top := len(stack) - 1 11 | for -1 < top && nums[stack[top]] < v { 12 | nums[stack[top]] = v // 出栈后 虽然值变动了 不过也不管了 不影响 13 | stack = stack[:top] 14 | top-- 15 | } 16 | stack = append(stack, i) 17 | } 18 | 19 | for _, index := range stack { 20 | if n <= index { 21 | break 22 | } 23 | nums[index] = -1 24 | } 25 | return nums[:n] 26 | } 27 | -------------------------------------------------------------------------------- /Tree/Deep First Search/leaf/0404.sum-of-left-leaves 左叶子之和/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/sum-of-left-leaves/ 4 | 5 | type TreeNode struct { 6 | Val int 7 | Left *TreeNode 8 | Right *TreeNode 9 | } 10 | 11 | // ❓ 左叶子之和 12 | 13 | func sumOfLeftLeaves(root *TreeNode) int { 14 | var sum int 15 | var dfs func(node *TreeNode) 16 | dfs = func(node *TreeNode) { 17 | if node == nil { 18 | return 19 | } 20 | dfs(node.Left) 21 | dfs(node.Right) 22 | 23 | if node.Left != nil && node.Left.Left == nil && node.Left.Right == nil { 24 | sum += node.Left.Val 25 | } 26 | } 27 | dfs(root) 28 | return sum 29 | } 30 | -------------------------------------------------------------------------------- /Trie/✅ 0386.lexicographical-numbers 字典序排数 FOR/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/lexicographical-numbers 4 | 5 | // 1 2 6 | // 10 11.. 20 7 | 8 | // ❓ 字典序排数 9 | // ⚠️ 子节点10 大于 父节点1 10 | // ⚠️ 右节点11 大于 左节点10 11 | 12 | func lexicalOrder(n int) []int { 13 | var numsOrder []int 14 | var num = 1 15 | for len(numsOrder) < n { 16 | // 进入到最低层 (乘以10进入下层) 17 | for num <= n { 18 | numsOrder = append(numsOrder, num) 19 | num *= 10 20 | } 21 | 22 | // 遍历完毕 or 超出范围 (除以10返回上层) 23 | for num%10 == 9 || n < num { 24 | num /= 10 25 | } 26 | // 同层遍历 or 返回上层后+1 27 | num++ 28 | } 29 | return numsOrder 30 | } 31 | -------------------------------------------------------------------------------- /LinkedList/0142.linked-list-cycle-ii 环的起点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/linked-list-cycle-ii 9 | 10 | func detectCycle(head *ListNode) *ListNode { 11 | slow, fast := head, head 12 | for fast != nil && fast.Next != nil { 13 | slow = slow.Next 14 | fast = fast.Next.Next 15 | if slow == fast { // 相遇时 在环内 16 | for slow != head { // 如果以环起点，相遇时必定也是环起点 17 | slow = slow.Next // 因为 slow 入环 fast 相对于 slow 多走了 head->环起点 18 | head = head.Next // 所以 相遇时 slow head->环起点 = slow->环起点 19 | } 20 | return slow 21 | } 22 | } 23 | return nil 24 | } 25 | -------------------------------------------------------------------------------- /LinkedList/0817.linked-list-components 链表组件/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/linked-list-components 9 | 10 | func numComponents(head *ListNode, G []int) int { 11 | var m = map[int]struct{}{} 12 | 13 | for _, v := range G { 14 | m[v] = struct{}{} 15 | } 16 | 17 | var flag, res int 18 | 19 | for head != nil { 20 | _, ok := m[head.Val] 21 | if ok { // 出现一次 22 | flag++ 23 | } else { // 不存在 24 | flag = 0 25 | } 26 | if flag == 1 { // 出现1次 即算一个组件 之后累计的忽略 27 | res++ 28 | } 29 | head = head.Next 30 | } 31 | 32 | return res 33 | } 34 | -------------------------------------------------------------------------------- /LinkedList/1474.delete-n-nodes-after-m-nodes-of-a-linked-list 删除m节点后移动n节点/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/delete-n-nodes-after-m-nodes-of-a-linked-list 9 | 10 | // 直接模拟 11 | func deleteNodes(head *ListNode, m int, n int) *ListNode { 12 | res := head 13 | for head != nil { 14 | for i := 1; i < m && head != nil; i++ { 15 | head = head.Next 16 | } 17 | pre := head 18 | 19 | for j := -1; j < n && head != nil; j++ { 20 | head = head.Next 21 | } 22 | 23 | if pre != nil { 24 | pre.Next = head 25 | } 26 | } 27 | 28 | return res 29 | } 30 | -------------------------------------------------------------------------------- /Bit/subset/0784.letter-case-permutationmain.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/letter-case-permutation 4 | 5 | func letterCasePermutation(s string) []string { 6 | var subset int 7 | var buf = []byte(s) 8 | var idxes []int 9 | for i := range s { 10 | if 'A' <= s[i] { 11 | idxes = append(idxes, i) 12 | subset |= 1 << i 13 | } 14 | } 15 | 16 | var strs []string 17 | sub := subset 18 | for { 19 | for _, idx := range idxes { 20 | buf[idx] = s[idx] ^ byte(sub>>idx&1<<5) 21 | } 22 | strs = append(strs, string(buf)) 23 | if sub == 0 { 24 | break 25 | } 26 | sub = (sub - 1) & subset 27 | } 28 | return strs 29 | } 30 | -------------------------------------------------------------------------------- /Enum/0038.count-and-say 外观数列/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | import "strconv" 4 | 5 | // https://leetcode.cn/problems/count-and-say/ 6 | 7 | func countAndSay(n int) string { 8 | var res = []byte("1$") 9 | var cur []byte 10 | var cnt = 1 11 | for ; 1 < n; n-- { 12 | l1 := len(res) - 1 13 | cur = []byte{} 14 | for i := 0; i < l1; i++ { 15 | if res[i] == res[i+1] { 16 | cnt++ 17 | } else { 18 | cur = append(cur, strconv.Itoa(cnt)...) 19 | cur = append(cur, res[i]) 20 | cnt = 1 21 | } 22 | } 23 | 24 | res = []byte{} 25 | res = append(res, cur...) 26 | res = append(res, '$') 27 | } 28 | return string(res[:len(res)-1]) 29 | } 30 | -------------------------------------------------------------------------------- /Hash/comb/1711.count-good-meals 大餐总数.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | // https://leetcode.cn/problems/count-good-meals 4 | 5 | // ❓ 大餐(和为2的幂)总数 6 | 7 | func countPairs(deliciousness []int) int { 8 | var cnt, sumMax int 9 | numMpCnt := map[int]int{} 10 | for _, delicious := range deliciousness { 11 | // 最大幂 12 | if sumMax>>1 < delicious { 13 | sumMax = delicious << 1 14 | } 15 | // 2的幂循环一遍 16 | for sum := 1; sum <= sumMax; sum <<= 1 { 17 | if sum < delicious { 18 | continue 19 | } 20 | numTarget := sum - delicious 21 | cnt += numMpCnt[numTarget] 22 | } 23 | // 存入 24 | numMpCnt[delicious]++ 25 | } 26 | return cnt % (1e9 + 7) 27 | } 28 | -------------------------------------------------------------------------------- /LinkedList/0082.remove-duplicates-from-sorted-list-ii 删除重复全部元素/main.go: -------------------------------------------------------------------------------- 1 | package main 2 | 3 | type ListNode struct { 4 | Val int 5 | Next *ListNode 6 | } 7 | 8 | // https://leetcode.cn/problems/remove-duplicates-from-sorted-list-ii 9 | 10 | func deleteDuplicates(head *ListNode) *ListNode { 11 | zero := &ListNode{Next: head} 12 | cur := zero 13 | for cur.Next != nil && cur.Next.Next != nil { 14 | if cur.Next.Val == cur.Next.Next.Val { // 出现相同 15 | v := cur.Next.Val 16 | for cur.Next != nil && cur.Next.Val == v { // 所有相同的都删除 17 | cur.Next = cur.Next.Next 18 | } 19 | } else { 20 | cur = cur.Next 21 | } 22 | } 23 | return zero.Next 24 | } 25 | --------------------------------------------------------------------------------