From g97p0855@mn.waseda.ac.jp Fri May 14 16:23:02 1999
Received: from wise13.mn.waseda.ac.jp (wise13.mn.waseda.ac.jp [133.9.4.145])
	by newton.kashi.info.waseda.ac.jp (8.8.8/3.7W) with ESMTP id QAA03786
	for <kashi@kashi.info.waseda.ac.jp>; Fri, 14 May 1999 16:23:01 +0900 (JST)
Received: from lavie (mc133029.net.waseda.ac.jp [133.9.133.29]) by wise13.mn.waseda.ac.jp (8.9.1a/3.7W-19980811) with SMTP id QAA20243 for <kashi@kashi.info.waseda.ac.jp>; Fri, 14 May 1999 16:12:01 +0900 (JST)
Message-ID: <000301be9dd8$c0e6cac0$1d850985@lavie>
From: "Hiroki Masuda" <g97p0855@mn.waseda.ac.jp>
To: <kashi@kashi.info.waseda.ac.jp>
Subject: =?iso-2022-jp?B?GyRCJWwlXSE8JUgjMhsoQg==?=
Date: Fri, 14 May 1999 16:09:46 +0900
MIME-Version: 1.0
Content-Type: text/plain;
	charset="iso-2022-jp"
Content-Transfer-Encoding: 7bit
X-Priority: 3
X-MSMail-Priority: Normal
X-Mailer: Microsoft Outlook Express 4.72.3155.0
X-MimeOLE: Produced By Microsoft MimeOLE V4.72.3155.0
Status: OR

ｘ÷０を避けるためにしたパッチが逆効果になったので、最終的には割って商が１０
余りが０ならば　10/1　とみなすことにしました。

/***************************************************************************
**/
/*  Make 10 from four 1 digit numbers
*/
/*   G97P085-5
*/
/*    Hiroki Masuda       1999.5.
*/
/***************************************************************************
**/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>


#define KETA 4     /*-- The number of (1 digit number) --*/
#define MAX 10     /*-- Maximum letters on one formula --*/

#define TRUE 1     /*-- As you see      --*/
#define FALSE 0

#define PLS 0      /*-- calculation operator   --*/
#define SUB 1
#define MUL 2
#define DIV 3



typedef struct{    /*-- structure of ratinal number --*/
    long numerator;
    long denominator;
} rational_number;


/*-- rational number's stack operation --*/
rational_number r_pop(void);
void r_push(rational_number);


/*-- The four basic rules of arithmetic calculation --*/
rational_number r_plus(rational_number,rational_number);
rational_number r_sub(rational_number,rational_number);
rational_number r_mult(rational_number,rational_number);
rational_number r_div(rational_number,rational_number);
rational_number r_simplify(rational_number *);


int check(char *);/*-- check whether the formula become 10 or not --*/




/***************************************************************************
**/
/*  Make Combination
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
char *make_combi(char *to,char *formula1,char *formula2,int operation){
    char my_operator[2];

    switch(operation){
        case PLS:
            my_operator[0]='+';
            break;
        case SUB:
            my_operator[0]='-';
            break;
        case MUL:
            my_operator[0]='*';
            break;
        case DIV:
            my_operator[0]='/';
            break;
        default:
            printf("Operator_Error\n");
            exit(-1);
    }
    my_operator[1]='\0'; /*-- for safety operation --*/

    strcpy(to,formula1); /*-- return formula is postfix notation --*/
    strcat(to,formula2);
    strcat(to,my_operator);

    return to;
}




/***************************************************************************
**/
/*  Make up next formula & check it
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
int makeup(char formula[KETA][MAX],int number_of_element){
     char next_term[KETA][MAX];   /*-- retantion the origin
        --*/
     int i,j,k;                                 /*-- for
     --*/
     int mono_ptr;                         /*-- pointer to not combining
term         --*/
     int ope;                                /*--
         --*/
     int kekka=0;                          /*-- the number of
            --*/
     int next_element;                   /*-- number of terms for next
calculation --*/


     if(number_of_element==1){
          kekka=check(formula[0]); /*-- check the formula --*/
          return kekka;
     }

     next_element=number_of_element-1;

     for(i=number_of_element-1;  i>0;  i--){
          for(j=0;  j<i;  j++){
               mono_ptr=1;

               for(k=0;  k<number_of_element;  k++){
                    if(k!=i && k!=j)
                         strcpy(next_term[mono_ptr++],formula[k]);
               }


               for(ope=0;  ope<4;  ope++){
                    make_combi(next_term[0],formula[i],formula[j],ope);
                    kekka += makeup(next_term,next_element);
               }


               /*------------------------------------------------------*/
               /* for subtraction and the division
*/
               /*  replace operants
*/
               /*------------------------------------------------------*/
               if(strcmp(formula[i],formula[j])!=0){
                    make_combi(next_term[0],formula[j],formula[i],SUB);
                    kekka += makeup(next_term,next_element);

                    make_combi(next_term[0],formula[j],formula[i],DIV);
                    kekka += makeup(next_term,next_element);
               }

          }
     }

     return kekka;
}



