You just need to output the arrow that only appears once. That arrow is C2.

print("C2")

• I liked it!

One unusual thing about the statement is the presence of a emoji. More precisely, a smiling, emoji.

Okay, let's try to print a smiling emoji.

However, the output should be a string of characters and numbers, so we cannot do it directly.

There's one more suspicious thing in the statement — the $$$U+?=HAPPY$$$ equation. If we should print ?, what is the meaning of U?

U+ often indicates that an unicode of a special character is given — an international standardized encoding for characters, including emojis. A quick Google search can be used to obtain an unicode of any emoji, for example 😁 is represented as U+1F601 (in hexadecimal system). Outputing 😁 indeed works — however there are many possible answers.

Since both hexadecimal and decimal representation is commonly used, the checker was accepting smiling emojis in both formats.

print("1F601")

• I liked it!

What operation does "and" remind you of?

Here, "and" refers to bitwise AND. If we take the bits of $$$20260401$$$, we get $$$1001101010010011000110001$$$.

Now, notice that this is exactly as long as the string $$$\texttt{RXOEARDMTINHUSERMEDESIANT}$$$. This motivates us to look at the AND of these two strings: exactly those characters where the corresponding bit is $$$1$$$.

Doing so, we get the string $$$\texttt{READ}~\texttt{THE}~\texttt{REST}$$$. So we instead read the $$$0$$$ bits, and get $$$\texttt{XOR}~\texttt{MINUS}~\texttt{MEDIAN}$$$. Thus we simply output the XOR of the numbers minus their median.

#include <bits/stdc++.h>

using namespace std;

const int MAX = 200'007;
const int MOD = 1'000'000'007;

void solve() {
    int a[3];
    cin >> a[0] >> a[1] >> a[2];
    sort(a, a + 3);
    cout << (a[0] ^ a[1] ^ a[2]) - a[1] << '\n';    
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int tt; cin >> tt; for (int i = 1; i <= tt; i++) {solve();}
    // solve();
}

• I liked it!

Do the questions sound familiar?

Does the problem name sound familiar?

What happens when you submit the obvious answer "drive" for the first question?

If you submit "drive" the judge tells you:

