||Jai Sri Gurudev||

Sri AdichunchanagiriShikshana Trust (R)

SJB INSTITUTE OF TECHNOLOGY

An Autonomous Institute under VTU
Approved by AICTE, New Delhi, Recognized by UGC with 2(f) & 12(B)
No. 67, BGS Health & Education City, Dr. Vishnuvardhan Road, Kengeri, Bengaluru-560060.

ssssA Formative Assessment Report

On
Design and Analysis of Algorithm in Hacker Rank Platform
SUBMITTED IN THE FULFILLMENT FOR THE AWARD OF THE DEGREE OF

BACHELOR OF ENGINEERING
in
COMPUTER SCIENCE AND ENGINEERING
By

DIMPAL D
[1JB23CS044]

SUBMITTED TO:

MRS ANUSHA M
[Associative professor]
Dept. of CSE
SJB IT

Sl. No. Level Max. Marks Marks Obtained

1 Easy 20

2 Moderate 15

3 Hard 15

Total 50

Student Signature: Faculty Signature:

 CONTENTS
Easy Level:
Sl. No. Title Page. No.
1 SOLVE ME FIRST
2 A VERY BIG SUM
3 DIAGONAL DIFFERENCE
4 SIMPLE ARRAY SUM
5 INSERTION SORT PART 1
6 INSERTION SORT PART 2
7 MIN MAX SUM
8 STAIR CASE
9 PICKING NUMBER
10 CIRCULAR ROTATION

Moderate Level:
Sl. No. Title Page. No.
1 EXTRA LONG FACTORIAL
2 ORGANIZING CONTAINERS OF BALLS
3 ENCRYPTION
4 BIGGER IS GREATER
5 NON-DIVISIBLE SUBSET

Hard Level:
Sl. No. Title Page. No.
1 BIKE RACERS
2 MATRIX
3 CHIEF HOPPER
4 FLOYD: CITY OF BINDING LIGHTS
5 MATRIX LAYER ROTATION

Easy Level
Problem 1: Solve Me First
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <stdlib.h>

int SolveMeFirst(int a, int b) {

return a+b;
}

int main() {
int num1,num2;
scanf("%d %d",&num1,&num2);
int sum;
sum = solveMeFirst(num1,num2);
printf("%d",sum);
return 0;
}

Output:

Problem 2: A Very Big Sum

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);
long parse_long(char*);
long aVeryBigSum(int ar_count, long* ar) {
long sum=0;
for(int i=0;i<ar_count;i++){
sum+=ar[i];
}
return sum;
}
int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

int ar_count = parse_int(ltrim(rtrim(readline())));

char** ar_temp = split_string(rtrim(readline()));

long* ar = malloc(ar_count * sizeof(long));

for (int i = 0; i < ar_count; i++) {

long ar_item = parse_long(*(ar_temp + i));

*(ar + i) = ar_item;
}
long result = aVeryBigSum(ar_count, ar);
fprintf(fptr, "%ld\n", result);
 fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
 } else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}
 *(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

long parse_long(char* str) {

char* endptr;
long value = strtol(str, &endptr, 10);

if (endptr == str || *endptr! = '\0') {

exit (EXIT_FAILURE);
}
 return value;
}
Output:

Program 3: Diagonal Difference

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);
int diagonalDifference(int arr_rows, int arr_columns, int** arr) {
int primary_diagonal=0;
int secondary_diagonal=0;
for (int i = 0; i < arr_rows; i++) {
primary_diagonal += arr[i][i];
secondary_diagonal += arr[i][arr_columns - i - 1];
}

return abs(primary_diagonal - secondary_diagonal);

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

int n = parse_int(ltrim(rtrim(readline())));

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

for (int i = 0; i < n; i++) {

*(arr + i) = malloc(n * (sizeof(int)));

char** arr_item_temp = split_string(rtrim(readline()));

for (int j = 0; j < n; j++) {

int arr_item = parse_int(*(arr_item_temp + j));

*(*(arr + i) + j) = arr_item;
}
}
 int result = diagonalDifference(n, n, arr);

fprintf(fptr, "%d\n", result);

fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

 if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

 while (end >= str && isspace(*end)) {
end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;
token = strtok(NULL, " ");
}
return splits;
}
int parse_int(char* str) {
char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}
return value;
}

