void split(struct elem *list1,struct elem *list2)
  {
    struct elem *p1,*p2,*x,*y;
    int l1,l2;
    for (l1=0,p1=list1; p1; l1++,p1=p1->next)
      ;
    for (l2=0,p2=list2; p2; l2++,p2=p2->next)
      ;
    for (p1=list1; l1>l2; l2++,p1=p1->next)
      ;
    for (p2=list2; l2>l1; l1++,p2=p2->next)
      ;

    for (; p1->next!=p2->next; p1=p1->next,p2=p2->next)
      ;

    y=p1->next;
    while (y)
      {
	  x=y;
	  y=y->next;
	  p1->next=(struct elem*) malloc(sizeof(struct elem));
	  p2->next=(struct elem*) malloc(sizeof(struct elem));
	  p1=p1->next;
	  p2=p2->next;
	  p1->info=p2->info=x->info;
	  p1->next=p2->next=NULL;
	  free(x);
      }
  }

int check(char *str)
  {
    int len=strlen(str),i,m,pm,pn;
    for (i=0;str[i];i++)
      if (str[i]=='*')
	  break;
    if (str[i]==0)
      return 0;

    if (i%3!=0)
      return 0;
    else
      m=i/3;

    if (m*3+1+m!=len)
      return 0;

    for (i=i+1; str[i]; i++)
      if (str[i]=='*')
	  return 0;

    for (pm=1,pn=m*3+1; str[pn]; pm+=3,pn++)
      if (str[pm]!=str[pn] || str[pm]!=str[pm+2])
	  return 0;

    return 1;
  }

int path(int paths[][10],int si,int di,int track[][2])
  {
    static int row=0;
    int ti;
    if (si!=di)
      if (paths[si][di])
	  {
	    track[row][0]=si;
	    track[row][1]=di;
	    track[row+1][0]=-1;
	    track[row+1][1]=-1;
	    return 1;
	  }
      else
	  for (ti=0;ti<10;ti++)
	    if (ti!=si && row<10 && paths[si][ti])
	      {
	        track[row][0]=si;
	        track[row][1]=ti;
	        row++;
	        return(path(paths,ti,di,track));
	      }
    track[row+1][0]=-1;
    track[row+1][1]=-1;
    return 0;
  }

// .1 תוחפ ךרעמה ירביא רפסמ תא לבקמ end-ו start=0 ,היצקנופל תינושארה האירקב
// :ךכ עצבתת תינושארה האירקה זא םירביא 100 לעב אוה ךרעמה םא :לשמל
//  qsort(arr,0,99);
void qsort(int arr[],int start,int end)
  {
    int i=start,j=end,x=arr[(start+end)/2],temp;
    do
      {
	while (arr[i]<x)
	  i++;
	while (arr[j]>x)
	  j--;
	if (i<=j)
	  {
	    temp=arr[i];
	    arr[i++]=arr[j];
	    arr[j--]=temp;
	  }
      }
    while (i<j);
    if (start<j)
      qsort(arr,start,j);
    if (i<end)
      qsort(arr,i,end);
  }

void print_prime_list(int n)
  {
    int i;
    if (n>0)
      {
	  for (i=2; i<=n; i++)
	    if (n%i==0)
	      {
	        printf("%d ",i);
	        break;
	      }
	  print_prime_list(n/i);
      }
  }

#include<stdio.h>
#include<conio.h>

struct taarich { 
                 int day,month,year;
               };

struct taarich calculate(struct taarich dmy,int n);

void main()
  {
    struct taarich dmy;
    int n;
    clrscr();
    printf("Enter day : ");
    scanf("%d",&dmy.day);
    printf("Enter month : ");
    scanf("%d",&dmy.month);
    printf("Enter year : ");
    scanf("%d",&dmy.year);
    printf("Enter number of days past/future : ");
    scanf("%d",&n);
    printf("Date now is     : %d/%d/%d\n",dmy.day,dmy.month,dmy.year);
    dmy=calculate(dmy,n);
    printf("After %4d days : %d/%d/%d\n",n,dmy.day,dmy.month,dmy.year);
    getch();
  }

struct taarich calculate(struct taarich dmy,int n)
  {
    int months[]={31,28,31,30,31,30,31,31,30,31,30,31};
    int up_down=(n>0)? 1:-1;
    months[1]=28+(dmy.year%4==0);
    for (; n; n-=up_down)
      {
	  dmy.day+=up_down;
	  if (dmy.day<1)
	    {
	      dmy.month--;
	      if (dmy.month<1)
	        {
		    dmy.year--;
		    months[1]=28+(dmy.year%4==0);
		    dmy.month=12;
	        }
	      dmy.day=months[dmy.month-1];
	    }
	  if (dmy.day>months[dmy.month-1])
	    {
	      dmy.month++;
	      if (dmy.month>12)
	        {
		    dmy.year++;
		    months[1]=28+(dmy.year%4==0);
		    dmy.month=1;
	        }
	      dmy.day=1;
	    }
      }
    return (dmy);
  }

