AtCoder Grand Contest 025 will be held on Sunday (time). The writer is yutaka1999. This contest counts for GP30 scores.

Contest duration: TBD (about 2 hours)

The point values will be announced later.

Let's discuss problems after the contest.

# | User | Rating |
---|---|---|

1 | tourist | 3707 |

2 | Benq | 3672 |

3 | Radewoosh | 3627 |

4 | ksun48 | 3547 |

5 | Miracle03 | 3480 |

6 | ecnerwala | 3400 |

7 | peehs_moorhsum | 3384 |

8 | maroonrk | 3361 |

9 | sunset | 3338 |

10 | Um_nik | 3320 |

# | User | Contrib. |
---|---|---|

1 | 1-gon | 209 |

2 | Um_nik | 196 |

3 | YouKn0wWho | 192 |

4 | Errichto | 182 |

5 | awoo | 181 |

6 | sus | 180 |

7 | tourist | 175 |

8 | -is-this-fft- | 171 |

8 | SecondThread | 171 |

10 | Radewoosh | 170 |

AtCoder Grand Contest 025 will be held on Sunday (time). The writer is yutaka1999. This contest counts for GP30 scores.

Contest duration: TBD (about 2 hours)

The point values will be announced later.

Let's discuss problems after the contest.

AtCoder Grand Contest 024 will be held on Sunday (time). The writer is DEGwer. This contest counts for GP30 scores.

Contest duration: 130 minutes

The point values will be 300 — 500 — 700 — 1100 — 1200 — 2300.

Let's discuss problems after the contest.

AtCoder Grand Contest 023 will be held on Saturday (time). The writer is maroonrk. This contest counts for GP30 scores.

The point values (and duration) will be announced later.

Let's discuss problems after the contest.

We are planning to introduce a division system to AtCoder in the near future.

Here are our current plans (but this is tentative, we may change it based on your feedback):

The division cutoff is 2000. I think this is about the same as CF's 1900.

We'll hold div2 contests (called ABC) every week. Usually, 100 minutes and 5 tasks: 100, 200, 300, 400-500, 600-700. Rated for 0-2000.

Sometimes we'll hold div1 contests. There are two types of div1 contest: AGC and ARC. The first two tasks are shared with div2.

ARC: Usually 100 minutes and 4 tasks: 400-500, 600-700, 800-900, 1000-1200. Rated for 2000-2800.

AGC: Similar to current AGC. Rated for 2000-inf.

One major problem is that even strong people have to spend a few matches in Div2. Two "red performance" is good enough to reach Div1. Is it fine?

For example, it says that a gray coder solves a 200-point problem with probability 63%. Note that we use "estimated rating" instead of actual rating for this table (i.e., we don't subtract 1200 from newcomer's rating).

Please post here if you have some opinion about it.

Since nobody posts it, I do.

C: Can we solve it faster than ?

B: Is there a simple way to solve this? We want to count the number of integers that appear odd number of times in a given range. To do this, we can use bitset for frequent numbers and sweepline + data structure for rare numbers, but it looked much harder than some other tasks...

E: I assumed that the answer is either at most *N* or infinity. Why is this true?

G: Is there a solution that doesn't require reading papers (or at least reading the wikipedia article mentioned in the statement)? I heard that there's a paper that describes the solution.

AtCoder Grand Contest 021 will be held on Saturday (time). The writer is DEGwer. This contest counts for GP30 scores.

The point values will be announced later.

Let's discuss problems after the contest.

We've just rescheduled our contests.

Next Saturday, we'll hold a long (most probably 5 hours, but it is not finalized yet) contest on AtCoder. Note that the start time is unusual: please check here.

The problems are based on one of the problemsets of Petrozavodsk camp. If you are a participant of Petrozavodsk camp, please don't participate in this contest. And of course, please keep the problems secret!

