Problem:
Score : 400 points

Problem Statement

Give a pair of integers (A, B) such that A^5-B^5 = X.
It is guaranteed that there exists such a pair for the given integer X.

Constraints

1 \leq X \leq 10^9

X is an integer.

There exists a pair of integers (A, B) satisfying the condition in Problem Statement.

Input

Input is given from Standard Input in the following format:

X

Output

Print A and B, with space in between.
If there are multiple pairs of integers (A, B) satisfying the condition, you may print any of them.

A B

Sample Input 1

33

Sample Output 1

2 -1

For A=2 and B=-1, A^5-B^5 = 33.

Sample Input 2

1

Sample Output 2

0 -1

Solution in Scala (2.13.1) (judge verdict: Accepted)

import java.io.{BufferedOutputStream, BufferedReader, InputStreamReader, PrintWriter}

import scala.annotation.tailrec

object Main {
  def main(args: Array[String]): Unit = {
    val in = new BufferedReader(new InputStreamReader(System.in))
    val out = new PrintWriter(new BufferedOutputStream(System.out))
    val x = in.readLine().toInt

    def divisors(x: Int): List[Int] = {
      val limit = Math.sqrt(x).toInt + 1

      @tailrec
      def inner(ds: List[Int], i: Int): List[Int] = {
        if (i < limit) {
          if (x % i == 0) {
            if (x / i == i) {
              inner(i :: ds, i + 1)
            } else {
              inner(i :: x / i :: ds, i + 1)
            }
          } else {
            inner(ds, i + 1)
          }
        } else {
          ds
        }
      }

      inner(Nil, 1)
    }

    val ambs = divisors(x).sorted

    def findAB(amb: Int): Option[(Int, Int)] = {
      val target = x / amb

      for (a <- -118 to 119) {
        val b = a - amb
        val f = a * a * a * a + a * b * b * b + a * a * a * b + a * a * b * b + b * b * b * b
        if (f == target) {
          return Some(a, b)
        }
      }
      None
    }

    @tailrec
    def findFirstAB(ambs: List[Int]): (Int, Int) = {
      ambs match {
        case amb :: rest =>
          findAB(amb) match {
            case Some((a, b)) => (a, b)
            case None => findFirstAB(rest)
          }
        case Nil =>
          throw new Error()
      }
    }

    out.println(findFirstAB(ambs) match {
      case (a, b) => s"${a} ${b}"
    })

    out.flush()
  }
}