### Last week.. a competition code !

Last week, IEC celebrates OpenSource Mela. In code war, we got a programming contest in which the problem statement is :

5 \* 4 / 2 - 5 + 2 = 7 (evaluated from left to right). So, input format is:

5 4 2 5 2 7

and output is to put into a valid expression format(all possible format). So, if its 2 2 4, then 2+2=4 and 2\*2=4 is possible. I have written some code for this, which goes here :

```package problemstatement1;

import java.util.List;

public class Main {

String input = "2 0 2";
String output = new String();  // 5 \* 4 / 2 - 5 + 2 = 7
int resultVal = 0;
String operatorseq = new String();
int result = 0;
int totalcounter = 0;
boolean flag = true;

// converting input into easy format

String[] inputtoken = input.split(" ");
int[] numberseq = new int[inputtoken.length - 1];
int totaloperator = numberseq.length - 1;

public void isValid() {
if (inputtoken.length < 3) {
System.out.println("Usages ... Input Parameter should be three or more ");
System.exit(0);
}
}

public void processInput() {
try {
resultVal = Integer.parseInt(inputtoken[inputtoken.length - 1]);
} catch(NumberFormatException e) {
System.out.println("Parsing error" + "  " + e);
System.exit(0);
}
for (int i = 0; i < numberseq.length; i++) {
try {
numberseq[i] = Integer.parseInt(inputtoken[i]);
} catch(NumberFormatException e) {
System.out.println("Parsing error" + "  " + e);
System.exit(0);
}
}
}

public void showInput() {
for (int i = 0; i < numberseq.length; i++) {
// System.out.println(numberseq[i]);
}
}

public void getPermutation() {
GenerateOperators gen = new GenerateOperators("+-\*/", totaloperator);
List<String> v = gen.getVariations();
System.out.println("Possible Solutions");
for (int i = 0; i < v.size(); i++) {
operatorseq = v.get(i);
manupulate();
}
}

public void manupulate() {

result = 0;

for (int i = 0; i < operatorseq.length(); i++) {
if (i == 0) {
if ((operatorseq.charAt(i)) == '+') {
result = result + (numberseq[i] + numberseq[i + 1]);
}
if ((operatorseq.charAt(i)) == '-') {
result = result + (numberseq[i] - numberseq[i + 1]);
}
if ((operatorseq.charAt(i)) == '\*') {
result = result + (numberseq[i] \* numberseq[i + 1]);
}
if ((operatorseq.charAt(i)) == '/') {
try {
result = result + (numberseq[i] / numberseq[i + 1]);
} catch(Exception e) {
flag = false;
// don't do anything
}
}
} else {
if ((operatorseq.charAt(i)) == '+') {
result = result + numberseq[i + 1];
}
if ((operatorseq.charAt(i)) == '-') {
result = result - numberseq[i + 1];
}
if ((operatorseq.charAt(i)) == '\*') {
result = result \* numberseq[i + 1];
}
if ((operatorseq.charAt(i)) == '/') {
try {
result = result / numberseq[i + 1];
} catch(Exception e) {
flag = false;
// don't do anything
}
}
}
}
if (result == resultVal && flag == true) {
totalcounter++;
System.out.println("");
for (int i = 0; i < numberseq.length - 1; i++) {
System.out.print(numberseq[i] + "" + operatorseq.charAt(i));
}
System.out.print(numberseq[numberseq.length - 1]);
System.out.print("= " + result);
}
}

public void count() {
if(totalcounter == 0 ) {
System.out.println("NO EXPRESSION POSSIBLE");
System.exit(0);
}
else {
System.out.println("");
System.out.println("Total Possible Solution :" + totalcounter);
}
}
public static void main(String[] args) {
Main main = new Main();
main.isValid();
main.processInput();
main.showInput();
main.getPermutation();
main.count();
}
}

```

and one more file which is :

```package problemstatement1;

import java.util.List;
import java.util.ArrayList;

public class GenerateOperators {

private String a;
private int n;

public GenerateOperators(String a, int n) {
this.a = a;
this.n = n;
}

public List<String> getVariations() {
int l = a.length();
int permutations = (int) Math.pow(l, n);
char[][] storeCombination = new char[permutations][n];
for (int x = 0; x < n; x++) {
int temp = (int) Math.pow(l, x);
for (int p1 = 0; p1 < permutations;) {
for (int al = 0; al < l; al++) {
for (int p2 = 0; p2 < temp; p2++) {
storeCombination[p1][x] = a.charAt(al);
p1++;
}
}
}
}

List<String> result = new ArrayList<String>();
for (char[] permutation : storeCombination) {
}
return result;

}

public static void main(String[] args) {
GenerateOperators gen = new GenerateOperators("AAAMMBR", 7);
List<String> v = gen.getVariations();
for (int i=0;i<v.size();i++) {
String s1 = v.get(i);
System.out.println(s1);
}

}
}```

Feel free to use this code :-).

Very useful. Thank you very much and keep it up.

Posted by competearound123 on September 13, 2008 at 11:05 PM IST #

you are welcome !

Posted by Vaibhav on September 14, 2008 at 11:56 AM IST #

• HTML Syntax: NOT allowed