85 |
91 |
86 | {features.map((props, idx) => (
87 |
90 | 
14 | 15 | ## Algorithm 16 | 17 | - Find the middle index. 18 | - Check whether the element at the middle index is `1` or not. 19 | - Check whether the middle index is zero or whether the element at the position just before the middle index is zero or not. 20 | - If the above conditions are true then the middle index is the first occurrence of `1` in the array. 21 | - If the middle index is not zero and the element at the position just before the middle index is not zero: 22 | - Then repeat the above process for the subarray before the middle index if the middle element is `1`. 23 | - Then repeat the above process for the right subarray if the middle element is not `1`. 24 | 25 | ## Examples 26 | 27 | #### Example 1 28 | 29 | ``` 30 | Let the array be 0,1,1. 31 | The lower index is 0 and upper index is 2. 32 | The middle index is 1. 33 | The element present at index 1 is 1 and the element before it is 0. 34 | So the index 1 is the first occurence of first 1 in array. The position is 2. 35 | ``` 36 | 37 | #### Example 2 38 | 39 | ``` 40 | Let the array be 0,0. 41 | The lower index is 0 and upper index is 1. 42 | The middle index is 0. 43 | The element at the middle index is 0. 44 | The lower index is changed to middle index+1. 45 | However the lower index has become equal to the upper index. So -1 is returned. Occurence of 1 not found. 46 | ``` 47 | 48 | ## Code 49 | 50 | import Tabs from "@theme/Tabs"; 51 | import TabItem from "@theme/TabItem"; 52 | 53 |
23 | 24 | ## Examples 25 | 26 | #### Example 1 27 | 28 | ``` 29 | Let the string be AB+. 30 | A is pushes to the stack. 31 | B is pushed to the stack. 32 | + is an operator. 33 | A and B are popped back and expression +AB is printed. 34 | ``` 35 | 36 | #### Example 2 37 | 38 | ``` 39 | Let the string be AB+C+. 40 | A and B are pushed to stack. 41 | + is an operator, so A and B are popped out and the string +AB is pushed to stack. 42 | C is pushed to stack. 43 | + is operator, so the two elements of the stack are popped out and the string ++ABC is pushed to stack. 44 | ``` 45 | 46 | ## Code 47 | 48 | 49 | import Tabs from "@theme/Tabs"; 50 | import TabItem from "@theme/TabItem"; 51 | 52 |
My React page
23 |This is a React page
24 |Fig. 1: Classification of Data Structures
30 | 31 | Based on the above structure and arrangement of data, non-primitive data structures are further classified into linear and non-linear. 32 | 33 | ### ***Linear and Non-linear Structures*** 34 | Linear data structures are those where data can be processed in a linear fashion i.e one by one sequentially. It includes the following types of data structures: Arrays, Linked Lists, Stacks & Queues. 35 | Non-linear structures are those in which insertion and deletion are not possible in a linear fashion. It includes the following types of data structures: Trees & Graphs. 36 | 37 | ## Major Operations on Data Structures 38 | 39 | This section discusses the different operations that can be performed on various data structures. 40 | 41 | * ***Traversing : *** 42 | Accessing each record or element from a given file exactly once in order to process it is called traversing. For example, to print the marks of all the students in a class. 43 | 44 | * ***Searching : *** 45 | Finding the location of a given key value in a collection of various data items. 46 | It can be possible that the given key-value may or may not be present in that collection. For example, to find the names of all the people who live in a particular house. 47 | 48 | * ***Inserting : *** 49 | Adding a new element into existing files. For example, to add a particular data of a given student who has just enrolled in a school/college. 50 | 51 | * ***Deleting : *** 52 | Removing the elements from a collection of various data items. For example, to delete the data of a student who has dropped out of a school/college. 53 | 54 | * ***Sorting : *** 55 | Arranging the elements in the file or structure either in some logical order (alphabetically increasing order, decreasing order) or mathematical order. For example, arranging a deck of cards in ascending or descending order. 56 | 57 | * ***Merging : *** 58 | Combining the elements of two similar data structures to a new data structure of the same type. For example, when two lists `List A` and `List B` of size `P` and `Q` respectively, of similar type of elements, are joined to produce the third list, `List C` of size `(P+Q)`, then this process is called merging. 59 | 60 | ## Advantages of Data Structures 61 | 62 | Given below are some important ***advantages of data structures***: 63 | 64 | * Proper choice of data structures makes the program efficient in terms of space and time complexity. 65 | * It provides effective and efficient processing of small as well as a large amount of data. 66 | * They are re-usable. 67 | * They make the code cleaner and easier to understand. 68 | * Data structures are specified by an ADT (Abstract Data Type) which provides a level of abstraction. 69 | -------------------------------------------------------------------------------- /docs/data-structures/size-of-binary-tree.mdx: -------------------------------------------------------------------------------- 1 | --- 2 | title: Size of Binary Tree 3 | slug: /data-structures/size-of-binary-tree 4 | --- 5 | 6 | ## Introduction 7 | 8 | In this article, we will see how to find the size of a binary tree. In other words how many nodes are there in a tree. 9 | 10 | ## Explanation 11 | In this we are given an binary tree. We have to find the size of that binary tree means total number of nodes in binary tree. 12 | #### Example 1 13 |
14 |
15 | ```
16 | In the above diagram the binary tree has 5 nodes
17 | So the size of above binary tree is 5
18 |
19 | ```
20 | ## Algorithm
21 |
22 | For finding size of binary tree, we follow the following algorithm:
23 |
24 | * First, we will check that tree is empty or not.
25 |
26 | * If tree is empty then simply return 0 because it has zero size.
27 |
28 | * Otherwise find the size of left subtree and right subtree recursively.
29 |
30 | * Print the size of left subtree + right subtree + 1(for root).
31 |
32 | ## Code
33 |
34 | import Tabs from '@theme/Tabs';
35 | import TabItem from '@theme/TabItem';
36 |
37 |
142 |
143 | #### Output :
144 |
145 | ```
146 | 5
147 | ```
148 |
149 | ## Complexity Analysis
150 |
151 | - **Time Complexity:** `O(n)`
152 |
153 | - **Space Complexity:** `O(h)`
154 |
155 | where `n` is the number of elements and `h` is the height of binary tree.
156 |
--------------------------------------------------------------------------------
/docs/doc-guideline.md:
--------------------------------------------------------------------------------
1 | # DOC GUIDELINE
2 |
3 | ## How to write an article for the website
4 |
5 | 1. All the problems written should necessarily include 3 sections
6 | 1. Explanation of the article
7 | 2. Sample input
8 | 3. Sample output
9 |
10 | 2. All problems should be supplemented by examples of code.
11 |
12 | 3. Every problem should have two or more examples with at least one of them well-explained.
13 |
14 | 4. Time complexity and space complexity should be included, if applicable.
15 |
16 | 5. Formulae or any important point should be highlighted.
17 |
18 | ## GUIDELINES FOR THE CODE
19 | The guidelines for the code:
20 | 1. The width of text in each line should not exceed 60 characters
21 |
22 | 2. All documentations should be written using multi-line comments
23 |
24 | 3. Comments should be written above the code and not beside it.
25 |
26 | 4. Function and variable names should follow camelcasing. Example: uglyNumbers()
27 |
28 | 5. Indentation should be done using 4 spaces.
29 |
30 | 6. In case of the code being written in multiple languages, the output of all the codes should be the same
31 |
32 | 7. There should not be any spaces for function call or function declaration
33 |
34 | 8. Avoid the use of typedef
35 |
36 | 9. Avoid the use of static and global variables
37 |
38 | 10. When using cout, use a space between cout and "<<".
39 |
40 | 11. There should be space after comma in parameter passing and declaration list
41 |
42 | 12. In the beginning of each code, use multiline comments to explain the purpose of the program. Make the points bulleted and short.
43 |
44 | # Reviewing Process
45 |
46 | 1. Submit the article for review after writing it.
47 |
48 | 2. The team will review your article and give you feedback for the article
49 |
50 | 3. Work upon the feedback and improve your article. Submit it again for further review.
51 |
52 | 4. If all the required improvements have been made and the team approves your article, then your article will be published.
53 |
--------------------------------------------------------------------------------
/docs/dynamic-programming/dynamic-programming.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: What is Dynamic Programming?
3 | slug: /dynamic-programming
4 | ---
5 |
6 | This page would serve our needs for documentation of Dynamic Programming.
--------------------------------------------------------------------------------
/docs/dynamic-programming/egg-dropping-problem.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Egg Dropping Problem
3 | slug: /dynamic-programming/egg-dropping-problem
4 | ---
5 |
6 | This page would serve our needs for documentation of the Egg Dropping Problem.
--------------------------------------------------------------------------------
/docs/dynamic-programming/golomb-sequence.mdx:
--------------------------------------------------------------------------------
1 | ---
2 | title: Golomb Sequence
3 | slug: /dynamic-programming/golomb-sequence
4 | ---
5 |
6 | ## Introduction
7 |
8 | Golomb sequence is a non-decreasing sequence of integers where the nth term of the sequence is equal to the number of times `n` appears in the sequence.
9 |
10 | ## Explanation
11 |
12 | - The Golomb sequence is given by,
13 |
14 | `Golomb(1) = 1 (Base case)`
15 |
16 | `Golomb(n) = 1 + Golomb(n - Golomb(Golomb(n - 1))) for n > 1`.
17 |
18 | - Let us see one example:
19 |
20 | ```
21 | - The first few terms of the Golomb sequence are: `1, 2, 2, 3, 3, 4, 4, 4, . . .`
22 | - Here, the first term of the sequence is `1`, which means that `1` must appear only one time in
23 | the sequence.
24 | - Similarly, the second term is `2`, and we can see that `2` appears twice in the sequence.
25 | ```
26 |
27 | ## Algorithm
28 |
29 | ```
30 | - Given a number n.
31 | - Make an array to store the values of the Golomb sequence in a bottom-up manner.
32 | - Initialize array[1] = 1.
33 | - for i = 2 to n
34 | - array[i] = 1 + array[i - array[array[i - 1]]]
35 | - return array[n]
36 | ```
37 |
38 | ## Code
39 |
40 | import Tabs from '@theme/Tabs';
41 | import TabItem from '@theme/TabItem';
42 |
43 | Hello, Docusaurus!
48 | ) 49 | } 50 | ``` 51 | 52 | ```jsx title="src/components/HelloDocusaurus.js" 53 | function HelloDocusaurus() { 54 | returnHello, Docusaurus!
; 55 | } 56 | ``` 57 | 58 | ## Admonitions 59 | 60 | Docusaurus has a special syntax to create admonitions and callouts: 61 | 62 | :::tip My tip 63 | 64 | Use this awesome feature option 65 | 66 | ::: 67 | 68 | :::danger Take care 69 | 70 | This action is dangerous 71 | 72 | ::: 73 | 74 | :::tip My tip 75 | 76 | Use this awesome feature option 77 | 78 | ::: 79 | 80 | :::danger Take care 81 | 82 | This action is dangerous 83 | 84 | ::: 85 | 86 | ## React components 87 | 88 | Thanks to [MDX](https://mdxjs.com/), you can make your doc more interactive and use React components inside Markdown: 89 | 90 | ```jsx 91 | export const Highlight = ({children, color}) => ( 92 | 99 | {children} 100 | 101 | ); 102 | 103 |
15 | 16 | Formula: 17 | 18 | ``` 19 | nth Hexagonal Number: n * (2 * n - 1) 20 | ``` 21 | 22 | We can test whether a positive integer `x` is a hexagonal number or not by calculating below expression: 23 | 24 | ``` 25 | n = (sqrt(8*x + 1) + 1) / 4 26 | 27 | If n is an integer then x is a hexagonal number 28 | Else x is not a hexagonal number 29 | ``` 30 | 31 | Let's have few examples: 32 | 33 | ``` 34 | n = 1 35 | 1st hexagonal number = 1 36 | 37 | n = 3 38 | 3rd hexagonal number = 15 39 | 40 | n = 6 41 | 6th hexagonal number = 66 42 | ``` 43 | 44 | ## Code 45 | 46 | import Tabs from '@theme/Tabs'; 47 | import TabItem from '@theme/TabItem'; 48 | 49 |
17 |
18 | ```
19 | Given arr[8]= | 2 | 4 | 3 | 2 | 4 | 5 | 2 | 3 |
20 | Given number: 3
21 | So we iterate on whole array
22 | And increase the count if current number is equal to 3
23 | So after traversing the whole array it prints the count=2
24 | That means 3 is present 2 times
25 | If number is not present then it returns zero.
26 | ```
27 | ## Algorithm
28 |
29 | For counting occurrence of an element in array, we follow the following algorithm:
30 |
31 | * First, we initialize a count variable with 0.
32 |
33 | * Iterate on whole array and increase the count by 1 when our current element is equal to given element.
34 |
35 | * If element is not present print Invalid.
36 |
37 | * Otherwise display the value of count.
38 |
39 | ## Code
40 |
41 | import Tabs from '@theme/Tabs';
42 | import TabItem from '@theme/TabItem';
43 |
44 | 
15 | 16 | The value of `jth` entry in `ith` line is: 17 | ``` 18 | C(i, j) = i! / ( (i-j)! * j! ), ways to select j objects from the set of i objects 19 | ``` 20 | 21 | Let's have one example: 22 | ``` 23 | n = 3 24 | 25 | 1st row 26 | C(0 ,0) = 1, first element 27 | 28 | 2nd row 29 | C(1 ,0) = 1, first element 30 | C(1 ,1) = 1, second element 31 | 32 | 3rd row 33 | C(2 ,0) = 1, first element 34 | C(2 ,1) = 2, second element 35 | C(2 ,2) = 1, third element 36 | ``` 37 | 38 | ## Algorithm 39 | 40 | - Iterate `i` from `0 to n-1`. 41 | 42 | - For each iteration of `i`, iterate `j` from `0 to i` and print `C(i,j)`. 43 | 44 | ## Code 45 | 46 | import Tabs from '@theme/Tabs'; 47 | import TabItem from '@theme/TabItem'; 48 | 49 |
15 | 16 | Formula: 17 | ``` 18 | nth Tetrahedral Number: (n * (n + 1) * (n + 2)) / 6 19 | ``` 20 | 21 | Let's have few examples: 22 | ``` 23 | n = 3 24 | 3rd tetrahedral number = 10 25 | 26 | n = 5 27 | 5th tetrahedral number = 35 28 | 29 | n = 7 30 | 7th tetrahedral number = 84 31 | ``` 32 | 33 | ## Code 34 | 35 | import Tabs from '@theme/Tabs'; 36 | import TabItem from '@theme/TabItem'; 37 | 38 |
15 | 16 | Let's have one example: 17 | ``` 18 | n = 6 19 | total_points = 1 , total points in the triangle till now 20 | row_point = 2 , point in the next row 21 | 22 | Iteration 1: 23 | total_points = total_points + row_point = 3 24 | row_point = row_point + 1 = 3 25 | 26 | Iteration 2: 27 | total_points = total_points + row_point = 6 28 | row_point = row_point + 1 = 4 29 | 30 | n is a triangular number because total_points became equal to n 31 | ``` 32 | 33 | ## Algorithm 34 | 35 | - Initialize `total_points` to `1` and `row_point` to `2`. 36 | 37 | - Keep on increasing the `total_points` by `row_point` and `row_point` by `1` until `total_points` becomes equal or greater than given number. 38 | 39 | - If `total_points` becomes equal to `n` then it is triangular number. 40 | 41 | ## Code 42 | 43 | import Tabs from '@theme/Tabs'; 44 | import TabItem from '@theme/TabItem'; 45 | 46 |
46 | {imgUrl && (
47 |
54 | );
55 | }
56 |
57 | export default function Home() {
58 | const context = useDocusaurusContext();
59 | const {siteConfig = {}} = context;
60 | return (
61 |
48 | 
49 |
50 | )}
51 |
49 | {title}
52 |{description}
53 |
67 |
80 | {siteConfig.title}
68 |{siteConfig.tagline}
69 |
70 |
76 | Get Started
77 |
78 |
79 |