feat: problem 08

Author: All3yp

Daily_Coding_Problem-07.cpp

@@ -77,6 +77,6 @@ class SolutionLeetcode {
                 // converte os dois caracteres para inteiro e verifica se é menor ou igual a 26, se for, soma o elemento atual com o 
                 // elemento seguinte e o elemento atual com o elemento seguinte + 1, senão, soma o elemento atual com o elemento seguinte, ex: 111 = 3 (aaa, ka, ak)
         }
-        return dp[0];  // retorna o primeiro elemento do vetor para saber a quantidade de combinações possiveis de decodificação ex: 111 = 3 (aaa, ka, ak)
+        return dp[0];  // retorna o primeiro elemento do vetor para saber a quantidade de combinações possiveis de decodificação ex: 111 = 3 (aaa, ka, ak) 
     }
 };

Daily_Coding_Problem-08.cpp

@@ -0,0 +1,54 @@
+#include "Daily_Coding_Problem.h"
+
+/* MARK: - SOLUTION ✨ */
+
+// Cria uma Tree Node  (https://www.geeksforgeeks.org/binary-tree-set-1-introduction/)
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+};
+
+class Solution {
+    public:
+        int count = 0; // contador de possibilidades
+        bool isUnivalTree(TreeNode* root) { // função que verifica se a árvore é unival
+            if (root == NULL) return true; // se a raiz for nula, retorna true
+            if (root->left == NULL && root->right == NULL) { // se a raiz não for nula, mas os filhos forem nulos, retorna true
+                count++; // incrementa o contador
+                return true; // retorna true se a raiz não for nula e os filhos forem nulos
+            }
+            bool left = isUnivalTree(root->left); // chama a função isUnivalTree para o filho da esquerda
+            bool right = isUnivalTree(root->right); // chama a função isUnivalTree para o filho da direita
+            if (left && right) { // se os filhos forem unival
+                if (root->left != NULL && root->val != root->left->val) return false; // se o filho da esquerda não for nulo e o valor da raiz for diferente do valor do filho da esquerda, retorna false
+                if (root->right != NULL && root->val != root->right->val) return false; // se o filho da direita não for nulo e o valor da raiz for diferente do valor do filho da direita, retorna false
+                count++; // incrementa o contador
+                return true; // retorna true se os filhos forem unival
+            }
+            return false; // retorna false se os filhos não forem unival
+        }
+    private:
+        bool isUnivalTree(TreeNode* root, int val) {
+            if (root == NULL) return true;
+            if (root->val == val) { // se o valor da raiz for igual ao valor passado
+                return isUnivalTree(root->left, val) && isUnivalTree(root->right, val); // se o valor da raiz for igual ao valor passado, chama a função isUnivalTree para o filho da esquerda e para o filho da direita
+            }
+            return false;
+        }
+};
+
+int main()
+{
+    Solution solution;
+    TreeNode* root = new TreeNode(0);
+    root->left = new TreeNode(1);
+    root->right = new TreeNode(0);
+    root->right->left = new TreeNode(1);
+    root->right->right = new TreeNode(0);
+    root->right->left->left = new TreeNode(1);
+    root->right->left->right = new TreeNode(1);
+    solution.isUnivalTree(root);
+    std::cout << "Number of unival subtrees: " << solution.count << std::endl;
+}

Readme.md

@@ -14,7 +14,7 @@ For example, given `[10, 15, 3, 7]` and `k` of `17`, return true since `10 + 7`
 
 Bonus: Can you do this in one pass?
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-01.cpp)
+[Solution 🎉](Daily_Coding_Problem-01.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/two-sum/) to visit this question on [*LeetCode*](https://leetcode.com/).
 ---
 
@@ -32,7 +32,7 @@ the expected output would be `[2, 3, 6]`.
 
 Follow-up: what if you can't use division?
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-02.cpp)
+[Solution 🎉](Daily_Coding_Problem-02.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/product-of-array-except-self/) to visit this question on [*LeetCode*](https://leetcode.com/).
 ---
 
@@ -64,7 +64,7 @@ const node = new TreeNode(
 expect(deserialize(serialize(node)).left.left.val).toEqual('left.left');
 ```
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-03.cpp)
+[Solution 🎉](Daily_Coding_Problem-03.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/serialize-and-deserialize-bst/) to visit this question on [*LeetCode*](https://leetcode.com/).
 ---
 
@@ -78,7 +78,7 @@ For example, the input `[3, 4, -1, 1]` should give 2. The input `[1, 2, 0]` shou
 
 You can modify the input array in-place.
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-04.cpp)
+[Solution 🎉](Daily_Coding_Problem-04.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/first-missing-positive/) to visit a similar question on [*LeetCode*](https://leetcode.com/).
 ---
 
@@ -101,7 +101,7 @@ function cons(a, b) {
 
 Implement car and cdr.
 
-[🎉 Solution C++](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-05.cpp)</br>
+[🎉 Solution C++](Daily_Coding_Problem-05.cpp)</br>
 [🎉 Solution Swift](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_problem-05.swift)
 #### Click [__*here*__](https://leetcode.com/problems/number-of-good-pairs/) to visit a similar question on [*LeetCode*](https://leetcode.com/).
 
@@ -115,7 +115,7 @@ An XOR linked list is a more memory efficient doubly linked list. Instead of eac
 
 If using a language that has no pointers (such as Python), you can assume you have access to `get_pointer` and `dereference_pointer` functions that converts between nodes and memory addresses.
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-06.cpp)
+[Solution 🎉](Daily_Coding_Problem-06.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/maximum-xor-of-two-numbers-in-an-array/) to visit a similar question on [*LeetCode*](https://leetcode.com/).
 
 ---
@@ -128,7 +128,31 @@ Given the mapping `a = 1, b = 2, ... z = 26`, and an encoded message, count the
 For example, the message `'111'` would give 3, since it could be decoded as `'aaa'`, `'ka'`, and `'ak'`.
 You can assume that the messages are decodable. For example, `'001'` is not allowed.
 
-[Solution 🎉](https://github.com/All3yp/Daily-Coding-problems/blob/main/Daily_Coding_Problem-07.cpp)
+[Solution 🎉](Daily_Coding_Problem-07.cpp)
 #### Click [__*here*__](https://leetcode.com/problems/decode-ways/) to visit this question on [*LeetCode*](https://leetcode.com/).
 
 ---
+
+## 🚀 Problem 8 [Easy]
+
+####  This problem was asked by Google.
+
+A unival tree (which stands for "universal value") is a tree where all nodes under it have the same value.
+Given the root to a binary tree, count the number of unival subtrees.
+For example, the following tree has 5 unival subtrees:
+
+```
+   0
+  / \
+ 1   0
+    / \
+   1   0
+  / \
+ 1   1
+```
+
+[Solution 🎉](Daily_Coding_Problem-08.cpp)
+
+<!-- #### Click [__*here*__]() to visit this question on [*LeetCode*](https://leetcode.com/). -->
+
+---