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);
}