C 如何解决此分配问题（核心转储）？
我写了一个程序，接收两个多项式，然后用乘法计算它们的和C 如何解决此分配问题（核心转储）？,c,C,我写了一个程序，接收两个多项式，然后用乘法计算它们的和 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct monom { int coefficient; int power; }Monom; //defini
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
"2 4 -5 1 0 6 6 4 -8 0 7 3"
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
*** Error in `./vpl_execution': realloc(): invalid next size: 0x000000000070c210
***
/home/p18206/.vpl_launcher.sh: line 9: 25054 Aborted (core dumpe
d) ./vpl_execution
ome/p13634/.vpl_launcher.sh: line 9: 25304 Segmentation fault (core dumpe
d) ./vpl_execution
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
*** Error in `./vpl_execution': realloc(): invalid next size: 0x000000000070c210
***
/home/p18206/.vpl_launcher.sh: line 9: 25054 Aborted (core dumpe
d) ./vpl_execution
ome/p13634/.vpl_launcher.sh: line 9: 25304 Segmentation fault (core dumpe
d) ./vpl_execution
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct monom {
int coefficient;
int power;
}Monom;
//defining bool data type
typedef int bool;
#define TRUE 1
#define FALSE 0
#define MEMORY_ERROR_EXIT -1
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res);
void polySort(Monom* polynom, unsigned int size);
void removeElement(Monom* polynomArr, unsigned int size);
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size);
Monom* getPolynom(unsigned int* size);
void printPolynom(Monom* polynom, unsigned int size);
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2);
void checkMemoryAllocation(void *ptr);
void main()
{
Monom *polynom1, *polynom2; // The input polynoms
unsigned int polynom1Size, polynom2Size; // The size of each polynom
printf("Please enter the first polynom:\n");
polynom1 = getPolynom(&polynom1Size); // get polynom 1
printf("Please enter the second polynom:\n");
polynom2 = getPolynom(&polynom2Size); // get polynom 2
printf("The multiplication of the polynoms is:\n"); // print the multiplication
printPolyMul(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
printf("The sum of the polynoms is:\n"); // print the sum
printPolySum(polynom1, polynom1Size, polynom2, polynom2Size);
printf("\n");
free(polynom1); // releasing all memory allocations
free(polynom2);
}
Monom* getPolynom(unsigned int* size) {
/*This function recieve data from user*/
unsigned int phySize = 1, logSize = 0;
int currCofficient, currPower;
bool lContinue = TRUE; // a flag that keeps that signal if we should keep recieving input
Monom* polyArr;
polyArr = (Monom*)malloc(sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);
while (lContinue) { //while the user didn't press enter we keep on recieving input
scanf("%d%d", &currCofficient, &currPower);
if (currCofficient != 0) { //if the current cofficient is 0 we do nothing. Else we insert the input to the array
//if the logic size equal to the physical size we double the phySize and reallocate array with the new size
if (logSize == phySize) {
phySize *= 2;
polyArr = (Monom*)realloc(polyArr, sizeof(Monom)*phySize);
checkMemoryAllocation(polyArr);;
}
polyArr[logSize].coefficient = currCofficient; //we locate the input on the current position (logical size)
polyArr[logSize].power = currPower;
logSize++; //we increment logical size of the array
}
if (getchar() == '\n') // the user pressed enter - the flag is "turned off", and we stop receiving input
lContinue = FALSE;
}
*size = logSize; //size recieve the value "log size" which is the actual size of the array
polySort(polyArr, *size); //we sort the array based on power sizes
polyArr = sumSamePowerPoly(polyArr, size); //we unite Monoms that has the same power
return polyArr;
}
void polyMerge(Monom* arr1, unsigned int size1, Monom* arr2, unsigned int size2, Monom* res) {
/*This function merges two Monom arrays into one monom array sorted by powers from the biggest power to the smallest one*/
unsigned int i = 0, j = 0, k = 0;
while (i < size1 && j < size2) {
if (arr1[i].power > arr2[j].power)
res[k++] = arr1[i++];
else
res[k++] = arr2[j++];
}
while (i < size1) //While i<size1 keep copying values from array 1 to result array
res[k++] = arr1[i++];
while (j < size2) //While j<size2 keep copying values from array 2 to result array
res[k++] = arr2[j++];
}
void polySort(Monom* polynom, unsigned int size) {
/*This function sort a Monom array from the biggest power to the smalles one*/
Monom* temp;
unsigned int i;
if (size == 1)
return;
else {
polySort(polynom, size / 2);
polySort(polynom + size / 2, size - size / 2);
temp = (Monom*)malloc(sizeof(Monom)*size); //We temporary allocate an array that will keep the result of the merge
checkMemoryAllocation(temp);
polyMerge(polynom, size / 2, polynom + size / 2, size - size / 2, temp);
for (i = 0; i < size; i++) //We copy the temporary array into our data array
polynom[i] = temp[i];
free(temp); //We delete the allocated memory for the temporary array
}
}
Monom* sumSamePowerPoly(Monom* polynomArr, unsigned int* size) {
/*This function sum polynoms from the same degree to one polynom*/
unsigned int i;
for (i = 0; i < *size - 1; i++) { //We check for each Monom in the array if there are other monoms with the same power
while (polynomArr[i].power == polynomArr[i + 1].power) { //while power of a monom is eqaul to the power of other monoms
polynomArr[i].coefficient += polynomArr[i + 1].coefficient; //we add the next monom to the first one
removeElement(polynomArr + i + 1, *size - i); //and remove the monom we just united into another cell
*size -= 1;
}
}
polynomArr = (Monom*)realloc(polynomArr, sizeof(Monom)*(*size));
return polynomArr;
}
void removeElement(Monom* polynomArr, unsigned int size) {
/*This function removes an element from array*/
unsigned int i;
for (i = 0; i < size; i++) { //We copy each cell into the prior one
polynomArr[i] = polynomArr[i + 1];
}
}
void printPolynom(Monom* polynom, unsigned int size) {
/*This function prints polynom*/
unsigned int i;
for (i = 0; i < size; i++) {
if (polynom[i].power > 1) //if the power is bigger than one that print this form: coffx^power
printf("%dx^%d", polynom[i].coefficient, polynom[i].power);
else if (polynom[i].power == 1) //else if the power is one than print this form: coffx
printf("%dx", polynom[i].coefficient);
else //else print this form: coff
printf("%d", polynom[i].coefficient);
if (i < size - 1 && polynom[i + 1].coefficient > 0) //if there is another element after the current element and its
//cofficient is larger than 0 - print "+"
printf("+");
}
}
void printPolySum(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function print the sum of two polynoms*/
unsigned int i, j;
unsigned int size;
size = size1 + size2; //We set the size of sum result to be size of both of the polynoms
Monom* sumRes; //We create a sum result array
sumRes = (Monom*)malloc(sizeof(Monom)*size);
checkMemoryAllocation(sumRes);
//We copy each element from both of the polynoms array into the result array
for (i = 0; i < size1; i++)
sumRes[i] = polynom1[i];
for (i = size1, j = 0; i < size && j < size2; j++, i++) {
sumRes[i] = polynom2[j];
}
polySort(sumRes, size); //We sort all of the elements by power size
//We unite all of the cells who has the same power. This action actually sums both of the polynoms to one poly sum.
sumRes = sumSamePowerPoly(sumRes, &size);
printPolynom(sumRes, size); //We print sum reault
free(sumRes); //We free the sum result array after printing it
}
void printPolyMul(Monom* polynom1, unsigned int size1, Monom* polynom2, unsigned int size2) {
/*This function prints the multiplication of two polynoms*/
unsigned int i, j, k, size;
i = 0;
Monom* mulRes;
size = size1 * size2; //We set the size of sum result to be the multiplication of both of the polynoms size
mulRes = (Monom*)malloc(sizeof(Monom)*size); //We create a multiplication result array in which we will store the result of multiplying polynoms
checkMemoryAllocation(mulRes);
Monom temp; //We creat a temporary data type monom in which we will save the calculation of each multiplication
//We multiply the polynoms and keep the multiplication result in the mulRes array
for (j = 0; j < size1; j++) {
for (k = 0; k < size2; k++) {
temp.coefficient = polynom1[j].coefficient*polynom2[k].coefficient;
temp.power = polynom1[j].power + polynom2[k].power;
mulRes[i++] = temp;
}
}
polySort(mulRes, size); //We sort all of the elements by power size
mulRes = sumSamePowerPoly(mulRes, &size); //We unite all of the cells who has the same power
printPolynom(mulRes, size); //We print the multiplication result
free(mulRes); //We free the multiply result array after printing it
}
void checkMemoryAllocation(void *ptr)
/*This function check if the dynmic allocation we did has succseeded */
{
if (ptr == NULL)
{
printf("Memory allocation error\n");
exit(MEMORY_ERROR_EXIT);
}
}
\define\u CRT\u SECURE\u NO\u警告
#包括
#包括
#包括
typedef结构单体{
int系数；
整数幂；
}单体；
//定义bool数据类型
typedef int bool；
#定义真1
#定义FALSE 0
#定义内存\u错误\u退出-1
void polyMerge（单体*arr1，无符号整数大小1，单体*arr2，无符号整数大小2，单体*res）；
void polySort（单项式*多项式，无符号整数大小）；
void removeElement（Monom*polynomArr，无符号整数大小）；
MOMON*sumSamePowerPoly（MOMON*多项式，无符号整数*大小）；
monm*getPolynom（无符号整数*大小）；
void printPolynom（单项式*多项式，无符号整数大小）；
void printPolySum（单项式*多项式1，无符号整数大小1，单项式*多项式2，无符号整数大小2）；
void printPolyMul（单项式*多项式1，无符号整数大小1，单项式*多项式2，无符号整数大小2）；
无效检查存储器位置（无效*ptr）；
void main（）
{
monm*多项式1，*多项式2；//输入多项式
无符号整数多项式1大小，多项式2大小；//每个多项式的大小
printf（“请输入第一个多项式：\n”）；
polynom1=getPolynom（&polynom1Size）；//获取多项式1
printf（“请输入第二个多项式：\n”）；
polynom2=getPolynom（&polynom2Size）；//获取多项式2
printf（“多项式的乘法为：\n”）；//打印乘法
printPolyMul（多项式1、多项式1、多项式2、多项式2）；
printf（“\n”）；
printf（“多项式的和为：\n”）；//打印和
printPolySum（多项式1、多项式1、多项式2、多项式2）；
printf（“\n”）；
释放（多项式1）；//释放所有内存分配
自由（多项式2）；
}
Monom*getPolynom（无符号整数*大小）{
/*此函数用于接收来自用户的数据*/
unsigned int phySize=1，logSize=0；
电流效率，电流功率；
bool lContinue=TRUE；//如果我们继续接收输入，则保留该信号的标志
单体*polyArr；
polyArr=（单体*）malloc（单体大小）*物理化；
检查记忆位置（polyArr）；
while（lContinue）{//当用户没有按enter键时，我们继续接收输入
scanf（“%d%d”，&currCofficient，&currcpower）；
如果（currCofficient！=0）{//如果当前cofficient为0，则不执行任何操作。否则，将输入插入数组
//如果逻辑大小等于物理大小，则将物理大小加倍，并使用新大小重新分配阵列
if（logSize==phySize）{
phySize*=2；
polyArr=（单体*）realloc（polyArr，sizeof（单体）*物理化）；
检查存储器位置（polyArr）；；
}
polyArr[logSize]。系数=currcomficient；//我们在当前位置找到输入（逻辑大小）
polyArr[logSize]。功率=电流功率；
logSize++；//我们增加数组的逻辑大小
}
如果（getchar（）=='\n'）//用户按enter键，则标志为“关闭”，我们将停止接收输入
l继续=错误；
}
*size=logSize；//size接收值“log size”，它是数组的实际大小
polySort（polyArr，*size）；//我们根据功率大小对数组进行排序
polyArr=sumSamePowerPoly（polyArr，size）；//我们联合具有相同幂的单体
返回polyArr；
}
void polyMerge（单体*arr1，无符号整数大小1，单体*arr2，无符号整数大小2，单体*res）{
/*此函数用于将两个单体数组合并为一个单体数组，按从最大幂到最小幂的幂排序*/
无符号整数i=0，j=0，k=0；
而（iarr2[j].power）
res[k++]=arr1[i++]；
其他的
res[k++]=arr2[j++]；
}
while（i