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 OCaml (4.02.3) (judge verdict: Accepted)

module A = Array
module C = Char
module I = Int64
module L = List
module Q = Queue

let pf = Printf.printf
let sf = Scanf.scanf
let ssf = Scanf.sscanf

let read_int () = sf "%d " (fun x -> x)
let read_float () = sf "%f " (fun x -> x)
let read_str () = sf "%s " (fun x -> x)
let read_array read n = A.init n (fun _ -> read ())
let err s = raise (Failure s)

let range s t = A.init (t - s) @@ (+) s
let foreach fold_f init s t map_f =
  range s t |> A.map map_f |> A.fold_left fold_f init

let inf = int_of_float 1e18
let eps = 1e-11

module S = struct
  include String
  let of_array a = String.init (A.length a) (A.get a)
  let to_array s = A.init (String.length s) (String.get s)
end;;

let rec search vals str sum goal =
  match vals with
  | [] ->
     if sum = goal
     then Some str
     else None
  | x :: xs ->
     (* case + *)
     let case_plus = search xs (str ^ "+" ^ string_of_int x) (sum + x) goal in
     ( match case_plus with
       | None -> search xs (str ^ "-" ^ string_of_int x) (sum - x) goal
       | _ -> case_plus )

let () =
  let s = read_str () in
  let vals = S.to_array s |> A.map int_of_char |> A.to_list in
  let vals = L.map (fun x -> x - int_of_char '0') vals in
  let head = L.hd vals in
  let tail = L.tl vals in
  let res = search tail (string_of_int head) head 7 in
  match res with
  | None -> ()
  | Some x -> pf "%s=7\n" x