<?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/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/</link>
    <description>Recent content in 刻意练习 on 码上生长 - 探索个人成长的无限可能</description>
    <generator>Hugo -- 0.144.2</generator>
    <language>zh</language>
    <lastBuildDate>Fri, 23 May 2025 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://dstweihao.cn/categories/%E5%88%BB%E6%84%8F%E7%BB%83%E4%B9%A0/index.xml" rel="self" type="application/rss+xml" />
    <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>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>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>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>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>
  </channel>
</rss>
