p444.ans1
======================
0 1

=================
p444.ans2
======================
1 1

=================
p444.ans3
======================
0 1 

=================
p444.ans4
======================
2 0

=================
p444.ans5
======================
0 0

=================
p444.ans6
======================
0 2

=================
p444.cpp
======================
#include <bits/stdc++.h>

using namespace std;

template<typename T1, typename T2>
ostream& operator<<(ostream& out, const pair<T1, T2>& x) {
    return out << x.first << ' ' << x.second;
}

template<typename T1, typename T2>
istream& operator>>(istream& in, pair<T1, T2>& x) {
    return in >> x.first >> x.second;
}

template<typename T>
istream& operator>>(istream& in, vector<T>& a) {
    for(auto& x: a) {
        in >> x;
    }
    return in;
};

template<typename T>
ostream& operator<<(ostream& out, const vector<T>& a) {
    for(auto x: a) {
        out << x << ' ';
    }
    return out;
};

int64_t x, y;

void read() {
    cin >> x >> y;
}

void solve() {
    // Simulate long division of x by y digit by digit. The state at each step
    // is the current remainder; the next remainder is (rem * 10) % y. A finite
    // expansion is reached when the remainder hits 0; a recurring part begins
    // when a remainder repeats.
    //
    // visited[rem] stores the digit index at which remainder rem was first
    // seen. When rem == 0 we stop with no recurring part (length 0). When a
    // remainder repeats, the cycle length is the difference between the current
    // digit index and the index where that remainder first appeared, and the
    // non-recurring prefix length is digits - cycle_length.

    vector<int64_t> visited(y, -1);
    int64_t rem = x % y;
    int64_t digits = 0;
    while(rem != 0 && visited[rem] == -1) {
        visited[rem] = digits;
        rem = (rem * 10) % y;
        digits++;
    }

    int64_t non_recurring, cycle_length;
    if(rem == 0) {
        non_recurring = digits;
        cycle_length = 0;
    } else {
        cycle_length = digits - visited[rem];
        non_recurring = digits - cycle_length;
    }

    cout << non_recurring << ' ' << cycle_length << '\n';
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

    int T = 1;
    // cin >> T;
    for(int test = 1; test <= T; test++) {
        read();
        // cout << "Case #" << test << ": ";
        solve();
    }

    return 0;
}

=================
p444.in1
======================
1 3

=================
p444.in2
======================
1 6

=================
p444.in3
======================
5 3


=================
p444.in4
======================
5 4

=================
p444.in5
======================
200 2

=================
p444.in6
======================
25000 99

=================
statement.txt
======================
444. Headstrong Student
Time limit per test: 0.75 second(s)
Memory limit: 262144 kilobytes
input: standard
output: standard

You are a teacher at a cram school for elementary school pupils. One day, you showed your students how to calculate division of fraction in a class of mathematics. Your lesson was kind and fluent, and it seemed everything was going so well — except for one thing. After some experiences, a student Max got so curious about how precise he could compute the quotient. He tried many divisions asking you for a help, and finally found a case where the answer became an infinite fraction. He was fascinated with such a case, so he continued computing the answer. But it was clear for you the answer was an infinite fraction — no matter how many digits he computed, he wouldn't reach the end. Since you have many other things to tell in today's class, you can't leave this as it is. So you decided to use a computer to calculate the answer in turn of him. Actually you succeeded to persuade him that he was going into a loop, so it was enough for him to know how long he could compute before entering a loop. Your task now is to write a program which computes where the recurring part starts and the length of the recurring part, for given dividend/divisor pairs. All computation should be done in decimal numbers. If the specified dividend/divisor pair gives a finite fraction, your program should treat the length of the recurring part as 0.
Input
The input consists of a line containing two positive integers x and y, which specifies the dividend and the divisor, respectively. You may assume that 1 ≤ x,y ≤ 1000000.
Output
Your program should output a line containing two integers separated by exactly one blank character. The former describes the number of digits after the decimal point before the recurring part starts. And the latter describes the length of the recurring part.
Example(s)
sample input
sample output
1 3
0 1

sample input
sample output
1 6
1 1

sample input
sample output
5 3
0 1

sample input
sample output
5 4
2 0

sample input
sample output
200 2
0 0

sample input
sample output
25000 99
0 2

=================