4 out of 15 AI models gave the same answer as you (drive). This is not their most common answer, my condolences :(

This problem is a parody of Family Feud. However, instead of surveying 100 people, we surveyed 15 different AI models and gathered their answers. You have to figure out what is the most common answer among the AI models.

#include <bits/stdc++.h>
 
using namespace std;
 
int main(){
    vector<string> answers = {
        "",
        "walk",
        "no",
        "no",
        "no",
        "yes",
        "yes",
        "backwards",
        "seven",
    };
    
    int n;
    cin >> n;
    cout << answers[n];
}

• I liked it!

It is intentional.

use Dikjstra's algorithm.

The astute reader may have noticed that "Dijkstra" is spelled incorrectly as "Dikjstra" in the problem statement. As a reference to this Meta Hacker Cup problem, we can use Floyd Warshall with a loop order of i, k, then j to find the correct shortest paths.

#include <bits/stdc++.h>
 
using namespace std;
 
const int MX = 1e9;
 
int main(){
    int n, m;
    cin >> n >> m;
	vector<vector<int>> dist(n, vector<int>(n, MX));
	for(int i = 0; i<m; i++){
		int a, b, c;
		cin >> a >> b >> c;
		a--, b--;
		dist[a][b] = c;
		dist[b][a] = c;
	}
	for(int i = 0; i<n; i++){
		dist[i][i] = 0;
	}
	for(int i = 0; i<n; i++){
		for(int k = 0; k<n; k++){
			for(int j = 0; j<n; j++){
				dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
			}
		}
	}
    for(int i = 1; i<n; i++){
		if(dist[0][i] >= MX){
			cout << "-1\n";
		} else {
			cout << dist[0][i] << "\n";
		}
	}
}

• I liked it!

https://mirror.codeforces.com/contest/2095/problem/A

Subvert your expectations.

This problem is very, and I mean very, hard to solve in your head. Take your time.

All pieces are used. No piece needs to be flipped.

Subvert your expectations.

The answer is 5 digits long.

It you do it correctly, some things will line up.

Squint your eyes.

Through some work (and potentially assistance from image editing tools), you would be able to piece together the original untorn paper, which may look something like this:

Now squint your eyes and look down the middle row. Maybe cover the top and bottom part. You will see that the number $$$92136$$$ forms in the middle. This is the answer.

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

int main() {
    cout << 92136;
    return 0;
}

• I liked it!

It seems the answer was leaked somewhere. We have investigated thoroughly regarding this issue.

It seems a person had broken the rules. We quickly disqualified him before the contest ended.

Turns out this person managed to get the solutions to all problems from the editorial ahead of time. How is that even possible?

It seems this person leaked the answer through the very limited means of communication he had.

The person in question is AprilFoolsClairvoyant. Truly an anomaly.

The hidden string is bigchadjeff. You can now use this information to get Accepted.

Notes:

Some time during the contest, a user by the name of AprilFoolsClairvoyant started submitting correct editorial solutions to all problems. We recognized him, as we've dealt with him before in previous year's contest, where he submitted the first accepted solution to problem C with the assistance of time machines. You can find more information about this incident in the trivia section of problem C's editorial.

In our investigation, we noticed that he was submitting to problems in a weird, particular order. We have now found out that this was an attempt made by him to communicate the answer to other participants. He made 11 submissions in total, to problems in this order: B,I,G,C,H,A,D,J,E,F,F. He submitted to all problems, with a resubmission on F.

This spells out the answer (that coincidentally only has latin characters from a to j), which he once again obtained via the use of time machines. Such behaviour is unacceptable as time machines are prohibited by the codeforces rules, so we quickly disqualified him before the contest ended.

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

int main() {
    string s = "bigchadjeff";
    int tt;
    cin >> tt;
    while (tt--) {
        int i;
        cin >> i;
        cout << s[i-1] << '\n';
    }
    return 0;
}

• I liked it!

Does the image look familiar?

Did you click to the 2026 link on the announcement?

Well, that was actually a distraction. The problem is not about color blindness. Did you not read the problem name?

The image looks weird, why is that?

What could "double vision" refer to here?

This problem is a follow up on the last year's "blurred vision". However, as the name suggests, you need to use both of your eyes to solve it.

Specifically, the image is a autostereogram made out of the Ishihara Test in the rick roll video of the announcement. If you look at the image using the proper technique or use one of the online Autostereogram solvers, you would find the text "YU5zV2VS" embedded in the image.

If you haven't already, please try to see it without any tools.

#include <bits/stdc++.h>
 
using namespace std;
 
int main(){
    cout << "YU5zV2VS";
}

• I liked it!

Remember, you are a robot.

There are certain laws robots must follow.

Ensure the best possible outcome.

This problem can be solved using dynamic programming.

Because you are a robot, you must follow the three laws of robotics, which state that:

1. A robot may not injure a human being or, through inaction, allow a human being to come to harm.

2. A robot must obey the orders given it by human beings except where such orders would conflict with the First Law.

3. A robot must protect its own existence as long as such protection does not conflict with the First or Second Law

So the first priority is ensure minimal human damage, and because you were not given any orders from any humans, your second priority is minimizing damage to your own existence. Do keep in mind that all robots share a unified mind, so damage to any robot affects you as well.

Thus your objective is to first minimize the number of human casualties, then minimize the number of robot casualties. We can compute these values using dynamic programming on the tree.

Let

where:

• $$$x$$$ is the minimum number of human casualties,
• $$$y$$$ is the minimum number of robot casualties among all solutions that achieve the minimum $$$x$$$,

assuming the trolley starts at intersection $$$i$$$.

For each intersection $$$i$$$, consider all intersections $$$j$$$ such that $$$j$$$ is a child of $$$i$$$. Then,

where the minimum is taken in lexicographical order (first minimizing $$$x$$$, then $$$y$$$).

After computing all $$$dp[i]$$$, we reconstruct an optimal path.

Starting from the root (intersection $$$1$$$), repeatedly move to a child $$$j$$$ such that

Continue this process until reaching a leaf. This leaf is a valid answer. The time complexity of this solution is $$$O(n)$$$.

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

#define f first
#define s second
#define ll long long
#define pii pair<int,int>
#define pb push_back
#define mkp make_pair

const int MOD = 1e9+7; // 998244353;

vector<int> adj[200005];
pii dp[200005];
int a[200005];

void dfs(int node, int fa) {
	if (adj[node].empty()) {
		dp[node] = mkp(0,0);
		return;
	}
	dp[node] = mkp(2e9,2e9);
	for (auto it : adj[node]) {
		if (it == fa)continue;
		dfs(it,node);
		pii cur = dp[it];
		if (a[it] == 1)++cur.f;
		else if (a[it] == 2)++cur.s;
		dp[node] = min(dp[node],cur);
	}
	return;
}

int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	int tt;
	cin >> tt;
	while (tt--) {
		int n;
		cin >> n;
		for (int i = 1; i <= n; ++i) {
			adj[i].clear();
		}
		for (int i = 2; i <= n; ++i) {
			int x;
			cin >> x;
			adj[x].pb(i);
		}
		for (int i = 2; i <= n; ++i) {
			cin >> a[i];
		}
		dfs(1,0);
		int x = 1;
		while (adj[x].size()) {
			int y = -1;
			for (auto it : adj[x]) {
				pii cur = dp[it];
				if (a[it] == 1)++cur.f;
				else if (a[it] == 2)++cur.s;
				if (cur == dp[x]) {
					y = it;
					break;
				}
			}
			x = y;
		}
		cout << x << '\n';
	}
	return 0;
}

