es
Feedback

¡No caigas en manos de tramposos! Telemetrio encuentra y marca estos canales 👉 Si quieres ver la etiqueta, suscríbete

Leetcode with dani

Leetcode with dani

Ir al canal en Telegram

Join us and let's tackle leet code questions together: improve your problem-solving skills Preparing for coding interviews learning new algorithms and data structures connect with other coding enthusiasts

Mostrar más
1 240
Suscriptores
-124 horas
-37 días
-1730 días
Archivo de publicaciones
Day 2 Q1 31. Next Permutation Medium A permutation of an array of integers is an arrangement of its members into a sequence or linear order. For example, for arr = [1,2,3], the following are all the permutations of arr: [1,2,3], [1,3,2], [2, 1, 3], [2, 3, 1], [3,1,2], [3,2,1]. The next permutation of an array of integers is the next lexicographically greater permutation of its integer. More formally, if all the permutations of the array are sorted in one container according to their lexicographical order, then the next permutation of that array is the permutation that follows it in the sorted container. If such arrangement is not possible, the array must be rearranged as the lowest possible order (i.e., sorted in ascending order). For example, the next permutation of arr = [1,2,3] is [1,3,2]. Similarly, the next permutation of arr = [2,3,1] is [3,1,2]. While the next permutation of arr = [3,2,1] is [1,2,3] because [3,2,1] does not have a lexicographical larger rearrangement. Given an array of integers nums, find the next permutation of nums. The replacement must be in place and use only constant extra memory. Example 1: Input: nums = [1,2,3] Output: [1,3,2] Example 2: Input: nums = [3,2,1] Output: [1,2,3] Example 3: Input: nums = [1,1,5] Output: [1,5,1] Topics : Two pointer and Array Submit
04 feb 2025, 02:25

class Solution:
    def trap(self, height: List[int]) -> int:
        if not height:
            return 0
        left = 0
        right = len(height) - 1
        left_max = right_max = 0
        total = 0
        while left < right:
            if height[left] < height[right]:
                if height[left] >= left_max:
                    left_max = height[left]
                else:
                    total += left_max - height[left]
                left += 1
            else:
                if height[right] >= right_max:
                    right_max = height[right]
                else:
                    total += right_max - height[right]
                right -= 1
        return total
03 feb 2025, 14:55

u can invite ur friends to do questions together
u can invite ur friends to do questions together
03 feb 2025, 13:01

image_2025-02-03_21-00-16.png0.80 KB
03 feb 2025, 13:00
03 feb 2025, ~13:00

photo content
03 feb 2025, 12:58

42. Trapping Rain Water Given n non-negative integers representing an elevation map where the width of each bar is 1, compute
42. Trapping Rain Water Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it can trap after raining. Example 1: Input: height = [0,1,0,2,1,0,1,3,2,1,2,1] Output: 6 Explanation: The above elevation map (black section) is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Example 2: Input: height = [4,2,0,3,2,5] Output: 9 Constraints: n == height.length 1 <= n <= 2 * 104 0 <= height[i] <= 105 who wants to try answering this question? Don’t worry, it’s not too scary! 😄 Try
03 feb 2025, 12:10

Check this Website it has good road map to practice leetcode questions https://neetcode.io/roadmap
03 feb 2025, 12:00

03 feb 2025, 11:59
03 feb 2025, ~11:59

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
       
        num_indices = {}
        for i, num in enumerate(nums):
            if num in num_indices and i - num_indices[num] <= k:
                return True
            num_indices[num] = i

        return False
03 feb 2025, 11:43

class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
       
        num_indices = {}
        for i, num in enumerate(nums):
            if num in num_indices and i - num_indices[num] <= k:
                return True
            num_indices[num] = i

        return False
03 feb 2025, 11:43
03 feb 2025, ~11:44

