feat:leetcode

Author: ayoubzulfiqar

Diff for: AddBinary/add_binary.dart

@@ -180,7 +180,7 @@ class E {
       b = temp;
     }
     var carry = '0';
-    int k = 0;
+    // int k = 0;
     int j = b.length - 1;
     for (int i = a.length - 1; i >= 0; i--) {
       if (j >= 0) {

Diff for: LongestPathWithDifferentAdjacentCharacters/longest_path_with_Different_adjacent_characters.dart

@@ -67,7 +67,7 @@ class A {
     return maxi;
   }
 
-  int iterate(Node root) {
+  int iterate(Node? root) {
     if (root == null) {
       return 0;
     }

Diff for: MaximumProductOfSplittedBinaryTree/maximum_product_of_splitted_binary_tree.dart

@@ -51,7 +51,7 @@ class A {
   int maxProd = 0;
   int maxProduct(TreeNode? root) {
     dfs(root);
-    int rootProd = checkMax(root);
+    // int rootProd = checkMax(root);
     return (maxProd % (pow(10, 9) + 7)).toInt();
   }
 

Diff for: MinimumTimeToMakeRopeColorful/minimum_time_to_make_rope_colorful.dart

@@ -53,12 +53,13 @@ class A {
     int sum = 0, maxSum = 0;
     for (int i = 0; i < colors.length; i++) {
       sum += neededTime[i];
-      int max = neededTime[i], count = 0;
+      int max = neededTime[i];
+      // int count = 0;
       for (int j = i + 1;
           j < colors.length && colors.codeUnitAt(i) == colors.codeUnitAt(j);
           j++) {
         sum += neededTime[j];
-        count++;
+        // count++;
         if (neededTime[j] > max) max = neededTime[j];
         i = j;
       }

Diff for: NumberOfGoodPaths/number_of_good_paths.dart

@@ -228,7 +228,7 @@ class C {
     }
 
     // traverse node values from lowest to highest
-    MapEntry<int, List<int>> curr = tm.entries.first;
+    MapEntry<int, List<int>>? curr = tm.entries.first;
     while (curr != null) {
       List<int> listNodes = curr.value;
 

Diff for: TheSkylineProblem/the_skyline_problem.dart

@@ -48,7 +48,7 @@ import 'dart:math';
 
 class A {
   List<List<int>> getSkyline(List<List<int>> buildings) {
-    int n = buildings.length;
+    // int n = buildings.length;
     List<int> keys = [];
     for (List<int> building in buildings) {
       keys.add(building[0]);

Diff for: TopKFrequentElements/top_k_frequent_elements.dart

@@ -0,0 +1,30 @@
+/*
+
+*/
+
+import 'dart:collection';
+
+class A {
+  List<int> topKFrequent(List<int> words, int k) {
+    final HashMap<int, int> hashMap = HashMap<int, int>();
+
+    for (final int word in words) {
+      if (hashMap[word] == null) {
+        hashMap[word] = 1;
+      } else {
+        hashMap[word] = hashMap[word]! + 1;
+      }
+    }
+
+    final List<MapEntry<int, int>> sortedHashMap =
+        hashMap.entries.toList(growable: true)
+          ..sort((a, b) {
+            if (a.value.compareTo(b.value) == 0) {
+              return a.key.compareTo(b.key);
+            }
+            return b.value.compareTo(a.value);
+          });
+
+    return sortedHashMap.sublist(0, k).map((e) => e.key).toList();
+  }
+}

Diff for: TopKFrequentElements/top_k_frequent_elements.go

@@ -0,0 +1,56 @@
+package main
+
+import "container/heap"
+
+type Word struct {
+	word      int
+	frequency int
+}
+
+func newWord(word int, frequency int) *Word {
+	return &Word{word: word, frequency: frequency}
+}
+
+type H struct {
+	items []*Word
+}
+
+func (h *H) Len() int { return len(h.items) }
+
+func (h *H) Less(i, j int) bool {
+	if h.items[i].frequency != h.items[j].frequency {
+		return h.items[i].frequency < h.items[j].frequency
+	}
+	return h.items[i].word > h.items[j].word
+}
+
+func (h *H) Swap(i, j int) { h.items[i], h.items[j] = h.items[j], h.items[i] }
+
+func (h *H) Push(i interface{}) { h.items = append(h.items, i.(*Word)) }
+
+func (h *H) Pop() interface{} {
+	n := len(h.items)
+	item := h.items[n-1]
+	h.items = h.items[:n-1]
+	return item
+}
+
+func topKFrequent(words []int, k int) []int {
+	counts := map[int]int{}
+	h := &H{}
+	for _, v := range words {
+		counts[v]++
+
+	}
+	for key, v := range counts {
+		heap.Push(h, newWord(key, v))
+		if h.Len() > k {
+			heap.Pop(h)
+		}
+	}
+	result := []int{}
+	for h.Len() > 0 {
+		result = append([]int{heap.Pop(h).(*Word).word}, result...)
+	}
+	return result
+}

Diff for: TopKFrequentElements/top_k_frequent_elements.md

@@ -39,7 +39,7 @@ class A {
   List<String> topKFrequent(List<String> words, int k) {
     final hashMap = <String, int>{};
 
-    for (final word in words) {
+    for (final String word in words) {
       if (hashMap[word] == null) {
         hashMap[word] = 1;
       } else {

Diff for: TopKFrequentWords/top_k_frequent_words.dart

@@ -45,34 +45,6 @@ Follow-up: Can you come up with an algorithm that is less than O(n2) time comple
 
  */
 
-void main() {
-  final solution = Solution();
-
-  List<int> a = <int>[2, 3, 4];
-  int target = 5;
-
-  final s = solution.twoSum(a, target);
-//  print(s);
-
-// when you print it will show the position of two value
-//their sum will be equal to the target value
-  // print(s);
-
-  // SOLUTION - 2
-
-  final solutions = AlgorithmicSolution();
-  final ss = solutions.solution(a, target);
-  // print(ss);
-
-  final b = A();
-  final ba = b.twoSum(a, target);
-  // print(ba);
-
-  final c = B();
-  final ca = c.twoSum(a, target);
-  print(ca);
-}
-
 /**
  *
  * SOLUTION
@@ -153,18 +125,18 @@ class A {
 // Working perfect in Terminal
 // but runtime error inclusive range error
 
-  List<int> twoSum(List<int> nums, int target) {
-    List<int> result = <int>[];
-    for (var i = 0; i < nums.length; i++) {
-      int complement = target - nums[i];
-      var index = nums.indexOf(complement, i + 1);
-      if (nums[index] + nums[i] == target) {
-        return result = [i, index];
-      }
-      break;
-    }
-    return result;
-  }
+  // List<int> twoSum(List<int> nums, int target) {
+  //   List<int> result = <int>[];
+  //   for (int i = 0; i < nums.length; i++) {
+  //     int complement = target - nums[i];
+  //     var index = nums.indexOf(complement, i + 1);
+  //     if (nums[index] + nums[i] == target) {
+  //       return result = [i, index];
+  //     }
+  //     break;
+  //   }
+  //   return result;
+  // }
 }
 
 class B {
@@ -194,7 +166,6 @@ class B {
       correspondence[value] = i;
 
       // Remember = correspondence[missing] is Our key , correspondence[value] is Our Value
-
     }
     return [];
   }