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 Rust (1.42.0) (judge verdict: Accepted)

use std::io::{stdin, Read};

macro_rules! parse {
    ($it: ident ) => {};
    ($it: ident, ) => {};
    ($it: ident, $var:ident : $t:tt $($r:tt)*) => {
        let $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
    ($it: ident, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = parse_val!($it, $t);
        parse!($it $($r)*);
    };
}

macro_rules! parse_val {
    ($it: ident, [$t:tt; $len:expr]) => {
        (0..$len).map(|_| parse_val!($it, $t)).collect::<Vec<_>>();
    };
    ($it: ident, ($($t: ty),*)) => {
        ($(parse_val!($it, $t)),*)
    };
    ($it: ident, $t: ty) => {
        $it.next().unwrap().parse::<$t>().unwrap()
    };
}

const M: usize = 1000000;
fn solve(s: &str) {
    let mut it = s.split_whitespace();
    parse!(it, x: i64);
    for b in 0..M {
        let b = b as i64;
        let b5 = b.pow(5);
        if b.pow(5) > x {
            break;
        }
        let a5 = x - b.pow(5);
        let a = (a5 as f64).powf(1. / 5.) as i64;
        if a.pow(5) + b5 as i64 == x {
            println!("{} {}", a, -b);
            return;
        }
    }
    for b in 0..M {
        let b = b as i64;
        let b5 = b.pow(5);
        let a5 = x + b5;
        let a = (a5 as f64).powf(1. / 5.) as i64;
        if a.pow(5) - b5 as i64 == x {
            println!("{} {}", a, b);
            return;
        }
    }
    unreachable!();
}

fn main() {
    let mut s = String::new();
    stdin().read_to_string(&mut s).unwrap();
    solve(&s);
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn test_input() {
        let s = "
        ";
        solve(s);
    }
}