As the name suggest it is an easy problem all what is needed is to take a string s as input and print "Mohamed Salah"

-time complexity for this solution is O(1).

#include<iostream>
using namespace std;
int main()
{
 string str;cin>>str;
 cout<<"Mohamed Salah";
}

We want to make sure that each element only occurs one time. So, We’ll make a frequency array to count how many times each element occurred. Then, we’ll loop the frequency array to make sure that each element occurred 1 time. If there’s an element that occurs more than 1 time, we break from the loop and print "NO". If the loop is finished

Time Complexity : $$$O(N)$$$
Where $$$N$$$ is the size of the frequency array

#include <bits/stdc++.h>

using namespace std;

const int N = 1e5 + 5;

int main(){
    int t;
    cin >> t;
    while(t--){
        int freq[N] = {0};
        int n; cin >> n;
        for(int i = 0; i < n; i ++){
            int x; cin >> x;
            freq[x]++;
        }
        bool flag = false;
        for(int i = 0; i < N; i++){
            if(freq[i] > 1){
                flag = true;
                break;
            }
        }
        if(flag)
            cout << "NO" << endl;
        else
            cout << "YES" << endl;
}

If $$$a$$$%$$$b=0$$$ ($$$a$$$ is divisible by $$$b$$$), just print $$$0$$$. Otherwise, we need exactly $$$b − a$$$%$$$b$$$ moves to make zero remainder of $$$a$$$ modulo $$$b$$$. % is the modulo operation.

#include<iostream>
using namespace std;
int main(){
    int t = 1; cin >> t;
    while(t--){
        int a,b;
        cin >> a >> b;
        if(!(a%b)) cout<<"0\n";
        else cout<<b-(a%b)<<"\n";
    }
    return 0;
}

We caculate the sum of elements at even indices and the sum of elements in odd indices. then we compare these two numbers.

Time Complexity : $$$O(n)$$$
Where $$$n$$$ is the size of the array

#include <bits/stdc++.h>
#define ll long long

using namespace std;

int main(){
    ll i, n, odd = 0, even = 0;
    cin >> n;
    for(i = 1; i <= n; i++){
        ll x; cin >> x;
        if(( i%2 ))
            odd += x;
        else
            even += x;
    }
    if(odd > even)
        cout << "Odd" << endl;
    else if(even > odd)
        cout << "Even" << endl;
    else
        cout << "Equal" << endl;
    return 0;
}

In order to minimize the difference between the number of coins of 1 dollar $$$c1$$$ and 2 dollars $$$c2$$$, all we need to do is to divide the total number of burles $$$n$$$ by 3. Then, if the remainder from the division equals 1, increase the coins of $$$c1$$$ by one. And in case the remainder from the division is 2, then we will increase the coins of $$$c2$$$ by 1.

-Time complexity for this solution is O(1) per test case.

#include<iostream>
using namespace std;
int main() {
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        int c1,c2;
        c1=n/3;c2=n/3;
        c1+=(n%3==1);
        c2+=(n%3==2);
        cout<<c1<<" "<<c2<<endl;
    }

    return 0;
}

In this problem we want to find a number that is divisible by t and has n digits. But we found a series of problems:

1. n can be 100 -> there is no data type that handles such a big number (long long take up to pow(2,64))

2. How can I easily get a number divisible by t

The answer is t itself and

what about multiplying the number by 10 until I get the desired length? why 10: multiplying by 10 will keep the divisibility state (2x10 is divisible by 2 and 2x10x10 is still divisible by 2....)

so the answer will be the t multiplied by 10 until I reach the desired length. -> problem 2 solved

multiplying by 10 means adding 0 to the end of the number (2x10 = 20, 330x10 = 3300)

so we can print the t followed by zeros -> problem 1 solved

but when I will print -1? the answer is if the number of digits in t is less than n as the smallest number is divisble by t is t itself

-time complexity for this solution is O(n).

#include <iostream>
#include <vector>
using namespace std ;
int32_t main() {
    int n,t;cin>>n>>t;
    if(t == 10 && n== 1){
        cout<<"-1";
    }else{
        cout<<t;
        n--;
        if(t == 10)n--;
        for (int i = 0; i < n; ++i) {
            cout<<"0";
        }
    }
}

The key for solving this problem is the observation that the frequency of any element will not exceed 1000 (The maximum number of elements) The solution steps will be as follows

