package problem4

object problem4 {
  def isPalindrome(x: String) : Boolean = {
    var i = 0
    var j = x.length() - 1
    
    while(i <= j) {
      if (x.charAt(i) != x.charAt(j))
        return false
        
        i += 1
        j -= 1
    }
    return true
  }

  def main(args: Array[String]): Unit = {
    var max = 0
    for(i <- 100 to 1000) {
      for(j <- 100 to 1000) {
        var prod = i * j
        var prodStr = prod.toString()
        if (isPalindrome(prodStr)) {
          max = Math.max(max, prod)
        }
      }
    }
    
    println(max)
  }
}

package calculator

trait Element {

}

NumberElement.scala

package calculator

class NumberElement(numberArg: String) extends Element {
  var number: Double = numberArg.toDouble
  
  def getNumber = number
  
  override def toString() : String = {
    return number.toString()
  }
}

OperatorElement.scala

package calculator

sealed trait OperatorType
case object MULTIPLY extends OperatorType
case object DIVIDE extends OperatorType
case object ADD extends OperatorType
case object SUBTRACT extends OperatorType
case object EXPONENTIAL extends OperatorType
case object OPAREN extends OperatorType
case object CPAREN extends OperatorType
case object NULL extends OperatorType
  
class OperatorElement(operator: Character) extends Element {
  var type1 : OperatorType = NULL
  
  var c : Character = operator
  
  if(operator == '+')
    type1 = ADD
  else if(operator == '-')
    type1 = SUBTRACT
  else if(operator == '*')
    type1 = MULTIPLY
  else if(operator == '/')
    type1 = DIVIDE
  else if(operator == '^')
    type1 = EXPONENTIAL
  else if(operator == '(')
    type1 = OPAREN
  else if(operator == ')')
    type1 = CPAREN
    
  override def toString() : String = {
    return c.toString()
  }
}

Parser.scala

package calculator

import scala.collection.mutable.ArrayBuffer

class Parser {
  def Parse(s: String) : ArrayBuffer[Element] = 
  {
    var e = new ArrayBuffer[Element]()
    var sb = new StringBuilder()
    var i = 0
    for(i <- 0 until s.length()) 
    {
      var c = s.charAt(i)
      if(Character.isDigit(c))
        sb.append(c)
      if(i + 1 < s.length())
      {
        var d = s.charAt(i + 1)
        if(Character.isDigit(d) == false && sb.length() > 0)
        {
          e.append(new NumberElement(sb.toString()))
          sb.clear()
          
        }
      }
      
      if(c == '+' || c == '-' || c == '*' || c == '/' || c == '^' || c == '(' || c == ')')
        e.append(new OperatorElement(c));
    }
    
    if(sb.length() > 0)
      e.append(new NumberElement(sb.toString()));
    
    return e
  }
}

InfixToPostfix.scala

package calculator

import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Stack
import util.control.Breaks._

class InfixToPostfix {
  private var converted: ArrayBuffer[Element] = new ArrayBuffer[Element]

  def Precedence(c: OperatorElement) : Int = 
  {
    if(c.type1 == EXPONENTIAL)
    {
      return 2
    }
    else if(c.type1 == MULTIPLY || c.type1 == DIVIDE)
    {
      return 3
    }
    else if(c.type1 == ADD || c.type1 == SUBTRACT)
    {
      return 4
    }
    else
      return Int.MaxValue  
  }
  
  def ProcessOperators(st: Stack[Element], element: Element, top: Element)
  {
    var top1 = top;
    breakable
    {
	  while(st.size > 0 && Precedence(element.asInstanceOf[OperatorElement]) >= Precedence(top1.asInstanceOf[OperatorElement]))
	  {
	    var p = st.pop()
	    if(p.asInstanceOf[OperatorElement].type1 == OPAREN)
	      break
	    converted.append(p)
	    if(st.size > 0)
	      top1 = st.top
	  }
    }
  }
  
  def ConvertFromInfixToPostFix(e: ArrayBuffer[Element]) : ArrayBuffer[Element] = 
  {
    var stack1: ArrayBuffer[Element] = new ArrayBuffer[Element]()
    e.copyToBuffer(stack1)
    var st: Stack[Element] = new Stack[Element]()
    
    var i: Int = 0
    for(i <- 0 until stack1.length)
    {
      var element = stack1(i)
      if(element.isInstanceOf[OperatorElement])
      {
        if(st.isEmpty || element.asInstanceOf[OperatorElement].type1 == OPAREN)
          st.push(element);
        else
        {
          var top = st.top;
	      if(element.asInstanceOf[OperatorElement].type1 == CPAREN)
	          ProcessOperators(st, element, top);
	      else if(Precedence(element.asInstanceOf[OperatorElement]) < Precedence(top.asInstanceOf[OperatorElement]))
	          st.push(element);
	      else
	      {
	          ProcessOperators(st, element, top);
	          st.push(element);
	      }
        }
      }
      else
        converted.append(element);
    }
    
    while(st.size > 0)
    {
        var b1 = st.pop()
        converted.append(b1)
    } 
    return converted
  }
  
  override def toString(): String =
  {
    var sb: StringBuffer = new StringBuffer()
    converted.foreach(f => sb.append(f + " "))
    return sb.toString()
  }
}

PostFixEvaluator.scala

package calculator

import scala.collection.mutable.ArrayBuffer
import scala.collection.mutable.Stack

class PostFixEvaluator {
  def calculate(left: NumberElement, right: NumberElement, op: OperatorElement): NumberElement = 
  {
    var temp = Double.MaxValue
    if(op.type1 == ADD)
    {
      temp = left.getNumber + right.getNumber
    }
    else if(op.type1 == SUBTRACT)
    {
      temp = left.getNumber - right.getNumber
    }
    else if(op.type1 == MULTIPLY)
    {
      temp = left.getNumber * right.getNumber
    }
    else if(op.type1 == DIVIDE)
    {
      temp = left.getNumber / right.getNumber
    }
    else if(op.type1 == EXPONENTIAL)
    {
      temp = Math.pow(left.getNumber, right.getNumber)
    }
    
    return new NumberElement(temp.toString)
  }
  
  def Evaluate(e: ArrayBuffer[Element]): Double = 
  {
    var stack: Stack[Element] = new Stack[Element]
    var v: ArrayBuffer[Element] = new ArrayBuffer[Element]
    e.copyToBuffer(v)
    
    var i: Int = 0
    for(i <- 0 until v.length)
    {
      var element = v(i)
      if(element.isInstanceOf[NumberElement])
        stack.push(element)
      if(element.isInstanceOf[OperatorElement])
      {
        var right = stack.pop()
        var left = stack.pop()
        var result = calculate(left.asInstanceOf[NumberElement], right.asInstanceOf[NumberElement], element.asInstanceOf[OperatorElement])
        stack.push(result)
      }
    }
    return stack.pop().asInstanceOf[NumberElement].getNumber
  }
}

Calculator.scala

package calculator

object Calculator {
  def main(args: Array[String]): Unit = {
    val t = "4+6+9*8-(5*6+9)^2"
    val p = new Parser()
    var e = p.Parse(t)
    var i = new InfixToPostfix()
    e = i.ConvertFromInfixToPostFix(e)
    println(i)
    var pfe = new PostFixEvaluator();
    var result = pfe.Evaluate(e);
    println(result)
  }
}