update

leetcode/problem/bitwise-xor-of-all-pairings.html

@@ -0,0 +1,34 @@
+<p>You are given two <strong>0-indexed</strong> arrays, <code>nums1</code> and <code>nums2</code>, consisting of non-negative integers. There exists another array, <code>nums3</code>, which contains the bitwise XOR of <strong>all pairings</strong> of integers between <code>nums1</code> and <code>nums2</code> (every integer in <code>nums1</code> is paired with every integer in <code>nums2</code> <strong>exactly once</strong>).</p>
+
+<p>Return<em> the <strong>bitwise XOR</strong> of all integers in </em><code>nums3</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [2,1,3], nums2 = [10,2,5,0]
+<strong>Output:</strong> 13
+<strong>Explanation:</strong>
+A possible nums3 array is [8,0,7,2,11,3,4,1,9,1,6,3].
+The bitwise XOR of all these numbers is 13, so we return 13.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [1,2], nums2 = [3,4]
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+All possible pairs of bitwise XORs are nums1[0] ^ nums2[0], nums1[0] ^ nums2[1], nums1[1] ^ nums2[0],
+and nums1[1] ^ nums2[1].
+Thus, one possible nums3 array is [2,5,1,6].
+2 ^ 5 ^ 1 ^ 6 = 0, so we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= nums1.length, nums2.length &lt;= 10<sup>5</sup></code></li>
+	<li><code>0 &lt;= nums1[i], nums2[j] &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/longest-uploaded-prefix.html

@@ -0,0 +1,43 @@
+<p>You are given a stream of <code>n</code> videos, each represented by a <strong>distinct</strong> number from <code>1</code> to <code>n</code> that you need to &quot;upload&quot; to a server. You need to implement a data structure that calculates the length of the <strong>longest uploaded prefix</strong> at various points in the upload process.</p>
+
+<p>We consider <code>i</code> to be an uploaded prefix if all videos in the range <code>1</code> to <code>i</code> (<strong>inclusive</strong>) have been uploaded to the server. The longest uploaded prefix is the <strong>maximum </strong>value of <code>i</code> that satisfies this definition.<br />
+<br />
+Implement the <code>LUPrefix </code>class:</p>
+
+<ul>
+	<li><code>LUPrefix(int n)</code> Initializes the object for a stream of <code>n</code> videos.</li>
+	<li><code>void upload(int video)</code> Uploads <code>video</code> to the server.</li>
+	<li><code>int longest()</code> Returns the length of the <strong>longest uploaded prefix</strong> defined above.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input</strong>
+[&quot;LUPrefix&quot;, &quot;upload&quot;, &quot;longest&quot;, &quot;upload&quot;, &quot;longest&quot;, &quot;upload&quot;, &quot;longest&quot;]
+[[4], [3], [], [1], [], [2], []]
+<strong>Output</strong>
+[null, null, 0, null, 1, null, 3]
+
+<strong>Explanation</strong>
+LUPrefix server = new LUPrefix(4);   // Initialize a stream of 4 videos.
+server.upload(3);                    // Upload video 3.
+server.longest();                    // Since video 1 has not been uploaded yet, there is no prefix.
+                                     // So, we return 0.
+server.upload(1);                    // Upload video 1.
+server.longest();                    // The prefix [1] is the longest uploaded prefix, so we return 1.
+server.upload(2);                    // Upload video 2.
+server.longest();                    // The prefix [1,2,3] is the longest uploaded prefix, so we return 3.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>1 &lt;= video &lt;= n</code></li>
+	<li>All values of <code>video</code> are <strong>distinct</strong>.</li>
+	<li>At most <code>2 * 10<sup>5</sup></code> calls <strong>in total</strong> will be made to <code>upload</code> and <code>longest</code>.</li>
+	<li>At least one call will be made to <code>longest</code>.</li>
+</ul>

leetcode/problem/maximum-deletions-on-a-string.html