/***************************************************************************
**/
/*  Stack for rational_number
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
rational_number r_stack[MAX];
int r_stack_ptr;

void init_r_stack(void){/*-- initialize stack pointer --*/
     r_stack_ptr=0;
}

rational_number r_pop(void){
     return r_stack[--r_stack_ptr];
}

void r_push(rational_number a){
     r_stack[r_stack_ptr++]=a;
}




/***************************************************************************
**/
/*  Rational Number calculations
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
void simplify(rational_number *);/*-- reduce the fraction --*/


rational_number r_plus(rational_number a, rational_number b){
     rational_number c;

     c.denominator=a.denominator*b.denominator;
     c.numerator=a.numerator*b.denominator+b.numerator*a.denominator;

     return c;
}

rational_number r_sub(rational_number a,rational_number b){
     rational_number c;

     c.denominator=a.denominator*b.denominator;
     c.numerator=a.numerator*b.denominator-
                             b.numerator*a.denominator;

     return c;
}


rational_number r_mult(rational_number a,rational_number b){
     rational_number c;

     c.denominator=a.denominator*b.denominator;
     c.numerator=a.numerator*b.numerator;

     return c;
}

rational_number r_div(rational_number a,rational_number b){
     rational_number c;

     c.numerator=a.numerator*b.denominator;
     c.denominator=a.denominator*b.numerator;

     return c;
}


rational_number r_simplify(rational_number *a){
     int gcd;

     if(a->numerator>1000 || a->numerator<-10000){
          return *a;
     }/*-- patch for ?/0 --*/


     if(a->numerator==0){
          a->denominator=1;
          return *a;
     }

     gcd = ( abs(a->numerator) > abs(a->denominator) )?
          abs(a->denominator):abs(a->numerator) ;

     if( gcd==0 ) return *a;

     do{
          if(gcd==1) break;

          if( (a->numerator % gcd == 0) &&
               (a->denominator % gcd == 0) ) break;
          else
               gcd--;
     }while(1);

     a->numerator /= gcd;
     a->denominator /=gcd;

     if( a->numerator < 0 && a->denominator < 0 ){
          a->numerator = - a->numerator;
          a->denominator = -a->denominator;
     }
     else if( a->numerator <0 || a->denominator<0){
          a->numerator = -abs(a->numerator);
          a->denominator = abs(a->denominator);
     }
}


/***************************************************************************
**/
/*  Call the calclation function
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
rational_number computation(rational_number a,rational_number b,char ope){
     rational_number result;

     switch(ope){
          case '+':
               result=r_plus(a,b);
               break;
          case '-':
               result=r_sub(a,b);
               break;
          case '*':
               result=r_mult(a,b);
               break;
          case '/':
               if(b.numerator==0){/*-- pathch for ?/0 --*/
                    result.numerator=INT_MAX;
                    result.denominator=1;
                    break;
               }

               result=r_div(a,b);
               break;
     }

     return result;
}


/***************************************************************************
**/
/*  check whether the formula become 10 or not
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
int check(char *formula){
     rational_number temp,operant1,operant2;
     int i,number;

     for(i=0;  formula[i]!='\0' && i<MAX;  i++){
          if( '0'<=formula[i] && formula[i]<='9' ){ /*-- if it is
number --*/
               number=formula[i]-'0';

               temp.numerator=number;
               temp.denominator=1;

               r_push(temp);
          }
          else{ /*-- if it is operator --*/
               operant2=r_pop();
               operant1=r_pop();

               temp=computation(operant1,operant2,formula[i]);
               r_push(temp);
          }
     }

     temp=r_pop();


     /*r_simplify(&temp);*/ /*-- I was frustrated --*/

     if(temp.numerator/temp.denominator==10
          && temp.numerator%temp.denominator==0){

          temp.numerator=10;
          temp.denominator=1;
     }


     if(temp.numerator==10 && temp.denominator==1){
          printf("\t%s\n",formula);
          return TRUE;
     }
     else
          return FALSE;
    }



/***************************************************************************
**/
/*  main function
*/
/*   G97P085-5 Hiroki Masuda  1999.5
*/
/***************************************************************************
**/
void main(void){
     int a,b,c,d;
     int temp;
     int counter=0;
     char numbers[KETA][MAX];

     init_r_stack();

     a=0;
     while(a<10){
          b=a;
          numbers[0][0]=a+'0';
          numbers[0][1]='\0';

          while(b<10){
               c=b;
               numbers[1][0]=b+'0';
               numbers[1][1]='\0';

               while(c<10){
                    if(c==0){
                         c=1;
                    }

                    d=c;
                    numbers[2][0]=c+'0';
                    numbers[2][1]='\0';

                    while(d<10){
                         if(d==0){
                              d=1;
                         }
                         numbers[3][0]=d+'0';
                         numbers[3][1]='\0';

                         temp=makeup(numbers,KETA);

                         if(temp!=0){
                              counter++;
                              printf("%d%d%d%d\n",a,b,c,d);
                         }
                         d++;
                    }
                    c++;
               }
               b++;
          }
          a++;
     }

     printf("The number of combinatons is %d",counter);
}


--

　　　　　　　　　早稲田大学理工学部情報学科3年

　　　　　　　　　　　　　　　　増田大樹