53.

Maximum Subarray

Given an integer array nums, find the subarray with the

largest sum, and return its sum.

Example 1:

Input: nums = [-2,1,-3,4,-1,2,1,-5,4]

Output: 6
Explanation: The subarray [4,-1,2,1] has the largest sum
6.
Example 2:

Input: nums = [1]

Output: 1
Explanation: The subarray [1] has the largest sum 1.
Example 3:

Input: nums = [5,4,-1,7,8]

Output: 23
Explanation: The subarray [5,4,-1,7,8] has the largest
sum 23.

Constraints:

1 <= nums.length <= 105

-104 <= nums[i] <= 104

Follow up: If you have figured out the O(n) solution, try
coding another solution using the divide and conquer
approach, which is more subtle.

Solution
#include <stdio.h>
#include <stdlib.h>

// Function to find the maximum subarray sum using

Kadane's algorithm
int maxSubArray(int* nums, int numsSize) {
int sum1 = nums[0], sum2 = nums[0];
for (int i = 1; i < numsSize; i++) {
if (sum1 + nums[i] > nums[i])
sum1 = sum1 + nums[i];
else
 sum1 = nums[i];
if (sum1 > sum2)
sum2 = sum1;
}
return sum2;
}

int main() {
int numsSize;

// Read the size of the array

printf("Enter the size of the array: ");
scanf("%d", &numsSize);

// Allocate memory for the array

int* nums = (int*)malloc(numsSize * sizeof(int));

// Read the elements of the array

printf("Enter the elements of the array: ");
for (int i = 0; i < numsSize; i++)
scanf("%d", &nums[i]);

// Find and print the maximum subarray sum

int maxSum = maxSubArray(nums, numsSize);
printf("The maximum subarray sum is: %d\n", maxSum);

// Free the allocated memory

free(nums);

return 0;
}
4. Median of Two Sorted Arrays
Given two sorted arrays nums1 and nums2 of size m and n
respectively, return the median of the two sorted arrays.

The overall run time complexity should be O(log (m+n)).

Example 1:

Input: nums1 = [1,3], nums2 = [2]

Output: 2.00000
Explanation: merged array = [1,2,3] and median is 2.
Example 2:

Input: nums1 = [1,2], nums2 = [3,4]

Output: 2.50000
Explanation: merged array = [1,2,3,4] and median is (2 +
3) / 2 = 2.5.

Constraints:

nums1.length == m
nums2.length == n
0 <= m <= 1000
0 <= n <= 1000
1 <= m + n <= 2000
-106 <= nums1[i], nums2[i] <= 106

Solution
#include <stdio.h>
#include <stdlib.h>

// Function to find the median of two sorted arrays

double findMedianSortedArrays(int* nums1, int m, int*
nums2, int n) {
// Ensure nums1 is the smaller array
if (m > n)
return findMedianSortedArrays(nums2, n, nums1, m);

int imin = 0, imax = m, half_len = (m + n + 1) / 2;

while (imin <= imax) {
int i = (imin + imax) / 2;
int j = half_len - i;
 if (i < m && nums1[i] < nums2[j - 1])
imin = i + 1; // i is too small, must
increase it
else if (i > 0 && nums1[i - 1] > nums2[j])
imax = i - 1; // i is too big, must decrease
it
else { // i is perfect
int max_of_left;
if (i == 0)
max_of_left = nums2[j - 1];
else if (j == 0)
max_of_left = nums1[i - 1];
else
max_of_left = (nums1[i - 1] > nums2[j -
1]) ? nums1[i - 1] : nums2[j - 1];
if ((m + n) % 2 == 1)
return max_of_left;
int min_of_right;
if (i == m)
min_of_right = nums2[j];
else if (j == n)
min_of_right = nums1[i];
else
min_of_right = (nums1[i] < nums2[j]) ?
nums1[i] : nums2[j];
return (max_of_left + min_of_right) / 2.0;
}
}

return 0.0; // Should never be reached

}

