This is a constructive problem. It has many different approaches and solutions.

We have $$$2$$$ operations, sum of the numbers and $$$\mathrm{xor}$$$ of the numbers. They must be equal. To be more precise, we want this equation to hold

$$$A + B = 2 \cdot (A\, \mathrm{xor}\, B) = 2 \cdot x$$$

First thing we want to think about is: how fast can a naive iterative solution be? For given $$$x$$$ we can iterate over all $$$A$$$ and get $$$B = A \, \mathrm{xor}\, x$$$. This can be done in $$$\mathcal{O}(x)$$$. We will not solve the problem this way (TLE will be the result), but we can implement this iterative solution for all small tests, generate answers and use them to find patterns and properties.

Take a look at this solution https://codeforces.me/contest/1790/submission/190992078

Even from this cerr output we can see that for all numbers that have answers, the first way to build this answer is to take

$$$A = x/2$$$

$$$B = 3 \cdot x/2$$$

Actually this is enough to solve this problem. But that will not always be the case and generally you also want to know why does it work and how to prove it.

It makes sense to try analyzing individual bits for bitwise operations. Let's consider all possible combinations for bits in position $$$i$$$ in numbers $$$A$$$ and $$$B$$$:

• If $$$A[i] = 0, B[i] = 0$$$, then they have no effect on sum and on $$$\mathrm{xor}$$$
• If $$$A[i] = 0, B[i] = 1$$$, then they simultaneously add bit $$$i$$$ to sum and to $$$\mathrm{xor}$$$
• If $$$A[i] = 1, B[i] = 0$$$, completely matches previous one, no point to consider
• If $$$A[i] = 1, B[i] = 1$$$, then they have no effect on $$$\mathrm{xor}$$$, but they add bit $$$(i+1)$$$ to sum

We want to set bits in $$$A$$$ и $$$B$$$ in such a way, that it balances out $$$A + B$$$ and $$$2 \cdot (A\, \mathrm{xor}\, B)$$$ and also matches $$$x$$$. There is only one way to add the same bit $$$i$$$ simultaneously to $$$A + B$$$ and to $$$2 \cdot (A\, \mathrm{xor}\, B)$$$: make $$$A[i] = 0$$$, $$$B[i] = 1$$$, $$$A[i-1] = 1$$$, $$$B[i-1] = 1$$$. This way we will get $$$2$$$ binary digit overflows in sum and $$$\mathrm{xor}$$$ will have only one bit $$$i$$$ set.

010 $$$x$$$

001 $$$A$$$

011 $$$B$$$

100 $$$A+B$$$

010 $$$A\, \mathrm{xor}\, B$$$

100 $$$(A\, \mathrm{xor}\, B) \cdot 2$$$

This can be clearly seen on a small example $$$x=2, A=3, B=1$$$. The only way to set bit $$$i$$$ in number $$$x$$$ is to utilize two bits in numbers $$$A$$$ and $$$B$$$: bit $$$i$$$ and bit $$$(i-1)$$$. So if we want set bit $$$i$$$ in number $$$x$$$ to $$$1$$$, then bit $$$(i-1)$$$ must be set to $$$0$$$.

Thus answer exists for all possible numbers $$$x$$$ in which each bit equal to $$$1$$$ is preceded with bit equal to $$$0$$$. In other words for all $$$i$$$ that match $$$x[i] = 1$$$ we must also have $$$x[i-1] = 0$$$. This is also true for the lowest bit, it does not have any preceding bit, so it also must be equal to $$$0$$$

All possible answers for the same number $$$x$$$ differ from each other only in arrangements of bits in positions where those bits should be different ($$$A[i] = 1$$$ and $$$B[i] = 0$$$ or $$$A[i] = 0$$$ and $$$B[i] = 1$$$).

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();
    }
}

1

5 4

1 5

3

1 2 3 4 5

1 2

1 4

2 3

3 5