Question

Write a C function that implements the Liner Search algorithm instead of Binary Search.
However, this linear search algorithm returns the indices of the longest sorted subset of numbers in
an array of integers of size n. The longest sorted subset of numbers must satisfy three conditions.
First, the subset consists of unique numbers (no duplicate); second, all the numbers in this subset is
divisible by m, the minimum size of the subset is two elements. In the main method print all values
of all the discovered longest sorted subsets.
Notes there could be more than one longest sorted subset (e.g., two subsets that satisfy the
previously stated conditions). The subsets could exist in ascending or descending order. We
always scan the array from left to right ( 0 to n-1 indices)
Examples, find the longest sorted subset that is divisible by 3
5 3 2 8 12 6 9 9 21 30
The longest sorted subset that is divisible by 3 is {9, 21, 30}. It exists between indices [7 - 9]. Note
{6, 9, 9, 21, 30} is not the longest because the value 9 exists twice.
Examples, find the longest sorted subset that is divisible by 2
2 6 8 0 3 12 14 20 3 5
The longest sorted subset that is divisible by 2 are {2, 6, 8} and {12, 14, 20}. The exist between
indices [0-2] and [5-7]. Note {6, 9, 9, 21, 30} is not the longest because the value 9 exists twice.
Examples, find the longest sorted subset that is divisible by 3
19 0 13 11 2 9 17 1 3 5
The longest sorted subset that is divisible by 2 is empty or null .
Examples, find the longest sorted subset that is divisible by 5
5 15 50 3 19 80 50 10 2 7
The longest sorted subset that is divisible by 5 are {5, 15, 50} and {80, 50, 10}. The exist between
indices [0-2] and [5-7].

Elements are not sorted.

Answer 1

//do comment if any problem arises

//do thumbs up if it helps

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

//this function returns next element of array which id divisible by d starting from given start index

int next_divisible(int arr[], int n, int start, int d)

{

for (int i = start; i < n; i++)

if (arr[i] != 0 && arr[i] % d == 0)

return i;

return -1;

}

//this function returns true if element s is found starting from index l to r

int search(int array[], int l, int r, int s)

{

for (int i = l; i <= r; i++)

{

if (array[i] == s)

return 1;

}

return 0;

}

//number of indices found

int number = 0;

//this function returns 2d array where first collumn is start of index and second collumn denotes ending index of array where

//given subsequence is found

int **linearSearch(int array[], int n, int d)

{

//2d array

int **ret = (int **)(malloc(sizeof(int **)));

for (int i = 0; i < 10; i++)

{

ret[i] = (int *)(malloc(sizeof(int[2])));

ret[i][0] = ret[i][1] = 0;

}

int from = next_divisible(array, n, 0, d);

ret[0][0] = from;

ret[0][1] = from;

for (int i = from; i < n; i++)

{

//if next element is not 0 and divisible by d and is not repeted

if (array[i] != 0 && array[i] % d == 0 && search(array, ret[number][0], ret[number][1], array[i]) == 0)

{

ret[number][1] = i;

}

else

{

if (ret[number][1] - ret[number][0] > 1)

number++;

ret[number][0] = next_divisible(array, n, i, d);

ret[number][1] = next_divisible(array, n, i, d);

if (ret[number][0] == -1)

return ret;

i = next_divisible(array, n, i, d);

}

}

number++;

return ret;

}

int calculateMax(int **arr, int n)

{

int max = 0;

for (int i = 0; i < number; i++)

if (arr[i][1] - arr[i][0])

max = 0;

}

int main()

{

int array[] = {2, 6, 8, 0, 3, 12, 14, 20, 3, 5};

int size = 10;

int divisible_by = 2;

int **final = linearSearch(array, size, divisible_by);

int max = calculateMax(final, number);

for (int i = 0; i < number; i++)

if (final[i][1] - final[i][0] == max)

printf("index of longest subsequence [%d - %d]\n", final[i][0], final[i][1]);

}

Output: