This Embedded Systems and C Online Test Separates Good From Bad Hires

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.

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.

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:

In				Out
A	B	C	D	E
0	0	0	0	0
0	0	0	1	0
0	0	1	0	0
0	0	1	1	0
0	1	0	0	0
0	1	0	1	1
0	1	1	0	1
0	1	1	1	0
1	0	0	0	0
1	0	0	1	1
1	0	1	0	1
1	0	1	1	0
1	1	0	0	0
1	1	0	1	0
1	1	1	0	0
1	1	1	1	0

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

1st slot: __ gate

2nd slot: __ gate

3rd slot: __ gate

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 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" }.

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

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, a float, and an int take 4 bytes each
• A short takes 2 bytes
• A char takes 1 byte

The struct takes 48 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.