Daily 30 Days of JavaScript Challenge Complite

Author: securi3ytalent

Classes (Day 28 - 30)/Classes.md

@@ -0,0 +1,144 @@
+# 🏫 JavaScript Classes – সম্পূর্ণ গাইড
+
+## 📘 কি হলো Class?
+
+JavaScript–এ **Class** হলো একটি **blueprint** বা template, যা দিয়ে আমরা objects তৈরি করি।  
+Class–এর মধ্যে আমরা **properties (data)** এবং **methods (functions)** রাখতে পারি।  
+
+Class–এর সাহায্যে object-oriented programming (OOP) করা সহজ হয়।
+
+---
+
+## 💡 Syntax
+
+```javascript
+class Person {
+  constructor(name, age) {
+    this.name = name; // property
+    this.age = age;   // property
+  }
+
+  // method
+  greet() {
+    console.log(`Hello, my name is ${this.name}`);
+  }
+}
+```
+
+### 🧠 ব্যাখ্যা
+
+- class Person { ... } → Person নামের class তৈরি।
+- constructor → object তৈরি করার সময় run হয়।
+- this.name এবং this.age → এই object–এর property।
+- greet() → method, যেটি object থেকে call করা যায়।
+
+
+### 🧮 Object তৈরি (Instantiation)
+```js
+const person1 = new Person("Alice", 25);
+console.log(person1.name); // Output: Alice
+person1.greet();            // Output: Hello, my name is Alice
+```
+- new Person(...) → নতুন object তৈরি করে।
+- person1.name → property access।
+- person1.greet() → method call।
+
+
+🔹 Inheritance (উত্তরাধিকার)
+একটি class অন্য class–কে extend করতে পারে।
+```js
+class Student extends Person {
+  constructor(name, age, grade) {
+    super(name, age); // parent class constructor call
+    this.grade = grade;
+  }
+
+  study() {
+    console.log(`${this.name} is studying in grade ${this.grade}`);
+  }
+}
+
+const student1 = new Student("Bob", 20, 12);
+student1.greet(); // Hello, my name is Bob
+student1.study(); // Bob is studying in grade 12
+
+```
+- extends → inheritance দেখায়।
+- super() → parent class constructor call করতে হয়।
+
+
+🔹 Static Methods
+Class–এর method শুধুমাত্র class থেকে call করা যায়, object থেকে নয়।
+```js
+class MathUtil {
+  static square(x) {
+    return x * x;
+  }
+}
+
+console.log(MathUtil.square(5)); // 25
+
+```
+static keyword → object নয়, class–এর সাথে directly যুক্ত।
+
+
+🔹 Getters & Setters
+Class–এ property access করার জন্য getter ও setter ব্যবহার করা যায়।
+```js
+class Rectangle {
+  constructor(width, height) {
+    this.width = width;
+    this.height = height;
+  }
+
+  get area() {
+    return this.width * this.height;
+  }
+
+  set setWidth(width) {
+    this.width = width;
+  }
+}
+
+const rect = new Rectangle(5, 10);
+console.log(rect.area); // 50
+rect.setWidth = 7;
+console.log(rect.area); // 70
+
+```
+
+🔹 Private Fields (ES2022)
+```#``` দিয়ে private property তৈরি করা যায়, যা class বাহিরে access করা যায় না।
+
+
+
+
+
+```js
+class BankAccount {
+  #balance;
+
+  constructor(initialBalance) {
+    this.#balance = initialBalance;
+  }
+
+  deposit(amount) {
+    this.#balance += amount;
+  }
+
+  getBalance() {
+    return this.#balance;
+  }
+}
+
+const acc = new BankAccount(100);
+acc.deposit(50);
+console.log(acc.getBalance()); // 150
+// console.log(acc.#balance);  // Error
+
+```
+
+
+
+
+

Classes (Day 28 - 30)/Day 28/2694. Event Emitter.md

@@ -0,0 +1,106 @@
+# 🧩 LeetCode 2694: Event Emitter
+
+## 📘 সমস্যা বিবরণ (Problem Description)
+
+তোমাকে একটি **Event Emitter** class তৈরি করতে হবে।  
+Event Emitter হলো একটি design pattern, যা **event–triggered programming** কে সহজ করে।  
+
+- **on(eventName, callback)** → একটি callback function একটি event এর সাথে যুক্ত করে।  
+- **emit(eventName, args)** → event trigger করলে, সব callback–গুলো run হয়।  
+- **off(eventName, callback)** → event থেকে নির্দিষ্ট callback remove করা।  
+
+---
+
+## 💡 Intuition
+
+1. প্রতিটি event–এর জন্য একটি **callback list** রাখব।  
+2. `on` → callback add করবে।  
+3. `emit` → callback list traverse করে run করবে।  
+4. `off` → callback list থেকে remove করবে।  
+
+---
+
+## 🧮 JavaScript সমাধান
+
+```javascript
+class EventEmitter {
+  constructor() {
+    // Map eventName -> list of callbacks
+    this.events = new Map();
+  }
+
+  /**
+   * Add listener
+   * @param {string} eventName 
+   * @param {Function} callback 
+   */
+  on(eventName, callback) {
+    if (!this.events.has(eventName)) {
+      this.events.set(eventName, []);
+    }
+    this.events.get(eventName).push(callback);
+  }
+
+  /**
+   * Remove listener
+   * @param {string} eventName 
+   * @param {Function} callback 
+   */
+  off(eventName, callback) {
+    if (!this.events.has(eventName)) return;
+    const list = this.events.get(eventName);
+    this.events.set(
+      eventName,
+      list.filter(cb => cb !== callback)
+    );
+  }
+
+  /**
+   * Emit event
+   * @param {string} eventName 
+   * @param  {...any} args 
+   */
+  emit(eventName, ...args) {
+    if (!this.events.has(eventName)) return;
+    for (const cb of this.events.get(eventName)) {
+      cb(...args);
+    }
+  }
+}
+```
+
+### 🧠 ব্যাখ্যা
+| ধাপ | কাজ                                    | উদাহরণ                    |
+| --- | -------------------------------------- | ------------------------- |
+| 1️⃣ | `constructor` → Map তৈরি               | `this.events = new Map()` |
+| 2️⃣ | `on(event, cb)` → callback add         | `"click"` → `[cb1, cb2]`  |
+| 3️⃣ | `off(event, cb)` → callback remove     | `"click"` → `[cb2]`       |
+| 4️⃣ | `emit(event, args...)` → callback call | `cb2(args)`               |
+
+### 🧾 উদাহরণ
+```js
+const emitter = new EventEmitter();
+
+function cb1(data) { console.log('cb1', data); }
+function cb2(data) { console.log('cb2', data); }
+
+emitter.on("event1", cb1);
+emitter.on("event1", cb2);
+
+emitter.emit("event1", 42);
+// Output:
+// cb1 42
+// cb2 42
+
+emitter.off("event1", cb1);
+emitter.emit("event1", 100);
+// Output:
+// cb2 100
+
+```
+
+🔹 Key Points
+- Event Emitter হলো publish-subscribe pattern।
+- একই event multiple callback রাখতে পারা যায়।
+- emit করলে সব callback sequentially run হয়।
+- off দিয়ে callback remove করা যায়।

