定制小学四则运算

  1 import java.util.Random ;
  2 import java.util.Scanner;
  3 import java.lang.reflect.Array;
  4 import java.util.LinkedList;
  5 import java.util.List;
  6 
  7 public class FourOperations1 
  8 {
  9     public static void main(String[] ages)
 10     {
 11         while(1>0)
 12         {
 13             System.out.print("\n请选择要求："
 14                 +"\n  是否有乘除法；(True/False)"
 15                 +"\n  是否有括号（最多可以支持十个数参与运算）(True/False)；"
 16                 +"\n  数值范围(True(1~10)/False(1~100))；"
 17                 +"\n  加减乘除有无负数(True/False)；"
 18                 +"\n  除法有无余数(True/False)；");
 19             Scanner sc = new Scanner(System.in);
 20             Boolean[] a=new Boolean[5];
 21             for(int i=0;i<5;i++)
 22             {
 23                  a[i]=sc.nextBoolean();
 24             }
 25             System.out.println("请输入要出题的个数");
 26             Scanner N = new Scanner(System.in);
 27             int index=N.nextInt();
 28             int right=0,wrong=0;
 29         
 30             for(int ii=0;ii<index;ii++)
 31             {    
 32                 if(a[1]==false)
 33                 {
 34                     
 35                     int a1,a2,sign;
 36                     a1=RandomNum(100);
 37                     a2=RandomNum(100);
 38                     sign=RandomNum(4);
 39                     
 40                     /**按照用户规定的各种要求对数据进行修改使数据合乎规范**/
 41                     if(a[0]==false){
 42                         sign=sign%2;
 43                     }
 44                     else{
 45                         if(sign==3&&a[4]==false){
 46                             a1=a1*a2;
 47                         }    
 48                     }
 49                     if(a[3]==true&&(sign==0||sign==1)){
 50                         int ssign=RandomNum(2);
 51                         if(ssign==0){
 52                             a1=-a1;
 53                         }
 54                         int ssign2=RandomNum(2);
 55                         if(sign==0){
 56                             a2=-a2;
 57                         }
 58                     }        
 59                     if(a[2]==true){
 60                         a1=a1%10;
 61                         a2=a2%10;
 62                     }
 63                     if(a[4]==false){
 64                         a1=a1*a2;
 65                     }
 66                     //无效算式被取消
 67                     if(sign==3&&a2==0){
 68                         ii--;
 69                     }
 70                     else{
 71                         System.out.print(a1);
 72                         PrintSign(sign);
 73                         System.out.print(a2+"  =  ");
 74                         int jjudge,result;
 75                         if(sign==0){
 76                             result=a1+a2;
 77                         }
 78                         else if(sign==1){
 79                             result=a1-a2;
 80                         }
 81                         else if(sign==2){
 82                             result=a1*a2;
 83                         }
 84                         else{
 85                             result=a1/a2;
 86                         }
 87                         jjudge=judge(result);
 88                         if(jjudge==0){
 89                             right++;
 90                         }
 91                         if(jjudge==1){
 92                             wrong++;
 93                         }
 94                     }
 95                 }
 96                 else if(a[1]==true)
 97                 {
 98                     int size=RandomNum(9);
 99                     int[] array=new int[size*2+4];
100                     /**二叉树非叶子结点的取值，即四则运算运算符的随机选择**/
101                     if(a[0]==false)//条件 没有乘除法
102                     {
103                         for(int i=0;i<=size;i++){
104                             array[i]=RandomNum(2);
105                         }
106                     }
107                     else {
108                         for(int i=0;i<=size;i++){
109                             array[i]=RandomNum(4);
110                         }
111                     }
112                     /**二叉树叶子结点的取值，即四则运算运算数的随机取值**/
113                     if(a[2]==true)//数的取值范围为0~10
114                     {
115                         for(int i=size+1;i<=size*2+2;i++)
116                         {
117                             array[i]=RandomNum(6)+4;//防止取值为0~3 打印时显示成运算符
118                         } 
119                     }
120                     else{
121                         for(int i=size+1;i<=size*2+2;i++){
122                             
123                             array[i]=RandomNum(96)+4;
124                         } 
125                     }
126                     //限制条件：运算数随机选择是否为负数
127                     if(a[3]==true){
128                         for(int i=size+1;i<=size*2+2;i++){
129                             int ssign=RandomNum(2);
130                             if((array[i/2-1]==0||array[i/2-1]==1)&&ssign==0){
131                             array[i]=-array[i];
132                             }
133                         } 
134                     } 
135                     /**将数组结点构建成二叉树**/
136                     LinkedList<Node> nodeList = new LinkedList<Node>();
137                     for(int nodeIndex=0;nodeIndex<array.length;nodeIndex++){
138                          nodeList.add(new Node(array[nodeIndex]));       
139                     }
140                     creatBinTree(array,nodeList);
141                     Node root = nodeList.get(0);
142                     inOrderTraverse(root);
143                     System.out.println("  =  "); 
144                     values(root);   
145                     int jjudge=judge(root.result);
146              
147                     if(jjudge==0){
148                         right++;
149                     }
150                     if(jjudge==1){
151                         wrong++;
152                     }
153                 }
154             }
155             System.out.println("正确题数："+right+"错误题数："+wrong);
156         }
157     }
158     
159     /**取要求范围内的随机数**/
160     public static int RandomNum(int i)
161     {
162         Random a=new Random();
163         int a1=a.nextInt (i);
164         return a1;
165     }
166     
167     /**打印运算符**/
168     public static void PrintSign(int sign)
169     {
170         if(sign==0){
171             System.out.print("  +  ");
172         }
173         else if(sign==1){
174             System.out.print("  -  ");
175         }
176         else if(sign==2){
177             System.out.print("  *  ");
178         }
179         else if(sign==3){
180             System.out.print("  /  ");
181         }
182         else
183             System.out.print(sign);
184     }
185     
186     /**定义二叉树结构**/
187     public static class Node
188     {
189         Node leftchild;
190         Node rightchild;
191         int data;
192         int result;//各二叉树分支之下的四则运算结果
193         
194         Node(int newData){
195             leftchild=null;
196             rightchild=null;
197             data=newData;
198             result=data;
199         }
200     }
201     /**构建二叉树**/
202     public static void creatBinTree(int array[],LinkedList<Node> nodeList){
203         
204         for(int parentIndex=0;parentIndex<array.length/2-1;parentIndex++){
205             nodeList.get(parentIndex).leftchild = nodeList.get(parentIndex * 2 + 1);
206             nodeList.get(parentIndex).rightchild = nodeList.get(parentIndex * 2 + 2);            
207         }
208     }
209     /**中序遍历二叉树    即打印四则运算算式**/
210     public static void inOrderTraverse(Node node) {  
211         if (node == null)  
212             return;  
213         if (node.leftchild != null) {
214         System.out.print("(");  
215         }
216         inOrderTraverse(node.leftchild);  
217         PrintSign(node.data );  
218         inOrderTraverse(node.rightchild); 
219         if (node.rightchild != null) {
220             System.out.print(")");  
221         }
222     } 
223     /**计算四则运算的值，和括号内每一步运算的值 采用递归算法**/
224     public static void values(Node node){
225         if (node.leftchild== null) {
226              return;
227         }
228         values(node.leftchild);
229         values(node.rightchild);
230         if(node.data==0){
231             node.result=node.leftchild.result+node.rightchild.result;
232             }
233         else if(node.data==1){
234             node.result=node.leftchild.result-node.rightchild.result;
235         }
236         else if(node.data==2){
237             node.result=node.leftchild.result*node.rightchild.result;
238         }
239         else 
240         {
241             if(node.rightchild.result==0){
242                 System.out.println("被除数为零，该算式无效！");
243                 return;
244             }
245             node.result=node.leftchild.result/node.rightchild.result;
246         }
247     }
248     /**判断用户输入答案是否正确**/
249     public static int judge(int answer){
250          System.out.println("  请输入您的答案：  "); 
251             Scanner sc2 = new Scanner(System.in);
252             int userResult=sc2.nextInt();
253             System.out.println(" 正确答案是："+answer  ); 
254             if(userResult==answer){
255                 return 0;
256             }
257             else {
258                 return 1;
259             }
260     }
261 }