Added tasks 191-219

Author: javadev

LeetCodeNet/G0101_0200/S0133_clone_graph/readme.md

@@ -95,27 +95,31 @@ public class Node {
 
     public override string ToString() {
         var result = new System.Text.StringBuilder();
-        result.Append("[");
+        result.Append('[');
         bool first = true;
         foreach (var node in neighbors) {
-            if (!first) result.Append(",");
+            if (!first) {
+                result.Append(',');
+            }
             if (node.neighbors == null || node.neighbors.Count == 0) {
                 result.Append(node.val);
             } else {
                 var inner = new System.Text.StringBuilder();
-                inner.Append("[");
+                inner.Append('[');
                 bool innerFirst = true;
                 foreach (var nodeItem in node.neighbors) {
-                    if (!innerFirst) inner.Append(",");
+                    if (!innerFirst) {
+                        inner.Append(',');
+                    }
                     inner.Append(nodeItem.val);
                     innerFirst = false;
                 }
-                inner.Append("]");
+                inner.Append(']');
                 result.Append(inner.ToString());
             }
             first = false;
         }
-        result.Append("]");
+        result.Append(']');
         return result.ToString();
     }
 }

LeetCodeNet/G0101_0200/S0191_number_of_1_bits/readme.md

@@ -0,0 +1,64 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 191\. Number of 1 Bits
+
+Easy
+
+Write a function that takes an unsigned integer and returns the number of '1' bits it has (also known as the [Hamming weight](http://en.wikipedia.org/wiki/Hamming_weight)).
+
+**Note:**
+
+*   Note that in some languages, such as Java, there is no unsigned integer type. In this case, the input will be given as a signed integer type. It should not affect your implementation, as the integer's internal binary representation is the same, whether it is signed or unsigned.
+*   In Java, the compiler represents the signed integers using [2's complement notation](https://en.wikipedia.org/wiki/Two%27s_complement). Therefore, in **Example 3**, the input represents the signed integer. `-3`.
+
+**Example 1:**
+
+**Input:** n = 00000000000000000000000000001011
+
+**Output:** 3
+
+**Explanation:** The input binary string **00000000000000000000000000001011** has a total of three '1' bits. 
+
+**Example 2:**
+
+**Input:** n = 00000000000000000000000010000000
+
+**Output:** 1
+
+**Explanation:** The input binary string **00000000000000000000000010000000** has a total of one '1' bit. 
+
+**Example 3:**
+
+**Input:** n = 11111111111111111111111111111101
+
+**Output:** 31
+
+**Explanation:** The input binary string **11111111111111111111111111111101** has a total of thirty one '1' bits. 
+
+**Constraints:**
+
+*   The input must be a **binary string** of length `32`.
+
+**Follow up:** If this function is called many times, how would you optimize it?
+
+## Solution
+
+```csharp
+public class Solution {
+    public int HammingWeight(int n) {
+        int sum = 0;
+        bool flag = false;
+        if (n < 0) {
+            flag = true;
+            n = n - int.MinValue;
+        }
+        while (n > 0) {
+            int k = n % 2;
+            sum += k;
+            n /= 2;
+        }
+        return flag ? sum + 1 : sum;
+    }
+}
+```

LeetCodeNet/G0101_0200/S0199_binary_tree_right_side_view/readme.md

@@ -0,0 +1,71 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 199\. Binary Tree Right Side View
+
+Medium
+
+Given the `root` of a binary tree, imagine yourself standing on the **right side** of it, return _the values of the nodes you can see ordered from top to bottom_.
+
+**Example 1:**
+
+![](https://assets.leetcode.com/uploads/2021/02/14/tree.jpg)
+
+**Input:** root = [1,2,3,null,5,null,4]
+
+**Output:** [1,3,4] 
+
+**Example 2:**
+
+**Input:** root = [1,null,3]
+
+**Output:** [1,3] 
+
+**Example 3:**
+
+**Input:** root = []
+
+**Output:** [] 
+
+**Constraints:**
+
+*   The number of nodes in the tree is in the range `[0, 100]`.
+*   `-100 <= Node.val <= 100`
+
+## Solution
+
+```csharp
+using System.Collections.Generic;
+using LeetCodeNet.Com_github_leetcode;
+
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution {
+    public IList<int> RightSideView(TreeNode root) {
+        var list = new List<int>();
+        Recurse(root, 0, list);
+        return list;
+    }
+
+    private void Recurse(TreeNode node, int level, List<int> list) {
+        if (node != null) {
+            if (list.Count < level + 1) {
+                list.Add(node.val.Value);
+            }
+            Recurse(node.right, level + 1, list);
+            Recurse(node.left, level + 1, list);
+        }
+    }
+}
+```

LeetCodeNet/G0201_0300/S0201_bitwise_and_of_numbers_range/readme.md

@@ -0,0 +1,44 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 201\. Bitwise AND of Numbers Range
+
+Medium
+
+Given two integers `left` and `right` that represent the range `[left, right]`, return _the bitwise AND of all numbers in this range, inclusive_.
+
+**Example 1:**
+
+**Input:** left = 5, right = 7
+
+**Output:** 4 
+
+**Example 2:**
+
+**Input:** left = 0, right = 0
+
+**Output:** 0 
+
+**Example 3:**
+
+**Input:** left = 1, right = 2147483647
+
+**Output:** 0 
+
+**Constraints:**
+
+*   <code>0 <= left <= right <= 2<sup>31</sup> - 1</code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public int RangeBitwiseAnd(int left, int right) {
+        var shift = 0;
+        for (; left != right; left >>= 1, right >>= 1, shift++) { 
+
+        }
+        return left << shift;
+    }
+}
+```

LeetCodeNet/G0201_0300/S0202_happy_number/readme.md

@@ -0,0 +1,72 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 202\. Happy Number
+
+Easy
+
+Write an algorithm to determine if a number `n` is happy.
+
+A **happy number** is a number defined by the following process:
+
+*   Starting with any positive integer, replace the number by the sum of the squares of its digits.
+*   Repeat the process until the number equals 1 (where it will stay), or it **loops endlessly in a cycle** which does not include 1.
+*   Those numbers for which this process **ends in 1** are happy.
+
+Return `true` _if_ `n` _is a happy number, and_ `false` _if not_.
+
+**Example 1:**
+
+**Input:** n = 19
+
+**Output:** true
+
+**Explanation:**
+
+1<sup>2</sup> + 9<sup>2</sup> = 82
+
+8<sup>2</sup> + 2<sup>2</sup> = 68
+
+6<sup>2</sup> + 8<sup>2</sup> = 100
+
+1<sup>2</sup> + 0<sup>2</sup> + 0<sup>2</sup> = 1 
+
+**Example 2:**
+
+**Input:** n = 2
+
+**Output:** false 
+
+**Constraints:**
+
+*   <code>1 <= n <= 2<sup>31</sup> - 1</code>
+
+## Solution
+
+```csharp
+public class Solution {
+    public bool IsHappy(int n) {
+        bool happy;
+        int a = n;
+        int rem;
+        int sum = 0;
+        if (a == 1 || a == 7) {
+            happy = true;
+        } else if (a > 1 && a < 10) {
+            happy = false;
+        } else {
+            while (a != 0) {
+                rem = a % 10;
+                sum = sum + (rem * rem);
+                a = a / 10;
+            }
+            if (sum != 1) {
+                happy = IsHappy(sum);
+            } else {
+                happy = true;
+            }
+        }
+        return happy;
+    }
+}
+```

LeetCodeNet/G0201_0300/S0205_isomorphic_strings/readme.md

@@ -0,0 +1,74 @@
+[![](https://img.shields.io/github/stars/LeetCode-in-Net/LeetCode-in-Net?label=Stars&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net)
+[![](https://img.shields.io/github/forks/LeetCode-in-Net/LeetCode-in-Net?label=Fork%20me%20on%20GitHub%20&style=flat-square)](https://github.com/LeetCode-in-Net/LeetCode-in-Net/fork)
+
+## 205\. Isomorphic Strings
+
+Easy
+
+Given two strings `s` and `t`, _determine if they are isomorphic_.
+
+Two strings `s` and `t` are isomorphic if the characters in `s` can be replaced to get `t`.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.
+
+**Example 1:**
+
+**Input:** s = "egg", t = "add"
+
+**Output:** true 
+
+**Example 2:**
+
+**Input:** s = "foo", t = "bar"
+
+**Output:** false 
+
+**Example 3:**
+
+**Input:** s = "paper", t = "title"
+
+**Output:** true 
+
+**Constraints:**
+
+*   <code>1 <= s.length <= 5 * 10<sup>4</sup></code>
+*   `t.length == s.length`
+*   `s` and `t` consist of any valid ascii character.
+
+## Solution
+
+```csharp
+public class Solution {
+    public bool IsIsomorphic(string s, string t) {
+        int[] map = new int[128];
+        char[] str = s.ToCharArray();
+        char[] tar = t.ToCharArray();
+        int n = str.Length;
+        for (int i = 0; i < n; i++) {
+            if (map[tar[i]] == 0) {
+                if (Search(map, str[i], tar[i]) != -1) {
+                    return false;
+                }
+                map[tar[i]] = str[i];
+            } else {
+                if (map[tar[i]] != str[i]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private int Search(int[] map, int tar, int skip) {
+        for (int i = 0; i < 128; i++) {
+            if (i == skip) {
+                continue;
+            }
+            if (map[i] != 0 && map[i] == tar) {
+                return i;
+            }
+        }
+        return -1;
+    }
+}
+```