The clock only shows values from 0 to 59 and wraps around (modulo 60). The only thing to be checked here was if the call duration was a multiple of 60 seconds or not.

• If s % 60 == 0 → print "NO"
• Else → print "YES"

#include <bits/stdc++.h>
using namespace std;

//--------code begins here--------

void solve() {
    int s; cin >> s;
    if(s % 60) cout << "YES";
    else cout << "NO";
}

int main() {
  ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
  int T = 1;
  cin >> T;

  while (T--) {
    solve();
    cout << endl;
  }
  return 0;
}

Instead of making $$$1$$$, can we make a $$$0$$$?

The example in the problem statement is a misdirection which could lead to greedy ideas. However, the solution is pretty simple : Any number multiplied by $$$0$$$ is $$$0$$$, and we can add a $$$1$$$ to it.

Thus, for $$$n \geq 4$$$, the solution is simply : $$$X * (1 - 1) + 1$$$, which uses exactly $$$3$$$ 1's.

#include <bits/stdc++.h>
using namespace std;

using ll = long long;

int main() {
	ios_base::sync_with_stdio(false); cin.tie(0);

	int tc; cin >> tc;
	while(tc--) {
		int N; cin >> N;
		cout << min(N - 1, 3) << "\n";
	}

	return 0;
}

We solve the problem using 2D binary search.

Vibhaas is at some hidden point $$$(X,Y)$$$ within the range $$$(0,10^9)$$$ We maintain a rectangle that is guaranteed to contain this point. Initially, this rectangle is the entire grid.

At each step, we query the middle point of the current rectangle. Based on the judge’s response, we learn whether Vibhaas lies to the left or right (affecting the x-coordinate) and/or above or below (affecting the y-coordinate).

Using this information:

• We discard half of the range in the x-direction.
• We discard half of the range in the y-direction.

Thus, with every query, the possible search area shrinks significantly in both dimensions.

Since the coordinate range is at most 10^9, and

$$$2^{30} \gt 10^9$$$

after at most $$$30$$$ queries, the rectangle becomes a single point, which must be Vibhaas’s position.

#include <bits/stdc++.h>
using namespace std;

#ifndef LOCAL
#define debug(...) 0x0
#endif

#define sz(x) (int)(x).size()
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()

using ll = long long;

string query(int x, int y) {
    cout << "? " << x << " " << y << endl;
    string res;
    cin >> res;
    return res;
}

void answer(int x, int y) {
    cout << "! " << x << " " << y << endl;
}

void solve() {
    int l_low = 0, l_hi = 1e9;
    int b_low = 0, b_hi = 1e9;
    for(;;) {
        int l_mid = (l_low + l_hi) / 2;
        int b_mid = (b_low + b_hi) / 2;
        string res = query(l_mid, b_mid);
        if (res == "HERE") {
            answer(l_mid, b_mid);
            return;
        }
        if (res.find("LEFT") != string::npos) {
            l_hi = l_mid - 1;
        }
        if (res.find("RIGHT") != string::npos) {
            l_low = l_mid + 1;
        }
        if (res.find("UP") != string::npos) {
            b_low = b_mid + 1;
        }
        if (res.find("DOWN") != string::npos) {
            b_hi = b_mid - 1;
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(nullptr);
    int T = 1;
    while (T--) {
        solve();
        cout << "\n";
    }
    return 0;
}

We are given the expression:

This can be factorized as:

So the problem reduces to:

Count the number of ordered pairs $$$(a, b)$$$ such that $$$(a+1)(b+1)$$$ is a perfect square.

Let:

Then:

$$$x,y∈[2,N+1]$$$

We need to count pairs $$$(x,y)$$$ such that $$$x⋅y$$$ is a perfect square.

For any integer, we can remove all perfect square factors from it.

Example:

$$$12=4⋅3→$$$ reduced form = 3

$$$18=9⋅2→$$$ reduced form = 2

Now observe:

Two numbers x and y will have $$$x⋅y$$$ as a perfect square if and only if their reduced forms are equal.

For every number $$$x∈[2,N+1]$$$

1. compute its reduced form (by removing square factors).
2. Count how many numbers have the same reduced form.
3. If a reduced form appears c times, it contributes $$$c×c$$$ valid ordered pairs.

We precompute answers for all $$$N≤10^5$$$

• Maintain a frequency array freq

• Iterate $$$x=2$$$ to $$$10^5 + 1$$$

  • Compute reduced form of $$$x$$$
  • Increase its count
  • Maintain running answer:

Store answer for each $$$N$$$

Time Complexity:

$$$O(N*logN)$$$

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100000;
#define ll long long
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    vector<int> red(MAXN + 2);

    for (int i = 1; i <= MAXN + 1; i++) {
        int x = i;
        for (int j = 2; j * j <= x; j++) {
            while (x % (j * j) == 0) {
                x /= (j * j);
            }
        }
        red[i] = x;
    }

    vector<ll> ans(MAXN + 1, 0);
    unordered_map<int, int> freq;

    ll cur = 0;

    for (int x = 2; x <= MAXN + 1; x++) {
        int r = red[x];

        cur -= 1LL * freq[r] * freq[r];
        freq[r]++;
        cur += 1LL * freq[r] * freq[r];

        ans[x - 1] = cur;
    }

    int T;
    cin >> T;
    while (T--) {
        int N;
        cin >> N;
        cout << ans[N] << '\n';
    }

    return 0;
}

...

...

...

...

...

...

...

...