leetcode

Author: ayoubzulfiqar

CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.dart

@@ -0,0 +1,82 @@
+/*
+
+-* 1502. Can Make Arithmetic Progression From Sequence *-
+
+
+A sequence of numbers is called an arithmetic progression if the difference between any two consecutive elements is the same.
+
+Given an array of numbers arr, return true if the array can be rearranged to form an arithmetic progression. Otherwise, return false.
+
+ 
+
+Example 1:
+
+Input: arr = [3,5,1]
+Output: true
+Explanation: We can reorder the elements as [1,3,5] or [5,3,1] with differences 2 and -2 respectively, between each consecutive elements.
+Example 2:
+
+Input: arr = [1,2,4]
+Output: false
+Explanation: There is no way to reorder the elements to obtain an arithmetic progression.
+ 
+
+Constraints:
+
+2 <= arr.length <= 1000
+-106 <= arr[i] <= 106
+
+*/
+
+class A {
+  bool canMakeArithmeticProgression(List<int> arr) {
+    if (arr.length < 2) return false;
+
+    arr.sort();
+
+    int difference = arr[1] - arr[0];
+    for (int index = 2; index < arr.length; index++) {
+      if ((arr[index] - arr[arr.length - 1]) != difference) {
+        return false;
+      }
+    }
+    return true;
+  }
+}
+
+class B {
+  bool canMakeArithmeticProgression(List<int> arr) {
+    int length = arr.length;
+    int minVal = arr[0];
+    int maxVal = arr[0];
+
+    for (int number in arr) {
+      if (number < minVal) {
+        minVal = number;
+      }
+      if (number > maxVal) {
+        maxVal = number;
+      }
+    }
+
+    int diff = (maxVal - minVal) ~/ (length - 1);
+
+    for (int i = 0; i < length; i++) {
+      int expected = minVal + i * diff;
+      bool found = false;
+      for (int number in arr) {
+        if ((number - expected).abs() < 1e-9) {
+          found = true;
+          break;
+        }
+      }
+      if (!found) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+}
+
+

CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.go

@@ -0,0 +1,69 @@
+package main
+
+// func canMakeArithmeticProgression(arr []int) bool {
+// 	length := len(arr)
+// 	minVal := arr[0]
+// 	maxVal := arr[0]
+
+// 	for _, num := range arr {
+// 		if num < minVal {
+// 			minVal = num
+// 		}
+// 		if num > maxVal {
+// 			maxVal = num
+// 		}
+// 	}
+
+// 	diff := float64(maxVal-minVal) / float64(length-1)
+
+// 	for i := 0; i < length; i++ {
+// 		expected := float64(minVal) + float64(i)*diff
+// 		found := false
+// 		for _, num := range arr {
+// 			if math.Abs(float64(num)-expected) < 1e-9 {
+// 				found = true
+// 				break
+// 			}
+// 		}
+// 		if !found {
+// 			return false
+// 		}
+// 	}
+
+// 	return true
+// }
+
+func canMakeArithmeticProgression(arr []int) bool {
+	seed := 1000001
+	last := -seed
+
+	for _, x := range arr {
+		if x < seed {
+			seed = x
+		}
+		if x > last {
+			last = x
+		}
+	}
+
+	diff := last - seed
+	if diff == 0 {
+		return true
+	}
+	if diff%(len(arr)-1) != 0 {
+		return false
+	}
+	diff /= len(arr) - 1
+
+	res := 0
+	for i, x := range arr {
+		index := x - seed
+		if index%diff != 0 {
+			return false
+		}
+		index /= diff
+		res ^= i ^ index
+	}
+
+	return res == 0
+}

CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.md

@@ -222,6 +222,7 @@ This repo contain leetcode solution using DART and GO programming language. Most
 - [**404.** Sum of Left Leaves](SumOfLeftLeaves/sum_of_left_leaves.dart)
 - [**1232.** Check If It Is a Straight Line](CheckIfItIsAStraightLine/check_if_it_is_a_straight_line.dart)
 - [**405.** Convert a Number to Hexadecimal](ConvertANumberToHexadecimal/convert_a_number_to_hexadecimal.dart)
+- [**1502.** Can Make Arithmetic Progression From Sequence](CanMakeArithmeticProgressionFromSequence/can_make_arithmetic_progression_from_sequence.dart)
 
 ## Reach me via