solution in scala

def morganAndString(inputA: String, inputB: String): String = { var posA = 0 var posB = 0 val sb = new StringBuilder(inputA.length + inputB.length)

  while (posA < inputA.length || posB < inputB.length) {
    val nextA = {
      if (posA < inputA.length) Some(inputA(posA)) else None
    }
    val nextB = {
      if (posB < inputB.length) Some(inputB(posB)) else None
    }

    (nextA, nextB) match {
      case (Some(a), Some(b)) => {
        if (a == b) {

          val limit = min(inputA.length - posA, inputB.length - posB)

          def ALessB(): Boolean = {
            var i = 0
            while (i<limit && (inputA(posA + i) == inputB(posB + i))){
              i += 1
            }
            if (i == limit) {
              (inputA.length - posA) > (inputB.length - posB) // take the longer string if equal
            } else {
              inputA(posA + i) < inputB(posB + i)
            }
          }

          def nextNotStart(): Int = {
            var i = 0
            while (i < limit && inputA(posA + i) == a && inputB(posB + i) == a) {
              i+=1
            }
            i
          }

          val aOverB = ALessB()
          val takeUntil = nextNotStart()
          sb.append(a.toString * takeUntil)
          if (aOverB) {
            posA += takeUntil
          } else {
            posB += takeUntil
          }
        }
        else if (a < b) {
          posA += 1
          sb.append(a)
        }
        else {
          posB += 1
          sb.append(b)
        }
      }
      case (Some(a), None) => {
        posA += 1
        sb.append(a)
      }
      case (None, Some(b)) => {
        posB += 1
        sb.append(b)
      }
      case (None, None) => {
      }
    }
  }
  sb.toString()
}