|
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:
#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
|
|
|
|
|
|
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 />
}<br />
<br />
func2(x[])<br />
{<br />
for(int i=0;i<length(x);i++)><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! 
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++)>
{
}
}
}
}
Edit: Ah, better.
|
|
|
|
|
O(n). Right? 
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 
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.
|
|
|
|
|
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;
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...
|
|
|
|
|
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
|
|
|
|
|
General 
News 
Suggestion 
Question 
Bug 
Answer 
Joke 
Praise 
Rant 
Admin 
Submit an article or tip
