Progsity
CoursesLearnFreePlaygroundOnline JudgeContestsQuiz & Exams
Log inStart free
Progsity

Code your future, today!

Address: 128/2 East Tejturi Bazar, Tejgaon
Dhaka 1215, Bangladesh

Phone: +880 1844-287496

Email: support@progsity.io

Platform

  • Courses
  • Quiz & Exams
  • Road to FAANG
  • Programs
  • Online Judge
  • Contests
  • Host a contest, free
  • Playground
  • FAQ

Formats

  • Live Courses
  • Recorded Courses
  • Bootcamps
  • Institutional Training

Community

  • Ambassador Program
  • Events

Company

  • About
  • Contact
  • For Institutions
  • Policies
Online compilersCC++Python 3JavaJavaScript (Node.js)TypeScriptGoRustPHPRuby

© 2026 BWJ Tech Ltd. All rights reserved.

Progsity is a product of BWJ Tech Ltd., a company registered in Bangladesh (Reg. No. C-209121/2026).

HomeCoursesCompetitive ProgrammingCompetitive Programming for Beginners
Competitive ProgrammingLive + RecordedBeginnerRoad to FAANG · Phase 1

Competitive Programming for Beginners

Just started university and never coded? Begin from absolute zero in C and grow into a confident competitive programmer: logic, DSA, and real contest problem-solving.

Lessons: English + Bangla
Abu Jafar Md Jakaria

Abu Jafar Md Jakaria

Founder & CEO, Progsity

C and C++ Basics
DSA Foundations
Contest Problem Solving
Live Classes + Recordings
Bangla and English Support
Completion Certificate

7-day refund if you have completed under 20% of the course.

This course includes:

  • 30+ Live Classes
  • 25+ Programming Contests
  • 65+ Hours of Video
  • Certificate of Completion

Stack

Tools & Technologies

CLanguage
C++Language
GNU Compiler Collection (GCC)Tool
Visual Studio CodeTool
CodeforcesPlatform
AtCoderPlatform
CSES Problem SetPlatform
GitTool

Included

What’s Included

  • 30+ live classes

    Live sessions with the instructor, covering everything from your first C program through graphs and dynamic programming. Ask questions during class, and every session is recorded for later.

  • 25+ programming contests

    Timed contests run regularly through the course, so you get used to solving under real contest conditions well before your first rated round.

  • 65+ hours of video

    Full video coverage of the syllabus, taught in Bangla with all code and terminology in English. Watch at your own pace and rewatch whenever you need to.

  • 300+ practice problems

    Curated problems after every topic, each with hints and a worked solution, so you are never stuck without a way forward.

  • Progsity Playground

    An in-browser editor for C and C++. You can start writing and running code on day one, before setting anything up on your own machine.

  • Assignment feedback

    Submit your solutions and get specific comments on what to fix, rather than a simple pass or fail.

  • Weekly doubt-solving and office hours

    A weekly live session for questions on concepts and problems, plus weekday office hours when you need one-on-one help.

  • Batch community

    A group for your batch where you can ask questions at any hour, compare approaches with others, and keep pace with the rest of the class.

  • Lifetime access

    One payment covers the course for good, including any lessons or problem sets added later.

  • Certificate of completion

    Awarded once you finish the course and the final assessment. Every certificate carries a public verification link you can share on your CV or LinkedIn.

Practice

Where the practice actually happens

Watching lessons is the easy part. These two decide whether you are still solving problems in month three.

Progsity Playground running a C program in the browser, with the code editor on the left and the output panel on the right showing Hello, World! and an Accepted verdict.
Try it yourself

Progsity Playground

Run C and C++ straight in the browser, editor on one side, output and standard input on the other. Nothing to install, so trying an idea never waits on a working compiler.

The Achievements page showing level and XP progress, current and best streak, and the badge collection.
A ninety-day activity calendar where darker squares mean more XP earned that day, above the weekly leaderboard.

XP, streaks, badges and a weekly leaderboard

Every lesson, quiz and solved problem earns XP, which raises your level and unlocks badges, sixteen of them, from First Steps to a hundred-day streak. Each week you also see where you stand against the rest of your batch.

Certificate

Certificate & Career Outcomes

Certificate of Completion

Awarded upon successful course completion

Certificate of Completion

