Skip to content

Commit b98d9c0

Browse files
ajay-dhangarajay-dhangar
authored
Merge pull request #3909 from CodeHarborHub/restyled/dev-3
Restyle Debug code and deleted some folders and files
2 parents 16e501b + e2e1729 commit b98d9c0

11 files changed

+609
-607
lines changed

‎courses/recommend.md

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,4 +12,4 @@ hide_table_of_contents: true
1212

1313
import courses from '@site/src/database/courses';
1414

15-
<Courses courses={courses} />
15+
<Courses courses={courses} />

‎dsa-solutions/gfg-solutions/Easy problems/Lucky-Numbers.md

+191-195
Original file line numberDiff line numberDiff line change
@@ -1,195 +1,191 @@
1-
---
2-
id: lucky-number
3-
title: Nth Fibonacci Number
4-
sidebar_label: Nth Fibonacci Number
5-
tags:
6-
- Easy
7-
- Dynamic Programming
8-
- Math
9-
description: "This tutorial covers the solution to the Nth Fibonacci Number problem from the GeeksforGeeks."
10-
---
11-
## Problem Description
12-
13-
Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving at lucky numbers,
14-
Take the set of integers
15-
`1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, `19`,……
16-
First, delete every second number, we get following reduced set.
17-
`1`, `3`, `5`, `7`, `9`, `11`, `13`, `15`, `17`, `19`,…………
18-
Now, delete every third number, we get
19-
`1`, `3`, `7`, `9`, `13`, `15`, `19`,….….
20-
Continue this process indefinitely……
21-
Any number that does NOT get deleted due to above process is called “lucky”.
22-
23-
You are given a number N, you need to tell whether the number is lucky or not. If the number is lucky return 1 otherwise 0.
24-
25-
## Examples
26-
27-
**Example 1:**
28-
29-
```
30-
Input:
31-
N = 5
32-
Output: 0
33-
Explanation: 5 is not a lucky number
34-
as it gets deleted in the second
35-
iteration.
36-
```
37-
38-
**Example 2:**
39-
40-
```
41-
Input:
42-
N = 19
43-
Output: 1
44-
Explanation: 19 is a lucky number because
45-
it does not get deleted throughout the process.
46-
```
47-
48-
## Your Task
49-
50-
You don't need to read input or print anything. You only need to complete the function isLucky() that takes N as parameter and returns either False if the N is not lucky else True.
51-
52-
Expected Time Complexity: $O(sqrt(n))$
53-
54-
Expected Auxiliary Space: $O(1)$ for iterative approach.
55-
56-
## Constraints
57-
58-
* `1 ≤ n ≤ 10^5`
59-
60-
## Problem Explanation
61-
62-
Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving at lucky numbers,
63-
Take the set of integers
64-
`1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, `19`,……
65-
First, delete every second number, we get following reduced set.
66-
`1`, `3`, `5`, `7`, `9`, `11`, `13`, `15`, `17`, `19`,…………
67-
Now, delete every third number, we get
68-
`1`, `3`, `7`, `9`, `13`, `15`, `19`,….….
69-
Continue this process indefinitely……
70-
Any number that does NOT get deleted due to above process is called “lucky”.
71-
72-
You are given a number N, you need to tell whether the number is lucky or not. If the number is lucky return 1 otherwise 0.
73-
74-
## Code Implementation
75-
76-
<Tabs>
77-
<TabItem value="Python" label="Python" default>
78-
<SolutionAuthor name="@Ishitamukherjee2004"/>
79-
80-
```py
81-
def is_lucky(N):
82-
lucky_numbers = list(range(1, N + 1))
83-
delete_step = 2
84-
while delete_step <= len(lucky_numbers):
85-
lucky_numbers = [num for i, num in enumerate(lucky_numbers) if (i + 1) % delete_step != 0]
86-
delete_step += 1
87-
return 1 if N in lucky_numbers else 0
88-
89-
```
90-
91-
</TabItem>
92-
<TabItem value="C++" label="C++">
93-
<SolutionAuthor name="@Ishitamukherjee2004"/>
94-
95-
```cpp
96-
int isLucky(int N) {
97-
vector<int> luckyNumbers;
98-
for (int i = 1; i <= N; i++) {
99-
luckyNumbers.push_back(i);
100-
}
101-
int deleteStep = 2;
102-
while (deleteStep <= luckyNumbers.size()) {
103-
for (int i = deleteStep - 1; i < luckyNumbers.size(); i += deleteStep) {
104-
luckyNumbers.erase(luckyNumbers.begin() + i);
105-
}
106-
deleteStep++;
107-
}
108-
for (int num : luckyNumbers) {
109-
if (num == N) {
110-
return 1;
111-
}
112-
}
113-
return 0;
114-
}
115-
116-
```
117-
118-
</TabItem>
119-
120-
<TabItem value="Javascript" label="Javascript" default>
121-
<SolutionAuthor name="@Ishitamukherjee2004"/>
122-
123-
```javascript
124-
function isLucky(N) {
125-
let luckyNumbers = Array.from({ length: N }, (_, i) => i + 1);
126-
let deleteStep = 2;
127-
while (deleteStep <= luckyNumbers.length) {
128-
luckyNumbers = luckyNumbers.filter((_, i) => (i + 1) % deleteStep !== 0);
129-
deleteStep++;
130-
}
131-
return luckyNumbers.includes(N) ? 1 : 0;
132-
}
133-
134-
135-
```
136-
137-
</TabItem>
138-
139-
<TabItem value="Typescript" label="Typescript" default>
140-
<SolutionAuthor name="@Ishitamukherjee2004"/>
141-
142-
```typescript
143-
function isLucky(N) {
144-
let luckyNumbers = Array.from({ length: N }, (_, i) => i + 1);
145-
let deleteStep = 2;
146-
while (deleteStep <= luckyNumbers.length) {
147-
luckyNumbers = luckyNumbers.filter((_, i) => (i + 1) % deleteStep !== 0);
148-
deleteStep++;
149-
}
150-
return luckyNumbers.includes(N) ? 1 : 0;
151-
}
152-
153-
154-
```
155-
156-
</TabItem>
157-
158-
<TabItem value="Java" label="Java" default>
159-
<SolutionAuthor name="@Ishitamukherjee2004"/>
160-
161-
```java
162-
public int isLucky(int N) {
163-
List<Integer> luckyNumbers = new ArrayList<>();
164-
for (int i = 1; i <= N; i++) {
165-
luckyNumbers.add(i);
166-
}
167-
int deleteStep = 2;
168-
while (deleteStep <= luckyNumbers.size()) {
169-
for (int i = deleteStep - 1; i < luckyNumbers.size(); i += deleteStep) {
170-
luckyNumbers.remove(i);
171-
}
172-
deleteStep++;
173-
}
174-
for (int num : luckyNumbers) {
175-
if (num == N) {
176-
return 1;
177-
}
178-
}
179-
return 0;
180-
}
181-
182-
183-
```
184-
185-
</TabItem>
186-
</Tabs>
187-
188-
189-
## Time Complexity
190-
191-
* The iterative approach has a time complexity of $O(n^2)$.
192-
193-
## Space Complexity
194-
195-
* The space complexity is $O(n)$ since we are using only a fixed amount of extra space.
1+
---
2+
id: lucky-number
3+
title: Nth Fibonacci Number
4+
sidebar_label: Nth Fibonacci Number
5+
tags:
6+
- Easy
7+
- Dynamic Programming
8+
- Math
9+
description: "This tutorial covers the solution to the Nth Fibonacci Number problem from the GeeksforGeeks."
10+
---
11+
12+
## Problem Description
13+
14+
Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving at lucky numbers,
15+
Take the set of integers
16+
`1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, `19`,……
17+
First, delete every second number, we get following reduced set.
18+
`1`, `3`, `5`, `7`, `9`, `11`, `13`, `15`, `17`, `19`,…………
19+
Now, delete every third number, we get
20+
`1`, `3`, `7`, `9`, `13`, `15`, `19`,….….
21+
Continue this process indefinitely……
22+
Any number that does NOT get deleted due to above process is called “lucky”.
23+
24+
You are given a number N, you need to tell whether the number is lucky or not. If the number is lucky return 1 otherwise 0.
25+
26+
## Examples
27+
28+
**Example 1:**
29+
30+
```
31+
Input:
32+
N = 5
33+
Output: 0
34+
Explanation: 5 is not a lucky number
35+
as it gets deleted in the second
36+
iteration.
37+
```
38+
39+
**Example 2:**
40+
41+
```
42+
Input:
43+
N = 19
44+
Output: 1
45+
Explanation: 19 is a lucky number because
46+
it does not get deleted throughout the process.
47+
```
48+
49+
## Your Task
50+
51+
You don't need to read input or print anything. You only need to complete the function isLucky() that takes N as parameter and returns either False if the N is not lucky else True.
52+
53+
Expected Time Complexity: $O(sqrt(n))$
54+
55+
Expected Auxiliary Space: $O(1)$ for iterative approach.
56+
57+
## Constraints
58+
59+
- `1 ≤ n ≤ 10^5`
60+
61+
## Problem Explanation
62+
63+
Lucky numbers are subset of integers. Rather than going into much theory, let us see the process of arriving at lucky numbers,
64+
Take the set of integers
65+
`1`, `2`, `3`, `4`, `5`, `6`, `7`, `8`, `9`, `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, `19`,……
66+
First, delete every second number, we get following reduced set.
67+
`1`, `3`, `5`, `7`, `9`, `11`, `13`, `15`, `17`, `19`,…………
68+
Now, delete every third number, we get
69+
`1`, `3`, `7`, `9`, `13`, `15`, `19`,….….
70+
Continue this process indefinitely……
71+
Any number that does NOT get deleted due to above process is called “lucky”.
72+
73+
You are given a number N, you need to tell whether the number is lucky or not. If the number is lucky return 1 otherwise 0.
74+
75+
## Code Implementation
76+
77+
<Tabs>
78+
<TabItem value="Python" label="Python" default>
79+
<SolutionAuthor name="@Ishitamukherjee2004"/>
80+
81+
```py
82+
def is_lucky(N):
83+
lucky_numbers = list(range(1, N + 1))
84+
delete_step = 2
85+
while delete_step <= len(lucky_numbers):
86+
lucky_numbers = [num for i, num in enumerate(lucky_numbers) if (i + 1) % delete_step != 0]
87+
delete_step += 1
88+
return 1 if N in lucky_numbers else 0
89+
90+
```
91+
92+
</TabItem>
93+
<TabItem value="C++" label="C++">
94+
<SolutionAuthor name="@Ishitamukherjee2004"/>
95+
96+
```cpp
97+
int isLucky(int N) {
98+
vector<int> luckyNumbers;
99+
for (int i = 1; i <= N; i++) {
100+
luckyNumbers.push_back(i);
101+
}
102+
int deleteStep = 2;
103+
while (deleteStep <= luckyNumbers.size()) {
104+
for (int i = deleteStep - 1; i < luckyNumbers.size(); i += deleteStep) {
105+
luckyNumbers.erase(luckyNumbers.begin() + i);
106+
}
107+
deleteStep++;
108+
}
109+
for (int num : luckyNumbers) {
110+
if (num == N) {
111+
return 1;
112+
}
113+
}
114+
return 0;
115+
}
116+
117+
```
118+
119+
</TabItem>
120+
121+
<TabItem value="Javascript" label="Javascript" default>
122+
<SolutionAuthor name="@Ishitamukherjee2004"/>
123+
124+
```javascript
125+
function isLucky(N) {
126+
let luckyNumbers = Array.from({ length: N }, (_, i) => i + 1);
127+
let deleteStep = 2;
128+
while (deleteStep <= luckyNumbers.length) {
129+
luckyNumbers = luckyNumbers.filter((_, i) => (i + 1) % deleteStep !== 0);
130+
deleteStep++;
131+
}
132+
return luckyNumbers.includes(N) ? 1 : 0;
133+
}
134+
```
135+
136+
</TabItem>
137+
138+
<TabItem value="Typescript" label="Typescript" default>
139+
<SolutionAuthor name="@Ishitamukherjee2004"/>
140+
141+
```typescript
142+
function isLucky(N) {
143+
let luckyNumbers = Array.from({ length: N }, (_, i) => i + 1);
144+
let deleteStep = 2;
145+
while (deleteStep <= luckyNumbers.length) {
146+
luckyNumbers = luckyNumbers.filter((_, i) => (i + 1) % deleteStep !== 0);
147+
deleteStep++;
148+
}
149+
return luckyNumbers.includes(N) ? 1 : 0;
150+
}
151+
```
152+
153+
</TabItem>
154+
155+
<TabItem value="Java" label="Java" default>
156+
<SolutionAuthor name="@Ishitamukherjee2004"/>
157+
158+
```java
159+
public int isLucky(int N) {
160+
List<Integer> luckyNumbers = new ArrayList<>();
161+
for (int i = 1; i <= N; i++) {
162+
luckyNumbers.add(i);
163+
}
164+
int deleteStep = 2;
165+
while (deleteStep <= luckyNumbers.size()) {
166+
for (int i = deleteStep - 1; i < luckyNumbers.size(); i += deleteStep) {
167+
luckyNumbers.remove(i);
168+
}
169+
deleteStep++;
170+
}
171+
for (int num : luckyNumbers) {
172+
if (num == N) {
173+
return 1;
174+
}
175+
}
176+
return 0;
177+
}
178+
179+
180+
```
181+
182+
</TabItem>
183+
</Tabs>
184+
185+
## Time Complexity
186+
187+
- The iterative approach has a time complexity of $O(n^2)$.
188+
189+
## Space Complexity
190+
191+
- The space complexity is $O(n)$ since we are using only a fixed amount of extra space.

0 commit comments

Comments
 (0)