int main() {
int m, n;

// Read the size of the first array

printf("Enter the size of the first array: ");
scanf("%d", &m);

// Allocate memory for the first array

int* nums1 = (int*)malloc(m * sizeof(int));

// Read the elements of the first array

printf("Enter the elements of the first array: ");
for (int i = 0; i < m; i++)
scanf("%d", &nums1[i]);

// Read the size of the second array

 printf("Enter the size of the second array: ");
scanf("%d", &n);

// Allocate memory for the second array

int* nums2 = (int*)malloc(n * sizeof(int));

// Read the elements of the second array

printf("Enter the elements of the second array: ");
for (int i = 0; i < n; i++)
scanf("%d", &nums2[i]);

// Find and print the median of the two sorted arrays

double median = findMedianSortedArrays(nums1, m,
nums2, n);
printf("The median of the two sorted arrays
is: %.5f\n", median);

// Free the allocated memory

free(nums1);
free(nums2);

return 0;
}
11. Container With Most Water

You are given an integer array height of length n. There

are n vertical lines drawn such that the two endpoints of
the ith line are (i, 0) and (i, height[i]).

Find two lines that together with the x-axis form a

container, such that the container contains the most
water.

Return the maximum amount of water a container can store.

Notice that you may not slant the container.

Example 1:

Input: height = [1,8,6,2,5,4,8,3,7]

Output: 49
Explanation: The above vertical lines are represented by
array [1,8,6,2,5,4,8,3,7]. In this case, the max area of
water (blue section) the container can contain is 49.
Example 2:

Input: height = [1,1]

Output: 1

Constraints:

n == height.length
2 <= n <= 105
0 <= height[i] <= 104

Solution
#include <stdio.h>
#include <stdlib.h>

// Function to find the maximum area

int maxArea(int* height, int heightSize) {
int left = 0;
int right = heightSize - 1;
int maxArea = 0;

while (left < right) {

int currentArea = (right - left) * (height[left]
< height[right] ? height[left] : height[right]);
if (currentArea > maxArea)
maxArea = currentArea;
if (height[left] < height[right])
left++;
else
right--;
}

return maxArea;
}

int main() {
int n;

// Read the size of the array

printf("Enter the number of elements: ");
scanf("%d", &n);

// Allocate memory for the array

int* height = (int*)malloc(n * sizeof(int));

// Read the elements of the array

printf("Enter the heights: ");
for (int i = 0; i < n; i++)
scanf("%d", &height[i]);

// Find and print the maximum area

int max_area = maxArea(height, n);
printf("The maximum area is: %d\n", max_area);

// Free the allocated memory

free(height);

return 0;
}
215. Kth Largest Element in an Array

Given an integer array nums and an integer k, return the

kth largest element in the array.

Note that it is the kth largest element in the sorted

order, not the kth distinct element.

Can you solve it without sorting?

Example 1:

Input: nums = [3,2,1,5,6,4], k = 2

Output: 5
Example 2:

Input: nums = [3,2,3,1,2,4,5,5,6], k = 4

Output: 4

Constraints:

1 <= k <= nums.length <= 105

-104 <= nums[i] <= 104

Solution

#include <stdio.h>
#include <stdlib.h>

// Function to maintain the min-heap property

void heapify(int* heap, int heapSize, int i) {
int smallest = i; // Initialize smallest as root
int left = 2 * i + 1; // Left child
int right = 2 * i + 2; // Right child

// If left child is smaller than root

if (left < heapSize && heap[left] < heap[smallest])
smallest = left;

// If right child is smaller than the smallest so far

if (right < heapSize && heap[right] < heap[smallest])
smallest = right;

// If the smallest is not root

 if (smallest != i) {
// Swap values using XOR swap
heap[i] ^= heap[smallest] ^= heap[i] ^=
heap[smallest];
// Recursively heapify the affected sub-tree
heapify(heap, heapSize, smallest);
}
}

// Function to build a min-heap from the first k elements

void buildMinHeap(int* heap, int heapSize) {
// Build heap (rearrange array)
for (int i = heapSize / 2 - 1; i >= 0; i--)
heapify(heap, heapSize, i);
}

// Function to find the kth largest element in the array

int findKthLargest(int* nums, int numsSize, int k) {
// Allocate memory for a heap of size k
int* heap = (int*)malloc(k * sizeof(int));

// Initialize the heap with the first k elements

for (int i = 0; i < k; i++)
heap[i] = nums[i];

// Build the min-heap

buildMinHeap(heap, k);

// Process the remaining elements of the array

for (int i = k; i < numsSize; i++)
// If the current element is larger than the root
of the heap
if (nums[i] > heap[0]) {
// Replace the root with the current element
heap[0] = nums[i];
// Heapify the root to maintain the min-heap
property
heapify(heap, k, 0);
}

// The root of the heap is the kth largest element

int kthLargest = heap[0];

// Free the allocated memory for the heap

free(heap);

// Return the kth largest element

return kthLargest;
}
int main() {
int numsSize;
int k;

// Read the size of the array from the user

printf("Enter the number of elements: ");
scanf("%d", &numsSize);

// Allocate memory for the array

int* nums = (int*)malloc(numsSize * sizeof(int));

// Read the elements of the array from the user

printf("Enter the elements of the array: ");
for (int i = 0; i < numsSize; i++)
scanf("%d", &nums[i]);

// Read the value of k from the user

printf("Enter the value of k: ");
scanf("%d", &k);

// Find and print the kth largest element

int result = findKthLargest(nums, numsSize, k);
printf("The %dth largest element is %d\n", k, result);

// Free the allocated memory for the array

free(nums);

return 0;
}
518. Coin Change II

You are given an integer array coins representing coins

of different denominations and an integer amount
representing a total amount of money.

Return the number of combinations that make up that

amount. If that amount of money cannot be made up by any
combination of the coins, return 0.

You may assume that you have an infinite number of each

kind of coin.

The answer is guaranteed to fit into a signed 32-bit

integer.

Example 1:

Input: amount = 5, coins = [1,2,5]

Output: 4
Explanation: there are four ways to make up the amount:
5=5
5=2+2+1
5=2+1+1+1
5=1+1+1+1+1
Example 2:

Input: amount = 3, coins = [2]

Output: 0
Explanation: the amount of 3 cannot be made up just with
coins of 2.
Example 3:

Input: amount = 10, coins = [10]

Output: 1

Constraints:

1 <= coins.length <= 300

1 <= coins[i] <= 5000
All the values of coins are unique.
0 <= amount <= 5000

Solution
#include <stdio.h>
#include <stdlib.h>

int change(int amount, int* coins, int coinsSize) {

// Allocate and initialize the dp array
int* dp = (int*)calloc(amount + 1, sizeof(int));
dp[0] = 1; // There's one way to make amount 0, which
is to use no coins

// Fill the dp array

for (int i = 0; i < coinsSize; i++)
for (int j = coins[i]; j <= amount; j++)
dp[j] += dp[j - coins[i]];

int result = dp[amount];

free(dp); // Free the allocated memory
return result;
}

int main() {
int amount;
int coinsSize;

// Read the amount

printf("Enter the amount: ");
scanf("%d", &amount);

// Read the number of coins

printf("Enter the number of different coins: ");
scanf("%d", &coinsSize);

// Allocate memory for the coins array

int* coins = (int*)malloc(coinsSize * sizeof(int));

// Read the coin denominations

printf("Enter the coin denominations: ");
for (int i = 0; i < coinsSize; i++)
scanf("%d", &coins[i]);

// Find and print the number of combinations

int result = change(amount, coins, coinsSize);
printf("The number of combinations to make up the
amount %d is %d\n", amount, result);

// Free the allocated memory

free(coins);

return 0;
}
1365. How Many Numbers Are Smaller
Than the Current Number

Given the array nums, for each nums[i] find out how many
numbers in the array are smaller than it. That is, for
each nums[i] you have to count the number of valid j's
such that j != i and nums[j] < nums[i].

Return the answer in an array.

Example 1:

Input: nums = [8,1,2,2,3]

Output: [4,0,1,1,3]
Explanation:
For nums[0]=8 there exist four smaller numbers than it (1,
2, 2 and 3).
For nums[1]=1 does not exist any smaller number than it.
For nums[2]=2 there exist one smaller number than it (1).
For nums[3]=2 there exist one smaller number than it (1).
For nums[4]=3 there exist three smaller numbers than it
(1, 2 and 2).
Example 2:

Input: nums = [6,5,4,8]

Output: [2,1,0,3]
Example 3:

Input: nums = [7,7,7,7]

Output: [0,0,0,0]

Constraints:

2 <= nums.length <= 500

0 <= nums[i] <= 100
Solution
#include <stdio.h>
#include <stdlib.h>

int* smallerNumbersThanCurrent(int* nums, int numsSize,

int* returnSize) {
// Allocate memory for the result array
*returnSize = numsSize;
int* result = (int*)malloc(numsSize * sizeof(int));

// Frequency array to count occurrences of each

number in nums
int count[101] = {0};

// Count each number in the nums array

for (int i = 0; i < numsSize; i++)
count[nums[i]]++;

// Accumulate the counts to find how many numbers are

smaller than each number
int smallerCount[101] = {0};
for (int i = 1; i < 101; i++)
smallerCount[i] = smallerCount[i - 1] + count[i -
1];

// Fill the result array using the accumulated counts

for (int i = 0; i < numsSize; i++)
result[i] = smallerCount[nums[i]];

return result;
}

int main() {
int numsSize;
int *nums;
int returnSize;

// Read the size of the array

printf("Enter the number of elements in the array: ");
scanf("%d", &numsSize);

// Allocate memory for the array

nums = (int*)malloc(numsSize * sizeof(int));

// Read the elements of the array

printf("Enter the elements of the array: ");
for (int i = 0; i < numsSize; i++)
 scanf("%d", &nums[i]);

// Find the result array

int* result = smallerNumbersThanCurrent(nums,
numsSize, &returnSize);

// Print the result array

printf("Output: ");
for (int i = 0; i < returnSize; i++) {
printf("%d", result[i]);
if (i < returnSize - 1)
printf(", ");
}
printf("\n");

// Free the allocated memory

free(nums);
free(result);

return 0;
}
1450. Number of Students Doing
Homework at a Given Time
Given two integer arrays startTime and endTime and given
an integer queryTime.

The ith student started doing their homework at the time

startTime[i] and finished it at time endTime[i].

Return the number of students doing their homework at

time queryTime. More formally, return the number of
students where queryTime lays in the interval
[startTime[i], endTime[i]] inclusive.

Example 1:

Input: startTime = [1,2,3], endTime = [3,2,7], queryTime

= 4
Output: 1
Explanation: We have 3 students where:
The first student started doing homework at time 1 and
finished at time 3 and wasn't doing anything at time 4.
The second student started doing homework at time 2 and
finished at time 2 and also wasn't doing anything at time
4.
The third student started doing homework at time 3 and
finished at time 7 and was the only student doing
homework at time 4.
Example 2:

Input: startTime = [4], endTime = [4], queryTime = 4

Output: 1
Explanation: The only student was doing their homework at
the queryTime.

Constraints:

startTime.length == endTime.length
1 <= startTime.length <= 100
1 <= startTime[i] <= endTime[i] <= 1000
1 <= queryTime <= 1000

Solution
#include <stdio.h>
#include <stdlib.h>

// Function to count the number of students doing

homework at queryTime
int busyStudent(int* startTime, int startTimeSize, int*
endTime, int endTimeSize, int queryTime) {
int count = 0;
for (int i = 0; i < startTimeSize; i++)
if (startTime[i] <= queryTime && endTime[i] >=
queryTime)
count++;

return count;
}

int main() {
int n, queryTime;

// Read the size of the arrays

printf("Enter the number of students: ");
scanf("%d", &n);

// Allocate memory for startTime and endTime arrays

int* startTime = (int*)malloc(n * sizeof(int));
int* endTime = (int*)malloc(n * sizeof(int));

// Read the elements of the startTime array

printf("Enter the start times: ");
for (int i = 0; i < n; i++)
scanf("%d", &startTime[i]);

// Read the elements of the endTime array

printf("Enter the end times: ");
for (int i = 0; i < n; i++)
scanf("%d", &endTime[i]);

// Read the query time

printf("Enter the query time: ");
scanf("%d", &queryTime);

// Find and print the number of students doing

homework at queryTime
int result = busyStudent(startTime, n, endTime, n,
queryTime);
printf("Number of students doing homework at
time %d: %d\n", queryTime, result);

// Free the allocated memory

free(startTime);
free(endTime);

return 0;
}