@@ -0,0 +1,52 @@
+<p>You are given a string <code>s</code> consisting of only lowercase English letters. In one operation, you can:</p>
+
+<ul>
+	<li>Delete <strong>the entire string</strong> <code>s</code>, or</li>
+	<li>Delete the <strong>first</strong> <code>i</code> letters of <code>s</code> if the first <code>i</code> letters of <code>s</code> are <strong>equal</strong> to the following <code>i</code> letters in <code>s</code>, for any <code>i</code> in the range <code>1 &lt;= i &lt;= s.length / 2</code>.</li>
+</ul>
+
+<p>For example, if <code>s = &quot;ababc&quot;</code>, then in one operation, you could delete the first two letters of <code>s</code> to get <code>&quot;abc&quot;</code>, since the first two letters of <code>s</code> and the following two letters of <code>s</code> are both equal to <code>&quot;ab&quot;</code>.</p>
+
+<p>Return <em>the <strong>maximum</strong> number of operations needed to delete all of </em><code>s</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;abcabcdabc&quot;
+<strong>Output:</strong> 2
+<strong>Explanation:</strong>
+- Delete the first 3 letters (&quot;abc&quot;) since the next 3 letters are equal. Now, s = &quot;abcdabc&quot;.
+- Delete all the letters.
+We used 2 operations so return 2. It can be proven that 2 is the maximum number of operations needed.
+Note that in the second operation we cannot delete &quot;abc&quot; again because the next occurrence of &quot;abc&quot; does not happen in the next 3 letters.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;aaabaab&quot;
+<strong>Output:</strong> 4
+<strong>Explanation:</strong>
+- Delete the first letter (&quot;a&quot;) since the next letter is equal. Now, s = &quot;aabaab&quot;.
+- Delete the first 3 letters (&quot;aab&quot;) since the next 3 letters are equal. Now, s = &quot;aab&quot;.
+- Delete the first letter (&quot;a&quot;) since the next letter is equal. Now, s = &quot;ab&quot;.
+- Delete all the letters.
+We used 4 operations so return 4. It can be proven that 4 is the maximum number of operations needed.
+</pre>
+
+<p><strong>Example 3:</strong></p>
+
+<pre>
+<strong>Input:</strong> s = &quot;aaaaa&quot;
+<strong>Output:</strong> 5
+<strong>Explanation:</strong> In each operation, we can delete the first letter of s.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= s.length &lt;= 4000</code></li>
+	<li><code>s</code> consists only of lowercase English letters.</li>
+</ul>

leetcode/problem/maximum-sum-of-an-hourglass.html

@@ -0,0 +1,34 @@
+<p>You are given an <code>m x n</code> integer matrix <code>grid</code>.</p>
+
+<p>We define an <strong>hourglass</strong> as a part of the matrix with the following form:</p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/21/img.jpg" style="width: 243px; height: 243px;" />
+<p>Return <em>the <strong>maximum</strong> sum of the elements of an hourglass</em>.</p>
+
+<p><strong>Note</strong> that an hourglass cannot be rotated and must be entirely contained within the matrix.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/21/1.jpg" style="width: 323px; height: 323px;" />
+<pre>
+<strong>Input:</strong> grid = [[6,2,1,3],[4,2,1,5],[9,2,8,7],[4,1,2,9]]
+<strong>Output:</strong> 30
+<strong>Explanation:</strong> The cells shown above represent the hourglass with the maximum sum: 6 + 2 + 1 + 2 + 9 + 2 + 8 = 30.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+<img alt="" src="https://assets.leetcode.com/uploads/2022/08/21/2.jpg" style="width: 243px; height: 243px;" />
+<pre>
+<strong>Input:</strong> grid = [[1,2,3],[4,5,6],[7,8,9]]
+<strong>Output:</strong> 35
+<strong>Explanation:</strong> There is only one hourglass in the matrix, with the sum: 1 + 2 + 3 + 5 + 7 + 8 + 9 = 35.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>3 &lt;= m, n &lt;= 150</code></li>
+	<li><code>0 &lt;= grid[i][j] &lt;= 10<sup>6</sup></code></li>
+</ul>

leetcode/problem/minimize-xor.html

@@ -0,0 +1,40 @@
+<p>Given two positive integers <code>num1</code> and <code>num2</code>, find the integer <code>x</code> such that:</p>
+
+<ul>
+	<li><code>x</code> has the same number of set bits as <code>num2</code>, and</li>
+	<li>The value <code>x XOR num1</code> is <strong>minimal</strong>.</li>
+</ul>
+
+<p>Note that <code>XOR</code> is the bitwise XOR operation.</p>
+
+<p>Return <em>the integer </em><code>x</code>. The test cases are generated such that <code>x</code> is <strong>uniquely determined</strong>.</p>
+
+<p>The number of <strong>set bits</strong> of an integer is the number of <code>1</code>&#39;s in its binary representation.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> num1 = 3, num2 = 5
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The binary representations of num1 and num2 are 0011 and 0101, respectively.
+The integer <strong>3</strong> has the same number of set bits as num2, and the value <code>3 XOR 3 = 0</code> is minimal.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> num1 = 1, num2 = 12
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+The binary representations of num1 and num2 are 0001 and 1100, respectively.
+The integer <strong>3</strong> has the same number of set bits as num2, and the value <code>3 XOR 1 = 2</code> is minimal.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= num1, num2 &lt;= 10<sup>9</sup></code></li>
+</ul>

