Constructive. If every problem was constructive, i'd probably be a pupil

Bits

1995C - Squaring

1995B2 - Bouquet (Hard Version)

these are worst type of problem that I could imagine.

specifically problem using formula/math problem, like translate problem statement and then answer be like one line max(0, c[i-1] + ceil(log2(log2(a[i-1])/log2(a[i])))) * (k1-r)*x+(k2+r)*(x+1) where k1=min(c_x,m/x) and k2=min(c_{x+1},c/(x+1)) .. it's fucking insane actually

Graph, data structures and implementation

I don't like constructive ones

hard problems, but seriously, heavy implementation

I don't usually hate problems, I hate badly-written tutorials.

I hate bitmask problems.

implementation

Problems with no thinking or brute forcing and noticing a pattern which 99% of participants can't prove.

Geometry.

interactive...

Constructive and matrix implementation stuff

combinatorics and number theory

now that i think about this i only hate problems that are hard to implement i really never mind the topic i sometimes even solve geometry ...

number theory

DP: specifically plug, digit, bitmasks, and those where you have a complicated state and transition which often involve math.

IQ problems

bitset

Bit manipulation

Ad-hoc

Graph, problems with segment-tree/sqrt-decomposition and problems with fractional numbers.

Edit: And yeah, the most important. Games.

orz Implementation eric mathforces

flows and undirected graphs

Problems that are stolen from other sources

problems that i can't solve

Constructive/ad-hoc/guessing problems. Or when the proof is harder than the problem.

Ad-hoc problems in general.

Especially problems where you are given an array (or a binary/ternary/etc. string) and are asked to find the minimum number of operations to make the array satisfy a certain condition.

Data Structures.

When I'm coding for myself I love DS. When I'm coding for a contest I hate DS.

1. Problems with lots of corner cases that can't be generalized and require writing several huge IFs before\after core algorithm.
2. Problems where author expects people to solve it using a math formula\dp\something clever, but due to constraints it's possible to write a bruteforce solution in C++ (but not in other languages) which invalidates the whole point of the problem.

Graph problems really piss me off.

Bitmask and Interactive

Constructive problems first of all

Guess problems ( I mean not all of them are bad. If some observations lead you to the guess then this type of problem is fine. )

And math problems that are more suited for IMO or national mathematical rounds and you need to have knowledge of some theory that barely anyone knows.

And finally single trick pony problems (If you know it then you can solve it in 5 minutes. Otherwise good luck)

:v

Greedy+Games. With my slow brain and deterministic mindset combined, it's really hard to come up with an idea, assure that it would be correct, and keep that assurance solid enough so my mind could force itself to write the code. Or I'm just bad in heuristics-based stuff. :<

Problems that have strings or game theory. I always get super confused thinking about cases in Alice Bob problems.

interact problem

Anything that doesn't even slightly resemble a real world process.

I Hate Extensive and Long Implementation Problems :)

constructive problems , especially the ones which you need to generate a permutation which satisfies a random constraint

Casework problems.

if(a == b) {
    if(c + d <= 6969)
        a += 420;
    else if(b / 42 + c == 0) {
        a -= b * 69;
        if(a * c % 998244353 == 0)
            return true;
        else
            return false;
    }
    else {
        c -= b;
        if(b ^ d == 0xfadedeaeaea) {
            if(d & a == c)
                return true;
            else
                return false;
        }
        else {
            d ^= 0x6969696969;
            return (d + 42 == 0);
        }
    }
}
else {
    a = b * c % 998244353;
    if(a * d % 998244353 == 42069) {
        a *= d - 1;
        return (a == b - c);
    }
    else
        return (b + a == d ^ c);
}

Just.. ewww.

Those problems whose logic is pretty simple but have annoying edge-cases. Simple problems with many cases to consider and there is no pattern to use loop.

Geometry + Constructive + implementation

Constructives are the reason of me tanking the contest at which they appear especially at C.

brute force and greedy.

Greedy

Games and number theory

Geometry is shit

Dp Is Shit

Case work is Shit

DP. I hate DP :(

Constructive, combinatorics and very gross math problems

long code problems

ad-hoc stuff where 90% of the time the solution is guessable

I think the problems I like the least are problems that have way too much emphasis put on knowing some (relatively) hard algorithm or data structure, and otherwise the problem is pretty easy. This is even worse when such problems appear in onsite contests without internet access.

when you need to use some linear things on a graph or a tree.(for example:segment tree on graph)

geometry

games ofc, I cannot do optimally any case

dp+graphs... i love dp ...but when it gets merged with graphs i just hate it

I hate sigma problems.

Problems that i can't solve like C<D<E<F<G<H they take my entire time just to read and understand question then implement correctly, sometimes i think solving problems more than anyone did will make me better than them cause u will be familiar with ideas and implementation and you u dont have to waste your time reading, solving, implementing, debugging

String, heavy DS, heavy math

Math or data structures:(

Probability

for me its number theory

dp

1) Implementation heavy problem. (probably too many corner case are not my type.)
2) Every problem that require reconstruct the operations / rebuild the graph, rather than just asking number of operation.
may be, i am just saying all kind of problems i am weak at/

I would probably say the problems I struggle solving, which would probably mostly fall in implementation, and bitmasks. Bitmasks mostly because I am not too familiar with the topic and am still learning it, and implementation mostly because my program will fail some edge cases, and when solving such problems I always feel like diving into more particular cases and not getting a general solution. That is why, even when getting the right solution something feels wrong with implementation problems.

A more positive question I would have is what is your favorite topic ? I would say mine are number theory (I have more of a mathematical background than Computer science one) and maybe two pointers.

i like tree, actually i like everything but i m just stupid

Data Structures , Math

graph

Math problems, especially where solution time complexity is less than O(N), they are usually hard or you just have to know some specific math to solve them