how to combine these working parts??

this is a working part for checking the input

Code:

---



#include <stdio.h>
int valid(char buf[],int index);
int valid_s(char buf[],int index);
int nex_num(char buf[],int index);
int rid_next(char buf[],int index,int x);
int spin(char buf[],int arr[],int index,int num,int size);
int one_num(char buf[],int index,int start);
int rid(char buf[],int index,int x);
int main()
{
       
        int arr[4],t;
    char buf[] ="-000123        44        -143        23  +567        ";
    //t=valid_s(buf, 0);
 
        t=spin(buf,arr,0,0,4);
        printf("%d\n",t);
        //printf("%d %d %d %d\n",arr[0],arr[1],arr[2],arr[3]);
return 0;
}
int spin(char buf[],int arr[],int index,int num,int size)
{

        int loc;
    if (num>size-1)
        {
      return 0;
        }
        if (buf[index]=='\0')
        {
      return 1;
        }
        arr[num]=one_num(buf,index, index);
               
        //printf("%d\n",arr[num]);
        loc=rid_next( buf,index,0);
        //printf("%d",loc);
        loc=nex_num(buf,loc);
        if (loc==-1)
        {
        return 1;
        }
        //printf("%d",loc);

  return spin(buf,arr,loc,num+1,size);
}

int one_num(char buf[],int index,int start)
{
int y=1,x = 0;
 
        if(buf[start]=='-')
    {
        y=-1;
                index++;
      }
        if(buf[start]=='+')
    {
        index++;
      }
        x=rid(buf,index,0)*y;
        //        printf("%d",x);
return x;

}

int rid(char buf[],int index,int x)
{
if ((buf[index]<'0')||(buf[index]>'9'))
{
        //printf("%d",x);
return x;
}
  x *= 10;
  x += buf[index]-'0';
 
return rid(buf,index+1,x);

}

int nex_num(char buf[],int index)
{
  if ((buf[index]=='-')||(buf[index]=='+'))
  {
      return index;
  }
  if ((buf[index]>='0')&&(buf[index]<='9'))
  {
      return index;
    }
if  (buf[index]=='\0')
{
return -1;
}
return nex_num(buf,index+1);

}
int rid_next(char buf[],int index,int x)
{
    if ((buf[index]==' ')||(buf[index]=='\t'))
    {
        return index;
    }
 
    return rid_next(buf,index+1,x);

}


int valid(char buf[],int index)
{
    if ((buf[index]=='\0')&&(index==0))
    {
      return 0;
    }
    if (buf[index]=='\0')
    {
      return 1;
    }
    if ((buf[index]!='-')&&(buf[index]!='+')&&(buf[index]!=' ')&&(buf[index]!='\t')&&((buf[index]<'0')||(buf[index]>'9')))
    {
        return 0;
    }
    return valid(buf,index+1);
}
int valid_s(char buf[],int index)
{
        if ((buf[index]=='\0')&&(index==0))
    {
      return 0;
    }
        if (buf[index]=='\0')
        {
      return 1;
        }
    if ((buf[index]=='+')||(buf[index]=='-'))
    {
     
                if((buf[index+1]=='\t')||(buf[index+1]==' ')||((buf[index-1]>='0')&&(buf[index-1]<='9')&&(index>=1)))
                {
            return 0;
                }
                if((buf[index+1]=='-')||(buf[index+1]=='+'))
                {
          return 0;
                }
    }
        return valid_s(buf,index+1);
}

---

and this is the different working functions with a bad input
how to combine these two??

Code:

---



#include <stdio.h>

int part2(int arr[], int size, int sum1, int sum2, int i);
int partition(int arr[], int size);
int longest_ascending(int data[], int position, int previous, int length);
int read_array(int input[],int i,int size);
void recSelSort(int array[],int length);
void selSort(int array[], int i ,int length);
void swap(int num[],int i,int j);
int recFindMin(int array[], int index);

 void remove_duplicates(char string[], int index);
void overwrite(char string[], int index);
int has_duplicate(char string[], int index, char ch);


int merge_strings(char str1[], int index1,char str2[],int index2, char result[], int index3);
void read(char input2[],int i);
void main_menu();
void show_menu();
void clean();
int merge(char str1[], int index1,char str2[],int index2, char result[], int index3);
int merge_strings(char str1[], int index1,char str2[],int index2, char result[], int index3);

