November 30, 2023
Latest:
HackerRank Solution In C

# Post Transition in C – HackerRank Solution

## Post Transition in C – HackerRank Solution Explain VIDEO :

Post Transition in C – HackerRank Solution

## Problem :

• Objective
• Example
• Input Format
• Sample Input 0
• Sample Output 0
• Solution
• Explanations

## Objective :

We live in a big country. This country has towns_count towns in it. Each town has some post offices in which packages are stored and transferred.
Post offices have different inner structure. Specifically, each of them has some limitations on the packages it can store – their weight should be between min_weight and max_weight inclusively, where min_weight and max_weight are fixed for each office.
Packages are stored in some order in the office queue. That means, that they are processed using this order when sending and receiving.
Sometimes two post offices, even in different towns, may organize the following transaction: the first one sends all its packages to the second one. The second one accepts the packages that satisfy the weight condition for the second office and rejects all other ones. These rejected packages return to the first office back and are stored in the same order they were stored before they were sent. The accepted packages move to the tail of the second office’s queue in the same order they were stored in the first office.
You should process several queries in your program. You’ll be provided with structures package, post_of fice and town. in order to complete this task, you should fill the following functions:
print_all_packages : given the town t, print all packages in this town. They should be printed as follows:
Town_name:
0:
id_0
id_1

1:
id_2
id_3

where 0, 1 etc are the numbers of post offices and id0,id1 … are the ids of packages from the 0th post office in the order of its queue, id2, id3 are from the 1st one etc. There should be one ‘\t’ symbol before post office numbers and two ‘\t’ symbols before the ids.
send_all_acceptable_packages given the towns source and target and post office indices source_of fice_index and target_of fice_index, manage the transaction described above between the post office # source_of fice_index in town source and the post office # target_of fice_index in town target.
town_with_most_packages – given all towns, find the one with the most number of packages in all post offices altogether. If there are several of them, find the first one from the collection town.

find_town – given all towns and a string name, find the town with the name name. It’s guaranteed that the town exists.

This challenge requires you to print Hello World on a single line, and then print the already provided input string to stdout. If you are not familiar with C, you may want to read about the printf() command.

This challenge needs you to print hello World on one line, then print the already provided input string to stdout. If you’re not conversant in C, you will need to examine the printf() command.

## Input Format:

First line of the input contains a single integer town_count . town_count blocks follow, each describing a town. Every town block contains several lines. On the first line there is a string town_name – the name of the town. On the second line there is an integer of fices_count – the number of the offices in the town. of fices_count blocks follow then, each describing an office.
Every office block also contains several lines. On the first line there are three integers separated by single spaces: package_count (the number of packages in the office), min_weight and max_weight (described above) package_count. blocks follow, each describing a package.
Every package block contains exactly two lines. On the first line there is a string id which is an id of the package. On the second line there is an integer weight which is the weight of the package.
Then, there is a single integer queries on the line which is the number of queries. queries blocks follow, each describing a query.
Every query block contains several lines. On the first line there is an integer 12 or 3. If this integer is 1, on the second line there is a string town_name – the name of town for which all packages should be printed. If this integer is 2, on the second line there are string source_name, integer source_office_index, string target_name and target_office_index integer separated by single spaces. That means transactions between post office # source_office_index in the town source_name and post office # target_office_index in the town  target_name should be processed.
If the integer is 3, no lines follow and the town with the most number of packages should be found.

2
A
2
2 1 3
a 2
b 3
1 2 4
c 2
B
1
4 1 4
d 1
e 2
f 3
h 4
5
3
2 B 0 A 1
3
1 A
1 B

## Sample Output 0:

Town with the most number of packages is B
Town with the most number of packages is A
A:
0:
a
b
1:
c
e
f
h
B:
0:
d

## Solution Solution :

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_STRING_LENGTH 6

struct package
{
char* id;
int weight;
};

typedef struct package package;

struct post_office
{
int min_weight;
int max_weight;
package* packages;
int packages_count;
};

