DSA Update and Some Code notes Design

Author: VR-Rathod

pages/Abstract Classes.md

@@ -0,0 +1,34 @@
+# Explanation
+	- An **Abstract Class** is a class that cannot be instantiated directly. It defines a blueprint for subclasses to follow, and may contain abstract methods (methods without implementation) that must be implemented by concrete subclasses.
+	- **"Enforces a contract"**: Abstract classes ensure that subclasses implement the required methods.
+	- **Use Case**: When you want to define a common interface for a group of related classes.
+-
+- # Steps
+	- Create an abstract class using the `abc` module in Python.
+	-
+	- Define abstract methods using `@abstractmethod` decorator.
+	-
+	- Create concrete subclasses that implement the abstract methods.
+-
+- ```python
+  from abc import ABC, abstractmethod
+  
+  class Animal(ABC):
+      @abstractmethod
+      def sound(self):
+          pass
+  
+  class Dog(Animal):
+      def sound(self):
+          print("Woof!")
+  
+  class Cat(Animal):
+      def sound(self):
+          print("Meow!")
+  
+  dog = Dog()
+  dog.sound()  # Output: Woof!
+  
+  cat = Cat()
+  cat.sound()  # Output: Meow!
+  ```

pages/Abstraction.md

@@ -0,0 +1,33 @@
+# Explanation
+	- Abstraction is the OOP concept where you hide the complex implementation details and show only the essential features of an object. It allows you to focus on what an object does rather than how it performs the task. In Python, abstraction is typically implemented using abstract classes and abstract methods, where the class provides a skeleton and the subclass implements the details.
+	  
+	  **Key Points**:
+		- **Abstract Class**: A class that cannot be instantiated directly and may contain abstract methods.
+		- **Abstract Method**: A method in the abstract class that does not have any implementation and must be overridden in subclasses.
+-
+- # Steps
+	- Create an abstract class using the `ABC` module and `abstractmethod`.
+	-
+	- Define abstract methods without implementation in the abstract class.
+	-
+	- Implement these abstract methods in subclasses.
+-
+- ```python
+  from abc import ABC, abstractmethod
+  
+  class Animal(ABC):  # Abstract class
+      @abstractmethod
+      def sound(self):  # Abstract method
+          pass
+  
+  class Dog(Animal):  # Concrete class
+      def sound(self):
+          print("Woof!")
+  
+  class Cat(Animal):  # Concrete class
+      def sound(self):
+          print("Meow!")
+  
+  dog = Dog()
+  dog.sound()  # Output: Woof!
+  ```

pages/Binary Search.md

@@ -3,6 +3,7 @@
 -
 - # Steps:
 	- The **list must be sorted** first.
+	-
 	- Start with the low pointer at index 0 and the high pointer at the last index of the list.
 	-
 	- Find the middle element: `mid = (low + high) // 2`.

pages/Bubble Sort.md

@@ -13,19 +13,13 @@
 	- **Average and Worst Case:** **O(n^2)**.
 -
 - ```python
-  def bubble_sort(arr):
-      n = len(arr)
-      for i in range(n):
-          swapped = False
-          for j in range(0, n-i-1):
-              if arr[j] > arr[j+1]:
-                  arr[j], arr[j+1] = arr[j+1], arr[j]
-                  swapped = True
-          if not swapped:
-              break
-      return arr
+  arr = [64, 34, 25, 12, 22, 11, 90, 5]
 
-  # Example usage
-  arr = [64, 34, 25, 12, 22, 11, 90]
-  print("Sorted array is:", bubble_sort(arr))
+  n = len(arr)
+  for i in range(n-1):
+      for j in range(n-i-1):
+          if arr[j] > arr[j+1]:
+              arr[j], arr[j+1] = arr[j+1], arr[j]
+  
+  print("Sorted array:", my_array)
   ```

pages/CSS.md

@@ -1,5 +1,4 @@
 # History
