leetcode

Author: ayoubzulfiqar

DiagonalTraverseIi/diagonal_traverse_ii.dart

@@ -0,0 +1,59 @@
+/*
+
+-- 1424. Diagonal Traverse II--
+
+
+Given a 2D integer array nums, return all elements of nums in diagonal order as shown in the below images.
+
+ 
+
+Example 1:
+
+
+Input: nums = [[1,2,3],[4,5,6],[7,8,9]]
+Output: [1,4,2,7,5,3,8,6,9]
+Example 2:
+
+
+Input: nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
+Output: [1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]
+ 
+
+Constraints:
+
+1 <= nums.length <= 105
+1 <= nums[i].length <= 105
+1 <= sum(nums[i].length) <= 105
+1 <= nums[i][j] <= 105
+
+*/
+
+import 'dart:collection';
+
+
+class Solution {
+ List<int> findDiagonalOrder(List<List<int>> nums) {
+ final HashMap<int, List<int>> diagonals = HashMap();
+ final List<int> ans = <int>[];
+ final int n = nums.length;
+
+ for (int i = 0; i < n; i++) {
+ final int m = nums[i].length;
+ for (int j = 0; j < m; j++) {
+ final int sum = i + j;
+ if (!diagonals.containsKey(sum)) {
+ diagonals[sum] = <int>[];
+ }
+ diagonals[sum]?.add(nums[i][j]);
+ }
+ }
+
+ diagonals.forEach((sum, arr) {
+ for (int i = arr.length - 1; i >= 0; i--) {
+ ans.add(arr[i]);
+ }
+ });
+
+ return ans;
+ }
+}

DiagonalTraverseIi/diagonal_traverse_ii.go

@@ -0,0 +1,78 @@
+package main
+
+func findDiagonalOrder(nums [][]int) []int {
+var res [][]int
+m, size := len(nums), 0
+
+for i := 0; i < m; i++ {
+n, x := len(nums[i]), i
+for j := 0; j < n; j++ {
+if len(res) == x {
+res = append(res, []int{})
+}
+res[x] = append(res[x], nums[i][j])
+x++
+size++
+}
+}
+
+ans := make([]int, size)
+idx := 0
+
+for i := 0; i < len(res); i++ {
+for j := len(res[i]) - 1; j >= 0; j-- {
+ans[idx] = res[i][j]
+idx++
+}
+}
+
+return ans
+}
+/*
+
+
+func findDiagonalOrder(nums [][]int) []int {
+queue := list.New()
+queue.PushBack([2]int{0, 0})
+numRows := len(nums)
+var elems int
+
+for _, lst := range nums {
+elems += len(lst)
+}
+
+res := make([]int, elems)
+resIdx := 0
+
+for queue.Len() > 0 {
+size := queue.Len()
+
+for i := 0; i < size; i++ {
+next := queue.Remove(queue.Front()).([2]int)
+row, col := next[0], next[1]
+
+currentList := nums[row]
+if currentList[col] == math.MaxInt32 {
+continue
+}
+
+res[resIdx] = currentList[col]
+resIdx++
+
+currentList[col] = math.MaxInt32
+
+if row+1 < numRows && len(nums[row+1]) > col && nums[row+1][col] != math.MaxInt32 {
+queue.PushBack([2]int{row + 1, col})
+}
+
+if col+1 < len(currentList) && currentList[col+1] != math.MaxInt32 {
+queue.PushBack([2]int{row, col + 1})
+}
+}
+}
+
+return res
+}
+
+
+*/