Merge branch 'main' into main

Author: ajay-dhangar

blog/authors.yml

@@ -3,20 +3,18 @@ ajay-dhangar:
   title: Founder of CodeHarborHub
   url: https://ajay-dhangar.github.io/
   image_url: https://avatars.githubusercontent.com/u/99037494?v=4
+  email: [email protected]
+  page: true # Turns the feature on
+  description: >
+    A passionate developer who loves to code and build new things. I am a Full Stack Developer and a Cyber Security, ML & AI  Enthusiast. I am also a Technical Content Writer and a Speaker. I love to share my knowledge with the community. I am the Founder of CodeHarborHub. I am also a Technical Content Writer at GeeksforGeeks. I am a Girl Script Summer of Code 2024 Project Manager (PA).    
 
-ajay-dhangar_2024:
-  name: Ajay Dhangar
-  title: Software Engineer at OptimumAI
-  url: https://www.optimumai.in/community
-  image_url: https://avatars.githubusercontent.com/u/99037494?v=4
-
-
-ajay-dhangar_2020:
-  name: Ajay Dhangar
-  title: B.Tech (CSE) Student
-  url: https://github.com/ajay-dhangar
-  image_url: https://avatars.githubusercontent.com/u/99037494?v=4
-
+  socials:
+    x: CodesWithAjay
+    linkedin: ajay-dhangar
+    github: ajay-dhangar
+    stackoverflow: 18530900
+    newsletter: https://ajay-dhangar.github.io
+    
 hitesh-gahanolia:
   name: Hitesh Gahanolia
   tile: Final Year Student At MNNIT ALLAHABAD
@@ -27,7 +25,7 @@ dharshibalasubramaniyam:
   name: Dharshi B.
   tile: Software Engineering undergraduate
   url: https://github.com/dharshibalasubramaniyam
-  image_url:  https://avatars.githubusercontent.com/u/139672976?s=400&v=4
+  image_url: https://avatars.githubusercontent.com/u/139672976?s=400&v=4
 
 abhijith-m-s:
   name: Abhijith M S
@@ -82,4 +80,3 @@ akshitha-chiluka:
   title: Software Engineering Undergraduate
   url: https://github.com/AKSHITHA-CHILUKA
   image_url: https://avatars.githubusercontent.com/u/120377576?v=4
-

docs/Deep Learning/Optimizers in Deep Learning/Adam.md