void neighbours(int mat[][6])
  {
    int i,j,m,n,degel;
    for (i=0;i<6;i++)
      for (j=0;j<6;j++)
	  {
	    degel=1;
	    for (m=i-1; m<=i+1 && degel ;m++)
	      for (n=j-1; n<=j+1; n++)
	        if (m>=0 && m<6 && n>=0 && n<6)
		    if (!(i==m && j==n) && mat[i][j] <=mat[m][n])
		      {
		        degel=0;
		        break;
		      }
	    if (degel)
	      printf("Row: %d   Col: %d    Number: %d\n",i,j,mat[i][j]);
	  }
  }

void check(char *str)
  {
    char temp;
    int i,degel=0;
    for (i=0;str[i];i+=degel+1,degel=0)
      if (str[i]=='i' || str[i]=='I' || str[i+1]=='i' || str[i+1]=='I')
	  if (str[i]=='e' || str[i]=='E' || str[i+1]=='e' || str[i+1]=='E')
	    {
	      temp=str[i];
	      if (i>0 && (str[i-1]=='c' || str[i-1]=='C'))
	        {
		    if (temp=='i' || temp=='I')
		      {
		        str[i]=str[i+1];
		        str[i+1]=temp;
		      }
	        }
	      else
	        {
		    if (temp=='e' || temp=='E')
		      {
		        str[i]=str[i+1];
		        str[i+1]=temp;
		      }
	        }
	      degel=1;
	    }
  }

long int power(int a,int b)
  {
    int i,j;
    long int res,kefel;
    res=kefel=a;
    if (b==0)
      if (a==0)
	  return 0;
      else
	  return 1;
    for (i=1;i<b;i++)
      {
	  for (j=1;j<a;j++)
	    res+=kefel;
	  kefel=res;
       }
      return (res);
  }

struct elem *cancel(struct elem *list1,struct elem *list2)
  {
    struct elem *p1,*q1=NULL,*temp1,*temp2,*g,*h;
    for (p1=list1; p1 && list2;)
      {
	  if (p1->info==list2->info)
	    {
            temp1=p1;
            temp2=list2;
            while (temp1 && temp2)
              {
                if (temp1->info!=temp2->info)
                  break;
                temp1=temp1->next;
                temp2=temp2->next;
              }
  	      if (temp2==NULL)
	        {
		    if (q1==NULL)
		      list1=temp1;
		    else
		      q1->next=temp1;
		    for (h=g=p1; g!=temp1; )
		      {
		        h=h->next;
		        free(g);
		        g=h;
		      }
		    p1=temp1;
		    continue;
	        }
	    }
	  q1=p1;
	  p1=p1->next;
      }
    return (list1);
  }

int threat(char mat[][10])
  {
    int i,j,icat,imouse,jcat,jmouse,ijump,jjump,threat=1;
    for (i=0;i<10;i++)
      for (j=0;j<10;j++)
	  {
	    if (mat[i][j]=='C')
	      {
	        icat=i;
	        jcat=j;
	      }
	    if (mat[i][j]=='M')
	      {
	        imouse=i;
	        jmouse=j;
	      }
	  }

    // back or forward to reach mouse
    if (icat>imouse)
      ijump=-1;
    else
      ijump=1;

    // up or down to reach mouse
    if (jcat>jmouse)
      jjump=-1;
    else
      jjump=1;


    if (icat==imouse)  // if cat and mouse on same row
      {
	  for (j=jcat; j!=jmouse ;j+=jjump)
	    if (mat[icat][j]=='*')
	      {
	        threat=0;
	        break;
	      }
      }
    else
      if (jcat==jmouse)  // if cat and mouse on same column
	  {
	    for (i=icat; i!=imouse; i+=ijump)
	      if (mat[i][jcat]=='*')
	        {
		    threat=0;
		    break;
	        }
	  }
      else
	  if (icat-imouse==jcat-jmouse || icat-imouse==jmouse-jcat)
			      // Cat & mouse on same diagonal
	    {
	      for (i=icat,j=jcat; i!=imouse; i+=ijump,j+=jjump)
	        {
		    if (mat[i][j]=='*')
		      {
		        threat=0;
		        break;
		      }
	        }
	    }
	  else   // not same row, now same column, not same alachson
	    threat=0;

    return (threat);
  }