• I liked it!

First, click on the link to view the statement. Oh wait, we need to pass Codeforces's Cloudflare verification first. Simply click the checkbox and solve some CAPTCHAs, which are just clicking stop signs, typing words, etc.... Wait, since when do these things start having word games and math problems?

At some point the CAPTCHAs are getting so absurd it should be clear that it is not a real Cloudflare challenge page. In fact, solving these increasingly convoluted CAPTCHAs is the problem itself. After finishing all of them, you will be shown the actual problem statement which is trivial to solve.

If you've played the Robot game on neal.fun you should recognize what's happening pretty fast. If you have never played the game this problem was inspired from, I highly recommend playing it: https://neal.fun/not-a-robot/

#include <iostream>
 
int main() {
    std::cout << "Yes, I can attest to my status as a thoroughly validated, carbon-based biological entity.\n";
}

• I liked it!

void *my_malloc(size_t size) {
    if (void *ptr = HeapAlloc(GetProcessHeap(), 0, size ? size : 1)) return ptr;
    throw std::bad_alloc{};
}
void my_free(void *ptr) {
    HeapFree(GetProcessHeap(), 0, ptr);
}

void *operator new(size_t size, align_val_t al) {
    auto align = (uintptr_t)al;
    void *mem = ::operator new(size + align + sizeof(void *));
    void **ptr = (void **)(((uintptr_t)mem + align + sizeof(void *)) & ~(align - 1));
    ptr[-1] = mem;
    return ptr;
}
void operator delete(void *ptr, align_val_t al) noexcept {
    ::operator delete(((void **)ptr)[-1]);
}

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

This is because I have absolutely no idea what the code does or how it works. It might just not work at all. I am not responsible for any damages caused by it if you use it in your code (such as runtime errors or another bug causing even weirder TLEs).

#include <bits/stdc++.h>

using namespace std;
using namespace std::chrono;

nanoseconds alloc_time, dealloc_time;

void *alloc(size_t s) {
    auto t = high_resolution_clock::now();
    auto p = (void *)malloc(s);
    alloc_time += high_resolution_clock::now() - t;
    asm volatile("" ::"r"(p));
    return p;
}

void dealloc(void *p) {
    auto t = high_resolution_clock::now();
    free(p);
    dealloc_time += high_resolution_clock::now() - t;
}

int main() {
    auto c = alloc(0x1c);
    for (int i = 0; i < 40000; i++) {
        alloc(0x1c);
    }
    dealloc(c);
    for (int i = 0; i < 100000; i++) {
        dealloc(alloc(0x1c));
    }
    printf("alloc: %lld ms\n", round<milliseconds>(alloc_time).count());
    printf("dealloc: %lld ms\n", round<milliseconds>(dealloc_time).count());
}

alloc: 899 ms
dealloc: 0 ms

=====
Used: 904 ms, 1904 KB

#include <bits/stdc++.h>
#include <windows.h>

using namespace std;

void *operator new(size_t size) {
    if (void *ptr = HeapAlloc(GetProcessHeap(), 0, size ? size : 1)) return ptr;
    throw std::bad_alloc{};
}

void operator delete(void *ptr) {
    HeapFree(GetProcessHeap(), 0, ptr);
}

void *alloc(size_t s) {
    auto c = new char[s];
    asm volatile("" ::"r"(c));
    return c;
}