typedef struct post_office post_office;

struct town
{
char* name;
post_office* offices;
int offices_count;
};

typedef struct town town;

void print_all_packages(town t) {
printf(“%s:\n”, t.name);
for(int i = 0; i < t.offices_count; i ++) {
printf(“\t%d:\n”, i);
for(int j = 0; j < t.offices[i].packages_count; j ++) {
printf(“\t\t%s\n”, t.offices[i].packages[j].id);
}
}
}

void send_all_acceptable_packages(town* source, int source_office_index, town* target, int target_office_index) {

int min = target -> offices[target_office_index].min_weight;
int max = target -> offices[target_office_index].max_weight;

for(int i = 0; i < source -> offices[source_office_index].packages_count ; i ++) {
int weight = source -> offices[source_office_index].packages[i].weight;
if(weight >= min && weight <= max) {
target -> offices[target_office_index].packages = realloc(target -> offices[target_office_index].packages, (target -> offices[target_office_index].packages_count + 1) * sizeof(package));
target -> offices[target_office_index].packages[target -> offices[target_office_index].packages_count] = source -> offices[source_office_index].packages[i];
(target -> offices[target_office_index].packages_count)++;

for(int j = i; j < source -> offices[source_office_index].packages_count – 1; j ++) {
source -> offices[source_office_index].packages[j] = source -> offices[source_office_index].packages[j+1];
}
source -> offices[source_office_index].packages = realloc(source -> offices[source_office_index].packages, (source -> offices[source_office_index].packages_count – 1)* sizeof(package));
source -> offices[source_office_index].packages_count –;
i–;
}
}
}

town town_with_most_packages(town* towns, int towns_count) {
int index = 0, max = 0;
for(int i = 0; i < towns_count; i ++) {
int sum = 0;
for(int j = 0; j < towns[i].offices_count; j ++) {
sum += towns[i].offices[j].packages_count;
}
if(sum > max) {
max = sum;
index = i;
}
}
}

town* find_town(town* towns, int towns_count, char* name) {
int i;
for(i = 0; i < towns_count; i ++) {
if(! (strcmp(towns[i].name, name)) ) break;
}
}

int main()
{
int towns_count;
scanf(“%d”, &towns_count);
town* towns = malloc(sizeof(town)*towns_count);
for (int i = 0; i < towns_count; i++) {
towns[i].name = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf(“%s”, towns[i].name);
scanf(“%d”, &towns[i].offices_count);
towns[i].offices = malloc(sizeof(post_office)*towns[i].offices_count);
for (int j = 0; j < towns[i].offices_count; j++) {
scanf(“%d%d%d”, &towns[i].offices[j].packages_count, &towns[i].offices[j].min_weight, &towns[i].offices[j].max_weight);
towns[i].offices[j].packages = malloc(sizeof(package)*towns[i].offices[j].packages_count);
for (int k = 0; k < towns[i].offices[j].packages_count; k++) {
towns[i].offices[j].packages[k].id = malloc(sizeof(char) * MAX_STRING_LENGTH);
scanf(“%s”, towns[i].offices[j].packages[k].id);
scanf(“%d”, &towns[i].offices[j].packages[k].weight);
}
}
}
int queries;
scanf(“%d”, &queries);
char town_name[MAX_STRING_LENGTH];
while (queries–) {
int type;
scanf(“%d”, &type);
switch (type) {
case 1:
scanf(“%s”, town_name);
town* t = find_town(towns, towns_count, town_name);
print_all_packages(*t);
break;
case 2:
scanf(“%s”, town_name);
town* source = find_town(towns, towns_count, town_name);
int source_index;
scanf(“%d”, &source_index);
scanf(“%s”, town_name);
town* target = find_town(towns, towns_count, town_name);
int target_index;
scanf(“%d”, &target_index);
send_all_acceptable_packages(source, source_index, target, target_index);
break;
case 3:
printf(“Town with the most number of packages is %s\n”, town_with_most_packages(towns, towns_count).name);
break;
}
}
for(int i = 0; i < towns_count; i ++) {
for (int j = 0; j < towns[i].offices_count; j ++) {
free(towns[i].offices[j].packages);
}
free(towns[i].offices);
}
free(towns);
return 0;
}

