My challenge idea is this:

Generate 64 random integers between 1-100. Draw an 8x8 grid, so a cell for each number.

Your challenge is to place all the integers into the grid such that

• Each row is descendingly sorted
• Each column is descendingly sorted

or declare this impossible.

There are loads of different ways this can be done and multiple different but valid solutions. I would expect 100 such sets of integers to be sorted this way as the challenge.

Title:
Build a simple crypto portfolio tracker using any public API

Body:
Create a small command-line or web app that fetches cryptocurrency prices (BTC, ETH, SOL, etc.) from a free API (like CoinGecko or Binance) and displays your portfolio’s total value in USD.

Requirements:

• Use any language (Python, JS, Rust — your choice)

• Must handle at least 3 tokens

• Bonus: include percentage change and simple chart

Difficulty: Easy / Beginner-friendly
Estimated time: 30-60 minutes
Skills: API calls, JSON parsing, data visualization

Winner criteria: most creative UI or cleanest code

Counterattack!

Find a unique, imaginative, but also efficient way to respond to a hacker attack detected in an API endpoint on your server (for example, you receive a call that does not contain the required headers, or parameters that are not required, etc.).

Requirements:

• The response action must not overload your server (you could cause a DDoS without meaning to!)

• Server architecture: Linux, PHP 8+, MySQL 8

Victory:

The response that receives the most positive votes among those that are actually applicable

“Do you have the invitation?”

Discover the best way to prevent misuse of web APIs on a Linux server with PHP 8.2+, MySQL 8, 1 CPU core, and 2 GB RAM, apache2, fail2ban, modsecurity. (I chose low specifications to emphasize performance optimization, which otherwise would not be sufficiently evident).

You can use any tools/languages you want to prevent:

• unauthorized API calls (only logged-in devices can make a call)

• tampering with call content (e.g., manually modified body, altered timestamps, etc.)

• man-in-the-middle attacks (do not transmit clear text data to the API endpoint and vice versa, etc.)

• replay attacks

• etc

Any solution, even custom ones, is welcome.

The winner will be whoever proposes the solution that requires the least execution time and prevents the greatest number of attacks, preferably also providing the code and settings used (when calculating the execution times of the PHP endpoint, only the code for managing the security aspects covered by the challenge should be considered: receiving the request, decryption, various checks, providing the response. The client can be in Java or any other language).

Bonus:

optimization using a real connection (not in a localhost environment).

P.S. I am well aware that it is impossible to prevent all hacker attacks, but the goal here is to make it as difficult as possible.

P.S.2: You can also provide the logic and idea without writing code, but in that case, please provide clear and precise explanations.

Challenge Title:

The Shapeshifting Algorithm

problem statement:
You’re given a data processing pipeline where the shape of input data changes unpredictably at each run — sometimes it’s a list, sometimes a nested dictionary, sometimes a stringified JSON.
Your challenge is to write a single function that can detect, normalize, and transform any of these formats into a consistent, unified structure (e.g., a pandas Data Frame or a flat dictionary).

Twist:
You’re not allowed to use is instance() or type-checking directly. You have to infer the structure dynamically and handle it gracefully.

Goal:

• Create one robust Python function called normalize_data(input_data)

• It must accept any of the provided random structures and produce a uniform output

• It should never crash on invalid input — instead, log meaningful errors

Difficulty:
Intermediate–Advanced

Estimated Time to Solve:
2–3 hours

Required Skills / Technology:

• Python (handling dynamic data structures)

• JSON parsing / recursion

• Clean error handling

How Winners Could Be Selected:

• Reliability: Handles the most edge cases correctly

• Elegance: Short, clear, maintainable code

• Bonus Points: Add automatic type hints or data schema detection

Challenge Title

Emoji Compression Showdown

Prompt

You are presented with a large text file composed solely of emojis 😃🚀🎨.

Develop a program that compresses it to the smallest size possible while ensuring it remains 100% lossless.

Rules

• Any programming language is permitted.

• The solution must incorporate at least one custom compression technique (not merely zip/gzip).

• Decompression of a 50 MB file should be completed in under 5 seconds on a standard laptop.

Difficulty & Time

Intermediate–Advanced | Approximately 8–12 hours.

Skills

• Handling of Unicode & UTF-8

• Data compression algorithms (Huffman, LZ77/78, arithmetic coding, etc.)

• Efficient file input/output

Scoring

