Arrays in Data Structures
practice.

In special case, the time complexity of inserting/deleting elements at the end of dynamic array is . . . . . . . .

Suffix array can be created by performing . . . . . . . . traversal of a suffix tree.

If comparison based sorting algorithm is used construct the suffix array, then what will be time required to construct the suffix array?

Which of the following is/are advantages suffix array one suffix tree?
I. Lesser space requirement
II. Improved cache locality
III. Easy construction in linear time

Which of the following bitwise operations will you use to toggle a particular bit?

What will be the time complexity of the following code?

#include <bits/stdc++.h> 
using namespace std; 
void func(int arr[], int left, int right) 
{ 
    if (left >= right) 
    return; 
 
    int temp = arr[left];  
    arr[left] = arr[right]; 
    arr[right] = temp; 
 
    func(arr, left + 1, right - 1);  
}      
 
void printArray(int arr[], int size) 
{ 
    for (int i = 0; i < size; i++) 
    cout << arr[i] << " "; 
} 
 
int main() 
{ 
	int arr[] = {1,2,3,4}; 
	int n = sizeof(arr) / sizeof(arr[0]); 
	func(arr, 0, n-1); 
	printArray(arr, n); 
	return 0; 
}

Choose the appropriate code that counts the number of non-zero(non-null) elements in the sparse array.

Which of the following is a disadvantage of dynamic arrays?

What will be the auxiliary space requirement of the following code?

#include <bits/stdc++.h> 
using namespace std; 
void func(int arr[], int left, int right) 
{     
	while (left < right) 
	{ 
		int temp = arr[left]; 
		arr[left] = arr[right]; 
		arr[right] = temp; 
		left++; 
		right--; 
	} 
 
}	
 
void printArray(int arr[], int size) 
{ 
    for (int i = 0; i < size; i++) 
    cout << arr[i] << " "; 
} 
 
int main() 
{ 
	int arr[] = {1,4,3,5}; 
	int n = sizeof(arr) / sizeof(arr[0]); 
	func(arr, 0, n-1); 
	printArray(arr, n); 
	return 0; 
}

Which of the following is/are not applications of bit arrays?

Which of the following don't use matrices?

How many swaps are required for reversing an array having n elements where n is an odd number?

What is the space complexity of the code that uses merge sort for determining the number of inversions in an array?

What will be the auxiliary space complexity of the code to rotate an array by using the reversal algorithm (d = number of rotations)?

What is the time complexity of the code that uses self balancing BST for determining the number of inversions in an array?

Array is divided into two parts in . . . . . . . .

To search for an element in a sorted array, which searching technique can be used?

What will be the output of the following code?

#include <bits/stdc++.h> 
using namespace std; 
 
void func(int arr[], int n) 
{  
	int count[n]; 
	memset(count, 0, sizeof(count)); 
 
	for (int i=n-2; i>=0; i--) 
	{ 
		if (arr[i] >= n - i - 1) 
			count[i]++; 
 
		for (int j=i+1; j < n-1 && j <= arr[i] + i; j++) 
 
			if (count[j] != -1) 
				count[i] += count[j]; 
 
		if (count[i] == 0) 
			count[i] = -1; 
	} 
 
	for (int i=0; i<n; i++) 
		cout << count[i] << " "; 
} 
 
int main() 
{ 
	int arr[] = {1, 3, 5, 8, 9}; 
	int n = sizeof(arr) / sizeof(arr[0]); 
	func(arr, n); 
	return 0; 
}

Run-Length encoding is used to compress data in bit arrays.

In how many different ways we can reach the end of the array arr[]={1,3,5,8,9}?