leetcode

Author: ayoubzulfiqar

README.md

@@ -151,6 +151,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [**446.** Arithmetic Slices II - Subsequence](ArithmeticSlicesII-Subsequence/arithmetic_slices_II_subsequence.dart)
 - [**2225.** Find Players With Zero or One Losses](FindPlayersWithZeroOrOneLosses/find_players_with_zero_or_one_losses.dart)
 - [**380.** Insert Delete GetRandom O(1)](InsertDeleteGetRandom-01/insert_delete_getrandom_O1.dart)
+- [**1207.** Unique Number of Occurrences](UniqueNumberOfOccurrences/unique_number_of_occurrences.dart)
 
 ## Reach me via
 

UniqueNumberOfOccurrences/unique_number_of_occurrences.dart

@@ -0,0 +1,103 @@
+/*
+
+
+-* 1207. Unique Number of Occurrences *-
+
+
+Given an array of integers arr, return true if the number of occurrences of each value in the array is unique, or false otherwise.
+
+ 
+
+Example 1:
+
+Input: arr = [1,2,2,1,1,3]
+Output: true
+Explanation: The value 1 has 3 occurrences, 2 has 2 and 3 has 1. No two values have the same number of occurrences.
+Example 2:
+
+Input: arr = [1,2]
+Output: false
+Example 3:
+
+Input: arr = [-3,0,1,-3,1,1,1,-3,10,0]
+Output: true
+ 
+
+Constraints:
+
+1 <= arr.length <= 1000
+-1000 <= arr[i] <= 1000
+
+
+*/
+
+import 'dart:collection';
+
+class A {
+  bool uniqueOccurrences(List<int> arr) {
+    // hashmap to store all values of the array as key value pair
+    HashMap<int, int> map = HashMap();
+    // for all value inside our array
+    for (int number in arr) {
+      // we will add value of array as key and value + 1
+      map[number] = (map[number] ?? 0) + 1;
+    }
+    // hashSet to see the unique values
+    HashSet<int> hashSet = HashSet();
+// we will add all the values inside the set
+    hashSet.addAll(map.values);
+    // if the length of the unique set is same as the length of the map than true else false
+    return hashSet.length == map.length;
+  }
+}
+
+class B {
+  bool uniqueOccurrences(List<int> arr) {
+    arr.sort();
+    HashSet<int> unique = HashSet();
+
+    int c = 1;
+    for (int i = 1; i < arr.length; i++) {
+      if (arr[i] == arr[i - 1])
+        c++;
+      else {
+        if (unique.contains(c)) return false;
+
+        unique.add(c);
+
+        c = 1;
+      }
+    }
+
+    if (unique.contains(c)) return false;
+
+    return true;
+  }
+}
+
+class C {
+  bool uniqueOccurrences(List<int> arr) {
+    HashMap<int, int> map = HashMap();
+
+    for (int i = 0; i < arr.length; i++) {
+      int ele = arr[i];
+      if (map.containsKey(ele)) {
+        map[ele] = (map[ele] ?? 0) + 1;
+      } else {
+        map[ele] = 1;
+      }
+    }
+
+    List<int> freq = List.filled(1000, 0); //Constraint given
+
+    for (MapEntry<int, int> e in map.entries) {
+      int n = e.value;
+      if (freq[n] != 0) {
+        return false;
+      }
+      freq[n]++;
+    }
+
+    return true;
+  }
+}

UniqueNumberOfOccurrences/unique_number_of_occurrences.go

@@ -0,0 +1,62 @@
+package main
+
+/*
+
+bool uniqueOccurrences(List<int> arr) {
+    HashMap<int, int> map = HashMap();
+
+    for (int i = 0; i < arr.length; i++) {
+      int ele = arr[i];
+      if (map.containsKey(ele)) {
+        map[ele] = (map[ele] ?? 0) + 1;
+      } else {
+        map[ele] = 1;
+      }
+    }
+
+    List<int> freq = List.filled(1000, 0); //Constraint given
+
+    for (MapEntry<int, int> e in map.entries) {
+      int n = e.value;
+      if (freq[n] != 0) {
+        return false;
+      }
+      freq[n]++;
+    }
+
+    return true;
+  }
+
+*/
+
+func uniqueOccurrences(arr []int) bool {
+	// hashmap to store our keys & values
+	var hashMap = make(map[int]int)
+	// looping through each and every element of the array
+	for i := 0; i < len(arr); i++ {
+		// individual element of the array
+		var element int = arr[i]
+		// if the hashmap have contain our key
+		if _, key := hashMap[element]; key {
+			// than we will assign the the value + 1
+			hashMap[element] = hashMap[element] + 1
+		} else {
+			// else it's just 1
+			hashMap[element] = 1
+		}
+	}
+	// frequency array
+	var frequency = make([]int, 1000)
+	// _ use to skip key and than we will loop through the values of the map
+	for _, value := range hashMap {
+		// if the value is not zero
+		if frequency[value] != 0 {
+			// return false
+			return false
+		}
+		// and we will walk to see next value ++ means walking
+		frequency[value]++
+	}
+	// else return true
+	return true
+}

UniqueNumberOfOccurrences/unique_number_of_occurrences.md

@@ -0,0 +1,88 @@
+# 🔥 Unique Number of Occurrences 🔥 || 3 Approaches || Simple Fast and Easy || with Explanation
+
+## Solution - 1 HashMap + HashSet
+
+```dart
+import 'dart:collection';
+
+class Solution {
+  bool uniqueOccurrences(List<int> arr) {
+    // hashmap to store all values of the array as key value pair
+    HashMap<int, int> map = HashMap();
+    // for all value inside our array
+    for (int number in arr) {
+      // we will add value of array as key and value + 1
+      map[number] = (map[number] ?? 0) + 1;
+    }
+    // hashSet to see the unique values
+    HashSet<int> hashSet = HashSet();
+    // we will add all the values inside the set
+    hashSet.addAll(map.values);
+    // if the length of the unique set is same as the length of the map than true else false
+    return hashSet.length == map.length;
+  }
+}
+```
+
+## Solution - 2 HashSet
+
+```dart
+import 'dart:collection';
+
+class Solution {
+  bool uniqueOccurrences(List<int> arr) {
+    arr.sort();
+    HashSet<int> unique = HashSet();
+
+    int c = 1;
+    for (int i = 1; i < arr.length; i++) {
+      if (arr[i] == arr[i - 1])
+        c++;
+      else {
+        if (unique.contains(c)) return false;
+
+        unique.add(c);
+
+        c = 1;
+      }
+    }
+
+    if (unique.contains(c)) return false;
+
+    return true;
+  }
+}
+```
+
+## Solution - 3 HashMap + Frequency Array
+
+```dart
+import 'dart:collection';
+
+class Solution {
+  bool uniqueOccurrences(List<int> arr) {
+    HashMap<int, int> map = HashMap();
+
+    for (int i = 0; i < arr.length; i++) {
+      int ele = arr[i];
+      if (map.containsKey(ele)) {
+        map[ele] = (map[ele] ?? 0) + 1;
+      } else {
+        map[ele] = 1;
+      }
+    }
+
+    List<int> freq = List.filled(1000, 0); //Constraint given
+
+    for (MapEntry<int, int> e in map.entries) {
+      int n = e.value;
+      if (freq[n] != 0) {
+        return false;
+      }
+      freq[n]++;
+    }
+
+    return true;
+  }
+}
+```