Primary: The smallest valid compressed size will be the winner.

Tie-breaker: The fastest decompression time will serve as the tie-breaker.

The Challenge

Backend architectures are essential parts of projects. In this challenge, participants must design and implement a new backend architecture. It doesn't need to be built from scratch but it must be innovative. It means you may draw inspire from currently used architectures.

Difficulty: Intermediate - Advanced

Time: 4-12 hours

You can use whatever you want for backend language and database. However classic backend languages or frameworks are preffered (Java, Python, C#, Node.js, Go, Rust etc.).

Also you can use another architecture as a base and make significant improvements on that. Our main criteria is innovativeness

Requirements

The solution must include:

• A diagram of architecture (How services communicate, data flow etc.)

• An explanation of why this architecture is innovative

Bonuses:

• Minimal implementation

• Documentation of the architecture

Criteria:

• Innovativeness is the priority

• Clarity of the solution

• Scalability

• Crowd votes

Simulate using 2 x 6-sided dice to emulate the results of 1 x 12-sided die with the correct statistical distribution , i.e. each number has a 1 in 12 chance of appearing.

Now see how you can get 3 x 6 sided dice to emulate the results of an 18 sided die with the correct statistical distribution

Random nicknames generator

In this challenge we try to generate random gamer nicknames. This idea should not be reduced in a simple concatenation of a adj + noun of two lists but it SHOULD include rules and features that make the algorithm more interesting and creative.

But, how to win?

1. Community criteria -> based on up-votings of the proposed algorithms
2. Feature criteria -> based on how further it goes from the trivial solution
3. Interesting constraints suggested by SO community members in the comments of this post, or added by SO staff.

Challenge Idea: The Regex Escape Room

Difficulty: Medium

Estimated Time: 2-4 hours

Skills/Technologies: Regular expressions (regex)

The Challenge

You've been trapped in a digital "escape room" and the only way out is to solve a series of regex puzzles. You'll be given a set of strings and a specific goal for each one. Your task is to write a single regular expression for each puzzle that accomplishes the objective. Each successful solution unlocks the next puzzle.

The challenge will consist of three to five stages, each with a different theme.

Stage 1: The Data Scavenger

You are given a log file full of messy data. Your task is to extract specific pieces of information. For example, you might need to find all email addresses, phone numbers, or dates from a jumble of text.

Stage 2: The Code Cleaner

You're given a block of code with a variety of formatting issues. Your goal is to use regex to find and replace specific patterns. For example, you might need to find all instances of single-line comments and convert them to multi-line comments, or find and remove all trailing whitespace.

Stage 3: The Password Validator

You are tasked with creating a robust password validation system. You will need to write a single regex that checks for multiple conditions at once: a minimum length, the presence of at least one uppercase letter, one lowercase letter, one digit, and one special character.

How Winners Should Be Selected

Performance-Based Grading:

• Most Elegant Solution: Winners could be chosen based on the most concise and efficient regex. For example, a shorter regex that still meets all the requirements would be considered a superior solution.

• Most Creative Solution: Users who find a clever or unusual way to solve a puzzle could also be highlighted.

Challenge Idea: A game with INTENTIONAL bugs

We love games with no bugs so why not a challenge to build a game with intentional bugs

Requirements:

• At least 20 bugs the player must exploit to progress the level
• 3+ levels
• 3D, 2.5D or 2D
• Publish to WebGL OR distribute the executable

Other info:

• Difficulty: Easy-Medium depends on complexity
• Time Estimate: 24-48 hours depends
• Skills needed: Basic game engine understanding AND C# or Python/GDScript
• Winner selection: Members favorite (upvotes) OR best creativity, music, art, etc.
• Googling any tutorial is forbidden (so you dont cheat)
• For Python developers, I'd recommend to use pygame.

DON’T FIX. BREAK IT.

Competitive Hide and Seek (Fully Written-Out Challange)

• Theme: Puzzle/Algorithm
• Difficulty: Medium
• Time Estimate: 1-2 weeks
• Language: Python

Feel free to read the submission on github with pictures and code.

Concept

You and your friend are playing hide & seek. You both randomly spawn in a 2D grid-like room. The room has randomized walls that obstruct vision. If you are a seeker, your goal is to write an algorithm to catch the hider with the fewest steps possible. If you are a hider, your goal is to write an algorithm to delay the catching as much as possible. You can choose whether you want to play as a seeker or a hider. You can submit for both sides if you like.

Winners

All submitted algorithms for seekers and hiders will compete against each other on a predefined hidden test set of random maps and starting locations (set size to be determined).

The algorithm's performance is evaluated as an average across all games of the number of steps to catch the hider.

Therefore are two sets of gold/silver/bronze winners. Three for the best seeker algorithm. Three for the best hider algorithm.

Game Rules

Map

The map is a 2D grid of 20x20 (always the same size) cells. Each map has randomly placed walls of different shapes. The walls always cover approximately 25% of the map and in such a way that there are no inaccessible cells.

Movement

Both players are only allowed to move left, right, up, or down if there is no wall in front of the movement and they don't go out of bounds of the map.

The speed of the seeker is double the hider's to make catching possible. I.e., the seeker moves every step/iteration, while the hider moves only every second step.

On the second step, the seeker has the priority, i.e., the hider two distances away is always being caught if the seeker moves towards the hider.

Spawn Locations

The spawn of a seeker is uniformly random on the entire map. The spawn of a hider is uniformly random on the furthest quadrant from the seeker spawn to make close-distant spawns less likely.

The spawn at a distance closer than three is forbidden, as it is an automatic win for the seeker. The players spawn only in the "non-wall" (empty) cells.

Vision

The players have a vision of each other if there are no walls crossing the line connecting the two players. Once the players have vision of each other, they get the precise coordinates of their opponents.

Beginning of the game

At the beginning of the game, both players are given the full knowledge of the map and the starting locations of both the seeker and the hider.

End of the game

When the seeker's location becomes the hider's location, the game is over, and the number of the steps it took is the score for both algorithms.

To avoid games taking too long to finish, there are two other constraints:

1. The maximum number of steps is 10 x map_size = 4000. If the hider is not caught within 4000 steps, the hider is considered a winner with the highest score of 4000.
2. If the game lasts more than 5 minutes on the testing computer, the game is aborted, and the player who thought for the least time is considered a winner with the best possible score (1 for the seeker, 4000 for the hider).

Rules and Considerations

Programming Language

The main challenge is to solve the puzzle. Thus, the specific programming language is not strictly required to solve it. However, to make competitive integrity and testing of many solutions possible, the language of the submission and the game is chosen to be Python for the easiest syntax.

Exploits

As the main challenge in solving the puzzle, the code is not intended to be exploitable. Thus, hacks and exploits are not the primary goal of this challenge; however, they are not forbidden. If you manage to find an exploit, you are welcome to do so and write your submission. Your entry in the table of records will be marked with (exploit), though, to indicate an out-of-the-box solution.

However, if you find a very trivial exploit/bug potentially exploitable by many people, it would be nice to fix it.

Performance Requirements

There are no CPU or memory requirements. But please, be reasonable within the standard computer capabilities.

As mentioned above, there is a mandatory time requirement of the game duration to be less than 5 minutes. If the game exceeds 5 minutes of execution time, the algorithm contributing most to the execution time will be marked as the loser!

This is to avoid any algorithms that think infinitely about the next step.

Please make sure your algorithms are not stuck in the infinite loops and don't break games!

How to submit?

You are expected to write your own modified version of the Seeker or Hider class.

The rest of the code should remain untouched. Your solution should be as easy as copy-pasting your class implementation into the existing code.

Detailed Constraints of the Implementation

1. You cannot modify the imports. NumPy is the only external package that you have.

2. Your class must inherit the Player class and have the same start of the constructor as the player class.

3. You are not allowed to modify input arguments to the constructor. This is all information that is available to you.

4. Your class must implement move() method that is repeatedly called in the game loop. It should change the player's position.

5. Your move() method should move the player position only one cell at a time. No teleportation!

6. Your move() method should not climb walls.

7. Your move() method should not escape the realm of the existing 20x20 world.

def Seeker(Player):
    def __init__(self, game_map, spawn_position, enemy_spawn_position):
        super().__init__(game_map, spawn_position, enemy_spawn_position)

    def move(self):
        next_pos = self.very_advanced_catching_algorithm()

        if movement_rules_obided(self.game_map, self.pos, next_pos):
            self.pos = next_pos

If your move() method does not follow these rules, the game will keep you at the current location.

Please make sure your code runs on a decently modern Python 3 and NumPy version. To be decided, which are the specific versions to use for testing. E.g., the current code runs fine for me with Python == 3.9.21 and numpy == 2.0.2.

Code Details

• main.py - main game loop logic and checks for rules
• map.py - map generation
• players.py - file containing Seeker and Hider strategies
• game_utils.py - spawn/vision/movement functions used in the game

Map Generation

The map is a 20x20 2D NumPy array. The values of 0 and 1 represent empty cells/walls, respectively.

You can check the map.py for details.

The axis=0 is considered an x position, and axis=1 is a y position.

python3 map.py 42

Map is generated with seed 42. Good connectivity? True. Wall fraction: 0.26.
[[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 0 0 1 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 0 0 1 1 0 1 1 0 0 0 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 0 1]
 [0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0]
 [0 1 1 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0]
 [0 0 1 0 0 0 0 0 1 1 0 0 0 0 1 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 1 1 0 1 1 1 1 1 0 1 1 0]
 [0 0 0 0 0 0 1 0 0 0 0 1 1 1 0 0 0 1 1 0]
 [0 0 0 0 0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0]
 [0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0]
 [1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0]
 [1 1 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 1 0]
 [0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
 [0 0 0 1 1 0 0 1 1 1 0 0 0 0 0 1 1 1 1 0]
 [0 0 0 0 0 0 0 1 1 1 1 0 0 0 0 0 1 1 0 0]
 [0 0 0 0 0 0 0 1 1 1 1 1 1 1 0 0 0 0 1 1]
 [0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 0 0 0 1 1]
 [0 0 0 0 0 0 1 1 1 0 0 1 1 1 1 0 0 0 1 1]
 [0 0 0 0 0 0 1 1 1 0 0 0 0 0 1 1 0 0 0 0]]
0 - empty
1 - wall
2 - seeker
3 - hider

Vision

The vision is defined in game_utils.py in see_each_other(game_map, seeker_pos, hider_pos).

The players have vision of each other and are given their corresponding coordinates if the line connecting them does not intersect the walls. The "exactly at the corner of the wall" cases are treated as no vision.

Example submission

The current code features example Seeker and Hider implementation. You can check them out and even run the game to get the feeling how everything works.

python3 main.py 42 42

Create a web game in only HTML and CSS, with no JavaScript

The player should receive a visual reward for reaching a winning position and should be able to replay the game without reloading the page.

Examples:
1. Find 7 differences between 2 images
2. Drag the pointer from the beginning of a maze to the end
3. Open a combination lock
4. Complete a task before a timer runs out

See here: https://merncraft.github.io/Pure-CSS-Games/

• Difficulty level: requires knowledge of some advanced CSS techniques

• Estimate of time to create the challenge: a few hours

• Specific technology that must be utilized: only HTML and CSS

Idea

Write a simple interpreter, transpiler, compiler or just short specs for a custom programming language that works in a unique way or has a unique gimmick.

The language can be esoteric (not meant for actual use) or actually useful in unique situations.

Difficulty: Easy to Very hard depending on the approach chosen and/or the complexity of the invented programming language.

Skills required:

• Imagination

• Knowledge on Tokenizing and Parsing

Criteria:

• Originality

• Effort

• Functionality

The Flawless Code Challenge

Challenge Idea:

Write a function that is so perfectly simple and self-explanatory that it requires zero comments and no one can possibly misunderstand it. The function should perform a basic, trivial task, but the real challenge is making the code so "clean" that even a beginner, fresh out of their "hello world" tutorial, would immediately grasp its profound genius. Submissions will be judged on a negative metric: the more comments people feel the need to add, the more you fail.

Why this is challenge:

• Spot the error (in everyone else's understanding): It satirizes the notion of "self-documenting code" and the endless debate over code comments.

• Build something: It's a simple coding task with a very difficult, subjective meta-challenge.

Challenge Details:

• Difficulty: Impossible (due to human nature :) )

• Time to Solve: 5 minutes to write, a lifetime to justify

• Skills/Technology: Writing un-commented, "perfect" code. A deep understanding of sarcasm is also required.

• Winner Selection: The community will "vote up" the code they believe is the most needlessly complex for the task at hand. The true winner will be the one who gets the fewest upvotes, because no one understood their brilliant submission.

I would love to see a challenge with technology age constraints, for example:

Write a program with a GUI that solves shuffled Rubix cubes and displays you the solution, BUT it works on Windows XP.

• Difficulty: Hard
• Time it can take: At least 2 weeks for a great submission by a non-expert
• Specific skills: Likely C, C++ or C#, and possibly a good understanding of the Windows API of that time, or the ability to read the docs for people who haven't ever used it yet. Frameworks would also be allowed, so long as they work on WinXP.
• Recommendations for awards:
  • Crowd favourite (ONLY if downvotes are implemented)
  • Interesting use of the Windows API, whether it's for computing the solutions or for rendering.
  • Least lines of code (for people who use a GUI framework instead of direct API calls, count the approximate number of lines of code that framework has, not counting Windows/Microsoft-provided DLLs)
  • Most impressive (for example, if someone did 3D with DirectX or something instead of sticking to 2D textures)
  • Works on an even older system (for example, if it not only worked on WinXP, but also Win98)

Write a CLI program that <insert conditions here> that runs on the oldest OS you can find

• Difficulty: Hard
• Time it can take: I'd say two weeks, but it depends of the condition found
• Specific skills: Likely low level languages
• Recommendations for awards:
  • Crowd favourite (ONLY if downvotes are implemented)
  • Oldest system confirmed to work on
  • Most obscure programming language used (Not talking about code golfing languages, but rather, very old and specific programming languages like Prolog or COBOL)
  • Smallest executable size or smallest code size (not counting spaces and newlines)

Write a C/C++ CLI program that solves <insert complex math problem here> that doesn't use the standard library, any OS-specific API, nor architecture-specific inlined assembly instructions, so it is as universal as possible

• Difficulty: Medium
• Time it can take: One to two weeks depending of the math problem chosen
• Specific skills: C/C++
• Recommendations for awards:
  • Crowd favourite (ONLY if downvotes are implemented)
  • Oldest system confirmed to be compilable and executable on
  • Smallest executable size or smallest code size (not counting spaces and newlines)
  • Fastest program to solve the math problem

Challenge Idea: Build a “Traffic Light Simulator” Web App

Traffic systems are everywhere, and they can get chaotic! The challenge is to build a simulator where cars spawn randomly at each side of a traffic light, follow rules, and have fun personalities.

Requirements:

• Cars spawn randomly with varying numbers and types at each traffic light side.

• Traffic rules should be respected (e.g., don’t block turning lanes, obey light cycles).

Bonus:

• Add weather conditions (rain, fog, etc.) that affect driving behavior.

• Cars can have unique traits like drifting while turning, honking when the light turns green, etc.

• Include pedestrians crossing.

• Implement car crashes or collisions for chaotic fun.

Difficulty: Medium-hard (logic-heavy with room for creativity).

Time Estimate: 8–24 hours depending on depth of features.

Skills Needed: HTML, CSS, JavaScript (with optional canvas animations or game libraries).

Winner Selection: By upvotes (most fun/creative simulator wins).

Console Gamer

Create a fun console app game that can be downloaded / accessed and run.

Provide a short explanation of the game and instructions for downloading / accessing and running the game.

There is a lot of freedom for this challenge, and the game can take many form e.g. text based adventure game, card game, scrolling shooter.

Credit will be given to the most fun, creative and interesting games.

Rules

The game must be a console app based game

NO AI GENERATED GAMES!
You can use AI for ideas and assistance but no games that are just generated by AI. Provide full disclosure of any AI assistance used to create the game.

Difficulty: easy-intermediate
Estimated Time: 1-12 hours
Winner Selection: Most upvoted games - voters should vote for games that are fun, demonstrate creativity or capture interest
Skills: Any programming language - produce a console app game

Create an ASCII-Art Maze generator, bonus for programm solving your maze

Challenge Idea: Build a “One-Line Diary” Web App

We all write notes, todos, or even thoughts somewhere. The challenge is to build a web app where a user can write exactly one line per day (like a micro-diary).

Requirements:

• User can log in (simple auth or mock auth is fine).

• Each day they can write only one line. If they try to add a second one, they should get a small message like "Diary for today is already written".

• Show a history view where all past entries are listed with dates.

• Bonus: Add edit option within first 5 minutes after saving (after that, lock it).

Difficulty: Easy-medium. (Anyone can do basic CRUD, but the "only one entry per day with a small rule" makes it a bit tricky.)

Time Estimate: 2-4 hours depends.

Skills Needed: Basic frontend (React, Angular or plain HTML/JavaScript) + any backend (Node, Python, etc.) with DataBase.

Winner Selection: Members favourite (upvotes) or Best UI/UX.