Problem:
Score : 300 points

Problem Statement

Sitting in a station waiting room, Joisino is gazing at her train ticket.

The ticket is numbered with four digits A, B, C and D in this order, each between 0 and 9 (inclusive).

In the formula A op1 B op2 C op3 D = 7, replace each of the symbols op1, op2 and op3 with + or - so that the formula holds.

The given input guarantees that there is a solution. If there are multiple solutions, any of them will be accepted.

Constraints

0≤A,B,C,D≤9

All input values are integers.

It is guaranteed that there is a solution.

Input

Input is given from Standard Input in the following format:

ABCD

Output

Print the formula you made, including the part =7.

Use the signs + and -.

Do not print a space between a digit and a sign.

Sample Input 1

1222

Sample Output 1

1+2+2+2=7

This is the only valid solution.

Sample Input 2

0290

Sample Output 2

0-2+9+0=7

0 - 2 + 9 - 0 = 7 is also a valid solution.

Sample Input 3

3242

Sample Output 3

3+2+4-2=7

Solution in Rust (1.15.1) (judge verdict: Accepted)

#![allow(unused_imports)]
#![allow(non_snake_case)]
use std::cmp::*;
use std::collections::*;
use std::io::Write;

#[allow(unused_macros)]
macro_rules! debug {
    ($($e:expr),*) => {
        #[cfg(debug_assertions)]
        $({
            let (e, mut err) = (stringify!($e), std::io::stderr());
            writeln!(err, "{} = {:?}", e, $e).unwrap()
        })*
    };
}

fn main() {
    let x = read::<String>()
        .chars()
        .map(|x| x.to_digit(10).unwrap() as i32)
        .collect::<Vec<_>>();
    for i in 0..1 << 3 {
        let mut coef = vec![1; 3];
        for j in 0..3 {
            if i >> j & 1 == 1 {
                coef[j] = -1;
            }
        }
        if x[0] + coef[0] * x[1] + coef[1] * x[2] + coef[2] * x[3] == 7 {
            let mut ans = vec![std::char::from_digit(x[0] as u32, 10).unwrap()];
            if coef[0] == 1 {
                ans.push('+');
            } else {
                ans.push('-');
            }
            ans.push(std::char::from_digit(x[1] as u32, 10).unwrap());
            if coef[1] == 1 {
                ans.push('+');
            } else {
                ans.push('-');
            }
            ans.push(std::char::from_digit(x[2] as u32, 10).unwrap());
            if coef[2] == 1 {
                ans.push('+');
            } else {
                ans.push('-');
            }
            ans.push(std::char::from_digit(x[3] as u32, 10).unwrap());
            ans.push('=');
            ans.push('7');
            let ans = ans.into_iter().collect::<String>();
            println!("{}", ans);
            return;
        }
    }
}

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}