This is a **rated** contest for everyone, and this contest **counts for GP30 scores**. If you are a Petrozavodsk participant and you care GP30 scores, please let me know. We'll make sure that you won't get disadvantages (please check here, we'll handle you as a writer, i.e., increase the value of Y by one).

The writers are japan02 team (yosupo, sugim48, sigma425).

Note that AGC 021 was postponed to avoid collision with an Open Cup round.

UPD: the contest is actually 5 hours. contest link

AtCoder will hold a new onsite contest called AtCoder World Tour Finals 2018.

If you get the top 30 places in AGCs (and maybe some other types of contests), you will get GP30 scores. Eight people with the highest total GP30 scores in 2018 (except for people under 18) will be invited to Japan, probably in February 2019. We will cover flights and hotels. There's no upper bound for the age. You can participate in the finals even if you are employed.

Please check the details here.

Here's the total GP30 scores in 2017:

Rank | Handle | Score |
---|---|---|

1 | tourist | 870 |

2 | Um_nik | 519 |

3 | W4yneb0t | 514 |

4 | LHiC | 480 |

5 | Petr | 417 |

6 | ksun48 | 347 |

7 | yutaka1999 | 331 |

8 | V--o_o--V | 292 |

UPD: Added detailed information at the bottom of https://atcoder.jp/post/171.

You are given the first *n* (or *n* + 1 if necessary) terms of a former power series *P*(*x*) = *c*_{0} + *c*_{1}*x* + *c*_{2}*x*^{2} + .... What operations can be performed efficiently?

Obviously,

*P*(*x*) +*Q*(*x*),*P*(*x*) -*Q*(*x*),*P*'(*x*), ,*kP*(*x*) for a given constant*k*, can be done in*O*(*n*).*P*(*x*)*Q*(*x*) can be done in*O*(*nlogn*) by FFT.can be done in

*O*(*nlogn*): Link, check problem Ecan be done in

*O*(*nlogn*): Link, check problem E*exp*(*P*(*x*)) can be done in*O*(*nlogn*): Link, check Figure 1, left: Link

Open: Can we do more complicated operations like

*P*(*Q*(*x*)),*P*(*x*)^{1 / k},*sin*(*P*(*x*)),*arcsin*(*P*(*x*)), etc.? Are there other important operations?Probably a bit related to the computation of : when we are given two big decimal number

*x*and*y*, can we compute*x*/*y*?

The onsite event of CODE FESTIVAL 2017 will start soon. There will be four contests during the event:

Final Round. This is the main contest.

All contests will have parallel rounds. Only Final will be rated (and corresponding parallel round will be rated too).

Check the schedule of the contests at https://atcoder.jp/.

UPD: Now the final standings is available at https://beta.atcoder.jp/contests/cf17-final/standings.

Congratulations to winners:

Does anyone use testlib on cygwin + g++?

It gives a compilation error at the 434th line:

`_setmode(_fileno(file), O_BINARY);`

``

I know two ways to fix this issue:

Comment out the 434th line. However, it disables this line and I'm not sure whether this is a good way.

Add <io.h> to testlib. However, it works only on Windows.

How to fix the compilation error in a better way?

CODE FESTIVAL 2017 Qualification Round C will be held on Sunday (time). The writers are sugim48 and wo_.

Contest Announcement will be posted later.

This is one of the three qualification rounds of CODE FESTIVAL. In total, 20 foreign students will qualify in three rounds (Check the official site for detailed rules). **If you are eligible for the onsite contest, please don't forget to fill the form at https://krs.bz/rhd-itm/m/codefes2017_en.** Please check the detail of the tournament at http://codeforces.com/blog/entry/53502.

The contest duration is 2 hours, and there will be 6 problems. The first 4 problems are mainly used for choosing domestic students and much easier than other tournament competitions. However, we added two more problems and we hope these are interesting and challenging enough for choosing 20 qualifiers. Note that there is no time penalty for incorrect submissions. The time penalty is MAX, not SUM.

The point values are 100 — 200 — 400 — 700 — 1600 — 1800. If you are unfamiliar with AtCoder System, 2*X*-point problem in AtCoder is as hard as TopCoder's d1 *X*-point problem.

Let's discuss problems after the contest.

CODE FESTIVAL 2017 Qualification Round B will be held on Sunday (time). The writers are maroonrk, snuke, and myself.

This is one of the three qualification rounds of CODE FESTIVAL. In total, 20 foreign students will qualify in three rounds (Check the official site for detailed rules). **If you are eligible for the onsite contest, please don't forget to fill the form at https://krs.bz/rhd-itm/m/codefes2017_en.** Please check the detail of the tournament at http://codeforces.com/blog/entry/53502.

The contest duration is 2 hours, and there will be 6 problems. The first 4 problems are mainly used for choosing domestic students and much easier than other tournament competitions. However, we added two more problems and we hope these are interesting and challenging enough for choosing 20 qualifiers. Note that there is no time penalty for incorrect submissions. The time penalty is MAX, not SUM.

The point values are 100 — 200 (100) — 500 — 700 — 1600 — 1600. If you are unfamiliar with AtCoder System, 2*X*-point problem in AtCoder is as hard as TopCoder's d1 *X*-point problem.

Let's discuss problems after the contest.

CODE FESTIVAL 2017 Qualification Round A will be held on Saturday (time). The writer is sugim48 and DEGwer.

This is one of the three qualification rounds of CODE FESTIVAL. In total, 20 foreign students will qualify in three rounds (Check the official site for detailed rules). **If you are eligible for the onsite contest, please don't forget to fill the form at https://krs.bz/rhd-itm/m/codefes2017_en.** Please check the detail of the tournament at http://codeforces.com/blog/entry/53502.

The contest duration is 2 hours, and there will be 6 problems. The first 4 problems are mainly used for choosing domestic students and much easier than other tournament competitions. However, we added two more problems and we hope these are interesting and challenging enough for choosing 20 qualifiers. Note that there is no time penalty for incorrect submissions. The time penalty is MAX, not SUM.

The point values are 100 — 200 — 400 — 700 — 1600 — 1600. If you are unfamiliar with AtCoder System, 2*X*-point problem in AtCoder is as hard as TopCoder's d1 *X*-point problem.

Let's discuss problems after the contest.

Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo!

CF Handle | Country | Semifinal |
---|---|---|

tourist | Belarus | 2 |

s-quark | China | 2 |

scott_wu | United States | 1 |

-XraY- | Russia | 1 |

Coder | Georgia | 2 |

qwerty787788 | Ukraine | 2 |

Um_nik | Russia | 2 |

ikatanic | Croatia | 2 |

rng_58 | Japan | 1 |

Xhark | South Korea | 1 |

PavelKunyavskiy | Russia | 1 |

Retired_MiFaFaOvO | China | 1 |

I heard that one of advancers from 3A withdrew (~~but I don't know who~~ W4yneb0t).

Let's discuss problems.

By the way, finally reached #1!

Two years ago, the Codeforces rating system was changed significantly. The system is published here.

Let's take a close look at the formula:

- We compute
*seed*_{i}from old rating, so it corresponds to the performances of all old contests. *m*_{i}is the mean of*seed*_{i}and actual place. Roughly speaking, 50% of it comes from old contests and 50% comes from the most recent contest.*R*corresponds to*m*_{i}. 50% of it comes from old contests and 50% comes from the most recent contest.- The new rating is
*r*_{i}+*d*_{i}= (*r*_{i}+*R*) / 2. 25% comes from the most recent contest and 75% comes from others.

I prefer smaller rating changes in a single contest, at least for negative direction. Some reasons are:

Why do you put 25% weight on the most recent contest, even for experienced contestants (say, 100+ contests)? However, I agree that if the weight is smaller, it is too time-consuming to raise the rating for newcomers, which can be frustrating. In Glicko (an improved version of Elo), you are assigned a value called

*RD*. This value represents how inaccurate your rating is, and when*RD*is small, your rating change is smaller. You start from a very high*RD*, and if you keep competing, this value gradually decreases.It is possible that someone suddenly becomes stronger in a short period of time. However, the opposite is not true. Yes, if you don't practice, you may gradually decline, but this is much slower. When someone gets very bad performance, it is natural to think that it was because of a bad luck, not because of actual strength.

It is simply demotivating to lose way too much rating because of a single failure.

It seems there was "rating cap" in the old system. For example look at this. His rating changes in #270 and #318 were roughly the same.

What do you think?

**UPD.** Suggestion for the new formula.

I think slight modification is enough. In the current system, we use

*d*_{i} = (*R* - *r*_{i}) / 2

Change it to

*d*_{i} = *f*(*k*)·(*R* - *r*_{i})

where *k* is the number of contests you've participated (so, *k* = 0 for newcomers).

I suggest *f*(∞) = 1 / 5, and to compensate that *f*(0) should be a bit bigger. One possible explicit formula is:

https://r.recruit-jinji.jp/code_fes/us/index.html

Details will be announced in early August. In Japanese website, it says there will be 20 slots for international students.

According to Japanese website, the finals will be 25th-26th in November.

AtCoder Grand Contest 018 will be held on Sunday (time). The writer is maroonrk.

The point values will be 300 — 700 — 800 — 1100 — 1600 — 1700.

Let's discuss problems after the contest.

Recently I solved an interesting constructive task. Can you solve it? I'll reveal the source a bit later.

*N*(*N* + 1) soccer players stand in a row. The height of the *i*-th player is *h*_{i}. No two of them are of the same height.

Sir Alex wants to remove *N*(*N*−1) players from this row leaving a new row of 2*N* players in which the following *N* conditions hold:

- No one stands between the two tallest players,
- No one stands between the third and fourth tallest players,
- No one stands between the two shortest players.

Find one possible way to achieve this.

Constraints: 2 ≤ *N* ≤ 500, 1 ≤ *h*_{i} ≤ 10^{9}, *h*_{i} are pairwise distinct.

I couldn't find a place to discuss this.

When will we get results? Is anyone confident with B or F?

AtCoder Grand Contest 017 will be held on Sunday (time). The writer is semiexp.

The point values will be 200 — 400 — 1000 (500) — 1100 — 1200 — 1600.

Let's discuss problems after the contest.

AtCoder Grand Contest 016 will be held on Sunday (time). The writer is sugim48.

The point values will be 300 — 700 — 700 — 1000 — 1400 — 1600.

Let's discuss problems after the contest.

**UPD**: Now the editorial (check page 5) is ready.

I'll add some quick comments here.

A.

Try all characters from 'a' to 'z', and assume that we want to get a string that consists only of this character. What greedy strategy should we follow?

B.

Suppose that there are *C* colors in total. Then, each *a*_{i} must be either *C* or *C* - 1, and it means that the difference between the maximum and the minimum is at most one. Do some case-analysis using this fact.

C.

Suppose that *H* is not a multiple of *h*. Put a positive number in a cell if its row-number (0-based) is a multiple of *h*, otherwise put a negative number. Can you choose the "positive number" and the "negative number" properly?

D.

Create a new cell that keeps the xor of all elements. Each operation can be considered as a swap between this cell and another element in the sequence. Reduce it to a graph problem.

E.

Can you get YES/NO for a given pair of vertices (or more generally, a given set of vertices) in *O*(*M*)? Restate it in terms of graphs, then find an *O*(*NM* + *N*^{3}) solution.

F.

The task is about grundy numbers. Can you get *O*(*bell*_{number}(*N*)) solution by trying all possible grundy-number sequences? Can you reduce it to *O*(3^{N}) by DP?

```
x = 0;
while(x < 1){
y = x;
x += rand(); // returns a real number between 0 and 1, uniformly at random
}
```

What is the expected value of y?

It's not very hard, but the result is surprising.

Codeforces (c) Copyright 2010-2021 Mike Mirzayanov

The only programming contests Web 2.0 platform

Server time: Oct/20/2021 04:28:00 (f1).

Desktop version, switch to mobile version.

Supported by

User lists

Name |
---|