What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

| |

2871 Answers 2871

21 22
24 25

Maximize the Hello, world's in code permutations

In this task you should output this exact string: hi orb (because Earth is a sphere). However, here is the catch: you must output as many hi orb's as possible in all of your code permutations. Identical permutations do not count(e.g. aa's permutations count as one permutation)

Say you have a program abc that outputs this string. You should try your best to make acb, bac, bca, cab, and cba (i.e. the permutations of abc) also output this exact string.


  • No standard loopholes, please.
  • Input/output must obey our standard methods.
  • Your score is simply the factorial of the length of your code. You shall also present the following score: The score is counted in the negative of the length of your source code divided by the number of permutations that your code generates; (expression: -(source length/permutations).) Of course you want to keep your score as low as possible.
  • All comment characters in your language are disallowed, in order to avoid collapsing into a radiation-hardening challenge.
  • If you are using the filename as data, the filename must also count in the permutations.
  • The source code length should be <1000. (Don't ask why, it's just an attempt of avoiding abusing the source code length.)


  • Is it detailed enough?
  • Is the input/output rules clear enough?
  • Do I need any more information?

I don't think this is a duplicate because nobody has asked a question tagged with both permutation and hello-world. However, I worry that this challenge will collapse into a radiation-hardening challenge if you comment out a single character and then make sure that this will produce the same result, therefore making it a flavored version of this question and close to a duplicate.

| |
  • \$\begingroup\$ Can't you just extend your score by increasing your byte counnt, as long as you have some commented out part or no-op? \$\endgroup\$ – Jo King Sep 19 '19 at 8:50
  • \$\begingroup\$ Unneccecary NOPs are disallowed, and at least 1 permutation of your code must only contain relevant code and nops. is rather vague, since no-ops aren't really defined, nor is this challenge really that possible to increase score if you don't have no-ops, otherwise it will turn into a duplicate of the normal Hello World question \$\endgroup\$ – Jo King Sep 19 '19 at 9:25
  • \$\begingroup\$ This reminds me of a challenge I sandboxed a while ago, but deleted since it was clear it would produce only trivial answers \$\endgroup\$ – Jo King Sep 19 '19 at 9:27
  • \$\begingroup\$ code-golf scoring usually has lowest score (=code length) wins. If you break with that convention, you should mention it in the rules. I think a big problem with this is that for any non-trivial answer (Like H in HQ9+), the proof of correctness of the score is almost impossible, because unlike radiation-hardening, the amount of variants increases factorially instead of linearly with the code length. \$\endgroup\$ – AlienAtSystem Sep 19 '19 at 11:52
  • \$\begingroup\$ Hmm, it is okay, I will make the score negative then. I believe a program running the permutations of a string (not counting repeated ones) and evaluating them to check the result will be sufficient. Hmm, that's why the submittor needs to golf their code: to allow others to check their answers. \$\endgroup\$ – user85052 Sep 19 '19 at 12:09
  • \$\begingroup\$ That's where it's unfeasible: The highest-scoring answer in the challenge you linked has 96 bytes. That's 9.9*10^149 permutations to check if they output the correct result. Even assuming your implementation is the fastest possible, that would take years, just for that single answer. You can't brute-force determine the score, but using mathematical trickery to try and calculate the score by hand will be arduous and prone to errors. \$\endgroup\$ – AlienAtSystem Sep 19 '19 at 13:10
  • \$\begingroup\$ I don't think the limitations you have put are going to prevent this from falling apart. For example, this Pyth program works for any permutation of the code where only characters after the third " are permuted. Completely filling up the code allowed will achieve a score exceedingly close to zero. I don't think that is what you want, but I'm not really sure you can fix it (like what happened to Jo King), sorry. \$\endgroup\$ – FryAmTheEggman Sep 19 '19 at 18:38
  • \$\begingroup\$ @FryAmTheEggman this particular snippet fails the rule that all code needs to be relevant. However, even if we tighten the rule to all code being life and necessary, that is, in one permutation, all code is executed, and a deletion of any statement resulting in the code not outputting "Hello World" any more, you can still cheese the challenge by bloating the code. The only way to stop that would be to change the scoring method to also use the factorial of the byte count, but then A) HQ9+ is unbeatable and B) It's a math challenge because you have to calculate the amount of viable permutations \$\endgroup\$ – AlienAtSystem Sep 20 '19 at 10:06
  • 2
    \$\begingroup\$ Instead of helo word, wouldn't it make more sense to just use a different phrase like greeting earthlings or something along those lines? I agree with @AdmBorkBork that helo just looks weird. I do think it shouldn't be hello world to prevent builtins, so helo word is already better, but it still looks weird and will raise questions for sure.. \$\endgroup\$ – Kevin Cruijssen Sep 20 '19 at 12:38
  • \$\begingroup\$ I don't understand the scoring. If we're scored only on the factorial of the length of code, why does it matter how many permutations output hi orb? I would figure that the number of ways that is output should factor into the scoring somehow... \$\endgroup\$ – AdmBorkBork Sep 20 '19 at 14:11

The Celestial Bureaucracy


| |
  • \$\begingroup\$ This sounds like a lot of fun. When the exam is asked, is it possible to know which bot gave the exam? \$\endgroup\$ – Pureferret Sep 18 '19 at 11:58
  • 2
    \$\begingroup\$ You are given the ID of the bot via the parameter for ask, which allows you to identify if you've interacted with that bot before and if it's the Jade Emperor (because his ID is always -1). You won't get the name - if you want to identify the bot, you'll have to analyse its question and answer pattern. \$\endgroup\$ – AlienAtSystem Sep 18 '19 at 12:08

Creep Spread Territorial Control (WIP)


Blah blah blah flavor blah blah blah something about Starcraft blah blah blah


Initial State

There is a 150x150 grid of square cells with approximately 7500 random cells missing in a symmetric Perlin noise pattern. There are four creep spread factions competing for dominance of this territory beginning as a single cell 10 cells in from a corner of the grid (one faction per corner). Each faction starts with 50 energy. The board does not wrap around at the edges.


Each turn, each faction earns 1 point of energy for each controlled cell plus 20 base energy. This energy is used for expansion. How much a cell costs to expand to depends on how many cells controlled by the same faction are in the Moore neighborhood of the target cell.

  • 0 neighbors: cannot expand to this cell
  • 1 neighbor: 50 energy
  • 2 neighbors: 20 energy
  • 3 neighbors: 12 energy
  • 4 neighbors: 8 energy
  • 5 neighbors: 5 energy
  • 6 neighbors: 3 energy
  • 7 neighbors: 2 energy
  • 8 neighbors: 1 energy

There is no limit to how many cells can be expanded to in one turn other than energy costs. All expansions occur simultaneously. If two or more factions attempt to claim the same cell on the same turn, the one with the most neighbors of its own faction will claim the cell. If there is a tie, none of the factions claim that cell. Players whose expansions failed due to competition will not be refunded. Factions may expand onto each other's territory, stealing ownership of the cell.

Game End

The game lasts 10,000 turns or until there is only one faction remaining, whichever happens first. The winner is the faction with the most owned cells. Ties are broken by remaining energy.

The overall winner will be resolved with a randomized pool where each bot plays an equal number of games followed by 12 games of the top 4 contenders. (one for each possible corner positioning)


Write a bot that plays this game

  • Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer between \$0\$ and \$2^{32}-1\$ will be passed to the bot, which will be seedable in the controller.
  • Bots have perfect information of the current state of the board, which turn it is, and their own energy, but not the energy of other players.
  • Bots may not remember anything between turns, but may initialize constants and utility functions at the beginning of each game.

The list of desired expansions is ordered. As soon as an invalid expansion target cell is encountered (whether by cost or lack of same-faction neighbors) in this list, the rest of the list will be ignored and a warning will be logged.

