C Online Test

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:

T, -, -, X, -, -, -, T

Where the position ‘X' is compared to each position 'T'. The window is moved so 'X’ passes through all the values.

The malware has the following rules:

• If any of the ‘T' positions in the pattern are bigger or equal to 'X’ the malware replaces 'X' with 0.
• If the 'X' position in the pattern is near the left or right border and is missing a 'T' position neighbor, only the other side is considered.
• The malware finds all the positions first and only then sets them 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, number 4 was set to 0 because 5 is the bigger number.

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

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.

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.

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