void main()
{
    main_menu();

}
void main_menu()
{
    //opt1
        int i;
        int size;
        int inp[500];
        int data[500] ;
    char input[255];
    char input2[255];
    char result[510]={0};
    int flag;
  //opt1


        char opt[900];

  show_menu();

  scanf("%s",opt);

  clean();

  if((opt[0]>='0')&&(opt[0]<='9')&&(opt[1]=='\0'))
  {
      if (opt[0]=='1')
          {//start first
            printf("Enter the first string \n");
            read(input,0);
            printf("Enter the second string \n");
            read(input2,0);
            flag=merge_strings(input,0,input2,0,result, 0);
            printf("Answer:\n");

            if (flag==1)
            {
                  printf("%s\n",result);
                  printf("\n");
            }
            else
            {
                  printf("%s is invalid.\n",result);
            }
          }//end first
          if (opt[0]=='2')
          {
                  printf("Enter string:\n");
        read(input2,0);
                  remove_duplicates(input2,0);
                  printf("Answer:\n");
                printf("%s\n",input2);
            printf("\n");

          }
          if (opt[0]=='3')
          {
                  printf("Please enter the size of array you want to sort:\n");
                  scanf("%d",&size);
                  clean();
                  printf("Please enter %d values for the array (in one row):\n",size);
                    read_array(inp,0,size);

                        selSort(inp,size-1,size);
                        for(i=0;i<size;i++)
            {
              printf("%d ",inp[i]);
              }
            printf("\n");
                        clean();

          }
          if (opt[0]=='4')
          {
            printf("Please enter the size of the array :\n");
                  scanf("%d",&size);
                        clean();
            printf("Please enter %d values for the array (in one row):\n",size);
                    read_array(data,0,size);

          printf("Answer: %d\n",longest_ascending(data, 0, 0, size));
          printf("\n");
          }
          if (opt[0]=='5')
          {
              int t;
        int a[]={1,1,1,0,1,1,1};
  t=partition(a,sizeof(a)/sizeof(int));
  printf("%d\n",t);
          }
          if (opt[0]=='0')
          {
        return;
          }

  }//end else
  else
  {
      printf("Input incorrect! Please try again.\n");
      printf("\n");
  }
  main_menu();
}
void show_menu()
{
    printf("--------------------------\n");
        printf("Please enter your choice:\n");
    printf("1) Merge strings.\n");
    printf("2) Remove duplicates in the string.\n");
    printf("3) Sort the array using recursive selection sort.\n");
    printf("4) Calculate the length of the max increasing set.\n");
    printf("5) Check partition.\n");
    printf("0) Exit.\n");
 }
void clean()
{
        int lnd;
    lnd= getchar();
    if (lnd != '\n')
        {
        clean();
        }
        else
        {
          return;
        }
}

void read(char input2[],int i)
{
        char ch;
      ch=getchar();
        if (ch=='\n')
        {
      input2[i] = '\0';
          return ;
        }
    if ((i<39)&&( ch  != '\n') &&( ch >=0))
    {
      input2[i] = ch;
    }
    read(input2,i+1);
}

int merge_strings(char str1[], int index1,char str2[],int index2, char result[], int index3)
    {
        int answer;
                if ((str1[index1]=='\0') && (str2[index2]=='\0'))
        {
            result[index3] = '\0';
            return 1;
        }
                else if (((str1[index1]>='a')&&(str1[index1]<='z')) || ((str1[index1]>='A') && (str1[index1]<='Z'))
                          && ((str2[index2]>='a')&&(str2[index2]<='z')) || ((str2[index2]>='A') && (str2[index2]<='Z'))
                          || ((str1[index1]=='\0') || (str2[index2]=='\0')))
                        {
                        if (str2[index2]=='\0')
                                {
                                        if (str1[index1]>=result[index3-1])
                                        {
                                                result[index3]=str1[index1];
                                                answer=merge_strings(str1,index1+1,str2,index2,result,index3+1);
                                                if (answer == 0)
                                                        return 0;
                                                else
                                                        return 1;
                                        }
                                        else
                                                return 0;
                                }
                        else if (str1[index1]=='\0')
                                {
                                        if (str2[index2]>result[index3-1])
                                        {
                                                result[index3]=str2[index2];
                                                answer=merge_strings(str1,index1,str2,index2+1,result,index3+1);
                                                if (answer == 0)
                                                        return 0;
                                                else
                                                        return 1;
                                        }
                                        else
                                                return 0;
                                }
                        else if ((str1[index1]<=str2[index2]))
                                {
                                        if (str1[index1]>=result[index3-1])
                                        {
                                                result[index3]=str1[index1];
                                                answer=merge_strings(str1,index1+1,str2,index2,result,index3+1);
                                                if (answer == 0)
                                                        return 0;
                                                else
                                                        return 1;
                                        }

                                }

                        else if ((str2[index2]<=str1[index1]))
                        {
                                if (str2[index2]>result[index3-1])
                                {
                                        result[index3]=str2[index2];
                    answer=merge_strings(str1,index1,str2,index2+1,result,index3+1);
                    if (answer == 0)
                                                return 0;
                    else
                        return 1;
                                }
                        }
                }
        else
        {
                return 0;
        }
          return 0;
}



