Can you please share your thoughts on what will be time complexity for this
for(int i = 0; i <= n/2; i++) {
for(int j = n - i; j > n/2; j--) {
}
}
You just have to compute the number of times you execute your operation :
Hence, the complexity is O(n²).
Related
I tried to find the time complexity of the following two functions:
the first one
public static int myMethod1(int[] arr) {
int x = 0;
for (int i = 0; i < arr.length / 2; i++) {
for (int j = 0; j < arr.length; j++) {
for (int k = 0; k < arr.length; k++) {
x++;
if (k == arr.length / 2) {
break;
}
}
}
}
return x;
}
So with this one i am thinking.
The method contains 3 loops, and the loops are iterating over variable i, j and k…
i and j, and k are both incremented by 1 for each passing… this gives us as N For each LOOP which leaves us with three N’s.., which gives is O(N^3)
The next one is:
public static int myMethod(int N) {
int x = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N / 2; j++) {
for (int k = 1; k < N;) {
x++;
k *= 2;
}
}
}
return x;
}
With this i am thinking.
The method contains 3 loops, and the loops are iterating over variable i, j and k… i and j are both incremented by 1 for each passing… this gives us as N For each LOOP which leaves us with two N’s.. The last loop k doubles, which gives is log(n).
The result of the this problem is therefore O(N^2· log (N))
is this correct? and if it is not, why?
You are right. In both of the questions
This function returns the max char subset sequence. Example input and output are below. Can someone help with time complexity
function shortenString(str) {
let result = str.charAt(0);
for (let i = 1; i< str.length; i++) {
const c = str.charAt(i);
let j = i - 1;
while (j >= 0) {
const charA = result.charAt(j);
const charB = str.charAt(i);
console.log(`comparing ${charA} to ${charB}`);
if (result.charAt(j) < str.charAt(i)) {
result = result.substring(0, j);
}
j--;
}
result = result + str.charAt(i);
}
return result;
}
We can use the Big O notation to calculate its complexity here
If we look at the code we have to main loops - for and while
The for loop will do n iterations.
Meanwhile the while loop will do n(n+1)/2 iterations - which represent the sum of a series of n numbers. Its complexity is give by O(n^2);
Therefor the complexity of the code if n*n^2 = O(n^3)
Here's a sample solution for Sliding Window Maximum problem in Java.
Given an array nums, there is a sliding window of size k which is
moving from the very left of the array to the very right. You can only
see the k numbers in the window. Each time the sliding window moves
right by one position.
I want to get the time and space complexity of this function. Here's what I think would be the answer:
Time: O((n-k)(k * logk)) == O(nklogk)
Space (auxiliary): O(n) for return int[] and O(k) for pq. Total of O(n).
Is this correct?
private static int[] maxSlidingWindow(int[] a, int k) {
if(a == null || a.length == 0) return new int[] {};
PriorityQueue<Integer> pq = new PriorityQueue<Integer>(k, new Comparator<Integer>() {
// max heap
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
int[] result = new int[a.length - k + 1];
int count = 0;
// time: n - k times
for (int i = 0; i < a.length - k + 1; i++) {
for (int j = i; j < i + k; j++) {
// time k*logk (the part I'm not sure about)
pq.offer(a[j]);
}
// logk
result[count] = pq.poll();
count = count + 1;
pq.clear();
}
return result;
}
You're right in most of the part except -
for (int j = i; j < i + k; j++) {
// time k*logk (the part I'm not sure about)
pq.offer(a[j]);
}
Here total number of executions is log1 + log2 + log3 + log4 + ... + logk. The summation of this series -
log1 + log2 + log3 + log4 + ... + logk = log(k!)
And second thought is, you can do it better than your linearithmic time solution using double-ended queue property which will be O(n). Here is my solution -
public int[] maxSlidingWindow(int[] nums, int k) {
if (nums == null || k <= 0) {
return new int[0];
}
int n = nums.length;
int[] result = new int[n - k + 1];
int indx = 0;
Deque<Integer> q = new ArrayDeque<>();
for (int i = 0; i < n; i++) {
// remove numbers out of range k
while (!q.isEmpty() && q.peek() < i - k + 1) {
q.poll();
}
// remove smaller numbers in k range as they are useless
while (!q.isEmpty() && nums[q.peekLast()] < nums[i]) {
q.pollLast();
}
q.offer(i);
if (i >= k - 1) {
result[indx++] = nums[q.peek()];
}
}
return result;
}
HTH.
What is the complexity of this code?
public class test5{
public static void main(String[] args) {
int n = Integer.parseInt(args[0]);
for (int i = 1; i<=n; i++) {
for (int j = 1; j<=i; j++) {
System.out.print ("*");
}
System.out.println();
}
for (int i = n; i>=1; i--) {
for (int j = 1; j<=i; j++) {
System.out.print ("*");
}
System.out.println();
}
}
}
My assumption is that it will take O(n^2) operations because n*(n/2) + n*(n/2).
Am I right?
You are correct, a tight upper asymptotic bound for both the first and second nested loop blocks—say T_A(n) and T_B(n), respectively—is O(n^2), and hence the function as a whole runs as O(n^2), asymptotically.
You can analyze this in detail using Sigma notation to count the number of basic operations in the inner loop blocks for each of the nested loop blocks T_A(n) and T_B(n):
Where we've treated the System.out.print ("*"); operation as basic operation.
I need to perform an accumulative sum in an array in Java according to iteration number, like this.
for (int it = 1; it < 3; it++) {
for(int i = 0; i < simSource.length; i++) {
for (int j = 0; j < resulting.length; j++) {
results [i][j] = resulting[i][j] + (simSource[i] * 0.5)/3;
}
}
newResults = results;
}
Thus, in each iteration, the values in the array results[i][j] increase, and these values, are stored in an array. This process is repeated until the max amount of iterations - in the first "for".
My question/trouble is: How to store in the array the final values after each iteration?
Thank you very much.