Write-up for LeetCode problem 2727. Is Object Empty (#400)

Author: miorel

workspaces/javascript-leetcode-month/README.md

@@ -4,8 +4,8 @@ This directory contains the resources for the month of JavaScript on LeetCode, a
 
 ## Problem Order
 
-1. [2703. Return Length of Arguments Passed](https://leetcode.com/problems/return-length-of-arguments-passed/)
-2. [2727. Is Object Empty](https://leetcode.com/problems/is-object-empty/)
+1. [2703. Return Length of Arguments Passed](problems/2703-return-length-of-arguments-passed/)
+2. [2727. Is Object Empty](problems/2727-is-object-empty/)
 3. [2677. Chunk Array](https://leetcode.com/problems/chunk-array/)
 4. [2635. Apply Transform Over Each Element in Array](https://leetcode.com/problems/apply-transform-over-each-element-in-array/)
 5. [2634. Filter Elements from Array](https://leetcode.com/problems/filter-elements-from-array/)

workspaces/javascript-leetcode-month/problems/2703-return-length-of-arguments-passed/solution.md

@@ -1,9 +1,9 @@
 # 2703. Return Length of Arguments Passed
 
-[View Problem on LeetCode](https://leetcode.com/problems/return-length-of-arguments-passed/)
+[View this Write-up on LeetCode](https://leetcode.com/problems/return-length-of-arguments-passed/solutions/5722508/content/) | [View Problem on LeetCode](https://leetcode.com/problems/return-length-of-arguments-passed/)
 
 > [!WARNING]
-> This page includes spoilers. For a spoiler-free introduction to the problem, see the [README](README.md) file.
+> This page includes spoilers. For a spoiler-free introduction to the problem, see [the README file](README.md).
 
 ## Summary
 
@@ -114,7 +114,10 @@ We can also define new types, for example:
 type StringOrNumber = string | number;
 ```
 
-LeetCode's TypeScript template for this problem is unnecessarily complicated. It declares our rest parameter as an array of JSON values, and it defines a recursive type to express this! While this is interesting to illustrate the power of TypeScript, for this problem we don't care what arguments we get, we just care how many we get. Therefore I think it's sufficient to declare the arguments as being of type [`unknown`](https://www.typescriptlang.org/docs/handbook/2/functions.html#unknown). This is the safe way to say that we don't know the type. TypeScript will require us to test the type of the value before doing anything with it. In many LeetCode problems you will see `any`, which is the _unsafe_ way of saying we don't know the type. Unlike `unknown`, `any` allows us to do _anything_ with the value. It bypasses the typechecker for that section of code, and if we're not careful it can even leak to code that interacts with that section of code. It's best to avoid `any` as much as possible.
+LeetCode's TypeScript template for this problem is unnecessarily complicated. It declares our rest parameter as an array of JSON values, and it defines a recursive type to express this! While this is interesting to illustrate the power of TypeScript, for this problem we don't care what arguments we get, we just care how many we get. Therefore I think it's sufficient to declare the arguments as being of type [`unknown`](https://www.typescriptlang.org/docs/handbook/2/functions.html#unknown). This is the safe way to say that we don't know the type. TypeScript will require us to test the type of the value before doing anything with it.
+
+> [!WARNING]  
+> In many LeetCode problems you will see `any`, which is the _unsafe_ way of saying we don't know the type. Unlike `unknown`, `any` allows us to do _anything_ with the value. It bypasses the typechecker for that section of code, and if we're not careful it can even leak to code that interacts with that section of code. It's best to avoid `any` as much as possible.
 
 We can additionally mark array arguments as [`readonly`](https://www.typescriptlang.org/docs/handbook/typescript-in-5-minutes-func.html#readonly-and-const) when we don't intend to mutate them, as you'll see below.
 
@@ -312,3 +315,6 @@ const argumentsLength = function (..._args: readonly unknown[]): number {
    console.log(enclosing("a", "b", "c")); // prints 3
    console.log(enclosing("a", "b")); // prints 2
    ```
+
+> [!TIP]  
+> Thanks for reading! If you enjoyed this write-up, feel free to [up-vote it on LeetCode](https://leetcode.com/problems/return-length-of-arguments-passed/solutions/5722508/)! 🙏

workspaces/javascript-leetcode-month/problems/2727-is-object-empty/README.md

@@ -0,0 +1,13 @@
+# 2727. Is Object Empty
+
+[View Problem on LeetCode](https://leetcode.com/problems/is-object-empty/)
+
+Checking the length of an array is [straightforward](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/length), but less so for an arbitrary object. However, perhaps there's a way to turn the object into an array of key-value pairs? Looking up how to do so will reveal one possible solution strategy.
+
+The problem statement also mentions [`JSON.parse`](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse), a function that parses a string into JSON data. What's the opposite of `JSON.parse`? If we could find a function that turns data into strings, it would probably be fairly clear from the resulting string if the original object was empty.
+
+Both of the above strategies have one flaw, however. For a large object, turning it into an array or into a string will have linear time and space complexities. If you're an advanced JavaScript user, try to think of a solution that has constant complexities.
+
+It will also probably be helpful to be able to check if a value is an array or an object. [The `typeof` operator](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof) seems tempting, but unfortunately it won't work, because an array is still an object, so `typeof` on an array returns `"object"`. However, there is another function that does what we need. Search for it.
+
+Once you've worked on the problem, check out [the full write-up and solution](solution.md)!