mirror of
https://gitee.com/coder-xiaomo/leetcode-problemset
synced 2025-09-02 05:13:29 +08:00
update
This commit is contained in:
@@ -0,0 +1,28 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code> representing the score of students in an exam. The teacher would like to form one <strong>non-empty</strong> group of students with maximal <strong>strength</strong>, where the strength of a group of students of indices <code>i<sub>0</sub></code>, <code>i<sub>1</sub></code>, <code>i<sub>2</sub></code>, ... , <code>i<sub>k</sub></code> is defined as <code>nums[i<sub>0</sub>] * nums[i<sub>1</sub>] * nums[i<sub>2</sub>] * ... * nums[i<sub>k</sub>]</code>.</p>
|
||||
|
||||
<p>Return <em>the maximum strength of a group the teacher can create</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,-1,-5,2,5,-9]
|
||||
<strong>Output:</strong> 1350
|
||||
<strong>Explanation:</strong> One way to form a group of maximal strength is to group the students at indices [0,2,3,4,5]. Their strength is 3 * (-5) * 2 * 5 * (-9) = 1350, which we can show is optimal.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [-4,-5,-4]
|
||||
<strong>Output:</strong> 20
|
||||
<strong>Explanation:</strong> Group the students at indices [0, 1] . Then, we’ll have a resulting strength of 20. We cannot achieve greater strength.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 13</code></li>
|
||||
<li><code>-9 <= nums[i] <= 9</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,117 @@
|
||||
<p>Write a function that accepts two deeply nested objects or arrays <code>obj1</code> and <code>obj2</code> and returns a new object representing their differences.</p>
|
||||
|
||||
<p>The function should compare the properties of the two objects and identify any changes. The returned object should only contains keys where the value is different from <code>obj1</code> to <code>obj2</code>. For each changed key, the value should be represented as an array <code>[obj1 value, obj2 value]</code>. Keys that exist in one object but not in the other should not be included in the returned object. When comparing two arrays, the indices of the arrays are considered to be their keys. The end result should be a deeply nested object where each leaf value is a difference array.</p>
|
||||
|
||||
<p>You may assume that both objects are the output of <code>JSON.parse</code>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
obj1 = {}
|
||||
obj2 = {
|
||||
"a": 1,
|
||||
"b": 2
|
||||
}
|
||||
<strong>Output:</strong> {}
|
||||
<strong>Explanation:</strong> There were no modifications made to obj1. New keys "a" and "b" appear in obj2, but keys that are added or removed should be ignored.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
obj1 = {
|
||||
"a": 1,
|
||||
"v": 3,
|
||||
"x": [],
|
||||
"z": {
|
||||
"a": null
|
||||
}
|
||||
}
|
||||
obj2 = {
|
||||
"a": 2,
|
||||
"v": 4,
|
||||
"x": [],
|
||||
"z": {
|
||||
"a": 2
|
||||
}
|
||||
}
|
||||
<strong>Output:</strong>
|
||||
{
|
||||
"a": [1, 2],
|
||||
"v": [3, 4],
|
||||
"z": {
|
||||
"a": [null, 2]
|
||||
}
|
||||
}
|
||||
<strong>Explanation:</strong> The keys "a", "v", and "z" all had changes applied. "a" was chnaged from 1 to 2. "v" was changed from 3 to 4. "z" had a change applied to a child object. "z.a" was changed from null to 2.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
obj1 = {
|
||||
"a": 5,
|
||||
"v": 6,
|
||||
"z": [1, 2, 4, [2, 5, 7]]
|
||||
}
|
||||
obj2 = {
|
||||
"a": 5,
|
||||
"v": 7,
|
||||
"z": [1, 2, 3, [1]]
|
||||
}
|
||||
<strong>Output:</strong>
|
||||
{
|
||||
"v": [6, 7],
|
||||
"z": {
|
||||
"2": [4, 3],
|
||||
"3": {
|
||||
"0": [2, 1]
|
||||
}
|
||||
}
|
||||
}
|
||||
<strong>Explanation:</strong> In obj1 and obj2, the keys "v" and "z" have different assigned values. "a" is ignored because the value is unchanged. In the key "z", there is a nested array. Arrays are treated like objects where the indices are keys. There were two alterations to the the array: z[2] and z[3][0]. z[0] and z[1] were unchanged and thus not included. z[3][1] and z[3][2] were removed and thus not included.
|
||||
</pre>
|
||||
|
||||
<p><strong>Example 4:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
obj1 = {
|
||||
"a": {"b": 1},
|
||||
}
|
||||
obj2 = {
|
||||
"a": [5],
|
||||
}
|
||||
<strong>Output:</strong>
|
||||
{
|
||||
"a": [{"b": 1}, [5]]
|
||||
}
|
||||
<strong>Explanation:</strong> The key "a" exists in both objects. Since the two associated values have different types, they are placed in the difference array.</pre>
|
||||
|
||||
<p><strong>Example 5:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
obj1 = {
|
||||
"a": [1, 2, {}],
|
||||
"b": false
|
||||
}
|
||||
obj2 = {
|
||||
"b": false,
|
||||
"a": [1, 2, {}]
|
||||
}
|
||||
<strong>Output:</strong>
|
||||
{}
|
||||
<strong>Explanation:</strong> Apart from a different ordering of keys, the two objects are identical so an empty object is returned.</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= JSON.stringify(obj1).length <= 10<sup>4</sup></code></li>
|
||||
<li><code>2 <= JSON.stringify(obj2).length <= 10<sup>4</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,64 @@
|
||||
<p>Design an <code>EventEmitter</code> class. This interface is similar (but with some differences) to the one found in Node.js or the Event Target interface of the DOM. The <code>EventEmitter</code> should allow for subscribing to events and emitting them.</p>
|
||||
|
||||
<p>Your <code>EventEmitter</code> class should have the following two methods:</p>
|
||||
|
||||
<ul>
|
||||
<li><strong>subscribe</strong> - This method takes in two arguments: the name of an event as a string and a callback function. This callback function will later be called when the event is emitted.<br />
|
||||
An event should be able to have multiple listeners for the same event. When emitting an event with multiple callbacks, each should be called in the order in which they were subscribed. An array of results should be returned. You can assume no callbacks passed to <code>subscribe</code> are referentially identical.<br />
|
||||
The <code>subscribe</code> method should also return an object with an <code>unsubscribe</code> method that enables the user to unsubscribe. When it is called, the callback should be removed from the list of subscriptions and <code>undefined</code> should be returned.</li>
|
||||
<li><strong>emit</strong> - This method takes in two arguments: the name of an event as a string and an optional array of arguments that will be passed to the callback(s). If there are no callbacks subscribed to the given event, return an empty array. Otherwise, return an array of the results of all callback calls in the order they were subscribed.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> actions = ["EventEmitter", "emit", "subscribe", "subscribe", "emit"], values = [[], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent", "function cb1() { return 5; }"], ["firstEvent"]]
|
||||
<strong>Output:</strong> [[],["emitted",[]],["subscribed"],["subscribed"],["emitted",[5,6]]]
|
||||
<strong>Explanation:</strong>
|
||||
const emitter = new EventEmitter();
|
||||
emitter.emit("firstEvent"); // [], no callback are subscribed yet
|
||||
emitter.subscribe("firstEvent", function cb1() { return 5; });
|
||||
emitter.subscribe("firstEvent", function cb2() { return 6; });
|
||||
emitter.emit("firstEvent"); // [5, 6], returns the output of cb1 and cb2
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> actions = ["EventEmitter", "subscribe", "emit", "emit"], values = [[], ["firstEvent", "function cb1(...args) { return args.join(','); }"], ["firstEvent", [1,2,3]], ["firstEvent", [3,4,6]]]
|
||||
<strong>Output:</strong> [[],["subscribed"],["emitted",["1,2,3"]],["emitted",["3,4,6"]]]
|
||||
<strong>Explanation: </strong>Note that the emit method should be able to accept an OPTIONAL array of arguents.
|
||||
|
||||
const emitter = new EventEmitter();
|
||||
emitter.subscribe("firstEvent, function cb1(...args) { return args.join(','); });
|
||||
emitter.emit("firstEvent", [1, 2, 3]); // ["1,2,3"]
|
||||
emitter.emit("firstEvent", [3, 4, 6]); // ["3,4,6"]
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> actions = ["EventEmitter", "subscribe", "emit", "unsubscribe", "emit"], values = [[], ["firstEvent", "(...args) => args.join(',')"], ["firstEvent", [1,2,3]], [0], ["firstEvent", [4,5,6]]]
|
||||
<strong>Output:</strong> [[],["subscribed"],["emitted",["1,2,3"]],["unsubscribed",0],["emitted",[]]]
|
||||
<strong>Explanation:</strong>
|
||||
const emitter = new EventEmitter();
|
||||
const sub = emitter.subscribe("firstEvent", (...args) => args.join(','));
|
||||
emitter.emit("firstEvent", [1, 2, 3]); // ["1,2,3"]
|
||||
sub.unsubscribe(); // undefined
|
||||
emitter.emit("firstEvent", [4, 5, 6]); // [], there are no subscriptions
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= actions.length <= 10</code></li>
|
||||
<li><code>values.length === actions.length</code></li>
|
||||
<li>All test cases are valid, e.g. you don't need to handle scenarios when unsubscribing from a non-existing subscription.</li>
|
||||
<li>There are only 4 different actions: <code>EventEmitter</code>, <code>emit</code>, <code>subscribe</code>, and <code>unsubscribe</code>.</li>
|
||||
<li>The <code>EventEmitter</code> action doesn't take any arguments.</li>
|
||||
<li>The <code>emit</code> action takes between either 1 or 2 arguments. The first argument is the name of the event we want to emit, and the 2nd argument is passed to the callback functions.</li>
|
||||
<li>The <code>subscribe</code> action takes 2 arguments, where the first one is the event name and the second is the callback function.</li>
|
||||
<li>The <code>unsubscribe</code> action takes one argument, which is the 0-indexed order of the subscription made before.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> binary string <code>s</code> of length <code>n</code> on which you can apply two types of operations:</p>
|
||||
|
||||
<ul>
|
||||
<li>Choose an index <code>i</code> and invert all characters from index <code>0</code> to index <code>i</code> (both inclusive), with a cost of <code>i + 1</code></li>
|
||||
<li>Choose an index <code>i</code> and invert all characters from index <code>i</code> to index <code>n - 1</code> (both inclusive), with a cost of <code>n - i</code></li>
|
||||
</ul>
|
||||
|
||||
<p>Return <em>the <strong>minimum cost </strong>to make all characters of the string <strong>equal</strong></em>.</p>
|
||||
|
||||
<p><strong>Invert</strong> a character means if its value is '0' it becomes '1' and vice-versa.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "0011"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> Apply the second operation with <code>i = 2</code> to obtain <code>s = "0000" for a cost of 2</code>. It can be shown that 2 is the minimum cost to make all characters equal.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "010101"
|
||||
<strong>Output:</strong> 9
|
||||
<strong>Explanation:</strong> Apply the first operation with i = 2 to obtain s = "101101" for a cost of 3.
|
||||
Apply the first operation with i = 1 to obtain s = "011101" for a cost of 2.
|
||||
Apply the first operation with i = 0 to obtain s = "111101" for a cost of 1.
|
||||
Apply the second operation with i = 4 to obtain s = "111110" for a cost of 2.
|
||||
Apply the second operation with i = 5 to obtain s = "111111" for a cost of 1.
|
||||
The total cost to make all characters equal is 9. It can be shown that 9 is the minimum cost to make all characters equal.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length == n <= 10<sup>5</sup></code></li>
|
||||
<li><code>s[i]</code> is either <code>'0'</code> or <code>'1'</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,52 @@
|
||||
<p>Enhance all functions to have the <code>callPolyfill</code> method. The method accepts an object <code>obj</code> as it's first parameter and any number of additional arguments. The <code>obj</code> becomes the <code>this</code> context for the function. The additional arguments are passed to the function (that the <code>callPolyfill</code> method belongs on).</p>
|
||||
|
||||
<p>For example if you had the function:</p>
|
||||
|
||||
<pre>
|
||||
function tax(price, taxRate) {
|
||||
const totalCost = price * (1 + taxRate);
|
||||
console.log(`The cost of ${this.item} is ${totalCost}`);
|
||||
}
|
||||
</pre>
|
||||
|
||||
<p>Calling this function like <code>tax(10, 0.1)</code> will log <code>"The cost of undefined is 11"</code>. This is because the <code>this</code> context was not defined.</p>
|
||||
|
||||
<p>However, calling the function like <code>tax.callPolyfill({item: "salad"}, 10, 0.1)</code> will log <code>"The cost of salad is 11"</code>. The <code>this</code> context was appropriately set, and the function logged an appropriate output.</p>
|
||||
|
||||
<p>Please solve this without using the built-in <code>Function.call</code> method.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
fn = function add(b) {
|
||||
return this.a + b;
|
||||
}
|
||||
args = [{"a": 5}, 7]
|
||||
<strong>Output:</strong> 12
|
||||
<strong>Explanation:</strong>
|
||||
fn.callPolyfill({"a": 5}, 7); // 12
|
||||
callPolyfill sets the "this" context to {"a": 5}. 7 is passed as an argument.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong>
|
||||
fn = function tax(price, taxRate) {
|
||||
return `The cost of the ${this.item} is ${price * taxRate}`;
|
||||
}
|
||||
args = [{"item": "burger"}, 10, 1,1]
|
||||
<strong>Output:</strong> "The cost of the burger is 11"
|
||||
<strong>Explanation:</strong> callPolyfill sets the "this" context to {"item": "burger"}. 10 and 1.1 are passed as additional arguments.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul style="list-style-type:square;">
|
||||
<li><code><font face="monospace">typeof args[0] == 'object' and args[0] != null</font></code></li>
|
||||
<li><code>1 <= args.length <= 100</code></li>
|
||||
<li><code>2 <= JSON.stringify(args[0]).length <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,56 @@
|
||||
<p>You are given an <strong>undirected weighted</strong> <strong>connected</strong> graph containing <code>n</code> nodes labeled from <code>0</code> to <code>n - 1</code>, and an integer array <code>edges</code> where <code>edges[i] = [a<sub>i</sub>, b<sub>i</sub>, w<sub>i</sub>]</code> indicates that there is an edge between nodes <code>a<sub>i</sub></code> and <code>b<sub>i</sub></code> with weight <code>w<sub>i</sub></code>.</p>
|
||||
|
||||
<p>Some edges have a weight of <code>-1</code> (<code>w<sub>i</sub> = -1</code>), while others have a <strong>positive</strong> weight (<code>w<sub>i</sub> > 0</code>).</p>
|
||||
|
||||
<p>Your task is to modify <strong>all edges</strong> with a weight of <code>-1</code> by assigning them <strong>positive integer values </strong>in the range <code>[1, 2 * 10<sup>9</sup>]</code> so that the <strong>shortest distance</strong> between the nodes <code>source</code> and <code>destination</code> becomes equal to an integer <code>target</code>. If there are <strong>multiple</strong> <strong>modifications</strong> that make the shortest distance between <code>source</code> and <code>destination</code> equal to <code>target</code>, any of them will be considered correct.</p>
|
||||
|
||||
<p>Return <em>an array containing all edges (even unmodified ones) in any order if it is possible to make the shortest distance from </em><code>source</code><em> to </em><code>destination</code><em> equal to </em><code>target</code><em>, or an <strong>empty array</strong> if it's impossible.</em></p>
|
||||
|
||||
<p><strong>Note:</strong> You are not allowed to modify the weights of edges with initial positive weights.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/18/graph.png" style="width: 300px; height: 300px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 5, edges = [[4,1,-1],[2,0,-1],[0,3,-1],[4,3,-1]], source = 0, destination = 1, target = 5
|
||||
<strong>Output:</strong> [[4,1,1],[2,0,1],[0,3,3],[4,3,1]]
|
||||
<strong>Explanation:</strong> The graph above shows a possible modification to the edges, making the distance from 0 to 1 equal to 5.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/18/graph-2.png" style="width: 300px; height: 300px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 3, edges = [[0,1,-1],[0,2,5]], source = 0, destination = 2, target = 6
|
||||
<strong>Output:</strong> []
|
||||
<strong>Explanation:</strong> The graph above contains the initial edges. It is not possible to make the distance from 0 to 2 equal to 6 by modifying the edge with weight -1. So, an empty array is returned.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/19/graph-3.png" style="width: 300px; height: 300px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 4, edges = [[1,0,4],[1,2,3],[2,3,5],[0,3,-1]], source = 0, destination = 2, target = 6
|
||||
<strong>Output:</strong> [[1,0,4],[1,2,3],[2,3,5],[0,3,1]]
|
||||
<strong>Explanation:</strong> The graph above shows a modified graph having the shortest distance from 0 to 2 as 6.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 100</code></li>
|
||||
<li><code><font face="monospace">1 <= edges.length <= n * (n - 1) / 2</font></code></li>
|
||||
<li><code>edges[i].length == 3</code></li>
|
||||
<li><code>0 <= a<sub>i</sub>, b<sub>i </sub>< n</code></li>
|
||||
<li><code><font face="monospace">w<sub>i</sub> = -1 </font></code>or <code><font face="monospace">1 <= w<sub>i </sub><= 10<sup><span style="font-size: 10.8333px;">7</span></sup></font></code></li>
|
||||
<li><code>a<sub>i </sub>!= b<sub>i</sub></code></li>
|
||||
<li><code>0 <= source, destination < n</code></li>
|
||||
<li><code>source != destination</code></li>
|
||||
<li><code><font face="monospace">1 <= target <= 10<sup>9</sup></font></code></li>
|
||||
<li>The graph is connected, and there are no self-loops or repeated edges</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,36 @@
|
||||
<p>You are given a string <code>s</code> consisting only of <strong>uppercase</strong> English letters.</p>
|
||||
|
||||
<p>You can apply some operations to this string where, in one operation, you can remove <strong>any</strong> occurrence of one of the substrings <code>"AB"</code> or <code>"CD"</code> from <code>s</code>.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> possible length of the resulting string that you can obtain</em>.</p>
|
||||
|
||||
<p><strong>Note</strong> that the string concatenates after removing the substring and could produce new <code>"AB"</code> or <code>"CD"</code> substrings.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ABFCACDB"
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> We can do the following operations:
|
||||
- Remove the substring "<u>AB</u>FCACDB", so s = "FCACDB".
|
||||
- Remove the substring "FCA<u>CD</u>B", so s = "FCAB".
|
||||
- Remove the substring "FC<u>AB</u>", so s = "FC".
|
||||
So the resulting length of the string is 2.
|
||||
It can be shown that it is the minimum length that we can obtain.</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "ACBBD"
|
||||
<strong>Output:</strong> 5
|
||||
<strong>Explanation:</strong> We cannot do any operations on the string so the length remains the same.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 100</code></li>
|
||||
<li><code>s</code> consists only of uppercase English letters.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,48 @@
|
||||
<p>Create a class <code>ArrayWrapper</code> that accepts an array of integers in it's constructor. This class should have two features:</p>
|
||||
|
||||
<ul>
|
||||
<li>When two instances of this class are added together with the <code>+</code> operator, the resulting value is the sum of all the elements in both arrays.</li>
|
||||
<li>When the <code>String()</code> function is called on the instance, it will return a comma separated string surrounded by brackets. For example, <code>[1,2,3]</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [[1,2],[3,4]], operation = "Add"
|
||||
<strong>Output:</strong> 10
|
||||
<strong>Explanation:</strong>
|
||||
const obj1 = new ArrayWrapper([1,2]);
|
||||
const obj2 = new ArrayWrapper([3,4]);
|
||||
obj1 + obj2; // 10
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [[23,98,42,70]], operation = "String"
|
||||
<strong>Output:</strong> "[23,98,42,70]"
|
||||
<strong>Explanation:</strong>
|
||||
const obj = new ArrayWrapper([23,98,42,70]);
|
||||
String(obj); // "[23,98,42,70]"
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [[],[]], operation = "Add"
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong>
|
||||
const obj1 = new ArrayWrapper([]);
|
||||
const obj2 = new ArrayWrapper([]);
|
||||
obj1 + obj2; // 0
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>0 <= nums.length <= 1000</code></li>
|
||||
<li><code>0 <= nums[i] <= 1000</code></li>
|
||||
<li><code>Note: nums is the array passed to the constructor</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a string <code node="[object Object]">s</code> consisting of <strong>lowercase English letters</strong>, and you are allowed to perform operations on it. In one operation, you can <strong>replace</strong> a character in <code node="[object Object]">s</code> with another lowercase English letter.</p>
|
||||
|
||||
<p>Your task is to make <code node="[object Object]">s</code> a <strong>palindrome</strong> with the <strong>minimum</strong> <strong>number</strong> <strong>of operations</strong> possible. If there are <strong>multiple palindromes</strong> that can be <meta charset="utf-8" />made using the <strong>minimum</strong> number of operations, <meta charset="utf-8" />make the <strong>lexicographically smallest</strong> one.</p>
|
||||
|
||||
<p>A string <code>a</code> is lexicographically smaller than a string <code>b</code> (of the same length) if in the first position where <code>a</code> and <code>b</code> differ, string <code>a</code> has a letter that appears earlier in the alphabet than the corresponding letter in <code>b</code>.</p>
|
||||
|
||||
<p>Return <em>the resulting palindrome string.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "egcfe"
|
||||
<strong>Output:</strong> "efcfe"
|
||||
<strong>Explanation:</strong> The minimum number of operations to make "egcfe" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is "efcfe", by changing 'g'.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "abcd"
|
||||
<strong>Output:</strong> "abba"
|
||||
<strong>Explanation:</strong> The minimum number of operations to make "abcd" a palindrome is 2, and the lexicographically smallest palindrome string we can get by modifying two characters is "abba".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "seven"
|
||||
<strong>Output:</strong> "neven"
|
||||
<strong>Explanation:</strong> The minimum number of operations to make "seven" a palindrome is 1, and the lexicographically smallest palindrome string we can get by modifying one character is "neven".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 1000</code></li>
|
||||
<li><code>s</code> consists of only lowercase English letters<b>.</b></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,32 @@
|
||||
<p>You are given a <strong>0-indexed</strong> string <code>s</code> and a dictionary of words <code>dictionary</code>. You have to break <code>s</code> into one or more <strong>non-overlapping</strong> substrings such that each substring is present in <code>dictionary</code>. There may be some <strong>extra characters</strong> in <code>s</code> which are not present in any of the substrings.</p>
|
||||
|
||||
<p>Return <em>the <strong>minimum</strong> number of extra characters left over if you break up </em><code>s</code><em> optimally.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "leetscode", dictionary = ["leet","code","leetcode"]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> We can break s in two substrings: "leet" from index 0 to 3 and "code" from index 5 to 8. There is only 1 unused character (at index 4), so we return 1.
|
||||
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> s = "sayhelloworld", dictionary = ["hello","world"]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> We can break s in two substrings: "hello" from index 3 to 7 and "world" from index 8 to 12. The characters at indices 0, 1, 2 are not used in any substring and thus are considered as extra characters. Hence, we return 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= s.length <= 50</code></li>
|
||||
<li><code>1 <= dictionary.length <= 50</code></li>
|
||||
<li><code>1 <= dictionary[i].length <= 50</code></li>
|
||||
<li><code>dictionary[i]</code> and <code>s</code> consists of only lowercase English letters</li>
|
||||
<li><code>dictionary</code> contains distinct words</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,50 @@
|
||||
<p>Given a <strong>0-indexed</strong> 2D <code>grid</code> of size <code>m x n</code>, you should find the matrix <code>answer</code> of size <code>m x n</code>.</p>
|
||||
|
||||
<p>The value of each cell <code>(r, c)</code> of the matrix <code>answer</code> is calculated in the following way:</p>
|
||||
|
||||
<ul>
|
||||
<li>Let <code>topLeft[r][c]</code> be the number of <strong>distinct</strong> values in the top-left diagonal of the cell <code>(r, c)</code> in the matrix <code>grid</code>.</li>
|
||||
<li>Let <code>bottomRight[r][c]</code> be the number of <strong>distinct</strong> values in the bottom-right diagonal of the cell <code>(r, c)</code> in the matrix <code>grid</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p>Then <code>answer[r][c] = |topLeft[r][c] - bottomRight[r][c]|</code>.</p>
|
||||
|
||||
<p>Return <em>the matrix</em> <code>answer</code>.</p>
|
||||
|
||||
<p>A <strong>matrix diagonal</strong> is a diagonal line of cells starting from some cell in either the topmost row or leftmost column and going in the bottom-right direction until reaching the matrix's end.</p>
|
||||
|
||||
<p>A cell <code>(r<sub>1</sub>, c<sub>1</sub>)</code> belongs to the top-left diagonal of the cell <code>(r, c)</code>, if both belong to the same diagonal and <code>r<sub>1</sub> < r</code>. Similarly is defined bottom-right diagonal.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
<img alt="" src="https://assets.leetcode.com/uploads/2023/04/19/ex2.png" style="width: 786px; height: 121px;" />
|
||||
<pre>
|
||||
<strong>
|
||||
Input:</strong> grid = [[1,2,3],[3,1,5],[3,2,1]]
|
||||
<strong>Output:</strong> [[1,1,0],[1,0,1],[0,1,1]]
|
||||
<strong>Explanation:</strong> The 1<sup>st</sup> diagram denotes the initial grid.
|
||||
The 2<sup>nd</sup> diagram denotes a grid for cell (0,0), where blue-colored cells are cells on its bottom-right diagonal.
|
||||
The 3<sup>rd</sup> diagram denotes a grid for cell (1,2), where red-colored cells are cells on its top-left diagonal.
|
||||
The 4<sup>th</sup> diagram denotes a grid for cell (1,1), where blue-colored cells are cells on its bottom-right diagonal and red-colored cells are cells on its top-left diagonal.
|
||||
- The cell (0,0) contains [1,1] on its bottom-right diagonal and [] on its top-left diagonal. The answer is |1 - 0| = 1.
|
||||
- The cell (1,2) contains [] on its bottom-right diagonal and [2] on its top-left diagonal. The answer is |0 - 1| = 1.
|
||||
- The cell (1,1) contains [1] on its bottom-right diagonal and [1] on its top-left diagonal. The answer is |1 - 1| = 0.
|
||||
The answers of other cells are similarly calculated.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> grid = [[1]]
|
||||
<strong>Output:</strong> [[0]]
|
||||
<strong>Explanation:</strong> - The cell (0,0) contains [] on its bottom-right diagonal and [] on its top-left diagonal. The answer is |0 - 0| = 0.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == grid.length</code></li>
|
||||
<li><code>n == grid[i].length</code></li>
|
||||
<li><code>1 <= m, n, grid[i][j] <= 50</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,40 @@
|
||||
<p>You are given a <strong>0-indexed</strong> integer array <code>nums</code>, and you are allowed to <strong>traverse</strong> between its indices. You can traverse between index <code>i</code> and index <code>j</code>, <code>i != j</code>, if and only if <code>gcd(nums[i], nums[j]) > 1</code>, where <code>gcd</code> is the <strong>greatest common divisor</strong>.</p>
|
||||
|
||||
<p>Your task is to determine if for <strong>every pair</strong> of indices <code>i</code> and <code>j</code> in nums, where <code>i < j</code>, there exists a <strong>sequence of traversals</strong> that can take us from <code>i</code> to <code>j</code>.</p>
|
||||
|
||||
<p>Return <code>true</code><em> if it is possible to traverse between all such pairs of indices,</em><em> or </em><code>false</code><em> otherwise.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [2,3,6]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> In this example, there are 3 possible pairs of indices: (0, 1), (0, 2), and (1, 2).
|
||||
To go from index 0 to index 1, we can use the sequence of traversals 0 -> 2 -> 1, where we move from index 0 to index 2 because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1, and then move from index 2 to index 1 because gcd(nums[2], nums[1]) = gcd(6, 3) = 3 > 1.
|
||||
To go from index 0 to index 2, we can just go directly because gcd(nums[0], nums[2]) = gcd(2, 6) = 2 > 1. Likewise, to go from index 1 to index 2, we can just go directly because gcd(nums[1], nums[2]) = gcd(3, 6) = 3 > 1.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [3,9,5]
|
||||
<strong>Output:</strong> false
|
||||
<strong>Explanation:</strong> No sequence of traversals can take us from index 0 to index 2 in this example. So, we return false.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> nums = [4,3,12,8]
|
||||
<strong>Output:</strong> true
|
||||
<strong>Explanation:</strong> There are 6 possible pairs of indices to traverse between: (0, 1), (0, 2), (0, 3), (1, 2), (1, 3), and (2, 3). A valid sequence of traversals exists for each pair, so we return true.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= nums.length <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= nums[i] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,41 @@
|
||||
<p>Given a positive integer <code>n</code>, return <em>the <strong>punishment number</strong></em> of <code>n</code>.</p>
|
||||
|
||||
<p>The <strong>punishment number</strong> of <code>n</code> is defined as the sum of the squares of all integers <code>i</code> such that:</p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= i <= n</code></li>
|
||||
<li>The decimal representation of <code>i * i</code> can be partitioned into contiguous substrings such that the sum of the integer values of these substrings equals <code>i</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 10
|
||||
<strong>Output:</strong> 182
|
||||
<strong>Explanation:</strong> There are exactly 3 integers i that satisfy the conditions in the statement:
|
||||
- 1 since 1 * 1 = 1
|
||||
- 9 since 9 * 9 = 81 and 81 can be partitioned into 8 + 1.
|
||||
- 10 since 10 * 10 = 100 and 100 can be partitioned into 10 + 0.
|
||||
Hence, the punishment number of 10 is 1 + 81 + 100 = 182
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> n = 37
|
||||
<strong>Output:</strong> 1478
|
||||
<strong>Explanation:</strong> There are exactly 4 integers i that satisfy the conditions in the statement:
|
||||
- 1 since 1 * 1 = 1.
|
||||
- 9 since 9 * 9 = 81 and 81 can be partitioned into 8 + 1.
|
||||
- 10 since 10 * 10 = 100 and 100 can be partitioned into 10 + 0.
|
||||
- 36 since 36 * 36 = 1296 and 1296 can be partitioned into 1 + 29 + 6.
|
||||
Hence, the punishment number of 37 is 1 + 81 + 100 + 1296 = 1478
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= n <= 1000</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>Write a function <code>expect</code> that helps developers test their code. It should take in any value <code>val</code> and return an object with the following two functions.</p>
|
||||
|
||||
<ul>
|
||||
<li><code>toBe(val)</code> accepts another value and returns <code>true</code> if the two values <code>===</code> each other. If they are not equal, it should throw an error <code>"Not Equal"</code>.</li>
|
||||
<li><code>notToBe(val)</code> accepts another value and returns <code>true</code> if the two values <code>!==</code> each other. If they are equal, it should throw an error <code>"Equal"</code>.</li>
|
||||
</ul>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> func = () => expect(5).toBe(5)
|
||||
<strong>Output:</strong> {"value": true}
|
||||
<strong>Explanation:</strong> 5 === 5 so this expression returns true.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> func = () => expect(5).toBe(null)
|
||||
<strong>Output:</strong> {"error": "Not Equal"}
|
||||
<strong>Explanation:</strong> 5 !== null so this expression throw the error "Not Equal".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> func = () => expect(5).notToBe(null)
|
||||
<strong>Output:</strong> {"value": true}
|
||||
<strong>Explanation:</strong> 5 !== null so this expression returns true.
|
||||
</pre>
|
||||
@@ -0,0 +1,49 @@
|
||||
<p>Given a <strong>1-indexed</strong> <code>m x n</code> integer matrix <code>mat</code>, you can select any cell in the matrix as your <strong>starting cell</strong>.</p>
|
||||
|
||||
<p>From the starting cell, you can move to any other cell <strong>in the</strong> <strong>same row or column</strong>, but only if the value of the destination cell is <strong>strictly greater</strong> than the value of the current cell. You can repeat this process as many times as possible, moving from cell to cell until you can no longer make any moves.</p>
|
||||
|
||||
<p>Your task is to find the <strong>maximum number of cells</strong> that you can visit in the matrix by starting from some cell.</p>
|
||||
|
||||
<p>Return <em>an integer denoting the maximum number of cells that can be visited.</em></p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/23/diag1drawio.png" style="width: 200px; height: 176px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[3,1],[3,4]]
|
||||
<strong>Output:</strong> 2
|
||||
<strong>Explanation:</strong> The image shows how we can visit 2 cells starting from row 1, column 2. It can be shown that we cannot visit more than 2 cells no matter where we start from, so the answer is 2.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/23/diag3drawio.png" style="width: 200px; height: 176px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[1,1],[1,1]]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong> Since the cells must be strictly increasing, we can only visit one cell in this example.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2023/04/23/diag4drawio.png" style="width: 350px; height: 250px;" /></strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> mat = [[3,1,6],[-9,5,7]]
|
||||
<strong>Output:</strong> 4
|
||||
<strong>Explanation:</strong> The image above shows how we can visit 4 cells starting from row 2, column 1. It can be shown that we cannot visit more than 4 cells no matter where we start from, so the answer is 4.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>m == mat.length </code></li>
|
||||
<li><code>n == mat[i].length </code></li>
|
||||
<li><code>1 <= m, n <= 10<sup>5</sup></code></li>
|
||||
<li><code>1 <= m * n <= 10<sup>5</sup></code></li>
|
||||
<li><code>-10<sup>5</sup> <= mat[i][j] <= 10<sup>5</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,27 @@
|
||||
<p>Given a <strong>positive</strong> integer <code>num</code> represented as a string, return <em>the integer </em><code>num</code><em> without trailing zeros as a string</em>.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "51230100"
|
||||
<strong>Output:</strong> "512301"
|
||||
<strong>Explanation:</strong> Integer "51230100" has 2 trailing zeros, we remove them and return integer "512301".
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> num = "123"
|
||||
<strong>Output:</strong> "123"
|
||||
<strong>Explanation:</strong> Integer "123" has no trailing zeros, we return integer "123".
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>1 <= num.length <= 1000</code></li>
|
||||
<li><code>num</code> consists of only digits.</li>
|
||||
<li><code>num</code> doesn't have any leading zeros.</li>
|
||||
</ul>
|
||||
@@ -0,0 +1,35 @@
|
||||
<p>Given an object or array <code>obj</code>, return a <strong>compact object</strong>. A <strong>compact object</strong> is the same as the original object, except with keys containing <strong>falsy</strong> values removed. This operation applies to the object and any nested objects. Arrays are considered objects where the indices are keys. A value is considered <strong>falsy</strong> when <code>Boolean(value)</code> returns <code>false</code>.</p>
|
||||
|
||||
<p>You may assume the <code>obj</code> is the output of <code>JSON.parse</code>. In other words, it is valid JSON.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> obj = [null, 0, false, 1]
|
||||
<strong>Output:</strong> [1]
|
||||
<strong>Explanation:</strong> All falsy values have been removed from the array.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> obj = {"a": null, "b": [false, 1]}
|
||||
<strong>Output:</strong> {"b": [1]}
|
||||
<strong>Explanation:</strong> obj["a"] and obj["b"][0] had falsy values and were removed.</pre>
|
||||
|
||||
<p><strong class="example">Example 3:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> obj = [null, 0, 5, [0], [false, 16]]
|
||||
<strong>Output:</strong> [5, [], [16]]
|
||||
<strong>Explanation:</strong> obj[0], obj[1], obj[3][0], and obj[4][0] were falsy and removed.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>obj is a valid JSON object</code></li>
|
||||
<li><code>2 <= JSON.stringify(obj).length <= 10<sup>6</sup></code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
<p>You are given an integer array <code>prices</code> representing the prices of various chocolates in a store. You are also given a single integer <code>money</code>, which represents your initial amount of money.</p>
|
||||
|
||||
<p>You must buy <strong>exactly</strong> two chocolates in such a way that you still have some <strong>non-negative</strong> leftover money. You would like to minimize the sum of the prices of the two chocolates you buy.</p>
|
||||
|
||||
<p>Return <em>the amount of money you will have leftover after buying the two chocolates</em>. If there is no way for you to buy two chocolates without ending up in debt, return <code>money</code>. Note that the leftover must be non-negative.</p>
|
||||
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [1,2,2], money = 3
|
||||
<strong>Output:</strong> 0
|
||||
<strong>Explanation:</strong> Purchase the chocolates priced at 1 and 2 units respectively. You will have 3 - 3 = 0 units of money afterwards. Thus, we return 0.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> prices = [3,2,3], money = 3
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong> You cannot buy 2 chocolates without going in debt, so we return 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>2 <= prices.length <= 50</code></li>
|
||||
<li><code>1 <= prices[i] <= 100</code></li>
|
||||
<li><code>1 <= money <= 100</code></li>
|
||||
</ul>
|
||||
@@ -0,0 +1,31 @@
|
||||
Write a function <code>argumentsLength</code> that returns the count of arguments passed to it.
|
||||
<p> </p>
|
||||
<p><strong class="example">Example 1:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> argsArr = [5]
|
||||
<strong>Output:</strong> 1
|
||||
<strong>Explanation:</strong>
|
||||
argumentsLength(5); // 1
|
||||
|
||||
One value was passed to the function so it should return 1.
|
||||
</pre>
|
||||
|
||||
<p><strong class="example">Example 2:</strong></p>
|
||||
|
||||
<pre>
|
||||
<strong>Input:</strong> argsArr = [{}, null, "3"]
|
||||
<strong>Output:</strong> 3
|
||||
<strong>Explanation:</strong>
|
||||
argumentsLength({}, null, "3"); // 3
|
||||
|
||||
Three values were passed to the function so it should return 3.
|
||||
</pre>
|
||||
|
||||
<p> </p>
|
||||
<p><strong>Constraints:</strong></p>
|
||||
|
||||
<ul>
|
||||
<li><code>argsArr is a valid JSON array</code></li>
|
||||
<li><code>0 <= argsArr.length <= 100</code></li>
|
||||
</ul>
|
||||
Reference in New Issue
Block a user