Classes (Day 28 - 30)/Day 28/Event Emitter.js

@@ -0,0 +1,51 @@
+class EventEmitter {
+    constructor() {
+        this.events = new Map(); 
+        this.subscriptions = []; 
+    }
+
+    subscribe(eventName, callback) {
+        if (!this.events.has(eventName)) {
+            this.events.set(eventName, []);
+        }
+
+        const callbacks = this.events.get(eventName);
+        callbacks.push(callback);
+        const index = this.subscriptions.length;
+        this.subscriptions.push({ eventName, callback });
+
+        return {
+            unsubscribe: () => {
+                const sub = this.subscriptions[index];
+                if (!sub) return;
+                const arr = this.events.get(sub.eventName);
+                if (arr) {
+                    const i = arr.indexOf(sub.callback);
+                    if (i !== -1) arr.splice(i, 1);
+                }
+                this.subscriptions[index] = null;
+            }
+        };
+    }
+
+    emit(eventName, args = []) {
+        const callbacks = this.events.get(eventName) || [];
+        const results = [];
+        for (const cb of callbacks) {
+            results.push(cb(...args));
+        }
+        return results;
+    }
+}
+
+/**
+ * const emitter = new EventEmitter();
+ *
+ * // Subscribe to the onClick event with onClickCallback
+ * function onClickCallback() { return 99 }
+ * const sub = emitter.subscribe('onClick', onClickCallback);
+ *
+ * emitter.emit('onClick'); // [99]
+ * sub.unsubscribe(); // undefined
+ * emitter.emit('onClick'); // []
+ */

Classes (Day 28 - 30)/Day 29/2695. Array Wrapper.md

@@ -0,0 +1,71 @@
+# 🧩 LeetCode 2695: Array Wrapper
+
+## 📘 সমস্যা বিবরণ (Problem Description)
+
+তোমাকে একটি **Array Wrapper class** তৈরি করতে হবে যা একটি array কে wrap করে এবং কিছু সুবিধা দেয়:
+
+- **constructor(nums)** → array initialize করা।  
+- **valueOf()** → object কে number হিসেবে convert করা যায়।  
+- **toString()** → object কে string হিসেবে convert করা যায়।  
+
+এছাড়া, array–এর element–এর সাথে operator ব্যবহার করলে wrapper class ঠিকভাবে behave করবে।  
+
+---
+
+## 💡 Intuition
+
+1. Wrapper class–এ array store করা।  
+2. `valueOf()` → array–এর sum return করবে, যাতে number operations ঠিক হয়।  
+3. `toString()` → array–এর string representation return করবে।  
+
+---
+
+## 🧮 JavaScript সমাধান
+
+```javascript
+class ArrayWrapper {
+  constructor(nums) {
+    this.nums = nums; // array store
+  }
+
+  // Number context (like +, -)
+  valueOf() {
+    return this.nums.reduce((a, b) => a + b, 0);
+  }
+
+  // String context
+  toString() {
+    return `[${this.nums.join(',')}]`;
+  }
+}
+```
+
+### 🧠 ব্যাখ্যা
+
+| ধাপ | কাজ                                 | উদাহরণ                        |
+| --- | ----------------------------------- | ----------------------------- |
+| 1️⃣ | `constructor(nums)` → nums save করা | `[1,2,3]`                     |
+| 2️⃣ | `valueOf()` → number conversion     | `+wrapper` → 6                |
+| 3️⃣ | `toString()` → string conversion    | `String(wrapper)` → "[1,2,3]" |
+
+### 🧾 উদাহরণ
+```js
+const wrap1 = new ArrayWrapper([1,2,3]);
+const wrap2 = new ArrayWrapper([4,5,6]);
+
+console.log(+wrap1); // 6
+console.log(`${wrap1}`); // "[1,2,3]"
+console.log(wrap1 + wrap2); // 6 + 15 = 21
+
+console.log(wrap1.toString()); // "[1,2,3]"
+console.log(wrap2.valueOf()); // 15
+
+```
+
+🔹 Key Points
+- valueOf() → number context handle করে।
+- toString() → string context handle করে।
+- JavaScript–এ object operator use করলে valueOf() automatically call হয়।
+- Wrapper class দিয়ে array–কে context–specific behavior দেওয়া যায়।
+
+