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ás1 262
Suscriptores
-224 horas
+27 días
+830 días
Archivo de publicaciones
1 263
Channel Summary for 2025 🎉
Views
• 472 Total Posts
• 501 Average Views
• 236,817 Total Views
Top Post
• 2,058 Views
• https://t.me/leetcodeQ/1131
Activity
• 7 PM is when you were most active
• Wednesday is your most active day
• February is your most active month
@channel_unwrapped_bot #channel_unwrapped
1 263
'''
You are given a 2D integer array of student data students, where students[i] = [student_id, bench_id] represents that student student_id is sitting on the bench bench_id.
Return the maximum number of unique students sitting on any single bench. If no students are present, return 0.
Note: A student can appear multiple times on the same bench in the input, but they should be counted only once per bench.
Example 1:
Input: students = [[1,2],[2,2],[3,3],[1,3],[2,3]]
Output: 3
Explanation:
Bench 2 has two unique students: [1, 2].
Bench 3 has three unique students: [1, 2, 3].
The maximum number of unique students on a single bench is 3.
Example 2:
Input: students = [[1,1],[2,1],[3,1],[4,2],[5,2]]
Output: 3
Explanation:
Bench 1 has three unique students: [1, 2, 3].
Bench 2 has two unique students: [4, 5].
The maximum number of unique students on a single bench is 3.
Example 3:
Input: students = [[1,1],[1,1]]
Output: 1
Explanation:
The maximum number of unique students on a single bench is 1.
Example 4:
Input: students = []
Output: 0
Explanation:
Since no students are present, the output is 0.
Constraints:
0 <= students.length <= 100
students[i] = [student_id, bench_id]
1 <= student_id <= 100
1 <= bench_id <= 100
'''
# max = max(
# iterate 1-n / len array O(n)
# iterate over each rows O(n)
# compare prev row prev index
# if greater update max value
# return max value
# create hash map
# iterate over 0-n/ len arrar
# bech id as key , count
# iterate over the hash map
# return the max value
def counter(arr):
studentCounter = {} # O(n)
for i in range(len(arr)): # O(n)
studentCounter[arr[i][1]] = studentCounter.get(arr[i][1],set())
studentCounter[arr[i][1]].add(arr[i][0])
max_students = 0
for students in studentCounter.values(): # O(m)
max_students = max(max_students, len(students))
return max_students
# time complexity -- O(n+m) = O(n)
# space complexity -- O(n)
students = [[1,2]]
print(counter(students))
1 263
Repost from Hi, AI • Tech News
🚨 Indian Redditor Turns The Tables On Scammer With ChatGPT
A Reddit user named RailfanHS almost fell for a classic scam: "pay the delivery fee," and your money quietly disappears into the scammer's pocket.
Instead of falling for it, he decided to fight back and built a fake payment page using ChatGPT—all it took was a single prompt:
"Write code for a simple website that looks like a payment gateway, but when it loads, it asks for camera and GPS access, takes a photo, and sends it to the backend."The AI produced a working solution in a couple of minutes. RailfanHS sent the scammer the link and told him to "scan the QR code to speed up the payment." 📸 The scammer, eager for easy money, clicked "Allow" without thinking. The script instantly captured his selfie and exact coordinates and sent them back to the would‑be victim. The scammer got so scared he started calling back, begging and swearing he'd "quit this job!"
"Satisfaction of stealing from a thief is crazy," the author concluded.@hiaimediaen
1 263
'''
There are n windows open numbered from 1 to n, we want to simulate using alt + tab to navigate between the windows.
You are given an array windows which contains the initial order of the windows (the first element is at the top and the last one is at the bottom).
You are also given an array queries where for each query, the window queries[i] is brought to the top.
Return the final state of the array windows.
Example 1:
Input: windows = [1,2,3], queries =
[3,2,1]
Output: [2,3,1]
Explanation:
Here is the window array after each query:
Initial order: [1,2,3]
After the first query: [3,1,2]
After the second query: [3,1,2]
After the last query: [2,3,1]
Example 2:
Input: windows = [1,4,2,3], queries = [4,1,3]
Output: [3,1,4,2]
Explanation:
Here is the window array after each query:
Initial order: [1,4,2,3]
After the first query: [4,1,2,3]
After the second query: [1,4,2,3]
After the last query: [3,1,4,2]
Constraints:
1 <= n == windows.length <= 10**3
windows is a permutation of [1, n].
1 <= queries.length <= 10**3
1 <= queries[i] <= n
Follow Up: What if the constraint is 10^5?
'''
1 263
'''
You are given an integer n perform the following steps:
Convert each digit of n into its lowercase English word (e.g., 4 → "four", 1 → "one").
Concatenate those words in the original digit order to form a string s.
Return the number of distinct characters in s that appear an odd number of times.
Example 1:
Input: n = 41
Output: 5
Explanation:
41 → "fourone"
Characters with odd frequencies: 'f', 'u', 'r', 'n', 'e'. Thus, the answer is 5.
Example 2:
Input: n = 20
Output: 5
Explanation:
20 → "twozero"
Characters with odd frequencies: 't', 'w', 'z', 'e', 'r'. Thus, the answer is 5.
Constraints:
1 <= n <= 10**9
'''
def converted_inreger(n):
corresponding_lettr ={
0:"zero",
1:"one",
2:"two",
3:"three",
4:"four",
5:"five",
6:"six",
7:"seven",
8:"eight",
9:"nine"
}
coverted = ""
for i in str(n):
coverted += corresponding_lettr[int(i)]
count = 0
freq = {}
for s in coverted:
if s in freq:
freq[s] += 1
else:
freq[s] = 1
for st in freq:
if freq[st] % 2 != 0:
count += 1
return count
res = converted_inreger(41)
print(res)
1 263
'''
You are given an integer array nums. Return the largest integer that occurs exactly once in the array. If no integer occurs once, return -1.
Example 1
Input:
nums = [5,7,3,9,4,9,8,3,1]
Output:
8
Explanation:
The largest value is 9, but it appears twice.
The largest number that appears exactly once is 8.
Example 2
Input:
nums = [9,9,8,8]
Output:
-1
Explanation:
All numbers appear more than once, so return -1.
Constraints
1 <= nums.length <= 2000
0 <= nums[i] <= 1000
'''
1 263
'''
There are n kids with candies. You are given an integer array candies, where each candies[i] represents the number of candies the ith kid has, and an integer extraCandies, denoting the number of extra candies that you have.
Return a boolean array result of length n, where result[i] is true if, after giving the ith kid all the extraCandies, they will have the greatest number of candies among all the kids, or false otherwise.
Note that multiple kids can have the greatest number of candies.
Example 1:
Input: candies = [2,3,5,1,3], extraCandies = 3
Output: [true,true,true,false,true]
Explanation: If you give all extraCandies to:
Kid 1, they will have 2 + 3 = 5 candies, which is the greatest among the kids.
Kid 2, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
Kid 3, they will have 5 + 3 = 8 candies, which is the greatest among the kids.
Kid 4, they will have 1 + 3 = 4 candies, which is not the greatest among the kids.
Kid 5, they will have 3 + 3 = 6 candies, which is the greatest among the kids.
Example 2:
Input: candies = [4,2,1,1,2], extraCandies = 1
Output: [true,false,false,false,false]
Explanation: There is only 1 extra candy.
Kid 1 will always have the greatest number of candies, even if a different kid is given the extra candy.
Example 3:
Input: candies = [12,1,12], extraCandies = 10
Output: [true,false,true]
Constraints:
n == candies.length
2 <= n <= 100
1 <= candies[i] <= 100
1 <= extraCandies <= 50
'''
##function to add the extraccandies to each elements and compare
def compare_candies(arr, extra_candies):
max_candy = max(arr)
result = []
for num in arr:
result.append(num + extra_candies >= max_candy)
return result
candies = [2,3,5,1,3]
extraCandies = 3
print(compare_candies(candies, extraCandies))1 263
'''
Given an integer array nums, return true if nums is consecutive, otherwise return false. An array is consecutive if it contains every number in the range [x, x + n - 1] (inclusive), where x is the minimum number in the array and n is the length of the array.
Example 1:
Input: nums = [1,3,4,2]
1 - 0
2 - 1
index = val - min
for i in range(x,x+n-1+1):
if arr[i - x] != i
return False
return True
mn = 1
len = 4
[1,4]
Output: true
Explanation: The minimum value is 1 and the length of nums is 4. All of the values in the range [x, x + n - 1] = [1, 1 + 4 - 1] = [1, 4] = (1, 2, 3, 4) occur in nums.
Therefore, nums is consecutive.
Example 2:
Input: nums = [1,3]
mn = 1
len = 2
[1,2]
Output: false
Explanation: The minimum value is 1 and the length of nums is 2. The value 2 in the range [x, x + n - 1] = [1, 1 + 2 - 1], = [1, 2] = (1, 2) does not occur in nums.
Therefore, nums is not consecutive.
Example 3:
Input: nums = [3,5,4]
Output: true
Explanation: The minimum value is 3 and the length of nums is 3. All of the values in the range [x, x + n - 1] = [3, 3 + 3 - 1] = [3, 5] = (3, 4, 5) occur in nums. Therefore, nums is consecutive.
Constraints:
1 <= nums.length <= 10**5
0 <= nums[i] <= 10**5
approach
- prepare an arr that contains all the elemets in the range
- sort my array
'''
def check_consecutive(nums):
n = len(nums)
nums.sort()
minVal = nums[0]
for val in range(minVal, minVal + n ):
index = val - minVal
if nums[index] != val:
return False
return True
# time-compexity
nums = [1,3,4,2]
print(check_consecutive(nums))
1 263
'''
You have some apples and a basket that can carry up to 5000 units of weight.
Given an integer array weight where weight[i] is the weight of the ith apple, return the maximum number of apples you can put in the basket.
Example 1:
Input: weight = [100,200,150,1000]
Output: 4
Explanation: All 4 apples can be carried by the basket since their sum of weights is 1450.
Example 2:
Input: weight = [900,950,800,1000,700,800]
Output: 5
Explanation: The sum of weights of the 6 apples exceeds 5000 so we choose any 5 of them.
'''
weight = [100,200,150,5000]
def max_apple(weight):
left = 0
sum = 0
weight.sort()
while left < len(weight):
sum += weight[left]
if sum > 5000:
return left
else:
left +=1
return left
w = max_apple(weight)
print(w)
1 263
Repost from ALX Ethiopia
+8
The ALX x CodeLeague National Challenge was a huge success! Nearly 50 teams battled it out on Codeforces, celebrating top performers and first solvers. Big thanks to everyone who competed and pushed Ethiopian tech forward! 🚀🏆
#ALXEthiopia #CodeLeagueEthiopia #CompetitiveProgramming #Codeforces #DSA #ALXAfrica #LifeAtALX
1 263
Given a binary array nums, return the maximum number of consecutive 1's in the array if you can flip at most one 0. Example 1: Input: nums = [1,0,1,1,0] Output: 4 Explanation: - If we flip the first zero, nums becomes [1,1,1,1,0] and we have 4 consecutive ones. - If we flip the second zero, nums becomes [1,0,1,1,1] and we have 3 consecutive ones. The max number of consecutive ones is 4. Example 2: Input: nums = [1,0,1,1,0,1] Output: 4 Explanation: - If we flip the first zero, nums becomes [1,1,1,1,0,1] and we have 4 consecutive ones. - If we flip the second zero, nums becomes [1,0,1,1,1,1] and we have 4 consecutive ones. The max number of consecutive ones is 4. Constraints: 1 <= nums.length <= 10**3 nums[i] is either 0 or 1.Today's question
