Hi,Please fidn the Answer.Sorting,h is Header .pdf
•
0 likes•3 views
Hi, Please fidn the Answer. //////////////////Sorting,h is Header file which contians all Function decalartion #include #include // std::cout #include // std::shuffle #include // std::array #include // std::default_random_engine #include using namespace std; class Sorting { private: int num; public: Sorting::Sorting() { }; ///Buble Sort Input array and n Number of Elemnets void BubbleSorting(int array[], int n); void SelectionSorting(int array[], int n); void ShuffleArray(int array[], int n); void DisplayArray(int array[], int n); void displayMenu(); int choice; }; //////////////////////////Sorting.cpp is class fuction Which Implemnets the Function #include \"Sorting.h\" #include using namespace std; ///Sorting the Array Using Bubble Sort... void Sorting::BubbleSorting(int Array[],int n) { int temp = 0; cout << \"\ ------------ BUBBLE SORT ------------ \ \ \"; for (int i = 1; iArray[j + 1]) { temp = Array[j]; Array[j] = Array[j + 1]; Array[j + 1] = temp; } } cout << \"\ ------------ RESULTS BUBBLE SORT ------------ \ \ \"; DisplayArray(Array, n); } //////SelectionSorting input Array and n is number of Elemnets////////////////////// void Sorting::SelectionSorting(int Array[], int n) { int i, n, p, k, min, loc, temp; for (p = 1; p <= n - 1; p++) // Loop for Pass { min = Array[p]; // Element Selection loc = p; for (k = p + 1; k <= n; k++) // Finding Min Value { if (min > Array[k]) { min = Array[k]; loc = k; } } temp = Array[p]; // Swap Selected Element and Min Value Array[p] = Array[loc]; Array[loc] = temp; } cout << \"\ ------------ RESULTS SELECTION SORT ------------ \ \ \"; DisplayArray(Array, n); } //////SelectionSorting input Array and n is number of Elemnets////////////////////// ///exchange each element with a randomly chosen element. It\'s possible that an element will be exchanged with itself, but there is no problem with that void Sorting::ShuffleArray(int Array[], int n) { cout << \"\ ------------ ShuffleArray SORT ------------ \ \ \"; for (int i = 0; i #include \"Sorting.h\" using namespace std; int main() { bool SelectionOn = true; Sorting Sorting; int choice; int n = 10; int *Arry; while (SelectionOn != false) { cout << \"*******************************\ \"; cout << \" 1 - Enter User Input Array of Elements.\ \"; cout << \" 2 - Display User Input.\ \"; cout << \" 3 - Shuffle User Input the Elements i.\ \"; cout << \" 4 - Bubble Sorting.\ \"; cout << \" 5 - Selection Sorting.\ \"; cout << \" 6 - Exit.\ \"; cout << \" 7 - Display Menu Again. \ \"; cout << \" Enter your choice and press return: \"; cin >> choice; switch (choice) { case 1: cout << \"Enter User Input Array of Elements\ \"; cout << \"Enter No. of Elements=\"; cin >> n; Arry = new int[n]; cout << \"\ Enter Elements=\ \"; for (int i = 1; i <= n; i++) { cin >> Arry[i]; } break; case 2: cout << \"DISPLAY OF ARRAY\ \"; if (Arry != NULL) { Sorting.DisplayArray(Arry, n); } else { cout << \"ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1\ \"; } break; case 3: cout << \"SHUFFLE OF A.
Report
Share
Report
Share
Download to read offline
![Hi,
Please fidn the Answer.
//////////////////Sorting,h is Header file which contians all Function decalartion
#include
#include // std::cout
#include // std::shuffle
#include // std::array
#include // std::default_random_engine
#include
using namespace std;
class Sorting
{
private:
int num;
public:
Sorting::Sorting() {
};
///Buble Sort Input array and n Number of Elemnets
void BubbleSorting(int array[], int n);
void SelectionSorting(int array[], int n);
void ShuffleArray(int array[], int n);
void DisplayArray(int array[], int n);
void displayMenu();
int choice;
};
//////////////////////////Sorting.cpp is class fuction Which Implemnets the Function
#include "Sorting.h"
#include
using namespace std;
///Sorting the Array Using Bubble Sort...
void Sorting::BubbleSorting(int Array[],int n)
{](https://image.slidesharecdn.com/hipleasefidntheanswer-230410042823-14529e1f/85/Hi-Please-fidn-the-Answer-Sorting-h-is-Header-pdf-1-320.jpg)
![int temp = 0;
cout << " ------------ BUBBLE SORT ------------ ";
for (int i = 1; iArray[j + 1])
{
temp = Array[j];
Array[j] = Array[j + 1];
Array[j + 1] = temp;
}
}
cout << " ------------ RESULTS BUBBLE SORT ------------ ";
DisplayArray(Array, n);
}
//////SelectionSorting input Array and n is number of Elemnets//////////////////////
void Sorting::SelectionSorting(int Array[], int n)
{
int i, n, p, k, min, loc, temp;
for (p = 1; p <= n - 1; p++) // Loop for Pass
{
min = Array[p]; // Element Selection
loc = p;
for (k = p + 1; k <= n; k++) // Finding Min Value
{
if (min > Array[k])
{
min = Array[k];
loc = k;
}
}
temp = Array[p]; // Swap Selected Element and Min Value
Array[p] = Array[loc];
Array[loc] = temp;
}
cout << " ------------ RESULTS SELECTION SORT ------------ ";
DisplayArray(Array, n);](data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7)
Recommended
filesHeap.h#ifndef HEAP_H#define HEAP_H#includ.docx
files/Heap.h
#ifndef HEAP_H
#define HEAP_H
#include <vector>
#include <stdexcept> // std::out_of_range
#include <math.h> // pow()
using namespace std;
template<typename T>
class Heap
{
private:
vector<T> _items; // Main vector of elements for heap storage
/**
* Used to take unsorted data and heapify it
*/
void buildHeap()
{
for (int i = _items.size() / 2; i >= 0; i--)
{
percolateDown(i);
}
}
/*********************************************************************/
/********************* Microassignment zone *************************/
/**
* Percolates the item specified at by index down
* into its proper location within a heap.
* Used for dequeue operations and array to heap conversions
* MA TODO: Implement percolateDown!
*/
void percolateDown(int index)
{
}
/**
* Percolate up from a given index to fix heap property
* Used in inserting new nodes into the heap
* MA TODO: Implement percolateUp
*/
void percolateUp( int current_position )
{
}
/************************** Microassigment zone DONE *********************/
public:
/**
* Default empty constructor
*/
Heap()
{
}
/**
* Constructor with a vector of elements
*/
Heap(const vector<T> &unsorted)
{
for (int i = 0; i < unsorted.size(); i++)
{
_items.push_back(unsorted[i]);
}
buildHeap();
}
/**
* Adds a new item to the heap
*/
void insert(T item)
{
int current_position = size(); // Get index location
_items.push_back(item); // Add data to end
percolateUp( current_position ); // Adjust up, as needed
}
/**
* Returns the top-most item in our heap without
* actually removing the item from the heap
*/
T& getFirst()
{
if( size() > 0 )
return _items[0];
else
throw std::out_of_range("No elements in Heap.");
}
/**
* Removes minimum value from heap and returns it to the caller
*/
T deleteMin()
{
int last_index = size() - 1; // Calc last item index
int root_index = 0; // Root index (for readability)
T min_item = _items[root_index]; // Keep item to return
_items[root_index] = _items[last_index]; // Move last item to root
_items.erase(_items.end() - 1); // Erase last element entry
percolateDown(0); // Fix heap property
return min_item;
}
/**
* Returns true if heap is empty, else false
*/
bool isEmpty() const
{
return _items.size() == 0;
}
/**
* Returns current quantity of elements in heap (N)
*/
int size() const
{
return _items.size();
}
/**
* Return heap data in order from the _items vector
*/
string to_s() const
{
string ret = "";
for(int i = 0; i < _items.size(); i++)
{
ret += to_string(_items[i]) + " ";
}
return ret;
}
/**
...
g++ -o simpleVector.exe simpleVector.cpp #include stdio.h #i.pdf
//g++ -o simpleVector.exe simpleVector.cpp
#include
#include
#include
using namespace std;
/******************************************************
* Template class named SimpleVector
* An array that can hold any specified
* data type. Use a dynamic array.
******************************************************/
template
class SimpleVector
{
public:
//default constructor
SimpleVector();
//constructor with size of array
SimpleVector(int size);
//copy constructor
SimpleVector(const SimpleVector& object);
//setter method
void SetArray(int size);
//getter method
void ShowArray(int size);
//destructor
void FreeMemory();
//accessor method
int GetSizeOfArray();
//getter method
T GetElementAt(int index);
//Overload the [] operator. The argument is a subscript.
//This function returns a reference
//to the element in the array indexed by the subscript.
T operator [] (int subscript);
private:
//private memeber variable
T *array; //to dynamically allocate an array
T *copy;
};
//These function are going to be used in switch statement
//in order to test each case(integer, double, string).
void caseOne(int userInput, int size);
void caseTwo(int userInput, int size);
void caseThree(int userInput, int size);
int main() {
int userInput;
int size;
char keepInput;
do {
cout << \"What type of data do you want?\ \";
cout <<\"1. intger\ \";
cout <<\"2. double\ \";
cout <<\"3. strings\ \";
cin >> userInput;
cout << \"Enter the number of data \";
cin >> size;
switch(userInput) {
case 1:
{
caseOne(userInput, size);
break;
}
case 2:
{
caseTwo(userInput, size);
break;
}
case 3:
{
caseThree(userInput, size);
break;
}
default:
cout << \"invalid input\";
}
cout << \"\ Do you want to enter the data again?(Y/N)\ \";
cin >> keepInput;
} while(toupper(keepInput) == \'Y\');
return 0;
}
//This funciton is called in the switch satatement
//The purpose of this funtion is test SimpleVecor calss
//funciton for \'int\' type.
void caseOne(int userInput, int size) {
SimpleVectorintegerData(size);
integerData.SetArray(size);
integerData.ShowArray(size);
cout << \"\ Enter an index to retrieve the data\ \";
cin >> userInput;
cout << \"\ Getting an element of array by \ \";
cout << \"1. GetElementAt function : \";
cout << integerData.GetElementAt(userInput);
cout << \"\ 2. overloaded operator [] : \";
cout << integerData[userInput];
cout << \"\ \ Copying the array\";
SimpleVectornewIntegerData(integerData);
newIntegerData.ShowArray(size);
newIntegerData.FreeMemory();
}
//This funciton is called in the switch satatement
//The purpose of this funtion is test SimpleVecor calss
//funciton for \'double\' type.
void caseTwo(int userInput, int size) {
SimpleVectordoubleData(size);
doubleData.SetArray(size);
doubleData.ShowArray(size);
cout << \"\ Enter an index to retrieve the data\ \";
cin >> userInput;
cout << \"\ Getting an element of array by \ \";
cout << \"1. GetElementAt function : \";
cout << doubleData.GetElementAt(userInput);
cout << \"\ 2. overloaded operator [] : \";
cout << doubleData[.
PROVIDE COMMENTS TO FELLOW STUDENTS ANSWERS AND PLEASE DON’T SAY G.docx
PROVIDE COMMENTS TO FELLOW STUDENTS ANSWERS AND PLEASE DON’T SAY GOOD WORK NICE FORMULA OR SOMETHING LIKE THAT, BUT ACTULLY HE CAN USE. THANK YOU.
Hartleys Function Code
Contains unread posts
Actions for Hartleys Function Code
Chad Hartley posted Nov 5, 2015 5:10 PM
Subscribe
This program will add an integer number and a decimal number up to 2 decimal places. I have included notes in the code to explain what each thing does. I hope I did this right. It compiles successfully.
PseudoCode
Start
Declare int O1; Stands for Output1
O1=sum; Sum is the functions name
Int sum()
Declare variables
Int num1;
Float num2;
Write “Enter a number.”
Scanf num1
Write”Enter a decimal number.”
Scanf num2
Return num1+num2
end
C Code
#include <stdio.h>
int sum();//prototype
int main()//calling program
{
//Declare a varaiable
int O1;
O1=sum();//main is calling sum one time.
//if I listed this twice it would run the function 'sum' twice.
// Example: if I add a new int (int O1, O2) and declare O2 to
//be O2=sum then the function would run twice.
}
int sum ()//function 'sum'
{
int num1;// Declare intergers/variables
float num2;
printf("Enter a number.\n");
scanf("%d",&num1);// Take first input and assign it to num1
printf("Enter a decimal number.\n");
scanf("%.2f",&num2);
//Can use the printf statement but when you are calling an integer you can use the return.
//printf("The sum of %d, %d, is %d", num1,num2,num1+num2);
return num1+num2;
}
ADD COMMENT HERE
Chaotic Function
Contains unread posts
Actions for Chaotic Function
Joshua Ray posted Nov 5, 2015 2:33 PM
Subscribe
float tmp
int i
function float chaos(float num)
{
for i < 20
num = 3.9*num*(1-num)
print num
}
main
print "Program description"
print "Request input btw 0 and 1"
tmp = input
chaos(tmp)
/*
* File: main.c
* Author: JaiEllRei
*
* Created on November 5, 2015, 2:04 PM
*/
#include <stdio.h>
#include <stdlib.h>
float chaos(float num);
int main(void)
{
float tmp;
printf("This program illustrates a choatic function. \n");
printf("Input a number between 0 and 1: ");
scanf("%f", &tmp);
chaos(tmp);
}
float chaos(float num)
{
for (int i=0; i<20; i++){
/*Chaotic Formula*/
num = 3.9 * num * (1-num);
printf("%.3f \n", num);
}
}
This program illustrates a choatic function.
Input a number between 0 and 1: .2
0.624
0.915
0.303
0.824
0.566
0.958
0.156
0.514
0.974
0.098
0.345
0.881
0.409
0.943
0.210
0.647
0.891
0.379
0.918
0.293
ADD COMMENT HERE
//MPH to KPH Conversion Function
Function KPHConv(value) as float
Set KPHConv = value*1.609344
End Function
Pseudocode for simple conversion program calling function
//Declare function
// MPH to KPH Conversion Function
Functio ...
selection_sort..c#include stdio.hheader file input output func.pdf
selection_sort..c
#include //header file input output function
#define N 10//default value N=10
void selection_sort(int a[], int n);//function declaration
int *find_largest(int a[], int n);//function declaration
void swap(int *p, int *q);//function declaration
int main(void)
{//main function
int i;
int a[N];//variable declaration
int x,y;
printf(\"Enter %d numbers to be sorted: \", N);
for (i = 0; i < N; i++)
scanf(\"%d\", &a[i]);//keyboard inputting
selection_sort(a, N);//calling method
printf(\"In sorted order:\");
for (i = 0; i < N; i++)
printf(\" %d\", a[i]);
printf(\"\ \");
printf(\"largest element in the array :\");
*find_largest(a,N);//calling method
printf(\"\ Enter two variables for swapping :\");
scanf(\"%d\",&x);
scanf(\"%d\",&y);
swap(&x,&y);
return 0;
}
void selection_sort(int a[], int n)
{//function definition
int i, largest = 0, temp;
if (n == 1)
return;
for (i = 1; i < n; i++)
if (a[i] > a[largest])
largest = i;//selection sort logic
if (largest < n - 1) {
temp = a[n-1];
a[n-1] = a[largest];
a[largest] = temp;
}
selection_sort(a, n - 1);
}
int *find_largest(int *a, int n)
{//function definition
for(int i=1;i if you want to find smallest element*/
*a=*(a+i);
}
printf(\"%d\",*a);
}
void swap(int *p, int *q)
{//function definition
*p = *p + *q; // x now becomes 15
*q = *p - *q; // y becomes 10
*p = *p - *q; // x becomes 5
printf(\"After swapping of values :\");
printf(\"%d %d\ \",*p,*q);
}
output
Enter 10 numbers to be sorted: 562 1 344 6 4 3 2 4 67 8
In sorted order: 1 2 3 4 4 6 8 67 344 562
largest element in the array :562
Enter two variables for swapping :10 20
After swapping of
values :20 10
Solution
selection_sort..c
#include //header file input output function
#define N 10//default value N=10
void selection_sort(int a[], int n);//function declaration
int *find_largest(int a[], int n);//function declaration
void swap(int *p, int *q);//function declaration
int main(void)
{//main function
int i;
int a[N];//variable declaration
int x,y;
printf(\"Enter %d numbers to be sorted: \", N);
for (i = 0; i < N; i++)
scanf(\"%d\", &a[i]);//keyboard inputting
selection_sort(a, N);//calling method
printf(\"In sorted order:\");
for (i = 0; i < N; i++)
printf(\" %d\", a[i]);
printf(\"\ \");
printf(\"largest element in the array :\");
*find_largest(a,N);//calling method
printf(\"\ Enter two variables for swapping :\");
scanf(\"%d\",&x);
scanf(\"%d\",&y);
swap(&x,&y);
return 0;
}
void selection_sort(int a[], int n)
{//function definition
int i, largest = 0, temp;
if (n == 1)
return;
for (i = 1; i < n; i++)
if (a[i] > a[largest])
largest = i;//selection sort logic
if (largest < n - 1) {
temp = a[n-1];
a[n-1] = a[largest];
a[largest] = temp;
}
selection_sort(a, n - 1);
}
int *find_largest(int *a, int n)
{//function definition
for(int i=1;i if you want to find smallest element*/
*a=*(a+i);
}
printf(\"%d\",*a);
}
void swap(int *p, int *q)
{//function definition
*p = *p + *q; // x now becomes 15
*q = *p - *q; // y becomes 10
*p = *p - *q; // x bec.
Recommended
filesHeap.h#ifndef HEAP_H#define HEAP_H#includ.docx
files/Heap.h
#ifndef HEAP_H
#define HEAP_H
#include <vector>
#include <stdexcept> // std::out_of_range
#include <math.h> // pow()
using namespace std;
template<typename T>
class Heap
{
private:
vector<T> _items; // Main vector of elements for heap storage
/**
* Used to take unsorted data and heapify it
*/
void buildHeap()
{
for (int i = _items.size() / 2; i >= 0; i--)
{
percolateDown(i);
}
}
/*********************************************************************/
/********************* Microassignment zone *************************/
/**
* Percolates the item specified at by index down
* into its proper location within a heap.
* Used for dequeue operations and array to heap conversions
* MA TODO: Implement percolateDown!
*/
void percolateDown(int index)
{
}
/**
* Percolate up from a given index to fix heap property
* Used in inserting new nodes into the heap
* MA TODO: Implement percolateUp
*/
void percolateUp( int current_position )
{
}
/************************** Microassigment zone DONE *********************/
public:
/**
* Default empty constructor
*/
Heap()
{
}
/**
* Constructor with a vector of elements
*/
Heap(const vector<T> &unsorted)
{
for (int i = 0; i < unsorted.size(); i++)
{
_items.push_back(unsorted[i]);
}
buildHeap();
}
/**
* Adds a new item to the heap
*/
void insert(T item)
{
int current_position = size(); // Get index location
_items.push_back(item); // Add data to end
percolateUp( current_position ); // Adjust up, as needed
}
/**
* Returns the top-most item in our heap without
* actually removing the item from the heap
*/
T& getFirst()
{
if( size() > 0 )
return _items[0];
else
throw std::out_of_range("No elements in Heap.");
}
/**
* Removes minimum value from heap and returns it to the caller
*/
T deleteMin()
{
int last_index = size() - 1; // Calc last item index
int root_index = 0; // Root index (for readability)
T min_item = _items[root_index]; // Keep item to return
_items[root_index] = _items[last_index]; // Move last item to root
_items.erase(_items.end() - 1); // Erase last element entry
percolateDown(0); // Fix heap property
return min_item;
}
/**
* Returns true if heap is empty, else false
*/
bool isEmpty() const
{
return _items.size() == 0;
}
/**
* Returns current quantity of elements in heap (N)
*/
int size() const
{
return _items.size();
}
/**
* Return heap data in order from the _items vector
*/
string to_s() const
{
string ret = "";
for(int i = 0; i < _items.size(); i++)
{
ret += to_string(_items[i]) + " ";
}
return ret;
}
/**
...
g++ -o simpleVector.exe simpleVector.cpp #include stdio.h #i.pdf
//g++ -o simpleVector.exe simpleVector.cpp
#include
#include
#include
using namespace std;
/******************************************************
* Template class named SimpleVector
* An array that can hold any specified
* data type. Use a dynamic array.
******************************************************/
template
class SimpleVector
{
public:
//default constructor
SimpleVector();
//constructor with size of array
SimpleVector(int size);
//copy constructor
SimpleVector(const SimpleVector& object);
//setter method
void SetArray(int size);
//getter method
void ShowArray(int size);
//destructor
void FreeMemory();
//accessor method
int GetSizeOfArray();
//getter method
T GetElementAt(int index);
//Overload the [] operator. The argument is a subscript.
//This function returns a reference
//to the element in the array indexed by the subscript.
T operator [] (int subscript);
private:
//private memeber variable
T *array; //to dynamically allocate an array
T *copy;
};
//These function are going to be used in switch statement
//in order to test each case(integer, double, string).
void caseOne(int userInput, int size);
void caseTwo(int userInput, int size);
void caseThree(int userInput, int size);
int main() {
int userInput;
int size;
char keepInput;
do {
cout << \"What type of data do you want?\ \";
cout <<\"1. intger\ \";
cout <<\"2. double\ \";
cout <<\"3. strings\ \";
cin >> userInput;
cout << \"Enter the number of data \";
cin >> size;
switch(userInput) {
case 1:
{
caseOne(userInput, size);
break;
}
case 2:
{
caseTwo(userInput, size);
break;
}
case 3:
{
caseThree(userInput, size);
break;
}
default:
cout << \"invalid input\";
}
cout << \"\ Do you want to enter the data again?(Y/N)\ \";
cin >> keepInput;
} while(toupper(keepInput) == \'Y\');
return 0;
}
//This funciton is called in the switch satatement
//The purpose of this funtion is test SimpleVecor calss
//funciton for \'int\' type.
void caseOne(int userInput, int size) {
SimpleVectorintegerData(size);
integerData.SetArray(size);
integerData.ShowArray(size);
cout << \"\ Enter an index to retrieve the data\ \";
cin >> userInput;
cout << \"\ Getting an element of array by \ \";
cout << \"1. GetElementAt function : \";
cout << integerData.GetElementAt(userInput);
cout << \"\ 2. overloaded operator [] : \";
cout << integerData[userInput];
cout << \"\ \ Copying the array\";
SimpleVectornewIntegerData(integerData);
newIntegerData.ShowArray(size);
newIntegerData.FreeMemory();
}
//This funciton is called in the switch satatement
//The purpose of this funtion is test SimpleVecor calss
//funciton for \'double\' type.
void caseTwo(int userInput, int size) {
SimpleVectordoubleData(size);
doubleData.SetArray(size);
doubleData.ShowArray(size);
cout << \"\ Enter an index to retrieve the data\ \";
cin >> userInput;
cout << \"\ Getting an element of array by \ \";
cout << \"1. GetElementAt function : \";
cout << doubleData.GetElementAt(userInput);
cout << \"\ 2. overloaded operator [] : \";
cout << doubleData[.
PROVIDE COMMENTS TO FELLOW STUDENTS ANSWERS AND PLEASE DON’T SAY G.docx
PROVIDE COMMENTS TO FELLOW STUDENTS ANSWERS AND PLEASE DON’T SAY GOOD WORK NICE FORMULA OR SOMETHING LIKE THAT, BUT ACTULLY HE CAN USE. THANK YOU.
Hartleys Function Code
Contains unread posts
Actions for Hartleys Function Code
Chad Hartley posted Nov 5, 2015 5:10 PM
Subscribe
This program will add an integer number and a decimal number up to 2 decimal places. I have included notes in the code to explain what each thing does. I hope I did this right. It compiles successfully.
PseudoCode
Start
Declare int O1; Stands for Output1
O1=sum; Sum is the functions name
Int sum()
Declare variables
Int num1;
Float num2;
Write “Enter a number.”
Scanf num1
Write”Enter a decimal number.”
Scanf num2
Return num1+num2
end
C Code
#include <stdio.h>
int sum();//prototype
int main()//calling program
{
//Declare a varaiable
int O1;
O1=sum();//main is calling sum one time.
//if I listed this twice it would run the function 'sum' twice.
// Example: if I add a new int (int O1, O2) and declare O2 to
//be O2=sum then the function would run twice.
}
int sum ()//function 'sum'
{
int num1;// Declare intergers/variables
float num2;
printf("Enter a number.\n");
scanf("%d",&num1);// Take first input and assign it to num1
printf("Enter a decimal number.\n");
scanf("%.2f",&num2);
//Can use the printf statement but when you are calling an integer you can use the return.
//printf("The sum of %d, %d, is %d", num1,num2,num1+num2);
return num1+num2;
}
ADD COMMENT HERE
Chaotic Function
Contains unread posts
Actions for Chaotic Function
Joshua Ray posted Nov 5, 2015 2:33 PM
Subscribe
float tmp
int i
function float chaos(float num)
{
for i < 20
num = 3.9*num*(1-num)
print num
}
main
print "Program description"
print "Request input btw 0 and 1"
tmp = input
chaos(tmp)
/*
* File: main.c
* Author: JaiEllRei
*
* Created on November 5, 2015, 2:04 PM
*/
#include <stdio.h>
#include <stdlib.h>
float chaos(float num);
int main(void)
{
float tmp;
printf("This program illustrates a choatic function. \n");
printf("Input a number between 0 and 1: ");
scanf("%f", &tmp);
chaos(tmp);
}
float chaos(float num)
{
for (int i=0; i<20; i++){
/*Chaotic Formula*/
num = 3.9 * num * (1-num);
printf("%.3f \n", num);
}
}
This program illustrates a choatic function.
Input a number between 0 and 1: .2
0.624
0.915
0.303
0.824
0.566
0.958
0.156
0.514
0.974
0.098
0.345
0.881
0.409
0.943
0.210
0.647
0.891
0.379
0.918
0.293
ADD COMMENT HERE
//MPH to KPH Conversion Function
Function KPHConv(value) as float
Set KPHConv = value*1.609344
End Function
Pseudocode for simple conversion program calling function
//Declare function
// MPH to KPH Conversion Function
Functio ...
selection_sort..c#include stdio.hheader file input output func.pdf
selection_sort..c
#include //header file input output function
#define N 10//default value N=10
void selection_sort(int a[], int n);//function declaration
int *find_largest(int a[], int n);//function declaration
void swap(int *p, int *q);//function declaration
int main(void)
{//main function
int i;
int a[N];//variable declaration
int x,y;
printf(\"Enter %d numbers to be sorted: \", N);
for (i = 0; i < N; i++)
scanf(\"%d\", &a[i]);//keyboard inputting
selection_sort(a, N);//calling method
printf(\"In sorted order:\");
for (i = 0; i < N; i++)
printf(\" %d\", a[i]);
printf(\"\ \");
printf(\"largest element in the array :\");
*find_largest(a,N);//calling method
printf(\"\ Enter two variables for swapping :\");
scanf(\"%d\",&x);
scanf(\"%d\",&y);
swap(&x,&y);
return 0;
}
void selection_sort(int a[], int n)
{//function definition
int i, largest = 0, temp;
if (n == 1)
return;
for (i = 1; i < n; i++)
if (a[i] > a[largest])
largest = i;//selection sort logic
if (largest < n - 1) {
temp = a[n-1];
a[n-1] = a[largest];
a[largest] = temp;
}
selection_sort(a, n - 1);
}
int *find_largest(int *a, int n)
{//function definition
for(int i=1;i if you want to find smallest element*/
*a=*(a+i);
}
printf(\"%d\",*a);
}
void swap(int *p, int *q)
{//function definition
*p = *p + *q; // x now becomes 15
*q = *p - *q; // y becomes 10
*p = *p - *q; // x becomes 5
printf(\"After swapping of values :\");
printf(\"%d %d\ \",*p,*q);
}
output
Enter 10 numbers to be sorted: 562 1 344 6 4 3 2 4 67 8
In sorted order: 1 2 3 4 4 6 8 67 344 562
largest element in the array :562
Enter two variables for swapping :10 20
After swapping of
values :20 10
Solution
selection_sort..c
#include //header file input output function
#define N 10//default value N=10
void selection_sort(int a[], int n);//function declaration
int *find_largest(int a[], int n);//function declaration
void swap(int *p, int *q);//function declaration
int main(void)
{//main function
int i;
int a[N];//variable declaration
int x,y;
printf(\"Enter %d numbers to be sorted: \", N);
for (i = 0; i < N; i++)
scanf(\"%d\", &a[i]);//keyboard inputting
selection_sort(a, N);//calling method
printf(\"In sorted order:\");
for (i = 0; i < N; i++)
printf(\" %d\", a[i]);
printf(\"\ \");
printf(\"largest element in the array :\");
*find_largest(a,N);//calling method
printf(\"\ Enter two variables for swapping :\");
scanf(\"%d\",&x);
scanf(\"%d\",&y);
swap(&x,&y);
return 0;
}
void selection_sort(int a[], int n)
{//function definition
int i, largest = 0, temp;
if (n == 1)
return;
for (i = 1; i < n; i++)
if (a[i] > a[largest])
largest = i;//selection sort logic
if (largest < n - 1) {
temp = a[n-1];
a[n-1] = a[largest];
a[largest] = temp;
}
selection_sort(a, n - 1);
}
int *find_largest(int *a, int n)
{//function definition
for(int i=1;i if you want to find smallest element*/
*a=*(a+i);
}
printf(\"%d\",*a);
}
void swap(int *p, int *q)
{//function definition
*p = *p + *q; // x now becomes 15
*q = *p - *q; // y becomes 10
*p = *p - *q; // x bec.
2 BytesC++ course_2014_c3_ function basics¶meters and overloading
This is my C++ course / basic , intermediate and a little advance
C++, Implement the class BinarySearchTree, as given in listing 16-4 .pdf
C++, Implement the class BinarySearchTree, as given in listing 16-4 (below) Please include
main function.
//************************************* Here is listing 16-4
// Created by Frank M. Carrano and Timothy M. Henry.
// Copyright (c) 2017 Pearson Education, Hoboken, New Jersey.
// Listing 16-4.
/** Link-based implementation of the ADT binary search tree.
@file BinarySearchTree.h */
#ifndef BINARY_SEARCH_TREE_
#define BINARY_SEARCH_TREE_
#include \"BinaryTreeInterface.h\"
#include \"BinaryNode.h\"
#include \"BinaryNodeTree.h\"
#include \"NotFoundException.h\"
#include \"PrecondViolatedExcept.h\"
#include
template
class BinarySearchTree : public BinaryNodeTree
{
private:
std::shared_ptr> rootPtr;
protected:
//------------------------------------------------------------
// Protected Utility Methods Section:
// Recursive helper methods for the public methods.
//------------------------------------------------------------
// Places a given new node at its proper position in this binary
// search tree.
auto placeNode(std::shared_ptr> subTreePtr,
std::shared_ptr> newNode);
// Removes the given target value from the tree while maintaining a
// binary search tree.
auto removeValue(std::shared_ptr> subTreePtr,
const ItemType target,
bool& isSuccessful) override;
// Removes a given node from a tree while maintaining a binary search tree.
auto removeNode(std::shared_ptr> nodePtr);
// Removes the leftmost node in the left subtree of the node
// pointed to by nodePtr.
// Sets inorderSuccessor to the value in this node.
// Returns a pointer to the revised subtree.
auto removeLeftmostNode(std::shared_ptr>subTreePtr,
ItemType& inorderSuccessor);
// Returns a pointer to the node containing the given value,
// or nullptr if not found.
auto findNode(std::shared_ptr> treePtr,
const ItemType& target) const;
public:
//------------------------------------------------------------
// Constructor and Destructor Section.
//------------------------------------------------------------
BinarySearchTree();
BinarySearchTree(const ItemType& rootItem);
BinarySearchTree(const BinarySearchTree& tree);
virtual ~BinarySearchTree();
//------------------------------------------------------------
// Public Methods Section.
//------------------------------------------------------------
bool isEmpty() const;
int getHeight() const;
int getNumberOfNodes() const;
ItemType getRootData() const throw(PrecondViolatedExcept);
void setRootData(const ItemType& newData);
bool add(const ItemType& newEntry);
bool remove(const ItemType& target);
void clear();
ItemType getEntry(const ItemType& anEntry) const throw(NotFoundException);
bool contains(const ItemType& anEntry) const;
//------------------------------------------------------------
// Public Traversals Section.
//------------------------------------------------------------
void preorderTraverse(void visit(ItemType&)) const;
void inorderTraverse(void visit(ItemType&)) const;
void postorderTraverse(void visit(ItemType&)) const;
//----------.
#include iostream #include deque #include stdio.h scan.pdf
#include
#include
#include //scanf,printf
#include
#include //istringstream
using namespace std;
//maps
#include \"MapGeneric.h\"
#include \"MapTriple.h\"
#include \"MapAbsoluteValue.h\"
#include \"MapSquare.h\"
//filters
#include \"FilterGeneric.h\"
#include \"filterEven.h\"
#include \"filterPositive.h\"
#include \"filterPositiveTwoDigit.h\"
//reduce
#include \"ReduceGeneric.h\"
#include \"ReduceMinimum.h\"
#include \"ReduceGCD.h\"
int main()
{
deque L,L1,L2;
int i;
string line;
getline(cin,line);
if(line.size() == 0)
return 0;
line.erase(remove(line.begin(), line.end(), \',\'), line.end());
istringstream s(line);
while(s>>i)
{
L.push_back(i);
}
if(L.size() != 20)
return 0;
//converting L -> 3*|L| aka L1
MapTriple triple; MapAbsoluteValue abs;
L1 = triple.map(abs.map(L));
//converting L1 -> positive two digit integers -> even intergers aka L2
filterEven even; filterPositiveTwoDigit p2;
L2 = p2.filter(L1);
if(L2.size() <2)
return 0;
L2 = even.filter(L2);
if(L2.size() <2)
return 0;
//finding the minimum and GCD from L2 respectively
ReduceMinimum min; ReduceGCD gcd;
printf(\"%d %d\ \",min.reduce(L2),gcd.reduce(L2));
}
FilterGeneric.cpp
#include
#include
#include \"FilterGeneric.h\"
using namespace std;
deque FilterGeneric::filter(deque deq)
{
//calling recursive function with deq and its length
select(deq,deq.size()-1);
return filterDeq;
}
//int i is the index that will start from the length of deque till 0
void FilterGeneric::select(deque deq, int i)
{
if(i == 0)
{
bool val = f(deq[i]);
if(val)
filterDeq.push_front(deq[i]);
return;
}
bool val = f(deq[i]);
if(val)
filterDeq.push_front(deq[i]);
return select(deq,i-1);
}
FilterGeneric.h
#ifndef FILTERGENERIC_H
#define FILTERGENERIC_H
#include
class FilterGeneric
{
public:
std::deque filter(std::deque);
void select(std::deque,int);
protected:
//this deque will store the integers after filtration.
std::deque filterDeq;
private:
virtual bool f(int)=0;
};
#endif
MapAbsoluteValue.cpp
#include
#include
#include
#include \"MapGeneric.h\" //base
#include \"MapAbsoluteValue.h\"
using namespace std;
int MapAbsoluteValue::f(int num)
{
return abs(num);
}
MapAbsoluteValue.h
#ifndef MAPABSOLUTEVALUE_H
#define MAPABSOLUTEVALUE_H
#include
//this class will map a given input N, using the function map(input), to |N|
class MapAbsoluteValue: public MapGeneric
{
public:
//overwriting pure virtual function making N -> |N|
int f(int);
private:
};
#endif
MapGeneric.cpp
#include
#include
#include \"MapGeneric.h\"
using namespace std;
deque MapGeneric::map(deque deq)
{
//calling recursive function with deq and its length
calculate(deq,deq.size()-1);
return mapDeq;
}
//int i is the index that will start from the length of deque till 0
void MapGeneric::calculate(deque deq, int i)
{
if(i == 0)
{
int val = f(deq[i]);
mapDeq.push_front(val);
return;
}
int val = f(deq[i]);
mapDeq.push_front(val);
return calculate(deq,i-1);
}
MapGeneric.h
#ifndef MAPGENERIC_H
#define MAPGENERIC_H
#include
class MapGeneric
{
public:
std::deque ma.
C programming tweak needed for a specific program.This is the comp.pdf
C programming tweak needed for a specific program.
This is the complete program up and running. except for one modification that my teacher is
requiring but it is confusing me.
The program needs to allocate disjoint memory and use that.
right now im allocating a continous block of memory on the heap but I need it to do disjoing
memory instead.
// Purpose: Program will allow a reseller to save their sales and calculate their profits.
// Also able to view highest profitable items and remove any sales they no longer want in their
sales inventory.
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#define PAUSE system(\"pause\")
#define CLS system(\"cls\");
//#define FLUSH fflush(stdin);
//////////////// SRUCTS BELOW //////////////////////////
typedef struct
{
char itemName[40];
float purchasePrice;
float soldPrice;
float shippingPrice;
float ebayFee;
float payPalFee;
float profit;
}SALES;
////////// FUNCTION PROTOTYPE BELOW /////////////
void addSale(SALES *Inventory, int *InventoryCounter);
void displayMenu(int *InventoryCounter);
void displayProfit(int *InventoryCounter, SALES *Inventory);
void displaySales(int *InventoryCounter, SALES *Inventory);
int getChoice(int *InventoryCounter);
void searchSale(SALES* Inventory, int InventoryCounter);
void sortProfits(SALES* Inventory, int InventoryCounter);
void removeSale(SALES* Inventory, int *InventoryCounter);
main() {
int SIZE;
int userChoice;
int InventoryCounter = 0;
//printf(\"*********************\ \");
//printf(\"* Welcome Reseller! *\ \");
//printf(\"*********************\ \");
printf(\"Enter the size of todays inventory:\");
scanf(\"%i\", &SIZE);
SALES *Inventory;
Inventory = calloc(SIZE, sizeof(SALES));//Using dynamic memory to allocate space on the
heap
do {
userChoice = getChoice(&InventoryCounter);
switch (userChoice) {
case 1:// Add a Sale
if (InventoryCounter == SIZE) // statement checks so we dont exceed the size of the
inventory user wants to enter.
{
printf(\"You Have Reached Max Inventory \ \");
PAUSE;
}
else {
addSale(&(Inventory[InventoryCounter]), &InventoryCounter);
}
break;
case 2: // Display all sales records
displaySales(&InventoryCounter, Inventory);
PAUSE;
break;
case 3: // Display all profits
sortProfits(Inventory, InventoryCounter);
displayProfit(&InventoryCounter, Inventory);
PAUSE;
break;
case 4: // Display Inventory
searchSale(Inventory, InventoryCounter);
break;
case 5:// remove a sale
removeSale(Inventory, &InventoryCounter);
break;
case 6: // Quit
break;
default:
printf(\"Please choose a valid option\ \");
PAUSE;
break;
}// end of switch
} while (userChoice != 6);
free(Inventory);
} // End of main
//////////////////////////////////////////// FUNCTIONS BELOW //////////////////////////////////////////////////
void addSale(SALES *Inventory, int *InventoryCounter)// Function that adds sale and
calculates the fees in the background.
{
float payPalFee = 0; // variable to store the paypal fee from 1 sale
float ebayFee = 0; // variable to store ebay fee for 1 sale.
Please find my solution.Please let me know in case of any issue..pdf
Please find my solution.
Please let me know in case of any issue.
########## Invoice.java ###############
public class Invoice {
// instance variables
private String name;
private int itemNumber;
private int quantity;
private double price;
private double totalCost;
// setters
public void setName(String name) {
this.name = name;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public void setPrice(double price) {
this.price = price;
}
public void setItemNumber(int itemNumber){
this.itemNumber = itemNumber;
}
//display method
public void displayLine(){
totalCost = price*quantity;
System.out.println(\"Name: \"+name);
System.out.println(\"Item Number: \"+itemNumber);
System.out.println(\"Quantity: \"+quantity);
System.out.println(\"Price: \"+price);
System.out.println(\"Total Cost: \"+totalCost);
}
}
################ TestInvoice.java ###################
import java.util.Scanner;
public class TestInvoice {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// creating three methods
Invoice i1 = new Invoice();
Invoice i2 = new Invoice();
Invoice i3 = new Invoice();
// input for first invoice
System.out.print(\"Enter name of invoice1: \");
i1.setName(sc.next());
System.out.print(\"Enter item number: \");
i1.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i1.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i1.setPrice(sc.nextDouble());
System.out.println();
// input for second invoice
System.out.print(\"Enter name of invoice2: \");
i2.setName(sc.next());
System.out.print(\"Enter item number: \");
i2.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i2.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i2.setPrice(sc.nextDouble());
System.out.println();
// input for third invoice
System.out.print(\"Enter name of invoice3: \");
i3.setName(sc.next());
System.out.print(\"Enter item number: \");
i3.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i3.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i3.setPrice(sc.nextDouble());
System.out.println();
sc.close();
// displaying three invoice information
i1.displayLine();
System.out.println();
i2.displayLine();
System.out.println();
i3.displayLine();
System.out.println();
}
}
/*
Sample Output:
Enter name of invoice1: Invoice1
Enter item number: 123
Enter quantity: 21
Enter price: 34.56
Enter name of invoice2: Invoice2
Enter item number: 124
Enter quantity: 25
Enter price: 43.5
Enter name of invoice3: Invoice3
Enter item number: 125
Enter quantity: 27
Enter price: 65
Name: Invoice1
Item Number: 123
Quantity: 21
Price: 34.56
Total Cost: 725.76
Name: Invoice2
Item Number: 124
Quantity: 25
Price: 43.5
Total Cost: 1087.5
Name: Invoice3
Item Number: 125
Quantity: 27
Price: 65.0
Total Cost: 1755.0
*/
Solution
Please find my solution.
Please let me know in case of any issue.
########## Invoice.java ###############
public class Invoice {
// instance variables
private Str.
write the To Dos to get the exact outputNOte A valid Fraction .pdf
write the To Do\'s to get the exact output:
NOte: A valid Fraction number has a non-negative numerator and a positive denominator.
Default constructor initializes the object to safe empty state (an object with denom equals -1).
The two-argument constructor also validates the parameters and sets the object to the safe empty
state if the parameters are not valid.
Write the definitions and prototypes of following functions in Fraction.cpp and Fraction.h
respectively (They are indicated in the files by //TODO tag):
Define isEmpty function as a member function, which returns true if the object is in safe empty
state (an object is in the safe empty state if denominator (denom) equals -1).
Define display function, which sends a Fraction number to the output stream (with the
“Numerator/denominator” format). This function just prints \"Invalid Fraction Object!\" in the
screen if the object is in the safe empty state. In case that object denominator equals 1, it just
print the numerator.
Define the operator functions for the following operators:
“+=”, “+”, “*”
The overload of the above operators should make the following code possible:
The member operator+ : Adds two Fraction numbers and returns a Fraction number as the result.
This function returns an object with the safe empty state if either of Fraction numbers (operands)
is in safe empty state. It makes following code possible:
A+B ( where A and B are Fraction objects)
The member operator+= : Adds two Fraction numbers and assigns the result to the left operand,
then returns a reference to the left operand. If either of Fraction numbers (operands) is in safe
empty state, it initializes the left operand to the safe empty state, then returns a reference to the
left operand. It makes following code possible:
A+=B ( where A and B are Fraction objects)
The member operator* : Multiplies two Fraction numbers and returns a Fraction number as the
result. This function returns an object with the safe empty state if either of Fraction numbers
(operands) is in safe empty state. It makes following code possible:
A*B ( where A and B are Fraction objects)
fraction.cpp
#include \"Fraction.h\"
using namespace std;
namespace sict{
Fraction::Fraction(){
denom =-1; // safe empty state
}
Fraction::Fraction(int n, int d) // n: numerator, d: denominator
{
if(n >= 0 && d > 0){
num = n;
denom = d;
reduce();
}
else
denom =-1; // set to safe empty state
}
int Fraction::gcd() // returns the greatest common divisor of num and
denom
{
int mn = min(); // min of num and denom
int mx = max(); // mX of num and denom
for (int x=mn ; x > 0 ; x--) // find the greatest common divisor
if( mx % x == 0 && mn % x == 0)
return x;
return 1;
}
void Fraction::reduce() // simplify the Fraction number
{
int tmp = gcd();
num /= tmp;
denom /= tmp;
}
int Fraction::max ()
{
return (num >= denom) ? num : denom;
}
int Fraction::min()
{
return (num >= denom) ? denom : num;
}
// in_lab
// TODO: write the implementation of display function HERE
// TODO: w.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th..
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
Riboflavin is required in the conversion of carbo.pdf
Riboflavin is required in the conversion of carbohydrates, fat and protein into
energy required for cell functions.
Solution
Riboflavin is required in the conversion of carbohydrates, fat and protein into
energy required for cell functions..
PbS,Ag2O and CaSO4 are stable as they are insolub.pdf
PbS,Ag2O and CaSO4 are stable as they are insoluble in water .
Solution
PbS,Ag2O and CaSO4 are stable as they are insoluble in water ..
More Related Content
Similar to Hi,Please fidn the Answer.Sorting,h is Header .pdf
2 BytesC++ course_2014_c3_ function basics¶meters and overloading
This is my C++ course / basic , intermediate and a little advance
C++, Implement the class BinarySearchTree, as given in listing 16-4 .pdf
C++, Implement the class BinarySearchTree, as given in listing 16-4 (below) Please include
main function.
//************************************* Here is listing 16-4
// Created by Frank M. Carrano and Timothy M. Henry.
// Copyright (c) 2017 Pearson Education, Hoboken, New Jersey.
// Listing 16-4.
/** Link-based implementation of the ADT binary search tree.
@file BinarySearchTree.h */
#ifndef BINARY_SEARCH_TREE_
#define BINARY_SEARCH_TREE_
#include \"BinaryTreeInterface.h\"
#include \"BinaryNode.h\"
#include \"BinaryNodeTree.h\"
#include \"NotFoundException.h\"
#include \"PrecondViolatedExcept.h\"
#include
template
class BinarySearchTree : public BinaryNodeTree
{
private:
std::shared_ptr> rootPtr;
protected:
//------------------------------------------------------------
// Protected Utility Methods Section:
// Recursive helper methods for the public methods.
//------------------------------------------------------------
// Places a given new node at its proper position in this binary
// search tree.
auto placeNode(std::shared_ptr> subTreePtr,
std::shared_ptr> newNode);
// Removes the given target value from the tree while maintaining a
// binary search tree.
auto removeValue(std::shared_ptr> subTreePtr,
const ItemType target,
bool& isSuccessful) override;
// Removes a given node from a tree while maintaining a binary search tree.
auto removeNode(std::shared_ptr> nodePtr);
// Removes the leftmost node in the left subtree of the node
// pointed to by nodePtr.
// Sets inorderSuccessor to the value in this node.
// Returns a pointer to the revised subtree.
auto removeLeftmostNode(std::shared_ptr>subTreePtr,
ItemType& inorderSuccessor);
// Returns a pointer to the node containing the given value,
// or nullptr if not found.
auto findNode(std::shared_ptr> treePtr,
const ItemType& target) const;
public:
//------------------------------------------------------------
// Constructor and Destructor Section.
//------------------------------------------------------------
BinarySearchTree();
BinarySearchTree(const ItemType& rootItem);
BinarySearchTree(const BinarySearchTree& tree);
virtual ~BinarySearchTree();
//------------------------------------------------------------
// Public Methods Section.
//------------------------------------------------------------
bool isEmpty() const;
int getHeight() const;
int getNumberOfNodes() const;
ItemType getRootData() const throw(PrecondViolatedExcept);
void setRootData(const ItemType& newData);
bool add(const ItemType& newEntry);
bool remove(const ItemType& target);
void clear();
ItemType getEntry(const ItemType& anEntry) const throw(NotFoundException);
bool contains(const ItemType& anEntry) const;
//------------------------------------------------------------
// Public Traversals Section.
//------------------------------------------------------------
void preorderTraverse(void visit(ItemType&)) const;
void inorderTraverse(void visit(ItemType&)) const;
void postorderTraverse(void visit(ItemType&)) const;
//----------.
#include iostream #include deque #include stdio.h scan.pdf
#include
#include
#include //scanf,printf
#include
#include //istringstream
using namespace std;
//maps
#include \"MapGeneric.h\"
#include \"MapTriple.h\"
#include \"MapAbsoluteValue.h\"
#include \"MapSquare.h\"
//filters
#include \"FilterGeneric.h\"
#include \"filterEven.h\"
#include \"filterPositive.h\"
#include \"filterPositiveTwoDigit.h\"
//reduce
#include \"ReduceGeneric.h\"
#include \"ReduceMinimum.h\"
#include \"ReduceGCD.h\"
int main()
{
deque L,L1,L2;
int i;
string line;
getline(cin,line);
if(line.size() == 0)
return 0;
line.erase(remove(line.begin(), line.end(), \',\'), line.end());
istringstream s(line);
while(s>>i)
{
L.push_back(i);
}
if(L.size() != 20)
return 0;
//converting L -> 3*|L| aka L1
MapTriple triple; MapAbsoluteValue abs;
L1 = triple.map(abs.map(L));
//converting L1 -> positive two digit integers -> even intergers aka L2
filterEven even; filterPositiveTwoDigit p2;
L2 = p2.filter(L1);
if(L2.size() <2)
return 0;
L2 = even.filter(L2);
if(L2.size() <2)
return 0;
//finding the minimum and GCD from L2 respectively
ReduceMinimum min; ReduceGCD gcd;
printf(\"%d %d\ \",min.reduce(L2),gcd.reduce(L2));
}
FilterGeneric.cpp
#include
#include
#include \"FilterGeneric.h\"
using namespace std;
deque FilterGeneric::filter(deque deq)
{
//calling recursive function with deq and its length
select(deq,deq.size()-1);
return filterDeq;
}
//int i is the index that will start from the length of deque till 0
void FilterGeneric::select(deque deq, int i)
{
if(i == 0)
{
bool val = f(deq[i]);
if(val)
filterDeq.push_front(deq[i]);
return;
}
bool val = f(deq[i]);
if(val)
filterDeq.push_front(deq[i]);
return select(deq,i-1);
}
FilterGeneric.h
#ifndef FILTERGENERIC_H
#define FILTERGENERIC_H
#include
class FilterGeneric
{
public:
std::deque filter(std::deque);
void select(std::deque,int);
protected:
//this deque will store the integers after filtration.
std::deque filterDeq;
private:
virtual bool f(int)=0;
};
#endif
MapAbsoluteValue.cpp
#include
#include
#include
#include \"MapGeneric.h\" //base
#include \"MapAbsoluteValue.h\"
using namespace std;
int MapAbsoluteValue::f(int num)
{
return abs(num);
}
MapAbsoluteValue.h
#ifndef MAPABSOLUTEVALUE_H
#define MAPABSOLUTEVALUE_H
#include
//this class will map a given input N, using the function map(input), to |N|
class MapAbsoluteValue: public MapGeneric
{
public:
//overwriting pure virtual function making N -> |N|
int f(int);
private:
};
#endif
MapGeneric.cpp
#include
#include
#include \"MapGeneric.h\"
using namespace std;
deque MapGeneric::map(deque deq)
{
//calling recursive function with deq and its length
calculate(deq,deq.size()-1);
return mapDeq;
}
//int i is the index that will start from the length of deque till 0
void MapGeneric::calculate(deque deq, int i)
{
if(i == 0)
{
int val = f(deq[i]);
mapDeq.push_front(val);
return;
}
int val = f(deq[i]);
mapDeq.push_front(val);
return calculate(deq,i-1);
}
MapGeneric.h
#ifndef MAPGENERIC_H
#define MAPGENERIC_H
#include
class MapGeneric
{
public:
std::deque ma.
C programming tweak needed for a specific program.This is the comp.pdf
C programming tweak needed for a specific program.
This is the complete program up and running. except for one modification that my teacher is
requiring but it is confusing me.
The program needs to allocate disjoint memory and use that.
right now im allocating a continous block of memory on the heap but I need it to do disjoing
memory instead.
// Purpose: Program will allow a reseller to save their sales and calculate their profits.
// Also able to view highest profitable items and remove any sales they no longer want in their
sales inventory.
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
#define PAUSE system(\"pause\")
#define CLS system(\"cls\");
//#define FLUSH fflush(stdin);
//////////////// SRUCTS BELOW //////////////////////////
typedef struct
{
char itemName[40];
float purchasePrice;
float soldPrice;
float shippingPrice;
float ebayFee;
float payPalFee;
float profit;
}SALES;
////////// FUNCTION PROTOTYPE BELOW /////////////
void addSale(SALES *Inventory, int *InventoryCounter);
void displayMenu(int *InventoryCounter);
void displayProfit(int *InventoryCounter, SALES *Inventory);
void displaySales(int *InventoryCounter, SALES *Inventory);
int getChoice(int *InventoryCounter);
void searchSale(SALES* Inventory, int InventoryCounter);
void sortProfits(SALES* Inventory, int InventoryCounter);
void removeSale(SALES* Inventory, int *InventoryCounter);
main() {
int SIZE;
int userChoice;
int InventoryCounter = 0;
//printf(\"*********************\ \");
//printf(\"* Welcome Reseller! *\ \");
//printf(\"*********************\ \");
printf(\"Enter the size of todays inventory:\");
scanf(\"%i\", &SIZE);
SALES *Inventory;
Inventory = calloc(SIZE, sizeof(SALES));//Using dynamic memory to allocate space on the
heap
do {
userChoice = getChoice(&InventoryCounter);
switch (userChoice) {
case 1:// Add a Sale
if (InventoryCounter == SIZE) // statement checks so we dont exceed the size of the
inventory user wants to enter.
{
printf(\"You Have Reached Max Inventory \ \");
PAUSE;
}
else {
addSale(&(Inventory[InventoryCounter]), &InventoryCounter);
}
break;
case 2: // Display all sales records
displaySales(&InventoryCounter, Inventory);
PAUSE;
break;
case 3: // Display all profits
sortProfits(Inventory, InventoryCounter);
displayProfit(&InventoryCounter, Inventory);
PAUSE;
break;
case 4: // Display Inventory
searchSale(Inventory, InventoryCounter);
break;
case 5:// remove a sale
removeSale(Inventory, &InventoryCounter);
break;
case 6: // Quit
break;
default:
printf(\"Please choose a valid option\ \");
PAUSE;
break;
}// end of switch
} while (userChoice != 6);
free(Inventory);
} // End of main
//////////////////////////////////////////// FUNCTIONS BELOW //////////////////////////////////////////////////
void addSale(SALES *Inventory, int *InventoryCounter)// Function that adds sale and
calculates the fees in the background.
{
float payPalFee = 0; // variable to store the paypal fee from 1 sale
float ebayFee = 0; // variable to store ebay fee for 1 sale.
Please find my solution.Please let me know in case of any issue..pdf
Please find my solution.
Please let me know in case of any issue.
########## Invoice.java ###############
public class Invoice {
// instance variables
private String name;
private int itemNumber;
private int quantity;
private double price;
private double totalCost;
// setters
public void setName(String name) {
this.name = name;
}
public void setQuantity(int quantity) {
this.quantity = quantity;
}
public void setPrice(double price) {
this.price = price;
}
public void setItemNumber(int itemNumber){
this.itemNumber = itemNumber;
}
//display method
public void displayLine(){
totalCost = price*quantity;
System.out.println(\"Name: \"+name);
System.out.println(\"Item Number: \"+itemNumber);
System.out.println(\"Quantity: \"+quantity);
System.out.println(\"Price: \"+price);
System.out.println(\"Total Cost: \"+totalCost);
}
}
################ TestInvoice.java ###################
import java.util.Scanner;
public class TestInvoice {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// creating three methods
Invoice i1 = new Invoice();
Invoice i2 = new Invoice();
Invoice i3 = new Invoice();
// input for first invoice
System.out.print(\"Enter name of invoice1: \");
i1.setName(sc.next());
System.out.print(\"Enter item number: \");
i1.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i1.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i1.setPrice(sc.nextDouble());
System.out.println();
// input for second invoice
System.out.print(\"Enter name of invoice2: \");
i2.setName(sc.next());
System.out.print(\"Enter item number: \");
i2.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i2.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i2.setPrice(sc.nextDouble());
System.out.println();
// input for third invoice
System.out.print(\"Enter name of invoice3: \");
i3.setName(sc.next());
System.out.print(\"Enter item number: \");
i3.setItemNumber(sc.nextInt());
System.out.print(\"Enter quantity: \");
i3.setQuantity(sc.nextInt());
System.out.print(\"Enter price: \");
i3.setPrice(sc.nextDouble());
System.out.println();
sc.close();
// displaying three invoice information
i1.displayLine();
System.out.println();
i2.displayLine();
System.out.println();
i3.displayLine();
System.out.println();
}
}
/*
Sample Output:
Enter name of invoice1: Invoice1
Enter item number: 123
Enter quantity: 21
Enter price: 34.56
Enter name of invoice2: Invoice2
Enter item number: 124
Enter quantity: 25
Enter price: 43.5
Enter name of invoice3: Invoice3
Enter item number: 125
Enter quantity: 27
Enter price: 65
Name: Invoice1
Item Number: 123
Quantity: 21
Price: 34.56
Total Cost: 725.76
Name: Invoice2
Item Number: 124
Quantity: 25
Price: 43.5
Total Cost: 1087.5
Name: Invoice3
Item Number: 125
Quantity: 27
Price: 65.0
Total Cost: 1755.0
*/
Solution
Please find my solution.
Please let me know in case of any issue.
########## Invoice.java ###############
public class Invoice {
// instance variables
private Str.
write the To Dos to get the exact outputNOte A valid Fraction .pdf
write the To Do\'s to get the exact output:
NOte: A valid Fraction number has a non-negative numerator and a positive denominator.
Default constructor initializes the object to safe empty state (an object with denom equals -1).
The two-argument constructor also validates the parameters and sets the object to the safe empty
state if the parameters are not valid.
Write the definitions and prototypes of following functions in Fraction.cpp and Fraction.h
respectively (They are indicated in the files by //TODO tag):
Define isEmpty function as a member function, which returns true if the object is in safe empty
state (an object is in the safe empty state if denominator (denom) equals -1).
Define display function, which sends a Fraction number to the output stream (with the
“Numerator/denominator” format). This function just prints \"Invalid Fraction Object!\" in the
screen if the object is in the safe empty state. In case that object denominator equals 1, it just
print the numerator.
Define the operator functions for the following operators:
“+=”, “+”, “*”
The overload of the above operators should make the following code possible:
The member operator+ : Adds two Fraction numbers and returns a Fraction number as the result.
This function returns an object with the safe empty state if either of Fraction numbers (operands)
is in safe empty state. It makes following code possible:
A+B ( where A and B are Fraction objects)
The member operator+= : Adds two Fraction numbers and assigns the result to the left operand,
then returns a reference to the left operand. If either of Fraction numbers (operands) is in safe
empty state, it initializes the left operand to the safe empty state, then returns a reference to the
left operand. It makes following code possible:
A+=B ( where A and B are Fraction objects)
The member operator* : Multiplies two Fraction numbers and returns a Fraction number as the
result. This function returns an object with the safe empty state if either of Fraction numbers
(operands) is in safe empty state. It makes following code possible:
A*B ( where A and B are Fraction objects)
fraction.cpp
#include \"Fraction.h\"
using namespace std;
namespace sict{
Fraction::Fraction(){
denom =-1; // safe empty state
}
Fraction::Fraction(int n, int d) // n: numerator, d: denominator
{
if(n >= 0 && d > 0){
num = n;
denom = d;
reduce();
}
else
denom =-1; // set to safe empty state
}
int Fraction::gcd() // returns the greatest common divisor of num and
denom
{
int mn = min(); // min of num and denom
int mx = max(); // mX of num and denom
for (int x=mn ; x > 0 ; x--) // find the greatest common divisor
if( mx % x == 0 && mn % x == 0)
return x;
return 1;
}
void Fraction::reduce() // simplify the Fraction number
{
int tmp = gcd();
num /= tmp;
denom /= tmp;
}
int Fraction::max ()
{
return (num >= denom) ? num : denom;
}
int Fraction::min()
{
return (num >= denom) ? denom : num;
}
// in_lab
// TODO: write the implementation of display function HERE
// TODO: w.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th..
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
#include algorithm #include vector #include iostream usi.pdf
#include
#include
#include
using namespace std;
template //For Template
void bogosort(std::vector& array) //For bogosort
{
while (! is_sorted(array))
{
std::random_shuffle(array.begin(), array.end());
}
}
template
bool is_sorted(const std::vector& array) //Conforming for display
{
for (typename std::vector::size_type i = 1; i < array.size(); ++i)
{
if (array[i] < array[i-1])
{
return false;
}
}
return true;
}
std::vector a (10); //Creates a vector of size 10
int arr[10];
template
void accept(std::vector& array) //Accepts data to a vector
{
int c;
for(c = 0; c < 10; c++)
cin>>arr[c];
a.assign (arr,arr+10); //Assign array data to the vector
}
template
void display(std::vector& array) //Display the vector contents
{
for (std::vector::iterator it = array.begin(); it != array.end(); ++it)
std::cout << \' \' << *it;
}
template
void selection(std::vector& arr) //Selection soring operation
{
int mini, loc, temp, x, y;
mini = arr[0];
for(x = 0; x <= arr.size()-1; x++)
{
mini = arr[x]; //x position value of array is considered as minimum value
loc = x; //Stores the location of the minimum value
for(y = x + 1; y <= arr.size()-1; y++)
{
if(arr[y] < mini) //Checks the already minimum value with the array contents
{
mini = arr[y]; //Stores the new minimum value
loc = y; //Stores the location of the minimum value
}
}
if(loc != x) //If it is not the same location
{
temp = arr[x];
arr[x] = arr[loc];
arr[loc] = temp;
}
}
}
template
void bubble(std::vector &ar) //Bubble sort operation
{
bool swapp = true;
while(swapp)
{
swapp = false;
for (int i = 0; i < ar.size()-1; i++)
{
if (ar[i]>ar[i+1] )
{
ar[i] += ar[i+1];
ar[i+1] = ar[i] - ar[i+1];
ar[i] -=ar[i+1];
swapp = true;
}
}
}
}
int main()
{
char ch;
do
{
cout<<\"\ MENU\";
cout<<\"\ a Fill the array with user input\";
cout<<\"\ b Display the array\";
cout<<\"\ c Suffel the array element randomly\";
cout<<\"\ d Sort the array using bubble sort\";
cout<<\"\ e Sort the array using Selection Sort\";
cout<<\"\ f Exit Program\";
cout<<\"\ Enter your choice: \";
cin>>ch;
switch(ch)
{
case \'a\':
case \'A\':
accept(a);
cout<<\"\ Accept data operation completed \ \";
break;
case \'b\':
case \'B\':
display(a);
cout<<\"\ Display data operation completed \ \";
break;
case \'c\':
case \'C\':
bogosort(a);
bool b = is_sorted(a);
if(b == true)
display(a);
cout<<\"\ Bugg Sorting operation completed \ \";
break;
case \'d\':
case \'D\':
bubble(a);
display(a);
cout<<\"\ Bubble Sort operation completed \ \";
break;
case \'e\':
case \'E\':
selection(a);
display(a);
cout<<\"\ Selection Sort operation completed \ \";
break;
case \'f\':
case \'F\':
exit(0);
default:
cout<<\"\ Wrong Choice\";
}
}while(1); //Loop will continue infinitely till F or f is pressed
}
Output
MENU
a Fill the array with user input
b Display the array
c Suffel the array element randomly
d Sort the array using bubble sort
e Sort the array using Selection Sort
f Exit Program
Enter your choice: a
10
5
4
78
9
65
3
1
45
66
Accept data operation completed
MENU
a Fill th.
Similar to Hi,Please fidn the Answer.Sorting,h is Header .pdf (20)
2 BytesC++ course_2014_c3_ function basics¶meters and overloading
2 BytesC++ course_2014_c3_ function basics¶meters and overloading
C++, Implement the class BinarySearchTree, as given in listing 16-4 .pdf
C++, Implement the class BinarySearchTree, as given in listing 16-4 .pdf
#include iostream #include deque #include stdio.h scan.pdf
#include iostream #include deque #include stdio.h scan.pdf
C programming tweak needed for a specific program.This is the comp.pdf
C programming tweak needed for a specific program.This is the comp.pdf
Please find my solution.Please let me know in case of any issue..pdf
Please find my solution.Please let me know in case of any issue..pdf
write the To Dos to get the exact outputNOte A valid Fraction .pdf
write the To Dos to get the exact outputNOte A valid Fraction .pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
#include algorithm #include vector #include iostream usi.pdf
More from anandf0099
Riboflavin is required in the conversion of carbo.pdf
Riboflavin is required in the conversion of carbohydrates, fat and protein into
energy required for cell functions.
Solution
Riboflavin is required in the conversion of carbohydrates, fat and protein into
energy required for cell functions..
PbS,Ag2O and CaSO4 are stable as they are insolub.pdf
PbS,Ag2O and CaSO4 are stable as they are insoluble in water .
Solution
PbS,Ag2O and CaSO4 are stable as they are insoluble in water ..
If multiple orbitals of the same energy are avail.pdf
If multiple orbitals of the same energy are available unoccupied orbitals will be
filled before occupied orbitals are reused
Solution
If multiple orbitals of the same energy are available unoccupied orbitals will be
filled before occupied orbitals are reused.
What is a Distributed System Compare it with a computer network sys.pdf
What is a Distributed System? Compare it with a computer network system.
It is a one of the model in the computer network system; these components communicate and
coordinate their actions by interchanging the messages. Process of sharing complex problems
over the network we can use the distributed systems.
Distributed Systems can be configured in Local Area Network like 10\'s of host systems.
The main principles of distributed systems are
Resource Sharing
Concurrency
Transparency
Fault Tolerance.
Coming to the point of comparison computer network just contains the hardware and its software
that will used transfer the data based on the individual working of the network. In case of
Distributed system connect one system to another system and provides data transfer the other
machines outside the systems without know the complete about machine to other systems.
In other main comparison is distributed system have not idea about the multiple processor
methodlgies.While in computer network, explicitly log onto one machine and submit
jobs remotely all files moves around the network . In the distributed system it is not happened.
While another main difference is distributed system is built on the top of the systems.
Solution
What is a Distributed System? Compare it with a computer network system.
It is a one of the model in the computer network system; these components communicate and
coordinate their actions by interchanging the messages. Process of sharing complex problems
over the network we can use the distributed systems.
Distributed Systems can be configured in Local Area Network like 10\'s of host systems.
The main principles of distributed systems are
Resource Sharing
Concurrency
Transparency
Fault Tolerance.
Coming to the point of comparison computer network just contains the hardware and its software
that will used transfer the data based on the individual working of the network. In case of
Distributed system connect one system to another system and provides data transfer the other
machines outside the systems without know the complete about machine to other systems.
In other main comparison is distributed system have not idea about the multiple processor
methodlgies.While in computer network, explicitly log onto one machine and submit
jobs remotely all files moves around the network . In the distributed system it is not happened.
While another main difference is distributed system is built on the top of the systems..
USES OF FINANCIAL STATEMENT ANALYSISFINANCIAL STATEMENT ANALYSIS .pdf
USES OF FINANCIAL STATEMENT ANALYSIS:
FINANCIAL STATEMENT ANALYSIS IS STUDIED AND REVIEWED FOR MAKING
BETTER ECONOMIC DECISIONS BY THE USERS. THE THREE MAIN FINANCIAL
STATEMENTS ARE 1.CASH FLOW STATEMENT 2.BALANCE SHEET 3. INCOME
STATEMENT.
THE USERS OF THE FINANCIAL INFORMATION ARE THE
INVESTORS,STAKEHOLDERS,PUBLIC,INVESTORS.
BY USING VARIOUS METHODS OF FINANCIAL ANALYSIS LIKE 1. RATIO ANALYSIS
2. DU PONY ANALYSIS 3. HORIZONTAL AND 4. VERTICAL ANALYSIS. BY
STUDYING THE HISTORICAL DATA. WITH A SET OF ASSUMPTIONS WE CAN
PREDICT THE FUTURE PERFORMANCE OF THE COMPANY, AND ALSO
INVESTIGATE THE CURRENT PERFORMANCE WHICH WILL HELP THEM MAKE A
BETTER INFORMED FINANCIAL DECISION.
THE BALANCE SHEET PROVIDES DATA ON THE ASSETS AND LIABILITIES, AND
THE OWNERS\'S EQUITY OF THE COMPANY. THE INCOME STATEMENT BEGINS
WITH GROSS INCOME ANS ENDS WITH NET PROFIT. IT SHOWS THE OPERATING
PROFIT, EBIT, PAT, EBITDA. THE CASH FLOW STATEMENT SHOWS THE CASH
FLOWS OF THE COMPANY COMING FROM VARIOUS ACTIVITIES LIKE
OPERATING,INVESTING AND FINANCING.
WHAT ARE SIC CODES AND HOW THEY ARE USEFUL?
THESE ARE 4 DIGIT CODES ASSIGNED TO EVERY BUSINESS. THEY CAN HELP TO
FIND THE EXACT COMPANY WE ARE SEARCHING FOR IN THE PARTICULAR
INDUSTRY, AND ALSO THE TARGET THE RESULTS TO PARTICULAR REGION OR
DEMOGRAPHIC.
THE WAY TO READ SIC CODE IS SIMPLE ONCE WE KNOW THE INDUSTRY THE
COMPANY IS OPERATING IN.
THE FIRST TWO DIGITS DETERMINES THE MAJOR INDUSTRY GROUP.
THE THIRD DIGIT DETERMINES THE INDUSTRY GROUP.
THE FOURTH DIGIT DETERMINES THE INDUSTRY ITSELF.
THESE CODES ARE USEFUL IN THE SENSE THAT, USING THESE CODES CAN
REDUCE THE TIME AND EFFORT IN DOING ENDLESS HOURS OF RESEARCH IN
FINDING WHAT BUSINESSES ARE IN CERTAIN AREAS . WITH THE HELP OF THESE
CODES ,WE CAN EASILY FIND INFORMATION ON THE BUSINESS WE ARE
RESEARCHING ON.
WHAT ARE THE PROBLEMS OF FINANCIAL STATEMENT ANALYSIS:
1. THERE IS A LACK OF A THEORTICAL BACKGROUND FOR THE ANALYSIS OF
RATIOS, ITS DIFFICULT TO INTERPRET THE RATIOS. THIS LEADS TO IMPROPER
UNDERSTANDING OF THE RATIOS TO DEEM THEM AS APPROPRIATE OR NOT.
2. THE WIDE RANGE OF PRODUCTS IN WHICH A COMPANY TRADES,MAKES IT
DIFFICULT TO MAKE COMPARISON BETWEEN FIRMS HENCE RELATIVE RATIO
ANALYSIS BECOMES DIFFICULT.
3. WINDOW DRESSING BY FIRMS: SOME FIRMS RESORT TO PRACTICES WHERE
THEY INFLATE THEIR SALES FIGURES, OR SHOW BETTER LIQUIDITY POSITIONS
AND BETTER TURN OVER OF INVENTORY. THESE MALPRACTICES PRESENTS A
ROSY PICTURE TO THE INVESTOR.
WHY DO WE SAY FINANCIAL STATEMENTS ANALYSIS IS MANAGEMENT BY
EXCEPTION:
MANAGEMENT BY EXCEPTION IS THE STUDY OF THE FINANCIALS OF THE
BUSINESS ONLY IF THERE IS A SIGNIFICANT DEVIATION OF THE BUDGETED
FROM THE EXPECTED,ONLY THOSE ISSUES ARE BROUGHT UNDER THE SCRUTINY
OF THE MANAGEMENT . IT SAVES TIMES,AND HELP THE MANAGERS
EFFECTIVELY MANAGE THEIR BUSINESS.
IN THE SAME WAY FINANCIAL STATEMENT ANALYSIS PROVIDES A SUMMARY OF
THE BUSINESS RESULTS IN THE FINANCIAL YEAR AND ONLY STUDIES THE CORE
FINANCIALS OF THE BUSINESS.IT DOES POINT OUT IN.
The movement of watersolvent across the osmotic gradient takes plac.pdf
The movement of water/solvent across the osmotic gradient takes place in the presence of a
semi-permeable membrane. It functionally depends upon the concentration of solute particles
present on the both sides of the solutions which are separated by the semi-permeable membrane.
In a cell where the concentration gradient is such that water tends to move inside the cell, the cell
must be hypertonic with respect to the surroundings. Movement of water takes place across this
concentration gradient from hypotonic to hypertonic solution (from surrounding to cell) until the
osmotic concentration is same on both sides. In a plant cell, this movement will stop as early as
the concentrations are same on both sides.
On the contrary, the animal cells maintain a discrete physiological concentration of each and
every ion inside the cell which is necessary for solute transport, intercellular communication,
action potential and maintenance of electrochemical gradient. For this purpose, the animal cells
have different kind of solute channel protien located in their membranes. Although osmotic
gradient does play a role in solvent transport but maintenance of solute concentration is of
primary importance and thus the general osmotic gradient is different in animal cells as
compared to plant cells. In animal cells, it is more complex and sophisticated in nature and
requires ATP for operation purpose.
Solution
The movement of water/solvent across the osmotic gradient takes place in the presence of a
semi-permeable membrane. It functionally depends upon the concentration of solute particles
present on the both sides of the solutions which are separated by the semi-permeable membrane.
In a cell where the concentration gradient is such that water tends to move inside the cell, the cell
must be hypertonic with respect to the surroundings. Movement of water takes place across this
concentration gradient from hypotonic to hypertonic solution (from surrounding to cell) until the
osmotic concentration is same on both sides. In a plant cell, this movement will stop as early as
the concentrations are same on both sides.
On the contrary, the animal cells maintain a discrete physiological concentration of each and
every ion inside the cell which is necessary for solute transport, intercellular communication,
action potential and maintenance of electrochemical gradient. For this purpose, the animal cells
have different kind of solute channel protien located in their membranes. Although osmotic
gradient does play a role in solvent transport but maintenance of solute concentration is of
primary importance and thus the general osmotic gradient is different in animal cells as
compared to plant cells. In animal cells, it is more complex and sophisticated in nature and
requires ATP for operation purpose..
These groups are closely related not only is SO(2) a subgroup of O(.pdf
These groups are closely related: not only is SO(2) a subgroup of O(2) because any two
reflections gives a rotation.Over the field R of real numbers, the orthogonal group O(n,?R) and
the special orthogonal group SO(n,?R) are often simply denoted by O(n) and SO(n) if no
confusion is possible. They form real compact Lie groups of dimension n(n ? 1)/2. O(n,?R) has
two connected components, with SO(n,?R) being the identity component, i.e., the connected
component containing the identity matrix.
SO(n,?R) is a subgroup of E+(n), which consists of direct isometries, i.e., isometries preserving
orientation; it contains those that leave the origin fixed
Solution
These groups are closely related: not only is SO(2) a subgroup of O(2) because any two
reflections gives a rotation.Over the field R of real numbers, the orthogonal group O(n,?R) and
the special orthogonal group SO(n,?R) are often simply denoted by O(n) and SO(n) if no
confusion is possible. They form real compact Lie groups of dimension n(n ? 1)/2. O(n,?R) has
two connected components, with SO(n,?R) being the identity component, i.e., the connected
component containing the identity matrix.
SO(n,?R) is a subgroup of E+(n), which consists of direct isometries, i.e., isometries preserving
orientation; it contains those that leave the origin fixed.
The probability of atom has zero quanta of energy is P=Number.pdf
The probability of atom has zero quanta of energy is
P=Number of favarable states/Total number of states = 1/4 = 0.25 =25%
Solution
The probability of atom has zero quanta of energy is
P=Number of favarable states/Total number of states = 1/4 = 0.25 =25%.
Copper turns green because it oxidizes. Coppe.pdf
Copper \"turns green\" because it oxidizes. Copper oxide is green in color. The
green layer that forms is called patina, and is actually a protective surface.
Solution
Copper \"turns green\" because it oxidizes. Copper oxide is green in color. The
green layer that forms is called patina, and is actually a protective surface..
CO2 and NO2 are acidic oxides as non-metal form a.pdf
CO2 and NO2 are acidic oxides as non-metal form acidic oxides. Al2O3 is an
amphoteric oxide as it is a lewis acid but forms Al(OH)3 (which is basic) in water. CaO is basic
oxide as metals form basic oxides
Solution
CO2 and NO2 are acidic oxides as non-metal form acidic oxides. Al2O3 is an
amphoteric oxide as it is a lewis acid but forms Al(OH)3 (which is basic) in water. CaO is basic
oxide as metals form basic oxides.
Ques-1 Development of tube feet of CRINOIDEADevelopment of tube f.pdf
Ques-1: Development of tube feet of CRINOIDEA
Development of tube feet is from the larval stage in Crinoidea (echinoderms) and these tube foot
useful for locomotion in adult species. Echinoderms are deuterostomes. Larval forms of
echinoderms possess bilateral symmetry and a mouth arises from opposite end of the blastopore
and alimentary canal forms connecting both during embryonic development (metamorphosis).
Larval form is ciliated & from which this tube foot is developed in adults with pentaradial
symmetry during metamorphosis. Adult echinoderms possess a water vascular system associated
with external tube feet as well as a calcareous endoskeleton along with ossicles interconnected
collagen fibres. Sea urchins often use tube feet along with spines for jerking movement and
peristaltic movement.
Adult echinoderms possess a water vascular system associated with external tube feet as well as
a calcareous endoskeleton along with ossicles interconnected collagen fibres. Sea urchins often
use tube feet along with spines for jerking movement and peristaltic movement. These are
appeared in sea stars, these openings are smaller, and yellow button like warts located on the
aboral surface of sea stars. This opening has other important parts, which perform meticulous
function in water vascular system, and these parts are tube feet, stone canal, ring and radial
canals.
Ques-2:
Spine structure of Ophiuroidea (echinoderm) are arranged in 5 rows i& connected to ligaments
with mutable collagenous substance. These spines are composed of dermal calcareous ossicles or
calcareous spicules
Solution
Ques-1: Development of tube feet of CRINOIDEA
Development of tube feet is from the larval stage in Crinoidea (echinoderms) and these tube foot
useful for locomotion in adult species. Echinoderms are deuterostomes. Larval forms of
echinoderms possess bilateral symmetry and a mouth arises from opposite end of the blastopore
and alimentary canal forms connecting both during embryonic development (metamorphosis).
Larval form is ciliated & from which this tube foot is developed in adults with pentaradial
symmetry during metamorphosis. Adult echinoderms possess a water vascular system associated
with external tube feet as well as a calcareous endoskeleton along with ossicles interconnected
collagen fibres. Sea urchins often use tube feet along with spines for jerking movement and
peristaltic movement.
Adult echinoderms possess a water vascular system associated with external tube feet as well as
a calcareous endoskeleton along with ossicles interconnected collagen fibres. Sea urchins often
use tube feet along with spines for jerking movement and peristaltic movement. These are
appeared in sea stars, these openings are smaller, and yellow button like warts located on the
aboral surface of sea stars. This opening has other important parts, which perform meticulous
function in water vascular system, and these parts are tube feet, stone canal, ring and radial
canals.
Ques-2:
Spi.
Program.csusing System; using System.Collections.Generic; usin.pdf
Program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Population_Database
{
static class Program
{
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new Form1());
}
}
}
Form1.cs
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace Population_Database
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
private void cityBindingNavigatorSaveItem_Click(object sender, EventArgs e)
{
this.Validate();
this.cityBindingSource.EndEdit();
this.tableAdapterManager.UpdateAll(this.cityDataSet);
}
private void Form1_Load(object sender, EventArgs e)
{
// TODO: This line of code loads data into the \'cityDataSet.City\' table. You can move,
or remove it, as needed.
this.cityTableAdapter.Fill(this.cityDataSet.City);
}
private void btnAscPopulation_Click(object sender, EventArgs e)
{
// Sort the table by population in ascending order
this.cityTableAdapter.FillByAscPopulation(this.cityDataSet.City);
}
private void btnDescPopulation_Click(object sender, EventArgs e)
{
// Sort the table by population in descending order
this.cityTableAdapter.FillByDescPopulation(this.cityDataSet.City);
}
private void btnName_Click(object sender, EventArgs e)
{
this.cityTableAdapter.FillByCity(this.cityDataSet.City);
}
private void btnTotal_Click(object sender, EventArgs e)
{
// Declare variable to hold total population.
double totalPopulation;
// Get the total population.
totalPopulation = (double)this.cityTableAdapter.TotalPopulation();
// Display the total population.
MessageBox.Show(\"Total Population: \" + totalPopulation.ToString(\"n0\"));
}
private void btnAverage_Click(object sender, EventArgs e)
{
// Declare variable to hold average population.
double averagePopulation;
// Get the average population.
averagePopulation = (double)this.cityTableAdapter.AveragePopulation();
// Display the average population.
MessageBox.Show(\"Average Population: \" + averagePopulation.ToString(\"n0\"));
}
private void btnMaxPopulation_Click(object sender, EventArgs e)
{
// Declare variable to hold highest population.
double maxPopulation;
// Get the highest population.
maxPopulation = (double)this.cityTableAdapter.MaxPopulation();
// Display the highest population.
MessageBox.Show(\"Highest Population: \" + maxPopulation.ToString(\"n0\"));
}
private void btnMinPopulation_Click(object sender, EventArgs e)
{
// Declare variable to hold lowest population.
double minPopulation;
// Get the lowest population.
minPopulation = (double)this.cityTableAdapter.MinPopulation();
// Display the lowest population.
MessageBox.Show(\"Lowest Population: \" + minPopulation.ToString(\"n0\"));
}
private void btnExit_Click(object sender, EventArgs e)
{
// Cl.
package chegg;import java.util.ArrayList; import java.util.List;.pdf
package chegg;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class Vowles {
public static void main(String args[]) {
/* creating instance variable of List */
List letters = new ArrayList();
/* vowels instance variable for holding vowels */
List vowels = new ArrayList();
/* creating HashMap for storing vowels and count */
TreeMap map = new TreeMap();
/* Inserting vowels into treemap */
map.put(\"a\", 0);
map.put(\"e\", 0);
map.put(\"i\", 0);
map.put(\"o\", 0);
map.put(\"u\", 0);
/*
* creating instance variable of Scanner class for taking input from
* console
*/
Scanner scanner = new Scanner(System.in);
/*
* prompt for user input
*/
System.out.println(\"Please enter the letters with comma seperated\");
String input = scanner.nextLine();
/* closing scanner object */
scanner.close();
String[] letter = input.split(\",\");
/* Inserting letters into List */
for (String values : letter) {
letters.add(values);
}
/* ListIterator for iterating list */
ListIterator itr = letters.listIterator();
while (itr.hasNext()) {
String val = itr.next();
/* checking if value is any vowels */
if (val.equals(\"a\") || val.equals(\"e\") || val.equals(\"i\") || val.equals(\"o\") ||
val.equals(\"u\")) {
/* If vowels already exist in tree map */
if (map.containsKey(val)) {
Integer value = map.get(val);
map.put(val, ++value);
vowels.add(val);
} else {
map.put(val, 1);
vowels.add(val);
}
}
}
/* Removing all element from letters list */
letters.removeAll(letters);
/* Getting size of vowels */
int listSize = vowels.size();
System.out.println(\"There are \" + listSize + \" vowels in the list:\");
/* Iterating treeMap */
Set keys = map.keySet();
for (String key : keys) {
System.out.print(key + \"- \" + map.get(key) + \" \");
}
}
}
/***************output******************/
Please enter the letters with comma seperated
a,f,v,q,e,a,o,g,y,h,e,q,u
There are 6 vowels in the list:
a- 2 e- 2 i- 0 o- 1 u- 1
please rate the answer as best answer.
Thanks
Solution
package chegg;
import java.util.ArrayList;
import java.util.List;
import java.util.ListIterator;
import java.util.Scanner;
import java.util.Set;
import java.util.TreeMap;
public class Vowles {
public static void main(String args[]) {
/* creating instance variable of List */
List letters = new ArrayList();
/* vowels instance variable for holding vowels */
List vowels = new ArrayList();
/* creating HashMap for storing vowels and count */
TreeMap map = new TreeMap();
/* Inserting vowels into treemap */
map.put(\"a\", 0);
map.put(\"e\", 0);
map.put(\"i\", 0);
map.put(\"o\", 0);
map.put(\"u\", 0);
/*
* creating instance variable of Scanner class for taking input from
* console
*/
Scanner scanner = new Scanner(System.in);
/*
* prompt for user input
*/
System.out.println(\"Please enter the letters with comma seperated\");
String input = scanner.nextLine();
/* closing scanner object */
scanner.close();
String[] letter = in.
L{e^{-t}} = int _0 to infinty [e^{st}e^{2-t} dt = int _0 to infinty.pdf
L{e^{-t}} = int _0 to infinty [e^{st}*e^{2-t} dt = int _0 to infinty [e^{st}*e^{2} *e^{-t}dt =
e^{2} int _0 to infinty [e^{(s-1)t} dt
L{e^{-t}} = e^2/(s+1)
Solution
L{e^{-t}} = int _0 to infinty [e^{st}*e^{2-t} dt = int _0 to infinty [e^{st}*e^{2} *e^{-t}dt =
e^{2} int _0 to infinty [e^{(s-1)t} dt
L{e^{-t}} = e^2/(s+1).
Issue of Equity or Debt are commonly used methods for business finan.pdf
Issue of Equity or Debt are commonly used methods for business financing.
Buyer\'s of the Comany\'s Debt instruments have no claim to ownership in the business. This
prevents dilution of the Company\'s ownership. The holder of the debt instrument is akin to a
lender being entitled to principal / face value / base value and interest payments on the said
amount at the specified rate. The holder of the debt instrument in the Company has no right to
the future profits of the Company. However, due to the fixed nature of the returns on these
instruments, risk borne by the holder is low. Hence, the Cost of Debt Capital is also lower than
Equity Capital.
Issue of New Equity dilutes the existing ownership interest of the Company. In most cases it also
increases the shareholder base (number of shareholders) of the Company. The major
disadvantage is the possibility of future loss of control and decision making power (if issued to
large investors). However, the Company is not obligated to make payments of interest regularly
as in the case of Debt Instruments. This in turn preserves the cash flow of the Company and
makes profits available for reinvestment into the business. Equity holders take on more risk; due
to the uncertainty of business success and growth leading to uncertainty of cash inflows. This is
further magnified under a complex capital structure where the Company may have several other
obligations to meet in the pecking order first, such as secured debt, convertible hybrid
instruments, etc. The Company may also have obligations to Government Departments. These
factors result in Equity holders demanding a higher rate of return, for absorbing this risk. Thus,
the Cost of Equity is higher than cost of Debt.
When new debt is issued at high finance costs, i.e. high rates of interest, the Company may face
additional turmoil during uncertain or difficult financial situations as it increase the risk of
insolvency. Where the Company is already highly leveraged (high debt to equity ratio) and new
debt is issued at a high rate, the Company may face slower growth rates because of the obligation
to service debt before pumping resources into high growth projects and endeavours. Further, the
cost of debt also determines the cash flow to equity.
However, the one of the biggest advantages of debt over equity is that interest cost is allowed as
a deduction for the computation of tax. This in turn lowers the tax liability. Thus, the actual cost
of debt is lower than stated cost by the amount of the tax saving benefit.
The management of the Company is required to provide regular information for the investors /
shareholders to monitor. Investors / Shareholders regularly seek comprehensive updates about
the business, financial and performance information, guidace for the future, etc. This is
especially true for newer investors that are still gaining comfort about the Company This is
largely avoided when Debt instruments are issued.
Raising equity finance is very d.
In probability we have two types of eventsIndependent Events who.pdf
In probability we have two types of events:
Independent: Events who\'s probability is not affected by the previous event(s).
Dependent: Events who\'s probability can be affected by preious event(s).
What we have in this case is a dependent event because when we don\'t replace the marble, it
changes the amount of total marbles inside the jar and thus the chances of drawing another
marble changes.
Because one event relys on the other we must find their probabilities separately at first. So what
we do is figure out the probability of pulling out a blue marble and then the probability of pulling
out another after not replacing the first. We will call these event 1 and 2.
Event 1: To find the probability of pulling out a blue marble we just divide the amount of blue
marbles we have by the total marbles in the jar:
18/45. We will keep it in this form because this is the standard way of representing chances in
stats classes.
Event 2: Now what we have left are 17 blue marbles and a total of 44 marbles so the chances of
drawing a blue marble now become:
17/45.
To combine these two chances we now multiply them together:
18/45*17/44. We will of course have to find a least common denominator but that\'s not hard and
I\'m sure you could do that part on your own.
Solution
In probability we have two types of events:
Independent: Events who\'s probability is not affected by the previous event(s).
Dependent: Events who\'s probability can be affected by preious event(s).
What we have in this case is a dependent event because when we don\'t replace the marble, it
changes the amount of total marbles inside the jar and thus the chances of drawing another
marble changes.
Because one event relys on the other we must find their probabilities separately at first. So what
we do is figure out the probability of pulling out a blue marble and then the probability of pulling
out another after not replacing the first. We will call these event 1 and 2.
Event 1: To find the probability of pulling out a blue marble we just divide the amount of blue
marbles we have by the total marbles in the jar:
18/45. We will keep it in this form because this is the standard way of representing chances in
stats classes.
Event 2: Now what we have left are 17 blue marbles and a total of 44 marbles so the chances of
drawing a blue marble now become:
17/45.
To combine these two chances we now multiply them together:
18/45*17/44. We will of course have to find a least common denominator but that\'s not hard and
I\'m sure you could do that part on your own..
i have written ths code as per your requirements with clear comments.pdf
i have written ths code as per your requirements with clear comments as shown below with
output
package com.sanfoundry.hardgraph;
import java.util.Scanner;
import java.util.Vector;
class Node1
{
int name; // node ID, started from 0 to n-1
Vector preds; // predecessors (String)
Vector neibs; // neighbors (String)
Vector backs; // backward edges -node is end vertex (Integer)
Vector fors; // forward edges -node is start vertex (Integer)
int pNode; // previous node on the augmenting path
int pEdge; // from which edge this node comes on the augmenting
// path
public Node1(int id)
{
name = id;
backs = new Vector();
fors = new Vector();
pNode1 = -1;
pEdge = -1;
}
}
class Edge
{
int name; // edge ID, started from 0 to n-1
int start; // start vertex of this edge
int end; // end vertex of this edge
int direct; // forwards (+1) or backwards (-1) on augmenting path
// if 0 then not part of augmenting path
int capacity; // capacity
int flow; // current flow
public Edge(int id)
{
name = id;
start = -1;
end = -1;
direct = 0; // default is neither
capacity = 0;
flow = 0;
}
public String toString()
{
return name + \": s=\" + start + \" e=\" + end + \" d=\" + direct;
}
}
public class LongestPathinDAG
{
int n; // number of nodes
int target; // destination node
int minLength; // the minimal length of each path
Node1[] v; // used to store Nodes
Edge[] e; // used to store Edges
int[] path; // used to store temporary path
int length = 0; // length of the path
int distance = 0; // distance of the path
int[] bestPath; // used to store temporary path
int bestLength = 0; // length of the longest path
int bestDistance = -1000000; // distance of the longest path
int[] visited; // used to mark a node as visited if set as
// 1
public LongestPathinDAG()
{
Scanner sc = new Scanner(System.in);
System.out.println(\"Enter the number of vertices: \");
n = sc.nextInt();
System.out.println(\"Enter the number of edges: \");
int m = sc.nextInt();
v = new Node1[n];
e = new Edge[m];
System.out.println(n + \" nodes and \" + m + \" edges.\");
for (int i = 0; i < n; i++)
v[i] = new Node1(i);
int i = 0;
while (i < e.length)
{
Edge edge = new Edge(i);
int sVal = sc.nextInt();
edge.start = sVal;// sc.nextInt();
int eVal = sc.nextInt();
edge.end = eVal;// sc.nextInt();
edge.capacity = sc.nextInt();
System.out.println(\" edge: \" + edge.start + \" - \" + edge.end
+ \" : \" + edge.capacity);
edge.flow = 0;
e[i] = edge;
v[sVal].fors.add(i);
v[eVal].backs.add(i);
i++;
if (i == m)
break;
}
visited = new int[v.length];
path = new int[v.length];
bestPath = new int[v.length];
sc.close();
}
/*
* this function looks for a longest path starting from being to end,
* using the backtrack depth-first search.
*/
public boolean findLongestPath(int begin, int end, int minLen)
{
/*
* compute a longest path from begin to end
*/
target = end;
bestDistance = -100000000;
minLength = minLen;
dfsLongestPath(begin);
if (bestDistance == -100000000)
return false;
else
return true;
}
private void dfsLongestPath(int curr.
More from anandf0099 (20)
Riboflavin is required in the conversion of carbo.pdf
Riboflavin is required in the conversion of carbo.pdf
PbS,Ag2O and CaSO4 are stable as they are insolub.pdf
PbS,Ag2O and CaSO4 are stable as they are insolub.pdf
If multiple orbitals of the same energy are avail.pdf
If multiple orbitals of the same energy are avail.pdf
What is a Distributed System Compare it with a computer network sys.pdf
What is a Distributed System Compare it with a computer network sys.pdf
USES OF FINANCIAL STATEMENT ANALYSISFINANCIAL STATEMENT ANALYSIS .pdf
USES OF FINANCIAL STATEMENT ANALYSISFINANCIAL STATEMENT ANALYSIS .pdf
The movement of watersolvent across the osmotic gradient takes plac.pdf
The movement of watersolvent across the osmotic gradient takes plac.pdf
These groups are closely related not only is SO(2) a subgroup of O(.pdf
These groups are closely related not only is SO(2) a subgroup of O(.pdf
The probability of atom has zero quanta of energy is P=Number.pdf
The probability of atom has zero quanta of energy is P=Number.pdf
CO2 and NO2 are acidic oxides as non-metal form a.pdf
CO2 and NO2 are acidic oxides as non-metal form a.pdf
Ques-1 Development of tube feet of CRINOIDEADevelopment of tube f.pdf
Ques-1 Development of tube feet of CRINOIDEADevelopment of tube f.pdf
Program.csusing System; using System.Collections.Generic; usin.pdf
Program.csusing System; using System.Collections.Generic; usin.pdf
package chegg;import java.util.ArrayList; import java.util.List;.pdf
package chegg;import java.util.ArrayList; import java.util.List;.pdf
L{e^{-t}} = int _0 to infinty [e^{st}e^{2-t} dt = int _0 to infinty.pdf
L{e^{-t}} = int _0 to infinty [e^{st}e^{2-t} dt = int _0 to infinty.pdf
Issue of Equity or Debt are commonly used methods for business finan.pdf
Issue of Equity or Debt are commonly used methods for business finan.pdf
In probability we have two types of eventsIndependent Events who.pdf
In probability we have two types of eventsIndependent Events who.pdf
i have written ths code as per your requirements with clear comments.pdf
i have written ths code as per your requirements with clear comments.pdf
Recently uploaded
Normal Labour/ Stages of Labour/ Mechanism of Labour
Normal labor is also termed spontaneous labor, defined as the natural physiological process through which the fetus, placenta, and membranes are expelled from the uterus through the birth canal at term (37 to 42 weeks
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
The Challenger.pdf DNHS Official Publication
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Event Link:-
https://meetups.mulesoft.com/events/details/mulesoft-mysore-presents-exploring-gemini-ai-and-integration-with-mulesoft/
Agenda
● Java 17 Upgrade Overview
● Why and by when do customers need to upgrade to Java 17?
● Is there any immediate impact to upgrading to Mule Runtime 4.6 and beyond?
● Which MuleSoft products are in scope?
For Upcoming Meetups Join Mysore Meetup Group - https://meetups.mulesoft.com/mysore/
YouTube:- youtube.com/@mulesoftmysore
Mysore WhatsApp group:- https://chat.whatsapp.com/EhqtHtCC75vCAX7gaO842N
Speaker:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Organizers:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Giridhar Meka - https://www.linkedin.com/in/giridharmeka
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Shyam Raj Prasad-
https://www.linkedin.com/in/shyam-raj-prasad/
CACJapan - GROUP Presentation 1- Wk 4.pdf
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
Home assignment II on Spectroscopy 2024 Answers.pdf
Answers to Home assignment on UV-Visible spectroscopy: Calculation of wavelength of UV-Visible absorption
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
Synthetic Fiber Construction in lab .pptx
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
How to Make a Field invisible in Odoo 17
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
Model Attribute Check Company Auto Property
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
The approach at University of Liverpool.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Recently uploaded (20)
Normal Labour/ Stages of Labour/ Mechanism of Labour
Normal Labour/ Stages of Labour/ Mechanism of Labour
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Home assignment II on Spectroscopy 2024 Answers.pdf
Home assignment II on Spectroscopy 2024 Answers.pdf
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdf
Group Presentation 2 Economics.Ariana Buscigliopptx
Group Presentation 2 Economics.Ariana Buscigliopptx
Hi,Please fidn the Answer.Sorting,h is Header .pdf
- 1. Hi, Please fidn the Answer. //////////////////Sorting,h is Header file which contians all Function decalartion #include #include // std::cout #include // std::shuffle #include // std::array #include // std::default_random_engine #include using namespace std; class Sorting { private: int num; public: Sorting::Sorting() { }; ///Buble Sort Input array and n Number of Elemnets void BubbleSorting(int array[], int n); void SelectionSorting(int array[], int n); void ShuffleArray(int array[], int n); void DisplayArray(int array[], int n); void displayMenu(); int choice; }; //////////////////////////Sorting.cpp is class fuction Which Implemnets the Function #include "Sorting.h" #include using namespace std; ///Sorting the Array Using Bubble Sort... void Sorting::BubbleSorting(int Array[],int n) {
- 2. int temp = 0; cout << " ------------ BUBBLE SORT ------------ "; for (int i = 1; iArray[j + 1]) { temp = Array[j]; Array[j] = Array[j + 1]; Array[j + 1] = temp; } } cout << " ------------ RESULTS BUBBLE SORT ------------ "; DisplayArray(Array, n); } //////SelectionSorting input Array and n is number of Elemnets////////////////////// void Sorting::SelectionSorting(int Array[], int n) { int i, n, p, k, min, loc, temp; for (p = 1; p <= n - 1; p++) // Loop for Pass { min = Array[p]; // Element Selection loc = p; for (k = p + 1; k <= n; k++) // Finding Min Value { if (min > Array[k]) { min = Array[k]; loc = k; } } temp = Array[p]; // Swap Selected Element and Min Value Array[p] = Array[loc]; Array[loc] = temp; } cout << " ------------ RESULTS SELECTION SORT ------------ "; DisplayArray(Array, n);
- 3. } //////SelectionSorting input Array and n is number of Elemnets////////////////////// ///exchange each element with a randomly chosen element. It's possible that an element will be exchanged with itself, but there is no problem with that void Sorting::ShuffleArray(int Array[], int n) { cout << " ------------ ShuffleArray SORT ------------ "; for (int i = 0; i #include "Sorting.h" using namespace std; int main() { bool SelectionOn = true; Sorting Sorting; int choice; int n = 10; int *Arry; while (SelectionOn != false) { cout << "******************************* "; cout << " 1 - Enter User Input Array of Elements. "; cout << " 2 - Display User Input. "; cout << " 3 - Shuffle User Input the Elements i. "; cout << " 4 - Bubble Sorting. "; cout << " 5 - Selection Sorting. "; cout << " 6 - Exit. "; cout << " 7 - Display Menu Again. "; cout << " Enter your choice and press return: "; cin >> choice; switch (choice) {
- 4. case 1: cout << "Enter User Input Array of Elements "; cout << "Enter No. of Elements="; cin >> n; Arry = new int[n]; cout << " Enter Elements= "; for (int i = 1; i <= n; i++) { cin >> Arry[i]; } break; case 2: cout << "DISPLAY OF ARRAY "; if (Arry != NULL) { Sorting.DisplayArray(Arry, n); } else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 3: cout << "SHUFFLE OF ARRAY "; if (Arry != NULL) Sorting.ShuffleArray(Arry, n); else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 4: cout << "BUBBLE SORTING OF ARRAY "; if (Arry != NULL) Sorting.BubbleSorting(Arry, n); else
- 5. { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 5: cout << "SELCTION SORTING OF ARRAY "; if(Arry != NULL) Sorting.SelectionSorting(Arry, n); else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 6: cout << "EXIT PROGRAM "; SelectionOn = false; break; case 7: cout << "GO TO MAIN MENU "; cout << "Choose again. "; cin >> choice; break; default: cout << "Not a Valid Choice. "; cout << "Choose again. "; cin >> choice; break; } } return 0; }
- 6. Solution Hi, Please fidn the Answer. //////////////////Sorting,h is Header file which contians all Function decalartion #include #include // std::cout #include // std::shuffle #include // std::array #include // std::default_random_engine #include using namespace std; class Sorting { private: int num; public: Sorting::Sorting() { }; ///Buble Sort Input array and n Number of Elemnets void BubbleSorting(int array[], int n); void SelectionSorting(int array[], int n); void ShuffleArray(int array[], int n); void DisplayArray(int array[], int n); void displayMenu(); int choice; }; //////////////////////////Sorting.cpp is class fuction Which Implemnets the Function #include "Sorting.h" #include using namespace std; ///Sorting the Array Using Bubble Sort... void Sorting::BubbleSorting(int Array[],int n)
- 7. { int temp = 0; cout << " ------------ BUBBLE SORT ------------ "; for (int i = 1; iArray[j + 1]) { temp = Array[j]; Array[j] = Array[j + 1]; Array[j + 1] = temp; } } cout << " ------------ RESULTS BUBBLE SORT ------------ "; DisplayArray(Array, n); } //////SelectionSorting input Array and n is number of Elemnets////////////////////// void Sorting::SelectionSorting(int Array[], int n) { int i, n, p, k, min, loc, temp; for (p = 1; p <= n - 1; p++) // Loop for Pass { min = Array[p]; // Element Selection loc = p; for (k = p + 1; k <= n; k++) // Finding Min Value { if (min > Array[k]) { min = Array[k]; loc = k; } } temp = Array[p]; // Swap Selected Element and Min Value Array[p] = Array[loc]; Array[loc] = temp; } cout << " ------------ RESULTS SELECTION SORT ------------ ";
- 8. DisplayArray(Array, n); } //////SelectionSorting input Array and n is number of Elemnets////////////////////// ///exchange each element with a randomly chosen element. It's possible that an element will be exchanged with itself, but there is no problem with that void Sorting::ShuffleArray(int Array[], int n) { cout << " ------------ ShuffleArray SORT ------------ "; for (int i = 0; i #include "Sorting.h" using namespace std; int main() { bool SelectionOn = true; Sorting Sorting; int choice; int n = 10; int *Arry; while (SelectionOn != false) { cout << "******************************* "; cout << " 1 - Enter User Input Array of Elements. "; cout << " 2 - Display User Input. "; cout << " 3 - Shuffle User Input the Elements i. "; cout << " 4 - Bubble Sorting. "; cout << " 5 - Selection Sorting. "; cout << " 6 - Exit. "; cout << " 7 - Display Menu Again. "; cout << " Enter your choice and press return: "; cin >> choice; switch (choice)
- 9. { case 1: cout << "Enter User Input Array of Elements "; cout << "Enter No. of Elements="; cin >> n; Arry = new int[n]; cout << " Enter Elements= "; for (int i = 1; i <= n; i++) { cin >> Arry[i]; } break; case 2: cout << "DISPLAY OF ARRAY "; if (Arry != NULL) { Sorting.DisplayArray(Arry, n); } else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 3: cout << "SHUFFLE OF ARRAY "; if (Arry != NULL) Sorting.ShuffleArray(Arry, n); else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 4: cout << "BUBBLE SORTING OF ARRAY "; if (Arry != NULL) Sorting.BubbleSorting(Arry, n);
- 10. else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 5: cout << "SELCTION SORTING OF ARRAY "; if(Arry != NULL) Sorting.SelectionSorting(Arry, n); else { cout << "ENTER ELEMENTS TO ARRAY BY SELCTING CHOICE 1 "; } break; case 6: cout << "EXIT PROGRAM "; SelectionOn = false; break; case 7: cout << "GO TO MAIN MENU "; cout << "Choose again. "; cin >> choice; break; default: cout << "Not a Valid Choice. "; cout << "Choose again. "; cin >> choice; break; } } return 0; }