Introduction and Course Structure

Loading...

En provenance du cours de Saint Petersburg State University

Competitive Programmer's Core Skills

21 notes

Saint Petersburg State University

Competitive Programmer's Core Skills

21 notes

During the course, you’ll learn everything needed to participate in real competitions — that’s the main goal. Along the way you’ll also gain useful skills for which competitive programmers are so highly valued by employers: ability to write efficient, reliable, and compact code, manage your time well when it’s limited, apply basic algorithmic ideas to real problems, etc. We start from the very beginning by teaching you what competitions there are, what are their rules, what specifics problems have, how to read problem statements, how to organize your work, and what you should and shouldn’t do. So it’s fine if you’ve never taken part in programming competitions before. We’ll focus on skills essential to competitive programming: inventing solutions and proving their correctness, estimating their running time, testing and debugging programs, how to benefit from structuring code. We’ll also cover basic algorithmic ideas: brute force search, dynamic programming, greedy algorithms, segment trees. On competitions, there are a lot of specific pitfalls, perilous to beginners — but that’s not to worry, as we’ll go through the most common of them: integer overflow and issues with fractional numbers, troubles of particular programming languages, how to get unstuck in general. And, you’ll hone all these skills by solving practice problems, which are just like problems on real competitions. You could use any of the following programming languages: C, C++, C#, Haskell, Java, JavaScript, Python 2, Python 3, Ruby, Rust, Scala. We assume that you already know how to write simplest programs in one of these.

À partir de la leçon

Programming Competitions

We'll begin with introduction to the world of competitive programming — the rules, specialties and helpful tips on taking part in competitions in general. In a separate lesson, we'll learn how to test programs: what kinds of test cases there are, how to organize the search for a bugtest, and particularly a method of automating testing called stress-testing.

Introduction and Course Structure5:32

Specifics of Programming Competitions11:22

Problem Example8:10

Steps in Solving a Problem6:16

Soft Skills4:39

Competitions Review8:32

Rencontrer les enseignants

Alexander S. Kulikov
Visiting Professor
Department of Computer Science and Engineering
Alexander Logunov
Competitive Programming Co-coach at SPbSU
Kirill Simonov
Competitive Programming Co-Coach
Aliaksei Tolstsikau
Senior lecturer
Faculty of applied mathematics and computer science, Belarusian State University Academic programs coordinator, Yandex, Judge of Belarusian olympiad in Informatics. Judge of Western subregional contest of Northern Eurasia. ICPC World finalist (2010), Topcoder collegiate challenge finalist (2007), Google code jam finalist (2008).

Hi, my name is Kirill Simonov.

I am a Competitive programmer Coach at

Saint Petersburg State University and I'm excited to welcome you in this course.

First of all, a couple of thoughts about

why learning competitive programming is good for you.

Competitive programmers write reliable and efficient programs.

And so, it might help you in getting a job

or if you're writing in a job which handles large amount of data.

Competitive programmers also are very motivated

to learn and practice different algorithms.

And if you didn't get enough time to do it before,

with competitive programming, you'll do it easier.

In competitions there is also a very limited time like two hours on a lot of problems.

And so, it will gain you time management skills.

So you could do things efficiently under stress in limited time.

And it all algorithms,

efficient programs and managing time is

things that could be very useful not just in life,

but also for example on job interviews,

where you get asked algorithm questions and need to answer rather quickly.

Another good side in competitive programming is that its

community consists of very motivated and smart people,

and so it's a lot of pleasure being in the community and communicating with them.

And also, solving problems is just fun and captivating by itself.

So competitive programming is both a mind sport like

chess and a way to gain useful knowledge for your everyday life and job.

In this course, we'll cover basic skills and

tricks which may be needed for

a competitive programmer and also some common algorithmic ideas.

So you could jump right at competitions when you've finished this course.

In the first week, we'll introduce what competitions and problems on them are,

what are their specifics,

and we'll also talk a bit more about how to test your programs.

On the second week, we'll talk in detail how to write code that it's correct.

We'll also talk about the idea of brute force algorithms,

which could solve basically any problem,

only it's always slow.

It's usually slower than needed,

but sometimes it's the right solution.

And we'll also talk about time complexity,

meaning then, how you could estimate,

view your program pass or not on the said meters.

On the third week, we'll discuss issues that could be

with handling numbers in programs and in competitions.

This is just really good to show up.

And, we'll also discuss how to, well,

if you get stuck on some program,

when you have an implementation

and don't know what to do about it, because it doesn't work.

We'll talk about a few tips about how to get out of the situation.

On week four, we'll talk about an idea of greedy algorithms,

which is first of all a common type of algorithms.

And there are also a lot of pitfalls.

Correct solution and incorrect solution here are separated by a very close gap.

So here it's important to get the right idea and prove it,

or see otherwise that it's correct.

We'll also talk about specifics of different languages.

So which one for example you should choose

for use in BETA programmings, in BETA programming.

And we'll also cover a useful latest structure called a Segment Tree.

On weeks five and six,

we'll talk about dynamic programming.

It's a very common idea,

many algorithms could be reduced to it somehow.

We'll cover some common problems for example edit distance,

which is, what you should do to get one string from the other by insertion,

deletions and swapping characters.

Knapsack problem and other problems which are classic and basic.

And along the course,

you'll horn your skills,

get at lectures by solving programming assignments,

which are very similar to actual competition problems.

So that's what we'll be doing in the course.

In the next video, we'll start with specifics of competitive programming.

Explorer notre catalogue

Rejoignez-nous gratuitement et obtenez des recommendations, des mises à jour et des offres personnalisées.

Coursera propose un accès universel à la meilleure formation au monde, en partenariat avec des universités et des organisations du plus haut niveau, pour proposer des cours en ligne.

© 2019 Coursera Inc. Tous droits réservés.

Télécharger dans l'App Store

Disponible sur Google Play