leetcode/problem/number-of-common-factors.html

@@ -0,0 +1,27 @@
+<p>Given two positive integers <code>a</code> and <code>b</code>, return <em>the number of <strong>common</strong> factors of </em><code>a</code><em> and </em><code>b</code>.</p>
+
+<p>An integer <code>x</code> is a <strong>common factor</strong> of <code>a</code> and <code>b</code> if <code>x</code> divides both <code>a</code> and <code>b</code>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> a = 12, b = 6
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> The common factors of 12 and 6 are 1, 2, 3, 6.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> a = 25, b = 30
+<strong>Output:</strong> 2
+<strong>Explanation:</strong> The common factors of 25 and 30 are 1, 5.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= a, b &lt;= 1000</code></li>
+</ul>

leetcode/problem/number-of-pairs-satisfying-inequality.html

@@ -0,0 +1,41 @@
+<p>You are given two <strong>0-indexed</strong> integer arrays <code>nums1</code> and <code>nums2</code>, each of size <code>n</code>, and an integer <code>diff</code>. Find the number of <strong>pairs</strong> <code>(i, j)</code> such that:</p>
+
+<ul>
+	<li><code>0 &lt;= i &lt; j &lt;= n - 1</code> <strong>and</strong></li>
+	<li><code>nums1[i] - nums1[j] &lt;= nums2[i] - nums2[j] + diff</code>.</li>
+</ul>
+
+<p>Return<em> the <strong>number of pairs</strong> that satisfy the conditions.</em></p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [3,2,5], nums2 = [2,2,1], diff = 1
+<strong>Output:</strong> 3
+<strong>Explanation:</strong>
+There are 3 pairs that satisfy the conditions:
+1. i = 0, j = 1: 3 - 2 &lt;= 2 - 2 + 1. Since i &lt; j and 1 &lt;= 1, this pair satisfies the conditions.
+2. i = 0, j = 2: 3 - 5 &lt;= 2 - 1 + 1. Since i &lt; j and -2 &lt;= 2, this pair satisfies the conditions.
+3. i = 1, j = 2: 2 - 5 &lt;= 2 - 1 + 1. Since i &lt; j and -3 &lt;= 2, this pair satisfies the conditions.
+Therefore, we return 3.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> nums1 = [3,-1], nums2 = [-2,2], diff = -1
+<strong>Output:</strong> 0
+<strong>Explanation:</strong>
+Since there does not exist any pair that satisfies the conditions, we return 0.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>n == nums1.length == nums2.length</code></li>
+	<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums1[i], nums2[i] &lt;= 10<sup>4</sup></code></li>
+	<li><code>-10<sup>4</sup> &lt;= diff &lt;= 10<sup>4</sup></code></li>
+</ul>

leetcode/problem/remove-letter-to-equalize-frequency.html

@@ -0,0 +1,35 @@
+<p>You are given a <strong>0-indexed</strong> string <code>word</code>, consisting of lowercase English letters. You need to select <strong>one</strong> index and <strong>remove</strong> the letter at that index from <code>word</code> so that the <strong>frequency</strong> of every letter present in <code>word</code> is equal.</p>
+
+<p>Return<em> </em><code>true</code><em> if it is possible to remove one letter so that the frequency of all letters in </em><code>word</code><em> are equal, and </em><code>false</code><em> otherwise</em>.</p>
+
+<p><strong>Note:</strong></p>
+
+<ul>
+	<li>The <b>frequency</b> of a letter <code>x</code> is the number of times it occurs in the string.</li>
+	<li>You <strong>must</strong> remove exactly one letter and cannot chose to do nothing.</li>
+</ul>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre>
+<strong>Input:</strong> word = &quot;abcc&quot;
+<strong>Output:</strong> true
+<strong>Explanation:</strong> Select index 3 and delete it: word becomes &quot;abc&quot; and each character has a frequency of 1.
+</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre>
+<strong>Input:</strong> word = &quot;aazz&quot;
+<strong>Output:</strong> false
+<strong>Explanation:</strong> We must delete a character, so either the frequency of &quot;a&quot; is 1 and the frequency of &quot;z&quot; is 2, or vice versa. It is impossible to make all present letters have equal frequency.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>2 &lt;= word.length &lt;= 100</code></li>
+	<li><code>word</code> consists of lowercase English letters only.</li>
+</ul>