Available now! Telegram Research 2025 β the year's key insights 
Coding Interview Resources
Open in Telegram
This channel contains the free resources and solution of coding problems which are usually asked in the interviews. Managed by: @love_data
Show moreπ Analytical overview of Telegram channel Coding Interview Resources
Channel Coding Interview Resources (@crackingthecodinginterview) in the English language segment is an active participant. Currently, the community unites 52 168 subscribers, ranking 2 573 in the Technologies & Applications category and 7 189 in the India region.
π Audience metrics and dynamics
Since its creation on Π½Π΅Π²ΡΠ΄ΠΎΠΌΠΎ, the project has demonstrated rapid growth, gathering an audience of 52 168 subscribers.
According to the latest data from 13 June, 2026, the channel demonstrates stable activity. Although there has been a change in the number of participants by 174 over the last 30 days and by 29 over the last 24 hours, overall reach remains high.
- Verification status: Not verified
- Engagement rate (ER): The average audience engagement rate is 2.17%. Within the first 24 hours after publication, content typically collects 0.87% reactions from the total number of subscribers.
- Post reach: On average, each post receives 1 130 views. Within the first day, a publication typically gains 452 views.
- Reactions and interaction: The audience actively supports content: the average number of reactions per post is 2.
- Thematic interests: Content is focused on key topics such as array, stack, algorithm, programming, sort.
π Description and content policy
The author describes the resource as a platform for expressing subjective opinions:
βThis channel contains the free resources and solution of coding problems which are usually asked in the interviews.
Managed by: @love_dataβ
Thanks to the high frequency of updates (latest data received on 14 June, 2026), the channel maintains relevance and a high level of publication reach. Analytics show that the audience actively interacts with content, making it an important point of influence in the Technologies & Applications category.
52 168
Subscribers
+2924 hours
+507 days
+17430 days
Posts Archive
Problem: You are given a string with distinct letters. How to find k-th (lexicographically) permutation of this string?
Solution: Basically, each rectangle is represented by two segments on X and Y axes. Rectangles overlap if both segments overlap. Then we can compute the coordintates of vertices of the intersection by combining coordinate of left and right points of segment intersections. There is a good explanation of this idea here: https://www.interviewcake.com/question/java/rectangular-love
Problem: You are given 2 rectanges with sides parallel to the axes. The rectangles are specified with the coordinates of their vertices. Find a rectangle that represents the intersection of the given rectangles.
Solution: Basically, each rectangle is represented by two segments on X and Y axes. Rectangles overlap if both segments overlap. Then we can compute the coordintates of vertices of the intersection by combining coordinate of left and right points of segment intersections. There is a good explanation of this idea here: https://www.interviewcake.com/question/java/rectangular-love
Problem: You are given 2 rectanges with sides parallel to the axes. The rectangles are specified with the coordinates of their vertices. Find a rectangle that represents the intersection of the given rectangles.
Question: You have two sorted arrays A and B. Array A actually has some empty elements at the end, that would fit B. How to merge A and B together in sorted order?
Solution: typically, when we need to combine multiple sorted sequences into one we use merge sort. However, if we start from the beginning of A and B and store result in A we would have to move elemenets. But we can start merge sort from the end of arrays, thus filling in empty spaces in A.
Solution: If the array only contained positive integers the sorted array of squares would have the same order. When we also have negative numbers their squares would interleave with squares of positive numbers. But nevertheless we have the following property: |a_i| < |a_j| => a_i^2 < a_j^2. Therefore, the smallest square would come from the smallest absolute value. We can find zero (or the place where sign of numbers change) in the original array (using binary search) and then maintain two indexes to the current negative and positive candidates. On each step we check which of these numbers have smaller absolute value and add its square to the result, while advancing the corresponding index (backwards for negatives and forward for positives).
Problem: given a sorted array of integers (not necessarily positive) return a sorted array of squares of these integers.
Solution: A good first attempt is to realize that whenever we are dealing with sums over segments in array, we can precompute partials sums from 0 to i and then easily compute a sum on any interval as sum[i] - sum[j-1]. Using this approach we can iterate over all possible left ends of the interval and then find the right, which gives the sum closest to the given T. To do this we realize that since we only have positive integers, the sum will only increase as the interval get longer. Thus we can do binary search to find the right end. This gives us O(nlogn) solution. But we can do better. Let's start with some interval and try to grow/shrink it to make its sum closer to T. If the current sum is less than T, we know we need to grow the segment, so we move the right boundary. If the current sum is less than T we increment the left boundary. We can start with a segment that only contains a single left-most element and work our way to the right by constantly shifting either left or right end of the segment.
Problem: given an array of positive integers and a target total of T, find a contiguous subarray with sum equals T.
Solution: This kind of problems might be quite surprising, but they are not uncommon. These problems test your ability to think analytically in difficult situations. You need to demonstrate that you don't panic and don't get confused. With this particular problem we need to start from the basics: how to count the number of balls? We need to know the volume of a limousine and a ball and then we can divide one by the other. Next, we can estimate the volume of a limousine, e.g. by guessing its length, width and height and making some reasonable assumptions.
Next Problem:
How many tennis balls can you fit into a limousine?
Answer will be posted after 1 hour
It's my suggestion to go through problems first and try to solve them yourself before checking the solution. That's the best way to learn ππ
Solution: This is problem can have different solutions depending on requirements. Using hash map (or better just a bit vector) to keep track of the numbers we've seen while scanning the sequence we can solve the problem in O(n) time. However, we need O(n) space. Can we do this in O(1) memory? Brute force solution could be to try all elements first and look for a duplicate in second scan, which is O(n^2) time. Can we do better?... By sorting the array first we can move duplicates together and check in a single scan, which means O(n log n) total time complexity. What if we are not allowed to modify the original list of numbers? In this case we can use binary search. Let's count how many numbers from 1 to N/2 we have in our array. If we have more than half numbers from this range, than there is a duplicate, otherwise the duplicate must be from N/2 to N-1. This solution also has O(n log n) complexity.
Next Problem:
You are given an array of N numbers, each of which is from 1 to N-1. There is at least one duplicate (may be more). How to find a duplicate? What are some approaches when we do and don't have much additional memory?
Some possible solution for the problem posted above:
balanced binary search tree will provide us with all of these operations in O(log n). If some operations are more frequent, e.g. find max, min, we can use min and max heaps to make these operations in O(1). All elements are stored in linked list and heaps store pointers to nodes, so we can remove min and max in O(1) as well. Unfortunately, delete will take O(n). Please take a look at the following links for more ideas and discussion: http://www.geeksforgeeks.org/a-data-structure-question/
Create and implement a data structure that provides the following operations:
- insert
- delete
- find min
- find max
- delete min
- delete max