Understanding Time Complexity with Simple Examples Hey everyone! 👋 Today, we’re going to break down Time Complexity in the simplest way possible. Whether you're a beginner or just need a refresher, this guide will help you understand how algorithms perform as input sizes grow. Let’s dive in! 🚀 What is Time Complexity? Time Complexity is a way to describe how the runtime of an algorithm grows as the input size increases. It helps us compare algorithms and predict their performance without running them on actual machines. We use Big-O Notation (like O(n), O(log n), etc.) to express time complexity. It tells us the upper bound of an algorithm's runtime in the worst-case scenario. Real-Life Example: Finding a Pen in a Classroom Imagine you’re in a classroom with 100 students, and you’ve given your pen to one of them. You need to find it! Here’s how different approaches work: O(n²) Approach: Ask the first student if they have the pen. Also, ask them about the other 99 students. Repeat this for every student. This is inefficient and takes a lot of time. O(n) Approach: Go to each student one by one and ask if they have the pen. This is linear and much better than O(n²). O(log n) Approach: Divide the class into two groups. Ask: “Is the pen on the left or right side?” Repeat this process until you find the student with the pen. This is super efficient! Key Points About Time Complexity It’s Not Actual Runtime: Time Complexity doesn’t measure the exact time an algorithm takes to run. Instead, it measures how the runtime grows as the input size increases. Why Use Big-O? It helps us compare algorithms independent of hardware or programming language. For example, O(n) will always be faster than O(n²) for large inputs.
Examples to Understand Time Complexity

Example 1: Constant Time - O(1)
print("Hello World")
Explanation: The code runs in constant time because it prints "Hello World" only once, no matter the input size.
Time Complexity: O(1)

Example 2: Linear Time - O(n)
n = 8
for i in range(1, n + 1):
    print("Hello World !!!")
Explanation: The code prints "Hello World !!!" n times. As n grows, the runtime grows linearly.
Time Complexity: O(n)

Example 3: Logarithmic Time - O(log n)

n = 8
for i in range(1, n + 1, 2):
    print("Hello World !!!")
Explanation: The loop runs logarithmically because it skips half the steps each time.
Time Complexity: O(log n)

Example 4: Polynomial Time - O(n²)
n = 3
m = 3
arr = [[3, 2, 7], [2, 6, 8], [5, 1, 9]]
sum = 0

for i in range(n):
    for j in range(m):
        sum += arr[i][j]
print(sum)
Explanation: The code uses nested loops to sum all elements in a 2D array.
Time Complexity: O(n * m)
How to Compare Algorithms? To compare algorithms, we focus on: Growth Rate: How does the runtime grow as input size increases? Big-O Notation: Use it to express the upper bound of runtime. For example: O(1) < O(log n) < O(n) < O(n²) < O(2ⁿ) Why Does Time Complexity Matter? Efficiency: Helps us choose the best algorithm for large inputs. Scalability: Ensures our code performs well as data grows. Optimization: Guides us in writing faster and more efficient programs. Final Thoughts Understanding Time Complexity is crucial for writing efficient algorithms. By using Big-O Notation, we can predict how our code will perform and make better decisions when solving problems. Keep practicing, and soon you’ll be a pro at analyzing algorithms! 💪 Got questions? Drop them in the comments below! Let’s learn together. 🚀 Source: GeeksforGeeks and DeepSeek. Share to ur Friends
03 feb 2025, 05:27

