Problem:
かけざん

太郎君はかけざんを習いたての小学生です。なんとなく、彼はかけざんを気に入っているので、数字を見かけるとかけざんをしたくなります。そんな彼はここのところ、次のような処理を0以上の整数に施すことが好きなようです。

(処理の流れ)

手順1. ある0以上の整数nが10進数表示で一けたならばそこで処理を終了する。そうでなければ手順2に進む

手順2. 10以上の整数nを10進数表示をするとどこかの桁の間に切れ目を入れて二つの数字に分解することが可能である(例えば2012-> 20,12)。このような切り方としてありうるものに対して,得られた二つの数字を掛け合わせて最も大きいものを次のnとして手順1に戻る。(詳しくは下記の"手順2に関する補足を参照")

太郎君はこの処理を気に入っているようですが、何回手順2の操作を繰り返せばよいのか大きい数字だと予想ができず、もしかしたら無限回行われなければならないかもしれないと思っています。そこで、太郎君の兄であり大学生であるあなたに0以上の整数nに対してこの手順2を何回しなければならないかを聞いてきました。

あなたの仕事は、Q個の0以上の整数N1..NQが与えられるので、それぞれの整数で処理の終了までに何回の手順2が施されるかを求めることです。その際にもし無限回の手順が必要ならば、-1を出力してください。

手順2に関する補足

切り分けた結果、桁の初めに0がつくものも考慮に入れる必要があります。

例えばn=1024のとき、1*024 , 10*24 , 102*4をそれぞれ計算するとそれぞれ24,240,408となるため、408が選ばれ、これが次のnとなります。

Input

Q
N1
N2
...
NQ

Qは与えられる0以上の整数の個数を表す

Niは太郎君が気になっている0以上の整数で,i番目のものを表す

Constraints

1≤Q≤100
0≤Ni≤106

Output

Q個の整数を改行区切りで出力せよ

R1
R2
..
RQ

Riは、Niに対して処理を終了するまでに手順2を実行する回数を表す

Niに対して手順2を無限回だけ実行する必要がある場合はRi は -1となる

Sample Input 1

3
9
99
123

Output for the Sample Input 1

0
2
3

9は1桁の数なので、手順2が実行されることはありません。

99は2桁であり、手順2を施せば9,9としか分割できずその次の数は81となる。
81も2桁の数であり、手順2を施せば8,1としか分割できずその次の数は8となる。
1桁の数になったので処理が終了し、答えは2。

123は3桁の数なので、手順2を施します。
この場合は12,3と1,23の二つの分け方があり、それぞれでかけざんをすると36,23となるので、
36が次の数として選ばれます。

Sample Input 2

2
999999
1000000

Output for the Sample Input 2

12
1

Solution in JAVA (judge verdict: Accepted)

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.OptionalInt;
import java.util.Scanner;
import java.util.Set;
import java.util.stream.IntStream;

public class Main {

	public static void main(String[] args) {
		read().stream()//
				.map(new Main()::execute)//
				.forEach(System.out::println);
	}

	private static List<Integer> read() {
		Scanner sc = new Scanner(System.in);

		int q = sc.nextInt();
		List<Integer> valueList = new ArrayList<>();
		for (int i = 0; i < q; i++) {
			valueList.add(sc.nextInt());
		}

		sc.close();
		return valueList;
	}

	public int execute(int originalValue) {
		if (originalValue < 10) {
			return 0;
		} else {
			return execute(originalValue, new HashSet<>()).getAsInt();
		}
	}

	public OptionalInt execute(int originalValue, Set<Integer> valueSet) {
		if (originalValue < 10) {
			return OptionalInt.of(valueSet.size());
		} else if (valueSet.contains(originalValue)) {
			return OptionalInt.of(-1);
		} else {
			valueSet.add(originalValue);
			return execute(next(originalValue).getAsInt(), copy(valueSet));
		}
	}

	private <T> Set<T> copy(Set<T> source) {
		Set<T> dest = new HashSet<T>();
		dest.addAll(source);
		return dest;
	}

	private OptionalInt next(int value) {
		String str = String.valueOf(value);
		return IntStream.range(1, str.length())//
				.map(i -> Integer.parseInt(str.substring(0, i)) * Integer.parseInt(str.substring(i))).max();
	}
}