Mustafa

task-1/count-above-threshold.js

@@ -1 +1,12 @@
-//Your code here
+function countAboveThreshold(numbers, threshold) {
+  let count = 0;
+
+  for (let i = 0; i < numbers.length; i++) {
+    if (numbers[i] > threshold) {
+      count++;
+    }
+  }
+
+  return count;
+}
+module.exports = countAboveThreshold;

task-2/calculateAverage.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from "vitest";
+import { calculateAverage } from "./calculateAverage";
+
+describe("calculateAverage", () => {
+  it("returns average for valid numbers", () => {
+    expect(calculateAverage([2, 4, 6])).toBe(4);
+  });
+
+  it("returns number for single value", () => {
+    expect(calculateAverage([5])).toBe(5);
+  });
+
+  it("returns null for empty array", () => {
+    expect(calculateAverage([])).toBe(null);
+  });
+
+  it("returns null if input is not array", () => {
+    expect(calculateAverage("123")).toBe(null);
+  });
+
+  it("returns null if array contains non-number", () => {
+    expect(calculateAverage([1, 2, "3"])).toBe(null);
+  });
+
+  it("works with decimal numbers", () => {
+    expect(calculateAverage([1.5, 2.5])).toBe(2);
+  });
+});

task-3/count-vowels-debug.js

@@ -1,17 +1,23 @@
 function countVowels(text) {
   let count = 0;
 
-  for (let i = 0; i <= text.length; i++) {
+  for (let i = 0; i < text.length; i++) {
+    const char = text[i].toLowerCase();
+
     if (
-      text[i] === "a" ||
-      text[i] === "e" ||
-      text[i] === "i" ||
-      text[i] === "o" ||
-      text[i] === "u"
+      char === "a" ||
+      char === "e" ||
+      char === "i" ||
+      char === "o" ||
+      char === "u"
     ) {
       count++;
     }
   }
 
   return count;
 }
+countVowels("hello")      // 2
+countVowels("javascript") // 3
+countVowels("")           // 0
+countVowels("HELLO")      // 2

task-4/search-experiment.js

@@ -1,3 +1,76 @@
-// Write your code here
-// Use generateBigArray to create a big array numbers.
-// Example: generateBigArray(1000000) will create an array of 1 million numbers.
+import generateBigArray from "./bigArray.js";
+
+// Linear Search
+// -------------------------
+function linearSearch(array, target) {
+  for (let i = 0; i < array.length; i++) {
+    if (array[i] === target) {
+      return i;
+    }
+  }
+  return -1;
+}
+// Binary Search
+// -------------------------
+function binarySearch(array, target) {
+  let left = 0;
+  let right = array.length - 1;
+
+  while (left <= right) {
+    const mid = Math.floor((left + right) / 2);
+
+    if (array[mid] === target) {
+      return mid;
+    }
+
+    if (array[mid] < target) {
+      left = mid + 1;
+    } else {
+      right = mid - 1;
+    }
+  }
+
+  return -1;
+}
+
+// Generate Arrays (NOT timed)
+// -------------------------
+const array1K = generateBigArray(1000);
+const array100K = generateBigArray(100000);
+const array10M = generateBigArray(10000000);
+
+const target = 123456789; // A number that is not in the arrays to test worst-case scenario
+
+// Linear Search Tests
+// -------------------------
+console.time("Linear Search 1K");
+linearSearch(array1K, target);
+console.timeEnd("Linear Search 1K");
+
+console.time("Linear Search 100K");
+linearSearch(array100K, target);
+console.timeEnd("Linear Search 100K");
+
+console.time("Linear Search 10M");
+linearSearch(array10M, target);
+console.timeEnd("Linear Search 10M");
+
+console.log("----------------------------");
+
+// Binary Search Tests
+// -------------------------
+console.time("Binary Search 1K");
+binarySearch(array1K, target);
+console.timeEnd("Binary Search 1K");
+
+console.time("Binary Search 100K");
+binarySearch(array100K, target);
+console.timeEnd("Binary Search 100K");
+
+console.time("Binary Search 10M");
+binarySearch(array10M, target);
+console.timeEnd("Binary Search 10M");
+// Reflection:
+// Binary Search was much faster than Linear Search,
+// especially for large arrays because it has O(log n)
+// complexity compared to O(n).