int main() {
    auto c = alloc(0x1c);
    for (int i = 0; i < 40000; i++) {
        alloc(0x1c);
    }
    delete[] c;
    for (int i = 0; i < 100000; i++) {
        delete[] alloc(0x1c);
    }
}

void *my_malloc(size_t size) {
    if (void *ptr = HeapAlloc(GetProcessHeap(), 0, size ? size : 1)) return ptr;
    throw std::bad_alloc{};
}
void my_free(void *ptr) {
    HeapFree(GetProcessHeap(), 0, ptr);
}

void *operator new(size_t size, align_val_t al) {
    auto align = (uintptr_t)al;
    void *mem = ::operator new(size + align + sizeof(void *));
    void **ptr = (void **)(((uintptr_t)mem + align + sizeof(void *)) & ~(align - 1));
    ptr[-1] = mem;
    return ptr;
}
void operator delete(void *ptr, align_val_t al) noexcept {
    ::operator delete(((void **)ptr)[-1]);
}

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

This is because I have absolutely no idea what the code does or how it works. It might just not work at all. I am not responsible for any damages caused by it if you use it in your code (such as runtime errors or another bug causing even weirder TLEs).

fn main() {
    let x: i32 = 1_000_000_000;
    let y: i32 = 1_000_000_000;
    println!("{}", x * y);
}

Because it won't even compile.

error: this arithmetic operation will overflow
 --> foo.rs:4:20
  |
4 |     println!("{}", x * y);
  |                    ^^^^^ attempt to compute `1000000000_i32 * 1000000000_i32`, which would overflow
  |
  = note: `#[deny(arithmetic_overflow)]` on by default

error: aborting due to previous error

Overflow!

$$$10^9 \times 10^9$$$ does not fit inside the i32 type which can only hold numbers up to $$$2^{31}-1$$$. To store large numbers like $$$10^{18}$$$, you'll need bigger integer types like i64.

fn test(v: Vec<i32>) -> usize {
    v.len()
}

fn main() {
    const N: usize = 1_000_000;
    let mut sum = 0;
    let v = vec![0; N];
    for _i in 1..=N {
        sum += test(v);
    }
    println!("{}", sum);
}

You guessed correctly! It won't compile.

error[E0382]: use of moved value: `v`
  --> foo.rs:10:21
   |
8  |     let v = vec![0; N];
   |         - move occurs because `v` has type `Vec<i32>`, which does not implement the `Copy` trait
