isomorbhic srings question

Decorators topic added
mixins in progress

Author: mrinaljain

D/decorators/Animal.js

@@ -0,0 +1,18 @@
+function log(target, name, descriptor) {
+  const originalMethod = descriptor.value;
+  descriptor.value = function (...args) {
+    console.log(`Called ${name} with args: ${args}`);
+    return originalMethod.apply(this, args);
+  };
+  return descriptor;
+}
+
+class Example {
+  @log
+  greet(name) {
+    return `Hello, ${name}!`;
+  }
+}
+
+const example = new Example();
+example.greet("World"); // Logs: Called greet with args: [ 'World' ]

D/decorators/README.md

@@ -0,0 +1,7 @@
+# Decorators
+
+A decorator is a design pattern that allows you to modify or extend the behavior of an object or function or class without changing its original code
+
+*The core idea is that you "wrap" or "decorate" an object, class, or method to add extra features.*
+
+- decorators are usually prefixed with @.

D/decorators/decorator.js

@@ -0,0 +1,2 @@
+
+

E/es7/README.md

@@ -1,3 +1,4 @@
 **ES7 (ECMAScript 2016)**:
   - **Exponentiation Operator (`**`)**: The exponentiation operator (`**`) was introduced to replace `Math.pow()`. It allows you to raise numbers to a power more easily.
+  
   - **Array.prototype.includes**: A new method for arrays to check if an element exists in the array. It is more readable than `indexOf()`.

E/es8/README.md

@@ -1,6 +1,9 @@
 **ES8 (ECMAScript 2017)**:
 
   - **`async`/`await`**: Introduced as a cleaner way to handle asynchronous code by using promises in a more synchronous-like manner. It improves code readability and reduces callback hell.
+
   - **Object.entries() and Object.values()**: These methods provide an easy way to iterate over the properties and values of an object. `Object.entries()` returns an array of key-value pairs, while `Object.values()` returns an array of values.
+
   - **String padding methods (`padStart()` and `padEnd()`)**: These methods allow you to pad the beginning or the end of a string with specified characters to ensure a specific string length.
+  
   - **Shared memory and atomics**: Introduced shared memory for use with Web Workers and atomics for controlling concurrent access to memory.

M/mixin/mixin.js

@@ -0,0 +1,24 @@
+const flyingMixin = {
+  fly() {
+    console.log(`${this.name} is flying!`);
+  },
+};
+
+const walkingMixin = {
+  walk() {
+    console.log(`${this.name} is walking!`);
+  },
+};
+
+class Bird {
+  constructor(name) {
+    this.name = name;
+  }
+}
+
+// Applying mixins
+Object.assign(Bird.prototype, flyingMixin, walkingMixin);
+
+const eagle = new Bird("Eagle");
+eagle.fly(); // Output: Eagle is flying!
+eagle.walk(); // Output: Eagle is walking!

index.html

@@ -11,7 +11,7 @@
 
 
 
-   <script src="./leetcode-solutions/20-Valid_Parentheses.js"> </script>
+   <script src="./leetcode-solutions/205-Isomorphic_Strings.js"> </script>
 </body>
 
 </html>

leetcode-solutions/205-Isomorphic_Strings.js

@@ -0,0 +1,73 @@
+/*
+Given two strings s and t, determine if they are isomorphic.
+
+Two strings s and t are isomorphic if the characters in s can be replaced to get t.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.
+*/
+
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+var isIsomorphic = function (s, t) {
+  let map = new Map();
+
+  let ans = "";
+
+  for (let i = 0; i < s.length; i++) {
+    let elementS = s[i];
+    let elementT = t[i];
+    // check if item already exists in map
+    if (map.has(elementS)) {
+      // if yes => then add value corresponding to it in ans
+      ans += map.get(elementS);
+    } else {
+      // if no => add[same index] it to map => then add value to string
+      if ([...map.values()].includes(elementT)) {
+         return false;
+      }
+      map.set(elementS, elementT);
+      ans+= elementT;
+    }
+  }
+  console.log(ans);
+  
+  if(ans === t) return true;
+
+  return false;
+  
+};
+
+let s1 = "paper";
+let t1 = "title";
+let s2 = "foo";
+let t2 = "bar";
+let s3 = "egg";
+let t3 = "add";
+let s4 = "badc";
+let t4 = "baba";
+
+// console.log(isIsomorphic(s1, t1));
+// console.log(isIsomorphic(s2, t2));
+// console.log(isIsomorphic(s3, t3));
+console.log(isIsomorphic(s4, t4));
+ 
+
+
+// intution
+
+/* question says ki humko ekk string se dusti string bana k dekhna hai ki ban rhi hai k nhi
+given ki hum second string k elements ko first string k elements se replacce krte jaye.
+
+ek condition hai ki ek character ko ek value assign ho gy to vahi use hogi.
+
+
+iske liye we will use a map
+
+agar map mai value hai to usko use karenge 
+agar nhi hai to new use karenge 
+
+final jo string banegi usko second string se compare karenge for answer
+*/