o — ???

I have at times used o/z to keep track of the number of ones/zeroes in an array (often later realizing that I could simply have used cnt[2]). Note that this is a particularly cursed used of o as it looks like a 0 but is being used to indicate ones here, and I have indeed made mistakes because of this.

I have used o a handful of times for a random variable name I confirm o += 1 is awful 3/10

I use o for the order of a certain array, when you want to do some sort without messing with the original array. For example when doing MO i might do an implementation like that:

vector<pii> queries(q);

for(auto&[l,r] : queries)
    cin >> l >> r, r--;
    
vector<int> o(q);
iota(all(o),0);

sort(all(o),[&](int a, int b){
    const int ba = queries[a].ff/LEN, bb = queries[b].ff/LEN;

    if(ba == bb)
        return (ba&1) ? queries[a].ss > queries[b].ss : 
            queries[a].ss < queries[b].ss;
    return ba < bb;
});

The real unused character is _

For me, f and d are sometimes for dp, and g,h for the second and the third dp array.

o-??? r-right z-use me!!

You could use o for 1 to trick people into hacking your solutions thinking you have an off by 1 bug but it might violate code obfuscation rules and also requires hacking to be common in contests.

I use const modint<998244353> o=0;

I tend to use o to mean offset.

'o' for ones in zero and one array + odd even tracking also sometimes.

I name similarly. So do I think like an LGM?!

edit: this was meant to be a joke

o: odd

then I find out my code is failing because I wrote cnt = o instead of cnt = 0

If you really want to save as much time as possible on typing, you should be naming all of the variables 30+ symbols, so you train your typing speed while solving problems.

And after 10 years of CP you switch to 1 letter variables only to achieve maximum speed!

Am I the only one who always preferred using u as the first vertex and v as the second vertex?

It makes more sense to me since u comes before v in the alphabet and the edge is u -> v.

void dfs(int u) {
  for (int v : g[u]) {
    dfs(v);
  }
}

I use some of these, but everyone seems to have their own preferred variable and macro style. and i think That’s totally fine — as long as the code remains readable to you (and your teammates).

you use capital letters too when it gets real

I usually use k as a third iterator.

My most controversial one-letter variable naming's got to be using z for the third vertex (specifically, lca(u, v)). Come at me.

I use o — operator

I use o for "order", when ord is already taken

sometimes i define m as for mod purpose like m=1e9+7

If common small ones get used up, use their capital form.

o : ok

d — disrance and depth also s — sum t — temporary trash variable For me, in addition to above. In rest it all pretty much matches my usage of the letters haha

• r — row
• c — column
• l — lca
• f — first
• s — second, start
• e — end
• q — queue
• d — distance

v — vector

o — answer, output

There is something worse than #define int long long

constexpr int oo = 1e9;
constexpr ll OO = 1e18;

f also flow

l for list

For me:

d - depth (in tree problem)
f - father (in tree problem)
h - hash
m - map
p - mod (especially prime)
s - size (in tree problem) / set / stack

Well I think use s for sum is quite suitable

I usually use o for a iterator which is necessary but barely appears in any calculating of at least two variables lol

You can use ll like most of us. But if you really want to save time... You can try using '**o**'. If you say '**o**' is not even similar to long long or ll, then you can use L.

This is painfully accurate.

I've always assumed 'o' was for 'origin', but I've never actually used it. It's the emergency letter for when you run out of everything else.

Also, 'c' is frequently cost for me, especially in graph problems where w is already taken for weight.

So true lol

'o' can be count of odds, meanwhile i use 'q' for priority_queue

I also sometimes use o and e for even and odd counts.

What about one uppercase letter names? C for binomial, I and J for iterators, X for random intermediate value, A and B when the answer is A-B

v for value, w for walue

i for index, j for jndex XD

sometimes i use o for original, like ov — original value, nv — new value, but hardly use a single o as a name

I have always been advised against using single-letter variables.

I remember that I've recently posted similar comment. But turned out it was 10 years ago...

Here it is

I often use $$$t$$$ for second string, and $$$f$$$ for dp table.

you all cheaters should learn from this blog

Maybe in some data structures when we need to maintain two operations, 1 for ... and 2 for ..., we may use

int o;
cin >> o;
if(o == 1) { // first operation
} else { // second operation
}

Do you really think people who use #define int long long do so because long long is too long to type? We'd use #define ll long long then

Me:'o' for 'OMG What this'

f can be function, then g could be second function, and h third function.

I use d for

random name for me(in 2024.12~2025.7)(in order)(includes delta height ...) h y l z x now the same,except a,b,c,d added

so "z" is just useless -_-

and the funny thing is that I use "z" the most)

Great blog that helps me understand more about code habits. Here are some additional meanings (completely coming from my own style.)

p[] and s[] can also be used for prefixs and suffixes.

Sometimes, I use s[] to represent the size of a certain array or something similar to that.

z[] is sometimes used in the ex-kmp algorithm.

this is so accurate lmao

I sometime use p as prefix, s as sum and k as the third iterator

$$$\texttt{Variable 'o' stands for "Oh no, where did my bug go?"}$$$

I use the letter “o” to represent the abbreviation of “ok”, or simply because in some places using it looks round and cute.

This post reminded me of the exact same conversation i had years ago. Editoral for a problem used a variable named not o, not oo, but ooo. We were flabbergasted to say the least

Don't know about others ,but I find capital variable naming like A,M,N,O,I,J,CC,TT,MM,NN much handy xD , A, B -vectors
M,N — input size O- odd even counts I,J ->auto iterators CC ,TT — count . etc

Helpfull

Not one letter variables but I almost always use set<int> ste; and map<int,int> mpa;

I have used o a handful of times for a random variable name "ones" to count the number of ones in the string or array :)