codeforces 1005D Polycarp and Div 3

Polycarp likes numbers that are divisible by 3.

He has a huge number ss. Polycarp wants to cut from it the maximum number of numbers that are divisible by 33. To do this, he makes an arbitrary number of vertical cuts between pairs of adjacent digits. As a result, after mm such cuts, there will be m+1m+1 parts in total. Polycarp analyzes each of the obtained numbers and finds the number of those that are divisible by 33.

For example, if the original number is s=3121s=3121, then Polycarp can cut it into three parts with two cuts: 3|1|213|1|21. As a result, he will get two numbers that are divisible by 33.

Polycarp can make an arbitrary number of vertical cuts, where each cut is made between a pair of adjacent digits. The resulting numbers cannot contain extra leading zeroes (that is, the number can begin with 0 if and only if this number is exactly one character '0'). For example, 007, 01 and 00099 are not valid numbers, but 90, 0 and 10001are valid.

What is the maximum number of numbers divisible by 33 that Polycarp can obtain?

Input

The first line of the input contains a positive integer ss. The number of digits of the number ss is between 11 and 2⋅1052⋅105, inclusive. The first (leftmost) digit is not equal to 0.

Output

Print the maximum number of numbers divisible by 33 that Polycarp can get by making vertical cuts in the given number ss.

Examples

Input

3121

Output

2

Input

6

Output

1

Input

1000000000000000000000000000000000

Output

33

Input

201920181

Output

4

Note

In the first example, an example set of optimal cuts on the number is 3|1|21.

In the second example, you do not need to make any cuts. The specified number 6 forms one number that is divisible by 33.

In the third example, cuts must be made between each pair of digits. As a result, Polycarp gets one digit 1 and 3333 digits 0. Each of the 3333digits 0 forms a number that is divisible by 33.

In the fourth example, an example set of optimal cuts is 2|0|1|9|201|81. The numbers 00, 99, 201201 and 8181 are divisible by 33.

 

题意：给你一个全数字的字符串，要你切割任意多的位置，要求使最后能够被3整除的数最多，问最多有多少个；

思路：仔细想一想，你会发现，当位数到达3的时候，就有一定的感觉这个数里面总会能够再切割一下，然后会出现能够被3整除的数。然后我就打表确定的一下，你会发现，当数达到三位的时候，这个数中一定会有切割后能够被3整除的数。 于是有了最佳的贪心策略，如果当前s[i] 能够直接整除3，直接 ++ ans, 否则放入tmp，代表的当前数，但是还要同时记录 0,3,6,9 这四个数的count, 如果count > 0, 直接 ans += count, 否则，++ ans.

AC代码：

#include<bits/stdc++.h>
#define debug(x) cout << "[" << #x <<": " << (x) <<"]"<< endl
#define pii pair<int,int>
#define clr(a,b) memset((a),b,sizeof(a))
#define rep(i,a,b) for(int i = a;i < b;i ++)
#define pb push_back
#define MP make_pair
#define LL long long
#define INT(t) int t; scanf("%d",&t)
#define LLI(t) LL t; scanf("%I64d",&t)

using namespace std;

const int maxn = 2e5 + 10;
char s[maxn];

int main()
{
    while(~scanf("%s",s + 1)){
        int lens = strlen(s + 1);
        int ans = 0;
        int tmp = 0, coun = 0;
        rep(i,1,lens + 1){
            tmp = tmp * 10 + s[i] - '0';
            if(tmp % 3 == 0){
                ++ ans;
                coun = tmp = 0;
                continue;
            }
            if(s[i] == '0' || s[i] == '3' || s[i] == '6' || s[i] == '9')
                ++ coun;
            if(coun > 0){
                ans += coun;
                coun = tmp = 0;
            }
            else {
                if(tmp >= 100){
                    ++ ans;
                    coun = tmp = 0;
                }
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}