A completion certificate can recognize structured progress through the course, including core programming fundamentals, problem-solving practice, and contest preparation milestones.

Career Roles

Software Engineering InternICPC and NCPC contestantJunior Software Engineer

Details

About this course

A structured overview of what this course covers, how the learning path is organized, and what outcomes to expect.

Your first year of university is the perfect time to start competitive programming, and this course is built exactly for that moment.

You don't need any prior coding experience. We start from the very first line of C code (what a compiler is, how a program runs) and take you step by step all the way to Data Structures & Algorithms and real contest-level problem solving.

Competitive Programming (CP) is the single best way to sharpen your logical thinking, ace your university CS courses, crack technical interviews at top companies, and stand out in programming contests like ICPC, Codeforces, and the National Collegiate Programming Contest (NCPC).

This is not a "watch and forget" course. Every concept is followed by hands-on problems on online judges, weekly practice sets, and a problem-solving mindset that you'll carry for your entire career.

What makes this course different:

  • Built for the absolute beginner, no assumed knowledge.

  • Taught in Bangla, with all code and terminology in standard English.

  • Maps directly to your first-year CS syllabus (C, data structures).

  • Every topic comes with curated practice problems and editorial-style solutions.

  • A roadmap from "Hello World" to your first real Codeforces rating.

By the end, you'll be able to read a problem statement, design an algorithm, analyze its complexity, write clean C code, and submit a correct solution, confidently and on your own.

Fit

Fit & prerequisites

A quick check before you enroll: what you should already know, and who will get the most value from this course.

Prerequisites

Requirements

  • A laptop or desktop computer with internet access
  • Windows, macOS, or Linux is fine
  • No prior programming knowledge is required
  • Basic comfort using files, folders, and a code editor
  • High-school level math and logical thinking
  • Willingness to practice daily: solving problems is how you actually learn
  • Time for short, consistent practice sessions each week

Audience

Who this course is for

  • First-year university students (CSE, EEE, or any major) who are brand new to programming
  • Beginners who want a structured start
  • Anyone who tried coding before but never built a strong foundation
  • Students aiming for university programming contests, ICPC, or a future software career

Faculty

Your instructor

Abu Jafar Md Jakaria

Abu Jafar Md Jakaria

Founder & CEO, Progsity

Jakaria is the founder and CEO of Progsity, building structured EdTech experiences for Bangladeshi students. He is a Senior Lecturer in the Department of Computer Science and Engineering at Metropolitan University, where he teaches programming and guides students through hands-on competitive programming and software development. A serious competitive programmer himself, with over 150+ contests participated in and 3500+ problems solved. Beyond teaching, he founded BWJ Tech Ltd., OrByte Labs, DesnDev Tech, and ShohozDeal Ltd., bringing real industry leadership and engineering experience into every lesson. He believes most students don't fail at CP because of intelligence, they fail because of structure. Competitive Programming for Beginners is built to fix exactly that.

Next step

Continue the Road to FAANG path

When you finish this course, the next step stays clear and calm.

Next phase coming soon

This step is part of the path, but enrollment is not open yet.

Coming soon

Enroll

Ready to start learning?

Competitive Programming for Beginners

From ৳3,999

৳3,999

Outcomes

What you'll learn

  • Write, compile, and debug C programs from a blank file, with no prior coding experience
  • Turn a problem statement into working code using variables, conditions, loops, and functions
  • Work confidently with arrays (1D and 2D), strings, pointers, and structs
  • Write shorter, faster solutions in C++ using the STL: vector, map, set, sort, stack, queue
  • Read Big-O and judge whether your approach fits the time limit before you submit
  • Implement the core data structures yourself: stack, queue, linked list, tree, hash table, graph
  • Apply the algorithms contests test most: binary search, sorting, recursion, BFS, DFS, greedy, and introductory DP
  • Get your first Accepted on Codeforces, and understand the verdicts you get after that
  • Solve 300+ curated problems and build a public repository of your solutions
  • Take part in university contests, NCPC, or an ICPC preliminary with a real foundation

Curriculum

Course content

24 modules · 152 lessons

