Re: Big Oh Computation - Algorithms Discussion Boards

See, for instance, [^], [^], [^].

Smile | :)

If the Lord God Almighty had consulted me before embarking upon the Creation, I would have recommended something simpler.
-- Alfonso the Wise, 13th Century King of Castile.

This is going on my arrogant assumptions. You may have a superb reason why I'm completely wrong.
-- Iain Clarke

[Image resize DLL]

Hi ALL

I request some one can help me in generating the different combinations with the given string.

I am having string "ABC" and it need to generate the combinations with the same length string

Example: I am having string like "ABC" and generates Combinations
"ABC"
"ACB"
"BAC"
"BCA"
"CAB"
"CBA"

Same way if I choose 4 length string "ABCD" it should generate like below.

"ABCD"
"ABDC"
"ACBD"
"ACDB"
"ADBC"
"ADCB"
"BACD"
"BADC"
"BCAD"
"BCDA"
"BDAC"
"BDCA"
......should generate sixteen combinations..

length of the string can be dinamic(can be 5 , 6 or more).

Please can some one help me to build algorithm to generate this type of combinations in c#.

Thanks in Advance
Nivas

SatyaVas wrote:
......should generate sixteen combinations..

There are 24 combinations in this case. It's 4! (4 factorial).

The C++ standard library already contains functions to do this. This code will pull it off:

// VanillaConsole.cpp : Defines the entry point for the console application.
//
 
#include "stdafx.h"
#include <iostream>
#include <algorithm>
 
void main()
{
	using namespace std;
 
	char initial[] = "ABCD";
	char *pEnd = initial + sizeof(initial)/sizeof(initial[0])-1;
 
	do
	{
		cout << initial << endl;
	}
	while (next_permutation(initial, pEnd));
}

If you look at the source code that implements next_permutation you can easily write a C# version.

Steve

Thanque very much Steve

does anyone have a good formula for calculating azimuth between two city lat and lons

thanks

winburn wrote:
does anyone have a good formula for calculating azimuth between two city lat and lons

Google is your friend. Try the following search terms (without quotes).

formula latitude longitude azimuth

Good Day,

Given a pseudo code below:

<br />
main()<br />
{<br />
for(int i=0;i<n;i++)><br />
{<br />
x[i]=func1(func2(x[i]));<br />
}<br />
}<br />
<br />
func1(x[])<br />
{<br />
for(int i=0;i<length(x);i++)><br />
//Do something here<br />
}<br />
<br />
func2(x[])<br />
{<br />
for(int i=0;i<length(x);i++)><br />
//Do something here<br />
}<br />

How can I compute for the Asymptotic notation? I know that the loop in main() is O(n) and both func1 and func2 are O(n). But How can I combine the 3? Can I even combine the 3 to get O(N^3)? or it will be just O(3N)?

Thanks! Smile | :)

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

What would be your analysis of this?

main()
{
	for(int i=0;i<n;i++)>
	{
		for(int j=0;j<n;j++)>
		{
			for(int k=0;k<n;k++)>
			{
				// do the something from func2
			}
			// do the something from func 1
		}
	}
}

Edit: Ah, better.

O(n). Right? Sniff | :^)

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

How many times do we count to n?
Hint: it's not 3 Wink | ;)

main()
{
	int count = 0;
	for(int i=0;i<n;i++)>
	{
		for(int j=0;j<n;j++)>
		{
			for(int k=0;k<n;k++)>
			{
				count++;
			}
		}
	}
}

If this were a complexity of O(n) then count would be 3n. However it's not, what's the value of count at the end?

I'm not downing you, I'm just trying to help you come to the conclusion yourself.

hmm. So its O(N^3).

Can you please give a code example that will yield 3N? So I can properly differentiate the two.

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

main()
{
	int count = 0;
	for(int i=0;i<n;i++)>
	{
		count++;		
	}

	for(int i=0;i<n;i++)>
	{
		count++;		
	}

	for(int i=0;i<n;i++)>
	{
		count++;		
	}
}

