This problem I believe that everyone can solve but for example something curios that happen to me is that in the moment that I was writing the code for some reason I was doubting if 30 numbers after the first 3 or if the 3 count to the 30, but this problem it too simple and is about speed, so I decide to do the worst case that is that the count begin after the first three and search which are the first 30 numbers after the point and for the comparation of string use the length of the string that the problem give to make sure that I don't overflow or call something that doesn't exit.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    string s;
    cin >> s;
    string y = "3141592653589793238462643383279";
    int n = s.size();
    int ans = 0;
    for(int i = 0;i < n;i++){
        if(s[i] == y[i]){ans++;}
        else{break;}
    }
    cout << ans << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

For this problem onward I began to use the best weapon that have the beginners in my opinion and is don't overcomplicate only try to solve it like if you were doing it at hand and write the way that your brain think to solved it and later past it to code, this is really useful when you see that they give you variables that are really small, for example in this problem $$$n = 50$$$, which mean that you only have to fill 50 values of the dice maximum and $$$t = 1000$$$, so even in the most wild case there are only 5000 dice to fill which is a number pretty small for a problem. My way of solving it was thinking in the simplest steps are the following:

1. Make a dice value of $$$s-r$$$ that is the difference, in my code I think about the possibility that the difference is more than six and there is need of more dice, but they said that always exist the answer and only taking one dice will make the value of $$$s$$$ into $$$r$$$, so I had a bit of luck.

2. Fill the rest of the dice with what is necessary to make the total value of the dice into $$$s$$$, but I fill it in the most brute force possible that is one for one and only given plus one each time that I pass for some dice.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n,tots,r;
    cin >> n >> tots >> r;
    vector<int> a(n);
    int ans = 0;
    int i = 0;
    int diff = tots-r;
    while(diff > 0){
        if(diff > 6){a[i]=6;i++;diff-=6;}
        else{a[i]= diff;i++;break;}
    }
    tots -= (tots-r);
    int m = i;
    while(tots > 0){
        for(i = m;i < n && tots >0;i++){
            a[i]++;
            tots--;
        }
    }
    for(auto x : a){cout << x << " ";}
    cout << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

The same as the problem B, begin to try to solved yourself and you will notice that if you sum the position that a number have been at each iteration the one that sum the smallest is the number that is first in the original and the one that sum the biggest is the last one in the original and with it if you see the other numbers the most true that is become, the small the total sum of position is of a number the more to the left this will be and in the other case the more big the more to the right is his position the original array.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    vector<pair<int,int>>  a;
    map<int,int> b;
    for(int i =0;i < n;i++){
        
            for(int j = 0; j < n-1;j++){
            int x;
            cin >> x;
            b[x] += j+1;
            }
        
        
    }
    for(int i = 1;i <= n;i++){
        a.push_back({b[i],i});
    }
    sort(a.begin(),a.end());
    for(int i = 0;i < n;i++){
        cout <<a[i].second << " ";
    }
    cout << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

In this problem the reason that I see why someone couldn't do it are 3:

1. don't have confidence submitting something that maybe surpass time constraints
2. don't know how to use binary search
3. don't read right that is in the form $$$s, s+1, …, s+m−1$$$

To solve the first one as a beginner I think that you must realize that you don't have anything to lose and that you must use it to your favor in a way that you always are pushing yourself to try to at least do one submit to prove that you try your best

In the second one, to be real I don't understand binary search to deeply but I know to use the functions lower_bound() and upper_bound(), this is my way to pass question that need low time complexity

And the third is that for example a nest of dolls that don't work is $$${1,2,4}$$$ but maybe you didn't read right that the different of each adjacent element is maximum 1, so my tip is to read a bit slower the more that you are close to the end of the contest.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    vector<int> a(n);
    for(auto &x : a){cin >> x;}
    sort(a.begin(),a.end());
    int ans = 0;
    int h =  -1;
    while(a.size() > 0){
        if(h == -1){h = a[0];
        // cout << "erase ->  " << a[0] << "  ";
        a.erase(a.begin());}
        // for(auto x : a){cout << x << " ";}
        // cout << ans << '\n';
        if(a.size()==1 ){
            if(a[0] == h+1){ans++;}
            else{ans+=2;}
            break;
        }
        if(a[0] == a[a.size()-1] ){
            if(a[0] == h+1){
                ans += a.size();
            }
            else{
                ans += a.size()+1;
            }
            break;
        }
        auto it = upper_bound(a.begin(),a.end(),h);
        if(it == a.end()){ans++;h=-1;}
        else{
            
            if(*it == h+1){
            // cout << h << " " << *it ;
            // cout << " erase ->" << *it << '\n';
            h = *it;
            a.erase(it);}
            else{
                ans++;
                h=-1;
            }
    }
            }
            
    cout << ans << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

This one is the easiest, but I think that always that you read that you must give a number that is not the minimum or maximum of a list, you must think in make a vector, sort and print the position that you are interested. Like for example the second minimum would be a[1] or the second maximum a[n-2].

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    vector<int> a(3);
    for(auto &x : a){cin >> x;}
    sort(a.begin(),a.end());
    cout << a[1] << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