float sqr_root(int n)
  {
    float x=n,y=1;
    if (n<=0)
      return 0;
    while (x-y>0.001 || y-x>0.001)
      {
	  x=(x+y)/2;
	  y=n/x;
      }
    return (x);
  }

int latin(int mat[][4])
  {
    int i,j;
    for (i=0;i<16;i++)
      for (j=i+1;j<16;j++)
	if (mat[i/4][i%4]==mat[j/4][j%4])
	  return 0;
    return 1;
  }

#include<stdio.h>
#include<conio.h>
#include<alloc.h>
#include<stdlib.h>

struct linklist {
		      int info;
                	struct linklist *next;
      	    };
struct elem {
	        int info,shows;
	        struct elem *next;
	        struct linklist *where;
	      };

struct linklist *kelet();
void pelet(struct linklist *list);

void main()
  {
    struct elem *head=NULL,*hp,*hq,*new_elem;
    struct linklist *list,*p,*new_loc;
    int degel,mone;
    clrscr();
    list=kelet();
    clrscr();
    pelet(list);
    printf("\n\n");
    for (mone=1,p=list; p; mone++,p=p->next)
      {
	  degel=0;
	  for (hq=NULL,hp=head; hp && hp->info<=p->info; hq=hp,hp=hp->next)
	    if (hp->info==p->info)
	      {
	        degel=1;
	        hp->shows++;
	        break;
	      }
	  if (!degel)
	    {
	      new_elem=(struct elem*) malloc(sizeof(struct elem));
	      new_elem->info=p->info;
	      new_elem->shows=1;
	      new_elem->where=NULL;
	      if (head==NULL || p->info<head->info)
	        {
		    new_elem->next=head;
		    head=new_elem;
	        }
	      else
	        {
		    new_elem->next=hq->next;
		    hq->next=new_elem;
	        }
	      hp=new_elem;
	    }
	  new_loc=(struct linklist*) malloc(sizeof(struct linklist));
	  new_loc->next=hp->where;
	  hp->where=new_loc;
	  new_loc->info=mone;
      }

    for (hp=head; hp; hp=hp->next)
      {
	  printf("%d (%d)   ->   ",hp->info,hp->shows);
	  pelet(hp->where);
      }
    getch();
  }


struct linklist *kelet()
  {
    int n;
    struct linklist *list=NULL,*p=NULL,*new_elem;
    printf("Enter number or 0 to stop : ");
    scanf("%d",&n);
    while (n)
      {
	  new_elem=(struct linklist*) malloc(sizeof(struct linklist));
	  new_elem->next=NULL;
	  new_elem->info=n;
	  if (list==NULL)
	    list=new_elem;
	  else
	    p->next=new_elem;
	  p=new_elem;
	  printf("Enter number or 0 to stop : ");
	  scanf("%d",&n);
      }
    return (list);
  }


void pelet(struct linklist *list)
  {
    struct linklist *p;
    for (p=list; p; p=p->next)
      printf("%d -> ",p->info);
    printf("||\n");
  }

struct elem *zero_series(struct elem *list)
  {
    struct elem *p_main,*p_prev=NULL,*q_main,*q_prev;
    int counter;
    for (p_main=list; p_main;)
      {
	  counter=0;
	  if (p_main->info==0)
	    for (q_prev=q_main=p_main; q_main && q_main->info==0;
                             q_prev=q_main,q_main=q_main->next)
	        counter++;
	
        if (counter>0 && counter<4)
	    {
	      q_prev->next=(struct elem*) malloc(sizeof(struct elem));
	      q_prev=q_prev->next;
	      q_prev->info=counter;
	      q_prev->next=q_main;
	      p_main=q_main;
	      p_prev=q_prev;
	      continue;
	    }
	  if (counter>=4)
	    {
	      for (q_main=q_prev=p_main; q_prev && q_prev->info==0; )
	        {
		    q_main=q_main->next;
		    free(q_prev);
		    q_prev=q_main;
	        }
	      if (p_prev==NULL)
	        list=q_prev;
	      else
	        p_prev->next=q_prev;
	      p_main=q_prev;
	      continue;
	    }
	  p_prev=p_main;
	  p_main=p_main->next;
      }
    return (list);
  }

struct elem *tree_2_list(struct tree *t)
  {
    struct elem *list,*p;
    if (t==NULL)
      return(NULL);
    list=(struct elem*) malloc(sizeof(struct elem));
    list->info=t->info;
    list->next=tree_2_list(t->left);
    for(p=list; p->next; p=p->next)
      ;
    p->next=tree_2_list(t->right);
    return (list);
  }