9  |     for _i in 1..=N {
   |     --------------- inside of this loop
10 |         sum += test(v);
   |                     ^ value moved here, in previous iteration of loop
   |
note: consider changing this parameter type in function `test` to borrow instead if owning the value isn't necessary
  --> foo.rs:1:12
   |
1  | fn test(v: Vec<i32>) -> usize {
   |    ----    ^^^^^^^^ this parameter takes ownership of the value
   |    |
   |    in this function
help: consider cloning the value if the performance cost is acceptable
   |
10 |         sum += test(v.clone());
   |                      ++++++++

Types like Vec don't have the Copy trait to avoid accidental copying. So, it is moved into the test function. As you can see from the extremely helpful compile error messages, you moved v into a function during the first iteration of the loop, so you can't use it in the next iterations.

How to fix this? The compiler already told you the answer! You can either borrow the parameter (&Vec instead of Vec), or add .clone() to get an owned version of v. (And as the compiler message suggests, the second method will be slower.)

use std::io::{stdin, BufRead};

const N: usize = 100_000;

fn main() {
    let test_cases = 100_000;
    for _i in 0..test_cases {
        let a = vec![0; N];
        let n = stdin().lock().lines().next().parse();
        let mut sum: i32 = 0;
        for i in 0..n {
            sum += a[i];
        }
        println!("{}", sum);
    }
    // it is guaranteed that total sum of n is <= 100000
}

You guessed correctly again! It won't compile.

error[E0599]: no method named `parse` found for enum `Option` in the current scope
 --> foo.rs:9:47
  |
9 |         let n = stdin().lock().lines().next().parse();
  |                                               ^^^^^ method not found in `Option<Result<String, std::io::Error>>`

This is because a BufRead returns a Result<String, std::io::Error> when you read a line. The lines() method returns an iterator of lines. The first() method returns the first value of an iterator, which can be None. Its type is Option<Result<String, std::io::Error>>. Finally, the parse() method parses the string into a number, which may fail, so it returns a Result.

The correct code is to get the "success" values inside Options and Results! You can do it with unwrap (NOT RECOMMENDED). For example: let n = stdin().lock().lines().next().unwrap().unwrap().parse().unwrap();.

However, this is considered bad pratice, as you should always handle the error and none values properly.

fn main() {
    const N: usize = 5;
    let a = [0; N];
    a.fill(1);
    println!("{:?}", a);
}

Because it won't compile.

error[E0596]: cannot borrow `a` as mutable, as it is not declared as mutable
 --> foo.rs:4:5
  |
3 |     let a = [0; N];
  |         - help: consider changing this to be mutable: `mut a`
4 |     a.fill(1);
  |     ^^^^^^^^^ cannot borrow as mutable

Since you modify a, you need to declare it as mutable with let mut a = [0; N];.

Because endl isn't a thing in Rust.

By the way, println! is also quite slow. If you need to print many lines, consider using a BufWriter or converting all lines to strings first, joining those strings with "\n" then printing the joined string all at once.

Rust has the functions pow(), ilog(), ilog2(), etc. for integer types. These are pretty safe to use, since their results are either integers or rounded to integers so are precise. If you worry about overflowing, functions like checked_pow() return Option to help you check cases where integer overflows happen.

fn main() {
    assert_eq!(5i32.pow(2), 25);
    assert_eq!(69i32.ilog(3), 3);
}

fn main() {
    let v = Vec::<i32>::new();
    println!("{}", v.len() - 1);
}

Because of integer overflow.

thread 'main' panicked at 'attempt to subtract with overflow', foo.rs:3:20
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace

v.len() is an unsigned integer 0 and is the lowest number an unsigned type can represent. Attempting to subtract a positive value from it will result in an overflow.

fn main() {
    let a = 1;
    let b = 3;
    // we want to take a + b and bitwise & it with 3
    let result = a + b & 3;
    println!("{}", result);
}

The precedence of the + operator is higher than the & operator, so the operator + operates first, meaning a+b = 4 executes and then the & operator comes into play, so 4&3 executes and the output is clearly 0 for this.

Check out this to learn more about Rust operator precedence.

use std::collections::HashMap;
use std::io::{stdin, BufRead};

fn main() {
    const N: usize = 30_000;
    let mut mp = HashMap::<i64, usize>::new();
    for _i in 0..N {
        let x = stdin().lock().lines().next().unwrap().unwrap().parse().unwrap();
        *mp.entry(x).or_insert(0) += 1;
    }
    println!("{}", mp.values().max().unwrap())
}

Rust's HashMap by default uses a cryptographic hash function, which is also seeded by secure random numbers. This means it is extremely difficult to generate a hash collision in advance that blows up its complexity.

use std::collections::HashMap;

fn main() {
    let mut mp = HashMap::<i64, usize>::new();
    // add 1 to 5 to the map
    for k in 0..5 {
        *mp.entry(k).or_insert(0) += 1;
    }
    let mut cnt: usize = 0;
    // check how many numbers in the keys exist in the map
    for k in mp.keys() {
        if *mp.entry(*k).or_insert(0) != 0 {
            cnt += 1;
        }
    }
    // now print the size of the map
    println!("{} {}", cnt, mp.len())
}

Wrong, it's actually compile error.

error[E0502]: cannot borrow `mp` as mutable because it is also borrowed as immutable
  --> foo.rs:11:13
   |
10 |     for k in mp.keys() {
   |              ---------
   |              |
   |              immutable borrow occurs here
   |              immutable borrow later used here
11 |         if *mp.entry(*k).or_insert(0) != 0 {
   |             ^^^^^^^^^^^^ mutable borrow occurs here

In Rust, when you have a mutable borrow of a variable, then you cannot have other references to that variable, even immutable ones. The borrow checker of Rust is an extremely powerful feature, as it prevents many bugs (usually data races) that are caused by accidentally changing values while using them. You can learn more about references and borrowing by smashing me.

fn main() {
    const N: usize = 1_000_000;
    let mut s = String::new();
    for _i in 0..N {
        s = s + "ゑ";
    }
    println!("{}", s)
}

It's not $$$O(n^2)$$$! It's $$$O(n)$$$ actually.

This is because in Rust, the + operator of Strings consumes the value on the left hand side, while the right hand side is used to extend the buffer of the left string. This means that s = s + "ゑ"; is equivalent to pushing a string to s and then moving it to itself, without allocating a new String. This operation takes $$$O(1)$$$ amortized time.