Understanding Time Complexity with Simple Examples Hey everyone! 👋 Today, we’re going to break down Time Complexity in the simplest way possible. Whether you're a beginner or just need a refresher, this guide will help you understand how algorithms perform as input sizes grow. Let’s dive in! 🚀 What is Time Complexity? Time Complexity is a way to describe how the runtime of an algorithm grows as the input size increases. It helps us compare algorithms and predict their performance without running them on actual machines. We use Big-O Notation (like O(n), O(log n), etc.) to express time complexity. It tells us the upper bound of an algorithm's runtime in the worst-case scenario. Real-Life Example: Finding a Pen in a Classroom Imagine you’re in a classroom with 100 students, and you’ve given your pen to one of them. You need to find it! Here’s how different approaches work: O(n²) Approach: Ask the first student if they have the pen. Also, ask them about the other 99 students. Repeat this for every student. This is inefficient and takes a lot of time. O(n) Approach: Go to each student one by one and ask if they have the pen. This is linear and much better than O(n²). O(log n) Approach: Divide the class into two groups. Ask: “Is the pen on the left or right side?” Repeat this process until you find the student with the pen. This is super efficient! Key Points About Time Complexity It’s Not Actual Runtime: Time Complexity doesn’t measure the exact time an algorithm takes to run. Instead, it measures how the runtime grows as the input size increases. Why Use Big-O? It helps us compare algorithms independent of hardware or programming language. For example, O(n) will always be faster than O(n²) for large inputs. Examples to Understand Time Complexity Example 1: Constant Time - O(1) bash Copy Edit print("Hello World") Explanation: The code runs in constant time because it prints "Hello World" only once, no matter the input size. Time Complexity: O(1) Example 2: Linear Time - O(n) go Copy Edit n = 8 for i in range(1, n + 1): print("Hello World !!!") Explanation: The code prints "Hello World !!!" n times. As n grows, the runtime grows linearly. Time Complexity: O(n) Example 3: Logarithmic Time - O(log n) go Copy Edit n = 8 for i in range(1, n + 1, 2): print("Hello World !!!") Explanation: The loop runs logarithmically because it skips half the steps each time. Time Complexity: O(log n) Example 4: Polynomial Time - O(n²) lua Copy Edit n = 3 m = 3 arr = [[3, 2, 7], [2, 6, 8], [5, 1, 9]] sum = 0 for i in range(n): for j in range(m): sum += arr[i][j] print(sum) Explanation: The code uses nested loops to sum all elements in a 2D array. Time Complexity: O(n * m) How to Compare Algorithms? To compare algorithms, we focus on: Growth Rate: How does the runtime grow as input size increases? Big-O Notation: Use it to express the upper bound of runtime. For example: O(1) < O(log n) < O(n) < O(n²) < O(2ⁿ) Why Does Time Complexity Matter? Efficiency: Helps us choose the best algorithm for large inputs. Scalability: Ensures our code performs well as data grows. Optimization: Guides us in writing faster and more efficient programs. Final Thoughts Understanding Time Complexity is crucial for writing efficient algorithms. By using Big-O Notation, we can predict how our code will perform and make better decisions when solving problems. Keep practicing, and soon you’ll be a pro at analyzing algorithms! 💪 Got questions? Drop them in the comments below! Let’s learn together. 🚀 Source: GeeksforGeeks and DeepSeek. Share to ur Friends
03 feb 2025, 05:26
03 feb 2025, ~05:26

🌟 Understanding Time Complexity with Simple Examples 🌟 Hey everyone! 👋 Today, we’re breaking down Time Complexity simply. Perfect for beginners or refreshers! Let’s dive in! 🚀 🔍 What is Time Complexity? It describes how an algorithm's runtime grows as input size increases. Measured using Big-O Notation (O(n), O(log n), etc.) for worst-case scenarios. 🏫 Real-Life Example: Finding a Pen in a Classroom 100 students, 1 pen - how to find it? 1. O(n²) Approach: - Ask first student + all 99 others - Repeat for every student → Very inefficient 2. O(n) Approach: - Check each student one by one → Linear efficiency 3. O(log n) Approach: - Split class in half repeatedly → Super efficient! 💡 Key Points: 1. Measures growth rate, not actual runtime 2. Big-O allows hardware/language-agnostic comparisons 📊 Examples: 1. O(1) - Constant Time: print("Hello World") → Runs same time regardless of input 2. O(n) - Linear Time: for i in range(n): print("Hello") → Runtime grows linearly with input 3. O(log n) - Logarithmic: while n > 1: n = n/2 → Halves problem size each step 4. O(n²) - Polynomial: for i in range(n): for j in range(n): sum += i+j → Nested loops = quadratic growth ⚖️ Comparing Algorithms: O(1) < O(log n) < O(n) < O(n²) < O(2ⁿ) 🔑 Why It Matters: - Efficiency for large inputs - Scalability - Performance optimization 💬 Final Thoughts: Mastering time complexity helps write better algorithms. Keep practicing! 💪 Questions? Let’s discuss below! 👇 #Coding #Algorithms #ProgrammingTips Source: GeeksforGeeks & DeepSeek
03 feb 2025, 05:20
03 feb 2025, ~05:21

