We have two competitors, a tortoise and a monkey, each trying to reach position N. The tortoise moves a fixed distance S. in one step, so it needs ⌈N/S⌉ steps to finish. Meanwhile, the monkey can jump a distance between 1 and X per step. In the worst case (i.e., assuming the monkey always makes the maximum jump of X), it will require ⌈N/X⌉ steps to reach N.

Calculate Tortoise Steps: tortoise_steps= ⌈N/S⌉

Calculate Monkey Steps: monkey_steps= ⌈N/X⌉

Compare: If tortoise_steps < monkey_steps , the tortoise wins. If monkey_steps < tortoise_steps, the monkey wins. Otherwise, it’s a tie.

Finally, output "Tortoise", "Monkey", or "Tie" based on the comparison.

void solve() {
    int N, S, X;
    cin >> N >> S >> X;
    
    int tortoise_steps = ceil((double)N / S);
    int monkey_steps = ceil((double)N / X);
    
    string winner;
    if (tortoise_steps < monkey_steps) {
        winner = "Tortoise";
    } else if (monkey_steps < tortoise_steps) {
        winner = "Monkey";
    } else {
        winner = "Tie";
    }
    
    cout << winner << e;
}

1- Compute the total available area by multiplying the number of sheets by the area of each sheet.

2- Calculate the tray’s area as the square of its side length.

3- Compare the two areas: if total sheet area is at least the tray’s area, output YES; otherwise, NO.

To solve the problem, note that each Roqaq sheet is a square with area b^2, and with n boxes containing s sheets each, the total available area is n*s*b^2. The tray is also a square, with area a^2 . The cook can cover one full layer on the tray if the available area is at least as large as the tray’s area; that is, if n*s*b^2≥a^2. A correct implementation should compare these squared values directly to avoid any floating-point precision issues. The provided code mistakenly uses sqrt(n*s)*b≥a. for the comparison, which might work in some cases but is not as robust.

#include <bits/stdc++.h>
#define ll long long
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
using namespace std;
void solve (){
    ll a, b, n, s;
    cin >>a>>b>>n>>s;
    if(sqrt(n*s)*b>=a)cout <<"YES\n";
    else cout <<"NO\n";
}
int32_t main() {
    IOS;
    int tests = 1;
    cin >> tests;
    while (tests--) {
        solve();
    }
    return 0;
}

In this problem, you are asked to count the number of ways to choose exactly three bulbs to be turned on from a string of n bulbs, which is simply the combination n choose 3 The formula for this is: n * (n − 1) *(n−2)/6

Given that n can be as large as 10^15 , directly computing the product n*(n−1)*(n−2) might result in numbers that exceed the limits of built-in data types. To handle this, the solution first simplifies the expression by dividing by 6 before performing multiplications. This is done by taking the numbers n, n−1, and n−2 and sequentially canceling common factors with 6 using the greatest common divisor (GCD). After the cancellation, the product is computed in a way that avoids overflow.

Because the resulting number can be extremely large, the solution uses a custom string multiplication function (mul) to multiply numbers represented as strings, which simulates big integer arithmetic. The final product, which is the answer and printed as a string.

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
 
string mul(string a, string b){
    bool neg = 0;
    if(a[0] == '-'){
        neg ^= 1;
        a.erase(a.begin());
    }
    if(b[0] == '-'){
        neg ^= 1;
        b.erase(b.begin());
    }
    int len1 = a.size();
    int len2 = b.size();
    if (len1 == 0 || len2 == 0)
        return "0";
 
    vector<int> result(len1 + len2, 0);
    int i_n1 = 0; 
    int i_n2 = 0; 
     
    for (int i=len1-1; i>=0; i--){
        int carry = 0;
        int n1 = a[i] - '0';
        i_n2 = 0; 
         
        for (int j=len2-1; j>=0; j--){
            int n2 = b[j] - '0';
            int sum = n1*n2 + result[i_n1 + i_n2] + carry;
            carry = sum/10;
            result[i_n1 + i_n2] = sum % 10;
            i_n2++;
        }
 
        if (carry > 0)
            result[i_n1 + i_n2] += carry;
        i_n1++;
    }
 
    int i = result.size() - 1;
    while (i>=0 && result[i] == 0)
    i--;
 
    if (i == -1)
    return "0";
 
    string s = "";
    while (i >= 0)
        s += std::to_string(result[i--]);
    
    if(s != "0" && neg) 
        s = "-" + s;
    return s;
}
 
void hassan(){
    ll n;
    cin >> n;
    ll a = n , b = n - 1 , c = n - 2;
    ll x = 6;
 
    ll g = __gcd(a , x);
    a /= g;
    x /= g;
    g = __gcd(b , x);
    b /= g;
    x /= g;
    g = __gcd(c , x);
    c /= g;
    x /= g;
 
    cout << mul(to_string(a) , mul(to_string(b) , to_string(c))) << '\n';
}
 
int main(){
    ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
    int t; cin >> t; while(t --)
    hassan();
}

We model the orange as a perfect sphere whose diameter is n*x. Consequently, its radius is n*x/2. When you make a horizontal slice at a distance of i*x from the top (where i is counted in “slice-thickness” units), the cross-section is a circle whose radius r satisfies: r^2 = R^2 −(R−i x)^2 where : R=nx/2. Expanding and simplifying yields: r^2=x^2[i(n−i)]. Dr. Kawthar “dislikes the first and last slices,” meaning i must be strictly between 0 and n. So we look for an integer i∈[1,n−1] such that x^2 i(n−i)=r^2. If such an i exists, that slice’s top has the desired squared radius r^2. If no integer i satisfies the equation, we print −1. In the code, this check is done either by iterating through possible i values or by using binary search to find whether any i in the valid range yields the required r^2 . If found, we output i+1 (the slice number), else −1.

#include <bits/stdc++.h>
#define ll long long
#define IOS ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
using namespace std;
void solve() {
    ll n, x, ngiven; cin >> n >> x >> ngiven;
    if(n==2){cout<<-1<<endl;return;}
    ll dia = n * x, u = n / 2, l = 1;
    while (l <= u) {
        ll mid = (l + u) / 2;
        if (dia * x * mid - (x * mid) * (x * mid) == ngiven) {
            cout << mid + 1 << endl;
            return;
        } else if (dia * x * mid - (x * mid) * (x * mid) > ngiven) u = mid - 1;
        else l = mid + 1;
    }
    cout << -1 << endl;
}

int32_t main() {
    IOS;
    int tests=1;
    cin >> tests;
    while (tests--) {
        solve();
    }
    return 0;
}