feat(problems): add leetcode 169

Author: Gabb-c

pnpm-lock.yaml

@@ -0,0 +1,25 @@
+# 169. Majority Element
+
+Given an array `nums` of size `n`, *return the majority element.*
+
+The majority element is the element that appears more than `⌊n / 2⌋` times. You may assume that the majority element always exists in the array.
+
+### Examples
+
+```
+Input: nums = [3,2,3]
+Output: 3
+```
+
+```
+Input: nums = [2,2,1,1,1,2,2]
+Output: 2
+```
+
+### Constraints
+
+- n == nums.length
+- 1 <= n <= 5 * 10<sup>4</sup>
+- -10<sup>9</sup> <= nums[i] <= 10<sup>9</sup>
+
+**Follow-up:** Could you solve the problem in **linear time and in O(1)** space?

src/arrays/169-majority-element/README.md

@@ -0,0 +1,66 @@
+importtype{LeetcodeProblem}from"@typings/leetcode-problem";
+
+/**
+ * Finds the majority element in an array using the Boyer-Moore Voting Algorithm.
+ *
+ * The majority element is the element that appears more than half the times in the array.
+ * This algorithm has a time complexity of O(n) and a space complexity of O(1).
+ *
+ * @param nums An array of numbers.
+ * @returns The majority element in the array.
+ */
+constboyerMoore=(nums: number[]): number=>{
+// Initialize a counter and a candidate variable
+letcount=0;
+letcandidate: number|null=null;
+
+// Iterate through the array
+for(constnumofnums){
+if(count===0){
+// Set the candidate as the first element if count is 0
+candidate=num;
+}
+
+// Increment count if the current element is the candidate, decrement otherwise
+count+=num===candidate ? 1 : -1;
+}
+
+// Return the candidate if it exists (assuming a majority element always exists)
+returncandidateasnumber;
+};
+
+/**
+ * Finds the majority element in an array using a hash map.
+ *
+ * The majority element is the element that appears more than half the times in the array.
+ * This solution has a time complexity of O(n) and a space complexity of O(n) due to the hash map usage.
+ *
+ * @param nums An array of numbers.
+ * @returns The majority element in the array, or undefined if no majority exists.
+ */
+consthashMap=(nums: number[]): number|undefined=>{
+// Create a new map to store number counts
+constnumMap=newMap<number,number>();
+
+// Iterate through the array to count occurrences of each number
+for(constnumofnums){
+// If the number already exists in the map, increment its count, otherwise set count to 1
+numMap.has(num) ? numMap.set(num,(numMap.get(num)asnumber)+1) : numMap.set(num,1);
+
+// If the count of the current number exceeds half the length of the array, it's the majority element
+if((numMap.get(num)asnumber)>nums.length/2)returnnum;
+}
+
+// No majority element found, return undefined
+returnundefined;
+};
+
+exportconstMAJORITY_ELEMENT: LeetcodeProblem<number|undefined>={
+name: "169. Majority Element",
+code: "1",
+tags: ["Array"],
+solutions: [
+{name: "HashMap",implementation: hashMap},
+{name: "Boyer Moore",implementation: boyerMoore},
+],
+};

src/arrays/169-majority-element/index.ts

@@ -0,0 +1,16 @@
+import{bench,describe}from"vitest";
+
+import{MAJORITY_ELEMENT}from"..";
+import{TEST_DATA}from"./test-data";
+
+const{ name, solutions }=MAJORITY_ELEMENT;
+
+describe(name,()=>{
+for(const{ name, implementation }ofsolutions){
+bench(name,()=>{
+for(const{ input }ofTEST_DATA){
+implementation(input);
+}
+});
+}
+});

src/arrays/169-majority-element/tests/index.bench.ts

@@ -0,0 +1,26 @@
+import{describe,expect,it}from"vitest";
+
+import{MAJORITY_ELEMENT}from"..";
+import{TEST_DATA}from"./test-data";
+
+describe(MAJORITY_ELEMENT.name,()=>{
+// Loop through different implementations provided in solutions
+describe.each(MAJORITY_ELEMENT.solutions)("$name",({ implementation })=>{
+// Test for each test case
+it.each(TEST_DATA)(
+"should find the majority element in the array ($expected)",
+({ expected, input })=>{
+// Validate test data
+expect(input).toBeDefined();
+expect(expected).toBeDefined();
+
+// Run the test
+constresult=implementation(input);
+
+// Validate the output - ensure the result matches the expected indices
+expect(result).toBeDefined();
+expect(result).toEqual(expected);
+},
+);
+});
+});

src/arrays/169-majority-element/tests/index.spec.ts

@@ -0,0 +1,25 @@
+importtype{InputTestData}from"@typings/input-data";
+
+exportconstTEST_DATA: InputTestData<number[],number>[]=[
+{input: [3,2,3],expected: 3},
+{input: [2,2,1,1,1,2,2],expected: 2},
+{input: [1,2,2,3,2],expected: 2},
+{input: [5,5,2,2,5,5,5],expected: 5},
+{input: [1,1,2,2,3,3,3,3,3],expected: 3},
+{input: [6,5,5,5,5,5,5,5,5,5],expected: 5},
+{input: [9,9,9,9,9,9,9,9,9,8],expected: 9},
+{input: [-1,-2,-2,-2,-2,-2,-2,-2,-2,-2],expected: -2},
+{
+input: [
+1000000000,1000000000,1000000000,1000000000,1000000000,1000000000,999999999,1,2,3,
+],
+expected: 1000000000,
+},
+{
+input: [
+-1000000000,-1000000000,-1000000000,-1000000000,-1000000000,-1000000000,-999999999,1,
+2,3,
+],
+expected: -1000000000,
+},
+];