question is: i have 10 arrays,each array have 3 numbers.they are all double.
i want to get a number from each array and let their mul is between a range.
for example:a[i]={0.3,0.4,0,0.3}
b[i]={0.2,0.4,0,0.4}
c[i]={0.1,0.4,0,0.5}
d[i]={0.2,0.3,0,0.5}
e[i]={0.7,0.2,0,0.1}
f[i]={0.6,0.2,0,0.2}
g[i]={0.9,0.06,0,0.04}
h[i]={0.55,0.2,0,0.25}
j[i]={0.63,0.17,0,0.2}
k[i]={0.18,0.43,0,0.39}
l[i]={0.23,0.52,0,0.25}
m[i]={0.15,0.4,0,0.45}
n[i]={0.12,0.36,0,0.52}
double t=a[i]*b[i]*c[i]........n[i];
and (t>0.00000001 && t<0.0000001)
print out a[i] to n[i].
find out all the number.
so can u code it in c/c++.
i will online wait for your answer.
and my email address is leo_vs_yy@hotmail.com
jfaust
September 23rd, 2002, 10:06 AM
If you have a specific question, ask it. We will not do your homework for you.
Jeff
lfj
September 23rd, 2002, 07:39 PM
this is not a homework.
jfaust
September 24th, 2002, 12:44 AM
Well, this is very confusing. You say you have 10 arrays, and then you list 13 arrays. You say each array has 3 numbers, but in your example there are 4.
You want to multiply the nth element in each array? Well, it looks like you are doing that. I don't know what you are trying to say with "(t>0.00000001 && t<0.0000001)".
If you can provide a code sample that compiles and/or demonstrates the problem, maybe we can help.
This cleans up your code a little, and it now compiles. I didn't try to fix any of the logic in it since I don't understand what it's trying to do. At least it should be a better starting point.
else{
if (sum>=0.0000001 && sum<0.000001)
printf("second:" "%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f\n",a[i0],b[i1],c[i2],d[i3],e[i4],f[i5],g[i6],h[i7],j[i8],k[i9],l[i10],m[i11],o[i12]);
else {
if (sum>=0.000001 && sum<0.00001)
printf("third:" "%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f,%4.2f\n",a[i0],b[i1],c[i2],d[i3],e[i4],f[i5],g[i6],h[i7],j[i8],k[i9],l[i10],m[i11],o[i12]);
else
continue;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
system("pause");
return 0;
}
jfaust
September 24th, 2002, 10:39 PM
I still don't see a question here.
Jeff
tiesun
September 24th, 2002, 10:57 PM
I understand your meaning . but I dont know what are you question ? you already code it out.
proxima centaur
September 24th, 2002, 11:00 PM
Maybe it's because there isn't any, jfaust
:D
lfj, do yourself a favour, formulate a clear and elaborate question. Otherwise, we can only be mystified by the lack of information in your post.
lfj
September 25th, 2002, 01:14 AM
Do u know chinese?My English is so poor,so i am hard to explain
my meaning.So here,i try to do my best .
I want to input 13 arrays,and each array have 3 items.They r all input by keyboard.The programm is trying to find out all the items
in each array can make their mul in the range ,and then try to printing out them.Just like the coder i were wrote.But i found it's very slow to show all .How can it be faster?And make the result printed like that show all the first,and then show all the second,third,ect.
Paul McKenzie
September 25th, 2002, 01:53 AM
Originally posted by lfj
Do u know chinese?My English is so poor,so i am hard to explain
my meaning.So here,i try to do my best .
I want to input 13 arrays,and each array have 3 items.They r all input by keyboard.The programm is trying to find out all the items
in each array can make their mul in the range ,and then try to printing out them.Just like the coder i were wrote.But i found it's very slow to show all .How can it be faster?And make the result printed like that show all the first,and then show all the second,third,ect. Instead of trying to explain, how about giving us a sample of what is input, and what is output? Not in code, just numbers and a visual example. For example here is a question that is formulated correctly:
I would like to write a program that eliminates duplicates. For example:
{1,2,3,4,4,5,2} --> {1,2,3,4,5}
{0,0,0,1} --> {0,1}
(Then question is followed by some code)
Also, is there really a need for 13 to explain what the problem is? Why not first try 2 or 3? The code already is confusing, so cut it down to just 2 or 3 of these arrays. Trying to explain to us in C++ isn't going to be much help.
Regards,
Paul McKenzie
lfj
September 25th, 2002, 02:32 AM
input:
a[n]={3,5,6}
b[n]={4,6,9}
c[n]={7,9,4}
****************
sum=a[i]*b[j]*c[k]
for example:
(sum>50 && sum<100)
printf("%d,%d,%d\n",a[i],b[j],c[k])
(sum>100 && sum <200)
printf("%d,%d,%d\n",a[i],b[j],c[k])
just likt that.
TruBic
September 25th, 2002, 04:35 AM
Hi lfj
Your problem is a combination problem. I re-state the problem as follow: find all the combinations of 10 out of 3 (10 positions <=> your 10 array, 3 state <=> 0, 1, 2 = the indices to the double in each array). For these sort of combination it is best to solve by recursive.
The idea is we change the state of each pos one at a time, until all states are covered. Let take an example of 2 states and 3 pos (for short)
int States[MAX_POS-1] = {0, 0, ...0}; // initial state
double* A[MAX_POS-1] = {n0, n1, ... n9};
bool CheckResult(doulbe result, double minVal, double maxVal)
{
// do what ever kind of check you want here
// also print out whatever you want to print here
// example
// if (minVal <= result && result <= maxVal)
// print whatever you interested in here
}
void DoMul(int curPos, double minVal, double maxVal)
{
int pos;
// flag for us to stop the recursive
// we stop when the states at every pos is zero
bool stop = true;
double result = 1;
for (pos = 0 ; pos < MAX_POS ; ++pos)
{
result *= A[pos][States[pos]];
if (States[pos] != 0)
stop = false;
}
// CheckResult will do the comparision and output
CheckResult(result, minVal, maxVal);
if (stop)
return;
// try to increase the state of the current pos
if (State[curPos] < MAX_STATE)
++States[curPos]
else // we need to find out the next pos to increase
for (pos = curPos ; pos < MAX_POS ; ++pos)
if (States[pos] < MAX_STATE) // found the right pos now
{
curPos = pos;
++States[curPos];
DoMul(curPos, minVal, maxVal);
}
// if we got here it means all pos reach the MAX_STATE
// then we set the State of the current pos back to 0
States[curPos] = 0;
DoMul(curPos, minVal, maxVal);
}
Even better if you have access to STL, use the next_permutation to calculate the states, the code will be much shorter.
TruBic
September 25th, 2002, 02:51 PM
Hi jlf
My previous code was wrong! It loop forever :). I didn't check it at all. Here is the tested code with optimization as well (the idea is the same).
The optimization is based on the fact that every time we change the state of the current position we dont have to do the multiplication again we can calculate the new result from the previous result as follow:
newResult = oldResult * valueOfNewStateAtCurentPos / valueOfOldStateAtCurentPos. The only time we have to do the multiplication is when valueOfOldStateAtCurentPos == 0 which makes oldResult == 0, and 0 multiply by whatever is always 0 that's why we have to re-calculate it.
Here is the new code
// Combi.cpp : Defines the entry point for the console application.
//
// Make all these variable global to save the stack space, since we will do recursive
enum NLoopDirection {nldForward, nldBackward};
NLoopDirection LoopDirection;
int CurPos, States[MAX_POS];
double A[MAX_POS][MAX_STATE+1];
double MinValue, MaxValue, Result;
// helper to check the result and output interested value
void CheckResult()
{
int pos;
if (MinValue <= Result && Result <= MaxValue)
{
for (pos = 0 ; pos < MAX_POS ; ++pos)
printf("A%d[%d] = %f, ", pos, States[pos], A[pos][States[pos]]);
printf("Result = %f\n", Result);
}
}
// helper for calculating the saving result
void CalculateResult(int oldState)
{
// the calculation is as follows: Result = Result * newValueAtCurPos / oldValueAtCurPos
if (Result)
Result *= A[CurPos][States[CurPos]] / A[CurPos][oldState];
else if (0 == A[CurPos][oldState])
{
// result == 0 because the oldValueAtCurPos == 0, ===>>> we have to re-calculate the result
int i;
Result = 1;
for (i = 0 ; i < MAX_POS ; ++i)
if (0 == (Result *= A[i][States[i]]))
break;
}
}
// real part here
void DoMul()
{
bool stop = false;
int pos, oldState;
// check to increase the state of the current pos
oldState = States[CurPos];
if (LoopDirection == nldForward)
{
if (States[CurPos] < MAX_STATE)
++States[CurPos];
else
{
// need to find out the next position to increase
for (pos = CurPos ; pos < MAX_POS ; ++pos)
{
if (States[pos] < MAX_STATE)
{
// it's ok to increase the state of this pos and update the value of result
CurPos = pos;
oldState = States[CurPos];
++States[CurPos];
break;
}
}
if (MAX_POS == pos)
{
LoopDirection = nldBackward;
CurPos = MAX_POS-2;
oldState = States[CurPos];
++States[CurPos];
}
}
}
else
{
if (States[CurPos] > 0)
--States[CurPos];
else
{
// need to find out the next position to decrease
for (pos = CurPos ; pos >= 0 ; --pos)
{
if (States[pos] > 0)
{
// it's ok to decrease the state of this pos and update the value of result
CurPos = pos;
oldState = States[CurPos];
--States[CurPos];
break;
}
}
if (pos < 0)
return; // done
}
}
// Init the states array
memset(States, 0, MAX_POS*sizeof(int));
// Init the double arrays
for (pos = 0 ; pos < MAX_POS ; ++pos)
for (state = 0 ; state <= MAX_STATE ; ++state)
A[pos][state] = (double)rand()/RAND_MAX;
// Calculate the Result for the first permutation.
// result is used as the saving value in each permutation to speed up the performance.
Result = 1;
for (pos = 0 ; pos < MAX_POS ; ++pos)
if (0 == (Result *= A[pos][0]))
break;