leetcode

Author: ayoubzulfiqar

GroupThePeopleGivenTheGroupSizeTheyBelongTo/group_the_people_given_the_group_size_they_belong_to.dart

@@ -0,0 +1,124 @@
+/*
+
+-* 1282. Group the People Given the Group Size They Belong To *-
+
+There are n people that are split into some unknown number of groups. Each person is labeled with a unique ID from 0 to n - 1.
+
+You are given an integer array groupSizes, where groupSizes[i] is the size of the group that person i is in. For example, if groupSizes[1] = 3, then person 1 must be in a group of size 3.
+
+Return a list of groups such that each person i is in a group of size groupSizes[i].
+
+Each person should appear in exactly one group, and every person must be in a group. If there are multiple answers, return any of them. It is guaranteed that there will be at least one valid solution for the given input.
+
+ 
+
+Example 1:
+
+Input: groupSizes = [3,3,3,3,3,1,3]
+Output: [[5],[0,1,2],[3,4,6]]
+Explanation: 
+The first group is [5]. The size is 1, and groupSizes[5] = 1.
+The second group is [0,1,2]. The size is 3, and groupSizes[0] = groupSizes[1] = groupSizes[2] = 3.
+The third group is [3,4,6]. The size is 3, and groupSizes[3] = groupSizes[4] = groupSizes[6] = 3.
+Other possible solutions are [[2,1,6],[5],[0,4,3]] and [[5],[0,6,2],[4,3,1]].
+Example 2:
+
+Input: groupSizes = [2,1,3,3,3,2]
+Output: [[1],[0,5],[2,3,4]]
+ 
+
+Constraints:
+
+groupSizes.length == n
+1 <= n <= 500
+1 <= groupSizes[i] <= n
+
+
+*/
+
+import 'dart:collection';
+
+class A {
+ List<List<int>> groupThePeople(List<int> groupSizes) {
+ final HashMap<int, List<int>> hm = HashMap();
+ final List<List<int>> res = [];
+
+ for (int person = 0; person < groupSizes.length; person++) {
+ final int groupSize = groupSizes[person];
+ if (!hm.containsKey(groupSize)) {
+ hm[groupSize] = [person];
+ } else {
+ if (hm[groupSize]!.length < groupSize) {
+ hm[groupSize]!.add(person);
+ } else {
+ res.add(hm[groupSize]!);
+ hm[groupSize] = [person];
+ }
+ }
+ }
+
+ for (final List<int> list in hm.values) {
+ res.add(list);
+ }
+
+ return res;
+ }
+}
+
+class NodeList {
+ int val;
+ NodeList? next;
+
+ NodeList(this.val, [this.next]);
+}
+
+class LinkedList {
+ NodeList? head;
+ int length;
+
+ LinkedList()
+ : head = null,
+ length = 0;
+
+ void add(int val) {
+ final newNode = NodeList(val);
+ if (head == null) {
+ head = newNode;
+ } else {
+ NodeList? current = head;
+ while (current!.next != null) {
+ current = current.next;
+ }
+ current.next = newNode;
+ }
+ length++; // Increase the length when adding a node
+ }
+}
+
+class Solution {
+ List<List<int>> groupThePeople(List<int> groupSizes) {
+ final HashMap groupMap = HashMap<int, LinkedList>();
+ final result = <List<int>>[];
+
+ for (int person = 0; person < groupSizes.length; person++) {
+ final groupSize = groupSizes[person];
+ if (!groupMap.containsKey(groupSize)) {
+ groupMap[groupSize] = LinkedList();
+ }
+ groupMap[groupSize]!.add(person);
+
+ if (groupMap[groupSize]!.length == groupSize) {
+ final group = List<int>.filled(groupSize, 0);
+ var current = groupMap[groupSize]!.head;
+ for (var i = 0; i < groupSize; i++) {
+ group[i] = current!.val;
+ current = current.next;
+ }
+ result.add(group);
+ groupMap.remove(groupSize);
+ }
+ }
+
+ return result;
+ }
+}

GroupThePeopleGivenTheGroupSizeTheyBelongTo/group_the_people_given_the_group_size_they_belong_to.go

@@ -0,0 +1,58 @@
+package main
+
+
+
+type NodeList struct {
+Val int
+Next *NodeList
+}
+
+type LinkedList struct {
+Head *NodeList
+Length int // Add a Length field to keep track of the list length
+}
+
+func NewLinkedList() *LinkedList {
+return &LinkedList{nil, 0}
+}
+
+func (ll *LinkedList) Add(val int) {
+newNode := &NodeList{Val: val, Next: nil}
+if ll.Head == nil {
+ll.Head = newNode
+} else {
+current := ll.Head
+for current.Next != nil {
+current = current.Next
+}
+current.Next = newNode
+}
+ll.Length++ // Increase the length when adding a node
+}
+
+func groupThePeople(groupSizes []int) [][]int {
+groupMap := make(map[int]*LinkedList)
+result := make([][]int, 0)
+
+for person, groupSize := range groupSizes {
+if _, exists := groupMap[groupSize]; !exists {
+groupMap[groupSize] = NewLinkedList()
+}
+groupMap[groupSize].Add(person)
+
+if groupMap[groupSize].Length == groupSize {
+group := make([]int, groupSize)
+current := groupMap[groupSize].Head
+for i := 0; i < groupSize; i++ {
+group[i] = current.Val
+current = current.Next
+}
+result = append(result, group)
+delete(groupMap, groupSize)
+}
+}
+
+return result
+}
+
+