C Online Test

Your company is analyzing malware that targets numerical record files stored in an array.

The malware adjusts values at both the edges of the array using a window of size 's' as shown in the video below:

Implement the simulate method so that the malware behavior is replicated for further study.

A gaming company is working on a platformer game. They need a method that will compute the character's final speed, given a map and a starting speed.

The terrain on which the game character moves forward is made from various pieces of land placed together. Implement the method calculate_final_speed which takes the initial speed of the character, and an array of degrees of inclination that represent the uneven terrain.

The speed of the character will increase or decrease proportionally to the incline of the land, as shown in the image below:

The magnitude of the angle of inclination will always be < 90°. The speed change occurs only once for each piece of land. The method should immediately return 0 as the final speed if an incline reduces the speed to 0 or below 0, which makes the character lose 1 life.

For example, the below code:

int inclinations[] = { 0, 30, 0, -45, 0 };
int array_length = sizeof(inclinations) / sizeof(inclinations[0]);
printf("%.2f\n", calculate_final_speed(60, inclinations, array_length));

should print:

75.00

A megastore offers three types of discounts, which are represented as DiscountType enum.

Implement the get_discounted_price method which should take the total weight of the shopping cart, the total price, and the discount type. It should return the final discounted price based on the discount schemes as shown in the promotional video below:

(Open full-size video in a new tab)

For example, the following code:

printf("%.2f", get_discounted_price(12, 100, weight));

should print:

82.00

A turn-based strategy game has a grid with water and land. The grid contains a true value where it's water and false where it's land.

The player controls a boat unit with a particular movement pattern. It can only move to fixed destinations from its current position as shown in the video below:

The boat can only move in a direct path through water to the possible destinations, so a destination will become unreachable if there is land in the way.

Implement the can_travel_to function, that checks whether a destination is reachable by the boat. It should return true for destinations that are reachable according to the pattern above, and false for unreachable or out of bounds destinations which are outside the grid.

For example, consider the following code:

bool game_matrix[6][6] = {
    {false, true,  true,  false, false, false},
    {true,  true,  true,  false, false, false},
    {true,  true,  true,  true,  true,  true},
    {false, true,  true,  false, true,  true},
    {false, true,  true,  true,  false, true},
    {false, false, false, false, false, false},
};

printf("%d\n", can_travel_to((bool*) game_matrix, 6, 6, 3, 2, 2, 2)); // true, Valid move
printf("%d\n", can_travel_to((bool*) game_matrix, 6, 6, 3, 2, 3, 4)); // false, Can't travel through land
printf("%d\n", can_travel_to((bool*) game_matrix, 6, 6, 3, 2, 6, 2)); // false, Out of bounds

The following image shows valid and invalid destinations when the boat is in the position (3, 2):

Consider the struct UserInfo, which is used in a performance critical sub-system.

Currently, on a system:

• A long long takes 8 bytes
• A pointer takes 8 bytes
• A float and an int take 4 bytes each
• A short takes 2 bytes
• A char takes 1 byte

The struct takes 56 bytes of space. Rearrange the struct, without removing, renaming, or changing the type of the members, so that it uses less memory. The code uses pointers to struct members, so struct should be properly aligned.

Binary search tree (BST) is a binary tree where the value of each node is larger or equal to the values in all the nodes in that node's left subtree and smaller than the values in all the nodes in that node's right subtree.

Write a function that, efficiently with respect to time used, returns 1 if a given binary search tree contains a given value, else 0.

For example, for the following tree:

• n1 (Value: 1, Left: null, Right: null)
• n2 (Value: 2, Left: n1, Right: n3)
• n3 (Value: 3, Left: null, Right: null)

Call to contains(&n2, 3) should return 1 since a tree with root at n2 contains number 3.

Implement the count_views function. It accepts an array of pointers to the Viewer struct, the size of the array, and the character array with the video name. It should return the number of Viewers who have watched a Video with the name video_name.

For example,

Video videos[] = { {.name = "Soccer", .unique_views = 500},
                   {.name = "Basketball", .unique_views = 1000} };
Viewer viewer = {.username = "Dave", .watched_videos = videos,
                 .watched_videos_size = 2};    
Viewer *viewers[] = { &viewer };

calling count_views(viewers, 1, "Soccer") should return 1.

Implement the function find_roots to find the roots of the quadratic equation: ax² + bx + c = 0. The function can assign the roots to the values pointed by root1 and root2 in any order. If the equation has only one solution, the function should assign that solution as both roots. The equation will always have at least one solution.

The roots of the quadratic equation can be found with the following formula:

For example, find_roots(2, 10, 8) should assign -1,-4 or -4 and -1 to the values pointed by root1 and root2 as the roots of the equation 2x² + 10x + 8 = 0 are -1 and -4.

Implement function sort_words that sorts an array of words that contain lowercase characters from english alphabet, in descending order, and is efficient with respect to time used.

For example, the array { "cherry", "orange", "apple" } should, after sorting, become { "orange", "cherry", "apple" }.

Implement the inspect_bits function that checks if given number contains 2 or more consecutive ones in its binary representation. If it does, the function should return 1. Otherwise, it should return 0.

For example, inspect_bits(13) should return 1 as it contains 2 consecutive ones in its binary representation (1101).