76433 76433
project
  • luhanxin-community
    1. 前端设计
    • 计划
  • ai
    • 音乐 足迹 后台 瞬间 总结 首页
    已删除用户

    已删除用户

    该用户已被删除。

    • 累计撰写 25 篇文章
    • 累计创建 15 个分类
    • 累计收到 5 条评论
    • 导航
      • project
        • luhanxin-community
          • 前端设计
      • 计划
        • ai
      • 音乐
      • 足迹
      • 后台
      • 瞬间
      • 总结
      • 首页
      目录
    76433
    XIAOLUER|76433|LUHANXIN|JUWENZHANG

    Music

    • 2025-12-02 06:01
    • 239
    • 0
    • 0
    • 131

    Music

    https://blog.luhanxin.com/music
    作者

    luhanxin|juwenzhang

    发布于

    2025-12-02

    更新于

    2025-12-02

    许可协议
    CC BY 4.0

    评论

    标签
    trackexpressminiweb安全typescriptrustreact原理tencentbundlejavascriptnodejshybird知识海洋httpmonitor
    luhanxin
    最新文章
    • Javascript 手写题收集
    • 学习网站
    • openspec 实践总结
    • typescript
    • 微信小程序
    分类 更多
    • typescript 1
    • mini 1
    • tencent 2
    • web安全 1
    • rust 1
    • track 2
    • monitor 2
    • hybird 2
    • bundle 2
    • react原理 3
    音乐
    标签云
    trackexpressminiweb安全typescriptrustreact原理tencentbundlejavascriptnodejshybird知识海洋httpmonitor
    最新评论
    • luhanxin|juwenzhang
      luhanxin|juwenzhang
      2026-02-02
      <pre><code>const str = "info.adress.street" const obj = { info: { adress: { city: "beijing", street: "123 street" } } } function getObjValue(obj, str) { // 1. 进行字符串的切割吧 const strArr = str.split("."); let res = obj; let key = undefined; while (strArr.length) { // 首先获取得出第一个属性名出来吧 key = strArr.shift(); if (key in res) { res = res[key]; } else { return undefined; } } return res; } console.log(getObjValue(obj, str)); </code></pre><p></p>
    • luhanxin|juwenzhang
      luhanxin|juwenzhang
      2026-02-01
      <pre><code>/** * 通用 n 数之和，返回所有不重复的数值组合 * @param {number[]} nums - 原数组 * @param {number} n - 几数之和（n ≥ 2） * @param {number} target - 目标和 * @returns {number[][]} 所有不重复的组合 */ function nSum(nums, n, target) { const res = []; // 边界条件：n&lt;2 或 数组长度不足n，直接返回空 if (n &lt; 2 || nums.length &lt; n) return res; // 步骤1：排序（核心，为去重、双指针、剪枝服务） nums.sort((a, b) =&gt; a - b); // 递归辅助函数：从start索引开始，找count数之和为sum的组合，path是当前已选的数 function dfs(start, count, sum, path) { const len = nums.length; // 剪枝：剩余数字不够选，直接返回 if (len - start &lt; count) return; // 剪枝：升序数组，最小的count个数之和 &gt; sum → 不可能满足 if (nums[start] * count &gt; sum) return; // 剪枝：升序数组，最大的count个数之和 &lt; sum → 不可能满足 if (nums[len - 1] * count &lt; sum) return; // 终止条件：拆解到2数之和，用双指针求解 if (count === 2) { let left = start; let right = len - 1; while (left &lt; right) { const curSum = nums[left] + nums[right]; const leftVal = nums[left]; const rightVal = nums[right]; if (curSum === sum) { // 收集结果：当前路径 + 双指针的两个数 res.push([...path, leftVal, rightVal]); // 双指针去重：左指针跳过重复值 while (left &lt; right &amp;&amp; nums[left] === leftVal) left++; // 双指针去重：右指针跳过重复值 while (left &lt; right &amp;&amp; nums[right] === rightVal) right--; } else if (curSum &lt; sum) { // 和太小，左指针右移增大值 left++; } else { // 和太大，右指针左移减小值 right--; } } return; } // 非终止条件：递归拆解（固定1个数，找count-1数之和） for (let i = start; i &lt; len; i++) { // 固定数去重：和前一个数相同，跳过（避免重复组合） if (i &gt; start &amp;&amp; nums[i] === nums[i - 1]) continue; // 递归：起始索引i+1（不重复选当前数），剩余个数count-1，剩余目标sum-nums[i]，当前路径追加nums[i] dfs(i + 1, count - 1, sum - nums[i], [...path, nums[i]]); } } // 初始调用：从索引0开始，找n数之和为target，当前路径为空 dfs(0, n, target, []); return res; } /** * 通用 n 数之和，返回所有不重复的索引组合 * @param {number[]} nums - 原数组 * @param {number} n - 几数之和（n ≥ 2） * @param {number} target - 目标和 * @returns {number[][]} 所有不重复的索引组合 */ function nSumIndex(nums, n, target) { const res = []; if (n &lt; 2 || nums.length &lt; n) return res; // 步骤1：构建「值-原始索引」数组，并按值排序 const arr = nums.map((v, i) =&gt; ({ v, i })).sort((a, b) =&gt; a.v - b.v); const len = arr.length; function dfs(start, count, sum, path) { if (len - start &lt; count) return; if (arr[start].v * count &gt; sum) return; if (arr[len - 1].v * count &lt; sum) return; if (count === 2) { let left = start, right = len - 1; while (left &lt; right) { const curSum = arr[left].v + arr[right].v; if (curSum === sum) { // 收集索引组合，并排序（避免[0,1]和[1,0]重复） const indexPath = [...path, arr[left].i, arr[right].i].sort((a, b) =&gt; a - b); res.push(indexPath); // 跳过值重复的项（索引自然不同） while (left &lt; right &amp;&amp; arr[left].v === arr[left + 1].v) left++; while (left &lt; right &amp;&amp; arr[right].v === arr[right - 1].v) right--; left++; right--; } else if (curSum &lt; sum) { left++; } else { right--; } } return; } for (let i = start; i &lt; len; i++) { // 固定数去重：值重复则跳过 if (i &gt; start &amp;&amp; arr[i].v === arr[i - 1].v) continue; dfs(i + 1, count - 1, sum - arr[i].v, [...path, arr[i].i]); } } dfs(0, n, target, []); return res; } </code></pre><p></p>
    • luhanxin|juwenzhang
      luhanxin|juwenzhang
      2026-02-01
      <pre><code>def threeSum(nums): nums.sort() res = [] n = len(nums) for i in range(n - 2): if i &gt; 0 and nums[i] == nums[i - 1]: continue left, right = i + 1, n - 1 while left &lt; right: total = nums[i] + nums[left] + nums[right] if total &lt; 0: left += 1 elif total &gt; 0: right -= 1 else: res.append([nums[i], nums[left], nums[right]]) # 跳过重复元素 while left &lt; right and nums[left] == nums[left + 1]: left += 1 while left &lt; right and nums[right] == nums[right - 1]: right -= 1 left += 1 right -= 1 return res</code></pre><ul><li><p>核心思路是进行二分操作获取得到元素即可，以及需要进行的是跳过重复元素吧</p></li></ul><p></p>
    • luhanxin|juwenzhang
      luhanxin|juwenzhang
      2026-02-01
      <p>准备算法之前的话核心需要提前知道的是：<br />数据结构的特点和常用的 API 操作吧：<strong>数组、哈希表、列表、链表、树、图，栈，队列</strong>等数据结构，在日常开发中的话，常操作的就是我们的字符串，数组，哈希表这三种数据类型吧<br />在整个过程中穿插着对于<strong>数据的排序、去重，格式化，清洗，CRUD </strong>的操作吧<br />在实际开发中正则表达式也是一种方式来帮助我们完成有一些业务需求吧</p>
    • luhanxin|juwenzhang
      luhanxin|juwenzhang
      2026-02-01
      <pre><code>两数之和的升级思考，就是如何进行对应的收集所有结果并且返回 function twoSumAll(nums, target) { const res = []; const numToIndices = new Map(); for (let i = 0; i &lt; nums.length; i++) { const num = nums[i]; numToIndices.set(num, numToIndices.has(num) ? [...numToIndices.get(num), i] : [i]); } for (const num of numToIndices.keys()) { const diff = target - num; if (!numToIndices.has(diff) || num &gt; diff) continue; const indices1 = numToIndices.get(num); const indices2 = numToIndices.get(diff); if (num === diff) { for (let i = 0; i &lt; indices1.length; i++) { for (let j = i + 1; j &lt; indices1.length; j++) { res.push([indices1[i], indices1[j]].sort().join(',')); } } } else { for (const i of indices1) { for (const j of indices2) { res.push([i, j].sort().join(',')); } } } } return res; }</code></pre><pre><code> def twoSum(nums, target): map = {} for i, num in enumerate(nums): diff = target - num if diff in map: return [map[diff], i] map[num] = i return [] def twoSumAll(nums, target): res = [] map = {} # 遍历元素，构建基于元素的 hash 表 for i in range(len(nums)): curEle = nums[i] if curEle not in map: map[curEle] = [i] else: map[curEle].append(i) for num in map: diff = target - num if diff not in map: continue if diff &lt; num: continue indices1 = map[num] indices2 = map[diff] # 核心分为两种情况处理 if num == diff: # 处理同一个数的不同索引组合 for i in range(len(indices1)): for j in range(i+1, len(indices1)): pair = sorted([indices1[i], indices1[j]]) res.append(pair) else: # 处理不同数的索引组合 for i in indices1: for j in indices2: pair = sorted([i, j]) res.append(pair) return res arr = [2, 7, 2, 7, 11, 15] target = 9 print(twoSum(arr, target)) print(twoSumAll(arr, target)) </code></pre><p></p>
    弹
    • 76433 76433

    • © 2026 76433京ICP备2025152606号Powered by Halo & Dream

      0访客 0访问

      公网安备京ICP备2025152606号-1