@@ -0,0 +1,116 @@
+# Add Adam in Deep Learning Optimizers
+
+This Section contains an explanation and implementation of the Adam optimization algorithm used in deep learning. Adam (Adaptive Moment Estimation) is a popular optimizer that combines the benefits of two other widely used methods: AdaGrad and RMSProp.
+
+## Table of Contents
+- [Introduction](#introduction)
+- [Mathematical Explanation](#mathematical-explanation)
+  - [Adam in Gradient Descent](#adam-in-gradient-descent)
+  - [Update Rule](#update-rule)
+- [Implementation in Keras](#implementation-in-keras)
+- [Results](#results)
+- [Advantages of Adam](#advantages-of-adam)
+- [Limitations of Adam](#limitations-of-adam)
+
+
+## Introduction
+
+Adam is an optimization algorithm that computes adaptive learning rates for each parameter. It combines the advantages of the AdaGrad and RMSProp algorithms by using estimates of the first and second moments of the gradients. Adam is widely used in deep learning due to its efficiency and effectiveness.
+
+## Mathematical Explanation
+
+### Adam in Gradient Descent
+
+Adam optimizes the stochastic gradient descent by calculating individual adaptive learning rates for each parameter based on the first and second moments of the gradients.
+
+### Update Rule
+
+The update rule for Adam is as follows:
+
+1. Compute the first moment estimate (mean of gradients):
+
+$$
+m_t = \beta_1 m_{t-1} + (1 - \beta_1) g_t
+$$
+
+2. Compute the second moment estimate (uncentered variance of gradients):
+
+$$
+v_t = \beta_2 v_{t-1} + (1 - \beta_2) g_t^2
+$$
+
+3. Correct the bias for the first moment estimate:
+
+$$
+\hat{m}_t = \frac{m_t}{1 - \beta_1^t}
+$$
+
+4. Correct the bias for the second moment estimate:
+
+$$
+\hat{v}_t = \frac{v_t}{1 - \beta_2^t}
+$$
+
+5. Update the parameters:
+
+$$
+\theta_t = \theta_{t-1} - \frac{\eta}{\sqrt{\hat{v}_t} + \epsilon} \hat{m}_t
+$$
+
+where:
+- $\theta$ are the model parameters
+- $\eta$ is the learning rate
+- $\beta_1$ and $\beta_2$ are the exponential decay rates for the moment estimates
+- $\epsilon$ is a small constant to prevent division by zero
+- $g_t$ is the gradient at time step $t$
+
+## Implementation in Keras
+
+Simple implementation of the Adam optimizer using Keras:
+
+```python
+import numpy as np
+from keras.models import Sequential
+from keras.layers import Dense
+from keras.optimizers import Adam
+
+# Generate data
+X_train = np.random.rand(1000, 20)
+y_train = np.random.randint(2, size=(1000, 1))
+
+# Define a model
+model = Sequential()
+model.add(Dense(64, activation='relu', input_dim=20))
+model.add(Dense(1, activation='sigmoid'))
+
+# Compile the model with Adam optimizer
+optimizer = Adam(learning_rate=0.001)
+model.compile(optimizer=optimizer, loss='binary_crossentropy', metrics=['accuracy'])
+
+# Train the model
+model.fit(X_train, y_train, epochs=50, batch_size=32)
+```
+
+In this example:
+- We generate some dummy data for training.
+- We define a simple neural network model with one hidden layer.
+- We compile the model using the Adam optimizer with a learning rate of 0.001.
+- We train the model for 50 epochs with a batch size of 32.
+
+
+## Results
+
+The results of the training process, including the loss and accuracy, will be displayed after each epoch. You can adjust the learning rate and other hyperparameters to see how they affect the training process.
+
+## Advantages of Adam
+
+1. **Adaptive Learning Rates**: Adam computes adaptive learning rates for each parameter, which helps in faster convergence.
+2. **Momentum**: Adam includes momentum, which helps in smoothing the optimization path and avoiding local minima.
+3. **Bias Correction**: Adam includes bias correction, improving convergence in the early stages of training.
+4. **Robustness**: Adam works well in practice for a wide range of problems, including those with noisy gradients or sparse data.
+
+## Limitations of Adam
+
+1. **Hyperparameter Sensitivity**: The performance of Adam is sensitive to the choice of hyperparameters ($\beta_1$, $\beta_2$, $\eta$), which may require careful tuning.
+2. **Memory Usage**: Adam requires additional memory to store the first and second moments, which can be significant for large models.
+3. **Generalization**: Models trained with Adam might not generalize as well as those trained with simpler optimizers like SGD in certain cases.

dsa-solutions/gfg-solutions/Easy problems/FaithfulNumbers.md

@@ -0,0 +1,213 @@
+---
+id: faithful-numbers
+title: Faithful Numbers
+sidebar_label: Faithful-Numbers
+tags:
+  - Array
+  - Data Structure
+description: "This tutorial covers the solution to the Faithful Numbers problem from the GeeksforGeeks website."
+---
+## Problem Description
+
+A number is called faithful if you can write it as the sum of distinct powers of 7. 
+e.g.,  `2457 = 7 + 72 + 74` . If we order all the faithful numbers, we get the sequence `1 = 70`, `7 = 71`, `8 = 70 + 71`, `49 = 72`, `50 = 70 + 72` . . . and so on.
+Given some value of `N`, you have to find the N'th faithful number.
+
+## Examples
+
+**Example 1:**
+
+```
+Input:
+N = 3
+Output:
+8
+Explanation:
+8 is the 3rd Faithful number.
+```
+
+**Example 2:**
+
+```
+Input:
+N = 7
+Output:
+57
+Explanation:
+57 is the 7th Faithful number.
+```
+
+## Your Task
+You don't need to read input or print anything. Your task is to complete the function `nthFaithfulNum()` which takes an Integer N as input and returns the answer.
+
+
+Expected Time Complexity: $O(log(n))$
+
+Expected Auxiliary Space: $O(log(n))$
+
+## Constraints
+
+* `1 ≤ n ≤ 10^5`
+
+## Problem Explanation
+A number is called faithful if you can write it as the sum of distinct powers of 7. 
+e.g.,  `2457 = 7 + 72 + 74` . If we order all the faithful numbers, we get the sequence `1 = 70`, `7 = 71`, `8 = 70 + 71`, `49 = 72`, `50 = 70 + 72` . . . and so on.
+Given some value of `N`, you have to find the N'th faithful number.
+
+
+## Code Implementation
+
+<Tabs>
+  <TabItem value="Python" label="Python" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```python
+  
+def get_nth_faithful_number(n):
+    faithful_numbers = []
+    power = 0
+    while len(faithful_numbers) < n:
+        num = 7 ** power
+        faithful_numbers.append(num)
+        for i in range(len(faithful_numbers) - 1):
+            faithful_numbers.append(num + faithful_numbers[i])
+        power += 1
+    return faithful_numbers[n - 1]
+
+n = int(input("Enter the value of N: "))
+print("The {}th faithful number is: {}".format(n, get_nth_faithful_number(n)))
+
+  ```
+
+  </TabItem>
+  <TabItem value="C++" label="C++">
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```cpp
+#include <iostream>
+#include <vector>
+#include <cmath>
+
+int getNthFaithfulNumber(int n) {
+    std::vector<int> faithfulNumbers;
+    int power = 0;
+    while (faithfulNumbers.size() < n) {
+        int num = pow(7, power);
+        faithfulNumbers.push_back(num);
+        for (int i = 0; i < faithfulNumbers.size() - 1; i++) {
+            faithfulNumbers.push_back(num + faithfulNumbers[i]);
+        }
+        power++;
+    }
+    return faithfulNumbers[n - 1];
+}
+int main() {
+    int n;
+    std::cout << "Enter the value of N: ";
+    std::cin >> n;
+    std::cout << "The " << n << "th faithful number is: " << getNthFaithfulNumber(n) << std::endl;
+    return 0;
+}
+
+  ```
+
+  </TabItem>
+
+  <TabItem value="Javascript" label="Javascript" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```javascript
+ function getNthFaithfulNumber(n) {
+    let faithfulNumbers = [];
+    let power = 0;
+    while (faithfulNumbers.length < n) {
+        let num = Math.pow(7, power);
+        faithfulNumbers.push(num);
+        for (let i = 0; i < faithfulNumbers.length - 1; i++) {
+            faithfulNumbers.push(num + faithfulNumbers[i]);
+        }
+        power++;
+    }
+    return faithfulNumbers[n - 1];
+}
+let n = parseInt(prompt("Enter the value of N:"));
+alert("The " + n + "th faithful number is: " + getNthFaithfulNumber(n));
+
+
+  ```
+
+  </TabItem>
+
+  <TabItem value="Typescript" label="Typescript" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```typescript
+
+function getNthFaithfulNumber(n: number): number {
+    let faithfulNumbers: number[] = [];
+    let power: number = 0;
+    while (faithfulNumbers.length < n) {
+        let num: number = Math.pow(7, power);
+        faithfulNumbers.push(num);
+        for (let i: number = 0; i < faithfulNumbers.length - 1; i++) {
+            faithfulNumbers.push(num + faithfulNumbers[i]);
+        }
+        power++;
+    }
+    return faithfulNumbers[n - 1];
+}
+
+let n: number = parseInt(prompt("Enter the value of N:"));
+alert("The " + n + "th faithful number is: " + getNthFaithfulNumber(n));
+
+                  
+  ```
+
+  </TabItem>
+
+  <TabItem value="Java" label="Java" default>
+  <SolutionAuthor name="@Ishitamukherjee2004"/>
+
+  ```java
+import java.util.*;
+
+public class Main {
+    public static int getNthFaithfulNumber(int n) {
+        List<Integer> faithfulNumbers = new ArrayList<>();
+        int power = 0;
+        while (faithfulNumbers.size() < n) {
+            int num = (int) Math.pow(7, power);
+            faithfulNumbers.add(num);
+            for (int i = 0; i < faithfulNumbers.size() - 1; i++) {
+                faithfulNumbers.add(num + faithfulNumbers.get(i));
+            }
+            power++;
+        }
+        return faithfulNumbers.get(n - 1);
+    }
+    public static void main(String[] args) {
+        Scanner scanner = new Scanner(System.in);
+        System.out.print("Enter the value of N: ");
+        int n = scanner.nextInt();
+        System.out.println("The " + n + "th faithful number is: " + getNthFaithfulNumber(n));
+    }
+}
+
+
+  ```
+
+  </TabItem>
+</Tabs>
+
+
+## Solution Logic:
+This solution works by generating faithful numbers on the fly and storing them in a vector. It starts with the smallest faithful number, 1 (which is 7^0), and then generates larger faithful numbers by adding powers of 7 to the previously generated numbers.
+
+
+## Time Complexity
+
+* The function iterates through the array once, so the time complexity is $O(n log n)$.
+
+## Space Complexity
+
+* The function uses additional space for the result list, so the auxiliary space complexity is $O(n)$.