class Solution: def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool: num_indices = {} for i, num in enumerate(
class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
       
        num_indices = {}
        for i, num in enumerate(nums):
            if num in num_indices and i - num_indices[num] <= k:
                return True
            num_indices[num] = i

        return False
03 feb 2025, 02:47
03 feb 2025, ~11:43

class Solution: def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool: myset = set() l = 0 for i in range(len(nu
class Solution:
    def containsNearbyDuplicate(self, nums: List[int], k: int) -> bool:
        myset = set()
        l = 0
        for i in range(len(nums)):
            while(i-l>k):
                myset.remove(nums[l])
                l+=1
            if nums[i] in myset:
                return True
            myset.add(nums[i])
        return False
03 feb 2025, 02:47

Let’s tackle "Contains Duplicate II"! Day 1 Q 2 Problem Statement: Given an integer array nums and an integer k, return true if there are two distinct indices i and j such that: nums[i] == nums[j] abs(i - j) <= k Otherwise, return false. Examples to Get You Started: 🔹 Example 1: Input: nums = [1,2,3,1], k = 3 Output: true Explanation: The element 1 occurs at indices 0 and 3, and abs(0 - 3) <= 3. 🔹 Example 2: Input: nums = [1,0,1,1], k = 1 Output: true Explanation: The element 1 occurs at indices 2 and 3, and abs(2 - 3) <= 1. 🔹 Example 3: Input: nums = [1,2,3,1,2,3], k = 2 Output: false Explanation: No duplicates satisfy abs(i - j) <= 2. Your Task: Can you solve this efficiently? Think about using hash maps or sliding window techniques! 💡 Pro Tip: This problem is a great way to practice working with dictionaries or hash sets for tracking indices. Drop your solutions in the comments below! Let’s see who can come up with the most optimized approach. 🏆 Submit
03 feb 2025, 02:33

Ans: Fist do by your self
class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        myset = set()
        for i in nums:
            if i in myset:
                return True
            myset.add(i)
        return False
03 feb 2025, 02:29

Day 1 Q 1 Problem Statement: Given an integer array nums, return true if any value appears at least twice in the array, and false if every element is distinct. Examples to Get You Started: 🔹 Example 1: Input: nums = [1,2,3,1] Output: true Explanation: The element 1 occurs at indices 0 and 3. 🔹 Example 2: Input: nums = [1,2,3,4] Output: false Explanation: All elements are distinct. 🔹 Example 3: Input: nums = [1,1,1,3,3,4,3,2,4,2] Output: true Submit
03 feb 2025, 02:23

Hey everyone! 👋 I have a problem: I keep skipping LeetCode practice. 😓 Maybe you do too? Let’s fix this together! Join me: Starting Monday, promise yourself to solve at least 1 question daily from the 3 I share. Small steps, big progress! How it works: 1️⃣ Daily Questions: I’ll post 3 questions every day. Promise yourself to solve at least 1. 2️⃣ Try First: Solve it alone. If stuck, I’ll share answers so we can learn. 3️⃣ Repeat Hard Ones: Save tricky questions. Try them again after 3-4 days. 4️⃣ Help Each Other: Ask for hints or share tips—no shame! what do u think guys?
01 feb 2025, 14:56

🚀 Great Resource Alert! 👉 Mosh for Learning Check out this awesome channel for coding tutorials, tips, and more! It’s been super helpful for me, and I highly recommend it. Happy learning! 💻✨ NOT AN AD!
01 feb 2025, 14:31