The important thought that you must find is that if the maximum letter is 'a' you only need one and 'z' you need 26 and with only make in your mind the solution of two case you began to see what you need to do, I was a little nervous when I was writing the code and was thinking what is better if sort the string and see the last letter or used the function max_element, when you have dudes but you know that the code that you are in the middle of writing will work too, is best to commit to what you are writing in the moment that change to another solution in my experience. This work good in first or second problem for me because the solutions that you think probably will be right because they try to make easy for beginners like me, this is my way to be faster.

Another useful type for the problems that want you to make a letter a number is remember that 'a'-'a' is 0 or a character minus the same character will return 0.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    string s;
    cin >> s;
    sort(s.begin(),s.end());
    cout << s[n-1] - 'a' + 1 << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

Here strike again the idea that we see in the problem A, in this problem you only care about the maximum and the second maximum so you make a vector, sort and use a[n-1] when the value x is not the maximum and a[n-2] if x is equal to the maximum, but I used a different method of only stored the two maximum numbers in a vector because I think a better version before beginning to write.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    vector<int> a(n);
    vector<int> b(2);
    for(auto &x : a){cin >> x; 
        if(b[1] < x){
            b[0] = b[1];
            b[1] = x;
        }
        else if(b[1] == x){
            b[0] = b[1];
        }
        else if(b[0] < x){
            b[0] = x;
        }
        
    }
    for(auto x : a){
        if(x != b[1]){
            cout << x - b[1] << " ";
        }
        else{
            cout << x - b[0] << " ";
        }
    }
    cout << '\n';
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

Is curious because I have come across this kind of problems many times that they want you to search there is a "Valley" or a "Peak" in the vector I still don't have a good way of approach this kind, but they always give you the conditions that must meet so the idea is always searching in a for if the condition is meet and see what are the corners case.

In this case you want to focus in every point because you can make L=R, the segments with same numbers but for example if you have a segment equal to {3,3,3,3} you don't want to waste your time with {3},{3,3},{3,3,3} because they will contradict the condition a[l−1]>a[l] or a[r] < a[r+1] other that this is good to keep in mind that l=0 or r = n-1 are free passes.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    int i = 1;
    int l = 0;
    vector<int> a(n);
    cin >> a[0];
    int h = a[0];
    int ans = 0;
    int cnt = 1;
    for(i;i < n;i++){
        int x;
        cin >> a[i];
        x = a[i];
        if(x != h){
            // cout << l << " " << i <<  " ";
            if(l == 0){
                if(a[i-1] < a[i]){ans++;}
            }
            else if(a[l-1] > a[l]){
                if(a[i-1] < a[i]){ans++;}

            }
            // cout << ans << '\n';
            l = i;
            h = x;
        }
    }
    // cout << ans << " ";
    if(n == 1){
        cout << "YES\n";
        return;
    }

    if(a[n-1] == a[n-2]){
        if(l == 0){ans++;}
        else if(a[l-1] > a[l]){ans++;}
    }
    else{
        if(a[n-2] >  a[n-1]){ans++;}
    }
    // cout << ans << " ";
    ans == 1 ? cout << "YES\n" : cout << "NO\n";
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}

this one is just in my reach of knowledge so when I find problems that seem difficult at the beginning, I always try to see what type of input I can solve and corner case to corner case I will build my solution.

• The first one is what happen if n == 1? in this case no matter why I do the answer will be 0
• what happen if there are only ones? then the best is to make the last number a 0 and the answer will be n-1
• if there are only zeros? make the first number a 1 and the answer will be n-1

Now it's apparent that the best is to make the last one a zero or the first one converted to one and see how much we gain or lost for each operation and after seeing if it is good to make a change, go for all the vector and every see how much it will give to the answer. Another tip is to use comments when you feel that you are confused about what you have done and what not.

If you see my code is very inefficient but show that divide the problem in easy problems help you to see a solution.

#include <bits/stdc++.h>

using namespace std;
/*

  


*/
int gcd(int a,int b)
{
    if(b==0)
        return a;
    else
        return gcd(b,a%b);  
}

int lcm(int a,int b)
{
    return (a*b)/gcd(a,b);
}

void solve(){  
    int n;
    cin >> n;
    vector<int> a(n);
    vector<int> pos;
    long long tots = 0;
    int i = 1;
    int fz = -1;
    int posz = 0;

    for(auto &x : a){
        cin >> x;
        if(x == 1){pos.push_back(i);}
        if(x == 0 && fz == -1){fz = i;posz =  i-1;}
        i++;
    }
    int n1 = pos.size();
    int cntz = n-n1;
    if(n == 1){cout << "0\n";return;}
    if(n1 == 0 || fz == -1 || cntz == 0){
        cout << n-1 << '\n';return;
    }
    int val1 = cntz-1-posz;// first z to 1
    int val2 = (n1-1)-(n-pos.back());//last 1 to z
    // cout << val1 << " " << val2 << '\n';
    if(val1 > val2){
        a[posz] = 1;
        cntz--;
    }
    else if(val2 > 0){
        a[pos.back()-1] = 0;
        cntz++;
    }
    for(int i = 0;i < n;i++){
        if(a[i] == 0){cntz--;}
        else{
            tots += cntz;
        }
    }
    cout << tots << '\n'; 
}
int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);
    //cout.precision(10);
    int t = 0;
    cin >> t;
    for(int p = 0; p < t;p++){
        solve();
    }
}