-collapsed:: true
 	- **How**:
 		- Developed by **Håkon Wium Lie** and **Bert Bos** in **1994** at **W3C** (World Wide Web Consortium).
 		- Designed to separate **content** (HTML) from **presentation** (layout and style), enabling web developers to control the look and feel of a webpage without affecting its structure.
@@ -49,7 +48,7 @@ collapsed:: true
 	- Explore the following links for valuable resources, communities, and tools to enhance your skills:-
 		-
 		- [CSS Learning](https://github.com/micromata/awesome-css-learning)
-		- [How Degine Resources ?](https://github.com/bradtraversy/design-resources-for-developers)
+		- [How Design Resources ?](https://github.com/bradtraversy/design-resources-for-developers)
 		- [CSS Tips & Tricks ](https://github.com/AllThingsSmitty/css-protips)
 		- [Useful modules in CSS](https://github.com/awesome-css-group/awesome-css)
 		- [CSS Fremworks](https://github.com/troxler/awesome-css-frameworks)
@@ -60,4 +59,5 @@ collapsed:: true
 		- [No Worry About JavaScript 😉](https://github.com/you-dont-need/You-Dont-Need-JavaScript)
 		- [CSS Interview questions 😎](https://github.com/Devinterview-io/css-interview-questions)
 		- [CSS Animations](https://animate.style/)
-		- [Creative Buttons](https://tympanus.net/Development/CreativeButtons/)
+		- [Creative Buttons](https://tympanus.net/Development/CreativeButtons/)
+		- [animejs](https://animejs.com/)

pages/Class.md

@@ -0,0 +1,42 @@
+# Explanation
+	- A class is a blueprint for creating objects (instances). It defines the properties (attributes) and behaviors (methods) that the objects created from it will have. In Python, a class is created using the `class` keyword.
+-
+- # Steps
+	- Use the `class` keyword to define a class.
+	-
+	- **Add a Constructor (`__init__`)**:
+		- The constructor method is used to initialize the attributes of the class when an object is created.
+	-
+	- **Define Methods**:
+		- Methods are functions defined inside a class to perform actions or computations. These methods can modify or interact with the object's attributes.
+	-
+	- **Create Objects**:
+		- Once a class is defined, you can create objects (instances) of that class.
+-
+- ```python
+  # Step 1: Define the class
+  class Dog:
+      # Step 2: Add a constructor to initialize attributes
+      def __init__(self, name, age):
+          self.name = name  # attribute 'name'
+          self.age = age    # attribute 'age'
+  
+      # Step 3: Define a method
+      def bark(self):
+          print(f"{self.name} says woof!")
+  
+      # Another method
+      def info(self):
+          print(f"{self.name} is {self.age} years old.")
+  
+  # Step 4: Create objects (instances) of the class
+  dog1 = Dog("Buddy", 3)
+  dog2 = Dog("Lucy", 5)
+  
+  # Call methods on objects
+  dog1.bark()   # Output: Buddy says woof!
+  dog1.info()   # Output: Buddy is 3 years old.
+  
+  dog2.bark()   # Output: Lucy says woof!
+  dog2.info()   # Output: Lucy is 5 years old.
+  ```

pages/Composition.md

@@ -0,0 +1,28 @@
+# Explanation
+	- **Composition** is an OOP principle where one object is made up of other objects, i.e., it has instances of other classes as attributes. Composition represents a "has-a" relationship between objects.
+	- **Has-A Relationship**: This means that an object can contain other objects, which may represent part of its functionality.
+-
+- # Steps
+	- Define classes for both the containing class and the contained class.
+	-
+	- Create an instance of the contained class as an attribute in the containing class.
+	-
+	- Use the contained object's methods or attributes from the containing class.
+-
+- ```python
+  class Engine:
+      def start(self):
+          print("Engine started.")
+  
+  class Car:
+      def __init__(self, brand):
+          self.brand = brand
+          self.engine = Engine()  # Car has an engine (Composition)
+  
+      def drive(self):
+          self.engine.start()
+          print(f"The {self.brand} is driving.")
+  
+  car = Car("Toyota")
+  car.drive()
+  ```

pages/Constructor.md

@@ -0,0 +1,22 @@
+# Explanation
+	- A **constructor** is a special method that is called automatically when an object is created. In Python, the constructor is defined using the `__init__()` method. The constructor is used to initialize the attributes of the object when it is created.
+	  
+	  **Key Points**:
+		- **`__init__` Method**: A special method that acts as a constructor in Python. It is automatically invoked when an object is created.
+		- **Attribute Initialization**: Inside the constructor, you can initialize the object’s attributes with specific values.
+-
+- # Steps
+	- Define the `__init__()` method in your class.
+	-
+	- Initialize the object’s attributes inside the constructor.
+-
+- ```python
+  class Car:
+      def __init__(self, brand, model, year):  # Constructor
+          self.brand = brand
+          self.model = model
+          self.year = year
+  
+  car = Car("Toyota", "Corolla", 2022)  # Constructor is automatically called
+  print(car.brand)  # Output: Toyota
+  ```

pages/DSA , Algo & System Design.md

@@ -1,42 +1,43 @@
 # OOP consepts
 	- ## The  **core concepts**  of OOP are indeed  **14** :-
-		- **Class** - Blueprint for creating objects, defining properties and methods.
+		- [[Class]] - Blueprint for creating objects, defining properties and methods.
 		  logseq.order-list-type:: number
-		- Object - An instance of a class containing data and behavior.
+		- [[Constructor]] - Special method for initializing objects when created.
 		  logseq.order-list-type:: number
-		- **Encapsulation** - Bundling data and methods, restricting direct access to an object's internal state.
+		- [[Destructors]] - Method for cleaning up when an object is destroyed or goes out of scope.
 		  logseq.order-list-type:: number
-		- **Abstraction** - Hiding complex implementation details and exposing only essential features.
+		- [[Object]] - An instance of a class containing data and behavior.
 		  logseq.order-list-type:: number
-		- **Inheritance** - Mechanism by which one class derives properties and behaviors from another.
+		- [[Encapsulation]] - Bundling data and methods, restricting direct access to an object's internal state.
 		  logseq.order-list-type:: number
-		- **Polymorphism** - Ability for objects of different types to be treated as instances of a common superclass.
+		- [[Abstraction]] - Hiding complex implementation details and exposing only essential features.
 		  logseq.order-list-type:: number
-		- **Constructor** - Special method for initializing objects when created.
+		- [[Inheritance]] - Mechanism by which one class derives properties and behaviors from another.
 		  logseq.order-list-type:: number
-		- **Destructors** - Method for cleaning up when an object is destroyed or goes out of scope.
+		- [[Polymorphism]] - Ability for objects of different types to be treated as instances of a common superclass.
 		  logseq.order-list-type:: number
-		- **Composition** - Creating complex objects by combining simpler objects, a "has-a" relationship.
+		- [[Composition]] - Creating complex objects by combining simpler objects, a "has-a" relationship.
+		  id:: 67e63024-2a0a-4a19-aff1-05ad33f056cf
 		  logseq.order-list-type:: number
-		- **Interface** - Defines a contract that classes must follow, without providing implementation.
+		- [[Interface]] - Defines a contract that classes must follow, without providing implementation.
 		  logseq.order-list-type:: number
-		- **Method Overloading** - Defining multiple methods with the same name but different parameters.
+		- [[Method Overloading]] - Defining multiple methods with the same name but different parameters.
 		  logseq.order-list-type:: number
-		- **Method Overriding** - Redefining a method in a subclass to change its behavior.
+		- [[Method Overriding]] - Redefining a method in a subclass to change its behavior.
 		  logseq.order-list-type:: number
-		- **Static Methods and Class Methods** - Methods that belong to the class rather than instances.
+		- [[Static Methods and Class Methods]] - Methods that belong to the class rather than instances.
 		  logseq.order-list-type:: number
-		- **Dynamic Binding (Late Binding)** - Resolving method calls at runtime based on the object type.
+		- [[Dynamic Binding (Late Binding)]] - Resolving method calls at runtime based on the object type.
 		  logseq.order-list-type:: number
 	-
 	- ## **additional related concepts** or **design patterns** that can supplement or extend OOP are:-
-		- **Delegation** - One object handing over responsibilities to another.
-		- **Mixin** - A class that provides functionality to other classes without being a parent class.
-		- **Abstract Classes** - Classes that cannot be instantiated and may contain abstract methods.
-		- **Loose Coupling and High Cohesion** - Reducing dependencies between components and ensuring focused class responsibilities
-		- **Factory Pattern**: Creating objects without specifying the exact class of object to be created.
-		- **Observer Pattern**: Notifying multiple objects about state changes in another object.
-		- **Singleton Pattern**: Ensuring a class has only one instance and providing a global point of access.
+		- [[Delegation]] - One object handing over responsibilities to another.
+		- [[Mixin]] - A class that provides functionality to other classes without being a parent class.
+		- [[Abstract Classes]] - Classes that cannot be instantiated and may contain abstract methods.
+		- [[Loose Coupling and High Cohesion]] - Reducing dependencies between components and ensuring focused class responsibilities
+		- [[Factory Pattern]] - Creating objects without specifying the exact class of object to be created.
+		- [[Observer Pattern]] - Notifying multiple objects about state changes in another object.
+		- [[Singleton Pattern]] - Ensuring a class has only one instance and providing a global point of access.
 -
 - # Algorithms
 	- ## Searching:
@@ -117,7 +118,7 @@
 		- 15) [[Zobrist Hashing]] - hashing technique used in computer games
 		- 16) [[FM-index]] - data structure used for efficient full-text searching
 		- 17) [[Circular buffer]] - works like a fixed-size queue
-		- 18) [[Hungarian / Kuhn–Munkres / Munkres Assignment-Algorithm]] - combinatorial optimization algorithm
+		- 18) [[Hungarian - Kuhn–Munkres - Munkres Assignment-Algorithm]] - combinatorial optimization algorithm
 		- 19) [[Dekker's Algorithm]] - first algorithms to solve the mutual exclusion
 		- 20) [[Winged Edge]] - used to represent **polygonal meshes**
 		- 21) [[Burrows–Wheeler Transform]] - string transformation algorithm
@@ -129,6 +130,11 @@
 		- 27) [[Disjoint-set Data Structure]] - efficiently perform union and find operations
 		- 28)[[Bloom Filter]]  - space-efficient probabilistic data structure used to test whether
 -
+- # Short fourmulas
+	- [[fibonacci]] - Short trick
+	- [[palindrome]] - short method
+	-
+-
 - # More Learn
 	- Explore the following links for valuable resources, communities, and tools to enhance your skills:
 	-
@@ -150,7 +156,4 @@
 		- [System Design E-book](https://github.com/karanpratapsingh/system-design)
 		- [Coding Interview Preparation](https://github.com/jwasham/coding-interview-university)
 		- [SDE Interview Question](https://github.com/twowaits/SDE-Interview-Questions)
-		-
-		-
-		-
-		-
+-

pages/Delegation.md

@@ -0,0 +1,28 @@
+# Explanation
+	- **Delegation** is a design pattern where an object delegates responsibility for certain tasks to another object. Instead of doing the work itself, the delegating object asks another object (delegate) to perform the work.
+	- **"Has-A" relationship**: The delegating object "has a" reference to the delegating object and uses it to delegate responsibilities.
+	- **Use Case**: Useful when you want to separate concerns and avoid making a class too complex.
+-
+- # Steps
+	- Create a class that performs the main task (Delegate).
+	-
+	- Create a class that delegates tasks to the delegate class.
+	-
+	- The delegator calls methods on the delegate class to perform specific tasks.
+-
+- ```python
+  class Printer:
+      def print(self):
+          print("Printing document...")
+  
+  class Computer:
+      def __init__(self, printer):
+          self.printer = printer  # Delegating print functionality
+  
+      def print_document(self):
+          self.printer.print()  # Delegates the printing task
+  
+  printer = Printer()
+  computer = Computer(printer)
+  computer.print_document()  # Output: Printing document...
+  ```