Output:
Program 4: Simple Array Sum

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);

int simpleArraySum(int ar_count, int* ar) {

int sum = 0;
for (int i = 0; i < ar_count; i++) {
sum += ar[i];
}
return sum;

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

int ar_count = parse_int(ltrim(rtrim(readline())));

char** ar_temp = split_string(rtrim(readline()));

int* ar = malloc(ar_count * sizeof(int));

for (int i = 0; i < ar_count; i++) {

int ar_item = parse_int(*(ar_temp + i));

*(ar + i) = ar_item;
}

int result = simpleArraySum(ar_count, ar);

fprintf(fptr, "%d\n", result);

fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);
 if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

Output:
Program 5: Insertion Sort-Part 1

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);

void insertionSort1(int n, int arr_count, int* arr) {

int value = arr[n - 1]; // The last element that needs to be inserted
int i = n - 2;

// Shift elements to the right until we find the right position for `value`
while (i >= 0 && arr[i] > value) {
arr[i + 1] = arr[i];
i--;
// Print array state after shifting
for (int j = 0; j < n; j++) {
printf("%d", arr[j]);
if (j != n - 1) {
printf(" ");
}
}
printf("\n");
}
// Insert the value at its correct position
arr[i + 1] = value;

// Finally, print the array with the last element inserted in place
for (int j = 0; j < n; j++) {
printf("%d", arr[j]);
if (j != n - 1) {
printf(" ");
}
}
printf("\n");

}
int main()
{
int n = parse_int(ltrim(rtrim(readline())));

char** arr_temp = split_string(rtrim(readline()));

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

for (int i = 0; i < n; i++) {

int arr_item = parse_int(*(arr_temp + i));

*(arr + i) = arr_item;
}

insertionSort1(n, n, arr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

 if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}
char* rtrim(char* str) {
if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);
 if (endptr == str || *endptr != '\0') {
exit(EXIT_FAILURE);
}

return value;
}
Output:

Program 6: Insertion Sort-Part 2

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);

void insertionSort2(int n, int arr_count, int* arr) {

for (int i = 1; i < n; i++) {
int key = arr[i];
int j = i - 1;

// Shift elements of arr[0..i-1] that are greater than key, one position ahead
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;

// Print the array after inserting the key at its correct position
for (int k = 0; k < n; k++) {
printf("%d", arr[k]);
if (k != n - 1) {
printf(" ");
}
}
printf("\n");
}

int main()
{
int n = parse_int(ltrim(rtrim(readline())));

char** arr_temp = split_string(rtrim(readline()));

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

for (int i = 0; i < n; i++) {

int arr_item = parse_int(*(arr_temp + i));
 *(arr + i) = arr_item;
}

insertionSort2(n, n, arr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

 if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

 end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

Output:
Program 7: Min Max Sum

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);

void miniMaxSum(int arr_count, int* arr) {

long total = 0;
int min = INT_MAX;
int max = INT_MIN;

for (int i = 0; i < arr_count; i++) {

total += arr[i];
if (arr[i] < min) min = arr[i];
if (arr[i] > max) max = arr[i];
}

printf("%ld %ld\n", total - max, total - min);

int main()
{

char** arr_temp = split_string(rtrim(readline()));

int* arr = malloc(5 * sizeof(int));

for (int i = 0; i < 5; i++) {

int arr_item = parse_int(*(arr_temp + i));

*(arr + i) = arr_item;
}

miniMaxSum(5, arr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;
 while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}
return value;
}
Output:
Program 8: Staircase

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);

int parse_int(char*);
void staircase(int n) {
for (int i = 1; i <= n; i++) {
// Print spaces
 for (int j = 0; j < n - i; j++) {
printf(" ");
}
// Print hashes
for (int k = 0; k < i; k++) {
printf("#");
}
// New line
printf("\n");
}

int main()
{
int n = parse_int(ltrim(rtrim(readline())));

staircase(n);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;
 data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

Output:
Program 9: Picking Number

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);
int parse_int(char*);

int pickingNumbers(int a_count, int* a) {

int frequency[101] = {0}; // Assuming input values are between 0 and 100

for (int i = 0; i < a_count; i++) {

frequency[a[i]]++;
}

int max_length = 0;
for (int i = 1; i < 101; i++) {
int sum = frequency[i] + frequency[i - 1];
if (sum > max_length) {
max_length = sum;
}
}

return max_length;

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");
int n = parse_int(ltrim(rtrim(readline())));
char** a_temp = split_string(rtrim(readline()));
int* a = malloc(n * sizeof(int));

for (int i = 0; i < n; i++) {

int a_item = parse_int(*(a_temp + i));

*(a + i) = a_item;
}

int result = pickingNumbers(n, a);

fprintf(fptr, "%d\n", result);

fclose(fptr);

return 0;
}
char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
 } else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}
char** split_string(char* str) {
char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit (EXIT_FAILURE);
}

return value;
}