What Is Programming? How a Computer Thinks
Watch free
What Is Competitive Programming & Why Start in First Year
ICPC, Codeforces, NCPC: A Tour of the CP World
How to Get the Most Out of This Course (Study Plan)
Welcome: What You'll Get from This Course (Course Roadmap)
Watch free
Quiz: Check Your Understanding
Compiler, IDE, Editor, What's the Difference?
Watch free
Setting Up Your Machine: VS Code + GCC (and the Progsity Playground)
"Hello, World!", Your First C Program, Line by Line
Watch free
How a Program Compiles & Runs (Behind the Scenes)
Online Compilers & Creating Online Judge Accounts (Codeforces, CodeChef)
Assignment: Print Your Own Introduction
Quiz: Setup Checklist
What Are Variables & Why We Need Them
Data Types in Depth: int, long long, float, double, char
printf: Output Formatting Mastery
scanf: Reading Input (and the & Mystery)
Constants, Comments & Keeping Code Readable
Assignment: A Simple Calculator (Add, Subtract, Multiply, Divide)
Quiz: Variables & I/O
Arithmetic Operators & the Integer Division Trap
Relational & Logical Operators
Assignment, Increment & Decrement
Operator Precedence & Associativity
Type Casting: int vs double
Practice Set: 8 Basic Math Problems
Quiz: Operators & Expressions
if, else if, else
Nested Conditions & Common Mistakes
When to Use switch-case
The Ternary Operator
Practice: Even/Odd, Max/Min, Leap Year, Grade Calculation
Quiz: Conditionals
The for Loop: In Depth
while & do-while
break & continue
Nested Loops & Pattern Printing
Thinking in Loops: Sums, Factorial, Prime Check
Watch free
Practice Set: 12 Loop Problems
Quiz: Loops
What Are Functions & Why Split Your Code
Parameters, Return Values & Scope
Pass by Value: C Copies Everything
Recursion: A Function That Calls Itself
Watch free
Recursion Practice: Factorial, Fibonacci & Sum of Digits
Practice: Recursion Warm-up
Quiz: Functions & Recursion
What Are Arrays & Why We Need Them
Traversal Patterns: Sum, Max/Min, Count, Reverse
Linear Search & Frequency Counting
2D Arrays & Matrices
Out-of-Bounds & Uninitialized Arrays: the Bug Parade
Practice Set: 12 Array Problems
Quiz: Arrays
char & ASCII: Letters Are Numbers Too
Strings: char Array + '\0', and Reading Input Safely
string.h: strlen, strcpy, strcmp, strcat
String Problems: Palindrome, Reverse, Vowel & Word Count
Practice: Palindrome, Reverse, Vowel Count, Anagram
Quiz: Strings
Memory & Addresses: A City of Numbered Boxes (& and *)
Watch free
Pointers: Declare, Dereference & NULL: Picture by Picture
Pointers & Arrays: arr[i] Is *(arr + i)
Pass by Reference: The Swap That Finally Swaps
Dynamic Memory: malloc, calloc, free
Segfault, Dangling & Wild Pointers: The Bug Gallery
Practice: Pointers
Quiz: Pointers & Memory
struct: Building Your Own Data Type
struct Arrays & structs with Functions
typedef, Nested structs & Organizing Code
Where structs Shine in CP: Point, Student, Edge
Assignment: Student Marks Management Mini-Project
Quiz: Structs
Why Everyone Uses C++ in CP: Your First C++ Program
C vs C++ Side by Side: Your C Knowledge, New Names
References: The Pointer's Polite Sibling
Function Overloading, Default Arguments & const
Fast I/O: Contest Essentials
Practice: Rewrite Your C Toolkit in C++
Quiz: From C to C++
vector: The Array That Grows Itself
Watch free
vector in Depth: 2D vectors, Initialization & Functions
C++ string: Goodbye, char Array Pain
pair, auto & Range-based for: Clean Modern C++
set & multiset: Sorted, Unique, Automatic
map: A Frequency & Lookup Table for Anything
stack & queue: LIFO and FIFO in Practice
priority_queue & deque: The Specialists
Which Container When: The Complexity Cheat Sheet
sort: Sorting in One Line (Comparators & Lambdas)
Watch free
binary_search, lower_bound & upper_bound
The STL Toolbox: reverse, unique, accumulate & Friends
Build Your Own CP Template
What Does "Fast Code" Mean: Why Complexity Matters
Watch free
Big-O Notation, Made Simple
Recognizing O(1), O(log n), O(n), O(n log n), O(n²)
Reading Time Limits & Constraints in Contests (How Many Operations per Second?)
Space Complexity & Memory Limits
Quiz: Which Code Has Which Complexity
Linear Search
Binary Search: In Depth
Watch free
Common Bugs in Binary Search Implementations
Binary Search on Answer (Introduction)
Practice Set: Searching
Quiz: Searching
Bubble, Selection & Insertion Sort (Building Intuition)
Merge Sort & Divide and Conquer
Watch free
Quick Sort, and Why You Just Call sort()
Sorting as a Problem-Solving Tool
Practice Set: Sorting
Quiz: Sorting
Understanding the Recursion Tree & Call Stack
Generating Subsets & Permutations
The Backtracking Template
N-Queens & Maze Problems (Introduction)
Practice: Recursion & Backtracking
Quiz: Recursion & Backtracking
Primes & the Sieve of Eratosthenes
GCD & LCM (Euclidean Algorithm)
Modular Arithmetic & Handling Overflow
Fast Exponentiation (Introduction)
Factorization Basics
Practice Set: Number Theory
Quiz: Number Theory & Math
Stack: Concept & Array Implementation
Watch free
Queue & Circular Queue
Singly Linked List: Nodes, Insert, Delete
Doubly Linked List (Introduction)
Choosing the Right Structure for the Job
Practice: Bracket Matching & More
Quiz: Linear Data Structures
Tree Terminology & Binary Trees
Tree Traversal: Inorder, Preorder, Postorder
Binary Search Tree (BST)
Hashing & Frequency Arrays: Why They're So Powerful
Watch free
Practice: Trees & Hashing
Quiz: Trees & Hashing
What Is a Graph: Adjacency List & Matrix
BFS: Breadth-First Search
Watch free
DFS: Depth-First Search
Watch free
Connected Components & Simple Shortest Paths on Grids
Practice: Graphs
Quiz: Graphs
Greedy Thinking: When It Works, When It Doesn't
Introduction to Dynamic Programming (Fibonacci, Coin Change)
Watch free
How to Read Problems & Pick an Approach in Contests
Debugging & Catching Edge Cases
Where to Go Next: Your CP Roadmap (Growing Your Rating)
Final Practice Contest (5 Problems)
Final Quiz
Capstone Assignment: Solve & Submit Your Own Mini-Contest