void short_form(char str1[],char str2[])
  {
    int i,j=0,degel=1; // degel is 1 if char can go to str2
    for (i=0; str1[i]; i++)
      {
	  if (i>0 && str1[i]-1==str1[i-1] && str1[i]+1==str1[i+1])
	    {
	      degel=0;
	      continue;
	    }
	  if (degel==0)
	    str2[j++]='-';
	  str2[j++]=str1[i];
	  degel=1;
      }
    str2[j]=0;
  }

void piramid(int arr[])
  {
    int i,begin=0,end=9,direction=1,min,min_loc;
    while (end>begin)
      {
	  for (i=begin,min=arr[begin],min_loc=begin;i<=end;i++)
	    if (arr[i]<min)
	      {
	        min=arr[i];
	        min_loc=i;
	      }
	  if (direction)
	    {
	      arr[min_loc]=arr[begin];
	      arr[begin]=min;
	      begin++;
	    }
	  else
	    {
	      arr[min_loc]=arr[end];
	      arr[end]=min;
	      end--;
	    }
	  direction=(!direction);
      }
  }

int div_11(int num)
  {
    int sum=0;
    if (num<10 && num> -10)
      return (num==0);
    while (num)
      {
	  sum+=num%10;
	  sum-=(num/10)%10;
	  num/=100;
      }
    return (div_11(sum));
  }

int maximum(int mat[][6])
  {
    int i,j,m,n,max=0,godel,degel;
    for (i=0;i<6;i++)
      for (j=0;j<6;j++)
	  if (mat[i][j]==1)
	    {
	      godel=0;
	      degel=1;
	      for (m=0; mat[i+m][j+m]==1; m++)
	        {
		    for (n=0; n<m && degel; n++)
		      if (mat[m+i][n+j] || mat[n+i][m+j])
		        {
                      degel=0;
                      break;
                    }
		    if (degel==0)
		      break;
		    godel++;
	        }
	      if (godel>max)
	        max=godel;
	    }
    return (max);
  }

int tracks(int x,int y)
  {
    if (x==0 || y==0)
      return 1;
    else
      return (tracks(x-1,y)+tracks(x,y-1));
  }

#include <stdio.h>
#include <conio.h>
#include <string.h>

void combin(char *str,int current,int len);

void main()
  {
    char str[10];
    int len;
    clrscr();
    printf("Enter a short string : ");
    gets(str);
    len=strlen(str);
    combin(str,0,len);
    getch();
  }

void combin(char *string,int current,int len)
  {
    int i;
    char str[10],ch;
    strcpy(str,string);
    if (current<len)
      {
	  for (i=current; i<len; i++)
	    {
	      ch=str[current];
	      str[current]=str[i];
	      str[i]=ch;
	      combin(str,current+1,len);
	    }
      }
    else
      printf("%s\n",str);
  }

void join_arrays(int arr1[],int arr2[],int arr_big[])
  {
    int i=0,j=0,k=0;
    while (i<5 || j<5)
      {
        if (i<5 && j<5)
          if (arr1[i]<arr2[j])
            arr_big[k++]=arr1[i++];
          else
            arr_big[k++]=arr2[j++];
        else
          if (i<5) 
            arr_big[k++]=arr1[i++];
          else
            arr_big[k++]=arr2[j++];
      }
  }

int min(int arr1[],int arr2[])
  {
    int i=0,j=0;
    while (i<5 && j<5)
      {
	  if (arr1[i]==arr2[j])
	    return(arr1[i]);
	  else
	    if (arr1[i]<arr2[j])
	      i++;
	    else
	      j++;
      }
    return -1;
  }

int reverse(int num)
  {
    int rev=0;
    for (; num>0; num/=10)
      rev=rev*10+(num%10);
    return (rev);
  }

void arrange(int mat[][5])
  {
    int start=0,end=24,temp;
    for (start=0; start<end; start++)
      {
	  if (mat[start/5][start%5]%2==1)
	    for (; end>start; end--)
	      if (mat[end/5][end%5]%2==0)
	        {
		    temp=mat[start/5][start%5];
		    mat[start/5][start%5]=mat[end/5][end%5];
		    mat[end/5][end%5]=temp;
		    break;
	      }
      }
  }

int divider(int num1,int num2)
  {
    while (num1!=num2)
      {
	  if (num1>num2)
	    num1-=num2;
	  else
	    num2-=num1;
      }
    return (num1);
  }

int big_num(char *str)
  {
    int i,degel=1,num=0,max=0;
    for (i=0; degel; i++)
      {
	  if (str[i]>='0' && str[i]<='9')
	    num=num*10+str[i]-'0';
	  else
	    {
	      if (num>max)
	        max=num;
	      num=0;
	    }
        degel=(str[i]!=0);
      }
    return (max);
  }