int validate_expression(const char *expr)
{
  if(expr==NULL)
  {
    return -1;
  }
  int x=strlen(expr);
  const char* operators = "+-/*";
  if( isdigit(*(expr+x-1))==0 || isdigit(*(expr))==0)
  {
    return 0;
  }
  int i;
  for(i=0;i<x;i++)
  {
    if(isdigit(*(expr+i))==0)
       {
        const char* next_operator = strchr(operators,*(expr+i));
         if(next_operator==NULL || (i + 1 < x && strchr(operators,*(expr+i+1)) != NULL))//3+3\n
           return 0;
       }
  }

   return 1;

  }
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <string.h>
#include <ctype.h>
int add(const char* number1, const char* number2, char** result);
int validate(const char *number)
{
    if(number==NULL)
    {
       return 2;
    }
    int len =strlen(number);
    if(len==0)
    {
        return 1;
    }
    int i;
if(len>1 && *(number)=='0')
{
    return 1;
}
    for(i=0;i<len;i++)
    {
        if(i==0)
        {
            if((*number+i)=='-' && isdigit(*(number+i+1)))
                continue;
        }
        if(!isdigit(*(number+i)))
        {
            return 1;

        }
    }
    return 0;

}

int compare(const char* number1, const char* number2)
{
    int i, c1, c2, size1, size2, maxSize;

    if(number1 == NULL || number2 == NULL)
        return 2;
    if(validate(number1) == 1 || validate(number2) == 1)
        return 3;
    if(*number1 != '-' && *number2 == '-')
        return 1;
    if(*number1 == '-' && *number2 != '-')
        return -1;

    size1 = strlen(number1);
    size2 = strlen(number2);
    maxSize = size1;
    if(size2 > maxSize)
        maxSize = size2;

    for(i=maxSize; i>0; i--)
    {
        c1 = 0;
        if(size1-i >= 0)
            c1 = *(number1+size1-i) - '0';
        if(c1 + '0' == '-')
            c1 = 0;

        c2 = 0;
        if(size2-i >= 0)
            c2 = *(number2+size2-i) - '0';
        if(c2 + '0' == '-')
            c2 = 0;

        if(c1 > c2 && *number1 != '-')
            return 1;
        if(c1 > c2 && *number1 == '-')
            return -1;
        if(c1 < c2 && *number1 != '-')
            return -1;
        if(c1 < c2 && *number1 == '-')
            return 1;
    }

    return 0;
}


int subtract(const char* number1, const char* number2, char** result)
{
    int size1, size2, maxSize, sizeRes, i, i2, toSub, res;
    int c1, c2;
    int x;

    if(number1 == NULL || number2 == NULL || result == NULL)
        return 1;
    if(validate(number1) == 1 || validate(number2) == 1)
        return 2;

    if( *number1 != '-' && *number2 == '-' )
    {
        return add(number1, number2 + 1, result);
    }
    if( *number1 == '-' && *number2 != '-' )
    {
        res = add(number1 + 1, number2, result);
        size1 = strlen(*result);
        for(i=size1+1; i>0; i--)
            *(*(result)+i) = *(*(result)+i-1);
        *(*(result)) = '-';
        return res;
    }
    if( compare(number1, number2) == -1 && *number1!='-' && *number2!='-' )
    {
        res = subtract(number2, number1, result);
        size1 = strlen(*result);

        for(i=size1+1; i>0; i--)
            *(*(result)+i) = *(*(result)+i-1);
        *(*(result)) = '-';

        return res;
    }
    if( (compare(number1, number2) == 1 && *number1=='-' && *number2=='-') )
    {
        res = subtract(number2, number1, result);
        size1 = strlen(*result);

        for(i=0; i<size1; i++)
            *(*(result)+i) = *(*(result)+i+1);

        return res;
    }


    size1 = strlen(number1);
    size2 = strlen(number2);
    maxSize = size1;
    if(size2 > maxSize)
        maxSize = size2;
    *result = (char*)malloc( sizeof(char)*(maxSize+3) );
    if(*result == NULL)
        return 3;

    toSub = 0;
    sizeRes = 1;
    *(*result) = '\0';
    for(i=1; i<=size1 || i<=size2; i++)
    {
        c1 = 0;
        if(size1 - i >= 0)
            c1 = *(number1 + size1 - i) - '0' - toSub;
        if(c1 + '0' == '-')
            c1 = 0;
        toSub = 0;
        c2 = 0;
        if(size2 - i >= 0)
            c2 = *(number2 + size2 - i) - '0';
        if(c2 + '0' == '-')
            c2 = 0;

        if(c2 > c1)
            toSub++;

        res = c1 - c2 + toSub*10;
        for(i2=sizeRes; i2>0; i2--)
            *((*result)+i2) = *((*result)+i2-1);
        sizeRes++;
        *(*result) = res + '0';
    }
     x=strlen(*result);
    for(sizeRes=0; *((*result)+sizeRes) == '0'; sizeRes++){}
    if(sizeRes == x)
        sizeRes--;
    if(sizeRes > 0)
    {
        for(i=0; *((*result)+i+sizeRes) != '\0'; i++)
            *((*result)+i) = *((*result)+i+sizeRes);
        *((*result)+i) = '\0';
    }

    if(*number1 == '-' && *number2 == '-' && *(*result)!='0')
    {
        for(i=size1+1; i>0; i--)
            *(*(result)+i) = *(*(result)+i-1);
        *(*(result)) = '-';
    }

    return 0;
}