Ah I see.

Thank you!

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

So as you can see now.

When you nest loops you multiply the complexity.

When you have loops side by side, you add.

When you say we add, that means N+N+N or simply 3N.

Correct me if I'm wrong but there is no such thing as O(3N) but only O(N)?

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

That's exactly correct, on both counts.

leppyr64 wrote:
When you nest loops you multiply the complexity.

If the number of iterations on an inner loop is proportional to the size of the problem, and will be the same for all iterations of the outer loop, then the complexity of the outer loop is a factor of N greater than that of the inner loop. The same will be true if the number of iterations for the inner loop will be uniformly distributed over a range, the top of which is proportional to the size of the problem.

There will be occasions, however, where nested loops aren't nearly as bad as they appear because, while the worst-case time of the inner loops is proportional to the size of the problem, they will almost always execute much faster. In Shell Sort, for example, there are three nested loops. In the last iteration of the outer loop, the middle loop will execute N-1 times and the inner loop may (worst-case) execute O(N) times, but the worst-case time is far less than O(N^2).

Hmmm, how about this nested loop?

main()
{
	List<int[]> n = new List<int[]>();
	
	for(int i=0;i<n.count;i++)>
	{
		n[i]=new int[100];
		for(int j=0;j<n[i].length;j++)>
		{
			for(int k=0;k<n[i].length;k++)>
			{
				
			}
		}
	}
}

Will this still be O(N^3)? The two inner loops is not proportional to the size of the problem.

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

This is when you can start talking about O(N*M^2), where M is the "usual" size of an array stuffed in the list. In reality you'd probably have some idea about how many elements are put in the arrays. Say you were storing four integers in each array, and had hundreds of these arrays in the list, you would probably refer to it as O(N), as the M is fairly insignificant. If the arrays contained n.Length items, then it would be ^3...

Big-O notation is a very rough analysis, you are generally interested in the highest power.

Depends on data too, some sort algorithms are worst case O(N^2), but the likely case is much gentler.

Mark Churchill
Director, Dunn & Churchill Pty Ltd
Free Download: Diamond Binding: The simple, powerful, reliable, and effective data layer toolkit for Visual Studio.

Alpha release: Entanglar: Transparant multiplayer framework for .Net games.

I see. So in the example above, if N>100, M (Integer in each array) does not really matter? But if N < M ,then it matters.

So I can say that the best case is just O(N) and the worst is O(N^3)?

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

Hey Guys, don't want to start another thread so here it goes...

for(int i=0;i<n;i++)>
   int x=1+1; //Constant Operation

is this O(N) or O(1)? I'm just doing constant operation inside a loop.

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

It is O(1). It has nothing to do with what is inside the loop (as long as it is not another loop dependent upon "n"), just how many times you execute the loop. In your stated case, it is linear, for each increase of n you only execute the loop one more time.

You are doing the constant operation N times...

Mark Churchill
Director, Dunn & Churchill Pty Ltd
Free Download: Diamond Binding: The simple, powerful, reliable, and effective data layer toolkit for Visual Studio.

Alpha release: Entanglar: Transparant multiplayer framework for .Net games.

Yeah. But it doesn't matter right?

Its still O(n). It doesn't matter if the operations inside the loop is a expensive or inexpensive operation?

It is said that the most complex structures built by mankind are software systems. This is not generally appreciated because most people cannot see them. Maybe that's a good thing because if we saw them as buildings, we'd deem many of them unsafe.

Yep, it doesnt matter if the execution time is trivial. The main thing is that if you double N then you double the execution time. N*10 -> 10*t, etc.

In that exact case the compiler would probably optimise it to x = 2 Wink | ;)

Mark Churchill
Director, Dunn & Churchill Pty Ltd
Free Download: Diamond Binding: The simple, powerful, reliable, and effective data layer toolkit for Visual Studio.

Alpha release: Entanglar: Transparant multiplayer framework for .Net games.