hackerrank-solutions's Introduction

Summary

One year of experience in web application development using .NET Core Framework.
Proficient in Object-Oriented Programming, Data Structures, Algorithms, Design Patterns, and Problem Solving.
Eager learner passionate about advancing skills in .NET, Back-End technologies, DevOps, and emerging trends like Web 3, Blockchain, Linux, and Cloud Computing.
Detail-oriented and committed engineer known for on-time delivery of high-quality products. Self-motivated and quick learner.
👨‍🏫 Currently studying at:
🔭 Looking to collaborate on: JobWebsites and FreelanceWebsites.

Skills

{
    "skills": [
        "C#",                                   "ASP.NET Core Web API",     "Entity Framework Core",
        "Database Systems",                     "JSON Web Token (JWT)",     "Language Integrated Query (LINQ)",
        ".NET Core",                            "ASP.NET Core MVC",         "Microsoft Azure",
        "Software Engineering Practices",       "Clean Code",               "Unit Testing",
        "Microservices",                        "Cloud Computing",          "Problem Solving",
        "Object-Oriented Programming (OOP)",    "Data Structures",          "Algorithms",
        "SQL",                                  "Git",                      "Unix / Linux"
    ]
}

Contribution Activity

hackerrank-solutions's People

Stargazers

Watchers

hackerrank-solutions's Issues

Stacks (Data Structures)

Unsolved Challenges

AND xor OR

Queues (Data Structures)

Unsolved Challenges

Castle on the Grid + Castle on the Grid

Trees (Data Structures)

Unsolved Challenges

Strings (Algorithms)

Unsolved Challenges

Balanced Trees (Data Structures)

Unsolved Challenges

Post Transition

Not completed solution for Post Transition problem

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

struct package {
	char *ID;
	int weight;
    struct package *nextPtr;
};

typedef struct package Package;
typedef Package* PackagePtr;

struct postOffice {
	int minWeight;
	int maxWeight;
	int packagesCount;
    Package *packagesHeadPtr;
    Package *packagesTailPtr;
};

typedef struct postOffice PostOffice;

struct town {
	char name[6];
	int officesCount;
	PostOffice *offices;
};

typedef struct town Town;

void dequeue(PackagePtr *headPtr, PackagePtr *tailPtr) {
	PackagePtr tempPtr = *headPtr;
	*headPtr = (*headPtr)->nextPtr;

	if(*headPtr == NULL) {
		*tailPtr = NULL;
	}

    free(tempPtr->ID);
    tempPtr->ID = NULL;
	free(tempPtr);
	tempPtr = NULL;
}

void enqueue(PackagePtr *headPtr, PackagePtr *tailPtr, char ID[], int weight) {
	PackagePtr newPtr = malloc(sizeof(Package));
	
	if (newPtr == NULL) {
        exit(EXIT_FAILURE);
	}

	newPtr->ID = malloc(6 * sizeof(char));
    newPtr->ID = ID;
    newPtr->weight = weight;
	newPtr->nextPtr = NULL;

	if (*headPtr == NULL) {
		*headPtr = newPtr;
	} else {
		(*tailPtr)->nextPtr = newPtr;
	}

	*tailPtr = newPtr;
}


int findTown(Town towns[], int townsCount, char townName[]) {
    for (int i = 0; i < townsCount; i++) {
        if (!strcmp(townName, towns[i].name)) {
            return i;
        }
    }
    return -1;
}

void sendAllAcceptablePackages(Town towns[], int sourceOfficeIndex, int targetOfficeIndex) {
    PackagePtr currentPackage = towns[sourceOfficeIndex].offices->packagesHeadPtr;

    while (currentPackage != NULL) {
        if (currentPackage->weight >= towns[targetOfficeIndex].offices->minWeight &&
            currentPackage->weight <= towns[targetOfficeIndex].offices->maxWeight
        ) {
            enqueue(&towns[targetOfficeIndex].offices->packagesHeadPtr, 
                &towns[targetOfficeIndex].offices->packagesTailPtr, 
                towns[sourceOfficeIndex].offices->packagesHeadPtr->ID, 
                towns[sourceOfficeIndex].offices->packagesHeadPtr->weight
            );
        } else {
            enqueue(&towns[sourceOfficeIndex].offices->packagesHeadPtr, 
                &towns[sourceOfficeIndex].offices->packagesTailPtr, 
                towns[sourceOfficeIndex].offices->packagesHeadPtr->ID, 
                towns[sourceOfficeIndex].offices->packagesHeadPtr->weight
            );
        }
        dequeue(&towns[sourceOfficeIndex].offices->packagesHeadPtr, 
            &towns[sourceOfficeIndex].offices->packagesTailPtr
        );
    }
}

int main(int argc, char *argv[]) {

    int townsCount, queries;
	scanf("%i", &townsCount);
	Town* towns = malloc(townsCount * sizeof(Town));

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

		scanf("%s%i", towns[i].name, &towns[i].officesCount);
		towns[i].offices = malloc(towns[i].officesCount * sizeof(PostOffice));

		for (int j = 0; j < towns[i].officesCount; j++) {
			scanf("%i%i%i",
                &towns[i].offices[j].packagesCount,
                &towns[i].offices[j].minWeight,
                &towns[i].offices[j].maxWeight
            );
			towns[i].offices[j].packagesHeadPtr = NULL;
            towns[i].offices[j].packagesTailPtr = NULL;

			for (int k = 0; k < towns[i].offices[j].packagesCount; k++) {
                char ID[6];
                int weight;
				scanf("%s%i", ID, &weight);
                enqueue(&towns[i].offices[j].packagesHeadPtr,
                    &towns[i].offices[j].packagesTailPtr,
                    ID,
                    weight
                );
			}
		}
	}

	scanf("%i", &queries);

	while (queries--) {

        char townName[6];
		int type, sourceOfficeIndex, targetOfficeIndex, townIndex;

		scanf("%i", &type);

		switch (type) {
		case 1:
			scanf("%s", townName);
			int townIndex = findTown(towns, townsCount, townName);
			printf("%s:\n", towns[townIndex].name);
            for (int i = 0; i < towns[townIndex].officesCount; i++) {
                printf("\t%i:\n", i);
                PackagePtr currentPackage = towns[townIndex].offices[i].packagesHeadPtr;
                while (currentPackage != NULL) {
                    printf("\t\t%s\n", currentPackage->ID);
                    currentPackage = currentPackage->nextPtr;
                }
            }
			break;
		case 2:
			scanf("%s%i%s%i", townName, &sourceOfficeIndex, townName, &targetOfficeIndex);
			sendAllAcceptablePackages(towns, sourceOfficeIndex, targetOfficeIndex);
			break;
		case 3:
            for (int i = 0, packages = 0, maxPackages = -1; i < townsCount; i++, packages = 0) {
                for (int j = 0; j < towns[i].officesCount; j++) {
                    packages += towns[i].offices[j].packagesCount;
                }
                if (packages > maxPackages) {
                	maxPackages = packages;
                    townIndex = i;
                }
            }
			printf("Town with the most number of packages is %s\n", towns[townIndex].name);
			break;
		}
	}

	return EXIT_SUCCESS;
}