CODEWITHSUNDEEP
javaandroidif-statement
nexus490
nexus490

Reputation: 817

Maths operators

I have this method which will generate a random maths expression solve it and output the answer to a variable:

public int Nov2()
{
    char[] ops = new char[] {'+', '-', '*', '/'};
    int i = rand.nextInt(4-0) + 0;
    char op1 = ops[i];

    int novnum1 = rand.nextInt(101-1) + 1;

    int novnum2 = rand.nextInt(101-1) + 1;

    int nov2result = 0;

    switch(op1) {
        case '+': nov2result = novnum1 + novnum2; break;
        case '-': nov2result = novnum1 - novnum2; break;
        case '*': nov2result = novnum1 * novnum2; break;
        case '/': nov2result = novnum1 / novnum2; break;
    }

    String nov2Exp = novnum1 + " " + op1 + " " + novnum2 + " = ";

    Nov2resstor = nov2result;

    setContentView(R.layout.gameview);

    TextView display = (TextView) findViewById(R.id.exp);

    display.setText(nov2Exp);

    return nov2result;
}

How would i use the same sort of thing for expressions with more than two terms without having to write really complex if statements like this in my next method:

public int Eas3()
{
    char[] ops = new char[] {'+', '-', '*', '/'};
    int i = rand.nextInt(4-0) + 0;
    char op1 = ops[i];
    i = rand.nextInt(4-0) + 0;
    char op2 = ops[i];

    int easnum1 = rand.nextInt(101-1) + 1;

    int easnum2 = rand.nextInt(101-1) + 1;

    int easnum3 = rand.nextInt(101-1) + 1;

    int eas3result = 0;


    if (op1 == '+' && op2 == '+')
    {
        eas3result = ((easnum1 + easnum2) + easnum3);
    }
    else if (op1 == '+' && op2 == '-')
    {
        eas3result = ((easnum1 + easnum2) - easnum3);
    }
    else if (op1 == '+' && op2 == '*')
    {
        eas3result = ((easnum1 + easnum2) * easnum3);
    }
    else if (op1 == '+' && op2 == '-')
    {
        eas3result = ((easnum1 + easnum2) - easnum3);
    } 
.../

I have methods which do this for 2,3,4,5 and 6 so my if statements would become very large using this method.

Any ideas?

Upvotes: 3

Views: 366

Answers (9)

Venkatesh. P
Venkatesh. P

Reputation: 34

Try this:

public int Eas3()
{

    char[] ops = new char[] {'+', '-', '*', '/'};
    int i = rand.nextInt(4-0) + 0;
    char op1 = ops[i];
    i = rand.nextInt(4-0) + 0;
    char op2 = ops[i];

    int easnum1 = rand.nextInt(101-1) + 1;
    int easnum2 = rand.nextInt(101-1) + 1;
    int easnum3 = rand.nextInt(101-1) + 1;
    int eas3result = 0;
    if (op1 == '+')
    {
         switch(op2) 
         {
               case '+': eas3result=((easnum1 + easnum2) + easnum3); break;
               case '-': eas3result=((easnum1 - easnum2) - easnum3); break;
               case '*': eas3result=((easnum1 * easnum2) * easnum3); break;
               case '/': eas3result=((easnum1 / easnum2) / easnum3); break;        
         }
    }

..../

}

or even you can put outer IF in SWITCH like the following

public int Eas3()
{

    char[] ops = new char[] {'+', '-', '*', '/'};
    int i = rand.nextInt(4-0) + 0;
    char op1 = ops[i];
    i = rand.nextInt(4-0) + 0;
    char op2 = ops[i];

    int easnum1 = rand.nextInt(101-1) + 1;
    int easnum2 = rand.nextInt(101-1) + 1;
    int easnum3 = rand.nextInt(101-1) + 1;
    int eas3result = 0;
    int tempResult=0;
    switch(op1)
    {
         case '+': tempResult=(easnum1 + easnum2); break;
         case '-': tempResult=(easnum1 + easnum2) ; break;
         case '*': tempResult=(easnum1 + easnum2) ; break;
         case '/': tempResult=(easnum1 + easnum2) ; break;        
    }    
   switch(op2) 
     {
         case '+': eas3result=(tempResult + easnum3); break;
         case '-': eas3result=(tempResult - easnum3); break;
         case '*': eas3result=(tempResult * easnum3); break;
         case '/': eas3result=(tempResult / easnum3); break;        
     }

}

Upvotes: 0

jacobm
jacobm

Reputation: 14025

If you've got n operations on n+1 numbers, and you do the first one, then you're left with n-1 operations on n numbers. You can use this as the basis for a loop that will process any number of items easily.

int operate(int[] numbers, int[] operations) {
  if (numbers.length < 1 || numbers.length != operations.length + 1) {
    throw new IllegalArgumentException();
  }
  int result = numbers[0];  
  for (int i = 0; i < operations.length; ++i) {
    result = operate(operations[i], result, numbers[i+1]);
    // where operate() is your switch statement
  }
  return result;
}

Upvotes: 0

user684934
user684934

Reputation:

How about using recursion:

int num(int numberOfOperands, int current){
    if(numberOfOperands<=0) return current;
    switch(rand.nextInt(4)){
        case 0: return num(numberOfOperands-1, current + (rand.nextInt(100)+1)); break;
        case 1: return num(numberOfOperands-1, current - (rand.nextInt(100)+1)); break;
        case 2: return num(numberOfOperands-1, current * (rand.nextInt(100)+1)); break;
        case 3: return num(numberOfOperands-1, current / (rand.nextInt(100)+1)); break;
    }

}

int num(int numberOfOperands) throws Exception{
    if(numberOfOperands <=0) 
        throw new Exception("invalid number of operands: "+numberOfOperands);
    return num(numberOfOperands, rand.nextInt(100)+1);
}

This would, of course, ignore precedence of operations.

Upvotes: 1

FoamyGuy
FoamyGuy

Reputation: 46856

Check out this MathEval class I found online It will evaluate a String that represents an equation for you.

mySolver = new MathEval();
double answer = mySolver.evaluate(equation);

Upvotes: 2

Kirill Rakhman
Kirill Rakhman

Reputation: 43811

What you're looking for is called the composite pattern. You define an abstract Expression base class and derive it.

The classes must implement an evaluate() method which returns the result.

One sub class will be the constant which return it's value, another one would be a binary expression like plus, minus, etc. The evaluate() method will add/subtract/etc the result of the evaluated sub-expressions.

You can then build arbitrary expressions out of other expressions and then evaluate it without using one if condition.

Upvotes: 1

duffymo
duffymo

Reputation: 308753

Yes, another way to do it is to write Command objects:

public interface Command<V> {
    V execute(Object ... args); 
}

You'll write an object that implements this interface:

public class AdditionCommand implements Command<Double> {
    public Double execute(Object ... args) {
        Double x = (Double)args[0];
        Double y = (Double)args[1];
        return x+y;    
    }
}

Now you can look up in a Map using the operator:

Map<String, Command> opsLookup = new HashMap<String, Command>() {{
   opsLookup.put("+", new AddCommand<Number>());
   opsLookup.put("-", new SubtractCommand<Number>());
}};

No need for a switch.

Upvotes: 2

Marc Van Daele
Marc Van Daele

Reputation: 2734

I would use an array for the values easnum[], an array for the operands op[] and an array with intermediate values. Something along the following lines 

  for(...)
  {
     if(op[i]=='+') easintermediat[i+1] = easintermediate[i] + easnum[i]
     ...
  }

Upvotes: 0

AndreiBogdan
AndreiBogdan

Reputation: 11164

you can use the built-in Javascript engine.

import javax.script.ScriptEngineManager;
import javax.script.ScriptEngine;

public class Test 
{
  public static void main(String[] args) throws Exception
  {
       ScriptEngineManager mgr = new ScriptEngineManager();
        ScriptEngine engine = mgr.getEngineByName("JavaScript");
        String foo = "40+2";
        System.out.println(engine.eval(foo));
    } 
}

Upvotes: 2

RonnieVDPoel
RonnieVDPoel

Reputation: 101

You could make a string with the variables you are using like this:

String temp = "(" + easnum1 + op1 + easnum2 + ")" + op2 + easnum3;

after that you can use the ScriptEngineManager class to use javascript as the engine so you can use the eval method. 

ScriptEngineManager manager = new ScriptEngineManager();
ScriptEngine engine = manager.getEngineByName("js");        
Object result = engine.eval(temp);

this method does the calculations and returns the result.

Hope this helps.

Upvotes: 0

Related Questions