## Explanations : Click Me To Get Explain Video

Firstly, You have to Copy The Code Here and Go to Your Post Transition in C – HackerRank Solution Questions Problem. Then You Have to go Submission Page. Now You Have Pasted this Copy Code and Run This Code by Compiler. You Can See All Task Should be Done. All Private and Public Cases Passed. Then Submit Your Code Finally.

## What is #Include<stdio.h> ?

#include<stdio.h> is used to included header file in c programming language. It is a Mandetory. It is also Compiler Directives to Include INPUT/OUTPUT related function in our Program. The stdio.h is a file with “.h” extension which is contain the prototypes [not definition] of standard input-output functions used in c program.

For Others File We Have to Discuss in Future Articles. Visit Our Official Website.

Post Transition in C – HackerRank Solution is a Solution Where You Can See The Code of Post Transition in C – HackerRank Solution and Understand The Code Level. If You Want Others Code of Hackerrank Solution In C then You Can Visit Our Official Website For More Information About Hackerrank Solution In C.

## What is int main() ?

‘int main’ means our perform must come thusme whole number at the top of the execution and that we do so by returning zero at the top of the program. zero is that the normal for the “successful execution of the program”.

## What is Printf and Scanf ?

The printf() and scanf() functions area unit used for input and output in C language. each functions area unit inherent library functions, outlined in stdio.h (header file).

## What is Compiler ?

The language processor that reads the whole program written in application-oriented language as a full in one go and interprets it into identical program in machine language is named a Compiler. Example: C, C++, C#, Java. compilers/assemblers area unit themselves package, and reside where they were put in on the pc. that additionally implies that you just will have as many/few of every as you wish.

## How “Post Transition in C – HackerRank Solution” program works?

• The #include is a preprocessor command that tells the compiler to include the contents of stdio.h (standard input and output) file in the program.
• The stdio.h file contains functions such as scanf() and printf() to take input and display output respectively.
• If you use the printf() function without writing #include <stdio.h>, the program will not compile.
• The execution of a C program starts from the main() function.
• printf() is a library function to send formatted output to the screen. In this program, printf() displays Hello, World! in C text on the screen.
• The return 0; statement is the “Exit status” of the program. In simple terms, the program ends with this statement.

The #include could be a preprocessor command that tells the compiler to incorporate the contents of stdio.h (standard input and output) enter the program.
The stdio.h file contains functions like scanf() and printf() to require input and show output severally.
If you utilize the printf() perform while not writing #include , the program won’t compile.
The execution of a program starts from the main() perform.
printf() could be a library perform to send formatted output to the screen. during this program, printf() displays hello, World! in C text on the screen.
The return 0; statement is the “Exit status” of the program. In straightforward terms, the program ends with this statement.

#### Hackerrank Answer Post Transition in C – HackerRank Solution

Post Transition in C – HackerRank Solution may be a sample program designed to acquaint users with most programming languages. Beginners ar introduced to the essential syntax of a programing language by learning the way to print out “Hello World” on the device screen. printf(“Hello World”); This line tells the compiler to show the message “Hello World” on the screen. This line is termed an announcement in C. each statement is supposed to perform some task.

## Conclusion :

So, Learners today you have learned about basic Post Transition in C – HackerRank Solution. Now you can solve Post Transition in C – HackerRank Solution.

If you still have any doubt regarding the problem Just Watch Explanation Video, then Till any Queries , feel free to contact in the comment section.

## Disclaimer:

The above problem Post Transition in C – HackerRank Solution is generated by HackerRank but the solution is provided by Us (Check DMCA for Others). If you continue to have any doubt relating to the matter simply Watch rationalization Video, then until any Queries , be happy to contact within the comment section.