From e7e09d6b4052ec0adce154f824a34d9ded860908 Mon Sep 17 00:00:00 2001 From: Kosuri Indu Date: Fri, 26 Jul 2024 16:49:00 +0530 Subject: [PATCH] Concern Regarding Score Reduction and Disappearance of Pull Requests --- .../Easy problems/square-root.md | 386 +++++++++--------- .../01-Fibonacci-Sequence.md | 3 +- 2 files changed, 194 insertions(+), 195 deletions(-) diff --git a/dsa-solutions/gfg-solutions/Easy problems/square-root.md b/dsa-solutions/gfg-solutions/Easy problems/square-root.md index c249e2811..f0c2eb177 100644 --- a/dsa-solutions/gfg-solutions/Easy problems/square-root.md +++ b/dsa-solutions/gfg-solutions/Easy problems/square-root.md @@ -1,193 +1,193 @@ ---- -id: square-root -title: Square Root -sidebar_label: Square-Root -tags: - - Math - - Binary Search -description: "This document provides solutions to the problem of finding the Square Root of an integer." ---- - -## Problem - -Given an integer `x`, find the square root of `x`. If `x` is not a perfect square, then return the floor value of √x. - -### Examples - -**Example 1:** - -``` -Input: x = 5 -Output: 2 -Explanation: Since 5 is not a perfect square, the floor of the square root of 5 is 2. -``` - -**Example 2:** - -``` -Input: x = 4 -Output: 2 -Explanation: Since 4 is a perfect square, its square root is 2. -``` - -### Your Task - -You don't need to read input or print anything. The task is to complete the function `floorSqrt()` which takes `x` as the input parameter and returns its square root. Note: Try solving the question without using the sqrt function. The value of `x` ≥ 0. - -**Expected Time Complexity:** $O(log N)$ -**Expected Auxiliary Space:** $O(1)$ - -**Constraints** - -- `1 ≤ x ≤ 10^7` - -## Solution - -### Intuition & Approach - -To find the square root of a number without using the built-in `sqrt` function, we can use binary search. This approach leverages the fact that the square root of `x` must lie between `0` and `x`. By repeatedly narrowing down the range using binary search, we can efficiently find the floor value of the square root. - -### Implementation - - - - -```python -class Solution: - def floorSqrt(self, x: int) -> int: - if x == 0 or x == 1: - return x - start, end = 1, x - ans = 0 - while start <= end: - mid = (start + end) // 2 - if mid * mid == x: - return mid - if mid * mid < x: - start = mid + 1 - ans = mid - else: - end = mid - 1 - return ans -``` - - - - -```java -class Solution { - long floorSqrt(long x) { - if (x == 0 || x == 1) { - return x; - } - long start = 1, end = x, ans = 0; - while (start <= end) { - long mid = (start + end) / 2; - if (mid * mid == x) { - return mid; - } - if (mid * mid < x) { - start = mid + 1; - ans = mid; - } else { - end = mid - 1; - } - } - return ans; - } -} -``` - - - - -```cpp -class Solution { -public: - long long int floorSqrt(long long int x) { - if (x == 0 || x == 1) - return x; - long long int start = 1, end = x, ans = 0; - while (start <= end) { - long long int mid = (start + end) / 2; - if (mid * mid == x) - return mid; - if (mid * mid < x) { - start = mid + 1; - ans = mid; - } else { - end = mid - 1; - } - } - return ans; - } -}; -``` - - - - -```javascript -class Solution { - floorSqrt(x) { - if (x === 0 || x === 1) { - return x; - } - let start = 1, - end = x, - ans = 0; - while (start <= end) { - let mid = Math.floor((start + end) / 2); - if (mid * mid === x) { - return mid; - } - if (mid * mid < x) { - start = mid + 1; - ans = mid; - } else { - end = mid - 1; - } - } - return ans; - } -} -``` - - - - -```typescript -class Solution { - floorSqrt(x: number): number { - if (x === 0 || x === 1) { - return x; - } - let start = 1, - end = x, - ans = 0; - while (start <= end) { - let mid = Math.floor((start + end) / 2); - if (mid * mid === x) { - return mid; - } - if (mid * mid < x) { - start = mid + 1; - ans = mid; - } else { - end = mid - 1; - } - } - return ans; - } -} -``` - - - - -## Complexity Analysis - -The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $O(1)$. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions. - -**Time Complexity:** $O(log N)$ -**Auxiliary Space:** $O(1)$ +--- +id: square-root +title: Square Root +sidebar_label: Square-Root +tags: + - Math + - Binary Search +description: "This document provides solutions to the problem of finding the Square Root of an integer." +--- + +## Problem + +Given an integer `x`, find the square root of `x`. If `x` is not a perfect square, then return the floor value of √x. + +### Examples + +**Example 1:** + +``` +Input: x = 5 +Output: 2 +Explanation: Since 5 is not a perfect square, the floor of the square root of 5 is 2. +``` + +**Example 2:** + +``` +Input: x = 4 +Output: 2 +Explanation: Since 4 is a perfect square, its square root is 2. +``` + +### Your Task + +You don't need to read input or print anything. The task is to complete the function `floorSqrt()` which takes `x` as the input parameter and returns its square root. Note: Try solving the question without using the sqrt function. The value of `x` ≥ 0. + +**Expected Time Complexity:** $O(log N)$ +**Expected Auxiliary Space:** $O(1)$ + +**Constraints** + +- `1 ≤ x ≤ 10^7` + +## Solution + +### Intuition & Approach + +To find the square root of a number without using the built-in `sqrt` function, we can use binary search. This approach leverages the fact that the square root of `x` must lie between `0` and `x`. By repeatedly narrowing down the range using binary search, we can efficiently find the floor value of the square root. + +### Implementation + + + + +```python +class Solution: + def floorSqrt(self, x: int) -> int: + if x == 0 or x == 1: + return x + start, end = 1, x + ans = 0 + while start <= end: + mid = (start + end) // 2 + if mid * mid == x: + return mid + if mid * mid < x: + start = mid + 1 + ans = mid + else: + end = mid - 1 + return ans +``` + + + + +```java +class Solution { + long floorSqrt(long x) { + if (x == 0 || x == 1) { + return x; + } + long start = 1, end = x, ans = 0; + while (start <= end) { + long mid = (start + end) / 2; + if (mid * mid == x) { + return mid; + } + if (mid * mid < x) { + start = mid + 1; + ans = mid; + } else { + end = mid - 1; + } + } + return ans; + } +} +``` + + + + +```cpp +class Solution { +public: + long long int floorSqrt(long long int x) { + if (x == 0 || x == 1) + return x; + long long int start = 1, end = x, ans = 0; + while (start <= end) { + long long int mid = (start + end) / 2; + if (mid * mid == x) + return mid; + if (mid * mid < x) { + start = mid + 1; + ans = mid; + } else { + end = mid - 1; + } + } + return ans; + } +}; +``` + + + + +```javascript +class Solution { + floorSqrt(x) { + if (x === 0 || x === 1) { + return x; + } + let start = 1, + end = x, + ans = 0; + while (start <= end) { + let mid = Math.floor((start + end) / 2); + if (mid * mid === x) { + return mid; + } + if (mid * mid < x) { + start = mid + 1; + ans = mid; + } else { + end = mid - 1; + } + } + return ans; + } +} +``` + + + + +```typescript +class Solution { + floorSqrt(x: number): number { + if (x === 0 || x === 1) { + return x; + } + let start = 1, + end = x, + ans = 0; + while (start <= end) { + let mid = Math.floor((start + end) / 2); + if (mid * mid === x) { + return mid; + } + if (mid * mid < x) { + start = mid + 1; + ans = mid; + } else { + end = mid - 1; + } + } + return ans; + } +} +``` + + + + +## Complexity Analysis + +The provided solutions efficiently find the floor value of the square root of a given integer `x` using binary search. This approach ensures a time complexity of $ O(log N) and an auxiliary space complexity of $O(1)$. The algorithms are designed to handle large values of `x` up to 10^7 efficiently without relying on built-in square root functions. + +**Time Complexity:** $O(log N)$ +**Auxiliary Space:** $O(1)$ diff --git a/dsa/Algorithms/Dynamic Programming/01-Fibonacci-Sequence.md b/dsa/Algorithms/Dynamic Programming/01-Fibonacci-Sequence.md index 8360fabe3..06edc3ddf 100644 --- a/dsa/Algorithms/Dynamic Programming/01-Fibonacci-Sequence.md +++ b/dsa/Algorithms/Dynamic Programming/01-Fibonacci-Sequence.md @@ -4,7 +4,7 @@ title: Fibonacci Sequence using Dynamic Programming sidebar_label: Fibonacci Sequence tags: [python, java, c++, javascript, programming, algorithms, dynamic programming, tutorial, in-depth] description: In this tutorial, we will learn about the Fibonacci sequence and its implementation using Dynamic Programming in Python, Java, C++, and JavaScript with detailed explanations and examples. ---- +--- # Fibonacci Sequence using Dynamic Programming @@ -13,7 +13,6 @@ $[ F(n) = F(n-1) + F(n-2) ]$ with the base cases: $[ F(0) = 0, F(1) = 1 ]$ - ## Problem Statement Given an integer (n), compute the (n)-th Fibonacci number.