Embedded Systems and C Online Test

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

You have a component which should be used as part of a signal processing device. It has four input pins, one output pin, and three slots where you can insert logical gates:

The component should have the following truth table:

Choose appropriate logic gates for the component's slots to achieve the required truth table.

1st slot: __ gate

2nd slot: __ gate

3rd slot: __ gate

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 image 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.

Your company is analyzing malware which targets numerical record files.

The malware uses a sliding window over the array of numbers in a file, and tries to match the following pattern:

Tl, -, -, X, -, -, -, Tr

The entire window is moved so that 'X' passes through all the values and is compared to the numbers at the 'Tl' and 'Tr' locations, which are positioned at a constant offset to 'X'.

The malware has the following rules:

• If the value at the 'Tl' or 'Tr' position of the pattern is bigger or equal to the value at the 'X’ position, the malware replaces the value at 'X' with 0.
• If the value at the 'Tl' or 'Tr' offset is out of bounds, then the value at 'X' is only compared to the other existing value.
• The record is processed in two stages: first, all the positions that should be set to 0 are located, using the original values for comparison. Only after all positions have been identified do they get set to 0.

For example, if the values in a record file are the following:

{ 1, 2, 0, 5, 0, 2, 4, 3, 3, 3 }

The expected values after the malware runs are:

{ 1, 0, 0, 5, 0, 0, 0, 3, 3, 0 }

In this example, both '2's, the '4' and the last '3' were replaced by 0.

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

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).

The following part of the C code distributes packets from the input track to the output track:

void* take_and_put(void *arg)
{
    sem_wait(&semaphore);
    take();
    sem_post(&semaphore);

    pthread_mutex_lock(&mutex);
    put();
    pthread_mutex_unlock(&mutex);

    return NULL;
}

Where semaphore and mutex are initialized with:

// int sem_init(sem_t *sem, int pshared, unsigned int value);
sem_init(&semaphore, 0, 3);
// int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr);
pthread_mutex_init(&mutex, NULL);

If the function take_and_put is repeatedly called by a large number of threads, select correct statements about the take_and_put function.

A car company plans to extend its car computer system to offer Bluetooth connectivity with the owner's mobile phone.

Select all correct statements about the properties of such a connection.