void remove_duplicates(char string[], int index)
{
    int flag = -1;
    if (string[index] != '\0')
    {//
        flag = has_duplicate(string, index-1, string[index]);
        if (flag == 1)
        {
            overwrite(string, index);
            remove_duplicates(string, index);
        }
        else
        {
            remove_duplicates(string, index + 1);
        }
    }
}



int has_duplicate(char string[], int index, char ch)
{
      int check;
        if (index<0)
        {
          return 0;
        }
        if (ch==string[index])
        {
            return 1;
        }
        else
        {
          check=has_duplicate(string,index-1,ch);
          return check;
        }


}//end func


void overwrite(char string[], int index)
{

        if ( string[index]=='\0')
        {
            return;
        }
          if( string[index]!='\0')
        {
                string[index]=string[index+1];
                overwrite(string,index+1);
        }

}

// sort array from i (till i is sorted and min)
 void selSort(int array[], int i ,int length)
{
                if (i>=0)
            {
                                swap(array,i,recFindMin(array,i));
                                selSort(array,i-1,length);
                }
}


int recFindMin (int array[], int index)
{
    int local;
    if (index == 0)
    {
        return index;
    }

    local = recFindMin(array, index - 1);
    if (array[index] <array[local])
    {
        return local;  // what about this line
    }
    else
    {
        return index;
    }
}

void swap(int num[],int i,int j)
{
int temp;
temp=num[i];
num[i]=num[j];
num[j]=temp;
}
int read_array(int input[],int i,int size)
{
        int flag,rt;

        if (i==size)
        {

          return 1;
        }
    flag=scanf("%d",&input[i]);
        if (flag==0)
        {
                return 0;
        }

    rt=read_array(input,i+1,size);
        return 1;
}
int longest_ascending(int data[], int position, int previous, int length) {
    int longest=0;
        if(position >= length) return 0;



    /* This is the first number in a sequence. */
    if(position == previous) {
      // longest = maximum(longest,1 + longest_ascending(data, position + 1, previous, length)); //1
                if (longest>(1 + longest_ascending(data, position + 1, previous, length)))
        {
            longest=longest;
        }
        else
        {
            longest=1 + longest_ascending(data, position + 1, previous, length);

        }


        /* Try starting a sequence at the next position. */
        //longest = maximum(longest,longest_ascending(data, position + 1, position + 1, length)); //2

        if (longest>(longest_ascending(data, position + 1, previous+1, length)))
        {
          longest=longest;
        }
        else
        {
            longest= longest_ascending(data, position + 1, previous+1, length);


        }
    }
    else {  /* This is not the first number in a sequence. */
        /* This number is greater than the previous one;
            try adding it to the sequence.
        */
        if(data[position] > data[previous]) {
            //longest = maximum(longest,1 + longest_ascending(data, position + 1, position, length));//1
                        if (longest>(1 + longest_ascending(data, position + 1, position, length)))
            {
              longest=longest;
            }
              else
            {
              longest=1 + longest_ascending(data, position + 1, position, length);

            }
        }

        /* Try leaving this number out of the sequence. */
      //  longest = maximum(longest,longest_ascending(data, position + 1, previous, length));//3
                if (longest>(longest_ascending(data, position + 1, previous, length)))
        {
            longest=longest;
          }
        else
          {
            longest=longest_ascending(data, position + 1, previous, length);


          }

    }

    return longest;
}
int part2(int arr[], int size, int sum1, int sum2, int i) {
  if (i>=size) return (sum1==sum2 && sum1!=0 && sum2!=0) ? 1 : 0; // solution? if yes return 1, otherwise 0
  if (part2(arr, size, sum1, sum2+arr[i], i+1) == 1) return 1; // left recursively, return 1 if solution found
  if (part2(arr, size, sum1+arr[i], sum2, i+1) == 1) return 1; // right recursively, return 1 if solution found
  return 0; // no solution found, return 0
}

int partition(int arr[], int size) {
  return part2(arr,size,0,0,0);
}

---