Not_Just_Searching

• 

  hackathon

Inspiration

Competitive programming training programs like AspiHazar run the same contests season after season, and the coordinators change from year to year. When a new coordinator picks problems for the beginners division, there is no reliable way to know whether a problem was already used. Searching by keyword does not help, because the same idea can be told with completely different stories. "Count the apples in baskets l to r" and "range sum queries on an array" are the same problem, and no keyword search will connect them. I built Not_Just_Searching so coordinators can check what a problem is really about, not just what words it uses.

What it does

AlgoGuard AI is a web app that checks a candidate problem against an archive of past problems.

• Inspector: Paste a problem statement and it extracts the core algorithmic archetype (for example Prefix Sums, Two Pointers or Dynamic Programming), the target time complexity from the constraints, and the key equations.
• Duplication analyzer: It compares the problem's mechanics with every stored problem and shows a 0–100% risk score: green for safe, yellow for partial overlap, red for high duplicate risk. It explains why a problem was flagged and shows how little the wording overlaps, which is what a keyword search would have seen.
• Problem pool: A searchable, filterable archive. Clicking any problem opens its full statement. For beginner divisions it recommends unrepeated, verified alternatives.
• Dashboard: Problems indexed, duplicates blocked, category distribution, a coordinator turnover table, an audit log, and an exportable safety report. Adjustable thresholds let each coordinator choose how strict to be.

How we built it

It is a single-page app in plain HTML5, Tailwind CSS and vanilla JavaScript, with no backend. Every problem is turned into a weighted vector of ten algorithmic concepts (prefix sums, two pointers, DP, graphs and others) plus the kind of question being asked (count, optimize or decide). Candidates are compared with the archive by cosine similarity, scaled by how much the concept sets overlap. The vector database is simulated with a rule-based engine, and the archive holds 16 sample problems with paraphrased statements. I tested the engine on problem pairs where the story differs but the mechanics match, and on pairs where the opposite is true.

Challenges we ran into

My first version scored any two problems that shared one archetype at almost 100%, so a coin-counting DP and a stair-climbing DP looked identical. I fixed this by adding the intent of the question and the overlap between concept sets, and the score for a string problem sharing only one concept dropped from 83% to 52%. Parsing constraints like "2·10^5" also broke at first, and a bug kept the report window from closing. Honestly, a rule-based engine will miss ideas outside its concept list, which is the main limit of this prototype.

Accomplishments that we're proud of

It catches a duplicate hidden behind a completely different story, with high mechanic similarity and only a few percent keyword overlap. It also explains its reasoning, so a coordinator can open the flagged problem and check the call themselves. The whole app is one file that anyone can open in a browser with no installation.

What we learned

Plain similarity scores are easy to fool. Two problems can share a technique and still be different problems, so the intent of the question matters as much as the technique. I also learned to test with deliberately tricky pairs rather than only obvious ones, because the failures showed up there.

What's next for Not_Just_Searching

• Replace the rule-based engine with real text embeddings and a vector database.
• Let coordinators choose between testing a problem and adding it to the archive, with adding offered only for problems judged unrepeated.
• Split the archive into sections per division or competition (beginners and others), so it can keep growing.
• Import real past contests and problems from Codeforces and CSES.

Built With

• css
• html5
• javascript