Greetings Codeforces!

This year, that pride comes with something new: some of India's strongest competitive programming communities are stepping up to help the next generation make the same leap. IIT Roorkee, IIT BHU, IIT Delhi, IIIT Hyderabad, IIT Indore, IIT Kanpur, IIIT Delhi, IIT Hyderabad, IIT Madras, IIT Kharagpur and IIIT Bangalore will each be hosting one week of this year's camp — several of them home to teams heading to the World Finals themselves. Each host college will also conduct a class on a topic relevant to their week's contest, so you're not just solving problems set by these communities, you're learning directly from them. The people setting your problems and running your contests this year are drawn from the very communities pushing India towards the top of competitive programming. If that isn't motivation to give this camp everything you've got, we don't know what is.

With that, we're proud to open registrations for the Indian ICPC Camp 2026, proudly sponsored by Go For Gold (powered by NST), organized jointly by leading Indian institutes including IITs, NITs, IIITs and BITs. This camp is a continuation of last year's massively successful edition, which saw participation from over 3,000 teams across India.

What's New This Year

• World Finalist-hosted weeks: Several of this year's ICPC World Finals teams from India will each conduct one week of the camp — problems, contest, and post-contest discussion, run by people who just earned their seat at the World Finals.
• A tighter, sharper camp: We're running several weeks this year, so every week counts.

Schedule & Weekly Structure

• Contest window: Several weeks (exact dates to be announced via Discord/WhatsApp). Contests every Sunday, 2 PM – 7 PM IST (unless otherwise mentioned via Discord/WhatsApp). Ranklist freeze after 4 hours.

Each week of the camp will follow a structured learning timeline:

• Tuesday — Class on a topic (Div 1 + Div 2)
• Friday — Homework Discussion (questions given in class)
• Sunday — Contest
• Next week Thursday — Contest Discussion

Note: The first lecture will be conducted on 11th August (Tuesday). The first contest will be held on 16th August.

Educational Sessions

Alongside contests, each week's host college will conduct a topic-focused class tied to that week's contest. To cater to different skill levels, the educational sessions will be split into two divisions (Div 1 and Div 2). These will cover advanced algorithms, data structures, and problem-solving strategies relevant to the week's problem set, taught by some of India's best competitive programmers, including ICPC World Finalists and Codeforces Grandmasters. For the educational sessions, we have this channel GoForGold-NST, all the streams will be on this channel

Div 1 Topics

Div 2 Topics

Contest Rules

We'll be following these (mostly) standard ICPC Rules for all contests unless otherwise specified:

• Contests will be held weekly every Sunday from 2 PM – 7 PM IST. There will be two separate contests held for different divisions (Div 1 and Div 2). To be eligible for Div 1, at least one team member must have max rating >=1900.
• Teams of up to 3 people.
• 3 PC format.
• We highly recommend using only a team notebook for reference. — Can be a PDF or a repo, or a folder with the files, but prepared before the contest. In case you don't have any such material prepared, a good starting resource would be to use KACTL as is. It is a great notebook used by many WF teams. And if you're new and not very comfortable with notebooks like KACTL, feel free to use cp-algorithms for more familiar code snippets. However, note that cp-algorithms contains a lot more information than you would be normally allowed to carry in a notebook. Experienced teams are expected to stick to a team notebook.
• Since we understand most new teams do not have a notebook, we will allow these two aforementioned sites to be used during the contest. Please note, you are only allowed to use these sites, you are not allowed to open any other site, even if it's linked within these two:
  — KACTL
  — cp-algorithms
• You can also use the internet for looking up language documentation (and the github/hosted notebook if you don't have it on local). Please restrict yourself to the following sites for documentation:
  — C/C++ → cppreference.com / cplusplus.com/reference
  — Python → Python Docs
  — Kotlin → Kotlin Docs
  — Java → Java SE 17 Docs
• Copy-pasting code from the above is allowed (unlike ICPC regionals/WF where you must type it out).
• No Googling or using other sites (e.g., OEIS, past submissions, random blog posts).
• No use of AI/LLM based tools.
• Ranklist freeze after 4 hours.

Fair Play Rules:

• AI/LLM tools/Use of internet other than mentioned websites are strictly forbidden.
• If plagiarism is detected in any contest, that team will be removed from the final camp ranklist (even if they participated in other contests fairly).
• While we can't detect all cheating, we trust you to follow the rules, respect the competition and peers, and use this camp for learning and growth. We'll run background similarity checks to identify and remove violations.

Rating & Performance

Each team's performance in a contest is calculated as:

Where: * $$$P$$$ = performance score * $$$n = \max(50, \text{number of contest participants})$$$ * $$$\text{place}$$$ = one-indexed rank of the team

Note: A team that does not participate in a contest will automatically score 0 points for that round.

Team Rating: Based on performance over all contests held during the camp, the lowest two performances are discarded, and the remaining scores are summed to compute the team's final rating. Prizes will be distributed based on this final rating. Teams are allowed to skip up to two contests during the camp.

Prizes

Only current college students form same college are eligible for prizes. The details about prizes will be announced later on whatsapp group or discord server.

About Go For Gold

The Go For Gold campaign, powered by NST, is a long-term initiative to make India a global force in competitive programming. With structured mentorship, community-driven camps, and national collaboration, it aims to propel India towards winning its first-ever ICPC medal in the coming years. By participating in Indian ICPC Camp 2026, you are directly contributing to this vision — and this year, you'll be learning directly from the teams carrying that vision to the World Finals.

How to Join

• Join this Codeforces group: https://codeforces.me/group/wlb0UYQSQF/join
• Fill the Registration Form (only one participant per team should register).
• Join the Discord Server for announcements, discussions, and post-contest analysis.
• Join the WhatsApp Discussion group.

Making Teams:

• Go to Codeforces Teams.
• Click "Create new team." Put in your team name. Note that this MUST match the exact name filled in the registration form.
• Once it is created, invite your teammates and ask them to accept the invite.
• Once you are done, you can use this team to register for the contest in the group.

Join the Discord / WhatsApp community: These links would have been mailed to you. Discord will be where you can easily connect with most other members and discuss problem solutions etc., post contests. WhatsApp will primarily be used for announcements.

Few useful tips (Especially for newer teams):

• Read all problems. They are not in increasing order of difficulty.
• Don't just try problems that other teams have solved. There have been multiple instances of easier problems going unsolved due to leaderboard-bias. So attempt unsolved problems too.
• If you are stuck, discuss with your teammates and brainstorm together. You can also pair program and debug them together.

Host Institute Schedule

• Week 1 — IIT Roorkee
• Week 2 — IIT BHU
• Week 3 — IIT Delhi
• Week 4 — IIIT Hyderabad
• Week 5 — IIT Indore
• Week 6 — IIT Kanpur
• Week 7 — IIIT Delhi & IIT Kharagpur
• Week 8 — IIT Hyderabad
• Week 9 — IIT Madras
• Week 10 — IIIT Bangalore
• Week 11 — NST

FAQ

Q. Will the problems be in increasing order of difficulty? A. No. They will be in random order. Make sure to read all the problems!

Q. Do we have to type out the codes in our notebook? A. No, for this time, you can copy-paste the codes. But only codes that were prepared before the contest.

Q. What all programming languages are allowed? A. The same set of languages officially allowed at ICPC: Java, Kotlin, Python, and C/C++.

Q. What does scoreboard freeze mean? A. The contest is for 5 hours. After 4 hours, the scoreboard will freeze. This means you won't get updates on what other teams have solved. But you will get the verdict for your submissions during this time. The scoreboard will be thawed during the closing ceremony. This is to add more suspense and excitement during prize distribution.

Q. Eligibility to qualify for prizes? A. The same eligibility rules used by ICPC. Team members must be registered students at the time of the camp. Also, teams are allowed to skip 2 of the several planned contests in camp.

Q. How are team ratings calculated? A. Lowest 2 performances of a team are discarded and then averaged to compute a team's rating. If a team skipped a contest, then this skip is included in the lowest performances. The performance of a team in a contest is calculated using the formula above.

UPDATE

WhatsApp Discussion group link updated!

Update

First Contest going to start in almost 1 hour (6pm — 11pm) Link for First Contest :

https://codeforces.me/group/wlb0UYQSQF/contest/710855 (Div 1)

https://codeforces.me/group/wlb0UYQSQF/contest/710866 (Div 2)

Applications for the IICPC DELTA Program are now open!

Hello everyone!

Registrations for the IICPC DELTA Program 2026 are now officially open.

Welcome to DELTA — Discovery and Early Learning in Trading & Algorithms, a highly selective initiative by IICPC focused on identifying and nurturing exceptional early undergraduate talent interested in quantitative trading, algorithms, technology, systems and problem solving.

This edition is proudly supported by leading quantitative trading and technology firms including Optiver, Hudson River Trading and more.

About DELTA

DELTA is designed to give high-potential students early exposure to the world of quantitative trading and advanced technology through a rigorous combination of assessments, competitions, interviews, mentorship and industry interaction.

Participants will go through challenging Trading and Technology tracks covering:

• Probability & Mathematics
• Competitive Programming
• Algorithms & Data Structures
• Analytical Thinking
• Systems & Low Latency Concepts
• Market Making & Trading Theory
• Fast Decision Making under Pressure

The program aims to bring together some of the brightest students from premier institutes across India and APAC regions including Singapore, Thailand, South Korea, Indonesia and Vietnam.

Selected participants will also get opportunities to interact with partner firms, mentors and recruiters through the onsite bootcamp and networking sessions.

Program Highlights

• Fully Paid 4-Day Onsite Bootcamp in Mumbai
• Trading + Technology Specialized Tracks
• Mentorship and Sessions by Industry Professionals
• Networking with Top Students Across APAC
• Rigorous 3-Stage Selection Process
• Designed for High Potential Early Talent

Eligibility

The program is targeted towards:

• Early undergraduate students graduating in 2029 / 2030
• Students from:

• IITs and premier Indian institutes

• NUS / NTU Singapore
• Eligible APAC universities and institutes

International participation is open for students from multiple APAC countries including:

• Singapore
• Thailand
• South Korea
• Indonesia
• Vietnam
• and other eligible regions

Selection Process

Stage 1 — Resume Shortlisting

Applications will first be evaluated based on:

• Academic performance
• Competitive programming achievements
• Olympiads and contests
• Technical projects and experience
• Demonstrated interest in quantitative trading, algorithms or systems

Stage 2 — Online Assessment (OA)

Shortlisted candidates will participate in a rigorous online assessment consisting of:

• Mathematics & Probability
• Logical and Analytical Reasoning
• Aptitude & Problem Solving

The Technology Track OA will additionally include:

• Competitive Programming
• Algorithms & Data Structures
• Coding & Implementation Skills

Stage 3 — Interviews

Final shortlisted participants will undergo interviews focused on:

• Technical and analytical thinking
• Problem solving ability
• Mathematical and systems intuition
• Learning potential and communication

Final Bootcamp

Approximately 30–40 selected students will be invited for a fully sponsored onsite bootcamp in Mumbai featuring:

• Competitions and simulations
• Mentorship sessions
• Trading and technology workshops
• Networking opportunities
• Interaction with recruiters and partner firms

Sponsors & Partners

Supported by leading global quantitative trading and technology firms including:

• Optiver
• Hudson River Trading
• and more to be announced soon

Registration

Registrations are now open from 10 May 2026 to 28 June 2026.

Apply here: DELTA

For queries and updates, stay tuned for further announcements.

We hope to see you participating. Good luck!

Ok, so first of all i don't know if it exist. But i will share my algorithm here only.

MOTIVATION!

Radix sort with base > 10?

so my motivation came when i though of why can't we use base 1e5 or 1e6 in radix sort? and i came up with following idea.

Most of the questions on CF have limit of values <=1e9. So my algorithm focuses majorily on that thing.

Alogirthm.

let us define a constant base, now we will make groups on the basis of ai % base,

• group[j] -> contains ai / base of those whoose ai % base == j.
• counts[j] -> it will store total number of times ai / base is equal to j. Note that both arrays will be of length base.

Next question — Now, how can we find the index(in sorted array) of any value of any group?

Observe, let x be any value of group[i], then value = x * base + i, its index will be atleast bigger than prefix Sum of counts[i] upto x — 1, also value will be bigger than those value whoose group number is smaller with same x.

Final touch

1. After making groups, and counts make prefix array of counts(let us call that array pref).
2. Define another array Live of length base, (initate all elements with 0).
3. Iterate from group 0 -> base. Now for every element(x) in this group(i) do the following
   • value = x * base + i
   • the index of this value = pref[x — 1] + live[x]
   • now do live[x] += 1
   • Update array[index] = value.
4. the sorting is done!

Implementation!

void sortit(vector<int> &arr, int base = 1 << 15) {
    int n = arr.size();
    
    vector<vector<int>> grps(base);
    vector<int> cnts(base + 1), live(base);
    for (int i = 0; i < n; i++) {
        int z = arr[i] / base;
        grps[arr[i] % base].push_back(z);//adding each element in respective group
        cnts[z + 1]++;//increasing count
    }
    for (int i = 1; i < base; i++) cnts[i] += cnts[i - 1]; //making prefix array
    
    for (int i = 0; i < base; i++) {
        for (int &x : grps[i]) arr[cnts[x] + live[x]++] = x * base + i;
    }
}

Analysis.

For all values less than base^2(base = 2^15), the time complexity comes out to be O(n + base), 2 * n(2 for loops of n) + base(memory definition and prefix array). you can choose base depending on max value of array, N and memory.

For n > base it starts becoming faster and faster than cpp sort.

Results.

These results are when i ran them on my laptop. UPD- Added radix sort comparison also!

Size 1000 Sorting....

Time taken by sortit() -> 1ms
Time taken  by cpp sort() -> 0ms
Time taken by radix sort(base 256)(4 rounds) -> 0ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 4ms

Size 10000 Sorting....

Time taken by sortit() -> 1ms
Time taken  by cpp sort() -> 1ms
Time taken by radix sort(base 256)(4 rounds) -> 1ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 5ms

Size 100000 Sorting....

Time taken by sortit() -> 9ms
Time taken  by cpp sort() -> 15ms
Time taken by radix sort(base 256)(4 rounds) -> 5ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 18ms

Size 1000000 Sorting....

Time taken by sortit() -> 40ms
Time taken  by cpp sort() -> 185ms
Time taken by radix sort(base 256)(4 rounds) -> 54ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 90ms

Size 10000000 Sorting....

Time taken by sortit() -> 316ms
Time taken  by cpp sort() -> 2171ms
Time taken by radix sort(base 256)(4 rounds) -> 572ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 508ms

Size 100000000 Sorting....

Time taken by sortit() -> 3056ms
Time taken  by cpp sort() -> 24149ms
Time taken by radix sort(base 256)(4 rounds) -> 5747ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 4749ms

Size 1000000000 Sorting....

Time taken by sortit() -> 35071ms
Time taken  by cpp sort() -> 277987ms
Time taken by radix sort(base 256)(4 rounds) -> 65696ms
Time taken by radix sort(base 1 << 16)(2 rounds) -> 50732ms

For higher values of n, it tends to become faster. Hence, this is suitable for higher n values.

If you find any similar or same algorithm, please let me know!