int add(const char* number1, const char* number2, char** result)
{
    int x;
    int size1, size2, maxSize, sizeRes, i, i2, toAdd, res;
    char c1, c2;
    if(number1 == NULL || number2 == NULL || result == NULL)
        return 1;
    if(validate(number1) == 1 || validate(number2) == 1)
        return 2;

    if(*number1!='-' && *number2=='-')
    {
        return subtract(number1, number2+1, result);
    }
    if(*number1=='-' && *number2!='-')
    {
        return subtract(number2, number1+1, result);
    }

    size1 = strlen(number1);
    size2 = strlen(number2);
    maxSize = size1;
    if(size2 > maxSize)
        maxSize = size2;
    *result = (char*)malloc( sizeof(char)*(maxSize+3) );
    if(*result == NULL)
        return 3;

    toAdd = 0;
    sizeRes = 1;
    *(*result) = '\0';
    for(i=1; i<=size1+1 || i<=size2+1; i++)
    {
        c1 = '0';
        if(size1 - i >= 0)
            c1 = *(number1 + size1 - i);
        if(c1 == '-')
            c1 = '0';
        c2 = '0';
        if(size2 - i >= 0)
            c2 = *(number2 + size2 - i);
        if(c2 == '-')
            c2 = '0';

        res = (c1-'0') + (c2-'0') + toAdd;
        toAdd = res / 10;
        res = res % 10;

        for(i2=sizeRes; i2>0; i2--)
            *((*result)+i2) = *((*result)+i2-1);
        sizeRes++;
        *(*result) = res + '0';
    }

         x=strlen(*result);

    for(sizeRes=0; *((*result)+sizeRes) == '0'; sizeRes++){}
    if(sizeRes == x)
        sizeRes--;
    if(sizeRes > 0)
    {
        for(i=0; *((*result)+i+sizeRes) != '\0'; i++)
            *((*result)+i) = *((*result)+i+sizeRes);
        *((*result)+i) = '\0';
    }
sizeRes=strlen(*result);
    if(*number1 == '-' && *number2 == '-' && *(*result)!='0')
    {
        for(i=sizeRes+1; i>0; i--)
            *(*(result)+i) = *(*(result)+i-1);
        *(*(result)) = '-';
    }

    return 0;
}

int main()
{
    char *n1, *n2, *res1, *res2;
    char ch;
    res1 = NULL;
    res2 = NULL;
    n1 = (char*)malloc(sizeof(char)*201);
    n2 = (char*)malloc(sizeof(char)*201);

    if(n1 == NULL || n2 == NULL)
    {
        printf("Failed to allocate memory");
        if(n1!=NULL)
        {
            free(n1);
        }
        if(n2!=NULL)
        {
            free(n2);
        }
        return 2;
    }
    printf("number1: \n ");
    scanf("%200s", n1);
    ch = '\0';
    while(ch != '\n')
        ch = (char)fgetc(stdin);
    printf("number2: \n ");
    scanf("%200s", n2);


    if(validate(n1) == 1 || validate(n2) == 1)
    {
        printf("Error");

      free(n1);
       free(n2);
        return 1;
    }

    if( add(n1, n2, &res1) == 3 || subtract(n1, n2, &res2) == 3 )
    {

    free(n1);
    free(n2);
    if(res1!=NULL)
    {
        free(res1);
    }
    if(res2!=NULL)
    {
        free(res2);
    }

        printf("Failed to allocate memory");
        return 2;
    }

    printf(res1);
    printf("\n");
    printf(res2);

    free(res1);
    free(res2);
    free(n1);
    free(n2);
    return 0;
}