<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>职业与管理 on 码上生长 - 探索个人成长的无限可能</title>
    <link>https://dstweihao.cn/categories/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/</link>
    <description>Recent content in 职业与管理 on 码上生长 - 探索个人成长的无限可能</description>
    <generator>Hugo -- 0.144.2</generator>
    <language>zh</language>
    <lastBuildDate>Tue, 31 Mar 2026 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://dstweihao.cn/categories/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>45-任务变更很随意，应该怎么解决？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/45-%E4%BB%BB%E5%8A%A1%E5%8F%98%E6%9B%B4%E5%BE%88%E9%9A%8F%E6%84%8F%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E8%A7%A3%E5%86%B3/</link>
      <pubDate>Tue, 31 Mar 2026 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/45-%E4%BB%BB%E5%8A%A1%E5%8F%98%E6%9B%B4%E5%BE%88%E9%9A%8F%E6%84%8F%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E8%A7%A3%E5%86%B3/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311353971.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;前面已经对 “做好，而不是做完” 的问题进行了分析并提供了解决方案。&lt;/p&gt;
&lt;p&gt;现在，我们来分析和总结 “项目月末统计及时完成率，出现人人达标的情况” 这一问题，希望能梳理出有价值的见解。&lt;/p&gt;
&lt;p&gt;那就从源头开始，最开始，我们计划通过 “任务及时达成率” 来反映项目成员的工作情况，期望从中能发现一些问题并起到督促的作用。&lt;/p&gt;
&lt;p&gt;打算通过一定的约束力、紧迫感，促使大家及时完成手头上的工作，为此制定的规则是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;每个月未及时达标的任务不可超过 2 条，超过则需赞助部门经费 50 元。&lt;/li&gt;
&lt;li&gt;项目总负责人也不例外，同样需要赞助 50 元。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;之所以这样设计，是因为能让项目总负责人与项目成员站在同一战线上，有助于避免形成对立，降低工作开展的阻力。&lt;/p&gt;
&lt;p&gt;然而，历经一年有余，除了最开始有一两个项目成员未达标并缴纳了赞助费用外，此后很长时间都是人人达标的状态。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;这从正态分布上来说，就显得不切实际。因为，很少有人能保证所有任务都及时完成。而且，月月如此。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;为什么会出现这种情况呢？后来我分析了一下，原因是，我们对任务变更没有进行有效管控，插入需求的频率过高。为什么插入需求的频率会过高呢？因为项目业务需要根据客户反馈及时调整，第一时间响应客户需求。例如：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;突然有客户反馈紧急需求，希望快速响应；&lt;/li&gt;
&lt;li&gt;当前线上存在之前疏忽的功能细节，需要及时完善和补充；&lt;/li&gt;
&lt;li&gt;有客户询盘并表达合作意向，但对某个功能不太满意，需要及时给出优化方案以推进合作。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这些情况都会破坏之前制定好的项目计划和正在执行的任务。此时，无论是项目总负责人还是项目负责人，往往没有深究是否应该变更，而是默认允许变更。&lt;/p&gt;
&lt;p&gt;只要产品、后端、前端、运维等任何一方出现需求问题或任务执行未及时达成，影响后续关联任务，就会出现任务变更的情况。&lt;/p&gt;
&lt;p&gt;此时，很多人要么不具备分辨能力，要么贪图省事，不愿花心思去辨别是否真的应该允许变更，而是一概通过变更申请。&lt;/p&gt;
&lt;p&gt;要解决这个问题，首先应从减少插入需求入手。但对于研发工作而言，如果完全不允许插入需求和任务变更，就显得过于僵硬和死板。市场在实时变化，响应时间的早晚可能导致截然不同的结果。因此，对于紧急、关键的需求，肯定要及时响应。&lt;/p&gt;
&lt;p&gt;然而，如果总是允许插入需求，项目计划就容易失控。&lt;strong&gt;久而久之，项目成员会产生一种心态，反正最后都要变更计划，今天做完还是明天做完有什么区别呢？&lt;/strong&gt; 这种思想一旦萌生就很难消除，必须从根源上、从制度上解决。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311357615.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;项目负责人要引导项目成员主动思考是否可以通过其他方式解决延期风险，而不是通过变更影响后续任务。例如，可以提高事情优先级、提升工作效率、适当加班等。这样才能以目标为导向，锻炼应对不利情况的能力。&lt;/p&gt;
&lt;p&gt;当然，如果插入的需求需要较长的开发周期，自然需要变更任务计划，并同步更新。这一观点我在之前的文章《项目需求变更时如何处理》中也提到过。&lt;strong&gt;坦白讲，就是要在 “插入需求” 和 “任务变更” 之间取得一个平衡点。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这实际上，还是回到了项目计划和里程碑的目的。**正如我在之前多篇文章中提到的，项目计划的目的是提供一个方向和时间节点，就像大海中的灯塔，引导大家朝着同一个方向前进。**如果张三往东走，李四往西走，王五往南走，工作就无法有效开展。&lt;/p&gt;
&lt;p&gt;其次，项目负责人和项目成员在面对任务变更和各种突发事件时，应该充分发挥自己的智慧，制定有效的策略，就像行军打仗、摆兵布阵一样，明确先做什么、后做什么，如何争取资源，如何与其他成员和上级领导协调沟通，以确保在规定时间内达成目标。&lt;/p&gt;
&lt;p&gt;如果某个项目成员反馈任务需要变更（例如前端因为后端接口问题导致任务受阻，申请延长任务时间），项目负责人需要了解事情的前因后果，而不是仅凭这个项目成员的一面之词。这就需要把相关项目成员（如后端）叫来一起沟通，了解问题所在及解决方案，可能出现的情况包括：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;后端接口没有问题，只是两人对需求的理解有误，这种情况不需要变更；&lt;/li&gt;
&lt;li&gt;后端接口有问题，但前端可以先开发界面，最后一两天再联调，这种情况不一定需要变更；&lt;/li&gt;
&lt;li&gt;后端接口真的有问题，但前端对延长时间的理解有误，可能存在故意拉长时间的情况；&lt;/li&gt;
&lt;li&gt;后端接口真的有问题，追溯起来是因为对需求的理解不一致，这种情况可以总结经验，下次在需求层面多做分解和沟通；&lt;/li&gt;
&lt;li&gt;后端接口真的有问题，前端提出的延长时间合理，符合常规理解，可以同意变更。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;可以看到，&lt;strong&gt;有些任务只是看起来需要变更，有些任务只是看起来需要延长时间，实际上不一定如此。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;归根结底，就是项目负责人在执行上出现了问题，为什么没有做到位呢？&lt;strong&gt;换位思考，我在带一个项目，里面有关系好的，关系不好的，关系好的呢，肯定是适当通融，关系不好的呢，不想得罪对方，这是人之常情。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;每个人的角色不一样，所掌握的话语权和资源也不尽相同，面对同样的一个人或者一件事，在你看来，很容易处理，但其他人就会觉得很难，不同的立场，面对的阻力就会发生变化。&lt;/p&gt;
&lt;p&gt;所以，&lt;strong&gt;要为项目负责人的执行背书，从源头梳理，制定《项目管理规章制度》，特别是任务变更的规定&lt;/strong&gt;，然后，组织项目负责人讨论会议，对这份《项目管理规章制度》里的每一条规定，都反复讨论和敲定，有什么问题，当场提出来，现场就解决对方的顾虑和疑惑，能够达成共识。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;只有达成共识，项目负责人执行起来就会从被动变为主动。&lt;/strong&gt; 然后，再把这个《项目管理规章制度》在部门里发布和告知。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;之后，项目负责人在执行的时候，就照着规定行事，不用顾及对方的感受，直接按规矩办事，实事求是，如果对方反应很激烈，那也不用项目负责人去解决，只需要把这种对立情绪向上反馈，由项目总负责人、部门去解决，不用有心理负担。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;说到底，就是要给项目负责人做这个事情的正当性，而不是把压力完全由项目负责人承担&lt;/strong&gt;，从源头贯彻理念，而不是处于模棱两可的状态，规定个12345，有问题解决问题，直到大家都没有异议，那么执行起来，就不会有那么多阻力。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;谁没做到位，直接提出来，到底是什么原因，是制度的不完善，还是人的问题，制度不完善，继续完善制度，人的问题，就解决人的问题。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;最后，要提的一点是，任务变更固然是一个问题，但这都是基于 “目标如期达成存在很大风险” 这个主要矛盾延伸的，先明白了这一点，再去抓任务变更这个事情，才不会舍本逐末。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311357462.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311353971.jpeg"></p>
<p>前面已经对 “做好，而不是做完” 的问题进行了分析并提供了解决方案。</p>
<p>现在，我们来分析和总结 “项目月末统计及时完成率，出现人人达标的情况” 这一问题，希望能梳理出有价值的见解。</p>
<p>那就从源头开始，最开始，我们计划通过 “任务及时达成率” 来反映项目成员的工作情况，期望从中能发现一些问题并起到督促的作用。</p>
<p>打算通过一定的约束力、紧迫感，促使大家及时完成手头上的工作，为此制定的规则是：</p>
<ol>
<li>每个月未及时达标的任务不可超过 2 条，超过则需赞助部门经费 50 元。</li>
<li>项目总负责人也不例外，同样需要赞助 50 元。</li>
</ol>
<p>之所以这样设计，是因为能让项目总负责人与项目成员站在同一战线上，有助于避免形成对立，降低工作开展的阻力。</p>
<p>然而，历经一年有余，除了最开始有一两个项目成员未达标并缴纳了赞助费用外，此后很长时间都是人人达标的状态。</p>
<p><strong>这从正态分布上来说，就显得不切实际。因为，很少有人能保证所有任务都及时完成。而且，月月如此。</strong></p>
<p>为什么会出现这种情况呢？后来我分析了一下，原因是，我们对任务变更没有进行有效管控，插入需求的频率过高。为什么插入需求的频率会过高呢？因为项目业务需要根据客户反馈及时调整，第一时间响应客户需求。例如：</p>
<ol>
<li>突然有客户反馈紧急需求，希望快速响应；</li>
<li>当前线上存在之前疏忽的功能细节，需要及时完善和补充；</li>
<li>有客户询盘并表达合作意向，但对某个功能不太满意，需要及时给出优化方案以推进合作。</li>
</ol>
<p>这些情况都会破坏之前制定好的项目计划和正在执行的任务。此时，无论是项目总负责人还是项目负责人，往往没有深究是否应该变更，而是默认允许变更。</p>
<p>只要产品、后端、前端、运维等任何一方出现需求问题或任务执行未及时达成，影响后续关联任务，就会出现任务变更的情况。</p>
<p>此时，很多人要么不具备分辨能力，要么贪图省事，不愿花心思去辨别是否真的应该允许变更，而是一概通过变更申请。</p>
<p>要解决这个问题，首先应从减少插入需求入手。但对于研发工作而言，如果完全不允许插入需求和任务变更，就显得过于僵硬和死板。市场在实时变化，响应时间的早晚可能导致截然不同的结果。因此，对于紧急、关键的需求，肯定要及时响应。</p>
<p>然而，如果总是允许插入需求，项目计划就容易失控。<strong>久而久之，项目成员会产生一种心态，反正最后都要变更计划，今天做完还是明天做完有什么区别呢？</strong> 这种思想一旦萌生就很难消除，必须从根源上、从制度上解决。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311357615.jpeg"></p>
<p>项目负责人要引导项目成员主动思考是否可以通过其他方式解决延期风险，而不是通过变更影响后续任务。例如，可以提高事情优先级、提升工作效率、适当加班等。这样才能以目标为导向，锻炼应对不利情况的能力。</p>
<p>当然，如果插入的需求需要较长的开发周期，自然需要变更任务计划，并同步更新。这一观点我在之前的文章《项目需求变更时如何处理》中也提到过。<strong>坦白讲，就是要在 “插入需求” 和 “任务变更” 之间取得一个平衡点。</strong></p>
<p>这实际上，还是回到了项目计划和里程碑的目的。**正如我在之前多篇文章中提到的，项目计划的目的是提供一个方向和时间节点，就像大海中的灯塔，引导大家朝着同一个方向前进。**如果张三往东走，李四往西走，王五往南走，工作就无法有效开展。</p>
<p>其次，项目负责人和项目成员在面对任务变更和各种突发事件时，应该充分发挥自己的智慧，制定有效的策略，就像行军打仗、摆兵布阵一样，明确先做什么、后做什么，如何争取资源，如何与其他成员和上级领导协调沟通，以确保在规定时间内达成目标。</p>
<p>如果某个项目成员反馈任务需要变更（例如前端因为后端接口问题导致任务受阻，申请延长任务时间），项目负责人需要了解事情的前因后果，而不是仅凭这个项目成员的一面之词。这就需要把相关项目成员（如后端）叫来一起沟通，了解问题所在及解决方案，可能出现的情况包括：</p>
<ol>
<li>后端接口没有问题，只是两人对需求的理解有误，这种情况不需要变更；</li>
<li>后端接口有问题，但前端可以先开发界面，最后一两天再联调，这种情况不一定需要变更；</li>
<li>后端接口真的有问题，但前端对延长时间的理解有误，可能存在故意拉长时间的情况；</li>
<li>后端接口真的有问题，追溯起来是因为对需求的理解不一致，这种情况可以总结经验，下次在需求层面多做分解和沟通；</li>
<li>后端接口真的有问题，前端提出的延长时间合理，符合常规理解，可以同意变更。</li>
</ol>
<p>可以看到，<strong>有些任务只是看起来需要变更，有些任务只是看起来需要延长时间，实际上不一定如此。</strong></p>
<p>归根结底，就是项目负责人在执行上出现了问题，为什么没有做到位呢？<strong>换位思考，我在带一个项目，里面有关系好的，关系不好的，关系好的呢，肯定是适当通融，关系不好的呢，不想得罪对方，这是人之常情。</strong></p>
<p>每个人的角色不一样，所掌握的话语权和资源也不尽相同，面对同样的一个人或者一件事，在你看来，很容易处理，但其他人就会觉得很难，不同的立场，面对的阻力就会发生变化。</p>
<p>所以，<strong>要为项目负责人的执行背书，从源头梳理，制定《项目管理规章制度》，特别是任务变更的规定</strong>，然后，组织项目负责人讨论会议，对这份《项目管理规章制度》里的每一条规定，都反复讨论和敲定，有什么问题，当场提出来，现场就解决对方的顾虑和疑惑，能够达成共识。</p>
<p><strong>只有达成共识，项目负责人执行起来就会从被动变为主动。</strong> 然后，再把这个《项目管理规章制度》在部门里发布和告知。</p>
<p><strong>之后，项目负责人在执行的时候，就照着规定行事，不用顾及对方的感受，直接按规矩办事，实事求是，如果对方反应很激烈，那也不用项目负责人去解决，只需要把这种对立情绪向上反馈，由项目总负责人、部门去解决，不用有心理负担。</strong></p>
<p><strong>说到底，就是要给项目负责人做这个事情的正当性，而不是把压力完全由项目负责人承担</strong>，从源头贯彻理念，而不是处于模棱两可的状态，规定个12345，有问题解决问题，直到大家都没有异议，那么执行起来，就不会有那么多阻力。</p>
<p><strong>谁没做到位，直接提出来，到底是什么原因，是制度的不完善，还是人的问题，制度不完善，继续完善制度，人的问题，就解决人的问题。</strong></p>
<p>最后，要提的一点是，任务变更固然是一个问题，但这都是基于 “目标如期达成存在很大风险” 这个主要矛盾延伸的，先明白了这一点，再去抓任务变更这个事情，才不会舍本逐末。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202603311357462.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>技术分享的安排问题</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/49-%E6%8A%80%E6%9C%AF%E5%88%86%E4%BA%AB%E7%9A%84%E5%AE%89%E6%8E%92%E9%97%AE%E9%A2%98/</link>
      <pubDate>Tue, 20 Jan 2026 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/49-%E6%8A%80%E6%9C%AF%E5%88%86%E4%BA%AB%E7%9A%84%E5%AE%89%E6%8E%92%E9%97%AE%E9%A2%98/</guid>
      <description>&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;自身实力是根本（打铁还需自身硬）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;结果导向，不迷信过程&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;主干线思维，聚焦核心目标&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;第一性原理，目标导向的方法选择&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;把自己当成一个&amp;quot;国家&amp;quot;来经营&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打铁还需自身硬，落后就要挨打。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;只看结果，不注重过程，不迷信苦劳，只相信拿到结果。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&amp;quot;如何获得客户签约&amp;quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<ol>
<li>
<p>自身实力是根本（打铁还需自身硬）</p>
</li>
<li>
<p>结果导向，不迷信过程</p>
</li>
<li>
<p>主干线思维，聚焦核心目标</p>
</li>
<li>
<p>第一性原理，目标导向的方法选择</p>
</li>
<li>
<p>把自己当成一个&quot;国家&quot;来经营</p>
</li>
<li>
<p>强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？</p>
</li>
<li>
<p>打铁还需自身硬，落后就要挨打。</p>
</li>
<li>
<p>国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？</p>
</li>
<li>
<p>只看结果，不注重过程，不迷信苦劳，只相信拿到结果。</p>
</li>
<li>
<p>打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。</p>
</li>
<li>
<p>接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。</p>
</li>
<li>
<p>使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。</p>
</li>
<li>
<p>PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&quot;如何获得客户签约&quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>目标和计划为什么如此重要？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/48-%E7%9B%AE%E6%A0%87%E5%92%8C%E8%AE%A1%E5%88%92%E4%B8%BA%E4%BB%80%E4%B9%88%E5%A6%82%E6%AD%A4%E9%87%8D%E8%A6%81/</link>
      <pubDate>Tue, 20 Jan 2026 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/48-%E7%9B%AE%E6%A0%87%E5%92%8C%E8%AE%A1%E5%88%92%E4%B8%BA%E4%BB%80%E4%B9%88%E5%A6%82%E6%AD%A4%E9%87%8D%E8%A6%81/</guid>
      <description>&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;自身实力是根本（打铁还需自身硬）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;结果导向，不迷信过程&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;主干线思维，聚焦核心目标&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;第一性原理，目标导向的方法选择&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;把自己当成一个&amp;quot;国家&amp;quot;来经营&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打铁还需自身硬，落后就要挨打。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;只看结果，不注重过程，不迷信苦劳，只相信拿到结果。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&amp;quot;如何获得客户签约&amp;quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<ol>
<li>
<p>自身实力是根本（打铁还需自身硬）</p>
</li>
<li>
<p>结果导向，不迷信过程</p>
</li>
<li>
<p>主干线思维，聚焦核心目标</p>
</li>
<li>
<p>第一性原理，目标导向的方法选择</p>
</li>
<li>
<p>把自己当成一个&quot;国家&quot;来经营</p>
</li>
<li>
<p>强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？</p>
</li>
<li>
<p>打铁还需自身硬，落后就要挨打。</p>
</li>
<li>
<p>国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？</p>
</li>
<li>
<p>只看结果，不注重过程，不迷信苦劳，只相信拿到结果。</p>
</li>
<li>
<p>打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。</p>
</li>
<li>
<p>接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。</p>
</li>
<li>
<p>使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。</p>
</li>
<li>
<p>PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&quot;如何获得客户签约&quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>44-任务要做好，而不是做完？还是完成比完美更重要？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/44-%E4%BB%BB%E5%8A%A1%E8%A6%81%E5%81%9A%E5%A5%BD%E8%80%8C%E4%B8%8D%E6%98%AF%E5%81%9A%E5%AE%8C%E8%BF%98%E6%98%AF%E5%AE%8C%E6%88%90%E6%AF%94%E5%AE%8C%E7%BE%8E%E6%9B%B4%E9%87%8D%E8%A6%81/</link>
      <pubDate>Mon, 05 Jan 2026 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/44-%E4%BB%BB%E5%8A%A1%E8%A6%81%E5%81%9A%E5%A5%BD%E8%80%8C%E4%B8%8D%E6%98%AF%E5%81%9A%E5%AE%8C%E8%BF%98%E6%98%AF%E5%AE%8C%E6%88%90%E6%AF%94%E5%AE%8C%E7%BE%8E%E6%9B%B4%E9%87%8D%E8%A6%81/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051620807.png&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;
&lt;p&gt;近期，在项目管理过程中，发现了两个值得深思的问题：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;有的同事任务做完了，但是暴露出很多显而易见的问题；&lt;/li&gt;
&lt;li&gt;项目月末统计及时完成率，出现人人达标的情况。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这两个问题，都在一定程度上反映出任务执行过程中、项目管理方面存在一些方法不对，或者制度漏洞，导致没有达成预期的效果。&lt;/p&gt;
&lt;p&gt;现在，就基于这两个问题，好好分析以及给出对应的解决方案。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619773.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;任务要做好而不是做完&#34;&gt;任务要做好，而不是做完&lt;/h2&gt;
&lt;p&gt;在会议室验收功能的时候，有个同事开发的功能模块，比如设备列表，暴露出很多问题。而且，还是一些很明显的问题：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;列表只是展示 10 条数据，没有滚动条，没有分页，导致后面的数据都看不到；&lt;/li&gt;
&lt;li&gt;点击删除按钮的时候，没有二次弹窗让用户确认，而是直接删除了，删除之后列表也没有更新。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这些虽然是小问题，但是表面风平浪静，实则暗流涌动，从中可以窥见在水面下的深层问题：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;第一个就是没有用心在开发这个功能，这些都是很明显的问题，一些细节都是约定俗成，并不需要别人反复和你强调。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;第二个就是换位思考，假设你是用户，在使用自己开发的功能，难道就没觉得有问题吗？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;任务要做好，而不是做完，做完只是机械地执行，做好就需要动脑思考。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;任务执行过程中，到底有没有对这个任务的方方面面了解清楚呢？&lt;/p&gt;
&lt;p&gt;任务的背景是什么？为什么要做这个功能？什么人在用？到底会关注哪些细节？这个功能定好的实现方案，是否有更好的？现在遇到的这些问题，不解决的话，会留下什么隐患？&lt;/p&gt;
&lt;p&gt;经过这样反复思考，如果觉得有问题，就应该及时反馈、暴露出来、及时沟通和处理。&lt;/p&gt;
&lt;p&gt;而不要觉得，多一事不如少一事，差不多就行了，要是反馈的话，搞不好还增加工作量，我才不傻呢。&lt;/p&gt;
&lt;p&gt;大部分人都会这样想，并没有什么问题，还是那句话，人之常情。&lt;/p&gt;
&lt;p&gt;只是，要算一笔账的话，就会知道，很划不来。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;因为，如果后面功能验收出了问题，除了影响你在工作上的口碑，还有可能会返工，那还是要增加工作量的啊。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;那还不如，从一开始就做到位了。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;当然，有人会说，要是每做一个事情，就经常反馈、提建议，让人觉得自己很难沟通，怎么办？&lt;/p&gt;
&lt;p&gt;确实，有时候，要的就是执行命令，而不是习惯性抬杠。&lt;/p&gt;
&lt;p&gt;但，我想说的是，&lt;strong&gt;要看从集体利益，还是个人利益的角度出发了，如果是集体利益，而不是私心，只要说的有道理，都是应该听取的。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;凡事都可以商量着来。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619904.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;完成比完美更重要&#34;&gt;完成比完美更重要&lt;/h2&gt;
&lt;p&gt;在 2024 年 8 月，3A 大作《黑神话：悟空》上线以来，全网一片好评，很多人评价，包括我，都说是划时代的作品，会在游戏的历史长河中，被铭记于丰碑之上。&lt;/p&gt;
&lt;p&gt;但是，美中不足的是，后面两章，明显没有前面几章那么精细，赶工痕迹特别明显，特别是第六章，整一个大石敢当，实属无语，感觉有点敷衍了。&lt;/p&gt;
&lt;p&gt;如果好好打磨，会更上一层楼。只是没有办法了，没那么多时间了，所以，就像主创冯骥说的：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;“完成比完美更重要。”&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;在现实生活中，同样也是如此，很多坚持打卡的事情，早睡早起啊、坚持跑步啊、坚持控制饮食啊、坚持看书学习啊等等。&lt;/p&gt;
&lt;p&gt;有一些人，比如我，会陷入完美主义的陷阱，比如要在草稿纸上写一段话，如果第一个字感觉没写好，就会撕掉重写，这个现在看来，是有问题的。&lt;/p&gt;
&lt;p&gt;就好像人生，就好像打牌，&lt;strong&gt;不可能每一次开局都那么完美，只能是基于现有的牌，来不断调整策略、方法，然后能打赢。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;之所以写一个字，没写好，就可以撕掉重写，无非就是撕掉一张纸的成本过低罢了，没有伤筋动骨，当然不会觉得有什么。&lt;/p&gt;
&lt;p&gt;但是，无形之中，会养成这种较真的、不切实际的完美主义的思想，对于做好一些事情，是有害处的。&lt;/p&gt;
&lt;p&gt;而这种思维，和上面提的 &lt;strong&gt;“做好，而不是做完”&lt;/strong&gt; 的区别在于，是有先后顺序的，不同的阶段，不同的思维，不应一概而论。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619341.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;最后&#34;&gt;最后&lt;/h2&gt;
&lt;p&gt;总之，不管是工作还是生活，我的结论是：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;首先要有 “做好，而不是做完” 这个意识，等这个意识在你脑海中生根发芽，这是第一步。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;很多事情，你确定自己是真的倾尽全力了，只能做到这一步了，再怎么责备你也没办法了，就算拿把刀架你脖子上，也不会更进一步了。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;然后，这个时候，才可以说，完成比完美更重要，这是第二步。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;这是一个递进的思维意识，而不是像二极管一样，非黑即白，本身就是要辩证地看待。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;只是大部分人，没有第一步的意识，就妄想直接跳到第二步，来为自己的懈怠开脱。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619823.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051620807.png"></p>
<h2 id="前言">前言</h2>
<p>近期，在项目管理过程中，发现了两个值得深思的问题：</p>
<ol>
<li>有的同事任务做完了，但是暴露出很多显而易见的问题；</li>
<li>项目月末统计及时完成率，出现人人达标的情况。</li>
</ol>
<p>这两个问题，都在一定程度上反映出任务执行过程中、项目管理方面存在一些方法不对，或者制度漏洞，导致没有达成预期的效果。</p>
<p>现在，就基于这两个问题，好好分析以及给出对应的解决方案。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619773.jpeg"></p>
<h2 id="任务要做好而不是做完">任务要做好，而不是做完</h2>
<p>在会议室验收功能的时候，有个同事开发的功能模块，比如设备列表，暴露出很多问题。而且，还是一些很明显的问题：</p>
<ol>
<li>列表只是展示 10 条数据，没有滚动条，没有分页，导致后面的数据都看不到；</li>
<li>点击删除按钮的时候，没有二次弹窗让用户确认，而是直接删除了，删除之后列表也没有更新。</li>
</ol>
<p>这些虽然是小问题，但是表面风平浪静，实则暗流涌动，从中可以窥见在水面下的深层问题：</p>
<p><strong>第一个就是没有用心在开发这个功能，这些都是很明显的问题，一些细节都是约定俗成，并不需要别人反复和你强调。</strong></p>
<p><strong>第二个就是换位思考，假设你是用户，在使用自己开发的功能，难道就没觉得有问题吗？</strong></p>
<p><strong>任务要做好，而不是做完，做完只是机械地执行，做好就需要动脑思考。</strong></p>
<p>任务执行过程中，到底有没有对这个任务的方方面面了解清楚呢？</p>
<p>任务的背景是什么？为什么要做这个功能？什么人在用？到底会关注哪些细节？这个功能定好的实现方案，是否有更好的？现在遇到的这些问题，不解决的话，会留下什么隐患？</p>
<p>经过这样反复思考，如果觉得有问题，就应该及时反馈、暴露出来、及时沟通和处理。</p>
<p>而不要觉得，多一事不如少一事，差不多就行了，要是反馈的话，搞不好还增加工作量，我才不傻呢。</p>
<p>大部分人都会这样想，并没有什么问题，还是那句话，人之常情。</p>
<p>只是，要算一笔账的话，就会知道，很划不来。</p>
<p><strong>因为，如果后面功能验收出了问题，除了影响你在工作上的口碑，还有可能会返工，那还是要增加工作量的啊。</strong></p>
<p><strong>那还不如，从一开始就做到位了。</strong></p>
<p>当然，有人会说，要是每做一个事情，就经常反馈、提建议，让人觉得自己很难沟通，怎么办？</p>
<p>确实，有时候，要的就是执行命令，而不是习惯性抬杠。</p>
<p>但，我想说的是，<strong>要看从集体利益，还是个人利益的角度出发了，如果是集体利益，而不是私心，只要说的有道理，都是应该听取的。</strong></p>
<p>凡事都可以商量着来。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619904.jpeg"></p>
<h2 id="完成比完美更重要">完成比完美更重要</h2>
<p>在 2024 年 8 月，3A 大作《黑神话：悟空》上线以来，全网一片好评，很多人评价，包括我，都说是划时代的作品，会在游戏的历史长河中，被铭记于丰碑之上。</p>
<p>但是，美中不足的是，后面两章，明显没有前面几章那么精细，赶工痕迹特别明显，特别是第六章，整一个大石敢当，实属无语，感觉有点敷衍了。</p>
<p>如果好好打磨，会更上一层楼。只是没有办法了，没那么多时间了，所以，就像主创冯骥说的：</p>
<p><strong>“完成比完美更重要。”</strong></p>
<p>在现实生活中，同样也是如此，很多坚持打卡的事情，早睡早起啊、坚持跑步啊、坚持控制饮食啊、坚持看书学习啊等等。</p>
<p>有一些人，比如我，会陷入完美主义的陷阱，比如要在草稿纸上写一段话，如果第一个字感觉没写好，就会撕掉重写，这个现在看来，是有问题的。</p>
<p>就好像人生，就好像打牌，<strong>不可能每一次开局都那么完美，只能是基于现有的牌，来不断调整策略、方法，然后能打赢。</strong></p>
<p>之所以写一个字，没写好，就可以撕掉重写，无非就是撕掉一张纸的成本过低罢了，没有伤筋动骨，当然不会觉得有什么。</p>
<p>但是，无形之中，会养成这种较真的、不切实际的完美主义的思想，对于做好一些事情，是有害处的。</p>
<p>而这种思维，和上面提的 <strong>“做好，而不是做完”</strong> 的区别在于，是有先后顺序的，不同的阶段，不同的思维，不应一概而论。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619341.jpeg"></p>
<h2 id="最后">最后</h2>
<p>总之，不管是工作还是生活，我的结论是：</p>
<p><strong>首先要有 “做好，而不是做完” 这个意识，等这个意识在你脑海中生根发芽，这是第一步。</strong></p>
<p>很多事情，你确定自己是真的倾尽全力了，只能做到这一步了，再怎么责备你也没办法了，就算拿把刀架你脖子上，也不会更进一步了。</p>
<p><strong>然后，这个时候，才可以说，完成比完美更重要，这是第二步。</strong></p>
<p><strong>这是一个递进的思维意识，而不是像二极管一样，非黑即白，本身就是要辩证地看待。</strong></p>
<p><strong>只是大部分人，没有第一步的意识，就妄想直接跳到第二步，来为自己的懈怠开脱。</strong></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202601051619823.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>44-项目的全部生命周期</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/46-%E9%A1%B9%E7%9B%AE%E7%9A%84%E5%85%A8%E9%83%A8%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F/</link>
      <pubDate>Mon, 05 Jan 2026 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/46-%E9%A1%B9%E7%9B%AE%E7%9A%84%E5%85%A8%E9%83%A8%E7%94%9F%E5%91%BD%E5%91%A8%E6%9C%9F/</guid>
      <description>&lt;h4 id=&#34;不是单点突破而是回到源头&#34;&gt;不是单点突破，而是回到源头&lt;/h4&gt;
&lt;p&gt;所以最终还是要回到项目的完整的生命周期，对每一个环节，都要深入分析和研究，确保自己是真的做到位了。&lt;/p&gt;
&lt;p&gt;下一篇，就说明一下完整的项目生命周期有哪些。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241744525.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h4 id="不是单点突破而是回到源头">不是单点突破，而是回到源头</h4>
<p>所以最终还是要回到项目的完整的生命周期，对每一个环节，都要深入分析和研究，确保自己是真的做到位了。</p>
<p>下一篇，就说明一下完整的项目生命周期有哪些。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241744525.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>43-面对探索型功能开发任务，如何避免常见陷阱？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/43-%E9%9D%A2%E5%AF%B9%E6%8E%A2%E7%B4%A2%E5%9E%8B%E5%8A%9F%E8%83%BD%E5%BC%80%E5%8F%91%E4%BB%BB%E5%8A%A1%E5%A6%82%E4%BD%95%E9%81%BF%E5%85%8D%E5%B8%B8%E8%A7%81%E9%99%B7%E9%98%B1/</link>
      <pubDate>Tue, 25 Nov 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/43-%E9%9D%A2%E5%AF%B9%E6%8E%A2%E7%B4%A2%E5%9E%8B%E5%8A%9F%E8%83%BD%E5%BC%80%E5%8F%91%E4%BB%BB%E5%8A%A1%E5%A6%82%E4%BD%95%E9%81%BF%E5%85%8D%E5%B8%B8%E8%A7%81%E9%99%B7%E9%98%B1/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251740681.png&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;
&lt;p&gt;在软件开发过程中，我们经常会遇到一些探索型的功能开发任务，就是那些没有做过、没有参考案例、甚至整个部门都没人有经验的功能开发。&lt;/p&gt;
&lt;p&gt;这种任务往往充满了不确定性，也最容易出现问题。&lt;/p&gt;
&lt;h2 id=&#34;书接上回&#34;&gt;书接上回&lt;/h2&gt;
&lt;p&gt;还记得之前张三和李四因为临时方案爆发的争论吗？&lt;/p&gt;
&lt;p&gt;李四最近的开发工作一直都差强人意。&lt;/p&gt;
&lt;p&gt;每次功能做完在会议上演示，总是会被挑出很多问题：功能实现丢三落四、界面样式不够美观、逻辑处理不够完善等等。&lt;/p&gt;
&lt;h2 id=&#34;问题表现&#34;&gt;问题表现&lt;/h2&gt;
&lt;p&gt;这个问题到底出在哪里呢？是李四做事情不够用心吗？&lt;/p&gt;
&lt;p&gt;经过一段时间的观察，我发现问题主要出在两个方面：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;问题一：需求沟通不到位&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;首先是需求沟通的问题，很多时候，需求给出来的时候就存在可协商的空间，什么意思呢？就是需求描述不够明确，没有达到可量化的程度。&lt;/p&gt;
&lt;p&gt;比如只说 “界面主题色是蓝色”，但没有给出具体的十六进制值。对于开发人员来说，蓝色可以是天蓝色、浅蓝色、粉蓝色，甚至深蓝色。&lt;/p&gt;
&lt;p&gt;结果等开发完成了，你又不满意了，说想要的是深蓝色。这个时候功能都实现完了，找谁说理去？&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251713199.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;问题二：探索型任务的特殊性&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;第二个原因是，李四的开发任务是探索型的任务，这类功能没有做过，甚至整个部门就他一个人开始做。&lt;/p&gt;
&lt;p&gt;对于这种类型的任务，最容易出现的问题就是口头沟通的局限性，两个人在座位上你一句我一句地讨论功能实现、技术预研、技术框架、设计方案、函数封装等，都是口头沟通。&lt;/p&gt;
&lt;p&gt;因为没有参考案例，沟通双方很容易出现 “我觉得我说清楚了，你觉得你听明白了” 的情况。&lt;/p&gt;
&lt;p&gt;结果呢？&lt;/p&gt;
&lt;p&gt;等功能开发出来，李四觉得自己已经做到位了，张三一看，觉得和之前沟通的完全不是一回事儿。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251748358.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;解决方案&#34;&gt;解决方案&lt;/h2&gt;
&lt;p&gt;面对这些问题，我们应该怎么办呢？&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;对策一：需求量化是基础&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;首先，需求必须可量化、可验证，这是解决问题的第一步。&lt;/p&gt;
&lt;p&gt;颜色要给出具体的十六进制值，尺寸要给出具体的像素或百分比，功能要明确输入输出，性能要给出具体的指标要求。&lt;/p&gt;
&lt;p&gt;所以说，&lt;strong&gt;模糊的需求必然导致模糊的结果&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;对策二：方案文档不可少&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;其次，对于探索型任务，方案文档是关键。&lt;/p&gt;
&lt;p&gt;李四应该在开始敲代码前，先在脑子里过一遍整个开发流程，找出可能存在的技术难点和争议点，针对每个难点提供 1-2 个解决方案，然后形成方案文档，文档应包括：做什么、为什么、怎么做、有什么问题、怎么解决、结论。&lt;/p&gt;
&lt;p&gt;一来可以把思路梳理清楚，二来可以提前预知可能出现的问题，&lt;strong&gt;把风险在开发前就排除掉&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;对策三：多人讨论是保障&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;最后，一个人拍脑袋决定的方案往往存在隐患，正确的做法是召集项目负责人、相关同事等一起过一遍方案文档，大家从不同角度提出意见和建议，明确解决方案和实现方式。&lt;/p&gt;
&lt;p&gt;为什么要这么做？&lt;/p&gt;
&lt;p&gt;因为每个人掌握的信息不同，多人讨论可以避免信息盲区，可以发现个人思考中忽略的问题，最重要的是，&lt;strong&gt;集体决策可以分摊责任&lt;/strong&gt;，如果最后方案还是不太理想，也怪不到某一个人头上。&lt;/p&gt;
&lt;h2 id=&#34;总结&#34;&gt;总结&lt;/h2&gt;
&lt;p&gt;说实话，探索性功能开发确实充满挑战，很多人会觉得这类型的任务，最大的难点是在技术层面的攻关，但实际上，&lt;strong&gt;只要做事情的方式不对，同样得不到自己满意的结果&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;所以说，&lt;strong&gt;探索不代表可以随意，创新也需要规范&lt;/strong&gt;。按照正确的流程和方法去做，你会发现，很多看似复杂的问题其实都有章可循。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251741300.jpeg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251740681.png"></p>
<h2 id="前言">前言</h2>
<p>在软件开发过程中，我们经常会遇到一些探索型的功能开发任务，就是那些没有做过、没有参考案例、甚至整个部门都没人有经验的功能开发。</p>
<p>这种任务往往充满了不确定性，也最容易出现问题。</p>
<h2 id="书接上回">书接上回</h2>
<p>还记得之前张三和李四因为临时方案爆发的争论吗？</p>
<p>李四最近的开发工作一直都差强人意。</p>
<p>每次功能做完在会议上演示，总是会被挑出很多问题：功能实现丢三落四、界面样式不够美观、逻辑处理不够完善等等。</p>
<h2 id="问题表现">问题表现</h2>
<p>这个问题到底出在哪里呢？是李四做事情不够用心吗？</p>
<p>经过一段时间的观察，我发现问题主要出在两个方面：</p>
<p><strong>问题一：需求沟通不到位</strong></p>
<p>首先是需求沟通的问题，很多时候，需求给出来的时候就存在可协商的空间，什么意思呢？就是需求描述不够明确，没有达到可量化的程度。</p>
<p>比如只说 “界面主题色是蓝色”，但没有给出具体的十六进制值。对于开发人员来说，蓝色可以是天蓝色、浅蓝色、粉蓝色，甚至深蓝色。</p>
<p>结果等开发完成了，你又不满意了，说想要的是深蓝色。这个时候功能都实现完了，找谁说理去？</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251713199.png"></p>
<p><strong>问题二：探索型任务的特殊性</strong></p>
<p>第二个原因是，李四的开发任务是探索型的任务，这类功能没有做过，甚至整个部门就他一个人开始做。</p>
<p>对于这种类型的任务，最容易出现的问题就是口头沟通的局限性，两个人在座位上你一句我一句地讨论功能实现、技术预研、技术框架、设计方案、函数封装等，都是口头沟通。</p>
<p>因为没有参考案例，沟通双方很容易出现 “我觉得我说清楚了，你觉得你听明白了” 的情况。</p>
<p>结果呢？</p>
<p>等功能开发出来，李四觉得自己已经做到位了，张三一看，觉得和之前沟通的完全不是一回事儿。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251748358.jpeg"></p>
<h2 id="解决方案">解决方案</h2>
<p>面对这些问题，我们应该怎么办呢？</p>
<p><strong>对策一：需求量化是基础</strong></p>
<p>首先，需求必须可量化、可验证，这是解决问题的第一步。</p>
<p>颜色要给出具体的十六进制值，尺寸要给出具体的像素或百分比，功能要明确输入输出，性能要给出具体的指标要求。</p>
<p>所以说，<strong>模糊的需求必然导致模糊的结果</strong>。</p>
<p><strong>对策二：方案文档不可少</strong></p>
<p>其次，对于探索型任务，方案文档是关键。</p>
<p>李四应该在开始敲代码前，先在脑子里过一遍整个开发流程，找出可能存在的技术难点和争议点，针对每个难点提供 1-2 个解决方案，然后形成方案文档，文档应包括：做什么、为什么、怎么做、有什么问题、怎么解决、结论。</p>
<p>一来可以把思路梳理清楚，二来可以提前预知可能出现的问题，<strong>把风险在开发前就排除掉</strong>。</p>
<p><strong>对策三：多人讨论是保障</strong></p>
<p>最后，一个人拍脑袋决定的方案往往存在隐患，正确的做法是召集项目负责人、相关同事等一起过一遍方案文档，大家从不同角度提出意见和建议，明确解决方案和实现方式。</p>
<p>为什么要这么做？</p>
<p>因为每个人掌握的信息不同，多人讨论可以避免信息盲区，可以发现个人思考中忽略的问题，最重要的是，<strong>集体决策可以分摊责任</strong>，如果最后方案还是不太理想，也怪不到某一个人头上。</p>
<h2 id="总结">总结</h2>
<p>说实话，探索性功能开发确实充满挑战，很多人会觉得这类型的任务，最大的难点是在技术层面的攻关，但实际上，<strong>只要做事情的方式不对，同样得不到自己满意的结果</strong>。</p>
<p>所以说，<strong>探索不代表可以随意，创新也需要规范</strong>。按照正确的流程和方法去做，你会发现，很多看似复杂的问题其实都有章可循。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511251741300.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>42-项目紧急情况下，临时方案是救星还是地雷？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/42-%E9%A1%B9%E7%9B%AE%E7%B4%A7%E6%80%A5%E6%83%85%E5%86%B5%E4%B8%8B%E4%B8%B4%E6%97%B6%E6%96%B9%E6%A1%88%E6%98%AF%E6%95%91%E6%98%9F%E8%BF%98%E6%98%AF%E5%9C%B0%E9%9B%B7/</link>
      <pubDate>Mon, 24 Nov 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/42-%E9%A1%B9%E7%9B%AE%E7%B4%A7%E6%80%A5%E6%83%85%E5%86%B5%E4%B8%8B%E4%B8%B4%E6%97%B6%E6%96%B9%E6%A1%88%E6%98%AF%E6%95%91%E6%98%9F%E8%BF%98%E6%98%AF%E5%9C%B0%E9%9B%B7/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241734304.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;前言&#34;&gt;前言&lt;/h2&gt;
&lt;p&gt;说实话，这个事情真的太常见了。在项目开发过程中，时间紧、任务重，大家都想赶紧把功能做出来，这种时候往往就容易出现一些临时方案。&lt;/p&gt;
&lt;p&gt;但是呢，临时方案这个东西，&lt;strong&gt;用好了是救急，用不好就是埋雷&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;今天就给大家分享一个真实发生的案例，看看在项目紧急情况下，我们到底应该怎么处理。&lt;/p&gt;
&lt;h2 id=&#34;事情是这样的&#34;&gt;事情是这样的&lt;/h2&gt;
&lt;p&gt;李四最近在赶一个项目的进度。说实话，时间真的太紧了，按照正常的开发流程，根本来不及完成所有功能。于是呢，李四就动了个心思，用了一些临时的解决方案。&lt;/p&gt;
&lt;p&gt;比如说，有些条件判断、有些循环逻辑，本来应该是根据接口返回的数值来动态设置的，但是为了赶时间，李四直接把这些值硬编码写死了。这样做的好处是，功能马上就能跑起来，测试也能顺利通过。&lt;/p&gt;
&lt;p&gt;但是呢，这种做法在功能、代码规范上面肯定是有问题的。就像你盖房子，本来应该用钢筋混凝土浇筑的柱子，你用了几根木头临时支撑一下，虽然看起来也能立起来，但是，随着楼面东西越来越多，&lt;strong&gt;顶不住是时间问题&lt;/strong&gt;。&lt;/p&gt;
&lt;h2 id=&#34;矛盾爆发&#34;&gt;矛盾爆发&lt;/h2&gt;
&lt;p&gt;项目负责人张三在重构代码的时候，就发现了这个问题。说实话，张三当时就火了，在项目进度例会上直接就和李四争论起来了。&lt;/p&gt;
&lt;p&gt;从张三的角度来说，这种低级错误真的无法理解。代码规范这种约定俗成的东西，难道还需要一遍一遍地强调吗？如果每个人都这样随意修改代码，那项目质量怎么保证？&lt;/p&gt;
&lt;p&gt;从李四的角度来说，他觉得很委屈。当时项目时间那么紧张，我想出了临时方案，至少保证了功能按时上线，自己不但没被表扬，反而被批评，心里真的很不好受。&lt;/p&gt;
&lt;p&gt;双方都觉得自己有道理，看起来这个问题真的很无解。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241735791.jpeg&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;张三的问题&#34;&gt;张三的问题&lt;/h2&gt;
&lt;p&gt;说实话，张三作为项目负责人，也有他的责任。&lt;/p&gt;
&lt;p&gt;首先，&lt;strong&gt;代码审核没有做到位&lt;/strong&gt;。这种明显的硬编码问题，应该在第一时间就发现，而不是等到项目上线后才提出来。&lt;/p&gt;
&lt;p&gt;其次，在李四解释了原因之后，张三不应该过多指责，而是应该给出建设性的建议，帮助李四改进工作方式，避免下次再出现类似的问题。&lt;/p&gt;
&lt;h2 id=&#34;李四的问题&#34;&gt;李四的问题&lt;/h2&gt;
&lt;p&gt;李四的临时方案本身并没有太大问题，毕竟在紧急情况下，有时候确实需要一些特殊手段。&lt;/p&gt;
&lt;p&gt;但是呢，他的处理方式有问题。在使用临时方案之后，他应该有更好的选择：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;方案一：主动告知&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;在群里或者邮件中告知团队成员，说明自己使用了临时方案，并且承诺在时间节点过后会进行完善。这样既能保证项目进度，又能让团队成员了解情况。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;方案二：默默完善&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如果不想让太多人知道，至少在时间节点过后，自己要记得把这些临时方案替换成正式的解决方案。&lt;/p&gt;
&lt;p&gt;但是很遗憾，李四两个选择都没有做。所以才导致了后来的争执。&lt;/p&gt;
&lt;h2 id=&#34;总结&#34;&gt;总结&lt;/h2&gt;
&lt;p&gt;说实话，这个案例虽然看起来很简单，但背后反映的是项目管理中的一个普遍问题。&lt;/p&gt;
&lt;p&gt;在项目开发中，我们经常会遇到各种紧急情况，这时候就需要我们有灵活的应变能力。&lt;/p&gt;
&lt;p&gt;但是，&lt;strong&gt;灵活不等于随意&lt;/strong&gt;，我们需要在保证项目进度的同时，也要保证项目质量。&lt;/p&gt;
&lt;p&gt;最重要的是，遇到问题不要互相指责，而是要互相理解，共同寻找解决方案。&lt;/p&gt;
&lt;p&gt;只有这样，才能让团队变得更强大，项目变得更成功。&lt;/p&gt;
&lt;p&gt;记住，&lt;strong&gt;临时方案可以用，但一定要使用正确的方法，想出一个好点子，并不等于就解决了问题，要在执行层面也做到位，那才是真正的解决了问题，而不是出现新的问题&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241737479.jpeg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241734304.jpeg"></p>
<h2 id="前言">前言</h2>
<p>说实话，这个事情真的太常见了。在项目开发过程中，时间紧、任务重，大家都想赶紧把功能做出来，这种时候往往就容易出现一些临时方案。</p>
<p>但是呢，临时方案这个东西，<strong>用好了是救急，用不好就是埋雷</strong>。</p>
<p>今天就给大家分享一个真实发生的案例，看看在项目紧急情况下，我们到底应该怎么处理。</p>
<h2 id="事情是这样的">事情是这样的</h2>
<p>李四最近在赶一个项目的进度。说实话，时间真的太紧了，按照正常的开发流程，根本来不及完成所有功能。于是呢，李四就动了个心思，用了一些临时的解决方案。</p>
<p>比如说，有些条件判断、有些循环逻辑，本来应该是根据接口返回的数值来动态设置的，但是为了赶时间，李四直接把这些值硬编码写死了。这样做的好处是，功能马上就能跑起来，测试也能顺利通过。</p>
<p>但是呢，这种做法在功能、代码规范上面肯定是有问题的。就像你盖房子，本来应该用钢筋混凝土浇筑的柱子，你用了几根木头临时支撑一下，虽然看起来也能立起来，但是，随着楼面东西越来越多，<strong>顶不住是时间问题</strong>。</p>
<h2 id="矛盾爆发">矛盾爆发</h2>
<p>项目负责人张三在重构代码的时候，就发现了这个问题。说实话，张三当时就火了，在项目进度例会上直接就和李四争论起来了。</p>
<p>从张三的角度来说，这种低级错误真的无法理解。代码规范这种约定俗成的东西，难道还需要一遍一遍地强调吗？如果每个人都这样随意修改代码，那项目质量怎么保证？</p>
<p>从李四的角度来说，他觉得很委屈。当时项目时间那么紧张，我想出了临时方案，至少保证了功能按时上线，自己不但没被表扬，反而被批评，心里真的很不好受。</p>
<p>双方都觉得自己有道理，看起来这个问题真的很无解。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241735791.jpeg"></p>
<h2 id="张三的问题">张三的问题</h2>
<p>说实话，张三作为项目负责人，也有他的责任。</p>
<p>首先，<strong>代码审核没有做到位</strong>。这种明显的硬编码问题，应该在第一时间就发现，而不是等到项目上线后才提出来。</p>
<p>其次，在李四解释了原因之后，张三不应该过多指责，而是应该给出建设性的建议，帮助李四改进工作方式，避免下次再出现类似的问题。</p>
<h2 id="李四的问题">李四的问题</h2>
<p>李四的临时方案本身并没有太大问题，毕竟在紧急情况下，有时候确实需要一些特殊手段。</p>
<p>但是呢，他的处理方式有问题。在使用临时方案之后，他应该有更好的选择：</p>
<p><strong>方案一：主动告知</strong></p>
<p>在群里或者邮件中告知团队成员，说明自己使用了临时方案，并且承诺在时间节点过后会进行完善。这样既能保证项目进度，又能让团队成员了解情况。</p>
<p><strong>方案二：默默完善</strong></p>
<p>如果不想让太多人知道，至少在时间节点过后，自己要记得把这些临时方案替换成正式的解决方案。</p>
<p>但是很遗憾，李四两个选择都没有做。所以才导致了后来的争执。</p>
<h2 id="总结">总结</h2>
<p>说实话，这个案例虽然看起来很简单，但背后反映的是项目管理中的一个普遍问题。</p>
<p>在项目开发中，我们经常会遇到各种紧急情况，这时候就需要我们有灵活的应变能力。</p>
<p>但是，<strong>灵活不等于随意</strong>，我们需要在保证项目进度的同时，也要保证项目质量。</p>
<p>最重要的是，遇到问题不要互相指责，而是要互相理解，共同寻找解决方案。</p>
<p>只有这样，才能让团队变得更强大，项目变得更成功。</p>
<p>记住，<strong>临时方案可以用，但一定要使用正确的方法，想出一个好点子，并不等于就解决了问题，要在执行层面也做到位，那才是真正的解决了问题，而不是出现新的问题</strong>。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202511241737479.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>41-多项目管理中的人员调配思考</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/41-%E5%A4%9A%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E4%B8%AD%E7%9A%84%E4%BA%BA%E5%91%98%E8%B0%83%E9%85%8D%E6%80%9D%E8%80%83/</link>
      <pubDate>Mon, 18 Aug 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/41-%E5%A4%9A%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E4%B8%AD%E7%9A%84%E4%BA%BA%E5%91%98%E8%B0%83%E9%85%8D%E6%80%9D%E8%80%83/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181719035.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在多项目管理过程中，会遇到这样一个问题：有的项目人比较多，有的项目人比较少。&lt;/p&gt;
&lt;p&gt;比如 A 项目有张三、李四、王五等 4 个人，B 项目则只有赵六、王七 2 个人。&lt;/p&gt;
&lt;p&gt;这种情况下，通常会考虑从 A 项目调一个人去支持 B 项目。&lt;/p&gt;
&lt;p&gt;不过在做这个事情之前，得先想明白几个问题：我们为什么要调一个人去支持 B 项目？调谁合适？为什么是他？做这个事情的根本目的又是什么？&lt;/p&gt;
&lt;p&gt;如果不加深究，很容易得出答案：因为 A 项目人多，B 项目人少，适当匀一下，显得更为合理。&lt;/p&gt;
&lt;p&gt;但实际上，人员调配的真正目的是&lt;strong&gt;优化资源结构，把钱花在刀刃上，实现利益最大化。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;从这个角度出发，你会发现事实可能和之前预想的不一样：&lt;/p&gt;
&lt;p&gt;A 项目有 4 个人，B 项目有 2 个人，虽然 B 项目的事情好像更多更杂，表面看更应该加人。&lt;/p&gt;
&lt;p&gt;但&lt;strong&gt;结合项目对部门业绩发展的重要性来评估资源投入&lt;/strong&gt;就会清楚，A 项目是行业项目，B 项目只是对内的、满足公司自身需求的项目。&lt;/p&gt;
&lt;p&gt;显然，这两个项目对部门发展的重要性是不一样的，A 项目很明显更重要。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181726836.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;所以，即便 A 项目人多，B 项目人少又事情多，也不应该从 A 项目调离人员。&lt;/p&gt;
&lt;p&gt;正确的做法是&lt;strong&gt;加快 A 项目的功能迭代&lt;/strong&gt;，同时对 B 项目的功能进行筛选，先做高优先级的，低优先级的就推迟开发。&lt;/p&gt;
&lt;p&gt;除此之外，是否调离人员，还需要评估人员的重要性。&lt;/p&gt;
&lt;p&gt;结合实际情况，&lt;strong&gt;核心成员就该投入到重要性高的项目&lt;/strong&gt;，再结合对他的发展期望，调整到利于他发展的项目中。这样一来，他的能力能得到提升，也容易做出更好的业绩，从而激励到自身。&lt;/p&gt;
&lt;p&gt;还有一点，要尽量不过多变动当前人员负责的业务，不让他们掺杂过多业务，一来精力太分散，容易变得低效；二来人员掺杂过多业务，会加大管理难度，影响多项目推进。&lt;/p&gt;
&lt;p&gt;所以在我看来，多项目管理中的人员调配，可以通过这几个来判断：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;根据&lt;strong&gt;项目对部门业务发展的重要性&lt;/strong&gt;，评估投入资源。重要性高的项目人多，重要性低的项目人少。重要性低的项目事情多，就适当慢下来，按优先级处理。&lt;/li&gt;
&lt;li&gt;依据&lt;strong&gt;成员的重要性&lt;/strong&gt;进行调配，核心成员投入到重要性高的项目，利于其发展、做出业绩，实现自我激励。&lt;/li&gt;
&lt;li&gt;&lt;strong&gt;避免人员参与过多业务&lt;/strong&gt;，以最小力度调整人员，保持业务的稳定性。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181722214.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181719035.jpeg"></p>
<p>在多项目管理过程中，会遇到这样一个问题：有的项目人比较多，有的项目人比较少。</p>
<p>比如 A 项目有张三、李四、王五等 4 个人，B 项目则只有赵六、王七 2 个人。</p>
<p>这种情况下，通常会考虑从 A 项目调一个人去支持 B 项目。</p>
<p>不过在做这个事情之前，得先想明白几个问题：我们为什么要调一个人去支持 B 项目？调谁合适？为什么是他？做这个事情的根本目的又是什么？</p>
<p>如果不加深究，很容易得出答案：因为 A 项目人多，B 项目人少，适当匀一下，显得更为合理。</p>
<p>但实际上，人员调配的真正目的是<strong>优化资源结构，把钱花在刀刃上，实现利益最大化。</strong></p>
<p>从这个角度出发，你会发现事实可能和之前预想的不一样：</p>
<p>A 项目有 4 个人，B 项目有 2 个人，虽然 B 项目的事情好像更多更杂，表面看更应该加人。</p>
<p>但<strong>结合项目对部门业绩发展的重要性来评估资源投入</strong>就会清楚，A 项目是行业项目，B 项目只是对内的、满足公司自身需求的项目。</p>
<p>显然，这两个项目对部门发展的重要性是不一样的，A 项目很明显更重要。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181726836.jpeg"></p>
<p>所以，即便 A 项目人多，B 项目人少又事情多，也不应该从 A 项目调离人员。</p>
<p>正确的做法是<strong>加快 A 项目的功能迭代</strong>，同时对 B 项目的功能进行筛选，先做高优先级的，低优先级的就推迟开发。</p>
<p>除此之外，是否调离人员，还需要评估人员的重要性。</p>
<p>结合实际情况，<strong>核心成员就该投入到重要性高的项目</strong>，再结合对他的发展期望，调整到利于他发展的项目中。这样一来，他的能力能得到提升，也容易做出更好的业绩，从而激励到自身。</p>
<p>还有一点，要尽量不过多变动当前人员负责的业务，不让他们掺杂过多业务，一来精力太分散，容易变得低效；二来人员掺杂过多业务，会加大管理难度，影响多项目推进。</p>
<p>所以在我看来，多项目管理中的人员调配，可以通过这几个来判断：</p>
<ol>
<li>根据<strong>项目对部门业务发展的重要性</strong>，评估投入资源。重要性高的项目人多，重要性低的项目人少。重要性低的项目事情多，就适当慢下来，按优先级处理。</li>
<li>依据<strong>成员的重要性</strong>进行调配，核心成员投入到重要性高的项目，利于其发展、做出业绩，实现自我激励。</li>
<li><strong>避免人员参与过多业务</strong>，以最小力度调整人员，保持业务的稳定性。</li>
</ol>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508181722214.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>45-落后就要挨打</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/47-%E8%90%BD%E5%90%8E%E5%B0%B1%E8%A6%81%E6%8C%A8%E6%89%93/</link>
      <pubDate>Mon, 18 Aug 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/47-%E8%90%BD%E5%90%8E%E5%B0%B1%E8%A6%81%E6%8C%A8%E6%89%93/</guid>
      <description>&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;自身实力是根本（打铁还需自身硬）&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;结果导向，不迷信过程&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;主干线思维，聚焦核心目标&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;第一性原理，目标导向的方法选择&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;把自己当成一个&amp;quot;国家&amp;quot;来经营&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打铁还需自身硬，落后就要挨打。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;只看结果，不注重过程，不迷信苦劳，只相信拿到结果。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&amp;quot;如何获得客户签约&amp;quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<ol>
<li>
<p>自身实力是根本（打铁还需自身硬）</p>
</li>
<li>
<p>结果导向，不迷信过程</p>
</li>
<li>
<p>主干线思维，聚焦核心目标</p>
</li>
<li>
<p>第一性原理，目标导向的方法选择</p>
</li>
<li>
<p>把自己当成一个&quot;国家&quot;来经营</p>
</li>
<li>
<p>强如教员都有过屈辱的经历，我这点小小的委屈，又算得了什么？</p>
</li>
<li>
<p>打铁还需自身硬，落后就要挨打。</p>
</li>
<li>
<p>国与国之间，人与人之间，都是如此。如果不清楚怎么处理人与人之间的关系，那么可以把自己当成一个国家，看国家与国家之间是怎么处理这种关系的。打铁还需自身硬，落后就要挨打，古往今来，都是如此。就需要把自己当成一个国家来生存。看看中国近代史，是怎么变成现在这般强大的，又是付出了什么努力，多少鲜血和汗水？</p>
</li>
<li>
<p>只看结果，不注重过程，不迷信苦劳，只相信拿到结果。</p>
</li>
<li>
<p>打工人的思路：主干线为主，其他分支为辅，影响到主干线的，要么加班抽时间解决，要么砍掉或者下放任务给到其他人解决。</p>
</li>
<li>
<p>接到新任务做法：先判断是否对主干线有利，否则其他人来做或不做。</p>
</li>
<li>
<p>使用第一性原理，目标是什么？不用完全遵照现有的方式、方案来执行，只要达成目标，不管什么方法都可以。</p>
</li>
<li>
<p>PBL的核心是在解决实际问题中学习成长。你的每一个学习行动都要围绕&quot;如何获得客户签约&quot;这个核心问题展开。不要只是学习，要在实战中学习，在解决问题中成长！</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>40-AI代码评审出现幻觉问题应该怎么处理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/40-ai%E4%BB%A3%E7%A0%81%E8%AF%84%E5%AE%A1%E5%87%BA%E7%8E%B0%E5%B9%BB%E8%A7%89%E9%97%AE%E9%A2%98%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86/</link>
      <pubDate>Wed, 13 Aug 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/40-ai%E4%BB%A3%E7%A0%81%E8%AF%84%E5%AE%A1%E5%87%BA%E7%8E%B0%E5%B9%BB%E8%A7%89%E9%97%AE%E9%A2%98%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508142154693.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在之前的文章《37-AI 时代，代码评审方式究竟怎样优化？关键要点有哪些？》中已经提到，AI 代码评审基于 &lt;a href=&#34;https://github.com/mimo-x/Code-Review-GPT-Gitlab&#34;&gt;Code-Review-GPT-Gitlab&lt;/a&gt; 进行使用，因为这个开源库包含评分机制、问题反馈、修改建议和修正后的代码等部分，比较符合我的预期。&lt;/p&gt;
&lt;p&gt;在使用了一段时间之后，考虑到要基于流程规范来操作，项目成员提交代码后，最好能看到 AI 代码评审报告，然后根据反馈的问题修改后再提交代码。&lt;/p&gt;
&lt;p&gt;但怎样才算修改好了呢？这就需要制定一个标准，比如将 90 分作为评分标准，每个分支提交到仓库时，都需要达到 90 分以上，代码才能入库。&lt;/p&gt;
&lt;p&gt;然而，以 90 分作为标准执行一段时间后，有同事反馈这个标准可能不太合理。因为通过 AI 代码评审，出现了一些幻觉问题，这会导致评分不准确，使得 90 分的要求难以达成。&lt;/p&gt;
&lt;p&gt;幻觉问题一直是当下 AI 面临的较大难题，在我看来，这并非完全是由于私有化部署时使用的模型小、性能不够强大所致，很多市面上很强大的 AI 工具，同样存在这个问题。&lt;/p&gt;
&lt;p&gt;加上，其实提交的代码只是变更部分，AI 代码评审时，只会对 diff 部分进行检查，这就会存在对业务认知不完整的问题，因为&lt;strong&gt;项目中一个完整的业务功能，并不一定就在一个文件里完整呈现的。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;因此，流程调整为采用 “AI 预评审 + 人工复核” 的方式，依旧按照 90 分的评分要求，具体问题具体分析。如果出现幻觉问题，则灵活处理，而非因噎废食。&lt;/p&gt;
&lt;p&gt;关于幻觉问题，一方面可以考虑升级配置，比如购买性能更好的显卡；另一方面只能等待行业发展，以有效解决 AI 幻觉问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508142154200.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在《当 99% 可靠性是及格线，我们如何为大模型装上工程 “安全带”？》这篇文章中，提到了对幻觉问题的探索和解决，后续发展情况仍需持续关注：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;在 2025 世界人工智能大会（WAIC）上，蚂蚁集团旗下蚂蚁密算宣布对外开源高阶程序（High-Order Program）大模型可信应用技术框架，通过外部化控制与核验，为构建可信、可控、可维护的大模型应用提供了务实的参考标准。&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;除此之外，项目成员在提交代码之前，需要在 VSCode 中使用豆包 AI 插件，对所有改动的文件进行检查。&lt;/p&gt;
&lt;p&gt;这样至少能在提交代码、进行分支合并之前，在本地提前暴露问题，无需等到提交代码后再用 AI 进行代码评审，从而简化大量工作。&lt;/p&gt;
&lt;p&gt;不过，在本地使用豆包 AI 插件检查改动的代码时，无需过度检查。因为我发现，每次提问都会得到问题反馈，即便复制它建议的代码去询问，仍然会收到很多建议，这会让人感觉没完没了。&lt;/p&gt;
&lt;p&gt;毕竟代码的写法、规范并非只有一套，功能的实现细节也千差万别，并非绝对统一。所以，只需检查一次，把特别明显的问题改掉即可，若是吹毛求疵，只会陷入无尽的循环。&lt;/p&gt;
&lt;p&gt;至此，我之前认为代码评审完全可以由 AI 来完成并让整个流程顺畅运转的想法，显然有些激进了。&lt;/p&gt;
&lt;p&gt;以当前情况来看，无论 AI 代码评审能达到何种程度，即便幻觉问题能得到有效解决，也不应该完全由 AI 来承担这项工作。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508142154693.jpeg"></p>
<p>在之前的文章《37-AI 时代，代码评审方式究竟怎样优化？关键要点有哪些？》中已经提到，AI 代码评审基于 <a href="https://github.com/mimo-x/Code-Review-GPT-Gitlab">Code-Review-GPT-Gitlab</a> 进行使用，因为这个开源库包含评分机制、问题反馈、修改建议和修正后的代码等部分，比较符合我的预期。</p>
<p>在使用了一段时间之后，考虑到要基于流程规范来操作，项目成员提交代码后，最好能看到 AI 代码评审报告，然后根据反馈的问题修改后再提交代码。</p>
<p>但怎样才算修改好了呢？这就需要制定一个标准，比如将 90 分作为评分标准，每个分支提交到仓库时，都需要达到 90 分以上，代码才能入库。</p>
<p>然而，以 90 分作为标准执行一段时间后，有同事反馈这个标准可能不太合理。因为通过 AI 代码评审，出现了一些幻觉问题，这会导致评分不准确，使得 90 分的要求难以达成。</p>
<p>幻觉问题一直是当下 AI 面临的较大难题，在我看来，这并非完全是由于私有化部署时使用的模型小、性能不够强大所致，很多市面上很强大的 AI 工具，同样存在这个问题。</p>
<p>加上，其实提交的代码只是变更部分，AI 代码评审时，只会对 diff 部分进行检查，这就会存在对业务认知不完整的问题，因为<strong>项目中一个完整的业务功能，并不一定就在一个文件里完整呈现的。</strong></p>
<p>因此，流程调整为采用 “AI 预评审 + 人工复核” 的方式，依旧按照 90 分的评分要求，具体问题具体分析。如果出现幻觉问题，则灵活处理，而非因噎废食。</p>
<p>关于幻觉问题，一方面可以考虑升级配置，比如购买性能更好的显卡；另一方面只能等待行业发展，以有效解决 AI 幻觉问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508142154200.jpeg"></p>
<p>在《当 99% 可靠性是及格线，我们如何为大模型装上工程 “安全带”？》这篇文章中，提到了对幻觉问题的探索和解决，后续发展情况仍需持续关注：</p>
<blockquote>
<p>在 2025 世界人工智能大会（WAIC）上，蚂蚁集团旗下蚂蚁密算宣布对外开源高阶程序（High-Order Program）大模型可信应用技术框架，通过外部化控制与核验，为构建可信、可控、可维护的大模型应用提供了务实的参考标准。</p></blockquote>
<p>除此之外，项目成员在提交代码之前，需要在 VSCode 中使用豆包 AI 插件，对所有改动的文件进行检查。</p>
<p>这样至少能在提交代码、进行分支合并之前，在本地提前暴露问题，无需等到提交代码后再用 AI 进行代码评审，从而简化大量工作。</p>
<p>不过，在本地使用豆包 AI 插件检查改动的代码时，无需过度检查。因为我发现，每次提问都会得到问题反馈，即便复制它建议的代码去询问，仍然会收到很多建议，这会让人感觉没完没了。</p>
<p>毕竟代码的写法、规范并非只有一套，功能的实现细节也千差万别，并非绝对统一。所以，只需检查一次，把特别明显的问题改掉即可，若是吹毛求疵，只会陷入无尽的循环。</p>
<p>至此，我之前认为代码评审完全可以由 AI 来完成并让整个流程顺畅运转的想法，显然有些激进了。</p>
<p>以当前情况来看，无论 AI 代码评审能达到何种程度，即便幻觉问题能得到有效解决，也不应该完全由 AI 来承担这项工作。</p>
<p>采用 <strong>“本地 AI 插件检查 + AI 预评审 + 人工复核”</strong> 这三个步骤，或许更为合理。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508142154641.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>39-项目负责人怎么安排不同技术栈成员的任务</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/39-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E6%80%8E%E4%B9%88%E5%AE%89%E6%8E%92%E4%B8%8D%E5%90%8C%E6%8A%80%E6%9C%AF%E6%A0%88%E6%88%90%E5%91%98%E7%9A%84%E4%BB%BB%E5%8A%A1/</link>
      <pubDate>Sun, 10 Aug 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/39-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E6%80%8E%E4%B9%88%E5%AE%89%E6%8E%92%E4%B8%8D%E5%90%8C%E6%8A%80%E6%9C%AF%E6%A0%88%E6%88%90%E5%91%98%E7%9A%84%E4%BB%BB%E5%8A%A1/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102123383.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;一般而言，项目的任务计划都是由项目负责人制定的，其中需要明确每一条任务的优先级、开发周期和开发负责人。&lt;/p&gt;
&lt;p&gt;但是，有些项目负责人的技术背景是前端，有的是后端，还有的是终端。&lt;/p&gt;
&lt;p&gt;这就会遇到一个问题：&lt;strong&gt;他们怎么去制定其他技术栈成员的任务并进行验收？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;在此之前，我们默认都是由项目负责人完成这些工作的。比如，项目负责人张三是前端出身，现在他要给后端的李四制定开发任务。&lt;/p&gt;
&lt;p&gt;通常的做法是，张三会和李四沟通要开发的功能，然后由李四给出功能开发所需的时间，接着张三填写任务时间，任务安排便完成了。&lt;/p&gt;
&lt;p&gt;这里就存在可操作的空间，因为李四给出的时间没有第二人进行审核。而张三是前端出身，并不具备审核后端任务时间的能力。如此一来，任务安排就完全取决于李四是否厚道了。&lt;/p&gt;
&lt;p&gt;我们一直反复强调人性，可依赖人性做事情，迟早会出问题。&lt;/p&gt;
&lt;p&gt;今天李四心情好，可能就凭良心给出合理时间；哪天他心情不好，或许就会把任务时间拉长，好趁机摸鱼。&lt;/p&gt;
&lt;p&gt;写到这里，我想起 2020 年的几场培训，培训老师说过的一句话让我印象深刻：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;“如果你不想吃亏的话，要以最坏的情况去判断你的员工。”&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102125324.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;即便李四为人厚道、兢兢业业，不会偷奸耍滑，那你能保证王五、赵六也不会这样吗？&lt;/p&gt;
&lt;p&gt;你真的有时间和精力去仔细分析每个人，或者持续观察他们的一言一行吗？&lt;/p&gt;
&lt;p&gt;那样的话，你自己就不用干活了。&lt;/p&gt;
&lt;p&gt;所以，还是要回归到流程规范上来，不回避任何问题，把它暴露在阳光下，通过望闻问切，仔细分析原因和我们的诉求。&lt;/p&gt;
&lt;p&gt;接着就是大家沟通&lt;strong&gt;达成共识&lt;/strong&gt;，用规定来约束，用流程从源头解决问题。&lt;/p&gt;
&lt;p&gt;那接下来，如何从流程规范入手解决这个问题呢？&lt;/p&gt;
&lt;p&gt;这要从我们的目的出发，我们的目的是&lt;strong&gt;对任务进行有效制定、跟进和验收，而不是流于形式。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;既然要 &lt;strong&gt;“有效”&lt;/strong&gt;，就要实事求是，杜绝虚假。而规避虚假的办法，就是&lt;strong&gt;专业的事情交给专业的人。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;现实情况是，项目负责人并非全能全知，所以可以把这部分工作交给对应的同事来执行，引入&lt;strong&gt;技术端负责人&lt;/strong&gt;的角色。&lt;/p&gt;
&lt;p&gt;各项目可根据实际情况，设立前端负责人、后端负责人和终端负责人。他们的职责是协助项目负责人明确对应技术端任务的开发所需时间，跟进任务进展，并负责验收。&lt;/p&gt;
&lt;p&gt;整个项目的人员架构就变成：&lt;strong&gt;项目成员 - 技术端负责人 - 项目负责人&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;那么，项目成员的任务申请时间变更，由谁来审核呢？&lt;/p&gt;
&lt;p&gt;本来我觉得，项目的全部任务本应由项目负责人审核，而技术端负责人已经对开发周期（即天数）进行了把关，项目负责人依据这一点判断即可。&lt;/p&gt;
&lt;p&gt;但技术端负责人需要覆盖三个关键环节：制定、跟进和验收。变更属于跟进部分，如果这一环节改由项目负责人执行，整个任务的生命周期就无法形成闭环了。&lt;/p&gt;
&lt;p&gt;在项目管理系统中，曾经的设计思路是：&lt;strong&gt;项目成员的任务时间变更，审核人都是项目负责人。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如果现在引入端负责人的角色，那么&lt;strong&gt;技术端成员的任务时间变更就应由对应的技术端负责人审核，而技术端负责人的任务变更则由项目负责人审核。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;至此，我认为可以解决项目负责人如何制定、跟进和验收不同技术栈成员任务的问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102125244.jpg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102123383.jpg"></p>
<p>一般而言，项目的任务计划都是由项目负责人制定的，其中需要明确每一条任务的优先级、开发周期和开发负责人。</p>
<p>但是，有些项目负责人的技术背景是前端，有的是后端，还有的是终端。</p>
<p>这就会遇到一个问题：<strong>他们怎么去制定其他技术栈成员的任务并进行验收？</strong></p>
<p>在此之前，我们默认都是由项目负责人完成这些工作的。比如，项目负责人张三是前端出身，现在他要给后端的李四制定开发任务。</p>
<p>通常的做法是，张三会和李四沟通要开发的功能，然后由李四给出功能开发所需的时间，接着张三填写任务时间，任务安排便完成了。</p>
<p>这里就存在可操作的空间，因为李四给出的时间没有第二人进行审核。而张三是前端出身，并不具备审核后端任务时间的能力。如此一来，任务安排就完全取决于李四是否厚道了。</p>
<p>我们一直反复强调人性，可依赖人性做事情，迟早会出问题。</p>
<p>今天李四心情好，可能就凭良心给出合理时间；哪天他心情不好，或许就会把任务时间拉长，好趁机摸鱼。</p>
<p>写到这里，我想起 2020 年的几场培训，培训老师说过的一句话让我印象深刻：</p>
<p><strong>“如果你不想吃亏的话，要以最坏的情况去判断你的员工。”</strong></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102125324.jpg"></p>
<p>即便李四为人厚道、兢兢业业，不会偷奸耍滑，那你能保证王五、赵六也不会这样吗？</p>
<p>你真的有时间和精力去仔细分析每个人，或者持续观察他们的一言一行吗？</p>
<p>那样的话，你自己就不用干活了。</p>
<p>所以，还是要回归到流程规范上来，不回避任何问题，把它暴露在阳光下，通过望闻问切，仔细分析原因和我们的诉求。</p>
<p>接着就是大家沟通<strong>达成共识</strong>，用规定来约束，用流程从源头解决问题。</p>
<p>那接下来，如何从流程规范入手解决这个问题呢？</p>
<p>这要从我们的目的出发，我们的目的是<strong>对任务进行有效制定、跟进和验收，而不是流于形式。</strong></p>
<p>既然要 <strong>“有效”</strong>，就要实事求是，杜绝虚假。而规避虚假的办法，就是<strong>专业的事情交给专业的人。</strong></p>
<p>现实情况是，项目负责人并非全能全知，所以可以把这部分工作交给对应的同事来执行，引入<strong>技术端负责人</strong>的角色。</p>
<p>各项目可根据实际情况，设立前端负责人、后端负责人和终端负责人。他们的职责是协助项目负责人明确对应技术端任务的开发所需时间，跟进任务进展，并负责验收。</p>
<p>整个项目的人员架构就变成：<strong>项目成员 - 技术端负责人 - 项目负责人</strong>。</p>
<p>那么，项目成员的任务申请时间变更，由谁来审核呢？</p>
<p>本来我觉得，项目的全部任务本应由项目负责人审核，而技术端负责人已经对开发周期（即天数）进行了把关，项目负责人依据这一点判断即可。</p>
<p>但技术端负责人需要覆盖三个关键环节：制定、跟进和验收。变更属于跟进部分，如果这一环节改由项目负责人执行，整个任务的生命周期就无法形成闭环了。</p>
<p>在项目管理系统中，曾经的设计思路是：<strong>项目成员的任务时间变更，审核人都是项目负责人。</strong></p>
<p>如果现在引入端负责人的角色，那么<strong>技术端成员的任务时间变更就应由对应的技术端负责人审核，而技术端负责人的任务变更则由项目负责人审核。</strong></p>
<p>至此，我认为可以解决项目负责人如何制定、跟进和验收不同技术栈成员任务的问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508102125244.jpg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>38-别让进度汇报成流水账，拆解任务加明确要求就管用</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/38-%E5%88%AB%E8%AE%A9%E8%BF%9B%E5%BA%A6%E6%B1%87%E6%8A%A5%E6%88%90%E6%B5%81%E6%B0%B4%E8%B4%A6%E6%8B%86%E8%A7%A3%E4%BB%BB%E5%8A%A1%E5%8A%A0%E6%98%8E%E7%A1%AE%E8%A6%81%E6%B1%82%E5%B0%B1%E7%AE%A1%E7%94%A8/</link>
      <pubDate>Mon, 21 Jul 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/38-%E5%88%AB%E8%AE%A9%E8%BF%9B%E5%BA%A6%E6%B1%87%E6%8A%A5%E6%88%90%E6%B5%81%E6%B0%B4%E8%B4%A6%E6%8B%86%E8%A7%A3%E4%BB%BB%E5%8A%A1%E5%8A%A0%E6%98%8E%E7%A1%AE%E8%A6%81%E6%B1%82%E5%B0%B1%E7%AE%A1%E7%94%A8/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211814509.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在这篇文章《19 - 过进度方式二：项目成员依次说明和演示任务完成情况》中，已经讲明了当前项目过进度的方式：要求各项目成员到前面的座位来，把上两周以及下两周要做的工作情况汇报一下。&lt;/p&gt;
&lt;p&gt;但是，在执行大半年的时间里，发现有的项目成员在会议上汇报自己任务情况时，只是简单说明内容，两三句话就说完了。&lt;/p&gt;
&lt;p&gt;怎么引导项目成员更多地反馈工作中的情况，而不是让会议变成形式化、流水账式的无意义会议呢？&lt;/p&gt;
&lt;p&gt;我反复思考了一下，项目成员为什么不想说那么多呢？这个点其实在《19 - 过进度方式二：项目成员依次说明和演示任务完成情况》中也有过分析，这里就不再过多赘述了，无外乎就是多一事不如少一事 —— &lt;strong&gt;只要我说得越少，问题也就越少。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;不过，我也能想到其他的可能，比如 “就是线上修复了几个 Bug，没有什么可说的”“就是正常的功能开发，没什么可说的”“我做的是其他项目的，跟其他人关系不大，没什么可说的”。&lt;/p&gt;
&lt;p&gt;关键点就在于 &lt;strong&gt;“没有什么可说的”&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;为什么没有什么可说的呢？&lt;/p&gt;
&lt;p&gt;难道每个人在开发的过程中，真的一点问题都没有吗？&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211815841.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;每一条任务的制定，都包含需求、方案、研发、技术笔记和验收等多个环节。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这几个环节中，总该有可以说的点吧？&lt;/p&gt;
&lt;p&gt;但是，为什么没有什么可说的呢？原因就是没有做好相关的工作。&lt;/p&gt;
&lt;p&gt;很多需求只是一句话，或者口头说一下；很多方案也只是当面沟通一下，沟通好就完事了，没有整理成方案文档记录下来。&lt;/p&gt;
&lt;p&gt;至于研发过程中遇到的问题，&lt;strong&gt;有些 Bug 在没解决之前是 Bug，解决之后恍然大悟，就会觉得问题不值一提&lt;/strong&gt; “原来如此，我居然会犯这个低级错误？” 所以，也就觉得没有什么值得总结和记录的了。&lt;/p&gt;
&lt;p&gt;还有技术笔记，写这个是要花时间的，完全看每个人是否自觉去做，那真的太难了，大多数人的想法是，还不如省下这些时间去做下一条任务。&lt;/p&gt;
&lt;p&gt;甚至，有些人会觉得，这种知识点还要写技术笔记，会不会让人觉得自己技术很菜、水平很低，还不如不写。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211816234.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;任何问题都要透过表象抓住本质，一般这种问题，只是从人身上入手，效果不会很理想的，你可以口头要求对方一次两次，过段时间，只要你稍微疏忽了，对方也就松懈了，所以，还是要从源头去解决，也就是&lt;strong&gt;要从流程入手、从规章制度入手&lt;/strong&gt;，经过沟通讨论，定下一些规定，让大家一起遵守就好。&lt;/p&gt;
&lt;p&gt;比如，&lt;strong&gt;项目负责人在制定任务的时候，需要把任务要求写清楚，任务要先整理详细的需求文档、解决方案和技术笔记。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;之前可能只是 1 条 “支持 10 万台设备接入”的开发任务，里面涵盖着想让成员写各种文档的期望，现在这个事情直接挑明了，拆分成 3 条任务：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;支持 10 万台设备接入需求文档&lt;/li&gt;
&lt;li&gt;支持 10 万台设备接入解决方案&lt;/li&gt;
&lt;li&gt;XXX 框架基本使用、疑难问题解决等技术笔记&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;这样，就把之前依赖项目成员自觉的工作，变成硬性要求，以任务形式下达，让工作从无序变成有序，从无条理变为有章法。&lt;/p&gt;
&lt;p&gt;在这个基础上，项目进度会议中项目成员汇报进度时，就可以把这些资料都过一遍，然后再进行验收，应该能有效解决会议流水账的问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211817317.jpeg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211814509.jpeg"></p>
<p>在这篇文章《19 - 过进度方式二：项目成员依次说明和演示任务完成情况》中，已经讲明了当前项目过进度的方式：要求各项目成员到前面的座位来，把上两周以及下两周要做的工作情况汇报一下。</p>
<p>但是，在执行大半年的时间里，发现有的项目成员在会议上汇报自己任务情况时，只是简单说明内容，两三句话就说完了。</p>
<p>怎么引导项目成员更多地反馈工作中的情况，而不是让会议变成形式化、流水账式的无意义会议呢？</p>
<p>我反复思考了一下，项目成员为什么不想说那么多呢？这个点其实在《19 - 过进度方式二：项目成员依次说明和演示任务完成情况》中也有过分析，这里就不再过多赘述了，无外乎就是多一事不如少一事 —— <strong>只要我说得越少，问题也就越少。</strong></p>
<p>不过，我也能想到其他的可能，比如 “就是线上修复了几个 Bug，没有什么可说的”“就是正常的功能开发，没什么可说的”“我做的是其他项目的，跟其他人关系不大，没什么可说的”。</p>
<p>关键点就在于 <strong>“没有什么可说的”</strong>。</p>
<p>为什么没有什么可说的呢？</p>
<p>难道每个人在开发的过程中，真的一点问题都没有吗？</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211815841.jpeg"></p>
<p><strong>每一条任务的制定，都包含需求、方案、研发、技术笔记和验收等多个环节。</strong></p>
<p>这几个环节中，总该有可以说的点吧？</p>
<p>但是，为什么没有什么可说的呢？原因就是没有做好相关的工作。</p>
<p>很多需求只是一句话，或者口头说一下；很多方案也只是当面沟通一下，沟通好就完事了，没有整理成方案文档记录下来。</p>
<p>至于研发过程中遇到的问题，<strong>有些 Bug 在没解决之前是 Bug，解决之后恍然大悟，就会觉得问题不值一提</strong> “原来如此，我居然会犯这个低级错误？” 所以，也就觉得没有什么值得总结和记录的了。</p>
<p>还有技术笔记，写这个是要花时间的，完全看每个人是否自觉去做，那真的太难了，大多数人的想法是，还不如省下这些时间去做下一条任务。</p>
<p>甚至，有些人会觉得，这种知识点还要写技术笔记，会不会让人觉得自己技术很菜、水平很低，还不如不写。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211816234.jpeg"></p>
<p>任何问题都要透过表象抓住本质，一般这种问题，只是从人身上入手，效果不会很理想的，你可以口头要求对方一次两次，过段时间，只要你稍微疏忽了，对方也就松懈了，所以，还是要从源头去解决，也就是<strong>要从流程入手、从规章制度入手</strong>，经过沟通讨论，定下一些规定，让大家一起遵守就好。</p>
<p>比如，<strong>项目负责人在制定任务的时候，需要把任务要求写清楚，任务要先整理详细的需求文档、解决方案和技术笔记。</strong></p>
<p>之前可能只是 1 条 “支持 10 万台设备接入”的开发任务，里面涵盖着想让成员写各种文档的期望，现在这个事情直接挑明了，拆分成 3 条任务：</p>
<ol>
<li>支持 10 万台设备接入需求文档</li>
<li>支持 10 万台设备接入解决方案</li>
<li>XXX 框架基本使用、疑难问题解决等技术笔记</li>
</ol>
<p>这样，就把之前依赖项目成员自觉的工作，变成硬性要求，以任务形式下达，让工作从无序变成有序，从无条理变为有章法。</p>
<p>在这个基础上，项目进度会议中项目成员汇报进度时，就可以把这些资料都过一遍，然后再进行验收，应该能有效解决会议流水账的问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507211817317.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>37-AI 时代，代码评审方式究竟怎样优化？关键要点有哪些？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/37-ai-%E6%97%B6%E4%BB%A3%E4%BB%A3%E7%A0%81%E8%AF%84%E5%AE%A1%E6%96%B9%E5%BC%8F%E7%A9%B6%E7%AB%9F%E6%80%8E%E6%A0%B7%E4%BC%98%E5%8C%96%E5%85%B3%E9%94%AE%E8%A6%81%E7%82%B9%E6%9C%89%E5%93%AA%E4%BA%9B/</link>
      <pubDate>Wed, 02 Jul 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/37-ai-%E6%97%B6%E4%BB%A3%E4%BB%A3%E7%A0%81%E8%AF%84%E5%AE%A1%E6%96%B9%E5%BC%8F%E7%A9%B6%E7%AB%9F%E6%80%8E%E6%A0%B7%E4%BC%98%E5%8C%96%E5%85%B3%E9%94%AE%E8%A6%81%E7%82%B9%E6%9C%89%E5%93%AA%E4%BA%9B/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021608296.jpeg&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;背景&#34;&gt;背景&lt;/h1&gt;
&lt;p&gt;在项目开发过程中，代码评审还是很重要的，主要是为了解决代码规范、功能开发方式、相互学习等问题，代码是否符合规范，关系到项目成员协作的问题。&lt;/p&gt;
&lt;p&gt;如果写出来的代码风格五花八门，那么，在沟通交流上面，就额外增加了难度，而这是完全没有必要的。&lt;/p&gt;
&lt;p&gt;除此之外，上面说到的功能开发方式问题，意思就是，每个人都有可能是孤岛，一个人的想法可能会有缺陷，如果多个人沟通以及探讨，相互学习，有可能会从不同视角发现潜在的问题。&lt;/p&gt;
&lt;h1 id=&#34;人工代码评审&#34;&gt;人工代码评审&lt;/h1&gt;
&lt;p&gt;一直以来，我们要做项目代码评审，通常都是有这几种方式，比如项目组成员交叉验收各自的功能代码，然后把问题整理到文档，再一起组织代码评审会议，把问题都过一遍，然后安排任务去调整。一方面解决了代码存在的问题，另一方面通过深入交流，大家相互学习。&lt;/p&gt;
&lt;p&gt;还有，就是在 GitLab 代码合并阶段，项目成员发起功能分支合并至主分支，由项目负责人去审查项目成员提交的代码分支。&lt;/p&gt;
&lt;p&gt;如果没有问题，则合并到主分支；如果有问题，则反馈给项目成员。待项目成员修复完成再次发起分支代码合并，然后，项目负责人确认之后，合并到主分支。这个应该就是常规的代码评审流程。&lt;/p&gt;
&lt;p&gt;但是，随着团队的发展以及对降本增效的要求，开始着手去研究，团队中哪些工作是有可优化的空间？&lt;/p&gt;
&lt;p&gt;项目负责人承担的工作事务越来越多，怎么去有效简化无意义的工作，成为了当前亟需解决的问题。&lt;/p&gt;
&lt;h1 id=&#34;sonarqube&#34;&gt;SonarQube&lt;/h1&gt;
&lt;p&gt;基于上面降本增效的目的，我之前调研了 SonarQube 代码检测工具。&lt;/p&gt;
&lt;p&gt;它基本支持了市面上的 Java、Go、JavaScript、TypeScript 等十多种语言，并提供几千条代码规则，用于代码规范检查、代码优化提示等代码质量问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507011753711.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;支持结合 GitLab 的 CI/CD 做流水线事件中断，方便代码提交人员，自行去查看反馈的问题。&lt;/p&gt;
&lt;p&gt;并且，提供 SonarLint 这个 IDE 插件，在代码编写时，就反馈存在的问题，并给出修改建议。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021344526.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;后来为了减少项目负责人的代码评审工作，整个部门的项目，就都接入了 SonarQube 来实现代码问题检查工作。&lt;/p&gt;
&lt;p&gt;在使用 SonarQube 的过程中，给我印象深刻的主要有以下几点：&lt;/p&gt;
&lt;p&gt;如果一个历史项目要接入使用 SonarQube 工具去检查代码，这个时候，势必会有很多问题反馈，比如可能 2000 个问题，这个时候，是否要立马安排时间去解决呢？&lt;/p&gt;
&lt;p&gt;立马安排的话，就需要比较多的时间了，如果不立马安排解决的话，这些问题应该什么时候去解决呢？&lt;/p&gt;
&lt;p&gt;SonarQube 提出了一个 “新代码” 的概念了，意思就是，可以不立即就把这 2000 个问题修复掉，而是在项目功能迭代的过程中，逐步把有问题的代码修复掉。&lt;/p&gt;
&lt;p&gt;因为项目功能有迭代，意味着，这部分代码就需要去改动，趁此机会，刚好同步解决掉遗留的代码问题，慢慢地，遗留的 2000 个问题就会以这种方式解决掉。&lt;/p&gt;
&lt;p&gt;至于哪些没有迭代的，说明功能已经很稳定了，或者功能不重要，那优先级也相对更低了。&lt;/p&gt;
&lt;p&gt;SonarQube 官网文档的这篇说明 &lt;a href=&#34;https://docs.sonarsource.com/sonarqube-server/10.6/user-guide/clean-as-you-code/#developer-ownership&#34;&gt;《Clean as You Code》&lt;/a&gt; 提出的这个方法论，我觉得理念还是很不错的：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021402873.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;SonarQube 旨在通过帮助您（开发人员）确保您提交到项目中的每个代码更改都没有问题，从而确保高代码质量和安全性。通过始终提交干净的代码，您可以逐步提高项目的整体质量。我们称这种方法为“Clean as You Code”。&lt;/p&gt;
&lt;p&gt;Clean as You Code 的核心思想是将注意力和精力集中在新代码上。在您进行功能和改进时，SonarQube 会在每次新提交时分析您的代码，并在任何代码质量问题和安全问题上提醒您。然后，您可以立即解决这些问题，并确保添加到项目中的所有新代码始终是干净的。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021608296.jpeg"></p>
<h1 id="背景">背景</h1>
<p>在项目开发过程中，代码评审还是很重要的，主要是为了解决代码规范、功能开发方式、相互学习等问题，代码是否符合规范，关系到项目成员协作的问题。</p>
<p>如果写出来的代码风格五花八门，那么，在沟通交流上面，就额外增加了难度，而这是完全没有必要的。</p>
<p>除此之外，上面说到的功能开发方式问题，意思就是，每个人都有可能是孤岛，一个人的想法可能会有缺陷，如果多个人沟通以及探讨，相互学习，有可能会从不同视角发现潜在的问题。</p>
<h1 id="人工代码评审">人工代码评审</h1>
<p>一直以来，我们要做项目代码评审，通常都是有这几种方式，比如项目组成员交叉验收各自的功能代码，然后把问题整理到文档，再一起组织代码评审会议，把问题都过一遍，然后安排任务去调整。一方面解决了代码存在的问题，另一方面通过深入交流，大家相互学习。</p>
<p>还有，就是在 GitLab 代码合并阶段，项目成员发起功能分支合并至主分支，由项目负责人去审查项目成员提交的代码分支。</p>
<p>如果没有问题，则合并到主分支；如果有问题，则反馈给项目成员。待项目成员修复完成再次发起分支代码合并，然后，项目负责人确认之后，合并到主分支。这个应该就是常规的代码评审流程。</p>
<p>但是，随着团队的发展以及对降本增效的要求，开始着手去研究，团队中哪些工作是有可优化的空间？</p>
<p>项目负责人承担的工作事务越来越多，怎么去有效简化无意义的工作，成为了当前亟需解决的问题。</p>
<h1 id="sonarqube">SonarQube</h1>
<p>基于上面降本增效的目的，我之前调研了 SonarQube 代码检测工具。</p>
<p>它基本支持了市面上的 Java、Go、JavaScript、TypeScript 等十多种语言，并提供几千条代码规则，用于代码规范检查、代码优化提示等代码质量问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507011753711.png"></p>
<p>支持结合 GitLab 的 CI/CD 做流水线事件中断，方便代码提交人员，自行去查看反馈的问题。</p>
<p>并且，提供 SonarLint 这个 IDE 插件，在代码编写时，就反馈存在的问题，并给出修改建议。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021344526.png"></p>
<p>后来为了减少项目负责人的代码评审工作，整个部门的项目，就都接入了 SonarQube 来实现代码问题检查工作。</p>
<p>在使用 SonarQube 的过程中，给我印象深刻的主要有以下几点：</p>
<p>如果一个历史项目要接入使用 SonarQube 工具去检查代码，这个时候，势必会有很多问题反馈，比如可能 2000 个问题，这个时候，是否要立马安排时间去解决呢？</p>
<p>立马安排的话，就需要比较多的时间了，如果不立马安排解决的话，这些问题应该什么时候去解决呢？</p>
<p>SonarQube 提出了一个 “新代码” 的概念了，意思就是，可以不立即就把这 2000 个问题修复掉，而是在项目功能迭代的过程中，逐步把有问题的代码修复掉。</p>
<p>因为项目功能有迭代，意味着，这部分代码就需要去改动，趁此机会，刚好同步解决掉遗留的代码问题，慢慢地，遗留的 2000 个问题就会以这种方式解决掉。</p>
<p>至于哪些没有迭代的，说明功能已经很稳定了，或者功能不重要，那优先级也相对更低了。</p>
<p>SonarQube 官网文档的这篇说明 <a href="https://docs.sonarsource.com/sonarqube-server/10.6/user-guide/clean-as-you-code/#developer-ownership">《Clean as You Code》</a> 提出的这个方法论，我觉得理念还是很不错的：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021402873.png"></p>
<p>SonarQube 旨在通过帮助您（开发人员）确保您提交到项目中的每个代码更改都没有问题，从而确保高代码质量和安全性。通过始终提交干净的代码，您可以逐步提高项目的整体质量。我们称这种方法为“Clean as You Code”。</p>
<p>Clean as You Code 的核心思想是将注意力和精力集中在新代码上。在您进行功能和改进时，SonarQube 会在每次新提交时分析您的代码，并在任何代码质量问题和安全问题上提醒您。然后，您可以立即解决这些问题，并确保添加到项目中的所有新代码始终是干净的。</p>
<p>传统的代码质量方法通常强调在每个开发周期结束时有一个单独的审查阶段，在这个阶段发现并解决质量问题。在这个过程中有一个单独的阶段，通常由不同的团队进行，可能会导致问题，因为积累的技术债务量可能变得难以管理，而责任的划分意味着质量问题可能会从裂缝中消失。</p>
<p>Clean as You Code 避免了这些陷阱。它阐明了代码质量和代码安全性是您作为开发人员的责任。它还通过使其成为日常工作节奏的一部分，使代码质量的维护保持可控。</p>
<p>另一个让我印象深刻的是 SonarQube 代码检测结合 CI/CD 阻断流水线事件的功能，真正去应用了，才真正感受到这个功能的好处在哪里，比如前端项目，要合并分支并自动化发布到线上，这个时候，如果 SonarQube 检测到代码问题，就会中断发布流程，需要解决掉反馈的代码问题，才可以正常发布到线上，从而简化了项目负责人的代码评审工作。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507011757046.png"></p>
<p>但是，SonarQube 只是静态的代码检查，固定好规则，然后它就去检查，只是一个相对 “死板” 的检查方式，无法结合代码上下文，去提出更为深层次的问题，比如功能的实现方式，代码性能优化的写法建议等等，还是要人工去做这部分的工作。</p>
<h1 id="ai-代码评审">AI 代码评审</h1>
<p>随着 AI 大模型的爆发，我之前设想的通过 AI 去做代码评审的事情，开始可以去落实。</p>
<p>早在选定 SonarQube 作为代码评审检查工具，从而减少项目负责人的工作之时，我就设想能否通过 ChatGPT 来完成这个事情，这个是之前写的结论。</p>
<blockquote>
<p>借助 ChatGPT，利用 GitLab 获取到合并请求内容并发送到 ChatGPT 完成代码审查, 并将审查结果提交评论至修改行。当前环境下，该做法可能有点激进，存在法律和安全方面的风险。时机未成熟。</p></blockquote>
<p>当时是没想明白，怎么解决掉代码安全的问题，因为我们项目的代码，总不能接入公网吧，而且，GhatGPT 还是外网，还要翻墙，还要购买服务等等问题，就此作罢了。</p>
<p>可现在完全不同了，AI 大模型发展迅速，日新月变，全面开花。在这样的背景下，我知道时机应该成熟了。</p>
<p>我的想法是，能够通过 AI 把项目成员自己提交的代码分支，做一次代码评审，然后将代码中存在的问题反馈给项目成员，项目成员自行根据建议修复之后，再次推送分支，这一个过程完全不需要项目负责人参与。</p>
<p>项目负责人只需要在最后一步，合并分支代码的时候，看下 AI 代码评审报告，确定各方面评价满足预期，则合并分支代码，从而简化项目负责人的工作。</p>
<p>后来通过多次调研，发现 <strong><a href="https://github.com/mimo-x/Code-Review-GPT-Gitlab">Code-Review-GPT-Gitlab</a></strong> 这个项目比较符合预期，有评分、代码亮点、代码问题、修改建议、修改后的版本等等，就开始着手验证和执行。</p>
<p>不过，当前还有一个点要解决，因为这个评论是需要合并分支代码之后，才可以检查 diff 部分的代码，然后结合上下文，给出代码检查报告的，那么就没有做到阻断事件的效果了。</p>
<p>之前，总认为把这个约束放到人身上，大家自行去看合并后的分支报告就行了，不做强制要求。</p>
<p>但是，这种事情，是没办法去考验人性的，要大家自觉去做，可能一开始还行，时间久了，有什么突发事情、工作进度受阻、准备下班了等等原因，就开始趋利避害了。这个是正常的，所以，只能从源头去解决，那就是完善这个阻断事件的功能。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021424609.png"></p>
<h1 id="总结">总结</h1>
<p>上面就是代码评审的方式以及演变过程，不过，在实际应用中，AI 代码评审也不是万能的，除非你能把它喂到覆盖你需求的程度，但是，现阶段还是比较难的。</p>
<p>所以，最好还是结合代码评审会议去完善代码评审这个事情，比如一个季度开一次，都看看项目的代码，兴许可以发现一些 AI 代码评审覆盖不到的、团队特有的代码规范、功能实现方式可优化等问题。</p>
<p>在当下降本增效的浪潮之下，强调团队的产出，基于这个目的，各个工作环节，都要深入去分析，是否存在可以优化的要点，通过结合实际情况的分析与论证，比如，先以一个项目作为试点，看看大家的反馈如何，没有什么问题，再全面推进，再加以实施，更能做成一件事情，避免弄得载声怨道，事与愿违。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507021615626.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>技术网站使用体验与广告问题的思考</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E6%8A%80%E6%9C%AF%E7%BD%91%E7%AB%99%E4%BD%BF%E7%94%A8%E4%BD%93%E9%AA%8C%E4%B8%8E%E5%B9%BF%E5%91%8A%E9%97%AE%E9%A2%98%E7%9A%84%E6%80%9D%E8%80%83/</link>
      <pubDate>Thu, 26 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E6%8A%80%E6%9C%AF%E7%BD%91%E7%AB%99%E4%BD%BF%E7%94%A8%E4%BD%93%E9%AA%8C%E4%B8%8E%E5%B9%BF%E5%91%8A%E9%97%AE%E9%A2%98%E7%9A%84%E6%80%9D%E8%80%83/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508241419805.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;对于程序员来说，技术网站还是很多的，我可以列举出来很多个，比如 CSDN，简书，掘金，博客园，开源中国，力扣，InfoQ、思否等。&lt;/p&gt;
&lt;p&gt;早些年我是逛开源中国的，后来，发现了 CSDN，就迁移到 CSDN 了，但是，CSDN 广告真的太恐怖了，不到万不得已，我是绝对不想打开的，因为真的受不了这个广告，&lt;/p&gt;
&lt;p&gt;简书出来之后，就转到简书了，继续写一些技术文章，内容主要是遇到的问题分析、积累的一些解决方案等，但是，后来简书真的吃相越来越难看了。&lt;/p&gt;
&lt;p&gt;满屏的广告不说，文章最后本来应该就是评论区的，硬是要在这个小地方塞进去了十几篇推荐的文章，每次看到最后，想看下评论区，都要把窗口拖下去很久才行。&lt;/p&gt;
&lt;p&gt;文章左侧还有一个 APP 二维码，一直闪烁，我都不清楚简书的产品经理脑袋里装的都是什么，完全没有脑子，阅读文章内容时，注意力老是被这个二维码的动效干扰，人都变得很烦躁，猜测这个功能的目的，是为了推流下载简书 APP，但是，在实现这个目的过程中，采用了简答粗暴的方式，真的一点脑子都没有。&lt;/p&gt;
&lt;p&gt;再加上文章详情页，右侧推荐的文章都是那种 “庞太师与我娘亲二三事” 之类的文章，我当时就觉得受够了，简书死不足惜。&lt;/p&gt;
&lt;p&gt;再加上 2017 年饱醉豚无端抹黑程序员事件，彻底激了众怒了，所以，就转到博客园了。&lt;/p&gt;
&lt;p&gt;博客园的优点其实很多的，比如整个网站没什么广告，然后个人博客风格还可以自定义，编辑器也过得去，但是不知道什么原因，没有继续在上面发发技术文章，或者平时逛逛，基本上得很少用，只能是我自己的选择问题了。&lt;/p&gt;
&lt;p&gt;最后，就迁移到极客时间推出的 InfoQ 网站了，在上面写了几篇技术文章，感觉这个网站没那么多广告，这点还是很不错的，然后不管是编辑器、个人主页都很清爽，但说实话人气确实不咋地。而且，很多文章都是太资讯、行业化了？一看就不是程序员平时写的东西。&lt;/p&gt;
&lt;p&gt;后面，迁移到掘金了，在掘金应该是比较久的了，之前一直也是不错的，但是，最近感觉掘金的广告也变多了起来，可能是有 KPI 绩效的要求，每次打开，都要顶部撑开一个大位置，用来放广告，然后再收缩起来，不知道这个动画效果是不是没有处理好的原因，每次都感觉卡顿，然后莫名其妙的。&lt;/p&gt;
&lt;p&gt;这一点也是很烦的。以致有人写了文章吐槽这个，有意思的是，这篇文章还上掘金热搜榜了，也不知道掘金小编是怎么审核通过的，还是有格局的，亦或是早就看不惯了，迫于上级要求，只能通过这个方式表达不满了。&lt;/p&gt;
&lt;p&gt;然后我现在发文，是掘金和公众号一起，先是在公众号发完，然后同步到掘金，然后再同步到个人博客。这一流程基本沿用至今。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261359433.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261401459.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;上面就是一些使用技术网站的背景，从上面的描述中，可以看到，其实，自己是疯狂吐槽简书的，挑的问题也最多，那是因为很喜欢简书的，至少一开始真的很惊艳，干干净净，简简单单的，但是现在已经全都变了。&lt;/p&gt;
&lt;p&gt;但是，任何事情都要结合实际情况来分析，从不同的角度去看，每个人都有不一样的难处。&lt;/p&gt;
&lt;p&gt;用户觉得广告太多，阅读体验差，网站觉得我要运营，要买服务器，要花钱的，不搞点收益，怎么活下去，你们白嫖了还到处抱怨？&lt;/p&gt;
&lt;p&gt;要解决这个问题，还是在于用不用。&lt;/p&gt;
&lt;p&gt;如果不用那就眼不见为净，没有任何烦恼，如果要用，单纯去指责网站意义不大，愤怒、指责、抱怨只是短暂发泄下负面的情绪，没办法彻底解决掉这个问题。因为赚钱嘛，不寒碜。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261456171.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;同时，如果技术网站，要推行类似 Medium 的付费模式。我估计死得更快，我赏脸在你这个破网站上发表文章，没找你要稿费都不错了，我看点别人的文章还要收费？&lt;/p&gt;
&lt;p&gt;毕竟，我们没有这个付费的传统习惯，从最初的音乐、电影、单机游戏和办公软件之类的，能用盗版用盗版，这个怎么说呢，不去评判好坏了。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261453320.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;我也有理由说的！现在的视频网站，都什么操作？开通会员还得看广告，这不是坑人吗？会员等级还分三六九等，VIP分成了好几个档次，简直是要把用户的钱包榨干！更夸张的是，同一份资源，换个设备看还要多花钱，这也太离谱了吧！还有那些限制分辨率、限制投屏的操作，这不是欺负人吗？我可是乖乖交了会员费的好人，怎么就要被这样对待？好人就该被枪指着是吧！你们既然这样，那别怪我去找盗版了！脸都不要了！&lt;/p&gt;
&lt;p&gt;很多人都有过上面的经历，所以，才没办法单纯评判好坏。我们不是没有这个付费的传统习惯，我们只会为值得的东西买单。&lt;/p&gt;
&lt;p&gt;再加上 Windows 之前之所以能在中国打开市场，并且，占据大部分市场份额，就是因为它默许了 Windows 盗版横行。而且，在开源这一块也是一样，要想让我们付费和打赏，还是太难了，我看尤雨溪入驻国内 “爱发电” 平台，想要扩宽国内的 Vue 赞助渠道，不会有几个钢镚的。&lt;/p&gt;
&lt;p&gt;所以，回归正传，怎么解决这个技术网站的阅读体验问题呢？&lt;/p&gt;
&lt;p&gt;只能是折中的手段，那就是通过安装广告拦截插件来解决了。甚至定位并拦截哪些广告区域，通过这个方式，后面再浏览各大技术网站时，已经干净很多了。&lt;/p&gt;
&lt;p&gt;至此，现在看技术博文，就是在掘金比较多了，偶尔看下 InfoQ 上的文章，因为有一些资讯或者访谈类的文章，其实还是不错的。&lt;/p&gt;
&lt;p&gt;然后，因为之前的 ARTS 打卡活动，也经常要看下力扣的，现在这个打卡活动结束了，时不时也去看下日常的讨论，还有就是思否，这种问答式的模式其实还是很不错的，只是感觉有些时候，感兴趣的话题不是很多。&lt;/p&gt;
&lt;p&gt;现在，基本不会怎么改变这个习惯了吧。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261501513.jpeg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508241419805.jpg"></p>
<p>对于程序员来说，技术网站还是很多的，我可以列举出来很多个，比如 CSDN，简书，掘金，博客园，开源中国，力扣，InfoQ、思否等。</p>
<p>早些年我是逛开源中国的，后来，发现了 CSDN，就迁移到 CSDN 了，但是，CSDN 广告真的太恐怖了，不到万不得已，我是绝对不想打开的，因为真的受不了这个广告，</p>
<p>简书出来之后，就转到简书了，继续写一些技术文章，内容主要是遇到的问题分析、积累的一些解决方案等，但是，后来简书真的吃相越来越难看了。</p>
<p>满屏的广告不说，文章最后本来应该就是评论区的，硬是要在这个小地方塞进去了十几篇推荐的文章，每次看到最后，想看下评论区，都要把窗口拖下去很久才行。</p>
<p>文章左侧还有一个 APP 二维码，一直闪烁，我都不清楚简书的产品经理脑袋里装的都是什么，完全没有脑子，阅读文章内容时，注意力老是被这个二维码的动效干扰，人都变得很烦躁，猜测这个功能的目的，是为了推流下载简书 APP，但是，在实现这个目的过程中，采用了简答粗暴的方式，真的一点脑子都没有。</p>
<p>再加上文章详情页，右侧推荐的文章都是那种 “庞太师与我娘亲二三事” 之类的文章，我当时就觉得受够了，简书死不足惜。</p>
<p>再加上 2017 年饱醉豚无端抹黑程序员事件，彻底激了众怒了，所以，就转到博客园了。</p>
<p>博客园的优点其实很多的，比如整个网站没什么广告，然后个人博客风格还可以自定义，编辑器也过得去，但是不知道什么原因，没有继续在上面发发技术文章，或者平时逛逛，基本上得很少用，只能是我自己的选择问题了。</p>
<p>最后，就迁移到极客时间推出的 InfoQ 网站了，在上面写了几篇技术文章，感觉这个网站没那么多广告，这点还是很不错的，然后不管是编辑器、个人主页都很清爽，但说实话人气确实不咋地。而且，很多文章都是太资讯、行业化了？一看就不是程序员平时写的东西。</p>
<p>后面，迁移到掘金了，在掘金应该是比较久的了，之前一直也是不错的，但是，最近感觉掘金的广告也变多了起来，可能是有 KPI 绩效的要求，每次打开，都要顶部撑开一个大位置，用来放广告，然后再收缩起来，不知道这个动画效果是不是没有处理好的原因，每次都感觉卡顿，然后莫名其妙的。</p>
<p>这一点也是很烦的。以致有人写了文章吐槽这个，有意思的是，这篇文章还上掘金热搜榜了，也不知道掘金小编是怎么审核通过的，还是有格局的，亦或是早就看不惯了，迫于上级要求，只能通过这个方式表达不满了。</p>
<p>然后我现在发文，是掘金和公众号一起，先是在公众号发完，然后同步到掘金，然后再同步到个人博客。这一流程基本沿用至今。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261359433.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261401459.png"></p>
<p>上面就是一些使用技术网站的背景，从上面的描述中，可以看到，其实，自己是疯狂吐槽简书的，挑的问题也最多，那是因为很喜欢简书的，至少一开始真的很惊艳，干干净净，简简单单的，但是现在已经全都变了。</p>
<p>但是，任何事情都要结合实际情况来分析，从不同的角度去看，每个人都有不一样的难处。</p>
<p>用户觉得广告太多，阅读体验差，网站觉得我要运营，要买服务器，要花钱的，不搞点收益，怎么活下去，你们白嫖了还到处抱怨？</p>
<p>要解决这个问题，还是在于用不用。</p>
<p>如果不用那就眼不见为净，没有任何烦恼，如果要用，单纯去指责网站意义不大，愤怒、指责、抱怨只是短暂发泄下负面的情绪，没办法彻底解决掉这个问题。因为赚钱嘛，不寒碜。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261456171.jpg"></p>
<p>同时，如果技术网站，要推行类似 Medium 的付费模式。我估计死得更快，我赏脸在你这个破网站上发表文章，没找你要稿费都不错了，我看点别人的文章还要收费？</p>
<p>毕竟，我们没有这个付费的传统习惯，从最初的音乐、电影、单机游戏和办公软件之类的，能用盗版用盗版，这个怎么说呢，不去评判好坏了。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261453320.png"></p>
<p>我也有理由说的！现在的视频网站，都什么操作？开通会员还得看广告，这不是坑人吗？会员等级还分三六九等，VIP分成了好几个档次，简直是要把用户的钱包榨干！更夸张的是，同一份资源，换个设备看还要多花钱，这也太离谱了吧！还有那些限制分辨率、限制投屏的操作，这不是欺负人吗？我可是乖乖交了会员费的好人，怎么就要被这样对待？好人就该被枪指着是吧！你们既然这样，那别怪我去找盗版了！脸都不要了！</p>
<p>很多人都有过上面的经历，所以，才没办法单纯评判好坏。我们不是没有这个付费的传统习惯，我们只会为值得的东西买单。</p>
<p>再加上 Windows 之前之所以能在中国打开市场，并且，占据大部分市场份额，就是因为它默许了 Windows 盗版横行。而且，在开源这一块也是一样，要想让我们付费和打赏，还是太难了，我看尤雨溪入驻国内 “爱发电” 平台，想要扩宽国内的 Vue 赞助渠道，不会有几个钢镚的。</p>
<p>所以，回归正传，怎么解决这个技术网站的阅读体验问题呢？</p>
<p>只能是折中的手段，那就是通过安装广告拦截插件来解决了。甚至定位并拦截哪些广告区域，通过这个方式，后面再浏览各大技术网站时，已经干净很多了。</p>
<p>至此，现在看技术博文，就是在掘金比较多了，偶尔看下 InfoQ 上的文章，因为有一些资讯或者访谈类的文章，其实还是不错的。</p>
<p>然后，因为之前的 ARTS 打卡活动，也经常要看下力扣的，现在这个打卡活动结束了，时不时也去看下日常的讨论，还有就是思否，这种问答式的模式其实还是很不错的，只是感觉有些时候，感兴趣的话题不是很多。</p>
<p>现在，基本不会怎么改变这个习惯了吧。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506261501513.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>找技术答案的经历：从踩坑到用 AI 的变化</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E6%89%BE%E6%8A%80%E6%9C%AF%E7%AD%94%E6%A1%88%E7%9A%84%E7%BB%8F%E5%8E%86%E4%BB%8E%E8%B8%A9%E5%9D%91%E5%88%B0%E7%94%A8-ai-%E7%9A%84%E5%8F%98%E5%8C%96/</link>
      <pubDate>Sat, 21 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E6%89%BE%E6%8A%80%E6%9C%AF%E7%AD%94%E6%A1%88%E7%9A%84%E7%BB%8F%E5%8E%86%E4%BB%8E%E8%B8%A9%E5%9D%91%E5%88%B0%E7%94%A8-ai-%E7%9A%84%E5%8F%98%E5%8C%96/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508241418402.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;2020 年 7 月，因为第一次使用 Flutter 来开发项目，所以研究后发现，如果要使用 iPhone 真机调试，需要在 XCode 上运行。但当时苹果手机系统版本是 13.6，而 XCode 是 11.3.1，所以运行时出现如下提示：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-ts&#34; data-lang=&#34;ts&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;This&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;iPhone&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;is&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;running&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;iOS&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;13.6&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;17&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;G68&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;which&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;may&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;not&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;be&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;supported&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;by&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;this&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;version&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Xcode&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;An&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;updated&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;version&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Xcode&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;may&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;be&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;found&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;on&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;the&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;App&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Store&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;or&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;at&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;developer&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;apple&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;com&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;也就是说，当前 XCode 版本过低，不支持当前手机的版本。然而，App Store 没有 XCode 升级提示，我便以为 XCode 还没有新版本发布。那么，要解决这个问题，当下就是想办法让其支持 13.6 版本的手机。&lt;/p&gt;
&lt;p&gt;于是我在百度上搜索，发现 CSDN 有很多 iOS 13.6 真机调试包可以下载，但需要积分。由于 CSDN 广告太多，我早已反感，之前攒的积分也花光了，所以没办法下载。&lt;/p&gt;
&lt;p&gt;当时我就想，为什么别人能弄到这个 13.6 真机调试包，总不可能都是自己做出来的吧。反正我看到 CSDN 上面到处都是，都标着很高的积分，心里暗自吐槽，这尼玛是不是都你抄我、我抄你的啊。好多东西无非就是信息差，提前知道了，或者在外网看了相关讯息，拿到别人的东西，就拿到国内来卖。&lt;/p&gt;
&lt;p&gt;如果是自己辛辛苦苦弄出来的，也认了，毕竟是自己的劳动成果。但如果是拿别人的东西来唬人，那性质就不是一样的了。&lt;/p&gt;
&lt;p&gt;反正很长一段时间里，我使用百度搜索一些问题的解决方案，不下五六篇都是一模一样的，我都不知道谁才是原创。或者本来答案就是 Stack Overflow 上面的，只不过翻译了一下而已，也不给个链接或者标注下，真是糟糕透了。&lt;/p&gt;
&lt;p&gt;基于这个原因，我用必应搜索，搜索到的结果很干净，没有那么多杂七杂八的东西（比如满屏的广告）干扰定位问题答案。&lt;/p&gt;
&lt;p&gt;比如搜索 XCode 13.6 相关内容，我慢慢找，就发现了这个问题：&lt;a href=&#34;https://stackoverflow.com/questions/62934922/xcode-11-5-doesnt-support-ios-13-6&#34;&gt;Xcode 11.5 doesn&amp;rsquo;t support iOS 13.6?&lt;/a&gt;，没错，Stack Overflow 上面就有答案。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506211133523.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;Stack Overflow 除了访问很慢，其它没什么问题。而且在这个问答里，我找到了 13.6 真机调试包下载的地方，也就是 Github 上面的&lt;a href=&#34;https://github.com/filsv/iPhoneOSDeviceSupport&#34;&gt;iPhoneOSDeviceSupport&lt;/a&gt;。我看了这个项目，是好几年前的了，甚至 14.0 的真机调试包都有提供。所以我严重怀疑 CSDN 上面那些就是抄的这里的，从这里下载后，自己标上积分供人下载。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506211135778.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202508241418402.jpeg"></p>
<p>2020 年 7 月，因为第一次使用 Flutter 来开发项目，所以研究后发现，如果要使用 iPhone 真机调试，需要在 XCode 上运行。但当时苹果手机系统版本是 13.6，而 XCode 是 11.3.1，所以运行时出现如下提示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="nx">This</span> <span class="nx">iPhone</span> <span class="mi">11</span> <span class="k">is</span> <span class="nx">running</span> <span class="nx">iOS</span> <span class="mf">13.6</span> <span class="p">(</span><span class="mi">17</span><span class="nx">G68</span><span class="p">),</span> <span class="nx">which</span> <span class="nx">may</span> <span class="nx">not</span> <span class="nx">be</span> <span class="nx">supported</span> <span class="nx">by</span> <span class="k">this</span> <span class="nx">version</span> <span class="k">of</span> <span class="nx">Xcode</span><span class="p">.</span> <span class="nx">An</span> <span class="nx">updated</span> <span class="nx">version</span> <span class="k">of</span> <span class="nx">Xcode</span> <span class="nx">may</span> <span class="nx">be</span> <span class="nx">found</span> <span class="nx">on</span> <span class="nx">the</span> <span class="nx">App</span> <span class="nx">Store</span> <span class="nx">or</span> <span class="nx">at</span> <span class="nx">developer</span><span class="p">.</span><span class="nx">apple</span><span class="p">.</span><span class="nx">com</span><span class="p">.</span>
</span></span></code></pre></div><p>也就是说，当前 XCode 版本过低，不支持当前手机的版本。然而，App Store 没有 XCode 升级提示，我便以为 XCode 还没有新版本发布。那么，要解决这个问题，当下就是想办法让其支持 13.6 版本的手机。</p>
<p>于是我在百度上搜索，发现 CSDN 有很多 iOS 13.6 真机调试包可以下载，但需要积分。由于 CSDN 广告太多，我早已反感，之前攒的积分也花光了，所以没办法下载。</p>
<p>当时我就想，为什么别人能弄到这个 13.6 真机调试包，总不可能都是自己做出来的吧。反正我看到 CSDN 上面到处都是，都标着很高的积分，心里暗自吐槽，这尼玛是不是都你抄我、我抄你的啊。好多东西无非就是信息差，提前知道了，或者在外网看了相关讯息，拿到别人的东西，就拿到国内来卖。</p>
<p>如果是自己辛辛苦苦弄出来的，也认了，毕竟是自己的劳动成果。但如果是拿别人的东西来唬人，那性质就不是一样的了。</p>
<p>反正很长一段时间里，我使用百度搜索一些问题的解决方案，不下五六篇都是一模一样的，我都不知道谁才是原创。或者本来答案就是 Stack Overflow 上面的，只不过翻译了一下而已，也不给个链接或者标注下，真是糟糕透了。</p>
<p>基于这个原因，我用必应搜索，搜索到的结果很干净，没有那么多杂七杂八的东西（比如满屏的广告）干扰定位问题答案。</p>
<p>比如搜索 XCode 13.6 相关内容，我慢慢找，就发现了这个问题：<a href="https://stackoverflow.com/questions/62934922/xcode-11-5-doesnt-support-ios-13-6">Xcode 11.5 doesn&rsquo;t support iOS 13.6?</a>，没错，Stack Overflow 上面就有答案。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506211133523.png"></p>
<p>Stack Overflow 除了访问很慢，其它没什么问题。而且在这个问答里，我找到了 13.6 真机调试包下载的地方，也就是 Github 上面的<a href="https://github.com/filsv/iPhoneOSDeviceSupport">iPhoneOSDeviceSupport</a>。我看了这个项目，是好几年前的了，甚至 14.0 的真机调试包都有提供。所以我严重怀疑 CSDN 上面那些就是抄的这里的，从这里下载后，自己标上积分供人下载。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506211135778.png"></p>
<p>所以，求知要到知识的源头去。也正因如此，我现在都用必应搜索，或者到 Stack Overflow 找问题解决方案。现在国内的这个环境，真是无力吐槽。</p>
<p>但是，说回到现在 2025 年，因为 AI 的爆发，搜索引擎受到了很大冲击。我感觉 Stack Overflow 基本快没什么人用了，因为遇到问题，第一个想法肯定是先问 AI，最多对不确定的信息再三确认下。毕竟，AI 给的答案不一定都对，需要进一步甄别。但相比之前传统查找解决问题的方式，效率各方面都不可同日而语。</p>
<p>DeepSeek 过年时爆火，现在全球整个 AI 市场，各大模型感觉都不知道升级了多少代，速度真的太快了。比如，最近 360 纳米 AI 又搞出一个超级智能体，也是在进一步探索可能性。</p>
<p>在这样的时代背景下，上面存在的问题，将进一步被其他方式解决，比如使用 AI 来查找问题答案。那么不管各大技术网站、博文质量如何，你都不用操心这些了，最终能去伪存真、化繁为简，直接给你答案。</p>
<p>总之，还是那句话，拥抱变化，淘汰人的不是 AI，而是使用 AI 的人。这句话跟《浪客剑心》的那句台词有异曲同工之处：</p>
<p>“创造时代的并不是刀，而是使用刀的人。”</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506211404436.jpeg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>36-《精力管理》摘要</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/36-%E7%B2%BE%E5%8A%9B%E7%AE%A1%E7%90%86%E6%91%98%E8%A6%81/</link>
      <pubDate>Sat, 14 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/36-%E7%B2%BE%E5%8A%9B%E7%AE%A1%E7%90%86%E6%91%98%E8%A6%81/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507161935829.png&#34;&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;精力就是做事情的能力。包括体能、情感、思维、意志四个方面。&lt;/li&gt;
&lt;li&gt;今天我们要分析一条革命性的理论——管理精力，而非时间，才是是高效表现的基础。&lt;/li&gt;
&lt;li&gt;我们与运动员合作成功的秘诀并非在于技巧或战略。人们通常认为，才华横溢的人面对挑战时只要配备足够技能，就能够发挥出最好的水平。从我们的经验来看却并非如此。精力才是完全点燃才华和技能的正解。&lt;/li&gt;
&lt;li&gt;人们极少考虑我们消耗了多少精力储备，总是想当然地认为它能够随用随取。事实上，不断增长的需求逐步耗尽了我们的精力储备——尤其由于我们不对随着年龄出现的能力减退做任何补救。通过全方位的训练，我们可以极大地减缓身体和思维的衰退，并切实地深化情感和精神的能力，直至生命的尽头。&lt;/li&gt;
&lt;li&gt;如果某件事你每次做之前都需要思考，你很可能不会长久坚持这件事。&lt;/li&gt;
&lt;li&gt;通过运动和休息交替进行可以最大限度提高表现，这条理论最初由斐洛斯特拉图斯提出，他是古希腊运动员训练手册的编撰者。随着训练强度增大、对运动员要求提高，能力的恢复和补偿程度也必然相应增加，否则，运动员的表现将会逐渐下降。&lt;/li&gt;
&lt;li&gt;持续健身能带来身心改善，但若停止一周，曾经的改善就会大幅退步，只要停止4周，这种改善就会完全消失。&lt;/li&gt;
&lt;li&gt;自然本身存在规律的脉动，在活跃和休息之间有节奏、波浪形地交替。涨潮退潮，四季更替，日升日落，不胜枚举。同理，所有有机体都遵从恒久的节奏——鸟类迁徙，熊类冬眠，松鼠收集坚果，鱼儿产卵，生物的活动都有一定的间歇。&lt;/li&gt;
&lt;li&gt;张弛有度是全情投入、维持机能和保持健康的关键。相反，单线化运动最终会导致机能障碍和死亡。想象一幅健康的脑电图或心电图是如何起伏波动的，再想象它的反面，是不是一条直线？&lt;/li&gt;
&lt;li&gt;我拥有在任何情况下高度集中的能力，摒弃那些让我分心的事物。然而，我无法在打完18洞的过程里始终集中精力，即便可以，我怀疑我的思维也会过度损耗，思维变得混沌，最终还是无法推杆入洞。因而我制订了一套步骤，帮助我完成从高度集中到惬意放松的过渡，反之亦然。&lt;/li&gt;
&lt;li&gt;从最实用的角度看，全情投入的能力取决于周期性休息的能力。&lt;/li&gt;
&lt;li&gt;科技的进步永不止息。它本该帮我们更好地感知周围的事物，然而却成为现实中导致我们无法全情投入的祸因。&lt;/li&gt;
&lt;li&gt;《心流》的作者、心理学家米哈里·契克森米哈写道，“最佳时刻，往往发生在一个人的身心为了达成艰难目标或完成有意义的事情，而自愿达到极限的时候。”&lt;/li&gt;
&lt;li&gt;我们还发现，喝水或许是最常被人忽略的体能再生方式。口渴不会像饥饿一样散发出明显的信号，等我们感到口渴的时候，身体或许已经缺水很久了。一家研究机构称，每天至少饮用1.8公斤水对维持体能有诸多好处。&lt;/li&gt;
&lt;li&gt;睡眠需求随年龄、性别、基因体能而异，但普遍的科学共识是：人体每晚需要7至8小时的睡眠才可以运转良好。还有数项研究发现，即使将人们隔绝自然光或钟表，他们还是会每24小时睡眠7至8个小时。&lt;/li&gt;
&lt;li&gt;小憩就是一种精力恢复手段。斯坦皮发现，小睡片刻的工人即便不能长时间睡眠，仍可以保持超过24小时的惊人高效和敏锐。唯一需要注意的地方就是小憩需要定时，以免受试者陷入更深的睡眠中。如果小憩超出30或40分钟，许多受试者会感到眩晕无力，甚至比不睡更加疲倦。&lt;/li&gt;
&lt;li&gt;即便适度锻炼有诸多益处，大多数美国人还是几乎不锻炼。原因很简单，提升力量与耐力需要我们踏出舒适区，体验不适的感觉，并且需要持续一定时间才能见效。但大多数人在看到明显的效果之前就放弃了。&lt;/li&gt;
&lt;li&gt;对需要坐在办公桌前工作的大批白领来说，日常锻炼的缺乏阻碍了机体的自然增强，导致年龄增长后，大多数人应对挑战和压力的能力都逐渐下降。&lt;/li&gt;
&lt;li&gt;定期锻炼可以缓解他的紧张感，帮助他更好地控制情感。&lt;/li&gt;
&lt;li&gt;身体锻炼是思维和情感精力的极佳源泉。&lt;/li&gt;
&lt;li&gt;盖洛普公司发现，保持优秀表现的诀窍之一是在工作环境中至少交一位好朋友。一段稳固的关系包括付出与回报、倾诉与倾听、珍视他人和被人同等珍视。如果一段关系中总是付出而得不到相应的回馈，不免会感到空虚和失落。以自我为中心的关系，也称不上真正的情感关系。&lt;/li&gt;
&lt;li&gt;当愤怒逐渐累积时，保罗会选择用腹部做深呼吸，放松肩膀和面部肌肉，掐断自己一触即发的情绪。当情绪逐渐平复下来，他会想办法将沮丧的感觉用一种大家更容易接受的方式表现出来——通常是自嘲的方式。如果保罗认为有必要提出批评的意见，他会采用 “三明治”技巧。首先真诚地对该员工的良好表现给出正面评价，然后以讨论而非宣讲的形式提出批评意见——因为自己的看法或许并非完全准确，最后以鼓励结尾。用“三明治”的方式提出意见不仅让他看起来充满善意和关怀，而且更容易让员工听取他的建议，不会产生逆反心理。&lt;/li&gt;
&lt;li&gt;只有接受那些看似相反的品质，不逼自己在其间二选一，才有可能获得最深刻最丰富的情感能力。情感层面的全情投入需要遵循斯多葛派哲学家的“破格文体”——美德的共同存在性。从这一角度看来，没有一种美德是不依赖其他品质而成为美德的。所有的美德都有条件。例如，毫不留情的诚实只是残酷而已。&lt;/li&gt;
&lt;li&gt;越来越多证据表明，大脑的运作方式也类似肌肉——积极使用能够提升能力，使用不足就会萎缩。&lt;/li&gt;
&lt;li&gt;尼采有句名言 ：“知晓生命的意义，方能忍耐一切。”任何能够点燃人类精神的事物都有助于全情投入、促进最佳表现。意志精力的关键动力在于性格品质——一个人如果有自己的人生目标，他的勇气和信念，即使面对艰难困苦和个人牺牲也会在所不惜。意志精力由激情、奉献、正直与诚实支持着。&lt;/li&gt;
&lt;li&gt;弗兰克尔是纳粹集中营中幸存的心理学家，他创作了《活出生命的意义》这本经典巨著。书中他引用了尼采的名言：“知晓生命的意义，方能忍耐一切。”弗兰克尔也描述了在不断有人死去的环境中，这个认知如何挽救了他的生命：生而没有意义的人是痛苦的，没有目标、没有目的、无需继续忍受。他很快就会迷失。我们的人生态度需要从根本上转变。我们既要自己学着转变，也要向绝望之人伸出援手，告诉他我们对生活的期待其实并不重要，重要的是生活于我们有何期望。我们要停止追问生命的意义所在，每时每刻提醒自己接受生命的检视。我们的回应不仅体现在言语和冥想中，还要贯穿我们的行为举止。生命的终极意义是担起责任，找寻难题的答案，并且完成生命为每个人设定的任务。&lt;/li&gt;
&lt;li&gt;每个人都拥有许多未知的潜力，只能在困境中才会激发它们。&lt;/li&gt;
&lt;li&gt;当目标感从消极流向积极、从外部流向内部、从自己流向他人，它就成为生活中最强大也最持久的精力源。&lt;/li&gt;
&lt;li&gt;设想一下，如果你坐在一艘行驶在海上的小船里，船底突然开始漏水，你的目的肯定是阻止小船沉下去。但如果你一直忙着舀水，肯定无暇顾及小船的航向。生活也是如此。当我们忙着填补漏洞，不让自己沉底，就没有多余精力探寻更深层的意义了。&lt;/li&gt;
&lt;li&gt;出于对内心深处软弱无力的恐惧，恃强的人会蛮横粗暴地对待他人。因为不愿承认内心的不足，成功的领导者永远都在吹嘘自己的成就，炫耀自己认识多少大人物。&lt;/li&gt;
&lt;li&gt;“邪恶的本质缺陷并非是罪恶本身，而是自我否认。”《少有人走的路》的作者斯科特·派克写道，“邪恶攻击他人，而不承认自己的失败……因为必须否认自己是坏人，所以只能把别人当作坏人。”&lt;/li&gt;
&lt;li&gt;若困在狭隘的自我视角中，我们也不会注意到或有意培养自己的能力。我们或许可以尽力压制自己令人反感的一面，但同时也很难认可自己的优秀品质。&lt;/li&gt;
&lt;li&gt;使用许多手段否认生活中的不如意或逃避为此承担责任。责怪他人并将自己看作受害者是一种常见的方式。&lt;/li&gt;
&lt;li&gt;所有表现卓越的人都依靠积极的仪式习惯管理精力和规范行为。如果你一直久坐不动，打算开始锻炼身体，你可以最开始每周3次、每次步行15分钟，然后逐周增加步行时间或加快步伐。&lt;/li&gt;
&lt;li&gt;不管面对什么样的事情，他要么全情投入，要么有策略地离开。&lt;/li&gt;
&lt;li&gt;人类行为只有5%是受自我意识支配的。我们是习惯的造物，因而我们的行为有95%都是自动反应或对于某种需求或紧急情况的应激反应。&lt;/li&gt;
&lt;li&gt;在任何表现至上的领域，压力与恢复的平衡都至关重要。我们越能高效恢复精力，越能尽快储备资源以备调用。&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507161935829.png"></p>
<ol>
<li>精力就是做事情的能力。包括体能、情感、思维、意志四个方面。</li>
<li>今天我们要分析一条革命性的理论——管理精力，而非时间，才是是高效表现的基础。</li>
<li>我们与运动员合作成功的秘诀并非在于技巧或战略。人们通常认为，才华横溢的人面对挑战时只要配备足够技能，就能够发挥出最好的水平。从我们的经验来看却并非如此。精力才是完全点燃才华和技能的正解。</li>
<li>人们极少考虑我们消耗了多少精力储备，总是想当然地认为它能够随用随取。事实上，不断增长的需求逐步耗尽了我们的精力储备——尤其由于我们不对随着年龄出现的能力减退做任何补救。通过全方位的训练，我们可以极大地减缓身体和思维的衰退，并切实地深化情感和精神的能力，直至生命的尽头。</li>
<li>如果某件事你每次做之前都需要思考，你很可能不会长久坚持这件事。</li>
<li>通过运动和休息交替进行可以最大限度提高表现，这条理论最初由斐洛斯特拉图斯提出，他是古希腊运动员训练手册的编撰者。随着训练强度增大、对运动员要求提高，能力的恢复和补偿程度也必然相应增加，否则，运动员的表现将会逐渐下降。</li>
<li>持续健身能带来身心改善，但若停止一周，曾经的改善就会大幅退步，只要停止4周，这种改善就会完全消失。</li>
<li>自然本身存在规律的脉动，在活跃和休息之间有节奏、波浪形地交替。涨潮退潮，四季更替，日升日落，不胜枚举。同理，所有有机体都遵从恒久的节奏——鸟类迁徙，熊类冬眠，松鼠收集坚果，鱼儿产卵，生物的活动都有一定的间歇。</li>
<li>张弛有度是全情投入、维持机能和保持健康的关键。相反，单线化运动最终会导致机能障碍和死亡。想象一幅健康的脑电图或心电图是如何起伏波动的，再想象它的反面，是不是一条直线？</li>
<li>我拥有在任何情况下高度集中的能力，摒弃那些让我分心的事物。然而，我无法在打完18洞的过程里始终集中精力，即便可以，我怀疑我的思维也会过度损耗，思维变得混沌，最终还是无法推杆入洞。因而我制订了一套步骤，帮助我完成从高度集中到惬意放松的过渡，反之亦然。</li>
<li>从最实用的角度看，全情投入的能力取决于周期性休息的能力。</li>
<li>科技的进步永不止息。它本该帮我们更好地感知周围的事物，然而却成为现实中导致我们无法全情投入的祸因。</li>
<li>《心流》的作者、心理学家米哈里·契克森米哈写道，“最佳时刻，往往发生在一个人的身心为了达成艰难目标或完成有意义的事情，而自愿达到极限的时候。”</li>
<li>我们还发现，喝水或许是最常被人忽略的体能再生方式。口渴不会像饥饿一样散发出明显的信号，等我们感到口渴的时候，身体或许已经缺水很久了。一家研究机构称，每天至少饮用1.8公斤水对维持体能有诸多好处。</li>
<li>睡眠需求随年龄、性别、基因体能而异，但普遍的科学共识是：人体每晚需要7至8小时的睡眠才可以运转良好。还有数项研究发现，即使将人们隔绝自然光或钟表，他们还是会每24小时睡眠7至8个小时。</li>
<li>小憩就是一种精力恢复手段。斯坦皮发现，小睡片刻的工人即便不能长时间睡眠，仍可以保持超过24小时的惊人高效和敏锐。唯一需要注意的地方就是小憩需要定时，以免受试者陷入更深的睡眠中。如果小憩超出30或40分钟，许多受试者会感到眩晕无力，甚至比不睡更加疲倦。</li>
<li>即便适度锻炼有诸多益处，大多数美国人还是几乎不锻炼。原因很简单，提升力量与耐力需要我们踏出舒适区，体验不适的感觉，并且需要持续一定时间才能见效。但大多数人在看到明显的效果之前就放弃了。</li>
<li>对需要坐在办公桌前工作的大批白领来说，日常锻炼的缺乏阻碍了机体的自然增强，导致年龄增长后，大多数人应对挑战和压力的能力都逐渐下降。</li>
<li>定期锻炼可以缓解他的紧张感，帮助他更好地控制情感。</li>
<li>身体锻炼是思维和情感精力的极佳源泉。</li>
<li>盖洛普公司发现，保持优秀表现的诀窍之一是在工作环境中至少交一位好朋友。一段稳固的关系包括付出与回报、倾诉与倾听、珍视他人和被人同等珍视。如果一段关系中总是付出而得不到相应的回馈，不免会感到空虚和失落。以自我为中心的关系，也称不上真正的情感关系。</li>
<li>当愤怒逐渐累积时，保罗会选择用腹部做深呼吸，放松肩膀和面部肌肉，掐断自己一触即发的情绪。当情绪逐渐平复下来，他会想办法将沮丧的感觉用一种大家更容易接受的方式表现出来——通常是自嘲的方式。如果保罗认为有必要提出批评的意见，他会采用 “三明治”技巧。首先真诚地对该员工的良好表现给出正面评价，然后以讨论而非宣讲的形式提出批评意见——因为自己的看法或许并非完全准确，最后以鼓励结尾。用“三明治”的方式提出意见不仅让他看起来充满善意和关怀，而且更容易让员工听取他的建议，不会产生逆反心理。</li>
<li>只有接受那些看似相反的品质，不逼自己在其间二选一，才有可能获得最深刻最丰富的情感能力。情感层面的全情投入需要遵循斯多葛派哲学家的“破格文体”——美德的共同存在性。从这一角度看来，没有一种美德是不依赖其他品质而成为美德的。所有的美德都有条件。例如，毫不留情的诚实只是残酷而已。</li>
<li>越来越多证据表明，大脑的运作方式也类似肌肉——积极使用能够提升能力，使用不足就会萎缩。</li>
<li>尼采有句名言 ：“知晓生命的意义，方能忍耐一切。”任何能够点燃人类精神的事物都有助于全情投入、促进最佳表现。意志精力的关键动力在于性格品质——一个人如果有自己的人生目标，他的勇气和信念，即使面对艰难困苦和个人牺牲也会在所不惜。意志精力由激情、奉献、正直与诚实支持着。</li>
<li>弗兰克尔是纳粹集中营中幸存的心理学家，他创作了《活出生命的意义》这本经典巨著。书中他引用了尼采的名言：“知晓生命的意义，方能忍耐一切。”弗兰克尔也描述了在不断有人死去的环境中，这个认知如何挽救了他的生命：生而没有意义的人是痛苦的，没有目标、没有目的、无需继续忍受。他很快就会迷失。我们的人生态度需要从根本上转变。我们既要自己学着转变，也要向绝望之人伸出援手，告诉他我们对生活的期待其实并不重要，重要的是生活于我们有何期望。我们要停止追问生命的意义所在，每时每刻提醒自己接受生命的检视。我们的回应不仅体现在言语和冥想中，还要贯穿我们的行为举止。生命的终极意义是担起责任，找寻难题的答案，并且完成生命为每个人设定的任务。</li>
<li>每个人都拥有许多未知的潜力，只能在困境中才会激发它们。</li>
<li>当目标感从消极流向积极、从外部流向内部、从自己流向他人，它就成为生活中最强大也最持久的精力源。</li>
<li>设想一下，如果你坐在一艘行驶在海上的小船里，船底突然开始漏水，你的目的肯定是阻止小船沉下去。但如果你一直忙着舀水，肯定无暇顾及小船的航向。生活也是如此。当我们忙着填补漏洞，不让自己沉底，就没有多余精力探寻更深层的意义了。</li>
<li>出于对内心深处软弱无力的恐惧，恃强的人会蛮横粗暴地对待他人。因为不愿承认内心的不足，成功的领导者永远都在吹嘘自己的成就，炫耀自己认识多少大人物。</li>
<li>“邪恶的本质缺陷并非是罪恶本身，而是自我否认。”《少有人走的路》的作者斯科特·派克写道，“邪恶攻击他人，而不承认自己的失败……因为必须否认自己是坏人，所以只能把别人当作坏人。”</li>
<li>若困在狭隘的自我视角中，我们也不会注意到或有意培养自己的能力。我们或许可以尽力压制自己令人反感的一面，但同时也很难认可自己的优秀品质。</li>
<li>使用许多手段否认生活中的不如意或逃避为此承担责任。责怪他人并将自己看作受害者是一种常见的方式。</li>
<li>所有表现卓越的人都依靠积极的仪式习惯管理精力和规范行为。如果你一直久坐不动，打算开始锻炼身体，你可以最开始每周3次、每次步行15分钟，然后逐周增加步行时间或加快步伐。</li>
<li>不管面对什么样的事情，他要么全情投入，要么有策略地离开。</li>
<li>人类行为只有5%是受自我意识支配的。我们是习惯的造物，因而我们的行为有95%都是自动反应或对于某种需求或紧急情况的应激反应。</li>
<li>在任何表现至上的领域，压力与恢复的平衡都至关重要。我们越能高效恢复精力，越能尽快储备资源以备调用。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>35-《非暴力沟通》摘要</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/35-%E9%9D%9E%E6%9A%B4%E5%8A%9B%E6%B2%9F%E9%80%9A%E6%91%98%E8%A6%81/</link>
      <pubDate>Fri, 13 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/35-%E9%9D%9E%E6%9A%B4%E5%8A%9B%E6%B2%9F%E9%80%9A%E6%91%98%E8%A6%81/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507161935924.png&#34;&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;言语上的指责、嘲讽、否定、说教以及任意打断、拒不回应、随意出口的评价和结论给我们带来的情感和精神上的创伤，甚至比肉体的伤害更加令人痛苦。这些无心或有意的语言暴力让人与人变得冷漠、隔膜、敌视。&lt;/li&gt;
&lt;li&gt;我很希望这本书能帮助更多的人安静下来。使用暴力的人其实是因为他们内心的宁静遭到了破坏，所以他们才会用暴力的方式维护或寻求心灵的和平。&lt;/li&gt;
&lt;li&gt;非暴力沟通提醒我们人性是相通的——虽然每个人的价值观和生活方式或许不同，但作为人却有着共同的感受和需要。这样，在发生矛盾和冲突的时候，运用非暴力沟通，我们将能专注于彼此的感受和需要，从而促进倾听、理解以及由衷的互助。&lt;/li&gt;
&lt;li&gt;人们常说：“爱能使心灵的创伤痊愈。”&lt;/li&gt;
&lt;li&gt;作为有色人种，生活在执行种族隔离政策的南非并不是很有意思的事情。在那里，肤色随时都可能给你招来无情的刺激。十岁那年，白人打了我，他们认为我太黑了；接着，黑人又打了我，他们认为我太白了。这样的耻辱也许会让任何人想报复社会。&lt;/li&gt;
&lt;li&gt;非暴力生活的一个关键就是：感激生活的赐予，而不贪心。&lt;/li&gt;
&lt;li&gt;我意识到什么是真正的非暴力以及认识自身暴力的重要性。由于缺乏了解，我们常常认识不到自身的暴力。我们认为，只有打人、鞭挞、杀人以及战争等才算是暴力，而这类事与我们无关。&lt;/li&gt;
&lt;li&gt;因为恐惧无法带来和平。&lt;/li&gt;
&lt;li&gt;让尊重、理解、欣赏、感激、慈悲和友情，而非自私自利、贪婪、憎恨、偏见、怀疑和敌意，来主导生活。人们常说：这是一个弱肉强食的世界，为了生存，我们必须不择手段。这个观点，请恕我无法同意。&lt;/li&gt;
&lt;li&gt;我相信，人天生热爱生命，乐于互助。可是，究竟是什么，使我们难以体会到心中的爱，以致互相伤害？又是什么，让有些人即使在充满敌意的环境中，也能心存爱意？&lt;/li&gt;
&lt;li&gt;也许我们并不认为自己的谈话方式是“暴力”的，但我们的语言确实常常引发自己和他人的痛苦。&lt;/li&gt;
&lt;li&gt;当我们真诚助人时，我们丰富他人生命的愿望得到了满足。我们的行为，是出于由衷的喜悦。&lt;/li&gt;
&lt;li&gt;非暴力沟通的四个要素：1．观察 2．感受 3．需要 4．请求&lt;/li&gt;
&lt;li&gt;首先，留意发生的事情。我们此刻观察到什么？不管是否喜欢，只是说出人们所做的事情。要点是，清楚地表达观察结果，而不判断或评估。接着，表达感受，例如受伤、害怕、喜悦、开心、气愤等等。然后，说出哪些需要导致那样的感受。&lt;/li&gt;
&lt;li&gt;非暴力沟通提醒我们专注于彼此的观察、感受、需要和请求。它鼓励倾听，培育尊重与爱，使我们情意相通，乐于互助。有些人用非暴力沟通理解自己，有些人用它改善人际关系，还有人借助它改进工作。在世界各地，非暴力沟通被用来协调各个层面的争论和冲突。&lt;/li&gt;
&lt;li&gt;对他人的评价实际上反映了我们的需要和价值观。&lt;/li&gt;
&lt;li&gt;分类和评判提倡的是暴力。&lt;/li&gt;
&lt;li&gt;暴力的根源在于人们忽视彼此的感受与需要，而将冲突归咎于对方——至少大部分暴力的根源都是如此。&lt;/li&gt;
&lt;li&gt;美国领导人把前苏联看作是致力于摧毁美国生活方式的“邪恶帝国”；前苏联领导人将美国人看作是试图征服他们的“帝国主义压迫者”。双方都没有承认内心的恐惧。&lt;/li&gt;
&lt;li&gt;如果真的想过上悲惨生活，就去与他人做比较。&lt;/li&gt;
&lt;li&gt;比较也是一种评判。&lt;/li&gt;
&lt;li&gt;我们对自己的思想、情感和行动负有责任。可是，人们广泛使用“不得不”这一短语。例如：“不管你是否喜欢，有些事你不得不做。”显然，这种表达方式淡化了个人责任。“你让我”是人们常用的另一短语，例如：“你让我伤透了心。”此时，我们的表达方式忽视了我们情感的内在根源。&lt;/li&gt;
&lt;li&gt;我们可以用负责任的语言代替回避责任的语言。&lt;/li&gt;
&lt;li&gt;一旦意识不到我们是自己的主人，我们就成了危险人物。&lt;/li&gt;
&lt;li&gt;我们无法强迫他人按我们的期待生活。&lt;/li&gt;
&lt;li&gt;认为“某人应当受到惩罚”使我们难以体会到心中的爱。&lt;/li&gt;
&lt;li&gt;我们大多数的人使用的语言倾向于评判、比较、命令和指责，而不是鼓励我们倾听彼此的感受和需要。&lt;/li&gt;
&lt;li&gt;对于国王、沙皇、贵族来说，将臣民训练得具有奴隶般的精神状态符合他们的利益。“不应该”、“应该”和“不得不”这些表达方式特别适合这个目的：人们越是习惯于评定是非，他们也就越倾向于追随权威，来获得正确和错误的标准。一旦专注于自身的感受和需要，我们就不再是好奴隶和好属下。&lt;/li&gt;
&lt;li&gt;人天生热爱生命，乐于互助。可是，异化的沟通方式使我们难以体会到心中的爱。道德评判就是其中的一种，它将不符合我们价值观的人看作是不道德的或邪恶的。进行比较也是一种评判，它会蒙蔽对人对己的爱意。异化的沟通方式还淡化了我们对自己的思想、情感和行为的责任意识。此外，强人所难也会造成心灵的隔阂。&lt;/li&gt;
&lt;li&gt;不区分观察和评论，人们将倾向于听到批评。&lt;/li&gt;
&lt;li&gt;非暴力沟通的第一个要素是观察。我们仔细观察正在发生的事情，并清楚地说出观察结果。非暴力沟通并不要求我们保持完全的客观而不作任何评论。它只是强调区分观察和评论的重要性。将观察和评论混为一谈，人们将倾向于听到批评，甚至会产生逆反心理。&lt;/li&gt;
&lt;li&gt;不带评论的观察是人类智力的最高形式。&lt;/li&gt;
&lt;li&gt;对于大多数的人来说，观察他人及其行为，而不评判、指责或以其他方式进行分析，是难以做到的。&lt;/li&gt;
&lt;li&gt;非暴力沟通的第一个要素是观察。将观察和评论混为一谈，别人就会倾向于听到批评，并反驳我们。非暴力沟通是动态的语言，不主张绝对化的结论。它提倡在特定的时间和情境中进行观察，并清楚地描述观察结果。例如，它会说“欧文在过去的5场比赛中没有进一个球”，而不是说“欧文是个差劲的前锋”。&lt;/li&gt;
&lt;li&gt;只是描述观察结果而不含任何评论。&lt;/li&gt;
&lt;li&gt;非暴力沟通的第二个要素是感受。心理学家罗洛·梅（Rollo May）认为：“成熟的人十分敏锐，就像听交响乐的不同乐章，不论是热情奔放，还是柔和舒缓，他都能体察到细微的起伏。”&lt;/li&gt;
&lt;li&gt;当我们说“我觉得”，我们常常并不是在表达感受，而是在表达想法。&lt;/li&gt;
&lt;li&gt;非暴力沟通的第二个要素是感受。通过建立表达感受的词汇表，我们可以更清楚地表达感受，从而使沟通更为顺畅。在表达感受时，示弱有助于解决冲突。此外，非暴力沟通还对表达具体感受的词语与陈述想法、评论以及观点的词语作了区分。&lt;/li&gt;
&lt;li&gt;非暴力沟通强调，感受的根源在于我们自身。我们的需要和期待，以及对他人言行的看法，导致了我们的感受。&lt;/li&gt;
&lt;li&gt;听到不中听的话的四种选择：
1．责备自己 2．指责他人 3．体会自己的感受和需要 4．体会他人的感受和需要&lt;/li&gt;
&lt;li&gt;批评往往暗含着期待。对他人的批评实际上间接表达了我们尚未满足的需要。如果一个人说“你从不理解我”，他实际上是渴望得到理解。如果太太说“这个星期你每天都工作到很晚，你喜欢工作，不喜欢我”，那反映了她看重亲密关系。&lt;/li&gt;
&lt;li&gt;如果我们通过批评来提出主张，人们的反应常常是申辩或反击。反之，如果我们直接说出需要，其他人就较有可能作出积极的回应。&lt;/li&gt;
&lt;li&gt;双方都习惯于指责对方。&lt;/li&gt;
&lt;li&gt;如果我们不看重自己的需要，别人可能也不会。实际上，如果直接说出需要，获得积极回应的可能性就会增加。&lt;/li&gt;
&lt;li&gt;对于大多数人来说，个人成长一般会经历三个阶段：（1）“情感的奴隶”——我们认为自己有义务使他人快乐；（2）“面目可憎”时期——此时，我们拒绝考虑他人的感受和需要；（3）“生活的主人”——我们意识到，虽然我们对自己的意愿、感受和行动负有完全的责任，但无法为他人负责。与此同时，我们还认识到，我们无法牺牲他人来满足自己的需要。&lt;/li&gt;
&lt;li&gt;首先，清楚地告诉对方，我们希望他们做什么。如果我们请求他人不做什么，对方也许会感到困惑，不知道我们到底想要什么。而且，这样的请求还容易引起别人的反感。&lt;/li&gt;
&lt;li&gt;我们提出的请求越具体越好。如果我们的意思含糊不清，别人就难以了解我们到底想要什么。&lt;/li&gt;
&lt;li&gt;抽象的语言无助于深化自我认识。&lt;/li&gt;
&lt;li&gt;许多来向我求助的人后来发现，他们感到沮丧或灰心，很大程度上是因为他们不清楚自己对他人究竟有什么样的期待。&lt;/li&gt;
&lt;li&gt;如果我们只是表达自己的感受，别人可能就不清楚我们想要什么。&lt;/li&gt;
&lt;li&gt;像“你没有听明白”“这不是我的意思”“你听错了”这样的表达，很可能会让托尼觉得老师在批评他。&lt;/li&gt;
&lt;li&gt;参加集体讨论时，说清楚我们希望得到怎样的反馈，是至关重要的。如果不清楚发言的目的，我们的讨论也许只是在浪费时间，而无法满足任何人的需要。&lt;/li&gt;
&lt;li&gt;如何区分命令和请求：请求没有得到满足时，提出请求的人如果批评和指责，那就是命令；如果想利用对方的内疚来达到目的，也是命令。&lt;/li&gt;
&lt;li&gt;我们越是将他人的不顺从看作是对我们的排斥，我们所表达的愿望就越有可能被看作是命令。&lt;/li&gt;
&lt;li&gt;在生活中，如果我们不想勉强人，那么，清楚地表明这一点是重要的——这有助于人们相信我们提出的是请求而非命令。&lt;/li&gt;
&lt;li&gt;在人们无法满足我们的愿望时，我们是否尊重他们的感受和需要最能体现我们提出的是请求还是命令。如果我们愿意去体会是什么使他们无法说“是”，那么，根据我的定义，我们提出的就是请求而非命令。选择通过请求而非命令来表达愿望，并不意味着，一旦人们说“不”，我们就不再去满足自己的需要。但它意味着，除非已经充分体会是什么妨碍了他人说“是”，我们就不会试图说服他们。&lt;/li&gt;
&lt;li&gt;如果我们只是想改变别人，以使他们的行动符合我们的利益，那么非暴力沟通并不是适当的工具。非暴力沟通是用来帮助我们在诚实和倾听的基础上与人联系。使用非暴力沟通时，我们希望人们的改变和行动是出于对生命的爱。一旦人们相信我们看重彼此的感情，并能兼顾双方的需要，那么，他们也就会相信我们所表达的愿望是请求而非命令。&lt;/li&gt;
&lt;li&gt;我要会见的学生有四十位。在学校中，他们被看作是“品行不端”的学生。我认为，像“品行不端”这样的标签会带来很消极的影响。如果一个学生被贴上这样的标签，那岂不是说他不遵守学校规矩是正常的吗？这样的标签将鼓励学生做我们不希望他们做的事，然后，他们的行为似乎又进一步证实了我们的判断。&lt;/li&gt;
&lt;li&gt;“在印象中，如果我没照你说的去做，你就不会尊重我。如果我知道你并不想使唤我，在你叫我时，我会乐于回应你。如果你高高在上，像个盛气凌人的老板，你将会发现，你一头撞在了墙上。当你反复提醒我，你为我做的各种事情，你最好准备再次碰壁！你可以大声抱怨、责骂，但我仍不会去倒垃圾。即使你现在改变方式，我也需要时间忘记不快。”&lt;/li&gt;
&lt;li&gt;一旦人们认为不答应我们就会受到责罚，他们就会把我们的请求看作是命令。如果我们清楚地表达我们无意强人所难，人们一般会相信，我们提出的是请求而非命令。非暴力沟通的目的不是为了改变他人来迎合我们。相反，非暴力沟通重视每个人的需要，它的目的是帮助我们在诚实和倾听的基础上与人联系。&lt;/li&gt;
&lt;li&gt;在前四章中，我们介绍了如何通过非暴力沟通的四个要素来表达自己。本章我们将探讨如何倾听他人，了解他们的观察、感受、需要和请求，并给予反馈。&lt;/li&gt;
&lt;li&gt;尽管有种种相似之处，生活的每时每刻就像一个刚出生的婴儿，一张新的面孔，我们从未见过，也不可能再次见到。我们无法停留在过去，也无法预见我们的反应。我们需要不带成见地感受变化。我们需要用全身心去倾听。&lt;/li&gt;
&lt;li&gt;在安慰他人或提建议前，先看看那是否是他们想要的。&lt;/li&gt;
&lt;li&gt;·建议：“我想你应该……”
·比较：“这算不了什么。你听听我的经历……”
·说教：“如果你这样做……你将会得到很大的好处。”
·安慰：“这不是你的错；你已经尽最大努力了。”
·回忆：“这让我想起……”
·否定：“高兴一点。不要这么难过。”
·同情：“哦，你这可怜的人……”
·询问：“这种情况是什么时候开始的？”
·辩解：“我原想早点打电话给你，但昨晚……”
·纠正：“事情的经过不是那样的。”&lt;/li&gt;
&lt;li&gt;说了什么，并考虑他的情况符合哪种理论，我们是在诊断人——我们并没有倾听他们。在非暴力沟通中，倾听他人意味着，放下已有的想法和判断，一心一意地体会他人。倾听的这种品质体现了它与理解以及同情之间的区别。&lt;/li&gt;
&lt;li&gt;分析妨碍了倾听。&lt;/li&gt;
&lt;li&gt;不论别人说什么，我们只听到他们此时此刻的（a）观察，（b）感受，（c）需要 和（d）请求。&lt;/li&gt;
&lt;li&gt;在倾听他人的观察、感受、需要和请求之后，我们可以主动表达我们的理解。如果我们已经准确领会了他们的意思，我们的反馈将帮助他们意识到这一点。反之，如果我们的理解还不到位，他们也就有机会来纠正我们。此外，这样做还有助于人们体会自己的状况，从而深入了解自己。&lt;/li&gt;
&lt;li&gt;一般来说，如果一个人在说话时有明显的情绪，他一般会期待得到他人的反馈。如果我们自己是说话的那个人，我们不妨清楚地表明我们是否期待反馈。&lt;/li&gt;
&lt;li&gt;一个人在听别人谈自己的感受和需要时，将会留意其中是否暗含着批评或嘲讽。如果我们的语气很肯定，仿佛是在宣布他们的内心世界，那么，通常不会有好的反应。然而，一旦别人通过我们的语气意识到我们是在体会，而非下结论，他们一般就不会产生反感。&lt;/li&gt;
&lt;li&gt;有时，我们认为自己受到了指责，实际上，那些话是他人表达需要和请求的方式。如果意识到这一点，我们就不会认为自己的人格受到了伤害。反之，如果一心分析自己或对方的过错，我们就会认为自己被贬低了。&lt;/li&gt;
&lt;li&gt;作家约瑟夫·坎伯（Joseph Campbell）说道：“为了幸福，必须把‘别人怎么看我’这个问题放在一边。”&lt;/li&gt;
&lt;li&gt;如果人们常常怀疑我们的诚意，那么，我们就需要好好审视自己的动机。也许，我们只是在机械地运用非暴力沟通，而忘记其目的。这时，我们就可以问自己，我们关心的是加深与人的联系，还是以“标准的”非暴力沟通方式来说话。或者，虽然我们是以非暴力沟通的方式来表达自己，我们在乎的也许只是改变他人来迎合我们的需要。&lt;/li&gt;
&lt;li&gt;一旦一个人意识到自己得到了理解和接纳，一般来说，他会觉得很惬意。&lt;/li&gt;
&lt;li&gt;怎样判断对方的感受是否已经充分表达呢？首先，如果一个人觉得别人已经完全明白他的意思，他就会变得轻松。这时，我们也会感到放松。另一个更为明显的标志是，他停止了谈话。如果无法确定对方是否还有话要说，就不妨问一句：“你还有什么话要告诉我吗？”&lt;/li&gt;
&lt;li&gt;我们无法给别人我们自己都没有的东西。有时，我们会发现自己没有心情去关心别人。一般来说，这反映了我们也需要得到关心。如果告诉他人我们正处于痛苦中，我们无法顾及他们的感受和需要，别人很可能就会伸出援手。&lt;/li&gt;
&lt;li&gt;联合国前秘书长汉马斯克德（Dag Hammarskjold）曾经说道：“你越是留意自己内心的声音，就越能够听到别人的声音。”一旦我们能够敏锐地察觉并照顾自己的感受和需要，我们就有能力迅速调整好状态，来倾听他人。&lt;/li&gt;
&lt;li&gt;我大声地提出请求，是为了提醒他们注意我此时此刻的痛苦和需要。&lt;/li&gt;
&lt;li&gt;当他人遭遇不幸时，我们常常急于提建议，安慰，或表达我们的态度和感受。为了倾听他人，我们需要先放下已有的想法和判断，全心全意地体会对方。倾听他人有助于对他人的理解和接纳。&lt;/li&gt;
&lt;li&gt;如果有人倾听你，不对你评头论足，不替你担惊受怕，也不想改变你，这多美好啊……每当我得到人们的倾听和理解，我就可以用新的眼光看世界，并继续前进……这真神奇啊！一旦有人倾听，看起来无法解决的问题就有了解决办法，千头万绪的思路也会变得清晰起来。&lt;/li&gt;
&lt;li&gt;非暴力沟通鼓励我们表达自己最深的感受和需要，因此，我们有时也许会发现运用非暴力沟通是富有挑战性的。然而，通过倾听，我们将意识到他人的人性以及彼此的共通之处，这会使自我表达变得容易些。我们越是倾听他人语言背后的感受和需要，就越不怕与他们坦诚地沟通。我们最不愿意示弱的时候往往是因为担心失去控制想显得强硬的时候。&lt;/li&gt;
&lt;li&gt;“你和我们说，在一个生气的人面前，永远不要用‘不过’‘可是’‘但是’之类的词语。一开始，我很想为自己辩护，我想和他说，‘可是，我们真的没房间’。幸好，在那时，我想起了那句话。我一直记得这句话，是因为在一周前，妈妈在和我争吵时说，‘如果我说什么，你都说‘但是’，小心我杀了你’。想一想，我妈妈生气时听到‘但是’都想杀了我，何况那个男人呢？如果我在他愤怒时说，‘可是，我们真的没房间’，我想我早就没命了。”&lt;/li&gt;
&lt;li&gt;当别人说“不”的时候，我们常常会认为他们是在拒绝我们。有时，我们甚至还会觉得自己受到了伤害。然而，如果我们能够体会他人的感受和需要，我们也许就会发现是什么使他们无法答应我们的请求。&lt;/li&gt;
&lt;li&gt;有的时候，谈话的气氛很沉闷。我们体会不到说话的人有怎样的感受和需要，也不知道他对我们有什么期待。这样的谈话是很累人的。它只是在浪费我们的时间，而无法帮助我们与他人加深联系。这种局面的出现往往是因为说话的人并不清楚自己的感受、需要和请求。&lt;/li&gt;
&lt;li&gt;人们常常没有意识到，他们需要的是别人的理解和接纳。他们也没有意识到，直接表达自己的感受和需要，与讲故事相比，更容易得到他们所期待的联系。&lt;/li&gt;
&lt;li&gt;说的人更希望对方打断，而不是假装在听。&lt;/li&gt;
&lt;li&gt;所有的人都希望自己的话对人有益，而不想被人当作负担。&lt;/li&gt;
&lt;li&gt;有的时候，我们说了心里话，很想知道对方的反应，却发现对方一句话也不说。这时，我们也许会很不安，容易把事情往坏处想。在别人保持沉默时，我们一般会觉得有些别扭，而很难静下心来体会对方的感受和需要。&lt;/li&gt;
&lt;li&gt;倾听使我们勇于面对自己的弱点。它还可以帮助我们预防潜在的暴力，使谈话生动有趣，并了解“不！”和沉默所反映的感受和需要。一次又一次，我见证了，倾听帮助人们治愈心灵的创伤。&lt;/li&gt;
&lt;li&gt;非暴力沟通最重要的应用也许是培养对自己的爱。&lt;/li&gt;
&lt;li&gt;如何培养对自己的爱呢？转变自我评价的方式是一个重要方面。既然希望自己所做的任何事情都是有益的，那么，自我评价的方式就要有助于学习，使我们的选择符合生命的需要。然而，不幸的是，我们的自我评价方式往往导致自我憎恨，而无助于学习。&lt;/li&gt;
&lt;li&gt;失误揭示我们的局限性，并引导我们的成长。&lt;/li&gt;
&lt;li&gt;我希望，我们的改变是出于对生命的爱，而不是出于羞愧或内疚这些具有负面影响的心理。&lt;/li&gt;
&lt;li&gt;羞愧是自我憎恨的一种形式，出于羞愧的行为不是自由而快乐的行为。即使我们试图更加友善和体贴，一旦人们意识到我们行为背后的羞愧或内疚，他们对这些行为的欣赏也就比不上那些只是出于爱的行为。在我们的语言中，有一个词极易引起羞愧和内疚。我们经常使用它来打击自己。它在我们的意识中是如此根深蒂固，以致许多人无法想象，没有它生活将如何继续。这个词就是“应该”，也就是“我应该早点知道”或“我不应该做那件事情”中的“应该”。如果我们认为自己“应该”怎么样，在大多数的情况下，我们也就封闭了自我。因为“应该”意味着我们别无选择。这使我们感到无奈和沮丧。同时，又心有不甘，不愿屈服。&lt;/li&gt;
&lt;li&gt;自责是尚未满足的需要的可悲表达。&lt;/li&gt;
&lt;li&gt;经常责备自己、强迫自己将使我们“更像椅子而不像人”。非暴力沟通认为，对他人的指责反映了我们遇到了挫折——他人的行为不符合我们的需要。如果我们指责的那个人恰好是我们自己，那么，言下之意是：“我的行为不符合我的需要。”我相信，如果我们专注于需要是否得到满足以及得到怎样的满足，我们就更有可能从自我评价中获益。&lt;/li&gt;
&lt;li&gt;如果发现我们痛骂自己：“你看你，又把事情搞砸了！”我们马上就可以问：“我什么样的需要没有得到满足？”一旦意识到自己尚未满足的需要——很可能是多个层面的需要，我们的身心状态就会发生明显的变化。我们不再感到羞愧、内疚和沮丧，而开始体会到别的情感。不论它们是忧愁、失望、恐惧、悲伤、挫折感或别的——其目的都是推动我们去满足需要和追逐梦想。&lt;/li&gt;
&lt;li&gt;非暴力沟通鼓励我们直面人生的苦难：在遇到挫折时，充分体会人生的悲哀和内心的渴望。是的，感到遗憾是难免的。但它能帮助我们从经历中学习，而无须责备自己。我们意识到过去的行为违背了自己的需要及价值观，并允许这种觉察引发的情感充分流淌。一旦专注于尚未满足的需要，我们就会考虑如何满足它。反之，如果用苛刻的语言指责自己，我们不仅难以找到解决办法，而且容易陷于自我惩罚的痛苦中。&lt;/li&gt;
&lt;li&gt;非暴力沟通自我宽恕：感到遗憾时，我们试图了解过去的行为所要满足的需要。&lt;/li&gt;
&lt;li&gt;人的行为总是服务于自身的需要及价值观。&lt;/li&gt;
&lt;li&gt;当我们拥抱自己的各个方面，并理解它们所反映的需要及价值观，我们活在对自己深深的爱之中。&lt;/li&gt;
&lt;li&gt;我深信，出于对生命纯洁的爱，而不是出于恐惧、内疚、羞愧、职责或义务来选择生活，是爱惜自己的重要体现。&lt;/li&gt;
&lt;li&gt;不论你选择做什么，了解自己为什么要那样做。&lt;/li&gt;
&lt;li&gt;我们知道，如果不做某些事情，我们就会责备自己。我们认为不做那些事情是不对的、愚蠢的。可是，如果为了体面而循规蹈矩，我们最终难免会感到厌烦。&lt;/li&gt;
&lt;li&gt;最危险的行为也许是“因为别人的要求”我们不得不做。&lt;/li&gt;
&lt;li&gt;我相信，我们越是投入服务生命的乐趣中——服务生命是唯一的目的，我们也就越爱自己。&lt;/li&gt;
&lt;li&gt;非暴力沟通最重要的应用也许在于培育对自己的爱。当我们的表现不完美时，我们可以通过体会忧伤和自我宽恕，来看清个人成长的方向，以及避免自我惩罚。评价自己的行为时，我们专注于尚未满足的需要；这样，我们就不再依赖羞愧、内疚、恼怒或沮丧的心理来寻求改变，而让爱主导我们的学习和成长。&lt;/li&gt;
&lt;li&gt;充分表达愤怒的第一步是我们不再归咎于他人。如果我们认为“他让我很生气”，那么，我们难免就会指责他人。然而，实际情况是，我们心情并不取决于他人的行为。&lt;/li&gt;
&lt;li&gt;生气的原因在于我们的想法——对他人的评判和指责。&lt;/li&gt;
&lt;li&gt;如果在一个社会中，内疚被运用来控制人；那么，指责他人就容易成为一种习惯。同时，为了使这种手段奏效，我们可能就会认为一个人可以主导另一个人的情绪。&lt;/li&gt;
&lt;li&gt;听到不中听的话时，我们有四种选择：1．责备自己；2．指责他人；3．体会自己的感受和需要；4．体会他人的感受和需要。&lt;/li&gt;
&lt;li&gt;希望他人因为内疚发生改变，就是将刺激和原因混为一谈。&lt;/li&gt;
&lt;li&gt;假定我们约了个人，时间到了，她却没来。如果彼此的关系处于比较微妙的时期，我们可能会忧心忡忡。如果我们看重的是诚实守信，我们也许会觉得不耐烦。反之，如果我们想休息一会儿，我们可能就不会介意她来晚了。因此，同一件事情，不同的需要导致不同的感受。一旦意识到自己的需要——不论是友谊、诚信还是休息，我们就可以更加体贴自己。我们可能会有强烈的情绪，但不再生气。可是，如果意识不到自己尚未满足的需要，一心考虑别人的过错，我们难免就会生气。除了专注于自身的感受和需要，我们还可以选择去体会对方的感受和需要。此时，我们也不会感到生气。我们无须压抑愤怒，只要我们专注于他人的感受和需要，愤怒也就不再存在。&lt;/li&gt;
&lt;li&gt;在我看来，愤怒是我们的思维方式造成的。它的核心是尚未满足的需要。如果我们能够借助它来提醒自己——我们有需要没有得到满足，而我们的思维方式正使它难以得到满足，那愤怒就是有价值的。&lt;/li&gt;
&lt;li&gt;愤怒驱使我们去惩罚他人，而不是去满足需要。&lt;/li&gt;
&lt;li&gt;我们将会有意识地用“我生气是因为我需要……”来取代“我生气是因为他们……”。&lt;/li&gt;
&lt;li&gt;我生气的原因不在于别人做了什么，而在于我怎么看待对方及其行为。&lt;/li&gt;
&lt;li&gt;当我们意识到自己的需要，愤怒就转变为服务需要的情感。&lt;/li&gt;
&lt;li&gt;如果人们认为自己的痛苦是由其他人造成的，并认为那些人应该受到谴责或惩罚，那么，就像这位年轻的囚犯那样，他们播下了暴力的种子。&lt;/li&gt;
&lt;li&gt;指责一个人，往往使我们的愿望更难得到满足。&lt;/li&gt;
&lt;li&gt;指责他人有时可以使我们达到目的——出于害怕、内疚或惭愧，他们改变了自己的行为。&lt;/li&gt;
&lt;li&gt;批评和指责使人倾向于自我保护并变得更有攻击性。&lt;/li&gt;
&lt;li&gt;我们只是静静地体会自己。接着，想一想是什么想法使我们生气了。&lt;/li&gt;
&lt;li&gt;越是能够倾听他人，也越有机会被倾听。&lt;/li&gt;
&lt;li&gt;在大多数的情况下，在表达自己之前，我们需要先倾听他人。如果对方还处于某种情绪中，他们就很难静下心来体会我们的感受和需要。一旦我们用心倾听他们，并表达我们的理解，在得到倾听和理解之后，他们一般也就会开始留意我们的感受和需要。&lt;/li&gt;
&lt;li&gt;一旦意识到他人的感受和需要，我们就会发现彼此相同的人性。&lt;/li&gt;
&lt;li&gt;留意头脑中出现的暴力想法，而不评判它们。&lt;/li&gt;
&lt;li&gt;那位先生一直诉说着他的忧虑和不满。不经意间，他已经从犹太人谈到了黑人。看起来，他渴望有人了解他的痛苦。我静静地听着，大概十分钟后，他停了下来。他觉得我已经理解了他。&lt;/li&gt;
&lt;li&gt;人们常常觉得自己受到了指责，有时他们自己也同意，并开始恨自己——但这并不意味着他们会改变自己的行为。&lt;/li&gt;
&lt;li&gt;我们需要有足够的耐心来学习和运用非暴力沟通。在与人交往的过程中，我们的第一反应常常是习惯性的反应，因此，运用非暴力沟通有时是很别扭的事。然而，如果我们想要实现自己的人生选择，我们就要给自己充分的时间。&lt;/li&gt;
&lt;li&gt;练习把每一个指责都转化为尚未满足的需要。&lt;/li&gt;
&lt;li&gt;如果你希望自己在生气的时候也能运用非暴力沟通，我建议你做以下的练习。在前面，我们已经提到，我们生气是因为我们的想法——我们认为人们“应该”或“不应该”做什么，我们还给人贴上各种标签，并说长论短。请留意我们头脑中“我不喜欢抽烟的人……”之类的想法。然后，问自己：“我不喜欢他们……，是因为我什么样的需要没有得到满足？”通过这样的方式，我们就把注意力放在了尚未得到满足的需要，而不是考虑他人有什么过错。&lt;/li&gt;
&lt;li&gt;在生气时，批评和指责他人都无法真正传达我们的心声。如果想充分表达愤怒，我们就不能归咎于他人，而把注意力放在自己的感受和需要上。与批评和指责他人相比，直接说出我们的需要更有可能使我们的愿望得到满足。&lt;/li&gt;
&lt;li&gt;表达愤怒的四个步骤是：（1）停下来，除了呼吸，什么都别做；（2）想一想是什么想法使我们生气了；（3）体会自己的需要；（4）表达感受和尚未满足的需要。有时，在第3步和第4步之间，我们需要先倾听他人。在得到倾听和理解之后，他们也就可以静下心来体会我们的感受和需要。&lt;/li&gt;
&lt;li&gt;非暴力沟通认为，如果一个人做的事情会伤害到自己或他人，那是因为他不够成熟。为此，他需要得到帮助。如果我们不够成熟，我们可能会有以下的表现：（1）我们意识不到自己行为的后果；（2）我们认识不到，我们并不需要通过惩罚他人来满足自己的需要；（3）我们相信，我们有“权利”去惩罚或伤害他人，因为他们是罪有应得；（4）我们产生了幻觉，例如，听到“某种声音”叫我们去杀人。&lt;/li&gt;
&lt;li&gt;使用防卫性的强制力，是为了保护自己或他人，而不是为了惩罚、羞辱或谴责他人。&lt;/li&gt;
&lt;li&gt;我们希望痛苦能让他们：（1）意识到自己的过错；（2）感到懊悔；（3）改变行为。然而，在实际生活中，惩罚往往加强了对方的敌意和抵触心理，使双方的关系更加疏远。&lt;/li&gt;
&lt;li&gt;有的时候孩子拒绝做一件对他们有益的事情，只是因为他们不想在父母的压力面前屈服。其次，即使体罚能带来立竿见影的效果，这也并不意味着，其他方法无法达到同样的效果。最后，我还担心，体罚孩子会造成不良的社会影响。如果我们把暴力作为解决问题的办法，虽然孩子可能会去做我们要求的事，但这样做难道不是在鼓励孩子用暴力来解决冲突吗？&lt;/li&gt;
&lt;li&gt;当我们为了回避惩罚去做事情时，我们可能会忽视事情本身的价值，而陷于对失败的忧虑。如果员工的表现只是在服从管理层的命令，士气就会受到影响；或迟或早，工作效率就会降低。&lt;/li&gt;
&lt;li&gt;我希望他基于怎样的原因去做我想要他做的事情？&lt;/li&gt;
&lt;li&gt;了解别人基于什么样的原因来满足我们的愿望是至关重要的。&lt;/li&gt;
&lt;li&gt;在有些情形中，我们没有机会和他人交流，这时，我们也许需要使用强制力来保护自己和他人。我们这样做，是为了避免伤害，而不是为了惩罚他人。如果我们威胁他人或实施惩罚，人们常常会产生敌意和抵触心理。这样，彼此的关系将会疏远。同时，惩罚还可能使人忽视事情本身的意义，而把注意力放在不服从的后果上。如果我们试图通过惩罚来使人们认识自己的需要，那么，我们很可能适得其反。&lt;/li&gt;
&lt;li&gt;然而，对于大多数人来说，倾听和表达自己的需要并不容易。一般来说，我们的文化倾向于把个人需要看作是消极的、具有破坏性的。如果一个人公开表达自己的需要，就很可能被看作是自私的。&lt;/li&gt;
&lt;li&gt;专注于我们想要做的，而不是追究错在哪里。&lt;/li&gt;
&lt;li&gt;我感到惊讶的是，只要我不再批评和指责他人，而把注意力放在自己的感受和需要，我的心情就放松了许多。&lt;/li&gt;
&lt;li&gt;在情绪低落的时候，我们也许会怨天尤人。然而，如果我们以苛刻的态度对人对己，我们的心情也好不到哪里去。通过运用非暴力沟通，我们不再试图分析自己或他人有什么毛病，而是用心去了解我们的需要，这样，我们的内心将逐渐变得平和。一旦我们发现自己心底深处的愿望，并采取积极的行动，我们将会重获生活的热情。&lt;/li&gt;
&lt;li&gt;优雅地接受别人的感激。&lt;/li&gt;
&lt;li&gt;在别人表达感激时，人们通常有两种截然不同的反应。一种是自我膨胀，相信我们比别人优越；另一种是假谦虚，否定别人的欣赏，耸耸肩说：“哦，这没什么。”纳菲滋帮助我看到了，我们有别的方式来听取感激。如果我意识到我的能力是生命赋予我的，我就能够同时避免自我膨胀和假谦虚。&lt;/li&gt;
&lt;li&gt;虽然人们在听到感激时会不太自在，但绝大多数的人渴望得到他人的肯定和感激。&lt;/li&gt;
&lt;li&gt;我刚刚结束一个有100多人参加的研讨班，除了一个人，其他人都高度评价这次的研讨班。然而，我牢记的却是那个人的不满。&lt;/li&gt;
&lt;li&gt;约翰·鲍威尔（John Powell）在他的《爱的秘密》一书中讲到，对于没有在父亲活着的时候表达自己的感激，他十分伤心。这激起了我的强烈共鸣。如果无法向那些对我们的一生有极为重要影响的人表达感激，我们会感到多么悲哀啊！&lt;/li&gt;
&lt;li&gt;在赞扬他人时，我们很少揭示内心活动，而把自己放在了裁判的位置。赞扬也常常被人用来实现个人目的。非暴力沟通鼓励我们充分表达感激。在表达感激时，我们说出：（1）对我们有益的行为；（2）我们的哪些需要得到了满足；（3）我们的需要得到满足后，我们是什么样的心情。&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202507161935924.png"></p>
<ol>
<li>言语上的指责、嘲讽、否定、说教以及任意打断、拒不回应、随意出口的评价和结论给我们带来的情感和精神上的创伤，甚至比肉体的伤害更加令人痛苦。这些无心或有意的语言暴力让人与人变得冷漠、隔膜、敌视。</li>
<li>我很希望这本书能帮助更多的人安静下来。使用暴力的人其实是因为他们内心的宁静遭到了破坏，所以他们才会用暴力的方式维护或寻求心灵的和平。</li>
<li>非暴力沟通提醒我们人性是相通的——虽然每个人的价值观和生活方式或许不同，但作为人却有着共同的感受和需要。这样，在发生矛盾和冲突的时候，运用非暴力沟通，我们将能专注于彼此的感受和需要，从而促进倾听、理解以及由衷的互助。</li>
<li>人们常说：“爱能使心灵的创伤痊愈。”</li>
<li>作为有色人种，生活在执行种族隔离政策的南非并不是很有意思的事情。在那里，肤色随时都可能给你招来无情的刺激。十岁那年，白人打了我，他们认为我太黑了；接着，黑人又打了我，他们认为我太白了。这样的耻辱也许会让任何人想报复社会。</li>
<li>非暴力生活的一个关键就是：感激生活的赐予，而不贪心。</li>
<li>我意识到什么是真正的非暴力以及认识自身暴力的重要性。由于缺乏了解，我们常常认识不到自身的暴力。我们认为，只有打人、鞭挞、杀人以及战争等才算是暴力，而这类事与我们无关。</li>
<li>因为恐惧无法带来和平。</li>
<li>让尊重、理解、欣赏、感激、慈悲和友情，而非自私自利、贪婪、憎恨、偏见、怀疑和敌意，来主导生活。人们常说：这是一个弱肉强食的世界，为了生存，我们必须不择手段。这个观点，请恕我无法同意。</li>
<li>我相信，人天生热爱生命，乐于互助。可是，究竟是什么，使我们难以体会到心中的爱，以致互相伤害？又是什么，让有些人即使在充满敌意的环境中，也能心存爱意？</li>
<li>也许我们并不认为自己的谈话方式是“暴力”的，但我们的语言确实常常引发自己和他人的痛苦。</li>
<li>当我们真诚助人时，我们丰富他人生命的愿望得到了满足。我们的行为，是出于由衷的喜悦。</li>
<li>非暴力沟通的四个要素：1．观察 2．感受 3．需要 4．请求</li>
<li>首先，留意发生的事情。我们此刻观察到什么？不管是否喜欢，只是说出人们所做的事情。要点是，清楚地表达观察结果，而不判断或评估。接着，表达感受，例如受伤、害怕、喜悦、开心、气愤等等。然后，说出哪些需要导致那样的感受。</li>
<li>非暴力沟通提醒我们专注于彼此的观察、感受、需要和请求。它鼓励倾听，培育尊重与爱，使我们情意相通，乐于互助。有些人用非暴力沟通理解自己，有些人用它改善人际关系，还有人借助它改进工作。在世界各地，非暴力沟通被用来协调各个层面的争论和冲突。</li>
<li>对他人的评价实际上反映了我们的需要和价值观。</li>
<li>分类和评判提倡的是暴力。</li>
<li>暴力的根源在于人们忽视彼此的感受与需要，而将冲突归咎于对方——至少大部分暴力的根源都是如此。</li>
<li>美国领导人把前苏联看作是致力于摧毁美国生活方式的“邪恶帝国”；前苏联领导人将美国人看作是试图征服他们的“帝国主义压迫者”。双方都没有承认内心的恐惧。</li>
<li>如果真的想过上悲惨生活，就去与他人做比较。</li>
<li>比较也是一种评判。</li>
<li>我们对自己的思想、情感和行动负有责任。可是，人们广泛使用“不得不”这一短语。例如：“不管你是否喜欢，有些事你不得不做。”显然，这种表达方式淡化了个人责任。“你让我”是人们常用的另一短语，例如：“你让我伤透了心。”此时，我们的表达方式忽视了我们情感的内在根源。</li>
<li>我们可以用负责任的语言代替回避责任的语言。</li>
<li>一旦意识不到我们是自己的主人，我们就成了危险人物。</li>
<li>我们无法强迫他人按我们的期待生活。</li>
<li>认为“某人应当受到惩罚”使我们难以体会到心中的爱。</li>
<li>我们大多数的人使用的语言倾向于评判、比较、命令和指责，而不是鼓励我们倾听彼此的感受和需要。</li>
<li>对于国王、沙皇、贵族来说，将臣民训练得具有奴隶般的精神状态符合他们的利益。“不应该”、“应该”和“不得不”这些表达方式特别适合这个目的：人们越是习惯于评定是非，他们也就越倾向于追随权威，来获得正确和错误的标准。一旦专注于自身的感受和需要，我们就不再是好奴隶和好属下。</li>
<li>人天生热爱生命，乐于互助。可是，异化的沟通方式使我们难以体会到心中的爱。道德评判就是其中的一种，它将不符合我们价值观的人看作是不道德的或邪恶的。进行比较也是一种评判，它会蒙蔽对人对己的爱意。异化的沟通方式还淡化了我们对自己的思想、情感和行为的责任意识。此外，强人所难也会造成心灵的隔阂。</li>
<li>不区分观察和评论，人们将倾向于听到批评。</li>
<li>非暴力沟通的第一个要素是观察。我们仔细观察正在发生的事情，并清楚地说出观察结果。非暴力沟通并不要求我们保持完全的客观而不作任何评论。它只是强调区分观察和评论的重要性。将观察和评论混为一谈，人们将倾向于听到批评，甚至会产生逆反心理。</li>
<li>不带评论的观察是人类智力的最高形式。</li>
<li>对于大多数的人来说，观察他人及其行为，而不评判、指责或以其他方式进行分析，是难以做到的。</li>
<li>非暴力沟通的第一个要素是观察。将观察和评论混为一谈，别人就会倾向于听到批评，并反驳我们。非暴力沟通是动态的语言，不主张绝对化的结论。它提倡在特定的时间和情境中进行观察，并清楚地描述观察结果。例如，它会说“欧文在过去的5场比赛中没有进一个球”，而不是说“欧文是个差劲的前锋”。</li>
<li>只是描述观察结果而不含任何评论。</li>
<li>非暴力沟通的第二个要素是感受。心理学家罗洛·梅（Rollo May）认为：“成熟的人十分敏锐，就像听交响乐的不同乐章，不论是热情奔放，还是柔和舒缓，他都能体察到细微的起伏。”</li>
<li>当我们说“我觉得”，我们常常并不是在表达感受，而是在表达想法。</li>
<li>非暴力沟通的第二个要素是感受。通过建立表达感受的词汇表，我们可以更清楚地表达感受，从而使沟通更为顺畅。在表达感受时，示弱有助于解决冲突。此外，非暴力沟通还对表达具体感受的词语与陈述想法、评论以及观点的词语作了区分。</li>
<li>非暴力沟通强调，感受的根源在于我们自身。我们的需要和期待，以及对他人言行的看法，导致了我们的感受。</li>
<li>听到不中听的话的四种选择：
1．责备自己 2．指责他人 3．体会自己的感受和需要 4．体会他人的感受和需要</li>
<li>批评往往暗含着期待。对他人的批评实际上间接表达了我们尚未满足的需要。如果一个人说“你从不理解我”，他实际上是渴望得到理解。如果太太说“这个星期你每天都工作到很晚，你喜欢工作，不喜欢我”，那反映了她看重亲密关系。</li>
<li>如果我们通过批评来提出主张，人们的反应常常是申辩或反击。反之，如果我们直接说出需要，其他人就较有可能作出积极的回应。</li>
<li>双方都习惯于指责对方。</li>
<li>如果我们不看重自己的需要，别人可能也不会。实际上，如果直接说出需要，获得积极回应的可能性就会增加。</li>
<li>对于大多数人来说，个人成长一般会经历三个阶段：（1）“情感的奴隶”——我们认为自己有义务使他人快乐；（2）“面目可憎”时期——此时，我们拒绝考虑他人的感受和需要；（3）“生活的主人”——我们意识到，虽然我们对自己的意愿、感受和行动负有完全的责任，但无法为他人负责。与此同时，我们还认识到，我们无法牺牲他人来满足自己的需要。</li>
<li>首先，清楚地告诉对方，我们希望他们做什么。如果我们请求他人不做什么，对方也许会感到困惑，不知道我们到底想要什么。而且，这样的请求还容易引起别人的反感。</li>
<li>我们提出的请求越具体越好。如果我们的意思含糊不清，别人就难以了解我们到底想要什么。</li>
<li>抽象的语言无助于深化自我认识。</li>
<li>许多来向我求助的人后来发现，他们感到沮丧或灰心，很大程度上是因为他们不清楚自己对他人究竟有什么样的期待。</li>
<li>如果我们只是表达自己的感受，别人可能就不清楚我们想要什么。</li>
<li>像“你没有听明白”“这不是我的意思”“你听错了”这样的表达，很可能会让托尼觉得老师在批评他。</li>
<li>参加集体讨论时，说清楚我们希望得到怎样的反馈，是至关重要的。如果不清楚发言的目的，我们的讨论也许只是在浪费时间，而无法满足任何人的需要。</li>
<li>如何区分命令和请求：请求没有得到满足时，提出请求的人如果批评和指责，那就是命令；如果想利用对方的内疚来达到目的，也是命令。</li>
<li>我们越是将他人的不顺从看作是对我们的排斥，我们所表达的愿望就越有可能被看作是命令。</li>
<li>在生活中，如果我们不想勉强人，那么，清楚地表明这一点是重要的——这有助于人们相信我们提出的是请求而非命令。</li>
<li>在人们无法满足我们的愿望时，我们是否尊重他们的感受和需要最能体现我们提出的是请求还是命令。如果我们愿意去体会是什么使他们无法说“是”，那么，根据我的定义，我们提出的就是请求而非命令。选择通过请求而非命令来表达愿望，并不意味着，一旦人们说“不”，我们就不再去满足自己的需要。但它意味着，除非已经充分体会是什么妨碍了他人说“是”，我们就不会试图说服他们。</li>
<li>如果我们只是想改变别人，以使他们的行动符合我们的利益，那么非暴力沟通并不是适当的工具。非暴力沟通是用来帮助我们在诚实和倾听的基础上与人联系。使用非暴力沟通时，我们希望人们的改变和行动是出于对生命的爱。一旦人们相信我们看重彼此的感情，并能兼顾双方的需要，那么，他们也就会相信我们所表达的愿望是请求而非命令。</li>
<li>我要会见的学生有四十位。在学校中，他们被看作是“品行不端”的学生。我认为，像“品行不端”这样的标签会带来很消极的影响。如果一个学生被贴上这样的标签，那岂不是说他不遵守学校规矩是正常的吗？这样的标签将鼓励学生做我们不希望他们做的事，然后，他们的行为似乎又进一步证实了我们的判断。</li>
<li>“在印象中，如果我没照你说的去做，你就不会尊重我。如果我知道你并不想使唤我，在你叫我时，我会乐于回应你。如果你高高在上，像个盛气凌人的老板，你将会发现，你一头撞在了墙上。当你反复提醒我，你为我做的各种事情，你最好准备再次碰壁！你可以大声抱怨、责骂，但我仍不会去倒垃圾。即使你现在改变方式，我也需要时间忘记不快。”</li>
<li>一旦人们认为不答应我们就会受到责罚，他们就会把我们的请求看作是命令。如果我们清楚地表达我们无意强人所难，人们一般会相信，我们提出的是请求而非命令。非暴力沟通的目的不是为了改变他人来迎合我们。相反，非暴力沟通重视每个人的需要，它的目的是帮助我们在诚实和倾听的基础上与人联系。</li>
<li>在前四章中，我们介绍了如何通过非暴力沟通的四个要素来表达自己。本章我们将探讨如何倾听他人，了解他们的观察、感受、需要和请求，并给予反馈。</li>
<li>尽管有种种相似之处，生活的每时每刻就像一个刚出生的婴儿，一张新的面孔，我们从未见过，也不可能再次见到。我们无法停留在过去，也无法预见我们的反应。我们需要不带成见地感受变化。我们需要用全身心去倾听。</li>
<li>在安慰他人或提建议前，先看看那是否是他们想要的。</li>
<li>·建议：“我想你应该……”
·比较：“这算不了什么。你听听我的经历……”
·说教：“如果你这样做……你将会得到很大的好处。”
·安慰：“这不是你的错；你已经尽最大努力了。”
·回忆：“这让我想起……”
·否定：“高兴一点。不要这么难过。”
·同情：“哦，你这可怜的人……”
·询问：“这种情况是什么时候开始的？”
·辩解：“我原想早点打电话给你，但昨晚……”
·纠正：“事情的经过不是那样的。”</li>
<li>说了什么，并考虑他的情况符合哪种理论，我们是在诊断人——我们并没有倾听他们。在非暴力沟通中，倾听他人意味着，放下已有的想法和判断，一心一意地体会他人。倾听的这种品质体现了它与理解以及同情之间的区别。</li>
<li>分析妨碍了倾听。</li>
<li>不论别人说什么，我们只听到他们此时此刻的（a）观察，（b）感受，（c）需要 和（d）请求。</li>
<li>在倾听他人的观察、感受、需要和请求之后，我们可以主动表达我们的理解。如果我们已经准确领会了他们的意思，我们的反馈将帮助他们意识到这一点。反之，如果我们的理解还不到位，他们也就有机会来纠正我们。此外，这样做还有助于人们体会自己的状况，从而深入了解自己。</li>
<li>一般来说，如果一个人在说话时有明显的情绪，他一般会期待得到他人的反馈。如果我们自己是说话的那个人，我们不妨清楚地表明我们是否期待反馈。</li>
<li>一个人在听别人谈自己的感受和需要时，将会留意其中是否暗含着批评或嘲讽。如果我们的语气很肯定，仿佛是在宣布他们的内心世界，那么，通常不会有好的反应。然而，一旦别人通过我们的语气意识到我们是在体会，而非下结论，他们一般就不会产生反感。</li>
<li>有时，我们认为自己受到了指责，实际上，那些话是他人表达需要和请求的方式。如果意识到这一点，我们就不会认为自己的人格受到了伤害。反之，如果一心分析自己或对方的过错，我们就会认为自己被贬低了。</li>
<li>作家约瑟夫·坎伯（Joseph Campbell）说道：“为了幸福，必须把‘别人怎么看我’这个问题放在一边。”</li>
<li>如果人们常常怀疑我们的诚意，那么，我们就需要好好审视自己的动机。也许，我们只是在机械地运用非暴力沟通，而忘记其目的。这时，我们就可以问自己，我们关心的是加深与人的联系，还是以“标准的”非暴力沟通方式来说话。或者，虽然我们是以非暴力沟通的方式来表达自己，我们在乎的也许只是改变他人来迎合我们的需要。</li>
<li>一旦一个人意识到自己得到了理解和接纳，一般来说，他会觉得很惬意。</li>
<li>怎样判断对方的感受是否已经充分表达呢？首先，如果一个人觉得别人已经完全明白他的意思，他就会变得轻松。这时，我们也会感到放松。另一个更为明显的标志是，他停止了谈话。如果无法确定对方是否还有话要说，就不妨问一句：“你还有什么话要告诉我吗？”</li>
<li>我们无法给别人我们自己都没有的东西。有时，我们会发现自己没有心情去关心别人。一般来说，这反映了我们也需要得到关心。如果告诉他人我们正处于痛苦中，我们无法顾及他们的感受和需要，别人很可能就会伸出援手。</li>
<li>联合国前秘书长汉马斯克德（Dag Hammarskjold）曾经说道：“你越是留意自己内心的声音，就越能够听到别人的声音。”一旦我们能够敏锐地察觉并照顾自己的感受和需要，我们就有能力迅速调整好状态，来倾听他人。</li>
<li>我大声地提出请求，是为了提醒他们注意我此时此刻的痛苦和需要。</li>
<li>当他人遭遇不幸时，我们常常急于提建议，安慰，或表达我们的态度和感受。为了倾听他人，我们需要先放下已有的想法和判断，全心全意地体会对方。倾听他人有助于对他人的理解和接纳。</li>
<li>如果有人倾听你，不对你评头论足，不替你担惊受怕，也不想改变你，这多美好啊……每当我得到人们的倾听和理解，我就可以用新的眼光看世界，并继续前进……这真神奇啊！一旦有人倾听，看起来无法解决的问题就有了解决办法，千头万绪的思路也会变得清晰起来。</li>
<li>非暴力沟通鼓励我们表达自己最深的感受和需要，因此，我们有时也许会发现运用非暴力沟通是富有挑战性的。然而，通过倾听，我们将意识到他人的人性以及彼此的共通之处，这会使自我表达变得容易些。我们越是倾听他人语言背后的感受和需要，就越不怕与他们坦诚地沟通。我们最不愿意示弱的时候往往是因为担心失去控制想显得强硬的时候。</li>
<li>“你和我们说，在一个生气的人面前，永远不要用‘不过’‘可是’‘但是’之类的词语。一开始，我很想为自己辩护，我想和他说，‘可是，我们真的没房间’。幸好，在那时，我想起了那句话。我一直记得这句话，是因为在一周前，妈妈在和我争吵时说，‘如果我说什么，你都说‘但是’，小心我杀了你’。想一想，我妈妈生气时听到‘但是’都想杀了我，何况那个男人呢？如果我在他愤怒时说，‘可是，我们真的没房间’，我想我早就没命了。”</li>
<li>当别人说“不”的时候，我们常常会认为他们是在拒绝我们。有时，我们甚至还会觉得自己受到了伤害。然而，如果我们能够体会他人的感受和需要，我们也许就会发现是什么使他们无法答应我们的请求。</li>
<li>有的时候，谈话的气氛很沉闷。我们体会不到说话的人有怎样的感受和需要，也不知道他对我们有什么期待。这样的谈话是很累人的。它只是在浪费我们的时间，而无法帮助我们与他人加深联系。这种局面的出现往往是因为说话的人并不清楚自己的感受、需要和请求。</li>
<li>人们常常没有意识到，他们需要的是别人的理解和接纳。他们也没有意识到，直接表达自己的感受和需要，与讲故事相比，更容易得到他们所期待的联系。</li>
<li>说的人更希望对方打断，而不是假装在听。</li>
<li>所有的人都希望自己的话对人有益，而不想被人当作负担。</li>
<li>有的时候，我们说了心里话，很想知道对方的反应，却发现对方一句话也不说。这时，我们也许会很不安，容易把事情往坏处想。在别人保持沉默时，我们一般会觉得有些别扭，而很难静下心来体会对方的感受和需要。</li>
<li>倾听使我们勇于面对自己的弱点。它还可以帮助我们预防潜在的暴力，使谈话生动有趣，并了解“不！”和沉默所反映的感受和需要。一次又一次，我见证了，倾听帮助人们治愈心灵的创伤。</li>
<li>非暴力沟通最重要的应用也许是培养对自己的爱。</li>
<li>如何培养对自己的爱呢？转变自我评价的方式是一个重要方面。既然希望自己所做的任何事情都是有益的，那么，自我评价的方式就要有助于学习，使我们的选择符合生命的需要。然而，不幸的是，我们的自我评价方式往往导致自我憎恨，而无助于学习。</li>
<li>失误揭示我们的局限性，并引导我们的成长。</li>
<li>我希望，我们的改变是出于对生命的爱，而不是出于羞愧或内疚这些具有负面影响的心理。</li>
<li>羞愧是自我憎恨的一种形式，出于羞愧的行为不是自由而快乐的行为。即使我们试图更加友善和体贴，一旦人们意识到我们行为背后的羞愧或内疚，他们对这些行为的欣赏也就比不上那些只是出于爱的行为。在我们的语言中，有一个词极易引起羞愧和内疚。我们经常使用它来打击自己。它在我们的意识中是如此根深蒂固，以致许多人无法想象，没有它生活将如何继续。这个词就是“应该”，也就是“我应该早点知道”或“我不应该做那件事情”中的“应该”。如果我们认为自己“应该”怎么样，在大多数的情况下，我们也就封闭了自我。因为“应该”意味着我们别无选择。这使我们感到无奈和沮丧。同时，又心有不甘，不愿屈服。</li>
<li>自责是尚未满足的需要的可悲表达。</li>
<li>经常责备自己、强迫自己将使我们“更像椅子而不像人”。非暴力沟通认为，对他人的指责反映了我们遇到了挫折——他人的行为不符合我们的需要。如果我们指责的那个人恰好是我们自己，那么，言下之意是：“我的行为不符合我的需要。”我相信，如果我们专注于需要是否得到满足以及得到怎样的满足，我们就更有可能从自我评价中获益。</li>
<li>如果发现我们痛骂自己：“你看你，又把事情搞砸了！”我们马上就可以问：“我什么样的需要没有得到满足？”一旦意识到自己尚未满足的需要——很可能是多个层面的需要，我们的身心状态就会发生明显的变化。我们不再感到羞愧、内疚和沮丧，而开始体会到别的情感。不论它们是忧愁、失望、恐惧、悲伤、挫折感或别的——其目的都是推动我们去满足需要和追逐梦想。</li>
<li>非暴力沟通鼓励我们直面人生的苦难：在遇到挫折时，充分体会人生的悲哀和内心的渴望。是的，感到遗憾是难免的。但它能帮助我们从经历中学习，而无须责备自己。我们意识到过去的行为违背了自己的需要及价值观，并允许这种觉察引发的情感充分流淌。一旦专注于尚未满足的需要，我们就会考虑如何满足它。反之，如果用苛刻的语言指责自己，我们不仅难以找到解决办法，而且容易陷于自我惩罚的痛苦中。</li>
<li>非暴力沟通自我宽恕：感到遗憾时，我们试图了解过去的行为所要满足的需要。</li>
<li>人的行为总是服务于自身的需要及价值观。</li>
<li>当我们拥抱自己的各个方面，并理解它们所反映的需要及价值观，我们活在对自己深深的爱之中。</li>
<li>我深信，出于对生命纯洁的爱，而不是出于恐惧、内疚、羞愧、职责或义务来选择生活，是爱惜自己的重要体现。</li>
<li>不论你选择做什么，了解自己为什么要那样做。</li>
<li>我们知道，如果不做某些事情，我们就会责备自己。我们认为不做那些事情是不对的、愚蠢的。可是，如果为了体面而循规蹈矩，我们最终难免会感到厌烦。</li>
<li>最危险的行为也许是“因为别人的要求”我们不得不做。</li>
<li>我相信，我们越是投入服务生命的乐趣中——服务生命是唯一的目的，我们也就越爱自己。</li>
<li>非暴力沟通最重要的应用也许在于培育对自己的爱。当我们的表现不完美时，我们可以通过体会忧伤和自我宽恕，来看清个人成长的方向，以及避免自我惩罚。评价自己的行为时，我们专注于尚未满足的需要；这样，我们就不再依赖羞愧、内疚、恼怒或沮丧的心理来寻求改变，而让爱主导我们的学习和成长。</li>
<li>充分表达愤怒的第一步是我们不再归咎于他人。如果我们认为“他让我很生气”，那么，我们难免就会指责他人。然而，实际情况是，我们心情并不取决于他人的行为。</li>
<li>生气的原因在于我们的想法——对他人的评判和指责。</li>
<li>如果在一个社会中，内疚被运用来控制人；那么，指责他人就容易成为一种习惯。同时，为了使这种手段奏效，我们可能就会认为一个人可以主导另一个人的情绪。</li>
<li>听到不中听的话时，我们有四种选择：1．责备自己；2．指责他人；3．体会自己的感受和需要；4．体会他人的感受和需要。</li>
<li>希望他人因为内疚发生改变，就是将刺激和原因混为一谈。</li>
<li>假定我们约了个人，时间到了，她却没来。如果彼此的关系处于比较微妙的时期，我们可能会忧心忡忡。如果我们看重的是诚实守信，我们也许会觉得不耐烦。反之，如果我们想休息一会儿，我们可能就不会介意她来晚了。因此，同一件事情，不同的需要导致不同的感受。一旦意识到自己的需要——不论是友谊、诚信还是休息，我们就可以更加体贴自己。我们可能会有强烈的情绪，但不再生气。可是，如果意识不到自己尚未满足的需要，一心考虑别人的过错，我们难免就会生气。除了专注于自身的感受和需要，我们还可以选择去体会对方的感受和需要。此时，我们也不会感到生气。我们无须压抑愤怒，只要我们专注于他人的感受和需要，愤怒也就不再存在。</li>
<li>在我看来，愤怒是我们的思维方式造成的。它的核心是尚未满足的需要。如果我们能够借助它来提醒自己——我们有需要没有得到满足，而我们的思维方式正使它难以得到满足，那愤怒就是有价值的。</li>
<li>愤怒驱使我们去惩罚他人，而不是去满足需要。</li>
<li>我们将会有意识地用“我生气是因为我需要……”来取代“我生气是因为他们……”。</li>
<li>我生气的原因不在于别人做了什么，而在于我怎么看待对方及其行为。</li>
<li>当我们意识到自己的需要，愤怒就转变为服务需要的情感。</li>
<li>如果人们认为自己的痛苦是由其他人造成的，并认为那些人应该受到谴责或惩罚，那么，就像这位年轻的囚犯那样，他们播下了暴力的种子。</li>
<li>指责一个人，往往使我们的愿望更难得到满足。</li>
<li>指责他人有时可以使我们达到目的——出于害怕、内疚或惭愧，他们改变了自己的行为。</li>
<li>批评和指责使人倾向于自我保护并变得更有攻击性。</li>
<li>我们只是静静地体会自己。接着，想一想是什么想法使我们生气了。</li>
<li>越是能够倾听他人，也越有机会被倾听。</li>
<li>在大多数的情况下，在表达自己之前，我们需要先倾听他人。如果对方还处于某种情绪中，他们就很难静下心来体会我们的感受和需要。一旦我们用心倾听他们，并表达我们的理解，在得到倾听和理解之后，他们一般也就会开始留意我们的感受和需要。</li>
<li>一旦意识到他人的感受和需要，我们就会发现彼此相同的人性。</li>
<li>留意头脑中出现的暴力想法，而不评判它们。</li>
<li>那位先生一直诉说着他的忧虑和不满。不经意间，他已经从犹太人谈到了黑人。看起来，他渴望有人了解他的痛苦。我静静地听着，大概十分钟后，他停了下来。他觉得我已经理解了他。</li>
<li>人们常常觉得自己受到了指责，有时他们自己也同意，并开始恨自己——但这并不意味着他们会改变自己的行为。</li>
<li>我们需要有足够的耐心来学习和运用非暴力沟通。在与人交往的过程中，我们的第一反应常常是习惯性的反应，因此，运用非暴力沟通有时是很别扭的事。然而，如果我们想要实现自己的人生选择，我们就要给自己充分的时间。</li>
<li>练习把每一个指责都转化为尚未满足的需要。</li>
<li>如果你希望自己在生气的时候也能运用非暴力沟通，我建议你做以下的练习。在前面，我们已经提到，我们生气是因为我们的想法——我们认为人们“应该”或“不应该”做什么，我们还给人贴上各种标签，并说长论短。请留意我们头脑中“我不喜欢抽烟的人……”之类的想法。然后，问自己：“我不喜欢他们……，是因为我什么样的需要没有得到满足？”通过这样的方式，我们就把注意力放在了尚未得到满足的需要，而不是考虑他人有什么过错。</li>
<li>在生气时，批评和指责他人都无法真正传达我们的心声。如果想充分表达愤怒，我们就不能归咎于他人，而把注意力放在自己的感受和需要上。与批评和指责他人相比，直接说出我们的需要更有可能使我们的愿望得到满足。</li>
<li>表达愤怒的四个步骤是：（1）停下来，除了呼吸，什么都别做；（2）想一想是什么想法使我们生气了；（3）体会自己的需要；（4）表达感受和尚未满足的需要。有时，在第3步和第4步之间，我们需要先倾听他人。在得到倾听和理解之后，他们也就可以静下心来体会我们的感受和需要。</li>
<li>非暴力沟通认为，如果一个人做的事情会伤害到自己或他人，那是因为他不够成熟。为此，他需要得到帮助。如果我们不够成熟，我们可能会有以下的表现：（1）我们意识不到自己行为的后果；（2）我们认识不到，我们并不需要通过惩罚他人来满足自己的需要；（3）我们相信，我们有“权利”去惩罚或伤害他人，因为他们是罪有应得；（4）我们产生了幻觉，例如，听到“某种声音”叫我们去杀人。</li>
<li>使用防卫性的强制力，是为了保护自己或他人，而不是为了惩罚、羞辱或谴责他人。</li>
<li>我们希望痛苦能让他们：（1）意识到自己的过错；（2）感到懊悔；（3）改变行为。然而，在实际生活中，惩罚往往加强了对方的敌意和抵触心理，使双方的关系更加疏远。</li>
<li>有的时候孩子拒绝做一件对他们有益的事情，只是因为他们不想在父母的压力面前屈服。其次，即使体罚能带来立竿见影的效果，这也并不意味着，其他方法无法达到同样的效果。最后，我还担心，体罚孩子会造成不良的社会影响。如果我们把暴力作为解决问题的办法，虽然孩子可能会去做我们要求的事，但这样做难道不是在鼓励孩子用暴力来解决冲突吗？</li>
<li>当我们为了回避惩罚去做事情时，我们可能会忽视事情本身的价值，而陷于对失败的忧虑。如果员工的表现只是在服从管理层的命令，士气就会受到影响；或迟或早，工作效率就会降低。</li>
<li>我希望他基于怎样的原因去做我想要他做的事情？</li>
<li>了解别人基于什么样的原因来满足我们的愿望是至关重要的。</li>
<li>在有些情形中，我们没有机会和他人交流，这时，我们也许需要使用强制力来保护自己和他人。我们这样做，是为了避免伤害，而不是为了惩罚他人。如果我们威胁他人或实施惩罚，人们常常会产生敌意和抵触心理。这样，彼此的关系将会疏远。同时，惩罚还可能使人忽视事情本身的意义，而把注意力放在不服从的后果上。如果我们试图通过惩罚来使人们认识自己的需要，那么，我们很可能适得其反。</li>
<li>然而，对于大多数人来说，倾听和表达自己的需要并不容易。一般来说，我们的文化倾向于把个人需要看作是消极的、具有破坏性的。如果一个人公开表达自己的需要，就很可能被看作是自私的。</li>
<li>专注于我们想要做的，而不是追究错在哪里。</li>
<li>我感到惊讶的是，只要我不再批评和指责他人，而把注意力放在自己的感受和需要，我的心情就放松了许多。</li>
<li>在情绪低落的时候，我们也许会怨天尤人。然而，如果我们以苛刻的态度对人对己，我们的心情也好不到哪里去。通过运用非暴力沟通，我们不再试图分析自己或他人有什么毛病，而是用心去了解我们的需要，这样，我们的内心将逐渐变得平和。一旦我们发现自己心底深处的愿望，并采取积极的行动，我们将会重获生活的热情。</li>
<li>优雅地接受别人的感激。</li>
<li>在别人表达感激时，人们通常有两种截然不同的反应。一种是自我膨胀，相信我们比别人优越；另一种是假谦虚，否定别人的欣赏，耸耸肩说：“哦，这没什么。”纳菲滋帮助我看到了，我们有别的方式来听取感激。如果我意识到我的能力是生命赋予我的，我就能够同时避免自我膨胀和假谦虚。</li>
<li>虽然人们在听到感激时会不太自在，但绝大多数的人渴望得到他人的肯定和感激。</li>
<li>我刚刚结束一个有100多人参加的研讨班，除了一个人，其他人都高度评价这次的研讨班。然而，我牢记的却是那个人的不满。</li>
<li>约翰·鲍威尔（John Powell）在他的《爱的秘密》一书中讲到，对于没有在父亲活着的时候表达自己的感激，他十分伤心。这激起了我的强烈共鸣。如果无法向那些对我们的一生有极为重要影响的人表达感激，我们会感到多么悲哀啊！</li>
<li>在赞扬他人时，我们很少揭示内心活动，而把自己放在了裁判的位置。赞扬也常常被人用来实现个人目的。非暴力沟通鼓励我们充分表达感激。在表达感激时，我们说出：（1）对我们有益的行为；（2）我们的哪些需要得到了满足；（3）我们的需要得到满足后，我们是什么样的心情。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>34-《实践论》摘要</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/34-%E5%AE%9E%E8%B7%B5%E8%AE%BA%E6%91%98%E8%A6%81/</link>
      <pubDate>Thu, 12 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/34-%E5%AE%9E%E8%B7%B5%E8%AE%BA%E6%91%98%E8%A6%81/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506121839847.jpg&#34;&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;马克思以前的唯物论，离开人的社会性，离开人的历史发展，去观察认识问题，因此不能了解认识对社会实践的依赖关系，即认识对生产和阶级斗争的依赖关系。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;人的社会实践，不限于生产活动一种形式，还有多种其他的形式，阶级斗争，政治生活，科学和艺术的活动，总之社会实际生活的一切领域都是社会的人所参加的。因此，人的认识，在物质生活以外，还从政治生活文化生活中（与物质生活密切联系），在各种不同程度上，知道人和人的各种关系。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;马克思主义者认为人类社会的生产活动，是一步又一步地由低级向高级发展，因此，人们的认识，不论对于自然界方面，对于社会方面，也都是一步又一步地由低级向高级发展，即由浅入深，由片面到更多的方面。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;人们要想得到工作的胜利即得到预想的结果，一定要使自己的思想合于客观外界的规律性，如果不合，就会在实践中失败。人们经过失败之后，也就从失败取得教训，改正自己的思想使之适合于外界的规律性，人们就能变失败为胜利，所谓“失败者成功之母”，“吃一堑长一智”，就是这个道理。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;然而人的认识究竟怎样从实践发生，而又服务于实践呢？这只要看一看认识的发展过程就会明了的。原来人在实践过程中，开始只是看到过程中各个事物的现象方面，看到各个事物的片面，看到各个事物之间的外部联系。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;社会实践的继续，使人们在实践中引起感觉和印象的东西反复了多次，于是在人们的脑子里生起了一个认识过程中的突变（即飞跃），产生了概念。概念这种东西已经不是事物的现象，不是事物的各个片面，不是它们的外部联系，而是抓着了事物的本质，事物的全体，事物的内部联系了。概念同感觉，不但是数量上的差别，而且有了性质上的差别。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;认识的真正任务在于经过感觉而到达于思维，到达于逐步了解客观事物的内部矛盾，了解它的规律性，了解这一过程和那一过程间的内部联系，即到达于论理的认识。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;这种基于实践的由浅入深的辩证唯物论的关于认识发展过程的理论，在马克思主义以前，是没有一个人这样解决过的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;指出了社会的人在他们的生产和阶级斗争的复杂的、经常反复的实践中，由感性认识到论理认识的推移的运动。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;感觉只解决现象问题，理论才解决本质问题。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;马克思、恩格斯、列宁、斯大林之所以能够作出他们的理论，除了他们的天才条件之外，主要地是他们亲自参加了当时的阶级斗争和科学实验的实践，没有这后一个条件，任何天才也是不能成功的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;如果要直接地认识某种或某些事物，便只有亲身参加于变革现实、变革某种或某些事物的实践的斗争中，才能触到那种或那些事物的现象，也只有在亲身参加变革现实的实践的斗争中，才能暴露那种或那些事物的本质而理解它们。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;一切真知都是从直接经验发源的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;就知识的总体说来，无论何种知识都是不能离开直接经验的。任何知识的来源，在于人的肉体感官对客观外界的感觉，否认了这个感觉，否认了直接经验，否认亲自参加变革现实的实践，他就不是唯物论者。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;中国人有一句老话：“不入虎穴，焉得虎子。”这句话对于人们的实践是真理，对于认识论也是真理。离开实践的认识是不可能的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;中国人民对于帝国主义的认识也是这样。第一阶段是表面的感性的认识阶段，表现在太平天国运动和义和团运动等笼统的排外主义的斗争上。第二阶段才进到理性的认识阶段，看出了帝国主义内部和外部的各种矛盾，并看出了帝国主义联合中国买办阶级和封建阶级以压榨中国人民大众的实质，这种认识是从一九一九年五四运动前后才开始的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;那个具体战争的规律性，懂得了战略和战术，因而能够有把握地去指导战争。此时，如果改换一个无经验的人去指导，又会要在吃了一些败仗之后（有了经验之后）才能理会战争的正确的规律。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;如果这个人在这项工作中经过了一个时期，他有了这项工作的经验了，而他又是一个肯虚心体察情况的人，不是一个主观地、片面地、表面地看问题的人，他就能够自己做出应该怎样进行工作的结论，他的工作勇气也就可以大大地提高了。只有那些主观地、片面地和表面地看问题的人，跑到一个地方，不问环境的情况，不看事情的全体（事情的历史和全部现状），也不触到事情的本质（事情的性质及此一事情和其他事情的内部联系），就自以为是地发号施令起来，这样的人是没有不跌交子的。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;认识的过程，第一步，是开始接触外界事情，属于感觉的阶段。第二步，是综合感觉的材料加以整理和改造，属于概念、判断和推理的阶段。只有感觉的材料十分丰富（不是零碎不全）和合于实际（不是错觉），才能根据这样的材料造出正确的概念和论理来。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;第二是认识有待于深化，认识的感性阶段有待于发展到理性阶段——这就是认识论的辩证法。如果以为认识可以停顿在低级的感性阶段，以为只有感性认识可靠，而理性认识是靠不住的，这便是重复了历史上的“经验论”的错误。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;庸俗的事务主义家不是这样，他们尊重经验而看轻理论，因而不能通观客观过程的全体，缺乏明确的方针，没有远大的前途，沾沾自喜于一得之功和一孔之见。这种人如果指导革命，就会引导革命走上碰壁的地步。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;理性认识依赖于感性认识，感性认识有待于发展到理性认识，这就是辩证唯物论的认识论。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;认识从实践始，经过实践得到了理论的认识，还须再回到实践去。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;人类认识的历史告诉我们，许多理论的真理性是不完全的，经过实践的检验而纠正了它们的不完全性。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;斯大林说得好：“理论若不和革命实践联系起来，就会变成无对象的理论，同样，实践若不以革命理论为指南，就会变成盲目的实践。”&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;许多时候须反复失败过多次，才能纠正错误的认识，才能到达于和客观过程的规律性相符合，因而才能够变主观的东西为客观的东西，即在实践中得到预想的结果。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;革命时期情况的变化是很急速的，如果革命党人的认识不能随之而急速变化，就不能引导革命走向胜利。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;我们反对革命队伍中的顽固派，他们的思想不能随变化了的客观情况而前进，在历史上表现为右倾机会主义。这些人看不出矛盾的斗争已将客观过程推向前进了，而他们的认识仍然停止在旧阶段。一切顽固党的思想都有这样的特征。他们的思想离开了社会的实践，他们不能站在社会车轮的前头充任向导的工作，他们只知跟在车子后面怨恨车子走得太快了，企图把它向后拉，开倒车。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;我们也反对“左”翼空谈主义。他们的思想超过客观过程的一定发展阶段，有些把幻想看作真理，有些则把仅在将来有现实可能性的理想，勉强地放在现时来做，离开了当前大多数人的实践，离开了当前的现实性，在行动上表现为冒险主义。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;马克思主义者承认，在绝对的总的宇宙发展过程中，各个具体过程的发展都是相对的，因而在绝对真理的长河中，人们对于在各个一定发展阶段上的具体过程的认识只具有相对的真理性。无数相对的真理之总和，就是绝对的真理。客观过程的发展是充满着矛盾和斗争的发展，人的认识运动的发展也是充满着矛盾和斗争的发展。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;社会的发展到了今天的时代，正确地认识世界和改造世界的责任，已经历史地落在无产阶级及其政党的肩上。这种根据科学认识而定下来的改造世界的实践过程，在世界、在中国均已到达了一个历史的时节——自有历史以来未曾有过的重大时节，这就是整个儿地推翻世界和中国的黑暗面，把它们转变过来成为前所未有的光明世界。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;世界到了全人类都自觉地改造自己和改造世界的时候，那就是世界的共产主义时代。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;通过实践而发现真理，又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识，又从理性认识而能动地指导革命实践，改造主观世界和客观世界。实践、认识、再实践、再认识，这种形式，循环往复以至无穷，而实践和认识之每一循环的内容，都比较地进到了高一级的程度。这就是辩证唯物论的全部认识论，这就是辩证唯物论的知行统一观。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506121839847.jpg"></p>
<ol>
<li>
<p>马克思以前的唯物论，离开人的社会性，离开人的历史发展，去观察认识问题，因此不能了解认识对社会实践的依赖关系，即认识对生产和阶级斗争的依赖关系。</p>
</li>
<li>
<p>人的社会实践，不限于生产活动一种形式，还有多种其他的形式，阶级斗争，政治生活，科学和艺术的活动，总之社会实际生活的一切领域都是社会的人所参加的。因此，人的认识，在物质生活以外，还从政治生活文化生活中（与物质生活密切联系），在各种不同程度上，知道人和人的各种关系。</p>
</li>
<li>
<p>马克思主义者认为人类社会的生产活动，是一步又一步地由低级向高级发展，因此，人们的认识，不论对于自然界方面，对于社会方面，也都是一步又一步地由低级向高级发展，即由浅入深，由片面到更多的方面。</p>
</li>
<li>
<p>人们要想得到工作的胜利即得到预想的结果，一定要使自己的思想合于客观外界的规律性，如果不合，就会在实践中失败。人们经过失败之后，也就从失败取得教训，改正自己的思想使之适合于外界的规律性，人们就能变失败为胜利，所谓“失败者成功之母”，“吃一堑长一智”，就是这个道理。</p>
</li>
<li>
<p>然而人的认识究竟怎样从实践发生，而又服务于实践呢？这只要看一看认识的发展过程就会明了的。原来人在实践过程中，开始只是看到过程中各个事物的现象方面，看到各个事物的片面，看到各个事物之间的外部联系。</p>
</li>
<li>
<p>社会实践的继续，使人们在实践中引起感觉和印象的东西反复了多次，于是在人们的脑子里生起了一个认识过程中的突变（即飞跃），产生了概念。概念这种东西已经不是事物的现象，不是事物的各个片面，不是它们的外部联系，而是抓着了事物的本质，事物的全体，事物的内部联系了。概念同感觉，不但是数量上的差别，而且有了性质上的差别。</p>
</li>
<li>
<p>认识的真正任务在于经过感觉而到达于思维，到达于逐步了解客观事物的内部矛盾，了解它的规律性，了解这一过程和那一过程间的内部联系，即到达于论理的认识。</p>
</li>
<li>
<p>这种基于实践的由浅入深的辩证唯物论的关于认识发展过程的理论，在马克思主义以前，是没有一个人这样解决过的。</p>
</li>
<li>
<p>指出了社会的人在他们的生产和阶级斗争的复杂的、经常反复的实践中，由感性认识到论理认识的推移的运动。</p>
</li>
<li>
<p>感觉只解决现象问题，理论才解决本质问题。</p>
</li>
<li>
<p>马克思、恩格斯、列宁、斯大林之所以能够作出他们的理论，除了他们的天才条件之外，主要地是他们亲自参加了当时的阶级斗争和科学实验的实践，没有这后一个条件，任何天才也是不能成功的。</p>
</li>
<li>
<p>如果要直接地认识某种或某些事物，便只有亲身参加于变革现实、变革某种或某些事物的实践的斗争中，才能触到那种或那些事物的现象，也只有在亲身参加变革现实的实践的斗争中，才能暴露那种或那些事物的本质而理解它们。</p>
</li>
<li>
<p>一切真知都是从直接经验发源的。</p>
</li>
<li>
<p>就知识的总体说来，无论何种知识都是不能离开直接经验的。任何知识的来源，在于人的肉体感官对客观外界的感觉，否认了这个感觉，否认了直接经验，否认亲自参加变革现实的实践，他就不是唯物论者。</p>
</li>
<li>
<p>中国人有一句老话：“不入虎穴，焉得虎子。”这句话对于人们的实践是真理，对于认识论也是真理。离开实践的认识是不可能的。</p>
</li>
<li>
<p>中国人民对于帝国主义的认识也是这样。第一阶段是表面的感性的认识阶段，表现在太平天国运动和义和团运动等笼统的排外主义的斗争上。第二阶段才进到理性的认识阶段，看出了帝国主义内部和外部的各种矛盾，并看出了帝国主义联合中国买办阶级和封建阶级以压榨中国人民大众的实质，这种认识是从一九一九年五四运动前后才开始的。</p>
</li>
<li>
<p>那个具体战争的规律性，懂得了战略和战术，因而能够有把握地去指导战争。此时，如果改换一个无经验的人去指导，又会要在吃了一些败仗之后（有了经验之后）才能理会战争的正确的规律。</p>
</li>
<li>
<p>如果这个人在这项工作中经过了一个时期，他有了这项工作的经验了，而他又是一个肯虚心体察情况的人，不是一个主观地、片面地、表面地看问题的人，他就能够自己做出应该怎样进行工作的结论，他的工作勇气也就可以大大地提高了。只有那些主观地、片面地和表面地看问题的人，跑到一个地方，不问环境的情况，不看事情的全体（事情的历史和全部现状），也不触到事情的本质（事情的性质及此一事情和其他事情的内部联系），就自以为是地发号施令起来，这样的人是没有不跌交子的。</p>
</li>
<li>
<p>认识的过程，第一步，是开始接触外界事情，属于感觉的阶段。第二步，是综合感觉的材料加以整理和改造，属于概念、判断和推理的阶段。只有感觉的材料十分丰富（不是零碎不全）和合于实际（不是错觉），才能根据这样的材料造出正确的概念和论理来。</p>
</li>
<li>
<p>第二是认识有待于深化，认识的感性阶段有待于发展到理性阶段——这就是认识论的辩证法。如果以为认识可以停顿在低级的感性阶段，以为只有感性认识可靠，而理性认识是靠不住的，这便是重复了历史上的“经验论”的错误。</p>
</li>
<li>
<p>庸俗的事务主义家不是这样，他们尊重经验而看轻理论，因而不能通观客观过程的全体，缺乏明确的方针，没有远大的前途，沾沾自喜于一得之功和一孔之见。这种人如果指导革命，就会引导革命走上碰壁的地步。</p>
</li>
<li>
<p>理性认识依赖于感性认识，感性认识有待于发展到理性认识，这就是辩证唯物论的认识论。</p>
</li>
<li>
<p>认识从实践始，经过实践得到了理论的认识，还须再回到实践去。</p>
</li>
<li>
<p>人类认识的历史告诉我们，许多理论的真理性是不完全的，经过实践的检验而纠正了它们的不完全性。</p>
</li>
<li>
<p>斯大林说得好：“理论若不和革命实践联系起来，就会变成无对象的理论，同样，实践若不以革命理论为指南，就会变成盲目的实践。”</p>
</li>
<li>
<p>许多时候须反复失败过多次，才能纠正错误的认识，才能到达于和客观过程的规律性相符合，因而才能够变主观的东西为客观的东西，即在实践中得到预想的结果。</p>
</li>
<li>
<p>革命时期情况的变化是很急速的，如果革命党人的认识不能随之而急速变化，就不能引导革命走向胜利。</p>
</li>
<li>
<p>我们反对革命队伍中的顽固派，他们的思想不能随变化了的客观情况而前进，在历史上表现为右倾机会主义。这些人看不出矛盾的斗争已将客观过程推向前进了，而他们的认识仍然停止在旧阶段。一切顽固党的思想都有这样的特征。他们的思想离开了社会的实践，他们不能站在社会车轮的前头充任向导的工作，他们只知跟在车子后面怨恨车子走得太快了，企图把它向后拉，开倒车。</p>
</li>
<li>
<p>我们也反对“左”翼空谈主义。他们的思想超过客观过程的一定发展阶段，有些把幻想看作真理，有些则把仅在将来有现实可能性的理想，勉强地放在现时来做，离开了当前大多数人的实践，离开了当前的现实性，在行动上表现为冒险主义。</p>
</li>
<li>
<p>马克思主义者承认，在绝对的总的宇宙发展过程中，各个具体过程的发展都是相对的，因而在绝对真理的长河中，人们对于在各个一定发展阶段上的具体过程的认识只具有相对的真理性。无数相对的真理之总和，就是绝对的真理。客观过程的发展是充满着矛盾和斗争的发展，人的认识运动的发展也是充满着矛盾和斗争的发展。</p>
</li>
<li>
<p>社会的发展到了今天的时代，正确地认识世界和改造世界的责任，已经历史地落在无产阶级及其政党的肩上。这种根据科学认识而定下来的改造世界的实践过程，在世界、在中国均已到达了一个历史的时节——自有历史以来未曾有过的重大时节，这就是整个儿地推翻世界和中国的黑暗面，把它们转变过来成为前所未有的光明世界。</p>
</li>
<li>
<p>世界到了全人类都自觉地改造自己和改造世界的时候，那就是世界的共产主义时代。</p>
</li>
<li>
<p>通过实践而发现真理，又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识，又从理性认识而能动地指导革命实践，改造主观世界和客观世界。实践、认识、再实践、再认识，这种形式，循环往复以至无穷，而实践和认识之每一循环的内容，都比较地进到了高一级的程度。这就是辩证唯物论的全部认识论，这就是辩证唯物论的知行统一观。</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>33-《知行：技术人的管理之路》摘要</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/33-%E7%9F%A5%E8%A1%8C%E6%8A%80%E6%9C%AF%E4%BA%BA%E7%9A%84%E7%AE%A1%E7%90%86%E4%B9%8B%E8%B7%AF%E6%91%98%E8%A6%81/</link>
      <pubDate>Wed, 11 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/33-%E7%9F%A5%E8%A1%8C%E6%8A%80%E6%9C%AF%E4%BA%BA%E7%9A%84%E7%AE%A1%E7%90%86%E4%B9%8B%E8%B7%AF%E6%91%98%E8%A6%81/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506111946066.png&#34;&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;丹尼尔・平克在《驱动力 3.0》一书中有说：“服从让我们撑过白天，而投入才能让我们撑过夜晚。” 这告诉了我们一个很简单的事实：外驱让我们可以做好本职工作，而内驱才能让我们成就卓越。&lt;/li&gt;
&lt;li&gt;驱动力 2.0 的核心价值观是 “顺从”；而驱动力 3.0 的核心价值观是 “自主”。&lt;/li&gt;
&lt;li&gt;我们做管理工作的目标，归根结底，不就是 “群策群力打胜仗” 吗？“群策群力” 就是如何带好团队，“打胜仗” 就是如何取得好的业绩，“带人”+“做事”，齐了。&lt;/li&gt;
&lt;li&gt;想被提拔为一个管理者最好的方式，就是你首先成为一个实际上的管理者，我们常常把这样的晋升理念叫 “既定事实”，而这种理念在互联网行业里被广泛认同。&lt;/li&gt;
&lt;li&gt;无论你走哪条路上，你都会发现有些能力是共通的，比如规划、带人、沟通、执行等管理能力覆盖了全部 8 个方向。&lt;/li&gt;
&lt;li&gt;对于工程师思维特别重的管理者来说，他们尤其倚重技术；对于不懂技术的管理者来说，他们又特别迷信技术。&lt;/li&gt;
&lt;li&gt;做工程师的时候，技术是用来做事情的，掌握好技术的目的就是为了做好实施，看待技术是从如何运用的角度出发。而对于管理者来说，技术是达成目标的手段之一，所以看待技术是从如何评估的角度出发，评估该项技术是否是最合理的手段，以及如何选择才合理，并据此做出决策，因此常常被称为技术判断力。我们的老领导经常会告诫我们，即使做了管理，技术判断力不能丢，就是指这种能力。&lt;/li&gt;
&lt;li&gt;首先，把技术提到更高视角来看待。做技术的时候，把技术做好就是最大的目标；而做了管理之后，你会把技术作为一个手段来看待，看它究竟能为目标带来什么。但这并不意味着你就不再关心技术，只是关心的层次不同了，你开始需要借助每个人的技术能力去做更大的事情了。这很像在学习组装电脑，即便已经不需要关心主板、内存、CPU 的内部运行逻辑，但你还是要很清楚它们的功能是什么，接口什么样，以及从哪些维度去衡量一个主板的好坏、内存的好坏、CPU 的好坏，也得清楚在整台电脑中，哪个部件可能会是短板，等等。所以，技术转管理并不意味着不关心技术，只是更关心更大的目标和整体结果了。&lt;/li&gt;
&lt;li&gt;其次，换一种学习方式来掌握技术。你要深刻地认识到，亲自写代码固然是很好的学习技术的方式，但是作为 leader，你需要快速掌握更多的技术，并且快速判断该如何搭配使用，所以你一定得有更高效的学习方式才行。这里我介绍三个行之有效的做法：建立你的学习机制。你可以想想在团队内建立什么样的学习机制，可以帮助你借助团队的力量来提升技术判断力，并结合自己的情况来创建。请教专家。在了解某一个领域的情况时，借助你的平台，找你能找到的最厉害的专家高手进行请教，他们之所以成为高手，一般都能给出高屋建瓴、醍醐灌顶的认知。在这个知识型工作者的时代，和自己埋头思考相比，共创成果往往会出乎你想象，特别能增长见识，你可以看看在团队中如何建立共创机制。&lt;/li&gt;
&lt;li&gt;别忘了，自从你带团队的那一天起，你就已经不是一个人在战斗。所以，你可以依靠团队和更广的人脉，去拓展技术视野和技术判断力。常见的几个方式如下：建立技术学习机制。盘点你负责的业务，需要哪些方面的技术，成立一个或几个核心的技术小组，让团队对各个方向的技术保持敏感，要求小组定期做交流和分享，这样你就可以保持技术的敏感度。专项技术调研项目化。如果某项技术对团队的业务有重要的价值，可以专门立项做技术调研，并要求项目负责人做调研汇报。和技术大牛交流。越是厉害的技术人，越能深入浅出地把技术讲明白，所以针对某项技术找大牛取经，也是学习的好途径。你看，虽然实际操刀的时间少了，但是你和技术大牛的交流机会多了，一方面因为你有更大的影响力了，另一方面，你和大牛有了共同的诉求，就是把技术 “变现”，让技术产生价值。听取工作汇报。因为你带的是技术团队，大部分工作都和技术相关，在读员工的周报、季度汇报时，相互探讨，也是一种切磋和学习。总之，你会发现，技术管理人的技术水准的提升和保持，主要看能从周围人的身上汲取到多少信息和知识，而不再只是靠自学。&lt;/li&gt;
&lt;li&gt;站在工程师视角上，追求工作的极致品质，恰恰是一种良好的工匠精神。但是站在管理者视角上，就需要评估一段时间内的产出效率了。衡量一项工作 “到底需要花 5 天做到 70 分，还是 10 天做到 90 分”，是管理者的日常工作。90 分方案未必就比 70 分方案好，此时，就需要优秀工程师出身的你放弃一些执念了。一旦放松这个念头，你就会发现，完成一项工作，原来还有很多的手段可以选择。&lt;/li&gt;
&lt;li&gt;分工不是为了高效，而是为了能容纳更多的人来一起干更大、更复杂的事情，做简单的小事情，是不需要分工的。&lt;/li&gt;
&lt;li&gt;凝聚力即是团队协作的基础，又是团队协作的目标。强大的凝聚力，是战斗力强大的团队的重要特征之一。&lt;/li&gt;
&lt;li&gt;如果能够带出一个良好的团队，持续不断地把一件又一件的事情做好，才算是一个好的团队管理者。所以，团队产出是否可持续，是考量管理者价值的一个很重要的维度，它体现了这个团队是否健康，是否有耐力和韧劲。其中，耐力让团队走得远，韧劲让团队走得稳。&lt;/li&gt;
&lt;li&gt;提升一个团队的耐力和韧劲，有两个要素：梯队培养和团队文化。&lt;/li&gt;
&lt;li&gt;一个团队的文化价值观，主要来源于团队负责人或核心管理者。你是什么样的作风和价值观，你团队就会是什么样的，也就是说，你的团队文化和你喜欢什么样的文化关系不大，而和你是什么样的人关系很大。&lt;/li&gt;
&lt;li&gt;面对问题，如果你总是抱怨，那么和团队强调积极文化是不会成功的； 面对合作，如果你总是对抗，那么和团队强调紧密协作是不会成功的； 面对工作，如果你总是被动等待，那么和团队强调积极主动是不会成功的； 面对下属，如果你总是漠不关心，那么和团队强调温暖有爱也是不会成功的。&lt;/li&gt;
&lt;li&gt;你想打造什么样的团队文化，核心是从你身上的优秀品质中提炼，从而把你优秀的特质放大到整个团队。若你身上没有的特质，那就不适合作为团队的文化价值观去培育。&lt;/li&gt;
&lt;li&gt;很多管理者为了激发培养对象的成长动力，常用句式是，“如果你干得好，将会如何如何……” 我的建议是，只明确培养的意向和计划就足够了，最好不要作出成长之外的承诺。&lt;/li&gt;
&lt;li&gt;如果你团队有不少资历比你老的员工，或者有一些技术能力比你强的员工，那么我得首先恭喜你。因为这至少说明两个问题：第一，你真的是非常优秀，以至于你能被公司赏识来负责这样一个团队；第二，因为这些老资格和高能力员工的存在，你有机会做出更好的业绩。&lt;/li&gt;
&lt;li&gt;既然你被任命为这个团队的负责人，你就是此次时刻带领这个团队最合适的人。&lt;/li&gt;
&lt;li&gt;我曾经的上级传授给我一句话，非常有效，相信对于此时的你也一定会有帮助，她对我说：“你也许不是那个最强的人，但是你得相信，你是此时此刻做这事儿最合适的人。”&lt;/li&gt;
&lt;li&gt;对于提升员工个人能力来说，最关键的往往不是学习的方法，而是学习的意愿。&lt;/li&gt;
&lt;li&gt;主动学习的员工总会是少数派，不只是公司的员工如此，社会生活中的人们亦是如此，所以有人说，“学习是反人性的事情！”&lt;/li&gt;
&lt;li&gt;往往因为某个要素不具备就否定所有的可能性。&lt;/li&gt;
&lt;li&gt;给员工信心和耐心，允许他们犯错、走弯路。因为很多经验都是踩坑儿踩出来的，所以不能一出问题就劈头盖脸一顿批，甚至是剥夺其做事的机会。&lt;/li&gt;
&lt;li&gt;善用威者不轻怒，善用恩者不妄施。&lt;/li&gt;
&lt;li&gt;你要做的，不是和团队成员竞争、比较，也不是比团队每个人都强，而是要考虑如何让大家把自己的才智都发挥出来，去达成一个共同的团队目标。总之，你要做的不是管束和控制大家，而是引导和支持大家。&lt;/li&gt;
&lt;li&gt;你可能满足不了某员工所期望的工作内容，但是还有行为模式和思维模式方面可以考虑，比如某些人特别爱和人沟通协调，那就让他用沟通讨论的方式去工作；如果有人特别善于独立思考和筹划，那就发挥他的思维优势；有的人行动特别迅速，那就让他去快速启动一项工作。总之，千万别简单认为发挥员工优势，就是鼓励员工 “挑活”；优势是多层次的，所以让员工发挥优势这件事并不困难。&lt;/li&gt;
&lt;li&gt;这里我提供一个简单实用的方法，即尽量避免用 “任务性” 的语言，而多使用 “成果性” 的语言。比如你安排一项工作给员工，常见的说法是：“把项目 A 抓紧做一下吧，下周要发布。” 这在员工看起来，他收到了一项任务。但换成 “成果性” 的说法是：“项目 A 会帮我们验证一个结论，决定我们是否在这个方向上持续投入，下周就要做出决策，所以，你看下周能否搞定？” 显然，成果性的说法会让员工更清楚自己工作的价值，完成之后也会很有成就感。&lt;/li&gt;
&lt;li&gt;作为管理者，只有言行一致，保持承诺一致性，才能赢得团队的信任。&lt;/li&gt;
&lt;li&gt;每一个激励方案都需要去思考和设计，把外驱和内驱结合起来，把长期和短期结合起来，把业务推进和职业幸福集合起来，把个人工作和团队使命结合起来。&lt;/li&gt;
&lt;li&gt;大多管理者都能够想到这一点，就是在工作进展过程中要了解进度、评估风险，而不是任务交代完了就撒手不管了。&lt;/li&gt;
&lt;li&gt;既然是授权，事中最好不要干涉太多，只做约定好的 check 和支持就好。&lt;/li&gt;
&lt;li&gt;一线员工是用工作量来评估价值的，他们只要做出了自己该做的，就是有价值的；而管理者是用团队业绩来评估价值的，即便不是管理者个人的原因，只要结果是团队不出业绩，那么管理者的价值就很难体现。&lt;/li&gt;
&lt;li&gt;管理者分配工作的方式是直接交代要做什么，并不会和员工去分享和探讨这项工作的价值，以及对团队和公司意味着什么，所以起不到激励效果。&lt;/li&gt;
&lt;li&gt;作为管理者你可以亲身感受得到，总会有一批人因为工作没有价值而离职。他们不是矫情，而是真的需要看到自己给公司和社会带来什么价值。所以，管理者的一项重要修炼，就是去梳理团队的使命和项目的意义。&lt;/li&gt;
&lt;li&gt;对于新管理者，你在绩效评估和沟通之前，先审视一下自己的角色：你是这个团队的管理者，是这个团队的负责人，你是有责任来评价团队每个员工的工作表现和业绩的。你是站在团队的视角来看待这个问题，而不是站在任何一个成员的对立面来特别针对他。即便他做的也还不错，但是你如果还是把低绩效的名额给了他，那么你一定是有自己的依据的，所以这个绩效也的确是他应得的，你并不欠他什么。你有管理者的职业素养，有管理者的工作视角，也有令人信服的评价依据，你做出来的就是最公平和最恰当的决策。所以，你需要考虑的事情是，如何和他达成共识，期待并支持他也可以像其他同事一样，变得更加出色。 所以，你的角色不仅仅是一个评判者和告知者，还更是一个辅导者和支持者。&lt;/li&gt;
&lt;li&gt;希望我和初级管理者们澄清一个事情，那就是：“上级默认是需要管理者们主动向上沟通和反馈的，而非默认不需要。”&lt;/li&gt;
&lt;li&gt;相信你也听过这样一个说法：看似是两个人之间的沟通，其实至少是 “四个人” 之间的对话，哪 “四个人” 呢？也就是：你想表达的、你实际表达的、对方听到的和对方对于听到内容的理解，这其中每一步传递都会造成失真，所以很难领会到对方的真实意图也就情理之中了。&lt;/li&gt;
&lt;li&gt;向上沟通、向下沟通和横向沟通构成了管理沟通的主体，所以我把它们称为管理沟通的三大典型场景。&lt;/li&gt;
&lt;li&gt;管理者要做出好的业绩，就需要站高一层，站在自己上级的视角来和各个团队协同，以收获共同期待的成果。并且大部分时候，帮合作团队一起做好工作，也是为了自己的业绩，你并不会吃亏。&lt;/li&gt;
&lt;li&gt;工作中最好还是以做事为主，少考虑一些个人感受。如果就事论事地去沟通问题，反而会赢得更多合作者的尊重。&lt;/li&gt;
&lt;li&gt;不能默认对方一定能收到，而且不能默认对方理解的和你想的是一致的。&lt;/li&gt;
&lt;li&gt;对于你关心的问题，一定要去确认清楚，跟进到底，形成沟通闭环。&lt;/li&gt;
&lt;li&gt;影响力，是一种不使用强制性力量却能改变别人的看法和行为的能力。一般又分为职权影响力和非职权影响力。&lt;/li&gt;
&lt;li&gt;要想提升自己在这个因素上的影响力，不妨去盘点一下别人经常用什么正向的词来形容你，并进一步地把它们打磨得更加鲜明。一旦对方认同你的人品，就有了很好的信任基础。&lt;/li&gt;
&lt;li&gt;一旦违背了如下三个批评的原则，“促其改变” 的效果就很难达到： 人是 OK 的原则。即，对事不对人。批评事，不要打击人，更不能给人贴标签。 具体性原则。指出具体哪里做的不好，让对方容易认同。 面向未来的原则。体现负面的暂时性和过去时，并提供改变的 “出口”。&lt;/li&gt;
&lt;li&gt;我采取的策略是问自己这两个问题： 如果做，收益是否很大？收益越大，这个事情就越重要。 如果不做，损失是否很大？损失越大，这个事情就越紧急。&lt;/li&gt;
&lt;li&gt;可以靠经常能关注到的一个随身物件来提示。比如你的手环、戒指，甚至是手上的一个伤疤，只要你能时不时关注到，就可以。一旦看到这个物件，你就问一下自己 “我是不是在发怒”，这也是一种觉察。 每天写觉察日记，反思自己在情绪管理方面是否有所失误。我身边就有伙伴用这种方式并取得了比较好的效果。 可以和伙伴约定，请他帮忙提醒。一旦他发觉你情绪不对，都可以当场或事后提醒你，来加强觉察。 用你的重要关切来提醒。比如，你可以和你的上级约定，把这个季度的情绪化频次作为一项 KPI 纳入自己的《绩效计划》，从而让你心里总是悬着一根弦来不断提醒自己要注意情绪。细心的你一定发现了，这个方法显然也可以用于帮自己的下级来提升情绪管理的能力。事实上，我就用过，并且取得了很好的效果。&lt;/li&gt;
&lt;li&gt;作为管理者我们需要清楚一点，的确会有很多事情是我们掌控之外的，其中不乏不合理或不完善的。对于这样的情况，发泄抱怨则意味着我们内心深处已经对此无能无力了。而实际上，我们也许并不需要完美地解决这个问题，而只需要把一个 40 分的状态改善到 60 分就行了，或者即便没有改善到 60 分，我们也把事情往好的方向上推进了一点点，这也是我们的价值。而抱怨除了把负面情绪感染给团队之外，收获不到任何正向的价值。&lt;/li&gt;
&lt;li&gt;“这个规定太不合理了，没法遵守！”—— 那么，怎么样就合理了？ “我们在指定日期肯定做不完，没戏！”—— 那么，什么条件满足之后，就能做完呢？或者，认为什么时候能做完？ “这个设计很不合理，完全不考虑用户体验！”—— 那么，怎么样会合理一些呢？ “团队的氛围太差了，郁闷！”—— 那么，怎么做氛围会变好一点点呢？&lt;/li&gt;
&lt;li&gt;我会问自己的初心：“你到底想要的是什么？你能为上级、下级和公司带来哪些价值呢？” 通过问自己这个问题，我会秉持一种帮助公司、帮助 CEO 和下属的初衷，把我们的利益全部统一起来，以至于从一开始就不担心上级不信任、下级不服气以及同级排挤的问题。因为，每个人都不会拒绝你给他带来支持和帮助的。&lt;/li&gt;
&lt;li&gt;遇到冲突时，跳出自己的角色来判断是非对错，通过审视初心来做决策，很容易让自己充满力量。&lt;/li&gt;
&lt;li&gt;不要指望按照头衔去筹划自己的工作，就可以满足上级和公司的期待。&lt;/li&gt;
&lt;li&gt;如果你不主动去争取你想要的，你就不得不接受一些你不想要的。&lt;/li&gt;
&lt;li&gt;其实，我们对于一个人的评价，从来都是有双重标准的，一个标准是 “及格”，另外一个标准是 “优秀”。所谓 “及格”，就是只要胜任工作的要求就好了；而 “优秀”，除了胜任工作要求，还需要脱颖而出，超出团队普通表现，成为整个团队的核心人物。&lt;/li&gt;
&lt;li&gt;罗伯特・迪尔茨的 “NLP 逻辑层次图”，一个人的行为、能力、价值观，都源于一个最根本的认知，就是自我角色的设定。&lt;/li&gt;
&lt;li&gt;“7-2-1” 法则，即：10% 靠听课和看书自学，20% 靠相互交流和讨论，70% 靠工作实践。&lt;/li&gt;
&lt;li&gt;模仿，是人们学习新技能非常重要和常用的方式。当你尝试做管理的时候，也可能在不断模仿那些你认为 “最优秀” 的管理者，并希望像他们一样 “成功”。&lt;/li&gt;
&lt;li&gt;对于管理者来说，最大的客户就是上级，因此，价值最大化的核心就是去匹配上级和公司的期待。&lt;/li&gt;
&lt;li&gt;这是一种面向客户的视角，即，围绕客户的需要去发挥和提升自己的能力和价值。&lt;/li&gt;
&lt;li&gt;这个视角在 “求生存” 的时候特别好用，其逻辑是通过满足别人的期待，来获得自己生存的资源，因此也叫 “生存视角”。&lt;/li&gt;
&lt;li&gt;最核心的就是要厘清上级的期待并努力去兑现它，这对于在新的环境中 “生存” 下来是非常有效的，即是这个道理。&lt;/li&gt;
&lt;li&gt;职位头衔已经不再体现职责要求，我们需要从固化的职位要求中跳脱出来，从实际的工作需求去定义自己的职责和角色。&lt;/li&gt;
&lt;li&gt;我想说的是，无论是主动也好，被动也罢；无论是出于使命、兴趣也好，抑或是欲望、压力也罢，只要是在职场中，就有一个基本法则在发挥作用，那就是 “价值兑现”，即，你能收获多少回馈，取决于你能输出多少价值。这里的回馈不仅是指物质回馈，还包括成长感、成就感、幸福感等精神回馈。所以，无论是什么初衷，以及选择了什么样的职业道路，最终都会落在一个问题上：“我能否最大化地输出自己的价值？”&lt;/li&gt;
&lt;li&gt;即便如此，在最后的最后，我还是有两句话要交代：请耐心地给自己成长的时间。这个时代的快节奏带给我们很多的焦虑和不安，仿佛一不小心就会错过什么。其实，职业生涯就像一场 “马拉松”，很漫长，5 年或 10 年可以发生很多事，而你的生涯可能是 20 年、30 年，甚至可以像我一样，贯穿整个余生。在这么漫长的岁月中，肯定有人 “先胖”，有人 “后胖”，不用着急。成功其实很容易，因为所有的失败都不叫 “失败”，都只是 “尚未成功” 而已；只要有一次 “成功” 可以让你足慰平生，你就是个 “成功者”。互联网拉平了世界，你随时都有时间和机会去赢得自己的成功，或早或晚。用自己最擅长的姿势，开创属于自己的发展之路。不是前人走过的路才叫路，也没有什么规定好的 “管理之路” 是你必须要走的。因此，也就不存在所谓的 “弯路”，所有你走过的路都是你的成长之路，这条路是你自己开创的。事实上，所有的路上都有一条法则是奏效的，那就是 “价值兑换”，所以，做技术不重要，做管理也不重要，把技术和管理当成你职业的两条腿，在职场中输出自己最大的价值，才是最好的，才真正属于你。切记，不要被别人的路限制住，也不要被某个职位限制住，没有哪个职位可以定义你的职业发展。&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506111946066.png"></p>
<ol>
<li>丹尼尔・平克在《驱动力 3.0》一书中有说：“服从让我们撑过白天，而投入才能让我们撑过夜晚。” 这告诉了我们一个很简单的事实：外驱让我们可以做好本职工作，而内驱才能让我们成就卓越。</li>
<li>驱动力 2.0 的核心价值观是 “顺从”；而驱动力 3.0 的核心价值观是 “自主”。</li>
<li>我们做管理工作的目标，归根结底，不就是 “群策群力打胜仗” 吗？“群策群力” 就是如何带好团队，“打胜仗” 就是如何取得好的业绩，“带人”+“做事”，齐了。</li>
<li>想被提拔为一个管理者最好的方式，就是你首先成为一个实际上的管理者，我们常常把这样的晋升理念叫 “既定事实”，而这种理念在互联网行业里被广泛认同。</li>
<li>无论你走哪条路上，你都会发现有些能力是共通的，比如规划、带人、沟通、执行等管理能力覆盖了全部 8 个方向。</li>
<li>对于工程师思维特别重的管理者来说，他们尤其倚重技术；对于不懂技术的管理者来说，他们又特别迷信技术。</li>
<li>做工程师的时候，技术是用来做事情的，掌握好技术的目的就是为了做好实施，看待技术是从如何运用的角度出发。而对于管理者来说，技术是达成目标的手段之一，所以看待技术是从如何评估的角度出发，评估该项技术是否是最合理的手段，以及如何选择才合理，并据此做出决策，因此常常被称为技术判断力。我们的老领导经常会告诫我们，即使做了管理，技术判断力不能丢，就是指这种能力。</li>
<li>首先，把技术提到更高视角来看待。做技术的时候，把技术做好就是最大的目标；而做了管理之后，你会把技术作为一个手段来看待，看它究竟能为目标带来什么。但这并不意味着你就不再关心技术，只是关心的层次不同了，你开始需要借助每个人的技术能力去做更大的事情了。这很像在学习组装电脑，即便已经不需要关心主板、内存、CPU 的内部运行逻辑，但你还是要很清楚它们的功能是什么，接口什么样，以及从哪些维度去衡量一个主板的好坏、内存的好坏、CPU 的好坏，也得清楚在整台电脑中，哪个部件可能会是短板，等等。所以，技术转管理并不意味着不关心技术，只是更关心更大的目标和整体结果了。</li>
<li>其次，换一种学习方式来掌握技术。你要深刻地认识到，亲自写代码固然是很好的学习技术的方式，但是作为 leader，你需要快速掌握更多的技术，并且快速判断该如何搭配使用，所以你一定得有更高效的学习方式才行。这里我介绍三个行之有效的做法：建立你的学习机制。你可以想想在团队内建立什么样的学习机制，可以帮助你借助团队的力量来提升技术判断力，并结合自己的情况来创建。请教专家。在了解某一个领域的情况时，借助你的平台，找你能找到的最厉害的专家高手进行请教，他们之所以成为高手，一般都能给出高屋建瓴、醍醐灌顶的认知。在这个知识型工作者的时代，和自己埋头思考相比，共创成果往往会出乎你想象，特别能增长见识，你可以看看在团队中如何建立共创机制。</li>
<li>别忘了，自从你带团队的那一天起，你就已经不是一个人在战斗。所以，你可以依靠团队和更广的人脉，去拓展技术视野和技术判断力。常见的几个方式如下：建立技术学习机制。盘点你负责的业务，需要哪些方面的技术，成立一个或几个核心的技术小组，让团队对各个方向的技术保持敏感，要求小组定期做交流和分享，这样你就可以保持技术的敏感度。专项技术调研项目化。如果某项技术对团队的业务有重要的价值，可以专门立项做技术调研，并要求项目负责人做调研汇报。和技术大牛交流。越是厉害的技术人，越能深入浅出地把技术讲明白，所以针对某项技术找大牛取经，也是学习的好途径。你看，虽然实际操刀的时间少了，但是你和技术大牛的交流机会多了，一方面因为你有更大的影响力了，另一方面，你和大牛有了共同的诉求，就是把技术 “变现”，让技术产生价值。听取工作汇报。因为你带的是技术团队，大部分工作都和技术相关，在读员工的周报、季度汇报时，相互探讨，也是一种切磋和学习。总之，你会发现，技术管理人的技术水准的提升和保持，主要看能从周围人的身上汲取到多少信息和知识，而不再只是靠自学。</li>
<li>站在工程师视角上，追求工作的极致品质，恰恰是一种良好的工匠精神。但是站在管理者视角上，就需要评估一段时间内的产出效率了。衡量一项工作 “到底需要花 5 天做到 70 分，还是 10 天做到 90 分”，是管理者的日常工作。90 分方案未必就比 70 分方案好，此时，就需要优秀工程师出身的你放弃一些执念了。一旦放松这个念头，你就会发现，完成一项工作，原来还有很多的手段可以选择。</li>
<li>分工不是为了高效，而是为了能容纳更多的人来一起干更大、更复杂的事情，做简单的小事情，是不需要分工的。</li>
<li>凝聚力即是团队协作的基础，又是团队协作的目标。强大的凝聚力，是战斗力强大的团队的重要特征之一。</li>
<li>如果能够带出一个良好的团队，持续不断地把一件又一件的事情做好，才算是一个好的团队管理者。所以，团队产出是否可持续，是考量管理者价值的一个很重要的维度，它体现了这个团队是否健康，是否有耐力和韧劲。其中，耐力让团队走得远，韧劲让团队走得稳。</li>
<li>提升一个团队的耐力和韧劲，有两个要素：梯队培养和团队文化。</li>
<li>一个团队的文化价值观，主要来源于团队负责人或核心管理者。你是什么样的作风和价值观，你团队就会是什么样的，也就是说，你的团队文化和你喜欢什么样的文化关系不大，而和你是什么样的人关系很大。</li>
<li>面对问题，如果你总是抱怨，那么和团队强调积极文化是不会成功的； 面对合作，如果你总是对抗，那么和团队强调紧密协作是不会成功的； 面对工作，如果你总是被动等待，那么和团队强调积极主动是不会成功的； 面对下属，如果你总是漠不关心，那么和团队强调温暖有爱也是不会成功的。</li>
<li>你想打造什么样的团队文化，核心是从你身上的优秀品质中提炼，从而把你优秀的特质放大到整个团队。若你身上没有的特质，那就不适合作为团队的文化价值观去培育。</li>
<li>很多管理者为了激发培养对象的成长动力，常用句式是，“如果你干得好，将会如何如何……” 我的建议是，只明确培养的意向和计划就足够了，最好不要作出成长之外的承诺。</li>
<li>如果你团队有不少资历比你老的员工，或者有一些技术能力比你强的员工，那么我得首先恭喜你。因为这至少说明两个问题：第一，你真的是非常优秀，以至于你能被公司赏识来负责这样一个团队；第二，因为这些老资格和高能力员工的存在，你有机会做出更好的业绩。</li>
<li>既然你被任命为这个团队的负责人，你就是此次时刻带领这个团队最合适的人。</li>
<li>我曾经的上级传授给我一句话，非常有效，相信对于此时的你也一定会有帮助，她对我说：“你也许不是那个最强的人，但是你得相信，你是此时此刻做这事儿最合适的人。”</li>
<li>对于提升员工个人能力来说，最关键的往往不是学习的方法，而是学习的意愿。</li>
<li>主动学习的员工总会是少数派，不只是公司的员工如此，社会生活中的人们亦是如此，所以有人说，“学习是反人性的事情！”</li>
<li>往往因为某个要素不具备就否定所有的可能性。</li>
<li>给员工信心和耐心，允许他们犯错、走弯路。因为很多经验都是踩坑儿踩出来的，所以不能一出问题就劈头盖脸一顿批，甚至是剥夺其做事的机会。</li>
<li>善用威者不轻怒，善用恩者不妄施。</li>
<li>你要做的，不是和团队成员竞争、比较，也不是比团队每个人都强，而是要考虑如何让大家把自己的才智都发挥出来，去达成一个共同的团队目标。总之，你要做的不是管束和控制大家，而是引导和支持大家。</li>
<li>你可能满足不了某员工所期望的工作内容，但是还有行为模式和思维模式方面可以考虑，比如某些人特别爱和人沟通协调，那就让他用沟通讨论的方式去工作；如果有人特别善于独立思考和筹划，那就发挥他的思维优势；有的人行动特别迅速，那就让他去快速启动一项工作。总之，千万别简单认为发挥员工优势，就是鼓励员工 “挑活”；优势是多层次的，所以让员工发挥优势这件事并不困难。</li>
<li>这里我提供一个简单实用的方法，即尽量避免用 “任务性” 的语言，而多使用 “成果性” 的语言。比如你安排一项工作给员工，常见的说法是：“把项目 A 抓紧做一下吧，下周要发布。” 这在员工看起来，他收到了一项任务。但换成 “成果性” 的说法是：“项目 A 会帮我们验证一个结论，决定我们是否在这个方向上持续投入，下周就要做出决策，所以，你看下周能否搞定？” 显然，成果性的说法会让员工更清楚自己工作的价值，完成之后也会很有成就感。</li>
<li>作为管理者，只有言行一致，保持承诺一致性，才能赢得团队的信任。</li>
<li>每一个激励方案都需要去思考和设计，把外驱和内驱结合起来，把长期和短期结合起来，把业务推进和职业幸福集合起来，把个人工作和团队使命结合起来。</li>
<li>大多管理者都能够想到这一点，就是在工作进展过程中要了解进度、评估风险，而不是任务交代完了就撒手不管了。</li>
<li>既然是授权，事中最好不要干涉太多，只做约定好的 check 和支持就好。</li>
<li>一线员工是用工作量来评估价值的，他们只要做出了自己该做的，就是有价值的；而管理者是用团队业绩来评估价值的，即便不是管理者个人的原因，只要结果是团队不出业绩，那么管理者的价值就很难体现。</li>
<li>管理者分配工作的方式是直接交代要做什么，并不会和员工去分享和探讨这项工作的价值，以及对团队和公司意味着什么，所以起不到激励效果。</li>
<li>作为管理者你可以亲身感受得到，总会有一批人因为工作没有价值而离职。他们不是矫情，而是真的需要看到自己给公司和社会带来什么价值。所以，管理者的一项重要修炼，就是去梳理团队的使命和项目的意义。</li>
<li>对于新管理者，你在绩效评估和沟通之前，先审视一下自己的角色：你是这个团队的管理者，是这个团队的负责人，你是有责任来评价团队每个员工的工作表现和业绩的。你是站在团队的视角来看待这个问题，而不是站在任何一个成员的对立面来特别针对他。即便他做的也还不错，但是你如果还是把低绩效的名额给了他，那么你一定是有自己的依据的，所以这个绩效也的确是他应得的，你并不欠他什么。你有管理者的职业素养，有管理者的工作视角，也有令人信服的评价依据，你做出来的就是最公平和最恰当的决策。所以，你需要考虑的事情是，如何和他达成共识，期待并支持他也可以像其他同事一样，变得更加出色。 所以，你的角色不仅仅是一个评判者和告知者，还更是一个辅导者和支持者。</li>
<li>希望我和初级管理者们澄清一个事情，那就是：“上级默认是需要管理者们主动向上沟通和反馈的，而非默认不需要。”</li>
<li>相信你也听过这样一个说法：看似是两个人之间的沟通，其实至少是 “四个人” 之间的对话，哪 “四个人” 呢？也就是：你想表达的、你实际表达的、对方听到的和对方对于听到内容的理解，这其中每一步传递都会造成失真，所以很难领会到对方的真实意图也就情理之中了。</li>
<li>向上沟通、向下沟通和横向沟通构成了管理沟通的主体，所以我把它们称为管理沟通的三大典型场景。</li>
<li>管理者要做出好的业绩，就需要站高一层，站在自己上级的视角来和各个团队协同，以收获共同期待的成果。并且大部分时候，帮合作团队一起做好工作，也是为了自己的业绩，你并不会吃亏。</li>
<li>工作中最好还是以做事为主，少考虑一些个人感受。如果就事论事地去沟通问题，反而会赢得更多合作者的尊重。</li>
<li>不能默认对方一定能收到，而且不能默认对方理解的和你想的是一致的。</li>
<li>对于你关心的问题，一定要去确认清楚，跟进到底，形成沟通闭环。</li>
<li>影响力，是一种不使用强制性力量却能改变别人的看法和行为的能力。一般又分为职权影响力和非职权影响力。</li>
<li>要想提升自己在这个因素上的影响力，不妨去盘点一下别人经常用什么正向的词来形容你，并进一步地把它们打磨得更加鲜明。一旦对方认同你的人品，就有了很好的信任基础。</li>
<li>一旦违背了如下三个批评的原则，“促其改变” 的效果就很难达到： 人是 OK 的原则。即，对事不对人。批评事，不要打击人，更不能给人贴标签。 具体性原则。指出具体哪里做的不好，让对方容易认同。 面向未来的原则。体现负面的暂时性和过去时，并提供改变的 “出口”。</li>
<li>我采取的策略是问自己这两个问题： 如果做，收益是否很大？收益越大，这个事情就越重要。 如果不做，损失是否很大？损失越大，这个事情就越紧急。</li>
<li>可以靠经常能关注到的一个随身物件来提示。比如你的手环、戒指，甚至是手上的一个伤疤，只要你能时不时关注到，就可以。一旦看到这个物件，你就问一下自己 “我是不是在发怒”，这也是一种觉察。 每天写觉察日记，反思自己在情绪管理方面是否有所失误。我身边就有伙伴用这种方式并取得了比较好的效果。 可以和伙伴约定，请他帮忙提醒。一旦他发觉你情绪不对，都可以当场或事后提醒你，来加强觉察。 用你的重要关切来提醒。比如，你可以和你的上级约定，把这个季度的情绪化频次作为一项 KPI 纳入自己的《绩效计划》，从而让你心里总是悬着一根弦来不断提醒自己要注意情绪。细心的你一定发现了，这个方法显然也可以用于帮自己的下级来提升情绪管理的能力。事实上，我就用过，并且取得了很好的效果。</li>
<li>作为管理者我们需要清楚一点，的确会有很多事情是我们掌控之外的，其中不乏不合理或不完善的。对于这样的情况，发泄抱怨则意味着我们内心深处已经对此无能无力了。而实际上，我们也许并不需要完美地解决这个问题，而只需要把一个 40 分的状态改善到 60 分就行了，或者即便没有改善到 60 分，我们也把事情往好的方向上推进了一点点，这也是我们的价值。而抱怨除了把负面情绪感染给团队之外，收获不到任何正向的价值。</li>
<li>“这个规定太不合理了，没法遵守！”—— 那么，怎么样就合理了？ “我们在指定日期肯定做不完，没戏！”—— 那么，什么条件满足之后，就能做完呢？或者，认为什么时候能做完？ “这个设计很不合理，完全不考虑用户体验！”—— 那么，怎么样会合理一些呢？ “团队的氛围太差了，郁闷！”—— 那么，怎么做氛围会变好一点点呢？</li>
<li>我会问自己的初心：“你到底想要的是什么？你能为上级、下级和公司带来哪些价值呢？” 通过问自己这个问题，我会秉持一种帮助公司、帮助 CEO 和下属的初衷，把我们的利益全部统一起来，以至于从一开始就不担心上级不信任、下级不服气以及同级排挤的问题。因为，每个人都不会拒绝你给他带来支持和帮助的。</li>
<li>遇到冲突时，跳出自己的角色来判断是非对错，通过审视初心来做决策，很容易让自己充满力量。</li>
<li>不要指望按照头衔去筹划自己的工作，就可以满足上级和公司的期待。</li>
<li>如果你不主动去争取你想要的，你就不得不接受一些你不想要的。</li>
<li>其实，我们对于一个人的评价，从来都是有双重标准的，一个标准是 “及格”，另外一个标准是 “优秀”。所谓 “及格”，就是只要胜任工作的要求就好了；而 “优秀”，除了胜任工作要求，还需要脱颖而出，超出团队普通表现，成为整个团队的核心人物。</li>
<li>罗伯特・迪尔茨的 “NLP 逻辑层次图”，一个人的行为、能力、价值观，都源于一个最根本的认知，就是自我角色的设定。</li>
<li>“7-2-1” 法则，即：10% 靠听课和看书自学，20% 靠相互交流和讨论，70% 靠工作实践。</li>
<li>模仿，是人们学习新技能非常重要和常用的方式。当你尝试做管理的时候，也可能在不断模仿那些你认为 “最优秀” 的管理者，并希望像他们一样 “成功”。</li>
<li>对于管理者来说，最大的客户就是上级，因此，价值最大化的核心就是去匹配上级和公司的期待。</li>
<li>这是一种面向客户的视角，即，围绕客户的需要去发挥和提升自己的能力和价值。</li>
<li>这个视角在 “求生存” 的时候特别好用，其逻辑是通过满足别人的期待，来获得自己生存的资源，因此也叫 “生存视角”。</li>
<li>最核心的就是要厘清上级的期待并努力去兑现它，这对于在新的环境中 “生存” 下来是非常有效的，即是这个道理。</li>
<li>职位头衔已经不再体现职责要求，我们需要从固化的职位要求中跳脱出来，从实际的工作需求去定义自己的职责和角色。</li>
<li>我想说的是，无论是主动也好，被动也罢；无论是出于使命、兴趣也好，抑或是欲望、压力也罢，只要是在职场中，就有一个基本法则在发挥作用，那就是 “价值兑现”，即，你能收获多少回馈，取决于你能输出多少价值。这里的回馈不仅是指物质回馈，还包括成长感、成就感、幸福感等精神回馈。所以，无论是什么初衷，以及选择了什么样的职业道路，最终都会落在一个问题上：“我能否最大化地输出自己的价值？”</li>
<li>即便如此，在最后的最后，我还是有两句话要交代：请耐心地给自己成长的时间。这个时代的快节奏带给我们很多的焦虑和不安，仿佛一不小心就会错过什么。其实，职业生涯就像一场 “马拉松”，很漫长，5 年或 10 年可以发生很多事，而你的生涯可能是 20 年、30 年，甚至可以像我一样，贯穿整个余生。在这么漫长的岁月中，肯定有人 “先胖”，有人 “后胖”，不用着急。成功其实很容易，因为所有的失败都不叫 “失败”，都只是 “尚未成功” 而已；只要有一次 “成功” 可以让你足慰平生，你就是个 “成功者”。互联网拉平了世界，你随时都有时间和机会去赢得自己的成功，或早或晚。用自己最擅长的姿势，开创属于自己的发展之路。不是前人走过的路才叫路，也没有什么规定好的 “管理之路” 是你必须要走的。因此，也就不存在所谓的 “弯路”，所有你走过的路都是你的成长之路，这条路是你自己开创的。事实上，所有的路上都有一条法则是奏效的，那就是 “价值兑换”，所以，做技术不重要，做管理也不重要，把技术和管理当成你职业的两条腿，在职场中输出自己最大的价值，才是最好的，才真正属于你。切记，不要被别人的路限制住，也不要被某个职位限制住，没有哪个职位可以定义你的职业发展。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>32-如何提升项目管理能力</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/32-%E5%A6%82%E4%BD%95%E6%8F%90%E5%8D%87%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E8%83%BD%E5%8A%9B/</link>
      <pubDate>Tue, 10 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/32-%E5%A6%82%E4%BD%95%E6%8F%90%E5%8D%87%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E8%83%BD%E5%8A%9B/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506101409918.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;如何提升项目管理能力？这个问题覆盖面很广，其实，很多时候方法都是通用的，这方面和学一门技术所运用的技巧是一样的，可以先实践后学习，以终为始，先解决当前遇到的问题，解决了之后再总结，久而久之就像涂鸦一样，慢慢这一块那一块也会涂完，而不是一开始就按顺序涂完整幅画。&lt;/p&gt;
&lt;p&gt;在做事情的时候，有些知识不是立马就会用到的，学了之后没有应用，很快就会忘记，而且没有立马实践意味着没有产出，你没看到有什么显著的成果，就会打击积极性，便不利于你后续的学习。&lt;/p&gt;
&lt;p&gt;其实，这个思路无形之中刚好契合了毛泽东《实践论》所说的，“&lt;strong&gt;通过实践而发现真理，又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识，又从理性认识而能动地指导革命实践，改造主观世界和客观世界。实践、认识、再实践、再认识，这种形式，循环往复以至无穷，而实践和认识之每一循环的内容，都比较地进到了高一级的程度。这就是辩证唯物论的全部认识论，这就是辩证唯物论的知行统一观。&lt;/strong&gt;”&lt;/p&gt;
&lt;p&gt;所以，这也是我们项目计划为什么需要有复盘会议的原因，实践、认识、再实践、再认识，如此反复，不断地向真理靠近。&lt;/p&gt;
&lt;p&gt;市面上相关项目管理的书籍很多，但是大部分都是一些方法技巧，我始终认为方法固然很重要，但是意识才是最核心的那部分，只有不断修炼意识层面，哪怕方法暂时掌握不到位，日积月累，终有一日也会有所成就。&lt;/p&gt;
&lt;p&gt;所以，项目管理的书籍，我就只推荐一本，来自刘建国的《知行：技术人的管理之路》，主要内容就是程序员如何走上管理、为什么要做管理、怎么做好管理，全方位剖析会遇到的问题怎么解决等等，我觉得是很实用的一本书。&lt;/p&gt;
&lt;p&gt;其他的，就是一些看起来好像和项目管理一点关系都没有，实际上关联密切的书籍，首先就是《实践论》，它是如此的重要，以致我不得不多次提及，除了这本书之外，还推荐《非暴力沟通》和《精力管理》，附录会有一些摘要，可以简单看一下，基本上可以总结为四个方面，覆盖项目管理所需的各项能力：方法、意识、沟通、身体。&lt;/p&gt;
&lt;p&gt;其中，身体其实才是最重要的，它是一座高楼的地基。地基的好坏，直接影响到上层的建设。在项目管理上也是如此，它会关系到你能成长到哪一个阶段。&lt;/p&gt;
&lt;p&gt;因为对于项目负责人而言，无论是手头上的开发任务，还是面对与多个部门的沟通协作，以及处理诸多繁琐事务，外加达成目标的压力，无不耗费巨大的精力和心力。&lt;/p&gt;
&lt;p&gt;“身体是革命的本钱”，这句话大家都听过，所言非虚，在此就不再赘述了。&lt;/p&gt;
&lt;p&gt;至此，从 2022 年 8 月开始编写这些内容，从开发人员到项目负责人再到项目总负责人，对遇到的各类项目问题都进行了梳理，并以个人浅见提供了一些解决方案，总结为一句话就是：&lt;strong&gt;结果导向，修己安人&lt;/strong&gt;。&lt;/p&gt;
&lt;p&gt;这个系列，基本上就告一段落了，如果后面有一些心得还是会持续更新的。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506101409918.jpeg"></p>
<p>如何提升项目管理能力？这个问题覆盖面很广，其实，很多时候方法都是通用的，这方面和学一门技术所运用的技巧是一样的，可以先实践后学习，以终为始，先解决当前遇到的问题，解决了之后再总结，久而久之就像涂鸦一样，慢慢这一块那一块也会涂完，而不是一开始就按顺序涂完整幅画。</p>
<p>在做事情的时候，有些知识不是立马就会用到的，学了之后没有应用，很快就会忘记，而且没有立马实践意味着没有产出，你没看到有什么显著的成果，就会打击积极性，便不利于你后续的学习。</p>
<p>其实，这个思路无形之中刚好契合了毛泽东《实践论》所说的，“<strong>通过实践而发现真理，又通过实践而证实真理和发展真理。从感性认识而能动地发展到理性认识，又从理性认识而能动地指导革命实践，改造主观世界和客观世界。实践、认识、再实践、再认识，这种形式，循环往复以至无穷，而实践和认识之每一循环的内容，都比较地进到了高一级的程度。这就是辩证唯物论的全部认识论，这就是辩证唯物论的知行统一观。</strong>”</p>
<p>所以，这也是我们项目计划为什么需要有复盘会议的原因，实践、认识、再实践、再认识，如此反复，不断地向真理靠近。</p>
<p>市面上相关项目管理的书籍很多，但是大部分都是一些方法技巧，我始终认为方法固然很重要，但是意识才是最核心的那部分，只有不断修炼意识层面，哪怕方法暂时掌握不到位，日积月累，终有一日也会有所成就。</p>
<p>所以，项目管理的书籍，我就只推荐一本，来自刘建国的《知行：技术人的管理之路》，主要内容就是程序员如何走上管理、为什么要做管理、怎么做好管理，全方位剖析会遇到的问题怎么解决等等，我觉得是很实用的一本书。</p>
<p>其他的，就是一些看起来好像和项目管理一点关系都没有，实际上关联密切的书籍，首先就是《实践论》，它是如此的重要，以致我不得不多次提及，除了这本书之外，还推荐《非暴力沟通》和《精力管理》，附录会有一些摘要，可以简单看一下，基本上可以总结为四个方面，覆盖项目管理所需的各项能力：方法、意识、沟通、身体。</p>
<p>其中，身体其实才是最重要的，它是一座高楼的地基。地基的好坏，直接影响到上层的建设。在项目管理上也是如此，它会关系到你能成长到哪一个阶段。</p>
<p>因为对于项目负责人而言，无论是手头上的开发任务，还是面对与多个部门的沟通协作，以及处理诸多繁琐事务，外加达成目标的压力，无不耗费巨大的精力和心力。</p>
<p>“身体是革命的本钱”，这句话大家都听过，所言非虚，在此就不再赘述了。</p>
<p>至此，从 2022 年 8 月开始编写这些内容，从开发人员到项目负责人再到项目总负责人，对遇到的各类项目问题都进行了梳理，并以个人浅见提供了一些解决方案，总结为一句话就是：<strong>结果导向，修己安人</strong>。</p>
<p>这个系列，基本上就告一段落了，如果后面有一些心得还是会持续更新的。</p>
]]></content:encoded>
    </item>
    <item>
      <title>31-常用文档编写规范</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/31-%E5%B8%B8%E7%94%A8%E6%96%87%E6%A1%A3%E7%BC%96%E5%86%99%E8%A7%84%E8%8C%83/</link>
      <pubDate>Mon, 09 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/31-%E5%B8%B8%E7%94%A8%E6%96%87%E6%A1%A3%E7%BC%96%E5%86%99%E8%A7%84%E8%8C%83/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091859678.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;部门项目文档是使用 &lt;code&gt;ShowDoc&lt;/code&gt; 进行管理的，为了技术文档的整洁以及易于阅读，根据当前实际情况，整理了一些文档编写规范。&lt;/p&gt;
&lt;p&gt;标准的文档应包括 &lt;code&gt;TOC&lt;/code&gt; 标题目录、说明栏、标题、子标题（如果需要）、内容，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091842786.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091843371.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;2-标题&#34;&gt;2. 标题&lt;/h1&gt;
&lt;p&gt;标题总共有 3 种样式，可以选择任意一种，视具体情况而定，但是最好不要混用。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-ts&#34; data-lang=&#34;ts&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;#&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;一、样式&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;#&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;、样式&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;#&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;样式&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;预览效果，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091846702.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;如果只有一级标题，3 种样式都可以使用，&lt;strong&gt;如果有子标题，建议使用样式3&lt;/strong&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-ts&#34; data-lang=&#34;ts&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;#&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是一级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;##&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;1.1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是二级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;###&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;1.1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是三级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;###&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;1.1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是三级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;##&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;1.2&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是二级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;##&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;1.3&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是二级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;err&#34;&gt;#&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;这是一级标题&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;文档内容中显示的效果，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091826297.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;文档大纲显示的目录样式，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091827126.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;3-代码块&#34;&gt;3. 代码块&lt;/h1&gt;
&lt;p&gt;&lt;code&gt;Markdown&lt;/code&gt; 语法支持代码格式化，在文档中显示更为美观，方式是除了操作栏上面的快捷按钮 &lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091826634.png&#34;&gt;，也可以头尾加上```实现，我们通常使用这个功能主要是为了在文档中贴上代码，但也会在其他情况下使用，比如一些命令或者很长的 &lt;code&gt;Bug&lt;/code&gt; 报错信息。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;代码&lt;/li&gt;
&lt;/ol&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-vue&#34; data-lang=&#34;vue&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;CounterApp&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;nx&#34;&gt;data&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;counter&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;},&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;nx&#34;&gt;mounted&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;setInterval&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;this&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;counter&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;},&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1000&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;ol start=&#34;2&#34;&gt;
&lt;li&gt;命令&lt;/li&gt;
&lt;/ol&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-sh&#34; data-lang=&#34;sh&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;npm install
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;npm run dev
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;ol start=&#34;3&#34;&gt;
&lt;li&gt;Bug 报错信息&lt;/li&gt;
&lt;/ol&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-sh&#34; data-lang=&#34;sh&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;Uncaught TypeError: Cannot &lt;span class=&#34;nb&#34;&gt;read&lt;/span&gt; property &lt;span class=&#34;s1&#34;&gt;&amp;#39;toggleRowSelection&amp;#39;&lt;/span&gt; of undefined
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h1 id=&#34;4-文本高亮&#34;&gt;4. 文本高亮&lt;/h1&gt;
&lt;p&gt;文本高亮通常在输入英文单词时使用，一来为了强调重点，二来是为了界面美观。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091859678.png"></p>
<h1 id="1-前言">1. 前言</h1>
<p>部门项目文档是使用 <code>ShowDoc</code> 进行管理的，为了技术文档的整洁以及易于阅读，根据当前实际情况，整理了一些文档编写规范。</p>
<p>标准的文档应包括 <code>TOC</code> 标题目录、说明栏、标题、子标题（如果需要）、内容，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091842786.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091843371.png"></p>
<h1 id="2-标题">2. 标题</h1>
<p>标题总共有 3 种样式，可以选择任意一种，视具体情况而定，但是最好不要混用。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="err">#</span> <span class="err">一、样式</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="err">#</span> <span class="mi">1</span><span class="err">、样式</span><span class="mi">2</span>
</span></span><span class="line"><span class="cl"><span class="err">#</span> <span class="mi">1</span><span class="p">.</span> <span class="err">样式</span><span class="mi">3</span>
</span></span></code></pre></div><p>预览效果，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091846702.png"></p>
<p>如果只有一级标题，3 种样式都可以使用，<strong>如果有子标题，建议使用样式3</strong>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="err">#</span> <span class="mi">1</span><span class="p">.</span> <span class="err">这是一级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">##</span> <span class="mf">1.1</span> <span class="err">这是二级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">###</span> <span class="mf">1.1</span><span class="p">.</span><span class="mi">1</span> <span class="err">这是三级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">###</span> <span class="mf">1.1</span><span class="p">.</span><span class="mi">2</span> <span class="err">这是三级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">##</span> <span class="mf">1.2</span> <span class="err">这是二级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">##</span> <span class="mf">1.3</span> <span class="err">这是二级标题</span>
</span></span><span class="line"><span class="cl"><span class="err">#</span> <span class="mi">2</span><span class="p">.</span> <span class="err">这是一级标题</span>
</span></span></code></pre></div><p>文档内容中显示的效果，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091826297.png"></p>
<p>文档大纲显示的目录样式，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091827126.png"></p>
<h1 id="3-代码块">3. 代码块</h1>
<p><code>Markdown</code> 语法支持代码格式化，在文档中显示更为美观，方式是除了操作栏上面的快捷按钮 <img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091826634.png">，也可以头尾加上```实现，我们通常使用这个功能主要是为了在文档中贴上代码，但也会在其他情况下使用，比如一些命令或者很长的 <code>Bug</code> 报错信息。</p>
<ol>
<li>代码</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-vue" data-lang="vue"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">CounterApp</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">data</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">counter</span><span class="o">:</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">},</span>
</span></span><span class="line"><span class="cl">  <span class="nx">mounted</span><span class="p">()</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">setInterval</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">this</span><span class="p">.</span><span class="nx">counter</span><span class="o">++</span>
</span></span><span class="line"><span class="cl">    <span class="p">},</span> <span class="mi">1000</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><ol start="2">
<li>命令</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">npm install
</span></span><span class="line"><span class="cl">npm run dev
</span></span></code></pre></div><ol start="3">
<li>Bug 报错信息</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">Uncaught TypeError: Cannot <span class="nb">read</span> property <span class="s1">&#39;toggleRowSelection&#39;</span> of undefined
</span></span></code></pre></div><h1 id="4-文本高亮">4. 文本高亮</h1>
<p>文本高亮通常在输入英文单词时使用，一来为了强调重点，二来是为了界面美观。</p>
<ol>
<li>实现方式</li>
</ol>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="err">我们创建了一份完整的构建</span> <span class="sb">`Vue`</span> <span class="err">服务端渲染应用的指南。这份指南非常深入，适合已经熟悉</span> <span class="sb">`Vue`</span> <span class="err">、</span> <span class="sb">`webpack`</span> <span class="err">和</span> <span class="sb">`Node.js`</span> <span class="err">开发的开发者阅读。请移步</span> <span class="sb">`ssr.vuejs.org`</span> <span class="err">。</span>
</span></span></code></pre></div><ol start="2">
<li>实现效果</li>
</ol>
<p>我们创建了一份完整的构建 <code>Vue</code> 服务端渲染应用的指南。这份指南非常深入，适合已经熟悉 <code>Vue</code> 、 <code>webpack</code> 和 <code>Node.js</code> 开发的开发者阅读。请移步 <code>ssr.vuejs.org</code> 。</p>
<h1 id="5-超链接">5. 超链接</h1>
<p>超链接的使用方式，方括号里是超链接显示的文本内容，圆括号是超链接具体的网址。</p>
<ol>
<li>实现方式</li>
</ol>
<pre tabindex="0"><code>[ECMAScript 6](https://es6.ruanyifeng.com/)
</code></pre><ol start="2">
<li>实现效果</li>
</ol>
<p><a href="https://es6.ruanyifeng.com/">ECMAScript 6</a></p>
<h1 id="6-插入图片">6. 插入图片</h1>
<p>插入图片的使用方式和超链接方式很相似，只是在前面多个一个感叹号 <code>!</code> 而已。但这种不是最便捷的，如果是在 <code>ShowDoc</code> 上面使用，直接复制图片，在文档中粘贴即可，会自动上传并回显图片的路径。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506091903043.png"></p>
<h1 id="7-应用模板">7. 应用模板</h1>
<ol>
<li>解决方案文档，可以参照《Web应用实现在手机端访问和使用方案》</li>
<li>技术笔记文档，可以参照《Sentry的基本使用》、《Linux与Windows跨平台文件共享实现》</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>30-多项目的需求和计划如何有效规划</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/30-%E5%A4%9A%E9%A1%B9%E7%9B%AE%E7%9A%84%E9%9C%80%E6%B1%82%E5%92%8C%E8%AE%A1%E5%88%92%E5%A6%82%E4%BD%95%E6%9C%89%E6%95%88%E8%A7%84%E5%88%92/</link>
      <pubDate>Sat, 07 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/30-%E5%A4%9A%E9%A1%B9%E7%9B%AE%E7%9A%84%E9%9C%80%E6%B1%82%E5%92%8C%E8%AE%A1%E5%88%92%E5%A6%82%E4%BD%95%E6%9C%89%E6%95%88%E8%A7%84%E5%88%92/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071603375.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在前面《25 - 项目需求如何有效梳理》文章中，已经说明过项目需求应如何依据实际情况进行梳理。不过，那是针对单个项目的情况。&lt;/p&gt;
&lt;p&gt;倘若项目负责人负责多个项目，且这些项目之间存在一定关联，例如同属某个具体行业，此时，项目需求梳理就会面临问题。&lt;/p&gt;
&lt;p&gt;该项目负责人所在团队有 10 人，负责项目 A、B 两个项目，这就需要两份需求文档、两个项目计划以及两个版本发布时间。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;项目 A 的需求文档和项目计划&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071506286.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051758210.png&#34;&gt;&lt;/p&gt;
&lt;ol start=&#34;2&#34;&gt;
&lt;li&gt;项目 B 的需求文档和项目计划&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071509910.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051758321.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;按理来说，这种安排并没有什么问题。然而，由于这两个项目均由这 10 个人负责，存在人员复用的情况，项目 A 的需求和计划一旦发生变化，就会对项目 B 的需求和计划制定产生影响。&lt;/p&gt;
&lt;p&gt;对于项目负责人而言，项目管理的难度显著增加。一方面，需要在不同的项目文档里整理需求；另一方面，还需在不同项目中修改计划。&lt;/p&gt;
&lt;p&gt;此外，还有两个版本发布时间，原本 10 个人负责的工作，却出现两个目标时间节点，无论是目标导向还是上下级沟通，都变得很复杂。&lt;/p&gt;
&lt;p&gt;如何解决这一问题呢？&lt;/p&gt;
&lt;p&gt;一方面要简化项目负责人对多个项目的管理工作，另一方面要让这 10 个项目成员更具目标感和凝聚力，设定唯一目标，即 10 个人要在规定的时间节点前完成安排的任务。&lt;/p&gt;
&lt;p&gt;鉴于项目 A 和项目 B 同属一个行业，可以把它们转为子项目，重新创建一个总项目，下设子项目 A 和子项目 B，如此一来，就只需一份需求文档、一个项目计划和一个版本发布时间。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071525960.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051801688.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;但这里存在一个问题，总项目的版本号只是用来做需求规划的，项目 A、项目 B 都有各自独立的版本号，并没有办法沿用总项目的版本号。那么，如何将它们与需求文档关联起来，以便追溯呢？&lt;/p&gt;
&lt;p&gt;例如，项目 A 线上出现了 Bug，需要查看这个版本更新了哪些内容，才能判断 Bug 的影响范围。&lt;/p&gt;
&lt;p&gt;假设总项目需求文档是 V1.0，而项目 A 当前版本是 V2.1，怎么在需求文档中查看项目 A 的 V2.1 迭代了哪些功能呢？&lt;/p&gt;
&lt;p&gt;我能想到的是，只需要在总项目每个版本的需求文档里，在项目 A 旁标记当前版本号，并评估这些迭代功能是否需要升版本号即可。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071534091.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071603375.jpeg"></p>
<p>在前面《25 - 项目需求如何有效梳理》文章中，已经说明过项目需求应如何依据实际情况进行梳理。不过，那是针对单个项目的情况。</p>
<p>倘若项目负责人负责多个项目，且这些项目之间存在一定关联，例如同属某个具体行业，此时，项目需求梳理就会面临问题。</p>
<p>该项目负责人所在团队有 10 人，负责项目 A、B 两个项目，这就需要两份需求文档、两个项目计划以及两个版本发布时间。</p>
<ol>
<li>项目 A 的需求文档和项目计划</li>
</ol>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071506286.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051758210.png"></p>
<ol start="2">
<li>项目 B 的需求文档和项目计划</li>
</ol>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071509910.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051758321.png"></p>
<p>按理来说，这种安排并没有什么问题。然而，由于这两个项目均由这 10 个人负责，存在人员复用的情况，项目 A 的需求和计划一旦发生变化，就会对项目 B 的需求和计划制定产生影响。</p>
<p>对于项目负责人而言，项目管理的难度显著增加。一方面，需要在不同的项目文档里整理需求；另一方面，还需在不同项目中修改计划。</p>
<p>此外，还有两个版本发布时间，原本 10 个人负责的工作，却出现两个目标时间节点，无论是目标导向还是上下级沟通，都变得很复杂。</p>
<p>如何解决这一问题呢？</p>
<p>一方面要简化项目负责人对多个项目的管理工作，另一方面要让这 10 个项目成员更具目标感和凝聚力，设定唯一目标，即 10 个人要在规定的时间节点前完成安排的任务。</p>
<p>鉴于项目 A 和项目 B 同属一个行业，可以把它们转为子项目，重新创建一个总项目，下设子项目 A 和子项目 B，如此一来，就只需一份需求文档、一个项目计划和一个版本发布时间。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071525960.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506051801688.png"></p>
<p>但这里存在一个问题，总项目的版本号只是用来做需求规划的，项目 A、项目 B 都有各自独立的版本号，并没有办法沿用总项目的版本号。那么，如何将它们与需求文档关联起来，以便追溯呢？</p>
<p>例如，项目 A 线上出现了 Bug，需要查看这个版本更新了哪些内容，才能判断 Bug 的影响范围。</p>
<p>假设总项目需求文档是 V1.0，而项目 A 当前版本是 V2.1，怎么在需求文档中查看项目 A 的 V2.1 迭代了哪些功能呢？</p>
<p>我能想到的是，只需要在总项目每个版本的需求文档里，在项目 A 旁标记当前版本号，并评估这些迭代功能是否需要升版本号即可。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071534091.png"></p>
<p>如果要在该文档系统中列出项目 A 某个版本的全部需求（比如 V2.1 ），可以在搜索框使用【项目 A `2.1`】进行搜索，这样相关内容就能全部罗列出来。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506071538319.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>29-任务跟进问题的反思与解决方案</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/29-%E9%A1%B9%E7%9B%AE%E6%80%BB%E8%B4%9F%E8%B4%A3%E4%BA%BA%E6%80%8E%E4%B9%88%E8%B7%9F%E8%BF%9B%E4%BB%BB%E5%8A%A1/</link>
      <pubDate>Tue, 03 Jun 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/29-%E9%A1%B9%E7%9B%AE%E6%80%BB%E8%B4%9F%E8%B4%A3%E4%BA%BA%E6%80%8E%E4%B9%88%E8%B7%9F%E8%BF%9B%E4%BB%BB%E5%8A%A1/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031131783.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;最近，我发现有些事情安排下去后，如果我这边没有跟进到位，过一段时间，这件事情可能就突然没了下文。&lt;/p&gt;
&lt;p&gt;起因是之前我和项目负责人沟通一件事，有个项目的原型和已有项目基本没什么差别，于是探讨如何复用和设计，以实现前端组件复用，减少工作量。&lt;/p&gt;
&lt;p&gt;当时，我们在座位上沟通，也说好方案大概完成的时间。然而，过了一两周，我看项目需求文档时，发现上面压根没记录这件事。和他沟通后，他才又想起来好像有这么回事。&lt;/p&gt;
&lt;p&gt;乍听之下，肯定觉得这是项目负责人的问题。但深入思考后，我才意识到，很可能我这边才是最大的问题。&lt;/p&gt;
&lt;p&gt;为什么这么说呢？&lt;/p&gt;
&lt;p&gt;因为我习惯在滴答清单上列出每天要做的任务，每做完一条就勾选掉。这本身没什么问题，问题在于对于安排型任务，我也是如此处理。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031124170.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;通常我会和项目负责人在座位上沟通，把事情的背景、要做什么、为什么这样做以及要达成什么结果都说明清楚，然后给出大概的完成时间。&lt;/p&gt;
&lt;p&gt;之后，我就在滴答清单上把这条任务勾掉，觉得事情已经安排下去，就算做完了。&lt;/p&gt;
&lt;p&gt;但这个事情进入下一个环节，会出现哪些情况呢？&lt;/p&gt;
&lt;p&gt;如果项目负责人本身具备及时反馈的意识，那还好说。但要是项目负责人不重视，或者被其他事情干扰、疏忽了，而我这边又没有及时跟进，过了一两周甚至更久，才突然想起好像有这么一件事，那时可就晚了。&lt;/p&gt;
&lt;p&gt;这个时候，我能去问责项目负责人吗？&lt;/p&gt;
&lt;p&gt;其实也不是不行，但对方也有理由，这一两周也没闲着，只是事情太多太杂，忘记了而已。&lt;/p&gt;
&lt;p&gt;通常都是这类理由，所以问责也于事无补，反正也改变不了现在这个结果。因此，没必要问责，还是要从最本质的问题出发，找到最根本的原因，再通过一些策略彻底解决这个问题。&lt;/p&gt;
&lt;p&gt;首先，从我自身角度来说，就是要跟进到位。那怎么解决任务跟进的问题呢？&lt;/p&gt;
&lt;p&gt;我想到一个方案，就是在企业微信上创建一个任务清单表格，把需求提出方、提出时间、任务内容、安排时间、计划完成时间、验收情况、进度情况都填写清楚，并实时更新。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031126818.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;每周都要梳理一遍上面的任务情况，再结合每两周一次的项目进度会议，及时更新任务进度。&lt;/p&gt;
&lt;p&gt;如果出现任何问题，比如事情被遗忘、遇到困难、无法推进等等，及时沟通解决。等事情验收完成后，再在任务清单上标记已完成。我觉得这样就能解决上述问题。&lt;/p&gt;
&lt;p&gt;总的来说，安排任务时，不能只是把任务分配下去就高枕无忧了。虽然每一条任务的发布和验收形成闭环是很理想的状态，但在这个过程中，及时跟进也至关重要。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031131783.png"></p>
<p>最近，我发现有些事情安排下去后，如果我这边没有跟进到位，过一段时间，这件事情可能就突然没了下文。</p>
<p>起因是之前我和项目负责人沟通一件事，有个项目的原型和已有项目基本没什么差别，于是探讨如何复用和设计，以实现前端组件复用，减少工作量。</p>
<p>当时，我们在座位上沟通，也说好方案大概完成的时间。然而，过了一两周，我看项目需求文档时，发现上面压根没记录这件事。和他沟通后，他才又想起来好像有这么回事。</p>
<p>乍听之下，肯定觉得这是项目负责人的问题。但深入思考后，我才意识到，很可能我这边才是最大的问题。</p>
<p>为什么这么说呢？</p>
<p>因为我习惯在滴答清单上列出每天要做的任务，每做完一条就勾选掉。这本身没什么问题，问题在于对于安排型任务，我也是如此处理。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031124170.png"></p>
<p>通常我会和项目负责人在座位上沟通，把事情的背景、要做什么、为什么这样做以及要达成什么结果都说明清楚，然后给出大概的完成时间。</p>
<p>之后，我就在滴答清单上把这条任务勾掉，觉得事情已经安排下去，就算做完了。</p>
<p>但这个事情进入下一个环节，会出现哪些情况呢？</p>
<p>如果项目负责人本身具备及时反馈的意识，那还好说。但要是项目负责人不重视，或者被其他事情干扰、疏忽了，而我这边又没有及时跟进，过了一两周甚至更久，才突然想起好像有这么一件事，那时可就晚了。</p>
<p>这个时候，我能去问责项目负责人吗？</p>
<p>其实也不是不行，但对方也有理由，这一两周也没闲着，只是事情太多太杂，忘记了而已。</p>
<p>通常都是这类理由，所以问责也于事无补，反正也改变不了现在这个结果。因此，没必要问责，还是要从最本质的问题出发，找到最根本的原因，再通过一些策略彻底解决这个问题。</p>
<p>首先，从我自身角度来说，就是要跟进到位。那怎么解决任务跟进的问题呢？</p>
<p>我想到一个方案，就是在企业微信上创建一个任务清单表格，把需求提出方、提出时间、任务内容、安排时间、计划完成时间、验收情况、进度情况都填写清楚，并实时更新。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202506031126818.png"></p>
<p>每周都要梳理一遍上面的任务情况，再结合每两周一次的项目进度会议，及时更新任务进度。</p>
<p>如果出现任何问题，比如事情被遗忘、遇到困难、无法推进等等，及时沟通解决。等事情验收完成后，再在任务清单上标记已完成。我觉得这样就能解决上述问题。</p>
<p>总的来说，安排任务时，不能只是把任务分配下去就高枕无忧了。虽然每一条任务的发布和验收形成闭环是很理想的状态，但在这个过程中，及时跟进也至关重要。</p>
]]></content:encoded>
    </item>
    <item>
      <title>28-项目总负责人应该在什么时候介入项目</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/28-%E9%A1%B9%E7%9B%AE%E6%80%BB%E8%B4%9F%E8%B4%A3%E4%BA%BA%E5%BA%94%E8%AF%A5%E4%BB%80%E4%B9%88%E6%97%B6%E5%80%99%E4%BB%8B%E5%85%A5%E9%A1%B9%E7%9B%AE%E4%B8%AD/</link>
      <pubDate>Wed, 28 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/28-%E9%A1%B9%E7%9B%AE%E6%80%BB%E8%B4%9F%E8%B4%A3%E4%BA%BA%E5%BA%94%E8%AF%A5%E4%BB%80%E4%B9%88%E6%97%B6%E5%80%99%E4%BB%8B%E5%85%A5%E9%A1%B9%E7%9B%AE%E4%B8%AD/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280600445.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;项目总负责人究竟应该在什么时候介入项目呢？&lt;/p&gt;
&lt;p&gt;这个问题的本质其实是在深入探讨，何时需要项目总负责人直接替代项目负责人做出关键决策，或者直接介入并解决项目推进过程中遇到的具体问题。&lt;/p&gt;
&lt;p&gt;下面以项目负责人为张三、项目总负责人为王七的实际案例进行详细说明。&lt;/p&gt;
&lt;h1 id=&#34;2-事情起因&#34;&gt;2. 事情起因&lt;/h1&gt;
&lt;p&gt;曾经有一次，客户在项目沟通群里反馈了一个问题，明确提到平台的地图功能没有正常显示出来。&lt;/p&gt;
&lt;p&gt;当时正值周六，按照常规工作安排，大家都没有在公司上班，因此项目负责人张三可能没有及时留意到沟通群里的消息，也就没有在第一时间回复客户。&lt;/p&gt;
&lt;p&gt;后来，有看到消息的同事将客户反馈的问题转发到了部门群，这样整个部门的人员都能看到客户的反馈内容了。&lt;/p&gt;
&lt;p&gt;可即便如此，张三仍然没有在部门群里对客户的问题进行回复。&lt;/p&gt;
&lt;h1 id=&#34;3-张三为什么没有及时回复&#34;&gt;3. 张三为什么没有及时回复&lt;/h1&gt;
&lt;p&gt;事后了解到，他认为地图功能并不是由自己负责的项目团队开发的，而是属于其他项目团队的功能，自己负责的项目仅仅是在使用这个功能模块而已。&lt;/p&gt;
&lt;p&gt;也就是说，他在内心将自己定位为功能使用方，所以觉得不应该由自己来回复客户，而应该由负责开发地图功能的相关人员来处理。&lt;/p&gt;
&lt;h1 id=&#34;4-王七为什么没有及时回复&#34;&gt;4. 王七为什么没有及时回复&lt;/h1&gt;
&lt;p&gt;事实上，项目总负责人王七在周六当天也看到了客户在沟通群里反馈的消息，但他同样没有及时回复客户，就这样任由问题持续发酵。&lt;/p&gt;
&lt;p&gt;王七当时的想法是等着张三去处理这个问题 —— 因为在他看来，这是项目负责人职责范围内的事情。如果王七事事都介入处理，就相当于虽然已经对张三进行了授权，自己却又在一旁指手画脚，这样的做法显得有些奇怪。&lt;/p&gt;
&lt;p&gt;不过事后回头来看，王七在这件事情上确实存在考虑不周全的问题，没有全面深入地看到问题的核心本质。&lt;/p&gt;
&lt;h1 id=&#34;5-从客户的视角看问题&#34;&gt;5. 从客户的视角看问题&lt;/h1&gt;
&lt;p&gt;换位思考，假设你自己就是那位客户，在沟通群里反馈问题之后过了很长时间都没有人回复，会作何感想呢？&lt;/p&gt;
&lt;p&gt;而且需要注意的是，这次反馈问题的渠道不是工单渠道，而是群内的实时交流渠道，在这种情况下，客户即便不生气，心里也会十分不爽吧。&lt;/p&gt;
&lt;p&gt;毕竟，客户在使用功能时遇到了问题，急需解决以便正常使用，而我们却没有给予足够的重视。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280601514.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;6-张三的问题与改进&#34;&gt;6. 张三的问题与改进&lt;/h1&gt;
&lt;p&gt;张三的做法乍一看似乎有一定的合理性，但他根本没有想明白关键问题所在 —— 对外和对内处理问题的方式是截然不同的。&lt;/p&gt;
&lt;p&gt;在公司或者部门内部，上面提到的那种想法虽然存在一定问题，但还不是特别严重。&lt;/p&gt;
&lt;p&gt;因为无论对外还是对内，项目负责人的职责本来就包括对项目整体的管理，一旦出现问题，第一责任人肯定还是要找到项目负责人，怎么会有出现问题先去找具体功能负责人的道理呢？&lt;/p&gt;
&lt;p&gt;正确的处理流程应该是：客户的反馈先到达张三这里，然后由张三再去找对应的同事沟通并解决问题。&lt;strong&gt;在对外沟通时，个人所代表的不再是自己，而是整个公司。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;因此，每一句话、每一个行为都需要用公司的标准来严格要求自己。&lt;/p&gt;
&lt;p&gt;就算明知道问题属于其他项目组甚至其他部门，如果该部门的相关人员不在这个沟通群里，也应该先回复客户，比如可以说 “我先了解一下具体是什么问题”。&lt;/p&gt;
&lt;p&gt;然后再去寻找对应的同事，不管是部门内部的还是其他部门的，都要积极去协商协调，最终把问题解决掉。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;客户不会去关注你是哪个部门的，他们只知道你是这家公司的员工。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;不管在公司内部具体是由谁负责这件事情，客户只需要你帮忙解决他们遇到的问题，仅此而已。&lt;/strong&gt;&lt;/p&gt;
&lt;h1 id=&#34;7-王七的问题与改进&#34;&gt;7. 王七的问题与改进&lt;/h1&gt;
&lt;p&gt;当客户反馈问题之后，已经过去了五六个小时，张三还是没有回复客户。&lt;/p&gt;
&lt;p&gt;这个时候，王七可能觉得这是张三的职责所在，认为张三需要经历这样的事情，而这也正是导致王七没有直接介入沟通的原因，差不多就是想让张三通过这次犯错来积累工作经验。&lt;/p&gt;
&lt;p&gt;不过，王七也犯了同样的错误：从想法本身来看没有问题，把全部职责交给张三，张三就应该承担起相应的责任。&lt;/p&gt;
&lt;p&gt;但关键在于**要弄清楚是什么事情，不可能什么事情都能用来攒经验的。**就拿上面这件事情来说，&lt;strong&gt;客诉问题，一直是重中之重的事情，不可掉以轻心。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;正如前面所提到的，客户不会去关心你公司内部的分工情况，他们只知道你是这家公司的员工，你在客户面前的任何表现，都直接关系到客户对这家公司的整体印象。&lt;/p&gt;
&lt;p&gt;所以在这种情况下，当张三没有回复客户时，如果过了一两个小时，张三仍然没有回复，那么王七自己就需要直接介入，回复客户，并跟进这个事情，弄清楚到底是什么原因导致了这个问题，确保问题能有效解决。&lt;/p&gt;
&lt;p&gt;至于要问责或弄清楚张三为什么没有及时回复客户等事情，可以等事情解决了之后再说，现在首要解决的是客户遇到的问题，&lt;strong&gt;一切以客户为先。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280601121.jpg&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280600445.png"></p>
<h1 id="1-前言">1. 前言</h1>
<p>项目总负责人究竟应该在什么时候介入项目呢？</p>
<p>这个问题的本质其实是在深入探讨，何时需要项目总负责人直接替代项目负责人做出关键决策，或者直接介入并解决项目推进过程中遇到的具体问题。</p>
<p>下面以项目负责人为张三、项目总负责人为王七的实际案例进行详细说明。</p>
<h1 id="2-事情起因">2. 事情起因</h1>
<p>曾经有一次，客户在项目沟通群里反馈了一个问题，明确提到平台的地图功能没有正常显示出来。</p>
<p>当时正值周六，按照常规工作安排，大家都没有在公司上班，因此项目负责人张三可能没有及时留意到沟通群里的消息，也就没有在第一时间回复客户。</p>
<p>后来，有看到消息的同事将客户反馈的问题转发到了部门群，这样整个部门的人员都能看到客户的反馈内容了。</p>
<p>可即便如此，张三仍然没有在部门群里对客户的问题进行回复。</p>
<h1 id="3-张三为什么没有及时回复">3. 张三为什么没有及时回复</h1>
<p>事后了解到，他认为地图功能并不是由自己负责的项目团队开发的，而是属于其他项目团队的功能，自己负责的项目仅仅是在使用这个功能模块而已。</p>
<p>也就是说，他在内心将自己定位为功能使用方，所以觉得不应该由自己来回复客户，而应该由负责开发地图功能的相关人员来处理。</p>
<h1 id="4-王七为什么没有及时回复">4. 王七为什么没有及时回复</h1>
<p>事实上，项目总负责人王七在周六当天也看到了客户在沟通群里反馈的消息，但他同样没有及时回复客户，就这样任由问题持续发酵。</p>
<p>王七当时的想法是等着张三去处理这个问题 —— 因为在他看来，这是项目负责人职责范围内的事情。如果王七事事都介入处理，就相当于虽然已经对张三进行了授权，自己却又在一旁指手画脚，这样的做法显得有些奇怪。</p>
<p>不过事后回头来看，王七在这件事情上确实存在考虑不周全的问题，没有全面深入地看到问题的核心本质。</p>
<h1 id="5-从客户的视角看问题">5. 从客户的视角看问题</h1>
<p>换位思考，假设你自己就是那位客户，在沟通群里反馈问题之后过了很长时间都没有人回复，会作何感想呢？</p>
<p>而且需要注意的是，这次反馈问题的渠道不是工单渠道，而是群内的实时交流渠道，在这种情况下，客户即便不生气，心里也会十分不爽吧。</p>
<p>毕竟，客户在使用功能时遇到了问题，急需解决以便正常使用，而我们却没有给予足够的重视。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280601514.png"></p>
<h1 id="6-张三的问题与改进">6. 张三的问题与改进</h1>
<p>张三的做法乍一看似乎有一定的合理性，但他根本没有想明白关键问题所在 —— 对外和对内处理问题的方式是截然不同的。</p>
<p>在公司或者部门内部，上面提到的那种想法虽然存在一定问题，但还不是特别严重。</p>
<p>因为无论对外还是对内，项目负责人的职责本来就包括对项目整体的管理，一旦出现问题，第一责任人肯定还是要找到项目负责人，怎么会有出现问题先去找具体功能负责人的道理呢？</p>
<p>正确的处理流程应该是：客户的反馈先到达张三这里，然后由张三再去找对应的同事沟通并解决问题。<strong>在对外沟通时，个人所代表的不再是自己，而是整个公司。</strong></p>
<p>因此，每一句话、每一个行为都需要用公司的标准来严格要求自己。</p>
<p>就算明知道问题属于其他项目组甚至其他部门，如果该部门的相关人员不在这个沟通群里，也应该先回复客户，比如可以说 “我先了解一下具体是什么问题”。</p>
<p>然后再去寻找对应的同事，不管是部门内部的还是其他部门的，都要积极去协商协调，最终把问题解决掉。</p>
<p><strong>客户不会去关注你是哪个部门的，他们只知道你是这家公司的员工。</strong></p>
<p><strong>不管在公司内部具体是由谁负责这件事情，客户只需要你帮忙解决他们遇到的问题，仅此而已。</strong></p>
<h1 id="7-王七的问题与改进">7. 王七的问题与改进</h1>
<p>当客户反馈问题之后，已经过去了五六个小时，张三还是没有回复客户。</p>
<p>这个时候，王七可能觉得这是张三的职责所在，认为张三需要经历这样的事情，而这也正是导致王七没有直接介入沟通的原因，差不多就是想让张三通过这次犯错来积累工作经验。</p>
<p>不过，王七也犯了同样的错误：从想法本身来看没有问题，把全部职责交给张三，张三就应该承担起相应的责任。</p>
<p>但关键在于**要弄清楚是什么事情，不可能什么事情都能用来攒经验的。**就拿上面这件事情来说，<strong>客诉问题，一直是重中之重的事情，不可掉以轻心。</strong></p>
<p>正如前面所提到的，客户不会去关心你公司内部的分工情况，他们只知道你是这家公司的员工，你在客户面前的任何表现，都直接关系到客户对这家公司的整体印象。</p>
<p>所以在这种情况下，当张三没有回复客户时，如果过了一两个小时，张三仍然没有回复，那么王七自己就需要直接介入，回复客户，并跟进这个事情，弄清楚到底是什么原因导致了这个问题，确保问题能有效解决。</p>
<p>至于要问责或弄清楚张三为什么没有及时回复客户等事情，可以等事情解决了之后再说，现在首要解决的是客户遇到的问题，<strong>一切以客户为先。</strong></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505280601121.jpg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>27-项目管理制度难以执行的问题探讨</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/27-%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%88%B6%E5%BA%A6%E9%9A%BE%E4%BB%A5%E6%89%A7%E8%A1%8C%E7%9A%84%E9%97%AE%E9%A2%98%E6%8E%A2%E8%AE%A8/</link>
      <pubDate>Mon, 26 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/27-%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%88%B6%E5%BA%A6%E9%9A%BE%E4%BB%A5%E6%89%A7%E8%A1%8C%E7%9A%84%E9%97%AE%E9%A2%98%E6%8E%A2%E8%AE%A8/</guid>
      <description>&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262053475.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;在项目管理中，我们常会制定一些规章制度用以约束行为，从而有效推进项目。但现实中，无论是开会沟通通知还是口头传达的要求，往往只能坚持一段时间，过后便会恢复原状。&lt;/p&gt;
&lt;p&gt;正如那句话说的：&lt;strong&gt;“你无法要求别人做什么，除非他自己愿意去做。”&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;工作中亦是如此，即便强调过每天下班前要在项目任务系统填写当天日志，对方也只能坚持一阵子，时间一长便又故态复萌。&lt;/p&gt;
&lt;p&gt;同理，项目计划需要实时更新，以避免信息同步不及时影响后续功能开发或决策制定，但很多人依旧未能遵守，大多是坚持一段时间后便打回原形。&lt;/p&gt;
&lt;p&gt;这种现象很难单纯用对错来评判。回归本质，我们的核心目的在于：将所有问题公开化，通过即时沟通制定规章制度，确保各项目有效推进，避免延期，最终达成项目目标。&lt;/p&gt;
&lt;p&gt;那么，该如何解决这些问题呢？发脾气或许能起到一定作用，但也要看对象，而且大多数情况下并不推荐。更合适的做法是找个会议室私下沟通清楚，避免当众批评，以免引发逆反心理，得不偿失。&lt;/p&gt;
&lt;p&gt;因此，我们需要探寻有效的解决方法。就以任务日志缺填这一问题为例（实际情况中存在的问题远不止于此，此处仅作举例说明），可以采取以下措施：&lt;/p&gt;
&lt;p&gt;首先，将规章制度以严谨的文字梳理成文档，并建立惩罚机制。例如，约定任务日志缺填每月不得超过 3 次，否则需赞助50 块钱到部门经费 ，同时，项目总负责人自己也需赞助 50 块钱。&lt;/p&gt;
&lt;p&gt;这样做的目的在于：一方面，项目总负责人作为全部项目首要责任人，理应对项目中出现的任务问题负责；另一方面，避免将自己置于项目成员的对立面，减少摩擦，让大家感受到你与他们是站在同一阵线，制定这些规定只是为了更好地进行项目管理，而不是针对谁。&lt;/p&gt;
&lt;p&gt;在落实过程中，月底统计时如果发现有人当月缺填超过 3 次，就需要当面沟通了解情况，探究缺填的原因。&lt;/p&gt;
&lt;p&gt;沟通时要因人而异，大多数情况下，只要解释合理（无论真假），都按真实情况处理，并明确告知此次可以通融，但下个月如果再出现类似情况，将直接收取 50 块钱，不再给予额外机会。&lt;/p&gt;
&lt;p&gt;因为，我们的目的并不是为了这 50 块钱，所以，给对方一次改正的机会，让对方感受到被尊重，后续会更愿意、自觉地遵守这些规章制度。&lt;/p&gt;
&lt;p&gt;但凡事也有例外的，虽然应该不多。如果下个月对方依旧出现，任务日志缺填超过 3 次以上的情况，该如何处理？&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262053120.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;这需要根据具体原因来判断：如果理由充分、合情合理，可暂时不收取费用；如果理由并不充分，则直接收取费用，并与对方一同扫码将费用赞助至部门经费，同时在部门群内公开，以消除大家对项目总负责人是否也一起赞助 50 块钱了的疑虑。&lt;/p&gt;
&lt;p&gt;如果下个月仍然出现缺填且理由不充分，在要求对方赞助 50 块时态度还很恶劣，那么，就需要明确告诉对方：制定项目规章制度的目的是什么？任务日志的作用是什么 —— 让项目负责人能够实时了解每个人的工作情况、任务进度，以及是否存在影响项目推进的问题，以便及时采取其他方案。&lt;/p&gt;
&lt;p&gt;如果对方依旧不服从，就需要强硬处理，因为规章制度刚落实时如果不及时拔除这根钉子，后续将难以服众。&lt;/p&gt;
&lt;p&gt;总的来说，项目总负责人应以身作则，制定合理的规章制度，并通过实际沟通和客观判断，赢得大家的信任，促使大家养成良好习惯。&lt;/p&gt;
&lt;p&gt;实际上，设置 50 块钱赞助部门经费的规定，重点并非在于金额多少，而是形成一种无形的约束。&lt;/p&gt;
&lt;p&gt;理想状态下，一年可能就收个两三次，大概就 300 块钱左右。毕竟，钱好像不是很多，但是要让大家白白支出这笔钱，肯定觉得太亏了。相信这样应该能有效解决一些项目管理中遇到的问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262056402.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262053475.jpeg"></p>
<p>在项目管理中，我们常会制定一些规章制度用以约束行为，从而有效推进项目。但现实中，无论是开会沟通通知还是口头传达的要求，往往只能坚持一段时间，过后便会恢复原状。</p>
<p>正如那句话说的：<strong>“你无法要求别人做什么，除非他自己愿意去做。”</strong></p>
<p>工作中亦是如此，即便强调过每天下班前要在项目任务系统填写当天日志，对方也只能坚持一阵子，时间一长便又故态复萌。</p>
<p>同理，项目计划需要实时更新，以避免信息同步不及时影响后续功能开发或决策制定，但很多人依旧未能遵守，大多是坚持一段时间后便打回原形。</p>
<p>这种现象很难单纯用对错来评判。回归本质，我们的核心目的在于：将所有问题公开化，通过即时沟通制定规章制度，确保各项目有效推进，避免延期，最终达成项目目标。</p>
<p>那么，该如何解决这些问题呢？发脾气或许能起到一定作用，但也要看对象，而且大多数情况下并不推荐。更合适的做法是找个会议室私下沟通清楚，避免当众批评，以免引发逆反心理，得不偿失。</p>
<p>因此，我们需要探寻有效的解决方法。就以任务日志缺填这一问题为例（实际情况中存在的问题远不止于此，此处仅作举例说明），可以采取以下措施：</p>
<p>首先，将规章制度以严谨的文字梳理成文档，并建立惩罚机制。例如，约定任务日志缺填每月不得超过 3 次，否则需赞助50 块钱到部门经费 ，同时，项目总负责人自己也需赞助 50 块钱。</p>
<p>这样做的目的在于：一方面，项目总负责人作为全部项目首要责任人，理应对项目中出现的任务问题负责；另一方面，避免将自己置于项目成员的对立面，减少摩擦，让大家感受到你与他们是站在同一阵线，制定这些规定只是为了更好地进行项目管理，而不是针对谁。</p>
<p>在落实过程中，月底统计时如果发现有人当月缺填超过 3 次，就需要当面沟通了解情况，探究缺填的原因。</p>
<p>沟通时要因人而异，大多数情况下，只要解释合理（无论真假），都按真实情况处理，并明确告知此次可以通融，但下个月如果再出现类似情况，将直接收取 50 块钱，不再给予额外机会。</p>
<p>因为，我们的目的并不是为了这 50 块钱，所以，给对方一次改正的机会，让对方感受到被尊重，后续会更愿意、自觉地遵守这些规章制度。</p>
<p>但凡事也有例外的，虽然应该不多。如果下个月对方依旧出现，任务日志缺填超过 3 次以上的情况，该如何处理？</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262053120.jpeg"></p>
<p>这需要根据具体原因来判断：如果理由充分、合情合理，可暂时不收取费用；如果理由并不充分，则直接收取费用，并与对方一同扫码将费用赞助至部门经费，同时在部门群内公开，以消除大家对项目总负责人是否也一起赞助 50 块钱了的疑虑。</p>
<p>如果下个月仍然出现缺填且理由不充分，在要求对方赞助 50 块时态度还很恶劣，那么，就需要明确告诉对方：制定项目规章制度的目的是什么？任务日志的作用是什么 —— 让项目负责人能够实时了解每个人的工作情况、任务进度，以及是否存在影响项目推进的问题，以便及时采取其他方案。</p>
<p>如果对方依旧不服从，就需要强硬处理，因为规章制度刚落实时如果不及时拔除这根钉子，后续将难以服众。</p>
<p>总的来说，项目总负责人应以身作则，制定合理的规章制度，并通过实际沟通和客观判断，赢得大家的信任，促使大家养成良好习惯。</p>
<p>实际上，设置 50 块钱赞助部门经费的规定，重点并非在于金额多少，而是形成一种无形的约束。</p>
<p>理想状态下，一年可能就收个两三次，大概就 300 块钱左右。毕竟，钱好像不是很多，但是要让大家白白支出这笔钱，肯定觉得太亏了。相信这样应该能有效解决一些项目管理中遇到的问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505262056402.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week Finale</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-finale/</link>
      <pubDate>Fri, 23 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-finale/</guid>
      <description>&lt;p&gt;从 2023 年 10 月 22 日开始，我对自己说：如果能坚持每周更新一篇 ARTS 文章，就继续运营这个公众号并群发。&lt;/p&gt;
&lt;p&gt;所以前面 10 篇都没有群发记录，基本是偷偷在写 —— 主要想验证自己能否坚持下来，万一失败了，反正也不会有人知道。&lt;/p&gt;
&lt;p&gt;但当时心里一直想着：要做就做好，要么就不做。没有不清不楚、不黑不白、不上不下的中间地带。&lt;/p&gt;
&lt;p&gt;这个打卡活动，我从 2020 年 4 月底购买陈皓《左耳听风》课程时就知道了，起初打算试试看，后来不知怎么就不了了之。这次重拾起来主要有三个目的：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;平时上班敲代码的机会变少，想通过刷算法题保持对代码的感觉。&lt;/li&gt;
&lt;li&gt;我有一份问题清单，记录着工作中遇到的问题、技术点和小技巧，但一直没整理，打算通过 Tip 模块倒逼自己梳理。&lt;/li&gt;
&lt;li&gt;老生常谈的英语学习。&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;前期坚持的效果还不错，印象中没补几次卡，应该就是过年放假时间长了点，其他时候都还好。&lt;/p&gt;
&lt;p&gt;起初计划每周阅读 Medium 上的文章，说实话，上面的文章质量真不错，而且这个网站没有广告，阅读体验特别好。&lt;/p&gt;
&lt;p&gt;我做 Review 这件事的流程基本是：自己先看一遍，看不懂的用欧路翻译插件一键自动记录到生词本，了解大概内容后自己翻译，再用有道翻译原文，对比两者的差异。&lt;/p&gt;
&lt;p&gt;这个模式坚持了一段时间后，我觉得 Medium 上的文章有时太长，自行翻译太费时间，加上需要翻墙，在公司看文章很不方便，于是换成在 &lt;a href=&#34;https://breakingnewsenglish.com/&#34;&gt;Breaking News English&lt;/a&gt; 网站翻译新闻短文，一方面文章篇幅短，另一方面不用翻墙，还能了解新闻资讯。&lt;/p&gt;
&lt;p&gt;在这个网站坚持一段时间后，有一天我突然觉得自己看英文文章不发怵了，不管多长都能硬着头皮看下去，总觉得自己马上就能看懂了。但这种感觉没持续多久，就又回归正常状态了。&lt;/p&gt;
&lt;p&gt;说真的，我很讨厌英语，为什么要学这个东西呢？但后来我想明白了，“师夷长技以制夷” 的前提是你得懂对方在说什么。当然也可以用翻译软件，但学习一门语言就是在学习一种文化，只有了解了文化和风俗习惯，应对问题，才能游刃有余。这是翻译软件无法替代的。&lt;/p&gt;
&lt;p&gt;坚持这个打卡活动到某个时间点时，我突然觉得差不多了，就是已经不需要证明什么了。当时计划在 2024 年 10 月 22 日结束这个打卡活动。&lt;/p&gt;
&lt;p&gt;但刚好《黑神话：悟空》8 月底开售，我想自己都等了 4 年了，Windows 电脑和游戏手柄都有，装备齐全，没理由不去玩，一玩才发现，这质量也太高了吧，远远超出预期。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505232231255.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;9 月初通关《黑神话：悟空》后，我真正对魂类游戏产生了兴趣，想起 2017 年买的《黑暗之魂 3》，每次玩都因为不知道怎么玩，也不看攻略，再加上都是骷髅有点吓人，玩了几次，实在玩不下去，就作罢了。&lt;/p&gt;
&lt;p&gt;这次趁热打铁，我把老贼的《黑暗之魂 3》通关了，通关后才感叹这真是艺术品啊。它在我 Steam 游戏库里吃灰快 8 年，直到现在，我才真正体验到这部作品为什么是史诗级别的。接着我又通关了老贼的《艾尔登法环》，这部年度游戏也是神作，就不多说了。&lt;/p&gt;
&lt;p&gt;前前后后花了很多时间在游戏上，ARTS 打卡活动就经常断掉，只能攒起来恶补，每周一次的打卡规定也形同虚设。&lt;/p&gt;
&lt;p&gt;但我一点都不慌，也不觉得心虚，因为我已经不需要这些来证明自己能坚持这个打卡活动了。&lt;/p&gt;
&lt;p&gt;我坚信，即使是现在，我依然可以按严格的每周一更频率坚持打卡，只是已经没有这个必要了。&lt;/p&gt;
&lt;p&gt;从 2023 年 5 月 13 日陈皓过世到现在已经 2 年了，时间过得真快。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>从 2023 年 10 月 22 日开始，我对自己说：如果能坚持每周更新一篇 ARTS 文章，就继续运营这个公众号并群发。</p>
<p>所以前面 10 篇都没有群发记录，基本是偷偷在写 —— 主要想验证自己能否坚持下来，万一失败了，反正也不会有人知道。</p>
<p>但当时心里一直想着：要做就做好，要么就不做。没有不清不楚、不黑不白、不上不下的中间地带。</p>
<p>这个打卡活动，我从 2020 年 4 月底购买陈皓《左耳听风》课程时就知道了，起初打算试试看，后来不知怎么就不了了之。这次重拾起来主要有三个目的：</p>
<ol>
<li>平时上班敲代码的机会变少，想通过刷算法题保持对代码的感觉。</li>
<li>我有一份问题清单，记录着工作中遇到的问题、技术点和小技巧，但一直没整理，打算通过 Tip 模块倒逼自己梳理。</li>
<li>老生常谈的英语学习。</li>
</ol>
<p>前期坚持的效果还不错，印象中没补几次卡，应该就是过年放假时间长了点，其他时候都还好。</p>
<p>起初计划每周阅读 Medium 上的文章，说实话，上面的文章质量真不错，而且这个网站没有广告，阅读体验特别好。</p>
<p>我做 Review 这件事的流程基本是：自己先看一遍，看不懂的用欧路翻译插件一键自动记录到生词本，了解大概内容后自己翻译，再用有道翻译原文，对比两者的差异。</p>
<p>这个模式坚持了一段时间后，我觉得 Medium 上的文章有时太长，自行翻译太费时间，加上需要翻墙，在公司看文章很不方便，于是换成在 <a href="https://breakingnewsenglish.com/">Breaking News English</a> 网站翻译新闻短文，一方面文章篇幅短，另一方面不用翻墙，还能了解新闻资讯。</p>
<p>在这个网站坚持一段时间后，有一天我突然觉得自己看英文文章不发怵了，不管多长都能硬着头皮看下去，总觉得自己马上就能看懂了。但这种感觉没持续多久，就又回归正常状态了。</p>
<p>说真的，我很讨厌英语，为什么要学这个东西呢？但后来我想明白了，“师夷长技以制夷” 的前提是你得懂对方在说什么。当然也可以用翻译软件，但学习一门语言就是在学习一种文化，只有了解了文化和风俗习惯，应对问题，才能游刃有余。这是翻译软件无法替代的。</p>
<p>坚持这个打卡活动到某个时间点时，我突然觉得差不多了，就是已经不需要证明什么了。当时计划在 2024 年 10 月 22 日结束这个打卡活动。</p>
<p>但刚好《黑神话：悟空》8 月底开售，我想自己都等了 4 年了，Windows 电脑和游戏手柄都有，装备齐全，没理由不去玩，一玩才发现，这质量也太高了吧，远远超出预期。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505232231255.jpg"></p>
<p>9 月初通关《黑神话：悟空》后，我真正对魂类游戏产生了兴趣，想起 2017 年买的《黑暗之魂 3》，每次玩都因为不知道怎么玩，也不看攻略，再加上都是骷髅有点吓人，玩了几次，实在玩不下去，就作罢了。</p>
<p>这次趁热打铁，我把老贼的《黑暗之魂 3》通关了，通关后才感叹这真是艺术品啊。它在我 Steam 游戏库里吃灰快 8 年，直到现在，我才真正体验到这部作品为什么是史诗级别的。接着我又通关了老贼的《艾尔登法环》，这部年度游戏也是神作，就不多说了。</p>
<p>前前后后花了很多时间在游戏上，ARTS 打卡活动就经常断掉，只能攒起来恶补，每周一次的打卡规定也形同虚设。</p>
<p>但我一点都不慌，也不觉得心虚，因为我已经不需要这些来证明自己能坚持这个打卡活动了。</p>
<p>我坚信，即使是现在，我依然可以按严格的每周一更频率坚持打卡，只是已经没有这个必要了。</p>
<p>从 2023 年 5 月 13 日陈皓过世到现在已经 2 年了，时间过得真快。</p>
<p>我在《关于陈皓，二三事》这篇文章里介绍过一些交集，虽然我们从未沟通过，但我还是很感恩。</p>
<p>陈皓文章中体现的一些东西一直激励着我，虽说他是后端，我是前端，那个课程大部分内容是后端、大数据、Go 语言、各种服务器知识等，和我关联不大，但他在做人做事、职业规划、工作学习上的建议，让我醍醐灌顶，很是受用。</p>
<p>现在真的要结束了，想起过去快两年在电脑前码字的时光，不管是艳阳高照的白天，还是灯火通明的深夜，我都是开心的，也觉得很值得。</p>
<p>我相信 “日拱一卒，功不唐捐”。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505232301230.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>26-项目任务繁重领导还要加新任务怎么办</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/26-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E7%B9%81%E9%87%8D%E9%A2%86%E5%AF%BC%E8%BF%98%E8%A6%81%E5%8A%A0%E6%96%B0%E4%BB%BB%E5%8A%A1%E6%80%8E%E4%B9%88%E5%8A%9E/</link>
      <pubDate>Mon, 19 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/26-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E7%B9%81%E9%87%8D%E9%A2%86%E5%AF%BC%E8%BF%98%E8%A6%81%E5%8A%A0%E6%96%B0%E4%BB%BB%E5%8A%A1%E6%80%8E%E4%B9%88%E5%8A%9E/</guid>
      <description>&lt;p&gt;这个问题最初出现在技术管理沟通群里，有群友提问：自己负责的项目任务已十分繁重，可领导还要安排新任务，不知如何是好。答应吧，担心自己所在的小组即便累死累活也难以完成；不答应吧，又怕惹领导不高兴。&lt;/p&gt;
&lt;p&gt;我想起之前看《铁齿铜牙纪晓岚 4》时，有这样一段剧情：乾隆打算在凌烟阁挂上二十四幅功臣图，众人就谁排第一产生争执。乾隆使计让杜小月说出，若让纪晓岚进入军机部，也能像和珅一样出色，所以不同意和珅比纪晓岚厉害。乾隆顺水推舟，安排了角色互换的游戏，让纪晓岚去军机部，和珅去修四库全书。结果两人在处理不同部门事务时，因为缺乏经验，导致处处受阻，只能私下碰头商讨对策。&lt;/p&gt;
&lt;p&gt;剧中，纪晓岚说皇上让自己查张廷玉的几块银两用在何处，觉得这点小事不必斤斤计较。和珅则表示，皇上安排的事情，最怕的不是大事，因为大事有章法可循，按章办理即可；最怕的是小事，没有先例，只能琢磨心思、见招拆招，所以对皇上安排的小事，要特别小心。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505191948632.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;还有曾仕强先生在一期节目中说道：“如果老板让我去死，我到底去不去呢？” 他给出的回答是，先应承 “好的，老板”，然后自己不去就行了嘛。&lt;/p&gt;
&lt;p&gt;从上述事例中，我们能得到什么启发呢？一方面要明白领导的用意，另一方面是不要直接拒绝领导。关键在于不要直接拒绝，而非完全不能拒绝。&lt;/p&gt;
&lt;p&gt;其实核心还是 &lt;strong&gt;“先肯定后否决”&lt;/strong&gt; 的策略，这和我们平时常用的标准反驳句式如出一辙 ——&lt;strong&gt;“你说的确实有道理，但是……”&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;如果是我，我会先一口答应下来，尤其是在多人场合。如果只有自己和领导两人沟通，拒绝的影响相对小一些；然而在多人场合直接拒绝，领导可能会觉得没面子。要是领导心眼小、心胸狭窄，日后难免会给你穿小鞋。所以，先痛快地答应 “好的”，然后过半小时左右去找领导，解释目前手头上的任务太多，若新任务时间紧迫，是否可以将其他任务暂缓？如果不能暂缓，多项任务同时推进实在难以完成，恐怕最后会顾此失彼。&lt;/p&gt;
&lt;p&gt;这样做既能表明自己有积极完成任务的态度，又能说明客观条件不允许。领导的回应通常有两种：要么让你先暂缓其他任务，要么让你推迟新任务的完成时间，问题往往就能迎刃而解。当然，如果领导听不进建议，仍然一意孤行，直接干他就是了（哈哈哈，你敢信，我就敢说）。&lt;/p&gt;
&lt;p&gt;由此可以延伸思考，领导安排任务时，必然有自己的考量。一般有两种情况：一是从当时的实际情况出发，认为由你负责更为合适；二是借此进行测试。培养一个人并非突然委以重任或提拔，而是通过日常工作中的突然考验，时不时来这么一下，看你瞬间的反应，从多个维度综合评估你是否值得信任、能否为我所用。&lt;/p&gt;
&lt;p&gt;可能有人会说，公司的组织架构、管理方式和领导的性格等各方面情况都不一样，但我觉得核心逻辑是一样的 —— 先肯定后否决，只是在执行方式上，需根据实际情况调整。比如公司是扁平化管理，上下级没有明显的严格层级划分，而你对自己负责的项目情况又特别清楚，领导安排新的任务时，你完全可以直接当面解释目前的情况，说明加上新任务可能会导致的问题，而不必非要一口答应，等到半个小时之后才去找领导解释，那样做事就太死板了。&lt;/p&gt;
&lt;p&gt;不过话说回来，工作和生活本就是一体的，但又不尽相同，人在上面的行事风格差异很大。工作上的这种测试是可以接受的，毕竟只是工作。但生活中类似的测试，真的不能接受，因为很没意思。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>这个问题最初出现在技术管理沟通群里，有群友提问：自己负责的项目任务已十分繁重，可领导还要安排新任务，不知如何是好。答应吧，担心自己所在的小组即便累死累活也难以完成；不答应吧，又怕惹领导不高兴。</p>
<p>我想起之前看《铁齿铜牙纪晓岚 4》时，有这样一段剧情：乾隆打算在凌烟阁挂上二十四幅功臣图，众人就谁排第一产生争执。乾隆使计让杜小月说出，若让纪晓岚进入军机部，也能像和珅一样出色，所以不同意和珅比纪晓岚厉害。乾隆顺水推舟，安排了角色互换的游戏，让纪晓岚去军机部，和珅去修四库全书。结果两人在处理不同部门事务时，因为缺乏经验，导致处处受阻，只能私下碰头商讨对策。</p>
<p>剧中，纪晓岚说皇上让自己查张廷玉的几块银两用在何处，觉得这点小事不必斤斤计较。和珅则表示，皇上安排的事情，最怕的不是大事，因为大事有章法可循，按章办理即可；最怕的是小事，没有先例，只能琢磨心思、见招拆招，所以对皇上安排的小事，要特别小心。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505191948632.png"></p>
<p>还有曾仕强先生在一期节目中说道：“如果老板让我去死，我到底去不去呢？” 他给出的回答是，先应承 “好的，老板”，然后自己不去就行了嘛。</p>
<p>从上述事例中，我们能得到什么启发呢？一方面要明白领导的用意，另一方面是不要直接拒绝领导。关键在于不要直接拒绝，而非完全不能拒绝。</p>
<p>其实核心还是 <strong>“先肯定后否决”</strong> 的策略，这和我们平时常用的标准反驳句式如出一辙 ——<strong>“你说的确实有道理，但是……”</strong></p>
<p>如果是我，我会先一口答应下来，尤其是在多人场合。如果只有自己和领导两人沟通，拒绝的影响相对小一些；然而在多人场合直接拒绝，领导可能会觉得没面子。要是领导心眼小、心胸狭窄，日后难免会给你穿小鞋。所以，先痛快地答应 “好的”，然后过半小时左右去找领导，解释目前手头上的任务太多，若新任务时间紧迫，是否可以将其他任务暂缓？如果不能暂缓，多项任务同时推进实在难以完成，恐怕最后会顾此失彼。</p>
<p>这样做既能表明自己有积极完成任务的态度，又能说明客观条件不允许。领导的回应通常有两种：要么让你先暂缓其他任务，要么让你推迟新任务的完成时间，问题往往就能迎刃而解。当然，如果领导听不进建议，仍然一意孤行，直接干他就是了（哈哈哈，你敢信，我就敢说）。</p>
<p>由此可以延伸思考，领导安排任务时，必然有自己的考量。一般有两种情况：一是从当时的实际情况出发，认为由你负责更为合适；二是借此进行测试。培养一个人并非突然委以重任或提拔，而是通过日常工作中的突然考验，时不时来这么一下，看你瞬间的反应，从多个维度综合评估你是否值得信任、能否为我所用。</p>
<p>可能有人会说，公司的组织架构、管理方式和领导的性格等各方面情况都不一样，但我觉得核心逻辑是一样的 —— 先肯定后否决，只是在执行方式上，需根据实际情况调整。比如公司是扁平化管理，上下级没有明显的严格层级划分，而你对自己负责的项目情况又特别清楚，领导安排新的任务时，你完全可以直接当面解释目前的情况，说明加上新任务可能会导致的问题，而不必非要一口答应，等到半个小时之后才去找领导解释，那样做事就太死板了。</p>
<p>不过话说回来，工作和生活本就是一体的，但又不尽相同，人在上面的行事风格差异很大。工作上的这种测试是可以接受的，毕竟只是工作。但生活中类似的测试，真的不能接受，因为很没意思。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 51</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-51/</link>
      <pubDate>Sat, 17 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-51/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/range-addition-ii/&#34;&gt;598. 区间加法 II&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个 &lt;code&gt;m x n&lt;/code&gt; 的矩阵 &lt;code&gt;M&lt;/code&gt; 和一个操作数组 &lt;code&gt;op&lt;/code&gt; 。矩阵初始化时所有的单元格都为 &lt;code&gt;0&lt;/code&gt; 。&lt;code&gt;ops[i] = [ai, bi]&lt;/code&gt; 意味着当所有的 &lt;code&gt;0 &amp;lt;= x &amp;lt; ai&lt;/code&gt; 和 &lt;code&gt;0 &amp;lt;= y &amp;lt; bi&lt;/code&gt; 时， &lt;code&gt;M[x][y]&lt;/code&gt; 应该加 1。&lt;/p&gt;
&lt;p&gt;在 &lt;em&gt;执行完所有操作后&lt;/em&gt; ，计算并返回 &lt;em&gt;矩阵中最大整数的个数&lt;/em&gt; 。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505171101863.jpeg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;M&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中最大的整数是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;而且&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;M&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中有4个值为2的元素&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;因此返回&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果操作组为空，则表示都是0，直接返回m*n
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 找到最小的m和n
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minM&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minN&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;minM&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;minM&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;minN&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;minN&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;ops&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 返回最小的m和n的个数相乘
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minM&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minN&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;这道题其实还是很简单的，只是一开始会有点绕，不太清楚要讲什么，但是仔细观察就会发现，突破点就是这个 “矩阵中最大整数的个数”。因为所有的格子都要 + 1，所以，最大的整数只会出现在操作组a1、b1值最小的那个上面。所以，我们要做的工作，就是找出最小值的那个操作组。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2505/250515-carlo-ancelotti.html&#34;&gt;Carlo Ancelotti leaves Real Madrid to coach Brazil - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/range-addition-ii/">598. 区间加法 II</a></p>
<p>给你一个 <code>m x n</code> 的矩阵 <code>M</code> 和一个操作数组 <code>op</code> 。矩阵初始化时所有的单元格都为 <code>0</code> 。<code>ops[i] = [ai, bi]</code> 意味着当所有的 <code>0 &lt;= x &lt; ai</code> 和 <code>0 &lt;= y &lt; bi</code> 时， <code>M[x][y]</code> 应该加 1。</p>
<p>在 <em>执行完所有操作后</em> ，计算并返回 <em>矩阵中最大整数的个数</em> 。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505171101863.jpeg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">m</span> <span class="o">=</span> <span class="mi">3</span><span class="p">,</span> <span class="nx">n</span> <span class="o">=</span> <span class="mi">3</span><span class="err">，</span><span class="nx">ops</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span> <span class="nx">M</span> <span class="nx">中最大的整数是</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">而且</span> <span class="nx">M</span> <span class="nx">中有4个值为2的元素</span><span class="err">。</span><span class="nx">因此返回</span> <span class="mi">4</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">maxCount</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">m</span><span class="p">,</span> <span class="nx">n</span><span class="p">,</span> <span class="nx">ops</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果操作组为空，则表示都是0，直接返回m*n
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">ops</span><span class="p">.</span><span class="nx">length</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">m</span> <span class="o">*</span> <span class="nx">n</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 找到最小的m和n
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">minM</span> <span class="o">=</span> <span class="nx">m</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">minN</span> <span class="o">=</span> <span class="nx">n</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">ops</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">minM</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">minM</span><span class="p">,</span><span class="nx">ops</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="mi">0</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="nx">minN</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">minN</span><span class="p">,</span><span class="nx">ops</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="mi">1</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 返回最小的m和n的个数相乘
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">return</span> <span class="nx">minM</span> <span class="o">*</span> <span class="nx">minN</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>这道题其实还是很简单的，只是一开始会有点绕，不太清楚要讲什么，但是仔细观察就会发现，突破点就是这个 “矩阵中最大整数的个数”。因为所有的格子都要 + 1，所以，最大的整数只会出现在操作组a1、b1值最小的那个上面。所以，我们要做的工作，就是找出最小值的那个操作组。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2505/250515-carlo-ancelotti.html">Carlo Ancelotti leaves Real Madrid to coach Brazil - Breaking News English Lesson</a></p>
<p>65 岁的传奇足球教练卡洛・安切洛蒂已决定离开西班牙豪门皇家马德里，出任巴西国家队主教练。他执教皇马的最后一场比赛将于 5 月 25 日举行，次日他将正式走马上任巴西国家队主教练一职。安切洛蒂对记者表示：“从 26 日起，我将成为巴西队主帅，这是一项重大挑战。现在，我仍是皇马主帅，我希望能圆满完成这最后一段征程，为这段美妙的冒险画上句号。” 执教巴西队将是安切洛蒂首次担任国家队主教练一职。安切洛蒂是有史以来最成功的足球教练之一，他是唯一一位赢得过欧洲五大顶级联赛冠军的教练，还创纪录地五次捧起欧洲冠军联赛奖杯。</p>
<p>巴西队是世界上战绩最为辉煌的国家队，也是唯一一个五次夺得国际足联世界杯冠军的国家，但上一次夺冠还是在 2002 年，自那以后，巴西队再未闯入过世界杯决赛。2014 年，巴西队在半决赛中 1 比 7 惨败给德国队。巴西足球联合会主席埃德纳尔多・罗德里格斯希望安切洛蒂能扭转巴西队的命运。罗德里格斯先生说：“安切洛蒂是历史上最伟大的教练，如今他执掌着世界上最伟大的国家队。我们将携手为巴西足球书写新的辉煌篇章。” 安切洛蒂将率领巴西队出战下个月对阵巴拉圭和厄瓜多尔的世界杯预选赛。</p>
<h2 id="tip">Tip</h2>
<p>之前一直用 DeepSeek 来检查文章、公司文档的错别字和标点符号，结果它总是输出莫名其妙的东西。后来我换成 Kimi，虽然效果好了很多，但还是不尽如人意，很多语句都有问题。这次换成豆包 AI，好像是好一些，但也就那样吧。</p>
<p>所以说，想用 AI 写文，实际上搞不好反而会降低效率。当然，这还是得看使用的人，如果没什么底线，觉得输出的东西无所谓，那效率确实高得很。</p>
<h2 id="share">Share</h2>
<p>“醉后不知天在水，满船清梦压星河。”</p>
<p>这真的是人能写出来的么？</p>
]]></content:encoded>
    </item>
    <item>
      <title>25-项目需求如何有效梳理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/25-%E9%A1%B9%E7%9B%AE%E9%9C%80%E6%B1%82%E5%A6%82%E4%BD%95%E6%9C%89%E6%95%88%E6%A2%B3%E7%90%86/</link>
      <pubDate>Thu, 15 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/25-%E9%A1%B9%E7%9B%AE%E9%9C%80%E6%B1%82%E5%A6%82%E4%BD%95%E6%9C%89%E6%95%88%E6%A2%B3%E7%90%86/</guid>
      <description>&lt;p&gt;现在我们的需求梳理方式，基本上就是一句话。什么意思呢？就是有一个需求文档，项目负责人把要做的事情依次列出，再对其进行评估，如果需要设计原型，就安排产品进行功能原型设计，如果需要提供解决方案，那么就先安排自己或其他开发成员提供解决方案。&lt;/p&gt;
&lt;p&gt;好像没有什么问题？其实，真正的产品需求文档，也就是俗称的 PRD 文档，是很规范的，就不说什么形式上的问题，比如文档信息、版本更新历史、名词解释等等。就光内容的要求，就很精细。就拿 APP 的 PRD 文档来说，是需要把原型的图片贴到文档里的，然后要对每个功能和交互进行说明，比如点击这个按钮，会出现什么弹窗，弹窗的布局是什么样子的，内容是什么，文本是什么颜色的，是使用什么字体的等等。比如，XiaoPiu 的官方示例：&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505151110023.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;这样详细的好处是，在之前的文章《16 - 项目的任务质量如何保证》中已经有过类似的叙述，那就是避免需求边界不清晰，导致后续的返工。&lt;/p&gt;
&lt;p&gt;但是，对于我们现阶段而言，项目的需求应该怎么梳理呢？这个怎么说呢？如果是在大公司，分工比较明确，那么这样做无可厚非，精益求精未尝不可，但是，如果是中小型公司，或者只是一个部门，要自负盈亏，考虑到实际工作中的产出，或者说性价比，那么就感觉有点过度精细了，说好听点，是追求极致与差不多这个度怎么把控的问题，说直白点，是怎么利益最大化的问题。&lt;/p&gt;
&lt;p&gt;所以，从实际情况出发，虽然 PRD 文档规范化，有诸多好处，但是投入产出比显然很低的，因为没有那么多人手把这个需求做到这么精细的程度，加上平时沟通也很及时，有什么问题及时沟通处理就行，而且，PRD 文档规范化还有一个重要的目的是，为了和其他部门或其他公司进行沟通交流使用的。&lt;/p&gt;
&lt;p&gt;可是，只是我们部门内部使用的需求文档，就没必要这么精细了，只要能做好这件事情就行。但是，虽然是一句话需求，但还是有优化空间的，我们做不到整个文档规范化，但对这一句话的需求，可以规范化。&lt;/p&gt;
&lt;p&gt;上面说的是 PRD 文档的规范问题，但其实，对于需求的整理，可以遵循需求的 INVEST 原则。需求的 INVEST 原则最早由 极限编程（XP）的倡导者 Bill Wake 提出。这一原则旨在指导敏捷开发中用户故事的拆分与编写，帮助团队更高效地管理需求，确保故事的可交付性和价值性。&lt;/p&gt;
&lt;p&gt;INVEST 原则主要用于优化用户故事的描述，使其满足以下特性：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;独立性（Independent）&lt;/strong&gt;：故事之间减少依赖，便于单独开发和测试。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可协商性（Negotiable）&lt;/strong&gt;：避免过早锁定细节，鼓励通过沟通逐步完善需求。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;有价值（Valuable）&lt;/strong&gt;：每个故事必须为用户或客户提供明确价值，避免资源浪费。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可估算（Estimable）&lt;/strong&gt;：团队能评估工作量以制定迭代计划。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;短小（Small）&lt;/strong&gt; ：单个故事工作量控制在几天内，以降低风险。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;可测试（Testable）&lt;/strong&gt;：明确验收标准，确保功能可验证。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;结合我们部门自身情况，需求来源其实很多的，所以可分为两种，一种是部门外，另一种是部门内，如果是部门外，需要加上角色；如果是部门内，角色可不加。可以简化为，&lt;strong&gt;是谁？要做什么？为什么？&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;这里就以设备管理功能，写一个示例参考：&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;深圳客户希望能看到自己有多少台设备，方便统计和日常维护。&lt;/p&gt;&lt;/blockquote&gt;
&lt;ol&gt;
&lt;li&gt;是谁：深圳客户&lt;/li&gt;
&lt;li&gt;要做什么：看到自己有多少台设备&lt;/li&gt;
&lt;li&gt;为什么：方便统计和日常维护&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;通过这种方式，既能保证需求的清晰性和可操作性，又能在现有资源条件下实现需求梳理的优化，为项目的顺利推进奠定基础。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>现在我们的需求梳理方式，基本上就是一句话。什么意思呢？就是有一个需求文档，项目负责人把要做的事情依次列出，再对其进行评估，如果需要设计原型，就安排产品进行功能原型设计，如果需要提供解决方案，那么就先安排自己或其他开发成员提供解决方案。</p>
<p>好像没有什么问题？其实，真正的产品需求文档，也就是俗称的 PRD 文档，是很规范的，就不说什么形式上的问题，比如文档信息、版本更新历史、名词解释等等。就光内容的要求，就很精细。就拿 APP 的 PRD 文档来说，是需要把原型的图片贴到文档里的，然后要对每个功能和交互进行说明，比如点击这个按钮，会出现什么弹窗，弹窗的布局是什么样子的，内容是什么，文本是什么颜色的，是使用什么字体的等等。比如，XiaoPiu 的官方示例：</p>
<p><img alt="img" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505151110023.png"></p>
<p>这样详细的好处是，在之前的文章《16 - 项目的任务质量如何保证》中已经有过类似的叙述，那就是避免需求边界不清晰，导致后续的返工。</p>
<p>但是，对于我们现阶段而言，项目的需求应该怎么梳理呢？这个怎么说呢？如果是在大公司，分工比较明确，那么这样做无可厚非，精益求精未尝不可，但是，如果是中小型公司，或者只是一个部门，要自负盈亏，考虑到实际工作中的产出，或者说性价比，那么就感觉有点过度精细了，说好听点，是追求极致与差不多这个度怎么把控的问题，说直白点，是怎么利益最大化的问题。</p>
<p>所以，从实际情况出发，虽然 PRD 文档规范化，有诸多好处，但是投入产出比显然很低的，因为没有那么多人手把这个需求做到这么精细的程度，加上平时沟通也很及时，有什么问题及时沟通处理就行，而且，PRD 文档规范化还有一个重要的目的是，为了和其他部门或其他公司进行沟通交流使用的。</p>
<p>可是，只是我们部门内部使用的需求文档，就没必要这么精细了，只要能做好这件事情就行。但是，虽然是一句话需求，但还是有优化空间的，我们做不到整个文档规范化，但对这一句话的需求，可以规范化。</p>
<p>上面说的是 PRD 文档的规范问题，但其实，对于需求的整理，可以遵循需求的 INVEST 原则。需求的 INVEST 原则最早由 极限编程（XP）的倡导者 Bill Wake 提出。这一原则旨在指导敏捷开发中用户故事的拆分与编写，帮助团队更高效地管理需求，确保故事的可交付性和价值性。</p>
<p>INVEST 原则主要用于优化用户故事的描述，使其满足以下特性：</p>
<ol>
<li>
<p><strong>独立性（Independent）</strong>：故事之间减少依赖，便于单独开发和测试。</p>
</li>
<li>
<p><strong>可协商性（Negotiable）</strong>：避免过早锁定细节，鼓励通过沟通逐步完善需求。</p>
</li>
<li>
<p><strong>有价值（Valuable）</strong>：每个故事必须为用户或客户提供明确价值，避免资源浪费。</p>
</li>
<li>
<p><strong>可估算（Estimable）</strong>：团队能评估工作量以制定迭代计划。</p>
</li>
<li>
<p><strong>短小（Small）</strong> ：单个故事工作量控制在几天内，以降低风险。</p>
</li>
<li>
<p><strong>可测试（Testable）</strong>：明确验收标准，确保功能可验证。</p>
</li>
</ol>
<p>结合我们部门自身情况，需求来源其实很多的，所以可分为两种，一种是部门外，另一种是部门内，如果是部门外，需要加上角色；如果是部门内，角色可不加。可以简化为，<strong>是谁？要做什么？为什么？</strong></p>
<p>这里就以设备管理功能，写一个示例参考：</p>
<blockquote>
<p>深圳客户希望能看到自己有多少台设备，方便统计和日常维护。</p></blockquote>
<ol>
<li>是谁：深圳客户</li>
<li>要做什么：看到自己有多少台设备</li>
<li>为什么：方便统计和日常维护</li>
</ol>
<p>通过这种方式，既能保证需求的清晰性和可操作性，又能在现有资源条件下实现需求梳理的优化，为项目的顺利推进奠定基础。</p>
]]></content:encoded>
    </item>
    <item>
      <title>24-项目测试流程漏洞分析以及改进</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/24-%E9%A1%B9%E7%9B%AE%E6%B5%8B%E8%AF%95%E6%B5%81%E7%A8%8B%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%E6%94%B9%E8%BF%9B/</link>
      <pubDate>Wed, 14 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/24-%E9%A1%B9%E7%9B%AE%E6%B5%8B%E8%AF%95%E6%B5%81%E7%A8%8B%E6%BC%8F%E6%B4%9E%E5%88%86%E6%9E%90%E4%BB%A5%E5%8F%8A%E6%94%B9%E8%BF%9B/</guid>
      <description>&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;项目发起测试时，首先要在 OA 填写软件测试申请单。填好之后，由项目负责人准备当前版本的测试用例，交给测试部门，同时沟通确定测试周期，之后才正式开始项目功能测试。&lt;/p&gt;
&lt;h1 id=&#34;2-线上版本出现明显的问题&#34;&gt;2. 线上版本出现明显的问题&lt;/h1&gt;
&lt;p&gt;最近有个线上平台，客户反馈说平台里有个列表的按钮怎么点都没反应，而且弹窗的样式也错乱了。可这个版本明明是测试通过才上线的，这就说明测试环节肯定出问题了。&lt;/p&gt;
&lt;h1 id=&#34;3-问题产生的原因分析&#34;&gt;3. 问题产生的原因分析&lt;/h1&gt;
&lt;p&gt;为什么会出现这种情况呢？&lt;/p&gt;
&lt;p&gt;主要还是测试流程有漏洞。因为项目负责人提供给测试部门的测试用例，只包含了当前迭代的需求。所以测试的时候，测试人员就只测了新增加的功能，而出问题的那个功能是旧功能，因为不在迭代的需求范围内，所以压根就没测。&lt;/p&gt;
&lt;p&gt;按理说，这个旧功能没做任何改动，怎么会出问题呢？&lt;/p&gt;
&lt;p&gt;后来发现，在开发当前迭代需求的时候，有可能开发人员不小心动到了这个功能的代码，或者是在修复其他小问题的时候影响到了它。&lt;/p&gt;
&lt;p&gt;还有可能是当前迭代需求其实和这个功能是有关联的，但我们只关注了迭代功能有没有完成，根本没管那些关联功能，这才导致问题在实际使用的时候暴露出来。&lt;/p&gt;
&lt;h1 id=&#34;4-测试流程改进办法&#34;&gt;4. 测试流程改进办法&lt;/h1&gt;
&lt;p&gt;为了解决测试覆盖不全，又不想每一轮都全部测一遍浪费时间的问题，我们优化了测试流程：&lt;/p&gt;
&lt;p&gt;项目负责人这边要提供完整的测试用例，还要标注清楚当前版本里哪些功能必须测试，哪些不用测试。&lt;/p&gt;
&lt;p&gt;测试人员分三轮进行测试：&lt;/p&gt;
&lt;p&gt;第一轮，不管标注的是不是必须测试，把平台所有功能的测试用例都过一遍；&lt;/p&gt;
&lt;p&gt;第二轮，专门验证已经修复的 Bug，同时再把那些必须测的功能测一遍；&lt;/p&gt;
&lt;p&gt;第三轮，等所有 Bug 都修好了，确定没什么大问题了，再把平台全部功能的测试用例再过一遍。&lt;/p&gt;
&lt;p&gt;这样一来，既能保证测试全面，又不会做太多无用功。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505141718208.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="1-前言">1. 前言</h1>
<p>项目发起测试时，首先要在 OA 填写软件测试申请单。填好之后，由项目负责人准备当前版本的测试用例，交给测试部门，同时沟通确定测试周期，之后才正式开始项目功能测试。</p>
<h1 id="2-线上版本出现明显的问题">2. 线上版本出现明显的问题</h1>
<p>最近有个线上平台，客户反馈说平台里有个列表的按钮怎么点都没反应，而且弹窗的样式也错乱了。可这个版本明明是测试通过才上线的，这就说明测试环节肯定出问题了。</p>
<h1 id="3-问题产生的原因分析">3. 问题产生的原因分析</h1>
<p>为什么会出现这种情况呢？</p>
<p>主要还是测试流程有漏洞。因为项目负责人提供给测试部门的测试用例，只包含了当前迭代的需求。所以测试的时候，测试人员就只测了新增加的功能，而出问题的那个功能是旧功能，因为不在迭代的需求范围内，所以压根就没测。</p>
<p>按理说，这个旧功能没做任何改动，怎么会出问题呢？</p>
<p>后来发现，在开发当前迭代需求的时候，有可能开发人员不小心动到了这个功能的代码，或者是在修复其他小问题的时候影响到了它。</p>
<p>还有可能是当前迭代需求其实和这个功能是有关联的，但我们只关注了迭代功能有没有完成，根本没管那些关联功能，这才导致问题在实际使用的时候暴露出来。</p>
<h1 id="4-测试流程改进办法">4. 测试流程改进办法</h1>
<p>为了解决测试覆盖不全，又不想每一轮都全部测一遍浪费时间的问题，我们优化了测试流程：</p>
<p>项目负责人这边要提供完整的测试用例，还要标注清楚当前版本里哪些功能必须测试，哪些不用测试。</p>
<p>测试人员分三轮进行测试：</p>
<p>第一轮，不管标注的是不是必须测试，把平台所有功能的测试用例都过一遍；</p>
<p>第二轮，专门验证已经修复的 Bug，同时再把那些必须测的功能测一遍；</p>
<p>第三轮，等所有 Bug 都修好了，确定没什么大问题了，再把平台全部功能的测试用例再过一遍。</p>
<p>这样一来，既能保证测试全面，又不会做太多无用功。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505141718208.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>23-项目当前版本中修复上个版本测试反馈 Bug 的时机</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/23-%E9%A1%B9%E7%9B%AE%E5%BD%93%E5%89%8D%E7%89%88%E6%9C%AC%E4%B8%AD%E4%BF%AE%E5%A4%8D%E4%B8%8A%E4%B8%AA%E7%89%88%E6%9C%AC%E6%B5%8B%E8%AF%95%E5%8F%8D%E9%A6%88-bug-%E7%9A%84%E6%97%B6%E6%9C%BA/</link>
      <pubDate>Thu, 08 May 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/23-%E9%A1%B9%E7%9B%AE%E5%BD%93%E5%89%8D%E7%89%88%E6%9C%AC%E4%B8%AD%E4%BF%AE%E5%A4%8D%E4%B8%8A%E4%B8%AA%E7%89%88%E6%9C%AC%E6%B5%8B%E8%AF%95%E5%8F%8D%E9%A6%88-bug-%E7%9A%84%E6%97%B6%E6%9C%BA/</guid>
      <description>&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;项目当前版本（假设为&lt;code&gt;1.0&lt;/code&gt;）开发完成之后，会提交给测试组进行测试，然后，开始进行下一个版本（假设为&lt;code&gt;2.0&lt;/code&gt;）的研发工作。&lt;/p&gt;
&lt;p&gt;但是，测试组测试周期可能要一两个月，期间会不断的反馈 &lt;code&gt;Bug&lt;/code&gt; 到系统里，等项目当前版本（&lt;code&gt;1.0&lt;/code&gt;） &lt;code&gt;Bug&lt;/code&gt; 修复完成之后，再进行下一轮的测试。&lt;/p&gt;
&lt;p&gt;这时，项目新的版本（&lt;code&gt;2.0&lt;/code&gt;）功能开发进行中，每个人都已经有自己的开发任务了，时间也排好了，应该怎么安排？&lt;/p&gt;
&lt;p&gt;还有，在 &lt;code&gt;A&lt;/code&gt; 功能模块上修复 &lt;code&gt;Bug&lt;/code&gt;，而同时又在 &lt;code&gt;A&lt;/code&gt; 功能模块上开发新的功能，代码合并可能会冲突等等问题怎么处理？&lt;/p&gt;
&lt;h1 id=&#34;2-权衡任务调整的利弊&#34;&gt;2. 权衡任务调整的利弊&lt;/h1&gt;
&lt;p&gt;因为测试反馈 &lt;code&gt;Bug&lt;/code&gt; 数量不是一个可控的事情，有时第一轮测试完成，都没几个 &lt;code&gt;Bug&lt;/code&gt;，有时第一轮测试就反馈好几十个 &lt;code&gt;Bug&lt;/code&gt;，完全可以衍生新的任务，评估个两三天去处理。&lt;/p&gt;
&lt;p&gt;所以，如果你打算，暂停或推迟当前版本（&lt;code&gt;2.0&lt;/code&gt;）的开发任务，而去执行修复上个版本（&lt;code&gt;1.0&lt;/code&gt;）的 &lt;code&gt;Bug&lt;/code&gt; 的任务，很有可能收益不大，因为可能都没有几个 &lt;code&gt;Bug&lt;/code&gt; 让你修复。&lt;/p&gt;
&lt;p&gt;但是，如果你完全对第一轮反馈的 &lt;code&gt;Bug&lt;/code&gt; 不管不顾，又会影响到测试组的测试进度。&lt;/p&gt;
&lt;h1 id=&#34;3-基于测试周期的任务调整&#34;&gt;3. 基于测试周期的任务调整&lt;/h1&gt;
&lt;p&gt;上面说的，虽然测试反馈 &lt;code&gt;Bug&lt;/code&gt; 的个数是不可控的，但庆幸的是，测试周期是明确的，比如第一轮具体是什么时间段，第二轮又是什么时间段，这些都是前期沟通好的，虽然偶有变数，但是大体上问题不大。&lt;/p&gt;
&lt;p&gt;在这个基础之下，项目负责人就要根据测试轮次结束的时间，对当前反馈的 &lt;code&gt;Bug&lt;/code&gt; 情况，进行任务上面的调整，比如第一轮测试反馈了 &lt;code&gt;50&lt;/code&gt; 个 &lt;code&gt;Bug&lt;/code&gt;，然后按功能模块划分清楚，以及哪些功能模块对应的负责人是谁，修复这些 &lt;code&gt;Bug&lt;/code&gt; 需要多少工作量，新增一条修复 &lt;code&gt;Bug&lt;/code&gt; 的任务在项目当前版本（&lt;code&gt;2.0&lt;/code&gt;）计划中。&lt;/p&gt;
&lt;h1 id=&#34;4-测试环节的漏洞&#34;&gt;4. 测试环节的漏洞&lt;/h1&gt;
&lt;p&gt;但是，如果 &lt;code&gt;Bug&lt;/code&gt; 特别多，花费了大量的时间，甚至影响到了当前版本（&lt;code&gt;2.0&lt;/code&gt;）的开发进度怎么办？&lt;/p&gt;
&lt;p&gt;这个时候，是否需要延长修复 &lt;code&gt;Bug&lt;/code&gt; 的任务呢？&lt;/p&gt;
&lt;p&gt;缩短开发的任务时间呢？&lt;/p&gt;
&lt;p&gt;加加班？&lt;/p&gt;
&lt;p&gt;这些方式可以解决这个问题，但是，治标不治本。&lt;/p&gt;
&lt;p&gt;因为在这个功能到测试组介入参与测试时，其实，已经有过三个环节，对功能进行测试了。&lt;/p&gt;
&lt;p&gt;一个是功能开发人员自测，编写测试用例，然后对开发的功能点一一测试。&lt;/p&gt;
&lt;p&gt;另一个是功能开发任务验收，这个验收的工作就是根据功能开发人员提供的测试用例，验收人自行跑一下这个测试用例，看下有没有什么问题。&lt;/p&gt;
&lt;p&gt;最后一个是项目负责人内测，就是项目当前版本（&lt;code&gt;1.0&lt;/code&gt;）结束，要给测试组提测之前，把全部功能都测试一遍。&lt;/p&gt;
&lt;p&gt;上面这三个环节，为什么不能发现和解决掉一些很明显的 &lt;code&gt;Bug&lt;/code&gt;，而一定要测试组测试时才发现？&lt;/p&gt;
&lt;h1 id=&#34;5-优化测试流程&#34;&gt;5. 优化测试流程&lt;/h1&gt;
&lt;p&gt;理想状态下，每一轮测试都不应反馈那么多 &lt;code&gt;Bug&lt;/code&gt; 的，然后需要排两三天的时间去处理的，通过一两天差不多了，甚至在开发当前功能时抽个一天的时间解决掉就行。&lt;/p&gt;
&lt;p&gt;所以，回答项目开发中应什么时候去修复测试反馈的 &lt;code&gt;Bug&lt;/code&gt; 这个问题，那就是做好下面的流程：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="1-前言">1. 前言</h1>
<p>项目当前版本（假设为<code>1.0</code>）开发完成之后，会提交给测试组进行测试，然后，开始进行下一个版本（假设为<code>2.0</code>）的研发工作。</p>
<p>但是，测试组测试周期可能要一两个月，期间会不断的反馈 <code>Bug</code> 到系统里，等项目当前版本（<code>1.0</code>） <code>Bug</code> 修复完成之后，再进行下一轮的测试。</p>
<p>这时，项目新的版本（<code>2.0</code>）功能开发进行中，每个人都已经有自己的开发任务了，时间也排好了，应该怎么安排？</p>
<p>还有，在 <code>A</code> 功能模块上修复 <code>Bug</code>，而同时又在 <code>A</code> 功能模块上开发新的功能，代码合并可能会冲突等等问题怎么处理？</p>
<h1 id="2-权衡任务调整的利弊">2. 权衡任务调整的利弊</h1>
<p>因为测试反馈 <code>Bug</code> 数量不是一个可控的事情，有时第一轮测试完成，都没几个 <code>Bug</code>，有时第一轮测试就反馈好几十个 <code>Bug</code>，完全可以衍生新的任务，评估个两三天去处理。</p>
<p>所以，如果你打算，暂停或推迟当前版本（<code>2.0</code>）的开发任务，而去执行修复上个版本（<code>1.0</code>）的 <code>Bug</code> 的任务，很有可能收益不大，因为可能都没有几个 <code>Bug</code> 让你修复。</p>
<p>但是，如果你完全对第一轮反馈的 <code>Bug</code> 不管不顾，又会影响到测试组的测试进度。</p>
<h1 id="3-基于测试周期的任务调整">3. 基于测试周期的任务调整</h1>
<p>上面说的，虽然测试反馈 <code>Bug</code> 的个数是不可控的，但庆幸的是，测试周期是明确的，比如第一轮具体是什么时间段，第二轮又是什么时间段，这些都是前期沟通好的，虽然偶有变数，但是大体上问题不大。</p>
<p>在这个基础之下，项目负责人就要根据测试轮次结束的时间，对当前反馈的 <code>Bug</code> 情况，进行任务上面的调整，比如第一轮测试反馈了 <code>50</code> 个 <code>Bug</code>，然后按功能模块划分清楚，以及哪些功能模块对应的负责人是谁，修复这些 <code>Bug</code> 需要多少工作量，新增一条修复 <code>Bug</code> 的任务在项目当前版本（<code>2.0</code>）计划中。</p>
<h1 id="4-测试环节的漏洞">4. 测试环节的漏洞</h1>
<p>但是，如果 <code>Bug</code> 特别多，花费了大量的时间，甚至影响到了当前版本（<code>2.0</code>）的开发进度怎么办？</p>
<p>这个时候，是否需要延长修复 <code>Bug</code> 的任务呢？</p>
<p>缩短开发的任务时间呢？</p>
<p>加加班？</p>
<p>这些方式可以解决这个问题，但是，治标不治本。</p>
<p>因为在这个功能到测试组介入参与测试时，其实，已经有过三个环节，对功能进行测试了。</p>
<p>一个是功能开发人员自测，编写测试用例，然后对开发的功能点一一测试。</p>
<p>另一个是功能开发任务验收，这个验收的工作就是根据功能开发人员提供的测试用例，验收人自行跑一下这个测试用例，看下有没有什么问题。</p>
<p>最后一个是项目负责人内测，就是项目当前版本（<code>1.0</code>）结束，要给测试组提测之前，把全部功能都测试一遍。</p>
<p>上面这三个环节，为什么不能发现和解决掉一些很明显的 <code>Bug</code>，而一定要测试组测试时才发现？</p>
<h1 id="5-优化测试流程">5. 优化测试流程</h1>
<p>理想状态下，每一轮测试都不应反馈那么多 <code>Bug</code> 的，然后需要排两三天的时间去处理的，通过一两天差不多了，甚至在开发当前功能时抽个一天的时间解决掉就行。</p>
<p>所以，回答项目开发中应什么时候去修复测试反馈的 <code>Bug</code> 这个问题，那就是做好下面的流程：</p>
<ol>
<li>功能开发人员自测</li>
<li>功能开发任务验收</li>
<li>项目负责人内测</li>
</ol>
<p>然后，等测试哪一天测试完成之后，评估一下反馈的 <code>Bug</code> 数量，补充一条修复 <code>Bug</code> 任务，同时，变更当前的开发任务时间。</p>
<p>理论上来说，这条修复 <code>Bug</code> 的任务时间也就一天左右，最多也就两天了，除非出现突发的不可控因素。</p>
<p><strong>如果反馈的 <code>Bug</code> 特别多，需要的修复时间也很长，意味着上面三个环节压根没有做到位。</strong></p>
<h1 id="6-代码合并问题的处理">6. 代码合并问题的处理</h1>
<p>这个问题，其实可以等版本 <code>1.0</code> 的测试全部通过，发布至线上环境之后，再把 <code>1.0</code> 的代码合并到 <code>2.0</code> 的分支（即当前的 `Dev 分支），解决掉冲突就可以了。</p>
<h1 id="7-整体流程">7. 整体流程</h1>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505081008638.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>22-怎么对反馈的 Bug 进行有效管理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/22-%E6%80%8E%E4%B9%88%E5%AF%B9%E5%8F%8D%E9%A6%88%E7%9A%84-bug-%E8%BF%9B%E8%A1%8C%E6%9C%89%E6%95%88%E7%AE%A1%E7%90%86/</link>
      <pubDate>Wed, 30 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/22-%E6%80%8E%E4%B9%88%E5%AF%B9%E5%8F%8D%E9%A6%88%E7%9A%84-bug-%E8%BF%9B%E8%A1%8C%E6%9C%89%E6%95%88%E7%AE%A1%E7%90%86/</guid>
      <description>&lt;p&gt;一个项目的 &lt;code&gt;Bug&lt;/code&gt; 来源是多方面的。有的是线上功能试用反馈，比如客户在使用平台功能时，发现了影响功能使用的 &lt;code&gt;Bug&lt;/code&gt;；有的是项目负责人验收任务时反馈的；还有的是测试人员反馈的。&lt;/p&gt;
&lt;p&gt;测试人员反馈的 &lt;code&gt;Bug&lt;/code&gt; 一般都记录在 &lt;code&gt;Bug&lt;/code&gt; 系统里进行管理，所以问题不大。发在沟通群里的，多个人看到了之后，会给功能负责人带来一定的约束力，通常问题也不大。&lt;/p&gt;
&lt;p&gt;最大的问题是那种私底下一对一沟通反馈的 &lt;code&gt;Bug&lt;/code&gt;。比如，项目负责人张三给项目成员李四发消息，反馈了一个功能上面的 &lt;code&gt;Bug&lt;/code&gt; ，李四说记下来了。&lt;/p&gt;
&lt;p&gt;如果李四解决了并反馈给张三，那还好；但如果李四不反馈，张三就不知道这个 &lt;code&gt;Bug&lt;/code&gt; 的状态了。除非张三主动去问，否则谁也不知道这个 &lt;code&gt;Bug&lt;/code&gt; 是否已经解决。&lt;/p&gt;
&lt;p&gt;写到这里，我不由得感叹，要做好一件事情，各方面的协作都要到位。**任何一个流程没有有效执行，都会导致后续的环节发生变化，并需及时提供相应的对策，从而使简单的问题复杂化。**所以，制定清晰的流程并传达到位，是多么的重要。&lt;/p&gt;
&lt;p&gt;首先，在推动从流程入手解决这个问题之前，要先分析一下：&lt;/p&gt;
&lt;p&gt;为什么反馈 &lt;code&gt;Bug&lt;/code&gt; 时要私底下一对一沟通呢？&lt;/p&gt;
&lt;p&gt;为什么不直接发到沟通群里呢？&lt;/p&gt;
&lt;p&gt;原因很简单，大家都是同事，低头不见抬头见。发现对方开发的功能出现了 &lt;code&gt;Bug&lt;/code&gt;，虽然不是什么大事，毕竟，谁都不能保证自己开发的功能，一个 &lt;code&gt;Bug&lt;/code&gt; 都没有。只是，发到项目沟通群里，当众指出别人的问题，不管对方心胸多么宽广，总会不高兴的，自然而然，都会觉得没必要做这种不讨好的事情，反正能解决掉这个 &lt;code&gt;Bug&lt;/code&gt; 就行，是否是私底下一对一沟通反馈，没有那么重要。&lt;/p&gt;
&lt;p&gt;我觉得换位思考，上面这样的原因是可以接受的，但是&lt;strong&gt;完全依赖人，而不是依赖流程，是不能彻底解决掉问题的。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;所以，我们可以这样规定：&lt;/p&gt;
&lt;p&gt;在 &lt;code&gt;Bug&lt;/code&gt; 系统上进行管理，为项目创建一个对应的版本。在这个版本的开发时间段内，遇到的所有问题，以及别人反馈的 &lt;code&gt;Bug&lt;/code&gt;，都记录在这个上面，而不是私下沟通。这样虽然是公开的，但是不去看就不会知道，不像在项目沟通群里，当众处刑。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504301641476.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;因为 &lt;code&gt;Bug&lt;/code&gt; 系统是和邮件关联的。比如你是项目负责人张三，在验收李四开发的一个功能时，发现了问题123，那么就在 &lt;code&gt;Bug&lt;/code&gt; 系统记录，并分配给李四。&lt;/p&gt;
&lt;p&gt;等李四解决掉 &lt;code&gt;Bug&lt;/code&gt; 之后，就修改这个 &lt;code&gt;Bug&lt;/code&gt; 的状态为 “已解决”，张三就知道 &lt;code&gt;Bug&lt;/code&gt; 已经解决了，然后再去跟进，这样就形成了闭环。&lt;/p&gt;
&lt;p&gt;那如果张三还是不把 &lt;code&gt;Bug&lt;/code&gt; 记录到 &lt;code&gt;Bug&lt;/code&gt; 系统，或者李四解决了 &lt;code&gt;Bug&lt;/code&gt; 但没有在 &lt;code&gt;Bug&lt;/code&gt; 系统上修改状态呢？&lt;/p&gt;
&lt;p&gt;那就需要及时介入沟通了，不能听之任之。&lt;strong&gt;抓而不紧，等于不抓&lt;/strong&gt;，出现问题要第一时间解决，表明你对这件事情很重视。&lt;/p&gt;
&lt;p&gt;否则，大家都觉得可有可无，慢慢就变成做做样子应付了事，那通过流程化解决对 &lt;code&gt;Bug&lt;/code&gt; 进行有效管理的初衷就无法达成了。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>一个项目的 <code>Bug</code> 来源是多方面的。有的是线上功能试用反馈，比如客户在使用平台功能时，发现了影响功能使用的 <code>Bug</code>；有的是项目负责人验收任务时反馈的；还有的是测试人员反馈的。</p>
<p>测试人员反馈的 <code>Bug</code> 一般都记录在 <code>Bug</code> 系统里进行管理，所以问题不大。发在沟通群里的，多个人看到了之后，会给功能负责人带来一定的约束力，通常问题也不大。</p>
<p>最大的问题是那种私底下一对一沟通反馈的 <code>Bug</code>。比如，项目负责人张三给项目成员李四发消息，反馈了一个功能上面的 <code>Bug</code> ，李四说记下来了。</p>
<p>如果李四解决了并反馈给张三，那还好；但如果李四不反馈，张三就不知道这个 <code>Bug</code> 的状态了。除非张三主动去问，否则谁也不知道这个 <code>Bug</code> 是否已经解决。</p>
<p>写到这里，我不由得感叹，要做好一件事情，各方面的协作都要到位。**任何一个流程没有有效执行，都会导致后续的环节发生变化，并需及时提供相应的对策，从而使简单的问题复杂化。**所以，制定清晰的流程并传达到位，是多么的重要。</p>
<p>首先，在推动从流程入手解决这个问题之前，要先分析一下：</p>
<p>为什么反馈 <code>Bug</code> 时要私底下一对一沟通呢？</p>
<p>为什么不直接发到沟通群里呢？</p>
<p>原因很简单，大家都是同事，低头不见抬头见。发现对方开发的功能出现了 <code>Bug</code>，虽然不是什么大事，毕竟，谁都不能保证自己开发的功能，一个 <code>Bug</code> 都没有。只是，发到项目沟通群里，当众指出别人的问题，不管对方心胸多么宽广，总会不高兴的，自然而然，都会觉得没必要做这种不讨好的事情，反正能解决掉这个 <code>Bug</code> 就行，是否是私底下一对一沟通反馈，没有那么重要。</p>
<p>我觉得换位思考，上面这样的原因是可以接受的，但是<strong>完全依赖人，而不是依赖流程，是不能彻底解决掉问题的。</strong></p>
<p>所以，我们可以这样规定：</p>
<p>在 <code>Bug</code> 系统上进行管理，为项目创建一个对应的版本。在这个版本的开发时间段内，遇到的所有问题，以及别人反馈的 <code>Bug</code>，都记录在这个上面，而不是私下沟通。这样虽然是公开的，但是不去看就不会知道，不像在项目沟通群里，当众处刑。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504301641476.png"></p>
<p>因为 <code>Bug</code> 系统是和邮件关联的。比如你是项目负责人张三，在验收李四开发的一个功能时，发现了问题123，那么就在 <code>Bug</code> 系统记录，并分配给李四。</p>
<p>等李四解决掉 <code>Bug</code> 之后，就修改这个 <code>Bug</code> 的状态为 “已解决”，张三就知道 <code>Bug</code> 已经解决了，然后再去跟进，这样就形成了闭环。</p>
<p>那如果张三还是不把 <code>Bug</code> 记录到 <code>Bug</code> 系统，或者李四解决了 <code>Bug</code> 但没有在 <code>Bug</code> 系统上修改状态呢？</p>
<p>那就需要及时介入沟通了，不能听之任之。<strong>抓而不紧，等于不抓</strong>，出现问题要第一时间解决，表明你对这件事情很重视。</p>
<p>否则，大家都觉得可有可无，慢慢就变成做做样子应付了事，那通过流程化解决对 <code>Bug</code> 进行有效管理的初衷就无法达成了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>21-项目里程碑应有复盘会议</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/21-%E9%A1%B9%E7%9B%AE%E9%87%8C%E7%A8%8B%E7%A2%91%E5%BA%94%E6%9C%89%E5%A4%8D%E7%9B%98%E4%BC%9A%E8%AE%AE/</link>
      <pubDate>Mon, 28 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/21-%E9%A1%B9%E7%9B%AE%E9%87%8C%E7%A8%8B%E7%A2%91%E5%BA%94%E6%9C%89%E5%A4%8D%E7%9B%98%E4%BC%9A%E8%AE%AE/</guid>
      <description>&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;复盘会议通常是在项目某个版本完成开发并正式上线之后才召开的，但复盘工作其实并不是等到最后才开始的。项目负责人应该在项目前期就开始着手准备，在项目推进的过程中，持续记录各种各样的问题，这样在会议上就能有更充分的内容来进行讨论和总结经验。&lt;/p&gt;
&lt;p&gt;当项目负责人要召开项目复盘会议的时候，需要把项目相关人员都通知到位，比如产品、后端、前端和测试等等。然后预订一个会议室，在群里发布会议通知，到时候按计划如期进行。&lt;/p&gt;
&lt;p&gt;这个复盘会议对于项目负责人来说，一方面能够吸取项目管理方面的经验，另一方面也有助于提升项目团队的凝聚力。&lt;/p&gt;
&lt;p&gt;在会议上，把项目开发过程中哪些是做得好的，哪些是做得不好的，依次都列出来，让大家一起讨论一下，有一个总结与反思的过程，也是一个一起分享成果的过程。&lt;/p&gt;
&lt;p&gt;对于做得好的地方，那肯定是要表扬的；对于做得不好的地方，大家就再接再厉。&lt;/p&gt;
&lt;p&gt;复盘会议上讨论的内容，基本上涵盖了项目版本周期的方方面面，目前主要总结了以下几点。&lt;/p&gt;
&lt;h1 id=&#34;2-任务完成情况&#34;&gt;2. 任务完成情况&lt;/h1&gt;
&lt;p&gt;这个版本的项目任务计划制定得是否合理？哪些任务有多次变更的？已过期的任务具体原因又是什么？&lt;/p&gt;
&lt;h1 id=&#34;3-测试反馈bug问题&#34;&gt;3. 测试反馈BUG问题&lt;/h1&gt;
&lt;p&gt;把这个版本测试提出的 &lt;code&gt;Bug&lt;/code&gt; 整理和归纳一下，分析一下具体的情况。哪些 &lt;code&gt;Bug&lt;/code&gt; 是完全可以通过提前规划来避免的呢？比如输入框的校验，基本都没有，功能开发的时候，只是保证能用就行了，功能的边界完全没有自测。类似这种问题，就可以在会上进行讨论，然后达成共识，加入到开发规范里，后续就可以规避类似的问题了。&lt;/p&gt;
&lt;h1 id=&#34;4-会议记录&#34;&gt;4. 会议记录&lt;/h1&gt;
&lt;p&gt;我们每次开会都有会议记录文档，然后会把反馈的问题都记录下来。这些文档在复盘的时候就会起到作用，可以从中吸取经验。看看有哪些问题是第一次出现的，那有没有对策可以避免再次出现呢？这些都是可以在复盘阶段解决的。&lt;/p&gt;
&lt;h1 id=&#34;5-技术笔记&#34;&gt;5. 技术笔记&lt;/h1&gt;
&lt;p&gt;技术笔记是开发过程中对功能难点进行总结的文档。遇到哪些功能解决不了的？后来又是怎么解决的？都可以在复盘会议上进行分享。&lt;/p&gt;
&lt;h1 id=&#34;6-群内反馈的问题&#34;&gt;6. 群内反馈的问题&lt;/h1&gt;
&lt;p&gt;群里反馈的问题可不止是项目讨论群里的，还有其他客户群里的。客户反馈了哪些问题，又提出了哪些需求？后续我们的工作要怎么规划？&lt;/p&gt;
&lt;h1 id=&#34;7-总结&#34;&gt;7. 总结&lt;/h1&gt;
&lt;p&gt;&lt;strong&gt;复盘的目的不是对过去的问责，而是对过去的反思和总结，并着眼于未来如何改善。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;项目这个版本的功能已经完成了，事已至此，没必要深究谁没做好，然后让对方有心理负担。我们的目的一向是解决问题，这次没做好，下次做好不就行了，谁都有没做好的时候。&lt;/p&gt;
&lt;p&gt;更重要的是，今天比昨天做好一点。更重要的是，着眼于未来，这个项目下一个版本能不能比上个版本做得更好一点？&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="1-前言">1. 前言</h1>
<p>复盘会议通常是在项目某个版本完成开发并正式上线之后才召开的，但复盘工作其实并不是等到最后才开始的。项目负责人应该在项目前期就开始着手准备，在项目推进的过程中，持续记录各种各样的问题，这样在会议上就能有更充分的内容来进行讨论和总结经验。</p>
<p>当项目负责人要召开项目复盘会议的时候，需要把项目相关人员都通知到位，比如产品、后端、前端和测试等等。然后预订一个会议室，在群里发布会议通知，到时候按计划如期进行。</p>
<p>这个复盘会议对于项目负责人来说，一方面能够吸取项目管理方面的经验，另一方面也有助于提升项目团队的凝聚力。</p>
<p>在会议上，把项目开发过程中哪些是做得好的，哪些是做得不好的，依次都列出来，让大家一起讨论一下，有一个总结与反思的过程，也是一个一起分享成果的过程。</p>
<p>对于做得好的地方，那肯定是要表扬的；对于做得不好的地方，大家就再接再厉。</p>
<p>复盘会议上讨论的内容，基本上涵盖了项目版本周期的方方面面，目前主要总结了以下几点。</p>
<h1 id="2-任务完成情况">2. 任务完成情况</h1>
<p>这个版本的项目任务计划制定得是否合理？哪些任务有多次变更的？已过期的任务具体原因又是什么？</p>
<h1 id="3-测试反馈bug问题">3. 测试反馈BUG问题</h1>
<p>把这个版本测试提出的 <code>Bug</code> 整理和归纳一下，分析一下具体的情况。哪些 <code>Bug</code> 是完全可以通过提前规划来避免的呢？比如输入框的校验，基本都没有，功能开发的时候，只是保证能用就行了，功能的边界完全没有自测。类似这种问题，就可以在会上进行讨论，然后达成共识，加入到开发规范里，后续就可以规避类似的问题了。</p>
<h1 id="4-会议记录">4. 会议记录</h1>
<p>我们每次开会都有会议记录文档，然后会把反馈的问题都记录下来。这些文档在复盘的时候就会起到作用，可以从中吸取经验。看看有哪些问题是第一次出现的，那有没有对策可以避免再次出现呢？这些都是可以在复盘阶段解决的。</p>
<h1 id="5-技术笔记">5. 技术笔记</h1>
<p>技术笔记是开发过程中对功能难点进行总结的文档。遇到哪些功能解决不了的？后来又是怎么解决的？都可以在复盘会议上进行分享。</p>
<h1 id="6-群内反馈的问题">6. 群内反馈的问题</h1>
<p>群里反馈的问题可不止是项目讨论群里的，还有其他客户群里的。客户反馈了哪些问题，又提出了哪些需求？后续我们的工作要怎么规划？</p>
<h1 id="7-总结">7. 总结</h1>
<p><strong>复盘的目的不是对过去的问责，而是对过去的反思和总结，并着眼于未来如何改善。</strong></p>
<p>项目这个版本的功能已经完成了，事已至此，没必要深究谁没做好，然后让对方有心理负担。我们的目的一向是解决问题，这次没做好，下次做好不就行了，谁都有没做好的时候。</p>
<p>更重要的是，今天比昨天做好一点。更重要的是，着眼于未来，这个项目下一个版本能不能比上个版本做得更好一点？</p>
]]></content:encoded>
    </item>
    <item>
      <title>20-项目进度会议时间过长的问题</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/20-%E9%A1%B9%E7%9B%AE%E8%BF%9B%E5%BA%A6%E4%BC%9A%E8%AE%AE%E6%97%B6%E9%97%B4%E8%BF%87%E9%95%BF%E7%9A%84%E9%97%AE%E9%A2%98/</link>
      <pubDate>Sun, 27 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/20-%E9%A1%B9%E7%9B%AE%E8%BF%9B%E5%BA%A6%E4%BC%9A%E8%AE%AE%E6%97%B6%E9%97%B4%E8%BF%87%E9%95%BF%E7%9A%84%E9%97%AE%E9%A2%98/</guid>
      <description>&lt;h1 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h1&gt;
&lt;p&gt;我们统一每周周二开项目进度会议，每个项目的情况都不一样，有些问题就是需要讨论很久，所以时间是无法评估的。&lt;/p&gt;
&lt;p&gt;我们不可能要求什么时间内一定要开完项目进度会议，只能说项目负责人需要知道项目进度会议的流程，并且逐渐按照流程执行。&lt;/p&gt;
&lt;p&gt;一般情况下，每周开一次项目进度会议，任务通常不会太多，通常一次会议所需时间应该不会太长，但是我们把项目会议流程梳理之后就会发现，时间是大大超出我们预期的，如下所示：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;项目进度情况（20 分钟）&lt;/li&gt;
&lt;li&gt;问题反馈讨论（20 分钟）&lt;/li&gt;
&lt;li&gt;任务验收
&lt;ul&gt;
&lt;li&gt;功能演示（20 分钟）&lt;/li&gt;
&lt;li&gt;代码抽查（20 分钟）&lt;/li&gt;
&lt;li&gt;文档查看（10 分钟）&lt;/li&gt;
&lt;li&gt;Bug 修复情况（10 分钟）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;后续工作安排
&lt;ul&gt;
&lt;li&gt;任务安排（20 分钟）&lt;/li&gt;
&lt;li&gt;加班情况（10 分钟）&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282158811.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;项目人较多时，就需要 &lt;code&gt;2&lt;/code&gt; 个小时左右；项目人较少时，也需要 &lt;code&gt;1&lt;/code&gt; 个小时左右。我觉得项目会议时间在 &lt;code&gt;1 - 2&lt;/code&gt; 个小时之内是可以接受的，但是开到 3 个小时以上就有点问题了。&lt;/p&gt;
&lt;p&gt;要解决问题，最终还是要回到问题本身。项目进度会议时间过长，你的诉求到底是什么？最要解决的本质问题是什么？难道真的是项目时间过长吗？&lt;/p&gt;
&lt;p&gt;那我直接规定每次开会不能超过某个时长就好了，没必要在这里纠结那么多。&lt;/p&gt;
&lt;p&gt;所以说，&lt;strong&gt;本质的问题不在项目会议时间过长，而在于这个项目进度会议的时间是否产生了价值，是否有必要。&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;那我们要清楚，到底是哪些问题，容易导致项目进度会议时间拉长呢？&lt;/p&gt;
&lt;p&gt;我想了一下，可能是这三种情况。&lt;/p&gt;
&lt;h1 id=&#34;2-没有在会前准备解决方案&#34;&gt;2. 没有在会前准备解决方案&lt;/h1&gt;
&lt;p&gt;有些问题没有在会前自己捋一遍，然后根据自己研究的结果，给出多个解决方案，并整理到文档中，然后发到项目讨论群里，而是自己闷头在研究，简单在脑里想了下，觉得想明白了，等到项目进度会议上再深入沟通。&lt;/p&gt;
&lt;p&gt;在项目进度会议上，没有什么文档，大家就一起参与讨论了，只是口头沟通，然后七嘴八舌的，说什么都有，这样行不行，那样行不行？&lt;/p&gt;
&lt;p&gt;讨论没有任何依据，只是凭感觉，反正你一句我一句，再加上一些闲话，最终浪费了很多时间。&lt;/p&gt;
&lt;p&gt;正确的做法应该是，在会前要把自己研究或者想到的解决方案，整理到文档中，要列举至少两三个方案，并把每个方案的优说明缺点清楚，最后在总结一栏，把自己推荐的方案标明清楚，并说明你选择该方案的原因。&lt;/p&gt;
&lt;p&gt;当然你可能会说，有些难题是在会上反馈出来的，哪有时间去准备解决方案文档，很多都是靠沟通交流得出的。&lt;/p&gt;
&lt;p&gt;如果是这种情况，那么可以简单沟通一下，然后回去整理好解决方案文档，发到项目讨论群里，然后叫上相关人员在座位上过一下，然后把最终结论补上文档即可。&lt;/p&gt;
&lt;h1 id=&#34;3-无关话题太多以及范围过大&#34;&gt;3. 无关话题太多以及范围过大&lt;/h1&gt;
&lt;p&gt;有时在项目进度例会上，很多时候沟通是没有依据的，也就是没有围绕项目当前的情况进行，总是一连串旁枝末节的话题，一个接一个没完没了。&lt;/p&gt;
&lt;p&gt;你说这些话题有必要讨论吗？&lt;/p&gt;
&lt;p&gt;当然有的，但是要看当前项目的情况和时机。比如有些规划是大半年以后的，有些甚至是几年后都不一定要做的，这些话题进行深入沟通可以增长个人的知识面，但是在当前没有什么意义，完全可以在私底下去了解。&lt;/p&gt;
&lt;p&gt;如果觉得很有用处，可以在了解之后，叫上几个人在座位上探讨一番，而不是在项目进度会议上。&lt;/p&gt;
&lt;p&gt;比如讨论 &lt;code&gt;App&lt;/code&gt; 的功能，说着说着，又说到 &lt;code&gt;Flutter&lt;/code&gt; 最近好像不太平，&lt;code&gt;Flutter&lt;/code&gt; 组又裁员了，然后还在 &lt;code&gt;GitHub&lt;/code&gt; 上面搞了一个社区的分支，单独维护，然后说不计划合并到 &lt;code&gt;Google&lt;/code&gt; 的主分支上了，然后又讨论 &lt;code&gt;Flutter&lt;/code&gt; 是不是要完蛋了？那我们后续开发 &lt;code&gt;App&lt;/code&gt; 要换不要技术方案？那老项目要怎么维护？&lt;code&gt;Android&lt;/code&gt;、&lt;code&gt;iOS&lt;/code&gt;、鸿蒙、微信小程序这些跨平台要怎么解决等等。&lt;/p&gt;
&lt;p&gt;完全没完没了，这些讨论当然有意义，但是，在项目进度例会上进行讨论，真的太不划算了。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="1-前言">1. 前言</h1>
<p>我们统一每周周二开项目进度会议，每个项目的情况都不一样，有些问题就是需要讨论很久，所以时间是无法评估的。</p>
<p>我们不可能要求什么时间内一定要开完项目进度会议，只能说项目负责人需要知道项目进度会议的流程，并且逐渐按照流程执行。</p>
<p>一般情况下，每周开一次项目进度会议，任务通常不会太多，通常一次会议所需时间应该不会太长，但是我们把项目会议流程梳理之后就会发现，时间是大大超出我们预期的，如下所示：</p>
<ul>
<li>项目进度情况（20 分钟）</li>
<li>问题反馈讨论（20 分钟）</li>
<li>任务验收
<ul>
<li>功能演示（20 分钟）</li>
<li>代码抽查（20 分钟）</li>
<li>文档查看（10 分钟）</li>
<li>Bug 修复情况（10 分钟）</li>
</ul>
</li>
<li>后续工作安排
<ul>
<li>任务安排（20 分钟）</li>
<li>加班情况（10 分钟）</li>
</ul>
</li>
</ul>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282158811.png"></p>
<p>项目人较多时，就需要 <code>2</code> 个小时左右；项目人较少时，也需要 <code>1</code> 个小时左右。我觉得项目会议时间在 <code>1 - 2</code> 个小时之内是可以接受的，但是开到 3 个小时以上就有点问题了。</p>
<p>要解决问题，最终还是要回到问题本身。项目进度会议时间过长，你的诉求到底是什么？最要解决的本质问题是什么？难道真的是项目时间过长吗？</p>
<p>那我直接规定每次开会不能超过某个时长就好了，没必要在这里纠结那么多。</p>
<p>所以说，<strong>本质的问题不在项目会议时间过长，而在于这个项目进度会议的时间是否产生了价值，是否有必要。</strong></p>
<p>那我们要清楚，到底是哪些问题，容易导致项目进度会议时间拉长呢？</p>
<p>我想了一下，可能是这三种情况。</p>
<h1 id="2-没有在会前准备解决方案">2. 没有在会前准备解决方案</h1>
<p>有些问题没有在会前自己捋一遍，然后根据自己研究的结果，给出多个解决方案，并整理到文档中，然后发到项目讨论群里，而是自己闷头在研究，简单在脑里想了下，觉得想明白了，等到项目进度会议上再深入沟通。</p>
<p>在项目进度会议上，没有什么文档，大家就一起参与讨论了，只是口头沟通，然后七嘴八舌的，说什么都有，这样行不行，那样行不行？</p>
<p>讨论没有任何依据，只是凭感觉，反正你一句我一句，再加上一些闲话，最终浪费了很多时间。</p>
<p>正确的做法应该是，在会前要把自己研究或者想到的解决方案，整理到文档中，要列举至少两三个方案，并把每个方案的优说明缺点清楚，最后在总结一栏，把自己推荐的方案标明清楚，并说明你选择该方案的原因。</p>
<p>当然你可能会说，有些难题是在会上反馈出来的，哪有时间去准备解决方案文档，很多都是靠沟通交流得出的。</p>
<p>如果是这种情况，那么可以简单沟通一下，然后回去整理好解决方案文档，发到项目讨论群里，然后叫上相关人员在座位上过一下，然后把最终结论补上文档即可。</p>
<h1 id="3-无关话题太多以及范围过大">3. 无关话题太多以及范围过大</h1>
<p>有时在项目进度例会上，很多时候沟通是没有依据的，也就是没有围绕项目当前的情况进行，总是一连串旁枝末节的话题，一个接一个没完没了。</p>
<p>你说这些话题有必要讨论吗？</p>
<p>当然有的，但是要看当前项目的情况和时机。比如有些规划是大半年以后的，有些甚至是几年后都不一定要做的，这些话题进行深入沟通可以增长个人的知识面，但是在当前没有什么意义，完全可以在私底下去了解。</p>
<p>如果觉得很有用处，可以在了解之后，叫上几个人在座位上探讨一番，而不是在项目进度会议上。</p>
<p>比如讨论 <code>App</code> 的功能，说着说着，又说到 <code>Flutter</code> 最近好像不太平，<code>Flutter</code> 组又裁员了，然后还在 <code>GitHub</code> 上面搞了一个社区的分支，单独维护，然后说不计划合并到 <code>Google</code> 的主分支上了，然后又讨论 <code>Flutter</code> 是不是要完蛋了？那我们后续开发 <code>App</code> 要换不要技术方案？那老项目要怎么维护？<code>Android</code>、<code>iOS</code>、鸿蒙、微信小程序这些跨平台要怎么解决等等。</p>
<p>完全没完没了，这些讨论当然有意义，但是，在项目进度例会上进行讨论，真的太不划算了。</p>
<p>正确的做法应该是，紧跟当前项目核心问题进行讨论。比如上面的例子，<code>App</code> 的某个功能，在使用或实现上是否出现了问题，以及怎么解决这些问题？不要把话题扩散太广，避免违背了这个会议的初衷。</p>
<p>这个<strong>会议的目的是要解决项目当前的问题</strong>，不是新闻热点讨论会议。</p>
<h1 id="4-会议主持人没有做好把控">4. 会议主持人没有做好把控</h1>
<p>上面的问题，虽然源头都是会议前没有准备问题的解决方案文档、无关话题太多以及范围过大，但是，真正可以解决掉这个问题的，当然还是要回归到项目负责人对会议开展的把控上。</p>
<p>一看到有任何苗头，就可以立马打断，把话题拉回项目自身，而不是放任不管，浪费白白太多时间。</p>
<p>项目进度例会，我们担心有些人不说，但又怕有些人说太多，所以还是要灵活把控这个尺度，<strong>鼓励少说的多说，控制说多的少说</strong>，但目的是一致的，为了能及时暴露项目当前存在的问题，以及讨论出解决这些问题的方案。</p>
<p>至于无关紧要之事，可以会后私下里沟通。</p>
<h1 id="5-总结">5. 总结</h1>
<p>项目进度会议时间过长的问题，最终还是要回归到这个问题的诉求上，也就是说，如果我们能够做到会议前准备好要讨论的问题的解决方案文档、减少无关话题、项目负责人做好会议进行的把控工作，那么应该是可以解决这个问题的。</p>
]]></content:encoded>
    </item>
    <item>
      <title>19-过进度方式二：项目成员依次汇报任务进度并演示功能</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/19-%E8%BF%87%E8%BF%9B%E5%BA%A6%E6%96%B9%E5%BC%8F%E4%BA%8C%E9%A1%B9%E7%9B%AE%E6%88%90%E5%91%98%E4%BE%9D%E6%AC%A1%E8%AF%B4%E6%98%8E%E5%92%8C%E6%BC%94%E7%A4%BA%E4%BB%BB%E5%8A%A1%E5%AE%8C%E6%88%90%E6%83%85%E5%86%B5/</link>
      <pubDate>Sat, 26 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/19-%E8%BF%87%E8%BF%9B%E5%BA%A6%E6%96%B9%E5%BC%8F%E4%BA%8C%E9%A1%B9%E7%9B%AE%E6%88%90%E5%91%98%E4%BE%9D%E6%AC%A1%E8%AF%B4%E6%98%8E%E5%92%8C%E6%BC%94%E7%A4%BA%E4%BB%BB%E5%8A%A1%E5%AE%8C%E6%88%90%E6%83%85%E5%86%B5/</guid>
      <description>&lt;p&gt;这几年项目进度例会的模式，都是按照上篇《18-过进度方式一：项目负责人进行全部功能演示》的方式进行的，其目的也在上篇说明清楚了，都是从项目负责人的能力提升方面考虑的，其会议流程是这样的：&lt;/p&gt;
&lt;p&gt;第一步，项目负责人把当前项目情况进行汇报，然后重点问题说一下。&lt;/p&gt;
&lt;p&gt;第二步，每个项目成员在自己的座位上，说一下上周做的事情，下周计划做什么，遇到什么问题。&lt;/p&gt;
&lt;p&gt;第三步，散会。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504251021563.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;但是，不同的阶段关注的重点不一样。&lt;/p&gt;
&lt;p&gt;在项目进度例会中，对当前所做的工作进行验收，是很重要的一环，这些也在《16-项目的任务质量如何保证》中，把前因后果也说明清楚了。&lt;/p&gt;
&lt;p&gt;本篇主要是探讨让项目负责人把全部功能进行演示和让项目成员依次汇报任务进度和演示，这两种方式不同之处在哪里？&lt;/p&gt;
&lt;p&gt;首先，我们要知道，参加会议的人，什么样的心态都有。有的人现在遇到了很多问题，亟需在会议上反馈出来，然后帮助他解决这些问题；有的人觉得我现在忙得很，又天天开会，真烦，能不能少开一点、少说一点，让我赶紧忙完，要不然就得加班了；有的人觉得真好啊，最好开一整天，又可以摸鱼了，等等。在这些心态之下，各人的反应也会不一样。但更深层的一点是，多一事不如少一事，你要让他主动去说，那太难了，你问了才会说，不问就不说，甚至你问了，也可能因为性格等各方面的原因，都不太愿意说太多。加上大部分人都在会上刷手机，不会有心思听那么多的。&lt;/p&gt;
&lt;p&gt;在这样的情况之下，让项目负责人把全部任务进度进行汇报并演示可验收的功能，很难覆盖到其他项目成员。他们本身不会觉得和这个会议有什么太大的关系，反正就是听一听，看一看手机，到了时间散会就完事儿。也许有些人可能有问题要反馈，但是他不会主动去提。&lt;/p&gt;
&lt;p&gt;所以，项目进度例会的整体流程就要进行调整：&lt;/p&gt;
&lt;p&gt;第一步，项目负责人要对项目当前的情况进行汇报，比如延期风险高不高？有什么重点问题？说一下，同步下信息，以及后续要注意哪些方面，等等。&lt;/p&gt;
&lt;p&gt;第二步，就是要项目成员依次到前面来，而不是在自己座位上。把自己上周完成了哪些任务说一下，哪些任务进度怎么样也说一下，然后是演示一下自己开发的功能或者一些技术文档，最后就是遇到了哪些问题？需要现在就讨论和解决，然后就是下周计划做什么？把这些信息都记录在会议记录文档上面。&lt;/p&gt;
&lt;p&gt;一方面可以减少项目负责人需要全面深入细节的工作；另一方面，可以侧面给项目成员一点压力。因为每次项目进度例会都要说一下工作内容，你如果上周完全都不用心，那么工作自然没什么产出，这样你总不能胡编乱造吧。&lt;/p&gt;
&lt;p&gt;冥冥之中，不需要谁整天盯着你工作，你自己清楚，无形之中，就会有约束力，也减少了项目负责人的管理工作。&lt;/p&gt;
&lt;p&gt;第三步，项目负责人把项目成员过进度中反馈的待解决问题，都记录到会议记录文档里面。下次项目进度例会，会看下待解决的问题是否已经解决。&lt;/p&gt;
&lt;p&gt;第四步，项目负责人要根据当前项目进度情况，再次强调要重点关注的点，然后评估下是否需要加班。如有需要，进行加班安排。&lt;/p&gt;
&lt;p&gt;第五步，散会。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504251025116.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;相信按上面这个流程，可以有效解决项目成员在会议上没有深入参与的问题，并且能起到日常工作的一些约束，加强自我管理的意识，达成期望的工作目标。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>这几年项目进度例会的模式，都是按照上篇《18-过进度方式一：项目负责人进行全部功能演示》的方式进行的，其目的也在上篇说明清楚了，都是从项目负责人的能力提升方面考虑的，其会议流程是这样的：</p>
<p>第一步，项目负责人把当前项目情况进行汇报，然后重点问题说一下。</p>
<p>第二步，每个项目成员在自己的座位上，说一下上周做的事情，下周计划做什么，遇到什么问题。</p>
<p>第三步，散会。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504251021563.png"></p>
<p>但是，不同的阶段关注的重点不一样。</p>
<p>在项目进度例会中，对当前所做的工作进行验收，是很重要的一环，这些也在《16-项目的任务质量如何保证》中，把前因后果也说明清楚了。</p>
<p>本篇主要是探讨让项目负责人把全部功能进行演示和让项目成员依次汇报任务进度和演示，这两种方式不同之处在哪里？</p>
<p>首先，我们要知道，参加会议的人，什么样的心态都有。有的人现在遇到了很多问题，亟需在会议上反馈出来，然后帮助他解决这些问题；有的人觉得我现在忙得很，又天天开会，真烦，能不能少开一点、少说一点，让我赶紧忙完，要不然就得加班了；有的人觉得真好啊，最好开一整天，又可以摸鱼了，等等。在这些心态之下，各人的反应也会不一样。但更深层的一点是，多一事不如少一事，你要让他主动去说，那太难了，你问了才会说，不问就不说，甚至你问了，也可能因为性格等各方面的原因，都不太愿意说太多。加上大部分人都在会上刷手机，不会有心思听那么多的。</p>
<p>在这样的情况之下，让项目负责人把全部任务进度进行汇报并演示可验收的功能，很难覆盖到其他项目成员。他们本身不会觉得和这个会议有什么太大的关系，反正就是听一听，看一看手机，到了时间散会就完事儿。也许有些人可能有问题要反馈，但是他不会主动去提。</p>
<p>所以，项目进度例会的整体流程就要进行调整：</p>
<p>第一步，项目负责人要对项目当前的情况进行汇报，比如延期风险高不高？有什么重点问题？说一下，同步下信息，以及后续要注意哪些方面，等等。</p>
<p>第二步，就是要项目成员依次到前面来，而不是在自己座位上。把自己上周完成了哪些任务说一下，哪些任务进度怎么样也说一下，然后是演示一下自己开发的功能或者一些技术文档，最后就是遇到了哪些问题？需要现在就讨论和解决，然后就是下周计划做什么？把这些信息都记录在会议记录文档上面。</p>
<p>一方面可以减少项目负责人需要全面深入细节的工作；另一方面，可以侧面给项目成员一点压力。因为每次项目进度例会都要说一下工作内容，你如果上周完全都不用心，那么工作自然没什么产出，这样你总不能胡编乱造吧。</p>
<p>冥冥之中，不需要谁整天盯着你工作，你自己清楚，无形之中，就会有约束力，也减少了项目负责人的管理工作。</p>
<p>第三步，项目负责人把项目成员过进度中反馈的待解决问题，都记录到会议记录文档里面。下次项目进度例会，会看下待解决的问题是否已经解决。</p>
<p>第四步，项目负责人要根据当前项目进度情况，再次强调要重点关注的点，然后评估下是否需要加班。如有需要，进行加班安排。</p>
<p>第五步，散会。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504251025116.png"></p>
<p>相信按上面这个流程，可以有效解决项目成员在会议上没有深入参与的问题，并且能起到日常工作的一些约束，加强自我管理的意识，达成期望的工作目标。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 49</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-49/</link>
      <pubDate>Wed, 23 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-49/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/convert-date-to-binary/&#34;&gt;3280. 将日期转换为二进制表示&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;date&lt;/code&gt;，它的格式为 &lt;code&gt;yyyy-mm-dd&lt;/code&gt;，表示一个公历日期。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;date&lt;/code&gt; 可以重写为二进制表示，只需要将年、月、日分别转换为对应的二进制表示（不带前导零）并遵循 &lt;code&gt;year-month-day&lt;/code&gt; 的格式。&lt;/p&gt;
&lt;p&gt;返回 &lt;code&gt;date&lt;/code&gt; 的 &lt;strong&gt;二进制&lt;/strong&gt; 表示。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;date&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;2080-02-29&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;100000100000-10-11101&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;mi&#34;&gt;100000100000&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11101&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;分别是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2080&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;02&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;29&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的二进制表示&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;convertDateToBinary&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;date&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;year&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;month&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;day&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;date&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;-&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;yearBinary&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;parseInt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;year&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;toString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;monthBinary&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;parseInt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;month&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;toString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dayBinary&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;parseInt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;day&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;toString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;sb&#34;&gt;`&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;${&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;yearBinary&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;}&lt;/span&gt;&lt;span class=&#34;sb&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;${&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;monthBinary&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;}&lt;/span&gt;&lt;span class=&#34;sb&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;${&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;dayBinary&lt;/span&gt;&lt;span class=&#34;si&#34;&gt;}&lt;/span&gt;&lt;span class=&#34;sb&#34;&gt;`&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;将日期格式的字符串拆分为年、月、日三个部分。&lt;/li&gt;
&lt;li&gt;利用 &lt;code&gt;Number.prototype.toString()&lt;/code&gt; 方法中基数的特性，将数字转换为二进制字符串。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2504/250414-water-purification.html&#34;&gt;Scientists discover new water purification microbes - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;科学家们在我们脚下的地球中发现了一种以前未知的微生物。密歇根州立大学的研究人员一直在探索地球表面下方和上方的一个区域，称为临界区。这个区域对于提供维持生命的条件至关重要。研究人员将这些微生物称为 CSP1-3。微生物可能是净化水过程的关键部分。微生物学家 James Tiedje 说，虽然土壤层负责雨水的大部分过滤，但 CSP1-3 也是必不可少的。他说：“CSP1-3 是清理土壤表层的清道夫。他们的工作是净化我们的饮用水。&lt;/p&gt;
&lt;p&gt;Tiedje 博士和他的团队专注于生活在我们脚下 200 米深处土壤中的微生物。他说，CSP1-3 微生物可以去除供水中的有害污染物和碎屑。他现在想在他的实验室中培养 CSP1-3，以了解更多关于它们的特性。他认为它们可以用来清理土壤中的污染。他说：“我们不知道它们代谢顽固污染物的能力，如果我们能了解这一点，我们就可以帮助解决地球上最紧迫的问题之一。scitechdaily.com 网站称：“了解这个新发现的群体可以促进保护工作并帮助应对气候变化。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在平时写邮件和使用 &lt;code&gt;typora&lt;/code&gt; 软件写日记的时候，特别苦恼怎么能快速插入日期，比如写日记，每次都要复制昨天的日记文档，然后修改时间，很是繁琐，所以就研究了一下，结果发现使用搜狗输入法就很快实现了。&lt;/p&gt;
&lt;p&gt;使用搜狗输入法，在中文模式下，输入 &lt;code&gt;rq&lt;/code&gt; ，则会自动显示日期格式 &lt;code&gt;年月日&lt;/code&gt; ，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202308301608646.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/convert-date-to-binary/">3280. 将日期转换为二进制表示</a></p>
<p>给你一个字符串 <code>date</code>，它的格式为 <code>yyyy-mm-dd</code>，表示一个公历日期。</p>
<p><code>date</code> 可以重写为二进制表示，只需要将年、月、日分别转换为对应的二进制表示（不带前导零）并遵循 <code>year-month-day</code> 的格式。</p>
<p>返回 <code>date</code> 的 <strong>二进制</strong> 表示。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span> <span class="nx">date</span> <span class="o">=</span> <span class="s2">&#34;2080-02-29&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span> <span class="s2">&#34;100000100000-10-11101&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="mi">100000100000</span><span class="p">,</span> <span class="mi">10</span> <span class="nx">和</span> <span class="mi">11101</span> <span class="nx">分别是</span> <span class="mi">2080</span><span class="p">,</span> <span class="mi">02</span> <span class="nx">和</span> <span class="mi">29</span> <span class="nx">的二进制表示</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">convertDateToBinary</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">date</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="p">[</span><span class="nx">year</span><span class="p">,</span> <span class="nx">month</span><span class="p">,</span> <span class="nx">day</span><span class="p">]</span> <span class="o">=</span> <span class="nx">date</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39;-&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">yearBinary</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">year</span><span class="p">).</span><span class="nx">toString</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">monthBinary</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">month</span><span class="p">).</span><span class="nx">toString</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">dayBinary</span> <span class="o">=</span> <span class="nb">parseInt</span><span class="p">(</span><span class="nx">day</span><span class="p">).</span><span class="nx">toString</span><span class="p">(</span><span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="sb">`</span><span class="si">${</span><span class="nx">yearBinary</span><span class="si">}</span><span class="sb">-</span><span class="si">${</span><span class="nx">monthBinary</span><span class="si">}</span><span class="sb">-</span><span class="si">${</span><span class="nx">dayBinary</span><span class="si">}</span><span class="sb">`</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>将日期格式的字符串拆分为年、月、日三个部分。</li>
<li>利用 <code>Number.prototype.toString()</code> 方法中基数的特性，将数字转换为二进制字符串。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2504/250414-water-purification.html">Scientists discover new water purification microbes - Breaking News English Lesson</a></p>
<p>科学家们在我们脚下的地球中发现了一种以前未知的微生物。密歇根州立大学的研究人员一直在探索地球表面下方和上方的一个区域，称为临界区。这个区域对于提供维持生命的条件至关重要。研究人员将这些微生物称为 CSP1-3。微生物可能是净化水过程的关键部分。微生物学家 James Tiedje 说，虽然土壤层负责雨水的大部分过滤，但 CSP1-3 也是必不可少的。他说：“CSP1-3 是清理土壤表层的清道夫。他们的工作是净化我们的饮用水。</p>
<p>Tiedje 博士和他的团队专注于生活在我们脚下 200 米深处土壤中的微生物。他说，CSP1-3 微生物可以去除供水中的有害污染物和碎屑。他现在想在他的实验室中培养 CSP1-3，以了解更多关于它们的特性。他认为它们可以用来清理土壤中的污染。他说：“我们不知道它们代谢顽固污染物的能力，如果我们能了解这一点，我们就可以帮助解决地球上最紧迫的问题之一。scitechdaily.com 网站称：“了解这个新发现的群体可以促进保护工作并帮助应对气候变化。</p>
<h2 id="tip">Tip</h2>
<p>在平时写邮件和使用 <code>typora</code> 软件写日记的时候，特别苦恼怎么能快速插入日期，比如写日记，每次都要复制昨天的日记文档，然后修改时间，很是繁琐，所以就研究了一下，结果发现使用搜狗输入法就很快实现了。</p>
<p>使用搜狗输入法，在中文模式下，输入 <code>rq</code> ，则会自动显示日期格式 <code>年月日</code> ，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202308301608646.png"></p>
<p>如果输入 <code>sj</code> ，则会显示<code>年月日时分秒</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202308301612720.png"></p>
<p>这样就可以快速插入日期了。</p>
<h2 id="share">Share</h2>
<p><a href="https://www.zhihu.com/tardis/zm/art/673733904?source_id=1005">一文读懂：PMF（product market fit）与产品管理</a></p>
<p>“一些初创企业，花很多的时间专注于他的新技术、新功能、新创意，不做用户访谈，花极少的时间验证市场需求、用户付费意愿，最后用一个产品去解决一个不存在的问题或者市场，拿着锤子找钉子，这样的结果大概率也是失败的。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>18-过进度方式一：项目负责人进行全部功能演示</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/18-%E8%BF%87%E8%BF%9B%E5%BA%A6%E6%96%B9%E5%BC%8F%E4%B8%80%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E8%BF%9B%E8%A1%8C%E5%85%A8%E9%83%A8%E5%8A%9F%E8%83%BD%E6%BC%94%E7%A4%BA/</link>
      <pubDate>Mon, 21 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/18-%E8%BF%87%E8%BF%9B%E5%BA%A6%E6%96%B9%E5%BC%8F%E4%B8%80%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E8%BF%9B%E8%A1%8C%E5%85%A8%E9%83%A8%E5%8A%9F%E8%83%BD%E6%BC%94%E7%A4%BA/</guid>
      <description>&lt;p&gt;在项目进度会议中，由开发人员自行演示近期完成的项目功能似乎无可厚非。毕竟，他们是最熟悉这些功能的操作流程的，部分功能甚至需要连接特定设备或模拟数据才能顺利演示。若非使用开发人员事先准备好的账号，整个演示流程可能会耗费大量时间，从而降低会议效率。&lt;/p&gt;
&lt;p&gt;然而，深入分析后不难发现，这种做法存在一些潜在问题。首先，项目负责人可能对其他同事开发的功能并不熟悉；其次，项目负责人作为整个项目的负责人，在进行项目整体汇报时，若将主要演示职责交给开发人员，会导致职责划分不清晰，这不仅不利于项目负责人的个人成长，也不利于项目的顺利开展。&lt;/p&gt;
&lt;p&gt;因此，项目功能演示环节最好由项目负责人全程主导，开发人员可适时进行补充。这样做的好处有三点：一是避免职责不清；二是增强项目负责人的责任感；三是促使项目负责人更深入地了解项目需求，因为只有真正理解项目需求，才能顺利进行演示，这也有助于后续的功能验收环节，其影响是多方面的。&lt;/p&gt;
&lt;p&gt;归根结底，问题的根源在于&lt;strong&gt;项目需求与方案环节&lt;/strong&gt;。项目负责人需要确保对项目需求有清晰、透彻的理解，虽然不一定亲自编写代码，但可以在脑海中模拟开发过程，至少要清楚功能的具体形态和使用方式。基于此，项目负责人可以在每周一提前浏览本周的任务，鉴于项目进度会议每周举行一次，本周需要实现的功能数量相对有限，亲自操作演示也不会花费过多时间，从而确保在周二的项目进度会议上能够清晰、准确地进行汇报。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>在项目进度会议中，由开发人员自行演示近期完成的项目功能似乎无可厚非。毕竟，他们是最熟悉这些功能的操作流程的，部分功能甚至需要连接特定设备或模拟数据才能顺利演示。若非使用开发人员事先准备好的账号，整个演示流程可能会耗费大量时间，从而降低会议效率。</p>
<p>然而，深入分析后不难发现，这种做法存在一些潜在问题。首先，项目负责人可能对其他同事开发的功能并不熟悉；其次，项目负责人作为整个项目的负责人，在进行项目整体汇报时，若将主要演示职责交给开发人员，会导致职责划分不清晰，这不仅不利于项目负责人的个人成长，也不利于项目的顺利开展。</p>
<p>因此，项目功能演示环节最好由项目负责人全程主导，开发人员可适时进行补充。这样做的好处有三点：一是避免职责不清；二是增强项目负责人的责任感；三是促使项目负责人更深入地了解项目需求，因为只有真正理解项目需求，才能顺利进行演示，这也有助于后续的功能验收环节，其影响是多方面的。</p>
<p>归根结底，问题的根源在于<strong>项目需求与方案环节</strong>。项目负责人需要确保对项目需求有清晰、透彻的理解，虽然不一定亲自编写代码，但可以在脑海中模拟开发过程，至少要清楚功能的具体形态和使用方式。基于此，项目负责人可以在每周一提前浏览本周的任务，鉴于项目进度会议每周举行一次，本周需要实现的功能数量相对有限，亲自操作演示也不会花费过多时间，从而确保在周二的项目进度会议上能够清晰、准确地进行汇报。</p>
]]></content:encoded>
    </item>
    <item>
      <title>17-解决代码合并引发的功能演示问题</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/17-%E8%A7%A3%E5%86%B3%E4%BB%A3%E7%A0%81%E5%90%88%E5%B9%B6%E5%BC%95%E5%8F%91%E7%9A%84%E5%8A%9F%E8%83%BD%E6%BC%94%E7%A4%BA%E9%97%AE%E9%A2%98/</link>
      <pubDate>Sat, 19 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/17-%E8%A7%A3%E5%86%B3%E4%BB%A3%E7%A0%81%E5%90%88%E5%B9%B6%E5%BC%95%E5%8F%91%E7%9A%84%E5%8A%9F%E8%83%BD%E6%BC%94%E7%A4%BA%E9%97%AE%E9%A2%98/</guid>
      <description>&lt;p&gt;我们每周二都会召开项目进度例会，会议中需要逐一汇报五六个项目的进展情况。为了能够在会议中顺利演示相关功能，必须将已开发完成的功能代码合并至&lt;code&gt;Dev&lt;/code&gt;分支，否则将无法进行功能演示。&lt;/p&gt;
&lt;p&gt;对于那些能够在会议前完成合并的分支，其代码已成功合并至开发环境平台，此时仅需进行功能验收即可。然而，功能分支的代码需经过项目负责人的评审，但往往功能开发任务在当天刚刚完成，而项目负责人本身还承担着其他功能的开发任务，因此难以及时完成代码评审及合并工作。在这种情况下，该如何妥善处理呢？&lt;/p&gt;
&lt;p&gt;一种可行的方案是&lt;code&gt;Clone&lt;/code&gt;功能分支代码至本地，在本地环境中运行并进行验收。但这一流程存在诸多不便：需要&lt;code&gt;Clone&lt;/code&gt;分支代码、安装依赖，且可能面临与本地环境不兼容的问题，还需进行微调才能成功运行，整个过程较为繁琐。在会议中花费大量时间进行此类操作显然毫无意义，那么如何简化这一流程呢？&lt;/p&gt;
&lt;p&gt;一方面，可以在会议前与相关人员进行沟通，提前了解哪些任务已完成且已合并至&lt;code&gt;Dev&lt;/code&gt;分支，哪些功能的代码尚未完成评审并合并至&lt;code&gt;Dev&lt;/code&gt;分支。对于尚未合并的功能分支，可提前将其&lt;code&gt;Clone&lt;/code&gt;至本地电脑，安装好依赖并成功运行，待开会时通过远程连接至本地电脑即可进行演示。&lt;/p&gt;
&lt;p&gt;另一种方案是直接打开代码仓库&lt;code&gt;GitLab&lt;/code&gt;，查看项目分支的代码，让负责功能开发的同事详细介绍该功能的实现方式以及代码的设计思路，这样既能解决上述问题，也能达到功能演示的目的。&lt;/p&gt;
&lt;p&gt;此外，还可以考虑在现有的&lt;code&gt;Dev&lt;/code&gt;、&lt;code&gt;TEST&lt;/code&gt;、&lt;code&gt;Staging&lt;/code&gt;、&lt;code&gt;Master&lt;/code&gt; 四个环境之外，额外设立一个&lt;code&gt;Preview&lt;/code&gt;环境。项目的各个功能分支，无论处于何种状态，均可立即合并至&lt;code&gt;Preview&lt;/code&gt;环境。功能开发完成后，项目负责人可直接将该功能分支合并至&lt;code&gt;Preview&lt;/code&gt;分支，解决合并冲突后通过&lt;code&gt;CI/CD&lt;/code&gt;流水线自动部署至&lt;code&gt;Preview&lt;/code&gt;环境，从而方便地进行功能演示。&lt;code&gt;Preview&lt;/code&gt;环境主要用于功能演示，最终的代码合并仍需以&lt;code&gt;Dev&lt;/code&gt;、&lt;code&gt;TEST&lt;/code&gt;、&lt;code&gt;Staging&lt;/code&gt;、&lt;code&gt;Master&lt;/code&gt; 四个分支为主，项目负责人在完成代码评审后，需将功能分支代码合并至&lt;code&gt;Dev&lt;/code&gt;分支。&lt;/p&gt;
&lt;p&gt;通过以上提供的三种解决方案，包括项目负责人在会前做好准备工作、通过&lt;code&gt;GitLab&lt;/code&gt;查看功能分支代码进行验收、提供&lt;code&gt;Preview&lt;/code&gt;环境以便直接合并功能分支进行验收，相信可以解决会议上因代码没有合并，从而无法进行功能演示的问题。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>我们每周二都会召开项目进度例会，会议中需要逐一汇报五六个项目的进展情况。为了能够在会议中顺利演示相关功能，必须将已开发完成的功能代码合并至<code>Dev</code>分支，否则将无法进行功能演示。</p>
<p>对于那些能够在会议前完成合并的分支，其代码已成功合并至开发环境平台，此时仅需进行功能验收即可。然而，功能分支的代码需经过项目负责人的评审，但往往功能开发任务在当天刚刚完成，而项目负责人本身还承担着其他功能的开发任务，因此难以及时完成代码评审及合并工作。在这种情况下，该如何妥善处理呢？</p>
<p>一种可行的方案是<code>Clone</code>功能分支代码至本地，在本地环境中运行并进行验收。但这一流程存在诸多不便：需要<code>Clone</code>分支代码、安装依赖，且可能面临与本地环境不兼容的问题，还需进行微调才能成功运行，整个过程较为繁琐。在会议中花费大量时间进行此类操作显然毫无意义，那么如何简化这一流程呢？</p>
<p>一方面，可以在会议前与相关人员进行沟通，提前了解哪些任务已完成且已合并至<code>Dev</code>分支，哪些功能的代码尚未完成评审并合并至<code>Dev</code>分支。对于尚未合并的功能分支，可提前将其<code>Clone</code>至本地电脑，安装好依赖并成功运行，待开会时通过远程连接至本地电脑即可进行演示。</p>
<p>另一种方案是直接打开代码仓库<code>GitLab</code>，查看项目分支的代码，让负责功能开发的同事详细介绍该功能的实现方式以及代码的设计思路，这样既能解决上述问题，也能达到功能演示的目的。</p>
<p>此外，还可以考虑在现有的<code>Dev</code>、<code>TEST</code>、<code>Staging</code>、<code>Master</code> 四个环境之外，额外设立一个<code>Preview</code>环境。项目的各个功能分支，无论处于何种状态，均可立即合并至<code>Preview</code>环境。功能开发完成后，项目负责人可直接将该功能分支合并至<code>Preview</code>分支，解决合并冲突后通过<code>CI/CD</code>流水线自动部署至<code>Preview</code>环境，从而方便地进行功能演示。<code>Preview</code>环境主要用于功能演示，最终的代码合并仍需以<code>Dev</code>、<code>TEST</code>、<code>Staging</code>、<code>Master</code> 四个分支为主，项目负责人在完成代码评审后，需将功能分支代码合并至<code>Dev</code>分支。</p>
<p>通过以上提供的三种解决方案，包括项目负责人在会前做好准备工作、通过<code>GitLab</code>查看功能分支代码进行验收、提供<code>Preview</code>环境以便直接合并功能分支进行验收，相信可以解决会议上因代码没有合并，从而无法进行功能演示的问题。</p>
]]></content:encoded>
    </item>
    <item>
      <title>16-项目的任务质量如何保证</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/16-%E9%A1%B9%E7%9B%AE%E7%9A%84%E4%BB%BB%E5%8A%A1%E8%B4%A8%E9%87%8F%E5%A6%82%E4%BD%95%E4%BF%9D%E8%AF%81/</link>
      <pubDate>Sat, 12 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/16-%E9%A1%B9%E7%9B%AE%E7%9A%84%E4%BB%BB%E5%8A%A1%E8%B4%A8%E9%87%8F%E5%A6%82%E4%BD%95%E4%BF%9D%E8%AF%81/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;项目的任务质量如何保证？在我看来，主要取决于以下这几个环节：需求要明确、任务开发时间要合理评估、任务需提供测试用例、在项目进度会议上进行功能演示。&lt;strong&gt;产品质量是生产出来的，不是检验出来的&lt;/strong&gt;，不可能全都依赖于验收环节，毕竟那时已经晚了。验收环节只是为任务的质量加了一层防护，应从源头开始，就要不断地关注和解决存在的问题。&lt;/p&gt;
&lt;h1 id=&#34;需求要明确&#34;&gt;需求要明确&lt;/h1&gt;
&lt;p&gt;需求要明确，这一点在前面几篇文章中都反复提到过，这里就不再赘述了。简而言之，就是产品的需求要具体到可量化的程度。比如我要买苹果，应该是我要买10斤XXX牌子的苹果。&lt;/p&gt;
&lt;h1 id=&#34;任务开发时间合理评估&#34;&gt;任务开发时间合理评估&lt;/h1&gt;
&lt;p&gt;在评估任务开发时间的时候，要根据实际情况，不能过于宽松。比如一个设备列表的功能排个两三天就差不多了，硬是排了一周多，这显然是有问题的。但也不能太严格，比如就给一天的时间，这就存心为难他人了，大可不必，实事求是就好了。&lt;/p&gt;
&lt;p&gt;有人觉得开发任务只要时间够长，那么交付的功能质量一定就更好，实际上并非如此。人性本就如此，很少有人会提前完成任务，大部分人都会压到最后一刻才说做完了，不过，这也没什么可指摘的，人之常情。&lt;/p&gt;
&lt;p&gt;所以，任务开发所需的时间，通常以一个“跳一跳能够够得到”的要求去评估即可。&lt;/p&gt;
&lt;p&gt;**我们不会要求一个只能跑10公里的人去跑马拉松，我们只会要求他不断地跑到10公里、11公里和9公里，而不是他每次都只跑了5公里。**道理是一样的，没有什么是十全十美的，只希望每个人都能在自身能力范围内做到最好，仅此而已。&lt;/p&gt;
&lt;h1 id=&#34;任务需提供测试用例&#34;&gt;任务需提供测试用例&lt;/h1&gt;
&lt;p&gt;我们开发人员在开发完成之后，就匆忙提交任务进度为100%，意味着任务已经完成了。但是在验收人去验收的时候，还是经常发现这样或那样的问题。&lt;/p&gt;
&lt;p&gt;为了解决这个问题，就需要把全部的问题都放到明面上，而不是藏着掖着，让大家都能清楚地知道，哪些功能确实是真的验收了。&lt;/p&gt;
&lt;p&gt;这就需要开发人员在开发完成这个功能之后，提供一个自测报告，也就是在AgileTC测试用例管理平台编写这个功能的测试用例（在《AgileTC测试用例管理平台的基本使用》这篇文章中有介绍过如何使用），把全部功能要测试的点依次列出。&lt;/p&gt;
&lt;p&gt;这样验收人在验收功能时，就可以根据这个测试用例，把全部功能都过一遍，有规范有依据，不会像之前那样混乱，到底哪些功能是没问题的，哪些功能是有问题的，一目了然，沟通效率也会更高。&lt;/p&gt;
&lt;p&gt;以微信读书PC端的功能为例，图一为微信读书PC端的页面，图二为根据功能编写的测试用例，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504121134646.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504121137716.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;什么时候编写测试用例&#34;&gt;什么时候编写测试用例&lt;/h1&gt;
&lt;p&gt;上面提到的是在任务开发完成之后再编写测试用例，但如果在需求阶段就编写测试用例会不会有什么问题呢？&lt;/p&gt;
&lt;p&gt;在需求阶段就编写测试用例，这种开发模式就是常说的&lt;code&gt;TDD&lt;/code&gt;（测试驱动开发）模式。这个方式当然是可行的，但存在一个问题，就是最终交付的功能和最初的需求可能会有出入，导致之前编写的测试用例不能用了，需要重新编写。&lt;/p&gt;
&lt;p&gt;首先，开发人员在需求阶段就编写测试用例，相当于在对需求进行分解，同时对需求也会更加了解，能和产品明确，达成共识，避免接下来出现返工的情况。&lt;/p&gt;
&lt;p&gt;总体而言，测试用例等同于列出需求点，后续需求有变更，也不是全部测试用例都不能用了，很大概率只是个别测试用例进行微调而已。&lt;/p&gt;
&lt;p&gt;所以，不管是在需求阶段还是开发完功能之后再编写，在我看来都可以的。&lt;/p&gt;
&lt;p&gt;说到底，测试用例最终还是要围绕需求来编写，从需求中提炼出的测试要点才是真实有效的。所以，**对被测对象业务的熟悉程度，也决定了能否设计出高质量的测试用例。**毕竟，各功能点之间往往都是有关联的，会隐藏很多被我们忽略掉或者是想不到的测试用例。&lt;/p&gt;
&lt;h1 id=&#34;在项目进度会议上进行功能演示&#34;&gt;在项目进度会议上进行功能演示&lt;/h1&gt;
&lt;p&gt;我们发现只有在项目进度会议上进行功能演示才会发现问题。开发人员通常口头上说“已经做完了”，这很有可能是片面的，并非开发人员存心欺瞒，只是每个人对需求的理解，有可能一开始就有差异，这种差异即便功能已经开发完成，还是可能会存在。&lt;/p&gt;
&lt;p&gt;在项目进度会议上进行功能演示，整个项目团队的人员都可以看到，并且可以随时提出问题，虽然这样会增加会议的时间，但我相信这是值得的。&lt;/p&gt;
&lt;p&gt;这其实也就是在敏捷开发模式中提到的&lt;code&gt;Sprint Review&lt;/code&gt;环节，简单来说，就是解决颗粒度对齐的问题（笑），能让项目团队中的相关人员，包括但不限于产品、研发、测试和需求提出方等参与验收当前开发的功能，确认是否有需求理解偏差或潜在的需求调整，能够及时反馈和沟通，有助于项目下一步的功能优化和工作安排。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="前言">前言</h1>
<p>项目的任务质量如何保证？在我看来，主要取决于以下这几个环节：需求要明确、任务开发时间要合理评估、任务需提供测试用例、在项目进度会议上进行功能演示。<strong>产品质量是生产出来的，不是检验出来的</strong>，不可能全都依赖于验收环节，毕竟那时已经晚了。验收环节只是为任务的质量加了一层防护，应从源头开始，就要不断地关注和解决存在的问题。</p>
<h1 id="需求要明确">需求要明确</h1>
<p>需求要明确，这一点在前面几篇文章中都反复提到过，这里就不再赘述了。简而言之，就是产品的需求要具体到可量化的程度。比如我要买苹果，应该是我要买10斤XXX牌子的苹果。</p>
<h1 id="任务开发时间合理评估">任务开发时间合理评估</h1>
<p>在评估任务开发时间的时候，要根据实际情况，不能过于宽松。比如一个设备列表的功能排个两三天就差不多了，硬是排了一周多，这显然是有问题的。但也不能太严格，比如就给一天的时间，这就存心为难他人了，大可不必，实事求是就好了。</p>
<p>有人觉得开发任务只要时间够长，那么交付的功能质量一定就更好，实际上并非如此。人性本就如此，很少有人会提前完成任务，大部分人都会压到最后一刻才说做完了，不过，这也没什么可指摘的，人之常情。</p>
<p>所以，任务开发所需的时间，通常以一个“跳一跳能够够得到”的要求去评估即可。</p>
<p>**我们不会要求一个只能跑10公里的人去跑马拉松，我们只会要求他不断地跑到10公里、11公里和9公里，而不是他每次都只跑了5公里。**道理是一样的，没有什么是十全十美的，只希望每个人都能在自身能力范围内做到最好，仅此而已。</p>
<h1 id="任务需提供测试用例">任务需提供测试用例</h1>
<p>我们开发人员在开发完成之后，就匆忙提交任务进度为100%，意味着任务已经完成了。但是在验收人去验收的时候，还是经常发现这样或那样的问题。</p>
<p>为了解决这个问题，就需要把全部的问题都放到明面上，而不是藏着掖着，让大家都能清楚地知道，哪些功能确实是真的验收了。</p>
<p>这就需要开发人员在开发完成这个功能之后，提供一个自测报告，也就是在AgileTC测试用例管理平台编写这个功能的测试用例（在《AgileTC测试用例管理平台的基本使用》这篇文章中有介绍过如何使用），把全部功能要测试的点依次列出。</p>
<p>这样验收人在验收功能时，就可以根据这个测试用例，把全部功能都过一遍，有规范有依据，不会像之前那样混乱，到底哪些功能是没问题的，哪些功能是有问题的，一目了然，沟通效率也会更高。</p>
<p>以微信读书PC端的功能为例，图一为微信读书PC端的页面，图二为根据功能编写的测试用例，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504121134646.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504121137716.png"></p>
<h1 id="什么时候编写测试用例">什么时候编写测试用例</h1>
<p>上面提到的是在任务开发完成之后再编写测试用例，但如果在需求阶段就编写测试用例会不会有什么问题呢？</p>
<p>在需求阶段就编写测试用例，这种开发模式就是常说的<code>TDD</code>（测试驱动开发）模式。这个方式当然是可行的，但存在一个问题，就是最终交付的功能和最初的需求可能会有出入，导致之前编写的测试用例不能用了，需要重新编写。</p>
<p>首先，开发人员在需求阶段就编写测试用例，相当于在对需求进行分解，同时对需求也会更加了解，能和产品明确，达成共识，避免接下来出现返工的情况。</p>
<p>总体而言，测试用例等同于列出需求点，后续需求有变更，也不是全部测试用例都不能用了，很大概率只是个别测试用例进行微调而已。</p>
<p>所以，不管是在需求阶段还是开发完功能之后再编写，在我看来都可以的。</p>
<p>说到底，测试用例最终还是要围绕需求来编写，从需求中提炼出的测试要点才是真实有效的。所以，**对被测对象业务的熟悉程度，也决定了能否设计出高质量的测试用例。**毕竟，各功能点之间往往都是有关联的，会隐藏很多被我们忽略掉或者是想不到的测试用例。</p>
<h1 id="在项目进度会议上进行功能演示">在项目进度会议上进行功能演示</h1>
<p>我们发现只有在项目进度会议上进行功能演示才会发现问题。开发人员通常口头上说“已经做完了”，这很有可能是片面的，并非开发人员存心欺瞒，只是每个人对需求的理解，有可能一开始就有差异，这种差异即便功能已经开发完成，还是可能会存在。</p>
<p>在项目进度会议上进行功能演示，整个项目团队的人员都可以看到，并且可以随时提出问题，虽然这样会增加会议的时间，但我相信这是值得的。</p>
<p>这其实也就是在敏捷开发模式中提到的<code>Sprint Review</code>环节，简单来说，就是解决颗粒度对齐的问题（笑），能让项目团队中的相关人员，包括但不限于产品、研发、测试和需求提出方等参与验收当前开发的功能，确认是否有需求理解偏差或潜在的需求调整，能够及时反馈和沟通，有助于项目下一步的功能优化和工作安排。</p>
]]></content:encoded>
    </item>
    <item>
      <title>15-项目任务验收工作没有真正落实</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/15-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E9%AA%8C%E6%94%B6%E5%B7%A5%E4%BD%9C%E6%B2%A1%E6%9C%89%E7%9C%9F%E6%AD%A3%E8%90%BD%E5%AE%9E/</link>
      <pubDate>Thu, 10 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/15-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E9%AA%8C%E6%94%B6%E5%B7%A5%E4%BD%9C%E6%B2%A1%E6%9C%89%E7%9C%9F%E6%AD%A3%E8%90%BD%E5%AE%9E/</guid>
      <description>&lt;p&gt;之前我们计划由项目负责人每周五进行任务验收，但在开展过程中，验收其他开发同事的任务时，经常出现缺胳膊少腿的情况：比如某个任务完成了，但文档没写，或者写了又没有提交更新；某个任务计划的结束时间都超过了，也没有及时变更，至于过期的原因也没有说明等等，执行起来很困难。现在在项目进度会议上把完成的任务进行验收，就需要周一的时候，项目负责人牵头更新任务的时间、功能和文档情况，否则周二在项目进度会议上，还是会出现各种各样的问题。但是周一的时候，项目负责人已经验收过任务，周二在项目进度会议上又要过一次，对于其他开发同事来说，就觉得被问了两次，显然这个方式可能没有从根本上解决问题。&lt;/p&gt;
&lt;p&gt;之前项目负责人去验收，实际上是不知道任务进度情况的，只有问了项目开发的同事才知道负责的任务完成了没有，项目负责人完全不知道有多少任务需要验收，完全是随机的状态，相应的其他事情的计划就又要变更了。那我们何不反过来，使用观察者模式，等开发同事完成任务后，给项目负责人发一下邮件或者企业微信的消息，一来形成闭环，二来强化开发同事任务是需要验收的这个意识。项目负责人这个时候立马去验收也可以，但不推荐，因为挨个去验收，精力就会分散，建议把可验收的任务整理记到下周一当天工作计划里，统一验收。后续等我们在线项目管理系统上线，里面就提供一个功能：如果开发同事任务完成，需提交技术文档（如有需要），然后把任务状态变更为待验收，这个时候，系统就会给项目负责人发一条可验收的邮件，相信可以有效解决这个问题。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504090957901.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>之前我们计划由项目负责人每周五进行任务验收，但在开展过程中，验收其他开发同事的任务时，经常出现缺胳膊少腿的情况：比如某个任务完成了，但文档没写，或者写了又没有提交更新；某个任务计划的结束时间都超过了，也没有及时变更，至于过期的原因也没有说明等等，执行起来很困难。现在在项目进度会议上把完成的任务进行验收，就需要周一的时候，项目负责人牵头更新任务的时间、功能和文档情况，否则周二在项目进度会议上，还是会出现各种各样的问题。但是周一的时候，项目负责人已经验收过任务，周二在项目进度会议上又要过一次，对于其他开发同事来说，就觉得被问了两次，显然这个方式可能没有从根本上解决问题。</p>
<p>之前项目负责人去验收，实际上是不知道任务进度情况的，只有问了项目开发的同事才知道负责的任务完成了没有，项目负责人完全不知道有多少任务需要验收，完全是随机的状态，相应的其他事情的计划就又要变更了。那我们何不反过来，使用观察者模式，等开发同事完成任务后，给项目负责人发一下邮件或者企业微信的消息，一来形成闭环，二来强化开发同事任务是需要验收的这个意识。项目负责人这个时候立马去验收也可以，但不推荐，因为挨个去验收，精力就会分散，建议把可验收的任务整理记到下周一当天工作计划里，统一验收。后续等我们在线项目管理系统上线，里面就提供一个功能：如果开发同事任务完成，需提交技术文档（如有需要），然后把任务状态变更为待验收，这个时候，系统就会给项目负责人发一条可验收的邮件，相信可以有效解决这个问题。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504090957901.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>14-项目进度会议的两种设计</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/14-%E9%A1%B9%E7%9B%AE%E8%BF%9B%E5%BA%A6%E4%BC%9A%E8%AE%AE%E7%9A%84%E4%B8%A4%E7%A7%8D%E8%AE%BE%E8%AE%A1/</link>
      <pubDate>Mon, 07 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/14-%E9%A1%B9%E7%9B%AE%E8%BF%9B%E5%BA%A6%E4%BC%9A%E8%AE%AE%E7%9A%84%E4%B8%A4%E7%A7%8D%E8%AE%BE%E8%AE%A1/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;召开项目进度会议的方式应依据部门的具体情况灵活安排。尽管一些部门的职能结构通常为项目总负责人、项目负责人，再到具体项目及其成员，但在实际召开项目进度会议时，通常有以下两种设计思路：一种是项目总负责人深度参与并引导会议；另一种则是授权项目负责人自行组织会议，而项目总负责人则另设专门的项目负责人会议。&lt;/p&gt;
&lt;h1 id=&#34;项目负责人主导型会议&#34;&gt;&lt;strong&gt;项目负责人主导型会议&lt;/strong&gt;&lt;/h1&gt;
&lt;p&gt;项目负责人主导项目进度会议的全过程。他们负责申请会议室、准备设备、在项目群中发布通知并召集相关人员参会，项目总负责人也会参与其中。会议中，无论是项目进度汇报、问题反馈、任务验收还是后续工作安排，均由项目负责人主导提出、讨论并解决问题，项目总负责人则主要扮演补充角色，例如指出潜在问题等。这种模式能够有效增强项目负责人的责任感，使其将项目视为自己的责任。换言之，项目负责人应明确，在项目事务中，他们行使的是权力而非义务。**权力是主动争取并愿意承担的事情，而义务则是他人强加的要求，二者意义截然不同。**许多项目负责人虽然参与了许多工作，但心态上仍与项目脱节，认为项目是上级安排的任务，只是机械地执行上级指令，而未意识到自己需要对项目的各个方面负责。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504070951070.png&#34;&gt;&lt;/p&gt;
&lt;h1 id=&#34;分层汇报机制会议&#34;&gt;分层汇报机制会议&lt;/h1&gt;
&lt;p&gt;在这种会议模式下，项目负责人负责组织项目进度会议，而项目总负责人则主导召开项目负责人会议，用于听取各项目负责人的项目整体情况汇报。这种方式通常适用于规模较大的团队，且对项目负责人和项目总负责人的能力要求较高，实施起来并非易事。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504070950661.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="前言">前言</h1>
<p>召开项目进度会议的方式应依据部门的具体情况灵活安排。尽管一些部门的职能结构通常为项目总负责人、项目负责人，再到具体项目及其成员，但在实际召开项目进度会议时，通常有以下两种设计思路：一种是项目总负责人深度参与并引导会议；另一种则是授权项目负责人自行组织会议，而项目总负责人则另设专门的项目负责人会议。</p>
<h1 id="项目负责人主导型会议"><strong>项目负责人主导型会议</strong></h1>
<p>项目负责人主导项目进度会议的全过程。他们负责申请会议室、准备设备、在项目群中发布通知并召集相关人员参会，项目总负责人也会参与其中。会议中，无论是项目进度汇报、问题反馈、任务验收还是后续工作安排，均由项目负责人主导提出、讨论并解决问题，项目总负责人则主要扮演补充角色，例如指出潜在问题等。这种模式能够有效增强项目负责人的责任感，使其将项目视为自己的责任。换言之，项目负责人应明确，在项目事务中，他们行使的是权力而非义务。**权力是主动争取并愿意承担的事情，而义务则是他人强加的要求，二者意义截然不同。**许多项目负责人虽然参与了许多工作，但心态上仍与项目脱节，认为项目是上级安排的任务，只是机械地执行上级指令，而未意识到自己需要对项目的各个方面负责。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504070951070.png"></p>
<h1 id="分层汇报机制会议">分层汇报机制会议</h1>
<p>在这种会议模式下，项目负责人负责组织项目进度会议，而项目总负责人则主导召开项目负责人会议，用于听取各项目负责人的项目整体情况汇报。这种方式通常适用于规模较大的团队，且对项目负责人和项目总负责人的能力要求较高，实施起来并非易事。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202504070950661.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>13-项目为什么需要加班</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/13-%E9%A1%B9%E7%9B%AE%E4%B8%BA%E4%BB%80%E4%B9%88%E9%9C%80%E8%A6%81%E5%8A%A0%E7%8F%AD/</link>
      <pubDate>Fri, 04 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/13-%E9%A1%B9%E7%9B%AE%E4%B8%BA%E4%BB%80%E4%B9%88%E9%9C%80%E8%A6%81%E5%8A%A0%E7%8F%AD/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;为何项目会频繁出现加班的情况呢？究其根源究竟在哪里呢？从项目管理的角度出发，我认为项目负责人可能在以下几个关键环节存在不足之处，从而引发了加班现象的产生。&lt;/p&gt;
&lt;h1 id=&#34;需求不够清晰明确&#34;&gt;需求不够清晰明确&lt;/h1&gt;
&lt;p&gt;项目需求是否已经足够明确呢？例如，当我要开发设备列表这一功能时，上级给出的需求仅仅是一句“实现对设备的管理”，而没有细化到该功能的具体要求，比如页面默认应显示10条数据、需支持分页功能且分页选项为10、20、30、50和100条，还要支持按设备名称和设备ID进行搜索，列表要展示的表头包括设备名称、设备ID、设备型号等。&lt;/p&gt;
&lt;p&gt;在需求沟通阶段，若未能明确需求的范围，就会使要做的工作存在过多不确定因素。就好比我要提一个需求，即“用一张纸剪一个圆”，如果只是简单地告诉对方“我要剪一个圈”，而对方仅凭感觉去剪，剪好后我却觉得不满意，要求剪得小一点，但又没有明确具体要多小，对方只能凭借自己的感觉不断尝试，直至剪出令我满意的结果为止。在这个过程中，对方其实一直在进行返工，这无疑就变相导致了加班的情况出现。&lt;/p&gt;
&lt;p&gt;正确的做法应当是，在告知对方要剪一个圆时，直接将圆画在纸上，待双方沟通确认之后，对方只需剪一次即可，从而避免出现反复返工的问题。&lt;/p&gt;
&lt;h1 id=&#34;项目缺乏充分的预研工作&#34;&gt;项目缺乏充分的预研工作&lt;/h1&gt;
&lt;p&gt;在项目的预研阶段，项目负责人需要在脑海中对项目从无到有的整个过程进行全面且深入的分析，将可能出现的问题逐一梳理，并且提供相应的解决方案，而不是仅仅依据需求阶段沟通好的需求，就仓促地开始着手实施。&lt;/p&gt;
&lt;p&gt;需求阶段的工作做到位只是基础的第一步，接下来的第二步就是要以终为始，从最终结果开始倒推，思考可能会遇到哪些问题呢？这个功能采用何种技术来实现呢？这个饼图应该使用哪个插件来制作呢？这个3D动画效果是选用哪个第三方库来实现，还是自行开发呢？天气数据又该使用哪个平台呢？客户提出的这个需求是否真的能够实现呢？类似这样的一系列问题都需要项目负责人提前想清楚，并且做到心中有数，甚至对于一些功能难点，还需要制作一个Demo来进行验证。&lt;/p&gt;
&lt;p&gt;倘若在这一阶段没有做到位，仅根据需求评估项目的开发计划，并且向客户承诺交付的时间，那么在项目推进过程中，一旦发现存在无法解决的问题，或者某个环节比预期花费了更多时间，为了应对这种阻碍项目推进的突发状况，项目负责人往往只能被迫安排加班，否则就无法按照预期完成项目。简而言之，就是前期预研工作没有做到位，从而意外地遇到了隐藏的暗礁。&lt;/p&gt;
&lt;h1 id=&#34;临时插入需求导致的问题&#34;&gt;临时插入需求导致的问题&lt;/h1&gt;
&lt;p&gt;其实关于项目推进过程中出现紧急需求插入的情况，已经在《10-项目需求变更时如何处理》这篇文章中有所提及，当遇到这种情况时，应该如何妥善解决呢？这里就不再重复阐述了，只是想说明一下为何这种情况下会出现加班的情况。原因就在于项目负责人没有充分按照《10-项目需求变更时如何处理》中提到的方案去操作，而是盲目地接下来，完全不进行沟通，只要上级提出任务，就理所当然地认为上级是知晓当前项目情况的，如果自己有不同意见，可能会给上级留下不好的印象，会被认为是身为项目负责人，稍微增加一点工作量就开始抱怨。于是，就硬着头皮接受了任务，但此时已经有正在进行的工作了，新增的任务必然需要额外的人力和时间去完成，那么在这种情况下，只能安排加班，否则还能怎么办呢？最终项目没有如期达成，被上级批评，而项目负责人自己却感到非常委屈，明明项目团队天天都在加班，只是差了一点点就完成了，却还要被批评，心里十分不爽。这就是典型的吃力不讨好，没有及时与上级进行沟通。很多人总是错误地认为上级是全能全知的，上级的决策一定都是正确的，既然上级安排了临时任务，那一定是有其原因的，也一定知道我正在忙很多事情。这种想法是不可取的。类似这种情况，由于项目需求变更、临时插入紧急任务，一定要及时向上级反馈，不能等到事情搞砸了，再去找各种理由，即便理由再充分，但项目没有按照预期交付，这个结果就是工作没有做好。&lt;/p&gt;
&lt;h1 id=&#34;关于加班的合理时机&#34;&gt;关于加班的合理时机&lt;/h1&gt;
&lt;p&gt;说实话，其实我是很反对加班的。虽然我加班还挺多的，但并不是因为我加班多才反对的，主要是加班要加得有意义，加班本身不应成为目的。然而，许多人却将加班视为勤奋的象征。例如，有人会说：“我一个月加班近50个小时，这难道还不算努力吗？”我见过太多人在正常工作时间内拖沓，却把事情留到加班时间去完成，这种行为毫无意义。&lt;/p&gt;
&lt;p&gt;加班应该是应对突发情况的手段，而不是常态。比如，当服务器突然宕机，或者线上平台的关键功能无法使用，严重影响用户体验时，这种紧急情况需要立即解决，加班是必要的。这种加班才是有意义的，因为它解决了实际问题，避免了更大的损失。&lt;/p&gt;
&lt;p&gt;许多硬性安排的加班往往只是形式主义，大多数人只是在“摸鱼”，不会关注“今天把事情做完”的重要性，不会追求提高工作效率，只是在凑时长而已。&lt;/p&gt;
&lt;p&gt;甚至有些人认为“我做得越快，不就是做得越多吗？”这种想法有一定道理，但关键在于如何利用时间。如果你担心完成任务太快会被认为无所事事，那么可以利用剩余时间学习新技术、阅读专业文章，提升自己，这才是更有意义的做法。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="前言">前言</h1>
<p>为何项目会频繁出现加班的情况呢？究其根源究竟在哪里呢？从项目管理的角度出发，我认为项目负责人可能在以下几个关键环节存在不足之处，从而引发了加班现象的产生。</p>
<h1 id="需求不够清晰明确">需求不够清晰明确</h1>
<p>项目需求是否已经足够明确呢？例如，当我要开发设备列表这一功能时，上级给出的需求仅仅是一句“实现对设备的管理”，而没有细化到该功能的具体要求，比如页面默认应显示10条数据、需支持分页功能且分页选项为10、20、30、50和100条，还要支持按设备名称和设备ID进行搜索，列表要展示的表头包括设备名称、设备ID、设备型号等。</p>
<p>在需求沟通阶段，若未能明确需求的范围，就会使要做的工作存在过多不确定因素。就好比我要提一个需求，即“用一张纸剪一个圆”，如果只是简单地告诉对方“我要剪一个圈”，而对方仅凭感觉去剪，剪好后我却觉得不满意，要求剪得小一点，但又没有明确具体要多小，对方只能凭借自己的感觉不断尝试，直至剪出令我满意的结果为止。在这个过程中，对方其实一直在进行返工，这无疑就变相导致了加班的情况出现。</p>
<p>正确的做法应当是，在告知对方要剪一个圆时，直接将圆画在纸上，待双方沟通确认之后，对方只需剪一次即可，从而避免出现反复返工的问题。</p>
<h1 id="项目缺乏充分的预研工作">项目缺乏充分的预研工作</h1>
<p>在项目的预研阶段，项目负责人需要在脑海中对项目从无到有的整个过程进行全面且深入的分析，将可能出现的问题逐一梳理，并且提供相应的解决方案，而不是仅仅依据需求阶段沟通好的需求，就仓促地开始着手实施。</p>
<p>需求阶段的工作做到位只是基础的第一步，接下来的第二步就是要以终为始，从最终结果开始倒推，思考可能会遇到哪些问题呢？这个功能采用何种技术来实现呢？这个饼图应该使用哪个插件来制作呢？这个3D动画效果是选用哪个第三方库来实现，还是自行开发呢？天气数据又该使用哪个平台呢？客户提出的这个需求是否真的能够实现呢？类似这样的一系列问题都需要项目负责人提前想清楚，并且做到心中有数，甚至对于一些功能难点，还需要制作一个Demo来进行验证。</p>
<p>倘若在这一阶段没有做到位，仅根据需求评估项目的开发计划，并且向客户承诺交付的时间，那么在项目推进过程中，一旦发现存在无法解决的问题，或者某个环节比预期花费了更多时间，为了应对这种阻碍项目推进的突发状况，项目负责人往往只能被迫安排加班，否则就无法按照预期完成项目。简而言之，就是前期预研工作没有做到位，从而意外地遇到了隐藏的暗礁。</p>
<h1 id="临时插入需求导致的问题">临时插入需求导致的问题</h1>
<p>其实关于项目推进过程中出现紧急需求插入的情况，已经在《10-项目需求变更时如何处理》这篇文章中有所提及，当遇到这种情况时，应该如何妥善解决呢？这里就不再重复阐述了，只是想说明一下为何这种情况下会出现加班的情况。原因就在于项目负责人没有充分按照《10-项目需求变更时如何处理》中提到的方案去操作，而是盲目地接下来，完全不进行沟通，只要上级提出任务，就理所当然地认为上级是知晓当前项目情况的，如果自己有不同意见，可能会给上级留下不好的印象，会被认为是身为项目负责人，稍微增加一点工作量就开始抱怨。于是，就硬着头皮接受了任务，但此时已经有正在进行的工作了，新增的任务必然需要额外的人力和时间去完成，那么在这种情况下，只能安排加班，否则还能怎么办呢？最终项目没有如期达成，被上级批评，而项目负责人自己却感到非常委屈，明明项目团队天天都在加班，只是差了一点点就完成了，却还要被批评，心里十分不爽。这就是典型的吃力不讨好，没有及时与上级进行沟通。很多人总是错误地认为上级是全能全知的，上级的决策一定都是正确的，既然上级安排了临时任务，那一定是有其原因的，也一定知道我正在忙很多事情。这种想法是不可取的。类似这种情况，由于项目需求变更、临时插入紧急任务，一定要及时向上级反馈，不能等到事情搞砸了，再去找各种理由，即便理由再充分，但项目没有按照预期交付，这个结果就是工作没有做好。</p>
<h1 id="关于加班的合理时机">关于加班的合理时机</h1>
<p>说实话，其实我是很反对加班的。虽然我加班还挺多的，但并不是因为我加班多才反对的，主要是加班要加得有意义，加班本身不应成为目的。然而，许多人却将加班视为勤奋的象征。例如，有人会说：“我一个月加班近50个小时，这难道还不算努力吗？”我见过太多人在正常工作时间内拖沓，却把事情留到加班时间去完成，这种行为毫无意义。</p>
<p>加班应该是应对突发情况的手段，而不是常态。比如，当服务器突然宕机，或者线上平台的关键功能无法使用，严重影响用户体验时，这种紧急情况需要立即解决，加班是必要的。这种加班才是有意义的，因为它解决了实际问题，避免了更大的损失。</p>
<p>许多硬性安排的加班往往只是形式主义，大多数人只是在“摸鱼”，不会关注“今天把事情做完”的重要性，不会追求提高工作效率，只是在凑时长而已。</p>
<p>甚至有些人认为“我做得越快，不就是做得越多吗？”这种想法有一定道理，但关键在于如何利用时间。如果你担心完成任务太快会被认为无所事事，那么可以利用剩余时间学习新技术、阅读专业文章，提升自己，这才是更有意义的做法。</p>
]]></content:encoded>
    </item>
    <item>
      <title>12-遇到问题无法解决应该怎么处理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/12-%E9%81%87%E5%88%B0%E9%97%AE%E9%A2%98%E6%97%A0%E6%B3%95%E8%A7%A3%E5%86%B3%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86/</link>
      <pubDate>Wed, 02 Apr 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/12-%E9%81%87%E5%88%B0%E9%97%AE%E9%A2%98%E6%97%A0%E6%B3%95%E8%A7%A3%E5%86%B3%E5%BA%94%E8%AF%A5%E6%80%8E%E4%B9%88%E5%A4%84%E7%90%86/</guid>
      <description>&lt;h1 id=&#34;前言&#34;&gt;前言&lt;/h1&gt;
&lt;p&gt;如果遇到问题，无法解决，应该怎么处理？其实，这个问题要从两个不同的视角来探讨：一个是项目成员的角度，另一个是项目负责人的角度。假设项目成员是李四、王五，项目负责人是张三。&lt;/p&gt;
&lt;h1 id=&#34;及时反馈&#34;&gt;及时反馈&lt;/h1&gt;
&lt;p&gt;比如项目成员李四，有一条功能开发的任务，工期为5天。在开发过程中，他遇到一个无法解决的问题，一个人琢磨了一两天，但始终无法突破，就这样卡在了这个点上。他的心路历程可能是这样的：一方面，他担心自己的技术能力不足，觉得这个问题在别人看来可能很简单，自己居然解决不了；另一方面，他想死磕到底，觉得遇到这样的技术难题，如果不解决就太不甘心了。这些想法本身没有问题，毕竟谁都不想被别人说技术菜，而死磕难题正是极客精神的体现，值得鼓励。&lt;/p&gt;
&lt;p&gt;但问题在于，这种心态放在项目团队中可能会带来隐患。&lt;strong&gt;项目最终看的是产出和结果&lt;/strong&gt;，而不是个人的技术表现。只要项目能够完成，其他因素都是次要的。从这个角度看，担心被人说技术菜、死磕技术难点，都变得毫无意义。因为&lt;strong&gt;解决问题的方式并不唯一，不一定非要从技术入手&lt;/strong&gt;。比如，李四可以把问题及时反馈给项目负责人张三，由张三组织项目团队讨论，甚至与客户沟通，看看是否可以通过微调需求来解决问题。也许客户的需求，用另一种呈现方式同样可以满足，而无需纠结于技术实现本身。&lt;/p&gt;
&lt;p&gt;有人可能会问，如果讨论后发现确实只能通过技术手段解决呢？如果项目负责人张三已经召集项目团队进行讨论，仍然没有解决方案，那又有什么可害怕的？大家绞尽脑汁都没能解决，怎么能说明李四技术很菜呢？如果有人质疑，他完全可以回怼：“你那么厉害，那你来试试看。”&lt;/p&gt;
&lt;p&gt;所以，项目成员遇到问题，如果已经使出浑身解数，还是没能解决，要及时反馈给项目负责人，要从项目全局角度考虑问题，而不只是个人的维度。你及时反馈，虽然是别人给你的解决思路，但最终执行的是你，这条任务还是你来完成的，而你如期完成了这条任务。&lt;/p&gt;
&lt;h1 id=&#34;小心猴子&#34;&gt;小心“猴子”&lt;/h1&gt;
&lt;p&gt;上面是项目成员李四的角度，那么从项目负责人张三的角度来看呢？&lt;/p&gt;
&lt;p&gt;如果项目成员不是像李四那样闷头死磕问题，而是遇到问题就立即反馈，比如王五，张三应该如何应对？&lt;/p&gt;
&lt;p&gt;有些项目负责人可能会及时介入，觉得自己项目同事遇到了问题，自己当仁不让，当然要身先士卒，冲到最前面了。这个本来是很好的行为，出发点也是好的，但这样做的结果是，原本属于王五的开发任务可能完全变成了张三的工作。这就是我们常说的**“小心下属的猴子跳到上级身上”**的问题。王五可能因此变得依赖，而张三则疲于奔命，吃力不讨好。这种情况本质上取决于项目成员的性格和工作态度。如果是这种倾向明显的同事，张三首先要做的不是直接介入，而是反问王五“有好好研究过了吗？”，如果王五支支吾吾，那就先让他自己研究一下，不要遇到点小问题就退缩，如果王五说已经研究过了，那张三就需要及时调整王五任务的优先级，让王五先做其他事情，避免他无所事事，自己再介入。&lt;/p&gt;
&lt;p&gt;意思就是说，对于项目成员反馈的问题，张三可以介入协助，但最好只提供解决问题的思路和建议，比如分享自己调研到的可行方案，然后交给王五去验证。张三的角色主要是引导作用，而不是直接接手去解决问题。他需要激发项目成员的主动性，让他们在遇到问题时真正动脑思考，而不是轻易放弃。如果最终仍然没有解决方案，张三可以召集相关同事讨论，甚至向上级反馈，让更高层来做决策。&lt;/p&gt;
&lt;p&gt;所以，项目负责人在处理项目成员反馈的问题时，应避免替团队成员承担过多责任，而是通过引导和协调，激发他们的主观能动性。一来项目成员可以得到锻炼，二来项目负责人可以投入精力在更重要的事情上，这对于项目团队而言，是大有裨益的。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h1 id="前言">前言</h1>
<p>如果遇到问题，无法解决，应该怎么处理？其实，这个问题要从两个不同的视角来探讨：一个是项目成员的角度，另一个是项目负责人的角度。假设项目成员是李四、王五，项目负责人是张三。</p>
<h1 id="及时反馈">及时反馈</h1>
<p>比如项目成员李四，有一条功能开发的任务，工期为5天。在开发过程中，他遇到一个无法解决的问题，一个人琢磨了一两天，但始终无法突破，就这样卡在了这个点上。他的心路历程可能是这样的：一方面，他担心自己的技术能力不足，觉得这个问题在别人看来可能很简单，自己居然解决不了；另一方面，他想死磕到底，觉得遇到这样的技术难题，如果不解决就太不甘心了。这些想法本身没有问题，毕竟谁都不想被别人说技术菜，而死磕难题正是极客精神的体现，值得鼓励。</p>
<p>但问题在于，这种心态放在项目团队中可能会带来隐患。<strong>项目最终看的是产出和结果</strong>，而不是个人的技术表现。只要项目能够完成，其他因素都是次要的。从这个角度看，担心被人说技术菜、死磕技术难点，都变得毫无意义。因为<strong>解决问题的方式并不唯一，不一定非要从技术入手</strong>。比如，李四可以把问题及时反馈给项目负责人张三，由张三组织项目团队讨论，甚至与客户沟通，看看是否可以通过微调需求来解决问题。也许客户的需求，用另一种呈现方式同样可以满足，而无需纠结于技术实现本身。</p>
<p>有人可能会问，如果讨论后发现确实只能通过技术手段解决呢？如果项目负责人张三已经召集项目团队进行讨论，仍然没有解决方案，那又有什么可害怕的？大家绞尽脑汁都没能解决，怎么能说明李四技术很菜呢？如果有人质疑，他完全可以回怼：“你那么厉害，那你来试试看。”</p>
<p>所以，项目成员遇到问题，如果已经使出浑身解数，还是没能解决，要及时反馈给项目负责人，要从项目全局角度考虑问题，而不只是个人的维度。你及时反馈，虽然是别人给你的解决思路，但最终执行的是你，这条任务还是你来完成的，而你如期完成了这条任务。</p>
<h1 id="小心猴子">小心“猴子”</h1>
<p>上面是项目成员李四的角度，那么从项目负责人张三的角度来看呢？</p>
<p>如果项目成员不是像李四那样闷头死磕问题，而是遇到问题就立即反馈，比如王五，张三应该如何应对？</p>
<p>有些项目负责人可能会及时介入，觉得自己项目同事遇到了问题，自己当仁不让，当然要身先士卒，冲到最前面了。这个本来是很好的行为，出发点也是好的，但这样做的结果是，原本属于王五的开发任务可能完全变成了张三的工作。这就是我们常说的**“小心下属的猴子跳到上级身上”**的问题。王五可能因此变得依赖，而张三则疲于奔命，吃力不讨好。这种情况本质上取决于项目成员的性格和工作态度。如果是这种倾向明显的同事，张三首先要做的不是直接介入，而是反问王五“有好好研究过了吗？”，如果王五支支吾吾，那就先让他自己研究一下，不要遇到点小问题就退缩，如果王五说已经研究过了，那张三就需要及时调整王五任务的优先级，让王五先做其他事情，避免他无所事事，自己再介入。</p>
<p>意思就是说，对于项目成员反馈的问题，张三可以介入协助，但最好只提供解决问题的思路和建议，比如分享自己调研到的可行方案，然后交给王五去验证。张三的角色主要是引导作用，而不是直接接手去解决问题。他需要激发项目成员的主动性，让他们在遇到问题时真正动脑思考，而不是轻易放弃。如果最终仍然没有解决方案，张三可以召集相关同事讨论，甚至向上级反馈，让更高层来做决策。</p>
<p>所以，项目负责人在处理项目成员反馈的问题时，应避免替团队成员承担过多责任，而是通过引导和协调，激发他们的主观能动性。一来项目成员可以得到锻炼，二来项目负责人可以投入精力在更重要的事情上，这对于项目团队而言，是大有裨益的。</p>
]]></content:encoded>
    </item>
    <item>
      <title>11-项目涉及设备的问题</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/11-%E9%A1%B9%E7%9B%AE%E6%B6%89%E5%8F%8A%E8%AE%BE%E5%A4%87%E7%9A%84%E9%97%AE%E9%A2%98/</link>
      <pubDate>Sun, 30 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/11-%E9%A1%B9%E7%9B%AE%E6%B6%89%E5%8F%8A%E8%AE%BE%E5%A4%87%E7%9A%84%E9%97%AE%E9%A2%98/</guid>
      <description>&lt;p&gt;我们部门在开发一些项目时，确实需要借用设备，但每次开发新需求时都要从硬件部门借设备，开发完成后又要归还。这种频繁的借还流程不仅增加了沟通成本，还导致项目负责人和开发人员对设备的功能和应用场景缺乏直观的了解。有时甚至连设备长什么样都不知道，这显然不利于我们真正理解业务需求，甚至可能导致开发方向与实际业务脱节。&lt;/p&gt;
&lt;p&gt;有人提议是否可以申请一些设备常驻我们部门，让项目相关人员在开发过程中能够随时试用设备，真实感受应用场景，同时遇到问题时可以立即用设备重现和排查。这个想法确实有一定道理，但仔细想想，设备本身也在不断迭代，如果设备长期放在我们部门，可能只能停留在某个版本，后续更新无法跟上，反而会限制我们的开发思路。此外，设备的使用频率主要集中在开发阶段，项目上线后很少再被关注，长期占用硬件资源可能造成浪费。&lt;/p&gt;
&lt;p&gt;其实，我们的核心问题并不是设备是否常驻，而是如何让开发人员在开发阶段有机会试用设备，从而增强对业务的理解和对设备功能的熟悉。与其申请设备常驻，不如在开发阶段短期借用设备，确保开发人员在关键阶段能够充分接触和使用设备，同时避免资源的长期占用。这样既能满足开发需求，又能兼顾资源的合理利用。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>我们部门在开发一些项目时，确实需要借用设备，但每次开发新需求时都要从硬件部门借设备，开发完成后又要归还。这种频繁的借还流程不仅增加了沟通成本，还导致项目负责人和开发人员对设备的功能和应用场景缺乏直观的了解。有时甚至连设备长什么样都不知道，这显然不利于我们真正理解业务需求，甚至可能导致开发方向与实际业务脱节。</p>
<p>有人提议是否可以申请一些设备常驻我们部门，让项目相关人员在开发过程中能够随时试用设备，真实感受应用场景，同时遇到问题时可以立即用设备重现和排查。这个想法确实有一定道理，但仔细想想，设备本身也在不断迭代，如果设备长期放在我们部门，可能只能停留在某个版本，后续更新无法跟上，反而会限制我们的开发思路。此外，设备的使用频率主要集中在开发阶段，项目上线后很少再被关注，长期占用硬件资源可能造成浪费。</p>
<p>其实，我们的核心问题并不是设备是否常驻，而是如何让开发人员在开发阶段有机会试用设备，从而增强对业务的理解和对设备功能的熟悉。与其申请设备常驻，不如在开发阶段短期借用设备，确保开发人员在关键阶段能够充分接触和使用设备，同时避免资源的长期占用。这样既能满足开发需求，又能兼顾资源的合理利用。</p>
]]></content:encoded>
    </item>
    <item>
      <title>10-项目需求变更时如何处理？</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/10-%E9%A1%B9%E7%9B%AE%E9%9C%80%E6%B1%82%E5%8F%98%E6%9B%B4%E6%97%B6%E5%A6%82%E4%BD%95%E5%A4%84%E7%90%86/</link>
      <pubDate>Sat, 29 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/10-%E9%A1%B9%E7%9B%AE%E9%9C%80%E6%B1%82%E5%8F%98%E6%9B%B4%E6%97%B6%E5%A6%82%E4%BD%95%E5%A4%84%E7%90%86/</guid>
      <description>&lt;p&gt;虽然在项目开发前期，我们已经做好准备工作，一个环节到一个环节有条不紊地执行，但不可否认，在这个过程中，难免会出现需求变更的情况。作为项目负责人，应该怎么去处理这件事呢？&lt;/p&gt;
&lt;p&gt;项目遇到需求变更，通常都是新增需求，很少是减少需求的变更。简而言之，就是增加了工作量。而项目负责人面临的难题在于：如何在不影响整体计划的前提下，高效应对这种变化。需求变更的规模有大有小，不可一概而论。如果是小的变更，那无伤大雅，适当微调即可。但倘若是很大的变更，比如新增的功能开发需要一两周甚至更长时间，那么整个项目计划可能就需要推倒重做，这无可厚非。&lt;/p&gt;
&lt;p&gt;我们要探讨的是介于这大小之间的需求变更——那些有机会在当前计划里解决掉的需求，比如增加了一周的工作量。你有信心能按当前制定的计划如期交付吗？现在的情况是，我们可能只是将需求变更分为大小两个情况：小的微调，大的立刻调整项目计划，然后项目上线时间就会变更。久而久之，这种处理方式可能会让人觉得理所当然。&lt;/p&gt;
&lt;p&gt;事实上，大部分项目开发工作是有协商空间的，并未被完全限定死。遇到突发情况，比如客户需求变更，但交付时间没有任何商量余地时，项目负责人该怎么办？有人可能会说加班，但有时加班未必能解决问题。&lt;/p&gt;
&lt;p&gt;也许现在我们可以慢慢培养这方面的意识和能力，在平时多积累这方面的经验，避免真正遇到事情时手忙脚乱、无从下手。也就是说，我们可以将需求变更分为三种情况：小的变更，微调即可；大的变更，比如需要增加两周工作量，那就变更项目计划；中等变更，比如需要增加一周工作量，我们先不急于调整计划 ，而是先想一想：有没有什么办法可以在不变更计划的情况下解决这个问题？然后将各种可能的解决方案列出来（1、2、3……），召集项目其他成员一起讨论。也许经过多轮讨论，我们就能找到解决方案。如果讨论后仍无法解决，再根据实际情况变更项目计划。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>虽然在项目开发前期，我们已经做好准备工作，一个环节到一个环节有条不紊地执行，但不可否认，在这个过程中，难免会出现需求变更的情况。作为项目负责人，应该怎么去处理这件事呢？</p>
<p>项目遇到需求变更，通常都是新增需求，很少是减少需求的变更。简而言之，就是增加了工作量。而项目负责人面临的难题在于：如何在不影响整体计划的前提下，高效应对这种变化。需求变更的规模有大有小，不可一概而论。如果是小的变更，那无伤大雅，适当微调即可。但倘若是很大的变更，比如新增的功能开发需要一两周甚至更长时间，那么整个项目计划可能就需要推倒重做，这无可厚非。</p>
<p>我们要探讨的是介于这大小之间的需求变更——那些有机会在当前计划里解决掉的需求，比如增加了一周的工作量。你有信心能按当前制定的计划如期交付吗？现在的情况是，我们可能只是将需求变更分为大小两个情况：小的微调，大的立刻调整项目计划，然后项目上线时间就会变更。久而久之，这种处理方式可能会让人觉得理所当然。</p>
<p>事实上，大部分项目开发工作是有协商空间的，并未被完全限定死。遇到突发情况，比如客户需求变更，但交付时间没有任何商量余地时，项目负责人该怎么办？有人可能会说加班，但有时加班未必能解决问题。</p>
<p>也许现在我们可以慢慢培养这方面的意识和能力，在平时多积累这方面的经验，避免真正遇到事情时手忙脚乱、无从下手。也就是说，我们可以将需求变更分为三种情况：小的变更，微调即可；大的变更，比如需要增加两周工作量，那就变更项目计划；中等变更，比如需要增加一周工作量，我们先不急于调整计划 ，而是先想一想：有没有什么办法可以在不变更计划的情况下解决这个问题？然后将各种可能的解决方案列出来（1、2、3……），召集项目其他成员一起讨论。也许经过多轮讨论，我们就能找到解决方案。如果讨论后仍无法解决，再根据实际情况变更项目计划。</p>
]]></content:encoded>
    </item>
    <item>
      <title>09-项目任务不应写多人负责</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/09-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E4%B8%8D%E5%BA%94%E5%86%99%E5%A4%9A%E4%BA%BA%E8%B4%9F%E8%B4%A3/</link>
      <pubDate>Wed, 26 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/09-%E9%A1%B9%E7%9B%AE%E4%BB%BB%E5%8A%A1%E4%B8%8D%E5%BA%94%E5%86%99%E5%A4%9A%E4%BA%BA%E8%B4%9F%E8%B4%A3/</guid>
      <description>&lt;p&gt;在项目开发过程中，我们常常会遇到一些任务需要多人共同负责的情况。例如，某个功能任务需要前后端同步开发，如果把前后端的开发人员都归到同一条任务上，就会出现一些问题。&lt;/p&gt;
&lt;p&gt;举个例子，设备管理模块的开发需要张三负责后端，李四负责前端。如果将他们的任务写在一起，当前进度显示为&lt;code&gt;60%&lt;/code&gt;，我们无法直接了解具体情况。这个&lt;code&gt;60%&lt;/code&gt;可能意味着后端已完成，只是前端还在开发；也可能是后端和前端都还未完成。这样一来，项目负责人就不得不去沟通询问，才能知道真实情况，这无疑降低了工作效率。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503261452379.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;因此，项目开发计划里的任务最好是一人一条，拆分清晰。这样做的好处有两个：一是可以明确职责，避免出现责任不清的情况；二是任务状态会更加透明，项目负责人能够一目了然地掌握每个环节的进展，从而减少管理难度。&lt;/p&gt;
&lt;p&gt;如下图所示，当任务拆分清晰后，我们可以立刻知道设备管理功能模块的后端开发进度为&lt;code&gt;100%&lt;/code&gt;，已经完成，而前端开发进度为&lt;code&gt;20%&lt;/code&gt;。这样一来，项目负责人就能根据这些信息及时调整计划，合理安排后续工作，确保项目顺利推进。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503261502187.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>在项目开发过程中，我们常常会遇到一些任务需要多人共同负责的情况。例如，某个功能任务需要前后端同步开发，如果把前后端的开发人员都归到同一条任务上，就会出现一些问题。</p>
<p>举个例子，设备管理模块的开发需要张三负责后端，李四负责前端。如果将他们的任务写在一起，当前进度显示为<code>60%</code>，我们无法直接了解具体情况。这个<code>60%</code>可能意味着后端已完成，只是前端还在开发；也可能是后端和前端都还未完成。这样一来，项目负责人就不得不去沟通询问，才能知道真实情况，这无疑降低了工作效率。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503261452379.png"></p>
<p>因此，项目开发计划里的任务最好是一人一条，拆分清晰。这样做的好处有两个：一是可以明确职责，避免出现责任不清的情况；二是任务状态会更加透明，项目负责人能够一目了然地掌握每个环节的进展，从而减少管理难度。</p>
<p>如下图所示，当任务拆分清晰后，我们可以立刻知道设备管理功能模块的后端开发进度为<code>100%</code>，已经完成，而前端开发进度为<code>20%</code>。这样一来，项目负责人就能根据这些信息及时调整计划，合理安排后续工作，确保项目顺利推进。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503261502187.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>08-项目中不可控的任务如何安排和验收</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/08-%E9%A1%B9%E7%9B%AE%E4%B8%AD%E4%B8%8D%E5%8F%AF%E6%8E%A7%E7%9A%84%E4%BB%BB%E5%8A%A1%E5%A6%82%E4%BD%95%E5%AE%89%E6%8E%92%E5%92%8C%E9%AA%8C%E6%94%B6/</link>
      <pubDate>Tue, 25 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/08-%E9%A1%B9%E7%9B%AE%E4%B8%AD%E4%B8%8D%E5%8F%AF%E6%8E%A7%E7%9A%84%E4%BB%BB%E5%8A%A1%E5%A6%82%E4%BD%95%E5%AE%89%E6%8E%92%E5%92%8C%E9%AA%8C%E6%94%B6/</guid>
      <description>&lt;p&gt;项目中有时会有一些任务的时间是不可控的，不可控的原因在于该工作完全受制于他人。意思就是如果其他人没有做好，比如前后端同步开发，前端通常可能会快一些，然后要等后端提供接口，这个时候联调工作是没办法开展的，也不知道什么时候可以，自己就会很被动，走走停停，既浪费时间精力，也容易没有任何产出。这种通常是其他人还没做好的情况，最怕的是那一种，比如设备那边说已经很OK了，现在可以开发了，然后去试用了，发现还是不行，然后一下子不知道该干嘛了，也不知道什么时候可以改好，等的话可能要很久，就浪费时间了，不等的话可能一下子就修复好可用了，自己完全处于左右为难的状态。&lt;/p&gt;
&lt;p&gt;之前有APP项目就是这样的情况，本来APP功能已经开发好了，然后测试阶段，设备经常出现问题，可以用但是又不稳定，经常测到一半就测不下去了，然后反馈给到设备那边，改了好几次，觉得可以了，又继续测试了，后来还是不行。反复多次我才醒悟苗头不对，不能再这样下去了，立马中止项目测试，和设备那边沟通，设备需要确保完全没有问题，再继续这个项目的工作，可以说是血的教训。&lt;/p&gt;
&lt;p&gt;这个问题之所以会造成那么大的影响，是因为我们在和他人协作的时候，没有和对方明确一个具体的时间节点，而是很含糊地回答道：“等某某完成了我才可以对接”，然后再问一句：“那他什么时候可以做完呢？过几天吧”，到底是几天？哪一天的？不知道呢。这样是有隐患的，因为这些模糊的信息，负责对接的开发同事完全就是看天吃饭了，任何结果完全是随机的。过几天，可能是一天，也可能是两天，甚至是一周或者更多，再者，项目负责人调整项目任务的时间也会变得很困难。&lt;/p&gt;
&lt;p&gt;我们需要和对方明确一个具体的时间节点，比如前端同事需要问下后端的同事，接口是哪一天可以提供使用，而这个使用的意思，基本上是自测过的，不说一个Bug都没有，至少是相对稳定的。我们知道这个具体的时间节点之后，就可以先安排其他事情了，项目开发工作的开展就会很清晰，而不是完全混乱的。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>项目中有时会有一些任务的时间是不可控的，不可控的原因在于该工作完全受制于他人。意思就是如果其他人没有做好，比如前后端同步开发，前端通常可能会快一些，然后要等后端提供接口，这个时候联调工作是没办法开展的，也不知道什么时候可以，自己就会很被动，走走停停，既浪费时间精力，也容易没有任何产出。这种通常是其他人还没做好的情况，最怕的是那一种，比如设备那边说已经很OK了，现在可以开发了，然后去试用了，发现还是不行，然后一下子不知道该干嘛了，也不知道什么时候可以改好，等的话可能要很久，就浪费时间了，不等的话可能一下子就修复好可用了，自己完全处于左右为难的状态。</p>
<p>之前有APP项目就是这样的情况，本来APP功能已经开发好了，然后测试阶段，设备经常出现问题，可以用但是又不稳定，经常测到一半就测不下去了，然后反馈给到设备那边，改了好几次，觉得可以了，又继续测试了，后来还是不行。反复多次我才醒悟苗头不对，不能再这样下去了，立马中止项目测试，和设备那边沟通，设备需要确保完全没有问题，再继续这个项目的工作，可以说是血的教训。</p>
<p>这个问题之所以会造成那么大的影响，是因为我们在和他人协作的时候，没有和对方明确一个具体的时间节点，而是很含糊地回答道：“等某某完成了我才可以对接”，然后再问一句：“那他什么时候可以做完呢？过几天吧”，到底是几天？哪一天的？不知道呢。这样是有隐患的，因为这些模糊的信息，负责对接的开发同事完全就是看天吃饭了，任何结果完全是随机的。过几天，可能是一天，也可能是两天，甚至是一周或者更多，再者，项目负责人调整项目任务的时间也会变得很困难。</p>
<p>我们需要和对方明确一个具体的时间节点，比如前端同事需要问下后端的同事，接口是哪一天可以提供使用，而这个使用的意思，基本上是自测过的，不说一个Bug都没有，至少是相对稳定的。我们知道这个具体的时间节点之后，就可以先安排其他事情了，项目开发工作的开展就会很清晰，而不是完全混乱的。</p>
]]></content:encoded>
    </item>
    <item>
      <title>07-项目中应提前准备下一阶段计划</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/07-%E9%A1%B9%E7%9B%AE%E4%B8%AD%E5%BA%94%E6%8F%90%E5%89%8D%E5%87%86%E5%A4%87%E4%B8%8B%E4%B8%80%E9%98%B6%E6%AE%B5%E8%AE%A1%E5%88%92/</link>
      <pubDate>Mon, 24 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/07-%E9%A1%B9%E7%9B%AE%E4%B8%AD%E5%BA%94%E6%8F%90%E5%89%8D%E5%87%86%E5%A4%87%E4%B8%8B%E4%B8%80%E9%98%B6%E6%AE%B5%E8%AE%A1%E5%88%92/</guid>
      <description>&lt;p&gt;在项目当前版本的功能开发任务都完成之后，&lt;strong&gt;人就空出来了&lt;/strong&gt;，通常这个时候，项目负责人还有很多繁琐的工作要做，比如项目内部验收、提交测试申请和版本发布等等。为了给项目成员找事情做，就匆匆忙忙安排下个版本的任务，然后项目成员只是简单了解下需求，就开始敲代码了。前期的需求分析、方案设计、开发计划，项目负责人是没有时间系统地去梳理的，这就容易造成项目成员在新功能开发过程中，需求理解有偏差，加上当前版本发布时间节点不明确，目标感也不强。&lt;/p&gt;
&lt;p&gt;项目负责人的开发任务应比项目成员提前3天左右时间结束，这个时候项目的其他功能还在继续开发，项目负责人可以借机着手准备下个阶段的任务（之所以是下个阶段，而不是下个版本，是因为有可能不是迭代这个项目了），将需求进行梳理分析，编写方案设计和制定开发计划，等到其他项目成员开发任务完成之后，就接着下个阶段的任务进行，项目负责人这时再回到当前项目，去做内部验收和提交测试申请，整个衔接是很清晰顺畅，不至于那么被动，捉襟见肘。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>在项目当前版本的功能开发任务都完成之后，<strong>人就空出来了</strong>，通常这个时候，项目负责人还有很多繁琐的工作要做，比如项目内部验收、提交测试申请和版本发布等等。为了给项目成员找事情做，就匆匆忙忙安排下个版本的任务，然后项目成员只是简单了解下需求，就开始敲代码了。前期的需求分析、方案设计、开发计划，项目负责人是没有时间系统地去梳理的，这就容易造成项目成员在新功能开发过程中，需求理解有偏差，加上当前版本发布时间节点不明确，目标感也不强。</p>
<p>项目负责人的开发任务应比项目成员提前3天左右时间结束，这个时候项目的其他功能还在继续开发，项目负责人可以借机着手准备下个阶段的任务（之所以是下个阶段，而不是下个版本，是因为有可能不是迭代这个项目了），将需求进行梳理分析，编写方案设计和制定开发计划，等到其他项目成员开发任务完成之后，就接着下个阶段的任务进行，项目负责人这时再回到当前项目，去做内部验收和提交测试申请，整个衔接是很清晰顺畅，不至于那么被动，捉襟见肘。</p>
]]></content:encoded>
    </item>
    <item>
      <title>06-项目计划如何制定</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/06-%E9%A1%B9%E7%9B%AE%E8%AE%A1%E5%88%92%E5%A6%82%E4%BD%95%E5%88%B6%E5%AE%9A/</link>
      <pubDate>Sun, 23 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/06-%E9%A1%B9%E7%9B%AE%E8%AE%A1%E5%88%92%E5%A6%82%E4%BD%95%E5%88%B6%E5%AE%9A/</guid>
      <description>&lt;p&gt;我们在制定项目计划的时候，如果只是把功能开发部分列出来，如下图所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157068.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;可能会造成项目延期，在上一篇文章《05-项目为什么总是延期》中已经分析过了，这里就不再赘述了，我们现在要探讨的是，如何制定一个项目计划呢？&lt;/p&gt;
&lt;p&gt;在开始项目计划制定之前，可以先了解一下开发模式的相关知识，这部分主要是&lt;a href=&#34;https://b23.tv/eeIEBa2&#34;&gt;《【清华大学】项目管理的逻辑（全6讲）》&lt;/a&gt;里面的内容，有兴趣的可以去看一下，还是很不错的。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. 瀑布式开发&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;预测型开发，在还没有开始着手编写代码前，就可以提前预知结果如何，之所以叫瀑布式，是因为整个开发流程都是有序的，就像水从上往下流，每一步做很到位就到下一阶段。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. 迭代式开发&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;迭代式开发，顾名思义，就是一个版本接着一个版本进行迭代，先将项目整体框架搭建好，然后基础布局全部铺开，就好像画人物肖像一样，先勾勒草图，画出人物整体轮廓，然后才依次画出脑袋、眉毛、眼睛、鼻子、嘴巴等等，全部画出来之后，才是着色。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. 增量式开发&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;增量式开发，咋听之下，与迭代式开发的意思一样，实际上是不一样的，增量式开发的意思是，每次只构建一点，每个阶段就交付一部分，然后组合在一起，还是用画人物肖像来举例子，一开始先画头发，画完之后上色，然后接着是眉毛，画好之后着色，以此类推，全部画好一个地方再接着画另一个地方，如下图所示：&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157400.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;4. 敏捷式开发&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;适应型开发，灵活性很高，需求可以随时提，然后放到需求池里，可能两周一个周期发一个版本。因为能干的活儿很有限，就像坐地铁一样，人很多，挤不上去那就下一趟，所以敏捷开发的思路就是，未必做得到，所以下个版本实现需求，可以有节奏地持续开发。&lt;/p&gt;
&lt;p&gt;以上就是常用的开发模式，但是我们在实际应用中，应该怎么选择哪一种开发模式呢？为此有一个&lt;code&gt;STACEY&lt;/code&gt;矩阵图可以作一些参考，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157174.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;从上图中可以知道，选择哪种开发模式，是基于需求和技术两个维度去评估的，所以项目负责人在编写项目需求与方案文档的时候，可能就可以做出判断了。说回我们自身，开发模式毕竟只是项目管理中的一种技巧，要深刻认识到它并不是万能的，如果掉入盲目迷信权威的陷阱，那么就太死板了，真正应用的时候，还是要考虑实际情况，在遵循基本原则的基础上，要明白事物变化的重要性，在变化的世界里使用不变的方法是不现实的，没有任何一种开发模式能够适用全部的项目。&lt;/p&gt;
&lt;p&gt;现在部门按照项目来管理，每个人都比较清楚自己要做的事情，也没有那么多交叉的任务，所以变更理应很少才对，在制定项目计划的时候，我们可以把项目开发的周期全部列出，虽然项目计划通常都会有变更，但项目计划最好能够做到有始有终，把全部任务时间明确一下，然后项目交付时间基本就确定了，其中的任意环节有变更，很有可能是不会影响到项目交付时间的。我们可以把项目计划分为11个环节，如下所示：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;需求分析&lt;/li&gt;
&lt;li&gt;原型设计&lt;/li&gt;
&lt;li&gt;方案设计&lt;/li&gt;
&lt;li&gt;开发计划&lt;/li&gt;
&lt;li&gt;开发阶段&lt;/li&gt;
&lt;li&gt;下版计划（下一阶段任务计划）&lt;/li&gt;
&lt;li&gt;内部验收&lt;/li&gt;
&lt;li&gt;产品验收&lt;/li&gt;
&lt;li&gt;测试阶段&lt;/li&gt;
&lt;li&gt;模拟升级&lt;/li&gt;
&lt;li&gt;正式发布&lt;/li&gt;
&lt;li&gt;复盘会议&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;如下图所示，就是根据这11个环节制定的项目开发计划，虽然实际情况会有所出入，但是可以知道这个项目12月底基本上就可以交付了，有这样很清晰的时间节点，对于接下来的开发工作，会更有目标和方向感，其中经常出现任务变更，大多是在开发阶段，但是并不代表做好这个环节就没事了，接下来的环节如果遇到问题，也是会影响到项目交付的，所以怎么能管理好一个项目，是需要多方面去思考和解决问题的，并不是只做好开发任务环节就行了。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157081.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>我们在制定项目计划的时候，如果只是把功能开发部分列出来，如下图所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157068.png"></p>
<p>可能会造成项目延期，在上一篇文章《05-项目为什么总是延期》中已经分析过了，这里就不再赘述了，我们现在要探讨的是，如何制定一个项目计划呢？</p>
<p>在开始项目计划制定之前，可以先了解一下开发模式的相关知识，这部分主要是<a href="https://b23.tv/eeIEBa2">《【清华大学】项目管理的逻辑（全6讲）》</a>里面的内容，有兴趣的可以去看一下，还是很不错的。</p>
<p><strong>1. 瀑布式开发</strong></p>
<p>预测型开发，在还没有开始着手编写代码前，就可以提前预知结果如何，之所以叫瀑布式，是因为整个开发流程都是有序的，就像水从上往下流，每一步做很到位就到下一阶段。</p>
<p><strong>2. 迭代式开发</strong></p>
<p>迭代式开发，顾名思义，就是一个版本接着一个版本进行迭代，先将项目整体框架搭建好，然后基础布局全部铺开，就好像画人物肖像一样，先勾勒草图，画出人物整体轮廓，然后才依次画出脑袋、眉毛、眼睛、鼻子、嘴巴等等，全部画出来之后，才是着色。</p>
<p><strong>3. 增量式开发</strong></p>
<p>增量式开发，咋听之下，与迭代式开发的意思一样，实际上是不一样的，增量式开发的意思是，每次只构建一点，每个阶段就交付一部分，然后组合在一起，还是用画人物肖像来举例子，一开始先画头发，画完之后上色，然后接着是眉毛，画好之后着色，以此类推，全部画好一个地方再接着画另一个地方，如下图所示：<img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157400.png"></p>
<p><strong>4. 敏捷式开发</strong></p>
<p>适应型开发，灵活性很高，需求可以随时提，然后放到需求池里，可能两周一个周期发一个版本。因为能干的活儿很有限，就像坐地铁一样，人很多，挤不上去那就下一趟，所以敏捷开发的思路就是，未必做得到，所以下个版本实现需求，可以有节奏地持续开发。</p>
<p>以上就是常用的开发模式，但是我们在实际应用中，应该怎么选择哪一种开发模式呢？为此有一个<code>STACEY</code>矩阵图可以作一些参考，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157174.png"></p>
<p>从上图中可以知道，选择哪种开发模式，是基于需求和技术两个维度去评估的，所以项目负责人在编写项目需求与方案文档的时候，可能就可以做出判断了。说回我们自身，开发模式毕竟只是项目管理中的一种技巧，要深刻认识到它并不是万能的，如果掉入盲目迷信权威的陷阱，那么就太死板了，真正应用的时候，还是要考虑实际情况，在遵循基本原则的基础上，要明白事物变化的重要性，在变化的世界里使用不变的方法是不现实的，没有任何一种开发模式能够适用全部的项目。</p>
<p>现在部门按照项目来管理，每个人都比较清楚自己要做的事情，也没有那么多交叉的任务，所以变更理应很少才对，在制定项目计划的时候，我们可以把项目开发的周期全部列出，虽然项目计划通常都会有变更，但项目计划最好能够做到有始有终，把全部任务时间明确一下，然后项目交付时间基本就确定了，其中的任意环节有变更，很有可能是不会影响到项目交付时间的。我们可以把项目计划分为11个环节，如下所示：</p>
<ol>
<li>需求分析</li>
<li>原型设计</li>
<li>方案设计</li>
<li>开发计划</li>
<li>开发阶段</li>
<li>下版计划（下一阶段任务计划）</li>
<li>内部验收</li>
<li>产品验收</li>
<li>测试阶段</li>
<li>模拟升级</li>
<li>正式发布</li>
<li>复盘会议</li>
</ol>
<p>如下图所示，就是根据这11个环节制定的项目开发计划，虽然实际情况会有所出入，但是可以知道这个项目12月底基本上就可以交付了，有这样很清晰的时间节点，对于接下来的开发工作，会更有目标和方向感，其中经常出现任务变更，大多是在开发阶段，但是并不代表做好这个环节就没事了，接下来的环节如果遇到问题，也是会影响到项目交付的，所以怎么能管理好一个项目，是需要多方面去思考和解决问题的，并不是只做好开发任务环节就行了。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202302282157081.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>05-项目为什么总是延期</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/05-%E9%A1%B9%E7%9B%AE%E4%B8%BA%E4%BB%80%E4%B9%88%E6%80%BB%E6%98%AF%E5%BB%B6%E6%9C%9F/</link>
      <pubDate>Fri, 21 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/05-%E9%A1%B9%E7%9B%AE%E4%B8%BA%E4%BB%80%E4%B9%88%E6%80%BB%E6%98%AF%E5%BB%B6%E6%9C%9F/</guid>
      <description>&lt;p&gt;当前一个项目在开发新需求的时候，我们制定的计划只是列出功能开发的部分，并不是整个项目全部的周期，这就造成项目从开始到能够正式上线，时间规划是不全面、不清晰的（只是代码编写部分有时间计划），项目负责人基本上只会关注功能开发的部分，至于内部验收、Bug修复、测试周期和版本发布时间等等环节，有点听天由命，完全是看前一个环节进展的情况而定——前一个环节进展顺利，那就到下一个环节，进展不顺利就变更下个环节的时间，反复几次，项目上线的时间一拖再拖，遥遥无期。&lt;/p&gt;
&lt;p&gt;之所以会这样，是因为在项目推进过程中，我们聚焦的一直是&lt;strong&gt;解决项目当前遇到的难题&lt;/strong&gt;，为了解决这个难题，不断地调整项目任务计划时间，明天后天下周下个月等等。也许我们可以转换一下思路：项目推进过程中，以终为始，以最终结果为导向，聚焦&lt;strong&gt;项目上线发布&lt;/strong&gt;这个目标。为了达成这个目标，我们要采取不同的做事情方式，也就是多维度思考如何解决问题。&lt;/p&gt;
&lt;p&gt;导致项目进度受阻的问题有大有小，如果是不可抗力的情况（比如有的项目需要用到设备，结果设备完全用不了），那当然没有办法，但这种情况相对来说还是比较少的。其他的那些问题就要想一下，是不是当下一定要解决，或者说一定要从技术层面解决才行呢？那当然不是，我们的需求只是解决问题，问题解决了就行，并不关心用了什么方式。就好像要从广州到北京，需求只是要去到北京，并不在乎你怎么过去，是要坐飞机、坐动车、自己开车或者打车什么都可以，只要能到北京就行。&lt;/p&gt;
&lt;p&gt;在项目推进过程中，项目负责人遇到问题时，以前可能是这样思考的：&amp;ldquo;这个问题解决起来很困难，可能需要5天的时间，我要问一下，项目计划能不能变更，调整一下上线的时间？&amp;ldquo;现在的话，如果是以终为始，可能就需要这样思考了：&amp;ldquo;这个问题解决起来很困难，可能需要5天时间，这个版本计划11月15日上线，时间有点紧张——这个功能是不是必须的？一定是这个版本要加的么？能不能下个版本？为什么需要5天的时间，有没有其他更好的解决方案？5天的时间里，我是不是可以先做其他事情？测试阶段、发版阶段还有没有什么潜在的问题？第三方编译走通过了么？时间有点赶，问题有点多，可能要动员一下，让大家知道现在时间有点紧张，加加班才行了，宁愿赶在前面，也不要后面遇到问题了没时间解决。&amp;rdquo;&lt;/p&gt;
&lt;p&gt;我们倾向于哪怕只是一点点可能性，也要挣扎一下，不要那么容易就缴械投降。还是要回到小平同志说的那句话：&amp;ldquo;不管黑猫白猫，能捉老鼠的就是好猫。&amp;rdquo;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>当前一个项目在开发新需求的时候，我们制定的计划只是列出功能开发的部分，并不是整个项目全部的周期，这就造成项目从开始到能够正式上线，时间规划是不全面、不清晰的（只是代码编写部分有时间计划），项目负责人基本上只会关注功能开发的部分，至于内部验收、Bug修复、测试周期和版本发布时间等等环节，有点听天由命，完全是看前一个环节进展的情况而定——前一个环节进展顺利，那就到下一个环节，进展不顺利就变更下个环节的时间，反复几次，项目上线的时间一拖再拖，遥遥无期。</p>
<p>之所以会这样，是因为在项目推进过程中，我们聚焦的一直是<strong>解决项目当前遇到的难题</strong>，为了解决这个难题，不断地调整项目任务计划时间，明天后天下周下个月等等。也许我们可以转换一下思路：项目推进过程中，以终为始，以最终结果为导向，聚焦<strong>项目上线发布</strong>这个目标。为了达成这个目标，我们要采取不同的做事情方式，也就是多维度思考如何解决问题。</p>
<p>导致项目进度受阻的问题有大有小，如果是不可抗力的情况（比如有的项目需要用到设备，结果设备完全用不了），那当然没有办法，但这种情况相对来说还是比较少的。其他的那些问题就要想一下，是不是当下一定要解决，或者说一定要从技术层面解决才行呢？那当然不是，我们的需求只是解决问题，问题解决了就行，并不关心用了什么方式。就好像要从广州到北京，需求只是要去到北京，并不在乎你怎么过去，是要坐飞机、坐动车、自己开车或者打车什么都可以，只要能到北京就行。</p>
<p>在项目推进过程中，项目负责人遇到问题时，以前可能是这样思考的：&ldquo;这个问题解决起来很困难，可能需要5天的时间，我要问一下，项目计划能不能变更，调整一下上线的时间？&ldquo;现在的话，如果是以终为始，可能就需要这样思考了：&ldquo;这个问题解决起来很困难，可能需要5天时间，这个版本计划11月15日上线，时间有点紧张——这个功能是不是必须的？一定是这个版本要加的么？能不能下个版本？为什么需要5天的时间，有没有其他更好的解决方案？5天的时间里，我是不是可以先做其他事情？测试阶段、发版阶段还有没有什么潜在的问题？第三方编译走通过了么？时间有点赶，问题有点多，可能要动员一下，让大家知道现在时间有点紧张，加加班才行了，宁愿赶在前面，也不要后面遇到问题了没时间解决。&rdquo;</p>
<p>我们倾向于哪怕只是一点点可能性，也要挣扎一下，不要那么容易就缴械投降。还是要回到小平同志说的那句话：&ldquo;不管黑猫白猫，能捉老鼠的就是好猫。&rdquo;</p>
]]></content:encoded>
    </item>
    <item>
      <title>04-项目负责人对业务不熟悉</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/04-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E5%AF%B9%E4%B8%9A%E5%8A%A1%E4%B8%8D%E7%86%9F%E6%82%89/</link>
      <pubDate>Thu, 20 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/04-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E5%AF%B9%E4%B8%9A%E5%8A%A1%E4%B8%8D%E7%86%9F%E6%82%89/</guid>
      <description>&lt;p&gt;一直以来，项目管理中存在一个较为突出的问题：项目负责人在接到产品需求后，往往只是简单浏览一眼，便着手制定项目开发计划。计划制定完成后，负责人通常只深入研究自己负责开发的模块，而对其他模块则不再深入了解。对于由其他同事负责开发的功能模块，项目负责人通常连三个基本问题都无法准确回答：一是“是什么”，即这个功能具体是什么；二是“为什么”，即客户为什么需要这个功能，这个功能对客户有什么实际用途，是否可以不开发；三是“怎么做”，即这个功能在前端和后端分别是如何实现的。即便能回答到第三个问题，通常也仅能涉及前端或后端的部分内容。而实际情况往往更为糟糕，有时连第一个问题都无法准确回答。负责开发该功能模块的同事，可能也是在开发过程中逐步了解需求，其对需求的掌握程度，刚好足以完成功能开发即可。&lt;/p&gt;
&lt;p&gt;这种状况容易导致项目管理出现诸多问题，表面上看似平静，实则处于一种失控状态，主要体现在以下几个方面：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;任务时间评估不到位&lt;/strong&gt;：项目负责人由于对整体功能和需求缺乏深入了解，导致在评估任务所需时间时不够准确，经常需要变更任务计划，影响项目进度的稳定性。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;风险意识不足&lt;/strong&gt;：由于对业务不够熟悉，项目负责人无法提前识别潜在的延期风险因素，也无法有效判断是否需要安排加班来应对可能出现的问题，从而增加了项目按时完成的不确定性。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;strong&gt;任务验收困难&lt;/strong&gt;：在验收功能时，由于项目负责人对业务和需求不够了解，只能依赖开发同事的回答来判断功能是否实现以及是否与需求一致。这种情况下，验收工作往往流于形式，难以深入和全面地评估功能质量，导致验收工作的积极性和效果都不理想。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;为了解决这些问题，项目负责人需要自行梳理一份详细的项目需求与功能实现文档。比如下图所示的文档格式。在文档中，将每个功能按照“是什么”、“为什么”、“怎么做”这三个问题进行清晰的梳理和记录。在项目推进过程中，一旦出现需求变更，应及时更新文档，确保项目负责人对项目的整体情况有清晰的把握和了解。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503202330117.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>一直以来，项目管理中存在一个较为突出的问题：项目负责人在接到产品需求后，往往只是简单浏览一眼，便着手制定项目开发计划。计划制定完成后，负责人通常只深入研究自己负责开发的模块，而对其他模块则不再深入了解。对于由其他同事负责开发的功能模块，项目负责人通常连三个基本问题都无法准确回答：一是“是什么”，即这个功能具体是什么；二是“为什么”，即客户为什么需要这个功能，这个功能对客户有什么实际用途，是否可以不开发；三是“怎么做”，即这个功能在前端和后端分别是如何实现的。即便能回答到第三个问题，通常也仅能涉及前端或后端的部分内容。而实际情况往往更为糟糕，有时连第一个问题都无法准确回答。负责开发该功能模块的同事，可能也是在开发过程中逐步了解需求，其对需求的掌握程度，刚好足以完成功能开发即可。</p>
<p>这种状况容易导致项目管理出现诸多问题，表面上看似平静，实则处于一种失控状态，主要体现在以下几个方面：</p>
<ol>
<li>
<p><strong>任务时间评估不到位</strong>：项目负责人由于对整体功能和需求缺乏深入了解，导致在评估任务所需时间时不够准确，经常需要变更任务计划，影响项目进度的稳定性。</p>
</li>
<li>
<p><strong>风险意识不足</strong>：由于对业务不够熟悉，项目负责人无法提前识别潜在的延期风险因素，也无法有效判断是否需要安排加班来应对可能出现的问题，从而增加了项目按时完成的不确定性。</p>
</li>
<li>
<p><strong>任务验收困难</strong>：在验收功能时，由于项目负责人对业务和需求不够了解，只能依赖开发同事的回答来判断功能是否实现以及是否与需求一致。这种情况下，验收工作往往流于形式，难以深入和全面地评估功能质量，导致验收工作的积极性和效果都不理想。</p>
</li>
</ol>
<p>为了解决这些问题，项目负责人需要自行梳理一份详细的项目需求与功能实现文档。比如下图所示的文档格式。在文档中，将每个功能按照“是什么”、“为什么”、“怎么做”这三个问题进行清晰的梳理和记录。在项目推进过程中，一旦出现需求变更，应及时更新文档，确保项目负责人对项目的整体情况有清晰的把握和了解。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202503202330117.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>03-项目负责人能力阶段划分</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/03-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E8%83%BD%E5%8A%9B%E9%98%B6%E6%AE%B5%E5%88%92%E5%88%86/</link>
      <pubDate>Wed, 19 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/03-%E9%A1%B9%E7%9B%AE%E8%B4%9F%E8%B4%A3%E4%BA%BA%E8%83%BD%E5%8A%9B%E9%98%B6%E6%AE%B5%E5%88%92%E5%88%86/</guid>
      <description>&lt;p&gt;我认真思考了一下，觉得项目负责人的能力可以分为五个阶段，分别对应的关键字是开发、方法、产品、整体、市场。虽然看起来好像呈递进关系，但是我发现实际上不是这样的，很多人可能没办法将其划分在哪个阶段，有些是好几个阶段都覆盖，各阶段要求的能力都有一点，但又不完全具备；有些是第二阶段了，可能第一阶段还没达到等等，所以这个划分只是参考。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;1. 开发能力&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;项目里自己负责开发的功能高质量完成，基本可以认为是&lt;strong&gt;可以直接给客户演示&lt;/strong&gt;的标准：功能没有特别重大的Bug（例如不会突然崩溃或无法使用）；功能边界定义清晰（例如手机号输入有格式限制，且包含正确提示和异常处理）；界面交互流畅，避免出现逻辑混乱的页面跳转；视觉细节完善，连一个像素的偏差都会调整到位。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;2. 方法论沉淀&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;项目里自己开发的模块业务非常熟悉，但其他人负责的部分了解不足；能够独立完成需求理解、方案设计、开发计划制定、内部验收、测试提交和项目上线全流程，对分配到的模块有完整把控力。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;3. 产品化思维&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;对项目中所有业务需求的关联性和实现路径一清二楚；熟练使用项目涉及的硬件设备及相关配套产品；如果由你主导，能够完成产品需求文档和原型设计，并对需求合理性提出专业建议。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;4. 技术全局观&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;突破单一技术栈限制，例如前端出身的负责人掌握后端核心技术逻辑，后端负责人熟悉前端核心实现原理，能够主导跨技术栈的方案设计与协作。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;5. 市场价值洞察&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;从技术执行转向产品驱动，深入理解产品的市场定位与核心价值（例如清楚产品解决什么痛点、目标用户是谁）；关注产品的市场推广策略与用户增长，推动技术方案适配市场需求。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>我认真思考了一下，觉得项目负责人的能力可以分为五个阶段，分别对应的关键字是开发、方法、产品、整体、市场。虽然看起来好像呈递进关系，但是我发现实际上不是这样的，很多人可能没办法将其划分在哪个阶段，有些是好几个阶段都覆盖，各阶段要求的能力都有一点，但又不完全具备；有些是第二阶段了，可能第一阶段还没达到等等，所以这个划分只是参考。</p>
<p><strong>1. 开发能力</strong></p>
<p>项目里自己负责开发的功能高质量完成，基本可以认为是<strong>可以直接给客户演示</strong>的标准：功能没有特别重大的Bug（例如不会突然崩溃或无法使用）；功能边界定义清晰（例如手机号输入有格式限制，且包含正确提示和异常处理）；界面交互流畅，避免出现逻辑混乱的页面跳转；视觉细节完善，连一个像素的偏差都会调整到位。</p>
<p><strong>2. 方法论沉淀</strong></p>
<p>项目里自己开发的模块业务非常熟悉，但其他人负责的部分了解不足；能够独立完成需求理解、方案设计、开发计划制定、内部验收、测试提交和项目上线全流程，对分配到的模块有完整把控力。</p>
<p><strong>3. 产品化思维</strong></p>
<p>对项目中所有业务需求的关联性和实现路径一清二楚；熟练使用项目涉及的硬件设备及相关配套产品；如果由你主导，能够完成产品需求文档和原型设计，并对需求合理性提出专业建议。</p>
<p><strong>4. 技术全局观</strong></p>
<p>突破单一技术栈限制，例如前端出身的负责人掌握后端核心技术逻辑，后端负责人熟悉前端核心实现原理，能够主导跨技术栈的方案设计与协作。</p>
<p><strong>5. 市场价值洞察</strong></p>
<p>从技术执行转向产品驱动，深入理解产品的市场定位与核心价值（例如清楚产品解决什么痛点、目标用户是谁）；关注产品的市场推广策略与用户增长，推动技术方案适配市场需求。</p>
]]></content:encoded>
    </item>
    <item>
      <title>02-项目管理的意义</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/02-%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E7%9A%84%E6%84%8F%E4%B9%89/</link>
      <pubDate>Tue, 18 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/02-%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E7%9A%84%E6%84%8F%E4%B9%89/</guid>
      <description>&lt;p&gt;我们探讨项目管理的意义，只会聚焦于关联密切的那部分。至于关系到公司成本投入等问题，虽然是不争的事实，但对于我们而言，有点遥远，就不再过多拓展。&lt;/p&gt;
&lt;p&gt;对于项目负责人而言，他需要明白项目管理的意义。根据我个人的一些经验，总结了以下三点，分别涉及一个项目完整的周期，即开始、过程和结束。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;一致性&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;目标一致、步伐一致，项目中的全体成员都需要知道，我们的目标是什么？并将全部精力投入到达成目标的要事上面。在这个过程中，间接实现了项目降本增效，还有提高团队的凝聚力。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;及时性&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;项目进行过程中，无时无刻都在发生变化，不管是项目制定的计划，还是遇到了业务或技术难点，及时了解到当下的情况，尽快解决问题，可以避免项目进度受阻。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;高质性&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;项目完成并不意味着没有问题，质量如何保证，就需要项目负责人进行项目的验收，不然怎么知道已经完善了呢？&lt;/p&gt;
&lt;p&gt;以上这三点都是对于项目而言，那么对于项目负责人来说，意义又在哪里呢？&lt;/p&gt;
&lt;p&gt;那就是一个人的成功（做好事情）固然值得肯定，但如果他能将这种成功因地制宜地在团队其他人身上应验，那将意义深远。一方面，团队里的成员能力有所提升，对项目上面的工作肯定是有帮助的；另一方面，我们都知道每个人都有自己对世界的一套认知，怎么做事情，都有自己的方式，我们只是一直在摸索那条规律，不断应验和调整。如果其他人也适用，那至少说明，你的一整套理论是有可取之处的，越来越靠近那条规律；如果不适用，那也可以借机进行反思和完善，对你而言是大有裨益的。这也是教员《实践论》里提到的观点：“人类认识的历史告诉我们，许多理论的真理性是不完全的，经过实践的检验而纠正了它们的不完全性。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>我们探讨项目管理的意义，只会聚焦于关联密切的那部分。至于关系到公司成本投入等问题，虽然是不争的事实，但对于我们而言，有点遥远，就不再过多拓展。</p>
<p>对于项目负责人而言，他需要明白项目管理的意义。根据我个人的一些经验，总结了以下三点，分别涉及一个项目完整的周期，即开始、过程和结束。</p>
<p><strong>一致性</strong></p>
<p>目标一致、步伐一致，项目中的全体成员都需要知道，我们的目标是什么？并将全部精力投入到达成目标的要事上面。在这个过程中，间接实现了项目降本增效，还有提高团队的凝聚力。</p>
<p><strong>及时性</strong></p>
<p>项目进行过程中，无时无刻都在发生变化，不管是项目制定的计划，还是遇到了业务或技术难点，及时了解到当下的情况，尽快解决问题，可以避免项目进度受阻。</p>
<p><strong>高质性</strong></p>
<p>项目完成并不意味着没有问题，质量如何保证，就需要项目负责人进行项目的验收，不然怎么知道已经完善了呢？</p>
<p>以上这三点都是对于项目而言，那么对于项目负责人来说，意义又在哪里呢？</p>
<p>那就是一个人的成功（做好事情）固然值得肯定，但如果他能将这种成功因地制宜地在团队其他人身上应验，那将意义深远。一方面，团队里的成员能力有所提升，对项目上面的工作肯定是有帮助的；另一方面，我们都知道每个人都有自己对世界的一套认知，怎么做事情，都有自己的方式，我们只是一直在摸索那条规律，不断应验和调整。如果其他人也适用，那至少说明，你的一整套理论是有可取之处的，越来越靠近那条规律；如果不适用，那也可以借机进行反思和完善，对你而言是大有裨益的。这也是教员《实践论》里提到的观点：“人类认识的历史告诉我们，许多理论的真理性是不完全的，经过实践的检验而纠正了它们的不完全性。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>01-写在前面</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/01-%E5%86%99%E5%9C%A8%E5%89%8D%E9%9D%A2/</link>
      <pubDate>Mon, 17 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E9%A1%B9%E7%9B%AE%E7%AE%A1%E7%90%86%E5%AE%9E%E8%B7%B5/01-%E5%86%99%E5%9C%A8%E5%89%8D%E9%9D%A2/</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;这些内容是我在2022年8月编写的，当时在部门内部进行了分享，主要涉及项目管理知识和个人工作经验总结。最开始我是计划以写书的方式系统整理这些内容，但因种种原因一直搁置。现在我觉得，事情还是越早开始越好，因为不同阶段的工作重心会有变化。若一味拖延，可能错失深入处理细节的机会，而且时间越久，当初的感受和体会也会淡去，相应的观点也可能会有出入。因此，现在就开始着手整理吧。&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;你可能是项目中的开发能手，最佳情况也只是能保证自己负责开发的功能没有问题，其他的你是无法保证的。哪怕你承担了项目中全部的开发工作，测试阶段、验收阶段和发布阶段也是需要其他人协助的。假设这些你都可以自己完成，而且也做得很到位，但要是需要该项目在很短的时间内交付，想必你就没有办法了。一个人的能力不管多高，人的精力终究是有限的，任何事情能够得到一个比较满意的结果，都离不开众人的努力，对于项目而言也是如此。&lt;/p&gt;
&lt;p&gt;在推进多项目管理过程中，反馈出来不少问题，我针对这些问题进行了分析，并且提供了一些相应的解决方案。不过这些方案不一定全对，只是我个人的一些反思总结和心得分享。我计划把内容分为意识、能力、方法、提升和附录这几个部分。意识主要是项目管理意识方面的探讨，意识是这一切的基础，意识没有到位，后面的其他方面做得再好，也是有局限性的，就像一棵大树，树根没有长好，枝干树叶的成长也是有限的。因为意识很重要，所以把它放在前面。能力主要是探讨项目管理应该具备哪些能力。方法主要是项目管理方法上面的探讨。至于附录，是一些有助于提升项目管理能力的书籍摘要。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<blockquote>
<p>这些内容是我在2022年8月编写的，当时在部门内部进行了分享，主要涉及项目管理知识和个人工作经验总结。最开始我是计划以写书的方式系统整理这些内容，但因种种原因一直搁置。现在我觉得，事情还是越早开始越好，因为不同阶段的工作重心会有变化。若一味拖延，可能错失深入处理细节的机会，而且时间越久，当初的感受和体会也会淡去，相应的观点也可能会有出入。因此，现在就开始着手整理吧。</p></blockquote>
<p>你可能是项目中的开发能手，最佳情况也只是能保证自己负责开发的功能没有问题，其他的你是无法保证的。哪怕你承担了项目中全部的开发工作，测试阶段、验收阶段和发布阶段也是需要其他人协助的。假设这些你都可以自己完成，而且也做得很到位，但要是需要该项目在很短的时间内交付，想必你就没有办法了。一个人的能力不管多高，人的精力终究是有限的，任何事情能够得到一个比较满意的结果，都离不开众人的努力，对于项目而言也是如此。</p>
<p>在推进多项目管理过程中，反馈出来不少问题，我针对这些问题进行了分析，并且提供了一些相应的解决方案。不过这些方案不一定全对，只是我个人的一些反思总结和心得分享。我计划把内容分为意识、能力、方法、提升和附录这几个部分。意识主要是项目管理意识方面的探讨，意识是这一切的基础，意识没有到位，后面的其他方面做得再好，也是有局限性的，就像一棵大树，树根没有长好，枝干树叶的成长也是有限的。因为意识很重要，所以把它放在前面。能力主要是探讨项目管理应该具备哪些能力。方法主要是项目管理方法上面的探讨。至于附录，是一些有助于提升项目管理能力的书籍摘要。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 48</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-48/</link>
      <pubDate>Sat, 08 Mar 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-48/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/first-letter-to-appear-twice/&#34;&gt;2351. 第一个出现两次的字母&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个由小写英文字母组成的字符串 &lt;code&gt;s&lt;/code&gt; ，请你找出并返回第一个出现 &lt;strong&gt;两次&lt;/strong&gt; 的字母。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;注意：&lt;/strong&gt;&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;如果 &lt;code&gt;a&lt;/code&gt; 的 &lt;strong&gt;第二次&lt;/strong&gt; 出现比 &lt;code&gt;b&lt;/code&gt; 的 &lt;strong&gt;第二次&lt;/strong&gt; 出现在字符串中的位置更靠前，则认为字母 &lt;code&gt;a&lt;/code&gt; 在字母 &lt;code&gt;b&lt;/code&gt; 之前出现两次。&lt;/li&gt;
&lt;li&gt;&lt;code&gt;s&lt;/code&gt; 包含至少一个出现两次的字母。&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;abccbaacz&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;c&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;字母&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;a&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在下标&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;、&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;处出现&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;字母&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;b&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在下标&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;处出现&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;字母&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;c&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在下标&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;、&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;处出现&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;字母&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;z&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在下标&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;处出现&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;字母&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;c&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;是第一个出现两次的字母&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;因为在所有字母中&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;c&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;第二次出现的下标是最小的&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;repeatedCharacter&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;earliestRepeatIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;Infinity&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 如果出现了第一次和最后一次的位置不相等，则表示有2个以上存在
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;lastIndexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;c1&#34;&gt;// 第一个出现两次的字母，则关键点就在第二次出现的位置，谁最靠前（indexOf越小），那么该位置的字母就是所求的值。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;            &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;secondOccurrenceIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;earliestRepeatIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;earliestRepeatIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;secondOccurrenceIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;earliestRepeatIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;如果出现了第一次和最后一次的位置不相等，则表示有2个以上存在&lt;/li&gt;
&lt;li&gt;第一个出现两次的字母，则关键点就在第二次出现的位置，谁最靠前（indexOf越小），那么该位置的字母就是所求的值。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2502/250227-fog-harvesting.html&#34;&gt;Fog harvesting could provide water for dry cities - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;全球许多地区降雨稀少，人们每日获取饮用水都面临巨大挑战。科学家发现了一项可能帮助世界最干旱城镇的新技术——从雾中收集水分，这项技术有望为数百万人口提供饮用水。智利研究人员正在探索&amp;quot;捕雾取水&amp;quot;技术的应用潜力。这项技术原理简单：在立柱之间悬挂巨型网状幕帘，当云雾穿行其间，水滴附着在网格表面，最终汇聚成水流通过下方管道导入储水罐。这种低成本、易操作的集水方式为干旱地区提供了新选择。&lt;/p&gt;
&lt;p&gt;来自首都圣地亚哥私立大学马约尔大学的研究团队，在年均降雨量不足5毫米的沙漠小镇阿尔托奥斯特西奥开展实地测试。当地居民日常饮用水主要依赖卡车运输。研究负责人弗吉尼亚·卡特·甘贝里尼博士指出，这项技术将开启&amp;quot;新时代&amp;quot;，其研究&amp;quot;标志着雾水资源利用认知的重大转变——从局限于农村地区的小型解决方案，升级为适用于城市的实用水源&amp;quot;。她补充道：&amp;ldquo;云雾中的水资源既能提升城市应对气候变化的能力，又能改善清洁水源的获取条件。&amp;rdquo;&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在 Windows 中，端口被占用，怎么解决？&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/first-letter-to-appear-twice/">2351. 第一个出现两次的字母</a></p>
<p>给你一个由小写英文字母组成的字符串 <code>s</code> ，请你找出并返回第一个出现 <strong>两次</strong> 的字母。</p>
<p><strong>注意：</strong></p>
<ul>
<li>如果 <code>a</code> 的 <strong>第二次</strong> 出现比 <code>b</code> 的 <strong>第二次</strong> 出现在字符串中的位置更靠前，则认为字母 <code>a</code> 在字母 <code>b</code> 之前出现两次。</li>
<li><code>s</code> 包含至少一个出现两次的字母。</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;abccbaacz&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="s2">&#34;c&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">字母</span> <span class="s1">&#39;a&#39;</span> <span class="nx">在下标</span> <span class="mi">0</span> <span class="err">、</span><span class="mi">5</span> <span class="nx">和</span> <span class="mi">6</span> <span class="nx">处出现</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">字母</span> <span class="s1">&#39;b&#39;</span> <span class="nx">在下标</span> <span class="mi">1</span> <span class="nx">和</span> <span class="mi">4</span> <span class="nx">处出现</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">字母</span> <span class="s1">&#39;c&#39;</span> <span class="nx">在下标</span> <span class="mi">2</span> <span class="err">、</span><span class="mi">3</span> <span class="nx">和</span> <span class="mi">7</span> <span class="nx">处出现</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">字母</span> <span class="s1">&#39;z&#39;</span> <span class="nx">在下标</span> <span class="mi">8</span> <span class="nx">处出现</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">字母</span> <span class="s1">&#39;c&#39;</span> <span class="nx">是第一个出现两次的字母</span><span class="err">，</span><span class="nx">因为在所有字母中</span><span class="err">，</span><span class="s1">&#39;c&#39;</span> <span class="nx">第二次出现的下标是最小的</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">repeatedCharacter</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">str</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">earliestRepeatIndex</span> <span class="o">=</span> <span class="kc">Infinity</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 如果出现了第一次和最后一次的位置不相等，则表示有2个以上存在
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">if</span> <span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="o">!==</span> <span class="nx">str</span><span class="p">.</span><span class="nx">lastIndexOf</span><span class="p">(</span><span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">]))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// 第一个出现两次的字母，则关键点就在第二次出现的位置，谁最靠前（indexOf越小），那么该位置的字母就是所求的值。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="kr">const</span> <span class="nx">secondOccurrenceIndex</span> <span class="o">=</span> <span class="nx">str</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">],</span> <span class="nx">str</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="nx">earliestRepeatIndex</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">earliestRepeatIndex</span><span class="p">,</span> <span class="nx">secondOccurrenceIndex</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">str</span><span class="p">[</span><span class="nx">earliestRepeatIndex</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>如果出现了第一次和最后一次的位置不相等，则表示有2个以上存在</li>
<li>第一个出现两次的字母，则关键点就在第二次出现的位置，谁最靠前（indexOf越小），那么该位置的字母就是所求的值。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2502/250227-fog-harvesting.html">Fog harvesting could provide water for dry cities - Breaking News English Lesson</a></p>
<p>全球许多地区降雨稀少，人们每日获取饮用水都面临巨大挑战。科学家发现了一项可能帮助世界最干旱城镇的新技术——从雾中收集水分，这项技术有望为数百万人口提供饮用水。智利研究人员正在探索&quot;捕雾取水&quot;技术的应用潜力。这项技术原理简单：在立柱之间悬挂巨型网状幕帘，当云雾穿行其间，水滴附着在网格表面，最终汇聚成水流通过下方管道导入储水罐。这种低成本、易操作的集水方式为干旱地区提供了新选择。</p>
<p>来自首都圣地亚哥私立大学马约尔大学的研究团队，在年均降雨量不足5毫米的沙漠小镇阿尔托奥斯特西奥开展实地测试。当地居民日常饮用水主要依赖卡车运输。研究负责人弗吉尼亚·卡特·甘贝里尼博士指出，这项技术将开启&quot;新时代&quot;，其研究&quot;标志着雾水资源利用认知的重大转变——从局限于农村地区的小型解决方案，升级为适用于城市的实用水源&quot;。她补充道：&ldquo;云雾中的水资源既能提升城市应对气候变化的能力，又能改善清洁水源的获取条件。&rdquo;</p>
<h2 id="tip">Tip</h2>
<p>在 Windows 中，端口被占用，怎么解决？</p>
<p>在 Windows 下检查端口 503 是否被占用，以管理员身份运行 “命令提示符” 窗口，使用命令检查当前端口使用的进程：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">netstat -ano <span class="p">|</span> findstr :503
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502211744587.png"></p>
<p>然后记下状态为 LISTENING 的数字（例如 39880），然后使用以下命令，终止进程：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl"> taskkill /PID <span class="m">39880</span> /F
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502211744928.png"></p>
<h2 id="share">Share</h2>
<p>《大才非学不成》 [明·郑晓]</p>
<p>胆欲大，心欲小；智欲圆，行欲方。大志非才不就，大才非学不成。学非记诵云尔，当究事所以然，融于心目，如身亲履之。南阳一出即相，淮阴一出即将，果盖世雄才，皆是平时所学。志士读书当知此。不然，世之能读书能文章不善做官做人者最多也。</p>
<p>​</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 47</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-47/</link>
      <pubDate>Sat, 08 Feb 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-47/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/detect-pattern-of-length-m-repeated-k-or-more-times/&#34;&gt;1566. 重复至少 K 次且长度为 M 的模式&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个正整数数组&lt;code&gt;arr&lt;/code&gt;，请你找出一个长度为&lt;code&gt;m&lt;/code&gt;且在数组中至少重复&lt;code&gt;k&lt;/code&gt;次的模式。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;模式&lt;/strong&gt;是由一个或多个值组成的子数组（连续的子序列），&lt;strong&gt;连续&lt;/strong&gt;重复多次但&lt;strong&gt;不重叠&lt;/strong&gt;。模式由其长度和重复次数定义。&lt;/p&gt;
&lt;p&gt;如果数组中存在至少重复&lt;code&gt;k&lt;/code&gt;次且长度为&lt;code&gt;m&lt;/code&gt;的模式，则返回&lt;code&gt;true&lt;/code&gt;，否则返回&lt;code&gt;false&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;模式&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的长度为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且连续重复&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;注意&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;模式可以重复&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;次或更多次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;但不能少于&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;containsPattern&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;valid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pos&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pos&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pos&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentPos&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pos&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;patternPos&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pos&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;currentPos&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;patternPos&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;valid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;valid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;valid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;首先检查数组的长度是否至少为 &lt;code&gt;m * k&lt;/code&gt;。如果不足，则直接返回 &lt;code&gt;false&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;遍历所有可能的模式起始位置 &lt;code&gt;i&lt;/code&gt;，确保这些位置可以容纳至少 &lt;code&gt;k&lt;/code&gt; 个连续的模式（即 &lt;code&gt;i&lt;/code&gt; 的范围是 &lt;code&gt;0&lt;/code&gt; 到 &lt;code&gt;arr.length - m * k&lt;/code&gt;）。&lt;/li&gt;
&lt;li&gt;对于每个起始位置 &lt;code&gt;i&lt;/code&gt;，检查从该位置开始的连续 &lt;code&gt;k&lt;/code&gt; 个模式的元素是否完全一致。直接通过数组索引比较元素。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2501/250130-working-remotely.html&#34;&gt;New Zealand relaxes visa rules for &amp;lsquo;digital nomads&amp;rsquo; - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/detect-pattern-of-length-m-repeated-k-or-more-times/">1566. 重复至少 K 次且长度为 M 的模式</a></p>
<p>给你一个正整数数组<code>arr</code>，请你找出一个长度为<code>m</code>且在数组中至少重复<code>k</code>次的模式。</p>
<p><strong>模式</strong>是由一个或多个值组成的子数组（连续的子序列），<strong>连续</strong>重复多次但<strong>不重叠</strong>。模式由其长度和重复次数定义。</p>
<p>如果数组中存在至少重复<code>k</code>次且长度为<code>m</code>的模式，则返回<code>true</code>，否则返回<code>false</code>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="nx">m</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">k</span> <span class="o">=</span> <span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">模式</span> <span class="p">(</span><span class="mi">4</span><span class="p">)</span> <span class="nx">的长度为</span> <span class="mi">1</span> <span class="err">，</span><span class="nx">且连续重复</span> <span class="mi">4</span> <span class="nx">次</span><span class="err">。</span><span class="nx">注意</span><span class="err">，</span><span class="nx">模式可以重复</span> <span class="nx">k</span> <span class="nx">次或更多次</span><span class="err">，</span><span class="nx">但不能少于</span> <span class="nx">k</span> <span class="nx">次</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">containsPattern</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="nx">m</span><span class="p">,</span> <span class="nx">k</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">n</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">n</span> <span class="o">&lt;</span> <span class="nx">m</span> <span class="o">*</span> <span class="nx">k</span><span class="p">)</span> <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;=</span> <span class="nx">n</span> <span class="o">-</span> <span class="nx">m</span> <span class="o">*</span> <span class="nx">k</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">valid</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">k</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">pos</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">pos</span> <span class="o">&lt;</span> <span class="nx">m</span><span class="p">;</span> <span class="nx">pos</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="kr">const</span> <span class="nx">currentPos</span> <span class="o">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">j</span> <span class="o">*</span> <span class="nx">m</span> <span class="o">+</span> <span class="nx">pos</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="kr">const</span> <span class="nx">patternPos</span> <span class="o">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="nx">pos</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(</span><span class="nx">arr</span><span class="p">[</span><span class="nx">currentPos</span><span class="p">]</span> <span class="o">!==</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">patternPos</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">valid</span> <span class="o">=</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                    <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">valid</span><span class="p">)</span> <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">valid</span><span class="p">)</span> <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>首先检查数组的长度是否至少为 <code>m * k</code>。如果不足，则直接返回 <code>false</code>。</li>
<li>遍历所有可能的模式起始位置 <code>i</code>，确保这些位置可以容纳至少 <code>k</code> 个连续的模式（即 <code>i</code> 的范围是 <code>0</code> 到 <code>arr.length - m * k</code>）。</li>
<li>对于每个起始位置 <code>i</code>，检查从该位置开始的连续 <code>k</code> 个模式的元素是否完全一致。直接通过数组索引比较元素。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2501/250130-working-remotely.html">New Zealand relaxes visa rules for &lsquo;digital nomads&rsquo; - Breaking News English Lesson</a></p>
<p>对有意在新西兰工作的人来说，这是一个好消息。该国放宽了签证政策，希望吸引&quot;数字游民&quot;在当地居住和工作长达九个月。数字游民指能基于远程在线工作方式在任何地方生活的人群。新西兰推出新签证，允许境外雇主员工在该国远程工作三个月，并可延长至九个月——但停留满九个月者可能需要缴税。经济增长部长尼古拉·威利斯表示，新政策旨在&quot;让更多富裕且极具才华的人通过入境口来到新西兰&quot;，以促进经济发展。</p>
<p>近年来该国经济面临多重挑战：新冠疫情重创的旅游业尚未恢复至疫情前水平，青年人才流失问题加剧——当前二十余岁年轻人赴海外工作数量创历史新高。移民部长埃丽卡·斯坦福预计，新签证持有者在境内停留时间延长将刺激消费，&ldquo;更重要的是希望他们能爱上这个地方&rdquo;。</p>
<h2 id="tip">Tip</h2>
<p>DeepSeek满血版使用</p>
<p>年前使用<code>DeepSeek</code>还挺顺畅的，没想到过年期间突然爆火，导致流量暴涨。再加上美帝“亡我之心不死”，天天攻击，服务器经常繁忙，有时候重复提问<code>20</code>多次都没反应，实在忍不了了，只能研究其他渠道来使用深度思考（R1）功能。</p>
<p>经过一番查找，发现可以使用硅基流动（SiliconFlow）提供的服务。硅基流动与华为云联合推出了基于昇腾云的DeepSeek R1 &amp; V3推理服务。使用邀请码注册：https://cloud.siliconflow.cn/i/wDEipqNd，可以赠送<code>14</code>块钱，足够用很久了。不过，由于这是<code>API</code>调用的方式，历史问答的内容无法保留，因此需要结合<code>Cherry Studio</code>客户端软件来使用。</p>
<p>当然，如果觉得麻烦，也可以考虑使用<code>360</code>的纳米<code>AI</code>搜索的慢思考模式，或者<code>kimi</code>的<code>k1.5长思考</code>模式。不过，就推理方面来说，还是觉得DeepSeek更有意思一些。</p>
<h2 id="share">Share</h2>
<p>哈哈哈，实属蚌埠住了。</p>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502082048894.png" style="zoom: 50%;" />
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 46</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-46/</link>
      <pubDate>Fri, 07 Feb 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-46/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/swap-for-longest-repeated-character-substring/&#34;&gt;1156. 单字符重复子串的最大长度&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;如果字符串中的所有字符都相同，那么这个字符串是单字符重复的字符串。&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;text&lt;/code&gt;，你只能交换其中两个字符一次或者什么都不做，然后得到一些单字符重复的子串。返回其中最长的子串的长度。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;ababa&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxRepOpt1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;max_length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; 
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;text&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;max_length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max_length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;max_length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;使用一个对象 &lt;code&gt;count&lt;/code&gt; 来统计每个字符的出现次数。遍历字符串，将每个字符的出现次数记录在 &lt;code&gt;count&lt;/code&gt; 中。&lt;/li&gt;
&lt;li&gt;使用一个外层循环，从每个字符开始，向右扩展，找到当前字符的最长连续重复子串。&lt;/li&gt;
&lt;li&gt;如果当前子串长度小于该字符的总出现次数，尝试检查子串两端是否有相同字符，或者中间是否有不同字符可以交换。&lt;/li&gt;
&lt;li&gt;每次找到一个更长的子串时，更新 &lt;code&gt;max_length&lt;/code&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2501/250127-year-of-the-snake.html&#34;&gt;Lunar New Year sees record migration in China - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/swap-for-longest-repeated-character-substring/">1156. 单字符重复子串的最大长度</a></p>
<p>如果字符串中的所有字符都相同，那么这个字符串是单字符重复的字符串。</p>
<p>给你一个字符串 <code>text</code>，你只能交换其中两个字符一次或者什么都不做，然后得到一些单字符重复的子串。返回其中最长的子串的长度。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">text</span> <span class="o">=</span> <span class="s2">&#34;ababa&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">3</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">maxRepOpt1</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">text</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">count</span> <span class="o">=</span> <span class="p">{};</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="kr">char</span> <span class="k">of</span> <span class="nx">text</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">count</span><span class="p">[</span><span class="kr">char</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span><span class="p">[</span><span class="kr">char</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="nx">count</span><span class="p">[</span><span class="kr">char</span><span class="p">]</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">max_length</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">n</span> <span class="o">=</span> <span class="nx">text</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">n</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="kr">char</span> <span class="o">=</span> <span class="nx">text</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">length</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> 
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">n</span> <span class="o">&amp;&amp;</span> <span class="nx">text</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">===</span> <span class="kr">char</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">length</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="nx">j</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="nx">count</span><span class="p">[</span><span class="kr">char</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">n</span> <span class="o">&amp;&amp;</span> <span class="nx">text</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">!==</span> <span class="kr">char</span> <span class="o">&amp;&amp;</span> <span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">&lt;</span> <span class="nx">n</span> <span class="o">&amp;&amp;</span> <span class="nx">text</span><span class="p">[</span><span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="kr">char</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="kd">let</span> <span class="nx">k</span> <span class="o">=</span> <span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="k">while</span> <span class="p">(</span><span class="nx">k</span> <span class="o">&lt;</span> <span class="nx">n</span> <span class="o">&amp;&amp;</span> <span class="nx">text</span><span class="p">[</span><span class="nx">k</span><span class="p">]</span> <span class="o">===</span> <span class="kr">char</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">length</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">k</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="nx">count</span><span class="p">[</span><span class="kr">char</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">length</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">length</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="nx">max_length</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">max_length</span><span class="p">,</span> <span class="nx">length</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">max_length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>使用一个对象 <code>count</code> 来统计每个字符的出现次数。遍历字符串，将每个字符的出现次数记录在 <code>count</code> 中。</li>
<li>使用一个外层循环，从每个字符开始，向右扩展，找到当前字符的最长连续重复子串。</li>
<li>如果当前子串长度小于该字符的总出现次数，尝试检查子串两端是否有相同字符，或者中间是否有不同字符可以交换。</li>
<li>每次找到一个更长的子串时，更新 <code>max_length</code>。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2501/250127-year-of-the-snake.html">Lunar New Year sees record migration in China - Breaking News English Lesson</a></p>
<p>春节是中国最重要的节日。数亿人会返回家乡庆祝这一传统佳节，今年也不例外。机场、火车站和汽车站挤满了踏上年度返乡之旅的旅客。今年对应中国十二生肖中的蛇年。庆祝活动从1月29日开始，持续长达16天，其中前七天是国家法定假日。路透社报道称今年出境游尤其受欢迎，援引某旅行社数据称&quot;平台出境航班和度假套餐预订量较去年翻倍&quot;，最热门目的地集中在亚洲地区。</p>
<p>美联社将中国春节称为&quot;全球最大规模的年度人口迁徙&quot;。随着中国现代化高速交通网络的发展，春运流动人数呈几何级增长。新华社预计今年出行人次将&quot;创历史新高&quot;。3500年前春节雏形初现时，离乡者寥寥无几。但随着中国经济腾飞，数十亿人因工作、求学或追求更好的生活在全国各地迁徙。这场年度迁徙潮成为经济助推器，旅游、酒店和零售行业在此期间迎来利润增长。</p>
<h2 id="tip">Tip</h2>
<p>通过TeamViewer传输exe文件过大的问题</p>
<p>使用<code>Electron</code>开发的一个<code>PC</code>软件，包大小为<code>400MB</code>，有可能是<code>TeamViewer</code>传输大小有限制，每次传到<code>200MB</code>就自动中断了，导致无法把<code>.exe</code>文件从<code>A</code>电脑传输到无网络的<code>B</code>电脑上，又不想使用<code>U盘</code>进行传输，因为<code>B</code>电脑主机环境在机房，操作起来非常不方便。为了解决这个问题，可以通过压缩分卷的方式，把<code>400MB</code>大小的软件包分成两个<code>200MB</code>即可。以<code>VSCode</code>软件为例，将<code>100MB</code>软件包压缩分卷为两个<code>50MB</code>的文件。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502061118092.png"></p>
<h2 id="share">Share</h2>
<p><a href="https://www.infoq.cn/article/00ZflUA3lzstmwIMRYDs">《2025 年，我的第一个建议是别当程序员了！但如果非要当，这些办法可以教会你如何提升自己》</a></p>
<ol>
<li>
<p>我在做事时，倾向于不轻易说“给你 10 个人去做”。因为一旦给团队说 10 个人去做，团队就不思考了。</p>
</li>
<li>
<p>优秀的程序员通过自己的思考，产生的影响是非线性的，一定要用好这种能力。</p>
</li>
<li>
<p>很多创新都是在资源受限的情况下被迫发生的。</p>
</li>
<li>
<p>我是个实用主义者，我所学的所有技术都是因为别人付钱让我去做项目。我从不免费学习知识或做项目。所以，我的判断完全不是从美感或品位出发的，在我看来，品位就是用最低的成本赚最多的钱。如果一个设计不能让我后续用最低成本维护、用最少时间达到效果并赚到钱，那它就不是好设计。</p>
</li>
<li>
<p>如果只注重表面的美观而忽视了实用性，那么这种所谓的“美”只是主观的，并不符合业界的实际需求和标准。</p>
</li>
<li>
<p>我认为所谓品味，你应该问自己：解决这个问题该用什么方法最优雅？这包括几方面考虑：一是你面临的脑力负担，需不需要了解全貌才能解决；二是你要承担多大风险，作为工程师，首先要考虑的是项目会不会因你的选择而失败；三是收益。</p>
</li>
<li>
<p>我自己在做重大决定时，第一个倾向是能不做就不做，能晚点做就晚点做，保持系统的简洁，也就是所谓的品味。作为古典程序员流派，我更倾向于以简单为美。</p>
</li>
<li>
<p>程序员并没有绝对的优秀与否之分，评价标准并非线性。写代码比我快一秒钟，或者接口设计比我好一点点，都不能简单判定谁更出色。不存在这样一个明确的标准，每个人都可以从他人身上学到东西。如果真有值得学习之处，交流其实更为重要，而不是纠结于谁更优秀。这涉及到自我认知的问题，我建议就是放弃所有这种自我优越感，每个人都能从对方身上学到东西。</p>
</li>
<li>
<p>我觉得程序员这个职业和传统职业最大的不同在于，我们不需要做前人做过的工作。一个人把别人做过的事再做一遍，这没什么了不起，甚至在这个行业是可耻的。看看世界上需要什么，有什么问题需要解决，把问题解决好，你就厉害了。你不需要和任何人比较，你就是最厉害的。</p>
</li>
<li>
<p>不喜欢一定是有原因的，要么违反你的人性，要么违反你的道德。不做自己不感兴趣的事本身就是一个加分项，你会更有意愿去钻研，不会觉得累。比如我过去三四年，每天工作十四五个小时很常见，虽然赚钱也不多，但核心是开心，因为做了自己感兴趣的事，就不会觉得累。</p>
</li>
<li>
<p>抬杠的过程有助于去魅，并且强迫自己找证据、了解真相。敢于抬杠是一个挑战权威的过程，并且强迫自己学习。年轻人要想办法做和别人不一样的那个人，无论是做人还是做事。别人都做得那么好了，你还有什么希望？你要做点自己感兴趣，觉得还没人好好做的事。</p>
</li>
<li>
<p>如果不会英语，那就去学。现在全球化是大趋势，英语不仅是语言，更是一种思维方式，尤其是技术领域，它已经成为了全球交流的通用语言。如果你想进步，就必须克服语言障碍，融入全球化的交流中。中国年轻开发者确实需要提升眼界。有一个简单的方法就是多看像 Hacker News 这样的国际知名技术社区，并积极参与其中的讨论。</p>
</li>
<li>
<p>只要有效就 OK，关键是无效。所以，无效才是原罪。</p>
</li>
<li>
<p>对我们所有创业者来说，创业者首先是个产品经理，产品到底给谁用，为什么用户要用，这才是关键。</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 45</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-45/</link>
      <pubDate>Wed, 01 Jan 2025 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-45/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop/&#34;&gt;1475. 商品折扣后的最终价格&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个数组 &lt;code&gt;prices&lt;/code&gt; ，其中 &lt;code&gt;prices[i]&lt;/code&gt; 是商店里第 &lt;code&gt;i&lt;/code&gt; 件商品的价格。&lt;/p&gt;
&lt;p&gt;商店里正在进行促销活动，如果你要买第 &lt;code&gt;i&lt;/code&gt; 件商品，那么你可以得到与 &lt;code&gt;prices[j]&lt;/code&gt; 相等的折扣，其中 &lt;code&gt;j&lt;/code&gt; 是满足 &lt;code&gt;j &amp;gt; i&lt;/code&gt; 且 &lt;code&gt;prices[j] &amp;lt;= prices[i]&lt;/code&gt; 的 &lt;strong&gt;最小下标&lt;/strong&gt; ，如果没有满足条件的 &lt;code&gt;j&lt;/code&gt; ，你将没有任何折扣。&lt;/p&gt;
&lt;p&gt;请你返回一个数组，数组中第 &lt;code&gt;i&lt;/code&gt; 个元素是折扣后你购买商品 &lt;code&gt;i&lt;/code&gt; 最终需要支付的价格。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;商品&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的价格为&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;price&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;你将得到&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的折扣&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以最终价格为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;商品&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的价格为&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;price&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;你将得到&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的折扣&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以最终价格为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;商品&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的价格为&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;price&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;你将得到&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的折扣&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以最终价格为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;商品&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;都没有折扣&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;finalPrices&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;priceDifferences&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;currentPrice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;lowerPriceIndexes&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;priceDifference&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;comparePrice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;compareIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;compareIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;comparePrice&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentPrice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;lowerPriceIndexes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;compareIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;lowerPriceIndexes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;priceDifference&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentPrice&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(...&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;lowerPriceIndexes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;priceDifference&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentPrice&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;prices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;minIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;priceDifferences&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;priceDifference&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;priceDifferences&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先遍历查询满足条件的下标，然后获取最小下标。&lt;/li&gt;
&lt;li&gt;如果没有符合条件的折扣，则使用当前价格。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2409/240916-astronauts-cosmonauts-taikonauts.html&#34;&gt;Mystery drones in USA causing alarm - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/final-prices-with-a-special-discount-in-a-shop/">1475. 商品折扣后的最终价格</a></p>
<p>给你一个数组 <code>prices</code> ，其中 <code>prices[i]</code> 是商店里第 <code>i</code> 件商品的价格。</p>
<p>商店里正在进行促销活动，如果你要买第 <code>i</code> 件商品，那么你可以得到与 <code>prices[j]</code> 相等的折扣，其中 <code>j</code> 是满足 <code>j &gt; i</code> 且 <code>prices[j] &lt;= prices[i]</code> 的 <strong>最小下标</strong> ，如果没有满足条件的 <code>j</code> ，你将没有任何折扣。</p>
<p>请你返回一个数组，数组中第 <code>i</code> 个元素是折扣后你购买商品 <code>i</code> 最终需要支付的价格。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">prices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">8</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">商品</span> <span class="mi">0</span> <span class="nx">的价格为</span> <span class="nx">price</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span><span class="o">=</span><span class="mi">8</span> <span class="err">，</span><span class="nx">你将得到</span> <span class="nx">prices</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="mi">4</span> <span class="nx">的折扣</span><span class="err">，</span><span class="nx">所以最终价格为</span> <span class="mi">8</span> <span class="o">-</span> <span class="mi">4</span> <span class="o">=</span> <span class="mi">4</span> <span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">商品</span> <span class="mi">1</span> <span class="nx">的价格为</span> <span class="nx">price</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span><span class="o">=</span><span class="mi">4</span> <span class="err">，</span><span class="nx">你将得到</span> <span class="nx">prices</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">=</span><span class="mi">2</span> <span class="nx">的折扣</span><span class="err">，</span><span class="nx">所以最终价格为</span> <span class="mi">4</span> <span class="o">-</span> <span class="mi">2</span> <span class="o">=</span> <span class="mi">2</span> <span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">商品</span> <span class="mi">2</span> <span class="nx">的价格为</span> <span class="nx">price</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span><span class="o">=</span><span class="mi">6</span> <span class="err">，</span><span class="nx">你将得到</span> <span class="nx">prices</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span><span class="o">=</span><span class="mi">2</span> <span class="nx">的折扣</span><span class="err">，</span><span class="nx">所以最终价格为</span> <span class="mi">6</span> <span class="o">-</span> <span class="mi">2</span> <span class="o">=</span> <span class="mi">4</span> <span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">商品</span> <span class="mi">3</span> <span class="nx">和</span> <span class="mi">4</span> <span class="nx">都没有折扣</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">finalPrices</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">prices</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">priceDifferences</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="nx">prices</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">currentPrice</span><span class="p">,</span> <span class="nx">currentIndex</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">lowerPriceIndexes</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">priceDifference</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="nx">prices</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">comparePrice</span><span class="p">,</span> <span class="nx">compareIndex</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">compareIndex</span> <span class="o">&gt;</span> <span class="nx">currentIndex</span> <span class="o">&amp;&amp;</span> <span class="nx">comparePrice</span> <span class="o">&lt;=</span> <span class="nx">currentPrice</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">lowerPriceIndexes</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">compareIndex</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">lowerPriceIndexes</span><span class="p">.</span><span class="nx">length</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">priceDifference</span> <span class="o">=</span> <span class="nx">currentPrice</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nx">minIndex</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(...</span><span class="nx">lowerPriceIndexes</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="nx">priceDifference</span> <span class="o">=</span> <span class="nx">currentPrice</span> <span class="o">-</span> <span class="nx">prices</span><span class="p">[</span><span class="nx">minIndex</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="nx">priceDifferences</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">priceDifference</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">priceDifferences</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>先遍历查询满足条件的下标，然后获取最小下标。</li>
<li>如果没有符合条件的折扣，则使用当前价格。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2409/240916-astronauts-cosmonauts-taikonauts.html">Mystery drones in USA causing alarm - Breaking News English Lesson</a></p>
<p>美国各地已经有数百起神秘无人机的目击事件。上个月，人们首次开始向警方讲述无人机的情况。从那以后，越来越多的人报告看到了他们。大多数目击事件发生在新泽西州。那里的居民很担心，因为无人机一直在军事基地上空飞行。在新泽西州唐纳德·特朗普的高尔夫球场附近发现了一架无人机。由于“可疑”无人机活动，纽约州斯图尔特机场上周关闭了一个小时。美国当局表示，他们不确定无人机来自哪里。一位发言人表示，不明飞行物（UFO）对公众没有危险。</p>
<p>由于无人机目击事件，许多阴谋论在网上开始出现。社交媒体上的一些人说俄罗斯和中国正在利用这些物体监视美国。一名新泽西州共和党众议员表示，这些无人机来自大西洋的一艘“伊朗母舰”。美国国土安全部部长告诉美国广播公司新闻，他知道“没有外国参与这些目击事件”。他补充说：“如果我们发现任何外国参与或犯罪活动，我们将与美国公众沟通。”联邦调查局调查人员表示，大多数无人机目击事件都是“认错人”的情况，人们对新闻报道“反应过度”。</p>
<h2 id="tip">Tip</h2>
<p><code>Element Plus</code>组件库的<code>Table</code>表格组件，在设置<code>el-table-column</code>的<code>type</code>为<code>selection</code>，<code>align</code>为<code>center</code>时，出现只有表头居中了，但是内容没有居中，排查了一下原因，是因为在自行封装的Table组件中，设置了<code>show-overflow-tooltip</code>，虽然已经过滤了type为custom的情况，但是缺少了过滤<code>selection</code>的情况，所以勾选框多了一个<code>el-tooltip</code>的样式，导致<code>center</code>不生效。</p>
<h2 id="share">Share</h2>
<p>因为在《铁齿铜牙纪晓岚》中知道“皎皎者易污”，然后把李固的《遗黄琼书》书信内容也看了一下，不得不说，写的真好，发人深省：</p>
<ol>
<li>盖君子谓：“伯夷隘，柳下惠不恭。”</li>
<li>常闻语曰：“峣峣者易缺，皎皎者易污。”《阳春》之曲，和者必寡；盛名之下，其实难副。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 44</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-44/</link>
      <pubDate>Wed, 09 Oct 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-44/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/reverse-words-in-a-string-iii/&#34;&gt;557. 反转字符串中的单词 III&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个字符串 &lt;code&gt;s&lt;/code&gt; ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;Let&amp;#39;s take LeetCode contest&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;s&amp;#39;teL ekat edoCteeL tsetnoc&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;reverseWords&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;match&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;sr&#34;&gt;/\S+/g&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;word&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;word&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;reverse&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;().&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;join&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;trimEnd&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;();&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;&lt;code&gt;String.prototype.match()&lt;/code&gt; 方法检索字符串与正则表达式进行匹配的结果。比如以上示例，&lt;code&gt;s.match(/\S+/g)&lt;/code&gt;的结果为&lt;code&gt; [ &amp;quot;Let&#39;s&amp;quot;, &#39;take&#39;, &#39;LeetCode&#39;, &#39;contest&#39; ]&lt;/code&gt;。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2409/240916-astronauts-cosmonauts-taikonauts.html&#34;&gt;Record number of people in space - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;太空变得越来越拥挤了。目前，太空中创纪录地有19人。这一记录是在俄罗斯联盟号宇宙飞船的三名乘员与国际空间站（ISS）对接后打破的。最近的任务包括NASA宇航员Don Pettit和俄罗斯宇航员Alexey Ovchinin以及Ivan Vagner。他们将国际空间站的居民人数增加到了12人。中国的宇航员也是这一记录的一部分。他们在天宫空间站有三名“太空人”在工作。剩下的四名太空旅行者是SpaceX的极光黎明任务的一部分。该项目在上周四见证了历史上第一次全平民太空行走。&lt;/p&gt;
&lt;p&gt;关于最近的记录有一点争议，那就是关于外太空起点的定义。NASA和美国军方将地球大气层和外太空的边界视为海拔80公里。按照这种解释，人类在太空中的记录是20人，在2023年5月和今年1月创下。然而，外太空边缘的传统定义被称为卡门线。国际航空联合会将这条线定为海拔100公里。新的记录使用了这个定义。卡门线用于法律目的，以区分飞机和宇宙飞船。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在给项目配置&lt;code&gt;Sentry&lt;/code&gt;时，要将&lt;code&gt;sourcemaps&lt;/code&gt;通过&lt;code&gt;sentry-wizard&lt;/code&gt;自动上传至&lt;code&gt;Sentry&lt;/code&gt;，但是却提示以下报错信息：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;Loading&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Wizard&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;failed&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Did&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;you&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;provide&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;the&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;URL&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;?&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;再三确认&lt;code&gt;URL&lt;/code&gt;是没有问题，所以，就很奇怪这是什么问题？&lt;/p&gt;
&lt;p&gt;使用&lt;code&gt;curl&lt;/code&gt;命令是没有问题的，但是，返回了&lt;code&gt;Sentry&lt;/code&gt;网站没有证书的信息。&lt;/p&gt;
&lt;p&gt;查看&lt;code&gt;Github&lt;/code&gt;上面的&lt;code&gt;Issues&lt;/code&gt;，发现有类似的问题，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;a href=&#34;https://github.com/getsentry/sentry-wizard/issues/416&#34;&gt;Loading Wizard failed for NextJs #416&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;提供的解决方案是，使用命令 &lt;code&gt;set NODE_TLS_REJECT_UNAUTHORIZED=0&lt;/code&gt; ，因为在&lt;code&gt;Node.js&lt;/code&gt; 中，&lt;code&gt;NODE_TLS_REJECT_UNAUTHORIZED&lt;/code&gt; 是一个环境变量，用于控制&lt;code&gt;Node.js&lt;/code&gt;在执行&lt;code&gt;HTTPS&lt;/code&gt;请求时是否应该拒绝未经授权的&lt;code&gt;SSL&lt;/code&gt;证书。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/reverse-words-in-a-string-iii/">557. 反转字符串中的单词 III</a></p>
<p>给定一个字符串 <code>s</code> ，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;Let&#39;s take LeetCode contest&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="s2">&#34;s&#39;teL ekat edoCteeL tsetnoc&#34;</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">reverseWords</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="nx">s</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="sr">/\S+/g</span><span class="p">).</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">word</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">result</span> <span class="o">+=</span> <span class="nx">word</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">).</span><span class="nx">reverse</span><span class="p">().</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39; &#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span><span class="p">.</span><span class="nx">trimEnd</span><span class="p">();</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p><code>String.prototype.match()</code> 方法检索字符串与正则表达式进行匹配的结果。比如以上示例，<code>s.match(/\S+/g)</code>的结果为<code> [ &quot;Let's&quot;, 'take', 'LeetCode', 'contest' ]</code>。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2409/240916-astronauts-cosmonauts-taikonauts.html">Record number of people in space - Breaking News English Lesson</a></p>
<p>太空变得越来越拥挤了。目前，太空中创纪录地有19人。这一记录是在俄罗斯联盟号宇宙飞船的三名乘员与国际空间站（ISS）对接后打破的。最近的任务包括NASA宇航员Don Pettit和俄罗斯宇航员Alexey Ovchinin以及Ivan Vagner。他们将国际空间站的居民人数增加到了12人。中国的宇航员也是这一记录的一部分。他们在天宫空间站有三名“太空人”在工作。剩下的四名太空旅行者是SpaceX的极光黎明任务的一部分。该项目在上周四见证了历史上第一次全平民太空行走。</p>
<p>关于最近的记录有一点争议，那就是关于外太空起点的定义。NASA和美国军方将地球大气层和外太空的边界视为海拔80公里。按照这种解释，人类在太空中的记录是20人，在2023年5月和今年1月创下。然而，外太空边缘的传统定义被称为卡门线。国际航空联合会将这条线定为海拔100公里。新的记录使用了这个定义。卡门线用于法律目的，以区分飞机和宇宙飞船。</p>
<h2 id="tip">Tip</h2>
<p>在给项目配置<code>Sentry</code>时，要将<code>sourcemaps</code>通过<code>sentry-wizard</code>自动上传至<code>Sentry</code>，但是却提示以下报错信息：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">Loading</span> <span class="nx">Wizard</span> <span class="nx">failed</span><span class="p">.</span> <span class="nx">Did</span> <span class="nx">you</span> <span class="nx">provide</span> <span class="nx">the</span> <span class="nx">right</span> <span class="nx">URL</span><span class="o">?</span>
</span></span></code></pre></div><p>再三确认<code>URL</code>是没有问题，所以，就很奇怪这是什么问题？</p>
<p>使用<code>curl</code>命令是没有问题的，但是，返回了<code>Sentry</code>网站没有证书的信息。</p>
<p>查看<code>Github</code>上面的<code>Issues</code>，发现有类似的问题，如下所示：</p>
<p><a href="https://github.com/getsentry/sentry-wizard/issues/416">Loading Wizard failed for NextJs #416</a></p>
<p>提供的解决方案是，使用命令 <code>set NODE_TLS_REJECT_UNAUTHORIZED=0</code> ，因为在<code>Node.js</code> 中，<code>NODE_TLS_REJECT_UNAUTHORIZED</code> 是一个环境变量，用于控制<code>Node.js</code>在执行<code>HTTPS</code>请求时是否应该拒绝未经授权的<code>SSL</code>证书。</p>
<p>然后，可以使用命令<code>npx @sentry/wizard@latest -i sourcemaps</code>可以正常执行了，只是在运行<code>npm run build</code>进行打包的时候，还是报错了，提示证书异常：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">error</span><span class="o">:</span> <span class="nx">API</span> <span class="nx">request</span> <span class="nx">failed</span>
</span></span><span class="line"><span class="cl">  <span class="nx">caused</span> <span class="nx">by</span><span class="o">:</span> <span class="p">[</span><span class="mi">60</span><span class="p">]</span> <span class="nx">SSL</span> <span class="nx">peer</span> <span class="nx">certificate</span> <span class="nx">or</span> <span class="nx">SSH</span> <span class="nx">remote</span> <span class="nx">key</span> <span class="nx">was</span> <span class="nx">not</span> <span class="nx">OK</span> <span class="p">(</span><span class="nx">schannel</span><span class="o">:</span> <span class="nx">SEC_E_UNTRUSTED_ROOT</span> <span class="p">(</span><span class="mh">0x80090325</span><span class="p">))</span>
</span></span></code></pre></div><p>所以，还是没办法解决，后来，<code>Sentry</code>更新了证书就好了。</p>
<h2 id="share">Share</h2>
<p>“套用98年乔丹对斯科特·伯勒尔的一段话：‘你肯定想再来一局，你想告诉你的外孙们，你打败了乔丹，那我和我外孙们说点什么？说我打败了斯科特·伯勒尔吗？’这才是真正的杀人诛心！他们赢了乔丹可以使劲吹。乔丹赢了他们有意思吗？”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 43</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-43/</link>
      <pubDate>Tue, 08 Oct 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-43/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/sign-of-the-product-of-an-array/&#34;&gt;1822. 数组元素积的符号&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;已知函数 &lt;code&gt;signFunc(x)&lt;/code&gt; 将会根据 &lt;code&gt;x&lt;/code&gt; 的正负返回特定值：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;如果 &lt;code&gt;x&lt;/code&gt; 是正数，返回 &lt;code&gt;1&lt;/code&gt; 。&lt;/li&gt;
&lt;li&gt;如果 &lt;code&gt;x&lt;/code&gt; 是负数，返回 &lt;code&gt;-1&lt;/code&gt; 。&lt;/li&gt;
&lt;li&gt;如果 &lt;code&gt;x&lt;/code&gt; 是等于 &lt;code&gt;0&lt;/code&gt; ，返回 &lt;code&gt;0&lt;/code&gt; 。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;nums&lt;/code&gt; 。令 &lt;code&gt;product&lt;/code&gt; 为数组 &lt;code&gt;nums&lt;/code&gt; 中所有元素值的乘积。&lt;/p&gt;
&lt;p&gt;返回 &lt;code&gt;signFunc(product)&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;数组中所有值的乘积是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;144&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;signFunc&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;144&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arraySign&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;product&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;product&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;product&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;product&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;signFunc&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;product&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;signFunc&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;题目很简单。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2409/240912-nature-and-mental-health.html&#34;&gt;Nature can reduce anxiety and boost mental health - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/sign-of-the-product-of-an-array/">1822. 数组元素积的符号</a></p>
<p>已知函数 <code>signFunc(x)</code> 将会根据 <code>x</code> 的正负返回特定值：</p>
<ul>
<li>如果 <code>x</code> 是正数，返回 <code>1</code> 。</li>
<li>如果 <code>x</code> 是负数，返回 <code>-1</code> 。</li>
<li>如果 <code>x</code> 是等于 <code>0</code> ，返回 <code>0</code> 。</li>
</ul>
<p>给你一个整数数组 <code>nums</code> 。令 <code>product</code> 为数组 <code>nums</code> 中所有元素值的乘积。</p>
<p>返回 <code>signFunc(product)</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span><span class="o">-</span><span class="mi">2</span><span class="p">,</span><span class="o">-</span><span class="mi">3</span><span class="p">,</span><span class="o">-</span><span class="mi">4</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">数组中所有值的乘积是</span> <span class="mi">144</span> <span class="err">，</span><span class="nx">且</span> <span class="nx">signFunc</span><span class="p">(</span><span class="mi">144</span><span class="p">)</span> <span class="o">=</span> <span class="mi">1</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">arraySign</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">product</span> <span class="o">=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    <span class="nx">nums</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">n</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">n</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">product</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="nx">product</span> <span class="o">=</span> <span class="nx">product</span> <span class="o">*</span> <span class="nx">n</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">signFunc</span><span class="p">(</span><span class="nx">product</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">signFunc</span><span class="p">(</span><span class="nx">p</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">p</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">p</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="o">-</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>题目很简单。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2409/240912-nature-and-mental-health.html">Nature can reduce anxiety and boost mental health - Breaking News English Lesson</a></p>
<p>我们都知道，置身于大自然中对我们有好处。新的研究表明，在自然界中仅 10 分钟就有助于我们的心理健康。该研究还表示，在自然环境中与他人共度时光有助于建立人际关系。即使在城市公园和园艺中也可以有所作为。香港城市大学的一项研究发现，大自然增加了我们将他人视为“完全的人”的方式。研究人员表示，这使我们更多地帮助和合作他人。我们变得更善于交际。这让我们对自己感觉更好。我们感觉更积极，因此我们的心理健康得到了改善。帮助他人也可以减轻我们的压力和焦虑。</p>
<p>心理健康是一个在世界范围内日益增长的问题。越来越多的人患有焦虑、抑郁和其他心理障碍。美国全国精神疾病联盟报告称，五分之一的美国人有心理健康问题。该研究包含关于大自然如何帮助解决这些问题的好建议。它说，在树上或田野里度过的时间与更好的睡眠和注意力的提高有关。日本千叶大学的一项研究发现，即使是鲜花也对心理健康有积极影响。研究人员发现，办公桌上放着一瓶玫瑰的员工在短短四分钟后就变得更加平静，压力也减轻了。</p>
<h2 id="tip">Tip</h2>
<p>在维护部门内部的API库时，出现执行命令报错，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202309251531813.png"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">errors</span><span class="o">:</span><span class="mi">477</span>
</span></span><span class="line"><span class="cl">    <span class="nx">ErrorCaptureStackTrace</span><span class="p">(</span><span class="nx">err</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="o">^</span>
</span></span><span class="line"><span class="cl"><span class="nb">Error</span><span class="o">:</span> <span class="nx">Command</span> <span class="nx">failed</span> <span class="kd">with</span> <span class="nx">ENOENT</span><span class="o">:</span> <span class="nx">npm</span> <span class="nx">run</span> <span class="nx">clean</span>
</span></span><span class="line"><span class="cl"><span class="nx">spawn</span> <span class="nx">npm</span> <span class="nx">run</span> <span class="nx">clean</span> <span class="nx">ENOENT</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">Process</span><span class="p">.</span><span class="nx">ChildProcess</span><span class="p">.</span><span class="nx">_handle</span><span class="p">.</span><span class="nx">onexit</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">child_process</span><span class="o">:</span><span class="mi">283</span><span class="o">:</span><span class="mi">19</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">onErrorNT</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">child_process</span><span class="o">:</span><span class="mi">478</span><span class="o">:</span><span class="mi">16</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">processTicksAndRejections</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">process</span><span class="o">/</span><span class="nx">task_queues</span><span class="o">:</span><span class="mi">83</span><span class="o">:</span><span class="mi">21</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">errno</span><span class="o">:</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">code</span><span class="o">:</span> <span class="s1">&#39;ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">syscall</span><span class="o">:</span> <span class="s1">&#39;spawn npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">path</span><span class="o">:</span> <span class="s1">&#39;npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">spawnargs</span><span class="o">:</span> <span class="p">[],</span>
</span></span><span class="line"><span class="cl">  <span class="nx">originalMessage</span><span class="o">:</span> <span class="s1">&#39;spawn npm run clean ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">shortMessage</span><span class="o">:</span> <span class="s1">&#39;Command failed with ENOENT: npm run clean\nspawn npm run clean ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">command</span><span class="o">:</span> <span class="s1">&#39;npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">exitCode</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">signal</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">signalDescription</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">stdout</span><span class="o">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">stderr</span><span class="o">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">failed</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">timedOut</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">isCanceled</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">killed</span><span class="o">:</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>从报错信息可知，代码在执行到<code>npm run clean</code>命令时报错了，提示找不到这个命令，但是我复制命令在终端运行是成功的，在windows10系统是没问题的，但我在mac系统上运行就报错了，执行代码如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">await</span> <span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>初步猜测，可能execa用法在mac环境中不生效。将其注释，没有提示报错，所以，接着就要研究如何在mac环境中使用execa了。只需将</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span> 
</span></span></code></pre></div><p>改写为</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;run&#39;</span><span class="p">,</span> <span class="s1">&#39;clean&#39;</span><span class="p">],</span> <span class="p">{</span> <span class="nx">shell</span><span class="o">:</span> <span class="kc">true</span> <span class="p">})</span>
</span></span></code></pre></div><p>即可，这时，我们就会想知道这两种用法有什么区别呢？</p>
<p><code>execa</code>是一个用于执行<code>shell</code>命令的<code>Node.js</code>模块，它可以将命令作为参数传递给它，并返回一个<code>Promise</code>，以便在命令执行完成之后处理。根据报错提示没有找到<code>npm</code>命令，很有可能是execa模块无法正确识别到环境变量。</p>
<p>所以将<code>npm run clean</code>拆分为<code>npm</code>和<code>run clean</code>两个参数，并将 shell 选项设置为<code>true</code>，以便在子进程中运行命令的时候使用默认的<code>shell</code>，这样可以正确找到<code>npm</code>命令并且识别环境变量，找到<code>npm</code>命令。</p>
<h2 id="share">Share</h2>
<p>“上兵伐谋，其次伐交，其次伐兵，其下攻城。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 42</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-42/</link>
      <pubDate>Wed, 02 Oct 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-42/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/check-if-number-has-equal-digit-count-and-digit-value/&#34;&gt;2283. 判断一个数的数字计数是否等于数位的值&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个下标从 &lt;strong&gt;0&lt;/strong&gt; 开始长度为 &lt;code&gt;n&lt;/code&gt; 的字符串 &lt;code&gt;num&lt;/code&gt; ，它只包含数字。&lt;/p&gt;
&lt;p&gt;如果对于 &lt;strong&gt;每个&lt;/strong&gt; &lt;code&gt;0 &amp;lt;= i &amp;lt; n&lt;/code&gt; 的下标 &lt;code&gt;i&lt;/code&gt; ，都满足数位 &lt;code&gt;i&lt;/code&gt; 在 &lt;code&gt;num&lt;/code&gt; 中出现了 &lt;code&gt;num[i]&lt;/code&gt;次，那么请你返回 &lt;code&gt;true&lt;/code&gt; ，否则返回 &lt;code&gt;false&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;1&amp;#39;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;数字&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中出现了一次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;2&amp;#39;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;数字&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中出现了两次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;1&amp;#39;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;数字&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中出现了一次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;数字&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;中出现了零次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;1210&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;满足题目要求条件&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以返回&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;digitCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;console&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;log&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;({&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;getCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;getCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;postion&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;postion&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;postion&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;postion&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;只需求得下标字符&lt;code&gt;i&lt;/code&gt;在字符串中出现的次数与&lt;code&gt;num[i]&lt;/code&gt;相等即可。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2409/240909-marmosets.html&#34;&gt;Marmoset monkeys call each other by name - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/check-if-number-has-equal-digit-count-and-digit-value/">2283. 判断一个数的数字计数是否等于数位的值</a></p>
<p>给你一个下标从 <strong>0</strong> 开始长度为 <code>n</code> 的字符串 <code>num</code> ，它只包含数字。</p>
<p>如果对于 <strong>每个</strong> <code>0 &lt;= i &lt; n</code> 的下标 <code>i</code> ，都满足数位 <code>i</code> 在 <code>num</code> 中出现了 <code>num[i]</code>次，那么请你返回 <code>true</code> ，否则返回 <code>false</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">num</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;1&#39;</span> <span class="err">。</span><span class="nx">数字</span> <span class="mi">0</span> <span class="nx">在</span> <span class="nx">num</span> <span class="nx">中出现了一次</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">num</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;2&#39;</span> <span class="err">。</span><span class="nx">数字</span> <span class="mi">1</span> <span class="nx">在</span> <span class="nx">num</span> <span class="nx">中出现了两次</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">num</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;1&#39;</span> <span class="err">。</span><span class="nx">数字</span> <span class="mi">2</span> <span class="nx">在</span> <span class="nx">num</span> <span class="nx">中出现了一次</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">num</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">=</span> <span class="s1">&#39;0&#39;</span> <span class="err">。</span><span class="nx">数字</span> <span class="mi">3</span> <span class="nx">在</span> <span class="nx">num</span> <span class="nx">中出现了零次</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="s2">&#34;1210&#34;</span> <span class="nx">满足题目要求条件</span><span class="err">，</span><span class="nx">所以返回</span> <span class="kc">true</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">digitCount</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">num</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">num</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">n</span> <span class="o">=</span> <span class="nx">num</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">({</span> <span class="nx">i</span><span class="p">,</span> <span class="nx">n</span> <span class="p">});</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nb">Number</span><span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="o">!==</span> <span class="nx">getCount</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">num</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">getCount</span><span class="p">(</span><span class="kr">char</span><span class="p">,</span> <span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">postion</span> <span class="o">=</span> <span class="nx">s</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="kr">char</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="nx">postion</span> <span class="o">!==-</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span><span class="o">++</span>
</span></span><span class="line"><span class="cl">            <span class="nx">postion</span> <span class="o">=</span> <span class="nx">s</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="kr">char</span><span class="p">,</span> <span class="nx">postion</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">count</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>只需求得下标字符<code>i</code>在字符串中出现的次数与<code>num[i]</code>相等即可。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2409/240909-marmosets.html">Marmoset monkeys call each other by name - Breaking News English Lesson</a></p>
<p>研究人员表示，狨猴会叫出对方的名字，类似于人类识别彼此的方式。这种 20 厘米长的灵长类动物原产于南美洲。耶路撒冷希伯来大学的科学家研究了 10 只狨猴的社会互动。研究小组发现，这些动物对他们组中的其他猴子使用了独特的叫声。该研究的合著者大卫·奥马尔博士说，狨猴是已知的第一批使用名字的非人类灵长类动物。研究人员将狨猴分为各种配对。然后，他们使用人工智能分析了 50,000 多只猴子的叫声。这使科学家们能够确定这些动物彼此都有名字。</p>
<p>Omer 博士认为，这些发现可以揭示人类语言是如何进化的。他说：“直到最近，人们还认为人类语言是一个无中生有的奇异现象。我们开始看到证据表明情况并非如此。Omer 假设了狨猴是如何发展出一种叫名系统的。他说：“狨猴生活在一夫一妻制的小家庭群体中，就像人类一样一起照顾它们的幼崽。这些相似性表明，他们面临着与我们早期前语言祖先相当的进化社会挑战。其他已知能通过名字识别同类生物的生物是海豚和大象。</p>
<h2 id="tip">Tip</h2>
<p>在<code>Windows</code>系统中，要删除多层级的文件夹，比如项目依赖包<code>node_module</code>，它的目录可能包含有成千上万的文件和子目录，因为系统删除时会将这些文件逐一检查，读取文件大小、权限验证等，会额外增加删除所需的时间，如果电脑配置不太行，真的让人受不了。</p>
<p>基于博文<a href="https://blog.csdn.net/xiaoerbuyu1233/article/details/108490963">《Windows下快速删除上万个文件和子目录(快速删除文件) 命令行cmd快速删除文件夹》</a>提供的解决方案如下：</p>
<p>在<code>D:\tools\FASTDEL</code>中新建一个<code>fastdel.bat</code>文件，然后复制下面的代码：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bat" data-lang="bat"><span class="line"><span class="cl"><span class="p">@</span><span class="k">ECHO</span> OFF
</span></span><span class="line"><span class="cl"><span class="k">ECHO</span> Delete Folder: <span class="nv">%CD%</span>
</span></span><span class="line"><span class="cl"><span class="k">PAUSE</span>
</span></span><span class="line"><span class="cl"><span class="k">SET</span> <span class="nv">FOLDER</span><span class="p">=</span><span class="nv">%CD%</span>
</span></span><span class="line"><span class="cl"><span class="k">CD</span> ..
</span></span><span class="line"><span class="cl"><span class="k">DEL</span> /F/Q/S <span class="s2">&#34;</span><span class="nv">%FOLDER%</span><span class="s2">\*&#34;</span> <span class="p">&gt;</span> NUL
</span></span><span class="line"><span class="cl"><span class="k">RMDIR</span> /Q/S <span class="s2">&#34;</span><span class="nv">%FOLDER%</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="k">EXIT</span>
</span></span></code></pre></div><p>保存之后，打开系统环境变量配置页面，在<code>Path</code>路径加上<code>D:\tools\FASTDEL</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409211001590.png"></p>
<p>之后，在你要删除的文件目录下，打开<code>Windows PowerShell</code>命令窗口，然后输入命令<code>FASTDEL</code>进行删除即可，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409211020986.png"></p>
<h2 id="share">Share</h2>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202410021756188.jpg"></p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 41</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-41/</link>
      <pubDate>Mon, 30 Sep 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-41/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/find-all-anagrams-in-a-string/&#34;&gt;438. 找到字符串中所有字母异位词&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定两个字符串 &lt;code&gt;s&lt;/code&gt; 和 &lt;code&gt;p&lt;/code&gt;，找到 &lt;code&gt;s&lt;/code&gt; 中所有 &lt;code&gt;p&lt;/code&gt; 的 异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;cbaebabacd&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;abc&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;起始索引等于&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的子串是&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;cba&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;它是&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;abc&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的异位词&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;起始索引等于&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的子串是&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;bac&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;它是&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;abc&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的异位词&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;findAnagrams&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;pCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;26&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;fill&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; 
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;26&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;fill&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;pCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;isEqual&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;pCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;a&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;charCodeAt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;isEqual&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;pCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sCount&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;p&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isEqual&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;count1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;26&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;count1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;创建&lt;code&gt;pCount&lt;/code&gt;和&lt;code&gt;sCount&lt;/code&gt;字母表，通过一个字母的&lt;code&gt;Unicode&lt;/code&gt;编码减去字母a的&lt;code&gt;Unicode&lt;/code&gt;编码，得到其在字母表中的位置，并且将其计数，通过滑动窗口，左减右加，最后通过对比相同位置计数是否相等，来确定是否是字母异位词。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2409/240902-eye-colour-change.html&#34;&gt;Eye colour change is riskiest cosmetic surgery - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/find-all-anagrams-in-a-string/">438. 找到字符串中所有字母异位词</a></p>
<p>给定两个字符串 <code>s</code> 和 <code>p</code>，找到 <code>s</code> 中所有 <code>p</code> 的 异位词的子串，返回这些子串的起始索引。不考虑答案输出的顺序。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;cbaebabacd&#34;</span><span class="p">,</span> <span class="nx">p</span> <span class="o">=</span> <span class="s2">&#34;abc&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">6</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span>
</span></span><span class="line"><span class="cl"><span class="nx">起始索引等于</span> <span class="mi">0</span> <span class="nx">的子串是</span> <span class="s2">&#34;cba&#34;</span><span class="p">,</span> <span class="nx">它是</span> <span class="s2">&#34;abc&#34;</span> <span class="nx">的异位词</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">起始索引等于</span> <span class="mi">6</span> <span class="nx">的子串是</span> <span class="s2">&#34;bac&#34;</span><span class="p">,</span> <span class="nx">它是</span> <span class="s2">&#34;abc&#34;</span> <span class="nx">的异位词</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">findAnagrams</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">s</span><span class="p">,</span> <span class="nx">p</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">p</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="nx">s</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">pCount</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="mi">26</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span> 
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">sCount</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="mi">26</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="kr">char</span> <span class="k">of</span> <span class="nx">p</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">pCount</span><span class="p">[</span><span class="kr">char</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span> <span class="o">-</span> <span class="s1">&#39;a&#39;</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)]</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">p</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">sCount</span><span class="p">[</span><span class="nx">s</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">-</span> <span class="s1">&#39;a&#39;</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)]</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">isEqual</span><span class="p">(</span><span class="nx">pCount</span><span class="p">,</span> <span class="nx">sCount</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">result</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">p</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">s</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">sCount</span><span class="p">[</span><span class="nx">s</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="nx">p</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="o">-</span> <span class="s1">&#39;a&#39;</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)]</span> <span class="o">-=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="nx">sCount</span><span class="p">[</span><span class="nx">s</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span> <span class="o">-</span> <span class="s1">&#39;a&#39;</span><span class="p">.</span><span class="nx">charCodeAt</span><span class="p">(</span><span class="mi">0</span><span class="p">)]</span> <span class="o">+=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">isEqual</span><span class="p">(</span><span class="nx">pCount</span><span class="p">,</span> <span class="nx">sCount</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">result</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">i</span> <span class="o">-</span> <span class="nx">p</span><span class="p">.</span><span class="nx">length</span> <span class="o">+</span> <span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">isEqual</span><span class="p">(</span><span class="nx">count1</span><span class="p">,</span> <span class="nx">count2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="mi">26</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">count1</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">!==</span> <span class="nx">count2</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>创建<code>pCount</code>和<code>sCount</code>字母表，通过一个字母的<code>Unicode</code>编码减去字母a的<code>Unicode</code>编码，得到其在字母表中的位置，并且将其计数，通过滑动窗口，左减右加，最后通过对比相同位置计数是否相等，来确定是否是字母异位词。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2409/240902-eye-colour-change.html">Eye colour change is riskiest cosmetic surgery - Breaking News English Lesson</a></p>
<p>全世界越来越多的人选择整容手术来提升他们的容貌。潜在患者可能不知道的是，改变眼睛颜色的手术是风险最大的。在线眼镜店 Overnight Glasses 进行的研究断言，眼部颜色手术有92%的可能性出现并发症。眼睛颜色变化在研究人员最危险的整容手术名单中名列前茅。此类手术包括虹膜植入物和激光色素去除。还有一个称为角膜色素沉着的程序。这是一种永久性的眼睛颜色变化，其中使用精密激光技术将特殊的着色剂插入眼睛中。</p>
<p>今年早些时候，美国眼科学会发布了对眼睛变色手术的警告。Ashley Brissette 博士强调了可能出错的事情。这些包括染料泄漏、过敏反应、感染、对光敏感、可能导致混浊或视力丧失的角膜损伤，以及最终失明。她说：“我们用眼睛做的任何事情，都必须非常非常小心。研究人员表示，恢复时间可能长达两个月，手术的平均费用为 12,000 美元。眼科医生 Nicole Bajic 建议戴彩色隐形眼镜，而不是动刀。她说，“可以给你你想要的外观，而不会危及你的眼睛健康”。</p>
<h2 id="tip">Tip</h2>
<p>在使用<code>npm i</code>命令给项目安装依赖时，出现卡住的情况，等了好久，也没见成功或者中断，这就无法入手去解决问题。使用命令<code>npm install --verbose</code>可以看到安装的更多信息，便于排查问题。</p>
<h2 id="share">Share</h2>
<p>“珍惜现在，就是穿越时空。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 40</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-40/</link>
      <pubDate>Thu, 19 Sep 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-40/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/rotate-array/&#34;&gt;189. 轮转数组&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个整数数组 &lt;code&gt;nums&lt;/code&gt;，将数组中的元素向右轮转 &lt;code&gt;k&lt;/code&gt; 个位置，其中 &lt;code&gt;k&lt;/code&gt; 是非负数。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;向右轮转&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;步&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;向右轮转&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;步&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;向右轮转&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;步&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;rotate&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;middlePart&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;splice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;unshift&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(...&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;middlePart&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;通过示例1，可以找到规律，元素向右轮转了k个位置，相当于从 &lt;code&gt;nums.length - count&lt;/code&gt; 位置截取然后再添加到数组的开头位置。如果&lt;code&gt;k&lt;/code&gt;的值等于数组长度，那么，经过向右轮转之后，各元素还是原位。因此，使用 &lt;code&gt;k % nums.length&lt;/code&gt; 取余，处理当k大于数组长度的情况。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2408/240812-emotional-attachment-to-ai.html&#34;&gt;1Scientists fear people will fall in love with AI voices - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;拥有 ChatGPT 的公司 OpenAI 担心人们可能会在情感上依赖人工智能的声音。该公司上周向用户发布了一种新的“高级语音模式”。聊天机器人配备了一系列栩栩如生的声音，这些声音与人声几乎没有区别。他们可以实时进行真实的对话，在适当的时间大笑，用“嗯”、“啊”和“嗯”插话，他们可以适应被打断。OpenAI 的一份报告指出，新发布的、听起来像人的声音可能会导致人们依赖 AI 来陪伴，甚至浪漫和爱情。它警告说：“用户可能会与 AI 建立社交关系，从而减少他们对人类互动的需求。&lt;/p&gt;
&lt;p&gt;OpenAI 报告警告说，未来的聊天机器人可能会从根本上改变社会。它们将重塑我们与家人、朋友和同事的互动方式。他们甚至可能篡夺人类之间的交流。该报告指出了新工具的好处。这些包括给孤独的人带来安慰和友谊，给那些缺乏自信的人信心。报告称，人们可能会获得足够的信心来开始在现实世界中约会。另一方面，聊天机器人可能会导致人们变得更粗鲁、更不耐烦和更自私。Wired.com 写道，新的聊天机器人包括“潜在的&amp;hellip;&amp;hellip;放大社会偏见，传播虚假信息，并帮助开发化学或生物武器”。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在运行&lt;code&gt;electron-vue&lt;/code&gt;项目时，打算把&lt;code&gt;node_modules&lt;/code&gt;删除了再重新安装，却提示&lt;code&gt;node_modules/electron&lt;/code&gt;文件夹正在被使用，删除失败。然后，把相关窗口都关闭了还是不行，猜测是有关联的进程没有关闭，所以，就看下怎么处理。步骤如下：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/rotate-array/">189. 轮转数组</a></p>
<p>给定一个整数数组 <code>nums</code>，将数组中的元素向右轮转 <code>k</code> 个位置，其中 <code>k</code> 是非负数。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">],</span> <span class="nx">k</span> <span class="o">=</span> <span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span>
</span></span><span class="line"><span class="cl"><span class="nx">向右轮转</span> <span class="mi">1</span> <span class="nx">步</span><span class="o">:</span> <span class="p">[</span><span class="mi">7</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">向右轮转</span> <span class="mi">2</span> <span class="nx">步</span><span class="o">:</span> <span class="p">[</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">向右轮转</span> <span class="mi">3</span> <span class="nx">步</span><span class="o">:</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">rotate</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">k</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">k</span> <span class="o">&lt;=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">count</span> <span class="o">=</span> <span class="nx">k</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">count</span> <span class="o">=</span> <span class="nx">k</span> <span class="o">%</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">middlePart</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">count</span><span class="p">,</span> <span class="nx">count</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="nx">nums</span><span class="p">.</span><span class="nx">unshift</span><span class="p">(...</span><span class="nx">middlePart</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">nums</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>通过示例1，可以找到规律，元素向右轮转了k个位置，相当于从 <code>nums.length - count</code> 位置截取然后再添加到数组的开头位置。如果<code>k</code>的值等于数组长度，那么，经过向右轮转之后，各元素还是原位。因此，使用 <code>k % nums.length</code> 取余，处理当k大于数组长度的情况。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2408/240812-emotional-attachment-to-ai.html">1Scientists fear people will fall in love with AI voices - Breaking News English Lesson</a></p>
<p>拥有 ChatGPT 的公司 OpenAI 担心人们可能会在情感上依赖人工智能的声音。该公司上周向用户发布了一种新的“高级语音模式”。聊天机器人配备了一系列栩栩如生的声音，这些声音与人声几乎没有区别。他们可以实时进行真实的对话，在适当的时间大笑，用“嗯”、“啊”和“嗯”插话，他们可以适应被打断。OpenAI 的一份报告指出，新发布的、听起来像人的声音可能会导致人们依赖 AI 来陪伴，甚至浪漫和爱情。它警告说：“用户可能会与 AI 建立社交关系，从而减少他们对人类互动的需求。</p>
<p>OpenAI 报告警告说，未来的聊天机器人可能会从根本上改变社会。它们将重塑我们与家人、朋友和同事的互动方式。他们甚至可能篡夺人类之间的交流。该报告指出了新工具的好处。这些包括给孤独的人带来安慰和友谊，给那些缺乏自信的人信心。报告称，人们可能会获得足够的信心来开始在现实世界中约会。另一方面，聊天机器人可能会导致人们变得更粗鲁、更不耐烦和更自私。Wired.com 写道，新的聊天机器人包括“潜在的&hellip;&hellip;放大社会偏见，传播虚假信息，并帮助开发化学或生物武器”。</p>
<h2 id="tip">Tip</h2>
<p>在运行<code>electron-vue</code>项目时，打算把<code>node_modules</code>删除了再重新安装，却提示<code>node_modules/electron</code>文件夹正在被使用，删除失败。然后，把相关窗口都关闭了还是不行，猜测是有关联的进程没有关闭，所以，就看下怎么处理。步骤如下：</p>
<p>打开任务管理器 ➔ 性能 ➔ CPU ➔ 打开资源监视器 ➔ 关联的句柄 ➔ 搜索句柄electron ➔ 右键结束进程。</p>
<h2 id="share">Share</h2>
<p>查理·芒格的“大猩猩理论”：一个聪明人进入一个有大猩猩的房间，解释他的想法是什么，而那个大猩猩只是坐在那里吃它的香蕉。结束这段谈话后，那个解释的人出来时一定变得更聪明了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 39</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-39/</link>
      <pubDate>Wed, 18 Sep 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-39/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/check-if-n-and-its-double-exist/&#34;&gt;1346. 检查整数及其两倍数是否存在&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;arr&lt;/code&gt;，请你检查是否存在两个整数 &lt;code&gt;N&lt;/code&gt; 和 &lt;code&gt;M&lt;/code&gt;，满足 &lt;code&gt;N&lt;/code&gt; 是 &lt;code&gt;M&lt;/code&gt; 的两倍（即，&lt;code&gt;N = 2 * M&lt;/code&gt;）。&lt;/p&gt;
&lt;p&gt;更正式地，检查是否存在两个下标 &lt;code&gt;i&lt;/code&gt; 和 &lt;code&gt;j&lt;/code&gt; 满足：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;i != j&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;0 &amp;lt;= i, j &amp;lt; arr.length&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;arr[i] == 2 * arr[j]&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;N&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;是&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;M&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的两倍&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;即&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;checkIfExist&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;map&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;includes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;把整数数组中的每个整数都乘以2，然后验证其值是否和数组中油相等的存在，如果存在，并且它的下标并不相等（为了排除&lt;code&gt;0*2=0&lt;/code&gt;的情况），则证明整数及其两倍数存在。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2408/240805-mercury-diamonds.html&#34;&gt;18-km wide diamond layer on Mercury, says study&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;美国著名影星玛丽莲·梦露曾唱过一首著名的歌:“钻石是女孩最好的朋友”。比利时列日大学的科学家们相信，他们已经发掘出了数量巨大的这种宝石。在水星的地壳下可能有一个18公里宽的宝石层。离我们最近的行星邻居很可能是天上的一颗宝石。研究人员测试了大约45亿年前水星是如何形成的。这颗行星是从宇宙尘埃和气体云的旋转中演化而来的。经过数百万年的时间，尘埃被压缩成石墨，石墨的化学性质与钻石相同。两者都是碳元素的固体形式。水星上的钻石不太可能被开采出来，因为它们在地表以下约500公里处。&lt;/p&gt;
&lt;p&gt;研究人员使用一种被称为砧压机的机器来模拟水星形成的条件。这台印刷机是用来制造人造钻石的。研究人员在石墨胶囊内混合了各种元素。其中包括硅、镁和铝。太空舱承受的压力是地球上的7万倍。它被加热到2000摄氏度的温度。首席研究员推测水星上的钻石。他说:“钻石只由碳构成，所以它们应该与我们在地球上所知道的相似……它们会像纯钻石。”科学家们相信在地球表面下有一千万亿吨钻石。专家表示，这些隐藏的宝石的价值几乎无法估量。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;使用&lt;code&gt;Chrome&lt;/code&gt;访问&lt;code&gt;HTTP&lt;/code&gt;网站时，因为浏览器自动转为&lt;code&gt;HTTPS&lt;/code&gt;导致访问失败，查了下网上的解决方案，如下所示：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;在&lt;code&gt;Chrome&lt;/code&gt;浏览器地址栏输入&lt;code&gt;chrome://net-internals/#hsts&lt;/code&gt;并回车。&lt;/li&gt;
&lt;li&gt;找到页面中的&lt;code&gt;Delete domain security policies&lt;/code&gt;部分。&lt;/li&gt;
&lt;li&gt;输入导致问题的网站域名。&lt;/li&gt;
&lt;li&gt;点击&lt;code&gt;Delete&lt;/code&gt;按钮删除该域名的安全策略。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;p&gt;前些天，早上过来公司，打开菜鸟教程网站，看了下正则表达式的内容，然后看了“关于我们”一栏，里面有句话说得蛮好的：“我们坚持一件事情，并不是因为这样做了会有效果，而是坚信，这样做是对的。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/check-if-n-and-its-double-exist/">1346. 检查整数及其两倍数是否存在</a></p>
<p>给你一个整数数组 <code>arr</code>，请你检查是否存在两个整数 <code>N</code> 和 <code>M</code>，满足 <code>N</code> 是 <code>M</code> 的两倍（即，<code>N = 2 * M</code>）。</p>
<p>更正式地，检查是否存在两个下标 <code>i</code> 和 <code>j</code> 满足：</p>
<ul>
<li><code>i != j</code></li>
<li><code>0 &lt;= i, j &lt; arr.length</code></li>
<li><code>arr[i] == 2 * arr[j]</code></li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">10</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">N</span> <span class="o">=</span> <span class="mi">10</span> <span class="nx">是</span> <span class="nx">M</span> <span class="o">=</span> <span class="mi">5</span> <span class="nx">的两倍</span><span class="err">，</span><span class="nx">即</span> <span class="mi">10</span> <span class="o">=</span> <span class="mi">2</span> <span class="o">*</span> <span class="mi">5</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">checkIfExist</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">map</span><span class="p">((</span><span class="nx">m</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">index</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">m</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">index</span> <span class="o">!=</span> <span class="o">-</span><span class="mi">1</span> <span class="o">&amp;&amp;</span> <span class="nx">index</span> <span class="o">!=</span> <span class="nx">i</span>
</span></span><span class="line"><span class="cl">  <span class="p">})</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">result</span><span class="p">.</span><span class="nx">includes</span><span class="p">(</span><span class="kc">true</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>把整数数组中的每个整数都乘以2，然后验证其值是否和数组中油相等的存在，如果存在，并且它的下标并不相等（为了排除<code>0*2=0</code>的情况），则证明整数及其两倍数存在。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2408/240805-mercury-diamonds.html">18-km wide diamond layer on Mercury, says study</a></p>
<p>美国著名影星玛丽莲·梦露曾唱过一首著名的歌:“钻石是女孩最好的朋友”。比利时列日大学的科学家们相信，他们已经发掘出了数量巨大的这种宝石。在水星的地壳下可能有一个18公里宽的宝石层。离我们最近的行星邻居很可能是天上的一颗宝石。研究人员测试了大约45亿年前水星是如何形成的。这颗行星是从宇宙尘埃和气体云的旋转中演化而来的。经过数百万年的时间，尘埃被压缩成石墨，石墨的化学性质与钻石相同。两者都是碳元素的固体形式。水星上的钻石不太可能被开采出来，因为它们在地表以下约500公里处。</p>
<p>研究人员使用一种被称为砧压机的机器来模拟水星形成的条件。这台印刷机是用来制造人造钻石的。研究人员在石墨胶囊内混合了各种元素。其中包括硅、镁和铝。太空舱承受的压力是地球上的7万倍。它被加热到2000摄氏度的温度。首席研究员推测水星上的钻石。他说:“钻石只由碳构成，所以它们应该与我们在地球上所知道的相似……它们会像纯钻石。”科学家们相信在地球表面下有一千万亿吨钻石。专家表示，这些隐藏的宝石的价值几乎无法估量。</p>
<h2 id="tip">Tip</h2>
<p>使用<code>Chrome</code>访问<code>HTTP</code>网站时，因为浏览器自动转为<code>HTTPS</code>导致访问失败，查了下网上的解决方案，如下所示：</p>
<ol>
<li>在<code>Chrome</code>浏览器地址栏输入<code>chrome://net-internals/#hsts</code>并回车。</li>
<li>找到页面中的<code>Delete domain security policies</code>部分。</li>
<li>输入导致问题的网站域名。</li>
<li>点击<code>Delete</code>按钮删除该域名的安全策略。</li>
</ol>
<h2 id="share">Share</h2>
<p>前些天，早上过来公司，打开菜鸟教程网站，看了下正则表达式的内容，然后看了“关于我们”一栏，里面有句话说得蛮好的：“我们坚持一件事情，并不是因为这样做了会有效果，而是坚信，这样做是对的。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 38</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-38/</link>
      <pubDate>Fri, 13 Sep 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-38/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/the-employee-that-worked-on-the-longest-task/&#34;&gt;2432. 处理用时最长的那个任务的员工&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;共有 &lt;code&gt;n&lt;/code&gt; 位员工，每位员工都有一个从 &lt;code&gt;0&lt;/code&gt; 到 &lt;code&gt;n - 1&lt;/code&gt; 的唯一 id 。&lt;/p&gt;
&lt;p&gt;给你一个二维整数数组 &lt;code&gt;logs&lt;/code&gt; ，其中 &lt;code&gt;logs[i] = [idi, leaveTimei]&lt;/code&gt; ：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;idi&lt;/code&gt; 是处理第 &lt;code&gt;i&lt;/code&gt; 个任务的员工的 id ，且&lt;/li&gt;
&lt;li&gt;&lt;code&gt;leaveTimei&lt;/code&gt; 是员工完成第 &lt;code&gt;i&lt;/code&gt; 个任务的时刻。所有 &lt;code&gt;leaveTimei&lt;/code&gt; 的值都是 &lt;strong&gt;唯一&lt;/strong&gt; 的。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;注意，第 &lt;code&gt;i&lt;/code&gt; 个任务在第 &lt;code&gt;(i - 1)&lt;/code&gt; 个任务结束后立即开始，且第 &lt;code&gt;0&lt;/code&gt; 个任务从时刻 &lt;code&gt;0&lt;/code&gt; 开始。&lt;/p&gt;
&lt;p&gt;返回处理用时最长的那个任务的员工的 id 。如果存在两个或多个员工同时满足，则返回几人中 &lt;strong&gt;最小&lt;/strong&gt; 的 id 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;任务&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;于时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;开始&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且在时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;结束&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;共计&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;个单位时间&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;任务&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;于时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;开始&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且在时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;结束&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;共计&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;个单位时间&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;任务&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;于时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;开始&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且在时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;结束&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;共计&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;个单位时间&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;任务&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;于时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;开始&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;且在时刻&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;结束&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;共计&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;个单位时间&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;时间最长的任务是任务&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;而&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;id&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的员工是处理此任务的员工&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以返回&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;hardestWorker&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestDuration&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;employeeDurationDifferences&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;log&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentTimeDiff&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;employeeDurationDifferences&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;([&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;logs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentTimeDiff&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;longestDuration&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;longestDuration&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentTimeDiff&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestDurationEmployees&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;employeeDurationDifferences&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;filter&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;diff&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;diff&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestDuration&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果只存在一个员工是这个任务时长，则直接返回该员工的ID
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;longestDurationEmployees&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestDurationEmployees&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestDurationEmployeeIds&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;longestDurationEmployees&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;record&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;longestDurationEmployeeIds&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;record&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(...&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;longestDurationEmployeeIds&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/the-employee-that-worked-on-the-longest-task/">2432. 处理用时最长的那个任务的员工</a></p>
<p>共有 <code>n</code> 位员工，每位员工都有一个从 <code>0</code> 到 <code>n - 1</code> 的唯一 id 。</p>
<p>给你一个二维整数数组 <code>logs</code> ，其中 <code>logs[i] = [idi, leaveTimei]</code> ：</p>
<ul>
<li><code>idi</code> 是处理第 <code>i</code> 个任务的员工的 id ，且</li>
<li><code>leaveTimei</code> 是员工完成第 <code>i</code> 个任务的时刻。所有 <code>leaveTimei</code> 的值都是 <strong>唯一</strong> 的。</li>
</ul>
<p>注意，第 <code>i</code> 个任务在第 <code>(i - 1)</code> 个任务结束后立即开始，且第 <code>0</code> 个任务从时刻 <code>0</code> 开始。</p>
<p>返回处理用时最长的那个任务的员工的 id 。如果存在两个或多个员工同时满足，则返回几人中 <strong>最小</strong> 的 id 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">n</span> <span class="o">=</span> <span class="mi">10</span><span class="p">,</span> <span class="nx">logs</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">],[</span><span class="mi">0</span><span class="p">,</span><span class="mi">9</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">15</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">任务</span> <span class="mi">0</span> <span class="nx">于时刻</span> <span class="mi">0</span> <span class="nx">开始</span><span class="err">，</span><span class="nx">且在时刻</span> <span class="mi">3</span> <span class="nx">结束</span><span class="err">，</span><span class="nx">共计</span> <span class="mi">3</span> <span class="nx">个单位时间</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">任务</span> <span class="mi">1</span> <span class="nx">于时刻</span> <span class="mi">3</span> <span class="nx">开始</span><span class="err">，</span><span class="nx">且在时刻</span> <span class="mi">5</span> <span class="nx">结束</span><span class="err">，</span><span class="nx">共计</span> <span class="mi">2</span> <span class="nx">个单位时间</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">任务</span> <span class="mi">2</span> <span class="nx">于时刻</span> <span class="mi">5</span> <span class="nx">开始</span><span class="err">，</span><span class="nx">且在时刻</span> <span class="mi">9</span> <span class="nx">结束</span><span class="err">，</span><span class="nx">共计</span> <span class="mi">4</span> <span class="nx">个单位时间</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">任务</span> <span class="mi">3</span> <span class="nx">于时刻</span> <span class="mi">9</span> <span class="nx">开始</span><span class="err">，</span><span class="nx">且在时刻</span> <span class="mi">15</span> <span class="nx">结束</span><span class="err">，</span><span class="nx">共计</span> <span class="mi">6</span> <span class="nx">个单位时间</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">时间最长的任务是任务</span> <span class="mi">3</span> <span class="err">，</span><span class="nx">而</span> <span class="nx">id</span> <span class="nx">为</span> <span class="mi">1</span> <span class="nx">的员工是处理此任务的员工</span><span class="err">，</span><span class="nx">所以返回</span> <span class="mi">1</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">hardestWorker</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">n</span><span class="p">,</span> <span class="nx">logs</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">longestDuration</span> <span class="o">=</span> <span class="nx">logs</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">employeeDurationDifferences</span> <span class="o">=</span> <span class="p">[[</span><span class="nx">logs</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span> <span class="nx">logs</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">]]];</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nx">logs</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">log</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">index</span> <span class="o">&gt;=</span> <span class="nx">logs</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">currentTimeDiff</span> <span class="o">=</span> <span class="nx">logs</span><span class="p">[</span><span class="nx">index</span> <span class="o">+</span> <span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">]</span> <span class="o">-</span> <span class="nx">logs</span><span class="p">[</span><span class="nx">index</span><span class="p">][</span><span class="mi">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="nx">employeeDurationDifferences</span><span class="p">.</span><span class="nx">push</span><span class="p">([</span><span class="nx">logs</span><span class="p">[</span><span class="nx">index</span> <span class="o">+</span> <span class="mi">1</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span> <span class="nx">currentTimeDiff</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">        <span class="nx">longestDuration</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">longestDuration</span><span class="p">,</span> <span class="nx">currentTimeDiff</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">longestDurationEmployees</span> <span class="o">=</span> <span class="nx">employeeDurationDifferences</span><span class="p">.</span><span class="nx">filter</span><span class="p">(</span><span class="nx">diff</span> <span class="p">=&gt;</span> <span class="nx">diff</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="nx">longestDuration</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果只存在一个员工是这个任务时长，则直接返回该员工的ID
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">longestDurationEmployees</span><span class="p">.</span><span class="nx">length</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">longestDurationEmployees</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">longestDurationEmployeeIds</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="nx">longestDurationEmployees</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">record</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">longestDurationEmployeeIds</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">record</span><span class="p">[</span><span class="mi">0</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(...</span><span class="nx">longestDurationEmployeeIds</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，通过<code>logs</code>二维数组，获取到每个员工的<code>ID</code>以及对应的任务时长，同时，使用<code>Math.max()</code>函数求得任务时长最大值，然后，筛选任务时长最大值的员工<code>ID</code>，如果只有一个员工，则直接返回结果，否则，通过遍历获取全部的员工<code>ID</code>，再使用<code>Math.min()</code>函数，求得最小值。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2407/240729-violence-against-women.html">Violence against women and girls at &rsquo;epidemic&rsquo; levels</a></p>
<p>英国警方发布了一份报告，强调针对妇女和女孩的暴力事件急剧增加。报告指出，厌女症和针对妇女的犯罪行为达到了创纪录的水平。据报道，一年内有100多万起此类犯罪。这可能只是冰山一角。将会有大量的暴力事件没有被报道。伦敦大都会警察局撰文描述了这一问题的严重性。报告称:“针对妇女和女孩的暴力是地方性的、系统性的，对社会的威胁与恐怖主义一样严重。”它补充说，针对妇女的犯罪占所有记录犯罪的20%。它说:“我们必须采取行动，改变妇女和女孩无法接受的现实。”</p>
<p>该报告由英国国家警察局长委员会和警务学院发布。副警长麦琪·布莱斯称这些数据“令人震惊”。她说:“对妇女和女孩的暴力行为是国家的紧急情况。作为一个社会，我们需要向前迈进，做出改变，不再认为针对妇女和女孩的暴力是不可避免的。”警方表示:“每12名女性中就有1人会成为暴力的受害者。每六起谋杀案中就有一起是家庭暴力造成的。每20个人中就有1个人——其中超过200万人——在他们的生活中会对妇女和女孩施暴。”报告称，基于性别的暴力犯罪包括骚扰、谋杀、网络性虐待、强奸和跟踪。</p>
<h2 id="tip">Tip</h2>
<p>markdown 文档如何自动加上标题编号？</p>
<p>因为我那个记录问题的<code>markdown</code>文档，需要时不时更新一下内容，所以，标题的编号也要同步更新，这个文档内容那么多，改起来工作量很大，只能研究一下，怎么在<code>markdown</code>文档里自动加上标题编号。</p>
<p>在<code>VSCode</code>里有插件能够实现这个需求，自己也使用了一段时间，感觉还是很方便的，只是因为电脑更新系统，不小心卸载了这个插件，不太记得插件名字了，只能使用另一个———— <a href="https://marketplace.visualstudio.com/items?itemName=panchaoxin.markdown-header">Markdown Header</a>。可使用这个插件增加标题编号时，发现它并不是基于现有的标题编号进行更新，而是额外增加了标题编号，比如<code>1.1 1.1</code>，加上要清空标题编号没有生效，只能看下，怎么把当前文档里的标题编号全都清空，然后，再使用这个插件自动生成标题编号，解决思路是，在<code>VSCode</code>中使用正则表达式搜索，匹配到<code># 1.2.3</code>类似的格式，一个<code>#</code>加一个空格，然后是标题编号，全部替换成<code>#</code>即可。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="p">(</span><span class="err">#\</span><span class="nx">s</span><span class="o">+</span><span class="p">)(</span><span class="err">\</span><span class="nx">b</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">(</span><span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">*</span><span class="err">\</span><span class="nx">b</span><span class="p">)</span>
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409051357213.png"></p>
<p>接着，使用<code>Ctrl+Shift+P</code>，选择<code>Markdown generate header number</code>，一键生成标题编号。</p>
<h2 id="share">Share</h2>
<p>“若不披上这件衣裳，众生又怎知我尘缘已断、金海尽干？”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 37</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-37/</link>
      <pubDate>Sat, 10 Aug 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-37/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/check-if-it-is-a-straight-line/&#34;&gt;1232. 缀点成线&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个数组 &lt;code&gt;coordinates&lt;/code&gt; ，其中 &lt;code&gt;coordinates[i] = [x, y]&lt;/code&gt; ， &lt;code&gt;[x, y]&lt;/code&gt; 表示横坐标为 &lt;code&gt;x&lt;/code&gt;、纵坐标为 &lt;code&gt;y&lt;/code&gt; 的点。请你来判断，这些点是否在该坐标系中属于同一条直线上。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202408031032533.jpeg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;checkStraightLine&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 两点确定一条直线
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 同一个X轴
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;allEqualX&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;every&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;allEqualX&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 同一个Y轴
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;allEqualY&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;every&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;allEqualY&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 对角线
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 斜率
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;slope&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 遍历剩余的坐标点，检查斜率是否一致
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;xi&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;yi&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coordinates&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 避免除以零，并且使用交叉乘积来比较斜率
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;yi&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;xi&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，我们明确需求，即判断一组点是否都在同一直线上。这包括三种情况：所有点的X轴坐标相同、所有点的Y轴坐标相同，或者是这些点构成一条斜线。我们可以使用&lt;code&gt;every&lt;/code&gt;方法遍历数组中的点，对比它们的X轴或Y轴坐标是否相同。&lt;/p&gt;
&lt;p&gt;接下来，对于斜线的判断，我们需要验证这些点的斜率是否一致。如果直接计算斜率 &lt;code&gt;(yi - y0) / (xi - x0)&lt;/code&gt; 并与另一个斜率 &lt;code&gt;(y2 - y1) / (x2 - x1)&lt;/code&gt; 进行比较，而 &lt;code&gt;x2 - x1&lt;/code&gt; 为0时，会遇到除零错误或浮点数精度问题。为了避免这些问题，我们可以使用交叉乘积的方法，即两边同时乘以 &lt;code&gt;(xi - x0) * (x2 - x1)&lt;/code&gt;，从而得到 &lt;code&gt;(yi - y0) * (x1 - x0) == (y1 - y0) * (xi - x0)&lt;/code&gt; 作为斜率是否相等的判断条件。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/check-if-it-is-a-straight-line/">1232. 缀点成线</a></p>
<p>给定一个数组 <code>coordinates</code> ，其中 <code>coordinates[i] = [x, y]</code> ， <code>[x, y]</code> 表示横坐标为 <code>x</code>、纵坐标为 <code>y</code> 的点。请你来判断，这些点是否在该坐标系中属于同一条直线上。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202408031032533.jpeg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">coordinates</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],[</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">],[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">],[</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],[</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">checkStraightLine</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">coordinates</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 两点确定一条直线
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">if</span> <span class="p">(</span><span class="nx">coordinates</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 同一个X轴
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">allEqualX</span> <span class="o">=</span> <span class="nx">coordinates</span><span class="p">.</span><span class="nx">every</span><span class="p">((</span><span class="nx">item</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">item</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">===</span> <span class="nx">coordinates</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">allEqualX</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 同一个Y轴
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">allEqualY</span> <span class="o">=</span> <span class="nx">coordinates</span><span class="p">.</span><span class="nx">every</span><span class="p">((</span><span class="nx">item</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">item</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="nx">coordinates</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">allEqualY</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 对角线
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="p">[</span><span class="nx">x0</span><span class="p">,</span> <span class="nx">y0</span><span class="p">]</span> <span class="o">=</span> <span class="nx">coordinates</span><span class="p">[</span><span class="mi">0</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">  <span class="kr">const</span> <span class="p">[</span><span class="nx">x1</span><span class="p">,</span> <span class="nx">y1</span><span class="p">]</span> <span class="o">=</span> <span class="nx">coordinates</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 斜率
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="kr">const</span> <span class="nx">slope</span> <span class="o">=</span> <span class="p">(</span><span class="nx">y1</span> <span class="o">-</span> <span class="nx">y0</span><span class="p">)</span> <span class="o">/</span> <span class="p">(</span><span class="nx">x1</span> <span class="o">-</span> <span class="nx">x0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 遍历剩余的坐标点，检查斜率是否一致
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">coordinates</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="p">[</span><span class="nx">xi</span><span class="p">,</span> <span class="nx">yi</span><span class="p">]</span> <span class="o">=</span> <span class="nx">coordinates</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 避免除以零，并且使用交叉乘积来比较斜率
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">((</span><span class="nx">yi</span> <span class="o">-</span> <span class="nx">y0</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nx">x1</span> <span class="o">-</span> <span class="nx">x0</span><span class="p">)</span> <span class="o">!==</span> <span class="p">(</span><span class="nx">y1</span> <span class="o">-</span> <span class="nx">y0</span><span class="p">)</span> <span class="o">*</span> <span class="p">(</span><span class="nx">xi</span> <span class="o">-</span> <span class="nx">x0</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="kc">false</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，我们明确需求，即判断一组点是否都在同一直线上。这包括三种情况：所有点的X轴坐标相同、所有点的Y轴坐标相同，或者是这些点构成一条斜线。我们可以使用<code>every</code>方法遍历数组中的点，对比它们的X轴或Y轴坐标是否相同。</p>
<p>接下来，对于斜线的判断，我们需要验证这些点的斜率是否一致。如果直接计算斜率 <code>(yi - y0) / (xi - x0)</code> 并与另一个斜率 <code>(y2 - y1) / (x2 - x1)</code> 进行比较，而 <code>x2 - x1</code> 为0时，会遇到除零错误或浮点数精度问题。为了避免这些问题，我们可以使用交叉乘积的方法，即两边同时乘以 <code>(xi - x0) * (x2 - x1)</code>，从而得到 <code>(yi - y0) * (x1 - x0) == (y1 - y0) * (xi - x0)</code> 作为斜率是否相等的判断条件。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2407/240725-mass-tourism.html">Spanish residents take to streets against mass tourism - Breaking News English Lesson</a></p>
<p>西班牙成千上万的人正在抗议大众旅游。在巴塞罗那，居民们用水枪向餐馆里的游客喷射。在马略卡岛上，一万人走上街头，手举横幅，上面写着：“够了！”和“马略卡不出售！”马略卡岛的人们对他们的租金上涨感到愤怒。由于旅游业的发展，当地人几乎无法购买房屋。由于公司正在购买房产以租给游客，房价飙升。Airbnb的一位发言人说：“旅游业从业者无法在自己所在的城市负担得起租金。”她补充说：“我们认为将经济……建立在……旅游业之上是不可持续的，必须改变。”
旅游区的居民有很多抱怨。他们说旅游对他们的生活产生了负面影响。许多人再也找不到住的地方了。一些人不得不搬出家园，因为房东正在提高租金。日常生活也成了问题。公交车和火车上挤满了背包客和拉着行李箱的游客。由于垃圾不断增加，城镇很难保持街道清洁。当地人也抱怨说，由于游客，他们无法在自己喜欢的餐馆吃饭。西班牙并不是唯一一个旅游业成为问题的国家。日本、奥地利和墨西哥已经采取行动，寻求在帮助当地人和可持续旅游业之间找到平衡。</p>
<h2 id="tip">Tip</h2>
<p><code>&lt;img&gt;</code> 动态修改图片颜色</p>
<p>在实现<code>el-menu</code>动态配置菜单图标的时候，因为从字体图标替换成在线获取的<code>.svg</code>图片，所以需要研究下如何实现动态配置颜色，好解决后续各项目不同主题的需求。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="nt">transform</span><span class="o">:</span> <span class="nt">translateX</span><span class="o">(</span><span class="nt">-80px</span><span class="o">);</span>
</span></span><span class="line"><span class="cl"><span class="nt">filter</span><span class="o">:</span> <span class="nt">drop-shadow</span><span class="o">(</span><span class="p">#</span><span class="nn">a80f0f</span> <span class="nt">80px</span> <span class="nt">0</span><span class="o">);</span>
</span></span></code></pre></div><h2 id="share">Share</h2>
<h2 id="独家专访亚马逊-cto-werner-vogels--infoq"><a href="https://mp.weixin.qq.com/s/YAvZPZfTFBLZ3OqnIHJElg">独家专访亚马逊 CTO Werner Vogels | InfoQ </a></h2>
<ol>
<li>各种商业机构和教育平台都能帮我们快速掌握新的编程语言，所以到底选择哪种语言本身已经不那么重要了。</li>
<li>由于技术发展太过迅速，高等教育、大学课程根本就跟不上变化。问问那些刚刚走出校园的学生就知道了，他们对区块链、生成式 AI 等新技术的了解肯定不如我们这些从业者。而且随着技术的采用周期越来越短，产品的上市速度也会远超以往。也就是说，学校里传授的知识不再具有先进性。所以除了编程语言之外，我们在学校中的最大收获就是学习能力，这种学习能力决定我们能否成为技术专家、保持终身钻研。</li>
<li>我认为任何接受过良好基础教育的人都有能力掌握计算机技术，即便专业不同。因为具体学了什么专业并不重要，重要的是教育经历让你掌握了学习能力、知道要如何设立更宏大的目标、如何汇总信息、记在脑子里、进行批判性思考，如此往复。</li>
<li>在实际工作中，我强调“协作”是日常工作的核心。</li>
<li>对于招聘，我更关心候选人是否具备在大学里培养的学习能力，而不仅仅是特定的语言或技术。</li>
<li>技术的变化一刻不停，永远别指望自己毕业之后头一年学到的东西够用一辈子。</li>
<li>但保守并不代表守旧，研究人员还是在努力把成果整合起来，打造出能让消费者们眼前一亮的产品。就像那个有趣的比喻，如果你看到一只熊在跳舞，那最重要的就是它能跳舞，而不是它跳得好不好。希望大家能用类似的心态看待前沿技术，尽量宽容一点。</li>
<li>AI 可以接管一些繁琐的任务，这使得开发者可以更专注于他们真正擅长的工作，如获取和整合信息、做出决策和规划。</li>
<li>人需要肩负起监管的职责。请记住，AI 只是辅助、是帮助我们的工具。它们是在帮我们做预测，而不是替我们做预测，责任永远要由人来承担。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 36</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-36/</link>
      <pubDate>Sun, 07 Jul 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-36/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/shuffle-string/&#34;&gt;1528. 重新排列字符串&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;s&lt;/code&gt; 和一个 &lt;strong&gt;长度相同&lt;/strong&gt; 的整数数组 &lt;code&gt;indices&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;请你重新排列字符串 &lt;code&gt;s&lt;/code&gt; ，其中第 &lt;code&gt;i&lt;/code&gt; 个字符需要移动到 &lt;code&gt;indices[i]&lt;/code&gt; 指示的位置。&lt;/p&gt;
&lt;p&gt;返回重新排列后的字符串。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/26/q1.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;codeleet&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;indices&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;leetcode&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;如上图所示&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;codeleet&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;重新排列后变为&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;leetcode&amp;#34;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;restoreString&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;indices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;indices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;题目很简单，只需要遍历&lt;code&gt;indices&lt;/code&gt;数组，对于每个遍历到的索引&lt;code&gt;i&lt;/code&gt;，我们取出&lt;code&gt;indices[i]&lt;/code&gt;的值，这个值直接对应了字符串&lt;code&gt;s&lt;/code&gt;中某个字符的索引。然后，我们根据这个索引从&lt;code&gt;s&lt;/code&gt;中取出相应的字符，并将这些字符按照&lt;code&gt;indices&lt;/code&gt;数组的顺序依次拼接起来，形成新的字符串。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2406/240624-medicinal-plants.html&#34;&gt;Chimpanzees use medicinal plants when sick - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;人类自史前时代起便开始使用药用植物，至今全球各地仍在使用传统草药。科学家首次发现黑猩猩也会寻找森林中的果实来为自己治病。英国牛津大学的研究人员在乌干达的布东戈中央森林保护区对黑猩猩的行为进行了研究。研究人员跟踪了一只手部受伤的黑猩猩，发现它在寻找一种蕨类植物的叶子。这种蕨类植物可能具有减轻黑猩猩手部肿胀的功效。另一只患有寄生虫感染的黑猩猩则寻找猫棘树的树皮，这有助于缓解它的病情。&lt;/p&gt;
&lt;p&gt;研究团队表示，黑猩猩的疾病和受伤情况与它们所食用的植物的药用特性之间存在很强的相关性。研究人员测试了不属于黑猩猩正常饮食的植物提取物，发现88%的提取物具有抗菌特性，33%的提取物具有抗炎特性。研究员兼人类学家艾洛蒂·弗雷曼博士表示：“药理学研究结果表明，布东戈的黑猩猩会食用多种具有强大药用特性的植物。”她说，她的团队对灵长类动物行为的研究可能为我们在生活中更广泛地使用自然疗法铺平道路。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在&lt;code&gt;Vue Next&lt;/code&gt;项目开发过程中，我们需要调试一些鼠标悬停才会出现的元素，比如&lt;code&gt;Element Plus&lt;/code&gt; 里的 &lt;code&gt;&amp;lt;el-dropdown&amp;gt;&lt;/code&gt; 组件，如要修改它下拉菜单的背景色，可使用鼠标悬停显示下拉框，然后按下快捷键 &lt;code&gt;Ctrl + Shift + C&lt;/code&gt; 触发视图查看，再点击下拉框即可获取&lt;code&gt;Class&lt;/code&gt;名称进行修改，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407050954853.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407051007783.png&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;p&gt;每个人所要追求的东西并不一样，没必要强人所难，说过一两次就够了，平常心对待，说到底，只不过一份工作而已，承载不了太多的东西。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/shuffle-string/">1528. 重新排列字符串</a></p>
<p>给你一个字符串 <code>s</code> 和一个 <strong>长度相同</strong> 的整数数组 <code>indices</code> 。</p>
<p>请你重新排列字符串 <code>s</code> ，其中第 <code>i</code> 个字符需要移动到 <code>indices[i]</code> 指示的位置。</p>
<p>返回重新排列后的字符串。</p>
<p><img alt="img" loading="lazy" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/07/26/q1.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;codeleet&#34;</span><span class="p">,</span> <span class="nx">indices</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="s2">&#34;leetcode&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">如上图所示</span><span class="err">，</span><span class="s2">&#34;codeleet&#34;</span> <span class="nx">重新排列后变为</span> <span class="s2">&#34;leetcode&#34;</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">restoreString</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">s</span><span class="p">,</span> <span class="nx">indices</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">indices</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">result</span> <span class="o">+=</span> <span class="nx">s</span><span class="p">[</span><span class="nx">indices</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">i</span><span class="p">)];</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>题目很简单，只需要遍历<code>indices</code>数组，对于每个遍历到的索引<code>i</code>，我们取出<code>indices[i]</code>的值，这个值直接对应了字符串<code>s</code>中某个字符的索引。然后，我们根据这个索引从<code>s</code>中取出相应的字符，并将这些字符按照<code>indices</code>数组的顺序依次拼接起来，形成新的字符串。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2406/240624-medicinal-plants.html">Chimpanzees use medicinal plants when sick - Breaking News English Lesson</a></p>
<p>人类自史前时代起便开始使用药用植物，至今全球各地仍在使用传统草药。科学家首次发现黑猩猩也会寻找森林中的果实来为自己治病。英国牛津大学的研究人员在乌干达的布东戈中央森林保护区对黑猩猩的行为进行了研究。研究人员跟踪了一只手部受伤的黑猩猩，发现它在寻找一种蕨类植物的叶子。这种蕨类植物可能具有减轻黑猩猩手部肿胀的功效。另一只患有寄生虫感染的黑猩猩则寻找猫棘树的树皮，这有助于缓解它的病情。</p>
<p>研究团队表示，黑猩猩的疾病和受伤情况与它们所食用的植物的药用特性之间存在很强的相关性。研究人员测试了不属于黑猩猩正常饮食的植物提取物，发现88%的提取物具有抗菌特性，33%的提取物具有抗炎特性。研究员兼人类学家艾洛蒂·弗雷曼博士表示：“药理学研究结果表明，布东戈的黑猩猩会食用多种具有强大药用特性的植物。”她说，她的团队对灵长类动物行为的研究可能为我们在生活中更广泛地使用自然疗法铺平道路。</p>
<h2 id="tip">Tip</h2>
<p>在<code>Vue Next</code>项目开发过程中，我们需要调试一些鼠标悬停才会出现的元素，比如<code>Element Plus</code> 里的 <code>&lt;el-dropdown&gt;</code> 组件，如要修改它下拉菜单的背景色，可使用鼠标悬停显示下拉框，然后按下快捷键 <code>Ctrl + Shift + C</code> 触发视图查看，再点击下拉框即可获取<code>Class</code>名称进行修改，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407050954853.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407051007783.png"></p>
<h2 id="share">Share</h2>
<p>每个人所要追求的东西并不一样，没必要强人所难，说过一两次就够了，平常心对待，说到底，只不过一份工作而已，承载不了太多的东西。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 35</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-35/</link>
      <pubDate>Sat, 06 Jul 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-35/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/latest-time-you-can-obtain-after-replacing-characters/&#34;&gt;3114. 替换字符可以得到的最晚时间&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;s&lt;/code&gt;，表示一个 12 小时制的时间格式，其中一些数字（可能没有）被 &lt;code&gt;&amp;quot;?&amp;quot;&lt;/code&gt; 替换。&lt;/p&gt;
&lt;p&gt;12 小时制时间格式为 &lt;code&gt;&amp;quot;HH:MM&amp;quot;&lt;/code&gt; ，其中 &lt;code&gt;HH&lt;/code&gt; 的取值范围为 &lt;code&gt;00&lt;/code&gt; 至 &lt;code&gt;11&lt;/code&gt;，&lt;code&gt;MM&lt;/code&gt; 的取值范围为 &lt;code&gt;00&lt;/code&gt; 至 &lt;code&gt;59&lt;/code&gt;。最早的时间为 &lt;code&gt;00:00&lt;/code&gt;，最晚的时间为 &lt;code&gt;11:59&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;你需要将 &lt;code&gt;s&lt;/code&gt; 中的 &lt;strong&gt;所有&lt;/strong&gt; &lt;code&gt;&amp;quot;?&amp;quot;&lt;/code&gt; 字符替换为数字，使得结果字符串代表的时间是一个 &lt;strong&gt;有效&lt;/strong&gt; 的 12 小时制时间，并且是可能的 &lt;strong&gt;最晚&lt;/strong&gt; 时间。&lt;/p&gt;
&lt;p&gt;返回结果字符串。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;1?:?4&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;11:54&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;通过替换&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;?&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;字符&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;可以得到的最晚12小时制时间是&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;11:54&amp;#34;&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;findLatestTime&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;replacementDigits&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;1&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;9&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;0&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;5&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;9&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;?&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;replacementDigits&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;char&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sub&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;substring&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;replacementString&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;?&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sub&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;replacementString&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;0&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;timeString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;?&amp;#34;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sub&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;replacementString&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;11&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;replacementString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;replace&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sub&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;replacementString&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，将&lt;code&gt;&amp;quot;HH:MM&amp;quot;&lt;/code&gt;的每个时分最大取值明确，然后如果是&lt;code&gt;?&lt;/code&gt;就替换成对应索引的数值，这样可以满足通用的情况下 ，在这个基础上，对特殊情况进行处理，然后得出想要的结果。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2406/240606-army-recruits.html&#34;&gt;Top US doctor wants social media health warnings - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/latest-time-you-can-obtain-after-replacing-characters/">3114. 替换字符可以得到的最晚时间</a></p>
<p>给你一个字符串 <code>s</code>，表示一个 12 小时制的时间格式，其中一些数字（可能没有）被 <code>&quot;?&quot;</code> 替换。</p>
<p>12 小时制时间格式为 <code>&quot;HH:MM&quot;</code> ，其中 <code>HH</code> 的取值范围为 <code>00</code> 至 <code>11</code>，<code>MM</code> 的取值范围为 <code>00</code> 至 <code>59</code>。最早的时间为 <code>00:00</code>，最晚的时间为 <code>11:59</code>。</p>
<p>你需要将 <code>s</code> 中的 <strong>所有</strong> <code>&quot;?&quot;</code> 字符替换为数字，使得结果字符串代表的时间是一个 <strong>有效</strong> 的 12 小时制时间，并且是可能的 <strong>最晚</strong> 时间。</p>
<p>返回结果字符串。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span> <span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;1?:?4&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span> <span class="s2">&#34;11:54&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span> <span class="nx">通过替换</span> <span class="s2">&#34;?&#34;</span> <span class="nx">字符</span><span class="err">，</span><span class="nx">可以得到的最晚12小时制时间是</span> <span class="s2">&#34;11:54&#34;</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">findLatestTime</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">timeString</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">replacementDigits</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;1&#34;</span><span class="p">,</span> <span class="s2">&#34;9&#34;</span><span class="p">,</span> <span class="s2">&#34;0&#34;</span><span class="p">,</span> <span class="s2">&#34;5&#34;</span><span class="p">,</span> <span class="s2">&#34;9&#34;</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">timeString</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="kr">char</span> <span class="o">=</span> <span class="nx">timeString</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="kr">char</span> <span class="o">===</span> <span class="s2">&#34;?&#34;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="kr">char</span> <span class="o">=</span> <span class="nx">replacementDigits</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="nx">result</span> <span class="o">+=</span> <span class="kr">char</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">sub</span> <span class="o">=</span> <span class="nx">result</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="mi">2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">replacementString</span> <span class="o">=</span> <span class="s2">&#34;&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">timeString</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">===</span> <span class="s2">&#34;?&#34;</span> <span class="o">&amp;&amp;</span> <span class="nb">Number</span><span class="p">(</span><span class="nx">sub</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">11</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">replacementString</span> <span class="o">=</span> <span class="s2">&#34;0&#34;</span> <span class="o">+</span> <span class="nx">timeString</span><span class="p">[</span><span class="mi">1</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">timeString</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="s2">&#34;?&#34;</span> <span class="o">&amp;&amp;</span> <span class="nb">Number</span><span class="p">(</span><span class="nx">sub</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">11</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">replacementString</span> <span class="o">=</span> <span class="s2">&#34;11&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">replacementString</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">result</span> <span class="o">=</span> <span class="nx">result</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="nx">sub</span><span class="p">,</span> <span class="nx">replacementString</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，将<code>&quot;HH:MM&quot;</code>的每个时分最大取值明确，然后如果是<code>?</code>就替换成对应索引的数值，这样可以满足通用的情况下 ，在这个基础上，对特殊情况进行处理，然后得出想要的结果。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2406/240606-army-recruits.html">Top US doctor wants social media health warnings - Breaking News English Lesson</a></p>
<p>社交媒体已经改变了世界。它既有好的一面，也有坏的一面。其中一个不好的地方是，它可能导致心理健康问题。这是美国顶级医生想要解决的问题。美国卫生与公共服务部部长维韦克·穆尔西希望社交媒体公司在其平台上发布有关心理健康的警告。他尤其担心这些平台对年轻人的伤害。他说算法导致年轻人接触到极端色情和暴力内容。穆尔西博士说：“现在是时候要求在社交媒体平台上贴上卫生与公共服务部长的警告标签了，指出社交媒体与青少年心理健康的严重损害有关。”他还表示，需要法律来保护年轻人在网络上的安全。</p>
<p>多年来，穆尔西博士一直在为加强对社交媒体的管控而奔走呼吁。2023年，他警告说，社交媒体对儿童和青少年的心理健康和福祉构成“严重的伤害风险”。他最近的警告发表在《纽约时报》的一篇客座文章中。他写道：“年轻人面临的心理健康危机是一场紧急事件。社交媒体已成为一个重要的促成因素。”他担心年轻人花在网络上的时间太长。他说“每天花费三个多小时在社交媒体上的年轻人面临焦虑和抑郁症状的风险是其他人的两倍。”穆尔西认为，就像香烟上的警告一样，在线警告也会有所帮助。</p>
<h2 id="tip">Tip</h2>
<p>Cookie Banner是指网站上出现的一种通知条，用于告知用户该网站使用Cookie等技术来收集、存储和处理用户数据，并且需要用户同意这些数据的使用。通常，Cookie Banner会包含一个简要的说明，告知用户使用Cookie的目的和类型，以及提供一个同意或拒绝的选项。此外，还可能包含一个链接，指向更详细的隐私政策或Cookie策略页面。</p>
<p>Cookie政策是网站提供给用户的一份声明，解释了网站如何使用Cookie（一种小型文本文件），以及与Cookie相关的数据收集和隐私保护措施。Cookie是一种存储在用户计算机上的文本文件，它包含有关用户访问网站的信息。许多网站使用Cookie来跟踪用户行为，例如记住用户首选项、购物车信息、广告和其他内容。Cookie政策通常包括以下信息：</p>
<ol>
<li>网站使用Cookie的目的和类型。</li>
<li>与Cookie相关的数据如何收集、存储和使用。</li>
<li>用户如何控制Cookie的使用和删除Cookie。</li>
<li>如何保护用户数据隐私。</li>
<li>Cookie政策的更新和变更如何通知用户。</li>
</ol>
<h2 id="share">Share</h2>
<p>既要，又要，还要。</p>
<p>不可能“我全都要的”，只能有所取舍，有失才有得。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 34</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-34/</link>
      <pubDate>Fri, 21 Jun 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-34/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/average-value-of-even-numbers-that-are-divisible-by-three/&#34;&gt;2455. 可被三整除的偶数的平均值&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个由正整数组成的整数数组 &lt;code&gt;nums&lt;/code&gt; ，返回其中可被 &lt;code&gt;3&lt;/code&gt; 整除的所有偶数的平均值。&lt;/p&gt;
&lt;p&gt;注意：&lt;code&gt;n&lt;/code&gt; 个元素的平均值等于 &lt;code&gt;n&lt;/code&gt; 个元素 &lt;strong&gt;求和&lt;/strong&gt; 再除以 &lt;code&gt;n&lt;/code&gt; ，结果 &lt;strong&gt;向下取整&lt;/strong&gt; 到最接近的整数。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;是可以被&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;整除的偶数&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;averageValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;total&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;total&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;?&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;floor&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;total&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;因为可被&lt;code&gt;3&lt;/code&gt;整除的判断条件为&lt;code&gt;nums[i] % 3 === 0&lt;/code&gt;，偶数的判断条件为&lt;code&gt;nums[i] % 2 === 0&lt;/code&gt;，所以可以合起来为&lt;code&gt;nums[i] % 6 === 0&lt;/code&gt;，然后，再使用&lt;code&gt;total&lt;/code&gt;来记录求和值，&lt;code&gt;count&lt;/code&gt;来记录次数，相除即可得到想要的平均值。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2406/240606-army-recruits.html&#34;&gt;Australia to allow foreign citizens into its army - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;澳大利亚很快将允许非澳大利亚人参军。来自英国、加拿大和新西兰等国家的人可以申请加入澳大利亚国防军(ADF)。澳大利亚在招人参军方面遇到了问题。政府希望向其他国家的人开放军队以解决征兵问题。ADF目前缺少约4400名工人。从7月起，在澳大利亚永久居住的新西兰人可以申请加入。明年，来自英国、美国和加拿大的学生将有机会。澳大利亚国防部长理查德·马尔斯(Richard Marles)表示，未来可能会有更多国家的人加入。&lt;/p&gt;
&lt;p&gt;马勒斯表示，出于安全考虑，法国正在改变征兵政策。他说:“澳大利亚政府选择发展澳大利亚国防军，因为这对于应对未来十年乃至更长时间内的国家安全挑战至关重要。”国防部发言人说:“为了发展国防军，我们采取了大胆的行动。从更广泛的人群中招募人才将有助于确保(ADF)反映澳大利亚的全面多样性，并能够吸引(所有)澳大利亚社会的人才。”反对党外交部长西蒙·伯明翰不同意这项政策。他说，这显示了政府的失败。他说:“我们应该看到更多的澳大利亚人有信心报名参加。”&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;Math.floor() 、Math.ceil() 和 Math.round()&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/average-value-of-even-numbers-that-are-divisible-by-three/">2455. 可被三整除的偶数的平均值</a></p>
<p>给你一个由正整数组成的整数数组 <code>nums</code> ，返回其中可被 <code>3</code> 整除的所有偶数的平均值。</p>
<p>注意：<code>n</code> 个元素的平均值等于 <code>n</code> 个元素 <strong>求和</strong> 再除以 <code>n</code> ，结果 <strong>向下取整</strong> 到最接近的整数。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">10</span><span class="p">,</span><span class="mi">12</span><span class="p">,</span><span class="mi">15</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">9</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="mi">6</span> <span class="nx">和</span> <span class="mi">12</span> <span class="nx">是可以被</span> <span class="mi">3</span> <span class="nx">整除的偶数</span><span class="err">。</span><span class="p">(</span><span class="mi">6</span> <span class="o">+</span> <span class="mi">12</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span> <span class="o">=</span> <span class="mi">9</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">averageValue</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">total</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">%</span> <span class="mi">6</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">total</span> <span class="o">+=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">      <span class="nx">count</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">count</span> <span class="o">&gt;</span> <span class="mi">0</span> <span class="o">?</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">floor</span><span class="p">(</span><span class="nx">total</span> <span class="o">/</span> <span class="nx">count</span><span class="p">)</span> <span class="o">:</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>因为可被<code>3</code>整除的判断条件为<code>nums[i] % 3 === 0</code>，偶数的判断条件为<code>nums[i] % 2 === 0</code>，所以可以合起来为<code>nums[i] % 6 === 0</code>，然后，再使用<code>total</code>来记录求和值，<code>count</code>来记录次数，相除即可得到想要的平均值。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2406/240606-army-recruits.html">Australia to allow foreign citizens into its army - Breaking News English Lesson</a></p>
<p>澳大利亚很快将允许非澳大利亚人参军。来自英国、加拿大和新西兰等国家的人可以申请加入澳大利亚国防军(ADF)。澳大利亚在招人参军方面遇到了问题。政府希望向其他国家的人开放军队以解决征兵问题。ADF目前缺少约4400名工人。从7月起，在澳大利亚永久居住的新西兰人可以申请加入。明年，来自英国、美国和加拿大的学生将有机会。澳大利亚国防部长理查德·马尔斯(Richard Marles)表示，未来可能会有更多国家的人加入。</p>
<p>马勒斯表示，出于安全考虑，法国正在改变征兵政策。他说:“澳大利亚政府选择发展澳大利亚国防军，因为这对于应对未来十年乃至更长时间内的国家安全挑战至关重要。”国防部发言人说:“为了发展国防军，我们采取了大胆的行动。从更广泛的人群中招募人才将有助于确保(ADF)反映澳大利亚的全面多样性，并能够吸引(所有)澳大利亚社会的人才。”反对党外交部长西蒙·伯明翰不同意这项政策。他说，这显示了政府的失败。他说:“我们应该看到更多的澳大利亚人有信心报名参加。”</p>
<h2 id="tip">Tip</h2>
<p>Math.floor() 、Math.ceil() 和 Math.round()</p>
<ol>
<li>Math.floor()，向下取整，Math.floor(5.96) = 5。</li>
<li>Math.ceil()，向上取整，Math.ceil(5.96) = 6。</li>
<li>Math.round()，四舍五入，取其值的绝对值进行四舍五入，如果原数是负数，结果保持为负。比如Math.round(5.96) = 6；Math.round(-5.0001) = -5。</li>
</ol>
<h2 id="share">Share</h2>
<p>第二名就是头号输家。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 33</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-33/</link>
      <pubDate>Thu, 20 Jun 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-33/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/special-array-i/&#34;&gt;3151. 特殊数组 I&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个 &lt;strong&gt;特殊数组&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;Aging 有一个整数数组 &lt;code&gt;nums&lt;/code&gt;。如果 &lt;code&gt;nums&lt;/code&gt; 是一个 &lt;strong&gt;特殊数组&lt;/strong&gt; ，返回 &lt;code&gt;true&lt;/code&gt;，否则返回 &lt;code&gt;false&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;只有两对相邻元素&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;它们都包含了奇偶性不同的数字&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;因此答案为&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isArraySpecial&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;一开始想到的方案是：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;如果nums[0] 为偶数时，只要遍历偶数索引，其值如果出现奇数，则返回false&lt;/li&gt;
&lt;li&gt;如果nums[0] 为奇数时，只要遍历偶数索引，其值如果出现偶数，则返回false&lt;/li&gt;
&lt;li&gt;否则，返回true&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;但是，出现相邻为奇数或偶数时，是不满足条件的，因为两个条件分开判断的，所以，还是把问题想复杂化了，其实处理起来很简单，只需要判断相邻的两个数，只要出现一次奇偶性相同，则为false，否则为true。&lt;/p&gt;
&lt;p&gt;但这里，也引申出了一个问题，检查数组边界和和不检查数组边界，哪个效率更高一点？&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;// 检查数组边界
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;   &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;// 不检查数组边界
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;   &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;一般来说，前者因为有一个比较的操作，所以，会影响到实际代码执行效率，但是，避免了潜在的数组越界错误；后者，没有这个比较操作，但是会有潜在数据越界错误。从健壮性和避免潜在错误的角度考虑，第一个方式是更推荐的写法。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2406/240603-rising-sea-levels.html&#34;&gt;Panama evacuates islanders due to rising sea levels - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;上升的海平面导致巴拿马撤离了其中一个岛屿的居民。位于巴拿马加勒比海岸的小岛加尔迪·苏格杜布的居民正在被重新安置到内陆。然而，一名巴拿马政府官员表示，一些人拒绝撤离他们的祖居。他们将一直留到最后一刻。巴拿马政府表示，加尔迪·苏格杜布是即将发生的事情的一个迹象，因为更多的低洼岛屿正面临被海水吞没的威胁。巴拿马环境部门最近的一项研究估计，该国将失去2.01%的沿海领土。该研究还指出，将有大约38,000人需要搬迁，成本约为12亿美元。&lt;/p&gt;
&lt;p&gt;加尔迪·苏格杜布一直是世代居住的古纳族人的家园。这个拥挤的岛屿只有366米长和137米宽，却曾经是将近300个家庭的家园。他们依靠捕鱼和旅游业谋生。24岁的岛民纳丁·莫拉莱斯说：“我们有点难过……但海水一点一点地淹没了这个岛屿。”她补充道：“最近，我发现气候变化产生了重大影响……潮汐的水位比以前更高，而且酷热难当。”莫拉莱斯女士表示，她希望她的社区在新的地点能够繁荣。她的新家将位于距离船只前往加尔迪·苏格杜布的港口两公里处，这是一项价值1200万美元的政府开发项目。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;git 切换分支&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/special-array-i/">3151. 特殊数组 I</a></p>
<p>如果数组的每一对相邻元素都是两个奇偶性不同的数字，则该数组被认为是一个 <strong>特殊数组</strong> 。</p>
<p>Aging 有一个整数数组 <code>nums</code>。如果 <code>nums</code> 是一个 <strong>特殊数组</strong> ，返回 <code>true</code>，否则返回 <code>false</code>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">只有两对相邻元素</span><span class="err">：</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span> <span class="nx">和</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">)</span><span class="err">，</span><span class="nx">它们都包含了奇偶性不同的数字</span><span class="err">，</span><span class="nx">因此答案为</span> <span class="kc">true</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">isArraySpecial</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">!==</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">&amp;&amp;</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">===</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>一开始想到的方案是：</p>
<ol>
<li>如果nums[0] 为偶数时，只要遍历偶数索引，其值如果出现奇数，则返回false</li>
<li>如果nums[0] 为奇数时，只要遍历偶数索引，其值如果出现偶数，则返回false</li>
<li>否则，返回true</li>
</ol>
<p>但是，出现相邻为奇数或偶数时，是不满足条件的，因为两个条件分开判断的，所以，还是把问题想复杂化了，其实处理起来很简单，只需要判断相邻的两个数，只要出现一次奇偶性相同，则为false，否则为true。</p>
<p>但这里，也引申出了一个问题，检查数组边界和和不检查数组边界，哪个效率更高一点？</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="c1">// 检查数组边界
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">!==</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">&amp;&amp;</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">===</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="c1">// 不检查数组边界
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">===</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">%</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">   <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>一般来说，前者因为有一个比较的操作，所以，会影响到实际代码执行效率，但是，避免了潜在的数组越界错误；后者，没有这个比较操作，但是会有潜在数据越界错误。从健壮性和避免潜在错误的角度考虑，第一个方式是更推荐的写法。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2406/240603-rising-sea-levels.html">Panama evacuates islanders due to rising sea levels - Breaking News English Lesson</a></p>
<p>上升的海平面导致巴拿马撤离了其中一个岛屿的居民。位于巴拿马加勒比海岸的小岛加尔迪·苏格杜布的居民正在被重新安置到内陆。然而，一名巴拿马政府官员表示，一些人拒绝撤离他们的祖居。他们将一直留到最后一刻。巴拿马政府表示，加尔迪·苏格杜布是即将发生的事情的一个迹象，因为更多的低洼岛屿正面临被海水吞没的威胁。巴拿马环境部门最近的一项研究估计，该国将失去2.01%的沿海领土。该研究还指出，将有大约38,000人需要搬迁，成本约为12亿美元。</p>
<p>加尔迪·苏格杜布一直是世代居住的古纳族人的家园。这个拥挤的岛屿只有366米长和137米宽，却曾经是将近300个家庭的家园。他们依靠捕鱼和旅游业谋生。24岁的岛民纳丁·莫拉莱斯说：“我们有点难过……但海水一点一点地淹没了这个岛屿。”她补充道：“最近，我发现气候变化产生了重大影响……潮汐的水位比以前更高，而且酷热难当。”莫拉莱斯女士表示，她希望她的社区在新的地点能够繁荣。她的新家将位于距离船只前往加尔迪·苏格杜布的港口两公里处，这是一项价值1200万美元的政府开发项目。</p>
<h2 id="tip">Tip</h2>
<p>git 切换分支</p>
<ol>
<li>git branch  查看当前分支</li>
<li>git branch -r 查看远程仓库的分支列表</li>
<li>git checkout <branch-name> 切换到已存在的分支</li>
<li>git checkout -b <new-branch-name> 创建并切换到新分支</li>
</ol>
<p>在切换分支前，确保你的工作目录是干净的（没有未提交的更改）。如果有未提交的更改，可以使用<code>git stash</code>命令将其暂存起来，然后再切换分支。</p>
<h2 id="share">Share</h2>
<p>布利斯定理：用较多的时间为一次工作事前计划，做这项工作所用的总时间就会减少。</p>
<ol>
<li>启示1：事前先思考，事后少烦恼。</li>
<li>启示2：事先做计划，成功概率大。</li>
<li>启示3：拆分大目标，再各个击破。</li>
</ol>
<p>凡事预则立，不立则废，好计划是成功的开始。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 32</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-32/</link>
      <pubDate>Sat, 15 Jun 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-32/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/number-of-good-pairs/&#34;&gt;1512. 好数对的数目&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;nums&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;如果一组数字 &lt;code&gt;(i,j)&lt;/code&gt; 满足 &lt;code&gt;nums[i]&lt;/code&gt; == &lt;code&gt;nums[j]&lt;/code&gt; 且 &lt;code&gt;i&lt;/code&gt; &amp;lt; &lt;code&gt;j&lt;/code&gt; ，就可以认为这是一组 &lt;strong&gt;好数对&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;返回好数对的数目。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;有&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;组好数对&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;分别是&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;下标从&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;开始&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;numIdenticalPairs&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;题目相对简单，使用for遍历两次，加上条件判断，累计出现好书对次数即可。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2405/240530-national-service.html&#34;&gt;UK leader wants national service for 18-year-olds  - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;英国首相里希·苏纳克计划为18岁年轻人引入国民服役制度，如果他所在的党派在7月4日的英国大选中获胜，他将推行强制国民服役。根据他的计划，年轻人满18岁时将有两个选择：一是花一年时间在陆军、海军或空军服役，政府预计约有3万人会选择这一选项；二是每月一个周末从事志愿工作，比如为英国的国民卫生服务体系、急救服务、消防服务或地方社区提供服务。苏纳克表示，这将帮助年轻人获得宝贵技能，并有助于“建设更强大的国家文化”。&lt;/p&gt;
&lt;p&gt;然而，苏纳克的计划遭到了许多人的批评。各种专家表示，该计划成本过高，且英国没有足够的人员来培训3万名军队志愿者。许多国防专家认为这一想法不切实际。前海军司令艾伦·韦斯特表示，虽然他对更多年轻人意识到国防的重要性感到高兴，但这一想法是“荒谬的”。他认为政府需要增加国防开支，而国民服役制度将“榨取”国防资金。许多年轻人也不同意这一计划，认为它剥夺了他们的自由。然而，一名17岁的年轻人表示，这将给许多年轻人带来目标，并指出国民服役制度在数十个国家都运作良好。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;升级 package.json 中全部依赖包到最新版本&lt;/p&gt;
&lt;p&gt;在 Vue 项目 package.json 中，要将全部依赖包升级至最新版本，可以使用工具 &lt;a href=&#34;https://github.com/raineorshine/npm-check-updates&#34;&gt;npm-check-updates &lt;/a&gt;实现，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202406111552312.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;全局安装&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;npm&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;install&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;g&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;npm&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;check&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;updates&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;或者，npx安装&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;npx&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;npm&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;check&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;updates&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;检查并显示最新版本&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;ncu&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;u&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;重新安装&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/number-of-good-pairs/">1512. 好数对的数目</a></p>
<p>给你一个整数数组 <code>nums</code> 。</p>
<p>如果一组数字 <code>(i,j)</code> 满足 <code>nums[i]</code> == <code>nums[j]</code> 且 <code>i</code> &lt; <code>j</code> ，就可以认为这是一组 <strong>好数对</strong> 。</p>
<p>返回好数对的数目。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">有</span> <span class="mi">4</span> <span class="nx">组好数对</span><span class="err">，</span><span class="nx">分别是</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">)</span> <span class="err">，</span><span class="nx">下标从</span> <span class="mi">0</span> <span class="nx">开始</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">numIdenticalPairs</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">==</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">&amp;&amp;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">j</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">count</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>题目相对简单，使用for遍历两次，加上条件判断，累计出现好书对次数即可。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2405/240530-national-service.html">UK leader wants national service for 18-year-olds  - Breaking News English Lesson</a></p>
<p>英国首相里希·苏纳克计划为18岁年轻人引入国民服役制度，如果他所在的党派在7月4日的英国大选中获胜，他将推行强制国民服役。根据他的计划，年轻人满18岁时将有两个选择：一是花一年时间在陆军、海军或空军服役，政府预计约有3万人会选择这一选项；二是每月一个周末从事志愿工作，比如为英国的国民卫生服务体系、急救服务、消防服务或地方社区提供服务。苏纳克表示，这将帮助年轻人获得宝贵技能，并有助于“建设更强大的国家文化”。</p>
<p>然而，苏纳克的计划遭到了许多人的批评。各种专家表示，该计划成本过高，且英国没有足够的人员来培训3万名军队志愿者。许多国防专家认为这一想法不切实际。前海军司令艾伦·韦斯特表示，虽然他对更多年轻人意识到国防的重要性感到高兴，但这一想法是“荒谬的”。他认为政府需要增加国防开支，而国民服役制度将“榨取”国防资金。许多年轻人也不同意这一计划，认为它剥夺了他们的自由。然而，一名17岁的年轻人表示，这将给许多年轻人带来目标，并指出国民服役制度在数十个国家都运作良好。</p>
<h2 id="tip">Tip</h2>
<p>升级 package.json 中全部依赖包到最新版本</p>
<p>在 Vue 项目 package.json 中，要将全部依赖包升级至最新版本，可以使用工具 <a href="https://github.com/raineorshine/npm-check-updates">npm-check-updates </a>实现，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202406111552312.png"></p>
<p>全局安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npm</span> <span class="nx">install</span> <span class="o">-</span><span class="nx">g</span> <span class="nx">npm</span><span class="o">-</span><span class="nx">check</span><span class="o">-</span><span class="nx">updates</span>
</span></span></code></pre></div><p>或者，npx安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npx</span> <span class="nx">npm</span><span class="o">-</span><span class="nx">check</span><span class="o">-</span><span class="nx">updates</span>
</span></span></code></pre></div><p>检查并显示最新版本</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">ncu</span> <span class="o">-</span><span class="nx">u</span>
</span></span></code></pre></div><p>重新安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npm</span> <span class="nx">install</span>
</span></span></code></pre></div><p>至此，完成。</p>
<h2 id="share">Share</h2>
<p>第一次知道技术胖，是在2018年，当时看他的博客学了一下Weex，然后是Flutter，后来没怎么关注了，没想到现在退休回老家当保安了，财富自由就是可以任性，不过，生活才是最重要的。最近，看了他新发布的这篇文章。</p>
<p><a href="https://juejin.cn/post/7314916944934518784">给年轻程序员的三点启示 | 程序软技能-01 - 掘金 (juejin.cn)</a></p>
<p>“我从06年开始进入编程领域，做过Java、Python、PHP，前端，现在已经回到自己的家乡，和母亲生活再一起，过着梦寐以求的田园生活。在编程领域摸爬滚打了16年，通过这个文章，我希望能给小伙伴一些启发。现在我已经退出职场，也不准备作培训和卖课，所以分享文章的目的很简单，就是想我在程序领域走过的弯路和踩过的坑，小伙伴不要再走一遍或者再踩坑了。”</p>
<p>“启示一：尽早作自己喜欢的事。”</p>
<p>“启示二：抛开代码与人沟通。”</p>
<p>“启示三：慢慢建立个人权威。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>关于陈皓，我的一些感受</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E5%85%B3%E4%BA%8E%E9%99%88%E7%9A%93%E6%88%91%E7%9A%84%E4%B8%80%E4%BA%9B%E6%84%9F%E5%8F%97/</link>
      <pubDate>Thu, 23 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E5%85%B3%E4%BA%8E%E9%99%88%E7%9A%93%E6%88%91%E7%9A%84%E4%B8%80%E4%BA%9B%E6%84%9F%E5%8F%97/</guid>
      <description>&lt;p&gt;去年差不多这个时候，听闻陈皓突然逝世，很是震惊。&lt;/p&gt;
&lt;p&gt;第一次知道陈皓这个名字，是在极客时间上面，因为购买了《左耳听风》课程，所以知道这个人。这个课程基本涵盖了陈皓个人网站上面的精华博文，因为很多涉及后端方面的内容，所以我并没有全部看完，只是看了技术基础、程序员练级攻略、程序员面试攻略、高效学习、高效沟通这几块内容，可以说干货满满，很受启发。并且，每次重温，都会有不同的体会。&lt;/p&gt;
&lt;p&gt;当时购买课程之后，可以加群的，即陈皓发起的ARTS活动，自己也申请入群，不知道为什么，没有入群成功，也就没太在意。想要打卡这个活动，又觉得有点难，很怕自己坚持不下来，所以就不了了之了。&lt;/p&gt;
&lt;p&gt;后来，听说他要和我所在的部门合作一些项目，觉得很巧，很有意思。&lt;/p&gt;
&lt;p&gt;只是去年他过来开会，沟通项目的业务，当时他就在一楼，本来想着去见一面，能请教一下问题，但是因为是后端相关的会议，加上觉得这样不太合适，所以就没下去。&lt;/p&gt;
&lt;p&gt;没想到过了两个多月他就因为心梗突然过世了，真是人生无常。当时看到百度热搜里那条过世的消息，心里蛮不是滋味的。&lt;/p&gt;
&lt;p&gt;陈皓自己个人网站，酷壳上面好几篇博文都很不错，也是上面课程的内容：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://coolshell.cn/articles/19085.html&#34;&gt;《谈谈我的“三观”》&lt;/a&gt; - 第一步要努力实现自我价值，第二步要全力照顾好家人，第三步要尽可能帮助善良的人，第四步为族群发声，第五步为国家争荣誉。事实上作为男人，前两步成功，人生已算得上圆满，做到第三步堪称伟大，而随意颠倒次序的那些人，一般不值得信任。修身齐家治国平天下。穷则独善其身，达则兼济天下。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://coolshell.cn/articles/4990.html&#34;&gt;《程序员技术练级攻略》&lt;/a&gt; - 有时候我们需要更多的是抬起头来看看技术以外的事情，或者是说我们在作技术的时候不去思考为什么会有这个技术，为什么不是别的，问题不在于技术，问题在于我们死读书，读死书，成了技术的书呆子。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://coolshell.cn/articles/19464.html&#34;&gt;《如何超过大多数人》&lt;/a&gt; - 要超过别人其实还是比较简单的，尤其在今天的中国，更是简单。因为，你只看看中国的互联网，你就会发现，他们基本上全部都是在消费大众，让大众变得更为地愚蠢和傻瓜。所以，在今天的中国，你基本上不用做什么，只需要不使用中国互联网，你就很自然地超过大多数人了。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://coolshell.cn/articles/17583.html&#34;&gt;《技术人员的发展之路》&lt;/a&gt; - 能够去规划自己的个人发展的人，通常都是有很多机会和可能性的人；有很多机会和可能性的人，通常都是有Leadership，喜欢冒险的人；有Leadership喜欢冒险的人，通常都是学习能力强，思维活跃，喜欢折腾，懂得“投资”的人；学习能力强思维活跃的人，通常来说，都是喜欢看书，喜欢实践和新鲜事物，不怕艰难和挑战，用智力而不是使蛮力的人；懂得“投资”的人，通常来说，他们更多的关注的是未来和长远的成长，而不是当下的KPI、奖金和晋升。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;a href=&#34;https://coolshell.cn/articles/20977.html&#34;&gt;《程序员如何把控自己的职业》&lt;/a&gt;- 如果你想更好的把握时代，提升自己，你需要知道这个时代的趋势是什么，需要什么样的人，这些人需要什么样的能力，这些能力是怎么获得的，投入到基础知识的学习就像“基建”一样，如果基础不好，不能长高，学习能力也是需要适应这个快速时代的重要的基础能力，没有好的学习能力，很快就会掉队被淘汰。&lt;/p&gt;
&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;从去年10月份开始，我突然萌生要打卡这个ARTS活动的想法，起初只是觉得我应该做这个事情，因为上班能敲代码的时间基本都没有了，只能下班回来找一点事情做，不让自己脱离代码太久了。我也并没有打算，能从ARTS打卡活动中，一定有所收获，但正是这种很坦然的心态，反而促使我坚持到了现在，而且在这过程之中，我从未有任何心理压力。&lt;/p&gt;
&lt;p&gt;说句题外话，陈皓老师真的看起来有点虚胖，健康状态真的不是很好。所以我们还是要多注意身体，不要熬夜，坚持运动，饮食有度，毕竟身体是革命的本钱，是好几个0前面的1，没有1，后面再多的0都是徒然。我也是一样，每天要去健身房，然后，不要熬夜了。但一直以来都太忙了，其他都能坚持下来，就是熬夜总是戒不掉，争取再努力，调整回来吧。最后以陈皓老师的座右铭结尾吧，与诸君共勉：&lt;/p&gt;
&lt;p&gt;“芝兰生于深谷，不以无人而不芳，君子修身养德，不以穷困而改志。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p>去年差不多这个时候，听闻陈皓突然逝世，很是震惊。</p>
<p>第一次知道陈皓这个名字，是在极客时间上面，因为购买了《左耳听风》课程，所以知道这个人。这个课程基本涵盖了陈皓个人网站上面的精华博文，因为很多涉及后端方面的内容，所以我并没有全部看完，只是看了技术基础、程序员练级攻略、程序员面试攻略、高效学习、高效沟通这几块内容，可以说干货满满，很受启发。并且，每次重温，都会有不同的体会。</p>
<p>当时购买课程之后，可以加群的，即陈皓发起的ARTS活动，自己也申请入群，不知道为什么，没有入群成功，也就没太在意。想要打卡这个活动，又觉得有点难，很怕自己坚持不下来，所以就不了了之了。</p>
<p>后来，听说他要和我所在的部门合作一些项目，觉得很巧，很有意思。</p>
<p>只是去年他过来开会，沟通项目的业务，当时他就在一楼，本来想着去见一面，能请教一下问题，但是因为是后端相关的会议，加上觉得这样不太合适，所以就没下去。</p>
<p>没想到过了两个多月他就因为心梗突然过世了，真是人生无常。当时看到百度热搜里那条过世的消息，心里蛮不是滋味的。</p>
<p>陈皓自己个人网站，酷壳上面好几篇博文都很不错，也是上面课程的内容：</p>
<ol>
<li>
<p><a href="https://coolshell.cn/articles/19085.html">《谈谈我的“三观”》</a> - 第一步要努力实现自我价值，第二步要全力照顾好家人，第三步要尽可能帮助善良的人，第四步为族群发声，第五步为国家争荣誉。事实上作为男人，前两步成功，人生已算得上圆满，做到第三步堪称伟大，而随意颠倒次序的那些人，一般不值得信任。修身齐家治国平天下。穷则独善其身，达则兼济天下。</p>
</li>
<li>
<p><a href="https://coolshell.cn/articles/4990.html">《程序员技术练级攻略》</a> - 有时候我们需要更多的是抬起头来看看技术以外的事情，或者是说我们在作技术的时候不去思考为什么会有这个技术，为什么不是别的，问题不在于技术，问题在于我们死读书，读死书，成了技术的书呆子。</p>
</li>
<li>
<p><a href="https://coolshell.cn/articles/19464.html">《如何超过大多数人》</a> - 要超过别人其实还是比较简单的，尤其在今天的中国，更是简单。因为，你只看看中国的互联网，你就会发现，他们基本上全部都是在消费大众，让大众变得更为地愚蠢和傻瓜。所以，在今天的中国，你基本上不用做什么，只需要不使用中国互联网，你就很自然地超过大多数人了。</p>
</li>
<li>
<p><a href="https://coolshell.cn/articles/17583.html">《技术人员的发展之路》</a> - 能够去规划自己的个人发展的人，通常都是有很多机会和可能性的人；有很多机会和可能性的人，通常都是有Leadership，喜欢冒险的人；有Leadership喜欢冒险的人，通常都是学习能力强，思维活跃，喜欢折腾，懂得“投资”的人；学习能力强思维活跃的人，通常来说，都是喜欢看书，喜欢实践和新鲜事物，不怕艰难和挑战，用智力而不是使蛮力的人；懂得“投资”的人，通常来说，他们更多的关注的是未来和长远的成长，而不是当下的KPI、奖金和晋升。</p>
</li>
<li>
<p><a href="https://coolshell.cn/articles/20977.html">《程序员如何把控自己的职业》</a>- 如果你想更好的把握时代，提升自己，你需要知道这个时代的趋势是什么，需要什么样的人，这些人需要什么样的能力，这些能力是怎么获得的，投入到基础知识的学习就像“基建”一样，如果基础不好，不能长高，学习能力也是需要适应这个快速时代的重要的基础能力，没有好的学习能力，很快就会掉队被淘汰。</p>
</li>
</ol>
<p>从去年10月份开始，我突然萌生要打卡这个ARTS活动的想法，起初只是觉得我应该做这个事情，因为上班能敲代码的时间基本都没有了，只能下班回来找一点事情做，不让自己脱离代码太久了。我也并没有打算，能从ARTS打卡活动中，一定有所收获，但正是这种很坦然的心态，反而促使我坚持到了现在，而且在这过程之中，我从未有任何心理压力。</p>
<p>说句题外话，陈皓老师真的看起来有点虚胖，健康状态真的不是很好。所以我们还是要多注意身体，不要熬夜，坚持运动，饮食有度，毕竟身体是革命的本钱，是好几个0前面的1，没有1，后面再多的0都是徒然。我也是一样，每天要去健身房，然后，不要熬夜了。但一直以来都太忙了，其他都能坚持下来，就是熬夜总是戒不掉，争取再努力，调整回来吧。最后以陈皓老师的座右铭结尾吧，与诸君共勉：</p>
<p>“芝兰生于深谷，不以无人而不芳，君子修身养德，不以穷困而改志。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 52</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-52/</link>
      <pubDate>Wed, 22 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-52/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/number-of-different-integers-in-a-string/&#34;&gt;1805. 字符串中不同整数的数目&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;word&lt;/code&gt; ，该字符串由数字和小写英文字母组成。&lt;/p&gt;
&lt;p&gt;请你用空格替换每个不是数字的字符。例如，&lt;code&gt;&amp;quot;a123bc34d8ef34&amp;quot;&lt;/code&gt; 将会变成 &lt;code&gt;&amp;quot; 123 34 8 34&amp;quot;&lt;/code&gt; 。注意，剩下的这些整数为（相邻彼此至少有一个空格隔开）：&lt;code&gt;&amp;quot;123&amp;quot;&lt;/code&gt;、&lt;code&gt;&amp;quot;34&amp;quot;&lt;/code&gt;、&lt;code&gt;&amp;quot;8&amp;quot;&lt;/code&gt; 和 &lt;code&gt;&amp;quot;34&amp;quot;&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;返回对 &lt;code&gt;word&lt;/code&gt; 完成替换后形成的 &lt;strong&gt;不同&lt;/strong&gt; 整数的数目。&lt;/p&gt;
&lt;p&gt;只有当两个整数的 &lt;strong&gt;不含前导零&lt;/strong&gt; 的十进制表示不同， 才认为这两个整数也不同。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;word&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;a123bc34d8ef34&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;不同的整数有&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;123&amp;#34;&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;、&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;34&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;8&amp;#34;&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;注意&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;34&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;只计数一次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;numDifferentIntegers&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;word&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 1. 匹配所有的数字，返回一个数组，每个元素是一个数字字符串
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;word&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;match&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;sr&#34;&gt;/\d+/g&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 2. 如果没有匹配到数字，返回0
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 3. 去掉前导0，返回一个新的数组，每个元素是一个数字字符串
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;replace&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;sr&#34;&gt;/^0+/&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 4. 用Set去重
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;set&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Set&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;// 去重
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;c1&#34;&gt;// 5. 返回Set的大小
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;set&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;size&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;匹配所有的数字，返回一个数组，每个元素是一个数字字符串。&lt;/li&gt;
&lt;li&gt;如果没有匹配到数字，返回0。&lt;/li&gt;
&lt;li&gt;去掉前导0，返回一个新的数组，每个元素是一个数字字符串。&lt;/li&gt;
&lt;li&gt;用Set去重。&lt;/li&gt;
&lt;li&gt;使用 set.size 返回大小，即为所求的值。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2505/250519-ginger-cats.html&#34;&gt;Scientists find why most ginger cats are male - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/number-of-different-integers-in-a-string/">1805. 字符串中不同整数的数目</a></p>
<p>给你一个字符串 <code>word</code> ，该字符串由数字和小写英文字母组成。</p>
<p>请你用空格替换每个不是数字的字符。例如，<code>&quot;a123bc34d8ef34&quot;</code> 将会变成 <code>&quot; 123 34 8 34&quot;</code> 。注意，剩下的这些整数为（相邻彼此至少有一个空格隔开）：<code>&quot;123&quot;</code>、<code>&quot;34&quot;</code>、<code>&quot;8&quot;</code> 和 <code>&quot;34&quot;</code> 。</p>
<p>返回对 <code>word</code> 完成替换后形成的 <strong>不同</strong> 整数的数目。</p>
<p>只有当两个整数的 <strong>不含前导零</strong> 的十进制表示不同， 才认为这两个整数也不同。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">word</span> <span class="o">=</span> <span class="s2">&#34;a123bc34d8ef34&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">不同的整数有</span> <span class="s2">&#34;123&#34;</span><span class="err">、</span><span class="s2">&#34;34&#34;</span> <span class="nx">和</span> <span class="s2">&#34;8&#34;</span> <span class="err">。</span><span class="nx">注意</span><span class="err">，</span><span class="s2">&#34;34&#34;</span> <span class="nx">只计数一次</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">numDifferentIntegers</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">word</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 1. 匹配所有的数字，返回一个数组，每个元素是一个数字字符串
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">nums</span> <span class="o">=</span> <span class="nx">word</span><span class="p">.</span><span class="nx">match</span><span class="p">(</span><span class="sr">/\d+/g</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 2. 如果没有匹配到数字，返回0
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span> <span class="o">===</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 3. 去掉前导0，返回一个新的数组，每个元素是一个数字字符串
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">nums</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">n</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">=</span> <span class="nx">n</span><span class="p">.</span><span class="nx">replace</span><span class="p">(</span><span class="sr">/^0+/</span><span class="p">,</span> <span class="s1">&#39;&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 4. 用Set去重
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">set</span> <span class="o">=</span> <span class="k">new</span> <span class="nx">Set</span><span class="p">(</span><span class="nx">nums</span><span class="p">);</span> <span class="c1">// 去重
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="c1">// 5. 返回Set的大小
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">return</span> <span class="nx">set</span><span class="p">.</span><span class="nx">size</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>匹配所有的数字，返回一个数组，每个元素是一个数字字符串。</li>
<li>如果没有匹配到数字，返回0。</li>
<li>去掉前导0，返回一个新的数组，每个元素是一个数字字符串。</li>
<li>用Set去重。</li>
<li>使用 set.size 返回大小，即为所求的值。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2505/250519-ginger-cats.html">Scientists find why most ginger cats are male - Breaking News English Lesson</a></p>
<p>科学家们揭开了一个关于猫科动物的长期谜团。日本九州大学的遗传学家发现，为什么十只橘猫中有八只是雄性。佐佐木博之博士发现，X 染色体上的一个突变导致了一种此前未知的“橘色基因”。佐佐木博士说：“找到这个基因一直是我的梦想，所以终于破解了这个谜团，我感到非常高兴。”这种基因负责动物皮肤的色素沉着。雄性哺乳动物有一条 X 染色体和一条 Y 染色体。如果雄性猫的 X 染色体上有这种基因，它就会是橘色的。由于雌性猫有两条 X 染色体，所以两条染色体上都需要有这种基因，猫才会是橘色的。这种情况发生的可能性较小。</p>
<p>佐佐木博士及其同事的研究成果已发表在《当代生物学》杂志上。在这项研究中，研究人员分析了 18 只猫的 DNA。其中 10 只猫的毛色为橘色。研究人员发现，所有橘色猫都有一种名为 ARHGAP36 的基因突变，而非橘色猫则没有这种突变。佐佐木博士表示，猫主人通常会将毛色与性格特征联系起来。他写道：“许多猫主人坚信不同毛色和花纹与不同性格有关。目前尚无科学证据支持这一观点，但这确实是个有趣的想法，我很想进一步探究。”他还表示，橘色猫可能具有某些共同的行为特征，因为它们大多是雄性。</p>
<h2 id="tip">Tip</h2>
<p>腾讯 ARC 图片修复工具，挺好用的。https://arc.tencent.com/zh/ai-demos/faceRestoration</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505222237754.png"></p>
<h2 id="share">Share</h2>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202505220644480.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 31</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-31/</link>
      <pubDate>Mon, 20 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-31/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/thousand-separator/&#34;&gt;1556. 千位分隔数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数 &lt;code&gt;n&lt;/code&gt;，请你每隔三位添加点（即 &amp;ldquo;.&amp;rdquo; 符号）作为千位分隔符，并将结果以字符串格式返回。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;123456789&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;123.456.789&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;thousandSeparator&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;String&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;.&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;因为是千位分隔数，所以使用倒序遍历，然后通过找规律，如下所示：&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;//index      0 123
const str = &amp;#34;1.234&amp;#34;
//index      012 345 678
const str = &amp;#34;123.456.789&amp;#34;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;从以上可知，str.length - i 的值得出为3、3和6，都是3的倍数，所以可以使用&lt;code&gt;(str.length - i) % 3 == 0&lt;/code&gt;来找到要插入&lt;code&gt;.&lt;/code&gt;的位置，加上当最后一位和第一位时不需要加上&lt;code&gt;.&lt;/code&gt;，然后通过result依次拼接字符串，得到所求结果值。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;题外话：最近总算把ARTS之前落下的进度赶上来了。好几次看着前面要补4篇左右，心里还是有点虚啊，但是从来没有要放弃，就觉得慢慢补回来就好了，不需要做任何心理建设，然后就补回来了。还是按正常节奏，每周完成一篇比较好。&lt;/p&gt;&lt;/blockquote&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240418-seafood-forever-chemicals.html&#34;&gt;Seafood could have higher levels of &amp;lsquo;forever chemicals&amp;rsquo; - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;一项新研究指出，海鲜中可能存在更高水平的“永久化学物质”。永久化学物质是人造毒素，不会分解。它们可以停留在人体血液中，导致各种健康问题，包括癌症、肾脏和肝脏问题、激素变化以及对胎儿发育的损害。来自美国达特茅斯学院的研究人员表示，应该为海鲜中的永久化学物质制定安全指南。他们说，这些毒素的水平在虾、明虾和龙虾等海洋生物中最高。这可能意味着喜欢寿司、生鱼片和虾仁鸡尾酒的人可能需要重新考虑他们的饮食习惯，减少一些海鲜的摄入量。&lt;/p&gt;
&lt;p&gt;永久化学物质在20世纪30年代被开发出来。从20世纪50年代以来，它们被用于制造许多产品。它们通常存在于食品包装中。我们大部分的食品包装纸、外卖盒、比萨盒和其他食品容器都含有这些化学物质。几十年来，这些化学物质已经进入了我们的食物链。研究人员表示，海鲜中的永久化学物质水平较高。梅根·罗曼诺教授表示，她希望人们继续享用海鲜，但要意识到风险。她说：“我们的建议不是不吃海鲜。海鲜是蛋白质和欧米茄脂肪酸的重要来源。”她补充说，让人们更多地了解我们所吃食物的成分是很重要的。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;git pull放弃本地修改，强制更新。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/thousand-separator/">1556. 千位分隔数</a></p>
<p>给你一个整数 <code>n</code>，请你每隔三位添加点（即 &ldquo;.&rdquo; 符号）作为千位分隔符，并将结果以字符串格式返回。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">n</span> <span class="o">=</span> <span class="mi">123456789</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="s2">&#34;123.456.789&#34;</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">thousandSeparator</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">str</span> <span class="o">=</span> <span class="nb">String</span><span class="p">(</span><span class="nx">n</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">s</span> <span class="o">=</span> <span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">((</span><span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">i</span><span class="p">)</span> <span class="o">%</span> <span class="mi">3</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="nx">i</span> <span class="o">!==</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">&amp;&amp;</span> <span class="nx">i</span> <span class="o">!==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">s</span> <span class="o">=</span> <span class="s1">&#39;.&#39;</span> <span class="o">+</span> <span class="nx">s</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="nx">result</span> <span class="o">=</span> <span class="nx">s</span> <span class="o">+</span> <span class="nx">result</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>因为是千位分隔数，所以使用倒序遍历，然后通过找规律，如下所示：</p>
<pre tabindex="0"><code>//index      0 123
const str = &#34;1.234&#34;
//index      012 345 678
const str = &#34;123.456.789&#34;
</code></pre><p>从以上可知，str.length - i 的值得出为3、3和6，都是3的倍数，所以可以使用<code>(str.length - i) % 3 == 0</code>来找到要插入<code>.</code>的位置，加上当最后一位和第一位时不需要加上<code>.</code>，然后通过result依次拼接字符串，得到所求结果值。</p>
<blockquote>
<p>题外话：最近总算把ARTS之前落下的进度赶上来了。好几次看着前面要补4篇左右，心里还是有点虚啊，但是从来没有要放弃，就觉得慢慢补回来就好了，不需要做任何心理建设，然后就补回来了。还是按正常节奏，每周完成一篇比较好。</p></blockquote>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240418-seafood-forever-chemicals.html">Seafood could have higher levels of &lsquo;forever chemicals&rsquo; - Breaking News English Lesson</a></p>
<p>一项新研究指出，海鲜中可能存在更高水平的“永久化学物质”。永久化学物质是人造毒素，不会分解。它们可以停留在人体血液中，导致各种健康问题，包括癌症、肾脏和肝脏问题、激素变化以及对胎儿发育的损害。来自美国达特茅斯学院的研究人员表示，应该为海鲜中的永久化学物质制定安全指南。他们说，这些毒素的水平在虾、明虾和龙虾等海洋生物中最高。这可能意味着喜欢寿司、生鱼片和虾仁鸡尾酒的人可能需要重新考虑他们的饮食习惯，减少一些海鲜的摄入量。</p>
<p>永久化学物质在20世纪30年代被开发出来。从20世纪50年代以来，它们被用于制造许多产品。它们通常存在于食品包装中。我们大部分的食品包装纸、外卖盒、比萨盒和其他食品容器都含有这些化学物质。几十年来，这些化学物质已经进入了我们的食物链。研究人员表示，海鲜中的永久化学物质水平较高。梅根·罗曼诺教授表示，她希望人们继续享用海鲜，但要意识到风险。她说：“我们的建议不是不吃海鲜。海鲜是蛋白质和欧米茄脂肪酸的重要来源。”她补充说，让人们更多地了解我们所吃食物的成分是很重要的。</p>
<h2 id="tip">Tip</h2>
<p>git pull放弃本地修改，强制更新。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git fetch --all
</span></span><span class="line"><span class="cl">git reset --hard origin/master
</span></span><span class="line"><span class="cl">git clean -f -d
</span></span></code></pre></div><ol>
<li><code>git fetch --all</code>：从远程仓库获取最新的内容。</li>
<li><code>git reset --hard origin/master</code>：将本地仓库的内容重置为与远程仓库相同，包括放弃任何本地修改。</li>
<li><code>git clean -f -d</code>：清除工作目录中未跟踪的文件和目录。</li>
</ol>
<h2 id="share">Share</h2>
<p>《À la folie》是一首法语歌曲，它还有一个日语版本，也非常好听。但我最喜欢的是MV版本，可能是因为多了一些铃铃铃的音效的缘故，超级好听，百听不厌。对我来说，一首歌曲的调调才是它的灵魂，其他都不是那么重要。</p>
<blockquote>
<p><a href="https://c6.y.qq.com/base/fcgi-bin/u?__=a0JQTl32bQN8">https://c6.y.qq.com/base/fcgi-bin/u?__=a0JQTl32bQN8</a></p></blockquote>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405202244764.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 30</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-30/</link>
      <pubDate>Sun, 19 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-30/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/largest-number-at-least-twice-of-others/&#34;&gt;747. 至少是其他数字两倍的最大数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;nums&lt;/code&gt; ，其中总是存在 &lt;strong&gt;唯一的&lt;/strong&gt; 一个最大整数 。&lt;/p&gt;
&lt;p&gt;请你找出数组中的最大元素并检查它是否 &lt;strong&gt;至少是数组中每个其他数字的两倍&lt;/strong&gt; 。如果是，则返回 &lt;strong&gt;最大元素的下标&lt;/strong&gt; ，否则返回 &lt;code&gt;-1&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;是最大的整数&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;对于数组中的其他整数&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;至少是数组中其他元素的两倍&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的下标是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以返回&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dominantIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;toSorted&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;先将数字从小到大排序，生成新数组；&lt;/li&gt;
&lt;li&gt;然后获取最后一位，如果大于等于倒数第二位的数值乘以2，则表示存在满足条件的最大整数，否则返回-1；&lt;/li&gt;
&lt;li&gt;通过indexOf在原nums数组中获取最大整数下标。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240415-auto-insurance.html&#34;&gt;Rising auto insurance premiums fuelling inflation - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;汽车保险费的飙升正在加剧美国的通货膨胀压力，成本以最快的速度上涨。仅在3月份，保险费就上涨了2.6%，这意味着成本比去年同期高出了22.2%。这些涨价导致了上个月通货膨胀率上升了0.4%。除汽车保险外，其他任何消费类别都没有像它一样飙升。Foxbusiness.com表示，美国汽车保险的平均费用已经超过每年2300美元，约合每月192美元。不断上涨的价格对最低收入者影响最大。对于那些在生活成本危机中努力维持生计的人来说，保险正成为一种更大的经济负担。&lt;/p&gt;
&lt;p&gt;汽车分析师肖恩·塔克试图解释价格上涨背后的原因。他说：“我认为最大的因素是新车和它们越来越贵，所以如果你撞坏了你的车，替换成本非常高，而且现在小事故的费用也很昂贵。”他将现代汽车中的技术、小工具和安全设备的复杂性归因于更昂贵的修理和更换成本。更换电动汽车电池的费用可能在6500美元到2万美元以上。一个简单的刮擦可能会损坏昂贵的嵌入式传感器、摄像头和声纳。推动劳动力成本上升的一个因素是汽车技工的短缺。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;git命令窗口样式美化&lt;/p&gt;
&lt;p&gt;用了N年的东西，一直没有关注样式问题，只觉得还行，但是最近安装nvm，发现一下字体看不清，就看下怎么设置样式，才发现这个可以右键Options然后进行设置，除了字体颜色、背景色，还有主题可选，但是试用了一下，不够美观，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402011121252.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;在网上查了一下，发现这个样式还不错。&lt;a href=&#34;https://blog.csdn.net/qq_46359697/article/details/107756317&#34;&gt;Git Bash界面的美化（一看必会）_git bash美化-CSDN博客&lt;/a&gt;，配置流程就是修改.minttyrc文件，位置在&lt;code&gt;C:\Users\weihao&lt;/code&gt;，将里面的使用#注释，然后复制样式覆盖即可。&lt;/p&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;img src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405190008036.png&#34; style=&#34;zoom: 50%;&#34; /&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/largest-number-at-least-twice-of-others/">747. 至少是其他数字两倍的最大数</a></p>
<p>给你一个整数数组 <code>nums</code> ，其中总是存在 <strong>唯一的</strong> 一个最大整数 。</p>
<p>请你找出数组中的最大元素并检查它是否 <strong>至少是数组中每个其他数字的两倍</strong> 。如果是，则返回 <strong>最大元素的下标</strong> ，否则返回 <code>-1</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="mi">6</span> <span class="nx">是最大的整数</span><span class="err">，</span><span class="nx">对于数组中的其他整数</span><span class="err">，</span><span class="mi">6</span> <span class="nx">至少是数组中其他元素的两倍</span><span class="err">。</span><span class="mi">6</span> <span class="nx">的下标是</span> <span class="mi">1</span> <span class="err">，</span><span class="nx">所以返回</span> <span class="mi">1</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">dominantIndex</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">sortedNums</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">toSorted</span><span class="p">((</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">a</span> <span class="o">-</span> <span class="nx">b</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">sortedNums</span><span class="p">[</span><span class="nx">sortedNums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="nx">sortedNums</span><span class="p">[</span><span class="nx">sortedNums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">2</span><span class="p">]</span> <span class="o">*</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">sortedNums</span><span class="p">[</span><span class="nx">sortedNums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="o">-</span><span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>先将数字从小到大排序，生成新数组；</li>
<li>然后获取最后一位，如果大于等于倒数第二位的数值乘以2，则表示存在满足条件的最大整数，否则返回-1；</li>
<li>通过indexOf在原nums数组中获取最大整数下标。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240415-auto-insurance.html">Rising auto insurance premiums fuelling inflation - Breaking News English Lesson</a></p>
<p>汽车保险费的飙升正在加剧美国的通货膨胀压力，成本以最快的速度上涨。仅在3月份，保险费就上涨了2.6%，这意味着成本比去年同期高出了22.2%。这些涨价导致了上个月通货膨胀率上升了0.4%。除汽车保险外，其他任何消费类别都没有像它一样飙升。Foxbusiness.com表示，美国汽车保险的平均费用已经超过每年2300美元，约合每月192美元。不断上涨的价格对最低收入者影响最大。对于那些在生活成本危机中努力维持生计的人来说，保险正成为一种更大的经济负担。</p>
<p>汽车分析师肖恩·塔克试图解释价格上涨背后的原因。他说：“我认为最大的因素是新车和它们越来越贵，所以如果你撞坏了你的车，替换成本非常高，而且现在小事故的费用也很昂贵。”他将现代汽车中的技术、小工具和安全设备的复杂性归因于更昂贵的修理和更换成本。更换电动汽车电池的费用可能在6500美元到2万美元以上。一个简单的刮擦可能会损坏昂贵的嵌入式传感器、摄像头和声纳。推动劳动力成本上升的一个因素是汽车技工的短缺。</p>
<h2 id="tip">Tip</h2>
<p>git命令窗口样式美化</p>
<p>用了N年的东西，一直没有关注样式问题，只觉得还行，但是最近安装nvm，发现一下字体看不清，就看下怎么设置样式，才发现这个可以右键Options然后进行设置，除了字体颜色、背景色，还有主题可选，但是试用了一下，不够美观，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402011121252.png"></p>
<p>在网上查了一下，发现这个样式还不错。<a href="https://blog.csdn.net/qq_46359697/article/details/107756317">Git Bash界面的美化（一看必会）_git bash美化-CSDN博客</a>，配置流程就是修改.minttyrc文件，位置在<code>C:\Users\weihao</code>，将里面的使用#注释，然后复制样式覆盖即可。</p>
<h2 id="share">Share</h2>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405190008036.png" style="zoom: 50%;" />
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 29</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-29/</link>
      <pubDate>Sat, 18 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-29/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/smallest-even-multiple/&#34;&gt;2413. 最小偶倍数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个正整数 &lt;code&gt;n&lt;/code&gt; ，返回 &lt;code&gt;2&lt;/code&gt; 和 &lt;code&gt;n&lt;/code&gt; 的最小公倍数（正整数）。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的最小公倍数是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;10&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;smallestEvenMultiple&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;两个数中一个数是另一个数的倍数，则较大的数就是它们的最小公倍数。&lt;/li&gt;
&lt;li&gt;两个数是相邻的自然数或是两个不同的质数，则它们的乘积就是最小公倍数。&lt;/li&gt;
&lt;li&gt;通过取余（%）运算符实现即可。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240411-music-tempo.html&#34;&gt;Chechnya bans music that is too slow or too fast - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;车臣共和国的文化部制定了关于人们可以听什么速度的音乐的规定。该部门禁止播放速度过快或过慢的歌曲，并发布了有关允许的歌曲节奏的公告。公告中写道：“从现在开始，所有的音乐、歌唱和舞蹈作品的节奏应该在80到116拍每分钟之间。”这个新标准的起点是每分钟80拍，比许多现代流行音乐要慢得多。然而，俄罗斯国歌通常以每分钟76拍的速度演奏。文化部尚未就国歌是否受到新规定的影响发表任何声明。很可能国歌将成为这一新规定的例外。&lt;/p&gt;
&lt;p&gt;禁止播放速度过快或过慢的音乐旨在保护车臣的文化和传统。《莫斯科时报》称这是为了“根除任何西方化的迹象”。车臣领导人拉姆赞·卡德罗夫表示，这项禁令是为了使音乐“符合车臣人的心态”。他补充道：“借用他人的音乐文化是不可容忍的。”车臣文化部部长穆萨·达达耶夫表示：“我们必须将车臣人民的文化遗产传承给人民和我们子孙后代。”当地艺术家需要在6月1日之前重新创作他们的歌曲以符合新的节奏要求。车臣的人们将不能再听到电子音乐，或者碧昂丝、公鸭和泰勒的许多歌曲。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;git clone xxx not found&lt;/p&gt;
&lt;p&gt;在使用git从gitlab下载项目的时候，出现以下这个报错问题：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;fatal&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;repository&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;https://gitlab.xxx.com/xxx/web/project-name/&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;not&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;found&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;因为URL是copy的，所以不会弄错，猜测应该是用户名和密码异常，所以使用以下命令进行配置：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;git config --global user.name &lt;span class=&#34;s2&#34;&gt;&amp;#34;xxxx&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;git config --global user.password &lt;span class=&#34;s2&#34;&gt;&amp;#34;xxxx&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;发现还是失败了，就想着怎么触发用户名和密码输入那个弹窗。看了一下发现使用的URL其实是没有.git结尾的，修改了一下clone的命令为：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;git clone https://gitlab.xxx.com/xxx/web/project-name.git
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;此时，触发了用户名和密码输入弹窗，填入正确信息即可，问题解决。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/smallest-even-multiple/">2413. 最小偶倍数</a></p>
<p>给你一个正整数 <code>n</code> ，返回 <code>2</code> 和 <code>n</code> 的最小公倍数（正整数）。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">n</span> <span class="o">=</span> <span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">10</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="mi">5</span> <span class="nx">和</span> <span class="mi">2</span> <span class="nx">的最小公倍数是</span> <span class="mi">10</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">smallestEvenMultiple</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">n</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">n</span> <span class="o">&gt;=</span> <span class="mi">2</span> <span class="o">&amp;&amp;</span> <span class="nx">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">n</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">n</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">n</span> <span class="o">*</span> <span class="mi">2</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>两个数中一个数是另一个数的倍数，则较大的数就是它们的最小公倍数。</li>
<li>两个数是相邻的自然数或是两个不同的质数，则它们的乘积就是最小公倍数。</li>
<li>通过取余（%）运算符实现即可。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240411-music-tempo.html">Chechnya bans music that is too slow or too fast - Breaking News English Lesson</a></p>
<p>车臣共和国的文化部制定了关于人们可以听什么速度的音乐的规定。该部门禁止播放速度过快或过慢的歌曲，并发布了有关允许的歌曲节奏的公告。公告中写道：“从现在开始，所有的音乐、歌唱和舞蹈作品的节奏应该在80到116拍每分钟之间。”这个新标准的起点是每分钟80拍，比许多现代流行音乐要慢得多。然而，俄罗斯国歌通常以每分钟76拍的速度演奏。文化部尚未就国歌是否受到新规定的影响发表任何声明。很可能国歌将成为这一新规定的例外。</p>
<p>禁止播放速度过快或过慢的音乐旨在保护车臣的文化和传统。《莫斯科时报》称这是为了“根除任何西方化的迹象”。车臣领导人拉姆赞·卡德罗夫表示，这项禁令是为了使音乐“符合车臣人的心态”。他补充道：“借用他人的音乐文化是不可容忍的。”车臣文化部部长穆萨·达达耶夫表示：“我们必须将车臣人民的文化遗产传承给人民和我们子孙后代。”当地艺术家需要在6月1日之前重新创作他们的歌曲以符合新的节奏要求。车臣的人们将不能再听到电子音乐，或者碧昂丝、公鸭和泰勒的许多歌曲。</p>
<h2 id="tip">Tip</h2>
<p>git clone xxx not found</p>
<p>在使用git从gitlab下载项目的时候，出现以下这个报错问题：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">fatal</span><span class="o">:</span> <span class="nx">repository</span> <span class="s1">&#39;https://gitlab.xxx.com/xxx/web/project-name/&#39;</span> <span class="nx">not</span> <span class="nx">found</span>
</span></span></code></pre></div><p>因为URL是copy的，所以不会弄错，猜测应该是用户名和密码异常，所以使用以下命令进行配置：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git config --global user.name <span class="s2">&#34;xxxx&#34;</span>
</span></span><span class="line"><span class="cl">git config --global user.password <span class="s2">&#34;xxxx&#34;</span>
</span></span></code></pre></div><p>发现还是失败了，就想着怎么触发用户名和密码输入那个弹窗。看了一下发现使用的URL其实是没有.git结尾的，修改了一下clone的命令为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git clone https://gitlab.xxx.com/xxx/web/project-name.git
</span></span></code></pre></div><p>此时，触发了用户名和密码输入弹窗，填入正确信息即可，问题解决。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402021037069.png"></p>
<h2 id="share">Share</h2>
<p><a href="https://developer.aliyun.com/article/1356721?utm_content=g_1000382235">技术人对抗焦虑的加减法-阿里云开发者社区 (aliyun.com)</a></p>
<ol>
<li>不要把别人贩卖的焦虑强加到自己的感受中</li>
<li>没有坑，就让自己先成为萝卜，等待机会</li>
<li>要抓住问题的本质，如果只是找一匹跑得更快的马，那就不会发明汽车</li>
<li>决定未来的不是过去，也不是他人的评价，而是你自己定义的将来</li>
<li>最挑战的事情，最高级的快乐</li>
<li>警惕低水平的勤奋，不要碎片化学习</li>
<li>认知自己，比认知知识点更重要</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 28</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-28/</link>
      <pubDate>Fri, 17 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-28/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/diagonal-traverse/&#34;&gt;498. 对角线遍历&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个大小为 &lt;code&gt;m x n&lt;/code&gt; 的矩阵 &lt;code&gt;mat&lt;/code&gt; ，请以对角线遍历的顺序，用一个数组返回这个矩阵中的所有元素。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2021/04/10/diag1-grid.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;findDiagonalOrder&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;row&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;  &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;col&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;d&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，检查矩阵的行数，如果矩阵是空的，直接返回一个空数组。&lt;/p&gt;
&lt;p&gt;然后，获取矩阵的行数 &lt;code&gt;m&lt;/code&gt; 和列数 &lt;code&gt;n&lt;/code&gt;，并初始化一个空数组 &lt;code&gt;result&lt;/code&gt; 来存储遍历的结果。接着，初始化变量 &lt;code&gt;row&lt;/code&gt; 和 &lt;code&gt;col&lt;/code&gt; 分别代表当前的行和列，&lt;code&gt;d&lt;/code&gt; 代表遍历的方向。在矩阵中，向右上方向移动，行数减小，列数增大，所以，当&lt;code&gt;d=1&lt;/code&gt;时，为右上方向遍历，当&lt;code&gt;d=-1&lt;/code&gt;时，为左下方向遍历。&lt;/p&gt;
&lt;p&gt;接下来，通过一个循环来遍历整个矩阵。在每一次循环中，将当前位置的值加入到结果数组中，然后根据当前的遍历方向 &lt;code&gt;d&lt;/code&gt; 来更新 &lt;code&gt;row&lt;/code&gt; 和 &lt;code&gt;col&lt;/code&gt; 的值。同时，根据不同的情况（比如超出边界），调整 &lt;code&gt;row&lt;/code&gt;、&lt;code&gt;col&lt;/code&gt; 和 &lt;code&gt;d&lt;/code&gt; 的值，以确保遍历的方向是正确的。&lt;/p&gt;
&lt;p&gt;最后，返回结果数组。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240408-solar-eclipse.html&#34;&gt;Rockets and planes chase the solar eclipse - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/diagonal-traverse/">498. 对角线遍历</a></p>
<p>给你一个大小为 <code>m x n</code> 的矩阵 <code>mat</code> ，请以对角线遍历的顺序，用一个数组返回这个矩阵中的所有元素。</p>
<p><img alt="img" loading="lazy" src="https://assets.leetcode.com/uploads/2021/04/10/diag1-grid.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">mat</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">7</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">findDiagonalOrder</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">mat</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="k">if</span> <span class="p">(</span><span class="nx">mat</span><span class="p">.</span><span class="nx">length</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="k">return</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">m</span> <span class="o">=</span> <span class="nx">mat</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">n</span> <span class="o">=</span> <span class="nx">mat</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">row</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">col</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">d</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">m</span> <span class="o">*</span> <span class="nx">n</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">result</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">mat</span><span class="p">[</span><span class="nx">row</span><span class="p">][</span><span class="nx">col</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">        <span class="nx">row</span> <span class="o">-=</span> <span class="nx">d</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="nx">col</span> <span class="o">+=</span> <span class="nx">d</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">row</span> <span class="o">&gt;=</span> <span class="nx">m</span><span class="p">)</span> <span class="p">{</span> <span class="nx">row</span> <span class="o">=</span> <span class="nx">m</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">col</span> <span class="o">+=</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">d</span> <span class="o">=</span> <span class="o">-</span><span class="nx">d</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">col</span> <span class="o">&gt;=</span> <span class="nx">n</span><span class="p">)</span> <span class="p">{</span> <span class="nx">col</span> <span class="o">=</span> <span class="nx">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">row</span> <span class="o">+=</span> <span class="mi">2</span><span class="p">;</span> <span class="nx">d</span> <span class="o">=</span> <span class="o">-</span><span class="nx">d</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">row</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">)</span>  <span class="p">{</span> <span class="nx">row</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">d</span> <span class="o">=</span> <span class="o">-</span><span class="nx">d</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">col</span> <span class="o">&lt;</span> <span class="mi">0</span><span class="p">)</span>  <span class="p">{</span> <span class="nx">col</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">d</span> <span class="o">=</span> <span class="o">-</span><span class="nx">d</span><span class="p">;</span> <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，检查矩阵的行数，如果矩阵是空的，直接返回一个空数组。</p>
<p>然后，获取矩阵的行数 <code>m</code> 和列数 <code>n</code>，并初始化一个空数组 <code>result</code> 来存储遍历的结果。接着，初始化变量 <code>row</code> 和 <code>col</code> 分别代表当前的行和列，<code>d</code> 代表遍历的方向。在矩阵中，向右上方向移动，行数减小，列数增大，所以，当<code>d=1</code>时，为右上方向遍历，当<code>d=-1</code>时，为左下方向遍历。</p>
<p>接下来，通过一个循环来遍历整个矩阵。在每一次循环中，将当前位置的值加入到结果数组中，然后根据当前的遍历方向 <code>d</code> 来更新 <code>row</code> 和 <code>col</code> 的值。同时，根据不同的情况（比如超出边界），调整 <code>row</code>、<code>col</code> 和 <code>d</code> 的值，以确保遍历的方向是正确的。</p>
<p>最后，返回结果数组。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240408-solar-eclipse.html">Rockets and planes chase the solar eclipse - Breaking News English Lesson</a></p>
<p>周一，天文学家和飞行员在天空中追逐日食。当时，加拿大、美国和墨西哥的数百万人凝视着天空，瞥见了罕见的天体事件——日全食。太阳、月亮和地球对齐，挡住了太阳圆盘的视线。 美国宇航局为其高空WB-57飞机配备了特殊的传感器和仪器，以从独特的太阳事件中收集信息。飞行员在15,240米高的日食中导航，以观察日冕 - 太阳的外表面。美国宇航局还向地球的高层大气层（称为电离层）发射火箭，试图解开太阳的一些最大谜团。</p>
<p>当月亮遮挡太阳的脸时，就会发生日全食。这种天体现象瞬间将白天变成黑夜。整体性意味着太阳的日冕变得比太阳的圆盘暗一百万倍。这使得科学家更容易观察和研究太阳。太阳天体物理学家阿米尔·卡斯皮博士解释说：“日全食让我们以任何其他时间和方式都不可能的方式研究和观察日冕。日食经常对自然产生令人困惑的影响。它们短暂地搅动了夜行动物，使鸟类和昆虫变得寂静。驾驶员也可能受到影响，应随着照明和能见度条件的变化而减速。</p>
<h2 id="tip">Tip</h2>
<p>Cannot find module xxx or its corresponding type declarations.</p>
<p>在Vue3项目的vite.config.ts中设置别名之后，在.vue文件中引入会报红提示这个没有找到的错误，验证了下，虽然不影响功能使用，但是体验不好。</p>
<p><code>VSCode</code>中使用<code>Ctrl+Shift+P</code>，然后输入<code>type</code>，选择<code>Volar:Select TypeScript Version...</code>，然后选择<code>Use Workspace Version xxx</code>即可。</p>
<h2 id="share">Share</h2>
<p>你要听人家说什么，而不是要听人家怎么说。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 50</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-50/</link>
      <pubDate>Mon, 13 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-50/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/longest-subarray-of-1s-after-deleting-one-element/&#34;&gt;1493. 删掉一个元素以后全为 1 的最长子数组&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个二进制数组 &lt;code&gt;nums&lt;/code&gt; ，你需要从中删掉一个元素。&lt;/p&gt;
&lt;p&gt;请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。&lt;/p&gt;
&lt;p&gt;如果不存在这样的子数组，请返回 0 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;删掉位置&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的数字后&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的最长全&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;子数组为&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestSubarray&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 检查数组是否全为1
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isAllOnes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;every&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 检查数组是否全为0
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isAllZeros&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;every&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 处理数组，返回最长连续1的长度
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;processArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;join&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;segments&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxLength&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;segment&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;segments&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;segment&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxLength&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;maxLength&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;segment&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxLength&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;isAllOnes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;isAllZeros&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 找出所有满足条件的0的位置
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;zeroIndices&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;zeroIndices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;zeroIndices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;processArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxResult&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;zeroIndices&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;modifiedArray&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;JSON&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;parse&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;JSON&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;stringify&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;));&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;modifiedArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentMax&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;processArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;modifiedArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;currentMax&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxResult&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;maxResult&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentMax&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxResult&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/longest-subarray-of-1s-after-deleting-one-element/">1493. 删掉一个元素以后全为 1 的最长子数组</a></p>
<p>给你一个二进制数组 <code>nums</code> ，你需要从中删掉一个元素。</p>
<p>请你在删掉元素的结果数组中，返回最长的且只包含 1 的非空子数组的长度。</p>
<p>如果不存在这样的子数组，请返回 0 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">2</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">删掉位置</span> <span class="mi">4</span> <span class="nx">的数字后</span><span class="err">，</span><span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span> <span class="nx">的最长全</span> <span class="mi">1</span> <span class="nx">子数组为</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">longestSubarray</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 检查数组是否全为1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">function</span> <span class="nx">isAllOnes</span><span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">every</span><span class="p">(</span><span class="nx">n</span> <span class="p">=&gt;</span> <span class="nx">n</span> <span class="o">===</span> <span class="mi">1</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 检查数组是否全为0
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">function</span> <span class="nx">isAllZeros</span><span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">every</span><span class="p">(</span><span class="nx">n</span> <span class="p">=&gt;</span> <span class="nx">n</span> <span class="o">===</span> <span class="mi">0</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 处理数组，返回最长连续1的长度
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">function</span> <span class="nx">processArray</span><span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">str</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s2">&#34;&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">segments</span> <span class="o">=</span> <span class="nx">str</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39;0&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">maxLength</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">segment</span> <span class="k">of</span> <span class="nx">segments</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">segment</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="nx">maxLength</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">maxLength</span> <span class="o">=</span> <span class="nx">segment</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">maxLength</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">isAllOnes</span><span class="p">(</span><span class="nx">nums</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">isAllZeros</span><span class="p">(</span><span class="nx">nums</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 找出所有满足条件的0的位置
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">zeroIndices</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="mi">1</span> <span class="o">||</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">===</span> <span class="mi">1</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">zeroIndices</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">i</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">zeroIndices</span><span class="p">.</span><span class="nx">length</span> <span class="o">===</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">processArray</span><span class="p">(</span><span class="nx">nums</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">maxResult</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="nx">zeroIndices</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">index</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">modifiedArray</span> <span class="o">=</span> <span class="nx">JSON</span><span class="p">.</span><span class="nx">parse</span><span class="p">(</span><span class="nx">JSON</span><span class="p">.</span><span class="nx">stringify</span><span class="p">(</span><span class="nx">nums</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">        <span class="nx">modifiedArray</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">currentMax</span> <span class="o">=</span> <span class="nx">processArray</span><span class="p">(</span><span class="nx">modifiedArray</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">currentMax</span> <span class="o">&gt;</span> <span class="nx">maxResult</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">maxResult</span> <span class="o">=</span> <span class="nx">currentMax</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">maxResult</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>处理特殊情况，如全1或全0数组。</li>
<li>遍历数组，找到所有<strong>左右至少有一个1的0的位置</strong>。</li>
<li>如果没有符合条件的0，则直接计算原数组的最长连续1的长度。</li>
<li>对于每个符合条件的0，替换为1，切割数组，找到最长长度。</li>
<li>比较所有替换后的最长长度，并减1。</li>
<li>最终返回最大值。</li>
</ol>
<blockquote>
<p>其实一开始，我是通过判断左右都为1的0才作为候选进行替换，但在实际操作中发现了一个问题：替换为1并切割后的长度并不比原生的长，导致所求结果出现偏差。具体来说，替换后的最长连续1的长度小于原生长度，最终返回了原生长度。而这个原生长度并没有经过0替换为1的操作，因此减1的修正逻辑是不必要的，导致结果一直错误。</p></blockquote>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2505/250512-india-pakistan-ceasefire.html">Pakistan and India agree to ceasefire - Breaking News English Lesson</a></p>
<p>巴基斯坦和印度宣布停火，但双方均声称对方违反协议。这两个拥核邻国在最近几周已濒临全面战争。此次冲突的导火索是4月22日在印度控制的克什米尔地区帕哈甘旅游胜地发生的袭击事件，造成26名平民死亡。印度指责巴基斯坦策划了此次袭击，但巴基斯坦坚决否认指控。袭击发生后，双方互相发动军事打击：印度向巴基斯坦旁遮普省的空军基地发射导弹，巴基斯坦则称其目标是印度的军事设施。这些行动加剧了局势升级为更危险地区冲突的风险。</p>
<p>尽管达成停火，但局势仍显脆弱。巴基斯坦外交部表示“仍致力于忠实地执行停火协议”。印度军方发言人则否认印方违反停火的指控，并警告称“若领土遭袭，印度将进行反击”，强调“印度军队已做好全面作战准备，随时捍卫国家”。美国总统特朗普宣布此次停火是在美国斡旋下达成的，美方“敦促双方寻求缓和局势的途径，并愿意协助启动建设性对话”。此外，中国外交部长王毅也表示愿为印巴停火发挥建设性作用，支持通过对话解决争端。</p>
<h2 id="tip">Tip</h2>
<p>如何在 Mermaid 在线编辑器中实现长截图？</p>
<p>在 <a href="https://mermaid-live.nodejs.cn/">Mermaid 在线编辑器</a> 上快速截图，虽然已经支持以 PNG 格式下载，但当流程图很长时，页面两边的间距过大，导致流程图内容展示过小。所以，可以使用 Google 浏览器的全屏截图功能。具体操作是：在流程图预览模式下，按下 <code>F12</code>，然后按下 <code>Ctrl + Shift + P</code>，输入 <code>screenshot</code>，选择 <strong>Capture full size screenshot</strong>，这样就可以实现长截图了。</p>
<p>不过，在 <a href="https://mermaid.nodejs.cn/">Mermaid 中文网</a> 上，这个方法一直没成功。后来发现，可以先点击 <strong>Kroki</strong> 预览流程图，然后缩小窗口，再使用上述命令，这样就能成功截图了。</p>
<h2 id="share">Share</h2>
<p><a href="https://www.infoq.cn/article/YgS4DyKMbX4p3mSSU8fA">AI 时代团队管理的变与不变-InfoQ</a></p>
<ol>
<li>软件改不动体现于，为了修复一个问题却带来了三个新问题，或为了修复一个小问题却导致了大故障，最终让人失去改的勇气和信心。</li>
<li>职业发展是在职场中完成的，而自我发展是在关系中完成的，且关系越是紧密的场合就越能帮助个人更好地发展自我。</li>
<li>一个自我发展不足的人，是很难在工作与生活中做好倾听、与人共情、尊重和看见他人的，且这些人也没有意识到这方面不足。</li>
<li>人最大的问题是不认为自己有问题，最重的傲慢是以为自己才对，背后折射出的是个人自我发展的不成熟。</li>
<li>育儿之所以对于成年人的自我发展那么重要，是因为成年人需要在一个更干净和纯粹的关系中，照见自己的不足、发现自己的傲慢与无知，通过这些强烈的刺激而引发自我改变。</li>
<li>自我成长是一个系统性的终身话题，对管理者的要求尤为高。</li>
<li><strong>未来淘汰你的不是 AI，而是掌握 AI 的人。</strong></li>
<li>人的核心竞争力在于通过软件设计驾驭复杂度，以及通过工程能力来确保软件开发的效率和质量，这两大内容没有人的参与 AI 独自是搞不定的。不过，我们可以通过用好 AI 而让这两件事变得更容易。</li>
<li>管理理念得从“胡萝卜 + 大棒”转向人性化管理和自组织管理。</li>
<li>实施人性化管理的背后，考验的是管理者自身的自我发展水平，当管理者不具备看见人、尊重人的能力并具备良好的独立人格时，他就很难有人性化管理的意识与行动。</li>
<li><strong>低效的团队会让人无一例外地发现，管理者是整个团队的最大瓶颈。</strong></li>
<li>这些管理者普遍面临精力、心力和能力“三力”不足的现象，以至于没有办法通过授权、放权、机制等有效的手段将自主性还给员工，从而让员工获得更多锻炼而更好地成长。</li>
<li>无论管理者有多强的能力，当一个团队交到他手上后，他就得想方设法激发每位团队成员的主人翁意识和工作热情，当员工有自主性时才能长出自驱力，进一步通过个体间的协作而变成自组织团队。</li>
<li>一个自组织团队的管理者，才能让自己的精力和心力不枯竭，而能打造出这样的团队，也意味着他是名胜任的管理者，证明自己的能力的同时，对管理者这个身份才会有认同感，才能找到成为管理者的价值感。</li>
<li>当管理者的焦点变成关注团队和人在先时，管理手段就会慢慢离开本能的命令和控制型。这个转变，也是从管理者个人的“我想”变成了整个团队的“我们想”。</li>
<li>管理者一定要有的认知是，团队是自己的，授权和支持员工的成长，最终都会让自己从中享受到成果，自己和员工是共赢而非博弈关系。共赢思维一旦建立，才会花更多的精力去塑造良好的团队文化氛围，以氛围做土壤，让员工进一步长出“我想”、“我要”和“我能”。</li>
<li>技术管理是有方法可循的，是可以学习的，最重要的是管理者得像解决软件缺陷那样去对待技术管理问题。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 27</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-27/</link>
      <pubDate>Fri, 10 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-27/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/length-of-last-word/&#34;&gt;58. 最后一个单词的长度&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串 &lt;code&gt;s&lt;/code&gt;，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 &lt;strong&gt;最后一个&lt;/strong&gt; 单词的长度。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;单词&lt;/strong&gt; 是指仅由字母组成、不包含任何空格字符的最大子字符串。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;Hello World&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;最后一个单词是&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;“&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;World&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;”，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;长度为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;lengthOfLastWord&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39; &amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;filter&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;只是通过空格切割字符串变成数组，然后过滤掉空字符串，即全部单词的数组，再取数组最后一个值的长度，即为所求值。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240404-gmail.html&#34;&gt;Gmail celebrates its 20th birthday - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;这家全球使用率最高的电子邮件提供商周一迎来了20岁生日。Gmail 于 2004 年 4 月 1 日推出。当时，它是革命性的，因为它提供了大量的存储空间，而且是免费的。有些人认为这是一个骗局，因为它是在愚人节宣布的。然而，这不是开玩笑。Gmail 免费提供了 1 GB 的巨大存储空间。许多其他提供商仅提供 15 兆字节。起初，人们只有在收到邀请后才能注册 Gmail。它成为技术爱好者的“必备”工具。Gmail成功的另一个原因是它搜索邮件的速度比当时的任何其他电子邮件服务都快。它在过滤垃圾邮件方面也更好。&lt;/p&gt;
&lt;p&gt;自 2004 年以来，Gmail 已成为全球最大的电子邮件提供商。超过 17 亿人使用它。这占世界人口的20%。在美国，大约45%的电子邮件用户使用它。多年来，谷歌已将其免费存储空间增加到 15 GB，并添加了许多新功能。其中之一是一键式取消订阅按钮，可将不需要的邮件拒之门外。另一个功能是“撤消发送”按钮。这允许用户在单击“发送”后停止发送邮件。PC Mag网站称，Gmail是当今生活的重要组成部分。它写道：“Gmail已经融入了这么多人的生活中，几乎没有人对此有太多想法。人们很可能会永远使用它。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;String.prototype.split() 方法接受一个模式，通过搜索模式将字符串分割成一个有序的子串列表，将这些子串放入一个数组，并返回该数组。&lt;/li&gt;
&lt;li&gt;Array.prototype.splice() 通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容。&lt;/li&gt;
&lt;li&gt;Array.prototype.slice() 返回一个新的数组对象，这一对象是一个由 &lt;code&gt;start&lt;/code&gt; 和 &lt;code&gt;end&lt;/code&gt; 决定的原数组的浅拷贝（包括 &lt;code&gt;start&lt;/code&gt;，不包括 &lt;code&gt;end&lt;/code&gt;），其中 &lt;code&gt;start&lt;/code&gt; 和 &lt;code&gt;end&lt;/code&gt; 代表了数组元素的索引。原始数组不会被改变。&lt;/li&gt;
&lt;li&gt;Array.prototype.toSpliced() 是 &lt;code&gt;splice()&lt;/code&gt;方法的复制版本。它返回一个新数组，并在给定的索引处删除和/或替换了一些元素。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;p&gt;在看《少年包青天》，然后八贤王对包拯说的一句话：“你的心，不要改，只是再多一点计谋和手段”。结合最近百度副总裁璩静事件，不管真心还是假意，是没办法用很激进的方式处理团队的事情，很容易落人口实，陷自己于不利之地。引以为戒，引以为戒。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/length-of-last-word/">58. 最后一个单词的长度</a></p>
<p>给你一个字符串 <code>s</code>，由若干单词组成，单词前后用一些空格字符隔开。返回字符串中 <strong>最后一个</strong> 单词的长度。</p>
<p><strong>单词</strong> 是指仅由字母组成、不包含任何空格字符的最大子字符串。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">s</span> <span class="o">=</span> <span class="s2">&#34;Hello World&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">最后一个单词是</span><span class="err">“</span><span class="nx">World</span><span class="err">”，</span><span class="nx">长度为</span> <span class="mi">5</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">lengthOfLastWord</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">s</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="nx">s</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39; &#39;</span><span class="p">).</span><span class="nx">filter</span><span class="p">((</span><span class="nx">item</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="nx">item</span> <span class="o">!==</span> <span class="s1">&#39;&#39;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span><span class="p">[</span><span class="nx">result</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">].</span><span class="nx">length</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>只是通过空格切割字符串变成数组，然后过滤掉空字符串，即全部单词的数组，再取数组最后一个值的长度，即为所求值。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240404-gmail.html">Gmail celebrates its 20th birthday - Breaking News English Lesson</a></p>
<p>这家全球使用率最高的电子邮件提供商周一迎来了20岁生日。Gmail 于 2004 年 4 月 1 日推出。当时，它是革命性的，因为它提供了大量的存储空间，而且是免费的。有些人认为这是一个骗局，因为它是在愚人节宣布的。然而，这不是开玩笑。Gmail 免费提供了 1 GB 的巨大存储空间。许多其他提供商仅提供 15 兆字节。起初，人们只有在收到邀请后才能注册 Gmail。它成为技术爱好者的“必备”工具。Gmail成功的另一个原因是它搜索邮件的速度比当时的任何其他电子邮件服务都快。它在过滤垃圾邮件方面也更好。</p>
<p>自 2004 年以来，Gmail 已成为全球最大的电子邮件提供商。超过 17 亿人使用它。这占世界人口的20%。在美国，大约45%的电子邮件用户使用它。多年来，谷歌已将其免费存储空间增加到 15 GB，并添加了许多新功能。其中之一是一键式取消订阅按钮，可将不需要的邮件拒之门外。另一个功能是“撤消发送”按钮。这允许用户在单击“发送”后停止发送邮件。PC Mag网站称，Gmail是当今生活的重要组成部分。它写道：“Gmail已经融入了这么多人的生活中，几乎没有人对此有太多想法。人们很可能会永远使用它。</p>
<h2 id="tip">Tip</h2>
<ol>
<li>String.prototype.split() 方法接受一个模式，通过搜索模式将字符串分割成一个有序的子串列表，将这些子串放入一个数组，并返回该数组。</li>
<li>Array.prototype.splice() 通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容。</li>
<li>Array.prototype.slice() 返回一个新的数组对象，这一对象是一个由 <code>start</code> 和 <code>end</code> 决定的原数组的浅拷贝（包括 <code>start</code>，不包括 <code>end</code>），其中 <code>start</code> 和 <code>end</code> 代表了数组元素的索引。原始数组不会被改变。</li>
<li>Array.prototype.toSpliced() 是 <code>splice()</code>方法的复制版本。它返回一个新数组，并在给定的索引处删除和/或替换了一些元素。</li>
</ol>
<h2 id="share">Share</h2>
<p>在看《少年包青天》，然后八贤王对包拯说的一句话：“你的心，不要改，只是再多一点计谋和手段”。结合最近百度副总裁璩静事件，不管真心还是假意，是没办法用很激进的方式处理团队的事情，很容易落人口实，陷自己于不利之地。引以为戒，引以为戒。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405092313021.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 26</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-26/</link>
      <pubDate>Thu, 09 May 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-26/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/search-insert-position/&#34;&gt;35. 搜索插入位置&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。&lt;/p&gt;
&lt;p&gt;请必须使用时间复杂度为 &lt;code&gt;O(log n)&lt;/code&gt; 的算法。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;searchInsert&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;floor&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;// 如果没有找到目标值，返回 left
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;一开始事宜for循环，然后加上三个if条件进行判断就解答出来了，但是，不符合题目要求的时间复杂度 &lt;code&gt;O(log n)&lt;/code&gt;，所以就看了一下官方解答思路，使用二分查找法解答。如果目标值存在于数组中，返回它的索引，如果不存在，返回目标值应该被插入的位置。二分查找法之前已经使用过，但是一下子没想起来，所以还是要多练习才行。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2404/240401-ai-extinction.html&#34;&gt;AI an &amp;rsquo;extinction-level threat&amp;rsquo; says study by experts - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;美国国务院委托的一份报告警告说，人工智能存在生存威胁。该报告假设了最坏情况下对人类的“灭绝级威胁”。作者指出，“武器化和失控导致的人工智能能力迅速扩大，对国家安全构成越来越大的风险”。该报告补充说，美国政府“明确而迫切需要”“迅速果断地”进行干预。它继续说：“先进人工智能的兴起有可能破坏全球安全的稳定，让人想起核武器的引入。该报告呼吁成立一个新的联邦机构来监管开发人工智能工具的公司，并限制人工智能的发展。&lt;/p&gt;
&lt;p&gt;这份长达247页的报告是国务院于2022年11月委托撰写的。它是由一家提供有关人工智能的技术简报和指导的公司编写的。作者与OpenAI、Google DeepMind和Meta等人工智能公司的专家进行了广泛的交谈。作者建议为人工智能模型的计算能力设定上限。他们还建议将开源或揭示更强大的人工智能模型背后的编码定为刑事犯罪。Futurism.com 网站表示：“超过一半的受访人工智能研究人员表示，人类有5%的可能性会被逼到灭绝，以及其他&amp;rsquo;极其糟糕的结果&amp;rsquo;。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;gitlab 仓库迁移&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-bash&#34; data-lang=&#34;bash&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt; git clone --mirror url
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt; git remote set-url –-push origin url
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt; git push --mirror 
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;然后会出现提示没有权限的问题，如下图所示：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/search-insert-position/">35. 搜索插入位置</a></p>
<p>给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。</p>
<p>请必须使用时间复杂度为 <code>O(log n)</code> 的算法。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],</span> <span class="nx">target</span> <span class="o">=</span> <span class="mi">5</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="mi">2</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">function</span> <span class="nx">searchInsert</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">left</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">right</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">while</span> <span class="p">(</span><span class="nx">left</span> <span class="o">&lt;=</span> <span class="nx">right</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">mid</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">floor</span><span class="p">((</span><span class="nx">left</span> <span class="o">+</span> <span class="nx">right</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">mid</span><span class="p">]</span> <span class="o">===</span> <span class="nx">target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="nx">mid</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">mid</span><span class="p">]</span> <span class="o">&lt;</span> <span class="nx">target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">left</span> <span class="o">=</span> <span class="nx">mid</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">right</span> <span class="o">=</span> <span class="nx">mid</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="nx">left</span><span class="p">;</span> <span class="c1">// 如果没有找到目标值，返回 left
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>一开始事宜for循环，然后加上三个if条件进行判断就解答出来了，但是，不符合题目要求的时间复杂度 <code>O(log n)</code>，所以就看了一下官方解答思路，使用二分查找法解答。如果目标值存在于数组中，返回它的索引，如果不存在，返回目标值应该被插入的位置。二分查找法之前已经使用过，但是一下子没想起来，所以还是要多练习才行。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2404/240401-ai-extinction.html">AI an &rsquo;extinction-level threat&rsquo; says study by experts - Breaking News English Lesson</a></p>
<p>美国国务院委托的一份报告警告说，人工智能存在生存威胁。该报告假设了最坏情况下对人类的“灭绝级威胁”。作者指出，“武器化和失控导致的人工智能能力迅速扩大，对国家安全构成越来越大的风险”。该报告补充说，美国政府“明确而迫切需要”“迅速果断地”进行干预。它继续说：“先进人工智能的兴起有可能破坏全球安全的稳定，让人想起核武器的引入。该报告呼吁成立一个新的联邦机构来监管开发人工智能工具的公司，并限制人工智能的发展。</p>
<p>这份长达247页的报告是国务院于2022年11月委托撰写的。它是由一家提供有关人工智能的技术简报和指导的公司编写的。作者与OpenAI、Google DeepMind和Meta等人工智能公司的专家进行了广泛的交谈。作者建议为人工智能模型的计算能力设定上限。他们还建议将开源或揭示更强大的人工智能模型背后的编码定为刑事犯罪。Futurism.com 网站表示：“超过一半的受访人工智能研究人员表示，人类有5%的可能性会被逼到灭绝，以及其他&rsquo;极其糟糕的结果&rsquo;。</p>
<h2 id="tip">Tip</h2>
<p>gitlab 仓库迁移</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"> git clone --mirror url
</span></span><span class="line"><span class="cl"> git remote set-url –-push origin url
</span></span><span class="line"><span class="cl"> git push --mirror 
</span></span></code></pre></div><p>然后会出现提示没有权限的问题，如下图所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202404091559471.png"></p>
<pre tabindex="0"><code>remote: GitLab: You are not allowed to force push code to a protected branch on this project.
</code></pre><p>需要打开GitLab，在项目设置那里，开启允许强制更新开关，然后再运行命令<code>git push --mirror</code>即可。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202404091600182.png"></p>
<h2 id="share">Share</h2>
<p>“每当你想要批评别人时，你要记住，这个世界上所有的人，并不是个个都有过你拥有的那些优越条件。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 25</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-25/</link>
      <pubDate>Sun, 28 Apr 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-25/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string/&#34;&gt;28. 找出字符串中第一个匹配项的下标&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你两个字符串 &lt;code&gt;haystack&lt;/code&gt; 和 &lt;code&gt;needle&lt;/code&gt; ，请你在 &lt;code&gt;haystack&lt;/code&gt; 字符串中找出 &lt;code&gt;needle&lt;/code&gt; 字符串的第一个匹配项的下标（下标从 0 开始）。如果 &lt;code&gt;needle&lt;/code&gt; 不是 &lt;code&gt;haystack&lt;/code&gt; 的一部分，则返回 &lt;code&gt;-1&lt;/code&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;haystack&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;sadbutsad&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;needle&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;sad&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;sad&amp;#34;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;在下标&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;和&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;处匹配&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;第一个匹配项的下标是&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以返回&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;haystack&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;needle&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;haystack&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;needle&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;indexOf()&lt;/code&gt;&lt;/strong&gt; 方法返回数组中第一次出现给定元素的下标，如果不存在则返回-1。这道题目只是这个方法的应用而已，没有太多可以说的。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2403/240325-electronic-waste-catastrophe.html&#34;&gt;Climate change increases price of Easter eggs - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;今年的复活节彩蛋价格将比去年高得多。原因是气候变化。极端的天气模式使种植可可变得更具挑战性。可可豆用于制作巧克力。全球约70％的可可豆在西非种植。加纳和科特迪瓦最近的高温、干旱和大雨大大减少了可可豆的种植量。温度比正常高四度。路透社称，与去年同期相比，可可价格已翻了一番。能源和气候分析师Amber Sawyer表示，西非农民在面对极端高温和降雨时“感到困难”。&lt;/p&gt;
&lt;p&gt;巧克力彩蛋是基督教复活节的礼物，庆祝耶稣的复活。传统上，人们染色和绘制鸡蛋。维基百科称，巧克力彩蛋最早出现在法国路易十四的宫廷，约在1725年。1873年，英国巧克力公司J.S. Fry生产了第一个空心巧克力蛋，类似于今天人们赠送的巧克力蛋。维基百科称：“在西方文化中，赠送巧克力彩蛋现在已经司空见惯，仅在英国就售出了8000万个复活节彩蛋。”然而，气候变化正在使种植可可豆变得更加困难。气候分析师表示，如果我们希望稳定供应可可和巧克力，就需要采取更多措施减少化石燃料排放。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;return&lt;/code&gt;语句终止函数的执行，并返回一个指定的值给函数调用者。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;break&lt;/code&gt;语句中止当前循环，&lt;code&gt;switch&lt;/code&gt;语句或&lt;code&gt;label&lt;/code&gt;语句，并把程序控制流转到紧接着被中止语句后面的语句。中止外层循环，需使用&lt;code&gt;label&lt;/code&gt;语句，在外层&lt;code&gt;for&lt;/code&gt;循环前加上&lt;code&gt;outer&lt;/code&gt;，然后使用&lt;code&gt;break outer&lt;/code&gt;实现。&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;&lt;code&gt;continue&lt;/code&gt;声明终止当前循环或标记循环的当前迭代中的语句执行，并在下一次迭代时继续执行循环。&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;p&gt;有些习惯一旦断掉，就很难再捡起来了，所以这个ARTS要补很多篇文章，只能先找下当前应对策略，一方面可以有效完成任务，另一方面先易后难，执行起来会顺利一点。事情太多太多了，雨露均沾很难，要有取舍，别到时候啥都没得到。&lt;/p&gt;
&lt;p&gt;睡觉，运动，饮食，学习，工作。身体是革命的本钱，任务美好的遐想都基于自身的健康，没有健康，这一切只不过是空中阁楼，不要做陀螺，要做不倒翁。&lt;/p&gt;
&lt;p&gt;不要被忙碌的表象迷惑，你所谓的熬夜只是在隔靴挠痒，根本没有，也不想命中要害，要对自己诚实，不要自欺欺人。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/find-the-index-of-the-first-occurrence-in-a-string/">28. 找出字符串中第一个匹配项的下标</a></p>
<p>给你两个字符串 <code>haystack</code> 和 <code>needle</code> ，请你在 <code>haystack</code> 字符串中找出 <code>needle</code> 字符串的第一个匹配项的下标（下标从 0 开始）。如果 <code>needle</code> 不是 <code>haystack</code> 的一部分，则返回 <code>-1</code> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">haystack</span> <span class="o">=</span> <span class="s2">&#34;sadbutsad&#34;</span><span class="p">,</span> <span class="nx">needle</span> <span class="o">=</span> <span class="s2">&#34;sad&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">0</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="s2">&#34;sad&#34;</span> <span class="nx">在下标</span> <span class="mi">0</span> <span class="nx">和</span> <span class="mi">6</span> <span class="nx">处匹配</span><span class="err">。</span>
</span></span><span class="line"><span class="cl"><span class="nx">第一个匹配项的下标是</span> <span class="mi">0</span> <span class="err">，</span><span class="nx">所以返回</span> <span class="mi">0</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">strStr</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">haystack</span><span class="p">,</span> <span class="nx">needle</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">haystack</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="nx">needle</span><span class="p">)</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p><strong><code>indexOf()</code></strong> 方法返回数组中第一次出现给定元素的下标，如果不存在则返回-1。这道题目只是这个方法的应用而已，没有太多可以说的。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240325-electronic-waste-catastrophe.html">Climate change increases price of Easter eggs - Breaking News English Lesson</a></p>
<p>今年的复活节彩蛋价格将比去年高得多。原因是气候变化。极端的天气模式使种植可可变得更具挑战性。可可豆用于制作巧克力。全球约70％的可可豆在西非种植。加纳和科特迪瓦最近的高温、干旱和大雨大大减少了可可豆的种植量。温度比正常高四度。路透社称，与去年同期相比，可可价格已翻了一番。能源和气候分析师Amber Sawyer表示，西非农民在面对极端高温和降雨时“感到困难”。</p>
<p>巧克力彩蛋是基督教复活节的礼物，庆祝耶稣的复活。传统上，人们染色和绘制鸡蛋。维基百科称，巧克力彩蛋最早出现在法国路易十四的宫廷，约在1725年。1873年，英国巧克力公司J.S. Fry生产了第一个空心巧克力蛋，类似于今天人们赠送的巧克力蛋。维基百科称：“在西方文化中，赠送巧克力彩蛋现在已经司空见惯，仅在英国就售出了8000万个复活节彩蛋。”然而，气候变化正在使种植可可豆变得更加困难。气候分析师表示，如果我们希望稳定供应可可和巧克力，就需要采取更多措施减少化石燃料排放。</p>
<h2 id="tip">Tip</h2>
<ul>
<li>
<p><code>return</code>语句终止函数的执行，并返回一个指定的值给函数调用者。</p>
</li>
<li>
<p><code>break</code>语句中止当前循环，<code>switch</code>语句或<code>label</code>语句，并把程序控制流转到紧接着被中止语句后面的语句。中止外层循环，需使用<code>label</code>语句，在外层<code>for</code>循环前加上<code>outer</code>，然后使用<code>break outer</code>实现。</p>
</li>
<li>
<p><code>continue</code>声明终止当前循环或标记循环的当前迭代中的语句执行，并在下一次迭代时继续执行循环。</p>
</li>
</ul>
<h2 id="share">Share</h2>
<p>有些习惯一旦断掉，就很难再捡起来了，所以这个ARTS要补很多篇文章，只能先找下当前应对策略，一方面可以有效完成任务，另一方面先易后难，执行起来会顺利一点。事情太多太多了，雨露均沾很难，要有取舍，别到时候啥都没得到。</p>
<p>睡觉，运动，饮食，学习，工作。身体是革命的本钱，任务美好的遐想都基于自身的健康，没有健康，这一切只不过是空中阁楼，不要做陀螺，要做不倒翁。</p>
<p>不要被忙碌的表象迷惑，你所谓的熬夜只是在隔靴挠痒，根本没有，也不想命中要害，要对自己诚实，不要自欺欺人。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 24</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-24/</link>
      <pubDate>Tue, 23 Apr 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-24/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/merge-two-sorted-lists/&#34;&gt;21. 合并两个有序链表&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;将两个升序链表合并为一个新的 &lt;strong&gt;升序&lt;/strong&gt; 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;示例 1：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt;/**
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * Definition for singly-linked list.
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * function ListNode(val, next) {
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; *     this.val = (val===undefined ? 0 : val)
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; *     this.next = (next===undefined ? null : next)
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * }
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; */&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt;/**
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * @param {ListNode} list1
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * @param {ListNode} list2
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; * @return {ListNode}
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;cm&#34;&gt; */&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mergeTwoLists&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;val&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;val&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mergeTwoLists&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mergeTwoLists&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;list1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;list2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/merge-two-sorted-lists/">21. 合并两个有序链表</a></p>
<p>将两个升序链表合并为一个新的 <strong>升序</strong> 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。</p>
<p><strong>示例 1：</strong></p>
<p><img alt="img" loading="lazy" src="https://assets.leetcode.com/uploads/2020/10/03/merge_ex1.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">list1</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">],</span> <span class="nx">list2</span><span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * Definition for singly-linked list.
</span></span></span><span class="line"><span class="cl"><span class="cm"> * function ListNode(val, next) {
</span></span></span><span class="line"><span class="cl"><span class="cm"> *     this.val = (val===undefined ? 0 : val)
</span></span></span><span class="line"><span class="cl"><span class="cm"> *     this.next = (next===undefined ? null : next)
</span></span></span><span class="line"><span class="cl"><span class="cm"> * }
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span>
</span></span><span class="line"><span class="cl"><span class="cm">/**
</span></span></span><span class="line"><span class="cl"><span class="cm"> * @param {ListNode} list1
</span></span></span><span class="line"><span class="cl"><span class="cm"> * @param {ListNode} list2
</span></span></span><span class="line"><span class="cl"><span class="cm"> * @return {ListNode}
</span></span></span><span class="line"><span class="cl"><span class="cm"> */</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">mergeTwoLists</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">list1</span><span class="p">,</span> <span class="nx">list2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">list1</span> <span class="o">===</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">list2</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">list2</span> <span class="o">===</span> <span class="kc">null</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">list1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="nx">list1</span><span class="p">.</span><span class="nx">val</span> <span class="o">&lt;</span> <span class="nx">list2</span><span class="p">.</span><span class="nx">val</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">list1</span><span class="p">.</span><span class="nx">next</span> <span class="o">=</span> <span class="nx">mergeTwoLists</span><span class="p">(</span><span class="nx">list1</span><span class="p">.</span><span class="nx">next</span><span class="p">,</span> <span class="nx">list2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">list1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">list2</span><span class="p">.</span><span class="nx">next</span> <span class="o">=</span> <span class="nx">mergeTwoLists</span><span class="p">(</span><span class="nx">list1</span><span class="p">,</span> <span class="nx">list2</span><span class="p">.</span><span class="nx">next</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">list2</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>比较两个链表的头节点，将较小的头节点作为合并后的链表的头节点，然后递归地将剩余的部分合并。</p>
<ol>
<li>首先，判断两个链表是否有空的情况，如果其中一个链表为空，说明另一个链表就是合并后的链表，直接返回。</li>
<li>接着，比较两个链表的头节点，将较小的头节点作为合并后的链表的头节点。</li>
<li>对于较小头节点所在的链表，将其头节点的下一个节点与另一个链表进行合并，得到的结果作为较小头节点的下一个节点。</li>
<li>返回较小头节点作为合并后的链表的头节点。</li>
<li>重复以上步骤，直到两个链表的所有节点都被合并。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240325-electronic-waste-catastrophe.html">UN warns of environmental e-waste catastrophe - Breaking News English Lesson</a></p>
<p>联合国向全球消费者发出了严厉警告。我们丢弃的电子产品数量已经造成了“环境灾难”。我们正在处理创纪录数量的“电子垃圾”。联合国将电子产品定义为任何带插头或电池的物品，并且通常含有有毒化学物质和物质，如铅和汞。电子垃圾包括被丢弃的手机、冰箱和电子烟。联合国全球电子垃圾监测器报告称，在2022年，全球产生了令人震惊的6200万吨电子垃圾。CNN表示，这些垃圾“可以填满超过150万辆40吨重的卡车，如果把它们挨个贴在一起，可以&hellip;绕过赤道”。</p>
<p>大多数电子垃圾来自发达国家。其中很多被发送到较贫穷的国家进行回收。然而，这些国家缺乏技术和资源以最大程度地减少环境破坏地处理电子垃圾。庞大的垃圾量造成了大量的健康问题。被倾倒的电子产品正在污染河流和海洋。去年有令人不安的58吨汞进入了环境。其中一部分进入了食物链。联合国指责制造商“缺乏责任心”，因为他们未能对其产品的命运负责。它还指责消费者，称“购买电子产品只需点击几下”，但“处理它们却更加困难”。</p>
<h2 id="tip">Tip</h2>
<p>链表（LinkedList）是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的引用。</p>
<p>常见的有单向链表和双向链表，单向链表中的每个节点只有一个指向下一个节点的引用，双向链表中每个节点都有两个引用，分别指向前一个节点和后一个节点。</p>
<p>链表的实现原理，主要依靠节点之间的引用关系。链表的头部指向第一个节点，而最后一个节点的指针指向 null。这样，当需要遍历链表时，只需从头部开始，依次沿着指针向下移动即可。</p>
<p>举个例子，假设我们有一个单向链表，其中包含节点 A、B、C 和 D，它们依次相连：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">A</span> <span class="o">-&gt;</span> <span class="nx">B</span> <span class="o">-&gt;</span> <span class="nx">C</span> <span class="o">-&gt;</span> <span class="nx">D</span> <span class="o">-&gt;</span> <span class="kc">null</span>
</span></span></code></pre></div><p>如果要查询链表中的某个节点，需要从头节点开始，沿着指针依次移动，直到找到目标节点或者到达链表末尾。</p>
<p>如果要删除或者插入节点，则需要调整相邻节点之间的引用关系，以保持链表的连续性。</p>
<p>与 ArrayList 相比，LinkedList 在查找和修改操作方面效率较低，因为需要遍历整个链表才能找到目标元素，但在增加和删除操作方面效率更高，因为不需要移动元素。</p>
<h2 id="share">Share</h2>
<p>循环论证是一种逻辑错误，具体表现为用来证明论题的论据本身的真实性要依靠论题来证明。换句话说，就是用论点去证明论据，再用论据来证明论点，这构成了一个无法打破的循环。比如，“真是奇怪，都说票好难抢，但是为什么动车上的人全都买到票了。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 23</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-23/</link>
      <pubDate>Fri, 29 Mar 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-23/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/best-sightseeing-pair/&#34;&gt;1014. 最佳观光组合&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个正整数数组 &lt;code&gt;values&lt;/code&gt;，其中 &lt;code&gt;values[i]&lt;/code&gt; 表示第 &lt;code&gt;i&lt;/code&gt; 个观光景点的评分，并且两个景点 &lt;code&gt;i&lt;/code&gt; 和 &lt;code&gt;j&lt;/code&gt; 之间的 &lt;strong&gt;距离&lt;/strong&gt; 为 &lt;code&gt;j - i&lt;/code&gt;。&lt;/p&gt;
&lt;p&gt;一对景点（&lt;code&gt;i &amp;lt; j&lt;/code&gt;）组成的观光组合的得分为 &lt;code&gt;values[i] + values[j] + i - j&lt;/code&gt; ，也就是景点的评分之和 &lt;strong&gt;减去&lt;/strong&gt; 它们两者之间的距离。&lt;/p&gt;
&lt;p&gt;返回一对观光景点能取得的最高分。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxScoreSightseeingPair&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxPrev&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;// 记录前面位置能够得到的最大得分
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxPrev&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;// 计算当前位置的得分
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;nx&#34;&gt;maxPrev&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;maxPrev&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;values&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;c1&#34;&gt;// 更新前面位置能够得到的最大得分
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;一开始我以为使用两个&lt;code&gt;for&lt;/code&gt;循环然后通过&lt;code&gt;Math.max()&lt;/code&gt;比较一下取最大值就解出来，然后提交到力扣后，提示超出时间限制。&lt;/p&gt;
&lt;p&gt;为了解决这个问题，可以使用动态规划来优化算法以避免重复计算，通过调整计算公式为&lt;code&gt;values[i] + i + (values[j] - j)&lt;/code&gt;，可以将当前位置的值加上索引值，再加上下一个位置的值减去索引值，然后取最大值。因此，可以将&lt;code&gt;values[i] + i&lt;/code&gt;和&lt;code&gt;values[j] - j&lt;/code&gt;分别都取最大值，然后再比较两者的和，从而得到观光景点能取得的最高分。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2403/240321-human-speech.html&#34;&gt;Human speech is 8 times older than we thought - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/best-sightseeing-pair/">1014. 最佳观光组合</a></p>
<p>给你一个正整数数组 <code>values</code>，其中 <code>values[i]</code> 表示第 <code>i</code> 个观光景点的评分，并且两个景点 <code>i</code> 和 <code>j</code> 之间的 <strong>距离</strong> 为 <code>j - i</code>。</p>
<p>一对景点（<code>i &lt; j</code>）组成的观光组合的得分为 <code>values[i] + values[j] + i - j</code> ，也就是景点的评分之和 <strong>减去</strong> 它们两者之间的距离。</p>
<p>返回一对观光景点能取得的最高分。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">values</span> <span class="o">=</span> <span class="p">[</span><span class="mi">8</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">6</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">11</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">values</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">+</span> <span class="nx">values</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">+</span> <span class="nx">i</span> <span class="o">-</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">8</span> <span class="o">+</span> <span class="mi">5</span> <span class="o">+</span> <span class="mi">0</span> <span class="o">-</span> <span class="mi">2</span> <span class="o">=</span> <span class="mi">11</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">maxScoreSightseeingPair</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">values</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">maxValue</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">maxPrev</span> <span class="o">=</span> <span class="nx">values</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="c1">// 记录前面位置能够得到的最大得分
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">values</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">maxValue</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">maxValue</span><span class="p">,</span> <span class="nx">maxPrev</span> <span class="o">+</span> <span class="nx">values</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">-</span> <span class="nx">i</span><span class="p">)</span> <span class="c1">// 计算当前位置的得分
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="nx">maxPrev</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">maxPrev</span><span class="p">,</span> <span class="nx">values</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">+</span> <span class="nx">i</span><span class="p">)</span> <span class="c1">// 更新前面位置能够得到的最大得分
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">maxValue</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>一开始我以为使用两个<code>for</code>循环然后通过<code>Math.max()</code>比较一下取最大值就解出来，然后提交到力扣后，提示超出时间限制。</p>
<p>为了解决这个问题，可以使用动态规划来优化算法以避免重复计算，通过调整计算公式为<code>values[i] + i + (values[j] - j)</code>，可以将当前位置的值加上索引值，再加上下一个位置的值减去索引值，然后取最大值。因此，可以将<code>values[i] + i</code>和<code>values[j] - j</code>分别都取最大值，然后再比较两者的和，从而得到观光景点能取得的最高分。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240321-human-speech.html">Human speech is 8 times older than we thought - Breaking News English Lesson</a></p>
<p>研究人员表示，他们已经找到了人类开始说话的可能历史时期。考古学家、史前史专家史蒂文·米森博士认为，基础语言形成于大约160万年前。这比许多科学家之前认为的时间早了八倍。进化学专家先前认为，人类口头语言始于大约20万年前。米森表示，他的研究显示，第一种人类语言要么在东非，要么在南非发展起来的。他说，说话的能力促进了进化。他说，语言“无疑是使随后大部分人类身体和文化进化成为可能的关键”。</p>
<p>米森博士在他的新书《语言之谜》（The Language Puzzle）中解释了他认为人类语言是如何在如此久远的过去发展起来的。他说，我们的大脑在大约150万年前迅速增大。这种增长改变了我们大脑的结构。一个称为额叶的区域发展了起来，这是大脑产生语言的部分。另一个重要的变化是我们声道的发育，这是我们产生声音，因此得以说话的地方。米森说，语言让人类得以传播到世界各地。这意味着人类可以做三件重要的事情。他们可以考虑和计划未来的行动，他们还可以传授知识。米森说，语言“深刻地改变了人类的故事”。</p>
<h2 id="tip">Tip</h2>
<p>打算将自己博客使用的PaperMod主题更新一下，然后放弃本地的修改，因为使用<code>git pull</code>时提示了本地有变动的部分，需要先处理才行，我觉得不是很重要，就打算放弃本地修改，强制更新，使用如下命令：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git fetch --all					
</span></span><span class="line"><span class="cl">git reset --hard origin/master
</span></span><span class="line"><span class="cl">git clean -f -d
</span></span></code></pre></div><p>三个命令解释如下：</p>
<ol>
<li><code>git fetch --all</code>：从远程仓库获取最新的内容。</li>
<li><code>git reset --hard origin/master</code>：将本地仓库的内容重置为与远程仓库相同，包括放弃任何本地修改。</li>
<li><code>git clean -f -d</code>：清除工作目录中未跟踪的文件和目录。</li>
</ol>
<h2 id="share">Share</h2>
<p>抓而不紧，等于不抓。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 22</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-22/</link>
      <pubDate>Wed, 20 Mar 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-22/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/non-decreasing-array/&#34;&gt;665. 非递减数列&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个长度为 &lt;code&gt;n&lt;/code&gt; 的整数数组 &lt;code&gt;nums&lt;/code&gt; ，请你判断在 &lt;strong&gt;最多&lt;/strong&gt; 改变 &lt;code&gt;1&lt;/code&gt; 个元素的情况下，该数组能否变成一个非递减数列。&lt;/p&gt;
&lt;p&gt;我们是这样定义一个非递减数列的： 对于数组中任意的 &lt;code&gt;i&lt;/code&gt; &lt;code&gt;(0 &amp;lt;= i &amp;lt;= n-2)&lt;/code&gt;，总满足 &lt;code&gt;nums[i] &amp;lt;= nums[i + 1]&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;你可以通过把第一个&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;变成&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;来使得它成为一个非递减数列&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;你不能在只改变一个元素的情况下将其变为非递减数列&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;checkPossibility&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 如果数组只有一个元素，则直接返回true
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 只要有一个不满足的元素，就拿到元素的下标，然后跳出循环。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 如果出现元素A的下一个值A+1大于等于上一个值A-1，则将A赋值为A+1。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 否则
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;c1&#34;&gt;// 再次遍历,如果修改某个元素后，不满足 nums[i] &amp;lt;= nums[i + 1]，则结果为false
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;  &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;      &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;  &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/non-decreasing-array/">665. 非递减数列</a></p>
<p>给你一个长度为 <code>n</code> 的整数数组 <code>nums</code> ，请你判断在 <strong>最多</strong> 改变 <code>1</code> 个元素的情况下，该数组能否变成一个非递减数列。</p>
<p>我们是这样定义一个非递减数列的： 对于数组中任意的 <code>i</code> <code>(0 &lt;= i &lt;= n-2)</code>，总满足 <code>nums[i] &lt;= nums[i + 1]</code>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span> <span class="nx">你可以通过把第一个</span> <span class="mi">4</span> <span class="nx">变成</span> <span class="mi">1</span> <span class="nx">来使得它成为一个非递减数列</span><span class="err">。</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">2</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span> <span class="nx">你不能在只改变一个元素的情况下将其变为非递减数列</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">checkPossibility</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// 如果数组只有一个元素，则直接返回true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">===</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="kd">let</span> <span class="nx">index</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
</span></span><span class="line"><span class="cl">  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 只要有一个不满足的元素，就拿到元素的下标，然后跳出循环。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">&gt;</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="nx">index</span> <span class="o">=</span> <span class="nx">i</span>
</span></span><span class="line"><span class="cl">      <span class="k">break</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="c1">// 如果出现元素A的下一个值A+1大于等于上一个值A-1，则将A赋值为A+1。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">if</span> <span class="p">(</span><span class="nx">index</span> <span class="o">===</span> <span class="mi">0</span> <span class="o">||</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span> <span class="o">-</span> <span class="mi">1</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 否则
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="c1">// 再次遍历,如果修改某个元素后，不满足 nums[i] &lt;= nums[i + 1]，则结果为false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>  <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">&gt;</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">      <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">  <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">  <span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，要先遍历数组，因为不管出现几次不满足<code>nums[i] &lt;= nums[i + 1]</code>条件的情况，只需要拿一次来改变元素，然后验证即可，所以当拿到不满足条件的情况时，立马跳出循环，然后通过这个元素的上一个和下一个值进行判断和改变，生成新的数组，再次遍历，如果出现一次不满足<code>nums[i] &lt;= nums[i + 1]</code>条件的情况，则可知结果为<code>false</code>，否则为<code>true</code>。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240318-giant-blueberry.html">Giant blueberry smashes record for heaviest ever - Breaking News English Lesson</a></p>
<p>澳大利亚的一位农民刚刚创下了世界上最大蓝莓的纪录。这颗巨大的蓝莓重达惊人的20.4克，轻松打破了之前的记录，之前的纪录是16.2克。这颗创纪录的蓝莓的直径相当于乒乓球大小，直径为39.31毫米，周长为12.35厘米。这颗创纪录的蓝莓几乎比普通蓝莓重了将近10倍。这颗水果是由澳大利亚新南威尔士州的Costa集团员工种植的。高级园艺师布拉德·霍金表示，他对吉尼斯世界纪录正式认证这一记录感到非常高兴。他说：“这是良好育种和良好种植的结合。”</p>
<p>霍金先生表示，他的蓝莓来自Eterna品种，以其脆爽的口感和长久的保鲜期而闻名。他告诉记者：“Eterna作为一个品种，具有非常出色的口味和一致大的果实。当我们采摘这一颗时，可能还有大约20颗其他大小相似的浆果。”他补充说：“尽管这个果实很大，但在质量或口味上绝对没有妥协，就像开发高端品种时所期望的那样。”起初，他不确定是否打破了记录。他说：“我们必须重新校准天平以确保我们没有搞混。”当被问及他会如何处理他的奖品蓝莓时，他建议用它来制作一杯果汁可能是最合适的结局。</p>
<h2 id="tip">Tip</h2>
<p>Array.prototype.reduce()</p>
<p><strong><code>reduce()</code></strong> 方法对数组中的每个元素按序执行一个提供的 <strong>reducer</strong> 函数，每一次运行 <strong>reducer</strong> 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。</p>
<p>比如使用<code>reduce</code>方法找到子数组长度最长的子数组的写法为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">longestSubArray</span> <span class="o">=</span> <span class="nx">arrs</span><span class="p">.</span><span class="nx">reduce</span><span class="p">((</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">current</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="nx">current</span><span class="p">.</span><span class="nx">length</span> <span class="o">?</span> <span class="nx">prev</span> <span class="o">:</span> <span class="nx">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div><h2 id="share">Share</h2>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202403111047902.jpg" style="zoom: 50%;" />
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 21</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-21/</link>
      <pubDate>Wed, 13 Mar 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-21/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/array-nesting/&#34;&gt;565. 数组嵌套&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;索引从&lt;code&gt;0&lt;/code&gt;开始长度为&lt;code&gt;N&lt;/code&gt;的数组&lt;code&gt;A&lt;/code&gt;，包含&lt;code&gt;0&lt;/code&gt;到&lt;code&gt;N - 1&lt;/code&gt;的所有整数。找到最大的集合&lt;code&gt;S&lt;/code&gt;并返回其大小，其中 &lt;code&gt;S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }&lt;/code&gt;且遵守以下的规则。&lt;/p&gt;
&lt;p&gt;假设选择索引为&lt;code&gt;i&lt;/code&gt;的元素&lt;code&gt;A[i]&lt;/code&gt;为&lt;code&gt;S&lt;/code&gt;的第一个元素，&lt;code&gt;S&lt;/code&gt;的下一个元素应该是&lt;code&gt;A[A[i]]&lt;/code&gt;，之后是&lt;code&gt;A[A[A[i]]]...&lt;/code&gt; 以此类推，不断添加直到&lt;code&gt;S&lt;/code&gt;出现重复的元素。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; 
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;2.&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;其中一种最长的&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;S&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;K&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;S&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;A&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]}&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arrayNesting&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 使用visited数组来记录访问过的元素
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;visited&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;fill&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;getNumValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 设置count，用于记录最大集合长度
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 直到为false,也就是已访问过，出现重复元素，则跳出循环，返回最大集合长度count
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;visited&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;visited&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestSubArray&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 因为前面如果已经访问过，那么后面再次访问时，获取数组长度值一定是比之前的小的。比如当i=0时，触发了后面i=3的递归遍历，当真的执行到i=3时，又重复进行，所以没有意义。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;visited&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;subArrayLength&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;getNumValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;c1&#34;&gt;// 每次遍历，比较大小，获取最大值，赋值给到longestSubArray
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;            &lt;span class=&#34;nx&#34;&gt;longestSubArray&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;longestSubArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;subArrayLength&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestSubArray&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;我一开始的思路是使用递归，依次将&lt;code&gt;nums&lt;/code&gt;各个元素都执行一遍，虽然也解出来了，但是无法满足力扣的解题需求，毕竟是暴力解法，不够优雅。然后使用&lt;code&gt;ChatGPT&lt;/code&gt;，让它诊断了下代码，提出特别好的解法，就是上面的代码。最核心的一点就是，使用&lt;code&gt;visited&lt;/code&gt;数组来记录访问过的元素，因为如果前面已经访问过，那么后面再次访问时，获取集合长度值一定是比之前的小。比如上面的示例1，当&lt;code&gt;i=0&lt;/code&gt;时，其值为&lt;code&gt;5&lt;/code&gt;，触发了后面&lt;code&gt;i=5&lt;/code&gt;的递归遍历，当真的执行到&lt;code&gt;i=5&lt;/code&gt;时，又重复进行，所以没有意义。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2403/240311-rain.html&#34;&gt;It once rained for two million years, say scientists&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;农民在干旱时期祈求降雨。我们大多数人都有过这样的经历，即希望上天为我们的花园降雨以便浇灌植物。然而，我们谁也无法想象一场持续200万年的长时间降雨。英国地质学家和法医科学家阿拉斯泰尔·鲁菲尔发现，在2亿至3亿年前，在盘古大陆分离成大陆之前，地球确实经历了一个长达200万年不间断降雨的时代。鲁菲尔博士说，这有助于促进全球动植物的发展。他认为，降雨可能是由一系列大规模火山喷发后湿度的大幅上升引发的。&lt;/p&gt;
&lt;p&gt;鲁费尔博士及其团队是基于在欧洲东阿尔卑斯山脉进行的研究，该研究于20世纪70年代和80年代展开。数据显示，在可追溯到2亿多年前的古老岩石中沉积了不寻常的地层。鲁菲尔说，这导致越来越多的证据表明，雨季可能是“使恐龙和可能是我们现代陆地动物群其他成员多样化并占领陆地”的触发因素。他补充说：“这可能是生命史上最重要的事件之一，因为它不仅在允许恐龙时代的同时，也促成了大多数构成现代动物群的关键类群的起源，包括龟类、鳄鱼、蜥蜴和哺乳动物。”&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;Flutter国内环境配置&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/array-nesting/">565. 数组嵌套</a></p>
<p>索引从<code>0</code>开始长度为<code>N</code>的数组<code>A</code>，包含<code>0</code>到<code>N - 1</code>的所有整数。找到最大的集合<code>S</code>并返回其大小，其中 <code>S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }</code>且遵守以下的规则。</p>
<p>假设选择索引为<code>i</code>的元素<code>A[i]</code>为<code>S</code>的第一个元素，<code>S</code>的下一个元素应该是<code>A[A[i]]</code>，之后是<code>A[A[A[i]]]...</code> 以此类推，不断添加直到<code>S</code>出现重复的元素。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">A</span> <span class="o">=</span> <span class="p">[</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span> 
</span></span><span class="line"><span class="cl"><span class="nx">A</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="mi">5</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="mi">4</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">2</span><span class="p">]</span> <span class="o">=</span> <span class="mi">0</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">3</span><span class="p">]</span> <span class="o">=</span> <span class="mi">3</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">4</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">5</span><span class="p">]</span> <span class="o">=</span> <span class="mi">6</span><span class="p">,</span> <span class="nx">A</span><span class="p">[</span><span class="mi">6</span><span class="p">]</span> <span class="o">=</span> <span class="mf">2.</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">其中一种最长的</span> <span class="nx">S</span><span class="p">[</span><span class="nx">K</span><span class="p">]</span><span class="o">:</span>
</span></span><span class="line"><span class="cl"><span class="nx">S</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">=</span> <span class="p">{</span><span class="nx">A</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nx">A</span><span class="p">[</span><span class="mi">5</span><span class="p">],</span> <span class="nx">A</span><span class="p">[</span><span class="mi">6</span><span class="p">],</span> <span class="nx">A</span><span class="p">[</span><span class="mi">2</span><span class="p">]}</span> <span class="o">=</span> <span class="p">{</span><span class="mi">5</span><span class="p">,</span> <span class="mi">6</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">0</span><span class="p">}</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">arrayNesting</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 使用visited数组来记录访问过的元素
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">visited</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">getNumValue</span><span class="p">(</span><span class="nx">index</span><span class="p">,</span> <span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 设置count，用于记录最大集合长度
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 直到为false,也就是已访问过，出现重复元素，则跳出循环，返回最大集合长度count
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">while</span> <span class="p">(</span><span class="o">!</span><span class="nx">visited</span><span class="p">[</span><span class="nx">index</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">visited</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span> <span class="o">=</span> <span class="kc">true</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="nx">index</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">index</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">count</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">longestSubArray</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 因为前面如果已经访问过，那么后面再次访问时，获取数组长度值一定是比之前的小的。比如当i=0时，触发了后面i=3的递归遍历，当真的执行到i=3时，又重复进行，所以没有意义。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">visited</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kd">let</span> <span class="nx">subArrayLength</span> <span class="o">=</span> <span class="nx">getNumValue</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">nums</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// 每次遍历，比较大小，获取最大值，赋值给到longestSubArray
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="nx">longestSubArray</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">longestSubArray</span><span class="p">,</span> <span class="nx">subArrayLength</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">longestSubArray</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>我一开始的思路是使用递归，依次将<code>nums</code>各个元素都执行一遍，虽然也解出来了，但是无法满足力扣的解题需求，毕竟是暴力解法，不够优雅。然后使用<code>ChatGPT</code>，让它诊断了下代码，提出特别好的解法，就是上面的代码。最核心的一点就是，使用<code>visited</code>数组来记录访问过的元素，因为如果前面已经访问过，那么后面再次访问时，获取集合长度值一定是比之前的小。比如上面的示例1，当<code>i=0</code>时，其值为<code>5</code>，触发了后面<code>i=5</code>的递归遍历，当真的执行到<code>i=5</code>时，又重复进行，所以没有意义。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240311-rain.html">It once rained for two million years, say scientists</a></p>
<p>农民在干旱时期祈求降雨。我们大多数人都有过这样的经历，即希望上天为我们的花园降雨以便浇灌植物。然而，我们谁也无法想象一场持续200万年的长时间降雨。英国地质学家和法医科学家阿拉斯泰尔·鲁菲尔发现，在2亿至3亿年前，在盘古大陆分离成大陆之前，地球确实经历了一个长达200万年不间断降雨的时代。鲁菲尔博士说，这有助于促进全球动植物的发展。他认为，降雨可能是由一系列大规模火山喷发后湿度的大幅上升引发的。</p>
<p>鲁费尔博士及其团队是基于在欧洲东阿尔卑斯山脉进行的研究，该研究于20世纪70年代和80年代展开。数据显示，在可追溯到2亿多年前的古老岩石中沉积了不寻常的地层。鲁菲尔说，这导致越来越多的证据表明，雨季可能是“使恐龙和可能是我们现代陆地动物群其他成员多样化并占领陆地”的触发因素。他补充说：“这可能是生命史上最重要的事件之一，因为它不仅在允许恐龙时代的同时，也促成了大多数构成现代动物群的关键类群的起源，包括龟类、鳄鱼、蜥蜴和哺乳动物。”</p>
<h2 id="tip">Tip</h2>
<p>Flutter国内环境配置</p>
<p>最近，github都登录不上，挂了梯子，git clone都是失败的，无奈之下，只能研究切换至国内镜像来使用。</p>
<p>首先，在<a href="https://flutter.cn/community/china?tab=windows">《在中国网络环境下使用 Flutter - Flutter 中文文档》</a>文档页面，可以看到相关介绍。主要是需要将<code>PUB_HOSTED_URL</code>和<code>FLUTTER_STORAGE_BASE_URL</code>设置为镜像站点。以 <code>CFUG</code>的镜像为例，使用管理员权限打开Windows Powershell，然后使用Windows setx命令永久设置环境变量，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl">setx PUB_HOSTED_URL https://pub.flutter-io.cn
</span></span><span class="line"><span class="cl">setx FLUTTER_STORAGE_BASE_URL https://storage.flutter-io.cn
</span></span></code></pre></div><p>然后关闭窗口，再打开，输入flutter doctor验证。</p>
<p>相关资料：</p>
<ol>
<li>Flutter 镜像安装帮助：https://mirrors.tuna.tsinghua.edu.cn/help/flutter</li>
<li>Flutter SDK：https://mirrors.tuna.tsinghua.edu.cn/help/flutter-sdk.git</li>
</ol>
<h2 id="share">Share</h2>
<p>面向 ChatGPT 学习和工作已经成为一种趋势，我自己也用了蛮久的，毕竟它可以快速提升效率。然而，我们需要警惕的是，如果在学习和工作中遇到问题时只是简单地抄答案，而没有尽最大努力尝试自己解决，那将是一种悲哀的做法。首先，这样做只是为了完成学习计划和工作任务，对自身不会有任何真正的收获；其次，ChatGPT 给出的答案并不一定完全正确，很多时候可能是胡编乱造的，如果我们没有进一步甄别和思考，很容易被误导。因此，ChatGPT 应该被视为辅助工具，而不应该直接依赖它来解决问题本身。无论答案正确与否，我们都应该自行判断、思考和学习。知其然知其所以然。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 20</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-20/</link>
      <pubDate>Sat, 09 Mar 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-20/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/queens-that-can-attack-the-king/&#34;&gt;1222. 可以攻击国王的皇后&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;在一个 &lt;strong&gt;下标从 0 开始&lt;/strong&gt; 的 &lt;code&gt;8 x 8&lt;/code&gt; 棋盘上，可能有多个黑皇后和一个白国王。&lt;/p&gt;
&lt;p&gt;给你一个二维整数数组 &lt;code&gt;queens&lt;/code&gt;，其中 &lt;code&gt;queens[i] = [xQueeni, yQueeni]&lt;/code&gt; 表示第 &lt;code&gt;i&lt;/code&gt; 个黑皇后在棋盘上的位置。还给你一个长度为 &lt;code&gt;2&lt;/code&gt; 的整数数组 &lt;code&gt;king&lt;/code&gt;，其中 &lt;code&gt;king = [xKing, yKing]&lt;/code&gt; 表示白国王的位置。&lt;/p&gt;
&lt;p&gt;返回 &lt;em&gt;能够直接攻击国王的黑皇后的坐标&lt;/em&gt;。你可以以 &lt;strong&gt;任何顺序&lt;/strong&gt; 返回答案。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;示例 1：&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://pic.leetcode.cn/1703052515-HqjAJq-chess1.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queens&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;king&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;上面的图示显示了三个可以直接攻击国王的皇后和三个不能攻击国王的皇后&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;（&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;用红色虚线标记&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;）。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;queensAttacktheKing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queens&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;king&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 初始化棋盘
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;from&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;({&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;},&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;from&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;({&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;},&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;null&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;));&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 将皇后的位置标记在棋盘上
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;queens&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queen&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queen&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queen&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;Q&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;});&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;res&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 顺时针方向遍历棋盘
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;directions&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;element&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;directions&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;dx&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dy&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;element&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;king&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dx&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;king&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dy&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;Q&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;res&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;([&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dx&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;dy&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;res&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/queens-that-can-attack-the-king/">1222. 可以攻击国王的皇后</a></p>
<p>在一个 <strong>下标从 0 开始</strong> 的 <code>8 x 8</code> 棋盘上，可能有多个黑皇后和一个白国王。</p>
<p>给你一个二维整数数组 <code>queens</code>，其中 <code>queens[i] = [xQueeni, yQueeni]</code> 表示第 <code>i</code> 个黑皇后在棋盘上的位置。还给你一个长度为 <code>2</code> 的整数数组 <code>king</code>，其中 <code>king = [xKing, yKing]</code> 表示白国王的位置。</p>
<p>返回 <em>能够直接攻击国王的黑皇后的坐标</em>。你可以以 <strong>任何顺序</strong> 返回答案。</p>
<p><strong>示例 1：</strong></p>
<p><img loading="lazy" src="https://pic.leetcode.cn/1703052515-HqjAJq-chess1.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">queens</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">],[</span><span class="mi">4</span><span class="p">,</span><span class="mi">0</span><span class="p">],[</span><span class="mi">0</span><span class="p">,</span><span class="mi">4</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">2</span><span class="p">,</span><span class="mi">4</span><span class="p">]],</span> <span class="nx">king</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">3</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">上面的图示显示了三个可以直接攻击国王的皇后和三个不能攻击国王的皇后</span><span class="err">（</span><span class="nx">用红色虚线标记</span><span class="err">）。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">queensAttacktheKing</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">queens</span><span class="p">,</span> <span class="nx">king</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 初始化棋盘
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">board</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">({</span> <span class="nx">length</span><span class="o">:</span> <span class="mi">8</span> <span class="p">},</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">({</span> <span class="nx">length</span><span class="o">:</span> <span class="mi">8</span> <span class="p">},</span> <span class="p">()</span> <span class="p">=&gt;</span> <span class="kc">null</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 将皇后的位置标记在棋盘上
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">queens</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">queen</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">board</span><span class="p">[</span><span class="nx">queen</span><span class="p">[</span><span class="mi">0</span><span class="p">]][</span><span class="nx">queen</span><span class="p">[</span><span class="mi">1</span><span class="p">]]</span> <span class="o">=</span> <span class="s1">&#39;Q&#39;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">});</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">res</span> <span class="o">=</span> <span class="p">[];</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 顺时针方向遍历棋盘
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">directions</span> <span class="o">=</span> <span class="p">[</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">        <span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">,</span> <span class="o">-</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="nx">element</span> <span class="k">of</span> <span class="nx">directions</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="p">[</span><span class="nx">dx</span><span class="p">,</span> <span class="nx">dy</span><span class="p">]</span> <span class="o">=</span> <span class="nx">element</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">x</span> <span class="o">=</span> <span class="nx">king</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">+</span> <span class="nx">dx</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">y</span> <span class="o">=</span> <span class="nx">king</span><span class="p">[</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="nx">dy</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="k">while</span> <span class="p">(</span><span class="nx">x</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="nx">x</span> <span class="o">&lt;</span> <span class="mi">8</span> <span class="o">&amp;&amp;</span> <span class="nx">y</span> <span class="o">&gt;=</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="nx">y</span> <span class="o">&lt;</span> <span class="mi">8</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">x</span><span class="p">][</span><span class="nx">y</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;Q&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">res</span><span class="p">.</span><span class="nx">push</span><span class="p">([</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">]);</span>
</span></span><span class="line"><span class="cl">                <span class="k">break</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="nx">x</span> <span class="o">+=</span> <span class="nx">dx</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="nx">y</span> <span class="o">+=</span> <span class="nx">dy</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">res</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>首先初始化一个<code>8*8</code>的棋盘，将皇后的位置标记在棋盘上；</li>
<li>以国王为坐标系原点，顺时针遍历国王周围的<code>8</code>个方向，每次沿着一个方向遍历到边界，如果遇到皇后，将其坐标加入结果数组；</li>
<li>返回结果数组。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240307-sora-text-to-video.html">Hollywood actor says OpenAI Sora could cause job losses</a></p>
<p>好莱坞制片人兼演员泰勒·佩里担心人工智能将导致电影行业的就业岗位减少。他举了一个个人的例子来说明这种情况正在发生。他说他计划进行8亿美元的电影工作室扩建项目，但已经推迟了这个项目的实施，等待看看人工智能的发展情况。他认为人工智能将对就业产生巨大的影响。他在接受《好莱坞报道》网站采访时表达了他的担忧。他说：“必须有一些规定来保护我们（免受人工智能的影响）。如果没有，我就看不出我们如何生存下去。”他说OpenAI的新文字转视频工具Sora让他推迟了工作室的计划，他说他的项目“因为Sora和我看到的东西而搁置了”。</p>
<p>Sora是一个新的工具，可以生成长达一分钟的视频。用户只需输入提示，软件就会创建一个视频。它还可以根据一张照片创建视频。Sora的名称来自日语单词“天空”，纽约时报说这是为了展示工具的“无限创意潜力”。泰勒·佩里表示，他理解人工智能在电影制作中的有用性，但他担心会导致就业岗位减少。他说：“这让我非常担心行业中的所有人。我立刻开始考虑到受到影响的行业中的所有人，包括演员和编辑。”他补充道：“我认为这将触及我们行业的每个角落。”</p>
<blockquote>
<p>注：我只想到《浪客剑心》里那句台词：“创造时代的并不是刀，而是使用刀的人。”</p></blockquote>
<h2 id="tip">Tip</h2>
<p>git clone fatal：发送请求时出错&hellip;</p>
<p>在使用<code>git clone</code>项目时，提示以下信息，然后一直需要提示输入用户名和密码。</p>
<pre tabindex="0"><code>fatal: 发送请求时出错。
fatal: 服务器提交了协议冲突. Section=ResponseStatusLine
</code></pre><p>从上面可知，应该是git配置上面出现了问题，所以就打算将<code>git</code>配置初始化，通过以下命令查看<code>git</code>配置文件所在位置，并将所有<code>.gitconfig</code>文件全都删除。</p>
<pre tabindex="0"><code>git config --list --show-origin
</code></pre><p>重新打开<code>Git Bash Here</code>，使用以下命令，然后配置<code>Git</code>在本地存储凭据信息，以便自动记住用户名和密码，避免每次进行<code>Git</code>操作时都需要输入凭据信息。</p>
<pre tabindex="0"><code>git config --global credential.helper store
</code></pre><p>然后只要输入一次用户名和密码，后续操作就都不需要输入了。</p>
<h2 id="share">Share</h2>
<p><a href="https://cloud.tencent.com/developer/article/1873011">研发效能度量实践者指南（万字长文）-腾讯云开发者社区-腾讯云 (tencent.com)</a></p>
<ol>
<li>“我虽然没有功劳，但是我也有苦劳。” 大部分人可能只关注自己的付出，但并不关心付出所获得的实际效果。作为管理者应该为“苦劳鼓掌，为功劳付钱”。而功劳和苦劳的体现也需要借助客观的度量数据来体现，否则团队中的成员会逐渐陷入碌碌无为的窘境。</li>
<li>管理者往往会把目标拆解为可度量的指标。但是，目标和指标常常并不是简单的全局与局部的关系。目标的拆解过程看起来很顺畅，是那么地理所当然，但是当把拆解完的指标合并起来的的时候，结果往往让人哭笑不得。有一个笑话说的是，“你问人工智能，我要找一个女朋友，像安·海瑟薇一样的大眼睛，像朱莉娅·罗伯茨一样的大嘴，喜爱运动，陆上运动、水上运动都会。人工智能就根据这几个指标给出了母青蛙的答案”。所以，指标和目标常常并不是充分必要的关系。</li>
<li>指标是为了实现目标的，但是在实践过程中，指标很多时候却是与目标为敌的。管理者常常把目标拆解为指标，时间久了以后，他就只知道指标，而忘了背后更重要的目标。如果目标是林，那么指标就是木，时间久了就是只见树木，不见森林。这个时候忘记了目标是什么的管理者就会变得非常短视。那些不懂数据的人很糟糕，而最最糟糕的人是那些只看数字的人。在福特汽车的发展史上，有一段至暗时期。那些实践经验丰富，但是没有上过商学院的的老一辈管理层被干掉，取而代之的名校管理背景的数据分析师，公司试图通过精细化的数字管理来实现业务的增长。由于这些数据分析师并不熟悉业务，所以就只能看度量数据，越是不懂业务就越依赖度量数据来做决策，最后使整个公司陷入了泥潭。软件研发也有类似的尴尬，为了更好的代码质量，所以就制定了严格的代码测试覆盖率要求。时间一久，大家都机械性的追求这个指标，而忘记了当时设立这个指标的初衷，于是就出现了高覆盖率的大量单元测试中没有断言这样尴尬的局面。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 19</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-19/</link>
      <pubDate>Sat, 02 Mar 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-19/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/image-smoother/&#34;&gt;661. 图片平滑器&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;图像平滑器&lt;/strong&gt; 是大小为 &lt;code&gt;3 x 3&lt;/code&gt; 的过滤器，用于对图像的每个单元格平滑处理，平滑处理后单元格的值为该单元格的平均灰度。&lt;/p&gt;
&lt;p&gt;每个单元格的 &lt;strong&gt;平均灰度&lt;/strong&gt; 定义为：该单元格自身及其周围的 8 个单元格的平均值，结果需向下取整。（即，需要计算蓝色平滑器中 9 个单元格的平均值）。&lt;/p&gt;
&lt;p&gt;如果一个单元格周围存在单元格缺失的情况，则计算平均灰度时不考虑缺失的单元格（即，需要计算红色平滑器中 4 个单元格的平均值）。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2021/05/03/smoother-grid.jpg&#34;&gt;&lt;/p&gt;
&lt;p&gt;给你一个表示图像灰度的 &lt;code&gt;m x n&lt;/code&gt; 整数矩阵 &lt;code&gt;img&lt;/code&gt; ，返回对图像的每个单元格平滑处理后的图像 。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;示例 1:&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2021/05/03/smooth-grid.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;img&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;对于点&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;/&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mf&#34;&gt;0.75&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;对于点&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;/&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mf&#34;&gt;0.83333333&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;对于点&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;/&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;平均&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mf&#34;&gt;0.88888889&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;imageSmoother&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;img&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;img&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;img&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;fill&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;map&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(()&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;fill&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;));&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;calculate&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;calculate&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;totalValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;m&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;n&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;totalValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;img&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;totalValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，代码初始化了两个变量 &lt;code&gt;m&lt;/code&gt; 和 &lt;code&gt;n&lt;/code&gt;，分别表示输入二维数组 &lt;code&gt;img&lt;/code&gt; 的行数和列数。然后，创建了一个与 &lt;code&gt;img&lt;/code&gt; 相同大小的二维数组 &lt;code&gt;result&lt;/code&gt;，用于存储平滑后的图像。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/image-smoother/">661. 图片平滑器</a></p>
<p><strong>图像平滑器</strong> 是大小为 <code>3 x 3</code> 的过滤器，用于对图像的每个单元格平滑处理，平滑处理后单元格的值为该单元格的平均灰度。</p>
<p>每个单元格的 <strong>平均灰度</strong> 定义为：该单元格自身及其周围的 8 个单元格的平均值，结果需向下取整。（即，需要计算蓝色平滑器中 9 个单元格的平均值）。</p>
<p>如果一个单元格周围存在单元格缺失的情况，则计算平均灰度时不考虑缺失的单元格（即，需要计算红色平滑器中 4 个单元格的平均值）。</p>
<p><img loading="lazy" src="https://assets.leetcode.com/uploads/2021/05/03/smoother-grid.jpg"></p>
<p>给你一个表示图像灰度的 <code>m x n</code> 整数矩阵 <code>img</code> ，返回对图像的每个单元格平滑处理后的图像 。</p>
<p><strong>示例 1:</strong></p>
<p><img loading="lazy" src="https://assets.leetcode.com/uploads/2021/05/03/smooth-grid.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span><span class="nx">img</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">],[</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span><span class="p">[[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">],</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="mi">0</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="o">:</span>
</span></span><span class="line"><span class="cl"><span class="nx">对于点</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">)</span><span class="o">:</span> <span class="nx">平均</span><span class="p">(</span><span class="mi">3</span><span class="o">/</span><span class="mi">4</span><span class="p">)</span> <span class="o">=</span> <span class="nx">平均</span><span class="p">(</span><span class="mf">0.75</span><span class="p">)</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl"><span class="nx">对于点</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">),</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">),</span> <span class="p">(</span><span class="mi">2</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span><span class="o">:</span> <span class="nx">平均</span><span class="p">(</span><span class="mi">5</span><span class="o">/</span><span class="mi">6</span><span class="p">)</span> <span class="o">=</span> <span class="nx">平均</span><span class="p">(</span><span class="mf">0.83333333</span><span class="p">)</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl"><span class="nx">对于点</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)</span><span class="o">:</span> <span class="nx">平均</span><span class="p">(</span><span class="mi">8</span><span class="o">/</span><span class="mi">9</span><span class="p">)</span> <span class="o">=</span> <span class="nx">平均</span><span class="p">(</span><span class="mf">0.88888889</span><span class="p">)</span> <span class="o">=</span> <span class="mi">0</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">imageSmoother</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">img</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">m</span> <span class="o">=</span> <span class="nx">img</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">n</span> <span class="o">=</span> <span class="nx">img</span><span class="p">[</span><span class="mi">0</span><span class="p">].</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">result</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">m</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">).</span><span class="nx">map</span><span class="p">(()</span> <span class="p">=&gt;</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="nx">n</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="mi">0</span><span class="p">));</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">m</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">n</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">result</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="o">=</span> <span class="nx">calculate</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">j</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">calculate</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">totalValue</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">x</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span> <span class="nx">x</span> <span class="o">&lt;=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">m</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span> <span class="nx">x</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">y</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">j</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span> <span class="nx">y</span> <span class="o">&lt;=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">n</span> <span class="o">-</span> <span class="mi">1</span><span class="p">);</span> <span class="nx">y</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">totalValue</span> <span class="o">+=</span> <span class="nx">img</span><span class="p">[</span><span class="nx">x</span><span class="p">][</span><span class="nx">y</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">                <span class="nx">count</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">totalValue</span> <span class="o">/</span> <span class="nx">count</span> <span class="o">&gt;&gt;</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，代码初始化了两个变量 <code>m</code> 和 <code>n</code>，分别表示输入二维数组 <code>img</code> 的行数和列数。然后，创建了一个与 <code>img</code> 相同大小的二维数组 <code>result</code>，用于存储平滑后的图像。</p>
<p>接下来，使用两个嵌套的循环遍历 <code>img</code> 中的每个像素，通过调用内部函数 <code>calculate</code> 计算对应位置的平均值，并将结果存储到 <code>result</code> 数组中。</p>
<p><code>calculate</code> 函数用于计算给定位置 <code>(i, j)</code> 像素及其周围像素的平均值。它首先定义了两个变量 <code>totalValue</code> 和 <code>count</code>，分别用于记录像素值的总和和像素数量。</p>
<p>然后，使用两个嵌套的循环遍历 <code>(i, j)</code> 周围的像素。通过调用 <code>Math.max</code> 和 <code>Math.min</code> 函数来确保不越界，遍历的范围是 <code>(i-1, j-1)</code> 到 <code>(i+1, j+1)</code>。在每次遍历中，将遍历到的像素值累加到 <code>totalValue</code> 中，并增加 <code>count</code> 的值。</p>
<p>最后，返回 <code>totalValue / count</code> 的整数部分，使用位右移运算符 <code>&gt;&gt; 0</code> 实现。这样就得到了 <code>(i, j)</code> 像素及其周围像素的平均值。</p>
<p>整个过程在外部循环中进行，完成后返回平滑后的图像 <code>result</code>。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2403/240304-weighing-airline-passengers.html">Airline starts to weigh luggage AND passengers - Breaking News English Lesson</a></p>
<p>芬兰国家航空公司芬兰航空已经开始在从首都赫尔辛基出发的航班上对乘客进行称重。这次称重是基于自愿的原则，并且完全匿名。公司发言人表示，这项新举措是为了确保航班安全标准得到遵守。他说，任何一架飞机都不应超过安全起降的最大重量限制。这个重量包括飞机本身、燃料、托运行李和货物、机上餐饮品、水箱和乘客的重量。芬兰航空表示，航空公司无法准确知道乘客和他们的随身行李的具体重量，因此他们必须依赖航空当局提供的平均估计值。</p>
<p>自愿参加称重的乘客将在赫尔辛基机场的登机口站上称重秤。芬兰航空官员最初担心客户会强烈反对，因为体重是一个非常私人的问题。然而，在测试的第一个星期，超过1000名乘客同意接受称重。公司表示：“我们希望能够有足够多的志愿者，包括商务和休闲旅行者，以便我们可以获得尽可能准确的信息来进行重要的平衡计算。”它补充说：“目前为止，我们的客户对此反应非常积极。”一位官员表示，旅客可以“放心”，他们的体重不会与个人数据关联起来，可以“安心”。</p>
<h2 id="tip">Tip</h2>
<p>超长<code>String</code>转<code>Number</code>精度丢失问题</p>
<p>在实现算法题时，遇到最后数字相加的值和预期的值不一致，因为使用的<code>Number(str)</code>方法，有一定的区间限制，会出现精度丢失。修改为使用<code>BigInt</code>实现，可以表示任意大的整数，但是<code>BigInt</code>在表示时，后缀会有一个<code>n</code>，这样的话就没办法直接和<code>Number</code>类型的数字进行运算，只能<code>Number</code>转为<code>BigInt</code>来运算，拿到结果之后再进行下一步处理。</p>
<h2 id="share">Share</h2>
<p><a href="https://www.infoq.cn/article/Ly4avjCIkBp2gF3eqrEK">OpenAI也搞“年龄歧视”？奥特曼对话盖茨爆料：员工整体年龄偏大，是个坏兆头-InfoQ精选文章</a></p>
<p><strong>山姆·奥特曼:</strong> 大家一定经常让你提点建议，那你一般会怎么说？</p>
<p><strong>比尔·盖茨:</strong> 我觉得这世界上有很多不同形式的人才。在我的职业生涯之初，我只重视纯粹的智商，类似于工程技术的灵性。当然，这个逻辑在财务和销售领域也有体现。但事实证明这是不对的。能建立起强大团队的技能组合才是重中之重。能引导人们思考、找到想要解决的问题、建立一支融合不同人才的队伍，才是最重要的能力所在。所以我想告诉年轻人，数学和科学能力当然很重要，但如果你真想成就一番事业，那么前面说的这种才能组合必不可少。</p>
<p>你呢，你会给出什么样的建议？</p>
<p><strong>山姆·奥特曼:</strong> 我比较关注大多数人对于风险的错误理解。大家往往害怕放弃自己当前这份轻松愉快的工作，不敢奔赴自己真正想做的事情。但实际上，如果始终止步不前，那他们最终回顾一生，只会感叹自己从没有投入过、没有创办自己想象中的企业、也没试着成为一名 AI 研究者。我觉得这才是最大的风险，是让整个人生沦于平庸的风险。</p>
<p>正因为如此，我们应该明确自己的目标，同时积极询问其他人需要什么，这就是良好的开端。很多人都在以自己不想的方式虚耗时间，而我给出的建议就是试着以积极的方式解决这个问题。</p>
<p><strong>比尔·盖茨:</strong> 确实，让人们从事一份自己有成就感、满足感的工作，往往能够迸发出他们自己都难以想象的力量。</p>
<p><strong>山姆·奥特曼:</strong> 绝对是这样。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 18</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-18/</link>
      <pubDate>Wed, 28 Feb 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-18/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/max-consecutive-ones/&#34;&gt;485. 最大连续 1 的个数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个二进制数组 &lt;code&gt;nums&lt;/code&gt; ， 计算其中最大连续 &lt;code&gt;1&lt;/code&gt; 的个数。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;开头的两位和最后的三位都是连续&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;所以最大连续&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;的个数是&lt;/span&gt; &lt;span class=&#34;mf&#34;&gt;3.&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;findMaxConsecutiveOnes&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 数组转换为字符串
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;join&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果不存在0，则直接返回数组长度即可
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果不存在1，则直接返回0
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;indexOf&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;1&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 通过0切割为各字符串数组
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;join&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;0&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 通过比较字符长度，从长到短排序，然后获取索引为0，即可获取最大连续1的个数的值
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sort&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先讲nums数组转换为字符串，然后通过0切割成不同长度全为1的字符串数组，本来一开始打算使用Math.max(&amp;hellip;arr)实现的，但是因为Math.max()在执行时，会转换为数字进行比较，而且是number类型，在转换超长字符串111时，丢失精度，最大只能返回8，无法满足解题需求。所以，调整为使用sort来实现，当b.length - a.length时，按照字符串长度从长到短进行排序；当a.length - b.length时，按照字符串长度从短到长进行排序，然后通过索引0获取最大值maxValue，至此，maxValue.length即为所求值。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2402/240229-cold-weather-exercise.html&#34;&gt;Cold weather exercise burns more calories&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;每个人都知道锻炼对保持健康是必不可少的。它可以降低患心脏病的风险，并帮助我们保持健康的体重。它还能减轻压力，让我们更快乐。医生说，在寒冷的天气里锻炼对我们更有好处。在寒冷或寒冷的天气里慢跑甚至游泳对我们的身心健康有额外的好处。原因是寒冷给我们的心脏一个更有活力的锻炼。纽约特殊外科医院的安吉拉·佩德约诺维奇医生解释了原因。她说:“在寒冷的天气里，你的心脏必须更加努力地将血液输送到全身。随着时间的推移，这有助于提高你的耐力。”&lt;/p&gt;
&lt;p&gt;佩德约诺维奇博士说，寒冷天气的锻炼可以帮助身体以更快的速度燃烧卡路里。她说:“因为你的身体需要更努力地工作来保持核心温度，所以在寒冷的环境中锻炼实际上会增加卡路里的燃烧。”在低温下进行体育锻炼可以促进我们的新陈代谢，从而帮助我们减肥。在寒冷中，我们的新陈代谢减慢，所以我们可以保存脂肪和保暖。另一个好处是，在自然光下有助于减轻我们的压力。这对于患有季节性情感障碍(S.A.D.)的人来说尤其如此。这是一种由冬季白昼变短、变暗引起的抑郁症。这在远离赤道的人身上更为常见。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;注：所以为什么说减肥最佳运动方式是游泳，一方面是上面的原因，另一方面是因为不伤膝盖，但是游完泳很容易饿，这点就很需要克制了，很多人就死在这点上哈哈哈。但是，我游了一两个月之后，发现游泳不一定就是最好的，因为水的阻力，相比慢跑，还是很难持续游起来的，没有强度心率没有达标，燃脂效率很低，效果就不够明显了。有一说一，蝶泳、自由泳这些真是难学，还是慢慢来吧。叔本华也说过保持身体健康的方式，里面就有“每日需运动两小时”和“经常洗冷水浴”。好长一段时间，因为嫌太麻烦了，冬天也是洗冷水澡的，但前提是水量要大，三下五除二就洗完了，不然真受不了。不过这些年都懈怠了，有时也觉得没必要刻意过得苦哈哈的，差不多就行了。不过，不要总是让自己身体和心态处于太安逸的环境，总归是对的。&lt;/p&gt;&lt;/blockquote&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;为什么&lt;code&gt;Math.max(...[ &#39;&#39;, &#39;&#39;,&#39;&#39; ])&lt;/code&gt;的值为0？&lt;/p&gt;
&lt;p&gt;这行代码使用扩展运算符将数组 &lt;code&gt;[&amp;quot;&amp;quot;, &amp;quot;&amp;quot;, &amp;quot;&amp;quot;, &amp;quot;&amp;quot;]&lt;/code&gt; 展开成参数列表，相当于 &lt;code&gt;Math.max(&amp;quot;&amp;quot;, &amp;quot;&amp;quot;, &amp;quot;&amp;quot;, &amp;quot;&amp;quot;)&lt;/code&gt;。由于 &lt;code&gt;Math.max()&lt;/code&gt; 方法会将所有参数转换为数字再比较大小，空字符串会被转换为数字 0，因此最终比较的参数为 &lt;code&gt;Math.max(0, 0, 0, 0)&lt;/code&gt;。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/max-consecutive-ones/">485. 最大连续 1 的个数</a></p>
<p>给定一个二进制数组 <code>nums</code> ， 计算其中最大连续 <code>1</code> 的个数。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">开头的两位和最后的三位都是连续</span> <span class="mi">1</span> <span class="err">，</span><span class="nx">所以最大连续</span> <span class="mi">1</span> <span class="nx">的个数是</span> <span class="mf">3.</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">findMaxConsecutiveOnes</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 数组转换为字符串
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">str</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果不存在0，则直接返回数组长度即可
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="s1">&#39;0&#39;</span><span class="p">)</span> <span class="o">===</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果不存在1，则直接返回0
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">indexOf</span><span class="p">(</span><span class="s1">&#39;1&#39;</span><span class="p">)</span> <span class="o">===</span> <span class="o">-</span><span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 通过0切割为各字符串数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">arr</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">join</span><span class="p">(</span><span class="s1">&#39;&#39;</span><span class="p">).</span><span class="nx">split</span><span class="p">(</span><span class="s1">&#39;0&#39;</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 通过比较字符长度，从长到短排序，然后获取索引为0，即可获取最大连续1的个数的值
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kr">const</span> <span class="nx">maxValue</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">sort</span><span class="p">(</span><span class="kd">function</span> <span class="p">(</span><span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">b</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">a</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="p">})[</span><span class="mi">0</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">maxValue</span><span class="p">.</span><span class="nx">length</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先讲nums数组转换为字符串，然后通过0切割成不同长度全为1的字符串数组，本来一开始打算使用Math.max(&hellip;arr)实现的，但是因为Math.max()在执行时，会转换为数字进行比较，而且是number类型，在转换超长字符串111时，丢失精度，最大只能返回8，无法满足解题需求。所以，调整为使用sort来实现，当b.length - a.length时，按照字符串长度从长到短进行排序；当a.length - b.length时，按照字符串长度从短到长进行排序，然后通过索引0获取最大值maxValue，至此，maxValue.length即为所求值。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2402/240229-cold-weather-exercise.html">Cold weather exercise burns more calories</a></p>
<p>每个人都知道锻炼对保持健康是必不可少的。它可以降低患心脏病的风险，并帮助我们保持健康的体重。它还能减轻压力，让我们更快乐。医生说，在寒冷的天气里锻炼对我们更有好处。在寒冷或寒冷的天气里慢跑甚至游泳对我们的身心健康有额外的好处。原因是寒冷给我们的心脏一个更有活力的锻炼。纽约特殊外科医院的安吉拉·佩德约诺维奇医生解释了原因。她说:“在寒冷的天气里，你的心脏必须更加努力地将血液输送到全身。随着时间的推移，这有助于提高你的耐力。”</p>
<p>佩德约诺维奇博士说，寒冷天气的锻炼可以帮助身体以更快的速度燃烧卡路里。她说:“因为你的身体需要更努力地工作来保持核心温度，所以在寒冷的环境中锻炼实际上会增加卡路里的燃烧。”在低温下进行体育锻炼可以促进我们的新陈代谢，从而帮助我们减肥。在寒冷中，我们的新陈代谢减慢，所以我们可以保存脂肪和保暖。另一个好处是，在自然光下有助于减轻我们的压力。这对于患有季节性情感障碍(S.A.D.)的人来说尤其如此。这是一种由冬季白昼变短、变暗引起的抑郁症。这在远离赤道的人身上更为常见。</p>
<blockquote>
<p>注：所以为什么说减肥最佳运动方式是游泳，一方面是上面的原因，另一方面是因为不伤膝盖，但是游完泳很容易饿，这点就很需要克制了，很多人就死在这点上哈哈哈。但是，我游了一两个月之后，发现游泳不一定就是最好的，因为水的阻力，相比慢跑，还是很难持续游起来的，没有强度心率没有达标，燃脂效率很低，效果就不够明显了。有一说一，蝶泳、自由泳这些真是难学，还是慢慢来吧。叔本华也说过保持身体健康的方式，里面就有“每日需运动两小时”和“经常洗冷水浴”。好长一段时间，因为嫌太麻烦了，冬天也是洗冷水澡的，但前提是水量要大，三下五除二就洗完了，不然真受不了。不过这些年都懈怠了，有时也觉得没必要刻意过得苦哈哈的，差不多就行了。不过，不要总是让自己身体和心态处于太安逸的环境，总归是对的。</p></blockquote>
<h2 id="tip">Tip</h2>
<p>为什么<code>Math.max(...[ '', '','' ])</code>的值为0？</p>
<p>这行代码使用扩展运算符将数组 <code>[&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;]</code> 展开成参数列表，相当于 <code>Math.max(&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;)</code>。由于 <code>Math.max()</code> 方法会将所有参数转换为数字再比较大小，空字符串会被转换为数字 0，因此最终比较的参数为 <code>Math.max(0, 0, 0, 0)</code>。</p>
<p>在 JavaScript 中，空字符串会被转换为数字 0 是因为在进行字符串转换为数字的过程中，如果字符串包含非数字字符（除了符号、小数点等特殊字符），则会被转换为数字 0。当 JavaScript 引擎在转换字符串为数字时，会按照以下规则进行处理：</p>
<ol>
<li>如果字符串中包含非数字字符（除了符号、小数点等特殊字符），则转换结果为 NaN（Not-a-Number）。</li>
<li>如果字符串为空字符串或只包含空格字符，则转换结果为数字 0。</li>
<li>如果字符串表示整数或浮点数形式的数字（例如 &ldquo;123&rdquo;、&ldquo;3.14&rdquo;），则会按照对应的数字进行转换。</li>
</ol>
<p>因此，空字符串会被转换为数字 0 是因为它不包含任何数字字符，符合规则2的转换规则。</p>
<h2 id="share">Share</h2>
<p><a href="https://www.infoq.cn/article/AwaLR90KhsuAIwgamEvo">代码人生攻略：程序员们如何为自己编织一份明朗未来？— InfoQ精选文章</a></p>
<p>主要分享了对大模型时代的变革、生成式AI对各技术领域的影响、大模型时代。程序员的“生存法则”变了吗？、巨头碾压，大模型小创企业有核心壁垒吗？从事开源项目的收益问题、互联网公司是否还需要CTO等问题的讨论，值得一看。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 17</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-17/</link>
      <pubDate>Mon, 26 Feb 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-17/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/add-to-array-form-of-integer/&#34;&gt;989. 数组形式的整数加法&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;整数的 &lt;strong&gt;数组形式&lt;/strong&gt; &lt;code&gt;num&lt;/code&gt; 是按照从左到右的顺序表示其数字的数组。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;例如，对于 &lt;code&gt;num = 1321&lt;/code&gt; ，数组形式是 &lt;code&gt;[1,3,2,1]&lt;/code&gt; 。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;给定 &lt;code&gt;num&lt;/code&gt; ，整数的 &lt;strong&gt;数组形式&lt;/strong&gt; ，和整数 &lt;code&gt;k&lt;/code&gt; ，返回 &lt;em&gt;整数 &lt;code&gt;num + k&lt;/code&gt; 的 &lt;strong&gt;数组形式&lt;/strong&gt;&lt;/em&gt; 。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;34&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1200&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;34&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1234&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;addToArrayForm&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;numStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;outStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;outNum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;numStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;numStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;num&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;outStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;BigInt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;numStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;BigInt&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;outStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;outStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;n&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;outNum&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;outStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;outNum&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，先将num数组转为数字，然后再和k相加，最后再次遍历为数组即可。在实现过程中遇到Number转换超长String会出现精度丢失问题，使用BigInt实现，但是因为BigInt格式后缀会有n，所以在转换为数组时，判断去掉n。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2402/240226-decimal-point.html&#34;&gt;Decimal point 150 years older than thought&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;一项新发现令全球数学家兴奋不已。最近出土的文件显示，生活在威尼斯的商人乔瓦尼·比安奇尼(Giovanni Bianchini)在14世纪40年代的记录中使用了一个小数点。历史学家对这一重大发现给予了高度评价，因为它意味着小数点的使用比之前认为的要早150年。比安奇尼是一位敏锐的天文学家，他对自己观测到的天象进行了详细标注，并提供了基于恒星和行星排列计算占星术预测给威尼斯人民。格伦·范·布鲁梅伦博士注意到比安奇尼在1441年至1450年间一篇论文中使用了小数点。如今，小数点已成为我们生活中不可或缺的一部分，并且看起来已经被使用了几千年。历史学家指出，在20世纪90年代，伊斯兰世界就开始采用某种形式上等同于小数点功能的符号。很可能是由于比安奇尼曾去过中东并受到那里学者们影响所致，这些学者在许多数学概念形成方面扮演着关键角色。其他历史证据表明，在12世纪中国知识分子也采用过某种形式上等同于小数点功能的符号。直到1593年才有确切记录显示最早明确使用小数点系统，当时德国数学家克里斯托夫·克拉维斯在其天文研究中应用了该系统。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;在windows环境使用git安装nvm&lt;/p&gt;
&lt;p&gt;因公司电脑做了软件安装限制，导致不能使用.exe方式配置nvm工具，但是平时项目开发中，经常需对老项目使用不同的node版本，所以这个工具还是很重要的。确定研究一下有没有其他方式配置nvm，在github上看到有&lt;a href=&#34;https://github.com/nvm-sh/nvm?tab=readme-ov-file#git-install&#34;&gt;Git Install&lt;/a&gt;章节，用法是要git clone项目源码下来，然后配置，但是现在github一直clone不了项目，所以就去gitee上看了一下，发现有这个仓库&lt;a href=&#34;https://gitee.com/RubyMetric/nvm-cn?_from=gitee_search&#34;&gt;nvm-cn: 🧊 nvm国内安装工具 (gitee.com)&lt;/a&gt;，用法很简单，只需要在&lt;code&gt;Git Bash Here&lt;/code&gt;上使用以下命令即可安装：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/add-to-array-form-of-integer/">989. 数组形式的整数加法</a></p>
<p>整数的 <strong>数组形式</strong> <code>num</code> 是按照从左到右的顺序表示其数字的数组。</p>
<ul>
<li>例如，对于 <code>num = 1321</code> ，数组形式是 <code>[1,3,2,1]</code> 。</li>
</ul>
<p>给定 <code>num</code> ，整数的 <strong>数组形式</strong> ，和整数 <code>k</code> ，返回 <em>整数 <code>num + k</code> 的 <strong>数组形式</strong></em> 。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">num</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">],</span> <span class="nx">k</span> <span class="o">=</span> <span class="mi">34</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="mi">1200</span> <span class="o">+</span> <span class="mi">34</span> <span class="o">=</span> <span class="mi">1234</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">addToArrayForm</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">num</span><span class="p">,</span> <span class="nx">k</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">numStr</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">outStr</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">outNum</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">num</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">numStr</span> <span class="o">=</span> <span class="nx">numStr</span> <span class="o">+</span> <span class="nx">num</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="nx">outStr</span> <span class="o">=</span> <span class="nx">BigInt</span><span class="p">(</span><span class="nx">numStr</span><span class="p">)</span> <span class="o">+</span> <span class="nx">BigInt</span><span class="p">(</span><span class="nx">k</span><span class="p">)</span> <span class="o">+</span> <span class="s1">&#39;&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">outStr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">outStr</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">!==</span> <span class="s1">&#39;n&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">outNum</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nb">Number</span><span class="p">(</span><span class="nx">outStr</span><span class="p">[</span><span class="nx">i</span><span class="p">]))</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">outNum</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，先将num数组转为数字，然后再和k相加，最后再次遍历为数组即可。在实现过程中遇到Number转换超长String会出现精度丢失问题，使用BigInt实现，但是因为BigInt格式后缀会有n，所以在转换为数组时，判断去掉n。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2402/240226-decimal-point.html">Decimal point 150 years older than thought</a></p>
<p>一项新发现令全球数学家兴奋不已。最近出土的文件显示，生活在威尼斯的商人乔瓦尼·比安奇尼(Giovanni Bianchini)在14世纪40年代的记录中使用了一个小数点。历史学家对这一重大发现给予了高度评价，因为它意味着小数点的使用比之前认为的要早150年。比安奇尼是一位敏锐的天文学家，他对自己观测到的天象进行了详细标注，并提供了基于恒星和行星排列计算占星术预测给威尼斯人民。格伦·范·布鲁梅伦博士注意到比安奇尼在1441年至1450年间一篇论文中使用了小数点。如今，小数点已成为我们生活中不可或缺的一部分，并且看起来已经被使用了几千年。历史学家指出，在20世纪90年代，伊斯兰世界就开始采用某种形式上等同于小数点功能的符号。很可能是由于比安奇尼曾去过中东并受到那里学者们影响所致，这些学者在许多数学概念形成方面扮演着关键角色。其他历史证据表明，在12世纪中国知识分子也采用过某种形式上等同于小数点功能的符号。直到1593年才有确切记录显示最早明确使用小数点系统，当时德国数学家克里斯托夫·克拉维斯在其天文研究中应用了该系统。</p>
<h2 id="tip">Tip</h2>
<p>在windows环境使用git安装nvm</p>
<p>因公司电脑做了软件安装限制，导致不能使用.exe方式配置nvm工具，但是平时项目开发中，经常需对老项目使用不同的node版本，所以这个工具还是很重要的。确定研究一下有没有其他方式配置nvm，在github上看到有<a href="https://github.com/nvm-sh/nvm?tab=readme-ov-file#git-install">Git Install</a>章节，用法是要git clone项目源码下来，然后配置，但是现在github一直clone不了项目，所以就去gitee上看了一下，发现有这个仓库<a href="https://gitee.com/RubyMetric/nvm-cn?_from=gitee_search">nvm-cn: 🧊 nvm国内安装工具 (gitee.com)</a>，用法很简单，只需要在<code>Git Bash Here</code>上使用以下命令即可安装：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">bash -c <span class="s2">&#34;</span><span class="k">$(</span>curl -fsSL https://gitee.com/RubyMetric/nvm-cn/raw/main/install.sh<span class="k">)</span><span class="s2">&#34;</span>
</span></span></code></pre></div><p>然后验证一下，使用命令<code>nvm ls</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402011112106.png"></p>
<p>使用<code>nvm</code>命令时只能在<code>Git Bash Here</code>上使用，在<code>Windows PowerShell</code>和<code>CMD</code>命令窗口是使用不了的。</p>
<p>指定默认的Node版本，使用一下命令：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">nvm</span> <span class="nx">alias</span> <span class="k">default</span> <span class="mf">16.14</span><span class="p">.</span><span class="mi">2</span>
</span></span></code></pre></div><h2 id="share">Share</h2>
<p>技术的发展是永无止境的，脚踏实地才能遥望星空。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 16</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-16/</link>
      <pubDate>Fri, 02 Feb 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-16/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/available-captures-for-rook/&#34;&gt;999. 可以被一步捕获的棋子数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;在一个 8 x 8 的棋盘上，有一个白色的车（&lt;code&gt;Rook&lt;/code&gt;），用字符 &lt;code&gt;&#39;R&#39;&lt;/code&gt; 表示。棋盘上还可能存在空方块，白色的象（&lt;code&gt;Bishop&lt;/code&gt;）以及黑色的卒（&lt;code&gt;pawn&lt;/code&gt;），分别用字符 &lt;code&gt;&#39;.&#39;&lt;/code&gt;，&lt;code&gt;&#39;B&#39;&lt;/code&gt; 和 &lt;code&gt;&#39;p&#39;&lt;/code&gt; 表示。不难看出，大写字符表示的是白棋，小写字符表示的是黑棋。&lt;/p&gt;
&lt;p&gt;车按国际象棋中的规则移动。东，西，南，北四个基本方向任选其一，然后一直向选定的方向移动，直到满足下列四个条件之一：&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;棋手选择主动停下来。&lt;/li&gt;
&lt;li&gt;棋子因到达棋盘的边缘而停下。&lt;/li&gt;
&lt;li&gt;棋子移动到某一方格来捕获位于该方格上敌方（黑色）的卒，停在该方格内。&lt;/li&gt;
&lt;li&gt;车不能进入/越过已经放有其他友方棋子（白色的象）的方格，停在友方棋子前。&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;你现在可以控制车移动一次，请你统计有多少敌方的卒处于你的捕获范围内（即，可以被一步捕获的棋子数）。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/02/23/1253_example_1_improved.PNG&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;p&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;R&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;p&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;p&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;.&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;在本例中&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;车能够捕获所有的卒&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;numRookCaptures&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 定义标记outer，用于break中止外层for循环，结束获取R位置的流程。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;outer&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;R&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;outer&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;B&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;p&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;B&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;p&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;B&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;p&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;B&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;board&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;p&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/available-captures-for-rook/">999. 可以被一步捕获的棋子数</a></p>
<p>在一个 8 x 8 的棋盘上，有一个白色的车（<code>Rook</code>），用字符 <code>'R'</code> 表示。棋盘上还可能存在空方块，白色的象（<code>Bishop</code>）以及黑色的卒（<code>pawn</code>），分别用字符 <code>'.'</code>，<code>'B'</code> 和 <code>'p'</code> 表示。不难看出，大写字符表示的是白棋，小写字符表示的是黑棋。</p>
<p>车按国际象棋中的规则移动。东，西，南，北四个基本方向任选其一，然后一直向选定的方向移动，直到满足下列四个条件之一：</p>
<ul>
<li>棋手选择主动停下来。</li>
<li>棋子因到达棋盘的边缘而停下。</li>
<li>棋子移动到某一方格来捕获位于该方格上敌方（黑色）的卒，停在该方格内。</li>
<li>车不能进入/越过已经放有其他友方棋子（白色的象）的方格，停在友方棋子前。</li>
</ul>
<p>你现在可以控制车移动一次，请你统计有多少敌方的卒处于你的捕获范围内（即，可以被一步捕获的棋子数）。</p>
<p><img loading="lazy" src="https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2019/02/23/1253_example_1_improved.PNG"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="p">[</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;p&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;R&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;p&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;p&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">],</span>
</span></span><span class="line"><span class="cl"><span class="p">[</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">,</span><span class="s2">&#34;.&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">在本例中</span><span class="err">，</span><span class="nx">车能够捕获所有的卒</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">numRookCaptures</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">board</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">x</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">y</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 定义标记outer，用于break中止外层for循环，结束获取R位置的流程。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">outer</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">board</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">]</span> <span class="o">==</span> <span class="s1">&#39;R&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">x</span> <span class="o">=</span> <span class="nx">j</span>
</span></span><span class="line"><span class="cl">                <span class="nx">y</span> <span class="o">=</span> <span class="nx">i</span>
</span></span><span class="line"><span class="cl">                <span class="k">break</span> <span class="nx">outer</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">x</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">y</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;B&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">y</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;p&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">x</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="mi">8</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">y</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;B&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">y</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;p&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">y</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">x</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;B&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">x</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;p&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">y</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="mi">8</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">x</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;B&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">board</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">x</span><span class="p">]</span> <span class="o">===</span> <span class="s1">&#39;p&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">count</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">count</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，我们需要找到<code>R</code>的位置，然后从该位置开始，依次向上、下、左、右四个方向遍历。我们可以定义一个变量<code>count</code>来记录出现<code>p</code>的有效次数。在遍历过程中，我们需要判断是否存在<code>B</code>，如果存在，就停止该方向的遍历。如果遇到有效的<code>p</code>，就将计数<code>count</code>加1，并停止该方向的遍历。最终，返回<code>count</code>的值，即为题目所求的次数。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401311336693.png"></p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2401/240122-fire-ants.html">Deadly fire ants spreading across Australia</a></p>
<p>澳大利亚独特的生态系统正受到一种入侵和致命物种——红火蚁的威胁。这种微小的蚂蚁原产于南美洲，但在过去一个世纪里已经传播到世界各地。它是世界上最具入侵性的生物之一。它对农作物和农业用地造成了广泛的破坏。它还杀死了大量的本地昆虫和其他动物，包括牲畜。蚂蚁的剧痛和毒液叮咬会导致人类严重的过敏反应。它还可能导致致命的过敏性休克。农业部长的一位女发言人称火蚁是“一种可怕的入侵性超级害虫，会造成严重的社会、经济和环境危害”。</p>
<p>2001年，红火蚁首次在澳大利亚被发现。自那时以来，它们在很大程度上被限制在昆士兰州内。然而，澳大利亚入侵物种委员会(ISC)表示，这些蚂蚁正在洪水中传播到全国各地。它们成千上万地相互粘着，在暴风雨的洪水中形成“筏子”。ISC的一份声明称：“火蚁在降雨前后更加活跃，可以形成巨大的漂浮筏，随着水流移动，在新地区建立立足点。”它补充说：“我们的团队专注于限制进一步的传播。”ISC警告说，如果目前的爆发不得到控制，火蚁将到达“澳大利亚的每一个角落”。</p>
<h2 id="tip">Tip</h2>
<p>Package.json中依赖库版本号前缀^和~的区别？</p>
<p>在了解<code>^</code>和<code>~</code>区别之前，我们需要在<a href="https://semver.org/lang/zh-CN/">语义化版本 2.0.0 | Semantic Versioning (semver.org)</a>上了解项目版本号规范。根据语义化版本规范，一个版本号由三个数字组成，用点号分隔，格式为&quot;主版本号.次版本号.补丁版本号&quot;，例如版本号2.5.6。以下是对每个数字的含义：</p>
<ol>
<li>主版本号：当进行大规模的API变更或不兼容的改动时，增加主版本号。这意味着新版本可能会导致现有代码无法正常工作。</li>
<li>次版本号：当添加新功能，但保持向后兼容时，增加次版本号。新版本引入的改动应该可以与旧版本的代码兼容。</li>
<li>补丁版本号：当进行小的bug修复或性能优化等不影响现有功能的改动时，增加补丁版本号。补丁版本号的更新应该不会引入新的功能或破坏现有功能。</li>
</ol>
<p>在package.json文件中，dependencies字段用于指定项目所依赖的包及其版本。在这些依赖项的版本号中：</p>
<ol>
<li><code>^</code>符号：允许安装指定版本的最新次要版本，但不包括更高的主要版本。例如，如果依赖项的版本号为^1.2.3，那么运行npm install命令时，将安装1.2.3版本的最新次要版本，例如1.2.4、1.3.0，但不会安装2.0.0版本。</li>
<li><code>~</code>符号：允许安装指定版本的最新补丁版本，但不包括更高的次要版本。例如，如果依赖项的版本号为~1.2.3，那么运行npm install命令时，将安装1.2.3版本的最新补丁版本，例如1.2.4，但不会安装1.3.0版本。</li>
</ol>
<p>总结起来，<code>^</code>符号允许安装指定版本的最新次要版本，而<code>~</code>符号允许安装指定版本的最新补丁版本。</p>
<h2 id="share">Share</h2>
<ol>
<li>在给任何事情下结论之前，需要做下调研，依据事实和数据来判断，不能空口无凭。</li>
<li>发脾气不是你的目的，解决问题才是，不要让愤怒影响到自己的判断。</li>
<li>如果管人是那么简单的事情，那么管理也不会是一门复杂的学科，如果团队里的人都如此合你心意，什么工作都做得很好，那还要你干嘛，你不就是有和没有都是一样了么？容人所短，用其所长。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 15</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-15/</link>
      <pubDate>Mon, 22 Jan 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-15/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/reshape-the-matrix/&#34;&gt;566. 重塑矩阵&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;在 MATLAB 中，有一个非常有用的函数 &lt;code&gt;reshape&lt;/code&gt; ，它可以将一个 &lt;code&gt;m x n&lt;/code&gt; 矩阵重塑为另一个大小不同（&lt;code&gt;r x c&lt;/code&gt;）的新矩阵，但保留其原始数据。&lt;/p&gt;
&lt;p&gt;给你一个由二维数组 &lt;code&gt;mat&lt;/code&gt; 表示的 &lt;code&gt;m x n&lt;/code&gt; 矩阵，以及两个正整数 &lt;code&gt;r&lt;/code&gt; 和 &lt;code&gt;c&lt;/code&gt; ，分别表示想要的重构的矩阵的行数和列数。&lt;/p&gt;
&lt;p&gt;重构后的矩阵需要将原始矩阵的所有元素以相同的 &lt;strong&gt;行遍历顺序&lt;/strong&gt; 填充。&lt;/p&gt;
&lt;p&gt;如果具有给定参数的 &lt;code&gt;reshape&lt;/code&gt; 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2021/04/24/reshape1-grid.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;matrixReshape&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;r&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;allNums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;allNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;allNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;r&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;allNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;resultValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;allNums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;splice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultValue&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;首先，我们可以定义一个空数组&lt;code&gt;allNums&lt;/code&gt;来存储&lt;code&gt;mat&lt;/code&gt;矩阵中的所有元素。然后，我们需要判断&lt;code&gt;allNums&lt;/code&gt;的长度是否等于重塑后矩阵的行数&lt;code&gt;r&lt;/code&gt;乘以列数&lt;code&gt;c&lt;/code&gt;。如果不相等，说明无法进行重塑操作，直接返回原始矩阵&lt;code&gt;mat&lt;/code&gt;。如果相等，我们可以定义一个空数组&lt;code&gt;result&lt;/code&gt;来存储重塑后的矩阵。接下来，我们可以通过列数&lt;code&gt;c&lt;/code&gt;的值，使用数组&lt;code&gt;splice(startIndex, endIndex)&lt;/code&gt;方法对&lt;code&gt;allNums&lt;/code&gt;进行截取，直到&lt;code&gt;allNums&lt;/code&gt;的长度为&lt;code&gt;0&lt;/code&gt;。在每次截取后，将截取的部分作为一行加入&lt;code&gt;resultValue&lt;/code&gt;数组中。完成截取后，我们可以返回&lt;code&gt;resultValue&lt;/code&gt;作为重塑后的矩阵。一开始没看完题目描述最后一句，导致解题出现偏差。本来很简单的题目，自己想复杂了。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2401/240118-trillionaire.html&#34;&gt;World will see first trillionaire in next 10 years&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;一首著名的歌曲和一个问答节目问道：“谁想成为百万富翁？”几十年来，拥有一百万美元是超级富豪的目标。现在，目标变成了十亿美元。反贫困慈善机构乐施会刚刚发布了一份报告，称未来十年内世界将诞生第一个万亿富翁。一万亿是一个巨大的数字和难以置信的金额。它由1后面跟着12个0组成。一万亿等于一百万个一百万美元。该慈善机构表示，贫富差距正在扩大，并指出自新冠疫情爆发以来这种差距已经“被加速”。报告还说：“我们将在未来十年内产生一个万亿富翁，而要消除贫困，则需要200多年。”&lt;/p&gt;
&lt;p&gt;乐施会在世界经济论坛的年度会议上谈到了不平等问题。作为例子，它表示自2020年以来全球最富有的五个人的财富增长了114% 。该慈善机构发言人说：“前五位亿万富翁们的财富增加了两倍。另一方面，近50亿人变得更穷。”特斯拉CEO埃隆·马斯克是地球上最富有的人。他个人身价接近2500亿美元。AP新闻社称：“如果某人真正达到那个万亿元里程碑，他或她将与油气资源丰厚的沙特阿拉伯具有相同价值。”乐施会表示现在世界正处于“分裂之初”，呼吁开启“公共行动新时代”以缩小财富差距。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;注：作为快船队小卡球迷，不得不说，这两年快船老板鲍尔默确实赚麻了。&lt;img alt=&#34;14EE39EE&#34; loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401221553947.gif&#34;&gt;&lt;/p&gt;&lt;/blockquote&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;使用npm install package@latest 时，安装的是V1.6.0还是V1.6.1-beta ？&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/reshape-the-matrix/">566. 重塑矩阵</a></p>
<p>在 MATLAB 中，有一个非常有用的函数 <code>reshape</code> ，它可以将一个 <code>m x n</code> 矩阵重塑为另一个大小不同（<code>r x c</code>）的新矩阵，但保留其原始数据。</p>
<p>给你一个由二维数组 <code>mat</code> 表示的 <code>m x n</code> 矩阵，以及两个正整数 <code>r</code> 和 <code>c</code> ，分别表示想要的重构的矩阵的行数和列数。</p>
<p>重构后的矩阵需要将原始矩阵的所有元素以相同的 <strong>行遍历顺序</strong> 填充。</p>
<p>如果具有给定参数的 <code>reshape</code> 操作是可行且合理的，则输出新的重塑矩阵；否则，输出原始矩阵。</p>
<p><img alt="img" loading="lazy" src="https://assets.leetcode.com/uploads/2021/04/24/reshape1-grid.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">mat</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]],</span> <span class="nx">r</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="nx">c</span> <span class="o">=</span> <span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">4</span><span class="p">]]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">matrixReshape</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">mat</span><span class="p">,</span> <span class="nx">r</span><span class="p">,</span> <span class="nx">c</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">allNums</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">mat</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">mat</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">allNums</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">mat</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">allNums</span><span class="p">.</span><span class="nx">length</span> <span class="o">!==</span> <span class="nx">r</span> <span class="o">*</span> <span class="nx">c</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">mat</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">resultValue</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="p">(</span><span class="nx">allNums</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">resultValue</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">allNums</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">c</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">resultValue</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先，我们可以定义一个空数组<code>allNums</code>来存储<code>mat</code>矩阵中的所有元素。然后，我们需要判断<code>allNums</code>的长度是否等于重塑后矩阵的行数<code>r</code>乘以列数<code>c</code>。如果不相等，说明无法进行重塑操作，直接返回原始矩阵<code>mat</code>。如果相等，我们可以定义一个空数组<code>result</code>来存储重塑后的矩阵。接下来，我们可以通过列数<code>c</code>的值，使用数组<code>splice(startIndex, endIndex)</code>方法对<code>allNums</code>进行截取，直到<code>allNums</code>的长度为<code>0</code>。在每次截取后，将截取的部分作为一行加入<code>resultValue</code>数组中。完成截取后，我们可以返回<code>resultValue</code>作为重塑后的矩阵。一开始没看完题目描述最后一句，导致解题出现偏差。本来很简单的题目，自己想复杂了。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2401/240118-trillionaire.html">World will see first trillionaire in next 10 years</a></p>
<p>一首著名的歌曲和一个问答节目问道：“谁想成为百万富翁？”几十年来，拥有一百万美元是超级富豪的目标。现在，目标变成了十亿美元。反贫困慈善机构乐施会刚刚发布了一份报告，称未来十年内世界将诞生第一个万亿富翁。一万亿是一个巨大的数字和难以置信的金额。它由1后面跟着12个0组成。一万亿等于一百万个一百万美元。该慈善机构表示，贫富差距正在扩大，并指出自新冠疫情爆发以来这种差距已经“被加速”。报告还说：“我们将在未来十年内产生一个万亿富翁，而要消除贫困，则需要200多年。”</p>
<p>乐施会在世界经济论坛的年度会议上谈到了不平等问题。作为例子，它表示自2020年以来全球最富有的五个人的财富增长了114% 。该慈善机构发言人说：“前五位亿万富翁们的财富增加了两倍。另一方面，近50亿人变得更穷。”特斯拉CEO埃隆·马斯克是地球上最富有的人。他个人身价接近2500亿美元。AP新闻社称：“如果某人真正达到那个万亿元里程碑，他或她将与油气资源丰厚的沙特阿拉伯具有相同价值。”乐施会表示现在世界正处于“分裂之初”，呼吁开启“公共行动新时代”以缩小财富差距。</p>
<blockquote>
<p>注：作为快船队小卡球迷，不得不说，这两年快船老板鲍尔默确实赚麻了。<img alt="14EE39EE" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401221553947.gif"></p></blockquote>
<h2 id="tip">Tip</h2>
<p>使用npm install package@latest 时，安装的是V1.6.0还是V1.6.1-beta ？</p>
<p>在部门搭建私有<code>npm</code>仓库，对一些组件库和工具库进行管理，但是出现有同事使用<code>package@latest</code>下载到了<code>beta</code>版本，研究了<code>npm</code>发包机制知道问题出在哪里，因为在发布版本时，都是使用<code>npm publish</code>命令的，所以事实上<code>V1.6.0-beta</code>只是名称改为了<code>-beta</code>而已，要解决这个问题，后续beta版本发布时，需要使用命令<code>npm publish --tag beta</code>。官方文档如下<a href="https://docs.npmjs.com/adding-dist-tags-to-packages">Adding dist-tags to packages | npm Docs (npmjs.com)</a>。</p>
<h2 id="share">Share</h2>
<p>奥卡姆的剃刀定律：在诸多相互竞争的理论中，选择假设最小的，也即最简单的可能就是最正确的，切勿浪费较多东西去做那些用较少东西同样可以做好的事情。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 14</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-14/</link>
      <pubDate>Thu, 18 Jan 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-14/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time/&#34;&gt;1450. 在既定时间做作业的学生人数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你两个整数数组 &lt;code&gt;startTime&lt;/code&gt;（开始时间）和 &lt;code&gt;endTime&lt;/code&gt;（结束时间），并指定一个整数 &lt;code&gt;queryTime&lt;/code&gt; 作为查询时间。&lt;/p&gt;
&lt;p&gt;已知，第 &lt;code&gt;i&lt;/code&gt; 名学生在 &lt;code&gt;startTime[i]&lt;/code&gt; 时开始写作业并于 &lt;code&gt;endTime[i]&lt;/code&gt; 时完成作业。&lt;/p&gt;
&lt;p&gt;请返回在查询时间 &lt;code&gt;queryTime&lt;/code&gt; 时正在做作业的学生人数。形式上，返回能够使 &lt;code&gt;queryTime&lt;/code&gt; 处于区间 &lt;code&gt;[startTime[i], endTime[i]]&lt;/code&gt;（含）的学生人数。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-html&#34; data-lang=&#34;html&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;示例 1：
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;输入：startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;输出：1
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;解释：一共有 3 名学生。
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;第一名学生在时间 1 开始写作业，并于时间 3 完成作业，在时间 4 没有处于做作业的状态。
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;第二名学生在时间 2 开始写作业，并于时间 2 完成作业，在时间 4 没有处于做作业的状态。
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;第三名学生在时间 3 开始写作业，预计于时间 7 完成作业，这是是唯一一名在时间 4 时正在做作业的学生。
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;busyStudent&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;startTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;endTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;queryTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;doHomeworkCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;startTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;queryTime&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;startTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;queryTime&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;endTime&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;doHomeworkCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;doHomeworkCount&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/number-of-students-doing-homework-at-a-given-time/">1450. 在既定时间做作业的学生人数</a></p>
<p>给你两个整数数组 <code>startTime</code>（开始时间）和 <code>endTime</code>（结束时间），并指定一个整数 <code>queryTime</code> 作为查询时间。</p>
<p>已知，第 <code>i</code> 名学生在 <code>startTime[i]</code> 时开始写作业并于 <code>endTime[i]</code> 时完成作业。</p>
<p>请返回在查询时间 <code>queryTime</code> 时正在做作业的学生人数。形式上，返回能够使 <code>queryTime</code> 处于区间 <code>[startTime[i], endTime[i]]</code>（含）的学生人数。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-html" data-lang="html"><span class="line"><span class="cl">示例 1：
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">输入：startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
</span></span><span class="line"><span class="cl">输出：1
</span></span><span class="line"><span class="cl">解释：一共有 3 名学生。
</span></span><span class="line"><span class="cl">第一名学生在时间 1 开始写作业，并于时间 3 完成作业，在时间 4 没有处于做作业的状态。
</span></span><span class="line"><span class="cl">第二名学生在时间 2 开始写作业，并于时间 2 完成作业，在时间 4 没有处于做作业的状态。
</span></span><span class="line"><span class="cl">第三名学生在时间 3 开始写作业，预计于时间 7 完成作业，这是是唯一一名在时间 4 时正在做作业的学生。
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">busyStudent</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">startTime</span><span class="p">,</span> <span class="nx">endTime</span><span class="p">,</span> <span class="nx">queryTime</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">doHomeworkCount</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">startTime</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">queryTime</span> <span class="o">&gt;=</span> <span class="nx">startTime</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">&amp;&amp;</span> <span class="nx">queryTime</span> <span class="o">&lt;=</span> <span class="nx">endTime</span><span class="p">[</span><span class="nx">i</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">doHomeworkCount</span> <span class="o">+=</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">doHomeworkCount</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>因为开始时间和结束时间是一一对应的，所以只需要使用startTime来遍历即可，然后判断queryTime的值是否处于startTime和endTime之间，如果是就+1。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2401/240111-purple-rain-prince.html">Prince&rsquo;s &lsquo;Purple Rain&rsquo; movie to become a musical</a></p>
<p>1984年的电影《Purple Rain》将被改编成百老汇音乐剧，上演地点在纽约。这部电影是基于艺术家Prince创作的同名专辑而制作的，他也在其中担任主演。这应该会鼓励人们去观看音乐剧版本。新音乐剧的制片人对他们的项目感到兴奋。他们表示：“自从Prince传世经典电影问世已经过去了40年，我们认为没有比这个舞台改编更适合用来致敬Prince和他留下的遗产。” 他们还补充说：“我们迫不及待地想让新一代人重新发现《Purple Rain》，再次体验它那强大的力量，但这一次是现场版。”
《Purple Rain》电影凭借最佳原创歌曲配乐获得了奥斯卡金像奖。许多评论家认为《Purple Rain》是最伟大的音乐电影之一。《Purple Rain》专辑连续24周位居美国公告牌200强榜首，并在该榜单上停留了167周之久。其中包含了热门单曲“When Doves Cry”。该电影讲述了一个有抱负的歌手和吉他手努力成名的故事。故事展示了他复杂的家庭生活、与音乐竞争对手之间的战斗以及一段新恋情。Prince于2016年因服用止痛药物过量而去世，全球销售超过1亿张唱片，使其成为史上销量最高的音乐艺术家之一。</p>
<h2 id="tip">Tip</h2>
<p>Android toolchain - develop for Android devices</p>
<p>在运行flutter doctor命令检测flutter开发环境情况的时候，提示没有找到Android SDK，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401150959898.png"></p>
<p>但在【Setting——Languages&amp;Frameworks——Android SDK——Android SDK Location】上已经配置了对应的地址。可能的原因是flutter的配置没有生效，使用以下命令解决，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-dart" data-lang="dart"><span class="line"><span class="cl"><span class="n">flutter</span> <span class="n">config</span> <span class="o">--</span><span class="n">android</span><span class="o">-</span><span class="n">sdk</span> <span class="nl">E:</span><span class="err">\</span><span class="n">Data</span><span class="err">\</span><span class="n">SDK</span><span class="err">\</span><span class="n">AndroidSDK</span>
</span></span></code></pre></div><p>提示已经配置成功，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401150958681.png"></p>
<p>此时，再次运行flutter doctor命令，会提示缺少<code>cmdline-tools component</code>，让你运行命令<code>path/to/sdkmanager --install &quot;cmdline-tools;latest&quot;</code>去解决，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401151001456.png"></p>
<p>很有可能是Android SDK没有下载这个依赖，查看Android SDK配置页面，将<code>Android SDK Command-line Tools（latest）</code>勾选上即可，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401151005501.png"></p>
<p>然后，继续运行flutter doctor命令，会提示你一些Android许可证不被接受，需要运行命令<code>flutter doctor --android-licenses</code>，然后一直选择<code>y</code>即可，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-dart" data-lang="dart"><span class="line"><span class="cl"> <span class="n">Some</span> <span class="n">Android</span> <span class="n">licenses</span> <span class="n">not</span> <span class="n">accepted</span><span class="p">.</span> <span class="n">To</span> <span class="n">resolve</span> <span class="k">this</span><span class="p">,</span> <span class="nl">run:</span> <span class="n">flutter</span> <span class="n">doctor</span> <span class="o">--</span><span class="n">android</span><span class="o">-</span><span class="n">licenses</span>
</span></span></code></pre></div><p>至此，flutter开发环境Android SDK配置不生效问题得以解决。</p>
<h2 id="share">Share</h2>
<p>《名侦探柯南：绯色的不在场证明》和《名侦探柯南：绯色的弹丸》很好看。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 13</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-13/</link>
      <pubDate>Tue, 16 Jan 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-13/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/monotonic-array/&#34;&gt;896. 单调数列&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;如果数组是单调递增或单调递减的，那么它是 &lt;strong&gt;单调&lt;/strong&gt; 的。&lt;/p&gt;
&lt;p&gt;如果对于所有 &lt;code&gt;i &amp;lt;= j&lt;/code&gt;，&lt;code&gt;nums[i] &amp;lt;= nums[j]&lt;/code&gt;，那么数组 &lt;code&gt;nums&lt;/code&gt; 是单调递增的。 如果对于所有 &lt;code&gt;i &amp;lt;= j&lt;/code&gt;，&lt;code&gt;nums[i]&amp;gt; = nums[j]&lt;/code&gt;，那么数组 &lt;code&gt;nums&lt;/code&gt; 是单调递减的。&lt;/p&gt;
&lt;p&gt;当给定的数组 &lt;code&gt;nums&lt;/code&gt; 是单调数组时返回 &lt;code&gt;true&lt;/code&gt;，否则返回 &lt;code&gt;false&lt;/code&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isMonotonic&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isIncreasing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isDecreasing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;isIncreasing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;isDecreasing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;break&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isIncreasing&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isDecreasing&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;定义两个变量isIncreasing和isDecreasing，初始值均设为true。通过for循环遍历数列，当出现不满足从小到大的条件时，将isIncreasing设为false并跳出循环。然后继续判断是否满足从大到小的条件，如果不满足，则将isDecreasing设为false并跳出循环。最后通过逻辑与判断，只要isIncreasing或isDecreasing中有一个为true，即可确认为单调数列。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2401/240108-winter-coat-muggings.html&#34;&gt;Muggers now targeting luxury winter coats&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;世界各地的城市都发生了一连串的抢劫事件，因为劫匪们都把注意力集中在一种新的物品上——奢侈的外套。最近几周，在伦敦、华盛顿和其他大都市地区，人们的外套都被持刀抢劫了。英国伯明翰一名男子的夹克被小偷偷走，他的脸被划伤。犯罪分子的目标是单价高达2200美元的大衣。除了从人们的背上偷走外套外，小偷还闯入人们的车辆。伯明翰城市大学的犯罪学家大卫·威尔逊教授警告说，这些抢劫案是一种新的“奢侈犯罪趋势”的开始。他说，盗窃事件“令人担忧”。&lt;/p&gt;
&lt;p&gt;威尔逊教授警告那些穿着高端冬季夹克的人要小心了。他说:“我会告诉任何穿着加拿大鹅品牌夹克的人要小心，注意你周围的环境和你周围的人。”你必须警惕那些可能试图偷走它们的机会主义者。”他补充说:“窃贼过去常常以劳力士手表为目标，这些手表售价数千英镑，然后在网上出售。”伦敦交通局的一位发言人说:“加拿大鹅毛大衣是抢劫的目标。这对我们来说是一个真正的担忧，因为它确实影响了年轻人在网络上的安全。”她补充说，这种“贪婪的犯罪”是“非常令人担忧、恐吓和恐惧的”。&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;因项目开发计划使用Bing Maps地图替换百度地图，所以就需要考虑坐标转换的问题，否则定位会出现偏差，当前在 &lt;a href=&#34;https://www.lddgo.net&#34;&gt;www.lddgo.net&lt;/a&gt; 上面发现有坐标系转换工具，就使用了一下，进行验证。&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Bing Maps转百度地图国内地址：GCJ02 -&amp;gt; BD09 偏差几米左右&lt;/li&gt;
&lt;li&gt;Bing Maps转百度地图国外地址：WGS84 -&amp;gt; BD09 偏差几米左右&lt;/li&gt;
&lt;li&gt;百度地图转Bing Maps国内地址：BD09 -&amp;gt; GCJ02 偏差几米左右&lt;/li&gt;
&lt;li&gt;百度地图转Bing Maps国外地址：国外坐标不需要转换，直接用 偏差几米左右&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;慈不掌兵，因小失大。&lt;/li&gt;
&lt;li&gt;了解了下showcase，对项目质量的提升应该很有帮助，想办法落实。&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/monotonic-array/">896. 单调数列</a></p>
<p>如果数组是单调递增或单调递减的，那么它是 <strong>单调</strong> 的。</p>
<p>如果对于所有 <code>i &lt;= j</code>，<code>nums[i] &lt;= nums[j]</code>，那么数组 <code>nums</code> 是单调递增的。 如果对于所有 <code>i &lt;= j</code>，<code>nums[i]&gt; = nums[j]</code>，那么数组 <code>nums</code> 是单调递减的。</p>
<p>当给定的数组 <code>nums</code> 是单调数组时返回 <code>true</code>，否则返回 <code>false</code>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">isMonotonic</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">isIncreasing</span> <span class="o">=</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">isDecreasing</span> <span class="o">=</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">&lt;=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">isIncreasing</span> <span class="o">=</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="nx">nums</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">isDecreasing</span> <span class="o">=</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">            <span class="k">break</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">isIncreasing</span> <span class="o">||</span> <span class="nx">isDecreasing</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>定义两个变量isIncreasing和isDecreasing，初始值均设为true。通过for循环遍历数列，当出现不满足从小到大的条件时，将isIncreasing设为false并跳出循环。然后继续判断是否满足从大到小的条件，如果不满足，则将isDecreasing设为false并跳出循环。最后通过逻辑与判断，只要isIncreasing或isDecreasing中有一个为true，即可确认为单调数列。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2401/240108-winter-coat-muggings.html">Muggers now targeting luxury winter coats</a></p>
<p>世界各地的城市都发生了一连串的抢劫事件，因为劫匪们都把注意力集中在一种新的物品上——奢侈的外套。最近几周，在伦敦、华盛顿和其他大都市地区，人们的外套都被持刀抢劫了。英国伯明翰一名男子的夹克被小偷偷走，他的脸被划伤。犯罪分子的目标是单价高达2200美元的大衣。除了从人们的背上偷走外套外，小偷还闯入人们的车辆。伯明翰城市大学的犯罪学家大卫·威尔逊教授警告说，这些抢劫案是一种新的“奢侈犯罪趋势”的开始。他说，盗窃事件“令人担忧”。</p>
<p>威尔逊教授警告那些穿着高端冬季夹克的人要小心了。他说:“我会告诉任何穿着加拿大鹅品牌夹克的人要小心，注意你周围的环境和你周围的人。”你必须警惕那些可能试图偷走它们的机会主义者。”他补充说:“窃贼过去常常以劳力士手表为目标，这些手表售价数千英镑，然后在网上出售。”伦敦交通局的一位发言人说:“加拿大鹅毛大衣是抢劫的目标。这对我们来说是一个真正的担忧，因为它确实影响了年轻人在网络上的安全。”她补充说，这种“贪婪的犯罪”是“非常令人担忧、恐吓和恐惧的”。</p>
<h2 id="tip">Tip</h2>
<p>因项目开发计划使用Bing Maps地图替换百度地图，所以就需要考虑坐标转换的问题，否则定位会出现偏差，当前在 <a href="https://www.lddgo.net">www.lddgo.net</a> 上面发现有坐标系转换工具，就使用了一下，进行验证。</p>
<ol>
<li>Bing Maps转百度地图国内地址：GCJ02 -&gt; BD09 偏差几米左右</li>
<li>Bing Maps转百度地图国外地址：WGS84 -&gt; BD09 偏差几米左右</li>
<li>百度地图转Bing Maps国内地址：BD09 -&gt; GCJ02 偏差几米左右</li>
<li>百度地图转Bing Maps国外地址：国外坐标不需要转换，直接用 偏差几米左右</li>
</ol>
<h2 id="share">Share</h2>
<ol>
<li>慈不掌兵，因小失大。</li>
<li>了解了下showcase，对项目质量的提升应该很有帮助，想办法落实。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 12</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-12/</link>
      <pubDate>Thu, 11 Jan 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-12/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/matrix-diagonal-sum/&#34;&gt;1572. 矩阵对角线元素的和&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个正方形矩阵 &lt;code&gt;mat&lt;/code&gt;，请你返回矩阵对角线元素的和。&lt;/p&gt;
&lt;p&gt;请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;img&#34; loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2020/08/14/sample_1911.png&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;25&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;对角线的和为&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;25&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;请注意&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;元素&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;只会被计算一次&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;diagonalSum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 设置总和值
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 遍历相加
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果mat长度是奇数，会出现中心值相加两次的情况，所以这里要减去一次。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 获取数组中间下标值，减去1除以2加上1就是中间值，但是因为下标是0开始的，所以减去1
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;coreIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;/&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;mat&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;coreIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;coreIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sumValue&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;通过遍历二维数组，找到每个元素位置的规律即可，就是&lt;code&gt;mat[i][i]&lt;/code&gt;和&lt;code&gt;mat[i][mat.length - 1 - i]&lt;/code&gt;，然后处理二维数组长度是偶数和奇数的情况，奇数情况下，会出现多加一次中间值的情况，减去一次即可。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2401/240101-weight-loss-drugs.html&#34;&gt;Better weight-loss drugs predicted for 2024&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;最常见的新年决心之一就是减肥。由于最近批准的注射药物被证明在帮助人们减肥方面特别有效，减肥有望在2024年变得更容易实现。它们属于一类叫做GLP-1的药物。其中最著名的是Wegovy和Ozempic。据drugs.com网站报道，在对使用Wegovy药物的患者进行的广泛研究中，有83%的参与者减掉了5%或更多的体重。相比之下，只有31%的服用安慰剂的参与者能够实现相同的减重效果。梅奥诊所(Mayo Clinic)的一位心脏病专家表示，减肥药物“将继续存在”，而且“越来越多的此类药物将进入市场”。&lt;/p&gt;
&lt;p&gt;行业专家强调了这些新疗法的重要性。著名杂志《科学》宣布，该系列减肥药将成为2023年医学界的“年度突破”。对于超重的人和那些发现锻炼困难的人来说，今年可能会更好。一种叫做Zepbound的新药物已经获得批准。在临床试验中，服用这种药物的人平均减轻了20%至25%的体重。肥胖专家朱莉安娜·西蒙内蒂医生说，这些新药“很神奇，因为它们解决了体重反弹的潜在生理原因”。她补充说:“过去十年我一直在这个领域工作，结果非常令人印象深刻。”&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;PATCH、PUT和POST方法的区别？&lt;/p&gt;
&lt;table&gt;
  &lt;thead&gt;
      &lt;tr&gt;
          &lt;th&gt;请求方法&lt;/th&gt;
          &lt;th&gt;作用&lt;/th&gt;
          &lt;th&gt;请求是否有主体&lt;/th&gt;
          &lt;th&gt;成功的响应是否有主体&lt;/th&gt;
          &lt;th&gt;安全&lt;/th&gt;
          &lt;th&gt;幂等&lt;/th&gt;
          &lt;th&gt;可缓存&lt;/th&gt;
          &lt;th&gt;允许在HTML表单中使用&lt;/th&gt;
      &lt;/tr&gt;
  &lt;/thead&gt;
  &lt;tbody&gt;
      &lt;tr&gt;
          &lt;td&gt;PATCH&lt;/td&gt;
          &lt;td&gt;用于对资源进行部分修改。&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;可能有&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;不允许&lt;/td&gt;
      &lt;/tr&gt;
      &lt;tr&gt;
          &lt;td&gt;PUT&lt;/td&gt;
          &lt;td&gt;创建一个新的资源或用请求的有效载荷替换目标资源的表示。&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;可能有&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;不允许&lt;/td&gt;
      &lt;/tr&gt;
      &lt;tr&gt;
          &lt;td&gt;POST&lt;/td&gt;
          &lt;td&gt;发送数据给服务器。&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;是&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;否&lt;/td&gt;
          &lt;td&gt;仅在包含足够新的信息时&lt;/td&gt;
          &lt;td&gt;允许&lt;/td&gt;
      &lt;/tr&gt;
  &lt;/tbody&gt;
&lt;/table&gt;
&lt;p&gt;幂等：任何数量的重复、相同的请求都会使资源处于相同的状态。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/matrix-diagonal-sum/">1572. 矩阵对角线元素的和</a></p>
<p>给你一个正方形矩阵 <code>mat</code>，请你返回矩阵对角线元素的和。</p>
<p>请你返回在矩阵主对角线上的元素和副对角线上且不在主对角线上元素的和。</p>
<p><img alt="img" loading="lazy" src="https://assets.leetcode.com/uploads/2020/08/14/sample_1911.png"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">mat</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="p">[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">            <span class="p">[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">25</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">对角线的和为</span><span class="err">：</span><span class="mi">1</span> <span class="o">+</span> <span class="mi">5</span> <span class="o">+</span> <span class="mi">9</span> <span class="o">+</span> <span class="mi">3</span> <span class="o">+</span> <span class="mi">7</span> <span class="o">=</span> <span class="mi">25</span>
</span></span><span class="line"><span class="cl"><span class="nx">请注意</span><span class="err">，</span><span class="nx">元素</span> <span class="nx">mat</span><span class="p">[</span><span class="mi">1</span><span class="p">][</span><span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="mi">5</span> <span class="nx">只会被计算一次</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">diagonalSum</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">mat</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 设置总和值
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">sumValue</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">mat</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 遍历相加
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="nx">sumValue</span> <span class="o">=</span> <span class="nx">sumValue</span> <span class="o">+</span> <span class="nx">mat</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">+</span> <span class="nx">mat</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">mat</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span> <span class="o">-</span> <span class="nx">i</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果mat长度是奇数，会出现中心值相加两次的情况，所以这里要减去一次。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">mat</span><span class="p">.</span><span class="nx">length</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 获取数组中间下标值，减去1除以2加上1就是中间值，但是因为下标是0开始的，所以减去1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="kd">let</span> <span class="nx">coreIndex</span> <span class="o">=</span> <span class="p">((</span><span class="nx">mat</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">)</span> <span class="o">/</span> <span class="mi">2</span><span class="p">)</span> <span class="o">+</span> <span class="mi">1</span> <span class="o">-</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">        <span class="nx">sumValue</span> <span class="o">=</span> <span class="nx">sumValue</span> <span class="o">-</span> <span class="nx">mat</span><span class="p">[</span><span class="nx">coreIndex</span><span class="p">][</span><span class="nx">coreIndex</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">sumValue</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>通过遍历二维数组，找到每个元素位置的规律即可，就是<code>mat[i][i]</code>和<code>mat[i][mat.length - 1 - i]</code>，然后处理二维数组长度是偶数和奇数的情况，奇数情况下，会出现多加一次中间值的情况，减去一次即可。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2401/240101-weight-loss-drugs.html">Better weight-loss drugs predicted for 2024</a></p>
<p>最常见的新年决心之一就是减肥。由于最近批准的注射药物被证明在帮助人们减肥方面特别有效，减肥有望在2024年变得更容易实现。它们属于一类叫做GLP-1的药物。其中最著名的是Wegovy和Ozempic。据drugs.com网站报道，在对使用Wegovy药物的患者进行的广泛研究中，有83%的参与者减掉了5%或更多的体重。相比之下，只有31%的服用安慰剂的参与者能够实现相同的减重效果。梅奥诊所(Mayo Clinic)的一位心脏病专家表示，减肥药物“将继续存在”，而且“越来越多的此类药物将进入市场”。</p>
<p>行业专家强调了这些新疗法的重要性。著名杂志《科学》宣布，该系列减肥药将成为2023年医学界的“年度突破”。对于超重的人和那些发现锻炼困难的人来说，今年可能会更好。一种叫做Zepbound的新药物已经获得批准。在临床试验中，服用这种药物的人平均减轻了20%至25%的体重。肥胖专家朱莉安娜·西蒙内蒂医生说，这些新药“很神奇，因为它们解决了体重反弹的潜在生理原因”。她补充说:“过去十年我一直在这个领域工作，结果非常令人印象深刻。”</p>
<h2 id="tip">Tip</h2>
<p>PATCH、PUT和POST方法的区别？</p>
<table>
  <thead>
      <tr>
          <th>请求方法</th>
          <th>作用</th>
          <th>请求是否有主体</th>
          <th>成功的响应是否有主体</th>
          <th>安全</th>
          <th>幂等</th>
          <th>可缓存</th>
          <th>允许在HTML表单中使用</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>PATCH</td>
          <td>用于对资源进行部分修改。</td>
          <td>是</td>
          <td>可能有</td>
          <td>否</td>
          <td>是</td>
          <td>否</td>
          <td>不允许</td>
      </tr>
      <tr>
          <td>PUT</td>
          <td>创建一个新的资源或用请求的有效载荷替换目标资源的表示。</td>
          <td>是</td>
          <td>可能有</td>
          <td>否</td>
          <td>是</td>
          <td>否</td>
          <td>不允许</td>
      </tr>
      <tr>
          <td>POST</td>
          <td>发送数据给服务器。</td>
          <td>是</td>
          <td>是</td>
          <td>否</td>
          <td>否</td>
          <td>仅在包含足够新的信息时</td>
          <td>允许</td>
      </tr>
  </tbody>
</table>
<p>幂等：任何数量的重复、相同的请求都会使资源处于相同的状态。</p>
<p>以上内容来源于www.mozilla.org。</p>
<h2 id="share">Share</h2>
<p>之前跟欧路词典反馈过，建议浏览器插件加上一个功能，查询单词时自动添加到生词本，后来支持了，用起来还是很不错的。提高英文水平，就不会每次在Review上花那么多时间了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 11</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-11/</link>
      <pubDate>Thu, 04 Jan 2024 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-11/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/transpose-matrix/&#34;&gt;867. 转置矩阵&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个二维整数数组 &lt;code&gt;matrix&lt;/code&gt;， 返回 &lt;code&gt;matrix&lt;/code&gt; 的 &lt;strong&gt;转置矩阵&lt;/strong&gt; 。&lt;/p&gt;
&lt;p&gt;矩阵的 &lt;strong&gt;转置&lt;/strong&gt; 是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://assets.leetcode.com/uploads/2021/02/10/hint_transpose.png&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;matrix&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;transpose&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;matrix&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultArr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;matrix&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;matrix&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;c1&#34;&gt;// 如果是undefined，则赋值[]
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;!&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;resultArr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;resultArr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;resultArr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;matrix&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultArr&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;从示例1可以看出，转置前后的数据，其实是有规律可循的，所求的二维数组，其实就是转置前，每个子元素数组同下标的集合，示例1中的147分别是matrix中各子元素数组下标为0的值，以此类推，使用两个for循环得到结果。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2312/231228-chat-with-whale.html&#34;&gt;Scientists &amp;rsquo;talk&amp;rsquo; with a whale for 20 minutes&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;科学家表示，他们与一头鲸鱼进行了一次“对话”。他们还表示，这种聊天可以帮助他们有朝一日与外星人交谈。这些科学家来自加州大学、阿拉斯加鲸鱼基金会和SETI(搜寻外星智慧)。这三个组织联合起来，与一头名叫吐温的座头鲸交谈。他们用“座头鲸语言”和她交谈了20分钟。他们的对话发生在科学家们向阿拉斯加海岸外的海洋发送“联系电话”之后。吐温听到了呼唤，做出了回应。她游到考察船边聊天。SETI表示，这是人类和座头鲸之间的第一次交流。&lt;/p&gt;
&lt;p&gt;科学家们说，他们与吐温的对话并不深刻。布伦达·麦考恩教授说，这更像是一系列的问候。鲸鱼使用联络呼叫让其他鲸鱼知道它们在哪里。科学家们在20分钟内发起了36次同样的呼叫。每一次，吐温都做出了回应。她甚至匹配了研究人员每一次呼叫的间隔时间。麦考恩教授告诉《商业内幕》网站，她的研究可以让与外星人交谈变得更容易。她说:“这个星球上有各种各样的智能体。通过研究它们，我们可以更好地了解外星人可能是什么样子的，因为它们不会完全同我们一样。”&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;switch 和 if else 哪个效率高&lt;/p&gt;
&lt;p&gt;在大多数情况下，&lt;code&gt;switch&lt;/code&gt; 语句的效率通常比 &lt;code&gt;if else&lt;/code&gt; 语句要高。这是因为 &lt;code&gt;switch&lt;/code&gt; 语句使用了跳转表来查找符合条件的分支，而不是逐个比较条件。跳转表实际上是一个数组，通过将条件值作为索引，可以直接访问到对应的目标地址。因此，跳转表的查找方式具有固定的时间复杂度 O(1)，无论有多少个分支，查找时间都是恒定的。&lt;/p&gt;
&lt;p&gt;相比之下，&lt;code&gt;if else&lt;/code&gt; 语句需要逐个比较条件，如果有多个条件，它的查找时间将随着条件数量和复杂度的增加而增加。在最坏的情况下，&lt;code&gt;if else&lt;/code&gt; 语句的时间复杂度可能达到 O(n)，其中 n 是分支的数量。&lt;/p&gt;
&lt;p&gt;然而，在实际应用中，仍然需要根据具体的场景来选择使用 &lt;code&gt;switch&lt;/code&gt; 还是 &lt;code&gt;if else&lt;/code&gt;。如果条件是固定的值，且分支数量较多，建议使用 &lt;code&gt;switch&lt;/code&gt; 语句。如果条件是动态的，并且需要进行更复杂的条件判断，建议使用 &lt;code&gt;if else&lt;/code&gt; 语句。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/transpose-matrix/">867. 转置矩阵</a></p>
<p>给你一个二维整数数组 <code>matrix</code>， 返回 <code>matrix</code> 的 <strong>转置矩阵</strong> 。</p>
<p>矩阵的 <strong>转置</strong> 是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。</p>
<p><img loading="lazy" src="https://assets.leetcode.com/uploads/2021/02/10/hint_transpose.png"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">matrix</span> <span class="o">=</span> <span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">3</span><span class="p">],[</span><span class="mi">4</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">6</span><span class="p">],[</span><span class="mi">7</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">9</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="p">[[</span><span class="mi">1</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">7</span><span class="p">],[</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">8</span><span class="p">],[</span><span class="mi">3</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">9</span><span class="p">]]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">transpose</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">matrix</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">var</span> <span class="nx">resultArr</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">matrix</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">matrix</span><span class="p">[</span><span class="nx">i</span><span class="p">].</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// 如果是undefined，则赋值[]
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="k">if</span> <span class="p">(</span><span class="o">!</span><span class="nx">resultArr</span><span class="p">[</span><span class="nx">j</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">resultArr</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="nx">resultArr</span><span class="p">[</span><span class="nx">j</span><span class="p">].</span><span class="nx">push</span><span class="p">(</span><span class="nx">matrix</span><span class="p">[</span><span class="nx">i</span><span class="p">][</span><span class="nx">j</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">resultArr</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>从示例1可以看出，转置前后的数据，其实是有规律可循的，所求的二维数组，其实就是转置前，每个子元素数组同下标的集合，示例1中的147分别是matrix中各子元素数组下标为0的值，以此类推，使用两个for循环得到结果。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2312/231228-chat-with-whale.html">Scientists &rsquo;talk&rsquo; with a whale for 20 minutes</a></p>
<p>科学家表示，他们与一头鲸鱼进行了一次“对话”。他们还表示，这种聊天可以帮助他们有朝一日与外星人交谈。这些科学家来自加州大学、阿拉斯加鲸鱼基金会和SETI(搜寻外星智慧)。这三个组织联合起来，与一头名叫吐温的座头鲸交谈。他们用“座头鲸语言”和她交谈了20分钟。他们的对话发生在科学家们向阿拉斯加海岸外的海洋发送“联系电话”之后。吐温听到了呼唤，做出了回应。她游到考察船边聊天。SETI表示，这是人类和座头鲸之间的第一次交流。</p>
<p>科学家们说，他们与吐温的对话并不深刻。布伦达·麦考恩教授说，这更像是一系列的问候。鲸鱼使用联络呼叫让其他鲸鱼知道它们在哪里。科学家们在20分钟内发起了36次同样的呼叫。每一次，吐温都做出了回应。她甚至匹配了研究人员每一次呼叫的间隔时间。麦考恩教授告诉《商业内幕》网站，她的研究可以让与外星人交谈变得更容易。她说:“这个星球上有各种各样的智能体。通过研究它们，我们可以更好地了解外星人可能是什么样子的，因为它们不会完全同我们一样。”</p>
<h2 id="tip">Tip</h2>
<p>switch 和 if else 哪个效率高</p>
<p>在大多数情况下，<code>switch</code> 语句的效率通常比 <code>if else</code> 语句要高。这是因为 <code>switch</code> 语句使用了跳转表来查找符合条件的分支，而不是逐个比较条件。跳转表实际上是一个数组，通过将条件值作为索引，可以直接访问到对应的目标地址。因此，跳转表的查找方式具有固定的时间复杂度 O(1)，无论有多少个分支，查找时间都是恒定的。</p>
<p>相比之下，<code>if else</code> 语句需要逐个比较条件，如果有多个条件，它的查找时间将随着条件数量和复杂度的增加而增加。在最坏的情况下，<code>if else</code> 语句的时间复杂度可能达到 O(n)，其中 n 是分支的数量。</p>
<p>然而，在实际应用中，仍然需要根据具体的场景来选择使用 <code>switch</code> 还是 <code>if else</code>。如果条件是固定的值，且分支数量较多，建议使用 <code>switch</code> 语句。如果条件是动态的，并且需要进行更复杂的条件判断，建议使用 <code>if else</code> 语句。</p>
<h2 id="share">Share</h2>
<p>总是有人要赢的，那为什么不能是我呢？ —— 科比·布莱恩特</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 10</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-10/</link>
      <pubDate>Sun, 31 Dec 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-10/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/count-good-triplets/&#34;&gt;1534. 统计好三元组&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;arr&lt;/code&gt; ，以及 &lt;code&gt;a&lt;/code&gt;、&lt;code&gt;b&lt;/code&gt; 、&lt;code&gt;c&lt;/code&gt; 三个整数。请你统计其中好三元组的数量。&lt;/p&gt;
&lt;p&gt;如果三元组 &lt;code&gt;(arr[i], arr[j], arr[k])&lt;/code&gt; 满足下列全部条件，则认为它是一个 &lt;strong&gt;好三元组&lt;/strong&gt; 。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;0 &amp;lt;= i &amp;lt; j &amp;lt; k &amp;lt; arr.length&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;|arr[i] - arr[j]| &amp;lt;= a&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;|arr[j] - arr[k]| &amp;lt;= b&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;|arr[i] - arr[k]| &amp;lt;= c&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;其中 &lt;code&gt;|x|&lt;/code&gt; 表示 &lt;code&gt;x&lt;/code&gt; 的绝对值。&lt;/p&gt;
&lt;p&gt;返回 &lt;strong&gt;好三元组的数量&lt;/strong&gt;。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;一共有&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;个好三元组&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;),&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)]&lt;/span&gt; &lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;countGoodTriplets&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultCount&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;abs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;a&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;abs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;b&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;abs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;k&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;c&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;resultCount&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;resultCount&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;要得到好三元组的数量，要先判断出&lt;code&gt;i&lt;/code&gt;、&lt;code&gt;j&lt;/code&gt;、&lt;code&gt;k&lt;/code&gt;能有多少种组合，使用&lt;code&gt;3&lt;/code&gt;个&lt;code&gt;for&lt;/code&gt;来遍历，因为&lt;code&gt;0 &amp;lt;= i &amp;lt; j &amp;lt; k &amp;lt; arr.length&lt;/code&gt;的条件，可以&lt;code&gt;i&lt;/code&gt;从&lt;code&gt;0&lt;/code&gt;开始，&lt;code&gt;j&lt;/code&gt;从&lt;code&gt;i+1&lt;/code&gt;开始，&lt;code&gt;k&lt;/code&gt;从&lt;code&gt;j+1&lt;/code&gt;开始，依次得出&lt;code&gt;arr[i], arr[j], arr[k]&lt;/code&gt;存在的组合，然后使用4个条件进行判断，使用&lt;code&gt;resultCount&lt;/code&gt;来计数即可。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/count-good-triplets/">1534. 统计好三元组</a></p>
<p>给你一个整数数组 <code>arr</code> ，以及 <code>a</code>、<code>b</code> 、<code>c</code> 三个整数。请你统计其中好三元组的数量。</p>
<p>如果三元组 <code>(arr[i], arr[j], arr[k])</code> 满足下列全部条件，则认为它是一个 <strong>好三元组</strong> 。</p>
<ul>
<li><code>0 &lt;= i &lt; j &lt; k &lt; arr.length</code></li>
<li><code>|arr[i] - arr[j]| &lt;= a</code></li>
<li><code>|arr[j] - arr[k]| &lt;= b</code></li>
<li><code>|arr[i] - arr[k]| &lt;= c</code></li>
</ul>
<p>其中 <code>|x|</code> 表示 <code>x</code> 的绝对值。</p>
<p>返回 <strong>好三元组的数量</strong>。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">arr</span> <span class="o">=</span> <span class="p">[</span><span class="mi">3</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">9</span><span class="p">,</span><span class="mi">7</span><span class="p">],</span> <span class="nx">a</span> <span class="o">=</span> <span class="mi">7</span><span class="p">,</span> <span class="nx">b</span> <span class="o">=</span> <span class="mi">2</span><span class="p">,</span> <span class="nx">c</span> <span class="o">=</span> <span class="mi">3</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">一共有</span> <span class="mi">4</span> <span class="nx">个好三元组</span><span class="err">：</span><span class="p">[(</span><span class="mi">3</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="mi">3</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">),</span> <span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">1</span><span class="p">)]</span> <span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">countGoodTriplets</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">arr</span><span class="p">,</span> <span class="nx">a</span><span class="p">,</span> <span class="nx">b</span><span class="p">,</span> <span class="nx">c</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">resultCount</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">k</span> <span class="o">=</span> <span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">k</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">k</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(</span><span class="mi">0</span> <span class="o">&lt;=</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">k</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span> <span class="o">&amp;&amp;</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">abs</span><span class="p">(</span><span class="nx">arr</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">-</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">j</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="nx">a</span> <span class="o">&amp;&amp;</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">abs</span><span class="p">(</span><span class="nx">arr</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">-</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">k</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="nx">b</span> <span class="o">&amp;&amp;</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">abs</span><span class="p">(</span><span class="nx">arr</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">-</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">k</span><span class="p">])</span> <span class="o">&lt;=</span> <span class="nx">c</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="o">++</span><span class="nx">resultCount</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">resultCount</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>要得到好三元组的数量，要先判断出<code>i</code>、<code>j</code>、<code>k</code>能有多少种组合，使用<code>3</code>个<code>for</code>来遍历，因为<code>0 &lt;= i &lt; j &lt; k &lt; arr.length</code>的条件，可以<code>i</code>从<code>0</code>开始，<code>j</code>从<code>i+1</code>开始，<code>k</code>从<code>j+1</code>开始，依次得出<code>arr[i], arr[j], arr[k]</code>存在的组合，然后使用4个条件进行判断，使用<code>resultCount</code>来计数即可。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2312/231218-brainoware-biocomputer.html">Scientists make biocomputer with brain tissue</a></p>
<p>随着研究人员制造出“生物计算机”，人与机器的融合又向前迈进了一步。美国印第安纳大学的生物工程师将实验室培养的人类脑组织与微电极结合在一起。科学家们将他们的发明命名为Brainoware。它还处于发展的萌芽阶段，但已经可以执行语音识别等复杂任务。首席研究员郭峰博士希望他的软件将有助于推进人工智能技术。这也可能意味着人工智能硬件比单纯使用硅芯片消耗的能源要少得多。郭博士说:“这只是概念验证，表明我们可以完成这项工作。我们还有很长的路要走。”</p>
<p>研究人员表示，他们的Brainware系统利用了“类器官”。这些是人工培育的类似器官的组织束和干细胞。郭博士说，他的团队的类器官就像迷你大脑。它们已经转化并发展了神经元，类似于人类大脑中的神经元。研究人员表示，他们的下一步是研究如何让Brainware适应更高级别的任务。这项技术有一天可以用来创建改进的大脑模型，并推动神经科学研究向前发展。它还可能促进神经系统疾病的治疗。研究人员当前面临的一个主要挑战是找到如何保持活组织存活的解决方案。</p>
<h2 id="tip">Tip</h2>
<p>什么是npx？</p>
<p>因为最近在项目Vue3中集成Sentry前端异常监控系统，看到官方文档里有使用npx的指令，就去了解了一下。当你在项目中使用npx执行一个命令时，npx 会在当前项目的的<code>./node_modules/.bin</code>目录下查找是否有对应可执行的命令，没有找到的话再从全局环境查找是否有安装对应的模块，如果全局环境中没有，会创建一个临时目录，并在其中下载对应的模块，命令执行完毕后临时目录会被删除，不会占有本地资源。这种机制可以确保在执行命令时使用最新的模块，并且不会对全局环境造成过多的污染。</p>
<h2 id="share">Share</h2>
<ol>
<li>感觉一直在补ARTS的打卡任务，按理这周应该是ARTS Week 11了，不过这周就想补上了，不清楚为什么那么忙，太多太多需要做的事情。</li>
<li>无论做什么事情，要做就做好，不然就不做。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 9</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-09/</link>
      <pubDate>Mon, 25 Dec 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-09/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/three-consecutive-odds/&#34;&gt;1550. 存在连续三个奇数的数组&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数数组 &lt;code&gt;arr&lt;/code&gt;，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 &lt;code&gt;true&lt;/code&gt; ；否则，返回 &lt;code&gt;false&lt;/code&gt; 。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;示例 1：

输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;threeConsecutiveOdds&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果数组长度小于3，则直接返回false
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;lastIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 定义当前值、下一个值、再下一个值，如果存在连续的三个奇数，则可直接得到结果，返回true
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;current&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;last&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;arr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 如果已经比较至数组倒数第三个，还是没有结果，而当i是倒数第二个时，因为只有2个值了，就没有比较的必要了，返回结果false
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;lastIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;current&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;next&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;amp;&amp;amp;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;last&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;总的来说，编辑数组，判断是否存在连续三个元素都是奇数的情况，有则返回&lt;code&gt;true&lt;/code&gt;，否则继续遍历，不是就接着比较，等到最后倒数第三个还是没有结果，意味着不存在，返回&lt;code&gt;false&lt;/code&gt;。&lt;/p&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2312/231211-peach-fuzz-colour-of-the-year.html&#34;&gt;Peach fuzz is colour of the year for 2024&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;官方宣布，柔和桃（Peach fuzz）是2024年的年度流行色。世界色彩权威机构潘通（Pantone）将柔和桃选为2024年最能给人们带来舒适的色调。Pantone是有关配色方案的信息和建议的首选来源。它从2000年开始评选年度颜色。对即将到来的年度色调的审议小组表示：“柔和桃能带来归属感，并激发人们重新调整和追求成长的机会。”它补充说，在柔和桃中，“我们可以从内心寻找平静，这会对我们的幸福产生积极的影响。”潘通色彩研究所（Pantone Colour Institute）副总裁劳里•普雷斯曼（Laurie Pressman）表示，这种颜色“温馨的感觉能够把人们聚在一起，并丰富我们的灵魂”。&lt;/p&gt;
&lt;p&gt;潘通配色系统是所有颜色的行业标准。到2024年，从平面设计到时尚，再到科技，各行各业都有可能将柔和桃融入他们的产品、营销和广告中。该公司的网站称：“潘通提供了一种通用的色彩语言，使品牌和制造商在工作流程的每个阶段都能做出对色彩至关重要的决定。”它补充道：“潘通的色彩语言支持所有注重色彩的行业，比如纺织品、服装、美容、室内设计、建筑和工业设计等，其中印刷、纺织品、塑料、颜料和涂料等多种材料已有超过10000种颜色标准。”&lt;/p&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;解决 android gradle 下载特别慢的问题&lt;/p&gt;
&lt;p&gt;在&lt;code&gt;flutter/android&lt;/code&gt;开发时，经常遇到&lt;code&gt;gradle&lt;/code&gt;下载特别慢的问题，甚至是超时失败，严重影响到项目的开发工作，为了解决这个问题，可以考虑替换成国内的镜像来下载解决。首先，在&lt;code&gt;android/gradle/wrapper/gradle-wrapper.properties&lt;/code&gt;中，查看当前&lt;code&gt;gradle&lt;/code&gt;版本，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251127878.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;然后在&lt;a href=&#34;https://mirrors.cloud.tencent.com/gradle/&#34;&gt;腾讯镜像gradle&lt;/a&gt;上面，查看是否存在该版本，如下所示：&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251128029.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/three-consecutive-odds/">1550. 存在连续三个奇数的数组</a></p>
<p>给你一个整数数组 <code>arr</code>，请你判断数组中是否存在连续三个元素都是奇数的情况：如果存在，请返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
<pre tabindex="0"><code>示例 1：

输入：arr = [2,6,4,1]
输出：false
解释：不存在连续三个元素都是奇数的情况
</code></pre><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">threeConsecutiveOdds</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">arr</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果数组长度小于3，则直接返回false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">if</span> <span class="p">(</span><span class="nx">arr</span><span class="p">.</span><span class="nx">length</span> <span class="o">&lt;</span> <span class="mi">3</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">lastIndex</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">arr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 定义当前值、下一个值、再下一个值，如果存在连续的三个奇数，则可直接得到结果，返回true
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="kd">let</span> <span class="nx">current</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">next</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">last</span> <span class="o">=</span> <span class="nx">arr</span><span class="p">[</span><span class="nx">i</span> <span class="o">+</span> <span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="c1">// 如果已经比较至数组倒数第三个，还是没有结果，而当i是倒数第二个时，因为只有2个值了，就没有比较的必要了，返回结果false
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">&gt;</span> <span class="nx">lastIndex</span> <span class="o">-</span> <span class="mi">2</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">current</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!==</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="nx">next</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!==</span> <span class="mi">0</span> <span class="o">&amp;&amp;</span> <span class="nx">last</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">return</span> <span class="kc">true</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>总的来说，编辑数组，判断是否存在连续三个元素都是奇数的情况，有则返回<code>true</code>，否则继续遍历，不是就接着比较，等到最后倒数第三个还是没有结果，意味着不存在，返回<code>false</code>。</p>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2312/231211-peach-fuzz-colour-of-the-year.html">Peach fuzz is colour of the year for 2024</a></p>
<p>官方宣布，柔和桃（Peach fuzz）是2024年的年度流行色。世界色彩权威机构潘通（Pantone）将柔和桃选为2024年最能给人们带来舒适的色调。Pantone是有关配色方案的信息和建议的首选来源。它从2000年开始评选年度颜色。对即将到来的年度色调的审议小组表示：“柔和桃能带来归属感，并激发人们重新调整和追求成长的机会。”它补充说，在柔和桃中，“我们可以从内心寻找平静，这会对我们的幸福产生积极的影响。”潘通色彩研究所（Pantone Colour Institute）副总裁劳里•普雷斯曼（Laurie Pressman）表示，这种颜色“温馨的感觉能够把人们聚在一起，并丰富我们的灵魂”。</p>
<p>潘通配色系统是所有颜色的行业标准。到2024年，从平面设计到时尚，再到科技，各行各业都有可能将柔和桃融入他们的产品、营销和广告中。该公司的网站称：“潘通提供了一种通用的色彩语言，使品牌和制造商在工作流程的每个阶段都能做出对色彩至关重要的决定。”它补充道：“潘通的色彩语言支持所有注重色彩的行业，比如纺织品、服装、美容、室内设计、建筑和工业设计等，其中印刷、纺织品、塑料、颜料和涂料等多种材料已有超过10000种颜色标准。”</p>
<h2 id="tip">Tip</h2>
<p>解决 android gradle 下载特别慢的问题</p>
<p>在<code>flutter/android</code>开发时，经常遇到<code>gradle</code>下载特别慢的问题，甚至是超时失败，严重影响到项目的开发工作，为了解决这个问题，可以考虑替换成国内的镜像来下载解决。首先，在<code>android/gradle/wrapper/gradle-wrapper.properties</code>中，查看当前<code>gradle</code>版本，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251127878.png"></p>
<p>然后在<a href="https://mirrors.cloud.tencent.com/gradle/">腾讯镜像gradle</a>上面，查看是否存在该版本，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251128029.png"></p>
<p>最后将<code>distributionUrl</code>设置为腾讯镜像地址即可，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="n">distributionUrl</span><span class="o">=</span><span class="n">https</span><span class="err">\</span><span class="p">:</span><span class="c1">//mirrors.cloud.tencent.com/gradle/gradle-7.5-all.zip</span><span class="w">
</span></span></span></code></pre></div><h2 id="share">Share</h2>
<p>之前一直觉得代码评审不是很重要，加上也没那么多时间去做这个事情，然后这些天刚好打算在项目质量上面，有一些突破，从需求到开发到测试到上线，可以做什么来提升项目的质量？自然而然就涉及到代码评审了，然后开了一下午会，好像也没看了多少代码，太耗费时间了。总的感受还是，从源头去解决问题，也就是在gitlab合并代码前，一定要根据制定的代码规范检查一遍，然后才是具体实现的功能逻辑是否有缺陷，确保合并时代码是符合规范的，这样后续的代码评审会议，时间也不会那么久了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 8</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-08/</link>
      <pubDate>Sat, 16 Dec 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-08/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/valid-parentheses/&#34;&gt;20. 有效的括号&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个只包括 &lt;code&gt;&#39;(&#39;&lt;/code&gt;，&lt;code&gt;&#39;)&#39;&lt;/code&gt;，&lt;code&gt;&#39;{&#39;&lt;/code&gt;，&lt;code&gt;&#39;}&#39;&lt;/code&gt;，&lt;code&gt;&#39;[&#39;&lt;/code&gt;，&lt;code&gt;&#39;]&#39;&lt;/code&gt; 的字符串 &lt;code&gt;s&lt;/code&gt; ，判断字符串是否有效。&lt;/p&gt;
&lt;p&gt;有效字符串需满足：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;左括号必须用相同类型的右括号闭合。&lt;/li&gt;
&lt;li&gt;左括号必须以正确的顺序闭合。&lt;/li&gt;
&lt;li&gt;每个右括号都有一个对应的相同类型的左括号。&lt;/li&gt;
&lt;/ol&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;示例 1：
输入：s = &amp;#34;()&amp;#34;
输出：true

示例 2：
输入：s = &amp;#34;(]&amp;#34;
输出：false
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isValid&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;%&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;map&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;s1&#34;&gt;&amp;#39;(&amp;#39;&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;)&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;s1&#34;&gt;&amp;#39;[&amp;#39;&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;]&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;s1&#34;&gt;&amp;#39;{&amp;#39;&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;}&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;stack&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;(&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;[&amp;#39;&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;||&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;{&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;stack&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;s&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;map&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;stack&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;pop&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;()])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;kc&#34;&gt;false&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;stack&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;总的来说，就是通过栈后进先出（LIFO ，Last In First Out）的机制实现。&lt;/li&gt;
&lt;li&gt;如果字符串长度不是偶数，则说明不是成对的，可直接返回&lt;code&gt;false&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;通过&lt;code&gt;Map&lt;/code&gt;，创建一个对象，用来处理左右括号映射关系&lt;/li&gt;
&lt;li&gt;创建一个数组&lt;code&gt;stack&lt;/code&gt;，用来实现栈的操作&lt;/li&gt;
&lt;li&gt;如果是左括号，则入栈&lt;code&gt;stack.push(s)&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;如果是右括号，&lt;code&gt;stack.pop()&lt;/code&gt; 栈顶的左括号出栈，获取它映射的右括号，进行比较&lt;/li&gt;
&lt;li&gt;如果不相等，直接返回&lt;code&gt;false&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;当&lt;code&gt;stack&lt;/code&gt;长度为空，说明入栈的左括号都找到了对应的右括号，返回&lt;code&gt;true&lt;/code&gt;，否则为&lt;code&gt;false&lt;/code&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2312/231214-javier-milei.html&#34;&gt;Argentina&amp;rsquo;s president warns of economic &amp;lsquo;shock treatment&amp;rsquo;&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;阿根廷有了一位新总统。他叫哈维尔·米莱。他出人意料地赢得了11月的选举。米莱承诺要扭转阿根廷糟糕的经济。他特别表示，他将降低目前在140%左右的通胀率。他还希望大幅削减公共债务。在过去的几十年里，阿根廷借了很多钱。米莱开始想偿还这笔钱。在他作为总统的第一次演讲中，他说经济需要“休克疗法”来恢复。他表示，前几届政府花费太多，“没有钱了”。他警告阿根廷人，未来几年的生活将会很艰难。他说，人们将不得不生活在“紧缩”中以帮助经济。&lt;/p&gt;
&lt;p&gt;哈维尔·米莱与阿根廷以前见过的任何政治家都不同。他是一个极右翼政治家。许多人说他很像美国前总统川普和巴西前总统博索纳罗。在米莱竞选期间，人们经常看到他拿着电锯。他想让人们知道，他将在经济方面大幅削减开支。他称自己的选举胜利是阿根廷历史的转折点，就像1989年柏林墙的倒塌一样。他承诺限制堕胎权并放宽枪支法。他也因为不相信气候变化而惹恼了环保人士。他说:“我们知道，短期内形势将会恶化，但之后我们将看到我们努力的成果。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/valid-parentheses/">20. 有效的括号</a></p>
<p>给定一个只包括 <code>'('</code>，<code>')'</code>，<code>'{'</code>，<code>'}'</code>，<code>'['</code>，<code>']'</code> 的字符串 <code>s</code> ，判断字符串是否有效。</p>
<p>有效字符串需满足：</p>
<ol>
<li>左括号必须用相同类型的右括号闭合。</li>
<li>左括号必须以正确的顺序闭合。</li>
<li>每个右括号都有一个对应的相同类型的左括号。</li>
</ol>
<pre tabindex="0"><code>示例 1：
输入：s = &#34;()&#34;
输出：true

示例 2：
输入：s = &#34;(]&#34;
输出：false
</code></pre><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">isValid</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">str</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">str</span><span class="p">.</span><span class="nx">length</span> <span class="o">%</span> <span class="mi">2</span> <span class="o">!==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kr">const</span> <span class="nx">map</span> <span class="o">=</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="s1">&#39;(&#39;</span><span class="o">:</span> <span class="s1">&#39;)&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s1">&#39;[&#39;</span><span class="o">:</span> <span class="s1">&#39;]&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">        <span class="s1">&#39;{&#39;</span><span class="o">:</span> <span class="s1">&#39;}&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">stack</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">str</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">s</span> <span class="o">=</span> <span class="nx">str</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">s</span> <span class="o">==</span> <span class="s1">&#39;(&#39;</span> <span class="o">||</span> <span class="nx">s</span> <span class="o">==</span> <span class="s1">&#39;[&#39;</span> <span class="o">||</span> <span class="nx">s</span> <span class="o">==</span> <span class="s1">&#39;{&#39;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">stack</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">s</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">s</span> <span class="o">!==</span> <span class="nx">map</span><span class="p">[</span><span class="nx">stack</span><span class="p">.</span><span class="nx">pop</span><span class="p">()])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">stack</span><span class="p">.</span><span class="nx">length</span> <span class="o">==</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>总的来说，就是通过栈后进先出（LIFO ，Last In First Out）的机制实现。</li>
<li>如果字符串长度不是偶数，则说明不是成对的，可直接返回<code>false</code></li>
<li>通过<code>Map</code>，创建一个对象，用来处理左右括号映射关系</li>
<li>创建一个数组<code>stack</code>，用来实现栈的操作</li>
<li>如果是左括号，则入栈<code>stack.push(s)</code></li>
<li>如果是右括号，<code>stack.pop()</code> 栈顶的左括号出栈，获取它映射的右括号，进行比较</li>
<li>如果不相等，直接返回<code>false</code>。</li>
<li>当<code>stack</code>长度为空，说明入栈的左括号都找到了对应的右括号，返回<code>true</code>，否则为<code>false</code>。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2312/231214-javier-milei.html">Argentina&rsquo;s president warns of economic &lsquo;shock treatment&rsquo;</a></p>
<p>阿根廷有了一位新总统。他叫哈维尔·米莱。他出人意料地赢得了11月的选举。米莱承诺要扭转阿根廷糟糕的经济。他特别表示，他将降低目前在140%左右的通胀率。他还希望大幅削减公共债务。在过去的几十年里，阿根廷借了很多钱。米莱开始想偿还这笔钱。在他作为总统的第一次演讲中，他说经济需要“休克疗法”来恢复。他表示，前几届政府花费太多，“没有钱了”。他警告阿根廷人，未来几年的生活将会很艰难。他说，人们将不得不生活在“紧缩”中以帮助经济。</p>
<p>哈维尔·米莱与阿根廷以前见过的任何政治家都不同。他是一个极右翼政治家。许多人说他很像美国前总统川普和巴西前总统博索纳罗。在米莱竞选期间，人们经常看到他拿着电锯。他想让人们知道，他将在经济方面大幅削减开支。他称自己的选举胜利是阿根廷历史的转折点，就像1989年柏林墙的倒塌一样。他承诺限制堕胎权并放宽枪支法。他也因为不相信气候变化而惹恼了环保人士。他说:“我们知道，短期内形势将会恶化，但之后我们将看到我们努力的成果。”</p>
<h2 id="tip">Tip</h2>
<p>栈是一种后进先出（LIFO）的数据结构，**类似于我们在现实生活中处理堆叠的物体的方式。**栈的主要操作包括将元素压入栈（push），从栈中弹出元素（pop），和查看栈顶元素（peek）。</p>
<h2 id="share">Share</h2>
<p>最近观察，所见所闻，想到《铁齿铜牙纪晓岚》中和珅演的王刚对纪晓岚说的“清官的确令人敬佩，可清官也令人畏啊。”清官易苛，苛则寡恩，仗着自己平时廉洁，以自己为标准，可以毫无顾忌对他人横加指责。以之对应的则是在工作中，在团队管理上，仗着自己为了团队兢兢业业，没有任何私心，所作所为完全经得起推敲，就开始眼里容不得沙子了，好像谁都不如自己用心一样，那么简单的事情怎么还做不好呢？水至清则无鱼，谁身上没有点问题呢，想想自己的缺点，想想别人的长处，会容得下世界上很多事情。有时候说还不如不说，做还不如不做，完全是以你想要的结果为准，只要结果是达到预期的，不管什么方式都是可以的，尊重，理解，保持平和的心态。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 7</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-07/</link>
      <pubDate>Thu, 30 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-07/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/longest-common-prefix/&#34;&gt;14. 最长公共前缀&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;编写一个函数来查找字符串数组中的最长公共前缀。&lt;/p&gt;
&lt;p&gt;如果不存在公共前缀，返回空字符串 &lt;code&gt;&amp;quot;&amp;quot;&lt;/code&gt;。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;示例 1：
输入：strs = [&amp;#34;flower&amp;#34;,&amp;#34;flow&amp;#34;,&amp;#34;flight&amp;#34;]
输出：&amp;#34;fl&amp;#34;
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;temp&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;temp&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStrValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;];&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStrValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;substring&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;minStr&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;总的来说就是，先将字符串数组排序，拿到最短的字符串，通过遍历这个最短的字符串，依次对比其他字符串相同下标的字符，是否相等，拿到出现不相等的下标，然后截取这个最短字符串的前缀即是我们要求的值。&lt;/li&gt;
&lt;li&gt;首先，如果字符串数组是&lt;code&gt;[&amp;quot;&amp;quot;]&lt;/code&gt;,直接返回结果为&lt;code&gt;&amp;quot;&amp;quot;&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;如果字符串数组只有一个元素，就返回元素自身。&lt;/li&gt;
&lt;li&gt;使用冒泡排序，将字符串数组，长度最短的字符串放在前面，获取最短字符串的值。&lt;/li&gt;
&lt;li&gt;遍历最短字符串，依次对比其他字符串的相同下标的字符，是否相等，如果不相等，就返回存在不相等的下标，比如&lt;code&gt;[ &#39;flow&#39;, &#39;flower&#39;, &#39;flight&#39; ]&lt;/code&gt;，通过&lt;code&gt;flow&lt;/code&gt;来遍历，然后会在&lt;code&gt;o&lt;/code&gt;也就是下标为&lt;code&gt;2&lt;/code&gt;时，出现不相等，此时就截取最短字符串的值，&lt;code&gt;minStr.substring(0, i)&lt;/code&gt;，最长公共前缀。&lt;/li&gt;
&lt;li&gt;题外话，前面的&lt;code&gt;if&lt;/code&gt;是在力扣提交解法，反馈之后补上的，有点写测试用例的意思，当时我也在想，能不能有一个完美的解法，但是，仔细一想，直接根据特殊场景，给出直接的结果，虽然会觉得代码有点难看，但结果本身就是提高算法效率的事情，所以就这样了。一开始这道题目没有一点思路的，反复研究，才想到解法。不管解法好坏，当下的目的是解得出来，思路最重要，等积累到一定程度，自己能力有所长进，相信给出的解法一定会越来越优雅。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://medium.com/@oyinade/stop-telling-people-everything-5cfc217988a8&#34;&gt;Stop Telling People Everything. My experience | by Oyinade | Oct, 2023 | Medium&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;你知道，当人们说不要透露下一步或者自己的计划给别人，不要告诉别人任何事情。在某种程度上，我一直觉得这句话很难理解，因为你不告诉别人你的情况，别人怎么能帮到你呢？我想说的是，没有人天生就是一座孤岛，在你生命的某个时刻，你需要和别人有交集。你需要别人帮助你，指导你，给你指路。&lt;/p&gt;
&lt;p&gt;让我用自己来举例子，在三年前，当我还在读大学的时候，我接到了一个很小的项目，我决定测试一下这句话，看看我最后的表现如何，所以我没有告诉任何人关于这个项目。&lt;/p&gt;
&lt;p&gt;当然，我对这个项目做了研究，我还上网寻求指导，我很有信心它会成为一个非常棒的项目。&lt;/p&gt;
&lt;p&gt;我要展示作品的那一天到来了，当我起身开始展示时，我的很多朋友，甚至我周围的人，都有点震惊地发现，我被交给了这个项目，却没有提起任何事情，因为这是一个相当大的交易。&lt;/p&gt;
&lt;p&gt;我能听到有人说，“她为什么不告诉我们”的窃窃私语，但木已成舟，我现在要展示它。当我开始我的演讲时，我没有足够的信心来讲好，我的肢体语言传达了一个完全不同的信息，我匆忙做了所有的事情，一个本应该花45分钟简单而清晰的解释的演讲，在15分钟内就完成了。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/longest-common-prefix/">14. 最长公共前缀</a></p>
<p>编写一个函数来查找字符串数组中的最长公共前缀。</p>
<p>如果不存在公共前缀，返回空字符串 <code>&quot;&quot;</code>。</p>
<pre tabindex="0"><code>示例 1：
输入：strs = [&#34;flower&#34;,&#34;flow&#34;,&#34;flight&#34;]
输出：&#34;fl&#34;
</code></pre><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">strs</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&#34;&#34;</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="s2">&#34;&#34;</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">strs</span><span class="p">.</span><span class="nx">length</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">strs</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">strs</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">strs</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="nx">i</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">strs</span><span class="p">[</span><span class="nx">j</span><span class="p">].</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="nx">strs</span><span class="p">[</span><span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">].</span><span class="nx">length</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="kd">let</span> <span class="nx">temp</span> <span class="o">=</span> <span class="nx">strs</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">                <span class="nx">strs</span><span class="p">[</span><span class="nx">j</span><span class="p">]</span> <span class="o">=</span> <span class="nx">strs</span><span class="p">[</span><span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">                <span class="nx">strs</span><span class="p">[</span><span class="nx">j</span> <span class="o">+</span> <span class="mi">1</span><span class="p">]</span> <span class="o">=</span> <span class="nx">temp</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">minStr</span> <span class="o">=</span> <span class="nx">strs</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">minStr</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kr">const</span> <span class="nx">minStrValue</span> <span class="o">=</span> <span class="nx">minStr</span><span class="p">[</span><span class="nx">i</span><span class="p">];</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">j</span> <span class="o">=</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">j</span> <span class="o">&lt;</span> <span class="nx">strs</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">j</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">strs</span><span class="p">[</span><span class="nx">j</span><span class="p">][</span><span class="nx">i</span><span class="p">]</span> <span class="o">!==</span> <span class="nx">minStrValue</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span> <span class="nx">minStr</span><span class="p">.</span><span class="nx">substring</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">minStr</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>总的来说就是，先将字符串数组排序，拿到最短的字符串，通过遍历这个最短的字符串，依次对比其他字符串相同下标的字符，是否相等，拿到出现不相等的下标，然后截取这个最短字符串的前缀即是我们要求的值。</li>
<li>首先，如果字符串数组是<code>[&quot;&quot;]</code>,直接返回结果为<code>&quot;&quot;</code>。</li>
<li>如果字符串数组只有一个元素，就返回元素自身。</li>
<li>使用冒泡排序，将字符串数组，长度最短的字符串放在前面，获取最短字符串的值。</li>
<li>遍历最短字符串，依次对比其他字符串的相同下标的字符，是否相等，如果不相等，就返回存在不相等的下标，比如<code>[ 'flow', 'flower', 'flight' ]</code>，通过<code>flow</code>来遍历，然后会在<code>o</code>也就是下标为<code>2</code>时，出现不相等，此时就截取最短字符串的值，<code>minStr.substring(0, i)</code>，最长公共前缀。</li>
<li>题外话，前面的<code>if</code>是在力扣提交解法，反馈之后补上的，有点写测试用例的意思，当时我也在想，能不能有一个完美的解法，但是，仔细一想，直接根据特殊场景，给出直接的结果，虽然会觉得代码有点难看，但结果本身就是提高算法效率的事情，所以就这样了。一开始这道题目没有一点思路的，反复研究，才想到解法。不管解法好坏，当下的目的是解得出来，思路最重要，等积累到一定程度，自己能力有所长进，相信给出的解法一定会越来越优雅。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://medium.com/@oyinade/stop-telling-people-everything-5cfc217988a8">Stop Telling People Everything. My experience | by Oyinade | Oct, 2023 | Medium</a></p>
<p>你知道，当人们说不要透露下一步或者自己的计划给别人，不要告诉别人任何事情。在某种程度上，我一直觉得这句话很难理解，因为你不告诉别人你的情况，别人怎么能帮到你呢？我想说的是，没有人天生就是一座孤岛，在你生命的某个时刻，你需要和别人有交集。你需要别人帮助你，指导你，给你指路。</p>
<p>让我用自己来举例子，在三年前，当我还在读大学的时候，我接到了一个很小的项目，我决定测试一下这句话，看看我最后的表现如何，所以我没有告诉任何人关于这个项目。</p>
<p>当然，我对这个项目做了研究，我还上网寻求指导，我很有信心它会成为一个非常棒的项目。</p>
<p>我要展示作品的那一天到来了，当我起身开始展示时，我的很多朋友，甚至我周围的人，都有点震惊地发现，我被交给了这个项目，却没有提起任何事情，因为这是一个相当大的交易。</p>
<p>我能听到有人说，“她为什么不告诉我们”的窃窃私语，但木已成舟，我现在要展示它。当我开始我的演讲时，我没有足够的信心来讲好，我的肢体语言传达了一个完全不同的信息，我匆忙做了所有的事情，一个本应该花45分钟简单而清晰的解释的演讲，在15分钟内就完成了。</p>
<p>讲师们很不高兴，事实上，如果我能把他们脸上的表情用语言表达出来，那就是，我们应该把它交给别人。</p>
<p>在我完成演讲后，我的一个朋友过来问我，你为什么不告诉我们，然后我们就可以帮助你或指导你怎么做了。我一句话也说不出来，因为我认为我做的是对的。但是我的表现和对整个情况的判断低于平均水平，没有给人留下深刻的印象。</p>
<p>说句公道话，我会让别人教我怎么做，我从那次经历中学到了什么呢，那就是，如果你不知道如何做某件事，就向能帮助你的人求助，不要指望自己能做得很好。</p>
<p>“别再向别人透露你的计划了。”</p>
<p>我认为我对这个概念的理解不够好，或者我可能把它用在了错误的情况下。我甚至读过一些关于生活中真正成功人士的书，他们也说了同样的话，但我不明白他们的意思。</p>
<p>我仍然在努力理解这句话的真正含义以及如何应用它。如果你能帮助我更清楚地理解，我将不胜感激，因为最近我一直在经历艰难的挑战，老实说，我需要帮助。</p>
<p>所以我同意这句话吗？不完全是。我觉得如果你的计划需要帮助，你应该去找那些更了解你的人，那些有纯洁意图的人。</p>
<h2 id="tip">Tip</h2>
<pre tabindex="0"><code>X [ERROR] No known conditions for &#34;./lib/locale/lang/zh-cn&#34; specifier in &#34;element-plus&#34; package [plugin vite:dep-scan]
</code></pre><p><code>Vue3</code>项目模版打算部署至<code>Sentry</code>前端监控系统试用，然后就运行项目，因为<code>nodejs</code>版本升级到了<code>v18.18.0</code>，出现一些依赖不兼容的问题，就打算趁这个机会升级至<code>Vite5</code>，然后就遇到了<code>Element Plus</code>组件库国际化问题，研究了一下，是用法上面有了变化导致的，具体可以看这个<code>issue</code>，[<a href="https://github.com/element-plus/element-plus/issues/13609">i18n] [All] [plugin:vite:import-analysis] No known conditions for &ldquo;./lib/locale/lang/zh-cn&rdquo; specifier in &ldquo;element-plus&rdquo; package · Issue #13609 · element-plus/element-plus (github.com)</a>，方案就是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="c1">// 2.3.7以及之前的用法
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">import</span> <span class="nx">zhCN</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/lib/locale/lang/zh-cn&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">en</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/lib/locale/lang/en&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 2.3.8+
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">import</span> <span class="nx">zhCN</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/dist/locale/zh-cn.mjs&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">en</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/dist/locale/en.mjs&#34;</span><span class="p">;</span>
</span></span></code></pre></div><h2 id="share">Share</h2>
<p>“我今天去种地了，什么地？对你的死心塌地。我今天还钓鱼了，什么鱼？对你的至死不渝。”在B站听的电影解说，现听现抄，被逗笑了，实属蚌埠住了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 6</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-06/</link>
      <pubDate>Mon, 27 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-06/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/palindrome-number/&#34;&gt;9. 回文数&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个整数 &lt;code&gt;x&lt;/code&gt; ，如果 &lt;code&gt;x&lt;/code&gt; 是一个回文整数，返回 &lt;code&gt;true&lt;/code&gt; ；否则，返回 &lt;code&gt;false&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;例如，&lt;code&gt;121&lt;/code&gt; 是回文，而 &lt;code&gt;123&lt;/code&gt; 不是。&lt;/li&gt;
&lt;/ul&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;121&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;kc&#34;&gt;true&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;isPalindrome&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;turnX&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;&amp;#39;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strX&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;String&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strX&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;turnX&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;turnX&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strX&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;turnX&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;首先，将整数转化为字符串，然后for遍历，倒序输出，组合成翻转的字符串&lt;/li&gt;
&lt;li&gt;将翻转后的字符串转换成整数和原始整数比较，如果相等，则为&lt;code&gt;true&lt;/code&gt;，反之为&lt;code&gt;false&lt;/code&gt;。&lt;/li&gt;
&lt;li&gt;上面这个是很直观的一种解法，其实自己想过另一种解法，就是双指针，左右逐步向中间执行对比，只要有一个不相等则为&lt;code&gt;false&lt;/code&gt;，否则就是&lt;code&gt;true&lt;/code&gt;。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2311/231127-bacteria-memories.html&#34;&gt;Bacteria Memories - ESL Lesson Plan - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;细菌在其单细胞形式中具有一种机制，可以存储记忆并将其传递给后代。&lt;/li&gt;
&lt;li&gt;细菌没有大脑，但它们可以从环境中收集信息，如果它们经常遇到这种环境，它们可以存储它，并在以后快速访问它，以造福它们。&lt;/li&gt;
&lt;li&gt;细菌的记忆与人类不同。它可能更类似于我们的肌肉记忆。我们的身体组织对下一步该做什么有一种感觉，因为以前已经重复了很多次。&lt;/li&gt;
&lt;li&gt;铁不仅对地球生命的起源至关重要，而且对生命的进化也至关重要。细胞利用它是有道理的。&lt;/li&gt;
&lt;li&gt;我们对细菌行为了解得越多，就越容易对抗它们。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;掘金小册子&lt;a href=&#34;https://juejin.cn/book/6844733783166418958&#34;&gt;《你不知道的 Chrome 调试技巧》&lt;/a&gt;是免费的，里面主要是讲了一些Chrome DevTools的使用技巧，今天看完，主要是记录了下一些印象比较深的点：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;全屏截图，通过 &lt;code&gt;Capture full size screenshot&lt;/code&gt; 命令。&lt;/li&gt;
&lt;li&gt;取色器，Chrome DevTools 自带取色器，之前一直没注意。&lt;/li&gt;
&lt;li&gt;console.table（） 可以将对象或数组以一个表格方式打印出来，方便查看。&lt;/li&gt;
&lt;li&gt;console.log({value1,value2,value3}) 当想打印多个值时，要区分总是要加上前缀，如&lt;code&gt;value1---&lt;/code&gt;，其实通过&lt;code&gt;{}&lt;/code&gt;就可以以对象的格式打印出来。&lt;/li&gt;
&lt;li&gt;console.log()并没有立即拍摄对象快照，它只是存储一个指向对象的引用，在代码返回事件队列时才去拍摄快照。 使用 &lt;code&gt;JSON.stringify()&lt;/code&gt; 方法处理打印的结果。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;share&#34;&gt;Share&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;很多事情不能太急着下结论，要缓一缓，不能自己认为是什么样的，就笃定事实就是这样的，要慢一点，不能依据情绪判断事情，这样很容易出问题，话一旦说出口，就很难改变了，没有调查就没有发言权，任何凭感觉而做的判断，都是在给自己设下陷阱。&lt;/li&gt;
&lt;li&gt;谁身上多少都有些问题，用人要用其长处。&lt;/li&gt;
&lt;/ol&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/palindrome-number/">9. 回文数</a></p>
<p>给你一个整数 <code>x</code> ，如果 <code>x</code> 是一个回文整数，返回 <code>true</code> ；否则，返回 <code>false</code> 。</p>
<p>回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。</p>
<ul>
<li>例如，<code>121</code> 是回文，而 <code>123</code> 不是。</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">x</span> <span class="o">=</span> <span class="mi">121</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="kc">true</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">isPalindrome</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">x</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">turnX</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">strX</span> <span class="o">=</span> <span class="nb">String</span><span class="p">(</span><span class="nx">x</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="nx">strX</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&gt;=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span><span class="o">--</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">turnX</span> <span class="o">=</span> <span class="nx">turnX</span> <span class="o">+</span> <span class="nx">strX</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nb">Number</span><span class="p">(</span><span class="nx">turnX</span><span class="p">)</span> <span class="o">==</span> <span class="nx">x</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>首先，将整数转化为字符串，然后for遍历，倒序输出，组合成翻转的字符串</li>
<li>将翻转后的字符串转换成整数和原始整数比较，如果相等，则为<code>true</code>，反之为<code>false</code>。</li>
<li>上面这个是很直观的一种解法，其实自己想过另一种解法，就是双指针，左右逐步向中间执行对比，只要有一个不相等则为<code>false</code>，否则就是<code>true</code>。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2311/231127-bacteria-memories.html">Bacteria Memories - ESL Lesson Plan - Breaking News English Lesson</a></p>
<ol>
<li>细菌在其单细胞形式中具有一种机制，可以存储记忆并将其传递给后代。</li>
<li>细菌没有大脑，但它们可以从环境中收集信息，如果它们经常遇到这种环境，它们可以存储它，并在以后快速访问它，以造福它们。</li>
<li>细菌的记忆与人类不同。它可能更类似于我们的肌肉记忆。我们的身体组织对下一步该做什么有一种感觉，因为以前已经重复了很多次。</li>
<li>铁不仅对地球生命的起源至关重要，而且对生命的进化也至关重要。细胞利用它是有道理的。</li>
<li>我们对细菌行为了解得越多，就越容易对抗它们。</li>
</ol>
<h2 id="tip">Tip</h2>
<p>掘金小册子<a href="https://juejin.cn/book/6844733783166418958">《你不知道的 Chrome 调试技巧》</a>是免费的，里面主要是讲了一些Chrome DevTools的使用技巧，今天看完，主要是记录了下一些印象比较深的点：</p>
<ol>
<li>全屏截图，通过 <code>Capture full size screenshot</code> 命令。</li>
<li>取色器，Chrome DevTools 自带取色器，之前一直没注意。</li>
<li>console.table（） 可以将对象或数组以一个表格方式打印出来，方便查看。</li>
<li>console.log({value1,value2,value3}) 当想打印多个值时，要区分总是要加上前缀，如<code>value1---</code>，其实通过<code>{}</code>就可以以对象的格式打印出来。</li>
<li>console.log()并没有立即拍摄对象快照，它只是存储一个指向对象的引用，在代码返回事件队列时才去拍摄快照。 使用 <code>JSON.stringify()</code> 方法处理打印的结果。</li>
</ol>
<h2 id="share">Share</h2>
<ol>
<li>很多事情不能太急着下结论，要缓一缓，不能自己认为是什么样的，就笃定事实就是这样的，要慢一点，不能依据情绪判断事情，这样很容易出问题，话一旦说出口，就很难改变了，没有调查就没有发言权，任何凭感觉而做的判断，都是在给自己设下陷阱。</li>
<li>谁身上多少都有些问题，用人要用其长处。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 5</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-05/</link>
      <pubDate>Sat, 25 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-05/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/container-with-most-water/&#34;&gt;11. 盛最多水的容器&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个长度为 &lt;code&gt;n&lt;/code&gt; 的整数数组 &lt;code&gt;height&lt;/code&gt; 。有 &lt;code&gt;n&lt;/code&gt; 条垂线，第 &lt;code&gt;i&lt;/code&gt; 条线的两个端点是 &lt;code&gt;(i, 0)&lt;/code&gt; 和 &lt;code&gt;(i, height[i])&lt;/code&gt; 。&lt;/p&gt;
&lt;p&gt;找出其中的两条线，使得它们与 &lt;code&gt;x&lt;/code&gt; 轴共同构成的容器可以容纳最多的水。&lt;/p&gt;
&lt;p&gt;返回容器可以储存的最大水量。&lt;/p&gt;
&lt;p&gt;**说明：**你不能倾斜容器。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://aliyun-lc-upload.oss-cn-hangzhou.aliyuncs.com/aliyun-lc-upload/uploads/2018/07/25/question_11.jpg&#34;&gt;&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;49&lt;/span&gt; 
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;图中垂直线代表输入数组&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;6&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;5&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;8&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;在此情况下&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;，&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;容器能够容纳水&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;（&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;表示为蓝色部分&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;）&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;的最大值为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;49&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;maxArea&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;area&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;while&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;       &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentArea&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;min&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;*&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;       &lt;span class=&#34;nx&#34;&gt;area&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Math&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;max&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;area&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;currentArea&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;       &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;height&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;          &lt;span class=&#34;nx&#34;&gt;left&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;       &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;          &lt;span class=&#34;nx&#34;&gt;right&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;--&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;       &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;area&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;定义两个指针left和right，分别指向容器的左边界和右边界。&lt;/li&gt;
&lt;li&gt;定义一个变量area用于存储最大面积的结果，初始值为0。&lt;/li&gt;
&lt;li&gt;使用一个循环，当left小于right时进行迭代：计算当前的面积，即min(height[left], height[right]) * (right - left)。Math.min()返回传入参数中最小值。&lt;/li&gt;
&lt;li&gt;如果当前面积大于area，则更新area的值。&lt;/li&gt;
&lt;li&gt;如果height[left]小于height[right]，则将left右移一位；否则将right左移一位。&lt;/li&gt;
&lt;li&gt;循环结束后，返回area作为最大面积的结果。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://breakingnewsenglish.com/2311/231123-napoleon-hat.html&#34;&gt;Napoleon&amp;rsquo;s Hat - ESL Lesson Plan - Breaking News English Lesson&lt;/a&gt;&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;拿破仑的帽子是拍卖史上最贵的，以210万美元的价格售出。&lt;/li&gt;
&lt;li&gt;拿破仑大约有120顶帽子，本周这顶破记录的帽子由毛毡制成，上面有法国国旗的红、白、蓝三种颜色。&lt;/li&gt;
&lt;li&gt;最近有好莱坞电影《拿破仑》上映，由雷德利·斯科特执导，华金·菲尼克斯饰演拿破仑，凡妮莎·柯比饰演约瑟芬。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;tip&#34;&gt;Tip&lt;/h2&gt;
&lt;p&gt;项目中有些接口，请求的资源大小有200KB之多，在前端页面交互使用上体验很差，而这些资源通常都不会改变，频繁去请求作用不大，徒增服务器负担。为了解决这个问题，引入HTTP 304 状态码机制，当浏览器发起一个条件请求到服务器时，服务器会使用304状态码来表示请求资源未更新，可以直接使用当前缓存的资源，无需再重新从服务器下载。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/container-with-most-water/">11. 盛最多水的容器</a></p>
<p>给定一个长度为 <code>n</code> 的整数数组 <code>height</code> 。有 <code>n</code> 条垂线，第 <code>i</code> 条线的两个端点是 <code>(i, 0)</code> 和 <code>(i, height[i])</code> 。</p>
<p>找出其中的两条线，使得它们与 <code>x</code> 轴共同构成的容器可以容纳最多的水。</p>
<p>返回容器可以储存的最大水量。</p>
<p>**说明：**你不能倾斜容器。</p>
<p><img loading="lazy" src="https://aliyun-lc-upload.oss-cn-hangzhou.aliyuncs.com/aliyun-lc-upload/uploads/2018/07/25/question_11.jpg"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">7</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">49</span> 
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">图中垂直线代表输入数组</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">6</span><span class="p">,</span><span class="mi">2</span><span class="p">,</span><span class="mi">5</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">8</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">7</span><span class="p">]</span><span class="err">。</span><span class="nx">在此情况下</span><span class="err">，</span><span class="nx">容器能够容纳水</span><span class="err">（</span><span class="nx">表示为蓝色部分</span><span class="err">）</span><span class="nx">的最大值为</span> <span class="mi">49</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">maxArea</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">height</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">left</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">right</span> <span class="o">=</span> <span class="nx">height</span><span class="p">.</span><span class="nx">length</span> <span class="o">-</span> <span class="mi">1</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">area</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="k">while</span> <span class="p">(</span><span class="nx">left</span> <span class="o">&lt;</span> <span class="nx">right</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">       <span class="kd">let</span> <span class="nx">currentArea</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">min</span><span class="p">(</span><span class="nx">height</span><span class="p">[</span><span class="nx">left</span><span class="p">],</span> <span class="nx">height</span><span class="p">[</span><span class="nx">right</span><span class="p">])</span> <span class="o">*</span> <span class="p">(</span><span class="nx">right</span> <span class="o">-</span> <span class="nx">left</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">       <span class="nx">area</span> <span class="o">=</span> <span class="nb">Math</span><span class="p">.</span><span class="nx">max</span><span class="p">(</span><span class="nx">area</span><span class="p">,</span> <span class="nx">currentArea</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">       <span class="k">if</span> <span class="p">(</span><span class="nx">height</span><span class="p">[</span><span class="nx">left</span><span class="p">]</span> <span class="o">&lt;</span> <span class="nx">height</span><span class="p">[</span><span class="nx">right</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">          <span class="nx">left</span><span class="o">++</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">       <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">          <span class="nx">right</span><span class="o">--</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">       <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">area</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>定义两个指针left和right，分别指向容器的左边界和右边界。</li>
<li>定义一个变量area用于存储最大面积的结果，初始值为0。</li>
<li>使用一个循环，当left小于right时进行迭代：计算当前的面积，即min(height[left], height[right]) * (right - left)。Math.min()返回传入参数中最小值。</li>
<li>如果当前面积大于area，则更新area的值。</li>
<li>如果height[left]小于height[right]，则将left右移一位；否则将right左移一位。</li>
<li>循环结束后，返回area作为最大面积的结果。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://breakingnewsenglish.com/2311/231123-napoleon-hat.html">Napoleon&rsquo;s Hat - ESL Lesson Plan - Breaking News English Lesson</a></p>
<ol>
<li>拿破仑的帽子是拍卖史上最贵的，以210万美元的价格售出。</li>
<li>拿破仑大约有120顶帽子，本周这顶破记录的帽子由毛毡制成，上面有法国国旗的红、白、蓝三种颜色。</li>
<li>最近有好莱坞电影《拿破仑》上映，由雷德利·斯科特执导，华金·菲尼克斯饰演拿破仑，凡妮莎·柯比饰演约瑟芬。</li>
</ol>
<h2 id="tip">Tip</h2>
<p>项目中有些接口，请求的资源大小有200KB之多，在前端页面交互使用上体验很差，而这些资源通常都不会改变，频繁去请求作用不大，徒增服务器负担。为了解决这个问题，引入HTTP 304 状态码机制，当浏览器发起一个条件请求到服务器时，服务器会使用304状态码来表示请求资源未更新，可以直接使用当前缓存的资源，无需再重新从服务器下载。</p>
<ol>
<li>
<p>背景、初衷和目标：304状态码主要是为了减少不必要的网络请求，减少服务器负担和提高性能而设计的。当客户端发起条件请求时，服务器可以通过304状态码告知客户端，所请求的资源未发生变化，可以直接使用当前缓存的资源。</p>
</li>
<li>
<p>优势和劣势：优势：可以减少网络请求加快前端页面加载速度，降低服务器负担。劣势：如果配置不正确，可能导致前端页面展示的不是最新的数据。</p>
</li>
<li>
<p>使用场景： 适用于请求资源过大的业务场景，或者图片、样式等静态资源。</p>
</li>
<li>
<p>组成部分和关键点：前端发起的条件请求时需要在请求头中包含条件标识，如If-Modified-Since、If-None-Match等，服务器收到请求后，判断资源是否有更新，如果没有更新会返回304状态码。</p>
<p>如下所示：</p>
<pre tabindex="0"><code>GET /example.html HTTP/1.1
Host: www.example.com
If-None-Match: &#34;abc123&#34;
If-Modified-Since: Fri, 24 Nov 2023 01:27:35 GMT

HTTP/1.1 304 Not Modified
</code></pre></li>
<li>
<p>底层原理和关键实现：当服务器收到前端发起的请求之后，会比较请求中的条件标识和资源的最后更新时间或实体标签，判断资源是否有更新，如果没有更新则返回304状态码，否则会返回200状态码和最新的资源内容。</p>
</li>
<li>
<p>已有的实现和对比： 大多数主流的web服务器和浏览器都支持304状态码，如Apache、Nginx、IIS等。与传统的200状态码相比，304状态码能更有效地利用缓存，减少不必要的网络请求和降低服务器资源负担。</p>
</li>
</ol>
<p>要验证服务器是否正确处理304状态码，可以打开浏览器的开发者工具中切换到 Network（网络）选项卡，查看指定的网络请求，在第一次请求之后的请求，是否显示  304 Not Modified ，然后其 Size 和Time 是否较少。如是，就说明在请求时，是使用了浏览器自身的缓存而不是重新从服务器下载资源。</p>
<h2 id="share">Share</h2>
<p>上周生病了之后，就没及时打卡这个活动了，整个人都晕晕的。只能这周补上了，加上RMPW活动，应该是要四篇，但也只能慢慢补了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 4</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-04/</link>
      <pubDate>Sun, 12 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-04/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为  &lt;a href=&#34;https://leetcode.cn/problems/move-zeroes/&#34;&gt;283. 移动零&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个数组 &lt;code&gt;nums&lt;/code&gt;，编写一个函数将所有 &lt;code&gt;0&lt;/code&gt; 移动到数组的末尾，同时保持非零元素的相对顺序。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;请注意&lt;/strong&gt; ，必须在不复制数组的情况下原地对数组进行操作。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;12&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;moveZeroes&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 记录数组中存在0的个数
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 使用递归的方式，遍历删除数组中的0，并且记录数组中出现0的次数。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;deleteZeroes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;deleteZeroes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;splice&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;deleteZeroes&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 根据数组中出现0的次数，将删除全部0后的数据，在尾部添加count次0元素。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;lt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;count&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;++&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;首先，先找到数组中0的位置，然后依次将其从数组中删除，并记录出现0的次数。&lt;/li&gt;
&lt;li&gt;根据0出现的次数，在数据尾部加上0。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;review&#34;&gt;Review&lt;/h2&gt;
&lt;p&gt;&lt;a href=&#34;https://medium.com/@anjishnuray/your-life-is-built-by-what-you-do-after-your-work-hours-bc26ecc68169&#34;&gt;Your Life Is Built By What You Do After Your Work Hours | by Anjishnu Ray | Medium&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;你的工作会给你的人生带来价值，但不会很多，特别是你还很年轻的时候，你的人生是由你下班后的空闲时间决定的。&lt;/p&gt;
&lt;p&gt;我们通常工作6~8个小时，除去睡觉的时间，仍然还有8个小时的空闲时间。这些时间足够让你用来创造更有可能性的未来。&lt;/p&gt;
&lt;p&gt;成功人士总是会选择艰难的道路，首先你要在脑海中想象自己就是一位成功人士，然后在现实中，也这样认为。在这些下班后的空闲时间里，你是选择去Netflix网站看电影，还是用来打磨你的技能，你是得过且过，还是为你的将来制定周详的计划？成功人士总是选择艰难的道路，因为尽管很困难，但它是有价值的。&lt;/p&gt;
&lt;p&gt;成功人士总是优先考虑成就而不是舒适度。这是他们的生活方式。他们每天如此，最终使他成为现实中的成功人士。&lt;/p&gt;
&lt;p&gt;当你工作的时候，你就是在工作，你是在成长，在进步，在完成项目，这没有错。但是你是否想过利用你的空闲时间来打磨你的技能，实验和尝试新的事物？如果这些努力给你带来好处，你会后悔吗？肯定不会，但是如果你浪费你的空闲时间在肤浅的事情和盲目的娱乐上，肯定会让你后悔。不是说现在，而是在未来的某个时刻。&lt;/p&gt;
&lt;p&gt;休息能够恢复你的精力，放松能让你感到舒适。我们是人，当然需要休息，我们需要恢复精力和适当放松。这些都是必需品。但是安逸？我们为什么觉得安逸是一个必需品呢？它不是必需的，不应该成为一个必选项。&lt;/p&gt;
&lt;p&gt;就像那些成功人士说的那样，最好的潜力往往能在人们的坟墓中找到。这是因为直到他们死去，他们都没有在梦想中投入足够的努力和精力。&lt;/p&gt;
&lt;p&gt;青春是用来燃烧的，而不是用来消磨的。把这句话印到你的脑海之中吧。&lt;/p&gt;
&lt;p&gt;当人们老去之时，唯一的希望就是还能够拥有更多的时间。不，这不可能。当你变老之时，你是为自己的一生感到自豪，还是后悔不已呢？&lt;/p&gt;
&lt;p&gt;你不会活上一千年。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为  <a href="https://leetcode.cn/problems/move-zeroes/">283. 移动零</a></p>
<p>给定一个数组 <code>nums</code>，编写一个函数将所有 <code>0</code> 移动到数组的末尾，同时保持非零元素的相对顺序。</p>
<p><strong>请注意</strong> ，必须在不复制数组的情况下原地对数组进行操作。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">0</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">12</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">12</span><span class="p">,</span><span class="mi">0</span><span class="p">,</span><span class="mi">0</span><span class="p">]</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">moveZeroes</span> <span class="o">=</span> <span class="kd">function</span><span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 记录数组中存在0的个数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">count</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 使用递归的方式，遍历删除数组中的0，并且记录数组中出现0的次数。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">deleteZeroes</span><span class="p">(</span><span class="nx">nums</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="kd">function</span> <span class="nx">deleteZeroes</span><span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">nums</span><span class="p">[</span><span class="nx">i</span><span class="p">]</span> <span class="o">==</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">nums</span><span class="p">.</span><span class="nx">splice</span><span class="p">(</span><span class="nx">i</span><span class="p">,</span> <span class="mi">1</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="nx">count</span><span class="o">++</span>
</span></span><span class="line"><span class="cl">                <span class="k">return</span> <span class="nx">deleteZeroes</span><span class="p">(</span><span class="nx">nums</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">nums</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 根据数组中出现0的次数，将删除全部0后的数据，在尾部添加count次0元素。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">for</span> <span class="p">(</span><span class="kd">let</span> <span class="nx">i</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span> <span class="nx">i</span> <span class="o">&lt;</span> <span class="nx">count</span><span class="p">;</span> <span class="nx">i</span><span class="o">++</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">nums</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="mi">0</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">nums</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span></code></pre></div><p>解题思路：</p>
<ol>
<li>首先，先找到数组中0的位置，然后依次将其从数组中删除，并记录出现0的次数。</li>
<li>根据0出现的次数，在数据尾部加上0。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://medium.com/@anjishnuray/your-life-is-built-by-what-you-do-after-your-work-hours-bc26ecc68169">Your Life Is Built By What You Do After Your Work Hours | by Anjishnu Ray | Medium</a></p>
<p>你的工作会给你的人生带来价值，但不会很多，特别是你还很年轻的时候，你的人生是由你下班后的空闲时间决定的。</p>
<p>我们通常工作6~8个小时，除去睡觉的时间，仍然还有8个小时的空闲时间。这些时间足够让你用来创造更有可能性的未来。</p>
<p>成功人士总是会选择艰难的道路，首先你要在脑海中想象自己就是一位成功人士，然后在现实中，也这样认为。在这些下班后的空闲时间里，你是选择去Netflix网站看电影，还是用来打磨你的技能，你是得过且过，还是为你的将来制定周详的计划？成功人士总是选择艰难的道路，因为尽管很困难，但它是有价值的。</p>
<p>成功人士总是优先考虑成就而不是舒适度。这是他们的生活方式。他们每天如此，最终使他成为现实中的成功人士。</p>
<p>当你工作的时候，你就是在工作，你是在成长，在进步，在完成项目，这没有错。但是你是否想过利用你的空闲时间来打磨你的技能，实验和尝试新的事物？如果这些努力给你带来好处，你会后悔吗？肯定不会，但是如果你浪费你的空闲时间在肤浅的事情和盲目的娱乐上，肯定会让你后悔。不是说现在，而是在未来的某个时刻。</p>
<p>休息能够恢复你的精力，放松能让你感到舒适。我们是人，当然需要休息，我们需要恢复精力和适当放松。这些都是必需品。但是安逸？我们为什么觉得安逸是一个必需品呢？它不是必需的，不应该成为一个必选项。</p>
<p>就像那些成功人士说的那样，最好的潜力往往能在人们的坟墓中找到。这是因为直到他们死去，他们都没有在梦想中投入足够的努力和精力。</p>
<p>青春是用来燃烧的，而不是用来消磨的。把这句话印到你的脑海之中吧。</p>
<p>当人们老去之时，唯一的希望就是还能够拥有更多的时间。不，这不可能。当你变老之时，你是为自己的一生感到自豪，还是后悔不已呢？</p>
<p>你不会活上一千年。</p>
<p>每一分钟都很重要。</p>
<p>每一个行动都算数。</p>
<p>说实话，一旦你变老了，你就不会再有那么多时间和精力，但是现在，你还很年轻，精力是无限的，精神气、对知识的渴望和对世界的好奇心，都是无限的。要把它们用在正确的方向上。</p>
<p>如果你没有掌控自己的人生，那人生将毫无意义。成功人士通过征服自己来征服自己的人生。那不是一天一周或者一个月的事情，这需要花费好几年的时间。他们坚信自己能够成功，所以一次又一次的坚持，永不放弃。</p>
<p>难道你不想感受那种成就感吗？</p>
<h2 id="tip">Tip</h2>
<p><code>npm install</code> 自己<code>vue next</code>模版，出现封装的库引向的是<code>192.168.24.XXX</code>的npm私有源，使用命令<code>npm config set</code>设置了新的npm私有源<code>112.230.193.XXX</code>，但是一直没有生效，总是报错如下：</p>
<p><img loading="lazy" src="/Users/haowei/Documents/%E5%BE%AE%E4%BF%A1%E5%85%AC%E4%BC%97%E5%8F%B7/Picture/202311081429242.png"></p>
<p>原因是因为<code>package-lock.json</code>里面的是<code>192.168.24.XXX</code>的npm私有源，虽然在终端运行命令<code>npm config set</code>设置新的npm私有源路径，但<code>npm install</code>时，读取的还是<code>package-lock.json</code>里面的，起因是npm私有源路径有改动，这个模版没有及时进行更新。涉及到的知识点可以是<code>package-lock.json</code>和<code>package.json</code>的异同。<code>package.json</code>是对项目的高级描述，用于指定项目的基本信息和依赖包的版本范围，而<code>package-lock.json</code>是由<code>npm</code>自动生成和维护的文件，用于确保项目在不同环境下安装的依赖包的版本一致性，在实际开发中，我们只需要编辑和维护<code>package.json</code>文件，而<code>package-lock.json</code>文件会在每次执行<code>npm install</code>命令时自动更新。</p>
<h2 id="share">Share</h2>
<p>很多时候，察言观色有利于我们读懂对方要说的意思，但在争吵中，这却是有害的，你可能会说，不是有些情况是我们要根据对方的反映，选择一些可以缓和场面的用词么，但是，这个前提是你自己情绪是稳定的，然而，在这一步之前，我们很容易忽略对方说的内容，而过分在意对方说话时的神情和语气，导致自己的情绪先失控了。在这个时候，我们是做不到什么察言观色的，基本无脑输出了，所以在争吵的时候，我们不要在意别人怎么说，只需要在意说的是什么，别人声调一拉高，你也跟着拉高，最后只能针尖对麦芒，无法收场。别人声调一拉高，你还是很平和的说出你自己的观点，别人自然觉得有点尴尬，也会降低声调好好说话。当然你也会说，这也太憋屈了吧，凭啥别人怎么爽都行，不高兴就怼，你却要思前顾后的，一忍再忍，好不窝囊。这当然也没错，但是如果你的目的是想解决问题本身，而不是在争吵上面争个输赢，那也只能如此了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>RMPW Week 1</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/rmpw-week-1/</link>
      <pubDate>Sun, 12 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/rmpw-week-1/</guid>
      <description>&lt;h2 id=&#34;read&#34;&gt;Read&lt;/h2&gt;
&lt;img src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311012011478.jpg&#34; alt=&#34;23845292-2_u_9&#34; style=&#34;zoom: 80%;&#34; /&gt;
&lt;p&gt;《新参者》仿佛还是在沿用《白夜行》的写作方式，表面上一直游离在剧情主线之外，一直在叙述一些仿佛和凶杀案无关的事情，实际上环环相扣，直到最后，才会把所有的事情全都串起来。整本书不算特别惊艳，如果《白夜行》可以是9.7分，那《新参者》可能也就8.0分，行凶者是谁也不觉得有多意外，可能是很晚才出场的缘故，一般最不可能是凶手的，结果是凶手，这种反差可能才会更为强烈，行凶的动机也略微俗套。书中觉得出彩的，反而是一些温暖人心的小事情，大多都是关乎亲情。不同的店铺，不同的家庭，不同表达爱的方式。印象中特别深刻的是，三井峰子对其多年未见、关系紧张的儿子弘毅表达的爱意，那是一个美丽的误会，但却深入人心。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;动机这东西，只要本人不说，就没人知道。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;男人解决不了婆媳间的矛盾，事情没那么简单。你能做的就是倾听各自的说辞。只要默默听就行，一定不要反驳，不然只会火上浇油。听完就做出理解的表情，说她有道理，说得对，然后告诉她会找机会把她的想法转达给另一方。当然，千万不要真去转达。总有一天，她还会责问你，事情办得怎样了。到时你就要忍，让她们把矛头指向你。你能做的只有这些。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;这个嘛，果然是因为你。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;三井女士搬到小传马町后，每天应该都过得很快乐。她完全沉浸在默默守望的愉悦中了。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;我从和户纪子的事中明白了一个道理，那就是男人要想让女人幸福，就得像牛马一样工作。但峰子的行动又告诉我，仅仅那样也不行。我真是蠢极了。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;我的确疼爱儿子，而且对这点很有自信。但疼爱和重视不一样。所谓重视，是考虑孩子的未来，不断为他做出最好的选择，我却没能那么做。我只是为自己有了一个可以倾注爱的对象而极其高兴。&lt;/p&gt;&lt;/blockquote&gt;
&lt;blockquote&gt;
&lt;p&gt;当然，孩子总有一天会长大，不会永远那么可爱，有时还会闯祸。这种时候，父亲往往会选择逃避。工作一忙，他们更为自己找到一个体面的借口。我也一样。妻子跟我说起儿子时，我只嫌她啰唆，根本不想跟她一起解决问题。当妻子因此责怪我时，我总会说自己有工作。即便工作不忙，我也总把这句话当武器，将所有麻烦都推给妻子，甚至在听说儿子交了狐朋狗友时，我也并不在意。我乐观地认为，稍微活泼一点的男孩子总有一段时期会这样。实际上，我的乐观只是在自欺欺人。&lt;/p&gt;&lt;/blockquote&gt;
&lt;h2 id=&#34;movies&#34;&gt;Movies&lt;/h2&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://files.nowre.com/articles/2022/12/oppenheimer.jpeg&#34;&gt;&lt;/p&gt;
&lt;p&gt;去年五六月份就听说克里斯托弗·诺兰要拍一部关于原子弹的电影，当时并不知道奥本海默这个人，后来才去了解了一下。说到诺兰的实拍，不免会在各平台看到很多梗图，印象最深的是女王和天行者的表情图，真的要实拍吗？真的吗&amp;hellip;&amp;hellip;这时想起来还是让人忍俊不禁。时间过得太快了，本来以为诺兰的新作还要很久才能看到，没想到电影那么快就上映了。我上次看诺兰的电影应该是《信条》，虽然很烧脑，但是看完还是觉得不错，我还是比较喜欢有点新意或真正用心去拍的电影。&lt;/p&gt;
&lt;p&gt;有时候我也在想什么才是一部好电影？是票房好？是口碑好？还是看导演是谁？演员是谁？或者说我喜欢的就是？&lt;/p&gt;
&lt;p&gt;《奥本海默》整部电影时长长达3个小时，在电影院里算是相当长了，剧情主要讲述了奥本海默这个项目经理在二战期间带领团队研制原子弹的过程，这就是”曼哈顿计划“，以及二战结束后所遭遇的不公正待遇。看完这部电影，我不禁想起《模仿游戏》、《萨利机长》，还有《钱学森》、《横空出世》，这些电影都与《奥本海默》有相似之处，可能是因为它们都涉及到有毒的青苹果、拍摄手法、个人遭遇以及有关原子弹的话题。&lt;/p&gt;
&lt;p&gt;诺兰在这部电影中依旧使用了他擅长的时间线穿梭叙事手法，如果观影中稍不注意，就会觉得这电影被剪得稀碎，难以理清整部电影剧情的走向。加上彩色和黑白画面的交叉使用，就好像正派和反派的对立着，从不同视角叙说这一段历史，然后才汇集于故事的结局之中，让这种稀碎感更为严重，总的来说，电影还是很能发人深思的。&lt;/p&gt;
&lt;p&gt;核武器的滥用会给人类的未来带来怎样严重的后果？电影中展现了很多奥本海默对后果的想象，无尽的爆炸，无休止的灭亡，哀乐响彻蓝色星球上空。&lt;/p&gt;
&lt;p&gt;“现在我成了死神，世界的毁灭者。”&lt;/p&gt;
&lt;p&gt;基里安·墨菲曾在蝙蝠侠三部曲中饰演稻草人，但我不记得他也出演过《盗梦空间》，这个演员的长相确实很有特点，尤其是他那如海洋一样深邃的眼睛。我听说他主演的《浴血黑帮》电视剧也很不错，打算找时间看一看。&lt;/p&gt;
&lt;p&gt;电影中也讲了奥本海默的情史，不得不说，奥本海默，你可真的是玩得花。&lt;/p&gt;
&lt;p&gt;在《奥本海默》中，只有在实验引爆时才出现蘑菇云，本来以为会看到小男孩和胖子的实拍，可惜并没有。&lt;/p&gt;
&lt;p&gt;电影的音乐非常出色，特别是几段旋律，例如American Prometheus、Can You Hear The Music和Destroyer Of Worlds等，我自己也专门找了一下这些曲子。&lt;/p&gt;
&lt;p&gt;另外，爱因斯坦在电影中出现了几次，这些画面我都非常喜欢，特别是最后和奥本海默在湖边的对话，一下子就升华了电影的主题。&lt;/p&gt;
&lt;p&gt;“有一天，当他们对你的惩罚足够多时，他们会给你提供鲑鱼和土豆沙拉，发表演讲，给你一枚奖章。请记住，这不是为了你，而是为了他们”。&lt;/p&gt;
&lt;p&gt;尽管原子弹在二战的胜利中发挥了重要作用，作为有良心的科学家，我们应该始终为全人类的未来着想。然而，现实往往是残酷的，鸟尽弓藏，到头来只不过是政治斗争中的牺牲品，棋盘上的一枚棋子。&lt;/p&gt;
&lt;h2 id=&#34;poetry&#34;&gt;Poetry&lt;/h2&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311090721103.png&#34;&gt;&lt;/p&gt;
&lt;h2 id=&#34;writing&#34;&gt;Writing&lt;/h2&gt;
&lt;p&gt;其实，本来不打算整这第二个打卡活动了，也就是RMPW，本来ARTS已经够花时间的了。但是不整这个，一来对不上AR7这个网名，本来这个的意思就是这两个打卡活动的开头字母，外加每周一次的意思。&lt;/p&gt;
&lt;p&gt;每次打算去做这个事情，总是害怕做不到怎么办？读书笔记要整理，电影要看，诗词要背，文章要写。仔细想一下，还是很花时间的，看什么书，什么电影，背哪些诗词，自己是很明白的，但是要写什么，倒是难住我了。一开始的设计思路是，把看的书，外加看的电影和背的诗词，联系起来，然后在跑步时，构思一下文章，甚至一篇小说，但是，总觉得太耗时间了，在跑步机上面我要看书的。然后就是，基于世界名画，构思一篇小说，或者看图写话，用文字准确描绘名画的场景，这样一来可以知道世界名画相关知识，增长知识面，二来我也比较感兴趣。但还是觉得不妥，总觉得要素过多，不便于坚持下去，一开始应该从简单的开始，先能坚持一段时间，再慢慢上强度，思来想去，就变成现在这样子，“每周一篇原创作品，畅所欲言，题材不限，体裁不限，如不是诗词，字数800字左右。”本来打算只是100字的，贵在坚持嘛，但是又太简单了，毕竟是以周为单位，不是以天为单位。&lt;/p&gt;
&lt;p&gt;但具体要写些什么呢？&lt;/p&gt;
&lt;p&gt;我自己本来就有写日记，心里话都在里面了（你信么？不信就对了），然后平时工作上面遇到的严重问题，检讨和反思过程也要写一下，加上健身日记，也写写心得体会，接下去要去完善的部分，还有平时的技术博文，感觉自己写东西的机会还是很多的，但大多都率性而为，没有任何约束就是了，通常都是简单检查一下，有没有错别字，有没有病句就够了，至于遣词造句，梳理文章整体脉络，结构，逻辑自洽，是没有什么深入的，别人看得懂就行。想到这些，我就觉得，还是对自己要求高一些，毕竟，我都快忘了写文学方面文章的感觉是什么样的了。不管悲春伤秋？矫揉造作？无病呻吟？还是堆砌辞藻？都有吧，也都忘得七七八八了。&lt;/p&gt;
&lt;p&gt;写到这里，我好像明白为什么这个RMPW被我推迟了一个多月了，因为总是打算去做这些事情之后，才去完成这些环节的工作，比如要去看新的书籍、电影、诗词，完成之后，才可以开始不是？但是，其实不一定非要这样，还有其他的思路，就是先掏空自己，先把自己所做过的会的，先整理出来，看的书和电影，读书时代背了还记得的诗词，先把这些依次输出，一来相对简单，而且刚好可以借此机会重温，二来会促使自己要不断输入，不然就没有东西可写了。&lt;/p&gt;
&lt;p&gt;在小学那时数学老师就告诉我们，写文章的技巧，就是不管三七二十一，想到什么写什么，不要去想写下的文字到底符不符合作文主旨，哪怕前言不搭后语，都可以，全都写出来之后，你就知道自己应该怎么办了。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="read">Read</h2>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311012011478.jpg" alt="23845292-2_u_9" style="zoom: 80%;" />
<p>《新参者》仿佛还是在沿用《白夜行》的写作方式，表面上一直游离在剧情主线之外，一直在叙述一些仿佛和凶杀案无关的事情，实际上环环相扣，直到最后，才会把所有的事情全都串起来。整本书不算特别惊艳，如果《白夜行》可以是9.7分，那《新参者》可能也就8.0分，行凶者是谁也不觉得有多意外，可能是很晚才出场的缘故，一般最不可能是凶手的，结果是凶手，这种反差可能才会更为强烈，行凶的动机也略微俗套。书中觉得出彩的，反而是一些温暖人心的小事情，大多都是关乎亲情。不同的店铺，不同的家庭，不同表达爱的方式。印象中特别深刻的是，三井峰子对其多年未见、关系紧张的儿子弘毅表达的爱意，那是一个美丽的误会，但却深入人心。</p>
<blockquote>
<p>动机这东西，只要本人不说，就没人知道。</p></blockquote>
<blockquote>
<p>男人解决不了婆媳间的矛盾，事情没那么简单。你能做的就是倾听各自的说辞。只要默默听就行，一定不要反驳，不然只会火上浇油。听完就做出理解的表情，说她有道理，说得对，然后告诉她会找机会把她的想法转达给另一方。当然，千万不要真去转达。总有一天，她还会责问你，事情办得怎样了。到时你就要忍，让她们把矛头指向你。你能做的只有这些。</p></blockquote>
<blockquote>
<p>这个嘛，果然是因为你。</p></blockquote>
<blockquote>
<p>三井女士搬到小传马町后，每天应该都过得很快乐。她完全沉浸在默默守望的愉悦中了。</p></blockquote>
<blockquote>
<p>我从和户纪子的事中明白了一个道理，那就是男人要想让女人幸福，就得像牛马一样工作。但峰子的行动又告诉我，仅仅那样也不行。我真是蠢极了。</p></blockquote>
<blockquote>
<p>我的确疼爱儿子，而且对这点很有自信。但疼爱和重视不一样。所谓重视，是考虑孩子的未来，不断为他做出最好的选择，我却没能那么做。我只是为自己有了一个可以倾注爱的对象而极其高兴。</p></blockquote>
<blockquote>
<p>当然，孩子总有一天会长大，不会永远那么可爱，有时还会闯祸。这种时候，父亲往往会选择逃避。工作一忙，他们更为自己找到一个体面的借口。我也一样。妻子跟我说起儿子时，我只嫌她啰唆，根本不想跟她一起解决问题。当妻子因此责怪我时，我总会说自己有工作。即便工作不忙，我也总把这句话当武器，将所有麻烦都推给妻子，甚至在听说儿子交了狐朋狗友时，我也并不在意。我乐观地认为，稍微活泼一点的男孩子总有一段时期会这样。实际上，我的乐观只是在自欺欺人。</p></blockquote>
<h2 id="movies">Movies</h2>
<p><img loading="lazy" src="https://files.nowre.com/articles/2022/12/oppenheimer.jpeg"></p>
<p>去年五六月份就听说克里斯托弗·诺兰要拍一部关于原子弹的电影，当时并不知道奥本海默这个人，后来才去了解了一下。说到诺兰的实拍，不免会在各平台看到很多梗图，印象最深的是女王和天行者的表情图，真的要实拍吗？真的吗&hellip;&hellip;这时想起来还是让人忍俊不禁。时间过得太快了，本来以为诺兰的新作还要很久才能看到，没想到电影那么快就上映了。我上次看诺兰的电影应该是《信条》，虽然很烧脑，但是看完还是觉得不错，我还是比较喜欢有点新意或真正用心去拍的电影。</p>
<p>有时候我也在想什么才是一部好电影？是票房好？是口碑好？还是看导演是谁？演员是谁？或者说我喜欢的就是？</p>
<p>《奥本海默》整部电影时长长达3个小时，在电影院里算是相当长了，剧情主要讲述了奥本海默这个项目经理在二战期间带领团队研制原子弹的过程，这就是”曼哈顿计划“，以及二战结束后所遭遇的不公正待遇。看完这部电影，我不禁想起《模仿游戏》、《萨利机长》，还有《钱学森》、《横空出世》，这些电影都与《奥本海默》有相似之处，可能是因为它们都涉及到有毒的青苹果、拍摄手法、个人遭遇以及有关原子弹的话题。</p>
<p>诺兰在这部电影中依旧使用了他擅长的时间线穿梭叙事手法，如果观影中稍不注意，就会觉得这电影被剪得稀碎，难以理清整部电影剧情的走向。加上彩色和黑白画面的交叉使用，就好像正派和反派的对立着，从不同视角叙说这一段历史，然后才汇集于故事的结局之中，让这种稀碎感更为严重，总的来说，电影还是很能发人深思的。</p>
<p>核武器的滥用会给人类的未来带来怎样严重的后果？电影中展现了很多奥本海默对后果的想象，无尽的爆炸，无休止的灭亡，哀乐响彻蓝色星球上空。</p>
<p>“现在我成了死神，世界的毁灭者。”</p>
<p>基里安·墨菲曾在蝙蝠侠三部曲中饰演稻草人，但我不记得他也出演过《盗梦空间》，这个演员的长相确实很有特点，尤其是他那如海洋一样深邃的眼睛。我听说他主演的《浴血黑帮》电视剧也很不错，打算找时间看一看。</p>
<p>电影中也讲了奥本海默的情史，不得不说，奥本海默，你可真的是玩得花。</p>
<p>在《奥本海默》中，只有在实验引爆时才出现蘑菇云，本来以为会看到小男孩和胖子的实拍，可惜并没有。</p>
<p>电影的音乐非常出色，特别是几段旋律，例如American Prometheus、Can You Hear The Music和Destroyer Of Worlds等，我自己也专门找了一下这些曲子。</p>
<p>另外，爱因斯坦在电影中出现了几次，这些画面我都非常喜欢，特别是最后和奥本海默在湖边的对话，一下子就升华了电影的主题。</p>
<p>“有一天，当他们对你的惩罚足够多时，他们会给你提供鲑鱼和土豆沙拉，发表演讲，给你一枚奖章。请记住，这不是为了你，而是为了他们”。</p>
<p>尽管原子弹在二战的胜利中发挥了重要作用，作为有良心的科学家，我们应该始终为全人类的未来着想。然而，现实往往是残酷的，鸟尽弓藏，到头来只不过是政治斗争中的牺牲品，棋盘上的一枚棋子。</p>
<h2 id="poetry">Poetry</h2>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311090721103.png"></p>
<h2 id="writing">Writing</h2>
<p>其实，本来不打算整这第二个打卡活动了，也就是RMPW，本来ARTS已经够花时间的了。但是不整这个，一来对不上AR7这个网名，本来这个的意思就是这两个打卡活动的开头字母，外加每周一次的意思。</p>
<p>每次打算去做这个事情，总是害怕做不到怎么办？读书笔记要整理，电影要看，诗词要背，文章要写。仔细想一下，还是很花时间的，看什么书，什么电影，背哪些诗词，自己是很明白的，但是要写什么，倒是难住我了。一开始的设计思路是，把看的书，外加看的电影和背的诗词，联系起来，然后在跑步时，构思一下文章，甚至一篇小说，但是，总觉得太耗时间了，在跑步机上面我要看书的。然后就是，基于世界名画，构思一篇小说，或者看图写话，用文字准确描绘名画的场景，这样一来可以知道世界名画相关知识，增长知识面，二来我也比较感兴趣。但还是觉得不妥，总觉得要素过多，不便于坚持下去，一开始应该从简单的开始，先能坚持一段时间，再慢慢上强度，思来想去，就变成现在这样子，“每周一篇原创作品，畅所欲言，题材不限，体裁不限，如不是诗词，字数800字左右。”本来打算只是100字的，贵在坚持嘛，但是又太简单了，毕竟是以周为单位，不是以天为单位。</p>
<p>但具体要写些什么呢？</p>
<p>我自己本来就有写日记，心里话都在里面了（你信么？不信就对了），然后平时工作上面遇到的严重问题，检讨和反思过程也要写一下，加上健身日记，也写写心得体会，接下去要去完善的部分，还有平时的技术博文，感觉自己写东西的机会还是很多的，但大多都率性而为，没有任何约束就是了，通常都是简单检查一下，有没有错别字，有没有病句就够了，至于遣词造句，梳理文章整体脉络，结构，逻辑自洽，是没有什么深入的，别人看得懂就行。想到这些，我就觉得，还是对自己要求高一些，毕竟，我都快忘了写文学方面文章的感觉是什么样的了。不管悲春伤秋？矫揉造作？无病呻吟？还是堆砌辞藻？都有吧，也都忘得七七八八了。</p>
<p>写到这里，我好像明白为什么这个RMPW被我推迟了一个多月了，因为总是打算去做这些事情之后，才去完成这些环节的工作，比如要去看新的书籍、电影、诗词，完成之后，才可以开始不是？但是，其实不一定非要这样，还有其他的思路，就是先掏空自己，先把自己所做过的会的，先整理出来，看的书和电影，读书时代背了还记得的诗词，先把这些依次输出，一来相对简单，而且刚好可以借此机会重温，二来会促使自己要不断输入，不然就没有东西可写了。</p>
<p>在小学那时数学老师就告诉我们，写文章的技巧，就是不管三七二十一，想到什么写什么，不要去想写下的文字到底符不符合作文主旨，哪怕前言不搭后语，都可以，全都写出来之后，你就知道自己应该怎么办了。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 3</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-03/</link>
      <pubDate>Wed, 08 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-03/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为  &lt;a href=&#34;https://leetcode.cn/problems/longest-consecutive-sequence/&#34;&gt;128. 最长连续序列&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个未排序的整数数组 &lt;code&gt;nums&lt;/code&gt; ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。&lt;/p&gt;
&lt;p&gt;请你设计并实现时间复杂度为 &lt;code&gt;O(n)&lt;/code&gt; 的算法解决此问题。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;100&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;200&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;解释&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;：&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;最长数字连续序列是&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;3&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;它的长度为&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;4&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;。&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;longestConsecutive&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 如果数组为空，则值为0，否则最小为1
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceMaxValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;length&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;==&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;?&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 去重，使用对象key唯一性的特性实现数组去重。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 获取最终的去重后的数组
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;Object&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;hasOwnProperty&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;call&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;category&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;Number&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 将数组排序，从小到大排序
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sort&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;x&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;y&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 设置顺序起点为数组下标为0的位置
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 设置顺序起点值，下标为0的值
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;latestStartValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 用来记录每个顺序，以起点为key，总共有多少次。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;c1&#34;&gt;// 因为设置了latestStartValue = result[0]，默认会走else逻辑，sequenceCountObject[0]会多一次。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;c1&#34;&gt;// 实现的逻辑是，比如数组为[1,2,3,4,5,8,9,10]，当后一个数，减去它的下标等于当前值latestStartValue(4-3=1)，意味着还是处于顺序中，如果不是，比如到8了，那就开始新的顺序起点。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;            &lt;span class=&#34;c1&#34;&gt;// 其中，因为第一个起点数，不是每次都是下标0开始的，所以不能只是item - latestStartIndex，而是item - (index - latestStartIndex)拿到差值。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;-&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;latestStartValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;latestStartValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;c1&#34;&gt;// 如果当前值减去下标差值一直等于顺序起点值，意味着还处于顺序中，就加到对象这个以每个起点下标为key的值上，+1。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;                &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;c1&#34;&gt;//当对象中还没有存在这个起点下标的key时，默认从1开始，因为当latestStartIndex开始新的起点的时候，是走上面的if逻辑的，意味着这里要把起点的次数算上，所以是1+1,第一个1是起点，第二个1是记录次数
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;                    &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;latestStartIndex&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;c1&#34;&gt;// 获取多个顺序长度的最大值，如果比当前值大，则赋值最新。
&lt;/span&gt;&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;c1&#34;&gt;&lt;/span&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nb&#34;&gt;Object&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;hasOwnProperty&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;call&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceCountObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;&amp;gt;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceMaxValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;nx&#34;&gt;sequenceMaxValue&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sequenceMaxValue&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为  <a href="https://leetcode.cn/problems/longest-consecutive-sequence/">128. 最长连续序列</a></p>
<p>给定一个未排序的整数数组 <code>nums</code> ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。</p>
<p>请你设计并实现时间复杂度为 <code>O(n)</code> 的算法解决此问题。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="err">：</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="err">：</span><span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">100</span><span class="p">,</span><span class="mi">4</span><span class="p">,</span><span class="mi">200</span><span class="p">,</span><span class="mi">1</span><span class="p">,</span><span class="mi">3</span><span class="p">,</span><span class="mi">2</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="err">：</span><span class="mi">4</span>
</span></span><span class="line"><span class="cl"><span class="nx">解释</span><span class="err">：</span><span class="nx">最长数字连续序列是</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span><span class="err">。</span><span class="nx">它的长度为</span> <span class="mi">4</span><span class="err">。</span>
</span></span></code></pre></div><p>实现代码如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">longestConsecutive</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="c1">// 如果数组为空，则值为0，否则最小为1
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">sequenceMaxValue</span> <span class="o">=</span> <span class="nx">nums</span><span class="p">.</span><span class="nx">length</span> <span class="o">==</span> <span class="mi">0</span> <span class="o">?</span> <span class="mi">0</span> <span class="o">:</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">category</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 去重，使用对象key唯一性的特性实现数组去重。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">nums</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">item</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">category</span><span class="p">[</span><span class="nx">item</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">category</span><span class="p">[</span><span class="nx">item</span><span class="p">].</span><span class="nx">push</span><span class="p">(</span><span class="nx">item</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">category</span><span class="p">[</span><span class="nx">item</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">item</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 获取最终的去重后的数组
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">category</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">category</span><span class="p">,</span> <span class="nx">key</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">result</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nb">Number</span><span class="p">(</span><span class="nx">key</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 将数组排序，从小到大排序
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="nx">result</span><span class="p">.</span><span class="nx">sort</span><span class="p">((</span><span class="nx">x</span><span class="p">,</span> <span class="nx">y</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">return</span> <span class="nx">x</span> <span class="o">-</span> <span class="nx">y</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// 设置顺序起点为数组下标为0的位置
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">latestStartIndex</span> <span class="o">=</span> <span class="mi">0</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 设置顺序起点值，下标为0的值
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">latestStartValue</span> <span class="o">=</span> <span class="nx">result</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">    <span class="c1">// 用来记录每个顺序，以起点为key，总共有多少次。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="kd">let</span> <span class="nx">sequenceCountObject</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">    <span class="nx">result</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">item</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="c1">// 因为设置了latestStartValue = result[0]，默认会走else逻辑，sequenceCountObject[0]会多一次。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>        <span class="k">if</span> <span class="p">(</span><span class="nx">index</span> <span class="o">&gt;</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="c1">// 实现的逻辑是，比如数组为[1,2,3,4,5,8,9,10]，当后一个数，减去它的下标等于当前值latestStartValue(4-3=1)，意味着还是处于顺序中，如果不是，比如到8了，那就开始新的顺序起点。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="c1">// 其中，因为第一个起点数，不是每次都是下标0开始的，所以不能只是item - latestStartIndex，而是item - (index - latestStartIndex)拿到差值。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>            <span class="k">if</span> <span class="p">(</span><span class="nx">item</span> <span class="o">-</span> <span class="p">(</span><span class="nx">index</span> <span class="o">-</span> <span class="nx">latestStartIndex</span><span class="p">)</span> <span class="o">!==</span> <span class="nx">latestStartValue</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">latestStartIndex</span> <span class="o">=</span> <span class="nx">index</span>
</span></span><span class="line"><span class="cl">                <span class="nx">latestStartValue</span> <span class="o">=</span> <span class="nx">result</span><span class="p">[</span><span class="nx">index</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                
</span></span><span class="line"><span class="cl">                <span class="c1">// 如果当前值减去下标差值一直等于顺序起点值，意味着还处于顺序中，就加到对象这个以每个起点下标为key的值上，+1。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>                <span class="k">if</span> <span class="p">(</span><span class="nx">sequenceCountObject</span><span class="p">[</span><span class="nx">latestStartIndex</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">sequenceCountObject</span><span class="p">[</span><span class="nx">latestStartIndex</span><span class="p">]</span> <span class="o">=</span> <span class="nx">sequenceCountObject</span><span class="p">[</span><span class="nx">latestStartIndex</span><span class="p">]</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="c1">//当对象中还没有存在这个起点下标的key时，默认从1开始，因为当latestStartIndex开始新的起点的时候，是走上面的if逻辑的，意味着这里要把起点的次数算上，所以是1+1,第一个1是起点，第二个1是记录次数
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>                    <span class="nx">sequenceCountObject</span><span class="p">[</span><span class="nx">latestStartIndex</span><span class="p">]</span> <span class="o">=</span> <span class="mi">1</span> <span class="o">+</span> <span class="mi">1</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="c1">// 获取多个顺序长度的最大值，如果比当前值大，则赋值最新。
</span></span></span><span class="line"><span class="cl"><span class="c1"></span>    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">sequenceCountObject</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nb">Object</span><span class="p">.</span><span class="nx">hasOwnProperty</span><span class="p">.</span><span class="nx">call</span><span class="p">(</span><span class="nx">sequenceCountObject</span><span class="p">,</span> <span class="nx">key</span><span class="p">))</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="kr">const</span> <span class="nx">value</span> <span class="o">=</span> <span class="nx">sequenceCountObject</span><span class="p">[</span><span class="nx">key</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">value</span> <span class="o">&gt;</span> <span class="nx">sequenceMaxValue</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="nx">sequenceMaxValue</span> <span class="o">=</span> <span class="nx">value</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">sequenceMaxValue</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>首先将整个数组去重，然后从小到大排序，然后通过后一个数减去前一个数，其值是否为1来实现，主要思路是这个，但实现过程中，也是在不断地摸索，整体比前面两道题难很多，具体步骤如下：</p>
<ol>
<li>如果数组为空，则最长连续序列值sequenceMaxValue为0，否则sequenceMaxValue最小为1。</li>
<li>去重，使用对象key唯一性的特性实现数组去重。</li>
<li>获取最终的去重后的数组。</li>
<li>将数组排序，从小到大排序。</li>
<li>将数组遍历，创建一个对象，用每个顺序起点作为key，判断数组中的元素是否在这个顺序中，如果是，其值+1，如果不是，开始新的顺序，使用新的顺序起点为key，以此类推。</li>
<li>然后将对象中，value最大的，就是当前数组中，最长连续序列值。</li>
</ol>
<h2 id="review">Review</h2>
<p><a href="https://medium.com/@kevinnokiawriting/the-more-you-do-the-easier-it-gets-3230f80c7f97">The More You Do, The Easier It Gets | by Kevin Nokia Writing | Medium</a></p>
<p>作者主要是说之前一直喜欢玩电子游戏，花了很多时间在这上面，但是那都是短暂的快乐。所以他想要改变，想做一些值得的东西，那怎么能够改变呢？从习惯入手，在最初的14天或21天会很困难，但是在那之后，你的身体和心灵会帮助你养成你想要养成的新习惯，只需要21天，就会变得不一样，反复做你所做的事情，你做的越多，就越容易。最后，引用了一句宫本武藏的话：</p>
<p>“一开始可能看起来很困难，但不开始一切都很困难。”</p>
<p><img alt="image-20231108215109788" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311082151678.png"></p>
<h2 id="tip">Tip</h2>
<p>在<code>mac</code>下 <code>flutter</code> 怎么切换指定版本？在 <code>flutter sdk</code>目录下，运行命令 <code>git checkout &lt;指定版本&gt;</code>即可，比如 <code>git checkout 3.3.10</code>，然后使用命令 <code>flutter version</code> 查看当前版本，如下所示：<img alt="截屏2023-11-07 17.42.03" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311071742456.png"></p>
<h2 id="share">Share</h2>
<ol>
<li>
<p>学习减肥知识可以在薄荷健康APP上面，有很多教程，可以都看看。</p>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311032213494.png" alt="image-20231103221345776" style="zoom:33%;" />
</li>
<li>
<p>学习时间管理可以在滴答清单APP上面新手指南-最佳实践，上面有很多文章都很不错。</p>
<img src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311032214956.png" alt="image-20231103221454846" style="zoom:33%;" />
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>关于RMPW</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E5%85%B3%E4%BA%8Ermpw/</link>
      <pubDate>Wed, 08 Nov 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E5%85%B3%E4%BA%8Ermpw/</guid>
      <description>&lt;p&gt;&lt;code&gt;RMPW &lt;/code&gt; 是我基于陈皓提出的 &lt;code&gt;ARTS&lt;/code&gt; 所设想的一个关于写作方面的训练活动，以周为单位。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Read&lt;/code&gt;：每周一本书，概括该书内容，摘抄好句，思考感悟。 &lt;a href=&#34;https://weread.qq.com/&#34;&gt;微信读书-正版书籍小说免费阅读 (qq.com)&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Movies&lt;/code&gt;：每周一部电影，概括作品内容，摘抄好句，思考感悟。 &lt;a href=&#34;https://www.libvio.pro/&#34;&gt;LIBVIO-官网&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Poetry&lt;/code&gt;：每周背一首诗词/诗歌。  &lt;a href=&#34;https://www.gushiwen.cn/&#34;&gt;古诗文网-古诗文经典传承 (gushiwen.cn)&lt;/a&gt;上面有&lt;code&gt;译&lt;/code&gt;、&lt;code&gt;注&lt;/code&gt;、&lt;code&gt;赏&lt;/code&gt;、&lt;code&gt;音&lt;/code&gt;、&lt;code&gt;背&lt;/code&gt;功能，还是很方便的。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;writing&lt;/code&gt;：每周一篇原创作品，畅所欲言，题材不限，体裁不限，如不是诗词，字数800字左右。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><code>RMPW </code> 是我基于陈皓提出的 <code>ARTS</code> 所设想的一个关于写作方面的训练活动，以周为单位。</p>
<p><code>Read</code>：每周一本书，概括该书内容，摘抄好句，思考感悟。 <a href="https://weread.qq.com/">微信读书-正版书籍小说免费阅读 (qq.com)</a></p>
<p><code>Movies</code>：每周一部电影，概括作品内容，摘抄好句，思考感悟。 <a href="https://www.libvio.pro/">LIBVIO-官网</a></p>
<p><code>Poetry</code>：每周背一首诗词/诗歌。  <a href="https://www.gushiwen.cn/">古诗文网-古诗文经典传承 (gushiwen.cn)</a>上面有<code>译</code>、<code>注</code>、<code>赏</code>、<code>音</code>、<code>背</code>功能，还是很方便的。</p>
<p><code>writing</code>：每周一篇原创作品，畅所欲言，题材不限，体裁不限，如不是诗词，字数800字左右。</p>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 2</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-02/</link>
      <pubDate>Sun, 29 Oct 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-02/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为  &lt;a href=&#34;https://leetcode.cn/problems/group-anagrams/&#34;&gt;49. 字母异位词分组 - 力扣（LeetCode）&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。&lt;/p&gt;
&lt;p&gt;字母异位词 是由重新排列源单词的所有字母得到的一个新单词。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;示例&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;1&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输入&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;eat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;tea&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;tan&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;ate&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;nat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;bat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;输出&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;bat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;nat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;tan&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;ate&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;eat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;tea&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;实现代码如下所示：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;eat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;tea&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;tan&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;ate&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;nat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s2&#34;&gt;&amp;#34;bat&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;groupAnagrams&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sortedStrs&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;sortedStr&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;split&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;).&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sort&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;().&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;join&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;s2&#34;&gt;&amp;#34;&amp;#34;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;sortedStrs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;sortedStr&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;sortedStrs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;].&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;else&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;str&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;index&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;for&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;kr&#34;&gt;const&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;in&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;categories&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;key&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;])&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;result&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;groupAnagrams&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;strs&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路：&lt;/p&gt;
&lt;p&gt;通过查看示例1的输出数组得知，相同字母但顺序可以不一样，所以我们可以考虑，将各元素重新排序，那么就可以知道哪些元素是相同的。首先，先遍历 &lt;code&gt;strs&lt;/code&gt; 数组，使用 &lt;code&gt;split(&amp;quot;&amp;quot;)&lt;/code&gt; 将字符串&lt;code&gt;str&lt;/code&gt;分割为字符数组，然后使用 &lt;code&gt;sort()&lt;/code&gt; 对字符数组进行排序，最后使用 &lt;code&gt;join(&amp;quot;&amp;quot;)&lt;/code&gt; 将排序后的字符数组拼接为字符串。 &lt;code&gt;sortedStrs&lt;/code&gt; 其值如下：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;aet&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;aet&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;ant&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;aet&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;ant&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;abt&amp;#39;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;然后开始将 &lt;code&gt;sortedStrs&lt;/code&gt; 中的元素进行分类，将相同元素归入同一个数组中，使用对象&lt;code&gt;key&lt;/code&gt;的唯一性进行实现，遍历 &lt;code&gt;sortedStrs&lt;/code&gt; ，将元素作为对象 &lt;code&gt;categories&lt;/code&gt; 的&lt;code&gt;key&lt;/code&gt;值，如果&lt;code&gt;key&lt;/code&gt;没有存在，则生成新的&lt;code&gt;key&lt;/code&gt;，并将元素自身添加至&lt;code&gt;value&lt;/code&gt;数组中，如果已存在，则将元素添加至&lt;code&gt;value&lt;/code&gt;数组中。在以下代码中，如果 &lt;code&gt;sortedStrs&lt;/code&gt; 中有相同的元素，则加入到 &lt;code&gt;categories[str]&lt;/code&gt; 数组中，但是因为 &lt;code&gt;sortedStrs&lt;/code&gt; 是排序后的数据，虽然元素被排序了，但是下标 &lt;code&gt;index&lt;/code&gt; 是不变的，所以就 &lt;code&gt;push&lt;/code&gt; 原数组 &lt;code&gt;strs&lt;/code&gt; 相同下标的元素。因为如下所示：&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为  <a href="https://leetcode.cn/problems/group-anagrams/">49. 字母异位词分组 - 力扣（LeetCode）</a></p>
<p>给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。</p>
<p>字母异位词 是由重新排列源单词的所有字母得到的一个新单词。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">示例</span> <span class="mi">1</span><span class="o">:</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">输入</span><span class="o">:</span> <span class="nx">strs</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;eat&#34;</span><span class="p">,</span> <span class="s2">&#34;tea&#34;</span><span class="p">,</span> <span class="s2">&#34;tan&#34;</span><span class="p">,</span> <span class="s2">&#34;ate&#34;</span><span class="p">,</span> <span class="s2">&#34;nat&#34;</span><span class="p">,</span> <span class="s2">&#34;bat&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl"><span class="nx">输出</span><span class="o">:</span> <span class="p">[[</span><span class="s2">&#34;bat&#34;</span><span class="p">],[</span><span class="s2">&#34;nat&#34;</span><span class="p">,</span><span class="s2">&#34;tan&#34;</span><span class="p">],[</span><span class="s2">&#34;ate&#34;</span><span class="p">,</span><span class="s2">&#34;eat&#34;</span><span class="p">,</span><span class="s2">&#34;tea&#34;</span><span class="p">]]</span>
</span></span></code></pre></div><p>实现代码如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">strs</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&#34;eat&#34;</span><span class="p">,</span> <span class="s2">&#34;tea&#34;</span><span class="p">,</span> <span class="s2">&#34;tan&#34;</span><span class="p">,</span> <span class="s2">&#34;ate&#34;</span><span class="p">,</span> <span class="s2">&#34;nat&#34;</span><span class="p">,</span> <span class="s2">&#34;bat&#34;</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">groupAnagrams</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">strs</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">sortedStrs</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="nx">strs</span><span class="p">.</span><span class="nx">forEach</span><span class="p">(</span><span class="nx">str</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="kd">let</span> <span class="nx">sortedStr</span> <span class="o">=</span> <span class="nx">str</span><span class="p">.</span><span class="nx">split</span><span class="p">(</span><span class="s2">&#34;&#34;</span><span class="p">).</span><span class="nx">sort</span><span class="p">().</span><span class="nx">join</span><span class="p">(</span><span class="s2">&#34;&#34;</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">        <span class="nx">sortedStrs</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">sortedStr</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">categories</span> <span class="o">=</span> <span class="p">{}</span>
</span></span><span class="line"><span class="cl">    <span class="nx">sortedStrs</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">str</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="k">if</span> <span class="p">(</span><span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">].</span><span class="nx">push</span><span class="p">(</span><span class="nx">strs</span><span class="p">[</span><span class="nx">index</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">strs</span><span class="p">[</span><span class="nx">index</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl">        <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">result</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="k">for</span> <span class="p">(</span><span class="kr">const</span> <span class="nx">key</span> <span class="k">in</span> <span class="nx">categories</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">result</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">categories</span><span class="p">[</span><span class="nx">key</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">result</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">groupAnagrams</span><span class="p">(</span><span class="nx">strs</span><span class="p">)</span>
</span></span></code></pre></div><p>解题思路：</p>
<p>通过查看示例1的输出数组得知，相同字母但顺序可以不一样，所以我们可以考虑，将各元素重新排序，那么就可以知道哪些元素是相同的。首先，先遍历 <code>strs</code> 数组，使用 <code>split(&quot;&quot;)</code> 将字符串<code>str</code>分割为字符数组，然后使用 <code>sort()</code> 对字符数组进行排序，最后使用 <code>join(&quot;&quot;)</code> 将排序后的字符数组拼接为字符串。 <code>sortedStrs</code> 其值如下：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="p">[</span> <span class="s1">&#39;aet&#39;</span><span class="p">,</span> <span class="s1">&#39;aet&#39;</span><span class="p">,</span> <span class="s1">&#39;ant&#39;</span><span class="p">,</span> <span class="s1">&#39;aet&#39;</span><span class="p">,</span> <span class="s1">&#39;ant&#39;</span><span class="p">,</span> <span class="s1">&#39;abt&#39;</span> <span class="p">]</span>
</span></span></code></pre></div><p>然后开始将 <code>sortedStrs</code> 中的元素进行分类，将相同元素归入同一个数组中，使用对象<code>key</code>的唯一性进行实现，遍历 <code>sortedStrs</code> ，将元素作为对象 <code>categories</code> 的<code>key</code>值，如果<code>key</code>没有存在，则生成新的<code>key</code>，并将元素自身添加至<code>value</code>数组中，如果已存在，则将元素添加至<code>value</code>数组中。在以下代码中，如果 <code>sortedStrs</code> 中有相同的元素，则加入到 <code>categories[str]</code> 数组中，但是因为 <code>sortedStrs</code> 是排序后的数据，虽然元素被排序了，但是下标 <code>index</code> 是不变的，所以就 <code>push</code> 原数组 <code>strs</code> 相同下标的元素。因为如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">sortedStrs</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">str</span><span class="p">,</span> <span class="nx">index</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">if</span> <span class="p">(</span><span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">])</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">].</span><span class="nx">push</span><span class="p">(</span><span class="nx">strs</span><span class="p">[</span><span class="nx">index</span><span class="p">])</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">categories</span><span class="p">[</span><span class="nx">str</span><span class="p">]</span> <span class="o">=</span> <span class="p">[</span><span class="nx">strs</span><span class="p">[</span><span class="nx">index</span><span class="p">]]</span>
</span></span><span class="line"><span class="cl">    <span class="p">}</span>
</span></span><span class="line"><span class="cl"><span class="p">})</span>
</span></span></code></pre></div><p>至此，我们可以得到<code>categories</code>的值，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="p">{</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">aet</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;eat&#39;</span><span class="p">,</span> <span class="s1">&#39;tea&#39;</span><span class="p">,</span> <span class="s1">&#39;ate&#39;</span><span class="p">],</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">ant</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;tan&#39;</span><span class="p">,</span> <span class="s1">&#39;nat&#39;</span><span class="p">],</span> 
</span></span><span class="line"><span class="cl">    <span class="nx">abt</span><span class="o">:</span> <span class="p">[</span><span class="s1">&#39;bat&#39;</span><span class="p">]</span> 
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>然后通过遍历 <code>categories</code> 对象，将其值加入新的数组<code>result</code>即可完成，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="p">[</span> <span class="p">[</span> <span class="s1">&#39;eat&#39;</span><span class="p">,</span> <span class="s1">&#39;tea&#39;</span><span class="p">,</span> <span class="s1">&#39;ate&#39;</span> <span class="p">],</span> <span class="p">[</span> <span class="s1">&#39;tan&#39;</span><span class="p">,</span> <span class="s1">&#39;nat&#39;</span> <span class="p">],</span> <span class="p">[</span> <span class="s1">&#39;bat&#39;</span> <span class="p">]</span> <span class="p">]</span>
</span></span></code></pre></div><h2 id="review">Review</h2>
<p><a href="https://medium.com/@kevinnokiawriting/why-reading-is-part-of-success-6c9cea0c1edb">Why Reading Is Part of Success | by Kevin Nokia | Medium</a></p>
<p>作者主要是说了阅读为什么可以是成功的一部分，这是因为阅读就像是和他人交流，你总能从别人身上学到一些东西。如果你平时总是很固执和虚荣，觉得自己无所不知，他人的建议置若罔闻，那么你很容易走向困境。如果你想改变这种局面，那就需要知道：</p>
<ol>
<li>固执和虚荣会阻碍学习有价值的东西。</li>
<li>不要仰视任何人，不要瞧不起任何人。</li>
<li>尊重是学习的关键，这就是为什么我们需要倾听别人的声音。</li>
<li>如果你觉得听别人说话很难，那就从阅读开始吧，阅读是教你如何倾听的一个很简单的工具。</li>
<li>你可以从每天阅读5分钟开始。如果你还是觉得很难，你可以先读一分钟。</li>
</ol>
<h2 id="tip">Tip</h2>
<p><code>git clone -b ${1:-dev}</code> 的意思是，将远程仓库的分支代码克隆至本地，如果有传参，则克隆传入的分支代码，如果没有传参，则默认克隆<code>dev</code>分支的代码。通常项目会有设置<code>dev</code>、<code>test</code>、<code>staging</code>和<code>master</code>分支，如果想要部署不同环境时，依赖不同环境的库或项目，就会用到这个动态设置分支名称的功能。比如在<code>install.sh</code>文件中，有如下示例：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">git</span> <span class="nx">clone</span> <span class="o">-</span><span class="nx">b</span> <span class="nx">$</span><span class="p">{</span><span class="mi">1</span><span class="o">:-</span><span class="nx">dev</span><span class="p">}</span> <span class="nx">https</span><span class="o">:</span><span class="c1">//github.com/ar7/test.git
</span></span></span></code></pre></div><p>要在<code>.yml</code>中调用，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="p">.</span><span class="o">/</span><span class="nx">install</span><span class="p">.</span><span class="nx">sh</span> <span class="nx">$</span><span class="p">{</span><span class="nx">BRANCH_NAME</span><span class="p">}</span>
</span></span></code></pre></div><h2 id="share">Share</h2>
<ol>
<li>
<p>人们不会去做你想让他们去做的事情，他们只会去做他们想去做的事情。</p>
</li>
<li>
<p>我觉得一个人只要认真做事，那么就值得肯定，哪怕结果不是很好，那我也会舍得花费时间和精力去协助和分担，因为做好一件事情本来就是很难的，有些事一个人就可以，有些事就需要团队的力量。大家互帮互助，才会走得更远。但是如果和我耍小心机，所作所为完全是为了自己，任务难点就推给别人，一有问题就先甩锅，那么太让我生气了。以前心态还会爆炸，就在想为什么会有这种人，但也只是生闷气，后来想明白了，我只需要多为厚道、认真做事的同事服务，为他们争取更多的利益，偷奸耍滑的睁一只眼闭一只眼就可以了，没必要去指责，用其所长即可。大家都是打工的，爱咋地咋地，只需要重点关注团队核心三四个人，还有剩下认真做事的人就行，其他不值得浪费任何时间。</p>
</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>ARTS Week 1</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-01/</link>
      <pubDate>Sun, 22 Oct 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/arts-week-01/</guid>
      <description>&lt;h2 id=&#34;algorithm&#34;&gt;Algorithm&lt;/h2&gt;
&lt;p&gt;本周的算法题为 &lt;a href=&#34;https://leetcode.cn/problems/two-sum/description/?envType=study-plan-v2&amp;amp;envId=top-100-liked&#34;&gt;1. 两数之和 - 力扣（LeetCode）&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;给定一个整数数组 &lt;code&gt;nums&lt;/code&gt; 和一个整数目标值 &lt;code&gt;target&lt;/code&gt;，请你在该数组中找出 &lt;strong&gt;和为目标值&lt;/strong&gt; &lt;em&gt;&lt;code&gt;target&lt;/code&gt;&lt;/em&gt; 的那 &lt;strong&gt;两个&lt;/strong&gt; 整数，并返回它们的数组下标。&lt;/p&gt;
&lt;p&gt;你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。&lt;/p&gt;
&lt;p&gt;你可以按任意顺序返回答案。&lt;/p&gt;
&lt;pre tabindex=&#34;0&#34;&gt;&lt;code&gt;示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
&lt;/code&gt;&lt;/pre&gt;&lt;p&gt;实现代码如下所示：&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-js&#34; data-lang=&#34;js&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;mi&#34;&gt;2&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;7&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;11&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;15&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;mi&#34;&gt;9&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;kd&#34;&gt;var&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;twoSum&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;kd&#34;&gt;function&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;kd&#34;&gt;let&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;[]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;data&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;!==&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;k&#34;&gt;if&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;+&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;data&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;===&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;i&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                    &lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;j&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;                &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;            &lt;span class=&#34;p&#34;&gt;}&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&lt;/span&gt; &lt;span class=&#34;nb&#34;&gt;Array&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;from&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;k&#34;&gt;new&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;Set&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;))&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;    &lt;span class=&#34;k&#34;&gt;return&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;output&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;};&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;twoSum&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;nums&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;,&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;target&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;p&gt;解题思路是，遍历两次 &lt;code&gt;nums&lt;/code&gt; 数据，然后将 &lt;code&gt;nums[i]&lt;/code&gt; 和 &lt;code&gt;nums[j]&lt;/code&gt; 相加，如果其值等于 &lt;code&gt;target&lt;/code&gt; ，则添加到 &lt;code&gt;output&lt;/code&gt; 数组中，以示例1的数据举例，因为遍历两次，会出现 &lt;code&gt;[0,1]&lt;/code&gt; 和 &lt;code&gt;[1,0]&lt;/code&gt; 的情况，所以需要对数组去重，数组去重使用 &lt;code&gt;Array.from(new Set(output))&lt;/code&gt; 实现。至此，是可以实现示例1的需求了，但是如果是示例2时，就会出问题。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="algorithm">Algorithm</h2>
<p>本周的算法题为 <a href="https://leetcode.cn/problems/two-sum/description/?envType=study-plan-v2&amp;envId=top-100-liked">1. 两数之和 - 力扣（LeetCode）</a></p>
<p>给定一个整数数组 <code>nums</code> 和一个整数目标值 <code>target</code>，请你在该数组中找出 <strong>和为目标值</strong> <em><code>target</code></em> 的那 <strong>两个</strong> 整数，并返回它们的数组下标。</p>
<p>你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。</p>
<p>你可以按任意顺序返回答案。</p>
<pre tabindex="0"><code>示例 1：
输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
</code></pre><p>实现代码如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">nums</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">7</span><span class="p">,</span> <span class="mi">11</span><span class="p">,</span> <span class="mi">15</span><span class="p">],</span> <span class="nx">target</span> <span class="o">=</span> <span class="mi">9</span>
</span></span><span class="line"><span class="cl"><span class="kd">var</span> <span class="nx">twoSum</span> <span class="o">=</span> <span class="kd">function</span> <span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="kd">let</span> <span class="nx">output</span> <span class="o">=</span> <span class="p">[]</span>
</span></span><span class="line"><span class="cl">    <span class="nx">nums</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">item</span><span class="p">,</span> <span class="nx">i</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">nums</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">data</span><span class="p">,</span> <span class="nx">j</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">            <span class="k">if</span> <span class="p">(</span><span class="nx">i</span> <span class="o">!==</span> <span class="nx">j</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                <span class="k">if</span> <span class="p">(</span><span class="nx">item</span> <span class="o">+</span> <span class="nx">data</span> <span class="o">===</span> <span class="nx">target</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">output</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">i</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                    <span class="nx">output</span><span class="p">.</span><span class="nx">push</span><span class="p">(</span><span class="nx">j</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">                <span class="p">}</span>
</span></span><span class="line"><span class="cl">            <span class="p">}</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="p">})</span>
</span></span><span class="line"><span class="cl">    <span class="nx">output</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="k">new</span> <span class="nx">Set</span><span class="p">(</span><span class="nx">output</span><span class="p">))</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">output</span>
</span></span><span class="line"><span class="cl"><span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="nx">twoSum</span><span class="p">(</span><span class="nx">nums</span><span class="p">,</span> <span class="nx">target</span><span class="p">)</span>
</span></span></code></pre></div><p>解题思路是，遍历两次 <code>nums</code> 数据，然后将 <code>nums[i]</code> 和 <code>nums[j]</code> 相加，如果其值等于 <code>target</code> ，则添加到 <code>output</code> 数组中，以示例1的数据举例，因为遍历两次，会出现 <code>[0,1]</code> 和 <code>[1,0]</code> 的情况，所以需要对数组去重，数组去重使用 <code>Array.from(new Set(output))</code> 实现。至此，是可以实现示例1的需求了，但是如果是示例2时，就会出问题。</p>
<pre tabindex="0"><code>示例 2：
输入：nums = [3,2,4], target = 6
输出：[1,2]
</code></pre><p>因为是遍历两次<code>nums</code>数组的，当<code>[0,0]</code>时，也是可以满足等于6的条件的，然后两个0就会被添加到output数组中，然后去重，就会有0，然后我们通过肉眼可知，正确结果是[1,2]的，为了解决这个漏洞就需要判断不要让同下标的数值进行相加，也就是<code>if(i !== j)</code>。</p>
<p>这个代码实现思路其实很不满意，会有更优的实现方式，现在刚开始，首要目的是解得出来，后面总结再进一步学习和优化。</p>
<h2 id="review">Review</h2>
<p><a href="https://medium.com/@mirraesmael/the-reader-in-a-non-bookish-community-9cf4cd075753">The Reader in a Non-Bookish Community | by Mirra Esmael | Sep, 2023 | Medium</a></p>
<ol>
<li>作者认为阅读和成为读者都是一种骄傲，它不是由你读过的书的数量来定义的，也不是因为阅读是大多数人觉得令人生畏的活动之一，而是作为一个读书意味着你的大脑已经探索了无数页的论点、概念、问题和表述。</li>
<li>在作者家乡，根据读者主要阅读材料，可以有三种类型读者：1、为了学习而读书；2、为了背诵《古兰经》；3、为了娱乐而读书，作者是第三种读者。</li>
<li>爱读书的人是积极地、有规律地或大部分时间都在读书的人。</li>
<li>虽然阅读对大多数人来说有积极的内涵和印象，但是没有实际行动来支持这一点。</li>
<li>不管读书带来的是好处还是坏处，作者一直认为它是一个积极的因素，它给作者带来了更多的机会。这就是为什么作者一直在向她的朋友和亲人宣传阅读。</li>
</ol>
<h2 id="tip">Tip</h2>
<pre tabindex="0"><code>node:internal/errors:477
    ErrorCaptureStackTrace(err);
    ^
Error: Command failed with ENOENT: npm run clean
spawn npm run clean ENOENT
    at Process.ChildProcess._handle.onexit (node:internal/child_process:283:19)
    at onErrorNT (node:internal/child_process:478:16)
    at processTicksAndRejections (node:internal/process/task_queues:83:21) {
  errno: -2,
  code: &#39;ENOENT&#39;,
  syscall: &#39;spawn npm run clean&#39;,
  path: &#39;npm run clean&#39;,
  spawnargs: [],
  originalMessage: &#39;spawn npm run clean ENOENT&#39;,
  shortMessage: &#39;Command failed with ENOENT: npm run clean\nspawn npm run clean ENOENT&#39;,
  command: &#39;npm run clean&#39;,
  exitCode: undefined,
  signal: undefined,
  signalDescription: undefined,
  stdout: &#39;&#39;,
  stderr: &#39;&#39;,
  failed: true,
  timedOut: false,
  isCanceled: false,
  killed: false
}
</code></pre><p>从报错信息可知，代码在执行到<code>npm run clean</code>命令时报错了，提示找不到这个命令，但是我复制命令在终端运行是成功的，在windows10系统是没问题的，但我在mac系统上运行就报错了，执行代码如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">await</span> <span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>初步猜测，可能execa用法在mac环境中不生效。将其注释，没有提示报错，所以，接着就要研究如何在mac环境中使用execa了。只需将</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span> 
</span></span></code></pre></div><p>改写为</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;run&#39;</span><span class="p">,</span> <span class="s1">&#39;clean&#39;</span><span class="p">],</span> <span class="p">{</span> <span class="nx">shell</span><span class="o">:</span> <span class="kc">true</span> <span class="p">})</span>
</span></span></code></pre></div><p>即可，这时，我们就会想知道这两种用法有什么区别呢？</p>
<p><code>execa</code>是一个用于执行<code>shell</code>命令的<code>Node.js</code>模块，它可以将命令作为参数传递给它，并返回一个<code>Promise</code>，以便在命令执行完成之后处理。根据报错提示没有找到<code>npm</code>命令，很有可能是execa模块无法正确识别到环境变量。</p>
<p>所以将<code>npm run clean</code>拆分为<code>npm</code>和<code>run clean</code>两个参数，并将 shell 选项设置为<code>true</code>，以便在子进程中运行命令的时候使用默认的<code>shell</code>，这样可以正确找到<code>npm</code>命令并且识别环境变量，找到<code>npm</code>命令。</p>
<h2 id="share">Share</h2>
<ol>
<li>使用<code>ChatGPT</code>有一段时间了，发现用来工作和学习效率真是太高了，只要提问就能得到你想要的答案。我就一直在想，如果我一问就给出全部答案了，那我还写什么技术博文，直接复制粘贴就完成一篇技术博文了。但要真是这样，那可太没意思了，纯粹是搬运工，自己根本没掌握这些知识，有啥用？。<code>ChatGPT</code>只是一个工具，工具没有好坏，要看使用工具的人。</li>
<li>一直觉得“技术+英语+法律”应该是一个比较有优势的程序员形态，技术就像Y轴，英语就像是X轴，法律是坐标轴外圆，这是你能拥有的安全的东西。技术让你站得更高，英语让你看得更远，法律是让你可以做对的事情。</li>
</ol>
]]></content:encoded>
    </item>
    <item>
      <title>关于ARTS</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E5%85%B3%E4%BA%8Earts/</link>
      <pubDate>Sun, 08 Oct 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E5%85%B3%E4%BA%8Earts/</guid>
      <description>&lt;p&gt;&lt;code&gt;ARTS&lt;/code&gt; 是陈皓在课程《左耳听风》中提出的原创概念，以周为单位，循环反复的学习活动。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Algorithm&lt;/code&gt;： 在 &lt;a href=&#34;https://leetcode.cn/&#34;&gt;LeetCode&lt;/a&gt; 上做一道算法题，这一步主要是为了编程的训练和学习，如果不训练，看再多的书籍也是没有用的。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Review&lt;/code&gt;： 读一篇英文文章，主要是为了训练英文，英文能力不行，无法成为技术高手。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Tips&lt;/code&gt;： 分享一个小技术，可以总结和归纳日常生活中的知识点。&lt;/p&gt;
&lt;p&gt;&lt;code&gt;Share&lt;/code&gt;： 分享一个观点，为了让你建立影响力，能够输出价值观。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202310161002811.png&#34;&gt;&lt;/p&gt;</description>
      <content:encoded><![CDATA[<p><code>ARTS</code> 是陈皓在课程《左耳听风》中提出的原创概念，以周为单位，循环反复的学习活动。</p>
<p><code>Algorithm</code>： 在 <a href="https://leetcode.cn/">LeetCode</a> 上做一道算法题，这一步主要是为了编程的训练和学习，如果不训练，看再多的书籍也是没有用的。</p>
<p><code>Review</code>： 读一篇英文文章，主要是为了训练英文，英文能力不行，无法成为技术高手。</p>
<p><code>Tips</code>： 分享一个小技术，可以总结和归纳日常生活中的知识点。</p>
<p><code>Share</code>： 分享一个观点，为了让你建立影响力，能够输出价值观。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202310161002811.png"></p>
]]></content:encoded>
    </item>
    <item>
      <title>问题清单：点亮个人知识地图</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E9%97%AE%E9%A2%98%E6%B8%85%E5%8D%95%E7%82%B9%E4%BA%AE%E4%B8%AA%E4%BA%BA%E7%9F%A5%E8%AF%86%E5%9C%B0%E5%9B%BE/</link>
      <pubDate>Mon, 06 Mar 2023 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/%E9%97%AE%E9%A2%98%E6%B8%85%E5%8D%95%E7%82%B9%E4%BA%AE%E4%B8%AA%E4%BA%BA%E7%9F%A5%E8%AF%86%E5%9C%B0%E5%9B%BE/</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;在工作或学习的过程中，我们会遇到各种各样的问题。这些问题之所以成为问题，是因为它们触及了我们知识的盲区。面对未知，我们需要投入更多时间和精力去学习，逐步填补这些空白，从而点亮我们的知识地图。正是基于这个原因，就有了这个《问题清单》。🔸🔹&lt;/p&gt;&lt;/blockquote&gt;
&lt;h1 id=&#34;1-html&#34;&gt;1. HTML&lt;/h1&gt;
&lt;h2 id=&#34;11-img动态修改图片颜色-&#34;&gt;1.1. &lt;code&gt;&amp;lt;img&amp;gt;&lt;/code&gt;动态修改图片颜色 🔹&lt;/h2&gt;
&lt;p&gt;在实现el-menu动态配置菜单图标的时候，因为从字体图标替换成在线获取的.svg图片，所以需要研究下如何实现动态配置颜色，好解决后续各项目不通过主题的需求。&lt;/p&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-css&#34; data-lang=&#34;css&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nt&#34;&gt;transform&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nt&#34;&gt;translateX&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;nt&#34;&gt;-80px&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nt&#34;&gt;filter&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;:&lt;/span&gt; &lt;span class=&#34;nt&#34;&gt;drop-shadow&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;(&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;#&lt;/span&gt;&lt;span class=&#34;nn&#34;&gt;a80f0f&lt;/span&gt; &lt;span class=&#34;nt&#34;&gt;80px&lt;/span&gt; &lt;span class=&#34;nt&#34;&gt;0&lt;/span&gt;&lt;span class=&#34;o&#34;&gt;);&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h1 id=&#34;2-ai&#34;&gt;2. AI&lt;/h1&gt;
&lt;h2 id=&#34;21-deepseek满血版使用-&#34;&gt;2.1. DeepSeek满血版使用 🔹&lt;/h2&gt;
&lt;p&gt;年前使用&lt;code&gt;DeepSeek&lt;/code&gt;还挺顺畅的，没想到过年期间突然爆火，导致流量暴涨。再加上美帝“亡我之心不死”，天天攻击，导致服务器经常繁忙，有时候重复提问20多次都没反应，实在忍不了了，只能研究其他渠道来使用深度思考（R1）功能。&lt;/p&gt;
&lt;p&gt;经过一番查找，发现可以使用硅基流动（SiliconFlow）提供的服务。硅基流动与华为云联合推出了基于昇腾云的DeepSeek R1 &amp;amp; V3推理服务。使用邀请码注册：https://cloud.siliconflow.cn/i/wDEipqNd，可以赠送13块钱，足够用很久了。不过，由于这是API调用的方式，历史问答的内容无法保留，因此需要结合Cherry Studio客户端软件来使用。&lt;/p&gt;
&lt;p&gt;当然，如果觉得麻烦，也可以考虑使用360的纳米AI搜索的慢思考模式，或者kimi的k1.5长思考模式。不过，就推理方面来说，还是觉得DeepSeek更有意思一些。&lt;/p&gt;
&lt;h1 id=&#34;3-typescript&#34;&gt;3. TypeScript&lt;/h1&gt;
&lt;h2 id=&#34;31-as-keyof-typeof&#34;&gt;3.1. as keyof typeof&lt;/h2&gt;
&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-tsx&#34; data-lang=&#34;tsx&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;Element&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;implicitly&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;has&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;an&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;any&amp;#39;&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;type&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;because&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;expression&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;of&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;type&lt;/span&gt; &lt;span class=&#34;s1&#34;&gt;&amp;#39;string&amp;#39;&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;can&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;t be used to index type &amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39;. No index signature with a parameter of type &amp;#39;&lt;/span&gt;&lt;span class=&#34;kt&#34;&gt;string&lt;/span&gt;&lt;span class=&#34;s1&#34;&gt;&amp;#39; was found on type &amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;{}&lt;/span&gt;&lt;span class=&#34;err&#34;&gt;&amp;#39;&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;div class=&#34;highlight&#34;&gt;&lt;pre tabindex=&#34;0&#34; class=&#34;chroma&#34;&gt;&lt;code class=&#34;language-tsx&#34; data-lang=&#34;tsx&#34;&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;nx&#34;&gt;viewValue&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;forEach&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;((&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;: &lt;span class=&#34;kt&#34;&gt;string&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;)&lt;/span&gt; &lt;span class=&#34;o&#34;&gt;=&amp;gt;&lt;/span&gt; &lt;span class=&#34;p&#34;&gt;{&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;nx&#34;&gt;userInfoList&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;push&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;({&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;          &lt;span class=&#34;nx&#34;&gt;label&lt;/span&gt;: &lt;span class=&#34;kt&#34;&gt;t&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;locale&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;.&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;][&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;],&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;          &lt;span class=&#34;nx&#34;&gt;value&lt;/span&gt;: &lt;span class=&#34;kt&#34;&gt;userInfoObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;[&lt;/span&gt;&lt;span class=&#34;nx&#34;&gt;item&lt;/span&gt; &lt;span class=&#34;kr&#34;&gt;as&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;keyof&lt;/span&gt; &lt;span class=&#34;k&#34;&gt;typeof&lt;/span&gt; &lt;span class=&#34;nx&#34;&gt;userInfoObject&lt;/span&gt;&lt;span class=&#34;p&#34;&gt;]&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;        &lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;span class=&#34;line&#34;&gt;&lt;span class=&#34;cl&#34;&gt;&lt;span class=&#34;p&#34;&gt;})&lt;/span&gt;
&lt;/span&gt;&lt;/span&gt;&lt;/code&gt;&lt;/pre&gt;&lt;/div&gt;&lt;h1 id=&#34;4-javascript&#34;&gt;4. JavaScript&lt;/h1&gt;
&lt;h2 id=&#34;41-arrayprototypeevery&#34;&gt;4.1. Array.prototype.every()&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;every()&lt;/code&gt;&lt;/strong&gt; 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。&lt;/p&gt;
&lt;p&gt;every（）方法用来判断所有元素是否都通过制定函数的测试，&lt;/p&gt;
&lt;h2 id=&#34;42-mathfloor-mathceil-和-mathround-&#34;&gt;4.2. Math.floor() 、Math.ceil() 和 Math.round() 🔹&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;Math.floor()，向下取整，Math.floor(5.96) = 5。&lt;/li&gt;
&lt;li&gt;Math.ceil()，向上取整，Math.ceil(5.96) = 6。&lt;/li&gt;
&lt;li&gt;Math.round()，四舍五入，取其值的绝对值进行四舍五入，如果原数是负数，结果保持为负。比如Math.round(5.96) = 6；Math.round(-5.0001) = -5。&lt;/li&gt;
&lt;/ol&gt;
&lt;h2 id=&#34;43-简述js中-for-in-与-for-of-区别&#34;&gt;4.3. 简述js中 for in 与 for of 区别&lt;/h2&gt;
&lt;h2 id=&#34;44-js-遍历嵌套数组&#34;&gt;4.4. js 遍历嵌套数组&lt;/h2&gt;
&lt;h2 id=&#34;45-arrayprototypereduce-&#34;&gt;4.5. Array.prototype.reduce() 🔹&lt;/h2&gt;
&lt;p&gt;&lt;strong&gt;&lt;code&gt;reduce()&lt;/code&gt;&lt;/strong&gt; 方法对数组中的每个元素按序执行一个提供的 &lt;strong&gt;reducer&lt;/strong&gt; 函数，每一次运行 &lt;strong&gt;reducer&lt;/strong&gt; 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<blockquote>
<p>在工作或学习的过程中，我们会遇到各种各样的问题。这些问题之所以成为问题，是因为它们触及了我们知识的盲区。面对未知，我们需要投入更多时间和精力去学习，逐步填补这些空白，从而点亮我们的知识地图。正是基于这个原因，就有了这个《问题清单》。🔸🔹</p></blockquote>
<h1 id="1-html">1. HTML</h1>
<h2 id="11-img动态修改图片颜色-">1.1. <code>&lt;img&gt;</code>动态修改图片颜色 🔹</h2>
<p>在实现el-menu动态配置菜单图标的时候，因为从字体图标替换成在线获取的.svg图片，所以需要研究下如何实现动态配置颜色，好解决后续各项目不通过主题的需求。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-css" data-lang="css"><span class="line"><span class="cl"><span class="nt">transform</span><span class="o">:</span> <span class="nt">translateX</span><span class="o">(</span><span class="nt">-80px</span><span class="o">);</span>
</span></span><span class="line"><span class="cl"><span class="nt">filter</span><span class="o">:</span> <span class="nt">drop-shadow</span><span class="o">(</span><span class="p">#</span><span class="nn">a80f0f</span> <span class="nt">80px</span> <span class="nt">0</span><span class="o">);</span>
</span></span></code></pre></div><h1 id="2-ai">2. AI</h1>
<h2 id="21-deepseek满血版使用-">2.1. DeepSeek满血版使用 🔹</h2>
<p>年前使用<code>DeepSeek</code>还挺顺畅的，没想到过年期间突然爆火，导致流量暴涨。再加上美帝“亡我之心不死”，天天攻击，导致服务器经常繁忙，有时候重复提问20多次都没反应，实在忍不了了，只能研究其他渠道来使用深度思考（R1）功能。</p>
<p>经过一番查找，发现可以使用硅基流动（SiliconFlow）提供的服务。硅基流动与华为云联合推出了基于昇腾云的DeepSeek R1 &amp; V3推理服务。使用邀请码注册：https://cloud.siliconflow.cn/i/wDEipqNd，可以赠送13块钱，足够用很久了。不过，由于这是API调用的方式，历史问答的内容无法保留，因此需要结合Cherry Studio客户端软件来使用。</p>
<p>当然，如果觉得麻烦，也可以考虑使用360的纳米AI搜索的慢思考模式，或者kimi的k1.5长思考模式。不过，就推理方面来说，还是觉得DeepSeek更有意思一些。</p>
<h1 id="3-typescript">3. TypeScript</h1>
<h2 id="31-as-keyof-typeof">3.1. as keyof typeof</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-tsx" data-lang="tsx"><span class="line"><span class="cl"><span class="nx">Element</span> <span class="nx">implicitly</span> <span class="nx">has</span> <span class="nx">an</span> <span class="s1">&#39;any&#39;</span> <span class="kr">type</span> <span class="nx">because</span> <span class="nx">expression</span> <span class="k">of</span> <span class="kr">type</span> <span class="s1">&#39;string&#39;</span> <span class="nx">can</span><span class="s1">&#39;t be used to index type &#39;</span><span class="p">{}</span><span class="s1">&#39;. No index signature with a parameter of type &#39;</span><span class="kt">string</span><span class="s1">&#39; was found on type &#39;</span><span class="p">{}</span><span class="err">&#39;</span><span class="p">.</span>
</span></span></code></pre></div><div class="highlight"><pre tabindex="0" class="chroma"><code class="language-tsx" data-lang="tsx"><span class="line"><span class="cl"><span class="nx">viewValue</span><span class="p">.</span><span class="nx">forEach</span><span class="p">((</span><span class="nx">item</span>: <span class="kt">string</span><span class="p">)</span> <span class="o">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">        <span class="nx">userInfoList</span><span class="p">.</span><span class="nx">value</span><span class="p">.</span><span class="nx">push</span><span class="p">({</span>
</span></span><span class="line"><span class="cl">          <span class="nx">label</span>: <span class="kt">t</span><span class="p">[</span><span class="nx">locale</span><span class="p">.</span><span class="nx">value</span><span class="p">][</span><span class="nx">item</span><span class="p">],</span>
</span></span><span class="line"><span class="cl">          <span class="nx">value</span>: <span class="kt">userInfoObject</span><span class="p">[</span><span class="nx">item</span> <span class="kr">as</span> <span class="k">keyof</span> <span class="k">typeof</span> <span class="nx">userInfoObject</span><span class="p">]</span>
</span></span><span class="line"><span class="cl">        <span class="p">})</span>
</span></span><span class="line"><span class="cl"><span class="p">})</span>
</span></span></code></pre></div><h1 id="4-javascript">4. JavaScript</h1>
<h2 id="41-arrayprototypeevery">4.1. Array.prototype.every()</h2>
<p><strong><code>every()</code></strong> 方法测试一个数组内的所有元素是否都能通过指定函数的测试。它返回一个布尔值。</p>
<p>every（）方法用来判断所有元素是否都通过制定函数的测试，</p>
<h2 id="42-mathfloor-mathceil-和-mathround-">4.2. Math.floor() 、Math.ceil() 和 Math.round() 🔹</h2>
<ol>
<li>Math.floor()，向下取整，Math.floor(5.96) = 5。</li>
<li>Math.ceil()，向上取整，Math.ceil(5.96) = 6。</li>
<li>Math.round()，四舍五入，取其值的绝对值进行四舍五入，如果原数是负数，结果保持为负。比如Math.round(5.96) = 6；Math.round(-5.0001) = -5。</li>
</ol>
<h2 id="43-简述js中-for-in-与-for-of-区别">4.3. 简述js中 for in 与 for of 区别</h2>
<h2 id="44-js-遍历嵌套数组">4.4. js 遍历嵌套数组</h2>
<h2 id="45-arrayprototypereduce-">4.5. Array.prototype.reduce() 🔹</h2>
<p><strong><code>reduce()</code></strong> 方法对数组中的每个元素按序执行一个提供的 <strong>reducer</strong> 函数，每一次运行 <strong>reducer</strong> 会将先前元素的计算结果作为参数传入，最后将其结果汇总为单个返回值。</p>
<p>比如使用<code>reduce</code>方法找到子数组长度最长的子数组的写法为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">longestSubArray</span> <span class="o">=</span> <span class="nx">arrs</span><span class="p">.</span><span class="nx">reduce</span><span class="p">((</span><span class="nx">prev</span><span class="p">,</span> <span class="nx">current</span><span class="p">)</span> <span class="p">=&gt;</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">    <span class="k">return</span> <span class="nx">prev</span><span class="p">.</span><span class="nx">length</span> <span class="o">&gt;</span> <span class="nx">current</span><span class="p">.</span><span class="nx">length</span> <span class="o">?</span> <span class="nx">prev</span> <span class="o">:</span> <span class="nx">current</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="p">});</span>
</span></span></code></pre></div><p>以下是对JavaScript中数组（Array）原型方法 <code>filter()</code>, <code>from()</code>, 和 <code>map()</code> 的简要解释：</p>
<h3 id="451-arrayprototypefilter">4.5.1. Array.prototype.filter()</h3>
<p><code>filter()</code> 方法创建一个新数组，其包含通过所提供函数实现的测试的所有元素。这个方法对数组的每个元素执行一次给定的函数，并利用返回值（真值）来确定是否保留该元素。
<strong>语法</strong>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">newArray</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">filter</span><span class="p">(</span><span class="nx">callback</span><span class="p">(</span><span class="nx">element</span><span class="p">[,</span> <span class="nx">index</span><span class="p">[,</span> <span class="nx">array</span><span class="p">]])[,</span> <span class="nx">thisArg</span><span class="p">])</span>
</span></span></code></pre></div><p><strong>参数</strong>:</p>
<ul>
<li><code>callback</code>: 用来测试每个元素的函数，它可以接收三个参数：
<ul>
<li><code>element</code>: 当前正在处理的元素。</li>
<li><code>index</code>（可选）: 当前元素的索引。</li>
<li><code>array</code>（可选）: 调用 <code>filter</code> 的数组。</li>
</ul>
</li>
<li><code>thisArg</code>（可选）: 执行 <code>callback</code> 时使用的 <code>this</code> 值。
<strong>返回值</strong>: 一个新的、由通过测试的元素组成的数组。
<strong>示例</strong>:</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">array</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">4</span><span class="p">,</span> <span class="mi">5</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">filteredArray</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">filter</span><span class="p">(</span><span class="nx">element</span> <span class="p">=&gt;</span> <span class="nx">element</span> <span class="o">&gt;</span> <span class="mi">3</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">filteredArray</span><span class="p">);</span> <span class="c1">// [4, 5]
</span></span></span></code></pre></div><h3 id="452-arrayprototypefrom">4.5.2. Array.prototype.from()</h3>
<p><code>from()</code> 方法从类数组对象或可迭代对象创建一个新的、浅拷贝的数组实例。
<strong>语法</strong>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="nx">arrayLike</span><span class="p">[,</span> <span class="nx">mapFn</span><span class="p">[,</span> <span class="nx">thisArg</span><span class="p">]])</span>
</span></span></code></pre></div><p><strong>参数</strong>:</p>
<ul>
<li><code>arrayLike</code>: 一个类数组对象或可迭代对象，用来从中复制元素。</li>
<li><code>mapFn</code>（可选）: 如果指定了该参数，新数组中的每个元素都会执行该回调函数。</li>
<li><code>thisArg</code>（可选）: 执行 <code>mapFn</code> 时使用的 <code>this</code> 值。
<strong>返回值</strong>: 一个新的数组实例。
<strong>示例</strong>:</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">arrayLike</span> <span class="o">=</span> <span class="p">{</span> <span class="nx">length</span><span class="o">:</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">0</span><span class="o">:</span> <span class="s1">&#39;a&#39;</span><span class="p">,</span> <span class="mi">1</span><span class="o">:</span> <span class="s1">&#39;b&#39;</span><span class="p">,</span> <span class="mi">2</span><span class="o">:</span> <span class="s1">&#39;c&#39;</span> <span class="p">};</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">arrayFrom</span> <span class="o">=</span> <span class="nb">Array</span><span class="p">.</span><span class="nx">from</span><span class="p">(</span><span class="nx">arrayLike</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">arrayFrom</span><span class="p">);</span> <span class="c1">// [&#39;a&#39;, &#39;b&#39;, &#39;c&#39;]
</span></span></span></code></pre></div><h3 id="453-arrayprototypemap">4.5.3. Array.prototype.map()</h3>
<p><code>map()</code> 方法创建一个新数组，其结果是该数组中的每个元素都调用一个提供的函数后返回的结果。
<strong>语法</strong>:</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">newArray</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">map</span><span class="p">(</span><span class="nx">callback</span><span class="p">(</span><span class="nx">element</span><span class="p">[,</span> <span class="nx">index</span><span class="p">[,</span> <span class="nx">array</span><span class="p">]])[,</span> <span class="nx">thisArg</span><span class="p">])</span>
</span></span></code></pre></div><p><strong>参数</strong>:</p>
<ul>
<li><code>callback</code>: 为数组中的每个元素执行的函数，它接收三个参数：
<ul>
<li><code>element</code>: 当前正在处理的元素。</li>
<li><code>index</code>（可选）: 当前元素的索引。</li>
<li><code>array</code>（可选）: 调用 <code>map</code> 的数组。</li>
</ul>
</li>
<li><code>thisArg</code>（可选）: 执行 <code>callback</code> 时使用的 <code>this</code> 值。
<strong>返回值</strong>: 一个新数组，每个元素都是回调函数的结果。
<strong>示例</strong>:</li>
</ul>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-javascript" data-lang="javascript"><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">array</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">];</span>
</span></span><span class="line"><span class="cl"><span class="kr">const</span> <span class="nx">mappedArray</span> <span class="o">=</span> <span class="nx">array</span><span class="p">.</span><span class="nx">map</span><span class="p">(</span><span class="nx">element</span> <span class="p">=&gt;</span> <span class="nx">element</span> <span class="o">*</span> <span class="mi">2</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="nx">console</span><span class="p">.</span><span class="nx">log</span><span class="p">(</span><span class="nx">mappedArray</span><span class="p">);</span> <span class="c1">// [2, 4, 6]
</span></span></span></code></pre></div><p>这些方法都是JavaScript数组处理中非常有用的工具，它们允许开发者以声明式的方式操作数组，提高代码的可读性和简洁性。</p>
<p><strong><code>map()</code></strong> 方法<strong>创建一个新数组</strong>，这个新数组由原数组中的每个元素都调用一次提供的函数后的返回值组成。</p>
<h2 id="46-arrayprototypefill-">4.6. Array.prototype.fill() 🔸</h2>
<p><strong><code>fill()</code></strong> 方法用一个固定值填充一个数组中从起始索引（默认为 <code>0</code>）到终止索引（默认为 <code>array.length</code>）内的全部元素。它返回修改后的数组。比如，创建一个数组长度为8，默认值为false的数组：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kd">let</span> <span class="nx">visited</span> <span class="o">=</span> <span class="k">new</span> <span class="nb">Array</span><span class="p">(</span><span class="mi">5</span><span class="p">).</span><span class="nx">fill</span><span class="p">(</span><span class="kc">false</span><span class="p">);</span>
</span></span><span class="line"><span class="cl"><span class="c1">// [false, false, false, false, false]
</span></span></span></code></pre></div><h2 id="47-type-和-interface-声明的区别">4.7. type 和 interface 声明的区别</h2>
<p>type 和 interface 声明的区别，尽量使用 <strong>type</strong> 声明，如果使用 <strong>interface</strong> 但又不进行导出的话，会在 vue-tsc 生成类型声明时报错。</p>
<h2 id="48-jsonstringify-实现原理">4.8. JSON.stringify() 实现原理</h2>
<p>JSON.stringify() 实现原理，多层嵌套数据，转义等等问题理清楚</p>
<h2 id="49-js-二维数组">4.9. js 二维数组</h2>
<h2 id="410-暴力解法">4.10. 暴力解法</h2>
<h2 id="411-mathmin">4.11. Math.min()</h2>
<h2 id="412-双指针">4.12. 双指针</h2>
<h2 id="413-时间复杂度">4.13. 时间复杂度</h2>
<p>时间复杂度是用来衡量算法执行时间随输入规模增长而增长的程度的一个概念。它描述了算法的运行时间与输入规模之间的关系。通常用大O符号（O）来表示。</p>
<p>时间复杂度是对算法运行时间的一个上界估计，表示在最坏情况下，算法的运行时间随输入规模增长的趋势。它帮助我们理解算法在不同规模的输入下的性能表现，并且在选择算法时提供了一个指导。</p>
<p>常见的时间复杂度包括O(1)（常数时间）、O(log n)（对数时间）、O(n)（线性时间）、O(n log n)（线性对数时间）、O(n^2)（平方时间）等。时间复杂度越低，算法的性能越好。</p>
<h2 id="414-string">4.14. String</h2>
<h2 id="415-工厂模式">4.15. 工厂模式</h2>
<h2 id="416-闭包">4.16. 闭包</h2>
<h2 id="417-esmcjs构建">4.17. ESM、CJS构建</h2>
<h2 id="418-async的作用">4.18. async的作用</h2>
<h2 id="419-统计代码运行时长">4.19. 统计代码运行时长</h2>
<p>console.time(&rsquo;test&rsquo;) — 开启一个计时器</p>
<p>console.timeEnd(&rsquo;test&rsquo;) — 结束计时并且将结果在 console 中打印出来</p>
<h2 id="420-可选链操作符">4.20. 可选链操作符</h2>
<h2 id="421-tosorted">4.21. toSorted()</h2>
<pre tabindex="0"><code>const nums = [1, 2, 16, 35, 44, 100, 27, 0]
const newNums = nums.toSorted()
console.log(&#39;newNums---&#39;, newNums)
输出：[0, 1, 100, 16, 2, 27, 35, 44]
</code></pre><p>为啥输出结果没有成功排序？</p>
<h2 id="422-按位非">4.22. 按位非（~）🔸</h2>
<p><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Bitwise_NOT">按位非（~） - JavaScript | MDN (mozilla.org)</a></p>
<p>按位非（~）是一个位运算符，它的作用是对一个数的每个位取反，即0变为1，1变为0。在JavaScript中，对一个数取按位非相当于对这个数取反后再减1。</p>
<h2 id="423-二分查找算法">4.23. 二分查找算法</h2>
<h2 id="424-链表--linkedlist--">4.24. 链表  LinkedList  🔹</h2>
<p>链表（LinkedList）是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一个节点的引用。</p>
<p>常见的有单向链表和双向链表，单向链表中的每个节点只有一个指向下一个节点的引用，双向链表中每个节点都有两个引用，分别指向前一个节点和后一个节点。</p>
<p>链表的实现原理，主要依靠节点之间的引用关系。链表的头部指向第一个节点，而最后一个节点的指针指向 null。这样，当需要遍历链表时，只需从头部开始，依次沿着指针向下移动即可。</p>
<p>举个例子，假设我们有一个单向链表，其中包含节点 A、B、C 和 D，它们依次相连：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">A</span> <span class="o">-&gt;</span> <span class="nx">B</span> <span class="o">-&gt;</span> <span class="nx">C</span> <span class="o">-&gt;</span> <span class="nx">D</span> <span class="o">-&gt;</span> <span class="kc">null</span>
</span></span></code></pre></div><p>如果要查询链表中的某个节点，需要从头节点开始，沿着指针依次移动，直到找到目标节点或者到达链表末尾。</p>
<p>如果要删除或者插入节点，则需要调整相邻节点之间的引用关系，以保持链表的连续性。</p>
<p>与 ArrayList 相比，LinkedList 在查找和修改操作方面效率较低，因为需要遍历整个链表才能找到目标元素，但在增加和删除操作方面效率更高，因为不需要移动元素。</p>
<h2 id="425-动态规划">4.25. 动态规划</h2>
<p>斐波那契数列</p>
<p><a href="https://zhuanlan.zhihu.com/p/365698607">https://zhuanlan.zhihu.com/p/365698607</a></p>
<h2 id="426-returnbreak和continue-">4.26. return、break和continue 🔹</h2>
<ol>
<li>
<p><code>return</code>语句终止函数的执行，并返回一个指定的值给函数调用者。</p>
</li>
<li>
<p><code>break</code>语句中止当前循环，<code>switch</code>语句或<code>label</code>语句，并把程序控制流转到紧接着被中止语句后面的语句。中止外层循环，需使用<code>label</code>语句，在外层<code>for</code>循环前加上<code>outer</code>，然后使用<code>break outer</code>实现。</p>
</li>
<li>
<p><code>continue</code>声明终止当前循环或标记循环的当前迭代中的语句执行，并在下一次迭代时继续执行循环。</p>
</li>
</ol>
<h2 id="427-右移运算符-">4.27. 右移运算符 &raquo;</h2>
<p>为什么使用位右移运算符 &raquo; 0 实现可以实现取整？</p>
<p>在计算机中，位右移运算符 <code>&gt;&gt;</code> 只能用于整数类型，因此无法直接对浮点数进行位右移操作。如果尝试对浮点数进行位右移操作，编译器通常会将浮点数转换为整数，然后进行位右移操作。</p>
<p>在这种情况下，5.5 将被转换为整数 5，然后进行位右移操作。由于位右移操作是整数运算，结果也是整数，因此结果将是整数 5，而不是浮点数 5.5。</p>
<h2 id="428-位移运算符">4.28. 位移运算符</h2>
<p>&laquo; 、&raquo;、&raquo;&gt;</p>
<h2 id="429-赋值运算符">4.29. 赋值运算符</h2>
<p>&amp;=</p>
<h2 id="430-表达式和运算符">4.30. 表达式和运算符</h2>
<p><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators">表达式和运算符</a></p>
<h2 id="431-js向上取整向下取整四舍五入">4.31. JS向上取整、向下取整、四舍五入</h2>
<h2 id="432-字符串数组截取-">4.32. 字符串、数组截取 🔹</h2>
<ol>
<li>String.prototype.split() 方法接受一个模式，通过搜索模式将字符串分割成一个有序的子串列表，将这些子串放入一个数组，并返回该数组。</li>
<li>Array.prototype.splice() 通过移除或者替换已存在的元素和/或添加新元素就地改变一个数组的内容。</li>
<li>Array.prototype.slice() 返回一个新的数组对象，这一对象是一个由 <code>start</code> 和 <code>end</code> 决定的原数组的浅拷贝（包括 <code>start</code>，不包括 <code>end</code>），其中 <code>start</code> 和 <code>end</code> 代表了数组元素的索引。原始数组不会被改变。</li>
<li>Array.prototype.toSpliced() 是 <code>splice()</code>方法的复制版本。它返回一个新数组，并在给定的索引处删除和/或替换了一些元素。</li>
</ol>
<h2 id="433-为什么mathmax---的值为0-">4.33. 为什么Math.max(&hellip;[ &lsquo;&rsquo;, &lsquo;&rsquo;,&rsquo;&rsquo; ])的值为0 🔹</h2>
<p>这行代码使用扩展运算符将数组 <code>[&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;]</code> 展开成参数列表，相当于 <code>Math.max(&quot;&quot;, &quot;&quot;, &quot;&quot;, &quot;&quot;)</code>。由于 <code>Math.max()</code> 方法会将所有参数转换为数字再比较大小，空字符串会被转换为数字 0，因此最终比较的参数为 <code>Math.max(0, 0, 0, 0)</code>。</p>
<p>在 JavaScript 中，空字符串会被转换为数字 0 是因为在进行字符串转换为数字的过程中，如果字符串包含非数字字符（除了符号、小数点等特殊字符），则会被转换为数字 0。</p>
<p>当 JavaScript 引擎在转换字符串为数字时，会按照以下规则进行处理：</p>
<ol>
<li>如果字符串中包含非数字字符（除了符号、小数点等特殊字符），则转换结果为 NaN（Not-a-Number）。</li>
<li>如果字符串为空字符串或只包含空格字符，则转换结果为数字 0。</li>
<li>如果字符串表示整数或浮点数形式的数字（例如 &ldquo;123&rdquo;、&ldquo;3.14&rdquo;），则会按照对应的数字进行转换。</li>
</ol>
<p>因此，空字符串会被转换为数字 0 是因为它不包含任何数字字符，符合规则2的转换规则。</p>
<h2 id="434-数组转字符串">4.34. 数组转字符串</h2>
<p>to.String()</p>
<p>toLocaleString()</p>
<p>join()</p>
<h2 id="435-和的区别">4.35. <code>==</code>和<code>===</code>的区别</h2>
<h2 id="436-string和new-string的区别">4.36. String()和new String()的区别</h2>
<h2 id="437-字符串强制转换">4.37. 字符串强制转换</h2>
<p><a href="https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String#">https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/String#</a>字符串强制转换</p>
<h2 id="438-超长string转number精度丢失问题-">4.38. 超长String转number精度丢失问题 🔹</h2>
<p>在实现算法题时，遇到最后数字相加的值和预期的值不一致，因为使用的Number(str)方法，有一定的区间限制，会出现精度丢失。修改为使用BigInt实现，可以表示任意大的整数，但是BigInt在表示时，后缀会有一个n，这样的话就没办法直接和Number类型的数字进行运算，只能Number转为BigInt来运算，拿到结果之后再进行下一步处理。</p>
<h2 id="439-javascript中spliceslice和split含义和区别">4.39. JavaScript中splice、slice和split含义和区别？</h2>
<h2 id="440-jsonstringify实现原理了解">4.40. JSON.stringify()实现原理了解</h2>
<h2 id="441-base64算法">4.41. Base64算法</h2>
<p><a href="https://blog.csdn.net/qq_19782019/article/details/88117150">什么是Base64算法？——全网最详细讲解-CSDN博客</a></p>
<h2 id="442-hexbinaryascii和base64">4.42. hex、binary、ascii和base64</h2>
<p>Hexadecimal (hex)是一种基于16的数字系统，使用数字0-9和字母A-F来表示数值0-15。它常用于表示二进制数据的编码。</p>
<p>Binary (binary)是一种基于2的数字系统，使用数字0和1来表示数值。它是计算机中最基本的数字系统，用于表示所有的数据和指令。</p>
<p>ASCII (American Standard Code for Information Interchange)是一种字符编码标准，用于将字符映射为整数。每个ASCII字符都有一个对应的整数值，范围从0到127。</p>
<p>Base64是一种编码方式，用于将二进制数据转换为可打印的ASCII字符。它将3个字节的二进制数据编码成4个字符，通常用于在网络传输中传递二进制数据。</p>
<h2 id="443-索引下标">4.43. 索引、下标</h2>
<h2 id="444-哈希表">4.44. 哈希表</h2>
<h2 id="445-栈-">4.45. 栈 🔹</h2>
<p>栈是一种后进先出（LIFO）的数据结构，**类似于我们在现实生活中处理堆叠的物体的方式。**栈的主要操作包括将元素压入栈（push），从栈中弹出元素（pop），和查看栈顶元素（peek）。</p>
<h2 id="446-枚举">4.46. 枚举</h2>
<h2 id="447-export">4.47. export</h2>
<h2 id="448-严格模式">4.48. 严格模式</h2>
<h2 id="449-ts-ignore">4.49. @ts-ignore</h2>
<h2 id="450-constlet和var">4.50. const、let和var</h2>
<h2 id="451-自增运算符">4.51. 自增（++）运算符</h2>
<h2 id="452-什么是-f">4.52. 什么是 F#</h2>
<h2 id="453-typescript中元组的基本使用">4.53. TypeScript中元组的基本使用</h2>
<p>数组合并了相同类型的对象，而元组（Tuple）合并了不同类型的对象。</p>
<h2 id="454-switch-和-if-else-哪个效率高-">4.54. switch 和 if else 哪个效率高 🔹</h2>
<p>在大多数情况下，<code>switch</code> 语句的效率通常比 <code>if else</code> 语句要高。这是因为 <code>switch</code> 语句使用了跳转表来查找符合条件的分支，而不是逐个比较条件。跳转表实际上是一个数组，通过将条件值作为索引，可以直接访问到对应的目标地址。因此，跳转表的查找方式具有固定的时间复杂度 O(1)，无论有多少个分支，查找时间都是恒定的。</p>
<p>相比之下，<code>if else</code> 语句需要逐个比较条件，如果有多个条件，它的查找时间将随着条件数量和复杂度的增加而增加。在最坏的情况下，<code>if else</code> 语句的时间复杂度可能达到 O(n)，其中 n 是分支的数量。</p>
<p>然而，在实际应用中，仍然需要根据具体的场景来选择使用 <code>switch</code> 还是 <code>if else</code>。如果条件是固定的值，且分支数量较多，建议使用 <code>switch</code> 语句。如果条件是动态的，并且需要进行更复杂的条件判断，建议使用 <code>if else</code> 语句。</p>
<h1 id="5-network">5. Network</h1>
<h2 id="51-axios获取数据报错的json数据没有返回到catch里面">5.1. axios获取数据，报错的JSON数据没有返回到catch里面</h2>
<h2 id="52-axios实现自动设置cookie">5.2. axios实现自动设置cookie</h2>
<h2 id="53-axios中断已发出的请求简单示例验证">5.3. axios中断已发出的请求，简单示例验证</h2>
<h2 id="54-dnsurliptcphttp">5.4. DNS、URL、IP、TCP、HTTP</h2>
<h2 id="55-从输入-url-到页面加载完成发生了什么">5.5. 从输入 URL 到页面加载完成，发生了什么？</h2>
<h2 id="56-xmlhttprequest">5.6. XMLHttpRequest</h2>
<h2 id="57-ftp">5.7. FTP</h2>
<h2 id="58-file">5.8. file://</h2>
<h2 id="59-sentry没有8443端口之后">5.9. Sentry没有8443端口之后</h2>
<p>Sentry没有8443端口之后，可以使用Sentry cli登录，自动化上传SourceMap了？为啥？</p>
<h2 id="510-patchput和post方法的区别">5.10. PATCH、PUT和POST方法的区别？🔹</h2>
<table>
  <thead>
      <tr>
          <th>请求方法</th>
          <th>作用</th>
          <th>请求是否有主体</th>
          <th>成功的响应是否有主体</th>
          <th>安全</th>
          <th>幂等</th>
          <th>可缓存</th>
          <th>允许在HTML表单中使用</th>
      </tr>
  </thead>
  <tbody>
      <tr>
          <td>PATCH</td>
          <td>用于对资源进行部分修改。</td>
          <td>是</td>
          <td>可能有</td>
          <td>否</td>
          <td>是</td>
          <td>否</td>
          <td>不允许</td>
      </tr>
      <tr>
          <td>PUT</td>
          <td>创建一个新的资源或用请求的有效载荷替换目标资源的表示。</td>
          <td>是</td>
          <td>可能有</td>
          <td>否</td>
          <td>是</td>
          <td>否</td>
          <td>不允许</td>
      </tr>
      <tr>
          <td>POST</td>
          <td>发送数据给服务器。</td>
          <td>是</td>
          <td>是</td>
          <td>否</td>
          <td>否</td>
          <td>仅在包含足够新的信息时</td>
          <td>允许</td>
      </tr>
  </tbody>
</table>
<p>幂等：任何数量的重复、相同的请求都会使资源处于相同的状态。</p>
<p>以上内容来源于www.mozilla.org。</p>
<h2 id="511-状态码-">5.11. 状态码 🔹</h2>
<p>项目中有些接口，请求的资源大小有200KB之多，在前端页面交互使用上体验很差，而这些资源通常都不会改变，频繁去请求作用不大，徒增服务器负担。为了解决这个问题，引入HTTP 304 状态码机制，当浏览器发起一个条件请求到服务器时，服务器会使用304状态码来表示请求资源未更新，可以直接使用当前缓存的资源，无需再重新从服务器下载。</p>
<ol>
<li>
<p>背景、初衷和目标：304状态码主要是为了减少不必要的网络请求，减少服务器负担和提高性能而设计的。当客户端发起条件请求时，服务器可以通过304状态码告知客户端，所请求的资源未发生变化，可以直接使用当前缓存的资源。</p>
</li>
<li>
<p>优势和劣势：优势：可以减少网络请求加快前端页面加载速度，降低服务器负担。劣势：如果配置不正确，可能导致前端页面展示的不是最新的数据。</p>
</li>
<li>
<p>使用场景： 适用于请求资源过大的业务场景，或者图片、样式等静态资源。</p>
</li>
<li>
<p>组成部分和关键点：前端发起的条件请求时需要在请求头中包含条件标识，如If-Modified-Since、If-None-Match等，服务器收到请求后，判断资源是否有更新，如果没有更新会返回304状态码。</p>
<p>如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">GET</span> <span class="o">/</span><span class="nx">example</span><span class="p">.</span><span class="nx">html</span> <span class="nx">HTTP</span><span class="o">/</span><span class="mf">1.1</span>
</span></span><span class="line"><span class="cl"><span class="nx">Host</span><span class="o">:</span> <span class="nx">www</span><span class="p">.</span><span class="nx">example</span><span class="p">.</span><span class="nx">com</span>
</span></span><span class="line"><span class="cl"><span class="nx">If</span><span class="o">-</span><span class="nx">None</span><span class="o">-</span><span class="nx">Match</span><span class="o">:</span> <span class="s2">&#34;abc123&#34;</span>
</span></span><span class="line"><span class="cl"><span class="nx">If</span><span class="o">-</span><span class="nx">Modified</span><span class="o">-</span><span class="nx">Since</span><span class="o">:</span> <span class="nx">Fri</span><span class="p">,</span> <span class="mi">24</span> <span class="nx">Nov</span> <span class="mi">2023</span> <span class="mi">01</span><span class="o">:</span><span class="mi">27</span><span class="o">:</span><span class="mi">35</span> <span class="nx">GMT</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="nx">HTTP</span><span class="o">/</span><span class="mf">1.1</span> <span class="mi">304</span> <span class="nx">Not</span> <span class="nx">Modified</span>
</span></span></code></pre></div></li>
<li>
<p>底层原理和关键实现：当服务器收到前端发起的请求之后，会比较请求中的条件标识和资源的最后更新时间或实体标签，判断资源是否有更新，如果没有更新则返回304状态码，否则会返回200状态码和最新的资源内容。</p>
</li>
<li>
<p>已有的实现和对比： 大多数主流的web服务器和浏览器都支持304状态码，如Apache、Nginx、IIS等。与传统的200状态码相比，304状态码能更有效地利用缓存，减少不必要的网络请求和降低服务器资源负担。</p>
</li>
</ol>
<p>要验证服务器是否正确处理304状态码，可以打开浏览器的开发者工具中切换到 Network（网络）选项卡，查看指定的网络请求，在第一次请求之后的请求，是否显示  304 Not Modified ，然后其 Size 和Time 是否较少。如是，就说明在请求时，是使用了浏览器自身的缓存而不是重新从服务器下载资源。</p>
<h2 id="512-fetch-api">5.12. Fetch API</h2>
<h2 id="513-http请求行请求头请求体响应行响应头响应体详解">5.13. HTTP请求行、请求头、请求体、响应行、响应头、响应体详解</h2>
<h1 id="6-git">6. Git</h1>
<h2 id="61-git-clone--b-1-dev">6.1. git clone -b ${1:-dev}</h2>
<h2 id="62-gitlab-仓库迁移-">6.2. gitlab 仓库迁移 🔹</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl"> git clone --mirror url
</span></span><span class="line"><span class="cl"> git remote set-url –-push origin url
</span></span><span class="line"><span class="cl"> git push --mirror 
</span></span></code></pre></div><p>然后会出现提示没有权限的问题，如下图所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202404091559471.png"></p>
<pre tabindex="0"><code>remote: GitLab: You are not allowed to force push code to a protected branch on this project.
</code></pre><p>需要打开GitLab，在项目设置那里，开启允许强制更新开关，然后再运行命令<code>git push --mirror</code>即可。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202404091600182.png"></p>
<h2 id="63-git-pull放弃本地修改强制更新-">6.3. git pull放弃本地修改，强制更新 🔹</h2>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git fetch --all
</span></span><span class="line"><span class="cl">git reset --hard origin/master
</span></span><span class="line"><span class="cl">git clean -f -d
</span></span></code></pre></div><ol>
<li><code>git fetch --all</code>：从远程仓库获取最新的内容。</li>
<li><code>git reset --hard origin/master</code>：将本地仓库的内容重置为与远程仓库相同，包括放弃任何本地修改。</li>
<li><code>git clean -f -d</code>：清除工作目录中未跟踪的文件和目录。</li>
</ol>
<h2 id="64-git-clone-fatal发送请求时出错-">6.4. git clone fatal：发送请求时出错 🔹</h2>
<p>在使用<code>git clone</code>项目时，提示以下信息，然后一直需要提示输入用户名和密码。</p>
<pre tabindex="0"><code>fatal: 发送请求时出错。
fatal: 服务器提交了协议冲突. Section=ResponseStatusLine
</code></pre><p>从上面可知，应该是git配置上面出现了问题，所以就打算将<code>git</code>配置初始化，通过以下命令查看<code>git</code>配置文件所在位置，并将所有<code>.gitconfig</code>文件全都删除。</p>
<pre tabindex="0"><code>git config --list --show-origin
</code></pre><p>重新打开<code>Git Bash Here</code>，使用以下命令，然后配置<code>Git</code>在本地存储凭据信息，以便自动记住用户名和密码，避免每次进行<code>Git</code>操作时都需要输入凭据信息。</p>
<pre tabindex="0"><code>git config --global credential.helper store
</code></pre><p>然后只要输入一次用户名和密码，后续操作就都不需要输入了。</p>
<h2 id="65-git命令出现fatal-发送请求时出错错误-">6.5. git命令出现“fatal: 发送请求时出错”错误 🔸</h2>
<p>fatal: 发送请求时出错。
fatal: 服务器提交了协议冲突. Section=ResponseStatusLine</p>
<h2 id="66-git-clone-xxx-not-found-">6.6. git clone xxx not found 🔹</h2>
<p>在使用git从gitlab下载项目的时候，出现以下这个报错问题：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">fatal</span><span class="o">:</span> <span class="nx">repository</span> <span class="s1">&#39;https://gitlab.xxx.com/xxx/web/project-name/&#39;</span> <span class="nx">not</span> <span class="nx">found</span>
</span></span></code></pre></div><p>因为URL是copy的，所以不会弄错，猜测应该是用户名和密码异常，所以使用以下命令进行配置：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git config --global user.name <span class="s2">&#34;xxxx&#34;</span>
</span></span><span class="line"><span class="cl">git config --global user.password <span class="s2">&#34;xxxx&#34;</span>
</span></span></code></pre></div><p>发现还是失败了，就想着怎么触发用户民和密码输入那个弹窗。看了一下发现使用的URL其实是没有.git结尾的，修改了一下clone的命令为：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bash" data-lang="bash"><span class="line"><span class="cl">git clone https://gitlab.xxx.com/xxx/web/project-name.git
</span></span></code></pre></div><p>此时，触发了用户名和密码输入弹窗，填入正确信息即可，问题解决。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402021037069.png"></p>
<h2 id="67-git命令窗口样式美化-">6.7. git命令窗口样式美化 🔹</h2>
<p>用了七八年的东西，一直没有关注样式问题，只觉得还行，但是最近安装nvm，发现一下字体看不清，就看下怎么设置样式，才发现这个可以右键Options然后进行设置，除了字体颜色、背景色，还有主题可选，但是试用了一下，不够美观，如下所示：</p>
<p><img alt="企业微信截图_1706757695363" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402011121252.png"></p>
<p>在网上查了一下，发现这个样式还不错。<a href="https://blog.csdn.net/qq_46359697/article/details/107756317">Git Bash界面的美化（一看必会）_git bash美化-CSDN博客</a>，配置流程就是修改.minttyrc文件，位置在<code>C:\Users\weihao</code>，将里面的使用#注释，然后复制样式覆盖即可。</p>
<h2 id="68-git-切换分支-">6.8. git 切换分支 🔹</h2>
<ol>
<li>git branch  查看当前分支</li>
<li>git branch -r 查看远程仓库的分支列表</li>
<li>git checkout <branch-name> 切换到已存在的分支</li>
<li>git checkout -b <new-branch-name> 创建并切换到新分支</li>
</ol>
<p>在切换分支前，确保你的工作目录是干净的（没有未提交的更改）。如果有未提交的更改，可以使用<code>git stash</code>命令将其暂存起来，然后再切换分支。</p>
<h1 id="7-npm">7. npm</h1>
<h2 id="71-怎么通过vue3项目相关配置知道其依赖的node和npm版本">7.1. 怎么通过Vue3项目相关配置，知道其依赖的node和npm版本</h2>
<h2 id="72-node和npm是什么关系">7.2. node和npm是什么关系</h2>
<h2 id="73-为什么npm升级之后不做向前兼容老项目需要依赖指定版本才可以正常运行">7.3. 为什么npm升级之后不做向前兼容，老项目需要依赖指定版本才可以正常运行</h2>
<h2 id="74-npm-install-命令-整个流程是什么样子的">7.4. npm install 命令 整个流程是什么样子的</h2>
<h2 id="75-npm-run-dev-命令整个流程又是什么样子的">7.5. npm run dev 命令整个流程又是什么样子的</h2>
<h2 id="76---force--和---legacy-peer-deps--的区别是什么">7.6. <code>--force</code>  和 <code>--legacy-peer-deps</code>  的区别是什么</h2>
<h2 id="77-npmnode怎么做到前端组规范">7.7. npm、node怎么做到前端组规范</h2>
<h2 id="78-npm-升级至最新命令-npm-install--g-npmlatest">7.8. npm 升级至最新命令 npm install -g npm@latest</h2>
<h2 id="79-npm-安装指定版本命令-npm-install---g">7.9. npm 安装指定版本命令 npm install <a href="mailto:npm@6.14.15">npm@6.14.15</a> -g</h2>
<h2 id="710-error-command-failed-with-enoent-npm-run-clean">7.10. Error: Command failed with ENOENT: npm run clean🔹</h2>
<p>在维护部门内部的API库时，出现执行命令报错，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202309251531813.png"></p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">errors</span><span class="o">:</span><span class="mi">477</span>
</span></span><span class="line"><span class="cl">    <span class="nx">ErrorCaptureStackTrace</span><span class="p">(</span><span class="nx">err</span><span class="p">);</span>
</span></span><span class="line"><span class="cl">    <span class="o">^</span>
</span></span><span class="line"><span class="cl"><span class="nb">Error</span><span class="o">:</span> <span class="nx">Command</span> <span class="nx">failed</span> <span class="kd">with</span> <span class="nx">ENOENT</span><span class="o">:</span> <span class="nx">npm</span> <span class="nx">run</span> <span class="nx">clean</span>
</span></span><span class="line"><span class="cl"><span class="nx">spawn</span> <span class="nx">npm</span> <span class="nx">run</span> <span class="nx">clean</span> <span class="nx">ENOENT</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">Process</span><span class="p">.</span><span class="nx">ChildProcess</span><span class="p">.</span><span class="nx">_handle</span><span class="p">.</span><span class="nx">onexit</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">child_process</span><span class="o">:</span><span class="mi">283</span><span class="o">:</span><span class="mi">19</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">onErrorNT</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">child_process</span><span class="o">:</span><span class="mi">478</span><span class="o">:</span><span class="mi">16</span><span class="p">)</span>
</span></span><span class="line"><span class="cl">    <span class="nx">at</span> <span class="nx">processTicksAndRejections</span> <span class="p">(</span><span class="nx">node</span><span class="o">:</span><span class="nx">internal</span><span class="o">/</span><span class="nx">process</span><span class="o">/</span><span class="nx">task_queues</span><span class="o">:</span><span class="mi">83</span><span class="o">:</span><span class="mi">21</span><span class="p">)</span> <span class="p">{</span>
</span></span><span class="line"><span class="cl">  <span class="nx">errno</span><span class="o">:</span> <span class="o">-</span><span class="mi">2</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">code</span><span class="o">:</span> <span class="s1">&#39;ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">syscall</span><span class="o">:</span> <span class="s1">&#39;spawn npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">path</span><span class="o">:</span> <span class="s1">&#39;npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">spawnargs</span><span class="o">:</span> <span class="p">[],</span>
</span></span><span class="line"><span class="cl">  <span class="nx">originalMessage</span><span class="o">:</span> <span class="s1">&#39;spawn npm run clean ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">shortMessage</span><span class="o">:</span> <span class="s1">&#39;Command failed with ENOENT: npm run clean\nspawn npm run clean ENOENT&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">command</span><span class="o">:</span> <span class="s1">&#39;npm run clean&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">exitCode</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">signal</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">signalDescription</span><span class="o">:</span> <span class="kc">undefined</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">stdout</span><span class="o">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">stderr</span><span class="o">:</span> <span class="s1">&#39;&#39;</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">failed</span><span class="o">:</span> <span class="kc">true</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">timedOut</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">isCanceled</span><span class="o">:</span> <span class="kc">false</span><span class="p">,</span>
</span></span><span class="line"><span class="cl">  <span class="nx">killed</span><span class="o">:</span> <span class="kc">false</span>
</span></span><span class="line"><span class="cl"><span class="p">}</span>
</span></span></code></pre></div><p>从报错信息可知，代码在执行到<code>npm run clean</code>命令时报错了，提示找不到这个命令，但是我复制命令在终端运行是成功的，在windows10系统是没问题的，但我在mac系统上运行就报错了，执行代码如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="kr">await</span> <span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span>
</span></span></code></pre></div><p>初步猜测，可能execa用法在mac环境中不生效。将其注释，没有提示报错，所以，接着就要研究如何在mac环境中使用execa了。只需将</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm run clean&#39;</span><span class="p">)</span> 
</span></span></code></pre></div><p>改写为</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">execa</span><span class="p">(</span><span class="s1">&#39;npm&#39;</span><span class="p">,</span> <span class="p">[</span><span class="s1">&#39;run&#39;</span><span class="p">,</span> <span class="s1">&#39;clean&#39;</span><span class="p">],</span> <span class="p">{</span> <span class="nx">shell</span><span class="o">:</span> <span class="kc">true</span> <span class="p">})</span>
</span></span></code></pre></div><p>即可，这时，我们就会想知道这两种用法有什么区别呢？</p>
<p><code>execa</code>是一个用于执行<code>shell</code>命令的<code>Node.js</code>模块，它可以将命令作为参数传递给它，并返回一个<code>Promise</code>，以便在命令执行完成之后处理。根据报错提示没有找到<code>npm</code>命令，很有可能是execa模块无法正确识别到环境变量。</p>
<p>所以将<code>npm run clean</code>拆分为<code>npm</code>和<code>run clean</code>两个参数，并将 shell 选项设置为<code>true</code>，以便在子进程中运行命令的时候使用默认的<code>shell</code>，这样可以正确找到<code>npm</code>命令并且识别环境变量，找到<code>npm</code>命令。</p>
<h2 id="711-npm-i-时卡住了">7.11. npm i 时卡住了🔹</h2>
<p>在使用<code>npm i</code>命令给项目安装依赖时，出现卡住的情况，等了好久，也没见成功或者中断，这就无法入手去解决问题。使用命令<code>npm install --verbose</code>可以看到安装的更多信息，便于排查问题。</p>
<h2 id="712-在windows环境使用git安装nvm-">7.12. 在windows环境使用git安装nvm 🔹</h2>
<p>因公司电脑做了软件安装限制，导致不能使用.exe方式配置nvm工具，但是平时项目开发中，经常需对老项目使用不同的node版本，所以这个工具还是很重要的。确定研究一下有没有其他方式配置nvm，在github上看到有<a href="https://github.com/nvm-sh/nvm?tab=readme-ov-file#git-install">Git Install</a>章节，用法是要git clone项目源码下来，然后配置，但是现在github一直clone不了项目，所以就去gitee上看了一下，发现有这个仓库<a href="https://gitee.com/RubyMetric/nvm-cn?_from=gitee_search">nvm-cn: 🧊 nvm国内安装工具 (gitee.com)</a>，用法很简单，只需要在<code>Git Bash Here</code>上使用以下命令即可安装：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">bash -c <span class="s2">&#34;</span><span class="k">$(</span>curl -fsSL https://gitee.com/RubyMetric/nvm-cn/raw/main/install.sh<span class="k">)</span><span class="s2">&#34;</span>
</span></span></code></pre></div><p>然后验证一下，使用命令<code>nvm ls</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402011112106.png"></p>
<p>使用<code>nvm</code>命令时只能在<code>Git Bash Here</code>上使用，在<code>Windows PowerShell</code>和<code>CMD</code>命令窗口是使用不了的。</p>
<p>安装新版本</p>
<pre tabindex="0"><code>nvm install 20.11.1
</code></pre><p>切换版本</p>
<pre tabindex="0"><code>nvm use 16.14.2
</code></pre><p>指定默认的Node版本，使用一下命令：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">nvm</span> <span class="nx">alias</span> <span class="k">default</span> <span class="mf">16.14</span><span class="p">.</span><span class="mi">2</span>
</span></span></code></pre></div><p>问题：git bash here每次启动都很慢。</p>
<p><a href="https://superuser.com/questions/1733316/git-bash-extremely-slow-start-up-on-windows">Git Bash extremely slow start up on Windows - Super User</a></p>
<h2 id="713-npm-elasticdump">7.13. npm elasticdump</h2>
<h2 id="714-npm-install-xxxx-legacy-peer-deps">7.14. npm install xxxx &ndash;legacy-peer-deps</h2>
<p>npm install xxxx &ndash;legacy-peer-deps 解决依赖冲突 （https://bbs.huaweicloud.com/blogs/349716?utm_source=zhihu&amp;utm_medium=bbs-ex&amp;utm_campaign=other&amp;utm_content=content）</p>
<h2 id="715-npmyarnpnpm-幽灵依赖">7.15. npm、yarn、pnpm 幽灵依赖</h2>
<h2 id="716-pnpm-的-workspaces-方案">7.16. pnpm 的 workspaces 方案</h2>
<h2 id="717-npm-config-set设置了新的npm私有源但是一直没有生效">7.17. npm config set设置了新的npm私有源，但是一直没有生效🔹</h2>
<p><code>npm install</code> 自己<code>vue next</code>模版，出现封装的库引向的是<code>192.168.24.XXX</code>的npm私有源，使用命令<code>npm config set</code>设置了新的npm私有源<code>112.230.193.XXX</code>，但是一直没有生效，总是报错如下：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311081429242.png"></p>
<p>原因是因为<code>package-lock.json</code>里面的是<code>192.168.24.XXX</code>的npm私有源，虽然在终端运行命令<code>npm config set</code>设置新的npm私有源路径，但<code>npm install</code>时，读取的还是<code>package-lock.json</code>里面的，起因是npm私有源路径有改动，这个模版没有及时进行更新。涉及到的知识点可以是<code>package-lock.json</code>和<code>package.json</code>的异同。<code>package.json</code>是对项目的高级描述，用于指定项目的基本信息和依赖包的版本范围，而<code>package-lock.json</code>是由<code>npm</code>自动生成和维护的文件，用于确保项目在不同环境下安装的依赖包的版本一致性，在实际开发中，我们只需要编辑和维护<code>package.json</code>文件，而<code>package-lock.json</code>文件会在每次执行<code>npm install</code>命令时自动更新。</p>
<h2 id="718-rollup550">7.18. Rollup5.50</h2>
<h2 id="719-esbuild">7.19. esbuild</h2>
<h2 id="720-zwsvue-next-workspace540-">7.20. &ldquo;@zws/vue-next&rdquo;: &ldquo;workspace:5.40 &quot;</h2>
<p>&ldquo;@zws/vue-next&rdquo;: &ldquo;workspace:5.40 &ldquo;这个用法为什么会失败？原因是pnpm的workspace用法上面有问题。</p>
<h2 id="721-npm--d--dev--g">7.21. npm -D -dev -g</h2>
<h2 id="722-pnpm-的-monorepo">7.22. pnpm 的 monorepo</h2>
<h2 id="723-什么是npx">7.23. 什么是npx？🔹</h2>
<p>因为最近在项目Vue3中集成Sentry前端异常监控系统，看到官方文档里有使用npx的指令，就去了解了一下。当你在项目中使用npx执行一个命令时，npx 会在当前项目的的<code>./node_modules/.bin</code>目录下查找是否有对应可执行的命令，没有找到的话再从全局环境查找是否有安装对应的模块，如果全局环境中没有，会创建一个临时目录，并在其中下载对应的模块，命令执行完毕后临时目录会被删除，不会占有本地资源。这种机制可以确保在执行命令时使用最新的模块，并且不会对全局环境造成过多的污染。</p>
<h2 id="724-使用npm-install-packagelatest-时安装的是v160还是v161-beta-">7.24. 使用npm install package@latest 时，安装的是V1.6.0还是V1.6.1-beta ？🔹</h2>
<p>在部门搭建私有<code>npm</code>仓库，对一些组件库和工具库进行管理，但是出现有同事使用<code>package@latest</code>下载到了<code>beta</code>版本，研究了<code>npm</code>发包机制知道问题出在哪里，因为在发布版本时，都是使用<code>npm publish</code>命令的，所以事实上<code>V1.6.0-beta</code>只是名称改为了<code>-beta</code>而已，要解决这个问题，后续beta版本发布时，需要使用命令<code>npm publish --tag beta</code>。官方文档如下<a href="https://docs.npmjs.com/adding-dist-tags-to-packages">Adding dist-tags to packages | npm Docs (npmjs.com)</a>。</p>
<h1 id="8-vue">8. Vue</h1>
<h2 id="81-createwebhashhistory">8.1. createWebHashHistory</h2>
<h2 id="82-vuepress-2x-打包流程机制以及md文档越来越多打包特别慢的原因">8.2. vuepress 2.x 打包流程机制，以及md文档越来越多，打包特别慢的原因</h2>
<h2 id="83-chrome使用http访问会强转为https的问题-">8.3. Chrome使用http访问会强转为https的问题 🔹</h2>
<p>使用Chrome访问HTTP网站时，若浏览器自动转为HTTPS导致访问失败，可尝试以下步骤解决：</p>
<ol>
<li>在Chrome浏览器地址栏输入<code>chrome://net-internals/#hsts</code>并回车。</li>
<li>找到页面中的<code>Delete domain security policies</code>部分。</li>
<li>输入导致问题的网站域名。</li>
<li>点击<code>Delete</code>按钮删除该域名的安全策略。</li>
</ol>
<p>完成上述步骤后，Chrome将不再自动将HTTP请求转为HTTPS，从而解决强转为https的问题。</p>
<h2 id="84-chrome-调试鼠标悬停后出现的元素-">8.4. Chrome 调试鼠标悬停后出现的元素 🔹</h2>
<p>在<code>Vue Next</code>项目开发过程中，我们需要调试一些鼠标悬停才会出现的元素，比如<code>Element Plus</code> 里的 <code>&lt;el-dropdown&gt;</code> 组件，如要修改它下拉菜单的背景色，可使用鼠标悬停显示下拉框，然后按下快捷键 <code>Ctrl + Shift + C</code> 触发视图查看，再点击下拉框即可获取<code>Class</code>名称进行修改，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407050954853.png"></p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202407051007783.png"></p>
<h2 id="85-pixijs">8.5. pixijs</h2>
<p><a href="https://pixijs.com/">https://pixijs.com/</a></p>
<h2 id="86-vue-i18n-must-be-called-at-the-top-of-a-setup-function">8.6. vue-i18n Must be called at the top of a <code>setup</code> function</h2>
<p>在使用vue-i18n的时候，因为是在组合式函数.ts文件中使用的，所以，报错显示如下信息：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="nx">Must</span> <span class="nx">be</span> <span class="nx">called</span> <span class="nx">at</span> <span class="nx">the</span> <span class="nx">top</span> <span class="k">of</span> <span class="nx">a</span> <span class="sb">`setup`</span> <span class="kd">function</span>
</span></span></code></pre></div><h2 id="87-升级packagejson中全部依赖包到最新版本-">8.7. 升级package.json中全部依赖包到最新版本 🔹</h2>
<p>在Vue项目package.json中，要将全部依赖包升级至最新版本，可以使用工具<a href="https://github.com/raineorshine/npm-check-updates">npm-check-updates</a>实现，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202406111552312.png"></p>
<p>全局安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npm</span> <span class="nx">install</span> <span class="o">-</span><span class="nx">g</span> <span class="nx">npm</span><span class="o">-</span><span class="nx">check</span><span class="o">-</span><span class="nx">updates</span>
</span></span></code></pre></div><p>或者，npx安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npx</span> <span class="nx">npm</span><span class="o">-</span><span class="nx">check</span><span class="o">-</span><span class="nx">updates</span>
</span></span></code></pre></div><p>检查并显示最新版本</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">ncu</span> <span class="o">-</span><span class="nx">u</span>
</span></span></code></pre></div><p>重新安装</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">npm</span> <span class="nx">install</span>
</span></span></code></pre></div><p>至此，完成。</p>
<h2 id="88-el-table-column中设置type为selectionalign为center异常问题-">8.8. el-table-column中设置type为selection，align为center，异常问题 🔹</h2>
<p><code>Element Plus</code>组件库的<code>Table</code>表格组件，在设置<code>el-table-column</code>的<code>type</code>为<code>selection</code>，<code>align</code>为<code>center</code>时，出现只有表头居中了，但是内容没有居中，排查了一下原因，是因为在自行封装的Table组件中，设置了<code>show-overflow-tooltip</code>，虽然已经过滤了type为custom的情况，但是缺少了过滤<code>selection</code>的情况，所以勾选框多了一个<code>el-tooltip</code>的样式，导致<code>center</code>不生效。</p>
<h2 id="89-自行封装的table组件顶部边框线没有显示问题-">8.9. 自行封装的Table组件，顶部边框线没有显示问题 🔸</h2>
<p>自行封装的Table组件，顶部边框线没有显示，排查了一下，问题出在<code>.el-table .el-table__cell</code>这个样式，因为我们自己封装的组件库，样式文件来源都会有@xxx标识的，而这个的引用则是<code>index-5c8207ce.css</code>，初步判断是<code>Element Plus</code>官方样式。对比其他项目也是用的这个组件库，是没有这个问题的。<code>Element Plus</code>版本号也是一样的，所以猜测应该是<code>Element Plus</code>样式问题。检查了一下该项目，发现引用的样式是很久以前<code>Beta</code>版本，用来自定义主题的样式的，替换成<code>Element Plus</code>默认用法<code>import 'element-plus/dist/index.css'</code>，发现问题解决了。</p>
<h2 id="810-cannot-find-module-xxx-or-its-corresponding-type-declarations-">8.10. Cannot find module xxx or its corresponding type declarations. 🔹</h2>
<p>在Vue3项目的vite.config.ts中设置别名之后，在.vue文件中引入会报红提示这个没有找到的错误，验证了下，虽然不影响功能使用，但是体验不好。</p>
<p><code>VSCode</code>中使用<code>Ctrl+Shift+P</code>，然后输入<code>type</code>，选择<code>Volar:Select TypeScript Version...</code>，然后选择<code>Use Workspace Version xxx</code>即可。</p>
<h2 id="811-百度网站不支持iframe问题">8.11. 百度网站不支持iframe问题</h2>
<h2 id="812-查看vue3项目所需的node和npm版本">8.12. 查看Vue3项目所需的node和npm版本</h2>
<p>如果我新接受一个vue项目，我怎么知道应该使用哪个版本的node和npm去npm install安装依赖的？</p>
<h2 id="813-packagejson中依赖库版本号前缀和的区别">8.13. Package.json中依赖库版本号前缀^和~的区别？🔹</h2>
<p>在了解<code>^</code>和<code>~</code>区别之前，我们需要在<a href="https://semver.org/lang/zh-CN/">语义化版本 2.0.0 | Semantic Versioning (semver.org)</a>上了解项目版本号规范。根据语义化版本规范，一个版本号由三个数字组成，用点号分隔，格式为&quot;主版本号.次版本号.补丁版本号&rdquo;，例如版本号2.5.6。以下是对每个数字的含义：</p>
<ol>
<li>主版本号：当进行大规模的API变更或不兼容的改动时，增加主版本号。这意味着新版本可能会导致现有代码无法正常工作。</li>
<li>次版本号：当添加新功能，但保持向后兼容时，增加次版本号。新版本引入的改动应该可以与旧版本的代码兼容。</li>
<li>补丁版本号：当进行小的bug修复或性能优化等不影响现有功能的改动时，增加补丁版本号。补丁版本号的更新应该不会引入新的功能或破坏现有功能。</li>
</ol>
<p>在package.json文件中，dependencies字段用于指定项目所依赖的包及其版本。在这些依赖项的版本号中：</p>
<ol>
<li><code>^</code>符号：允许安装指定版本的最新次要版本，但不包括更高的主要版本。例如，如果依赖项的版本号为^1.2.3，那么运行npm install命令时，将安装1.2.3版本的最新次要版本，例如1.2.4、1.3.0，但不会安装2.0.0版本。</li>
<li><code>~</code>符号：允许安装指定版本的最新补丁版本，但不包括更高的次要版本。例如，如果依赖项的版本号为~1.2.3，那么运行npm install命令时，将安装1.2.3版本的最新补丁版本，例如1.2.4，但不会安装1.3.0版本。</li>
</ol>
<p>总结起来，<code>^</code>符号允许安装指定版本的最新次要版本，而<code>~</code>符号允许安装指定版本的最新补丁版本。</p>
<h2 id="814-无头浏览器">8.14. 无头浏览器</h2>
<h2 id="815-在线地图坐标系转换工具使用">8.15. 在线地图坐标系转换工具使用🔹</h2>
<p>因项目开发计划使用Bing Maps地图替换百度地图，所以就需要考虑坐标转换的问题，否则定位会出现偏差，当前在 <a href="https://www.lddgo.net">www.lddgo.net</a> 上面发现有<a href="https://www.lddgo.net/convert/coordinate">坐标系转换工具</a>，就使用了一下，进行验证。</p>
<ol>
<li>Bing Maps转百度地图国内地址：GCJ02 -&gt; BD09 偏差几米左右</li>
<li>Bing Maps转百度地图国外地址：WGS84 -&gt; BD09 偏差几米左右</li>
<li>百度地图转Bing Maps国内地址：BD09 -&gt; GCJ02 偏差几米左右</li>
<li>百度地图转Bing Maps国外地址：国外地址不需要转换，直接用 偏差几米左右</li>
</ol>
<h2 id="816-国际化地图技术选型">8.16. 国际化地图技术选型</h2>
<p>因为项目业务后续会涉及国外市场，导致项目地图要能在国外使用，有客户反馈在国外定位，搜索地址没有找到，</p>
<h2 id="817-雪碧图">8.17. 雪碧图</h2>
<h2 id="818-变量提升">8.18. 变量提升</h2>
<p><a href="https://developer.mozilla.org/zh-CN/docs/Glossary/Hoisting">Hoisting（变量提升） - MDN Web 文档术语表：Web 相关术语的定义 | MDN (mozilla.org)</a></p>
<p>以下是对您列出的各个Vue.js相关主题的简要解释：</p>
<h3 id="8181-v-bindattrs">8.18.1. v-bind=&quot;$attrs&rdquo;</h3>
<p>在Vue.js中，<code>v-bind=&quot;$attrs&quot;</code>是一个特殊的绑定，它可以将父组件中没有被作为prop声明的属性（attribute）自动传递给子组件的根元素。这在创建封装组件时非常有用，可以确保所有传递给组件的属性都被正确地应用到组件的根元素上，而不需要在子组件中显式地定义每个prop。</p>
<h3 id="8182-unplugin-vue-define-options">8.18.2. unplugin-vue-define-options</h3>
<p><code>unplugin-vue-define-options</code> 是一个Vue.js插件，它允许开发者在单文件组件（SFC）中定义组件选项，而无需使用<code>export default</code>语法。这可以在某些情况下简化组件的编写，尤其是在使用TypeScript时，可以减少样板代码。</p>
<h3 id="8183-在-vue6163-中ontrack-和-ontrigger-的区别">8.18.3. 在 Vue6.16.3 中，<code>onTrack</code> 和 <code>onTrigger</code> 的区别？</h3>
<p>在Vue 3.6中，<code>onTrack</code>和<code>onTrigger</code>是用于调试的钩子，它们与Vue的响应式系统相关。</p>
<ul>
<li><code>onTrack</code>：当组件的渲染响应式依赖被追踪时调用。这个钩子可以用来了解哪些响应式属性被组件的渲染所依赖。</li>
<li><code>onTrigger</code>：当响应式属性被修改时调用，可以用来了解响应式属性的变动是如何影响组件的。
这两个钩子有助于开发者更好地理解响应式系统的行为，尤其是在进行性能优化时。</li>
</ul>
<h3 id="8184-vue-nextumdcjs">8.18.4. vue-next.umd.cjs</h3>
<p><code>vue-next.umd.cjs</code>通常指的是Vue.js下一个主要版本的UMD（Universal Module Definition）构建的CommonJS版本。UMD是一种模块定义方式，使得代码可以在客户端和服务端不同的环境中运行。<code>.cjs</code>扩展名表明这是一个CommonJS模块，通常用于Node.js环境。</p>
<h3 id="8185-ztpctablepaginationvaluepagesize-is-possibly-undefinedts18048">8.18.5. &lsquo;ztpcTablePagination.value.pageSize&rsquo; is possibly &lsquo;undefined&rsquo;.ts(18048)</h3>
<p>这个错误信息来自TypeScript编译器，它提示开发者在使用<code>ztpcTablePagination.value.pageSize</code>时，这个值可能是<code>undefined</code>。为了解决这个问题，开发者需要确保在使用<code>pageSize</code>之前它已经被正确地初始化或检查了其是否为<code>undefined</code>。可以使用TypeScript的非空断言操作符<code>!</code>或者显式的类型守卫。</p>
<h3 id="8186-vue-spa单页面的加载过程">8.18.6. Vue Spa单页面的加载过程</h3>
<p>Vue单页面应用（Single Page Application, SPA）的加载过程通常包括以下步骤：</p>
<ol>
<li><strong>下载入口HTML文件</strong>：用户访问Vue SPA时，浏览器首先下载入口HTML文件。</li>
<li><strong>加载JavaScript主文件</strong>：HTML文件中通常会包含一个或多个JavaScript文件链接，这些文件包含Vue框架和应用代码。</li>
<li><strong>初始化Vue实例</strong>：JavaScript文件加载完成后，Vue实例被创建并挂载到DOM上。</li>
<li><strong>路由解析</strong>：Vue Router（Vue.js的路由库）解析URL，确定应该显示哪个组件。</li>
<li><strong>组件渲染</strong>：根据路由，相应的组件被渲染到页面上。</li>
<li><strong>数据获取</strong>：组件可能需要从服务器获取数据，这通常通过API请求完成。</li>
<li><strong>更新视图</strong>：一旦数据被获取，视图会根据数据更新。
这个过程使得用户在浏览SPA时，不需要重新加载整个页面，只需更新必要的部分，从而提供了更加流畅的用户体验。</li>
</ol>
<h2 id="819-vue3项目模版升级至vite5element-plus组件库国际化问题">8.19. Vue3项目模版升级至Vite5，Element Plus组件库国际化问题🔹</h2>
<p>X [ERROR] No known conditions for &ldquo;./lib/locale/lang/zh-cn&rdquo; specifier in &ldquo;element-plus&rdquo; package [plugin vite:dep-scan]</p>
<p>Vue3项目模版，打算部署至Sentry前端监控系统试用，然后就运行项目，因为nodejs版本升级到了v18.18.0，出现一些依赖不兼容的问题，就打算趁这个机会升级至Vite5，然后就遇到了Element Plus组件库国际化问题，研究了一下，是用法上面有了变化导致的，具体可以看这个issue，[<a href="https://github.com/element-plus/element-plus/issues/13609">i18n] [All] [plugin:vite:import-analysis] No known conditions for &ldquo;./lib/locale/lang/zh-cn&rdquo; specifier in &ldquo;element-plus&rdquo; package · Issue #13609 · element-plus/element-plus (github.com)</a>，方案就是：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="c1">// 2.3.7以及之前的用法
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">import</span> <span class="nx">zhCN</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/lib/locale/lang/zh-cn&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">en</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/lib/locale/lang/en&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl">
</span></span><span class="line"><span class="cl"><span class="c1">// 2.3.8之后的用法
</span></span></span><span class="line"><span class="cl"><span class="c1"></span><span class="kr">import</span> <span class="nx">zhCN</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/dist/locale/zh-cn.mjs&#34;</span><span class="p">;</span>
</span></span><span class="line"><span class="cl"><span class="kr">import</span> <span class="nx">en</span> <span class="nx">from</span> <span class="s2">&#34;element-plus/dist/locale/en.mjs&#34;</span><span class="p">;</span>
</span></span></code></pre></div><h2 id="820-掘金小册子你不知道的-chrome-调试技巧">8.20. 掘金小册子《你不知道的 Chrome 调试技巧》🔹</h2>
<p>掘金小册子<a href="https://juejin.cn/book/6844733783166418958">《你不知道的 Chrome 调试技巧》</a>是免费的，里面主要是讲了一些Chrome DevTools的使用技巧，今天看完，主要是记录了下一些印象比较深的点：</p>
<ol>
<li>全屏截图，通过 <code>Capture full size screenshot</code> 命令。</li>
<li>取色器，Chrome DevTools 自带取色器，之前一直没注意。</li>
<li>console.table（） 可以将对象或数组以一个表格方式打印出来，方便查看。</li>
<li>console.log({value1,value2,value3}) 当想打印多个值时，要区分总是要加上前缀，其实通过<code>{}</code>就可以以对象的格式打印出来。</li>
<li>console.log()并没有立即拍摄对象快照，它只是存储一个指向对象的引用，在代码返回事件队列时才去拍摄快照。 使用 <code>JSON.stringify()</code> 方法处理打印的结果。</li>
</ol>
<h2 id="821-el-cascader-导致-out-of-memory-的原因分析">8.21. <code>&lt;el-cascader /&gt;</code>导致 Out of Memory 的原因分析</h2>
<h2 id="822-在-html-中div-和divdiv-的区别">8.22. 在 HTML 中，<code>&lt;div /&gt;</code>和<code>&lt;div&gt;&lt;div /&gt;</code>的区别</h2>
<p>两种不同的语法形式，具有不同的含义。</p>
<div />是一个自闭合标签的写法，它表示一个 div 标签没有子元素，例如 <div class="example" /> 标签就是一个自闭合标签，它没有子元素，用来表示一个空的 div 元素。
<div><div /></div>是一个 div 元素包含一个自闭合 div 标签的写法，它表示一个 div 元素包含一个没有子元素的子 div 元素，例如 <div class="example"><div /></div> 标签就是一个 div 元素包含一个子 div 元素的示例。
<p>需要注意的是，<code>&lt;div /&gt;</code>语法形式在 HTML 中并不是标准的写法，而是在某些框架和库中使用的一种简化语法，例如 React 中的 JSX，它可以用来表示一个空的 div 元素。在标准的 HTML 中，需要使用具体的标签名称来表示一个元素的开始和结束，例如 <code>&lt;div&gt;&lt;/div&gt;</code> 标签表示一个 div 元素的开始和结束。</p>
<h2 id="823-el-table-向上向下添加一行">8.23. el-table 向上向下添加一行</h2>
<h2 id="824-el-table-实现拖拽">8.24. el-table 实现拖拽</h2>
<p>el-table 实现拖拽 （https://blog.csdn.net/ddsuuny/article/details/123206503）</p>
<h2 id="825-el-table-实现合并单元格">8.25. el-table 实现合并单元格</h2>
<p>el-table 实现合并单元格（https://blog.csdn.net/weixin_45392318/article/details/124170355）</p>
<h2 id="826-css中position属性">8.26. css中position属性</h2>
<p>css中position属性(absolute|relative|static|fixed)概述及应用</p>
<h2 id="827-vitepress的基本使用与vuepress的对比">8.27. vitepress的基本使用，与vuepress的对比</h2>
<h2 id="828-md文档中使用table标签页会生成br的问题">8.28. MD文档中使用<code>&lt;table&gt;</code>标签页，会生成br的问题</h2>
<p>MD文档中使用<code>&lt;table&gt;</code>标签页，会生成br的问题研究，初步是转义的问题</p>
<h2 id="829-微信pc端浏览器调试解决方案">8.29. 微信PC端浏览器调试解决方案</h2>
<h2 id="830-前端拓扑图编辑器插件选型对比">8.30. 前端拓扑图编辑器插件选型对比</h2>
<p>AntV 蚂蚁金服 G6 是一个图可视化引擎。它提供了图的绘制、布局、分析、交互、动画等图可视化的基础能力。旨在让关系变得透明，简单。让用户获得关系数据的 Insight</p>
<h2 id="831-vue中实现左右上下拖拽复制">8.31. vue中实现左右、上下拖拽、复制</h2>
<h2 id="832-vue实现点击复制功能">8.32. vue实现点击复制功能</h2>
<h2 id="833-基于vue的简单流程图开发">8.33. 基于vue的简单流程图开发</h2>
<h2 id="834-jsplumb-jquery流程图插件">8.34. jsplumb-jquery流程图插件</h2>
<h2 id="835-font-size-在多个浏览器上面的差异">8.35. font-size 在多个浏览器上面的差异</h2>
<h2 id="836-vue使用js-xlsx插件导出excel表格">8.36. vue使用js-xlsx插件导出Excel表格</h2>
<h2 id="837-vuex如何用watch监听thisstore数据的变化">8.37. vuex如何用watch监听this.$store数据的变化</h2>
<h2 id="838-element源码系列row以及col组件">8.38. Element源码系列——Row以及Col组件</h2>
<h2 id="839-正则匹配公司名称">8.39. 正则匹配公司名称</h2>
<h2 id="840-中国省市数据">8.40. 中国省市数据</h2>
<h2 id="841-vue基于element组件的国籍选择框">8.41. vue基于element组件的国籍选择框</h2>
<h2 id="842-vue中v-if与v-show的区别">8.42. vue中v-if与v-show的区别</h2>
<h2 id="843-如何让element-ui的message消息提示每次只弹出一个">8.43. 如何让Element UI的Message消息提示每次只弹出一个</h2>
<h2 id="844-vue中监听键盘事件">8.44. vue中监听键盘事件</h2>
<h2 id="845-vue如何在-v-for-列表中动态添加-ref-并获取对应元素dom">8.45. vue如何在 v-for 列表中动态添加 ref 并获取对应元素dom</h2>
<h2 id="846-vue页面的定时刷新">8.46. vue页面的定时刷新</h2>
<h2 id="847-vue---elementui中循环渲染表格控制字段的显示与隐藏-v-if与v-for同时使用">8.47. vue - ElementUI中循环渲染表格，控制字段的显示与隐藏 v-if与v-for同时使用</h2>
<h2 id="848-vue-router-报错uncaught-in-promise-navigationduplicate_name-navigationduplicated">8.48. vue router 报错：Uncaught (in promise) NavigationDuplicate{_name: &ldquo;NavigationDuplicated&rdquo;}</h2>
<h2 id="849-vue-data-响应式失效">8.49. vue data 响应式失效</h2>
<p>vue中通过import引入一个对象，将对象赋值到data中，然后异步修改data中这个对象的属性的值，vue无法监听到</p>
<h2 id="850-从0到1搭建webpack2vue2自定义模板详细教程">8.50. 从0到1搭建webpack2+vue2自定义模板详细教程</h2>
<h2 id="851-vueuse的原理和组件的书写规则">8.51. vue.use的原理和组件的书写规则</h2>
<h2 id="852-vue-thisrouterpush传参">8.52. vue this.$router.push()传参</h2>
<h2 id="853-父元素设置了minheight子元素设置height100无效">8.53. 父元素设置了minheight，子元素设置height100%无效</h2>
<h2 id="854-span-超过长度限制-隐藏并在鼠标移入时显示全部字段">8.54. span 超过长度限制 隐藏并在鼠标移入时显示全部字段</h2>
<h2 id="855-element导航菜单自定义样式">8.55. Element导航菜单自定义样式</h2>
<h2 id="856-vue打包后字体图标显示小方块">8.56. vue打包后字体图标显示小方块</h2>
<h2 id="857-exports-和-moduleexports-的区别">8.57. exports 和 module.exports 的区别</h2>
<h2 id="858-vue父组件向子组件传递一个动态的值子组件如何保持实时更新实时更新">8.58. vue父组件向子组件传递一个动态的值，子组件如何保持实时更新实时更新？</h2>
<h1 id="9-flutter">9. Flutter</h1>
<h2 id="91-android-studio-全局搜索快捷键ctrlshiftf失效">9.1. Android Studio 全局搜索快捷键Ctrl+Shift+F失效</h2>
<p>在Android Studio中使用全局搜索快捷键Ctrl+Shift+F时，总是没有任何反应，第一感觉是其他软件占用了这个快捷按键，所以检查了一下，发现在搜狗输入法里就有这个设置，就选择去掉了，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202403181136214.png"></p>
<h2 id="92-cocoapods">9.2. cocoapods</h2>
<p><a href="https://guides.cocoapods.org/using/getting-started.html#updating-cocoapods">https://guides.cocoapods.org/using/getting-started.html#updating-cocoapods</a></p>
<h2 id="93-mac中的ruby是什么">9.3. Mac中的Ruby是什么？</h2>
<p>brew、Ruby、gem</p>
<h2 id="94-flutter-shorebird">9.4. flutter shorebird</h2>
<h2 id="95-萤石flutter插件ys_play65">9.5. 萤石flutter插件ys_play6.5</h2>
<p><a href="https://pub.dev/packages/ys_play">ys_play | Flutter package (pub.dev)</a></p>
<h2 id="96-running-gradle-task-assembledebug">9.6. Running Gradle task &lsquo;assembleDebug&rsquo;&hellip;</h2>
<p>Flutter项目初始化时，一直卡在这个任务上面，在Flutter项目android目录下使用命令<code>./gradlew.bat assembleDebug</code>可以看到详情的信息，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401311718114.png"></p>
<h2 id="97-fvm-版本管理">9.7. fvm 版本管理</h2>
<h2 id="98-flutter国内环境配置-">9.8. Flutter国内环境配置 🔹</h2>
<p>最近，github都登录不上，挂了梯子，git clone都是失败的，无奈之下，只能研究切换至国内镜像来使用。</p>
<p>首先，在<a href="https://flutter.cn/community/china?tab=windows">《在中国网络环境下使用 Flutter - Flutter 中文文档》</a>文档页面，可以看到相关介绍。主要是需要将<code>PUB_HOSTED_URL</code>和<code>FLUTTER_STORAGE_BASE_URL</code>设置为镜像站点。以 <code>CFUG</code>的镜像为例，使用管理员权限打开Windows Powershell，然后使用Windows setx命令永久设置环境变量，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-shell" data-lang="shell"><span class="line"><span class="cl">setx PUB_HOSTED_URL https://pub.flutter-io.cn
</span></span><span class="line"><span class="cl">setx FLUTTER_STORAGE_BASE_URL https://storage.flutter-io.cn
</span></span></code></pre></div><p>然后关闭窗口，再打开，输入flutter doctor验证。</p>
<p>相关资料：</p>
<ol>
<li>Flutter 镜像安装帮助：https://mirrors.tuna.tsinghua.edu.cn/help/flutter</li>
<li>Flutter SDK：https://mirrors.tuna.tsinghua.edu.cn/help/flutter-sdk.git</li>
</ol>
<h2 id="99-pub-getpub-upgrade和pub-outdated">9.9. Pub get、Pub upgrade和Pub outdated</h2>
<h2 id="910-使用flutter-pub-get-会修改pubspeclock么">9.10. 使用flutter pub get 会修改pubspec.lock么？</h2>
<h2 id="911-android-toolchain---develop-for-android-devices-">9.11. Android toolchain - develop for Android devices 🔹</h2>
<p>在运行flutter doctor命令检测flutter开发环境情况的时候，提示没有找到Android SDK，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401150959898.png"></p>
<p>但在【Setting——Languages&amp;Frameworks——Android SDK——Android SDK Location】上已经配置了对应的地址。可能的原因是flutter的配置没有生效，使用以下命令解决，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-dart" data-lang="dart"><span class="line"><span class="cl"><span class="n">flutter</span> <span class="n">config</span> <span class="o">--</span><span class="n">android</span><span class="o">-</span><span class="n">sdk</span> <span class="nl">E:</span><span class="err">\</span><span class="n">Data</span><span class="err">\</span><span class="n">SDK</span><span class="err">\</span><span class="n">AndroidSDK</span>
</span></span></code></pre></div><p>提示已经配置成功，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401150958681.png"></p>
<p>此时，再次运行flutter doctor命令，会提示缺少<code>cmdline-tools component</code>，让你运行命令<code>path/to/sdkmanager --install &quot;cmdline-tools;latest&quot;</code>去解决，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401151001456.png"></p>
<p>很有可能是Android SDK没有下载这个依赖，查看Android SDK配置页面，将<code>Android SDK Command-line Tools（latest）</code>勾选上即可，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202401151005501.png"></p>
<p>然后，继续运行flutter doctor命令，会提示你一些Android许可证不被接受，需要运行命令<code>flutter doctor --android-licenses</code>，然后一直选择<code>y</code>即可，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-dart" data-lang="dart"><span class="line"><span class="cl"> <span class="n">Some</span> <span class="n">Android</span> <span class="n">licenses</span> <span class="n">not</span> <span class="n">accepted</span><span class="p">.</span> <span class="n">To</span> <span class="n">resolve</span> <span class="k">this</span><span class="p">,</span> <span class="nl">run:</span> <span class="n">flutter</span> <span class="n">doctor</span> <span class="o">--</span><span class="n">android</span><span class="o">-</span><span class="n">licenses</span>
</span></span></code></pre></div><p>至此，flutter开发环境Android SDK配置不生效问题得以解决。</p>
<h2 id="912-gradle-wrapperproperties里怎么知道当前有下载了哪些版本">9.12. gradle-wrapper.properties里怎么知道当前有下载了哪些版本？</h2>
<h2 id="913-exception-in-thread-main-javautilzipzipexception-zip-end-header-not-found">9.13. Exception in thread &ldquo;main&rdquo; java.util.zip.ZipException: zip END header not found</h2>
<p>原因是grade版本不存在。</p>
<h2 id="914-could-not-determine-the-dependencies-of-task-easy_pdf_viewercompiledebugaidl">9.14. Could not determine the dependencies of task &lsquo;:easy_pdf_viewer:compileDebugAidl&rsquo;.</h2>
<blockquote>
<p>Failed to find Platform SDK with path: platforms;android-30</p></blockquote>
<h2 id="915-library-dart-packages-has-broken-classes-paths">9.15. Library Dart Packages has broken classes paths</h2>
<p><a href="https://github.com/flutter/flutter/issues/72773">Library Dart Packages has broken classes path: · Issue #72773 · flutter/flutter (github.com)</a></p>
<h2 id="916-android-gradle-下载特别慢的问题">9.16. android gradle 下载特别慢的问题🔹</h2>
<p>在<code>flutter/android</code>开发时，经常遇到<code>gradle</code>下载特别慢的问题，甚至是超时失败，严重影响到项目的开发工作，为了解决这个问题，可以考虑替换成国内的镜像来下载解决。首先，在<code>android/gradle/wrapper/gradle-wrapper.properties</code>中，查看当前<code>gradle</code>版本，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251127878.png"></p>
<p>然后在<a href="https://mirrors.cloud.tencent.com/gradle/">腾讯镜像gradle</a>上面，查看是否存在该版本，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202312251128029.png"></p>
<p>最后将<code>distributionUrl</code>设置为腾讯镜像地址即可，如下所示：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-java" data-lang="java"><span class="line"><span class="cl"><span class="n">distributionUrl</span><span class="o">=</span><span class="n">https</span><span class="err">\</span><span class="p">:</span><span class="c1">//mirrors.cloud.tencent.com/gradle/gradle-7.5-all.zip</span><span class="w">
</span></span></span></code></pre></div><p><a href="https://blog.csdn.net/youngwah292/article/details/110734407">gradle不同版本下载太慢&mdash;腾讯做了国内镜像可以直接下载_gradle 下载-CSDN博客</a></p>
<h2 id="917-put-getpub-upgrade和pub-outdated">9.17. Put get、Pub upgrade和Pub outdated</h2>
<h2 id="918-windows-defender-防火墙域专用和公用有什么区别">9.18. Windows Defender 防火墙，域、专用和公用有什么区别？</h2>
<h2 id="919-genymotion-mac-插件路径设置">9.19. Genymotion Mac 插件路径设置</h2>
<p>Genymotion Mac 插件路径设置，其值为<code>/Applications/Genymotion.app</code></p>
<h2 id="920-error-java_home-is-set-to-an-invalid-directory-dtoolsjavajdk-19">9.20. ERROR: JAVA_HOME is set to an invalid directory: D:\tools\Java\jdk-19</h2>
<p>项目中因为遇到报错，然后计划使用java 1.8版本，然后JAVA_HOME已经变更了，但是每次运行Flutter项目一直都是报这个错，指向的是之前的旧路径。</p>
<h2 id="921-flutter-在mac下怎么切换指定版本">9.21. flutter 在Mac下怎么切换指定版本？🔹</h2>
<p>在flutter sdk目录下，运行命令 git checkout &lt;指定版本&gt;即可，比如 git checkout 3.3.10，然后使用命令flutter version 查看当前版本，如下所示：<img alt="截屏2023-11-07 17.42.03" loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202311071742456.png"></p>
<p>当想要从指定版本切换回最新版本时，可以在flutter sdk目录下，运行命令<code>git branch</code>显示。</p>
<h1 id="10-sentry">10. Sentry</h1>
<h2 id="101-loading-wizard-failed-did-you-provide-the-right-url">10.1. Loading Wizard failed. Did you provide the right URL?🔹</h2>
<p>在给项目配置Sentry时，要将sourcemaps通过sentry-wizard自动上传至Sentry，但是确提示以下报错信息：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">Loading</span> <span class="nx">Wizard</span> <span class="nx">failed</span><span class="p">.</span> <span class="nx">Did</span> <span class="nx">you</span> <span class="nx">provide</span> <span class="nx">the</span> <span class="nx">right</span> <span class="nx">URL</span><span class="o">?</span>
</span></span></code></pre></div><p>再三确认URL是没有问题，所以，就很奇怪这是什么问题？</p>
<p>使用curl命令是没有问题的，但是，返回了sentry网站没有证书的信息。</p>
<p>查看github上面的issues，发现有类似的问题，如下所示：</p>
<p><a href="https://github.com/getsentry/sentry-wizard/issues/416">Loading Wizard failed for NextJs #416</a></p>
<p>提供的解决方案是，使用命令 <code>set NODE_TLS_REJECT_UNAUTHORIZED=0</code> ，因为在 Node.js 中，<code>NODE_TLS_REJECT_UNAUTHORIZED</code> 是一个环境变量，用于控制 Node.js 在执行 HTTPS 请求时是否应该拒绝未经授权的 SSL 证书。</p>
<p>然后，可以使用命令<code>npx @sentry/wizard@latest -i sourcemaps</code>可以正常执行了，只是在运行<code>npm run build</code>进行打包的时候，还是报错了，提示证书异常：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-js" data-lang="js"><span class="line"><span class="cl"><span class="nx">error</span><span class="o">:</span> <span class="nx">API</span> <span class="nx">request</span> <span class="nx">failed</span>
</span></span><span class="line"><span class="cl">  <span class="nx">caused</span> <span class="nx">by</span><span class="o">:</span> <span class="p">[</span><span class="mi">60</span><span class="p">]</span> <span class="nx">SSL</span> <span class="nx">peer</span> <span class="nx">certificate</span> <span class="nx">or</span> <span class="nx">SSH</span> <span class="nx">remote</span> <span class="nx">key</span> <span class="nx">was</span> <span class="nx">not</span> <span class="nx">OK</span> <span class="p">(</span><span class="nx">schannel</span><span class="o">:</span> <span class="nx">SEC_E_UNTRUSTED_ROOT</span> <span class="p">(</span><span class="mh">0x80090325</span><span class="p">))</span>
</span></span></code></pre></div><p>所以，还是没办法解决，后来，Sentry更新了证书就好了。</p>
<h1 id="11-electron-vue">11. Electron-Vue</h1>
<h2 id="111-通过teamviewer传输exe文件过大的问题">11.1. 通过TeamViewer传输exe文件过大的问题🔹</h2>
<p>使用<code>Electron</code>开发的一个<code>PC</code>软件，包大小为<code>400MB</code>，有可能是<code>TeamViewer</code>传输大小有限制，每次传到<code>200MB</code>就自动中断了，导致无法把<code>.exe</code>文件从<code>A</code>电脑传输到无网络的<code>B</code>电脑上，又不想使用<code>U盘</code>进行传输，因为<code>B</code>电脑主机环境在机房，操作起来非常不方便。为了解决这个问题，可以通过压缩分卷的方式，把<code>400MB</code>大小的软件包分成两个<code>200MB</code>即可。以<code>VSCode</code>软件为例，将<code>100MB</code>软件包压缩分卷为两个<code>50MB</code>的文件。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502061118092.png"></p>
<h2 id="112-node_module-删除失败">11.2. node_module 删除失败🔹</h2>
<p>在运行<code>electron-vue</code>项目时，打算把<code>node_modules</code>删除了再重新安装，却提示<code>node_modules/electron</code>文件夹正在被使用，删除失败。然后，把相关窗口都关闭了还是不行，猜测是有关联的进程没有关闭，所以，就看下怎么处理。步骤如下：</p>
<p>打开任务管理器 ➔ 性能 ➔ CPU ➔ 打开资源监视器 ➔ 关联的句柄 ➔ 搜索句柄electron ➔ 右键结束进程。</p>
<h1 id="12-java">12. JAVA</h1>
<h2 id="121-at模式和透传模式">12.1. AT模式和透传模式🔹</h2>
<p>AT模式（AT Command Mode）：AT指令模式是一种通过发送特定的AT指令来控制设备的工作模式。在AT模式下，通过发送预定义的AT指令，可以实现对设备进行各种操作，例如设置参数、查询状态、发送数据等。这种模式通常用于与嵌入式设备进行通信，例如GSM模块、蓝牙模块等。</p>
<p>透传模式（Transparent Mode）：透传模式是一种直接将串口数据透传到目标设备的工作模式。在透传模式下，设备不会解析和处理接收到的数据，而是直接将数据转发给目标设备，同时将目标设备返回的数据原封不动地传输回来。透传模式通常用于需要将串口数据传递给其他设备进行处理的场景，例如将串口数据透传给单片机、传感器等。</p>
<h2 id="122-lora和lorawan的区别">12.2. LoRa和LoRaWAN的区别？🔹</h2>
<p>LoRa（长距离低功耗射频）和LoRaWAN（长距离低功耗广域网）是两个不同的概念，它们在物联网（IoT）领域中扮演不同的角色。</p>
<p>LoRa是一种调制技术，用于在无线通信中实现长距离和低功耗的传输。它是由Semtech公司开发的，基于扩频技术的无线通信技术。LoRa可以在不同的频段上进行通信，并具有较高的抗干扰能力和覆盖范围。它被用于构建物联网中的无线传感器网络，可以在城市、农村和工业环境中提供广泛的连接。</p>
<p>LoRaWAN则是一种基于LoRa技术的通信协议，用于在LoRa网络中实现端到端的通信。LoRaWAN定义了设备和网络之间的通信协议，包括设备的注册、数据传输、安全性等方面。LoRaWAN协议采用星形拓扑结构，其中终端设备通过网关与云服务器进行通信。LoRaWAN网络旨在为物联网设备提供长距离的、低功耗的、双向的通信能力，并具有较高的可扩展性和覆盖范围。</p>
<p>因此，LoRa是一种物理层技术，而LoRaWAN是在LoRa技术基础上建立的一种通信协议。LoRa提供了物理层的无线通信能力，而LoRaWAN定义了设备和网络之间的通信规则和协议，使得物联网设备可以在LoRa网络中进行通信。</p>
<p>以下是对您列出的各个主题的简要概述：</p>
<h3 id="1221-火焰图">12.2.1. 火焰图</h3>
<p>火焰图（Flame Graph）是由性能分析师和程序员使用的性能分析工具，它可以帮助开发者查看和分析软件程序的性能瓶颈。火焰图以一个倒置的树状图形式展现，其中每一列代表一个函数调用栈，宽度表示函数在样本中占用的时间比例。通过火焰图，可以快速定位到占用CPU时间最多的代码路径。</p>
<h3 id="1222-集群">12.2.2. 集群</h3>
<p>集群（Cluster）指的是一组计算机（节点）的组合，它们协同工作以完成特定的任务。在计算领域，集群可以提高系统的可靠性、可用性和性能。在分布式系统中，集群通常用于负载均衡、故障转移和高可用性等场景。</p>
<h3 id="1223-k8s">12.2.3. K8s</h3>
<p>K8s 是 Kubernetes 的缩写，它是一个开源的容器编排系统，用于自动化应用容器的部署、扩展和管理。Kubernetes 提供了一个平台，允许你在物理机或虚拟机集群上调度和运行容器。它广泛应用于微服务架构中，以支持自动化、弹性伸缩和声明式配置。</p>
<h3 id="1224-内网外网穿透">12.2.4. 内网、外网穿透</h3>
<p>内网穿透是指将局域网（内网）的服务映射到公网（外网），使得外网的设备可以访问内网的服务。外网穿透则通常指从外网访问内网资源的过程。这通常通过NAT穿透技术实现，常用的工具有Ngrok、FRP等。</p>
<h3 id="1225-jenkins">12.2.5. Jenkins</h3>
<p>Jenkins 是一个开源的自动化服务器，它支持多种自动化任务，如构建、测试和部署软件。Jenkins 可以通过插件扩展其功能，广泛应用于持续集成（CI）和持续部署（CD）领域。</p>
<h3 id="1226-junit5">12.2.6. JUnit5</h3>
<p>JUnit5 是一个Java语言的单元测试框架，用于编写和运行测试代码。它支持模块化，并且与Java 8及更高版本特性兼容。JUnit5 提供了新的注解和断言方法，使得测试更加简洁和强大。</p>
<h3 id="1227-prometheus">12.2.7. Prometheus</h3>
<p>Prometheus 是一个开源监控系统和时间序列数据库。它通过收集和存储指标数据，并通过规则对数据进行分析和告警。Prometheus 广泛用于监控云原生应用，并且与Kubernetes有良好的集成。</p>
<h3 id="1228-探活">12.2.8. 探活</h3>
<p>探活（Health Check）是指定期检查系统或服务的运行状态，以确保它们正常工作。在分布式系统中，探活机制可以自动检测服务故障并进行恢复，常见的探活方式包括HTTP探活、TCP探活等。</p>
<h3 id="1229-kafka">12.2.9. Kafka</h3>
<p>Kafka 是一个开源的流处理平台，由LinkedIn公司开发，用于构建实时的数据流和应用程序。它以高吞吐量、可扩展性和持久性著称，常用于处理大规模数据流，如日志聚合、实时分析、事件源和消息队列。</p>
<h3 id="12210-springfox">12.2.10. springfox</h3>
<p>Springfox 是一个开源的API文档生成工具，它基于Spring MVC和Spring Web的注解，自动生成API文档。Springfox 支持Swagger 2.0和OpenAPI 3.0规范，可以帮助开发者快速生成和展示RESTful API的文档。不过，随着Springdoc OpenAPI的兴起，Springfox的使用正在逐渐减少。</p>
<h1 id="13-android">13. Android</h1>
<h2 id="131-android-studio-引入so文件">13.1. Android Studio 引入.so文件</h2>
<h2 id="132-mac-env-node--no-such-file-or-directory">13.2. mac env: node : No such file or directory</h2>
<h2 id="133-android基础控件popupwindow模仿ios底部弹窗">13.3. Android基础控件—PopupWindow模仿ios底部弹窗</h2>
<h2 id="134-mac-环境变量">13.4. mac 环境变量</h2>
<h2 id="135-打印retrofit请求地址参数以及返回结果">13.5. 打印Retrofit请求地址、参数、以及返回结果</h2>
<h2 id="136-glide设置圆形图片与圆角图片">13.6. glide设置圆形图片与圆角图片</h2>
<h2 id="137-使用retrofit进行post请求报错-field-parameters-can-only-be-used-with-form-encoding">13.7. 使用Retrofit进行Post请求报错： @Field parameters can only be used with form encoding.</h2>
<h2 id="138-全局变量快速m命名">13.8. 全局变量快速m命名</h2>
<h2 id="139-两分钟理解android中pxdpsp的区别">13.9. 两分钟理解Android中PX、DP、SP的区别</h2>
<h2 id="1310-retrofit2-使用multipart上传文件">13.10. Retrofit2 使用@Multipart上传文件</h2>
<h2 id="1311-集合遍历增删报错-at-javautilhashmapkeyiteratornext">13.11. 集合遍历增删报错 at java.util.HashMap$KeyIterator.next</h2>
<h2 id="1312-linuxcp-复制文件文件夹到文件夹">13.12. linux：cp 复制文件、文件夹到文件夹</h2>
<h2 id="1313-java-gson获取jsonobject下所有键的列表">13.13. Java GSON：获取JSONObject下所有键的列表</h2>
<h2 id="1314-android中切换到主线程更新方法">13.14. Android中切换到主线程更新方法</h2>
<h2 id="1315-android-单例模式的正确姿势">13.15. Android 单例模式的正确姿势</h2>
<h2 id="1316-dagger716-详解">13.16. dagger7.16 详解</h2>
<h2 id="1317-java及android中常用链式调用写法简单示例">13.17. Java及Android中常用链式调用写法简单示例</h2>
<h2 id="1318-android-okhttp-之websocket简单使用">13.18. Android Okhttp 之WebSocket简单使用</h2>
<h2 id="1319-okhttp-中的websocket-结合rxjava-的网络请求封装">13.19. okhttp 中的websocket 结合RxJava 的网络请求封装</h2>
<h2 id="1320-adapter与activity之间的传值">13.20. Adapter与Activity之间的传值</h2>
<h2 id="1321-android-evenbus的基本使用">13.21. Android EvenBus的基本使用</h2>
<h2 id="1322-constraintlayout看完一篇真的就够了么">13.22. ConstraintLayout，看完一篇真的就够了么？</h2>
<h2 id="1323-toolbar设置详解">13.23. Toolbar设置详解</h2>
<h2 id="1324-给toolbar的menu添加图标">13.24. 给Toolbar的menu添加图标</h2>
<h2 id="1325-android--constraintlayout-中心对齐图像和文本">13.25. Android – ConstraintLayout 中心对齐图像和文本</h2>
<h2 id="1326-android-复杂的列表视图新写法-multitype-详解篇">13.26. Android 复杂的列表视图新写法: MultiType 详解篇</h2>
<h2 id="1327-android-rxjavaretrofit-一次合并请求多个接口">13.27. Android RxJava+Retrofit 一次（合并）请求多个接口</h2>
<h2 id="1328-android之application的使用">13.28. Android之Application的使用</h2>
<h2 id="1329-rxjavaretrofit使用okhttp保存和添加cookie">13.29. Rxjava、Retrofit使用OkHttp保存和添加cookie</h2>
<h2 id="1330-retrofit使用拦截器添加cookie">13.30. Retrofit使用拦截器添加Cookie</h2>
<h2 id="1331-android-glide简单使用">13.31. android Glide简单使用</h2>
<h2 id="1332-sharedpreference的优化">13.32. SharedPreference的优化</h2>
<h2 id="1333-ontouch关于performclick的warning">13.33. OnTouch关于performClick的Warning</h2>
<h2 id="1334-mvpretrofit实现的原生登录注册">13.34. MVP+Retrofit实现的原生登录注册</h2>
<h2 id="1335-drawlefttextviewedittext中图片大小设置">13.35. drawleft，textview、EditText中图片大小设置</h2>
<h2 id="1336-edittext组件drawableleft属性设置的图片和hint设置的文字之间的距离">13.36. EditText组件drawableLeft属性设置的图片和hint设置的文字之间的距离</h2>
<h2 id="1337-android实现沉浸式状态栏效果">13.37. Android实现沉浸式状态栏效果</h2>
<h2 id="1338-迁移到-androidx">13.38. 迁移到 AndroidX</h2>
<h2 id="1339-recyclerview多item布局实现">13.39. RecyclerView多item布局实现</h2>
<h2 id="1340-一种优雅的方式实现recyclerview条目多类型">13.40. 一种优雅的方式实现RecyclerView条目多类型</h2>
<h2 id="1341-bottomnavigationview点击图标颜色不改变">13.41. BottomNavigationView点击图标颜色不改变</h2>
<h2 id="1342-androidviewviewgroupjumpdrawablestocurrentstateviewgroupjava6690">13.42. android.view.ViewGroup.jumpDrawablesToCurrentState(ViewGroup.java:6690)</h2>
<h2 id="1343-android-studio-提取局部变量全局变量方法快捷键">13.43. android studio 提取局部变量，全局变量，方法快捷键</h2>
<h2 id="1344-bottomnavigationview底部导航的使用">13.44. BottomNavigationVIew底部导航的使用</h2>
<h2 id="1345-android中butterknife的使用">13.45. Android中ButterKnife的使用</h2>
<h2 id="1346-看完让你彻底搞懂websocket原理">13.46. 看完让你彻底搞懂Websocket原理</h2>
<h2 id="1347-uncaught-referenceerror-xxx-is-not-defined-at-htmlinputelementonclick">13.47. Uncaught ReferenceError: xxx is not defined at HTMLInputElement.onclick</h2>
<h2 id="1348-zxing扫一扫实现机制和算法研究透彻">13.48. ZXing扫一扫，实现机制和算法，研究透彻</h2>
<h2 id="1349-app在修改昵称和上传头像失败">13.49. App在修改昵称和上传头像失败</h2>
<p>App在修改昵称和上传头像后，按两次返回键退出，再重新登录，显示的还是之前的头像和昵称，但是如果彻底关闭该应用，就不会出现这个现象，跟event内存有关</p>
<h2 id="1350-昵称的正则">13.50. 昵称的正则</h2>
<p>昵称的正则，允许中英文数字混合，并且限制中文时是26个汉字，英文时是2~12个英文字母，混输时(比如中英、中数、英数)是多少字符，更为人性化的提示</p>
<h2 id="1351-json数据递归遍历">13.51. JSON数据，递归遍历</h2>
<h2 id="1352-关于java对象作为参数传递是传值还是传引用的问题">13.52. 关于Java对象作为参数传递是传值还是传引用的问题</h2>
<h2 id="1353-android-studio打包签名-signature-versions-v1v2的选择问题">13.53. Android Studio打包签名 Signature Versions V1、V2的选择问题</h2>
<h2 id="1354-es6promisegeneratornextyield与koa">13.54. ES6、PROMISE、GENERATOR、NEXT、YIELD与KOA</h2>
<h2 id="1355-取代promise的generator生成器函数">13.55. 取代Promise的Generator生成器函数</h2>
<h2 id="1356-android-studio之gradle自动化构建打包">13.56. Android Studio之Gradle自动化构建打包</h2>
<h2 id="1357-android-使用jenkins持续集成打包发包">13.57. Android 使用Jenkins持续集成打包发包</h2>
<h2 id="1358-gradle-手动编译出android的简单的apk文件">13.58. gradle 手动编译出android的简单的apk文件</h2>
<h2 id="1359-gradle-命令打包apk">13.59. gradle 命令打包apk</h2>
<h2 id="1360-jest顺序执行测试">13.60. JEST顺序执行测试</h2>
<h2 id="1361-android-实现类似微信异地登录强制下线">13.61. Android 实现类似微信，异地登录强制下线</h2>
<h1 id="14-windows">14. Windows</h1>
<h2 id="141-windows系统快速删除多层级的文件夹-">14.1. Windows系统快速删除多层级的文件夹 🔹</h2>
<p>在<code>Windows</code>系统中，要删除多层级的文件夹，比如项目依赖包<code>node_module</code>，它的目录可能包含有成千上万的文件和子目录，因为系统删除时会将这些文件逐一检查，读取文件大小、权限验证等，会额外增加删除所需的时间，如果电脑配置不太行，真的让人受不了。</p>
<p>基于博文<a href="https://blog.csdn.net/xiaoerbuyu1233/article/details/108490963">《Windows下快速删除上万个文件和子目录(快速删除文件) 命令行cmd快速删除文件夹》</a>提供的解决方案如下：</p>
<p>在<code>D:\tools\FASTDEL</code>中新建一个<code>fastdel.bat</code>文件，然后复制下面的代码：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-bat" data-lang="bat"><span class="line"><span class="cl"><span class="p">@</span><span class="k">ECHO</span> OFF
</span></span><span class="line"><span class="cl"><span class="k">ECHO</span> Delete Folder: <span class="nv">%CD%</span>
</span></span><span class="line"><span class="cl"><span class="k">PAUSE</span>
</span></span><span class="line"><span class="cl"><span class="k">SET</span> <span class="nv">FOLDER</span><span class="p">=</span><span class="nv">%CD%</span>
</span></span><span class="line"><span class="cl"><span class="k">CD</span> ..
</span></span><span class="line"><span class="cl"><span class="k">DEL</span> /F/Q/S <span class="s2">&#34;</span><span class="nv">%FOLDER%</span><span class="s2">\*&#34;</span> <span class="p">&gt;</span> NUL
</span></span><span class="line"><span class="cl"><span class="k">RMDIR</span> /Q/S <span class="s2">&#34;</span><span class="nv">%FOLDER%</span><span class="s2">&#34;</span>
</span></span><span class="line"><span class="cl"><span class="k">EXIT</span>
</span></span></code></pre></div><p>保存之后，打开系统环境变量配置页面，在<code>Path</code>路径加上<code>D:\tools\FASTDEL</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409211001590.png"></p>
<p>之后，在你要删除的文件目录下，打开<code>Windows PowerShell</code>命令窗口，然后输入命令<code>FASTDEL</code>进行删除即可，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409211020986.png"></p>
<h2 id="142-端口被占用怎么解决">14.2. 端口被占用，怎么解决？🔹</h2>
<p>在 Windows 下检查端口 503 是否被占用，以管理员身份运行 “命令提示符” 窗口，使用命令检查当前端口使用的进程：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl">netstat -ano <span class="p">|</span> findstr :503
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502211744587.png"></p>
<p>然后记下状态为 LISTENING 的数字（例如 39880），然后使用以下命令，终止进程：</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-sh" data-lang="sh"><span class="line"><span class="cl"> taskkill /PID <span class="m">39880</span> /F
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202502211744928.png"></p>
<h1 id="15-技术管理">15. 技术管理</h1>
<h2 id="151-独家专访亚马逊-cto-werner-vogels--infoq--">15.1. <a href="https://mp.weixin.qq.com/s/YAvZPZfTFBLZ3OqnIHJElg">独家专访亚马逊 CTO Werner Vogels | InfoQ </a> 🔹</h2>
<ol>
<li>各种商业机构和教育平台都能帮我们快速掌握新的编程语言，所以到底选择哪种语言本身已经不那么重要了。</li>
<li>由于技术发展太过迅速，高等教育、大学课程根本就跟不上变化。问问那些刚刚走出校园的学生就知道了，他们对区块链、生成式 AI 等新技术的了解肯定不如我们这些从业者。而且随着技术的采用周期越来越短，产品的上市速度也会远超以往。也就是说，学校里传授的知识不再具有先进性。所以除了编程语言之外，我们在学校中的最大收获就是学习能力，这种学习能力决定我们能否成为技术专家、保持终身钻研。</li>
<li>我认为任何接受过良好基础教育的人都有能力掌握计算机技术，即便专业不同。因为具体学了什么专业并不重要，重要的是教育经历让你掌握了学习能力、知道要如何设立更宏大的目标、如何汇总信息、记在脑子里、进行批判性思考，如此往复。</li>
<li>在实际工作中，我强调“协作”是日常工作的核心。</li>
<li>对于招聘，我更关心候选人是否具备在大学里培养的学习能力，而不仅仅是特定的语言或技术。</li>
<li>技术的变化一刻不停，永远别指望自己毕业之后头一年学到的东西够用一辈子。</li>
<li>但保守并不代表守旧，研究人员还是在努力把成果整合起来，打造出能让消费者们眼前一亮的产品。就像那个有趣的比喻，如果你看到一只熊在跳舞，那最重要的就是它能跳舞，而不是它跳得好不好。希望大家能用类似的心态看待前沿技术，尽量宽容一点。</li>
<li>AI 可以接管一些繁琐的任务，这使得开发者可以更专注于他们真正擅长的工作，如获取和整合信息、做出决策和规划。</li>
<li>人需要肩负起监管的职责。请记住，AI 只是辅助、是帮助我们的工具。它们是在帮我们做预测，而不是替我们做预测，责任永远要由人来承担。</li>
</ol>
<h2 id="152-闭环管理">15.2. 闭环管理</h2>
<h2 id="153-巨佬jake-wharton曾说过一个app只需要一个activity">15.3. 巨佬Jake Wharton曾说过：一个App只需要一个Activity</h2>
<h2 id="154-infoq-在-ete-大会上对-android-工程师-jake-wharton-的采访">15.4. InfoQ 在 ETE 大会上对 Android 工程师 Jake Wharton 的采访</h2>
<h2 id="155-几种思维">15.5. 几种思维</h2>
<ol>
<li>
<p>归纳性思维：</p>
</li>
<li>
<p>结构性思维：</p>
</li>
<li>
<p>MECE原则：</p>
</li>
<li>
<p>慢就是快，少就是多。</p>
</li>
<li>
<p>别人有，我们也要有的思路是否正确？</p>
</li>
</ol>
<h2 id="156-我们就要做第一">15.6. 我们就要做第一</h2>
<p>我有时也在想，为什么不能是我呢？我就想干掉所有人，就要做最强的那一个。表面再怎么与世无争，再怎么云淡风轻，但还是无法压制内心深处的猛兽，那种感觉越来越强烈。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202403091016929.png"></p>
<p>前年在整理团队定位、目标、规范、愿景等文档，在和领导谈心时，说到团队未来的发展，当时脱口而出，“团队发展壮大，成立子公司，其他部门凭什么就要比我们厉害呢？我们就要做第一。”现在想来，不免有点心虚，且不说公司关系错综复杂、外部市场瞬息万变，光是团队本身都有很多问题需要解决，谁和谁讨论问题吵起来了要从中调和；谁在会议上说话太难听了要及时打断，避免伤害其他同事自尊；谁和谁表面和气，暗地里互不对付，要及时察觉，避免后续任务安排不够妥当；谁工作上总是耍些小聪明杀了他的心都有了，但又不能表现出来&hellip;&hellip;看似鸡毛蒜皮的事情，但又关乎团队的健康成长，每每斡旋其中，不堪其扰，而这也只是团队管理的一小部分工作而已。话说回来，虽然有点心虚，但我不后悔当时说上面那些话，即便现在也是如此，为什么就要比别人差呢？我就想努力干掉其他人。敢想就敢要，越挫就越勇。等到真有那一天（嗯&hellip;真的很难的了哈哈哈&hellip;稍微试一试），我想我就会离开，进行下一阶段的事情。</p>
<h2 id="157-兵熊熊一个将熊熊一窝">15.7. 兵熊熊一个，将熊熊一窝</h2>
<p>一个能打的人只是他能打，能让一群能打的人聚集在一起去“打”，那战斗力可想而知。</p>
<h2 id="158-太阳底下没有新鲜事儿">15.8. 太阳底下没有新鲜事儿</h2>
<p>太阳底下没有新鲜事儿。</p>
<h2 id="159-如果你录用我">15.9. 如果你录用我</h2>
<ol>
<li><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202403140910843.jpg"></li>
</ol>
<h2 id="1510-技术人对抗焦虑的加减法-">15.10. 技术人对抗焦虑的加减法 🔹</h2>
<p><a href="https://developer.aliyun.com/article/1356721?utm_content=g_1000382235">技术人对抗焦虑的加减法-阿里云开发者社区 (aliyun.com)</a></p>
<ol>
<li>不要把别人贩卖的焦虑强加到自己的感受中</li>
<li>没有坑，就让自己先成为萝卜，等待机会</li>
<li>要从本质去思考问题，如果只是找一匹跑得更快的马，那就不会发明汽车</li>
<li>决定未来的不是过去，也不是他人的评价，而是你自己定义的将来。</li>
<li>最挑战的事情，最高级的快乐</li>
<li>警惕低水平的勤奋，不要碎片化学习</li>
<li>认知自己，比认知知识点更重要</li>
</ol>
<h2 id="1511-比尔盖茨山姆奥特曼-">15.11. 比尔·盖茨&amp;山姆·奥特曼 🔹</h2>
<p><a href="https://www.infoq.cn/article/Ly4avjCIkBp2gF3eqrEK">OpenAI也搞“年龄歧视”？奥特曼对话盖茨爆料：员工整体年龄偏大，是个坏兆头-InfoQ精选文章</a></p>
<p><strong>山姆·奥特曼:</strong> 大家一定经常让你提点建议，那你一般会怎么说？</p>
<p><strong>比尔·盖茨:</strong> 我觉得这世界上有很多不同形式的人才。在我的职业生涯之初，我只重视纯粹的智商，类似于工程技术的灵性。当然，这个逻辑在财务和销售领域也有体现。但事实证明这是不对的。能建立起强大团队的技能组合才是重中之重。能引导人们思考、找到想要解决的问题、建立一支融合不同人才的队伍，才是最重要的能力所在。所以我想告诉年轻人，数学和科学能力当然很重要，但如果你真想成就一番事业，那么前面说的这种才能组合必不可少。</p>
<p>你呢，你会给出什么样的建议？</p>
<p><strong>山姆·奥特曼:</strong> 我比较关注大多数人对于风险的错误理解。大家往往害怕放弃自己当前这份轻松愉快的工作，不敢奔赴自己真正想做的事情。但实际上，如果始终止步不前，那他们最终回顾一生，只会感叹自己从没有投入过、没有创办自己想象中的企业、也没试着成为一名 AI 研究者。我觉得这才是最大的风险，是让整个人生沦于平庸的风险。</p>
<p>正因为如此，我们应该明确自己的目标，同时积极询问其他人需要什么，这就是良好的开端。很多人都在以自己不想的方式虚耗时间，而我给出的建议就是试着以积极的方式解决这个问题。</p>
<p><strong>比尔·盖茨:</strong> 确实，让人们从事一份自己有成就感、满足感的工作，往往能够迸发出他们自己都难以想象的力量。</p>
<p><strong>山姆·奥特曼:</strong> 绝对是这样。</p>
<h2 id="1512-为什么都开始搞研发效能">15.12. 为什么都开始搞研发效能？</h2>
<p><a href="https://mp.weixin.qq.com/s?__biz=MjM5ODYwMjI2MA==&amp;mid=2649762616&amp;idx=1&amp;sn=3b7f6e570b390697d0cacb248ab9b020&amp;chksm=beccb84389bb3155ed9531ac8111c65d06eb6ec5f2912a4378e87eadd3d41870988c5d988ef3&amp;scene=21#wechat_redirect">为什么都开始搞研发效能？ (qq.com)</a></p>
<ol>
<li>国内的很多工程实践是为了做而做，而不是从本质上认可这一工程实践的实际价值。</li>
<li>当把度量变成一个指标游戏的时候，永远不要低估人们在追求指标方面“创造性”，总之我们不应该纯粹面向指标去开展工作，而应该看到指标背后更大的目标，或者是制定这些指标背后的真正动机。</li>
<li>人越来越像工具，而工具越来越像人。</li>
<li>对于研发效能，实施的思路不对，方法不对会搞垮一个团队，我们需要的是体系化的方法论和相应的工程实践。</li>
</ol>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202402231713334.png"></p>
<h2 id="1513-研发效能度量实践者指南-">15.13. 研发效能度量实践者指南 🔹</h2>
<p><a href="https://cloud.tencent.com/developer/article/1873011">研发效能度量实践者指南（万字长文）-腾讯云开发者社区-腾讯云 (tencent.com)</a></p>
<ol>
<li>“我虽然没有功劳，但是我也有苦劳。” 大部分人可能只关注自己的付出，但并不关心付出所获得的实际效果。作为管理者应该为“苦劳鼓掌，为功劳付钱”。而功劳和苦劳的体现也需要借助客观的度量数据来体现，否则团队中的成员会逐渐陷入碌碌无为的窘境。</li>
<li>管理者往往会把目标拆解为可度量的指标。但是，目标和指标常常并不是简单的全局与局部的关系。目标的拆解过程看起来很顺畅，是那么地理所当然，但是当把拆解完的指标合并起来的的时候，结果往往让人哭笑不得。有一个笑话说的是，“你问人工智能，我要找一个女朋友，像安·海瑟薇一样的大眼睛，像朱莉娅·罗伯茨一样的大嘴，喜爱运动，陆上运动、水上运动都会。人工智能就根据这几个指标给出了母青蛙的答案”。所以，指标和目标常常并不是充分必要的关系。</li>
<li>指标是为了实现目标的，但是在实践过程中，指标很多时候却是与目标为敌的。管理者常常把目标拆解为指标，时间久了以后，他就只知道指标，而忘了背后更重要的目标。如果目标是林，那么指标就是木，时间久了就是只见树木，不见森林。这个时候忘记了目标是什么的管理者就会变得非常短视。那些不懂数据的人很糟糕，而最最糟糕的人是那些只看数字的人。在福特汽车的发展史上，有一段至暗时期。那些实践经验丰富，但是没有上过商学院的的老一辈管理层被干掉，取而代之的名校管理背景的数据分析师，公司试图通过精细化的数字管理来实现业务的增长。由于这些数据分析师并不熟悉业务，所以就只能看度量数据，越是不懂业务就越依赖度量数据来做决策，最后使整个公司陷入了泥潭。软件研发也有类似的尴尬，为了更好地代码质量，所以就制定了严格的代码测试覆盖率要求。时间一久，大家都机械性的追求这个指标，而忘记了当时设立这个指标的初衷，于是就出现了高覆盖率的大量单元测试中没有断言这样尴尬的局面。</li>
</ol>
<h2 id="1514-showcase深入了解">15.14. Showcase深入了解</h2>
<p><a href="https://blog.csdn.net/Teamo_mc/article/details/129097764">ShowCase 专治开发的「我自测好了」</a></p>
<h2 id="1515-如何正确的做技术选型">15.15. 如何正确的做技术选型？</h2>
<h2 id="1516-为什么技术团队应该写博客">15.16. 为什么技术团队应该写博客？</h2>
<h2 id="1517-编写高质量的代码从命名入手">15.17. 编写高质量的代码——从命名入手</h2>
<h2 id="1518-产业数字人才研究与发展报告2023pdf">15.18. 产业数字人才研究与发展报告2023.pdf</h2>
<p><a href="https://www2.deloitte.com/content/dam/Deloitte/cn/Documents/consulting/deloitte-cn-hc-industrial-digital-talents-zh-230609.pdf">deloitte-cn-hc-industrial-digital-talents-zh-230609.pdf</a></p>
<p><a href="https://new.qq.com/rain/a/20230321A0APKZ00">《产业数字人才研究与发展报告》：我国数字人才缺口超过2500万_腾讯新闻 (qq.com)</a></p>
<h2 id="1519-cookie-banner--cookie-policy-">15.19. Cookie Banner &amp; Cookie Policy 🔹</h2>
<p>Cookie Banner是指网站上出现的一种通知条，用于告知用户该网站使用Cookie等技术来收集、存储和处理用户数据，并且需要用户同意这些数据的使用。通常，Cookie Banner会包含一个简要的说明，告知用户使用Cookie的目的和类型，以及提供一个同意或拒绝的选项。此外，还可能包含一个链接，指向更详细的隐私政策或Cookie策略页面。</p>
<p>Cookie政策是网站提供给用户的一份声明，解释了网站如何使用Cookie（一种小型文本文件），以及与Cookie相关的数据收集和隐私保护措施。Cookie是一种存储在用户计算机上的文本文件，它包含有关用户访问网站的信息。许多网站使用Cookie来跟踪用户行为，例如记住用户首选项、购物车信息、广告和其他内容。Cookie政策通常包括以下信息：</p>
<ol>
<li>网站使用Cookie的目的和类型。</li>
<li>与Cookie相关的数据如何收集、存储和使用。</li>
<li>用户如何控制Cookie的使用和删除Cookie。</li>
<li>如何保护用户数据隐私。</li>
<li>Cookie政策的更新和变更如何通知用户。</li>
</ol>
<h2 id="1520-gdpr">15.20. GDPR</h2>
<p>GDPR的全面实施，意味着欧盟对于个人信息的保护及监管达到了前所未有的高度，GDPR堪称史上最严格的数据保护法案，任何违反GDPR的行为，将会产生1000万到2000万欧元的罚款，或企业全球年营业额的2%到4%，以数额最大的为准。</p>
<p><a href="https://zhuanlan.zhihu.com/p/401330458">一文读懂GDPR - 知乎 (zhihu.com)</a></p>
<h2 id="1521-快速访问github网站">15.21. 快速访问github网站</h2>
<p>最近遇到访问<code>github</code>经常失败的问题，因为在公司<code>Windows</code>电脑是不能随便安装软件的，没办法安装梯子软件，所以就找了一下有什么方式能辅助访问<code>github</code>，查了一下在<code>Microsoft Store</code>上有一个<code>Watt Toolkit</code>软件可以使用，效果还可以。</p>
<h2 id="1522-edge浏览器解决新建标签页被限制问题">15.22. Edge浏览器解决新建标签页被限制问题</h2>
<p>使用<a href="https://microsoftedge.microsoft.com/addons/detail/custom-new-tab/onagfgjlokaciajhjmajljcfanonbmia">Custom New Tab - Microsoft Edge Addons</a>插件解决。</p>
<h2 id="1523-问题清单文档内容布局错乱">15.23. 问题清单文档内容布局错乱</h2>
<p>这个文档出现内容全都塞到目录上面去了，然后怎么调整都没有用，排查了一下，原因是有些标题出现<code>&lt;table&gt;</code>、<code>&lt;div&gt;</code>但是没有使用高亮符将其高亮，变成文本显示，因为之前<code>Paper</code>主题为了显示<code>&lt;img/&gt;</code>设置了解析<code>html</code>代码，所以导致其解析成html代码运行了。</p>
<h2 id="1524-如果没有人读博客为什么要写呢">15.24. <a href="https://andysblog.uk/why-blog-if-nobody-reads-it/">如果没有人读博客，为什么要写呢？</a></h2>
<ol>
<li>博客的目标读者，其实不是互联网人群，而是未来的你，你的文章会让你看到自己思想的演变。</li>
<li>你写博客是因为你在思考，因为你在观察，因为你希望把它放在某个地方。</li>
<li>如果有人读了，那就更好了。如果没有，工作还是完成了。这才是真正的重点。</li>
</ol>
<h1 id="16-小技巧">16. 小技巧</h1>
<h2 id="161-如何在-mermaid-在线编辑器中实现长截图-">16.1. 如何在 Mermaid 在线编辑器中实现长截图 🔹</h2>
<p>在 <a href="https://mermaid-live.nodejs.cn/">Mermaid 在线编辑器</a> 上快速截图，虽然已经支持以 PNG 格式下载，但当流程图很长时，页面两边的间距过大，导致流程图内容展示过小。所以，可以使用 Google 浏览器的全屏截图功能。具体操作是：在流程图预览模式下，按下 <code>F12</code>，然后按下 <code>Ctrl + Shift + P</code>，输入 <code>screenshot</code>，选择 <strong>Capture full size screenshot</strong>，这样就可以实现长截图了。</p>
<p>不过，在 <a href="https://mermaid.nodejs.cn/">Mermaid 中文网</a> 上，这个方法一直没成功。后来发现，可以先点击 <strong>Kroki</strong> 预览流程图，然后缩小窗口，再使用上述命令，这样就能成功截图了。</p>
<h2 id="162-ubuntu系统终端切换至root">16.2. Ubuntu系统，终端切换至root</h2>
<p>在终端输入 <code>su</code> 然后输入密码即可。</p>
<h2 id="163-邮件typora软件插入日期">16.3. 邮件、typora软件插入日期🔹</h2>
<p>在平时写邮件和 <code>typora</code> 软件写日记的时候，特别苦恼怎么能快速插入日期，比如写日记，每次都要复制昨天的日记文档，然后修改时间，很是繁琐，所以就研究了一下，结果发现使用搜狗输入法就很快实现了。</p>
<p>使用搜狗输入法，在中文模式下，输入 <code>rq</code> ，则会自动显示日期格式 <code>年月日</code> ，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202308301608646.png"></p>
<p>如果输入 <code>sj</code> ，则会显示<code>年月日时分秒</code>，如下所示：</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202308301612720.png"></p>
<p>这样就可以快速插入日期了。</p>
<h2 id="164-markdown-自动加上标题编号-">16.4. Markdown 自动加上标题编号 🔹</h2>
<p>因为我那个记录问题的<code>markdown</code>文档，需要时不时更新一下内容，所以，标题的编号也要同步更新，这个文档内容那么多，改起来工作量很大，只能研究一下，怎么在<code>markdown</code>文档里自动加上标题编号。</p>
<p>在<code>VSCode</code>里有插件能够实现这个需求，自己也使用了一段时间，感觉还是很方便的，只是因为电脑更新系统，不小心卸载了这个插件，不太记得插件名字了，只能使用另一个———— <a href="https://marketplace.visualstudio.com/items?itemName=panchaoxin.markdown-header">Markdown Header</a>。可使用这个插件增加标题编号时，发现它并不是基于现有的标题编号进行更新，而是额外增加了标题编号，比如<code>1.1 1.1</code>，加上要清空标题编号没有生效，只能看下，怎么把当前文档里的标题编号全都清空，然后，再使用这个插件自动生成标题编号，解决思路是，在<code>VSCode</code>中使用正则表达式搜索，匹配到<code># 1.2.3</code>类似的格式，一个<code>#</code>加一个空格，然后是标题编号，全部替换成<code>#</code>即可。</p>
<div class="highlight"><pre tabindex="0" class="chroma"><code class="language-ts" data-lang="ts"><span class="line"><span class="cl"><span class="p">(</span><span class="err">#\</span><span class="nx">s</span><span class="o">+</span><span class="p">)(</span><span class="err">\</span><span class="nx">b</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">(</span><span class="err">\</span><span class="p">.</span><span class="err">\</span><span class="nx">d</span><span class="o">+</span><span class="p">)</span><span class="o">*</span><span class="err">\</span><span class="nx">b</span><span class="p">)</span>
</span></span></code></pre></div><p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202409051357213.png"></p>
<p>接着，使用<code>Ctrl+Shift+P</code>，选择<code>Markdown generate header number</code>，一键生成标题编号。</p>
<h2 id="165-每日背英语单词">16.5. 每日背英语单词</h2>
<p>之前一直计划每天背30个英文单词，但是坚持了几天就不了了之，总觉得太费时间了，搞不好就要1个小时，有点难顶，现在回过头来想想，自己在做事情上面，还是不够聪明，其实不用贪多，很多学习并不是为了学习知识，而是学习一种习惯，就好像ARTS，并不指望能有多大的收益，最主要的是保持一种习惯，保持一种感觉，这种感觉类似于篮球中的投篮手感，如果中断的时间过久，就会生疏。所以，可以调整为每天就5个英语单词，这个要求不过分吧。</p>
<h2 id="166-写作技巧">16.6. 写作技巧</h2>
<ol>
<li>背景、初衷和目标</li>
<li>优势和劣势</li>
<li>适用场景</li>
<li>组成部分和关键点</li>
<li>底层原理和关键实现</li>
<li>已有的实现和对比</li>
</ol>
<h1 id="17-其他">17. 其他</h1>
<h2 id="171-大猩猩理论">17.1. 大猩猩理论🔹</h2>
<p>查理·芒格的“大猩猩理论”：一个聪明人进入一个有大猩猩的房间，解释他的想法是什么，而那个大猩猩只是坐在那里吃它的香蕉。结束这段谈话后，那个解释的人出来时一定变得更聪明了。</p>
<h2 id="172-康波周期">17.2. 康波周期</h2>
<h2 id="173-忙碌海狸图灵机">17.3. “忙碌海狸”图灵机</h2>
<h2 id="174-西蒙学习法">17.4. 西蒙学习法</h2>
]]></content:encoded>
    </item>
    <item>
      <title>第十一周：学习总结</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%8D%81%E4%B8%80%E5%91%A8%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93/</link>
      <pubDate>Mon, 11 Jan 2021 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%8D%81%E4%B8%80%E5%91%A8%E5%AD%A6%E4%B9%A0%E6%80%BB%E7%BB%93/</guid>
      <description>&lt;h2 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h2&gt;
&lt;p&gt;历时三个月的学习，让我对管理有了更为清晰的认知，以前自己是摸着石头过河，很难判断什么样的方式，或者说什么样的思路是正确的，但是，经过这段时间的学习，自己好像突然在迷雾中看见了明灯，可以看见前方的路况，仿佛看到了整个管理世界的地图，然后知道了自己处于哪个位置。&lt;/p&gt;
&lt;h2 id=&#34;2-角色转变&#34;&gt;2. 角色转变&lt;/h2&gt;
&lt;p&gt;在没有学习之前，我是这样认为的，普通员工只需要做好自己手头上的工作，比如他是一位开发人员，那么他只需要按照需求完成开发任务即可，但是管理者不一样，管理者可能也会有项目的开发任务，但是他不能仅仅只是做好自己的开发工作，还需要对整个团队负责。管理者自己的工作做得很好，但是如果整个团队的成果很糟糕，那么这个管理者就是失败的。&lt;/p&gt;
&lt;p&gt;但我也只是认识到这一层而已，如果有人问我，那么管理者要怎么对团队负责呢？用什么方式呢？估计我就回答不上来了。所以，我反思的一个心得就是，角色应该转变，但是怎么转变呢？具体应该要怎么做？是事无巨细还是发号指令？在项目早期，管理者可以带头冲锋，负责很多项目功能的开发，但在项目后期，应该要试着将有挑战性的开发任务留给其他人，帮助其成长，自己应该往更高一层维度去思考项目的问题，关注项目开发进度，项目往后发展方向等等，更加注重全局，而不是局部。&lt;/p&gt;
&lt;h2 id=&#34;3-双赢&#34;&gt;3. 双赢&lt;/h2&gt;
&lt;p&gt;不管从公司，还是个人，管理的目的，最终受益都是双赢，这是我所认为的。&lt;/p&gt;
&lt;p&gt;从公司层面，管理是为了能让公司长久地健康生存下去；从部门层面，管理是为了让团队能够做出更好的成果；从员工层面，管理可以有效的提高员工自身的工作效率；从管理者层面，管理是为了实现管理者的心中较为自我的愿景，实现自我价值。&lt;/p&gt;
&lt;p&gt;学习的这段时间，更让我体会到“双赢”无处不在，不管是自己所交的朋友，还是其他事情，很多都是无意识的，都是有“双赢”的东西在里面，透过这个，更让我明白的一个点就是，如果一个很喜欢为他人着想的人，喜欢帮助别人的人，他应该知道，收取别人的回报是明智的行为，且不说，是“孔子批评子贡做好事不领取奖金”那个典故的原因，更多是因为很多人在无私奉献之后，没有接受别人的称赞，他自以为自己是很高尚的，但是如果对方以后做了什么稍有不好的地方，他基本上就会以为，以前我那么对他，他原来是这样的人，真是不值得。还有一些就是朋友之间的买卖交易，一些东西可能朋友之间关系很好的，自己是可以白送的，但还是要收钱的，也是这个原因，可以收的很少，但是不能不收。在我的理解范畴内，就是打破了“双赢”的平衡导致的。&lt;/p&gt;
&lt;h2 id=&#34;4-大道至简&#34;&gt;4. 大道至简&lt;/h2&gt;
&lt;p&gt;对于管理而言，光有内功和招式，没有实战去验证，那不算真正掌握。即便学以致用，有所成效，但有可能只是暂时的，学得再多的东西，人自己的品性才是最根本的，如果你内功深厚，哪怕没有招式，至少保证怎么打都打不死，对应的就是，虽然你没有掌握太多管理上面的方法，但如果知道关怀下属，以诚相待，让对方能感觉到你的诚意，那么对于整个团队而言，基本盘还是有的。但是，要上升到更高的层面，就需要科学的管理方式，也就是武功招式了。&lt;/p&gt;
&lt;p&gt;大道至简，作为管理者，最终可能还是要回归到个人品性的修炼上面，待人接物，行为举止，都是修行。就好像学习技术一样，各种前沿框架、前沿技术满天飞，但是基础知识不扎实，到头来，很容易就变成泡沫，一吹就破。&lt;/p&gt;
&lt;h2 id=&#34;5-以人为本&#34;&gt;5. 以人为本&lt;/h2&gt;
&lt;p&gt;“大道至简”是指让管理者知道回归到个人品性的修炼上面，“以人为本”是要让管理者知道你要管理的是人，是一个个有血有肉活生生的人，不是要管理团队里的那些工作，那只是表面的东西，核心其实还是人。&lt;/p&gt;
&lt;p&gt;一方面，既然是人，那就需要知道人是怎么想的，我们不可能知道每个人的想法，但是可以把人特有的一些共性总结出来，深入去理解这些共性，那么就很好理解自己员工的一些想法，就比较好把掌控整个团队的运转。另一方面，以人为本，就需要体现出管理者对下属的关怀，就需要管理者关注下属的各个方面，而不仅仅只是工作，还要包括生活，让他可以给公司带来收益的同时，自己也能够得到成长，这就体现“双赢”的思维了。一个团队，是由一个个人组成的，任何一个环节出了问题，都会影响到整个团队。&lt;/p&gt;
&lt;p&gt;我最近听到的很喜欢的一句话就是伦纳德说的，“我们希望球队中每个人都能成为自己角色上的赢家。”&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;多年以后再看这些培训作业，有些太理想化了，说到底，管理只不过是公司为了能获取到更多利益的手段罢了，不用说得那么高大上，每个人的利益诉求并不一样，你不能强求他人按你的标准去做事情，自己也不要入戏太深，只是一份工作而已，没有必要有那么多的情绪。在工作上，你想要做成一些远大的事情，如果很难，那就适当妥协就好了，可以慢慢把这口气攒起来，迟早有一天，可以有机会完全贯彻你的意志，成为你想要的样子。&lt;/p&gt;&lt;/blockquote&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-前言">1. 前言</h2>
<p>历时三个月的学习，让我对管理有了更为清晰的认知，以前自己是摸着石头过河，很难判断什么样的方式，或者说什么样的思路是正确的，但是，经过这段时间的学习，自己好像突然在迷雾中看见了明灯，可以看见前方的路况，仿佛看到了整个管理世界的地图，然后知道了自己处于哪个位置。</p>
<h2 id="2-角色转变">2. 角色转变</h2>
<p>在没有学习之前，我是这样认为的，普通员工只需要做好自己手头上的工作，比如他是一位开发人员，那么他只需要按照需求完成开发任务即可，但是管理者不一样，管理者可能也会有项目的开发任务，但是他不能仅仅只是做好自己的开发工作，还需要对整个团队负责。管理者自己的工作做得很好，但是如果整个团队的成果很糟糕，那么这个管理者就是失败的。</p>
<p>但我也只是认识到这一层而已，如果有人问我，那么管理者要怎么对团队负责呢？用什么方式呢？估计我就回答不上来了。所以，我反思的一个心得就是，角色应该转变，但是怎么转变呢？具体应该要怎么做？是事无巨细还是发号指令？在项目早期，管理者可以带头冲锋，负责很多项目功能的开发，但在项目后期，应该要试着将有挑战性的开发任务留给其他人，帮助其成长，自己应该往更高一层维度去思考项目的问题，关注项目开发进度，项目往后发展方向等等，更加注重全局，而不是局部。</p>
<h2 id="3-双赢">3. 双赢</h2>
<p>不管从公司，还是个人，管理的目的，最终受益都是双赢，这是我所认为的。</p>
<p>从公司层面，管理是为了能让公司长久地健康生存下去；从部门层面，管理是为了让团队能够做出更好的成果；从员工层面，管理可以有效的提高员工自身的工作效率；从管理者层面，管理是为了实现管理者的心中较为自我的愿景，实现自我价值。</p>
<p>学习的这段时间，更让我体会到“双赢”无处不在，不管是自己所交的朋友，还是其他事情，很多都是无意识的，都是有“双赢”的东西在里面，透过这个，更让我明白的一个点就是，如果一个很喜欢为他人着想的人，喜欢帮助别人的人，他应该知道，收取别人的回报是明智的行为，且不说，是“孔子批评子贡做好事不领取奖金”那个典故的原因，更多是因为很多人在无私奉献之后，没有接受别人的称赞，他自以为自己是很高尚的，但是如果对方以后做了什么稍有不好的地方，他基本上就会以为，以前我那么对他，他原来是这样的人，真是不值得。还有一些就是朋友之间的买卖交易，一些东西可能朋友之间关系很好的，自己是可以白送的，但还是要收钱的，也是这个原因，可以收的很少，但是不能不收。在我的理解范畴内，就是打破了“双赢”的平衡导致的。</p>
<h2 id="4-大道至简">4. 大道至简</h2>
<p>对于管理而言，光有内功和招式，没有实战去验证，那不算真正掌握。即便学以致用，有所成效，但有可能只是暂时的，学得再多的东西，人自己的品性才是最根本的，如果你内功深厚，哪怕没有招式，至少保证怎么打都打不死，对应的就是，虽然你没有掌握太多管理上面的方法，但如果知道关怀下属，以诚相待，让对方能感觉到你的诚意，那么对于整个团队而言，基本盘还是有的。但是，要上升到更高的层面，就需要科学的管理方式，也就是武功招式了。</p>
<p>大道至简，作为管理者，最终可能还是要回归到个人品性的修炼上面，待人接物，行为举止，都是修行。就好像学习技术一样，各种前沿框架、前沿技术满天飞，但是基础知识不扎实，到头来，很容易就变成泡沫，一吹就破。</p>
<h2 id="5-以人为本">5. 以人为本</h2>
<p>“大道至简”是指让管理者知道回归到个人品性的修炼上面，“以人为本”是要让管理者知道你要管理的是人，是一个个有血有肉活生生的人，不是要管理团队里的那些工作，那只是表面的东西，核心其实还是人。</p>
<p>一方面，既然是人，那就需要知道人是怎么想的，我们不可能知道每个人的想法，但是可以把人特有的一些共性总结出来，深入去理解这些共性，那么就很好理解自己员工的一些想法，就比较好把掌控整个团队的运转。另一方面，以人为本，就需要体现出管理者对下属的关怀，就需要管理者关注下属的各个方面，而不仅仅只是工作，还要包括生活，让他可以给公司带来收益的同时，自己也能够得到成长，这就体现“双赢”的思维了。一个团队，是由一个个人组成的，任何一个环节出了问题，都会影响到整个团队。</p>
<p>我最近听到的很喜欢的一句话就是伦纳德说的，“我们希望球队中每个人都能成为自己角色上的赢家。”</p>
<blockquote>
<p>多年以后再看这些培训作业，有些太理想化了，说到底，管理只不过是公司为了能获取到更多利益的手段罢了，不用说得那么高大上，每个人的利益诉求并不一样，你不能强求他人按你的标准去做事情，自己也不要入戏太深，只是一份工作而已，没有必要有那么多的情绪。在工作上，你想要做成一些远大的事情，如果很难，那就适当妥协就好了，可以慢慢把这口气攒起来，迟早有一天，可以有机会完全贯彻你的意志，成为你想要的样子。</p></blockquote>
]]></content:encoded>
    </item>
    <item>
      <title>第十周：目标计划管理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%8D%81%E5%91%A8%E7%9B%AE%E6%A0%87%E8%AE%A1%E5%88%92%E7%AE%A1%E7%90%86/</link>
      <pubDate>Sun, 10 Jan 2021 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%8D%81%E5%91%A8%E7%9B%AE%E6%A0%87%E8%AE%A1%E5%88%92%E7%AE%A1%E7%90%86/</guid>
      <description>&lt;h2 id=&#34;1-企业的目的&#34;&gt;1. 企业的目的&lt;/h2&gt;
&lt;p&gt;企业不同时期的目标是不一样的，第一阶段是保证存活；第二阶段是为了发展，加强公司业绩，达到预期的盈利；第三阶段是在发展壮大之后，有更多精力投入公司健康运转的事情，保证长久的生存下去；第四阶段是为了公司品牌，提升公司的品牌效应；第五阶段回馈社会，在社会上更多影响力。&lt;/p&gt;
&lt;p&gt;其实，这和人的成长路径是一样的，把企业当做一个人来看待，未尝不可，道理都是互通的。&lt;/p&gt;
&lt;h2 id=&#34;2-企业靠什么盈利&#34;&gt;2. 企业靠什么盈利&lt;/h2&gt;
&lt;p&gt;自身的竞争力，别人没有的我有，别人有的我的更好。&lt;/p&gt;
&lt;h2 id=&#34;3-管理不仅仅是项目管理&#34;&gt;3. 管理不仅仅是项目管理&lt;/h2&gt;
&lt;p&gt;我之前理解的管理，是对于整个部门来说的，除了项目管理，还有工作之外的事情，比如团建、购买零食等等生活上的一些建设，让我觉得管理就是当爹又当妈，很操心的。我只是理解到这一层，但是听完张工的讲的管理体系化，管理不只是自己部门的事情，是整个公司涉及到的方方面面。如果把管理体系化的概念放到部门里去，把部门当成一个微小型的公司，相信你就会明白，管理应该要做什么，不会只是局部的工作，而是整体。&lt;/p&gt;
&lt;h2 id=&#34;4-完美的整体是由不完美的局部构成的&#34;&gt;4. 完美的整体是由不完美的局部构成的&lt;/h2&gt;
&lt;p&gt;我之前有听过“木桶理论”，和课上讲的“短板理论”一样，意思是要想让团队成长，只需要补上薄弱的环节即可。同时，还有另一种见解的“长板理论”，意思是要充分发挥团队成员的优势，安排其去做适合自己的工作，那么，得到的成果一定可以抹平甚至超过薄弱部分所带来的负作用。&lt;/p&gt;
&lt;p&gt;结合这两种理论，我的理解是“木桶理论”当然有用，但它更多是关注到他人的缺点，很容易看不到他人的优势，至于“长板理论”，只会关注他人的优势，而忽略掉了缺点，所以，在实际中还是要结合着使用，在保证缺点处于一个可以接受的条件下，充分发挥长处会更好。比如之前不善言谈，说话都紧张到结巴，但是根据“木桶理论”，补强了沟通方面的问题，不说健谈，至少说话不紧张，有一个正常沟通的能力就好，在这个条件下，再充分发挥其优势在对的工作上。&lt;/p&gt;
&lt;h2 id=&#34;5-达成共识&#34;&gt;5. 达成共识&lt;/h2&gt;
&lt;p&gt;我认为达成共识的首要条件是，两个人讨论的确实是同一个东西，至少不是鸡同鸭讲，所说的都在同一个频道上，那怎么做到这点？那就需要多去描述客观事实，而不是表达感受，也就是课上讲到的现象和评价，非暴力沟通里也提到了这点，就是双方少用评价型的措词，比如说要开发一个杯子，讨论一个杯子的设计怎么样：&lt;/p&gt;
&lt;p&gt;张三说，这个杯子设计的很好看啊。&lt;/p&gt;
&lt;p&gt;李四说，这个杯子哪里好看了，这都什么设计啊。&lt;/p&gt;
&lt;p&gt;这些都是评价，好看与否都是主观的，这种带有主观性质语言，别人是很难感同身受的。除了增加不必要的沟通成本之外，还有可能演变成为争吵。&lt;/p&gt;
&lt;p&gt;如果张三说，杯子外部是光滑的，没有磨砂，用户使用很容易摔碎，这是在描述现象，那么李四就很容易理解张三的意思是“容易摔碎”，那就可以针对这一点展开深入讨论，确保双方都在讨论同一件事情。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-企业的目的">1. 企业的目的</h2>
<p>企业不同时期的目标是不一样的，第一阶段是保证存活；第二阶段是为了发展，加强公司业绩，达到预期的盈利；第三阶段是在发展壮大之后，有更多精力投入公司健康运转的事情，保证长久的生存下去；第四阶段是为了公司品牌，提升公司的品牌效应；第五阶段回馈社会，在社会上更多影响力。</p>
<p>其实，这和人的成长路径是一样的，把企业当做一个人来看待，未尝不可，道理都是互通的。</p>
<h2 id="2-企业靠什么盈利">2. 企业靠什么盈利</h2>
<p>自身的竞争力，别人没有的我有，别人有的我的更好。</p>
<h2 id="3-管理不仅仅是项目管理">3. 管理不仅仅是项目管理</h2>
<p>我之前理解的管理，是对于整个部门来说的，除了项目管理，还有工作之外的事情，比如团建、购买零食等等生活上的一些建设，让我觉得管理就是当爹又当妈，很操心的。我只是理解到这一层，但是听完张工的讲的管理体系化，管理不只是自己部门的事情，是整个公司涉及到的方方面面。如果把管理体系化的概念放到部门里去，把部门当成一个微小型的公司，相信你就会明白，管理应该要做什么，不会只是局部的工作，而是整体。</p>
<h2 id="4-完美的整体是由不完美的局部构成的">4. 完美的整体是由不完美的局部构成的</h2>
<p>我之前有听过“木桶理论”，和课上讲的“短板理论”一样，意思是要想让团队成长，只需要补上薄弱的环节即可。同时，还有另一种见解的“长板理论”，意思是要充分发挥团队成员的优势，安排其去做适合自己的工作，那么，得到的成果一定可以抹平甚至超过薄弱部分所带来的负作用。</p>
<p>结合这两种理论，我的理解是“木桶理论”当然有用，但它更多是关注到他人的缺点，很容易看不到他人的优势，至于“长板理论”，只会关注他人的优势，而忽略掉了缺点，所以，在实际中还是要结合着使用，在保证缺点处于一个可以接受的条件下，充分发挥长处会更好。比如之前不善言谈，说话都紧张到结巴，但是根据“木桶理论”，补强了沟通方面的问题，不说健谈，至少说话不紧张，有一个正常沟通的能力就好，在这个条件下，再充分发挥其优势在对的工作上。</p>
<h2 id="5-达成共识">5. 达成共识</h2>
<p>我认为达成共识的首要条件是，两个人讨论的确实是同一个东西，至少不是鸡同鸭讲，所说的都在同一个频道上，那怎么做到这点？那就需要多去描述客观事实，而不是表达感受，也就是课上讲到的现象和评价，非暴力沟通里也提到了这点，就是双方少用评价型的措词，比如说要开发一个杯子，讨论一个杯子的设计怎么样：</p>
<p>张三说，这个杯子设计的很好看啊。</p>
<p>李四说，这个杯子哪里好看了，这都什么设计啊。</p>
<p>这些都是评价，好看与否都是主观的，这种带有主观性质语言，别人是很难感同身受的。除了增加不必要的沟通成本之外，还有可能演变成为争吵。</p>
<p>如果张三说，杯子外部是光滑的，没有磨砂，用户使用很容易摔碎，这是在描述现象，那么李四就很容易理解张三的意思是“容易摔碎”，那就可以针对这一点展开深入讨论，确保双方都在讨论同一件事情。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第九周：员工激励理论</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B9%9D%E5%91%A8%E5%91%98%E5%B7%A5%E6%BF%80%E5%8A%B1%E7%90%86%E8%AE%BA/</link>
      <pubDate>Sat, 09 Jan 2021 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B9%9D%E5%91%A8%E5%91%98%E5%B7%A5%E6%BF%80%E5%8A%B1%E7%90%86%E8%AE%BA/</guid>
      <description>&lt;h2 id=&#34;1-关注自己到关注他人&#34;&gt;1. 关注自己到关注他人&lt;/h2&gt;
&lt;p&gt;你是激励者，也会是被激励者。&lt;/p&gt;
&lt;p&gt;虽然每个人的价值观不一样，但要做好激励员工这件事情，我觉得可以从自身角度出发，可以问问自己，你是如何被激励的？&lt;/p&gt;
&lt;p&gt;如果是我，就只想要钱？&lt;/p&gt;
&lt;p&gt;钱当然是很实际的可以激励自己的东西，但是，如果让你去做一些你极为厌恶的事情，我相信，抛开那种极端的假设，比如给你一个亿，你做不做？所以，我们只讨论现实的情况，钱不一定就是有用的，它只会起到很微弱的效果，起到决定性因素的，其实是自身的感受。&lt;/p&gt;
&lt;p&gt;除了钱，还有呢？&lt;/p&gt;
&lt;p&gt;那就是自己可以做好自己手头上的工作。&lt;/p&gt;
&lt;p&gt;怎么可以让我做好手头上的工作呢？&lt;/p&gt;
&lt;p&gt;那就需要好的环境和氛围，比如上级的理解，给予自己支持和肯定，比如与其他同事相处融洽。&lt;/p&gt;
&lt;p&gt;做好手头上的工作了，然后呢？&lt;/p&gt;
&lt;p&gt;可以按照自己的意愿做自己想做的事情。&lt;/p&gt;
&lt;p&gt;上级给了条件和营造良好的环境氛围，然后呢？&lt;/p&gt;
&lt;p&gt;那就是自己做的事情可以给公司带来收益，同时可以帮助到其他同事，实现自我价值。&lt;/p&gt;
&lt;p&gt;通过这一连串的反问，基本上可以体会到被激励者的心路历程，虽然不一定通用，但是人下意识，应该都是觉得自己的感受最重要。我觉得这样换角度去想这些事情，可以很好的为激励他人做准备。&lt;/p&gt;
&lt;h2 id=&#34;2-给予员工表达自己的机会&#34;&gt;2. 给予员工表达自己的机会&lt;/h2&gt;
&lt;p&gt;就拿项目负责人来举例，有时候同事并不是说不想做好自己负责的工作，而是在向项目负责人提建议的时候，项目负责人往往第一个反应就是，“领导说了必须这样做，只要照着做就好了，要不你找下领导吧，他说是这样做的。”&lt;/p&gt;
&lt;p&gt;这种回复并没有给同事一个合理的解释，项目负责人解决问题的方式只知道将问题抛给上级，用上级来施压，让下属屈服。这种处理方式可以说是非常糟糕的，项目负责人会这样，基本上是这以下这些原因，一是为了怕上级不满意；二是为了省事，本来已经安排好了，突然有这个想法，可能多出工作量，项目不能按时交付怎么办。&lt;/p&gt;
&lt;p&gt;在和其他人沟通交流的时候，我也一直在说，如果对这个需求有新的想法，哪怕这个需求是谁说必须要这么做的，只要给出的理由很充分，那也是可以商量的。这样做的目的在于，一来是给予员工表达自己想法的机会，二来是让员工感觉到自己在做自己的项目，而不是在帮别人做项目。&lt;/p&gt;
&lt;p&gt;作为被激励者也需要明白，有些东西不是非黑即白的，有些功能需求你是不认可的，但是考虑到整个团体的利益，或者说当前所处的一个情况，是需要根据实际情况，酌情处理的，这个时候，你就需要知道适当的妥协了。&lt;/p&gt;
&lt;p&gt;比如你想买一个西瓜，标价是 100 元/个，但你目前没有足够的钱，想要攒够钱再去买。然而，当你超级想吃这个西瓜时，难道你真的要等到攒满 100 元再去买吗？其实，你可以尝试和店家商量，看能否降低价格或者只买半个。通常，人们不会死板地等到攒够钱再购买，而是在不违背法律和道德的前提下，灵活地处理问题。因为人是灵活的，情况也是多变的。&lt;/p&gt;
&lt;p&gt;就我个人而言，一个很好的员工激励案例应当是“望梅止渴”，因为它以极小的成本产生了巨大的效果：&lt;/p&gt;
&lt;p&gt;“曹操行军途中，找不到水源，士兵们都非常口渴，于是他传令道，前边有一片梅子林，结了很多果子，梅子酸甜可以解渴。士兵听了后，嘴里的口水都流了出来，曹操利用这个办法促使部队尽快赶到了前方，找到了水源。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-关注自己到关注他人">1. 关注自己到关注他人</h2>
<p>你是激励者，也会是被激励者。</p>
<p>虽然每个人的价值观不一样，但要做好激励员工这件事情，我觉得可以从自身角度出发，可以问问自己，你是如何被激励的？</p>
<p>如果是我，就只想要钱？</p>
<p>钱当然是很实际的可以激励自己的东西，但是，如果让你去做一些你极为厌恶的事情，我相信，抛开那种极端的假设，比如给你一个亿，你做不做？所以，我们只讨论现实的情况，钱不一定就是有用的，它只会起到很微弱的效果，起到决定性因素的，其实是自身的感受。</p>
<p>除了钱，还有呢？</p>
<p>那就是自己可以做好自己手头上的工作。</p>
<p>怎么可以让我做好手头上的工作呢？</p>
<p>那就需要好的环境和氛围，比如上级的理解，给予自己支持和肯定，比如与其他同事相处融洽。</p>
<p>做好手头上的工作了，然后呢？</p>
<p>可以按照自己的意愿做自己想做的事情。</p>
<p>上级给了条件和营造良好的环境氛围，然后呢？</p>
<p>那就是自己做的事情可以给公司带来收益，同时可以帮助到其他同事，实现自我价值。</p>
<p>通过这一连串的反问，基本上可以体会到被激励者的心路历程，虽然不一定通用，但是人下意识，应该都是觉得自己的感受最重要。我觉得这样换角度去想这些事情，可以很好的为激励他人做准备。</p>
<h2 id="2-给予员工表达自己的机会">2. 给予员工表达自己的机会</h2>
<p>就拿项目负责人来举例，有时候同事并不是说不想做好自己负责的工作，而是在向项目负责人提建议的时候，项目负责人往往第一个反应就是，“领导说了必须这样做，只要照着做就好了，要不你找下领导吧，他说是这样做的。”</p>
<p>这种回复并没有给同事一个合理的解释，项目负责人解决问题的方式只知道将问题抛给上级，用上级来施压，让下属屈服。这种处理方式可以说是非常糟糕的，项目负责人会这样，基本上是这以下这些原因，一是为了怕上级不满意；二是为了省事，本来已经安排好了，突然有这个想法，可能多出工作量，项目不能按时交付怎么办。</p>
<p>在和其他人沟通交流的时候，我也一直在说，如果对这个需求有新的想法，哪怕这个需求是谁说必须要这么做的，只要给出的理由很充分，那也是可以商量的。这样做的目的在于，一来是给予员工表达自己想法的机会，二来是让员工感觉到自己在做自己的项目，而不是在帮别人做项目。</p>
<p>作为被激励者也需要明白，有些东西不是非黑即白的，有些功能需求你是不认可的，但是考虑到整个团体的利益，或者说当前所处的一个情况，是需要根据实际情况，酌情处理的，这个时候，你就需要知道适当的妥协了。</p>
<p>比如你想买一个西瓜，标价是 100 元/个，但你目前没有足够的钱，想要攒够钱再去买。然而，当你超级想吃这个西瓜时，难道你真的要等到攒满 100 元再去买吗？其实，你可以尝试和店家商量，看能否降低价格或者只买半个。通常，人们不会死板地等到攒够钱再购买，而是在不违背法律和道德的前提下，灵活地处理问题。因为人是灵活的，情况也是多变的。</p>
<p>就我个人而言，一个很好的员工激励案例应当是“望梅止渴”，因为它以极小的成本产生了巨大的效果：</p>
<p>“曹操行军途中，找不到水源，士兵们都非常口渴，于是他传令道，前边有一片梅子林，结了很多果子，梅子酸甜可以解渴。士兵听了后，嘴里的口水都流了出来，曹操利用这个办法促使部队尽快赶到了前方，找到了水源。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>第八周：非暴力沟通</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%85%AB%E5%91%A8%E9%9D%9E%E6%9A%B4%E5%8A%9B%E6%B2%9F%E9%80%9A/</link>
      <pubDate>Fri, 08 Jan 2021 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%85%AB%E5%91%A8%E9%9D%9E%E6%9A%B4%E5%8A%9B%E6%B2%9F%E9%80%9A/</guid>
      <description>&lt;h2 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h2&gt;
&lt;p&gt;《非暴力沟通》这本书我只看了一半，就看不下去了，但是听完这堂课，书中的内容突然清晰了好多，很有兴趣将这本书细细研读一遍。&lt;/p&gt;
&lt;blockquote&gt;
&lt;p&gt;注：当时确实这么想的，只是后来真香了哈哈。&lt;/p&gt;&lt;/blockquote&gt;
&lt;h2 id=&#34;2-观察与评论&#34;&gt;2. 观察与评论&lt;/h2&gt;
&lt;p&gt;“非暴力沟通并不要求我们保持完全的客观而不作评论。”这个观点引起了我对课堂上的案例，进行了深入思考：&lt;/p&gt;
&lt;p&gt;有个学校的老师和校长经常抱怨彼此之间很难进行良好的沟通。&lt;/p&gt;
&lt;p&gt;卢森堡博士组织了一个会议，并询问老师们：“校长的哪些行为不符合你们的要求？”&lt;/p&gt;
&lt;p&gt;教师A：“他是个大嘴巴！”&lt;/p&gt;
&lt;p&gt;卢森堡：“我的意思是想了解校长说了什么？做了什么？而‘大嘴巴’只是对校长的评价。”&lt;/p&gt;
&lt;p&gt;在这个例子中，教师A回答的“他是个大嘴巴！”这个答案，只是答非所问而已，因为“大嘴巴”并不是一个行为。如果卢森堡博士把问题变成“校长是个怎么样的人？”，那么教师A回答“他是个大嘴巴！”且不说这个是很主观、很有攻击性的答复，但确实是回答了“校长是个怎么样的人”这个问题。难道还要这样回答“校长经常在会议中，回顾他的童年和战时的经历，有时造成会议超时半小时以上。”这会不会显得很啰嗦？&lt;/p&gt;
&lt;p&gt;我有些疑惑，就是我们有没有可能变成了为了观察而观察？&lt;/p&gt;
&lt;p&gt;比如，我自己设想的这样的一个场景：&lt;/p&gt;
&lt;p&gt;小明：“我今天5点下班，先骑车到体育馆，然后打了半个小时篮球，感觉好累，全身出汗，买了一瓶农夫山泉，喝完之后&amp;hellip;&amp;hellip;”&lt;/p&gt;
&lt;p&gt;小强：“你吃晚饭了么？”&lt;/p&gt;
&lt;p&gt;小明：“&amp;hellip;&amp;hellip;喝完之后，又继续打了半个小时，然后才骑车回去，到家之后，洗了个澡，就7点半了，然后骑车出来找你&amp;hellip;&amp;hellip;”&lt;/p&gt;
&lt;p&gt;小强：“停停停，我只想知道你吃晚饭没有，说那么多废话干嘛？！”&lt;/p&gt;
&lt;p&gt;写完这个对话场景后，我联想到了自己在日常沟通中的表现。有时，我也不能很准确地回答提问者的问题，总是抓不住问题的核心，言简意赅地回答。我往往会在回答前铺垫太多，要到最后才抛出最核心的内容，这很容易让提问者感到困惑或烦躁，因为在他们看来，我可能说了太多的“废话”。&lt;/p&gt;
&lt;p&gt;就好像《三傻大闹宝莱坞》里的一样，教授问兰彻，“机械装置是什么？”兰彻回答，“能省力的东西就是机械装置。”然后教授不认可他的回答，只认可了查尔图的回答，“机械装置是实物构件的组合，各部分有确定的相对运动，借此，能量和动量相互转换，就像螺丝钉和螺帽，或者杠杆围绕支点转动，还有滑轮的枢纽之类的。尤其是构造，多少有点复杂。包括活动部件的组成，或者简单的机械零件，比如滚轮，杠杆，凸轮等等。”&lt;/p&gt;
&lt;p&gt;兰彻的回答显然是带有评论的观察，查尔图是不带评论的，但是现实生活中，我们是更倾向于兰彻的这种回答，就是用最简短的话语，表达出能让听者便于理解的信息。&lt;/p&gt;
&lt;p&gt;人不是机器，学习一个东西之后，要灵活运用，不应该一刀切，所以《非暴力沟通》也在强调，不要求我们保持完全的客观而不作评论，需要根据不同情境选择恰当的沟通方式。而这一点，我想才是最难修炼的部分。&lt;/p&gt;
&lt;h2 id=&#34;3-幸福是什么&#34;&gt;3. 幸福是什么&lt;/h2&gt;
&lt;p&gt;在探讨非暴力沟通中的“感受”部分时，我们被引导要放下“我执”，这意味着我们需要超越自我中心，学会换位思考，多从他人的视角看问题，并尽力感受对方当下的心情。这让我不禁联想到叔本华在《人生的智慧》中的观点：“理性的人追求的并非快乐，而是避免痛苦。”我对此的理解是，当我们足够智慧时，我们不再追求那些我们尚未拥有的东西，而是学会珍惜我们当前所拥有的。&lt;/p&gt;
&lt;p&gt;我认为，将叔本华在《人生的智慧》中关于“幸福”的这部分内容融入讲解会很有意义。两者的核心思想是一致的：人生所追求的快乐往往是短暂的，而痛苦则是常态，只是有时被快乐所掩盖。就就像你第一天吃这碗面很开心，第二天还是很开心的，第三天第四天呢，天天都吃呢，你可能就不开心了。而你在没吃这碗面之前，相对于“很开心”，其实可以说是不开心的，你只是从“不开心”变成了“不开心”，本质上只是从曲线底部又到了曲线底部而已，并没什么不同。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-前言">1. 前言</h2>
<p>《非暴力沟通》这本书我只看了一半，就看不下去了，但是听完这堂课，书中的内容突然清晰了好多，很有兴趣将这本书细细研读一遍。</p>
<blockquote>
<p>注：当时确实这么想的，只是后来真香了哈哈。</p></blockquote>
<h2 id="2-观察与评论">2. 观察与评论</h2>
<p>“非暴力沟通并不要求我们保持完全的客观而不作评论。”这个观点引起了我对课堂上的案例，进行了深入思考：</p>
<p>有个学校的老师和校长经常抱怨彼此之间很难进行良好的沟通。</p>
<p>卢森堡博士组织了一个会议，并询问老师们：“校长的哪些行为不符合你们的要求？”</p>
<p>教师A：“他是个大嘴巴！”</p>
<p>卢森堡：“我的意思是想了解校长说了什么？做了什么？而‘大嘴巴’只是对校长的评价。”</p>
<p>在这个例子中，教师A回答的“他是个大嘴巴！”这个答案，只是答非所问而已，因为“大嘴巴”并不是一个行为。如果卢森堡博士把问题变成“校长是个怎么样的人？”，那么教师A回答“他是个大嘴巴！”且不说这个是很主观、很有攻击性的答复，但确实是回答了“校长是个怎么样的人”这个问题。难道还要这样回答“校长经常在会议中，回顾他的童年和战时的经历，有时造成会议超时半小时以上。”这会不会显得很啰嗦？</p>
<p>我有些疑惑，就是我们有没有可能变成了为了观察而观察？</p>
<p>比如，我自己设想的这样的一个场景：</p>
<p>小明：“我今天5点下班，先骑车到体育馆，然后打了半个小时篮球，感觉好累，全身出汗，买了一瓶农夫山泉，喝完之后&hellip;&hellip;”</p>
<p>小强：“你吃晚饭了么？”</p>
<p>小明：“&hellip;&hellip;喝完之后，又继续打了半个小时，然后才骑车回去，到家之后，洗了个澡，就7点半了，然后骑车出来找你&hellip;&hellip;”</p>
<p>小强：“停停停，我只想知道你吃晚饭没有，说那么多废话干嘛？！”</p>
<p>写完这个对话场景后，我联想到了自己在日常沟通中的表现。有时，我也不能很准确地回答提问者的问题，总是抓不住问题的核心，言简意赅地回答。我往往会在回答前铺垫太多，要到最后才抛出最核心的内容，这很容易让提问者感到困惑或烦躁，因为在他们看来，我可能说了太多的“废话”。</p>
<p>就好像《三傻大闹宝莱坞》里的一样，教授问兰彻，“机械装置是什么？”兰彻回答，“能省力的东西就是机械装置。”然后教授不认可他的回答，只认可了查尔图的回答，“机械装置是实物构件的组合，各部分有确定的相对运动，借此，能量和动量相互转换，就像螺丝钉和螺帽，或者杠杆围绕支点转动，还有滑轮的枢纽之类的。尤其是构造，多少有点复杂。包括活动部件的组成，或者简单的机械零件，比如滚轮，杠杆，凸轮等等。”</p>
<p>兰彻的回答显然是带有评论的观察，查尔图是不带评论的，但是现实生活中，我们是更倾向于兰彻的这种回答，就是用最简短的话语，表达出能让听者便于理解的信息。</p>
<p>人不是机器，学习一个东西之后，要灵活运用，不应该一刀切，所以《非暴力沟通》也在强调，不要求我们保持完全的客观而不作评论，需要根据不同情境选择恰当的沟通方式。而这一点，我想才是最难修炼的部分。</p>
<h2 id="3-幸福是什么">3. 幸福是什么</h2>
<p>在探讨非暴力沟通中的“感受”部分时，我们被引导要放下“我执”，这意味着我们需要超越自我中心，学会换位思考，多从他人的视角看问题，并尽力感受对方当下的心情。这让我不禁联想到叔本华在《人生的智慧》中的观点：“理性的人追求的并非快乐，而是避免痛苦。”我对此的理解是，当我们足够智慧时，我们不再追求那些我们尚未拥有的东西，而是学会珍惜我们当前所拥有的。</p>
<p>我认为，将叔本华在《人生的智慧》中关于“幸福”的这部分内容融入讲解会很有意义。两者的核心思想是一致的：人生所追求的快乐往往是短暂的，而痛苦则是常态，只是有时被快乐所掩盖。就就像你第一天吃这碗面很开心，第二天还是很开心的，第三天第四天呢，天天都吃呢，你可能就不开心了。而你在没吃这碗面之前，相对于“很开心”，其实可以说是不开心的，你只是从“不开心”变成了“不开心”，本质上只是从曲线底部又到了曲线底部而已，并没什么不同。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第七周：与领导沟通的方法</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%83%E5%91%A8%E4%B8%8E%E9%A2%86%E5%AF%BC%E6%B2%9F%E9%80%9A%E7%9A%84%E6%96%B9%E6%B3%95/</link>
      <pubDate>Mon, 04 Jan 2021 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%83%E5%91%A8%E4%B8%8E%E9%A2%86%E5%AF%BC%E6%B2%9F%E9%80%9A%E7%9A%84%E6%96%B9%E6%B3%95/</guid>
      <description>&lt;h2 id=&#34;1-聊天与沟通有何区别&#34;&gt;1. 聊天与沟通有何区别&lt;/h2&gt;
&lt;p&gt;首先，聊天和沟通有何区别，影响沟通水平最重要的是什么？&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;聊天&lt;/strong&gt;侧重于人，通常是因为双方关系还不错，愿意花时间和精力去交流，这种交流是主动积极的，所谈论的事情并不一定有关联，可以前面在说跑步，后面就在谈论正在看的小说，谈论的内容并不重要，只是喜欢一起聊天而已。&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;沟通&lt;/strong&gt;侧重于事，是为了解决事情而发生的，对方是谁并不重要，退一万步来说，哪怕你很讨厌他，但是为了解决当前的这个事情，你不得不去找对方讨论这件事情，然后找到解决问题的方案。&lt;/p&gt;
&lt;p&gt;影响沟通水平最重要的因素，我认为可以分为以下两个部分：&lt;/p&gt;
&lt;h3 id=&#34;11-察言观色的能力&#34;&gt;1.1 察言观色的能力&lt;/h3&gt;
&lt;p&gt;生活中有很好的例子来体现沟通方式的差异，那就是微信聊天、打电话聊天和面对面聊天。在微信里聊天，如果没有表情或者一些语气助词，同样的文字可能就表达出不一样的意思，很容易造成误会；打电话聊天，可以听到对方的语气，但是看不到对方的面部表情，也很容易造成误会；面对面聊天，可以看到对方的面部表情，感受到对方的语气，误会的概率会降低很多。&lt;/p&gt;
&lt;h3 id=&#34;12-用很少的话语能表达足够准确的信息&#34;&gt;1.2 用很少的话语能表达足够准确的信息&lt;/h3&gt;
&lt;p&gt;对于这个问题，表达足够准确的信息，不如说是如何让对方在短时间内就理解你要表达的意思。这个“准确”的确应该以听者为标准，而不是仅基于表述者。除了文字表达和口头表达，画图表达确实也是很好的方式。不过，我认为最好的方式之一，应该是举例子。&lt;/p&gt;
&lt;p&gt;在生活中，每个人都遇到过和知道的一些小事，可以作为解释和说明的绝佳素材。例如，“学习要打好基础”，当有人质疑这一观点时，解释其重要性可能会显得苍白无力。但如果我们通过举例来说明，效果会大不相同。&lt;/p&gt;
&lt;p&gt;你可以这样说：“想象一下，万丈高楼平地起。我们都知道为什么一栋楼的地基要打得那么厚实，因为如果地基不牢固，那么上面的楼层就会有坍塌的风险。同样地，一棵树，如果树枝被折断了，它不至于死亡，但是如果树根生病了，那就没得救了。学习也是如此，基础不扎实，后面的学习就会像建在沙堆上的高楼，随时可能崩塌。”&lt;/p&gt;
&lt;p&gt;这样的举例更容易让听者理解“学习要打好基础”的意思，并产生认同感。&lt;/p&gt;
&lt;h2 id=&#34;2-沟通前我们要想清楚&#34;&gt;2. 沟通前我们要想清楚&lt;/h2&gt;
&lt;h3 id=&#34;21-为什么我们沟通的目的是什么&#34;&gt;2.1 为什么，我们沟通的目的是什么&lt;/h3&gt;
&lt;p&gt;想清楚这一点很重要，因为很多沟通最后会演变成争吵，大家忘记了最初要沟通解决的问题，而是过分关注问题之外的一些事情，比如对方的语气或言下之意等。在沟通过程中，应该时刻强调我们沟通的目的是什么，目的就是解决这个问题，其他的不应该浪费这个时间。&lt;/p&gt;
&lt;h3 id=&#34;22-要什么对方的需求和利益是什么&#34;&gt;2.2 要什么，对方的需求和利益是什么&lt;/h3&gt;
&lt;p&gt;在沟通一件事情，比如一个项目任务时，要明白对方提出要求的原因是什么，对方为什么不同意你的方案。此时，可以适当换位思考，想象自己站在对方的角度会作何反应，是不是也会不同意。换位思考是有用的，但应该是自发地去做，而不是要求对方。避免使用诸如“你到底有没有想过我这边的情况？”的表述，而应该说：“我知道如果我是你，我也会考虑这样的方案，因为这样实现可以减少很多工作量，但基于用户体验，这个方案对我这边显然是不合理的，因为&amp;hellip;&amp;hellip;”&lt;/p&gt;
&lt;p&gt;在沟通中，始终考虑双赢，可以减少争执。理解对方不同意的原因，是否有苦衷，换做是自己是否也会这样选择。如果双方都能有这样的理解，那么沟通不会是问题。&lt;/p&gt;
&lt;h3 id=&#34;23-干什么我希望对方如何反应或行动&#34;&gt;2.3 干什么，我希望对方如何反应或行动&lt;/h3&gt;
&lt;p&gt;这个“干什么”的前提是解决了前面“要什么”的问题。如果前面的问题已经解决，那么这个问题通常不是大问题。&lt;/p&gt;
&lt;h3 id=&#34;24-说什么我要传达的信息是什么&#34;&gt;2.4 说什么，我要传达的信息是什么&lt;/h3&gt;
&lt;p&gt;到这个阶段，双方应该已经达成一致。至于可能的问题，更多的是如何让对方明白你要传达的信息。如果表达不清楚，可能会导致成果与预期不符，这会增加时间成本，造成不必要的损失。&lt;/p&gt;
&lt;h2 id=&#34;3-与领导沟通的方式&#34;&gt;3. 与领导沟通的方式&lt;/h2&gt;
&lt;p&gt;在与领导沟通时，基本的尊重是不可或缺的，同时要保持自信，不怯场，至少要保证说话要利索。有些人在与领导沟通时可能会感到抵触或害怕，但克服这种心理非常关键。&lt;/p&gt;
&lt;p&gt;当要向领导反馈问题时，一个好的思路历程可以是这样的：首先发现问题，然后分析这个问题出现的原因，接着思考如何解决，并探讨是否还有其他解决方案，比较各方案之间的利弊，解释为什么最终选择了这个方案，再回顾为什么会出现这个问题，并讨论如何避免未来再次发生。下属的职责是列出这些选项，而领导则更多是在做选择题。&lt;/p&gt;
&lt;p&gt;沟通的主要目的是解决问题，因此应坦诚交流，有问题及时反馈。不要害怕让领导觉得自己能力不足，因为及时反馈和解决问题可以避免问题扩大化，减少潜在的严重后果。要知道，越早反馈，问题就越容易解决。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-聊天与沟通有何区别">1. 聊天与沟通有何区别</h2>
<p>首先，聊天和沟通有何区别，影响沟通水平最重要的是什么？</p>
<p><strong>聊天</strong>侧重于人，通常是因为双方关系还不错，愿意花时间和精力去交流，这种交流是主动积极的，所谈论的事情并不一定有关联，可以前面在说跑步，后面就在谈论正在看的小说，谈论的内容并不重要，只是喜欢一起聊天而已。</p>
<p><strong>沟通</strong>侧重于事，是为了解决事情而发生的，对方是谁并不重要，退一万步来说，哪怕你很讨厌他，但是为了解决当前的这个事情，你不得不去找对方讨论这件事情，然后找到解决问题的方案。</p>
<p>影响沟通水平最重要的因素，我认为可以分为以下两个部分：</p>
<h3 id="11-察言观色的能力">1.1 察言观色的能力</h3>
<p>生活中有很好的例子来体现沟通方式的差异，那就是微信聊天、打电话聊天和面对面聊天。在微信里聊天，如果没有表情或者一些语气助词，同样的文字可能就表达出不一样的意思，很容易造成误会；打电话聊天，可以听到对方的语气，但是看不到对方的面部表情，也很容易造成误会；面对面聊天，可以看到对方的面部表情，感受到对方的语气，误会的概率会降低很多。</p>
<h3 id="12-用很少的话语能表达足够准确的信息">1.2 用很少的话语能表达足够准确的信息</h3>
<p>对于这个问题，表达足够准确的信息，不如说是如何让对方在短时间内就理解你要表达的意思。这个“准确”的确应该以听者为标准，而不是仅基于表述者。除了文字表达和口头表达，画图表达确实也是很好的方式。不过，我认为最好的方式之一，应该是举例子。</p>
<p>在生活中，每个人都遇到过和知道的一些小事，可以作为解释和说明的绝佳素材。例如，“学习要打好基础”，当有人质疑这一观点时，解释其重要性可能会显得苍白无力。但如果我们通过举例来说明，效果会大不相同。</p>
<p>你可以这样说：“想象一下，万丈高楼平地起。我们都知道为什么一栋楼的地基要打得那么厚实，因为如果地基不牢固，那么上面的楼层就会有坍塌的风险。同样地，一棵树，如果树枝被折断了，它不至于死亡，但是如果树根生病了，那就没得救了。学习也是如此，基础不扎实，后面的学习就会像建在沙堆上的高楼，随时可能崩塌。”</p>
<p>这样的举例更容易让听者理解“学习要打好基础”的意思，并产生认同感。</p>
<h2 id="2-沟通前我们要想清楚">2. 沟通前我们要想清楚</h2>
<h3 id="21-为什么我们沟通的目的是什么">2.1 为什么，我们沟通的目的是什么</h3>
<p>想清楚这一点很重要，因为很多沟通最后会演变成争吵，大家忘记了最初要沟通解决的问题，而是过分关注问题之外的一些事情，比如对方的语气或言下之意等。在沟通过程中，应该时刻强调我们沟通的目的是什么，目的就是解决这个问题，其他的不应该浪费这个时间。</p>
<h3 id="22-要什么对方的需求和利益是什么">2.2 要什么，对方的需求和利益是什么</h3>
<p>在沟通一件事情，比如一个项目任务时，要明白对方提出要求的原因是什么，对方为什么不同意你的方案。此时，可以适当换位思考，想象自己站在对方的角度会作何反应，是不是也会不同意。换位思考是有用的，但应该是自发地去做，而不是要求对方。避免使用诸如“你到底有没有想过我这边的情况？”的表述，而应该说：“我知道如果我是你，我也会考虑这样的方案，因为这样实现可以减少很多工作量，但基于用户体验，这个方案对我这边显然是不合理的，因为&hellip;&hellip;”</p>
<p>在沟通中，始终考虑双赢，可以减少争执。理解对方不同意的原因，是否有苦衷，换做是自己是否也会这样选择。如果双方都能有这样的理解，那么沟通不会是问题。</p>
<h3 id="23-干什么我希望对方如何反应或行动">2.3 干什么，我希望对方如何反应或行动</h3>
<p>这个“干什么”的前提是解决了前面“要什么”的问题。如果前面的问题已经解决，那么这个问题通常不是大问题。</p>
<h3 id="24-说什么我要传达的信息是什么">2.4 说什么，我要传达的信息是什么</h3>
<p>到这个阶段，双方应该已经达成一致。至于可能的问题，更多的是如何让对方明白你要传达的信息。如果表达不清楚，可能会导致成果与预期不符，这会增加时间成本，造成不必要的损失。</p>
<h2 id="3-与领导沟通的方式">3. 与领导沟通的方式</h2>
<p>在与领导沟通时，基本的尊重是不可或缺的，同时要保持自信，不怯场，至少要保证说话要利索。有些人在与领导沟通时可能会感到抵触或害怕，但克服这种心理非常关键。</p>
<p>当要向领导反馈问题时，一个好的思路历程可以是这样的：首先发现问题，然后分析这个问题出现的原因，接着思考如何解决，并探讨是否还有其他解决方案，比较各方案之间的利弊，解释为什么最终选择了这个方案，再回顾为什么会出现这个问题，并讨论如何避免未来再次发生。下属的职责是列出这些选项，而领导则更多是在做选择题。</p>
<p>沟通的主要目的是解决问题，因此应坦诚交流，有问题及时反馈。不要害怕让领导觉得自己能力不足，因为及时反馈和解决问题可以避免问题扩大化，减少潜在的严重后果。要知道，越早反馈，问题就越容易解决。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第六周：你推崇的领导方式是怎么样的</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%85%AD%E5%91%A8%E4%BD%A0%E6%8E%A8%E5%B4%87%E7%9A%84%E9%A2%86%E5%AF%BC%E6%96%B9%E5%BC%8F%E6%98%AF%E6%80%8E%E4%B9%88%E6%A0%B7%E7%9A%84/</link>
      <pubDate>Tue, 01 Dec 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%85%AD%E5%91%A8%E4%BD%A0%E6%8E%A8%E5%B4%87%E7%9A%84%E9%A2%86%E5%AF%BC%E6%96%B9%E5%BC%8F%E6%98%AF%E6%80%8E%E4%B9%88%E6%A0%B7%E7%9A%84/</guid>
      <description>&lt;h2 id=&#34;1-你所推崇的领导方式&#34;&gt;1. 你所推崇的领导方式&lt;/h2&gt;
&lt;p&gt;“君子有诸己而后求诸人，无诸己而后非诸人。”&lt;/p&gt;
&lt;p&gt;我所推崇的领导方式，应该是以身作则，不会要求别人做我自己做不到的事情，当然，也不会强求他人做我自己可以做到的事情。&lt;/p&gt;
&lt;p&gt;我也同意没有最好的领导方式，只有最适合的，方式要因人而异，在刘建国的《技术管理实战36讲》中提到的领导方式有以下四种。&lt;/p&gt;
&lt;h3 id=&#34;11-指令式&#34;&gt;1.1 指令式&lt;/h3&gt;
&lt;p&gt;重事不重人，关注目标和结果，喜欢发号施令但不亲力亲为；比如安排下属去开发一个功能，直接说明是用什么技术，如何实现，下属只需要去完成。&lt;/p&gt;
&lt;h3 id=&#34;12-支持式&#34;&gt;1.2 支持式&lt;/h3&gt;
&lt;p&gt;重人不重事，希望带头冲锋亲力亲为，特别在意团队成员的感受，并替他们分担工作；比如安排下属去开发一个功能，遇到了技术难点，会直接去帮助他们解决这个技术难点。&lt;/p&gt;
&lt;h3 id=&#34;13-教练式&#34;&gt;1.3 教练式&lt;/h3&gt;
&lt;p&gt;重人也重事，关注全局和方向，并在做事上给予教练式的辅导和启发；比如安排下属去开发一个功能，会引导下属，看下用这个技术可不可以，或者会问对方，你自己觉得怎么去实现这个功能更好？下属可以选择实现这个功能的方式，对这个开发任务有更多的掌控力。&lt;/p&gt;
&lt;h3 id=&#34;14-授权式&#34;&gt;1.4 授权式&lt;/h3&gt;
&lt;p&gt;不重人也不重事，关注目标和结果，不关心过程和人员发展。比如安排下属去开发一个功能，到了指定的时间，去询问下属功能开发完成与否。&lt;/p&gt;
&lt;h2 id=&#34;2-情境领导&#34;&gt;2. 情境领导&lt;/h2&gt;
&lt;h3 id=&#34;21-情景一&#34;&gt;2.1 情景一&lt;/h3&gt;
&lt;p&gt;“不是你对下属做什么，而是你们一起做什么。”&lt;/p&gt;
&lt;p&gt;对于这句话的理解是，要有一个整体的思维，领导和下属不是割裂的，要时刻让下属知道，你是时刻在关注他在做的事情，有问题可以实时反馈上来，大家一起解决，他不是孤军奋战。所以我往往安排好工作任务之后，都会和对方强调一下，有什么问题及时反馈给我就好了，不要憋着什么都不说，没关系的，有问题大家一起讨论，集思广益，就可以很快解决遇到的问题。&lt;/p&gt;
&lt;h3 id=&#34;22-情景二&#34;&gt;2.2 情景二&lt;/h3&gt;
&lt;p&gt;“作为领导最重要的不是你在场发生了什么，而是你不在场时发生了什么。”&lt;/p&gt;
&lt;p&gt;我的理解是，一个团队的负责人，在团队初期，在各方面都还不够形成体系的时候，会是一只领头羊的角色，如果按领导方式划分，早期应该是指令式和支持式的，后期应该是教练式和授权式。越往后更多是处于后勤的角色，都是在做“为了保证团队正常运转”的工作，而不是在前面带头冲锋。领导不在的时候，团队也能够正常运转，马车之前需要挥鞭子的人，现在马车都可以自己跑了。&lt;/p&gt;
&lt;p&gt;有些时候，作为团队负责人，会担心下属做不好这件事，然后大包大揽，这个做法其实是错误的，一来，人的精力是有限的，长此以往，总会有忙不过来的时候，真到那这个时候，项目开发进度受影响怎么办？临时安排其他人参与，进度也不见得能赶上，因为他还要了解需要开发的需求，这个是需要时间的。二来，如果都是大包大揽，下属得不到锻炼的机会，容易导致他没有动力，消磨了他的斗志。&lt;/p&gt;
&lt;h2 id=&#34;3-四个阶段&#34;&gt;3. 四个阶段&lt;/h2&gt;
&lt;h3 id=&#34;31-热情的初学者&#34;&gt;3.1 热情的初学者&lt;/h3&gt;
&lt;p&gt;对这个世界充满希望，很有干劲，所以我们需要做的是手把手去指导，比如把一些框架的学习计划制定好，让其在指定时间内，完成一个项目的学习Demo。&lt;/p&gt;
&lt;h3 id=&#34;32-憧憬幻灭的学习者&#34;&gt;3.2 憧憬幻灭的学习者&lt;/h3&gt;
&lt;p&gt;这个阶段的人，一种可能是觉得世界太大了，需要学习的东西太多了，自己那么渺小，还学什么？有点像苏格拉底说的那句话，“我知道自己一无所知。”这个时候更多的是需要让其从这个想法中抽离出来，比如可以这么说，需要学习的东西确实很多，但是不可能有人什么都知道，最好还是结合自身的优势，选择对自己来说更有潜力的方向。只要照这个方向努力，路线就会很清晰；另一种可能是觉得世界太大了，需要学习的东西太多了，那真是太好了，我要学习学习再学习，对于这种人，更多是鼓励为主，当然最好也是结合他自身的优势，给出努力的方向。&lt;/p&gt;
&lt;h3 id=&#34;33-能干谨慎的执行者&#34;&gt;3.3 能干谨慎的执行者&lt;/h3&gt;
&lt;p&gt;这个阶段的人，有能力并且遇到过很多坑，是经历过风雨的类型，所以做事情会很小心，会考虑各方面的因素，这是好事，但是如果是一些很有创造力空间的工作，可能会出现，为了防止问题出现，过于谨慎，不敢冒险的问题。所以，凡事都不是绝对的，只能根据实际的情况出发，给对方做这些事情的权利，减少顾虑，让其好好发挥自身优势。&lt;/p&gt;
&lt;h3 id=&#34;34-独立自主的完成者&#34;&gt;3.4 独立自主的完成者&lt;/h3&gt;
&lt;p&gt;这个更多是相信的力量，信任对于一个想把事情做好的人来说，是最大的鼓励。&lt;/p&gt;
&lt;p&gt;如果下属犯了一些错误，我觉得可以多给些机会，因为一个想把事情做好的人，一定是付出很多努力的，不会是敷衍了事，所以如果犯错了，那一定会很自责，最难受的不是别人，一定会是他自己。这个时候，如果上级没有责怪，而是给予更多的鼓励，我相信会得到一个超出预期的结果。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-你所推崇的领导方式">1. 你所推崇的领导方式</h2>
<p>“君子有诸己而后求诸人，无诸己而后非诸人。”</p>
<p>我所推崇的领导方式，应该是以身作则，不会要求别人做我自己做不到的事情，当然，也不会强求他人做我自己可以做到的事情。</p>
<p>我也同意没有最好的领导方式，只有最适合的，方式要因人而异，在刘建国的《技术管理实战36讲》中提到的领导方式有以下四种。</p>
<h3 id="11-指令式">1.1 指令式</h3>
<p>重事不重人，关注目标和结果，喜欢发号施令但不亲力亲为；比如安排下属去开发一个功能，直接说明是用什么技术，如何实现，下属只需要去完成。</p>
<h3 id="12-支持式">1.2 支持式</h3>
<p>重人不重事，希望带头冲锋亲力亲为，特别在意团队成员的感受，并替他们分担工作；比如安排下属去开发一个功能，遇到了技术难点，会直接去帮助他们解决这个技术难点。</p>
<h3 id="13-教练式">1.3 教练式</h3>
<p>重人也重事，关注全局和方向，并在做事上给予教练式的辅导和启发；比如安排下属去开发一个功能，会引导下属，看下用这个技术可不可以，或者会问对方，你自己觉得怎么去实现这个功能更好？下属可以选择实现这个功能的方式，对这个开发任务有更多的掌控力。</p>
<h3 id="14-授权式">1.4 授权式</h3>
<p>不重人也不重事，关注目标和结果，不关心过程和人员发展。比如安排下属去开发一个功能，到了指定的时间，去询问下属功能开发完成与否。</p>
<h2 id="2-情境领导">2. 情境领导</h2>
<h3 id="21-情景一">2.1 情景一</h3>
<p>“不是你对下属做什么，而是你们一起做什么。”</p>
<p>对于这句话的理解是，要有一个整体的思维，领导和下属不是割裂的，要时刻让下属知道，你是时刻在关注他在做的事情，有问题可以实时反馈上来，大家一起解决，他不是孤军奋战。所以我往往安排好工作任务之后，都会和对方强调一下，有什么问题及时反馈给我就好了，不要憋着什么都不说，没关系的，有问题大家一起讨论，集思广益，就可以很快解决遇到的问题。</p>
<h3 id="22-情景二">2.2 情景二</h3>
<p>“作为领导最重要的不是你在场发生了什么，而是你不在场时发生了什么。”</p>
<p>我的理解是，一个团队的负责人，在团队初期，在各方面都还不够形成体系的时候，会是一只领头羊的角色，如果按领导方式划分，早期应该是指令式和支持式的，后期应该是教练式和授权式。越往后更多是处于后勤的角色，都是在做“为了保证团队正常运转”的工作，而不是在前面带头冲锋。领导不在的时候，团队也能够正常运转，马车之前需要挥鞭子的人，现在马车都可以自己跑了。</p>
<p>有些时候，作为团队负责人，会担心下属做不好这件事，然后大包大揽，这个做法其实是错误的，一来，人的精力是有限的，长此以往，总会有忙不过来的时候，真到那这个时候，项目开发进度受影响怎么办？临时安排其他人参与，进度也不见得能赶上，因为他还要了解需要开发的需求，这个是需要时间的。二来，如果都是大包大揽，下属得不到锻炼的机会，容易导致他没有动力，消磨了他的斗志。</p>
<h2 id="3-四个阶段">3. 四个阶段</h2>
<h3 id="31-热情的初学者">3.1 热情的初学者</h3>
<p>对这个世界充满希望，很有干劲，所以我们需要做的是手把手去指导，比如把一些框架的学习计划制定好，让其在指定时间内，完成一个项目的学习Demo。</p>
<h3 id="32-憧憬幻灭的学习者">3.2 憧憬幻灭的学习者</h3>
<p>这个阶段的人，一种可能是觉得世界太大了，需要学习的东西太多了，自己那么渺小，还学什么？有点像苏格拉底说的那句话，“我知道自己一无所知。”这个时候更多的是需要让其从这个想法中抽离出来，比如可以这么说，需要学习的东西确实很多，但是不可能有人什么都知道，最好还是结合自身的优势，选择对自己来说更有潜力的方向。只要照这个方向努力，路线就会很清晰；另一种可能是觉得世界太大了，需要学习的东西太多了，那真是太好了，我要学习学习再学习，对于这种人，更多是鼓励为主，当然最好也是结合他自身的优势，给出努力的方向。</p>
<h3 id="33-能干谨慎的执行者">3.3 能干谨慎的执行者</h3>
<p>这个阶段的人，有能力并且遇到过很多坑，是经历过风雨的类型，所以做事情会很小心，会考虑各方面的因素，这是好事，但是如果是一些很有创造力空间的工作，可能会出现，为了防止问题出现，过于谨慎，不敢冒险的问题。所以，凡事都不是绝对的，只能根据实际的情况出发，给对方做这些事情的权利，减少顾虑，让其好好发挥自身优势。</p>
<h3 id="34-独立自主的完成者">3.4 独立自主的完成者</h3>
<p>这个更多是相信的力量，信任对于一个想把事情做好的人来说，是最大的鼓励。</p>
<p>如果下属犯了一些错误，我觉得可以多给些机会，因为一个想把事情做好的人，一定是付出很多努力的，不会是敷衍了事，所以如果犯错了，那一定会很自责，最难受的不是别人，一定会是他自己。这个时候，如果上级没有责怪，而是给予更多的鼓励，我相信会得到一个超出预期的结果。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第五周：坦诚是领导力的根基</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%BA%94%E5%91%A8%E5%9D%A6%E8%AF%9A%E6%98%AF%E9%A2%86%E5%AF%BC%E5%8A%9B%E7%9A%84%E6%A0%B9%E5%9F%BA/</link>
      <pubDate>Wed, 25 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%BA%94%E5%91%A8%E5%9D%A6%E8%AF%9A%E6%98%AF%E9%A2%86%E5%AF%BC%E5%8A%9B%E7%9A%84%E6%A0%B9%E5%9F%BA/</guid>
      <description>&lt;h2 id=&#34;1-懂得很多道理依然过不好这一生&#34;&gt;1. 懂得很多道理，依然过不好这一生&lt;/h2&gt;
&lt;p&gt;“纸上得来终觉浅，绝知此事要躬行。”&lt;/p&gt;
&lt;p&gt;我们往往就是这样，开导别人的时候，口若悬河，心灵鸡汤信手拈来，自以为洞穿了他人困境的本质，并且找到了解决办法，但是理论并不等于实践，再加上人与人是不一样的，就像《了不起的盖茨比》里面说的那一句话：&lt;/p&gt;
&lt;p&gt;“当你想要开口批评别人的时候，”父亲对我说，“你要想到，这个世界上不是所有人都像你一样，拥有那么多优越的条件。”&lt;/p&gt;
&lt;p&gt;每个人身处的环境不一样的，父母性格不一样，家庭氛围也不一样，道理和言行，知道不代表就可以做好。&lt;/p&gt;
&lt;h2 id=&#34;2-为什么大多中彩票的人不能守住巨额的财产&#34;&gt;2. 为什么大多中彩票的人不能守住巨额的财产？&lt;/h2&gt;
&lt;p&gt;我们在课堂上，已经说过了，就是因为没有驾驭财富的能力。&lt;/p&gt;
&lt;p&gt;就像《了凡四训》里说的那样，“世间享千金之产者，定是千金人物；享百金之产者，定是百金人物；应饿死者，定是饿死人物。天不过因材而笃，几曾加纤毫意思。”&lt;/p&gt;
&lt;p&gt;虽然这句话有点因果宿命论，但重点是那句“天不过因材而笃”，上天只是根据那是一个怎么样的人而定他的命数罢了。放在管理上面来说，可以引申出的东西，就是知人善用了，没有清晰认识到下属各方面的能力，就没办法合理的去安排对应的工作，人有千面，各有所长，管理所做的就是，让其在合适的工作上发挥自身的长处。&lt;/p&gt;
&lt;h2 id=&#34;3-什么是坦诚&#34;&gt;3. 什么是坦诚？&lt;/h2&gt;
&lt;p&gt;坦诚，就是不带敌意地、真诚地表达意见。&lt;/p&gt;
&lt;p&gt;我能想到关于坦诚的东西，应该是勇于承认自己的错误，这会比过多的狡辩有用的多。&lt;/p&gt;
&lt;p&gt;《人性的弱点》里有一个例子，卡耐基早上出门遛狗，因为没有给爱犬带上口笼，被巡逻的警察呵责了一顿，没想到第二天遛狗的时候还是忘记了，心想这下完蛋了，不等警察开口，卡耐基就直接说，我愿意接受你的处罚，因为你上次说过，在公园里，狗嘴上没带上口笼那是触犯法律的。但是，有意思的事情发生了，警察没有呵责，反而一直在替卡耐基辩解，早上没有人的时候，带自己爱犬来公园里走走也是很不错的，而且这只狗还那么小，不至于伤人云云。&lt;/p&gt;
&lt;p&gt;很多年前，在家乡市里骑电动车，有过没有注意到红绿灯被罚款的经历，当时很尴尬，自己是真的没看到红绿灯，位置实在是太偏了，然后被抓了，心里当然很委屈，如果自己心存侥幸故意为之，那么认栽，毕竟这种行为是不对的。但自己没有这样的心思，阴差阳错发生了这种事情，难免会很郁闷。但我自己是这样想的，事情已经发生了，虽然是无心的，但确实是做错了，那就认了。然后我也没有为自己辩解什么，交警怎么说的，我点头就是了，说没注意到，下次多注意下，然后就是签字，罚款二十块钱。我看到桌上有好多人的检讨书，我就说，检讨书要怎么写的，然后交警就是，不用写了，下次注意点，看好红绿灯，我就说声“谢谢”就走了。&lt;/p&gt;
&lt;p&gt;我们可以试想，如果被抓了的第一反应就是，为自己辩解，我哪里闯红灯了，也不看看灯的位置，这谁看得到？然后，假如交警让写检讨书，都罚钱了，下次注意点就好了，还写什么检讨书？这不浪费时间么？总之，会把事情弄得一团槽。&lt;/p&gt;
&lt;h2 id=&#34;4-为什么人们不愿意坦诚相见&#34;&gt;4. 为什么人们不愿意坦诚相见？&lt;/h2&gt;
&lt;p&gt;从环境方面来说，大多数人，特别是小时候在农村生活的，都会知道，在当时哪家有台电视机，那了不得了，熙熙攘攘的，平时都一大群人，小孩子也多，没有网络，没有电脑，也没有手机，平时都是到处串门。&lt;/p&gt;
&lt;p&gt;现在生活水平普遍提高了，有网络了，有电脑了，有手机了，楼房也起来了，而且更多的是，来到城市生活，高楼大夏，漂漂亮亮的，不管买房还是租房，你的对门住的是一个陌生人，你也是别人的陌生人，现在的环境让你感觉不到在家乡的那种自在，冥冥之中，强化了这个“防人之心不可无”的感受。&lt;/p&gt;
&lt;p&gt;从个人方面来说，我所认为的是，就好像枪战，没有人喜欢把自己暴露在空旷的平地上，当成活靶子一样，任人拿捏。所以，这一切纯粹出于自我保护的动物本能。&lt;/p&gt;
&lt;h2 id=&#34;5-怎么获得信任&#34;&gt;5. 怎么获得信任？&lt;/h2&gt;
&lt;p&gt;要获得信任，那就是坦诚相见了，先去相信别人，发自内心的，叔本华在《人生的智慧》里说道：&lt;/p&gt;
&lt;p&gt;“要是我们对一个人有所怀疑，那么和他交谈的时候就应该假装对他的话深信不疑；因为这样他就会变得胆大妄为，有恃无恐地说谎，最后自己揭穿了自己。但是，如果我们发现这个人的言语透露出了一部分他隐藏起来的真实情况，那我们就应该假装不相信他的话。这样一来，他由于受到了抵抗的刺激，就会调出更多的真实情况来应战。”&lt;/p&gt;
&lt;p&gt;说的是如何拆穿一个人的谎言的做法，但是人与人之间的相处，如果都是这种弯弯绕绕的东西，那就太过于悲哀了，太浪费生命了，人生不应该是这样的。&lt;/p&gt;
&lt;p&gt;说回到管理，怎么获得信任，一是增强自身能力，可以让上级对自己有信心；二是相信的力量，相信下属能完成这个工作，给足信心。&lt;/p&gt;
&lt;h2 id=&#34;6-言出必行&#34;&gt;6. 言出必行&lt;/h2&gt;
&lt;p&gt;言必行，行必果，“曾子杀猪”的故事就不复述了，在工作中的话，应该是项目进度制定这方面，有较为突出的应用，既然制定了完成日期，那么就要做到在这个时间点交付，我想，“言出必行”的想法在这上面还是很有帮助的，因为目标很明确，就是这个时间点，完成这个任务。&lt;/p&gt;
&lt;h2 id=&#34;7-坦诚的应用&#34;&gt;7. 坦诚的应用&lt;/h2&gt;
&lt;p&gt;其实上面的内容和例子，很多都是关于坦诚的，坦诚那么重要，我们还能怎么做呢？&lt;/p&gt;
&lt;p&gt;我想到的还是《人性的弱点》里的一个例子：&lt;/p&gt;
&lt;p&gt;“有一次，我妻子问总统，美洲鹑鸟是什么样子？因为她从没有见过鹑鸟，而罗斯福总统不厌其详地告诉了她。过些时候，我家里的电话铃声响了—一爱默士和他妻子住在罗斯福总统牡蛎湾住宅内的一所小房子里——我妻子接了电话，原来是总统亲自打来的。罗斯福总统在电话里告诉她，现在窗外正有一只鹑鸟，如果她向窗外看去，就可以看到了。”&lt;/p&gt;
&lt;p&gt;坦诚的前提是如何能很好的与别人进行交流，至少你们之间的对话是平和的，而不是针锋相对的，除了把人当人看，还有就是不要吝啬对他人的称赞，要对他人发自内心的重视。&lt;/p&gt;
&lt;p&gt;不管承认与否，一个人往往会下意识地最重视的永远都会是自己，自己的模样，自己的名字，每个人在看合影的时候，第一时间都在找自己，每个人在看名单的时候，第一时间也都在找自己的名字，所以，对他人的重视，本身就是对他人的一种肯定。&lt;/p&gt;
&lt;p&gt;称赞确实是很好的拉近人与人之间关系的良药，一直都记得很多年前在建设银行办业务，银行大叔夸我写字好看，虽然我知道他是个很好的人，懂得怎么做可以让别人开心，我也知道这是一种真诚的“套路”，但是那么多年过去了，有时还会莫名其妙的想起这个事情，甚至是什么地点，大概什么时间段，以及什么桌子上填表，大叔穿着以及大概样貌，虽然过去有10年了，我还是记得，所以说我也很无奈，掉进这个“陷阱”。&lt;/p&gt;
&lt;p&gt;我就在想，一个人的内心，或多或少都是喜欢被人认可和称赞的，当然是那种发自内心的称赞，是不是阿谀奉承，其实是可以感觉得到的，因为人还是有些自知之明的，对比之下，就知道对方所说是敷衍，还是发自内心了。&lt;/p&gt;
&lt;p&gt;讨好不是一个好词，在生活中基于开玩笑性质，偶尔为之没什么问题，但是在职场中，切记不要讨好你的领导或者老板，他们只会特别警惕，你有什么目的？你是否不怀好意？反而得不偿失。我有一个同事，平时沟通的时候，经常说一些显得我更加高瞻远瞩的话，其实我心里很不舒服，我知道自己几斤几两的，其实他没有必要这样，本来能力就已经很出众了，人际关系搞得也很不错，把手头上的工作做好，其他盘外招并不需要的，如果需要，那说明所遇并未良人，不值得跟随。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-懂得很多道理依然过不好这一生">1. 懂得很多道理，依然过不好这一生</h2>
<p>“纸上得来终觉浅，绝知此事要躬行。”</p>
<p>我们往往就是这样，开导别人的时候，口若悬河，心灵鸡汤信手拈来，自以为洞穿了他人困境的本质，并且找到了解决办法，但是理论并不等于实践，再加上人与人是不一样的，就像《了不起的盖茨比》里面说的那一句话：</p>
<p>“当你想要开口批评别人的时候，”父亲对我说，“你要想到，这个世界上不是所有人都像你一样，拥有那么多优越的条件。”</p>
<p>每个人身处的环境不一样的，父母性格不一样，家庭氛围也不一样，道理和言行，知道不代表就可以做好。</p>
<h2 id="2-为什么大多中彩票的人不能守住巨额的财产">2. 为什么大多中彩票的人不能守住巨额的财产？</h2>
<p>我们在课堂上，已经说过了，就是因为没有驾驭财富的能力。</p>
<p>就像《了凡四训》里说的那样，“世间享千金之产者，定是千金人物；享百金之产者，定是百金人物；应饿死者，定是饿死人物。天不过因材而笃，几曾加纤毫意思。”</p>
<p>虽然这句话有点因果宿命论，但重点是那句“天不过因材而笃”，上天只是根据那是一个怎么样的人而定他的命数罢了。放在管理上面来说，可以引申出的东西，就是知人善用了，没有清晰认识到下属各方面的能力，就没办法合理的去安排对应的工作，人有千面，各有所长，管理所做的就是，让其在合适的工作上发挥自身的长处。</p>
<h2 id="3-什么是坦诚">3. 什么是坦诚？</h2>
<p>坦诚，就是不带敌意地、真诚地表达意见。</p>
<p>我能想到关于坦诚的东西，应该是勇于承认自己的错误，这会比过多的狡辩有用的多。</p>
<p>《人性的弱点》里有一个例子，卡耐基早上出门遛狗，因为没有给爱犬带上口笼，被巡逻的警察呵责了一顿，没想到第二天遛狗的时候还是忘记了，心想这下完蛋了，不等警察开口，卡耐基就直接说，我愿意接受你的处罚，因为你上次说过，在公园里，狗嘴上没带上口笼那是触犯法律的。但是，有意思的事情发生了，警察没有呵责，反而一直在替卡耐基辩解，早上没有人的时候，带自己爱犬来公园里走走也是很不错的，而且这只狗还那么小，不至于伤人云云。</p>
<p>很多年前，在家乡市里骑电动车，有过没有注意到红绿灯被罚款的经历，当时很尴尬，自己是真的没看到红绿灯，位置实在是太偏了，然后被抓了，心里当然很委屈，如果自己心存侥幸故意为之，那么认栽，毕竟这种行为是不对的。但自己没有这样的心思，阴差阳错发生了这种事情，难免会很郁闷。但我自己是这样想的，事情已经发生了，虽然是无心的，但确实是做错了，那就认了。然后我也没有为自己辩解什么，交警怎么说的，我点头就是了，说没注意到，下次多注意下，然后就是签字，罚款二十块钱。我看到桌上有好多人的检讨书，我就说，检讨书要怎么写的，然后交警就是，不用写了，下次注意点，看好红绿灯，我就说声“谢谢”就走了。</p>
<p>我们可以试想，如果被抓了的第一反应就是，为自己辩解，我哪里闯红灯了，也不看看灯的位置，这谁看得到？然后，假如交警让写检讨书，都罚钱了，下次注意点就好了，还写什么检讨书？这不浪费时间么？总之，会把事情弄得一团槽。</p>
<h2 id="4-为什么人们不愿意坦诚相见">4. 为什么人们不愿意坦诚相见？</h2>
<p>从环境方面来说，大多数人，特别是小时候在农村生活的，都会知道，在当时哪家有台电视机，那了不得了，熙熙攘攘的，平时都一大群人，小孩子也多，没有网络，没有电脑，也没有手机，平时都是到处串门。</p>
<p>现在生活水平普遍提高了，有网络了，有电脑了，有手机了，楼房也起来了，而且更多的是，来到城市生活，高楼大夏，漂漂亮亮的，不管买房还是租房，你的对门住的是一个陌生人，你也是别人的陌生人，现在的环境让你感觉不到在家乡的那种自在，冥冥之中，强化了这个“防人之心不可无”的感受。</p>
<p>从个人方面来说，我所认为的是，就好像枪战，没有人喜欢把自己暴露在空旷的平地上，当成活靶子一样，任人拿捏。所以，这一切纯粹出于自我保护的动物本能。</p>
<h2 id="5-怎么获得信任">5. 怎么获得信任？</h2>
<p>要获得信任，那就是坦诚相见了，先去相信别人，发自内心的，叔本华在《人生的智慧》里说道：</p>
<p>“要是我们对一个人有所怀疑，那么和他交谈的时候就应该假装对他的话深信不疑；因为这样他就会变得胆大妄为，有恃无恐地说谎，最后自己揭穿了自己。但是，如果我们发现这个人的言语透露出了一部分他隐藏起来的真实情况，那我们就应该假装不相信他的话。这样一来，他由于受到了抵抗的刺激，就会调出更多的真实情况来应战。”</p>
<p>说的是如何拆穿一个人的谎言的做法，但是人与人之间的相处，如果都是这种弯弯绕绕的东西，那就太过于悲哀了，太浪费生命了，人生不应该是这样的。</p>
<p>说回到管理，怎么获得信任，一是增强自身能力，可以让上级对自己有信心；二是相信的力量，相信下属能完成这个工作，给足信心。</p>
<h2 id="6-言出必行">6. 言出必行</h2>
<p>言必行，行必果，“曾子杀猪”的故事就不复述了，在工作中的话，应该是项目进度制定这方面，有较为突出的应用，既然制定了完成日期，那么就要做到在这个时间点交付，我想，“言出必行”的想法在这上面还是很有帮助的，因为目标很明确，就是这个时间点，完成这个任务。</p>
<h2 id="7-坦诚的应用">7. 坦诚的应用</h2>
<p>其实上面的内容和例子，很多都是关于坦诚的，坦诚那么重要，我们还能怎么做呢？</p>
<p>我想到的还是《人性的弱点》里的一个例子：</p>
<p>“有一次，我妻子问总统，美洲鹑鸟是什么样子？因为她从没有见过鹑鸟，而罗斯福总统不厌其详地告诉了她。过些时候，我家里的电话铃声响了—一爱默士和他妻子住在罗斯福总统牡蛎湾住宅内的一所小房子里——我妻子接了电话，原来是总统亲自打来的。罗斯福总统在电话里告诉她，现在窗外正有一只鹑鸟，如果她向窗外看去，就可以看到了。”</p>
<p>坦诚的前提是如何能很好的与别人进行交流，至少你们之间的对话是平和的，而不是针锋相对的，除了把人当人看，还有就是不要吝啬对他人的称赞，要对他人发自内心的重视。</p>
<p>不管承认与否，一个人往往会下意识地最重视的永远都会是自己，自己的模样，自己的名字，每个人在看合影的时候，第一时间都在找自己，每个人在看名单的时候，第一时间也都在找自己的名字，所以，对他人的重视，本身就是对他人的一种肯定。</p>
<p>称赞确实是很好的拉近人与人之间关系的良药，一直都记得很多年前在建设银行办业务，银行大叔夸我写字好看，虽然我知道他是个很好的人，懂得怎么做可以让别人开心，我也知道这是一种真诚的“套路”，但是那么多年过去了，有时还会莫名其妙的想起这个事情，甚至是什么地点，大概什么时间段，以及什么桌子上填表，大叔穿着以及大概样貌，虽然过去有10年了，我还是记得，所以说我也很无奈，掉进这个“陷阱”。</p>
<p>我就在想，一个人的内心，或多或少都是喜欢被人认可和称赞的，当然是那种发自内心的称赞，是不是阿谀奉承，其实是可以感觉得到的，因为人还是有些自知之明的，对比之下，就知道对方所说是敷衍，还是发自内心了。</p>
<p>讨好不是一个好词，在生活中基于开玩笑性质，偶尔为之没什么问题，但是在职场中，切记不要讨好你的领导或者老板，他们只会特别警惕，你有什么目的？你是否不怀好意？反而得不偿失。我有一个同事，平时沟通的时候，经常说一些显得我更加高瞻远瞩的话，其实我心里很不舒服，我知道自己几斤几两的，其实他没有必要这样，本来能力就已经很出众了，人际关系搞得也很不错，把手头上的工作做好，其他盘外招并不需要的，如果需要，那说明所遇并未良人，不值得跟随。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第三周：从错误中认识到管理</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%89%E5%91%A8%E4%BB%8E%E9%94%99%E8%AF%AF%E4%B8%AD%E8%AE%A4%E8%AF%86%E5%88%B0%E7%AE%A1%E7%90%86/</link>
      <pubDate>Wed, 18 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%89%E5%91%A8%E4%BB%8E%E9%94%99%E8%AF%AF%E4%B8%AD%E8%AE%A4%E8%AF%86%E5%88%B0%E7%AE%A1%E7%90%86/</guid>
      <description>&lt;h2 id=&#34;1-约定两周时间完成这个功能&#34;&gt;1. 约定两周时间，完成这个功能&lt;/h2&gt;
&lt;p&gt;在管理者分配好项目任务后，只是口头约定两周的时间，没有形成需求文档。对于需求，人与人的理解是不一样的，有些太过于抽象的东西，太难以描绘，只能一而再再而三的确认，同时跟进下属开发的情况，第一时间看其是否偏离自己所理解的需求，以免成品与自己的期望相差过大。这上面是从管理者的角度来说的，当然下属也要做到向上沟通，主动提出问题，反馈情况，遇到什么问题，自己无法解决的，及时找上级寻求帮助，共同完成这件事情。&lt;/p&gt;
&lt;h2 id=&#34;2-当众批评&#34;&gt;2. 当众批评&lt;/h2&gt;
&lt;p&gt;当众批评很容易造成更多不必要的伤害，批评并不能解决问题，只会恶化当前情况，最好私底下找对方聊聊具体的问题。通常用到当众批评这个方式，都是因为对方屡教不改，才不得已为之，能不用最好不用。人非圣贤孰能无过，人都会有做错事的时候，可以给对方一些机会，但要看对方是否认识到自己的错误，并且努力去改正。我认为怎么样做好一件事情才是最重要的，达到预期才是最重要的，问题不在批评这个行为，是在于批评往往是在恶化这个情况，把事情搞砸，如果批评能做好事情，那未尝不可，但很难很难。如何调整想要批评下属的心态，那就要提升一下认知，清楚地认识到你是一个团体的负责人，任何错误你都要背锅，这样或许就会想到，虽然是对方的错误，但自己有些地方可能也没做好。这样一想心态就会平和一些了。&lt;/p&gt;
&lt;h2 id=&#34;3-关于公平&#34;&gt;3. 关于公平&lt;/h2&gt;
&lt;p&gt;世上没有公平的事情，人与人之间相处的方式，对待的态度肯定是会有差异的，这些感性的因素或多或少会影响着自己，管理者对于下属的公平，就像课上讨论的，不是管理者自己觉得公平，是要让下属觉得公平，是的，工作上做到以工作结果来权衡，至于交流态度，都差不多吧，坦诚相待，大家平和一些，懂得换位思考，互相帮助，都很好的。&lt;/p&gt;
&lt;h2 id=&#34;4-向上沟通&#34;&gt;4. 向上沟通&lt;/h2&gt;
&lt;p&gt;工作中遇到一些问题，如果自己没有办法解决，当然要需求帮助了，单打独斗自然可以锻炼自己的能力，但是有些事情，就是需要你现在立马去解决，而你诸事缠身，无能为力，这个时候硬撑着是没有意义的，就好像解决代码 BUG 一样，一开始你可以给自己定个时间，比如半个小时，半个小时过后，如果你一直没能解决，这个时候继续熬着，不寻求帮助，很大概率最后两三个小时，甚至更久时间都解决不了，因为人的思维是有局限性的，你脑袋里想尽了所有办法，都没能解决，难道就凭空可以冒出一些不在你思维范围的想法么，所以这个时候，就需要交流沟通，这个很重要，虽然你问了别人，他不一定也知道，但是他说了想法之后，可能会给你新的启发，这就是交流的目的，寻找更多的可能性。所以出现问题，及时反馈到上级很有必要，因为上级他身处的位置，掌握的信息更为全面，可以提出更多可能的解决方案。&lt;/p&gt;
&lt;h2 id=&#34;5-总结&#34;&gt;5. 总结&lt;/h2&gt;
&lt;p&gt;总的来说，在错误中认识管理，也就是从错误中吸取经验，避免重蹈覆辙。这节课，张工是以自己经历的真实场景来讲解的，有好几个在管理上面来说失败的例子，我们在课上，看着屏幕，揪着很多错误发表很多觉得正确的处理方案，我也说了一些觉得可以改进，这样做应该更好的处理方式。后来，我一直在想这个事情，如果放到自己身上，我就一定可以做好不会出错么，很多理论的东西都是死的，就像数学公式一样，但人是活的，是一直变化着捉摸不透的，人都喜欢好为人师，喜欢出谋划策，喜欢批评教育别人，这件事应该怎么做，但在当时的场景下，自己一定可以做好这些事情吗？&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-约定两周时间完成这个功能">1. 约定两周时间，完成这个功能</h2>
<p>在管理者分配好项目任务后，只是口头约定两周的时间，没有形成需求文档。对于需求，人与人的理解是不一样的，有些太过于抽象的东西，太难以描绘，只能一而再再而三的确认，同时跟进下属开发的情况，第一时间看其是否偏离自己所理解的需求，以免成品与自己的期望相差过大。这上面是从管理者的角度来说的，当然下属也要做到向上沟通，主动提出问题，反馈情况，遇到什么问题，自己无法解决的，及时找上级寻求帮助，共同完成这件事情。</p>
<h2 id="2-当众批评">2. 当众批评</h2>
<p>当众批评很容易造成更多不必要的伤害，批评并不能解决问题，只会恶化当前情况，最好私底下找对方聊聊具体的问题。通常用到当众批评这个方式，都是因为对方屡教不改，才不得已为之，能不用最好不用。人非圣贤孰能无过，人都会有做错事的时候，可以给对方一些机会，但要看对方是否认识到自己的错误，并且努力去改正。我认为怎么样做好一件事情才是最重要的，达到预期才是最重要的，问题不在批评这个行为，是在于批评往往是在恶化这个情况，把事情搞砸，如果批评能做好事情，那未尝不可，但很难很难。如何调整想要批评下属的心态，那就要提升一下认知，清楚地认识到你是一个团体的负责人，任何错误你都要背锅，这样或许就会想到，虽然是对方的错误，但自己有些地方可能也没做好。这样一想心态就会平和一些了。</p>
<h2 id="3-关于公平">3. 关于公平</h2>
<p>世上没有公平的事情，人与人之间相处的方式，对待的态度肯定是会有差异的，这些感性的因素或多或少会影响着自己，管理者对于下属的公平，就像课上讨论的，不是管理者自己觉得公平，是要让下属觉得公平，是的，工作上做到以工作结果来权衡，至于交流态度，都差不多吧，坦诚相待，大家平和一些，懂得换位思考，互相帮助，都很好的。</p>
<h2 id="4-向上沟通">4. 向上沟通</h2>
<p>工作中遇到一些问题，如果自己没有办法解决，当然要需求帮助了，单打独斗自然可以锻炼自己的能力，但是有些事情，就是需要你现在立马去解决，而你诸事缠身，无能为力，这个时候硬撑着是没有意义的，就好像解决代码 BUG 一样，一开始你可以给自己定个时间，比如半个小时，半个小时过后，如果你一直没能解决，这个时候继续熬着，不寻求帮助，很大概率最后两三个小时，甚至更久时间都解决不了，因为人的思维是有局限性的，你脑袋里想尽了所有办法，都没能解决，难道就凭空可以冒出一些不在你思维范围的想法么，所以这个时候，就需要交流沟通，这个很重要，虽然你问了别人，他不一定也知道，但是他说了想法之后，可能会给你新的启发，这就是交流的目的，寻找更多的可能性。所以出现问题，及时反馈到上级很有必要，因为上级他身处的位置，掌握的信息更为全面，可以提出更多可能的解决方案。</p>
<h2 id="5-总结">5. 总结</h2>
<p>总的来说，在错误中认识管理，也就是从错误中吸取经验，避免重蹈覆辙。这节课，张工是以自己经历的真实场景来讲解的，有好几个在管理上面来说失败的例子，我们在课上，看着屏幕，揪着很多错误发表很多觉得正确的处理方案，我也说了一些觉得可以改进，这样做应该更好的处理方式。后来，我一直在想这个事情，如果放到自己身上，我就一定可以做好不会出错么，很多理论的东西都是死的，就像数学公式一样，但人是活的，是一直变化着捉摸不透的，人都喜欢好为人师，喜欢出谋划策，喜欢批评教育别人，这件事应该怎么做，但在当时的场景下，自己一定可以做好这些事情吗？</p>
]]></content:encoded>
    </item>
    <item>
      <title>第四周：心态和角色</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%9B%9B%E5%91%A8%E5%BF%83%E6%80%81%E5%92%8C%E8%A7%92%E8%89%B2/</link>
      <pubDate>Wed, 18 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E5%9B%9B%E5%91%A8%E5%BF%83%E6%80%81%E5%92%8C%E8%A7%92%E8%89%B2/</guid>
      <description>&lt;h2 id=&#34;1-关注自己到关注他人&#34;&gt;1. 关注自己到关注他人&lt;/h2&gt;
&lt;p&gt;关注自己到关注他人，就是利己到利他，基本上就是从全局的角度去看待事情，而不单单是自己一亩三分地里耕耘，团队出的任何事情，首要责任就在管理者身上，不再是单打独斗了，你个人表现再好没有用的，就好像打篮球比赛，你个人得到 60 分，但是如果比赛输了，哪怕你是张伯伦再世，得到 100 分也没有用，整个的团队的成绩才是你的成绩。&lt;/p&gt;
&lt;h2 id=&#34;2-把人当人看&#34;&gt;2. 把人当人看&lt;/h2&gt;
&lt;p&gt;说到慈悲，我想到了弘一法师，也就是李叔同，在电影《一轮明月》中，有这样的一个场景，在西湖上，两舟相向，此时，李叔同已选择在杭州虎跑寺出家，他的日本妻子匆匆赶来，只为得到他的回答，爱是什么，他回答道，爱，就是慈悲。他的妻子所问的是男女之爱，李叔同回答的是众生之爱，由小爱转为大爱。&lt;/p&gt;
&lt;p&gt;丰子恺提到人生的三重境界，就是在说自己的恩师李叔同，分别是物质生活，就是人最基本的生存，成家立业，追求物质；精神生活，就是醉心于艺术创作之中；灵魂生活，就是宗教。其实这个和课堂上讨论的东西很像，也是心态和角色的变化，那为什么会有这些变化呢？更多的是内驱力，就是自身的一种追求，但是管理有点不一样，大部分人其实都是外部给的压力，就是告诉你，你要做管理了，并不是你告诉你自己，你要做管理了。所以自己对自己身份的认知和肯定是很重要的，没有这个肯定，后面的管理工作基本没办法展开，这是先决条件。&lt;/p&gt;
&lt;p&gt;说到李叔同，我觉得从他的一生来看，可挖掘的点其实还是很多的，很多道理都适用于管理，比如丰子恺的《怀念李叔同先生》里说的那些事迹，如果从管理的方向去解读，会很有意思：&lt;/p&gt;
&lt;p&gt;“有一个人上音乐课时不唱歌而看别的书，有一个人上音乐课时吐痰在地板上，以为李先生看不见的，其实他都知道。但他不立刻责备，等到下课后，他用很轻而严肃的声音郑重地说：“某某等一等出去。”于是这位某某同学只得站着。等到别的同学都出去了，他又用轻而严肃的声音向这某某同学和气地说：“下次上课时不要看别的书。”或者：“下次痰不要吐在地板上。”说过之后他微微一鞠躬，表示你出去罢。出来的人大都脸上发红。”&lt;/p&gt;
&lt;p&gt;这个给出了如何指出下属的错误的方法。&lt;/p&gt;
&lt;p&gt;“有一次他到我家。我请他藤椅子里坐。他把藤椅子轻轻摇动，然后慢慢地坐下去。起先我不敢问。后来看他每次都如此，我就启问。法师回答我说：“这椅子里头，两根藤之间，也许有小虫伏着。突然坐下去，要把它们压死，所以先摇动一下，慢慢地坐下去，好让它们走避。”&lt;/p&gt;
&lt;p&gt;这个指明了把下属当人看，你要管理的不是机器，是活生生的人，为人处世，更多的是要有慈悲之心。&lt;/p&gt;
&lt;h2 id=&#34;3-主动沟通&#34;&gt;3. 主动沟通&lt;/h2&gt;
&lt;p&gt;在努力减少信息不对称的过程中，我意识到有时会出现这样的情况：当我们将自己手头上的工作安排给他人时，对方可能会感到困惑甚至不满。换位思考，他们可能会想：“我原本的工作安排得很好，为什么现在要接手你的事情呢？如果我做完了自己的任务，就可以稍微轻松一下了，而现在却突然要接手你的工作，那你是不是就轻松了，而我就变得更忙了？”&lt;/p&gt;
&lt;p&gt;这种想法是非常普遍的，因为每个人都希望自己的工作越轻松越好。因此，在安排工作给他人时，我们需要坦诚地与他们沟通，进行充分的信息交流。我们可以向对方解释清楚当前的情况，例如：“我现在身上有很多事情需要处理，比如这个项目和那个计划，实在是忙不过来，无法在短期内完成这些任务。” 同时，也要说明这些工作的重要性以及为何需要他们的协助：“这些工作原本是我负责的，因为我对它们非常了解，但现在由于时间紧迫，我希望能够得到你的帮助。”&lt;/p&gt;
&lt;p&gt;通过积极的沟通，我们可以让对方了解我们的处境和所面临的压力，从而增加他们的理解和配合。所以，管理者在给下属安排工作的时候，不应该只是像下达命令一样，告诉对方要做什么就可以了，应该要把这个事情的前因后果一道告知对方，为什么要做这个事情？为什么要你做这个事情？为什么要现在做这个事情？&lt;/p&gt;
&lt;h2 id=&#34;4-经营者的心态&#34;&gt;4. 经营者的心态&lt;/h2&gt;
&lt;p&gt;正如课堂上讨论的，如果自己经营着一家杂货店，那么应该怎么做呢？如果自己只是这家杂货店的收银员，估计每天也就是对对账而已，但是，如果自己是杂货店的老板，那么要考虑的东西就很多了：&lt;/p&gt;
&lt;p&gt;​    杂货店开在哪里？&lt;/p&gt;
&lt;p&gt;​    杂货店从哪里进货？&lt;/p&gt;
&lt;p&gt;​    杂货店重点卖什么？&lt;/p&gt;
&lt;p&gt;​    杂货店需要赚多少才能盈利？&lt;/p&gt;
&lt;p&gt;​    &amp;hellip;&amp;hellip;&lt;/p&gt;
&lt;p&gt;身处不同位置，需要考虑的事情不一样，面临的问题也就不一样。回到管理本身，如果自己只是开发人员，那么只需要做好手头上的工作即可，但要管理一个团队，就需要考虑整个团队的运转，分工是否明确，计划是否合理等等。这些要能做好，就需要清晰地认识到角色不同，需要承担的责任也会不同。&lt;/p&gt;
&lt;p&gt;回到丰子恺《怀念李叔同先生》这篇文章，里面还提到了李叔同从小到大，各种角色的转变：&lt;/p&gt;
&lt;p&gt;“他出身于富裕之家，他的父亲是天津有名的银行家，在上海南洋公学读书奉母时，他是一个翩翩公子。”&lt;/p&gt;
&lt;p&gt;“后来他到日本，看见明治维新的文化，就渴慕西洋文明。他立刻放弃了翩翩公子的态度，改做一个留学生。”&lt;/p&gt;
&lt;p&gt;“他在日本演当时西洋著名的悲剧《茶花女》时，高帽子、燕尾服、尖头皮鞋，竟活像一个西洋人。”&lt;/p&gt;
&lt;p&gt;“他回国后不久，就被南京高等师范请去教图画、音乐。后来又应杭州师范之聘，同时兼任两个学校的课，这时候，李先生已由留学生变为教师。漂亮的洋装不穿了，却换上灰色粗布袍子、黑布马褂、布底鞋子。”&lt;/p&gt;
&lt;p&gt;“出家后，再去望他时，他已光着头皮，穿着僧衣，俨然一位清癯的法师了。”&lt;/p&gt;
&lt;p&gt;“弘一法师每做一种人，都做得十分像样。好比全能的优伶：起青衣像个青衣，起老生像个老生，起大面又像个大面&amp;hellip;&amp;hellip;都是认真的缘故。”&lt;/p&gt;
&lt;p&gt;从上面的例子，可以知道做事认真的重要性，其实恰好说明了，要成为那一种人，先假装自己就是那种人。在我看来，李叔同之所以身份能够转变得如此成功，除了认真之外，也从着装上潜移默化地强化了这种认知：&lt;/p&gt;
&lt;p&gt;“我现在是这种人了，就应该要做这种人应该做的事情。”&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-关注自己到关注他人">1. 关注自己到关注他人</h2>
<p>关注自己到关注他人，就是利己到利他，基本上就是从全局的角度去看待事情，而不单单是自己一亩三分地里耕耘，团队出的任何事情，首要责任就在管理者身上，不再是单打独斗了，你个人表现再好没有用的，就好像打篮球比赛，你个人得到 60 分，但是如果比赛输了，哪怕你是张伯伦再世，得到 100 分也没有用，整个的团队的成绩才是你的成绩。</p>
<h2 id="2-把人当人看">2. 把人当人看</h2>
<p>说到慈悲，我想到了弘一法师，也就是李叔同，在电影《一轮明月》中，有这样的一个场景，在西湖上，两舟相向，此时，李叔同已选择在杭州虎跑寺出家，他的日本妻子匆匆赶来，只为得到他的回答，爱是什么，他回答道，爱，就是慈悲。他的妻子所问的是男女之爱，李叔同回答的是众生之爱，由小爱转为大爱。</p>
<p>丰子恺提到人生的三重境界，就是在说自己的恩师李叔同，分别是物质生活，就是人最基本的生存，成家立业，追求物质；精神生活，就是醉心于艺术创作之中；灵魂生活，就是宗教。其实这个和课堂上讨论的东西很像，也是心态和角色的变化，那为什么会有这些变化呢？更多的是内驱力，就是自身的一种追求，但是管理有点不一样，大部分人其实都是外部给的压力，就是告诉你，你要做管理了，并不是你告诉你自己，你要做管理了。所以自己对自己身份的认知和肯定是很重要的，没有这个肯定，后面的管理工作基本没办法展开，这是先决条件。</p>
<p>说到李叔同，我觉得从他的一生来看，可挖掘的点其实还是很多的，很多道理都适用于管理，比如丰子恺的《怀念李叔同先生》里说的那些事迹，如果从管理的方向去解读，会很有意思：</p>
<p>“有一个人上音乐课时不唱歌而看别的书，有一个人上音乐课时吐痰在地板上，以为李先生看不见的，其实他都知道。但他不立刻责备，等到下课后，他用很轻而严肃的声音郑重地说：“某某等一等出去。”于是这位某某同学只得站着。等到别的同学都出去了，他又用轻而严肃的声音向这某某同学和气地说：“下次上课时不要看别的书。”或者：“下次痰不要吐在地板上。”说过之后他微微一鞠躬，表示你出去罢。出来的人大都脸上发红。”</p>
<p>这个给出了如何指出下属的错误的方法。</p>
<p>“有一次他到我家。我请他藤椅子里坐。他把藤椅子轻轻摇动，然后慢慢地坐下去。起先我不敢问。后来看他每次都如此，我就启问。法师回答我说：“这椅子里头，两根藤之间，也许有小虫伏着。突然坐下去，要把它们压死，所以先摇动一下，慢慢地坐下去，好让它们走避。”</p>
<p>这个指明了把下属当人看，你要管理的不是机器，是活生生的人，为人处世，更多的是要有慈悲之心。</p>
<h2 id="3-主动沟通">3. 主动沟通</h2>
<p>在努力减少信息不对称的过程中，我意识到有时会出现这样的情况：当我们将自己手头上的工作安排给他人时，对方可能会感到困惑甚至不满。换位思考，他们可能会想：“我原本的工作安排得很好，为什么现在要接手你的事情呢？如果我做完了自己的任务，就可以稍微轻松一下了，而现在却突然要接手你的工作，那你是不是就轻松了，而我就变得更忙了？”</p>
<p>这种想法是非常普遍的，因为每个人都希望自己的工作越轻松越好。因此，在安排工作给他人时，我们需要坦诚地与他们沟通，进行充分的信息交流。我们可以向对方解释清楚当前的情况，例如：“我现在身上有很多事情需要处理，比如这个项目和那个计划，实在是忙不过来，无法在短期内完成这些任务。” 同时，也要说明这些工作的重要性以及为何需要他们的协助：“这些工作原本是我负责的，因为我对它们非常了解，但现在由于时间紧迫，我希望能够得到你的帮助。”</p>
<p>通过积极的沟通，我们可以让对方了解我们的处境和所面临的压力，从而增加他们的理解和配合。所以，管理者在给下属安排工作的时候，不应该只是像下达命令一样，告诉对方要做什么就可以了，应该要把这个事情的前因后果一道告知对方，为什么要做这个事情？为什么要你做这个事情？为什么要现在做这个事情？</p>
<h2 id="4-经营者的心态">4. 经营者的心态</h2>
<p>正如课堂上讨论的，如果自己经营着一家杂货店，那么应该怎么做呢？如果自己只是这家杂货店的收银员，估计每天也就是对对账而已，但是，如果自己是杂货店的老板，那么要考虑的东西就很多了：</p>
<p>​    杂货店开在哪里？</p>
<p>​    杂货店从哪里进货？</p>
<p>​    杂货店重点卖什么？</p>
<p>​    杂货店需要赚多少才能盈利？</p>
<p>​    &hellip;&hellip;</p>
<p>身处不同位置，需要考虑的事情不一样，面临的问题也就不一样。回到管理本身，如果自己只是开发人员，那么只需要做好手头上的工作即可，但要管理一个团队，就需要考虑整个团队的运转，分工是否明确，计划是否合理等等。这些要能做好，就需要清晰地认识到角色不同，需要承担的责任也会不同。</p>
<p>回到丰子恺《怀念李叔同先生》这篇文章，里面还提到了李叔同从小到大，各种角色的转变：</p>
<p>“他出身于富裕之家，他的父亲是天津有名的银行家，在上海南洋公学读书奉母时，他是一个翩翩公子。”</p>
<p>“后来他到日本，看见明治维新的文化，就渴慕西洋文明。他立刻放弃了翩翩公子的态度，改做一个留学生。”</p>
<p>“他在日本演当时西洋著名的悲剧《茶花女》时，高帽子、燕尾服、尖头皮鞋，竟活像一个西洋人。”</p>
<p>“他回国后不久，就被南京高等师范请去教图画、音乐。后来又应杭州师范之聘，同时兼任两个学校的课，这时候，李先生已由留学生变为教师。漂亮的洋装不穿了，却换上灰色粗布袍子、黑布马褂、布底鞋子。”</p>
<p>“出家后，再去望他时，他已光着头皮，穿着僧衣，俨然一位清癯的法师了。”</p>
<p>“弘一法师每做一种人，都做得十分像样。好比全能的优伶：起青衣像个青衣，起老生像个老生，起大面又像个大面&hellip;&hellip;都是认真的缘故。”</p>
<p>从上面的例子，可以知道做事认真的重要性，其实恰好说明了，要成为那一种人，先假装自己就是那种人。在我看来，李叔同之所以身份能够转变得如此成功，除了认真之外，也从着装上潜移默化地强化了这种认知：</p>
<p>“我现在是这种人了，就应该要做这种人应该做的事情。”</p>
]]></content:encoded>
    </item>
    <item>
      <title>第二周：一将功成万骨枯</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%BA%8C%E5%91%A8%E4%B8%80%E5%B0%86%E5%8A%9F%E6%88%90%E4%B8%87%E9%AA%A8%E6%9E%AF/</link>
      <pubDate>Mon, 16 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%BA%8C%E5%91%A8%E4%B8%80%E5%B0%86%E5%8A%9F%E6%88%90%E4%B8%87%E9%AA%A8%E6%9E%AF/</guid>
      <description>&lt;h2 id=&#34;1-前言&#34;&gt;1. 前言&lt;/h2&gt;
&lt;p&gt;对于课后作业，我一直在想，应该怎么完成这个作业，如果只是复述或者总结整节课的知识点，那直接看PPT课件就好了，PPT课件总结得已经足够好了。所以我有时会无从下手，毕竟，课堂上讲的大多都是对管理整个体系的理解与认知，不会具体到对某个场景应该给出什么对策，所以很简单，把自己认为的想到的，全都整理出来就好了。&lt;/p&gt;
&lt;p&gt;“人是你在用，为什么出了成绩是你的功劳，而犯错就是别人的事呢？”&lt;/p&gt;
&lt;p&gt;开课看到屏幕上这句话，它一下子就戳中了我，因为之前有一段时间，刚好遇到类似的事情，不是我自己的事情，是生活上的事情。&lt;/p&gt;
&lt;p&gt;NBA球星伦纳德，他能力出众，被誉为联盟前五的球员。去年他加入快船队并担任球队领袖。由于腿部受伤，他需要负荷管理，意味着常规赛82场比赛他无法全力，需要经常休息，不上场打比赛，要到最后关头，也就是季后赛要争冠了才发力，给人留下的印象就是其他队友累死累活，他留着力气最后再拼去摘桃子，因为要是快船队夺冠，他的功劳肯定最大，他得到的荣誉也最多，他能力最那么强，其他队员不可能盖过他的光芒。&lt;/p&gt;
&lt;p&gt;但是可惜，今年快船队更衣室出了问题，爆出很多有队友不服伦纳德的消息，差不多就是空降之后，抢夺了老队员各方面的利益了等等，快船队没有坚持到最后夺冠，很多人批评伦纳德作为球队领袖，没有领导力，没有妥善解决队友之间的矛盾，意思就是镇不住场子，把整个球队带动起来，向前更进一步。&lt;/p&gt;
&lt;p&gt;伦纳德个人能力联盟顶级，为人和善，懂得牺牲，不爱说话，给人的感觉就是很木讷，只顾以身作则，对领导球队并不上心，或者说并没表现出来，基本就是这样一个情况。&lt;/p&gt;
&lt;p&gt;通过这件事情，我思考了以下三点。&lt;/p&gt;
&lt;h2 id=&#34;2-关于功劳&#34;&gt;2. 关于功劳&lt;/h2&gt;
&lt;p&gt;我们常说“众人拾柴火焰高”，一个团队，如果没有凝聚力，那么就会像一盘散沙一样，毫无战斗力，只有众人心齐，力往一处使，这样才能将整个团队的战斗力发挥到最大，这时，能够引导众人心齐之人，便是这个团队的负责人了，这一个做事的过程，没有什么问题，有问题的是在获利的这个事情上，是啊，人是你在用，为什么出了成绩都是你的功劳，我们常说“一将功成万骨枯”，一个将帅的成功都是靠牺牲成千上万的生命换来的，事实虽是如此，但是回到上面那句话本身，我是觉得问出这句话的人和此人的领导都有问题，我不知道其他人是怎么想的，至少在我看来，在其位谋其政，任其职尽其责，认清自己的定位是很重要的，首先你是小兵的时候，当然要先做好自己的本分了，做好牺牲的觉悟了，这是很正常的，但如果是将帅，每一次战役的成功，当然要懂得将功劳归功于部下，你运筹帷幄之中，决胜在千里之外，但是上场杀敌，将生死置之度外的是小兵，为部下争取更多的利益，有助于稳定军心，水能载舟亦能覆舟，一向如此。&lt;/p&gt;
&lt;h2 id=&#34;3-关于责任&#34;&gt;3. 关于责任&lt;/h2&gt;
&lt;p&gt;至于“而犯错就是别人的事呢？”，在我看来，不管团体里的员工犯了什么错，一个团队没有做好一件事情，那么作为团队负责人，必定是揽全责的，就好像快船队出局了，虽然不是伦纳德的错，但他作为球队领袖，就应该负起所有的责任，没错，把锅背好。&lt;/p&gt;
&lt;p&gt;很多人都是习惯推卸责任，常常出口就是，都是谁谁谁谁的问题，才导致了我这个问题，我不是很喜欢这些说辞，但如果只是自己的事情，有时候觉得可以理解，但如果事关团队，而你作为团队负责人，上级指出你这个团队在做这件事情时，出了问题，然而你给出的解释是，都是我们团队谁谁谁谁的问题，不是我的问题，这样是很危险的，作为一个团队的负责人，遇到问题，第一时间不是想着去解决问题，而是在问责，此时纠结是谁的责任，并没有什么意义，因为问题已经出现了，解决问题才是最重要的，至于是谁的责任，这个可以后面再来处理。&lt;/p&gt;
&lt;p&gt;在我看来，管理一个团队其实很辛苦的，辛苦往往表现在操心上，差不多就是当爹又当妈，很多事情都要考虑周全，之前我一直想要做好一些事情，因为我相信“木桶定律”，一个水桶能装多少水取决于它最短的那块木板，一个团队的战斗力也是可以这样理解的，所以我一直想多努力一下，不想拖后腿，这是作为个人来说的，但是如果上升到去管理一个团队，那不是独善其身就可以的，基本上要事无巨细，关注团队的方方面面，需要花费的精力可想而知，不过我是喜欢能够给别人提供帮助的，一个团队有很好的氛围，大家努力去做一些事情，感觉还是很不错的。&lt;/p&gt;
&lt;h2 id=&#34;4-关于空降领导&#34;&gt;4. 关于空降领导&lt;/h2&gt;
&lt;p&gt;空降领导的问题，为什么工作中空降领导特别难做，以上伦纳德的例子就足以说明。因为这个需要各方面的技巧才行，首先就是授权的问题，如果伦纳德刚来的时候，老板、管理层和主教练没有当场表示出其为球队领袖，那么老队员是不会服从的，这个就要考虑到人性的复杂性了，换位思考其实也就知道了，突然来一个上级领导，虽然后面会接受，但至少第一时间，心里面肯定是不会舒服的，这是人之常情，我觉得可以理解，因为自己与你并无交集，为什么要听你的安排。所以作为空降领导，就需要和其他队员搞好关系了，比如团建什么的，但是伦纳德木讷的性格很难让人相信，他有这个处理能力，再加上主教练里弗斯喜欢与队员称兄道弟，这就让老队员很容易不注意边界。我记得在中学时代，军训的时候，有同学和教官在休息的时候，有说有笑，嬉皮笑脸的，到了真正归队训练的时候，这位同学还是这样，然后教官就给了他一脚，他很诧异，然后教官又给了一脚，他就明白了。总之，在我看来，空降领导的问题，关系到的因素很多，需要花费很多的心力才能处理好。&lt;/p&gt;
&lt;p&gt;总的来说，企业就是要盈利的，管理就是为了能够让企业长久健康的盈利，为了达到这个目的，我们才需要学习这方面的知识，这是一个需要持续积累的过程。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<h2 id="1-前言">1. 前言</h2>
<p>对于课后作业，我一直在想，应该怎么完成这个作业，如果只是复述或者总结整节课的知识点，那直接看PPT课件就好了，PPT课件总结得已经足够好了。所以我有时会无从下手，毕竟，课堂上讲的大多都是对管理整个体系的理解与认知，不会具体到对某个场景应该给出什么对策，所以很简单，把自己认为的想到的，全都整理出来就好了。</p>
<p>“人是你在用，为什么出了成绩是你的功劳，而犯错就是别人的事呢？”</p>
<p>开课看到屏幕上这句话，它一下子就戳中了我，因为之前有一段时间，刚好遇到类似的事情，不是我自己的事情，是生活上的事情。</p>
<p>NBA球星伦纳德，他能力出众，被誉为联盟前五的球员。去年他加入快船队并担任球队领袖。由于腿部受伤，他需要负荷管理，意味着常规赛82场比赛他无法全力，需要经常休息，不上场打比赛，要到最后关头，也就是季后赛要争冠了才发力，给人留下的印象就是其他队友累死累活，他留着力气最后再拼去摘桃子，因为要是快船队夺冠，他的功劳肯定最大，他得到的荣誉也最多，他能力最那么强，其他队员不可能盖过他的光芒。</p>
<p>但是可惜，今年快船队更衣室出了问题，爆出很多有队友不服伦纳德的消息，差不多就是空降之后，抢夺了老队员各方面的利益了等等，快船队没有坚持到最后夺冠，很多人批评伦纳德作为球队领袖，没有领导力，没有妥善解决队友之间的矛盾，意思就是镇不住场子，把整个球队带动起来，向前更进一步。</p>
<p>伦纳德个人能力联盟顶级，为人和善，懂得牺牲，不爱说话，给人的感觉就是很木讷，只顾以身作则，对领导球队并不上心，或者说并没表现出来，基本就是这样一个情况。</p>
<p>通过这件事情，我思考了以下三点。</p>
<h2 id="2-关于功劳">2. 关于功劳</h2>
<p>我们常说“众人拾柴火焰高”，一个团队，如果没有凝聚力，那么就会像一盘散沙一样，毫无战斗力，只有众人心齐，力往一处使，这样才能将整个团队的战斗力发挥到最大，这时，能够引导众人心齐之人，便是这个团队的负责人了，这一个做事的过程，没有什么问题，有问题的是在获利的这个事情上，是啊，人是你在用，为什么出了成绩都是你的功劳，我们常说“一将功成万骨枯”，一个将帅的成功都是靠牺牲成千上万的生命换来的，事实虽是如此，但是回到上面那句话本身，我是觉得问出这句话的人和此人的领导都有问题，我不知道其他人是怎么想的，至少在我看来，在其位谋其政，任其职尽其责，认清自己的定位是很重要的，首先你是小兵的时候，当然要先做好自己的本分了，做好牺牲的觉悟了，这是很正常的，但如果是将帅，每一次战役的成功，当然要懂得将功劳归功于部下，你运筹帷幄之中，决胜在千里之外，但是上场杀敌，将生死置之度外的是小兵，为部下争取更多的利益，有助于稳定军心，水能载舟亦能覆舟，一向如此。</p>
<h2 id="3-关于责任">3. 关于责任</h2>
<p>至于“而犯错就是别人的事呢？”，在我看来，不管团体里的员工犯了什么错，一个团队没有做好一件事情，那么作为团队负责人，必定是揽全责的，就好像快船队出局了，虽然不是伦纳德的错，但他作为球队领袖，就应该负起所有的责任，没错，把锅背好。</p>
<p>很多人都是习惯推卸责任，常常出口就是，都是谁谁谁谁的问题，才导致了我这个问题，我不是很喜欢这些说辞，但如果只是自己的事情，有时候觉得可以理解，但如果事关团队，而你作为团队负责人，上级指出你这个团队在做这件事情时，出了问题，然而你给出的解释是，都是我们团队谁谁谁谁的问题，不是我的问题，这样是很危险的，作为一个团队的负责人，遇到问题，第一时间不是想着去解决问题，而是在问责，此时纠结是谁的责任，并没有什么意义，因为问题已经出现了，解决问题才是最重要的，至于是谁的责任，这个可以后面再来处理。</p>
<p>在我看来，管理一个团队其实很辛苦的，辛苦往往表现在操心上，差不多就是当爹又当妈，很多事情都要考虑周全，之前我一直想要做好一些事情，因为我相信“木桶定律”，一个水桶能装多少水取决于它最短的那块木板，一个团队的战斗力也是可以这样理解的，所以我一直想多努力一下，不想拖后腿，这是作为个人来说的，但是如果上升到去管理一个团队，那不是独善其身就可以的，基本上要事无巨细，关注团队的方方面面，需要花费的精力可想而知，不过我是喜欢能够给别人提供帮助的，一个团队有很好的氛围，大家努力去做一些事情，感觉还是很不错的。</p>
<h2 id="4-关于空降领导">4. 关于空降领导</h2>
<p>空降领导的问题，为什么工作中空降领导特别难做，以上伦纳德的例子就足以说明。因为这个需要各方面的技巧才行，首先就是授权的问题，如果伦纳德刚来的时候，老板、管理层和主教练没有当场表示出其为球队领袖，那么老队员是不会服从的，这个就要考虑到人性的复杂性了，换位思考其实也就知道了，突然来一个上级领导，虽然后面会接受，但至少第一时间，心里面肯定是不会舒服的，这是人之常情，我觉得可以理解，因为自己与你并无交集，为什么要听你的安排。所以作为空降领导，就需要和其他队员搞好关系了，比如团建什么的，但是伦纳德木讷的性格很难让人相信，他有这个处理能力，再加上主教练里弗斯喜欢与队员称兄道弟，这就让老队员很容易不注意边界。我记得在中学时代，军训的时候，有同学和教官在休息的时候，有说有笑，嬉皮笑脸的，到了真正归队训练的时候，这位同学还是这样，然后教官就给了他一脚，他很诧异，然后教官又给了一脚，他就明白了。总之，在我看来，空降领导的问题，关系到的因素很多，需要花费很多的心力才能处理好。</p>
<p>总的来说，企业就是要盈利的，管理就是为了能够让企业长久健康的盈利，为了达到这个目的，我们才需要学习这方面的知识，这是一个需要持续积累的过程。</p>
]]></content:encoded>
    </item>
    <item>
      <title>第一周：参照与变迁</title>
      <link>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%80%E5%91%A8%E5%8F%82%E7%85%A7%E4%B8%8E%E5%8F%98%E8%BF%81/</link>
      <pubDate>Fri, 13 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://dstweihao.cn/posts/%E8%81%8C%E4%B8%9A%E4%B8%8E%E7%AE%A1%E7%90%86/%E8%81%8C%E5%9C%BA%E4%B8%8E%E8%AE%A4%E7%9F%A5/%E7%AC%AC%E4%B8%80%E5%91%A8%E5%8F%82%E7%85%A7%E4%B8%8E%E5%8F%98%E8%BF%81/</guid>
      <description>&lt;blockquote&gt;
&lt;p&gt;这是我于2020年10月参加的一个为期10周的管理课程培训的作业集。当时要求每周都需提交一篇课后作业。现在打算重温并整理这些作业，以验证自己在这几年间是否真正有所长进。&lt;/p&gt;&lt;/blockquote&gt;
&lt;p&gt;事物一旦向相反方向发生改变，那么会相对程度的改变，并且会下意识的以未改变的状态作为参照物，事物存在本质是一种平衡，跟相对性、守恒有关，跟参照物无关。&lt;/p&gt;
&lt;p&gt;参照物是我们能够感受到事物存在的必要条件，平衡一旦遭到破坏，事物就会消亡，但是组成事物的元素不会消失，只是会重组新的事物出现，并且达到某一种平衡，冰化水，水化水蒸气便是如此。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240044706.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;一个人的行为可能因情境和动机的不同而表现出不同的好坏程度。同样的小错误，在好人身上可能受到严厉的指责，而在被认为有改过之心的“坏人”身上，却可能被视为具有教育的价值，前者是否定，而后者则是肯定。为了更具体地理解这种变化，我倾向于将好坏程度具象化：&lt;code&gt;X&lt;/code&gt;轴正半轴代表好的程度，负半轴则代表坏的程度，其绝对值的大小反映了好坏的程度。如果以&lt;code&gt;Y&lt;/code&gt;轴为镜面对称，那么好坏之间的转变将呈现相对程度的对称变化。&lt;/p&gt;
&lt;p&gt;物极必反，这一原理表明事物在极端状态下往往会向反方向转变。然而，问题的关键在于，当事物尚未达到这种极端状态时，其转变会呈现何种态势？我认为，即使没有达到临界点，事物也会发生相反方向、相对程度的转变。换句话说，一个人并不需要在好到极致后才会变坏，也不必在坏到极致后才会向好转变。这种转变是连续的、动态的，而非仅在极端状态下才发生。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240050412.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;假设&lt;code&gt;C&lt;/code&gt;为地面，&lt;code&gt;A&lt;/code&gt;为地面挖坑的深度，如果&lt;code&gt;A&lt;/code&gt;的深度为&lt;code&gt;0&lt;/code&gt;，那么&lt;code&gt;B&lt;/code&gt;的高度也会为&lt;code&gt;0&lt;/code&gt;，&lt;code&gt;A&lt;/code&gt;挖得越深，&lt;code&gt;B&lt;/code&gt;也就越高。山之所以高不见得是山本身的原因，有可能是海太深的原因，同理，海之所以深，也有可能是山太高的原因。至此，基本可以说明，事物存在本身有一种此消彼长的平衡，这种平衡一旦遭到破坏，那么事物就会消亡，比如将深坑&lt;code&gt;A&lt;/code&gt;重新填满，那么&lt;code&gt;B&lt;/code&gt;的高度就会消失，然而事物的本质并不会消失，而是转化成另外一种平衡，&lt;code&gt;AB&lt;/code&gt;消失，曲线消失，但是会变成直线&lt;code&gt;C&lt;/code&gt;这样另一种平衡的状态。&lt;/p&gt;
&lt;p&gt;&lt;img loading=&#34;lazy&#34; src=&#34;https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240057500.png&#34;&gt;&lt;/p&gt;
&lt;p&gt;如上图&lt;code&gt;A&lt;/code&gt;和&lt;code&gt;B&lt;/code&gt;，用白色的粉笔写字时，会下意识选择黑板，用黑色墨水写字时，会下意识选择白色的纸张，这基本说明，事物一旦向相反方向发生改变（白色粉笔变成黑色钢笔），会下意识的以未改变时的状态（白色）作为参照物，会因为黑夜而觉得灯光明亮，会因为白天烈日高照而觉得山洞漆黑，灯光明亮程度和山洞漆黑程度一直都没有改变，变的是参照物。&lt;/p&gt;
&lt;p&gt;用黑色钢笔在黑板上写字和用白色粉笔在白色纸张上写字，如果我们不睁眼细看，基本不可能察觉得到文字，更谈不上写的是什么内容了，所以会说什么都没有，因此，人是很容易受到眼睛欺骗的，这是眼界的局限性，也是人的局限性。所以说，事物存在本身与参照物无关，但是我们能够感受到事物的存在与参照物有关，参照物一旦消失，我们就无法感受到事物的存在，没有黑夜，就不会知道什么是白天，没有好人，就不会知道什么是坏人，如果好人全部消失，那么剩下的“坏人”在失去参照物的情况下，其“坏”的定义也将不复存在。&lt;/p&gt;
&lt;p&gt;当然，这是理想状态下的想法，较为现实的比喻是，一群人排队，从高到矮，如果把最高的拿掉，那么第二高的就会变成最高的，再把这个最高拿掉，之前第三高的就会变成最高的，也就是说，如果好人全部消失，因为人的差异性和复杂性，那么剩下的那些坏人中就会出现新的“好人”，如果坏人全部消失，就会从剩下的那些好人里面出现新的“坏人”，如此循坏，不断出现新的参照物和新的平衡，人还是当初那些人，只是参照物不一样了。&lt;/p&gt;
&lt;p&gt;我们常说一个人由好（以坏为参照）变坏（以好为参照），但通常不会提及由小坏（以好为参照）到更坏（同样是以好为参照）的转变，前者因为参照物不一样，所以感觉到的变化就越大，那种憎恨的感情便更强烈，而后者因为参照物一样，那么感觉到的变化会很小，较之前者那种憎恨的感觉也会小很多，就好像我们只会注意到很刺眼的黑板上的白色粉笔字和白色纸张上的黑色钢笔字，从来没有注意过偌大的黑板和白色纸张这两个参照物一样，这同样体现了我们眼界的局限性。&lt;/p&gt;
&lt;p&gt;参照物是一切问题得以产生的原因，不要让眼睛欺骗了自己。&lt;/p&gt;</description>
      <content:encoded><![CDATA[<blockquote>
<p>这是我于2020年10月参加的一个为期10周的管理课程培训的作业集。当时要求每周都需提交一篇课后作业。现在打算重温并整理这些作业，以验证自己在这几年间是否真正有所长进。</p></blockquote>
<p>事物一旦向相反方向发生改变，那么会相对程度的改变，并且会下意识的以未改变的状态作为参照物，事物存在本质是一种平衡，跟相对性、守恒有关，跟参照物无关。</p>
<p>参照物是我们能够感受到事物存在的必要条件，平衡一旦遭到破坏，事物就会消亡，但是组成事物的元素不会消失，只是会重组新的事物出现，并且达到某一种平衡，冰化水，水化水蒸气便是如此。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240044706.png"></p>
<p>一个人的行为可能因情境和动机的不同而表现出不同的好坏程度。同样的小错误，在好人身上可能受到严厉的指责，而在被认为有改过之心的“坏人”身上，却可能被视为具有教育的价值，前者是否定，而后者则是肯定。为了更具体地理解这种变化，我倾向于将好坏程度具象化：<code>X</code>轴正半轴代表好的程度，负半轴则代表坏的程度，其绝对值的大小反映了好坏的程度。如果以<code>Y</code>轴为镜面对称，那么好坏之间的转变将呈现相对程度的对称变化。</p>
<p>物极必反，这一原理表明事物在极端状态下往往会向反方向转变。然而，问题的关键在于，当事物尚未达到这种极端状态时，其转变会呈现何种态势？我认为，即使没有达到临界点，事物也会发生相反方向、相对程度的转变。换句话说，一个人并不需要在好到极致后才会变坏，也不必在坏到极致后才会向好转变。这种转变是连续的、动态的，而非仅在极端状态下才发生。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240050412.png"></p>
<p>假设<code>C</code>为地面，<code>A</code>为地面挖坑的深度，如果<code>A</code>的深度为<code>0</code>，那么<code>B</code>的高度也会为<code>0</code>，<code>A</code>挖得越深，<code>B</code>也就越高。山之所以高不见得是山本身的原因，有可能是海太深的原因，同理，海之所以深，也有可能是山太高的原因。至此，基本可以说明，事物存在本身有一种此消彼长的平衡，这种平衡一旦遭到破坏，那么事物就会消亡，比如将深坑<code>A</code>重新填满，那么<code>B</code>的高度就会消失，然而事物的本质并不会消失，而是转化成另外一种平衡，<code>AB</code>消失，曲线消失，但是会变成直线<code>C</code>这样另一种平衡的状态。</p>
<p><img loading="lazy" src="https://dstweihao-1300388255.cos.ap-guangzhou.myqcloud.com/images/202405240057500.png"></p>
<p>如上图<code>A</code>和<code>B</code>，用白色的粉笔写字时，会下意识选择黑板，用黑色墨水写字时，会下意识选择白色的纸张，这基本说明，事物一旦向相反方向发生改变（白色粉笔变成黑色钢笔），会下意识的以未改变时的状态（白色）作为参照物，会因为黑夜而觉得灯光明亮，会因为白天烈日高照而觉得山洞漆黑，灯光明亮程度和山洞漆黑程度一直都没有改变，变的是参照物。</p>
<p>用黑色钢笔在黑板上写字和用白色粉笔在白色纸张上写字，如果我们不睁眼细看，基本不可能察觉得到文字，更谈不上写的是什么内容了，所以会说什么都没有，因此，人是很容易受到眼睛欺骗的，这是眼界的局限性，也是人的局限性。所以说，事物存在本身与参照物无关，但是我们能够感受到事物的存在与参照物有关，参照物一旦消失，我们就无法感受到事物的存在，没有黑夜，就不会知道什么是白天，没有好人，就不会知道什么是坏人，如果好人全部消失，那么剩下的“坏人”在失去参照物的情况下，其“坏”的定义也将不复存在。</p>
<p>当然，这是理想状态下的想法，较为现实的比喻是，一群人排队，从高到矮，如果把最高的拿掉，那么第二高的就会变成最高的，再把这个最高拿掉，之前第三高的就会变成最高的，也就是说，如果好人全部消失，因为人的差异性和复杂性，那么剩下的那些坏人中就会出现新的“好人”，如果坏人全部消失，就会从剩下的那些好人里面出现新的“坏人”，如此循坏，不断出现新的参照物和新的平衡，人还是当初那些人，只是参照物不一样了。</p>
<p>我们常说一个人由好（以坏为参照）变坏（以好为参照），但通常不会提及由小坏（以好为参照）到更坏（同样是以好为参照）的转变，前者因为参照物不一样，所以感觉到的变化就越大，那种憎恨的感情便更强烈，而后者因为参照物一样，那么感觉到的变化会很小，较之前者那种憎恨的感觉也会小很多，就好像我们只会注意到很刺眼的黑板上的白色粉笔字和白色纸张上的黑色钢笔字，从来没有注意过偌大的黑板和白色纸张这两个参照物一样，这同样体现了我们眼界的局限性。</p>
<p>参照物是一切问题得以产生的原因，不要让眼睛欺骗了自己。</p>
]]></content:encoded>
    </item>
  </channel>
</rss>