Output:
Program 10: Circular Array Rotation

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);
int* circularArrayRotation(int a_count, int* a, int k, int queries_count, int* queries, int*
result_count) {
int* result = malloc(queries_count * sizeof(int));
*result_count = queries_count;
k = k % a_count;

for (int i = 0; i < queries_count; i++) {

int idx = (queries[i] - k + a_count) % a_count;
result[i] = a[idx];
}

return result;

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

char** first_multiple_input = split_string(rtrim(readline()));

int n = parse_int(*(first_multiple_input + 0));

int k = parse_int(*(first_multiple_input + 1));

int q = parse_int(*(first_multiple_input + 2));

char** a_temp = split_string(rtrim(readline()));

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

for (int i = 0; i < n; i++) {

int a_item = parse_int(*(a_temp + i));

*(a + i) = a_item;
}
 int* queries = malloc(q * sizeof(int));

for (int i = 0; i < q; i++) {

int queries_item = parse_int(ltrim(rtrim(readline())));

*(queries + i) = queries_item;
}

int result_count;
int* result = circularArrayRotation(n, a, k, q, queries, &result_count);

for (int i = 0; i < result_count; i++) {

fprintf(fptr, "%d", *(result + i));

if (i != result_count - 1) {
fprintf(fptr, "\n");
}
}

fprintf(fptr, "\n");

fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

 break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}
 while (*str != '\0' && isspace(*str)) {
str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}
 return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

Output:
 Moderate Level
Problem 1: Extra Long Factorial
#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);

int parse_int(char*);
void extraLongFactorials(int n) {
int result[1000];
result[0] = 1;
int result_size = 1;

for (int x = 2; x <= n; x++) {

int carry = 0;

for (int i = 0; i < result_size; i++) {

int prod = result[i] * x + carry;
result[i] = prod % 10;
carry = prod / 10;
}

while (carry) {
result[result_size] = carry % 10;
carry = carry / 10;
result_size++;
}
}
for (int i = result_size - 1; i >= 0; i--) {
printf("%d", result[i]);
}
printf("\n");

int main()
{
int n = parse_int(ltrim(rtrim(readline())));

extraLongFactorials(n);
 return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
 }

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}

*(end + 1) = '\0';

return str;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}
Output:

Program 2: Organizing Containers of Balls

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* ltrim(char*);
char* rtrim(char*);
char** split_string(char*);

int parse_int(char*);
char* organizingContainers(int container_rows, int container_columns, int** container) {
int* container_capacities = malloc(container_rows * sizeof(int));
int* type_totals = malloc(container_columns * sizeof(int));

for (int i = 0; i < container_rows; i++) {

container_capacities[i] = 0;
for (int j = 0; j < container_columns; j++) {
container_capacities[i] += container[i][j];
}
}

for (int j = 0; j < container_columns; j++) {

type_totals[j] = 0;
for (int i = 0; i < container_rows; i++) {
type_totals[j] += container[i][j];
}
}
for (int i = 0; i < container_rows - 1; i++) {
for (int j = i + 1; j < container_rows; j++) {
if (container_capacities[i] > container_capacities[j]) {
int temp = container_capacities[i];
container_capacities[i] = container_capacities[j];
container_capacities[j] = temp;
}
if (type_totals[i] > type_totals[j]) {
int temp = type_totals[i];
type_totals[i] = type_totals[j];
type_totals[j] = temp;
}
}
 }

for (int i = 0; i < container_rows; i++) {

if (container_capacities[i] != type_totals[i]) {
free(container_capacities);
free(type_totals);
return "Impossible";
}
}

free(container_capacities);
free(type_totals);
return "Possible";

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

int q = parse_int(ltrim(rtrim(readline())));

for (int q_itr = 0; q_itr < q; q_itr++) {

int n = parse_int(ltrim(rtrim(readline())));

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

for (int i = 0; i < n; i++) {

*(container + i) = malloc(n * (sizeof(int)));

char** container_item_temp = split_string(rtrim(readline()));

for (int j = 0; j < n; j++) {

int container_item = parse_int(*(container_item_temp + j));

*(*(container + i) + j) = container_item;
}
}

char* result = organizingContainers(n, n, container);

fprintf(fptr, "%s\n", result);

}
 fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;

data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
 } else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

char* ltrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

while (*str != '\0' && isspace(*str)) {

str++;
}

return str;
}

char* rtrim(char* str) {

if (!str) {
return '\0';
}

if (!*str) {
return str;
}

char* end = str + strlen(str) - 1;

while (end >= str && isspace(*end)) {

end--;
}
 *(end + 1) = '\0';

return str;
}

char** split_string(char* str) {

char** splits = NULL;
char* token = strtok(str, " ");

int spaces = 0;

while (token) {
splits = realloc(splits, sizeof(char*) * ++spaces);

if (!splits) {
return splits;
}

splits[spaces - 1] = token;

token = strtok(NULL, " ");

}

return splits;
}

int parse_int(char* str) {

char* endptr;
int value = strtol(str, &endptr, 10);

if (endptr == str || *endptr != '\0') {

exit(EXIT_FAILURE);
}

return value;
}

Output:
Program 3: Encryption

#include <assert.h>
#include <ctype.h>
#include <limits.h>
#include <math.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char* readline();
char* encryption(char* s) {
int len = strlen(s);
char* clean = malloc(len + 1);
int clean_len = 0;

for (int i = 0; i < len; i++) {

if (s[i] != ' ') {
clean[clean_len++] = s[i];
}
}
clean[clean_len] = '\0';
int L = clean_len;
int rows = floor(sqrt(L));
int cols = ceil(sqrt(L));
if (rows * cols < L) {
rows++;
}
int result_size = (cols + 1) * rows + 1; // +1 for '\0'
char* result = malloc(result_size);
int pos = 0;

for (int c = 0; c < cols; c++) {

for (int r = 0; r < rows; r++) {
int index = r * cols + c;
if (index < L) {
result[pos++] = clean[index];
}
}
result[pos++] = ' ';
}

if (pos > 0 && result[pos - 1] == ' ') {

result[pos - 1] = '\0'; // Replace last space with null terminator
} else {
result[pos] = '\0';
 }

free(clean);
return result;

int main()
{
FILE* fptr = fopen(getenv("OUTPUT_PATH"), "w");

char* s = readline();

char* result = encryption(s);

fprintf(fptr, "%s\n", result);

fclose(fptr);

return 0;
}

char* readline() {
size_t alloc_length = 1024;
size_t data_length = 0;

char* data = malloc(alloc_length);

while (true) {
char* cursor = data + data_length;
char* line = fgets(cursor, alloc_length - data_length, stdin);

if (!line) {
break;
}

data_length += strlen(cursor);

if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') {

break;
}

alloc_length <<= 1;
 data = realloc(data, alloc_length);

if (!data) {
data = '\0';

break;
}
}

if (data[data_length - 1] == '\n') {
data[data_length - 1] = '\0';

data = realloc(data, data_length);

if (!data) {
data = '\0';
}
} else {
data = realloc(data, data_length + 1);

if (!data) {
data = '\0';
} else {
data[data_length] = '\0';
}
}

return data;
}

Output:
Program 4: Bigger is Greater

#include <stdio.h>
#include <string.h>
char* biggerIsGreater(char* w) {
int n = strlen(w);

int i = n - 2;
while (i >= 0 && w[i] >= w[i + 1]) {
i--;
}

if (i == -1) {
return "no answer";
}

int j = n - 1;
while (w[j] <= w[i]) {
j--;
}

char temp = w[i];

w[i] = w[j];
w[j] = temp;

int left = i + 1, right = n - 1;

while (left < right) {
temp = w[left];
w[left] = w[right];
w[right] = temp;
left++;
right--;
}

return w;
}

