char c_input;
bool b_keepReading = true;
while(b_keepReading){
cin.get(&c_input);
if (c_input == "\n"){
b_keepReading = false;
}
}
//sort.cpp sorts the index from lowest value to highest value
//
//Adam Holthaus
#include "stdafx.h"
#include <iostream>
using namespace std;
double sort(double index[], int esave)
{
//Initializing variable
int n, min, entry, edefine;
for(edefine = 0; edefine < esave; edefine++)
{
min = index[edefine];
n = edefine;
for(entry = edefine; entry < esave; entry++)
{
if(index[n] < min)
{
min = index[n];
n = entry;
}
}
index[n] = index[edefine];
index[edefine] = min;
}
return index[esave];
}Do you have to write your own sorter function? qsort is built into cstdlib and is quite good at what it does. edit: Here's a simple insertion sort, you can find the algorithm all over the place.
void sort(double d_array[], int i_arrSize)
{
int i_swap;
double d_temp;
for (int x = 0; x < i_arrSize; x++){
d_temp = d_array[x];
i_swap = x-1;
while(d_temp < d_array[i_swap] && i_swap >= 0){
d_array[i_swap+1] = d_array[i_swap];
i_swap--;
}
d_array[i_swap+1] = d_temp;
}
}That's the strangest C++ I have ever seen....[-0MEGA-];1610703 said:
You cannot return arrays like that.
<echo>
Hello World!
</echo>Pointing out the fact that I was returning the array the way I was probably fixed it, let me see. What do you mean with a quick sort? Or merge sort? Time is not an issue, neither is space. From what I saw, the bubble sort doesn't seem like it will work well for this.
Do you have to write your own sorter function? qsort is built into cstdlib and is quite good at what it does. edit: Here's a simple insertion sort, you can find the algorithm all over the place.
/editCode:void sort(double d_array[], int i_arrSize) { int i_swap; double d_temp; for (int x = 0; x < i_arrSize; x++){ d_temp = d_array[x]; i_swap = x-1; while(d_temp < d_array[i_swap] && i_swap >= 0){ d_array[i_swap+1] = d_array[i_swap]; i_swap--; } d_array[i_swap+1] = d_temp; } }
Can you explain this function to me, why are you returning the last element of the array?
That's the strangest C++ I have ever seen....
Pointing out the fact that I was returning the array the way I was probably fixed it, let me see. What do you mean with a quick sort? Or merge sort? Time is not an issue, neither is space. From what I saw, the bubble sort doesn't seem like it will work well for this.
Yeah, I have to write my own (but I'm allowed to get help). Why all the underscores in the one you posted? Just confuses me
I don't know why I am returning the index with the last element...I'm going to fix that, and try it again, thanks.
EDIT: Didn't fix it.
Anyone know what I should be returning?
Also, thanks for the code Cromewell, I'm using it. Will update later.
EDIT2: still not working...
//sort.cpp sorts the index from lowest value to highest value
//
//Adam Holthaus
#include <iostream>
#include <cstdlib>
#include <cstdio>
void sort(double, int);
using namespace std;
void sort(double d_array[], int i_arrSize)
{
int i_swap;
double d_temp;
for (int x = 0; x < i_arrSize; x++){
d_temp = d_array[x];
i_swap = x-1;
while(d_temp < d_array[i_swap] && i_swap >= 0){
d_array[i_swap+1] = d_array[i_swap];
i_swap--;
}
d_array[i_swap+1] = d_temp;
}
}
int main(){
double d_sortMe[] = {1.0,2.0,5.0,3.0,6.0,2.5,1.3};
int i_arrSize = sizeof(d_sortMe)/sizeof(double);
printf("Original Order\n");
printf("------------------------\n");
for (int x = 0; x < i_arrSize; x++){
printf("%lf\n",d_sortMe[x]);
}
printf("------------------------\n");
printf("Sorted\n");
printf("------------------------\n");
sort(d_sortMe, sizeof(d_sortMe)/sizeof(double));
for (int x = 0; x < i_arrSize; x++){
printf("%lf\n",d_sortMe[x]);
}
printf("------------------------\n");
system("pause");
return 0;
}//sort.cpp sorts the index from lowest value to highest value
//
//Adam Holthaus
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cmath>
void sort(double, int);
using namespace std;
void sort(double d_array[], int i_arrSize)
{
int i_swap;
double d_temp;
for (int x = 0; x < i_arrSize; x++){
d_temp = d_array[x];
i_swap = x-1;
while(d_temp < d_array[i_swap] && i_swap >= 0){
d_array[i_swap+1] = d_array[i_swap];
i_swap--;
}
d_array[i_swap+1] = d_temp;
}
}
int main(){
double d_sortMe[] = {1.0,2.0,5.0,3.0,6.0,2.5,1.3};
double d_stdDev;
int i_arrSize = sizeof(d_sortMe)/sizeof(double);
cout << "Original Order" << endl;
cout << "------------------------" << endl;
for (int x = 0; x < i_arrSize; x++){
cout << d_sortMe[x] << endl;
}
cout << "------------------------" << endl;
cout << "Sorted" << endl;
cout << "------------------------" << endl;
sort(d_sortMe, i_arrSize);
for (int x = 0; x < i_arrSize; x++){
cout << d_sortMe[x] << endl;
}
cout << "------------------------" << endl;
system("pause");
return 0;
}long rational::lcd(long d2)
{
long minden, maxden, multiple;
minden = min(den, d2);
maxden = max(den, d2);
multiple = 1;
while(maxden*multiple%minden !=0)
multiple++;
return maxden*multiple;
}long rational::greatestcommonfactor(long x1, long x2)
{
long minnum, maxnum, gcf;
minnum = min(abs(x1), abs(x2));
maxnum = max(abs(x1), abs(x2));
gcf = minnum;
while(maxnum % gcf !=0 || minnum % gcf !=0)
gcf--;
return gcf;
}rational rational:: operator +(rational fraction_2)
{
long cden, gfc, x1, x2;
rational sum;
cden = lcd(fraction_2.den);
sum.den = cden;
x1 = num;
x2 = fraction_2.num;
gfc = greatestcommonfactor(x1, x2);
sum.num = x1 + x2;
return sum;
}// lab20.cpp : Defines the entry point for the console application.
//
#include "rational.h"
int _tmain(int argc, _TCHAR* argv[])
{
rational fraction_1, fraction_2, sum;
cout <<"Please enter fractions seperated by spaces, numerator and denominator seprated by spaces: ";
cin >>fraction_1 >>fraction_2;
sum = fraction_1 + fraction_2;
cout <<fraction_1 <<endl <<fraction_2 <<endl <<sum <<endl;
return 0;
}// header file to define the rational class
//
//Adam Holthaus, steve05
#include <iostream>
#include <fstream>
using namespace std;
class rational
{
friend istream& operator >>(istream&, rational&);
friend ostream& operator <<(ostream&, rational);
private:
long num, den;
public:
void reduce();
long greatestcommonfactor(long, long);
long lcd(long);
rational operator +(rational);
};