1. Sort the elements in reversed order.
2. Iterate from 1 to n (number of elements) for all numbers if the frequency of number equal to i print the number i times
3. This grantees that the elements is printed in the increasing order in frequency and if there is two elements with the same frequency they will be printed in decreasing order
4. Here we still have one problem we can't calculate frequency for negative values in array so we will use two arrays one for positive as usual and another one for negative if the number less than zero we will store its frequency in neg_freq array in its as follows if i = -5 neg_freq[5]++;

time complexity for this solution is O(n^2) as we iterate over all elements n times

#include<bits/stdc++.h>
using namespace std;
void fast(){ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);}

int main()
{
    fast();
    int neg_freq[1001]={0}, pos_freq[1001] = {0}; // array for positive and array for negative
    int n;
    cin >>n;
    int a[n];
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
        if(a[i] > 0)
            pos_freq[a[i]]++;
        else
            neg_freq[-a[i]]++;
    }
    
    sort(a, a+n);
    reverse(a, a+n);

    for (int i = 1; i <= n; ++i) {
        for(int j = 0; j < n; j++){
            if(a[j] > 0){
                if(pos_freq[a[j]] == i){
                    for(int k = 0; k < i; k++){
                        cout<<a[j]<<' ';
                    }
                    pos_freq[a[j]] = 0;
                }
            }else{
                if(neg_freq[-a[j]] == i){
                    for(int k = 0; k < i; k++){
                        cout<<a[j]<<' ';
                    }
                    neg_freq[-a[j]] = 0;
                }
            }
        }
    }
    return 0;
}

The Solution is to check the sum for each cell. For each cell (i , j) we can iterate over all elements in its diagonals calculate the sum and save the maximum. We have four different directions to go to

1. top right each cell in this direction (i, j) the next one is (i-1, j+1)
2. bottom left each cell in this direction (i, j) the next one is (i+1, j-1)
3. top left each cell in this direction (i, j) the next one is (i-1, j-1)
4. bottom right each cell in this direction (i, j) the next one is (i+1, j+1)

here at each cell the maximum number of elements to loop over is mx(m, n) so the time complexity is O(n*m*max(n, m))

#include<bits/stdc++.h>
using namespace std;
void fast(){ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);}

int main()
{
    fast();
    int t;
    cin >>t;
    while(t--){   // our test cases
        int n, m;
        cin >> n >> m;
        int a[n][m];
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                cin >> a[i][j];
            }
        }
        int mx = 0;
        for(int i = 0; i < n; i++)
        {
            for(int j = 0; j < m; j++)
            {
                int now = 0;
                int ci = i, cj = j;
                while(ci >= 0 && ci < n && cj >= 0 && cj < m)
                {
                    now+=a[ci][cj];
                    ci--;
                    cj--;     // top left direction
                }
                ci = i, cj = j;
                while(ci >= 0 && ci < n && cj >= 0 && cj < m)
                {
                    now+=a[ci][cj];
                    ci++;
                    cj--;   // bottom left direction
                }
                ci = i, cj = j;
                while(ci >= 0 && ci < n && cj >= 0 && cj < m)
                {
                    now+=a[ci][cj];
                    ci--;
                    cj++;   // top right direction
                }
                ci = i, cj = j;
                while(ci >= 0 && ci < n && cj >= 0 && cj < m)
                {
                    now+=a[ci][cj];
                    ci++;
                    cj++;   // bottom right direction 
                }
                now-=a[i][j]*3;  // we have added a[i][j] to sum 4 times. we need to add it only one time, so we subtract 3*a[i][j]
                mx = max(mx, now); // save maximum sum in mx
            }
        }
        cout << mx << endl;
    }
    return 0;
}

Not finished yet

#include<bits/stdc++.h>
using namespace std;
void fast(){ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);}

int main()
{
    fast();
    int n, m;
    cin >> n >> m;
    int arr[n];
    for(int i = 0; i<n; i++){
        cin >> arr[i];
    }
    int freq[100005]={0},pref[n+1];
    pref[n] = 0;
    for(int i = n-1; i>=0; i--){
        if(freq[arr[i]] == 0)
            pref[i] = pref[i+1] + 1;
        else
            pref[i] = pref[i+1];
        freq[arr[i]]++;
    }
    int q;
    while(m--){
        cin >> q;
        cout<<pref[q-1]<<"\n";
    }
    return 0;
}