**Problem : **
You are a teacher for a class of high school computer science students
and want to praise those students who do well in the class. As such, you
need to find out who they are. Given an array of *n* doubles where each
value represents a student's grade, write a function to find the highest
grade and return the index it sits at.

int find_highest_grade(int arr[], int n)
{
int i, largest = 0;
for(i=1; i<n; i++) {
if (arr[i] > arr[largest]) largest=i;
}
return largest;
}

**Problem : **
Given an array of *n* strings, write a function that returns the first
string whose length is greater than 15 characters.

char *find_big_string(char *arr[], int n)
{
int i;
for(i=0; i<n; i++) {
if (strlen(arr[i]) > 15) return arr[i];
}
return NULL;
}

**Problem : **
A friend tells you that he has come up with a function that implements
linear search for arrays in *O*(*logn*) time. Do you congratulate him,
or call him a liar? Why?

You call him a liar. Linear search requires you to look at, on average,
half the elements in the list. Therefore it is

*O*(*n*) by definition and
can't be done in

*O*(*logn*) time.

**Problem : **
Write a function that takes an array of n integers and returns the number
of integers that are a power of two. Challenge: determining whether a
number is a power of two can be done in a single line of code.

int num_power_two(int arr[], int n)
{
int i, num_powers = 0;
for(i=0; i<n; i) {
/* Use bitwise operators to check for powers of 2. */
if (!(arr[i] & (arr[i] - 1))) num_powers;
}
return num_powers;
}

**Problem : **
Challenge (this is tricky): Write a function that takes an array of
integers (and its length) and returns the largest consecutive sum found
in the array. In other words, if the array were:
-1 10 -1 11 100 -1000 20
It would return 120 (10 + -1 + 11 + 100).

void find_big_seq(int numbers[], int n)
{
int maxsofar = numbers[0];
int maxendhere = numbers[0];
int i, a, b;
for (i = 1; i < n; i++) {
a = maxendhere + numbers[i];
b = numbers[i];
maxendhere = a > b ? a : b;
if (maxendhere > maxsofar) maxsofar = maxendhere;
}
return maxsofar;
}

**Problem : **
You are given a two-dimensional array of integers: `int arr[100][50];`
Write a function that returns the largest integer in the array.

int find_large_int(int arr[100][50])
{
int i,j,largest_x=0, largest_y=0;
for(i=0; i<100; i) {
for(j=0; j<50; j) {
if (arr[i][j] > arr[largest_x][largest_y]) {
largest_x = i;
largest_y = j;
}
}
}
return arr[largest_x][largest_y];
}

**Problem : **
Linear search uses an exhaustive method of checking each element in the
array against a key value. When a match is found, the search halts. Will
sorting the array before using the linear search have any effect on its
efficiency?

No.

**Problem : **
In a best case situation, the element will be found with the fewest number
of comparisons. Where in the list would the key element be located?

It will be located at the beginning of the list.