C / C++ / MFC

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

struct thing1
{
	int n;
	char* word;
	
};

struct thing2
{
	int n;
	char* word;
	struct thing1 *node1;
};

struct response
{
	int n;
	struct thing2 *node2;
};

///declarations
//with malloc
int getDynamicResponse(struct response* res);
//without malloc
int getResponse(struct response* res);
//by ref
int getRefResponse(struct response* res);

//get structs
struct thing1 getThing1();
struct thing2 getThing2();
//by ref
void refThing1(struct thing1* out);
void refThing2(struct thing2* out);
//print
void showThing1(struct thing1 *t1);
void showThing2(struct thing2 *t2);
void showResponse(struct response *res);

///implementation
//get structs
struct thing1 getThing1()
{
	struct thing1 t1;
	t1.n = 1;
	t1.word = "thing1";
	return t1;
}

struct thing2 getThing2()
{
	struct thing2 t2;
	t2.n = 2;
	t2.word = "thing2";
	return t2;
}

//by ref
void refThing1(struct thing1* out)
{
	struct thing1 t1;
	t1.n = 3;
	t1.word = "refthing3";
	*out = t1;
}

void refThing2(struct thing2* out)
{
	struct thing2 t2;
	t2.n = 4;
	t2.word = "refthing4";
	*out = t2;
}

//print
void showThing1(struct thing1 *t1)
{
	printf("thing1\n");
	if(t1)
	{
		int i = t1->n;
		if(i) printf("n=%d\n", i);
		if(t1->word) printf("word=%s\n", t1->word);
	}
	else printf("Thing1 NULL");
}

void showThing2(struct thing2 *t2)
{
	printf("thing2\n");
	if(t2)
	{
		printf("n=%d\n", t2->n);
		if(t2->word) printf("word=%s\n", t2->word);
		if(t2->node1) showThing1(t2->node1);
	}
	else printf("Thing2 NULL");
}

void showResponse(struct response *res)
{
	if(res)
	{
		printf("response\n");
		printf("n=%d\n", res->n);
		if(res->node2) showThing2(res->node2);
	}
	else printf("Response NULL");
	
}

//with malloc
int getDynamicResponse(struct response* res)
{
	printf("\nwith malloc\n");
	printf("n=%d\n", res->n);
	struct response *tmp;
	tmp = (struct response*)malloc(sizeof(struct response));
	tmp->n = 12345;
	tmp->node2 = (struct thing2*)malloc(sizeof(struct thing2));
	tmp->node2->n = 2468;
	tmp->node2->word = "malloc1";
	tmp->node2->node1 = (struct thing1*)malloc(sizeof(struct thing1));
	tmp->node2->node1->n = 987;
	tmp->node2->node1->word = "malloc2";
	
	*res = *tmp;
	showResponse(res);
	printf("***************************\n");
	return 0;
}
//by ref
int getRefResponse(struct response* res)
{
	printf("\nby pointer ref\n");
	printf("n=%d\n", res->n);
	struct response out, *pout;
	res->n = 888;
	struct thing2 t2;
	struct thing1 t1;
	refThing2(&t2);	
	refThing1(&t1);	
	struct thing1 *p1 = &t1;
	struct thing2 *p2 = &t2;
	
	//link nodes
	pout = &out;
	pout->node2 = p2;
	pout->node2->node1 = p1;
	
	*res = out;
	showResponse(res);
	printf("***************************\n");
	return 0;
}

//without malloc
int getResponse(struct response* res)
{
	printf("\nlocal stack\n");
	printf("n=%d\n", res->n);
	struct response out, *pout;
	res->n = 99;
	struct thing2 tmp2 = getThing2();
	struct thing1 tmp1 = getThing1();
	struct thing1 *p1 = &tmp1;
	struct thing2 *p2 = &tmp2;
	//link nodes
	pout = &out;
	pout->node2 = p2;
	pout->node2->node1 = p1;
	
	*res = out;
	showResponse(res);
	printf("***************************\n");
	return 0;
}

int main(int argc, char **argv)
{
	printf("structs\n");
	struct response r1, r2, r3;
	r1.n = 51;
	r2.n = 52;
	r3.n = 53;
	getResponse(&r1);
	//error: local stack garbage	showResponse(&r1);
	printf("=====================\n");
	getRefResponse(&r2);
	showResponse(&r2);
	printf("=====================\n");
	getDynamicResponse(&r3);
	showResponse(&r3);
	printf("=====================\n");
	getchar();
	return 0;
}

Consider an 8-bit compiler say Turbo C, in which we have an integer of size, say 2-words i.e. 16-bits or 2 bytes. You need to store three integer values which are supposed to be as: 


Name | Range | Size Required 

===================================== 

Integer 1 | 0-3 | 2bits (00-11 in binary) 

Integer 2 | 0-5 | 3bits (000-101 in binary) 

Integer 3 | 0-7 | 3bits (000-111 in binary) 

In total, we need only 8bits to store all of these three values. Which means that a single variable of integer data type has enough memory to accommodate these values. 

The challenge is to store all of these three variables into a single instance of integer data type and retrieve it whenever required. 

In other words, you need to develop a program which can - at the maximum - use only two instances of integer data type, first one for the purpose of scanning values from the standard input device say keyboard and the second one to store the data entered by user in the form of three integer variables as discussed above and print them by retrieving it from the second instance in which the data was stored. 
Company Description Secpanel is a DIY security tool for cloud servers. 
Please see www.secpanel.com Requirements We are trying to solve the security problem for millions of servers on the internet. We are looking for people who are crazy enough to think they can solve the toughest of problems. And do. If you love to code and are sick of the protocol/HR/politics of big organizations, you should talk to us. 

Instead of a resume, please write a small piece of code for the following scenario: 

Consider an 8-bit compiler say Turbo C, in which we have an integer of size, say 2-words i.e. 16-bits or 2 bytes. You need to store three integer values which are supposed to be as: 


Name | Range | Size Required 

===================================== 

Integer 1 | 0-3 | 2bits (00-11 in binary) 

Integer 2 | 0-5 | 3bits (000-101 in binary) 

Integer 3 | 0-7 | 3bits (000-111 in binary) 

In total, we need only 8bits to store all of these three values. Which means that a single variable of integer data type has enough memory to accommodate these values. 

The challenge is to store all of these three variables into a single instance of integer data type and retrieve it whenever required. 

In other words, you need to develop a program which can - at the maximum - use only two instances of integer data type, first one for the purpose of scanning values from the standard input device say keyboard and the second one to store the data entered by user in the form of three integer variables as discussed above and print them by retrieving it from the second instance in which the data was stored.