int main() {
int t;
scanf("%d", &t);

while (t--) {
 char w[100];
scanf("%s", w);

printf("%s\n", biggerIsGreater(w));
}
return 0;
}
Output:

Program 5: Non-Divisible Subset

#include <stdio.h>

int nonDivisibleSubset(int n, int k, int S[]) {

 int remainder_count[k];

for (int i = 0; i < k; i++) {

remainder_count[i] = 0;
}

for (int i = 0; i < n; i++) {

remainder_count[S[i] % k]++;
}

int subset_size = (remainder_count[0] > 0) ? 1 : 0;

for (int i = 1; i <= k / 2; i++) {

if (i == k - i) {
subset_size += (remainder_count[i] > 0) ? 1 : 0;
} else {

subset_size += (remainder_count[i] > remainder_count[k - i]) ? remainder_count[i] :

remainder_count[k - i];
}
}

return subset_size;
}

int main() {
int n, k;
scanf("%d %d", &n, &k);

int S[n];
for (int i = 0; i < n; i++) {
scanf("%d", &S[i]);
}

printf("%d\n", nonDivisibleSubset(n, k, S));

return 0;
}
Output:

Hard Level
Problem 1: Bike Racers
#include <stdio.h>
#include <math.h>
#include <stdbool.h>

#define MAX_N 250

#define MAX_M 250

int bikers[MAX_N][2], bikes[MAX_M][2], N, M, K;

bool graph[MAX_N][MAX_M];
bool canMatch(int biker, int bike, long long distance) {
long long dx = bikers[biker][0] - bikes[bike][0];
long long dy = bikers[biker][1] - bikes[bike][1];
return (dx * dx + dy * dy) <= distance;
}

bool bpm(int u, bool seen[], int match[]) {

for (int v = 0; v < M; v++) {
if (graph[u][v] && !seen[v]) {
seen[v] = true;
if (match[v] < 0 || bpm(match[v], seen, match)) {
match[v] = u;
return true;
}
}
}
return false;
}

bool isPossible(long long distance) {

for (int i = 0; i < N; i++)
for (int j = 0; j < M; j++)
graph[i][j] = canMatch(i, j, distance);

int match[MAX_M];
for (int i = 0; i < M; i++) match[i] = -1;

int count = 0;
for (int i = 0; i < N; i++) {
bool seen[MAX_M] = {false};
if (bpm(i, seen, match))
count++;
if (count >= K) return true;
}
return false;
}

long long minSquaredDistance() {

long long left = 0, right = 2e14, ans = right;
while (left <= right) {
long long mid = left + (right - left) / 2;
if (isPossible(mid)) {
ans = mid;
right = mid - 1;
} else {
left = mid + 1;
}
}
return ans;
}
int main() {
scanf("%d %d %d", &N, &M, &K);
for (int i = 0; i < N; i++)
scanf("%d %d", &bikers[i][0], &bikers[i][1]);
for (int i = 0; i < M; i++)
scanf("%d %d", &bikes[i][0], &bikes[i][1]);
printf("%lld\n", minSquaredDistance());
return 0;
}

Output:

Program 2: Matrix

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

#define MAX_CITIES 100005

typedef struct {
int city1;
 int city2;
int time;
} Edge;

int parent[MAX_CITIES];
bool hasMachine[MAX_CITIES];
int find(int u) {
if (parent[u] != u)
parent[u] = find(parent[u]);
return parent[u];
}
void unionCities(int u, int v) {
int rootU = find(u);
int rootV = find(v);
parent[rootU] = rootV;
hasMachine[rootV] = hasMachine[rootV] || hasMachine[rootU];
}
int compareEdges(const void* a, const void* b) {
return ((Edge*)b)->time - ((Edge*)a)->time;
}