FAQ

Frequently asked questions

No. The course starts at the very first line of C: what a compiler is, how a program actually runs, and how to write and run your first one. Everything after that builds on what came before, so nothing is assumed.
Both, and it is fully online. Live classes follow the batch schedule and begin on 5 September 2026, so you move through the course alongside your cohort. Every class is recorded, and the 65+ hours of video are yours to watch at your own pace, whenever it suits you.
Both, in that order. C keeps memory and logic visible, which is what builds a foundation you can stand on. Once that is in place the course moves into C++ and the STL (vector, map, set, sort, stack, queue) which is what competitive programmers actually write in a contest.
Yes. Anything you miss live is waiting as a recording, and about an hour a day of steady practice is enough to stay with the batch. Consistency matters far more here than long sessions once a week.
Classes and explanations are in Bangla. All code, keywords, and technical terms stay in standard English, so you are not learning a translated vocabulary you would have to unlearn the moment you open a real problem statement.
Every practice problem ships with hints and a worked solution, so you always have a way forward. Past that there is a weekly live doubt-solving session, office hours on weekdays, and your batch community where you can ask at any hour.
That is what it is built for. The DSA topics, the 300+ practice problems, and the 25+ timed contests all point at the same skill: read a problem, pick an approach, and write a correct solution before the clock runs out.
bKash and Nagad are both accepted for this course. Once your payment is confirmed the course appears in your dashboard, and it stays there for life.
Yes, once you finish the course and the final assessment. Every certificate carries a public verification link, so anyone reading your CV or LinkedIn can check it for themselves.
You can ask for a full refund within 7 days of enrolling, as long as you have completed less than 20% of the course. After that the enrolment is final. Approved refunds go back to the same bKash or Nagad account you paid from, usually within 7 working days.
Self-learners who want a structured path from zero to Data Structures & Algorithms
  • Working developers who want to sharpen logic and speed
  • Bilingual learners who prefer English and Bangla support