| |
  • \$\begingroup\$ So if I build at 0,1 and 1,0 on the same turn while having a cell at 0,0, the cost would be 2000, yeah? Are failed expansions refunded? Also, I think having a source of randomness would be good. \$\endgroup\$ – Veskah Sep 13 '19 at 17:40
  • \$\begingroup\$ @Veskah, that would cost 2000, correct. I'll add some rules about when failed expansions are refunded. \$\endgroup\$ – Beefster Sep 13 '19 at 19:38
  • \$\begingroup\$ Suggestions: 1. Maybe allow expanding to own territory too? Could be used as a defensive mechanism when you can predict that you are going to be attacked. (should be thought about, could be bad) 2. Maybe set a limit on how many cell expansions can happen per turn to avoid exponentially expansion? I'm thinking that a bot which gains some advantage might get unstoppable when it is unlimited. \$\endgroup\$ – Night2 Sep 14 '19 at 7:33
  • \$\begingroup\$ 3. More clarification in rules about expansions, for example if player 1 and 2 have a tie on this turn for cell X and they both go for it, but player 1 also goes for a neighbor of cell X in same turn, will player 1 win? (@Veskah mentioned another scenario too) 4. I would suggest using JavaScript so more people can write and run the code (anyone with a browser can do it), also a controller with some helper functions could be nice, for example a function which returns expansion cost for a cell in an optimized way to avoid tens of different implementations for same common action. \$\endgroup\$ – Night2 Sep 14 '19 at 7:39
  • \$\begingroup\$ 5. "Bots have perfect information of the current state of the board.", does this include current energy value of other players? \$\endgroup\$ – Night2 Sep 14 '19 at 7:45
  • \$\begingroup\$ @Night2 1 Interesting. It seems a bit fiddly. 2 This should actually come out to a quadratic expansion rate since where you can expand to is derived from perimeter, which grows linearly. 3 All expansions are resolved simultaneously (as in Conway's Game of Life), so player 1 does not win that tie. 4 Javascript is the likely plan since I intend to have a significant graphical component. 5 I'll have to think about it. That could be rather interesting as 'private' information. \$\endgroup\$ – Beefster Sep 15 '19 at 3:00
  • \$\begingroup\$ 6. Proposal to spice things up: board is randomly generated, with some cells being unavailable for expansion. Uniform random, Perlin/Simplex noise, cellular automaton-based cave generation, etc. 7. Will the bots have access to the turn counter? 8. Maybe rotate and/or mirror the board provided to the bots so that each bot starts at, for example, the top-left corner from its perspective? \$\endgroup\$ – Alion Sep 15 '19 at 10:36
  • \$\begingroup\$ 9. Allow bots to pre-calculate some data on load or game start. This will allow people to speed up their bots. Especially useful if you end up implementing 6. \$\endgroup\$ – Alion Sep 15 '19 at 10:47
  • \$\begingroup\$ @Alion 6 That sounds pretty interesting. I'll probably expand the board slightly in that case. 7 Yes, they'll know what turn it is. 8 I don't think that adds much. I'm probably going to have to make copies of the board every turn anyway to make it impossible to cheat on accident though... 9 Seems reasonable. \$\endgroup\$ – Beefster Sep 16 '19 at 0:39
  • \$\begingroup\$ "Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer ... will be passed to the bot, which will be seedable in the controller.". Why not make a custom random function available or override the default random generator and make the controller generate and handle the seeds? For example in JavaScript users can still use the normal Math.random(), but you can use this to make it deterministic: davidbau.com/archives/2010/01/30/… \$\endgroup\$ – Night2 Sep 21 '19 at 11:21
  • \$\begingroup\$ @Night2, yeah. I'll probably do that since I'm going to have to use an RNG library anyway. \$\endgroup\$ – Beefster Sep 22 '19 at 2:32

Turing-complete regex subset

It's widely known that a programming language is one iff it's capable of addition of natural numbers and primality testing. In practice, this criterion has a high accuracy for distinguishing Turing-complete languages too.[citation needed]

Cops' challenge

Choose any of the programming languages available on tio.run. Write a regex that will define a subset of this programming language. The subset must still match the definition, though ideally this should be far from obvious.

Write two programs in this language that match this regex:

  1. Take two natural numbers, a and b, as input. Output a + b. The program must work for 0 ≤ a + b < 215.
  2. Take a natural number n as input. Output whether the number is prime. The program must work for 0 ≤ n < 215.

The behavior outside of this range is undefined. This means that you can output the correct answer, a cute cat ASCII art, an error, an invalid answer, invoke nasal demons, or anything else you can, or cannot, imagine.

Regex come in multiple flavors. Choose one. You can choose any flavor available on regex101, or Retina.

In your answer, include:

  • the programming language and regex flavor you chose
  • the regex delimiter and flags you chose (for example: //gm; does not apply to Retina)
  • the regex you wrote and its byte count
  • the byte counts of your two programs

Keep the programs hidden. If 7 days pass without anyone cracking your answer, you may reveal your two programs by editing them into your answer. This will make your answer safe. Your score then becomes your regex's bytecount (lower is better). Before your answer is safe, your score is positive infinity.

Robbers' challenge

Write two programs that prove the subset to be a valid programming language. The rules that apply here are the same that apply to the cops. Additionally, your programs must not exceed the cops' in length.

When you crack an answer, post your programs to the robbers' thread.

Meta questions

The above will be posted as the cops' thread, with the robbers' thread simply linking to it.

  • Any improvements to challenge structure? I've never done this before.
  • Do you see any loopholes that need addressing?
  • Are the allowed regex flavors reasonable?
  • Duplicates?
| |
  • \$\begingroup\$ I think this is a duplicate of codegolf.stackexchange.com/questions/136150/… \$\endgroup\$ – pppery Sep 22 '19 at 18:11
  • 1
    \$\begingroup\$ @pppery Hmm. These are definitely pretty similar. On the other hand, regexes might allow more interesting answers. \$\endgroup\$ – NieDzejkob Sep 22 '19 at 18:25
  • 1
    \$\begingroup\$ I'm not convinced this is a dupe since most of the interesting work here is in selecting the regex rather than in choosing a sequence, though I think the other challenge is cleaner. I think the optimal scoring regex will usually be to make an "unhash" that produces the appropriate programs. Unfortunately I don't have any suggestions at the moment to help fix that, but if you can then I think this is alright. \$\endgroup\$ – FryAmTheEggman Sep 22 '19 at 18:32
  • \$\begingroup\$ @FryAmTheEggman I can't see what you mean by "unhash" here. Could you elaborate? \$\endgroup\$ – NieDzejkob Sep 22 '19 at 18:36
  • \$\begingroup\$ Consider this program which performs the first task. The regex that matches only programs like this would be short but but not very informative. I think doing this but making guessing the magic number arbitrarily hard would usually be the best approach in a given language. \$\endgroup\$ – FryAmTheEggman Sep 22 '19 at 18:43
  • \$\begingroup\$ @FryAmTheEggman Like, /^\.vC\d+$/? I think that making it complicated enough would take quite a lot of bytes. \$\endgroup\$ – NieDzejkob Sep 22 '19 at 19:02
  • \$\begingroup\$ The point is that the number could be manipulated, so I could pad my program arbitrarily until I got a number that let me write a regex like ^...(2|10|76|345?)*$. That's neither very long nor easy to crack. \$\endgroup\$ – FryAmTheEggman Sep 22 '19 at 19:06
  • \$\begingroup\$ I like the idea of the challenge but I feel including the bit about Turing completeness is a bit of a red herring, it only really distracts from the challenge. \$\endgroup\$ – Ad Hoc Garf Hunter Sep 22 '19 at 21:30
  • \$\begingroup\$ To elaborate the particular part I like is regex selection part. I do agree that my challenge is a bit cleaner otherwise. \$\endgroup\$ – Ad Hoc Garf Hunter Sep 22 '19 at 21:31

Calculate the Ultraradical

| |
  • 1
    \$\begingroup\$ I'd recommend removing the text with a strikethrough; I think it is just confusing. "Accurate to 6 significant digits" isn't a very good validity criterion since it would require testing each and every possible input the program could handle. I'd recommend saying it has to be that accurate for your test cases but not be hardcoded for them, or something like that. \$\endgroup\$ – FryAmTheEggman Sep 19 '19 at 19:33

Byte-sized Huffman Coding (WIP)

Huffman codings are a method to compress data with certain frequency properties, usually text. Normally, these operate on bits rather than bytes, but this challenge will instead operate on whole bytes instead. Since you wouldn't get any benefit otherwise, you can represent multiple consecutive characters with a sequence of one or more bytes, for instance '. ' (a period followed by a space) could be represented by byte 1, 'The' could be represented with byte 2, and 'Ishmael' could be represented by a 255 then a 7 (among many other sequence codings).


Create a program that compresses a plain-text version of a work of literature by returning a byte-wise Huffman coding table and a sequence of bytes that represents the text with that table.

Rules and Assumptions

  • You may assume that the text is written in English and uses only printable ASCII characters plus space, newline, and tab.
  • It must be a proper Huffman coding; no mapping may be the prefix of another.
  • Not all Huffman sequences need to be mapped to a particular character sequence; you could, for instance, not have 7 mapped to anything or not have 255, 39 mapped to something, but have every other 1 and 2 byte sequence mapped to something.
  • The returned coding table must be able to encode every possible sequence of valid characters (as per the first assumption above). The simplest way to do this is to make sure that every individual character is mapped to a Huffman byte sequence.
  • It can be possible to encode a body of text multiple ways using the returned encoding table. If both ca and at are mapped to byte sequences, cat could be encoded two ways. This is totally fine.
  • Case must be preserved.
  • Runs do not need to be deterministic, i.e. two runs of the same program with the same input could produce different Huffman tables and compressed output.
  • Your program must return a result within a reasonable amount of time to be considered a valid solution. (If you want a hard limit, I'll say 5 minutes on a 2GHz Intel dual-core i5 with 16 GB RAM running Windows 10)


Your results will be run against a corpus of (TBD) 12 publicly available literary (and non-fiction) works. For each work of literature, your score will be the size, in bytes, of the compressed text, plus the total length of all text strings mapped to a byte sequence in the Huffman-coding table. Your overall score is the total score across all 12 works.

Literature list

  • The King James Bible
  • Hamlet by William Shakespeare
  • Dracula by Bram Stoker
  • Frankenstein by Mary Shelley
  • On the Origin of Species by Charles Darwin
  • Moby-Dick by Herman Melville
  • Little Women by Louisa May Alcott
  • Tom Sawyer by Mark Twain
  • Pride and Prejudice by Jane Austen
  • The Hound of the Baskervilles by Arthur Conan Doyle
  • < Something that entered the public domain in 2019 because it was published in 1923 >
  • < Something written in the last 20 years willingly released into the public domain or with a Creative Commons license that allows derivative works >


At least one of the last two literary works should preferably be written by a female author to hopefully make writing styles diverse enough to make hard-coded Huffman tables ineffective. Each work should be comparable in length to the other works.

Links to these books (in plain text) would be appreciated. Substitution suggestions are welcome.

I'm considering using something like the Weissman Score relative to gzip for the scoring method so that performance is factored into the score, but I'm concerned about reproducibility of time since that tends to vary even on the same machine due to caching and OS scheduling.

| |
  • \$\begingroup\$ If you want to vary writing styles, is there a non-fiction work that only contains the allowed characters? \$\endgroup\$ – trichoplax Sep 24 '19 at 23:21
  • \$\begingroup\$ @trichoplax The most notable non-fiction book I can think of for that would be "On the Origin of Species" by Charles Darwin. I've also thought about throwing in the King James bible. Maybe I could bump up the total to 12 works. I also probably will drop War and Peace because the plain text version I found was machine converted and has issues. \$\endgroup\$ – Beefster Sep 25 '19 at 15:21
  • \$\begingroup\$ Regarding plain text books, have you checked Project Gutenberg? They have plaintext versions of many of their books. \$\endgroup\$ – AdmBorkBork Sep 25 '19 at 18:35
  • \$\begingroup\$ I have no idea how much sample text is a good amount for this challenge (number of books, length of books) but it's probably worth doing some kind of rough check that there is enough text to give variation between answers (no optimal solution) while still being little enough text that running in a reasonable time is realistic (doesn't require weeks of work before an answer is efficient enough to meet the time restriction). Maybe others can suggest good ways of approximating this? \$\endgroup\$ – trichoplax Sep 25 '19 at 20:16
  • \$\begingroup\$ @trichoplax so basically you suggest sampling out, say, a few chapters instead of the whole book and then reducing the required runtime? I'm open to that, especially since the word count difference between Hamlet and the Bible is so big. The interesting thing about the Bible is that it has a ton of different authors, so it would almost be better to have the first chapter of each book instead of inserting, say, the entirety of Genesis. \$\endgroup\$ – Beefster Sep 26 '19 at 4:41
  • \$\begingroup\$ I couldn't guess at this point whether more text or less text would be better, and I don't have a way of estimating, just wondering if anyone else does. \$\endgroup\$ – trichoplax Sep 26 '19 at 7:32
  • \$\begingroup\$ I see no problem with 5 minutes as a rough time limit. I'd lean towards a time limit that allows someone to write a quick answer and then improve on it gradually, to encourage more participants. How long that needs to be for the text you settle on I don't know. As long as you're confident an optimal solution can't be found, you could just time a naive approach and then choose a time that doesn't exclude that. Then you can get lots of early answers to get the competition going, but still have open ended improvement over the long term \$\endgroup\$ – trichoplax Sep 26 '19 at 7:38
  • \$\begingroup\$ Not to say that this isn't an interesting challenge as it is but I do wonder if it wouldn't be more interesting without requiring that we use Huffman Encoding? \$\endgroup\$ – Shaggy Sep 27 '19 at 22:21


| |
  • 1
    \$\begingroup\$ For the tiebreak, what does code with the fewest bytes mean, given that we're outputting a county assignment? \$\endgroup\$ – xnor Oct 7 '19 at 22:24
  • \$\begingroup\$ @xnor - I modified the scoring mechanism to not require tie breaks. Thanks to this modification, I expect the code submissions to be much more interesting. \$\endgroup\$ – Dustin G. Mixon Oct 8 '19 at 17:06
  • \$\begingroup\$ I like your new assignment score and no longer having a code golf tiebreak.The leave-one-out looks kind-of complicated and might take a long time to run-- is there a way to simplify it? The challenge looks a lot more intimidating that when I last commented, though the idea looks the same. I guess you want to make sure people actually write code that kind-of generalizes rather than possible finding an assignment by hand. Maybe also consider something with the standard deviation in assignment place of the max-min ratio so there's also an incentive to try to balance populations in the middle? \$\endgroup\$ – xnor Oct 8 '19 at 22:48
  • \$\begingroup\$ @xnor - Great points, thanks! I simplified things by cutting the number of leave-one-out instances by a factor of 10. (I selected these 10 counties based on political geography considerations.) I also toned down the math speak to make the challenge less intimidating. I thought about standard deviation instead of max-min, but max-min is closer to how we enforce one person, one vote in practice. \$\endgroup\$ – Dustin G. Mixon Oct 9 '19 at 2:20

I came across this little web game Drench Its a fairly mindless game , I wrote a small JS snippet to play this game for me in the background of my browser, it cycles through and clicks on the 6 possible moves

let ind =0;
let games =0;
let wins =0;
let lastMoves = "";
  if (jQuery('.moveNum').text() != lastMoves) {
    lastMoves = jQuery('.moveNum').text();
    ind = ind%6;
  } else {
    if ((jQuery('.moveNum').text()*1)) {wins++;}

This Strategy wins about 3% of the time My question is, is there a more optimal strategy that will allow me to win a greater % of the time (without looking at the board)?

| |
  • 3
    \$\begingroup\$ Hi and thanks for using the sandbox! Though this is a bit unusual for this site, I think your question is on-topic, just far too broad. "Can I do better" just isn't something you can really ask on the SE network. I think the best way for you to move forward is to fully explain the game in the body of your post, and then score submissions based on their win percentage. \$\endgroup\$ – FryAmTheEggman Sep 21 '19 at 19:37
  • 1
    \$\begingroup\$ I really like the idea though - I think win% is the way to go \$\endgroup\$ – simonalexander2005 Sep 23 '19 at 15:20
  • 1
    \$\begingroup\$ Make this a code-challenge? To verify, you can run it for, for example, 500 times and calculate the winning percent? \$\endgroup\$ – HighlyRadioactive Oct 13 '19 at 8:49
  • \$\begingroup\$ Coded this up in p5.js, you can play it here hoppingmad9.github.io/dench Happy to convert it to pure js if needed and could add an interface to get the board state and input moves. \$\endgroup\$ – Sam Dean Oct 18 '19 at 12:14
  • \$\begingroup\$ oops, well I guess the code golf version can be called "Dench" not "Drench". I thought "Dench" was a weird name \$\endgroup\$ – Sam Dean Oct 18 '19 at 15:29
  • \$\begingroup\$ Probably needs a time limit for each turn to prevent people trying every single possibility of moves \$\endgroup\$ – Sam Dean Oct 25 '19 at 15:39

Create a safe crossing.

Given a string/number/array of any two distinct characters make the "squarest" 2D array that allows "someone" to cross from left to right or top to bottom "stepping" only on whichever character you have chosen as your stepping stone


Make the "squarest" array possible that contains a complete row or column of stepping stone characters. (clearer but takes away the fun story-ness)

"squarest" meaning smallest difference between the dimensions of the 2D array.


  • A string/number/array of your choosing consisting only of your two chosen distinct characters. So no error checking needed. Allow true/false values if input is array?
  • input will have at least 1 stepping stone character so that a valid solution is always possible 1 by x or x by 1
  • a minimum length of x? needed? might make it easier if there's some weirdness with very short arrays in the algorithms people come up with
  • the last row can be incomplete to allow for prime number length inputs and to more easily allow non trivial 1xX/Xx1 answers


The output should be the dimensions of the array

  • and specify the row or column to use?
  • print your 2D array so that the path can be seen graphically?

Test Cases

100100100 -> 3x3 array


11111000 -> 4x2 or 3x3 - 3x3 is squarer so is correct

1111    111
1000    110

11000011000101001001 -> 5x4


1000000000000 -> 12x1 - trivial as only 1 stepping stone


010111 -> 3x2 or 2x3 - either acceptable as both are only "1" away from square

010    01
111    01

This is code-golf so the shortest code in bytes wins.


  • allow diagonal crossings? does that make it a lot harder?
  • need a lot more test cases I think?
  • input spec
  • output spec
  • better/more tags?
| |

ASCII Sum of your code

Encoding is nice, adding things is also nice. Let's do both !

Your task will be to create a program that read itself, convert every of its character into ASCII values and return the sum of those numbers.


Let's say your program is Hello, world !. Convert every character into ascii values

H  e   l   l   o   ,  (space) w   o   r   l   d   (space) !
72 101 108 108 111 44 32      119 111 114 108 100 32      33

Now, sum everything into a meaningless very useful value

72 + 101 + 108 + 108 + 111 + 44 + 32 + 119 + 111 + 114 + 108 + 100 + 32 + 33
= 1193

Here it is, Hello, world! returns 1193 !


  • The code have to read itself and calculate the result
  • Standard loopholes are not allowed
  • This is codegolf, so the fewer bytes wins.
  • Non-standard languages with non-ASCII characters should use their own codepage's encodings (Thanks for @Veskah for this rule)


  • Is the challenge clear enouth ?
  • Is there an already existing challenge like this one ?
  • is this considered as a duplicate of this challenge ?
| |
  • 2
    \$\begingroup\$ I would probably have non-standard languages use their codepage's encodings (pretty much all of them should be 8 bytes) to crunch their output. The big hammer approach would be to ban non-ASCII languages but I would not recommend that. \$\endgroup\$ – Veskah Oct 23 '19 at 14:06
  • 3
    \$\begingroup\$ Requiting the code to read itself and do the calculation is a non-observable requirement. Since it seems you don't want programs that just hardcode the value, I think the best way to be just to require the program take in an input string to use. Regardless, I don't really see room for interesting golfing in the challenge, since pretty much any normal-ish language has built-ins to take ASCII values and compute sums, and weird languages that don't have already done these as subtasks for many many challenges. \$\endgroup\$ – xnor Oct 25 '19 at 0:52
  • \$\begingroup\$ @xnor Does this challenge with string input already exist ? \$\endgroup\$ – The random guy Oct 25 '19 at 7:06
  • 2
    \$\begingroup\$ I don't remember an exact one, but I'm finding very close ones: averaging ASCII values and summing then counting binary 1's, which was closed as a duplicate of one without the character adding. I also found an unrestricted quine challenge with the same task as yours. So I think there's a good chance this would be closed as a duplicate either way. \$\endgroup\$ – xnor Oct 25 '19 at 7:11
  • 1
    \$\begingroup\$ Yup, the last one is quite the same as mine. Duplicate it is then. \$\endgroup\$ – The random guy Oct 25 '19 at 7:13

It's slashing time

(Inspired by Seven Slash Display)

You're lying in bed, awake. Sleepily, you turn your head to the alarm clock and read what time it is. Since you're lying down, the clock is facing diagonally, making it difficult to read. You decide to write a program to help you out (hey, you're awake anyway).

Given a "slashed" seven-segment display, output what time it is in 24-hour format.

    /\  /
    \ \
   . \/
 /\ .


You can choose where to place the : between the numbers (for example, evenly spaced as above or left-aligned as below, etc.), but the : must be present.

Some further examples:

  / . /
 \  /




Here are the precise digit shapes:

\ \










Rules & Standard I/O boilerplate

  • The time will always be valid. For example, you'll never receive something like 30:25 or 7:99 or the like.
  • You're allowed to pad the input with whitespace however necessary (e.g., padding it to always be a rectangle with trailing spaces).
| |
  • \$\begingroup\$ Input always a valid time? Can we shift the dots? \$\endgroup\$ – Veskah Oct 29 '19 at 19:01
  • \$\begingroup\$ 2 in 2:03 is not aligned with other digits :( \$\endgroup\$ – tsh Oct 31 '19 at 8:53
  • \$\begingroup\$ @tsh Indeed it wasn't. Thanks for the correction! \$\endgroup\$ – AdmBorkBork Oct 31 '19 at 15:11

Room volume as a function of paint on the walls/ceiling

Task: Write a function that will take in the size of a room (height, width, and length) and a number of paint layers (given that the layers are of a consistent thickness) and return the area of free space in the room after that many layers of paint are applied.


  • Return the final area left in the room after the paint layers are added
  • should be able to run on a room of any size
  • The answer must account for the decreasing area in the room as each layer is applied.
  • number of layers and paint layer thickness should both be inputs
  • must account for walls and ceiling
  • standard loopholes are disallowed

The winner is determined via byte count

| |
  • 1
    \$\begingroup\$ How thick is each coat of paint? Also, do you mean return the volume of free space in the room? \$\endgroup\$ – girobuz Nov 14 '19 at 4:30

Substitute Unprintable ASCII Characters

Have y'all ever written an answer with unprintable ASCII characters in it and wished that there was an easy way to represent those characters in a printable way? Well, that's why the Control Pictures Unicode block was invented.

However, manually substituting these characters into one's answer is time-consuming, so that's what today's challenge is about: swapping out the nasty invisible characters for nice, readable characters.


You will be given strings that contain a mix of ASCII-only characters (i.e. the UTF-8 code point of each character will be in the range: \$0 \lt char \le 127\$).


For all unprintable characters, replace it with its corresponding character in the Control Pictures Unicode range.

In other words:

  • Characters in the range \$0 \lt char \lt 9\$ are replaced with their corresponding character
  • Vertical tabs and newlines (9 and 10) aren't replaced
  • Characters in the range \$11 \le char \lt 32\$ are replaced with their corresponding character
  • Spaces (32) aren't replaced
  • The delete character (127) is replaced with its corresponding character:


Characters are given as escapes for nice formatting here, but each character will be replaced with the unprintable character

In -> Out
\x1f\x1c\x1f\x1e\x1f\x1e\x1f\x1f\x1e\x1f\x1e\x1f -> ␟␜␟␞␟␞␟␟␞␟␞␟
Hello\x07World! -> Hello,␇World!
\x01\x02\x03\x04\x05\x06\x07\x08\x0c\x0b\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f\x7f -> ␁␂␃␄␅␆␇␈␌␋␎␏␐␑␒␓␔␕␖␗␘␙␚␛␜␝␞␟␡


  • All standard loopholes are forbidden
  • Character substitutions must be made according to the Control Pictures Unicode block


This is code-golf so the answer with the fewest amount of bytes wins.

Test-Case Generator

I have provided a test case generator for y'all. It prints inputs in the way they will be passed to your program and outputs the expected result.

Try it online!

| |
  • \$\begingroup\$ "DEL" (ASCII 127) is also unprintable. Also, did you mean 0≤char≤127? \$\endgroup\$ – Bubbler Nov 15 '19 at 8:00
  • \$\begingroup\$ Updated! (I forgot DEL wasn't printable) \$\endgroup\$ – Lyxal Nov 15 '19 at 8:04
  • \$\begingroup\$ I think you need to give test input as JSON (i.e. with escapes) \$\endgroup\$ – Adám Nov 15 '19 at 8:46
  • 1
    \$\begingroup\$ Space has a substitution character (). Should it be replaced? I think you should clearly state that ≤ (or < 32) and 127 should be replaced. \$\endgroup\$ – Adám Nov 15 '19 at 8:48
  • \$\begingroup\$ Updated accordingly. \$\endgroup\$ – Lyxal Nov 16 '19 at 1:33

List of integers to pairs ?? Any suggestions for the title ??

Write a function or a full program taking a list of non negative integers numbers L that outputs a pair of numbers [X , Y] such that X %( Y + i ) == L [ i ] .

Output specifications

  • You can output X Y in any order, just indicate it and be consistent.
  • X Y are also unsigned integers, obviously Y must be greater than 0 to avoid modulo 0 errors.
  • If your language doesn't support 0 indexed list you can consider X %( Y + i ) == L [ i + 1 ] ?? Any suggestions how to handle this ??


[ 1, 2, 3 ] => [ 11, 2 ]

 11 %( 2 + 0 ) = 1
 11 %( 2 + 1 ) = 2
 11 %( 2 + 2 ) = 3

[ 10, 2 ] => [ 98, 11 ]

 98 %( 11 + 0 ) = 10
 98 %( 11 + 1 ) = 2

Test cases

[ input ] , [ output ] pairs

[ 0, 1, 2 ] ,  [ 5, 1 ]
[ 1, 2 ] ,  [ 5, 2 ]
[ 1, 2, 3 ] ,  [ 11, 2 ]
[ 1, 2, 3, 4, 5 ] ,  [ 59, 2 ]
[ 4, 3, 2, 1, 0 ] ,  [ 9, 5 ]
[ 6, 12, 18 ] ,  [ 3318, 18 ]
[ 27, 18, 9 ] ,  [ 279, 28 ]
[ 3, 9, 27 ] ,  [ 4059, 26 ]
[ 2, 4, 8, 16 ] ,  [ 8584, 14 ]
[ 0, 0, 0, 0, 0, 0 ] ,  [ 60, 1 ]
[ 1, 1, 1, 1 ] ,  [ 61, 2 ]
[ 120, 20 ] ,  [ 12220, 121 ]
[ 10, 2 ] ,  [ 98, 11 ]
[ 9, 8, 7, 0 ] ,  [ 1339, 10 ]
[ 0, 1, 4, 9, 2, 10, 4, 15, 10, 5, 0, 16, 12, 8, 4, 0, 22, 19, 16, 13 ] ,  [ 100, 10 ]
[ 9, 99, 90, 81, 72, 63, 54, 45, 36, 27 ] ,  [ 999, 99 ]


  • Input/output can be given by any convenient method.
  • You can print it to STDOUT or return it as a function result.
  • Either a full program or a function are acceptable.
  • Standard loopholes are forbidden.
  • This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

| |
  • \$\begingroup\$ For the testcases I think you can omit the outer parenthesis and the trailing comma. Furthermore I'd talk about nonnegative integers instead of unsigned integers. \$\endgroup\$ – flawr Nov 17 '19 at 16:44
  • \$\begingroup\$ But I have another question: Is this problem always solvable? \$\endgroup\$ – flawr Nov 17 '19 at 16:44
  • \$\begingroup\$ @flawr thanks I'll fix then. For the second question Idk.. Numbers increase extremely, I made a program for solving the problem and also a program to do the reverse(X,Y to list) I may do some test for each X,Y to a certain number.. \$\endgroup\$ – AZTECCO Nov 17 '19 at 17:48
  • \$\begingroup\$ I don't think [0,0,1,1] has a solution (consider the parity of X) cc @flawr \$\endgroup\$ – H.PWiz Nov 17 '19 at 17:53
  • \$\begingroup\$ @H.PWiz sadly yes \$\endgroup\$ – AZTECCO Nov 17 '19 at 18:45
  • \$\begingroup\$ @flawr and H.PWiz so if it's not always solvable do I have to delete this challenge? \$\endgroup\$ – AZTECCO Nov 17 '19 at 18:47
  • 1
    \$\begingroup\$ I dunno, you could guarantee that the input is solvable. Or you could ask a different (harder) question instead: "Is there a solution?" \$\endgroup\$ – H.PWiz Nov 17 '19 at 19:06

Create a block maze solver AI

A block maze is a maze in which goal is to complete a pathway by adding blocks.

It starts like this :


# is a block (which can be crossed). . is empty space (which cannot be crossed).

The goal is to connect top-left corner S to the bottom-right corner E. Diagonals are not allowed.


One possible solution for the example above is to add three blocks like this :


Think about a man who want to cross a river with crocodiles . using huge stone blocks #.

The task is to create a program that take a grid as input and return a solution as output.


The sum of all blocks required to solve all solutions in a 1.000 test case file I will provide.

The winning program is the one that use the fewest blocks to solve all mazes.


  • All grids are 25 x 25.
  • Start / end points are always top-left / bottom-right corners. There is always a block on those points.
  • There is always one guaranteed solution (which can be found by filling all empty spaces)
  • Program must be entirely deterministic; pseudorandom solutions are allowed, but the program must generate the same output for the same test case every time. If two programs take the same number of steps (e.g. they both found the optimal solutions), the shorter program will win.

The program should return the solution as a sequence of blocks x-y coordinates (the coordinates of blocks to add to solve maze) in the format of your choosing :



  • I cannot think of a simple algorithm that returns an optimal (best possible) solution in a reasonable time. I expect programs to use some heuristics to get non-optimal/near-optimal solutions. I made the grids 25 x 25 to make it challenging enough and prevent simple solutions like brute force.
  • Is this a duplicate? There is lot of related questions but I couldn't find anything related to block maze.
  • The tags are . Anything else?

EDIT : as AlienAtSystem pointed out in comments, there is an optimal algorithm for all cases. I made some tests: even a slightly modified Dijkstra's algorithm will work (it will find shortest path in a short time). I will not post this challenge as it is trivial. I leave it here in case someone else would have same idea.

| |
  • \$\begingroup\$ By fewest total steps, do you mean cumulatively? \$\endgroup\$ – Corsaka Nov 20 '19 at 10:07
  • \$\begingroup\$ I mean the sum of all blocks. If solution for maze01 use 4 blocks and solution for maze02 use 5 blocks, it is 4+5 = 9 blocks in total. The lowest is the best. Someone who has 7+1=8 blocks will win. I have edited answer. \$\endgroup\$ – tigrou Nov 20 '19 at 10:37
  • \$\begingroup\$ You should allow people to have any output format as long as it has x first, y second. None of the mazes are duplicate. I can't think of any other tags. This should be good to post. \$\endgroup\$ – Corsaka Nov 20 '19 at 10:49
  • \$\begingroup\$ Should we add a test suite of some sort? Or how are you going to verify the score of a submission? But in general the challenge looks clear. A few questions: I assume there are some test cases among the 1000 requiring us to go right/up for the optimal solution, instead of only going left/down? Are the input-characters strict, or could we also use for example 012 for @.x respectively as integer-matrix? One other relevant tag: [path-finding] \$\endgroup\$ – Kevin Cruijssen Nov 20 '19 at 13:25
  • \$\begingroup\$ @KevinCruijssen I am planning to provide a program to validate solutions. right/up : some mazes might be shorter to solve that way but it is not allowed. The goal is go from top-left to bottom-right (not to cross from left to right). character set : programs should use the same characters as the test file. Anyway, using 012 might be a good idea (I might update the test file with such chars). There is no @ character in the test file since the start / end position are always the same. \$\endgroup\$ – tigrou Nov 20 '19 at 14:31
  • \$\begingroup\$ @tigrou Ah ok, so @ is not part of the input. In that case a binary-matrix with just 0s and 1s would be a suitable input format I guess. As for the right/up: I meant it for an input like this pastebin. With this maze you could walk from the top-left to bottom-right with just 2 x insertions (at the _ positions), but you'd have to travel up and left in the path from the top-left to bottom-right. But if I understand correctly we only travel right and down, so this would be the solution (with 4 insertions at _) instead? \$\endgroup\$ – Kevin Cruijssen Nov 20 '19 at 18:38
  • 1
    \$\begingroup\$ @KevinCruijssen : both solutions you posted are valid. You can go up / down / left right at any moment. \$\endgroup\$ – tigrou Nov 20 '19 at 18:42
  • \$\begingroup\$ I can think of an algorithm that should be optimal for all test cases. This could result in the tie-breaker problem if other people realize it, too. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 6:32
  • \$\begingroup\$ @AlienAtSystem : optimal algo : is it because of my test cases (which have some flaws) or the maze challenge in general ? \$\endgroup\$ – tigrou Nov 22 '19 at 8:20
  • 1
    \$\begingroup\$ @tigrou In general. It can be translated into a shortest path challenge over a considerably smaller graph. While A* wouldn't work on that one, other algorithms will. This wouldn't be short in terms of bytes, although I suspect not that much compared to other approaches, given that some part tasks need to be done by everyone. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 9:35
  • 2
    \$\begingroup\$ I think you don't need to give up entirely right away. While this doesn't work as test-battery challenge because it's too easy to get everything right, it should be good for posting as generic code golf. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:36

A Spherical Die


I have a spherical die, but it's a cheap one so it doesn't work properly. When I roll it, it doesn't always land directly on a "face" marking, but instead can result in an ambiguous result ("is that a 6, a 4 or a 2?")


Assume the die is a perfect, evenly-weighted Unit sphere (i.e. all points on the surface are radius 1cm from the center) , such that a "roll" can result in any point on the sphere being the uppermost point (the "roll value").

Assume that, if the die is placed or rolled such that 1 is at the "north pole", the conventions of a normal die will follow, i.e:

  • 6 will be at the "south pole"
  • 4, 5, 3, 2 will be on the "equator", clockwise in that order, equidistant around the sphere.

So, before it's rolled, the die looks like this:

image of die

The Challenge

Given a simulated roll of the die with the conditions above (i.e. coordinates representing the top of the die after it's rolled), identify the closest value (1-6) to that point (i.e. what the roll value should resolve to).


A co-ordinate on the sphere.

There are a few co-ordinate systems used for spheres, the two I'm familiar with (and so will provide examples in) are as follows:

  • P(1, φ, Θ) where φ is the "azimuth angle" (0..360), Θ is the "polar angle" (0..180)

  • P(x,y,z) where \$x^2+y^2+z^2=1\$

(note: the conversion between the two is: x = cos(φ)·sin(Θ); y = sin(φ)·sin(Θ); z = cos(Θ))

for clarity:

  • roll "1" is at P(1,n,0)
  • roll "2" is at P(1,270,90)
  • roll "3" is at P(1,180,90)
  • roll "4" is at P(1,0,90)
  • roll "5" is at P(1,90,90)
  • roll "6" is at P(1,n,180)


The nearest value (1-6) to that point. If the point is equidistant to two or more points, output any one of them.

Usual exclusions etc. apply.

| |
  • \$\begingroup\$ Does anyone know the maths for this? Feel free to edit it in! \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 9:40
  • \$\begingroup\$ I'm not sure I understand: You want us to generate a random point on a sphere and output the face of the die it corresponds to? \$\endgroup\$ – flawr Nov 22 '19 at 9:57
  • \$\begingroup\$ yeah, so generate a random point on the sphere, then find the nearest "face" - i.e. the nearest of the 6 points (top, bottom, 4 points on opposite sides around middle) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 11:11
  • \$\begingroup\$ This will be exactly equivalent to a uniform distribution over 6 values, just based on the symmetry of the situation. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 12:33
  • \$\begingroup\$ @AlienAtSystem yes, all outcomes are equally likely; but the challenge is determining which number any given point on the face of the sphere is closest to \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:04
  • 2
    \$\begingroup\$ That's not the challenge as posted. Right now, it's "Takes no input, returns the number the (internally generated) random point is closest to" which is, under the consensus of no unobservable requirements simply equal to "Takes no input, returns uniform random value from 1-6". If you want the challenge to be "Input is point on sphere, output is number it's closest to", then write that. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:09
  • \$\begingroup\$ @AlienAtSystem I've edited to try and make it clearer what I'm looking for. Is it clearer now? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:15
  • \$\begingroup\$ It's clearer that my point still stands. Look, "Make Voronoi cells on sphere" and "Generate uniformly random points on sphere" are both good challenges. But when put together like that, they annihilate each other and give you an extremely quick shortcut right from Input (None) to output (a die roll) that doesn't require calculation of either part. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:21
  • 2
    \$\begingroup\$ @AlienAtSystem thanks for the feedback, I'd never heard of a Voronoi cell before. What I'm asking, then, is "generate a random point on a sphere and say which Voronoi cell that point is in". Can you explain why that doesn't work? Note that I'm asking for both the point and the cell to be output, not just the cell - otherwise I agree, given the "no unobservable requirements" rule it would be possible to just generate a random number and pretend you'd done it properly (although that would be against the spirit of it) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:24
  • \$\begingroup\$ Would it be better for the point on the sphere to be the input, then? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:27
  • \$\begingroup\$ If you want the challenge to be about finding the points it's closest to, yes. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:31
  • \$\begingroup\$ I want it to be a good challenge on this theme, whatever that would look like :) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:33
  • \$\begingroup\$ Although I don't think the current challenge is bad, it's usually best to not have multiple challenges into one nor multiple outputs (since some languages aren't able to output more than once very easily). The two challenges are: 1. Generate a random coordinate on a sphere (in whichever coordinate system you want); 2. Given a (random) coordinate on a sphere, output the dice-value closest to it. No. 1 already is a challenge, so I agree it might be better to rewrite it to challenge No. 2. I do like the general idea though, so +1 from me. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:36
  • \$\begingroup\$ It would also need some info about the size of the sphere, and what to do when the coordinate is exactly in the center between two or three poles. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:39
  • \$\begingroup\$ @KevinCruijssen Thanks, that's helpful. \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 14:40

OEIS A125959

https://oeis.org/A125959 is a sequence I submitted. It is the following array, which then repeats:

1 2 3 4 5 6 7 8 9    
2 4 6 8 1 3 5 7 9    
3 6 9 3 6 9 3 6 9    
4 8 3 7 2 6 1 5 9    
5 1 6 2 7 3 8 4 9    
6 3 9 6 3 9 6 3 9    
7 5 3 1 8 6 4 2 9    
8 7 6 5 4 3 2 1 9    
9 9 9 9 9 9 9 9 9

This is a rather useful array for quickly calculating the digital root of the product of any two numbers (i.e the iterative sum of the digits of the product). See the OEIS link if you're interested in the details.

The challenge is to print the array in the shortest number of bytes.




The above array. It can be output as strings with new lines, or as a nested array, or an array of strings; but not as a single-line sequence (i.e. the 2d-nature of the array must be reflected in your output).

| |
  • 4
    \$\begingroup\$ So it's the multiplication table mod 9, except 0s are 9's? \$\endgroup\$ – xnor Nov 25 '19 at 12:58
  • \$\begingroup\$ @xnor is it? I hadn't spotted that before. Does that stop it being an interesting challenge? \$\endgroup\$ – simonalexander2005 Nov 25 '19 at 13:49
  • 1
    \$\begingroup\$ I believe it does (because it is "create a 10x10 table of the function (-~a*-~b-1)%9+1" now). \$\endgroup\$ – my pronoun is monicareinstate Nov 25 '19 at 14:05
  • 2
    \$\begingroup\$ I think it makes it too similar to generic print-a-multiplication table challenges, but others might disagree. \$\endgroup\$ – xnor Nov 26 '19 at 2:10

Times have changed!

(pun intended)


As mathematics progressed, mathematicians agreed upon the 'order of operations', to prevent mathematical expressions from becoming ambiguous.

Given the expression \$7 \times 6 + 5 \times 3\$ we know to first evalulate multiplication, giving \$ 42 + 15\$, which is equal to \$57\$.

But what if another group of mathematicians had agreed to evaluate addition before multiplication? This expression would become \$ 7 \times 11 \times 3\ = 231\$: which is different from our answer by an error of \$305\%\$!

The Challenge

Given a mathematical expression containing + (addition), * (multiplication), and the digits 0123456789, we can find:

  • \$E_1\$ - the 'real' value of the expression, when multiplication takes precendence.
  • \$E_2\$ - the 'alternate' value of the expression, when addition takes precedence.

Your task is to write a program or function which, given a string representing an expression, calculates and outputs the percentage error, \$\frac{|E_1 - E_2|}{E_1} \times 100\$.


  • WIP.
| |
  • \$\begingroup\$ Related \$\endgroup\$ – Chas Brown Dec 1 '19 at 22:33
  • \$\begingroup\$ @ChasBrown do you think it's similar enough to call this challenge a dupe? \$\endgroup\$ – FlipTack Dec 27 '19 at 14:14

Bake the cookie

Quick intro

So i was playing cookie clicker yesterday, and I thought about something. We keep producing cookies, without any loss. What if your cookies failed? This is where I thought about a clicker that would cook a cookie. Don't click too much, or the cookie will be overcooked!


Your task will be to create a function that will "bake" a cookie :

  • Your function will have to randomly select a number between 5 and 10 : it will establish the cooking duration of your cookie (and so, the number of time you'll have to call the function to cook your delicious cookie).
  • Each time you call that function, it will iterate the baking process of your cookie.
  • Your function should return "Undercooked" if your cookie is not fully cooked, "Overcooked" if you ... overcooked it, and "Cooked" when the cookie is baked just right.


Since I'm bad at explaining things, an example will show you more clearly what needs to be done. Let's call my function bake() :

bake()    // The random number generated is 6, so i need to call my function 6 times





bake()    // We hit the 6th function call, the cookie is baked.

bake()    // The 7th call overcooked the cookie. Congratulation, you ruined it.


  • The random number of iterations has to be set the first time you call the function. It has to be between 5 and 10 (inclusive).
  • A cookie has to be undercooked before being cooked, and has to be cooked before being overcooked. The 3 steps have to be reachable. A cookie can't uncook itself, therefore you can't go from cooked to undercooked, or from overcooked to cooked (it's too late, you ruined the cookie anyway).
  • The function can have as many parameters as you please.
  • Classic rules apply, no standard loopholes
  • This is codegolf, so the shortest code wins.


  • Is the challenge clear enough ?
  • Should I go with this method to iterate the "baking" process ?
  • Are there some rules I could add to make it more exciting ?
  • Does this challenge exist already ?
  • Should we bake pies instead ?
| |
  • \$\begingroup\$ I'm assuming bake() will take no parameters and will have to store the count somehow, which means you might want to include some rules about file and global variable I/O. I also did a small editing pass. \$\endgroup\$ – Veskah Dec 2 '19 at 16:14
  • \$\begingroup\$ @Veskah I never thout about restricting bake()'s parameters, gonna edit the rules to include this particulatiry. Also, thanks for the edits. \$\endgroup\$ – The random guy Dec 3 '19 at 8:12
  • \$\begingroup\$ I don't think I understand what you are trying to accomplish. Why do you refer to the submission always as a function? Could it not be a program? Similarly, your edit to allow arbitrarily many parameters conflicts with the general tone that seems to imply that we should be storing state between calls. I think you will want to try explaining the task simply, perhaps even to the level of a non-programmer. \$\endgroup\$ – FryAmTheEggman Dec 8 '19 at 19:47


| |
  • \$\begingroup\$ I don't think this is possible? Surely you can't tell what direction is involved with the mirrors, e.g. /1, can you tell if the pointer started on 1 going east vs / going north? \$\endgroup\$ – Jo King Dec 18 '19 at 9:10
  • \$\begingroup\$ @JoKing Hm yeah I think your right. I will try a little more but you are right that mirrors can't be used. \$\endgroup\$ – Ad Hoc Garf Hunter Dec 18 '19 at 15:06
  • \$\begingroup\$ @JoKing I actually do think this is possible. \$\endgroup\$ – Ad Hoc Garf Hunter Dec 18 '19 at 15:15

Traverse the Bridges of Köningsberg

The Seven Bridges of Köningsberg is a logical problem that singlehandedly kicked off both the fields of topology and graph theory. The city of Köningsberg was bisected by a river, with two islands in it. Thus the city spanned four landmasses. Connecting those were seven bridges. Leonhard Euler proved that it was impossible for a person to walk through Köningsberg and cross every bridge exactly once.

The bridges, increasingly abstract representation This is an increasingly abstract representation of the problem. The bridges can be represented as edges of a graph, and the landmasses as nodes. Try to start from one node, and "walk" to the other nodes, crossing every edge exactly once (crossing nodes multiple times is okay). Euler proved that it was impossible for Köningsberg. Info on how to solve this problem for any set of islands and bridges can be found on the Wiki page.

The problem

As input, your program/function should take an adjacency matrix, in any form that you wish (e.g. concatenating every number to a single string is fine, as is making a string list, or even a built-in matrix data structure if your language has one). The examples here are provided using a csv format.

The adjacency matrix for Köningsberg looks like this:


Each row and column represents the bridges from and to specific nodes. Node 1 (first row) has 2 bridges to node 2 (second column), and vice versa. Every bridge is bi-directional, so the matrix will always be symmetrical. Bridges from a node to itself are allowed (that does not make much sense architecturally, but topology nerds recently hacked several city planning agencies to make this challenge more interesting, so do not disappoint them) - but by convention such connections are counted double in the adjacency matrix.

Output, for any given adjacency matrix, a truthey/falsey value for whether it is possible to walk so that you traverse every edge exactly once. You don't need to end up back at your starting position - that's a different problem. The maximum amount of nodes/landmasses is 9, and the maximum amount of bridges between two landmasses is also 9. The maximum amount of bridges from one landmass to itself is 4 (notated as 8 in the matrix). There is no guarantee that all the landmasses are connected - if there's islands that you cannot reach, but you can reach all the bridges, then the answer is still truthey!

This is a challenge, so the shortest challenge in bytes wins!

Test cases












TRUE (there's no bridges, so they can all be reached)


FALSE (every landmass only connects to itself)


TRUE (starting at a landmass with a bridge, you can reach all of them)





Do I need to include the logical solution to the problem? It's pretty simple, but I might want to make figuring that out part of the challenge.

Any other feedback welcome, of course.

| |
  • 1
    \$\begingroup\$ Why are the outputs to 5th and 6th examples False? Looks like 5th is invalid (because it's not symmetric) and 6th should be True (because there are no bridges to start with, so we already walked over all bridges). \$\endgroup\$ – Bubbler Dec 17 '19 at 4:30
  • \$\begingroup\$ @Bubbler right on both counts (I was adjusting some of the squares but forgot the symmetry). Will update when I have time! \$\endgroup\$ – KeizerHarm Dec 17 '19 at 6:54
  • 1
    \$\begingroup\$ @Bubbler fixed! Thank you! \$\endgroup\$ – KeizerHarm Dec 17 '19 at 8:24
  • 1
    \$\begingroup\$ Pretty sure this is a duplicate \$\endgroup\$ – FlipTack Dec 20 '19 at 16:53
  • \$\begingroup\$ @FlipTack Oh, bugger. Is this one different enough because the input is an adjacency matrix rather than a list of bridges? \$\endgroup\$ – KeizerHarm Dec 20 '19 at 19:11
  • \$\begingroup\$ I wouldn't say so. Especially since the challenge isn't that interesting, just checking it's connected and there's 0-2 odd vertices. \$\endgroup\$ – FlipTack Dec 21 '19 at 6:55
  • \$\begingroup\$ Especially because the degree of a node is simply the sum over its line in the adjacency matrix. \$\endgroup\$ – AlienAtSystem Dec 22 '19 at 16:52

Title: When is Hannukah?


The input will be a year between 1583 and 2250.


The Gregorian date of the first evening of Hannukah that year. That is the day before the first full day of Hannukah. Your code should output the month and day of the month in any easy to understand human readable form of your choice.


2013    November 27 
2014    December 16
2015    December 6  
2016    December 24 
2017    December 12 
2018    December 2  
2019    December 22
2020    December 10 
2021    November 28 
2022    December 18
2023    December 7  
2024    December 25 
2025    December 14 
2026    December 4  
2027    December 24
2028    December 12 
2029    December 1  
2030    December 20 
2031    December 9  
2032    November 27 
2033    December 16

How do you do this?

It could hardly be simpler. We start with a couple of definitions:

We define a new inline notation for the division remainder of \$x\$ when divided by \$y\$: $$(x|y)=x \bmod y$$

For any year Gregorian year \$y\$, the Golden Number, $$G(y) = (y|19) + 1$$ For example, \$G(1996)=2\$ because \$(1996|19)=1\$.

To find \$H(y)\$, the first evening of Hannukah in the year \$y\$, we need to find \$R(y)\$ and \$R(y+1)\$, the day of September where Rosh Hashanah falls in \$y\$ and in \$y+1\$. Note that September \$n\$ where \$n≥31\$ is actually October \$n-30\$.

$$R(y)=⌊N(y)⌋ + P(y)$$ where \$⌊x⌋\$ denotes \$x-(x|1)\$, the integer part of \$x\$, and

$$N(y)= \Bigl \lfloor \frac{y}{100} \Bigr \rfloor - \Bigl \lfloor \frac{y}{400} \Bigr \rfloor - 2 + \frac{765433}{492480}\big(12G(y)|19\big) + \frac{(y|4)}4 - \frac{313y+89081}{98496}$$

We define \$D_y(n)\$ as the day of the week (with Sunday being \$0\$) that September \$n\$ falls on in the year \$y\$. Further, Rosh Hashanah has to be postponed by a number of days which is

$$P(y)=\begin{cases} 1, & \text{if } D_y\big(\lfloor N(y)\rfloor \big)\in\{0,3,5\} & (1)\\ 1, & \text{if } D_y\big(\lfloor N(y)\rfloor\big)=1 \text{ and } (N(y)|1)≥\frac{23269}{25920} \text{ and } \big(12G(y)|19\big)>11 & (2)\\ 2, & \text{if } D_y\big(\lfloor N(y)\rfloor \big)=2 \text{ and } (N(y)|1)≥\frac{1367}{2160} \text{ and } (12G(y)|19)>6 & (3)\\ 0, & \text{otherwise} & (4) \end{cases}$$

For example, in \$y=1996\$, \$G(y)=2\$, so the \$N(y)\approx13.5239\$. However, since September 13 in 1996 was a Friday, by Rule \$(1)\$, we must postpone by \$P(y)=1\$ day, so Rosh Hashanah falls on Saturday, September 14.

Let \$L(y)\$ be the number of days between September \$R(y)\$ in the year \$y\$ and September \$R(y+1)\$ in year \$y+1\$.

The first evening of Hannukah is:

$$ H(y)=\begin{cases} 83\text{ days after }R(y) & \text{if } L(y)\in\{355,385\}\\ 82\text{ days after }R(y) & \text{otherwise} \end{cases} $$

Notes and thanks

Thank you to @Adám for pointing me to the rules. To keep things simple, this challenge assumes the location to be Jerusalem.

| |
  • \$\begingroup\$ Please type out the rules on that image into actual text. Challenges are supposed to be self-contained, while that image will be subject to link rot. Also, it's lacking an explanation how the Golden Number G is calculated. \$\endgroup\$ – AlienAtSystem Dec 29 '19 at 20:26
  • \$\begingroup\$ What if the given year has no Hannukah? Or there are two "first day of Hannukah"s in the given year? \$\endgroup\$ – Adám Dec 30 '19 at 10:56
  • \$\begingroup\$ @Adam. Now you have confused me! For which years between 1900 and 2100 were there 0 or 2 Hannukahs? \$\endgroup\$ – Anush Dec 30 '19 at 11:01
  • \$\begingroup\$ @Anush Ah, I didn't notice the range. 3031 will have 0 and 3032 will have 2. \$\endgroup\$ – Adám Dec 30 '19 at 11:17
  • \$\begingroup\$ Hold on, the first evening? That'd be the day before before the "first day of Hannukah". You should be very clear about this. \$\endgroup\$ – Adám Dec 30 '19 at 11:26
  • \$\begingroup\$ Hm, I just noticed that there's a risk of people actually not implementing the algorithms, but instead relying on a built-in calendar conversion. Though you don't state it, the answer is always the 24th day of the month Kislev in the Hebrew year CivilYear+3761. \$\endgroup\$ – Adám Dec 30 '19 at 11:47
  • \$\begingroup\$ Also, you may want to extend the valid input range. Otherwise it will often be shortest to hard-code the dates, e.g. in base 30. \$\endgroup\$ – Adám Dec 31 '19 at 14:31
  • \$\begingroup\$ @Adam Could you please double check the formula in the question actually matches the example dates I have given. If so, I will post the question. \$\endgroup\$ – Anush Dec 31 '19 at 14:43
  • 1
    \$\begingroup\$ Working on it... \$\endgroup\$ – Adám Dec 31 '19 at 15:00
  • 1
    \$\begingroup\$ OK, I've tried it now and it works. It actually works. However, don't go ahead and post yet; There are a few issues to address. \$\endgroup\$ – Adám Dec 31 '19 at 15:39
  • \$\begingroup\$ The first day of Hannukah day 84 if Rosh Hashanah is day 1, so you need to add 83 to get the first day of Hannukah, but 82 to get the evening before. \$\endgroup\$ – Adám Dec 31 '19 at 15:40
  • \$\begingroup\$ The last three paragraphs are superfluous as your range is bigger. However, I also suggest adjusting the range somewhat. If you go above 2239 then .NET won't help (which may be good or bad depending on whether you want to push people to implement the actual algorithm instead of just converting the Hebrew date using the built-in. In any case, the Hebrew calendar isn't really defined beyond 2250. \$\endgroup\$ – Adám Dec 31 '19 at 15:47
  • \$\begingroup\$ You can however pull back the earliest year to 1583, but not earlier, as that's the first year of the civil calendar. \$\endgroup\$ – Adám Dec 31 '19 at 15:49
  • \$\begingroup\$ The mathematical formulas are really awkwardly written. Maybe MathJax those? I can do it if you want. \$\endgroup\$ – Adám Dec 31 '19 at 15:50
  • 2
    \$\begingroup\$ I would adjust the output requirements to read "The Gregorian date of the first evening of Hannukah." to pre-empt people just submitting print("24 Kislev"). \$\endgroup\$ – AlienAtSystem Jan 1 at 8:24

Decode the password

Given a printable ASCII string separated with spaces, output the specified index of every word. E.g.

"are turbas unsafe ?!", 1

will yield run!

  • When the index is out of bounds, this index should yield the null string (which can be joined with other strings).

More test cases

"Is Pascal truly unloyal to users?",3 -> "sure"
"I'd pass kittens to anyone stopping by!!",4 -> "stop!"
| |
  • 1
    \$\begingroup\$ The definitive answer here is yes. \$\endgroup\$ – Lyxal Feb 3 at 6:58
  • \$\begingroup\$ I assume this was just meant to be laying out the idea not to forget about it. But just in case I figured I should say that you definitely need to specify what happens when the index is too large for one of the substrings, and that the rest of the string will be printable ascii / whatever you choose. \$\endgroup\$ – FryAmTheEggman Feb 5 at 17:19
  • 1
    \$\begingroup\$ The first test case in the more test cases section seem wrong should it not yield "sule" and not "sure"? \$\endgroup\$ – Mukundan314 Feb 11 at 15:56
  • 2
    \$\begingroup\$ And the last test case only works for 1-indexing, while all others are 0-indexed. \$\endgroup\$ – AlienAtSystem Feb 11 at 16:10
  • \$\begingroup\$ What happened to this user? \$\endgroup\$ – S.S. Anne Feb 11 at 23:58

Is this entire list likewise-modulus-aligned?

A pair of numbers are aligned in a modulus when they all share the same remainder when they can be put under the modulus function against an integer greater than or equal to 2 and less than or equal to the absolute value of both.

For example,

13 and 22 are aligned numbers under 3 because
13%3 = 1
22%3 = 1

3<=13, 3<=22, and 3>=2

All our requirements are met.

A list is likewise-modulus-aligned when all the elements are aligned under the same modulus base.


Take in a list (not necessarily non-empty) of non-zero integers (not necessarily positive nor unique), and check if all the elements are likewise-modulus-aligned. Output is a truthy or falsy value.

Note; This is a "true-until-proven-otherwise" problem, meaning a single value in the list or an empty list will return TRUE.

Example I/O

      In      | Out | Why
         [5 7]|TRUE |1 mod 2
     [7 12 18]|FALSE|(7,18) are not mod-aligned
     [7 11 19]|TRUE |1 mod 2
  [5 13 28 44]|FALSE|(5,28) are not mod-aligned
[10 13 37 108]|FALSE|(37,108) aren't aligned in any base below 10
            []|TRUE |No disproven pairs
          [42]|TRUE |No disproven pairs
    [-5 13 16]|TRUE |1 mod 3
      [1 9 18]|FALSE|Arrays of size 2 or greater with 1 or -1 will always be false
    [14 17 19]|FALSE|Every pair is modulus-aligned, but not under the same base
[17,22,32,107]|TRUE |2 mod 5
      [4,8,12]|TRUE |0 mod 2
        [-1,1]|FALSE|No mod 1 allowed
           [1]|TRUE |No disproven pairs
       [7,7,7]|TRUE |Numbers >=2 are always mod-aligned with themselves
     [2,2,8,8]|TRUE |0 mod 2
   [3 9 22 22]|FALSE|Pairs don't suddenly make (9,22) mod-aligned.

Sandbox Questions

I'm gauging the interest to this question and seeing if this is an acceptable and unique challenge, just want to make sure I haven't missed another post doing a similar thing.

I changed the rules to be a lot more lenient on the comparisons, might do the pairwise comparison as a bonus or follow-up challenge later. But this is a compromise I can live with.

Extra Hints/Tips

For all non-1 derivations, a number will be aligned with its negative self.
1 is never aligned with any other number, nor will -1.
A number that is a multiple of another will be aligned with that number in all its factors.
Numbers that share factors will always align, but numbers that don't share factors also may.
All odd numbers are aligned with each other, as are all even numbers.

| |
  • 1
    \$\begingroup\$ I'm not clear on why this challenge asks to compare all pairs of a list, rather than just a single pair. The condition covers pairs of numbers, so it would be more natural to just receive a pair of numbers as input. \$\endgroup\$ – isaacg Feb 19 at 18:21
  • \$\begingroup\$ Because it's a combination of that function and a list-pair function with interesting shortcuts that can overlap. Asking for a pair could take X bits, and pushing all pairs to a function could take Y, but the combination of the two isn't necessarily X+Y. In my going at it, I saved like 8 bytes in the mix by being clever. This way, there are several ways to solve while still being a challenge. \$\endgroup\$ – Mathgeek Feb 19 at 18:24
  • 2
    \$\begingroup\$ Some test cases that are not 1 mod x would be good \$\endgroup\$ – Jo King Feb 20 at 5:21
  • \$\begingroup\$ Good suggestion, Jo. I just added one, and I'll add a few more in a bit - I hadn't even caught that! \$\endgroup\$ – Mathgeek Feb 20 at 13:32
  • 2
    \$\begingroup\$ While what you observed can be true, in my experience it is not usually a source of interest in golfing to combine tasks unnecessarily. Similarly, does including negative numbers make this task more interesting? In most languages this will not make a difference, but it will make answering in some languages (consider Retina) substantially more difficult - to the point where people probably won't answer. I always try to recommend making a challenge as simple as possible - just like writing a proof. \$\endgroup\$ – FryAmTheEggman Feb 20 at 18:59
  • \$\begingroup\$ I made negative numbers allowed because negative modulus is still a valid application of modulus - but that argument of "combining two things" is applicable to like literally every other code golf question. The string-wise calculus question could have just been "print out which of two characters is the largest", but then there was added difficulty to comparing pairs and assigning those values to distinct characters. This isn't just an arbitrary expansion, it's a setwise comparison of several elements applied over a function; You see these "expansions" all the time, so why is this one an issue? \$\endgroup\$ – Mathgeek Feb 20 at 19:24
  • \$\begingroup\$ I agree that the part of the challenge where you check every pair seems unnecessary, and was going to comment on this independently. I think just having two numbers as inputs would make a better challenge overall. Or, have all numbers in the list need to be aligned by the same modulus, which seems like a more natural extension. \$\endgroup\$ – xnor Feb 20 at 19:33
  • 2
    \$\begingroup\$ Okay, what about a fairer follow-up instead - instead of checking if all pairs are modulus-aligned, a list is modulus-aligned if all the entries share an identical mod-point. ie: They all have to be n mod m together for the list to be valid. Think that's still a more fair question? I think submitting pairs only is a very low-level simple problem that doesn't have any real puzzle or golfing elements to it, so I'd like it to be slightly more complex somehow. \$\endgroup\$ – Mathgeek Feb 20 at 19:37
  • 2
    \$\begingroup\$ What you and xnor propose sounds good to me. I tried to phrase what I said as suggestions and opinions, because that is all they are. There isn't anything wrong with what you have, but I know I'd be more likely to answer if you changed some things about it. The same is true for many challenges on this site (including my own). Over time, I've come to see that including requirements that are technically valid but aren't necessary rarely adds interest to a challenge. \$\endgroup\$ – FryAmTheEggman Feb 20 at 20:29
  • 1
    \$\begingroup\$ Doesn't [10 13 37 109] satisfy 1 mod 3 (and therefore it is modulus-aligned)? \$\endgroup\$ – Bubbler Feb 20 at 23:45
  • \$\begingroup\$ You're correct fixed! \$\endgroup\$ – Mathgeek Feb 21 at 13:14
  • 1
    \$\begingroup\$ @KevinCruijssen But that's fine. If I have a list [7, 14], they are aligned under Base 7. \$\endgroup\$ – Mathgeek Feb 21 at 14:40
  • 1
    \$\begingroup\$ I also just read the "(not necessarily positive nor unique)" part of your challenge, so you might want to add a few test cases containing multiple of the same number in that case. \$\endgroup\$ – Kevin Cruijssen Feb 21 at 14:46
  • 1
    \$\begingroup\$ Nice challenge btw. And good choice on explicitly mentioning "Note; This is a "true-until-proven-otherwise" problem, meaning a single value in the list or an empty list will return TRUE.", since those [1]/[-1] test cases are really annoying in my approach. ;) I had a prepared solution which worked for all initial test cases in 10 bytes, but now it's 50% larger to 15 bytes just to fix those two test cases, haha. Looking forward to when it goes live. I would leave it in the sandbox for a little while longer for others to give feedback though, just in case. Oh, and welcome to CGCC! \$\endgroup\$ – Kevin Cruijssen Feb 21 at 15:05
  • 1
    \$\begingroup\$ @xnor yes, the question then dissolves to finding whether the gcd of the differences of consecutive elements is >1. \$\endgroup\$ – Don Thousand Feb 21 at 16:09

Square-Cube Digit Usage

| |
  • \$\begingroup\$ In response to the first sentence: nice. \$\endgroup\$ – Lyxal Feb 20 at 0:43
  • \$\begingroup\$ I'm not exactly sure how your title relates to the challenge. Obviously "Square-Cube Digit Usage" won't exactly roll off the tongue, but what you have now seems misleading. \$\endgroup\$ – FryAmTheEggman Feb 20 at 20:22
  • \$\begingroup\$ Nice challenge. I prepared a solution for when it goes live. I would add a few more test cases first, though. One suggestion: 1333 (or 3133/3313/3331) -> 111 (first positive integer as input that has a 3-digit number as output). Here the results for the first 10,000 inputs. \$\endgroup\$ – Kevin Cruijssen Feb 21 at 10:53

Draw an American flag for any amount of states

The flag of the United States of America goes by many names. The Stars and Stripes. Old Glory. The Last Known Non-Erotic Usage Of The Verb 'To Spangle'.

It is also one of the few flags semi-regularly updated. The red and white stripes represent the 13 original states, but one more star has been added to the blue canton for every state that joined the union later. This last happened in 1960, when Hawaii got in. Flag designs with 51 stars are already waiting for when Puerto Rico or Washington D.C. are made states, but this vexillologist is lazy. You are to make a program that can draw the flag with any number of stars desired!


Here's a neat image of the official, government-standardised design for the current U.S. flag: flag design

Disregard the contents of the canton for now. Your program must draw a flag that adheres to only the ratios I give here:

  • A (the height of the flag) = 1
  • B (the width of the flag) = 19/10
  • C (the height of the canton) = 7/13
  • D (the width of the canton) = 19/25
  • L (the height of any stripe) = 1/13

Because raster solutions are not exact and this flag is commonly misdrawn anyway, there's tolerance of 2% for every ratio, taking the flag height as the base.

Furthermore, the correct colours must be used.

  • Every odd-numbered stripe must be this shade (hex): #B22234
  • The blue canton must be in this shade: #3C3B6E
  • Every even-numbered stripe, and every star, must be in this shade: #FFFFFF

Conversions to other colour coordinate systems can be found on the wiki page as well.


Your program must takes as input any integer between 0 and 200, and draw that number of stars within the canton. The following rules apply.

  • Each star must have five outer points and be five-fold rotationally symmetrical.
  • Each star must be the same size.
  • The bounding circles of stars may overlap, but the surface of the stars itself may not overlap.
  • The bounding circles of the stars may go outside the canton, but the surface of the stars itself may not go outside the canton.
  • I don't want solutions that just place every star on the same line; that would leave a lot of blue canton untouched, which would be a waste. So, as a rule, the combined surface area of the bounding circles of every star in the canton must be at least 20% of the surface area of the canton.

    Since overlapping bounding circles still count, you get a formula for the minimum width w of the star, where a is the area of the canton and n the number of stars: formula. See here for how it's derived.

Other specifications

There's no minimum or maximum size for your output image, though I recommend something that will allow 200 stars to fit but still be demonstrably star-shaped. When they are only a few pixels high, it becomes hard to argue that they have the required amount of points. Obviously, for vector solutions any size is permissible.

This is , so the smallest program wins!

Test cases

Because I gave no specific arrangement of the stars (you may arrange them however you want), there is an infinite number of correct and incorrect solutions for each number of stars. These are just examples of valid and invalid solutions:



Invalid (stars too small):




Invalid (stars of unequal size, going out of the canton):


Invalid (stars have too many points, stripes have wrong colours, colours are the wrong hue, proportions are wrong):



Do I need more test cases? Any other feedback?

| |
  • 2
    \$\begingroup\$ If you really want to allow 0 as an input, you'll need an exception to the rule that the combined areas of the bounding circle must be at least 20% of the area of the canton. (If there aren't any stars, there aren't any bounding circles, so the combined areas would be 0.) \$\endgroup\$ – Mitchell Spector Mar 7 at 2:19
  • 4
    \$\begingroup\$ I know it's less thematic, but maybe the task could be just to draw the canton? Arranging and drawing the stars is the interesting part, whereas the stripes aren't changing, so in terms of golfing the stripes seem somewhat extraneous. I guess you could also have the number of stripes be variable. \$\endgroup\$ – xnor Mar 7 at 17:40

Excessively complicated Game of Life

In the excessively complicated version of the Game of Life, the world is a \$W \times H\$ square torus with a grid of squares. Each square has a rulestring attached to it - by default, B/S. Each square has a dead or alive cell in it. Each alive cell is controlled by a player. Every turn, if there is not an alive cell in a square, it is born iff the part between B and / contains the number of alive neighbours. Every turn, if there is an alive cell in a square, it survives iff the part after S contains the number of alive neighbours. Cells are considered adjacent if they have a common edge or a corner. A cell is not adjacent with itself. Cells controlled by other players also count as alive neighbours.

For example, normal Conway's Game of Life cells have the B3/S23 rulestring: cells are born if they have exactly 3 alive neighbours, and survive if they have 2 or 3.

Each player starts with a B/S012345678 cell, placed uniformly randomly.

Each cell knows a 3x3 array of numbers from \$-1\$ to \$1\$, representing adjacent cells (including self). \$1\$ in it means an ally cell, \$0\$ means a dead cell, and \$-1\$ means an enemy cell, and a 3x3 array of rulestrings for adjacent cells.

Every turn, every cell can alter one bit of the rulestring of any adjacent square (including its own) - that is, remove or add a number from it (or, alternatively, it can do nothing).

When cells are born, the player they belong to is chosen semi-randomly: the odds of the cell being assigned to a player are proportional to the number of cells they contributed to the cell's birth.

A player is eliminated when all their cells die. When \$N\$ turns passed, or when only one player remains, the game ends. A full point is distributed between all remaining players proportionally to the number of cells they control (dead cells don't count).


  • Rulestrings are attached to squares, not to cells. When a cell dies, the rulestring on its square is not changed.
  • No cell can be born with zero alive adjacent cells (that is, rulestrings cannot start with B0).
  • When multiple cells attempt to alter the same bit in a rulestring, it is only affected once.


Define a pure function \$(nearbyStates, nearbyRules)\to(\Delta x, \Delta y, index)\$ to be used as the algorithm for your cells. To do nothing, output an index of 0.

Otherwise, an index of 1 corresponds to toggling B1, 2 to B2 and so on until B8, the index 9 is skipped, then an index of 10 corresponds to toggling S0, 11 to S1 and so on until S8.

Winning criterion

\$X\$ games are run, and the leaderboard is formed by sorting participants by the total number of points.

This is , so whoever wins wins!

Sandbox stuff

  • Is this a good idea?
  • Is the description of the game clear?

I think I decided that the language for submissions will be Javascript. Now I have to write a controller.

Besides the obvious Javascript option, I am considering C++ with a Javascript engine (probably V8). This can multiply the performance by \$\%NUMBER\_OF\_PROCESSORS\% \cdot \frac{cppPerformance}{jsPerformance} \cdot \frac{myC++skill}{myJSskill}\$, which can be quite large. Unfortunately, that might also muptiply the challenge's popularity by \$\frac{webBrowserLoadingSpeed}{programInstallationSpeed}\$, which can be quite small! Would that be a good idea?

| |
  • \$\begingroup\$ Disclaimer: I'm biased in both categories. Language: Leaning towards JS, especially since this challenge seems to be of the "hack around and see what works" type, and I believe browser-based ones shine here the most. Python seems to be popular as well, but AFAIK it's usually used for challenges that don't need rich visualization. Other languages, like Java, .NET, C++, etc., can also be considered, of course (higher performance)... Orientation: Removing orientation does seem to be a good fit. It increases the amount of interactions that can happen between any two entries. \$\endgroup\$ – Alion Mar 26 at 18:31
  • \$\begingroup\$ Regarding C++: You can have your cake and eat it too. Have you heard of Wasm and Web Workers? This combination lets you get near-native peformance along with multithreading all in the browser. \$\endgroup\$ – Alion Mar 29 at 13:40
  • \$\begingroup\$ Note that improving controller performance only gets you so far. You're gonna have to go the Formic route and cache entry responses in some smart way to extract all the potential of C++. \$\endgroup\$ – Alion Mar 29 at 13:48
  • \$\begingroup\$ @Alion I include "caching in some smart way" in "improving controller performance". I have also considered using Emscripten (and started using it, starting with the renderer first, because I randomly decided so) but then I got worried because I thought calling JS from WASM and WASM from JS is going to be too slow. After reading the comment, I googled and it turned out Emscripten has multithreading. I guess I'll continue now. \$\endgroup\$ – my pronoun is monicareinstate Mar 29 at 13:50
  • \$\begingroup\$ I'd like to see a good C/C++ KoTH. I'm always excluded from them because I don't know any languages that they're in. \$\endgroup\$ – S.S. Anne Apr 1 at 20:15
  • \$\begingroup\$ @SSAnne I do not understand your comment. Are you proposing a C/C++ KoTH, or are you stating that they cannot be good because you don't know these languages? \$\endgroup\$ – my pronoun is monicareinstate Apr 2 at 0:09

Are these the same time?


When asked about the time (i.e. hours and minutes), people naturally reply with any one of a given set of fairly common sentences:

  • (A) it is M past H
  • (B) it is M to H
  • (C) it is H minus M

Where M above refers to some amount of minutes and H to some amount of hours. Concrete corresponding examples, all referring to the time 3:40 pm:

  • (A) it is 40 past 3
  • (B) it is 20 to 4
  • (C) it is 4 minus 20


Given two of these sentences, output a Truthy value if they represent the same time and a Falsy value if they do not.


Your input will be two sentences of the above, where references to minutes will always be rounded to the nearest multiple of 5 (i.e. the minutes will always be one of 5, 10, 15, 20, ..., 50, 55.

Because all sentences start with "it is " you may ommit that from your input sentences.


A Truthy value if the two times are the same, a Falsy value otherwise.

Test cases

Here is a sample program for checking the test cases.


Should the minutes and hours in the input com as integers instead of English words?

| |
  • \$\begingroup\$ Interesting challenge. Yes, the minutes and hours in the input should come as integers. Otherwise, this becomes a chameleon challenge that appears to be about parsing relation words, but actually is about parsing English numbers. I think you can make the challenge more interesting by adding (D) it is H M. Please address 1) how to distinguish AM/PM or that we don't need to, 2) how to deal with roll-overs like "5 to 0", and 3) if H and M have upper and lower bounds. \$\endgroup\$ – Adám Apr 1 at 6:29
  • \$\begingroup\$ I kid you not, I have never heard any one call it "H minus M". Still, I agree with @Adám that y'all need to ensure that input and output formats are what I like to call "reasonable and convenient", with extra emphasis on the "convenient" part. \$\endgroup\$ – Lyxal Apr 1 at 6:52
  • 1
    \$\begingroup\$ @Lyxal Me neither. But actually, that can be fixed by changing "minus" to "in", as in "4 in 20 [minutes]" \$\endgroup\$ – Adám Apr 1 at 6:55
  • \$\begingroup\$ An alternative you might consider to checking if two sentences represent equal times, is to have code take just one and produce any "canonical form" of it, such that the canonical form can be anything where two inputs give the same canonical form if and only if they are equal. \$\endgroup\$ – xnor Apr 1 at 9:15
  • \$\begingroup\$ @petStorm thanks for your edit but I would prefer if you did not edit any reference programs into my sandboxed posts (you may comment with a TIO link) nor edited the challenge to cope with the feedback I get from commenters. The feedback is very good and I will take care of it, but I prefer to do it myself so I can do the changes I see necessary: e.g. if I am accepting hours and minutes as integers, I no longer want the minutes to be in the set 5, 10, 15, ..., 55. \$\endgroup\$ – RGS Apr 1 at 11:48

Similar Numbers


| |

Compactify the input


| |
  • \$\begingroup\$ Off topic: BASIC programmers were often recommended to name their variables this way. \$\endgroup\$ – Member for 3 months Apr 8 at 14:26
  • \$\begingroup\$ I agree that it's better to compress a single word instead. \$\endgroup\$ – Member for 3 months Apr 8 at 14:26
  • \$\begingroup\$ hmm ok, I'll do that \$\endgroup\$ – Command Master Apr 8 at 17:42
  • \$\begingroup\$ I think the mention of compression and natural language is misleading, since it leads the reader to expect some compression based on the statistical properties of text. \$\endgroup\$ – xnor Apr 8 at 18:36
  • \$\begingroup\$ hmm ok, do you have an idea for a better name? \$\endgroup\$ – Command Master Apr 9 at 4:53
  • \$\begingroup\$ Do you think Compactify the name is a good idea? \$\endgroup\$ – Member for 3 months Apr 9 at 8:44
  • \$\begingroup\$ Related. \$\endgroup\$ – Member for 3 months Apr 9 at 8:46
  • \$\begingroup\$ yes, I like that name, maybe Compactify the input though? As it doesn't have to be a name \$\endgroup\$ – Command Master Apr 9 at 9:02
  • 2
    \$\begingroup\$ I like Compactify the input \$\endgroup\$ – xnor Apr 10 at 12:12
  • \$\begingroup\$ Just an FYI, the regex \B[aeiou] matches each character to be removed. You may receive a lot of answers that are basically just that. \$\endgroup\$ – FryAmTheEggman Apr 12 at 5:10
21 22
24 25

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .