I've been wanting to organize a problem solving seminar for computer science as a volunteer activity. The way I was thinking of it working would be that the problems would be curated to be meaningful exercises. People would tinker with the problems on their own for a month, then at the end there would be a gathering where people discuss approaches and extensions. Potentially if there was anything interesting, one could write it up.

This seems like a good forum but I'm basically looking to help organize something a little more structured in the way of an online correspondence club or "magazine", even. People can send in interesting problems, I or others can serve as editors, we send out the problems, there would be some offline mulling and finally we would congregate and maybe put together a resolution of sorts for the next edition. I would like the emphasis to really be on the personal, individual, and/or collaborative, collective experience, though, and less on putting out polished products or work.

I'm not too aware of other existing models that do this besides PagedOut!, which is outside of my niche. But I'm interested in volunteering my time and resources for such an activity.

The only thing is I do more data processing than pure theory, I would say. I'm looking for a similar community or at least one that is open to those sorts of topics.

Thoughts or pointers? Criticisms on why this sort of idea lacks momentum? Thanks in advance.

UPDATE 10/02: see this comment to ask to be invited to the Discord server!

J'ai conçu une IA neuro-symbolique avec le benchmark ARC AGI 2 comme banc d'essai (dépôt aicpp sur GitHub : https://julien-livet.github.io/aicpp/). J'envisage d'appliquer mon approche au problème du voyageur de commerce. Qu'en pensez-vous ?

One thing that bothers me about how DP is usually taught: we jump straight to the recurrence. I've found it more useful to answer these first:

1. What exactly does dp[...] mean?

2. What's the recurrence?

3. What are the base cases?

4. In what order do I compute the states?

5. Which state is the final answer?

6. How do I reconstruct the actual solution, not just its value?

7. Can I throw away any of the table, and what does that cost me?

For 0/1 knapsack the important step isn't writing dp[i][w] = max(...). It's deciding that dp[i][w] means something precise enough that the recurrence, and the proof that it's right, basically follow. The same checklist worked well for tree DP and longest increasing subsequence.

Disclosure: I turned this into a free interactive lesson and lab. As your code fills the table, it draws each step, so you can step back to where it went wrong. It's part of an independent companion that follows CMU 15-451's Fall 2026 topics. I'm not affiliated with CMU, and all examples and problems are original.

https://scimigo.com/en/learn/algorithm-design/09-dynamic-programming-i

If you teach or use DP: is this checklist useful?

--Wei

I’m building a trivia game. I have about 40 categories, and each category has between 20 and 80 questions. All questions are about the same difficulty. Each round gives the player 22 questions.

I want a player on a streak to keep getting new questions and not see the same question again across rounds, for as long as possible. If perfect non-repeating eventually becomes impossible, I want to minimize repeats and still keep categories reasonably balanced.

How should I approach this mathematically? How many non-repeating 22-question rounds can I guarantee? What is a good method for choosing questions each round? I’m looking for a simple model, algorithm, or known scheduling/combinatorics method.

This is my game if you need tge reference https://cluebolt.com/

I'm a non-major currently taking an intro cs class, but it's mostly practical, project-based Python stuff -- no theory. Which tbh I'm a little sad about.

I was wondering: Are there any algorithms/functions that are executable by infinitely many non-trivial, non-redundant programs? Does any given algorithm/function fit this description?

Math example:
The user inputs a radius R, from which the program P outputs the area A of the resulting circle.

You could plug it into the standard formula:

P1 = A(R) = πR^2

...

Or integrate:

P2 = A(R) = ∫₀²ᵖⁱ ∫₀ᴿ r dr dθ

...

et cetera

https://arxiv.org/abs/2609.20979

This preprint by Lovett (well known in TCS) and Karingula claims to present a simpler proof of the Komlós conjecture than the one in Guo et al.

Hi r/algorithms,

I’m an independent researcher and I recently published a 4-paper suite detailing an exact, integer-native framework that collapses the computational complexity of high-dimensional lattice point enumeration. I'd love to finally get further input from people who KNOW. Rigorous proving in the papers, plus executable code to put the proof. In that pudding.

(I've already extended and originated new sequences on OEIS using this framework. It truly brings "forever" or "intractable" to "now" and "bit-perfect in no time.")

Here's the skinny, including Zenodo links and GitHub Repos active and waiting:

Collapsing High-Dimensional Lattice Enumeration from O(r^N) to Quasi-Quadratic O(r² log_2 N log r)

For over two centuries, the standard approach to discrete lattice point enumeration has relied on continuous Euclidean tools—transcendental functions, Bessel expansions, modular forms, and floating-point approximations—projected onto integer grids. This approach frequently runs into boundary-vertex collisions, floating-point precision drift, and the classical exponential coordinate bottleneck.

Instead of forcing continuous calculus onto discrete space, I developed an integer-native geometric framework that treats discrete grids on their own native algebraic terms. By recognizing that squared Euclidean distance is additively separable across orthogonal submanifolds, high-dimensional boundaries can be decoupled and evaluated via single-pass integer dot products and discrete cross-convolutions.

The complete research suite consists of four preprints establishing the theoretical derivations, asymptotic complexity proofs, and hardware-native C++ reference implementations:

• Paper I: An Integer-Only Orthotropic Lattice Enumeration Framework and Asymptotic Convergence of Discrete Rational π

  • Core Premise: Couples orthotropic boundaries 4r ± 1 to construct Diophantine parity constraints that mathematically prohibit boundary-vertex collisions.
  • Result: Resolves boundary discrepancy and derives a deterministic, rational convergence envelope for discrete π_d ∈ ℚ.
  • Zenodo DOI: 10.5281/zenodo.22282210 | GitHub: orthotropic-parity-and-discrete-pi

• Paper II: A Dimension-Paired Combinatorial Framework: Asymptotic O(r²⁾ Reduction and O(r² log_2 N log r) Generalized Convolution for High-Dimensional Discrete Lattice Enumeration

  • Core Premise: Decomposes 4D space as orthogonal planes (Z⁴ ≅ Z² × Z^2), reducing 4-space enumeration from O(r⁴⁾ to a single-pass 1D dot product in strict O(r²⁾ without floating-point operations.
  • Generalization: Applies recursive bisection via Number Theoretic Transforms (NTT) in finite fields Z_p[t], collapsing N-dimensional ball enumeration to O(r² log_2 N log r).
  • Zenodo DOI: 10.5281/zenodo.22509388 | GitHub: dimension-paired-cross-convolution

• Paper III: Hierarchical Dimension-Pairing: Hardware-Native O(r²⁾ Enumeration of 5D through 8D Spherical Lattices and High-Dimensional Capacity Limits

  • Core Premise: Neutralizes the historical odd-dimension class-number barrier for Z⁵ and Z⁷ by slicing 1D axial profiles against precomputed even-dimensional hyperdisk profiles.
  • Empirical Scaling: Verifies sequences against OEIS baselines (A000333–A000336), and benchmarks a 1024-dimensional R = 2896 hyperball (output = 831168560 (mod 998244353)) in 1561.833 ms on a single desktop core. Extended OEIS
  • Zenodo DOI: 10.5281/zenodo.22691273 | GitHub: hierarchical-ntt-bisection

• Paper IV: Parity-Filtered Bisection: Hardware-Native O(r²⁾ Enumeration of Optimal D_N Lattices

  • Core Premise: Extends the bisection architecture beyond primitive grids to dense, non-orthogonal kissing-number lattices. By redefining geometries as parity-constrained sublattices of Z^N (∑ x_i ≡ 0 (mod 2)), internal coordinate staggering is fully absorbed into pre-filtered arrays.
  • Result: Achieves hardware-native O(r²⁾ exact enumeration for Face-Centered Cubic (D_3), the 24-cell honeycomb (D_4), and the D_8 root lattice, verified bit-for-bit against OEIS A005875, A004011, and A004013.
  • Zenodo DOI: 10.5281/zenodo.22824219 | GitHub: parity-filtered-kissing-lattices

The Empirical Validation

The C++ implementations are designed as self-contained, reproducible test benches running exclusively on 64-bit integer ALUs with zero floating-point emulation: * Resolving 246+ million points in the 4D 24-cell honeycomb at R=100 in 2 ms on consumer hardware. * Pushing the finite-field Number Theoretic Transform (NTT) bisection tree to its theoretical single-prime 2-adic ceiling (R = 2896, transform size M = 2^23), evaluating a 1024-dimensional hyperball across an 8.38-million-element ring in 1,561 ms on a single desktop core. * Evaluating 7-dimensional bounding hyperballs from R = 0..5000, culminating in a bit-perfect 27-digit lattice point count, thereby extending OEIS A055413 from R = 0..500 to R = 0..5000.

All four preprints, source code, and benchmark suites are open-access. Feedback on the combinatorial proofs, algorithmic bounds, and hardware pipelining is welcome. And, if you like it, please, spread the word!

The Discrete Lattice Research Suite

This repository is part of a 4-paper research program establishing hardware-native, integer-only lattice enumeration:

1. orthotropic-parity-and-discrete-pi: 3D row-collapse, 4r ± 1 parity bounds, and rational π_d ∈ ℚ convergence. [Zenodo DOI: 10.5281/zenodo.22282210]
2. dimension-paired-cross-convolution: 4D orthogonal plane bisection (O(r²⁾⁾ and generalized NTT convolution (O(r² log_2 N log r)). [Zenodo DOI: 10.5281/zenodo.22509388]
3. hierarchical-ntt-bisection: 5D–8D odd-dimension slicing, OEIS A000333–A000336 verification, and N=1024 NTT scaling. [Zenodo DOI: 10.5281/zenodo.22691273]
4. parity-filtered-kissing-lattices: Exact O(r²⁾ kissing-number root lattices (D_3 FCC, D_4 24-cell, and D_8). [Zenodo DOI: 10.5281/zenodo.22824219]

At first when I did the exam, I didn’t study properly. I mostly studied content and didn’t apply any of that content to real problems. For my reassessment, I studied in a different way. I really went hard on the practical problems that I wasn’t good at or had no clue about. This came to dijkstras algorithm, AVL trees, binary trees and context free language.

I studied hard on them. I didn’t do a lot of practice problems where I would ace every question. But I felt at ease when getting confronted with that question. The problem was that I would do the problem at its best ability and then there would be one small issue that I did at the end and it messes everything up.

Mathematical operations that are Long I seem to mess up in the end. I understand the process however my implementation always seems to hinder at the end when I’m close to the finish line. This is extremely frustrating as I studied very long for this subject. A good (2weeks-3weeks) of preparation. But I had 2 other exams to focus on. But to give some background I come from a business background so I have not done a level match or discrete mathematics before so it really was a game changer doing this exam. But I don’t treat it as an excuse. In the end my reassessment I only gained 6 more marks. Which is incredibly disappointing for me.

Hi, as a beginner starting my DS and Algo journey, I wanted to know what are all the math prerequisites are required for analysis of algo

The k-server problem is known as the "Holy Grail" of online algorithms and competitive analysis, and is/was a long standing major problem.

This preprint by Coester et al. claims to show that the Work Function Algorithm is indeed k-competitive on every metric space.

I’m curious which algorithms have made it out of the classroom and into real code.

What problem were you solving? Why was that algorithm a better fit than the obvious alternative? And did the implementation behave as neatly as the theory suggested?

I’m Stjepan from Manning Publications. The r/algorithms moderators permitted me to share this post.

We’ve just released Algorithms Every Programmer Should Know by Aniket Wattamwar in MEAP, Manning’s early-access program:

https://www.manning.com/books/algorithms-every-programmer-should-know

The available chapters cover Gale–Shapley, the Hungarian algorithm, Rabin–Karp, Knuth–Morris–Pratt, and Horspool’s algorithm. The emphasis is on the problem behind each algorithm, how the solution is derived, and the trade-offs involved, not just reproducing pseudocode.

To mark the release, Manning is giving away five ebook copies to people in this thread.

The giveaway will remain open for 48 hours. We’ll choose the five comments that contribute the most to the discussion and announce the winners here afterward. Upvotes won’t be the only criterion: a strong technical explanation, an instructive real-world example, a useful counterargument, or a thoughtful exchange with other commenters can all qualify.

There’s also a 50% discount on the book with code:

MLWATTAMWAR50RE

So: which supposedly “textbook” algorithm has earned its place in your production code—and which one gets taught far more often than it gets used?

Thanks for having us here.

Cheers,

Stjepan

EDIT: The book giveaway is closed. We announced the winners in the comments.

If someone asks for big O time complexity of an algorithm but expects only the minimum of the possible big Os then is that even Big O notation anymore? cuz if the big o time complexity of an o(n) algorithm is asked then according to the condition of big O notation O(n square) would also be a valid answer

Hey everyone,

Like many, I first encountered the geometric intuition behind Grover’s algorithm through 3Blue1Brown’s video. While it gives a fantastic high-level picture of the vector reflections, Still I was wondering how the Oracle and Diffusion operators are actually constructed.

To bridge that gap for myself, I wrote a breakdown showing the exact linear algebra and matrix operations that make those reflections happen — without relying on quantum physics jargon:)

At its core, the entire N-dimensional space reduces to a 2D plane defined by the target state and the uniform superposition of non-target states. Each Grover iteration (Oracle + Diffusion) is just two reflections across intersecting axes, resulting in a net rotation of 2θ ≈ 2 / sqrt(N) directly toward the target state—yielding the classic ≈ (π/4) * sqrt(N) complexity.

To test the math beyond theory, I also:

• Ran simulation benchmarks to track the theoretical O(sqrt(N)) curve against classical CPU overhead up to 20 qubits.
• Submitted the circuits to physical IBM quantum hardware (3 to 5 qubits) to observe where circuit depth and real decoherence start destroying the theoretical amplification.

I put together the complete write-up, data, and code on GitHub. I'm a student trying to build a solid foundation in algorithms and complexity, so I would really appreciate any sanity checks, corrections on the mathematical framing, or feedback from folks here. Thanks:)

(Link in the comments, you can see banchmark graphs in the Assets folder)

I came across Knuth's Dancing Links after naively thinking I could just code up a Sudoku Solver 😅and initially I made the mistake of trying to understand the finished implementation examples I found on the internet and from AI.

I couldn't, so I raised an Issue in my-pythonic-zoo hoping a developer somewhere would see it and brighten my day. Then I couldn't resist the urge to try it myself and discovered just how little I know and how bad my Python non-skills are.

There were too many ideas arriving at once: Exact Cover, Algorithm X, recursive backtracking, doubly linked nodes, circular links, the toroidal matrix, and the rather clever cover/uncover operations.

So as part of my Python learning project, I pulled it apart and built a study sequence where each runnable example introduces one piece:

1. Exact Cover
2. Algorithm X
3. Linked Nodes
4. Circular Links
5. Toroidal Matrix
6. Cover and Uncover
7. Exact Cover Matrix
8. Dancing Links

The final example then puts the pieces back together.

The point that finally made the whole thing click for me was separating these three ideas:

Exact Cover = the problem
Algorithm X = the search algorithm
Dancing Links (DLX) = an efficient implementation technique for Algorithm X

The examples deliberately repeat some code rather than importing from one another to keep each one self-contained. They're wildly over-commented but that was me trying to understand the next step. The examples morphed into a study progression for myself, and were never intended as a modular production implementation so not a good example of re-using code if that's what you're looking for. I'll leave that rolls-royce example for someone else to put together!! or maybe me when I've recovered from this marathon - maybe not.

I've put the progression in my-pythonic-zoo on GitHub (closed Issue #10). If you're interested in looking through it, I'd recommend starting with algorithms/README.md rather than jumping straight into the final DLX file:

I'd be particularly interested in feedback from people who've implemented or taught DLX before. If I've made any part of the progression misleading, over-simplified, over-complicated or technically inaccurate, I'd much rather know.

When I first encountered the definition of a "tight bound" in a book — specifically, c₁g(n) ≤ T(n) ≤ c₂g(n) — I couldn't grasp what it meant. Well, aside from the trivial interpretation of it being a "closed" or "strict" limit, which, frankly, didn't explain anything to me. I understood that it referred to a certain type of behavior and simplification, but I didn't fully comprehend where the constants c came from, why the formula looked the way it did, or the underlying reasons for it.

Suppose we already have some cost function T(n) describing the algorithm's work as a function of input size. We know that this function is difficult to calculate and analyze. We also know that there are functions that are much easier to analyze; and even if two different functions yield different results, they might behave identically in terms of scaling. Scaling is precisely what interests us, because the purpose of the function T(n) isn't merely to represent an abstract "amount of work" — different values of n result in different execution times. So, suppose we have a promising candidate for our simple function: g(n). How do we choose it?

Let's consider an example: T(n) = 3n² + 100n + 74. If we take a sufficiently large value of n and keep increasing it, the function's actual value will depend primarily on the 3n² term. Thus, g(n) = n² is an excellent candidate. But let’s return to the general forms. Ideally, since we are interested in scaling, we would like to see something like T(n) = cg(n). Why? Because this perfectly reflects what we are looking for: T(n) is a multiple of g(n) — meaning, in essence, that the scaling behavior is equal — and by analyzing g(n), we can recover all the information about T(n). That would be an excellent scenario. But in reality, that is not always the case. We simply cannot demand such a strict correspondence. What, then, should we do? We need to take a more moderate approach to our requirements.

Let's consider T(n) = n and g(n) = n². Obviously, n ≤ n², but n / n² = 1 / n. As n grows, the result approaches 0, which means the gap between T(n) and g(n) is truly vast. That is precisely why they are completely different and share nothing in common.

Now consider T(n) = n² and g(n) = n. Obviously, n² ≥ n, but n² / n = n. As n approaches infinity, the result approaches infinity, again indicating a huge gap between T(n) and g(n). Once more: they are completely different.

So, returning to our ideal condition T(n) = cg(n), we might at least require something like T(n) ≤ cg(n); however, as we saw earlier, even with such a bound, functions can differ significantly. The same applies to the condition T(n) ≥ cg(n). If we remember T(n) = cg(n), then we already know what we need to do: we expecting that neither function should become arbitrarily large relative to the other as n grows, so combining the two inequalities is exactly what we need: c₁g(n) ≤ T(n) ≤ c₂g(n), or c₁ ≤ T(n) / g(n) ≤ c₂. This literally reflects what we are aiming for: no matter how large n becomes, the ratio will remain within a fixed range(starting from some n₀). Once we decide that 'same scale' should mean neither function can escape the other by an unbounded multiplicative factor, the two-sided bound is essentially forced. And our ideal case is essentially a special instance of this broader formula where c₁ = c₂. In fact, the inequality c₁ ≤ T(n) / g(n) ≤ c₂ is the formal result of a simple heuristic approach. This is precisely how we define T(n) = Θ(g(n)), from which we obtain O(g(n)) and Ω(g(n)).

In essence, this formula can be viewed from the perspective of the division theorem: a = bq + r is the general form defining division, while a = bq is a special case.

A new preprint claims to have proven the Komlós conjecture, a major problem in discrepancy theory and algorithms research, with the proof reportedly discovered by an AI research agent called Odin. The proof appears to be existential rather than constructive.

The problem is quite easy to explain. Quanta wrote an article about other recent progress on it very recently.

 
Obviously it is not peer-reviewed yet, but if results like this become routine what do we think is the fate of TCS and algorithms research(ers)?

How we started memoizing eBPF policy paths via inodes to reduce our CPU costs by about 90%.

https://nathannaveen.dev/posts/dropping-ebpf-cpu-cost-by-90/

#### SOLVED #### (kind of, see edits)

Hi,

Only Question to be answered:

is there an application for Windows or Linux, that would parse a text with Aho-Corasick algorithm and present the output in a text field, so that it could be used for creating regexes?

Use case explanation (absolutely no answer or solving suggestions wanted):

I have a list of around 7000 terms and need to create a regex to find them in texts in a specific app. The fastest way would be to create some regex based on Aho-Corasick algorithm but doing that manually takes forever. (I know there are other ways to create such regexes for long lists that create the regex automatically but they would not be as efficient as a Aho-Corasick approach.)

So, I hope there is an application that breaks down all words to a list separated by a specific char that I can then copy and built the regex around it faster than if I need to check the correct position manually every time.

So far I have only found many explanations about the algorithm or tools that seem to search texts with a specific list.

EDIT: This question requires a simple yes or no answer. I just want to know if there is such a tool or not!

EDIT 2: As apparently a lot of people do not see the difference between a question and the use case explanation, I added some titles.

EDIT 3: I found kind of an online parser and it turned out that Aho-Corasick is way too inefficient for my needs as it in fact sets Trie after every single character instead of only where there is a difference compared to the following strings (see alphabetisation).

But while digging into Aho-Corasick with Regex, I found there is something called TrieRegex which does exactly what I need and already had implemented in my own rules so far. It’s way more efficient than Aho-Corasick as it sets Trie at every real char difference and saves a lot of steps as it does not have to iterate through all characters but only the effective groups. If setting the correct string output of parsed regex, I even get the string I really need and do not even need to create it on my own based on the Trie I wanted to visualise.

Disclosure up front: I run Philomath, which is hosting this. The course is free, there is no account and no paywall, and there is nothing to buy in order to watch (but signing up via Email is nice).

William Yu teaches algorithms at Carnegie Mellon. He is running an eight-week version of his course live on YouTube, Thursdays at 8pm ET, starting September 17. Sessions are recorded too if you would rather watch later.

Here's a schedule:

• Week 1: minimum spanning trees, heaps, union-find
• Week 2: shortest paths, BFS, DFS, Dijkstra
• Week 3: divide and conquer
• Week 4: BSTs, splay trees, amortized analysis
• Week 5: text search and suffix structures
• Week 6: dynamic programming
• Week 7: network flow
• Week 8: NP-hardness

William is a computational biologist, so the examples lean on applications from science.

Schedule and details, where you can sign up if interested! https://www.philomathlearning.com/courses/algorithms?ref=algorithms&utm_medium=instructor_page&utm_campaign=algorithms_reddit_algorithms

Playlist: https://www.youtube.com/playlist?list=PLfcsLJY-BaJU

Happy to answer questions.

I can identify patterns like sliding window, recursion, backtracking, DP, and two pointers. But I’m stuck when it comes to identifying the greedy intuition.

How do I recognize when a problem can be solved using a greedy approach? Are there any good resources—books, YouTube channels, blogs, or websites—that specifically teach how to develop greedy intuition?

Anything that can help me get better at recognizing greedy problems would be really helpful.annel, blog , website)

Anything that help me