int main() {
int n, k;
scanf("%d %d", &n, &k);

int numEdges = n - 1;
Edge* edges = malloc(sizeof(Edge) * numEdges);

for (int i = 0; i < numEdges; i++) {

scanf("%d %d %d", &edges[i].city1, &edges[i].city2, &edges[i].time);
}

for (int i = 0; i < n; i++) {

parent[i] = i;
hasMachine[i] = false;
}

for (int i = 0; i < k; i++) {

int m;
scanf("%d", &m);
hasMachine[m] = true;
}
qsort(edges, numEdges, sizeof(Edge), compareEdges);
 int totalTime = 0;
for (int i = 0; i < numEdges; i++) {
int u = edges[i].city1;
int v = edges[i].city2;
int t = edges[i].time;

int rootU = find(u);

int rootV = find(v);

if (hasMachine[rootU] && hasMachine[rootV]) {

// Must cut this edge
totalTime += t;
} else {
unionCities(rootU, rootV);
}
}

printf("%d\n", totalTime);

free(edges);
return 0;
}

Output:
Program 3: Chief Hopper
#include <stdio.h>
int chiefHopper(int arr[], int n) {
int energy = 0;
for (int i = n - 1; i >= 0; i--) {
energy = (energy + arr[i] + 1) / 2;
}
return energy;
}

int main() {
int n;
scanf("%d", &n);

int arr[n];
for (int i = 0; i < n; i++) {
scanf("%d", &arr[i]);
}
int result = chiefHopper(arr, n);
printf("%d\n", result);
return 0;
}
Output:

Program 4: Floyd City of Binding Lights

#include <stdio.h>
#include <limits.h>

#define INF INT_MAX

#define MAX_NODES 1000
void floydWarshall(int dist[MAX_NODES][MAX_NODES], int n) {
for (int k = 1; k <= n; k++) {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (dist[i][k] != INF && dist[k][j] != INF && dist[i][j] > dist[i][k] + dist[k][j]) {
dist[i][j] = dist[i][k] + dist[k][j];
}
}
}
}
}

int main() {
int n, m;
int dist[MAX_NODES][MAX_NODES];

scanf("%d %d", &n, &m);

for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (i == j) {
dist[i][j] = 0;
} else {
dist[i][j] = INF;
}
}
}

for (int i = 0; i < m; i++) {

int u, v, w;
scanf("%d %d %d", &u, &v, &w);
dist[u][v] = w;
}
floydWarshall(dist, n);
int q;
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int u, v;
scanf("%d %d", &u, &v);
if (dist[u][v] == INF) {
 printf("-1\n");
} else {
printf("%d\n", dist[u][v]);
}
}
return 0;
}
Output:

Program 5: Matrix Layer Rotation

#include <stdio.h>
#include <stdlib.h>
#define MIN(a, b) ((a) < (b) ? (a) : (b))

void rotateMatrix(int rows, int cols, int r, int matrix[300][300]) {

int layers = MIN(rows, cols) / 2;

for (int l = 0; l < layers; l++) {

int top = l;
int bottom = rows - 1 - l;
int left = l;
int right = cols - 1 - l;
int perimeter = 2 * (bottom - top + right - left);
int *elements = (int *)malloc(perimeter * sizeof(int));
int idx = 0;
for (int i = left; i <= right; i++) elements[idx++] = matrix[top][i];
for (int i = top + 1; i <= bottom; i++) elements[idx++] = matrix[i][right];
for (int i = right - 1; i >= left; i--) elements[idx++] = matrix[bottom][i];
for (int i = bottom - 1; i > top; i--) elements[idx++] = matrix[i][left];
int rot = r % perimeter;
idx = 0;

for (int i = left; i <= right; i++) matrix[top][i] = elements[(idx + rot) % perimeter], idx++;
for (int i = top + 1; i <= bottom; i++) matrix[i][right] = elements[(idx + rot) % perimeter],
idx++;
for (int i = right - 1; i >= left; i--) matrix[bottom][i] = elements[(idx + rot) % perimeter],
idx++;
for (int i = bottom - 1; i > top; i--) matrix[i][left] = elements[(idx + rot) % perimeter],
idx++;

free(elements);
}
}

int main() {
int m, n, r;
scanf("%d %d %d", &m, &n, &r);

int matrix[300][300];
for (int i = 0; i < m; i++)
for (int j = 0; j < n; j++)
scanf("%d", &matrix[i][j]);

rotateMatrix(m, n, r, matrix);

for (int i = 0; i < m; i++) {

 for (int j = 0; j < n; j++)
printf("%d ", matrix[i][j]);
printf("\n");
}
return 0;
}
Output:

SUBMISSION LIST