Problem:
Score : 300 points

Problem Statement

Takahashi is organizing a party.

At the party, each guest will receive one or more snack pieces.

Takahashi predicts that the number of guests at this party will be A or B.

Find the minimum number of pieces that can be evenly distributed to the guests in both of the cases predicted.

We assume that a piece cannot be divided and distributed to multiple guests.

Constraints

1 \leq A, B \leq 10^5

A \neq B

All values in input are integers.

Input

Input is given from Standard Input in the following format:

A B

Output

Print the minimum number of pieces that can be evenly distributed to the guests in both of the cases with A guests and B guests.

Sample Input 1

2 3

Sample Output 1

6

When we have six snack pieces, each guest can take three pieces if we have two guests, and each guest can take two if we have three guests.

Sample Input 2

123 456

Sample Output 2

18696

Sample Input 3

100000 99999

Sample Output 3

9999900000

Solution in Scala (2.11.7) (judge verdict: Wrong Answer)

import java.util.Scanner

import scala.collection.mutable.{ArrayBuffer, ListBuffer}

object PrimeInt {
  val ps: Stream[Int] = 2 #:: Stream.from(3).filter(i => ps.takeWhile(j => j * j <= i).forall(k => i % k > 0))

  def isPrime(n: Int): Boolean = ps.takeWhile(_ <= n).contains(n)
}

object Primes extends Iterable[Long] {
  var checked = 2L
  val xs = ListBuffer(2L)

  def contains(i: Long): Boolean = xs.takeWhile(_ <= i).contains(i)

  def apply(i: Int): Long = {
    while (xs.length <= i) {
      var n = checked + 1
      while (xs.takeWhile(j => j * j <= n).exists(n % _ == 0)) {
        n += 1
      }
      xs.append(n)
      checked = n
    }
    xs(i)
  }

  override def iterator: Iterator[Long] = new Iterator[Long] {
    var i = 0

    override def hasNext: Boolean = true

    override def next(): Long = {
      val x = apply(i);
      i += 1;
      x
    }
  }
}

object PrimeCheck {
  def main(args: Array[String]): Unit = {
    for (i <- 0 to 10000) {
      println(Primes(i))
    }
  }

  def elapsed(): Unit = {
    val start = System.currentTimeMillis()
    val isprime = Primes.contains(100000L)
    val end = System.currentTimeMillis()
    printf("%d msec.\n", end - start)
  }
}

object Main {
  def main(args: Array[String]) {
    val result = solve(new Scanner(System.in))
    if (result.length > 0) println(result)
  }

  def solve(in: String): String = solve(new Scanner(in))

  def solve(sc: Scanner): String = {
    val A = sc.nextLong
    val B = sc.nextLong

    val ab = ArrayBuffer(1L)
    val primes = Primes.iterator
    var a = A
    var b = B
    var p = primes.next
    do {
      if (a % p == 0 && b % p == 0) {
        ab.append(p)
        a /= p
        b /= p
      }
      p = primes.next
    } while (p < a && p < b)

    (a * b * ab.product).toString
  }
}