The time complexity of the unshift method is O(n), where n is the length of the array. This is because when you unshift an element to the beginning of an array, all the other elements need to be shifted to the right to make room for the new element. So, in the worst case scenario, if we have an array with n elements, all n elements will need to be shifted one position to the right. As a result, the time it takes to unshift an element increases linearly with the size of the array.

java
 
 
Copy code
public int fibo(int number) {
    if (number <= 1) {  // Base cases for fibonacci series
        return 1;
    }

    int prev1 = 1, prev2 = 1, fibo = 1;

    for (int i = 2; i <= number; i++) {  // Loop starts from i = 2
        fibo = prev1 + prev2;  // Calculation of next fibonacci number

        prev2 = prev1;
        prev1 = fibo;
    }

    return fibo;
}

The time complexity of this algorithm is O(n) where n is the value of the parameter passed to the function. This is the optimal time complexity for finding any fibonacci number since we have to go through all the numbers from 0 to n.

In general, the swap method is usually more efficient in terms of time complexity compared to the count method. The count method has a time complexity of O(n+k) where n is the number of elements to be sorted and k is the range of the non-negative key values. On the other hand, the swap method has an average time complexity of O(n log n) for most implementations. However, the efficiency of each method can vary depending on the specific implementation and the input size.

Here is an example implementation of the swap method in JavaScript:

code
 
 
Copy code
function swap(arr, i, j) {
  let temp = arr[i];
  arr[i] = arr[j];
  arr[j] = temp;
}

function quickSort(arr, left = 0, right = arr.length - 1) {
  if (left >= right) {
    return;
  }

  const pivotIndex = Math.floor((left + right) / 2);
  const pivot = arr[pivotIndex];

  swap(arr, pivotIndex, right);

  let swapIndex = left;

  for (let i = left; i < right; i++) {
    if (arr[i] < pivot) {
      swap(arr, i, swapIndex);
      swapIndex++;
    }
  }

  swap(arr, swapIndex, right);

  quickSort(arr, left, swapIndex - 1);
  quickSort(arr, swapIndex + 1, right);

  return arr;
}

const unsortedArray = [3, 5, 1, 2, 4];
console.log(quickSort(unsortedArray));

I hope this helps! Let me know if you have any more questions.

To find the smallest number in an array, you can loop through each element in the array and keep track of the smallest number you've encountered so far. Here's an example implementation in JavaScript:

javascript
 
 
Copy code
function findSmallest(arr) {
  let smallest = arr[0];
  for (let i = 1; i < arr.length; i++) {
    if (arr[i] < smallest) {
      smallest = arr[i];
    }
  }
  return smallest;
}

The time complexity of this solution is O(n), where n is the number of elements in the array. This is because in the worst case scenario, we'd have to loop through the entire array once to find the smallest number.

Big-O notation is a symbolic representation used to describe how the performance of an algorithm scales with the size of the input. It is used to measure the time complexity and space complexity of an algorithm, by expressing the amount of resources (e.g. memory or time) that the algorithm requires in terms of the size of an input.