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

Sandbox FAQ


To post to the sandbox, scroll to the bottom of this page 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, though you can optionally add a title at the top. 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, and replace the post here with a link to the challenge and delete the sandbox post.


The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.


Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".


4561 Answers 4561

33 34
36 37

Multidimensional orthodiagonal steps

Step further in step generation.
Navigation in 2d matrix is common, but something uncommon is even more insteresting.
Now I'll ask you to develope shortest solutions to generate all possible steps in N-dimensional matrix.


Your code takes positive integer number N > 0 as input.
Your code must output all possible steps in matrix of N dimensions. In other words, you need to output coordinates of all cells that touch (0;...;0) cell in any way.


Input: 1


Input: 2


Input 3: Output:

(0,1,0)   (0,1,1)    (0,1,-1)
(0,-1,0)  (0,-1,1)   (0,-1,-1)
(1,0,0)   (1,0,1)    (1,0,-1)
(-1,0,0)  (-1,0,1)   (-1,0,-1)
(1,1,0)   (1,1,1)    (1,1,-1)
(1,-1,0)  (1,-1,1)   (1,-1,-1)
(-1,1,0)  (-1,1,1)   (-1,1,-1)
(-1,-1,0) (-1,-1,1)  (-1,-1,-1)


  1. Standart loopholes are disalowed
  2. Input number is always integer and always greater than zero
  3. Output order is not relevant
  4. Output is flexible. Coordinates just need to be distinguishable
  5. This is code-golf, so shortest answer in bytes wins
  • \$\begingroup\$ Some typos: insterestinginteresting, developedevelop, StandartStandard, disaloweddisallowed \$\endgroup\$
    – wastl
    May 19, 2018 at 9:04

Fridge magnet substitution (posted)

  • \$\begingroup\$ You should add 6 = 9, 7 = L, and C = U. If you're willing to have nuance like intransitivity and directionality, you could add Z = 2 (but not Z = R) H = I (but not H = 1), 7 = T (But not T = L), P => D (D doesn't really work for P, but P acts like a lower case d if you flip it over), Q => O (sorta works if you flip over Q), T => I (also flipped), V => C/U \$\endgroup\$
    – Beefster
    May 14, 2018 at 23:20
  • \$\begingroup\$ Good additions! I thought of having directionality, but I wanted to keep the commutation that message A->B implies B->A. I'll add the other ones though. \$\endgroup\$
    – maxb
    May 15, 2018 at 7:00

Treasure Map Drawing Bot

You're organizing a treasure hunt for your friends. To conduct things more easily, you want to draw a map of all locations where you hid the precious objects.


A string consisting of the locations of the objects separated by newlines. Each location is represented by two non-negative integer coordinates describing the position in the field by an x- and y-coordinate, 0 0 being the upper left corner. Example:

1 2
3 0
0 1


Your function or program should be able to construct a map denoting every given location with an x where the mark is found in row y + 1 and column x + 1 in the output. Unmarked locations are represented with a . The map also consists of a frame where the corners are +s, the vertical lines are |s and the horizontal lines are -s. Map for the input example given above:

|   x|
|x   |
| x  |

Possible Test Cases

"0 0"

"0 10
 5 5
 10 0"
|          x|
|           |
|           |
|           |
|           |
|     x     |
|           |
|           |
|           |
|           |
|x          |


"0 0
 0 2
 2 0"
|x x|
|   |
|x  |

Of course, this is , meaning that the solution with the lowest byte count wins!

  • 1
    \$\begingroup\$ You may wish to clarify that the (0,0) position is the upper left corner. This is common in computer graphics in my experience, but not any other field. If that isn't correct, then your test cases seem to be wrong (and you should clarify where the (0,0) position is anyway). \$\endgroup\$ May 14, 2018 at 17:21
  • \$\begingroup\$ Thanks, did that. \$\endgroup\$
    – racer290
    May 14, 2018 at 17:57

Is it a table?


Take an bitmap (in .bmp, 2D array, string containing line break, etc.), check whether it's a table, i.e. the outer border is a rectangle, and each separated (edge-connected) empty part in it is a rectangle.

Equivalently, each space area, including the outside one, has exactly 4 edges.

You can't assume there is or is no space outside of the table.

Test cases

True samples:

#           #
#           #
#     #     #
#     #     #
#         #
#         #
#         #
#   #     #
#####     #
# # #######
# # #     #
##   #   ##
##   #   ##
##### #####
######   ##
######   ##

Note that in this test case the smallest space area (with 1 space) is a rectangle, although it doesn't have a rectangular border with #.

False Samples:

#     #   #
#     #   #
#     #####
#         #

In this test case the lower-left empty region is a concave hexagon.

#    #     #
#    #     #

The outer border is not a rectangle.

#          #
#          #
#   ####   #
#   #  #   #
#   ####   #
#          #

The outer empty region has a "hole" inside.

Winning criteria

Shortest code win.

  • \$\begingroup\$ This is massively unspecified, and based on the test cases I'm not even sure why the truthy cases are tables and some of the falsey cases not.. As stated in the Sandbox description: "Write your challenge just as you would when actually posting it.", which this clearly isn't.. I'm assuming you just had this challenge as a idea and don't have the time yet to fully specify it, in which case it would be better to save it in a local Notepad doc until you have time to specify it, before posting it here. I do the same pretty often. \$\endgroup\$ May 25, 2018 at 11:40
  • \$\begingroup\$ @KevinCruijssen the whole one is a rectangle, and each separated part is a rectangle \$\endgroup\$
    – l4m2
    May 25, 2018 at 11:43
  • \$\begingroup\$ Why is the third test cases truthy? Do we look at the # for the outer rectangle, but the spaces for the inner ones? If either both # this third truthy case would be false; and if both space (somewhat), I could imagine the second falsey case to be true. \$\endgroup\$ May 25, 2018 at 11:51
  • \$\begingroup\$ @KevinCruijssen Also Notepad doesn't help wording, so your suggestion is bad \$\endgroup\$
    – l4m2
    May 25, 2018 at 12:43
  • \$\begingroup\$ I meant creating the answer with correct formatting here, then save it in Notepad++ until it's fully specified (which is what I do). Alternatively you can keep it open in your browser tab until it's fully specified before clicking the "post"-button. Either way, it clearly isn't "Write your challenge just as you would when actually posting it." right now.. That's all I wanted to state. It does look like an interesting challenge when it is fully specified, though. So you'll have my future upvote when it is. \$\endgroup\$ May 25, 2018 at 12:52
  • \$\begingroup\$ I think you should prove clearly how [it clearly isn't "Write your challenge just as you would when actually posting it."] @KevinCruijssen \$\endgroup\$
    – l4m2
    May 25, 2018 at 12:56
  • \$\begingroup\$ I don't understand this. Why is the third truthy test case truthy? Why are the first and third falsey test cases falsey? \$\endgroup\$ May 25, 2018 at 13:28
  • \$\begingroup\$ @AdmBorkBork its outer border is a 8*11 rect, and there are 4 empty rect parts in it, 3 2*3 and a 1*1. First false test contain an empty part with 6 edges, 3rd one with 8 edges \$\endgroup\$
    – l4m2
    May 25, 2018 at 14:00
  • \$\begingroup\$ So this is also a truthy example? \$\endgroup\$
    May 29, 2018 at 5:00
  • \$\begingroup\$ @user202729 True. Another true case I think maybe necessary is ### (no space area)? \$\endgroup\$
    – l4m2
    May 29, 2018 at 8:00

Formic Functions 2: Hierarchies

     Watch live | Active answers | Add new answer | Chat room | Source code | Leaderboard

               This is an open-ended challenge. New answers and updates are always welcome.

We've seen the territorial highland ants wander the lands in search of food. There have also been talks of aggressive forest ants lurking down below whilst feasting on fungi. These ants, however, are unlike any you've seen before. Collecting food is their goal, as always, but colonies don't need a queen - all ants of this subfamily are capable of creating offspring. There's a catch, though. New ants have less strength than their parent, unless the parent ant spends a large amount of food on them. Ants are capable of killing others weaker than them, and weaker ants are worth less, so your ants need to make careful choices.

Watching the game

Because this competition is made in JavaScript, you can see what other players have made already directly in your browser. Just click on one of the links above - you'll figure out the rest.


To keep the comment section clean, I highly encourage you to use the dedicated chat room for questions and discussion.


No official tournaments available yet.


Here are a couple of images taken at the end of a game that should entice you:

No screenshots available yet.

You can look at more simply by running games in your browser. The controller also allows you to zoom in so you can track the ants' decisions that result in the large-scale patterns you ultimately see.


A value range is indicated by a number followed by two dots and another number. "0..7" means "between 0 and 7, inclusive". A different type of range is indicated by a number followed by a plus sign. "1024+" means "greater than or equal to 1024".


Your task is to provide a JavaScript class that implements a getAction(view) function and optionally a constructor. All code provided by you will be run under strict mode.

The constructor is called with no arguments. It must take no more than one second to run. It must be side-effect free and must consistently result in an identical object after every run.

The getAction(view) function (henceforth known as the ant function) is called like this: yourConstructedObject.getAction(someViewArray);. It must also be side-effect free and must consistently return an object, and provide the same output every time if provided the same input.

At the start of every game, your ant function is granted 1 second of reserve time. It is also granted an additional 10 milliseconds of time every time it is called. Time measurement starts right before the function call and ends upon return. That time is then taken away from the reserve time. Your function must not run out of the reserve time.

The constructed object and any temporary data combined must not consume more than 64 MB of memory at any time.

Here's a template for you to fill in:

class Entry { // TODO: Change the "Entry" to whatever you want, preferably your entry name. Remember that this is a JavaScript class name, so you can't use some characters.
  constructor() {
    // TODO: Optionally fill this in.

  getAction(view) {
    // TODO: Fill this in.


The arena is a toroidal (edge wrapping) grid of hexagonal cells arranged in a rhombus of side length 1500. Initially, all cells have the color 0 and 0.1% have food placed on them, for a total of 2250 pieces of food. Up to 12 entries are randomly chosen every game and have their corresponding ants (one per entry) spawned in random locations, with no more than one ant occupying any cell. The initial turn order of ants is also randomized.


The game lasts 32768 turns, which are processed sequentially. Every turn, in an unchanging order, each ant has its corresponding function called with the local state of the arena passed as an argument. In other words, your ant function is called separately for every ant you control. The action chosen by the ant function is then taken immediately - other ants see the arena changes even during the same turn.



Each ant carries the following properties with them:

  • Position: Implementation-defined.
    • Ants do not have access to their global position.
  • Tier: An integer representing the tier of an ant.
    • Equal to 0 for all ants not spawned by other ants.
    • Doesn't change over an ant's lifespan.
    • The lower its tier, the less valuable an ant is.
    • There is no theoretical limit on how high or low tier can be.
  • Age: An integer representing how old an ant is.
    • Initially 0 for all ants.
    • After every action an ant takes its age goes up by one.
  • Food: An integer representing the amount of food an ant is carrying.
    • Initially 0 for all ants.
    • An ant may carry an unlimited amount of food.
  • Memory: An integer in the range 0..15 representing the memory of an ant.
    • Initially equal to 0 for all ants not spawned by other ants.
    • An ant may change it as part of any action.
    • Holds no meaning for the controller.
  • Owner: Implementation-defined.
    • Allows ants to see whether another one is a friend or not.


Each ant sees 6 cells in its neighborhood, as well as the cell it is currently occupying. Each cell contains the following properties:

  • color: An integer in the range 0..7 representing the current color of a cell.
  • food: A boolean representing whether or not a piece of food is present on a cell.
  • ant: An object if an ant is present on a cell, undefined otherwise. If present, the object has the following properties:
    • tier: Maps to Tier.
    • age: An integer in the range 0..3 representing an ant's age on a logarithmic scale. 0 actual age maps to 0, 1..31 actual age maps to 1, 32..1023 actual age maps to 2 and 1024+ maps to 4. [Sandbox note: I'm torn about whether or not the ants should have access to this information.]
    • [Sandbox] Alternative for or complement to age: older: A boolean representing whether or not an ant's age is higher that of the currently active ant.
    • food: An integer in the range 0..3 representing the amount of stored food by an ant on a logarithmic scale. 0 actual food maps to 0, 1..3 actual food maps to 1, 4..15 actual food maps to 2 and 16+ actual food maps to 3.
    • memory: Maps to Memory.
    • friend: A boolean representing whether or not an ant is under control of the same entry as the currently active ant.

Every turn sight is passed to your ant function as an array of 7 objects, arranged in this order:

 0 1
5 6 2
 4 3

The view is randomly rotated by a multiple of 60 degrees every time your ant function is called. This means that it's impossible to extract a consistent sense of direction without clever use of the environment.

Accessing one's own state is done by retrieving the ant object of the 7th element of the array, like this: const me = view[6].ant;


Each ant must perform an action every turn. The possible actions are as follows:

  • Move: Move to the desired cell.
    • Format: {cell: 0..6, action: 0}
    • When moving onto a cell with food on it, an ant automatically picks up the piece of food present.
    • When moving onto a cell with an ant on it, of the two ants only one remains. If the still ant's tier value is lower than that of the moving ant, then the still ant dies and is permanently removed from the game. Otherwise, the unfortunate fate awaits the moving ant instead. In either case, the remaining ant gains all the food of the ant that died and one more.
    • Staying still is a valid action and may hold merit in certain situations.
  • Paint: Change the color of the desired cell to the desired color.
    • Format: {cell: 0..6, action: 1, color: 0..7}
    • Changing the color of a cell to the same one is a valid action.
  • Place food: Put a piece of food onto the desired cell.
    • Format: {cell: 0..6, action: 2}
    • Placing a piece of food onto a cell with an ant on it results in that ant immediately picking it up.
    • Placing food costs food. An ant may only place a piece of food if it has at least one food stored, and one food is taken away from it.
    • Placing food onto own cell is a valid action, but placing food onto a cell with a piece of food already on it is not.
  • Spawn: Create a new ant under control of the same entry on the desired cell.
    • Format: {cell: 0..6, action: 3, tier: -1..+1, state: 0..15}
    • A parent ant must choose to spend 1, 4 or 16 food on the new ant by specifying a tier equal to -1, 0 or +1 respectively.
    • A parent ant may only spawn an ant of the desired tier if it has the necessary amount of food to do so, and that amount is taken away from it.
    • Spawning results in an ant of a tier equal to that of its parent plus the tier value specified.
    • A parent ant must choose the initial memory of the new ant by specifying a state. [Sandbox note: I'm considering not letting parents set the initial memory of offspring.]
    • The new ant is inserted into the turn order right before its parent.
    • Spawning an ant counts as movement for the new ant, and is resolved as such.
    • Spawning an ant onto own cell is a valid action and may hold merit in certain situations.
  • Memorize: Replace the currently active ant's memory with the desired number.
    • Format: {memory: 0..15}
    • Memorization is not an action itself. It must be appended to one of the four previously mentioned actions.
    • An ant may choose to leave this field undefined. No memory change occurs then. [Sandbox note: Torn about this as well.]

Format refers to the JavaScript object that must be returned by your ant function to perform a specific action.

Example outputs:

  • {cell: 0, action: 0} // Move to cell 0.
  • {cell: 6, action: 0} // Do nothing.
  • {cell: 6, action: 1, color: 0} // Set own cell color to 0.
  • {cell: 3, action: 2} // Put a piece of food onto cell 3. Invalid if there is a piece of food on cell 3.
  • {cell: 2, action: 3, tier: -1, state: 3} // Spawn an ant 1 tier lower than that of your own with initial memory equal to 3 on cell 2 at the cost of 1 food. Invalid if you have no food.
  • {cell: 5, action: 3, tier: +1, state: 11, memory: 14} // Spawn an ant 1 tier higher than that of your own with initial memory equal to 11 on cell 5 at the cost of 16 food whilst committing 14 to memory. Invalid if you have less than 16 food.
  • {cell: 6, action: 3, tier: 0, state: 0} // Spawn an ant with tier equal to that of your own with initial memory equal to 0 on your own cell at the cost of 4 food. A conflict occurs and the newly spawned ant dies, giving you a piece of food. Effectively, ou lost 3 pieces of food. Invalid if you have less than 4 food.
  • {cell: 6, action: 3, tier: +1, state: 0} // Spawn an ant 1 tier higher than that of your own with initial memory equal to 0 on your own cell at the cost of 16 food. A conflict occurs and you die, giving the newly spawned ant a piece of food (and any additional food you might've had). Effectively, you upgraded yourself at the cost of 15 food. Invalid if you have less than 16 food.
  • {cell: 3, action: 0, color: 5, test: true, memory: 1} // Move to cell 3 whilst committing 1 to memory. Values ofcolorandtestare irrelevant. You may choose to include unrelated properties - they are simply ignored. [Sandbox note: Maybe the controller shouldn't allow color in this case? This looks like it might be a good breeding ground for hard-to-detect bugs.]

Example invalid outputs (not exhaustive):

  • {cell: 7, action: 0} // Error: Value of "cell" outside required range 0..6.
  • {cell: 3} // Error: "action" left undefined.
  • {action: 1, color: 4} // Error: "cell" left undefined.
  • {cell: 4, action: 3, tier: -1} // Error: "state" left undefined.


At the end of each game, every entry participating in that game is evaluated according to this formula:


n is the number of ants belonging to the entry currently being evaluated
Ti is the tier of the ith ant belonging to the entry currently being evaluated
Fi is the amount of food the ith ant belonging to the entry currently being evaluated is holding

Or as pseudocode:

var evaluation = 0;
for (int i = 0; i < entry.ants.count; i++) {
  var ant = entry.ants[i];
  evaluation += Math.Pow(2, ant.tier) + Math.Pow(2, ant.tier - 1) * ant.food;

[Sandbox note: Should I count food as score or not?]

The final score of each entry is equal to the amount of entries whose evaluation was lower than that of the currently considered entry. This means that the highest score an entry can get is 11.


A tournament is nothing more than a series of individual games. At any point of a tournament the score of each entry is equal to the average of all of its scores.

Official tournaments

Official tournaments will be run by me on the latest version of Chrome on my personal computer, which at the time of writing is an AMD FX-8350, every time a new entry is posted or an existing one receives a meaningful edit. The leaderboard will be updated once the 1st place becomes consistent between 6 subsets of played games (which gives a probability of 96.875% that the first place won't change).

As stated before, there is no permanent winner. This means that no checkmark will be awarded to any answer, ever. I will continue to run new tournaments for as long as is practical.


Each submission must follow this general format:

Entry Title

[Optional text and pictures]

Code block with your JavaScript class

[Optional text, pictures and code blocks]

Not adhering to the above format may result in the submission not being properly picked up by the controller.

Explanations and pictures are highly encouraged, though not necessary. Making your entry pretty and well-documented will entice me (and probably a lot of people) to upvote it.


Your entry will be disqualified if it is found to not adhere to the specification correctly. Most of the time problems will be caught by the controller and reported, but some rules can't be checked programmatically, so they'll be enforced by hand. I reserve the right to disqualify an entry manually if it breaks the rules or if I subjectively believe it has not been made with fair competition in mind. I hope I haven't left any loopholes (and therefore won't have to exercise this power), but if I did then this rule prevents them from potentially ruining the entire challenge.

Disqualification during a game results in all of your ants being immediately and permanently removed from the turn order. Disqualification during a tournament invalidates all games in which your entry has participated and terminates the active game (as it would've been invalid anyway). Disqualification during an official tournament, aside from having the effects of a regular tournament disqualification, prohibits your entry from taking part in any future official tournament until meaningfully edited.

This is not supposed to be an additional challenge - helpful error messages along with your ant function's output and the input that disqualified it will be attached to the disqualification notice. I will also paste these messages into a comment informing you of a disqualification should your entry be disqualified during an official tournament.

Multiple entries and editing

You may provide multiple entries, provided that they do not team up against the others. As long as each entry is working solely towards its own victory, you are permitted to tailor your strategy to take advantage of others' weaknesses. You may also edit your answers whenever you choose. It is up to you whether you post a new entry or edit an existing one; just don't flood the game with nearly identical variations. If you make a variation of another person's entry, remember to give them credit by linking to their entry from your own.

Example entries


This entry demonstrates the minimal amount of code needed for something to be considered valid. It returns the same output regardless of input.

class Randant {
  getAction() {
    return {cell: 0, action: 0};

Because the orientation is random every time, Randant will perform a random walk instead of going straight.

Despite being very simple, this is a perfectly valid submission. It won't ever get disqualified either, because moving is guaranteed to be a valid action.

See Smart Randant on how one could go about improving this entry.

Smart Randant

This entry demonstrates basic mechanics that ought to be commonly used between more advanced entries. It is an improvement of Randant's general design. It depends on input this time around.

class SmartRandant {
  getAction(view) {
    const me = view[6].ant; // Get data about myself

    function wrap(number, cycleLength = 6, negativeSafety = 1) { // Defining functions inside the getAction(view) function is fine
      return (number + cycleLength * negativeSafety) % cycleLength; // Wraps numbers (allows for cyclic array access)

    function stronger(a, b) { // Checks if ant a is stronger than ant b
      return a && (!b || a.tier > b.tier);

    view.forEach((cell, i) => { // Modifying the view is perfectly acceptable (here we do it to store the index alongside each cell)
      cell.index = i;

    const dirs = view.slice(0, 6);
    const safe = dirs.filter((cell, i) => !stronger(dirs[cycle(i - 1)].ant, me) && !stronger(dirs[cycle(i + 1)].ant, me) && stronger(me, cell.ant)); // Create an array of cells that are safe to move to
    // TODO: Also consider attacking other ants that are at the same strength level as us by spawning a stronger ant on their face

    if (safe.length) { // If we've got some safe spaces to move to...
      const victims = safe.filter((cell) => cell.ant && stronger(me, cell.ant)); // Prioritize killing other ants

      if (victims.length) { // If we've got someone to kill...
        const target = victims.reduce((prev, next) => stronger(next.ant, prev.ant) ? next : prev); // Find the strongest victim and target it

        return {cell: target.index, action: 0};

      const food = safe.filter((cell) => cell.food); // Otherwise prioritize grabbing food

      if (food.length) { // If we've got some food to grab...
        return {cell: food[0].index, action: 0} // Just grab any piece
        // TODO: Grab the piece that has the most pieces of food next to it

      return {cell: safe[0].index, action: 0} // Otherwise move to any safe cell

    return {cell: 6, action: 0}; // If we don't have a safe cell to move to, just stay still and hope for the best
    // TODO: Handle this situation better

As you can see, Smart Randant is a lot smarter than his counterpart. Smart Randant dropped his suicidal tendencies by finding safe cells before moving. Note that despite not being suicidal, he may still be killed by particularly cunning entries. He's also more aggressive - he'll gladly attack opponents weaker than him and will grab nearby food. Finally, if he's got anywhere to go, he will go there. Otherwise, he'll just stay still, hoping for the best.

You may have also noticed that Smart Randant still has a lot to learn. You can edit your entries to your heart's content, so W.I.P. submissions are allowed, or even encouraged.


This entry demonstrates smart usage of the environment for the purpose of fighting randomness. It travels in a straight line, leaving behind a path. It also utilizes and expands Smart Randant's basic framework.



The chat room is active already and is a better place for extended discussion than the comment section. I'd also love to dicuss some preliminary ideas for potential strategies to be used in future entries (though let's try to restrict this dicussion to nothing more than interesting isolated systems rather than full submissions - I'm not particularly interested in posting a nearly-solved challenge).

Most links are broken for now. The controller, for example, doesn't exist yet.

I'm aware that I'll have to make (or find) a custom number library that can handle nearly arbitrarily small and large powers of 2 for scoring (I've managed to design a system which spawns progressively less valuable ants every 2 turns at no cost, leading to a score equal to about 1 + 2e-16384).



Hexarun (stylized as Hexarun!) is a simultaneous game with complete information. Hexarun is intended for a minimum of three (3) players.


Up to twelve (12) players start on a regular hexagonal toroidal board with a number placed on each hexagon. The objective of the game is to collect the numbers by navigating the board. Players have complete knowledge of the board and the participating players. The number on a hexagon is reduced by the amount being collected. The game ends when all hexagons become zero or if the game becomes stale. The player whose collection has the highest sum wins the game.

Each game consists of multiple turns. Before the first turn, players choose their own starting location. During each turn, players move within their vicinity at the same time. If a player is alone in a numbered hexagon, this player collects the entire number. If multiple players move into a single hexagon simultaneously, they split the number. Numbers are not exchanged between players during each game.

Game specifications

  1. Regular hexagonal toroidal board: Each edge of the board measures N=2*P hexagons where P is the number of players on the board. The numbers on the board are placed in concentric rings. The numbers on the edge of the board are 1, and each successive inner ring follows off the OEIS sequence A002024 which starts with 1, 2, 2, 3, 3, 3, 4, 4, 4, 4. As a final touch, increase the number in the center by 1 if it is not unique on the board. [Example Board (N=6)]

  2. A game ends when...

    a. Hexagons become zero: Numbers on all hexagons are zero.

    b. Game becomes stale: Scores do not change during 6*P consecutive turns.

  3. Legal moves...

    a. Run!: Moves into one of the six (6) neighboring hexagons.

    b. Nothing: Does literally nothing.

  4. Number collection:

    a. Collect: At the end of a turn, a player alone on a hexagon scores s=h points, where h is the number on the hexagon at the beginning of the turn.

    b. Split: At the end of a turn, n>1 players standing on a hexagon scores s=h/n points, where h is the number on the hexagon at the beginning of the turn, and / is integer division. The number on the hexagon at the end of the turn becomes h-s*n, a.k.a. the remainder.

    Example: At the end of a turn, a total of 3 players are on a hexagon with number 10, then each gets 3 points and the hexagon becomes 1.

How to play


Tournament rules



  • \$\begingroup\$ Note to self: Implement using davidje13/koth-webplayer. \$\endgroup\$
    – Frenzy Li
    May 31, 2018 at 9:37
  • 2
    \$\begingroup\$ 2*P scaling means that if there are more players, there's more proportional space for each player. In other words, there's more and more empty space between players. (As an extreme example, if you have 2 players, each player will have 8 squares each. If you have 100 players, each player will have 1600 squares each) \$\endgroup\$ May 31, 2018 at 12:57
  • 1
    \$\begingroup\$ The center of the board is more valuable, but because you are using that OEIS sequence, with big boards, there are tons of squares in the middle that will have the same number. I think you were aiming to have fights for the middle, but how I see it, there's plenty for everybody. \$\endgroup\$ May 31, 2018 at 13:02
  • \$\begingroup\$ Finally, winning this game is primarily done by predicting where people are going to go. This is problematic, because as it stands, the way to win is to identify bots based on movement, which leads to one-upping. \$\endgroup\$ May 31, 2018 at 13:05
  • \$\begingroup\$ @NathanMerrill I meant to say that P is the number of players on the board. If up to 12 players play at the same time, the edge size is up to 24. I'm still not entirely sure about that sequence, and it'll take some testplay to see. \$\endgroup\$
    – Frenzy Li
    May 31, 2018 at 13:10
  • 2
    \$\begingroup\$ Right. If you have 12 players, then the edge size is 24. 24*24 = 576, which is 48 squares per player. With 100 players, it is 200*200 = 40000, which is 400 squares per player. What you really want is X*sqrt(P), where X is the number of squares per player. \$\endgroup\$ May 31, 2018 at 14:31
  • \$\begingroup\$ @NathanMerrill I'm trying to think in your way. The total number of squares for the hex follows A003215. For edge size 24 (number of hexagons on a side of the hexagonal board), there are 24^3-(23)^3=1657 hexagons, so that's approximately 69 hexagons per player. \$\endgroup\$
    – Frenzy Li
    Jun 1, 2018 at 0:39
  • \$\begingroup\$ 69 is miscalculated, 138 should be the answer. 138 hexagons should be plenty. \$\endgroup\$
    – Frenzy Li
    Jun 1, 2018 at 0:55
  • \$\begingroup\$ Let us continue this discussion in chat. \$\endgroup\$ Jun 1, 2018 at 1:15

Base 18 & Decimal traffic light

Given a number n<180, output the n/10 part and the n%10 part in 7-seg.

7-seg shapes:

 000         222   333         555   666   777   888   999   AAA         CCC         EEE   FFF   GGG
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
             222   333   444   555   666         888   999   AAA   BBB         DDD   EEE   FFF         HHH
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
 000         222   333         555   666         888   999         BBB   CCC   DDD   EEE         GGG
  • Either led on or (led off&background) should be constant, and the left characters mean the other state, or
  • At least two of your background, led on and led off should be constant, and the left characters mean the left state.

  • \$\begingroup\$ add the tag ascii-art \$\endgroup\$
    – Beefster
    Jun 5, 2018 at 18:46
  • 5
    \$\begingroup\$ 1. Related, related, related, and plenty more. I wouldn't be surprised if this were closed as a dupe. 2. What does this have to do with traffic lights or base 18? 3. I don't understand the last two bullet points. Are they saying that I can choose to use the same character for on and off and essentially just always output 88? 4. Why is the shape for 0 the same as the shape for 8? \$\endgroup\$ Jun 6, 2018 at 8:50
  • \$\begingroup\$ @PeterTaylor 1. There are lots of related, but none of these are 2. video.baomihua.com/v/18443141 , base 18 because the next letter "i" can be mistaken with "1" 3. clarified somehow, though I don't know which choice you use 4. fixed \$\endgroup\$
    – l4m2
    Jun 6, 2018 at 11:01

Convincingly Fake Compression of Random Data

As you may know, it is impossible to write an compression method that takes strings of length \$n\$ and returns strings of length \$n - 1\$. This can be proven by a simple argument: Each compression function must be a bijection, because otherwise the compressed strings can not unambiguously be uncompressed. However, just considering bit strings, there are \$2^n\$ strings of length \$n\$, but only \$2^{n-1}\$ strings of length \$n-1\$, thus no such bijection can exist.

In other words, for each attempt to write such a compression function, there exist strings which cannot be compressed.

The task for the cops in this challenge is to write a function which looks like it can compress arbitrary fixed-length strings, and the task of the robbers is to find a string for which the compression function fails.


I'm not yet convinced if this will actually work as a challenge, mainly if it is feasible for the cops to write a submission which is not easily crackable. It might be easier for large \$n\$ so robbers can not brute force, so I could make the cops winning criterion about getting the safe submission with the lowest \$n\$. Any ideas for a better winning criterion?

Also do you think this will work as a challenge?

  • 2
    \$\begingroup\$ Might be too easy for a challenge. There's a 50% probability that you find a string which fails. \$\endgroup\$ Jun 26, 2018 at 14:17
  • 2
    \$\begingroup\$ Looks feasible to me. It may be good to fix the input into binary string, lower-case alphabet, or just ASCII and require the robbers to find two strings that "compress" to the same object. \$\endgroup\$ Jun 26, 2018 at 14:53
  • \$\begingroup\$ @EriktheOutgolfer yes, but with a well-crafted cop submission, it would be difficult to know that a string wasn't "compressed" unless the robber finds two strings that end up with the same string or writes a "decompression" function. \$\endgroup\$ Jun 26, 2018 at 14:56
  • \$\begingroup\$ @JungHwanMin Just run it and measure its length? \$\endgroup\$
    Jun 26, 2018 at 15:20
  • 1
    \$\begingroup\$ Anyway I think this is only feasible if the cops solution takes a very long time to run even for a single input, for most/all of the counterexamples. \$\endgroup\$
    Jun 26, 2018 at 15:24
  • \$\begingroup\$ @user202729 What I meant to say is that it is possible that there exists a "compressed" string that corresponds to only one "uncompressed" string, so it would be "compressed" when you feed it to the cop program. With a good cop program, it may be hard for robbers to find specific examples of strings that have the same "compressed" variation. \$\endgroup\$ Jun 26, 2018 at 16:15
  • \$\begingroup\$ @JungHw Pick random strings of length n and compress it, the expected number of runs until you crack the solution is 2. \$\endgroup\$
    Jun 26, 2018 at 16:21
  • \$\begingroup\$ @user202729 That doesn't make sense. Assuming that we use binary strings and exactly two strings compress to one string, the probability of getting no collision after picking 3 strings is 1 * (2^n - 2)/(2^n - 1) * (2^n - 4)/(2^n - 2), which should be close to 1 with large enough n. \$\endgroup\$ Jun 26, 2018 at 16:31
  • 1
    \$\begingroup\$ Perhaps the word "fail" has to be clearer. The challenge sounds possible if "failing" means "producing colliding outputs" instead of something on the lines of "crashing." With binary strings, Mathematica tells me that the expected value of trials needed to find colliding strings is ~946 with length 10, and ~1.05e+6 with length 20. \$\endgroup\$ Jun 26, 2018 at 16:46
  • \$\begingroup\$ @JungHwanMin Shouldn't generating a random string, compressing it, decompressing the result and checking whether this equals the original string yield a collision with probability 0.5? \$\endgroup\$
    – Laikoni
    Jun 26, 2018 at 21:14
  • \$\begingroup\$ @Laikoni then the robber would need to create a decompression function. Maybe I misunderstood the challenge, but I thought the only requirement for the cop was to include a compression algorithm. Having some obscure compression function that make "decompression" very challenging would make this challenge feasible. \$\endgroup\$ Jun 26, 2018 at 21:28
  • \$\begingroup\$ I suggest changing the challenge specification to my misinterpretation of the challenge specs. ;-) The robber would need to come up with either a decompression function or a counterexample to the compression algorithm (i.e. prove that the compression is not bijective). \$\endgroup\$ Jun 26, 2018 at 21:40
  • 1
    \$\begingroup\$ @JungHwanMin Thanks for the suggestions! The problem with the cop providing only a compression function is that they could submit any hash function, because that's what those fake compression functions actually are, and trying to prevent cops from submitting known-to-be-collision-resistant hash functions probably brings us into dupe-distance to this cnr challenge. \$\endgroup\$
    – Laikoni
    Jun 26, 2018 at 22:10
  • \$\begingroup\$ So the cops must write a decompression function too? \$\endgroup\$
    Jun 27, 2018 at 1:57
  • \$\begingroup\$ @user202729 That's what I originally envisioned, but at the moment that's up for debate in order to make the challenge feasible for the cops. \$\endgroup\$
    – Laikoni
    Jun 27, 2018 at 8:08

Progrqmming Puzzle andf Co9de Golf |


We all make mistakes. You, me, everyone. But not computers. They aren't making any mistake. Not even a single typo.
Time to change this injustice.


Your task will be to take a string as input, and display the string character by character, and with a cursor, as if someone was typing it. But there is a twist : sometimes, the "entered" character will be wrong. In that case there is a little pause, then the last entered character (which is supposed to be wrong) is deleted.


  • Input and output will contain only printable ASCII characters.
  • The cursor should be displayed as |, preceded by a space. This will always be displayed, from the empty string to the exact input displayed.
  • Each "iteration" (new character) is separated by a 0.25s pause (It takes time to write right). You can have a marge error of 0.05s, meaning the pause have to be lower than 0.2s, and lower than 0.3
  • Each character has exactly 1/10 chance to be wrong (that means it will be anything but the right character). In that case you should add a 1s pause ("Wait, did l really made a mistake?"), then delete this character, add a 0.25s pause (with a marge error of 0.05s), then continue.




Possible output

Note : I am planning to add a gif to show what the code should do. For now, consider every line as a gif frame

H |          // 0.25s pause
He |         // 0.25s   "
Hel |        // 0.25s   "
HelG |       // 1s      "
Hel |        // 0.25s   "
Hell |       // 0.25s   "
Hello |      // 0.25s   "
Hello! |     // done

Note for sandbox

  • Is this challenge good enough ?
  • Is this challenge already exist ?
  • Is this challenge clear enough ?
  • \$\begingroup\$ Are those typos in the body also intentional? e.g. whitch \$\endgroup\$
    – wastl
    Jun 22, 2018 at 12:48
  • \$\begingroup\$ @wastl Except for the title, this is just me being bad at writing english \$\endgroup\$ Jun 22, 2018 at 12:52
  • \$\begingroup\$ @AdmBorkBork the wrong character can be anything, except for the character it should have be. In my example the wrong character is a G, it could have been a a, a 7, a #, but not a l since it is the correct character. \$\endgroup\$ Jun 22, 2018 at 14:28
  • \$\begingroup\$ Is it acceptable if the "wrong" character is not random? For example, if a typo on a always becomes b. It might also be a good idea to restrict what characters need to be handled, e.g. "Input will, and output must, consist of only printable ASCII characters" \$\endgroup\$ Jun 22, 2018 at 15:53
  • \$\begingroup\$ @KamilDrakari as long as the "wrong" character is actually wrong, it's ok. And good idea for the input/output restrictions. \$\endgroup\$ Jun 22, 2018 at 20:04
  • \$\begingroup\$ Can we use \b to remove the previous character? How accurate does the delay have to be (0.24 seconds instead of 0.25?). Same question with randomness. Can we have an initial delay before output? Enough is spelt with a g. \$\endgroup\$
    – Jo King Mod
    Jun 27, 2018 at 2:35
  • \$\begingroup\$ @JoKing as long as the output shows that the character is removed, you can use \b. i'd say delay will have an error margin of 0.05s (basically 0.2s<delay<0.3s). However the randomness has to be exactly 1/10. I'll edit the question to add those criterias later. \$\endgroup\$ Jun 27, 2018 at 10:42
  • \$\begingroup\$ You say each character has a 1/10 chance of being wrong? Does this mean answers have to behave non-deterministically, or could a deterministic method be used as long as 1 out of every 10 characters is wrong. \$\endgroup\$
    – Wheat Wizard Mod
    Jun 28, 2018 at 13:27
  • \$\begingroup\$ @CatWizard Answer have to behave non deterministically : the total number of wrong characters will only rely to randomness. \$\endgroup\$ Jun 29, 2018 at 16:34
  • \$\begingroup\$ how are you going to measure exact timing on people's solutions? \$\endgroup\$
    – don bright
    Jul 7, 2018 at 2:16
  • \$\begingroup\$ @donbright with a chronometer ? More seriously, the point here is to get aproximately 4 characters in a second (unless there is a wrong one) \$\endgroup\$ Jul 9, 2018 at 9:30
  • \$\begingroup\$ i dont know how you can measure it, since computers run at different speeds, and OSes are not realtime OSes. but i like it enough anyways. \$\endgroup\$
    – don bright
    Jul 11, 2018 at 1:02

Role reversal

This is related to an old question, but is different enough that answers should be quite different to the older one.

You are given a sentence referring to two different people. Return the sentence with the roles reversed.

For example, for the input I will give you a kiss., you should return You will give me a kiss.

There will always be exactly two people referred to in the sentence, and they will be referred to with different pronouns. Here's a table of the pronouns that might be used (pronouns in a row refer to the same person. Pronouns in a column can be switched with one another to reverse a role).

 I         me       my           mine         myself
 you       you      your         yours        yourself     
 she       her      her          hers         herself
 he        him      his          his          himself      
 they      them     their        theirs       themselves 

Capitalisation matters (the first letter of the sentence should be capitalised, the pronoun "I" should always be capitalised, and no other pronoun is capitalised when not starting a sentence).

Words/punctuation not appearing in the pronoun table above shouldn't be changed. A pronoun word shouldn't be replaced if it appears as a substring of another word (e.g. 'history' shouldn't he changed). None of the inputs will be contractions using pronouns (so there won't be any inputs with "I'm" or "you're" etc).

Input/output examples:

in: She gave them hers!
out: They gave her theirs!

in: He will eat me if I don't eat him.
out: I will eat him if he don't eat me.

in: Get it for them yourself!
out: Get it for you themselves!

in: I think I am going to see him tomorrow.
out: He think he am going to see me tomorrow.

in: I am not interested in history, is he?
out: He am not interested in history, is I?


  • This is code golf so the shortest answer wins.
  • Standard loopholes are banned.
  • \$\begingroup\$ Any last thoughts before I post this? \$\endgroup\$
    – LangeHaare
    Jul 19, 2018 at 14:21

Use Japt Shortcuts

Japt is the PPCG Language of the Month for July, and I'm excited to try it out! In accordance with the Tips post I should use the Unicode Shortcuts. However, my keyboard seems to be lacking those important characters like "upside-down exclamation point" needed for optimum golfiness. Please write me a program to change horrible, verbose monstrosities like â m@VgUb==X into pristine, optimal code like â £VgUb¥X!


Given Japt code as input, output the same code making maximal use of the Unicode Shortcuts Japt supports.


  • Answers must support inputs containing any combination of valid Japt characters [Sandbox: is there a list of these? In particular, many languages need to use the NULL byte to indicate end of input, does Japt support NULL bytes in the middle of code?].
  • Input may be in any reasonable format (string, list of chars, etc.)
  • Output may be in any reasonable format, and does not need to be the same as the one used as input (e.g. "input as string => output as list of chars" is fine)
  • If multiple shortcuts are possible, use the one that replaces the most characters. For example, === should be replaced by not ¥=.
  • Your code does not need to handle ambiguous situations. For example, ==== could be shortened to ¶= or , so behavior is undefined if such a string shows up in the input.
  • Only shortcuts available in Japt 1.4.5 (most recent version at time of posting) need to be handled
  • Non-unicode shortcuts like _ and @ don't need to be handled
  • I've replaced easy-to-miss trailing spaces with where I found them. Those should be the literal space character ' ' when running tests or replacements. [Sandbox: Seriously, is there some better way to do this?]

Test Cases

?OvUf\l m_c %H} qV):0 => "?OvUf\l ®c %HÃqV):0"
Ov"y m_î íZ c p0} "p2␠ => Ov"y ®î íZ c p0Ã"²
=== => ¶
ñgJ òXYZ{XgJ <YgJ } mg mg␠ => ñÌòÈÌ<YÌÃmÎmÎ
w å+ m@Vå+ m+S+Xw} c => w å+ £Vå+ m+S+XwÃc

[Sandbox: The first two test cases are grabbed from some real Code Golf answers here and here. Should I replace them with something else?]

For reference, here is the full list of Unicode Shortcuts to be supported. It can also be found on the Japt Interpreter. Note that some shortcuts end in a space. [Sandbox: should I format this differently?]

¡   Um@
¢   Us2␠
£   m@
¤   s2␠
¥   ==
¦   !=
§   <=
¨   >=
©   &&
ª   ||
«   &&!
¬   q␠
®   m_
¯   s0,
°   ++
±   +=
²   p2␠
³   p3␠
´   --
µ   -=
¶   ===
·   qR␠
¸   qS␠
¹   )␠
º   ((
»   (((
¼   .25
½   .5
¾   .75
À   !==
Á   >>>
à   }␠
Ä   +1
Å   s1␠
Æ   o@
Ç   o_
É   -1
Ê   l␠
Ë   mDEF{D
Ì   gJ␠
Í   n2␠
Î   g␠
Ð   $new Date($
Ñ   *2
×   r*1␠
  • \$\begingroup\$ Nice idea! You can include trailing spaces by using <pre><code> ... </code></pre> instead of indenting, though they'll only be visible if the text is selected if you do it that way. (Also, Ê, Ì, and Í want their s back ;-) ) \$\endgroup\$ Jul 7, 2018 at 4:49

A note about this meta post:

I just have one example right now, but I will have three in the final.

I thought it would be interesting to have a problem about something I know a bit about. Right now it seems a bit mathy, but I wanted to ground the problem on something real. It feels more 'real-life' if you need to understand the spec in addition to golfing. The problem is I don't want it to seem like homework. Another problem is the actual computation that needs to take place isn't actually that hard once you understand the simplifications of the problem.

Let me know what you think.



Calculate the strain tensor and volume percent change of a cube given its material properties and stress tensor.


Common Terms

Stress Strain

  • Strain: ε, The amount of elongation per unit length, Units: \$\frac{in}{in}\$

  • Normal Stress: σ, The amount of force per unit area perpendicular to the cross section, Units: \$\frac{lbs}{in^2} = psi\$

  • Shear Stress: τ, The amount of force per unit area parallel to the cross section, Units: \$\frac{lbs}{in^2} = psi\$

  • Young's Modulus: E, The relationship between stress and strain: \$σ = Eε\$, Units: psi


  • Poisson's Ratio: ν, The relationship between strain in different directions. For a uniaxial bar: \$ε_{22} = -ν ε_{11}\$, Units: unitless

  • Index Notation: A short form for tensors written with subscripts \$i,j,k,l\$ to denote which element within the tensor. The number of subscripts the tensor has indicates what order it is. \$σ_{ij} \equiv \tensor{σ}\$ (Second Order)

  • Kroniker Delta: \$δ_{ij}\$, has the value of 1 if i=j, otherwise its value is 0. Index Notation for the Identity Tensor.

$$ δ_{ij} = \left[\begin{array}{ccc} δ_{11} & δ_{12} & δ_{13}\\ δ_{21} & δ_{22} & δ_{23}\\ δ_{31} & δ_{32} & δ_{33}\\ \end{array}\right] = \left[\begin{array}{ccc} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right] = I $$


A tensor in this context can be thought of as three directional components for each of the three positive faces of the cube.

Tensor on Cube

Although a Stress Tensor is not a matrix, it can be represented in matrix form by a 3x3 or other matrices:

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_{xx} & σ_{xy} & σ_{xz}\\ σ_{yx} & σ_{yy} & σ_{yz}\\ σ_{zx} & σ_{zy} & σ_{zz}\\ \end{array}\right] = \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{21} & σ_{22} & σ_{23}\\ σ_{31} & σ_{32} & σ_{33}\\ \end{array}\right] = \left[\begin{array}{c} σ_{11}\\ σ_{12}\\ \vdots \\ σ_{33}\\ \end{array}\right] = \left[\begin{array}{cccc} σ_{11} & σ_{12} & \dots & σ_{33}\\ \end{array}\right] $$

If a Tensor and a Kroniker Delta share the same indices, they are combined.

$$ σ_{ij} δ_{kj} = σ_{ik} $$

If a Tensor has repeating indices, then it is taken as a zero order tensor and the indices are summed.

$$ σ_{ij} δ_{ij} = σ_{ii} = \sum_{i=1}^{3} σ_{ii} \equiv tr(\tensor{σ}) = σ_{11} + σ_{22} + σ_{33} $$

Stress Strain Relationship

The relationship in one dimension is \$σ=Eε\$. For three dimensions we can use Hook's law to find the relationship between the strain tensor and the stress tensor as follows:

$$ σ_{ij} = C_{ijkl} ε_{kl} $$

This general case would need \$3^4 = 81\$ independent material properties to calculate the strain tensor. If we assume the cube has a symetric \$\tensor{σ}\$, symetric \$\tensor{ε}\$, is Elastic, Isotropic, Linear, and Homogeneous, then we only need two independent material properties: (Young's modulus: E, Poisson's Ratio: ν) or (Lamé modulus: λ, Shear modulus: μ). We can use either pair of values, but for this example it is much easier to calculate the strain tensor from the stress tensor using Young's Modulus and Poisson's Ratio.

And so we can simplify the stress tensor by what we know.

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_x & σ_{xy} & σ_{xz}\\ & σ_y & σ_{yz}\\ Sym & & σ_z\\ \end{array}\right] $$

And our new relationship is:

$$ ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij} $$

Calculating the Dilation

Volumetric Change

The Volumetric Strain can be found by calculating the trace of the strain tensor for very small values of strain. This is because for small values \$ε^3 \ll ε^2 \ll ε\$.

$$ {\frac {ΔV}{V_0}} \approx tr(\tensor{ε}) $$

Putting it all together

Therefore, in summary we can calculate the strain tensor with the following:

Using Index Notation:

$$ ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij} $$

Using Matrix Notation:

$$ ε_{ij} = \frac{1+ν}{E} \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{12} & σ_{22} & σ_{23}\\ σ_{13} & σ_{23} & σ_{33}\\ \end{array}\right] - \frac{ν}{E} tr(\tensor{σ}) \left[\begin{array}{c} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right] $$

Then calculate the volumetric change:

Index Notation

$$ {\frac {ΔV}{V_0}} = ε_{ij} δ_{ij} = ε_{ii} $$

Matrix Notation

$$ {\frac {ΔV}{V_0}} = tr(\tensor{ε}) $$


One positive long: Young's Modulus (Usually in the range 100 psi - 100,000,000 psi)

One positive decimal: Poissons's Ratio (Usually in the range 0.01 - 0.5)

Array of signed decimals for Stress Tensor (9 values)


Array of Strain Tensor, to at least five significant figures (same format as input)

Percent volume change of cube, to at least five significant figures


(simple example for now)

Young's Modulus: 29,000,000 psi
Poisson's Ratio: 0.30
Stress Tensor: [[50000,      0,     0]
                [    0, -10000,     0]
                [    0,      0, 25000]] psi
Strain Tensor: [[0.00157,        0,       0]
                [      0, -0.00112,       0]
                [      0,        0, 0.00045]] in/in
Dilation: 0.08966%


IO is flexible

  • Stress Tensor input can be any size array, or string

    • Input type and size must be the same as output
  • No formatting or units required

This is , least number of bytes for each language wins

  • \$\begingroup\$ Looks interesting. However, because all answers are publicly viewable, challenges where the main difficulty is the implementation (instead of understanding the challenge) is preferred. Looking at the input/output it appears that the implementation itself is probably complex enough to be interesting. \$\endgroup\$
    Jul 8, 2018 at 10:58
  • \$\begingroup\$ this is very fascinating. IMHO the writing could be adjusted for the audience. if they are like me, i dont really understand stress and strain, and what they mean in laymans terms. also i think it could be simplified a lot. take for example the first graph. what are the dashed lines? why are they numbered 1 and 2? what is 0.2%? why is there a cylinder there, and what does it mean? is any of that graph required to solve the puzzle? \$\endgroup\$
    – don bright
    Jul 11, 2018 at 1:42
  • \$\begingroup\$ @donbright Thank you, this is helpful. I will explain the fundamentals of stress and strain more, and annotate the pictures (which are directly from wikipedia). The graphs are not required to solve the puzzle, but they may be useful to understand the concepts. I have them to explain, but they are probably not as helpful to a layman. I will fix it up in the next few days. Btw, what do you you think of the explanations from the tensors section onwards? \$\endgroup\$ Jul 12, 2018 at 5:13
  • \$\begingroup\$ I think it's "Kronecker delta" not "Kroniker delta". Also what is \$\varepsilon_{11}\$ and \$\varepsilon_{22}\$? \$\endgroup\$
    Jul 13, 2018 at 2:54
  • \$\begingroup\$ You should probably describe what is a tensor too. (yes I can read Wikipedia and it's unambiguous but it would be more useful if a post contains all information) \$\endgroup\$
    Jul 13, 2018 at 2:57
  • \$\begingroup\$ still hoping for this one to become a challenge!!!! \$\endgroup\$
    – don bright
    May 27, 2019 at 23:46

Haferman Carpet

Given nonnegative integer input \$n\$ output the \$n\$th iteration of the Haferman carpet.

Constructing the carpet

  • The zeroth iteration is 1.
  • When going from the \$n\$th to the \$(n+1)\$th iteration, replace each \$1\$ with the pattern [[0,1,0],[1,0,1],[0,1,0]] and each \$0\$ with the pattern [[1,1,1],[1,1,1],[1,1,1]].

Test cases

0 [[1]]

1 [[0,1,0],[1,0,1],[0,1,0]]

2 [[1,1,1,0,1,0,1,1,1],[1,1,1,1,0,1,1,1,1],[1,1,1,0,1,0,1,1,1],

Standard I/O stuff


Is this a duplicate? I will make the rules more explicit later.

  • 2
    \$\begingroup\$ Talking about replacing a scalar with a 2D array confused me for quite a while. Having the test cases laid out in a way which obscures the 2D pattern of the carpet also doesn't help. \$\endgroup\$ Jul 13, 2018 at 8:43
  • \$\begingroup\$ As for dupes: these are probably the most closely related questions: two about the Sierpinski carpet and one which is general enough to draw that one and this one. I think it's borderline whether or not this adds something new to the site. \$\endgroup\$ Jul 13, 2018 at 8:47

Syllabification and classification (Venpa)


Venpa is a form of classical Tamil poetry, based upon certain rules of metric prosody. The complete rules form a context-free grammar, the task here is to test for a tiny subset of those rules.


  • Vowels: a, A, i, I, u, U, e, E, y, Y, o, O, W
    • small case represents "short" vowels, CAPS represent "long" vowels
    • y represents the y sound in "my".
    • W represents the "ou" sound in "mouse", and always comes in capital (long) form.
  • Consonant: everything else
    • the consonants can be in small case or capitals, whichever is convenient.

Word Segmenting

Words in the input are seen as composed of segments (which roughly correspond to the usual notion of a syllable). A segment divide occurs where:

  • two or more consonants occur together, tr, rpp, etc.
  • a long (capital) vowel occurs in the word, pO, W, mY etc.
  • two vowels have occurred since the last segment's end (or the word's beginning).

sanjIvi has segments san, jI, vi.
Yvar has Y,var.
vigadakavi has viga,daka,vi.
vAnily has vA,nily.
padAgytAngiha has padA, gytAn, giha
radagajaturagapadAdi has rada, gaja, tura, gapa, dA, di

(Consonants at the end of segments make no difference after segmentation and can be ignored - gytAn=gytA, var=va.)

As you can see, the segments are of two types:

  1. those with a single vowel, san, Y, vA, called a straight (S) segment
  2. those with two vowels, viga, nily, padA called a sequence (Q) segment

So the segment patterns of the above words are:

  sanjIvi              =              san + jI + vi          = SSS
  Yvar                 =                 Y + var             = SS
  vigadakavi           =            viga + daka + vi         = QQS
  vAnily               =                vA + nily            = SQ
  padAgytAngiha        =           padA + gytAn + giha       = QQQ
  radagajaturagapadAdi = rada + gaja + tura + gapa + dA + di = QQQQSS

Permitted patterns

The rules for words allowed in a Venpa are:

  1. a word should have one to three segments
  2. a one or two segment word can have any pattern (S, Q, SQ, SS, QS, QQ)
  3. a three segment word must end in a straight (S) segment

So out of the above, SSS, SS, QQS, and SQ are allowed, QQQ and QQQQSS are not.


Given an input word in the above letters, output its segment pattern if it's an allowed word, or a false-y value if it's not an allowed word.


  • Will be a single word composed of the characters mentioned under the Letters heading above
    • (Small case w will not be present anywhere in the text (neither as a vowel nor as a consonant))


  • The segment pattern of the input word, if it's an allowed word
    • can use any two distinct unambiguous characters to represent S segments and Q segments
  • A false-y value in your language if it's not an allowed word
  • Output is undefined for invalid input (i.e. has characters other than those specified)

Test cases

=> QQS
=> SS
=> falsey (QQQ not allowed)
=> SQ
=> SQS
=> falsey (more than 3 segments)
=> SSS
=> Q
  • 1
    \$\begingroup\$ fascinating. im probably very unusual, but i would like it even better if it was actual poetry instead of 'p' everywhere, maybe even in tamil script (although that would probably disqualify some languages) \$\endgroup\$
    – don bright
    Jul 7, 2018 at 2:37
  • 1
    \$\begingroup\$ Yeah, I intended to just remove some extraneous complexity, but somehow having input in this form makes it slightly less interesting even to me (and I'm not sure it removes a meaningful level of complexity anyway, relative to the rest of the task). I'll change it to use the actual consonants if anyone else here also feels this way. (The last two test case inputs are from actual poetry by the way, just with the consonants replaced.) \$\endgroup\$
    – Sundar R
    Jul 7, 2018 at 18:54
  • 1
    \$\begingroup\$ Using Tamil script would also be great, but my concern with that is mainly that it might make testing and debugging much harder for people who can't read the script. I can mitigate some of that by providing exhaustive test cases, but I'm not sure it's worth it. \$\endgroup\$
    – Sundar R
    Jul 7, 2018 at 18:58
  • \$\begingroup\$ yeah i think i might be a little unusual in my tastes, i still like the puzzle... \$\endgroup\$
    – don bright
    Jul 7, 2018 at 20:08
  • 1
    \$\begingroup\$ @donbright I've updated the post to use different consonants (corresponding to actual words). I like this version a lot better, but let's see how it's received. \$\endgroup\$
    – Sundar R
    Jul 20, 2018 at 14:18
  • \$\begingroup\$ I wrote a program that solves the examples you gave. my first pass was 60 lines of Rust code. i think it is a really good puzzle, great balance between an interesting puzzle and many ways to possibly reduce code size. very interesting. \$\endgroup\$
    – don bright
    Dec 29, 2018 at 14:10
  • \$\begingroup\$ i would like some more examples though. feel like my program might be wrong on some inputs. \$\endgroup\$
    – don bright
    Dec 29, 2018 at 14:11

DRAW me a picture: A QBasic metagolf challenge

The DRAW command in QBasic takes a string argument, consisting of instructions for moving the cursor and drawing line segments, and produces the appropriate line segments on the screen. The syntax of the instructions is very terse--perfect for a challenge!

The challenge

Write a program or function which:

  • Given a 2-D array of on and off pixels, representing a black-and-white image,
  • Generates a string that, when passed to QBasic's DRAW command, will draw that image on the screen,
  • While keeping the generated string as short as possible.

More about DRAW

Your program may use the following DRAW instructions:

(more details pending)

  • U - draw line upwards
  • D - draw line downwards
  • L - draw line to the left
  • R - draw line to the right
  • E - draw line diagonally up and to the right
  • F - draw line diagonally down and to the right
  • G - draw line diagonally down and to the left
  • H - draw line diagonally up and to the left
  • B - meta-instruction: prepend to any instruction to move the cursor accordingly but not draw the line
  • N - meta-instruction: prepend to any instruction to draw the line but not move the cursor

(examples + pictures pending)

The following instructions are outside the scope of this challenge and may not be used (even if they would improve your score): C, P, S, M, X, A, and TA.

Output requirements

Conceptually, your program's output will be substituted for the ... in the following QBasic program:

SCREEN 9        ' Graphics mode, 640 x 350 pixels
DRAW "B M 0,0"  ' Set drawing cursor to top left corner
DRAW "..."

(If the length of your output exceeds any limits on line or string literal length, it may be split across multiple DRAW commands in such a way that the instructions are preserved.)

The program will then be run, and the output image compared to your program's input. Where the input array has a 1, the output image must have a white pixel; where the input array has a 0, the output image must have a black pixel. The portion of the screen outside the input array's dimensions must be entirely black pixels.

Practically speaking, I will probably write a verification script in some other language, just to make testing easier.


Standard I/O methods apply. Output is case-insensitive. Input array dimensions will not exceed 640 x 350. (more rules pending)

Test cases

(test cases pending)


Your submission's score is the sum of the lengths of its outputs on these test cases. In the case of a tie, the earlier submission wins.

Note: this challenge is probably a variation on the Traveling Salesman Problem, meaning that an optimal solution will take exponential time. In order to receive a score, your submission must complete all test cases, which means that you'll need to take a sub-optimal approach.

Sandbox questions:

  • What's a good number of test cases?
  • Should I instead score submissions on a second, hidden set of test cases to prevent overfitting? Or should the hidden test cases be the (first) tiebreaker?
  • Is the implicit requirement "must complete all test cases before you can post it" enough of a bound on long execution times, or should I add a specific execution-time limit?
  • \$\begingroup\$ I would suggest explaining in what way the draw command is given its path length. \$\endgroup\$ Aug 3, 2018 at 22:25

Note: this is my first time posting, so I need help fleshing out the details. I'm aware there are plenty of Roman Numeral problems, but this is somewhat different.

When in Rome, count as Romans do!

This problem is inspired by this website, which published the following diagram:

enter image description here

This diagram shows us that the longest Roman Numeral expression under 250 is that of 188, which requires 9 numerals to express.

The standard symbols used to express most Roman Numerals are the following: {I, V, X, L, C, D, M}. In this challenge, your goal is to, given an positive integer n, compute the number of valid Roman Numeral representations that can be composed through concatenating n of the standard symbols.

Then, your program must output the result of this computation modulo 3997 (to prevent answers from getting too long) in Roman Numerals!

Rules for Roman Numeral Expressions

Roman Numerals originally only had "additive" pairing, meaning that numerals were always written in descending order, and the sum of the values of all the numerals was the value of the number.

Later on, subtractive pairing, the use of placing a smaller numeral in front of a larger in order to subtract the smaller from the larger, became commonplace to shorten Roman Numeral expressions. Subtractive pairs cannot be chained, like the following: IXL. This is considered invalid.

The following are the modern day rules for additive and subtractive pairing.

  1. Only one I, X, and C can be used as the leading numeral in part of a subtractive pair.
  2. I can only be placed before V and X in a subtractive pair.
  3. X can only be placed before L and C in a subtractive pair.
  4. C can only be placed before D and M in a subtractive pair.
  5. Other than subtractive pairs, numerals must be in descending order
  6. M, C, and X cannot be equalled or exceeded by smaller denominations.
  7. D, L, and V can each only appear once.
  8. Only M can be repeated 4 or more times.

Test Cases

Input: 1
Output: VII

More to be added.

Sandbox Users

Thoughts on this problem? I know it is really badly formatted but I thought the concept was cool. Thanks for the help!

  • 1
    \$\begingroup\$ So basically, find how many Roman numbers there are with n numerals? The modulo 3997 is probably not necessary, since the maximum for each n is only 8**n (and valid roman numerals are going to consist of a small fraction of that) \$\endgroup\$
    – Jo King Mod
    Aug 8, 2018 at 5:54
  • \$\begingroup\$ Alright, I'll remove the modulo part. Does the rest seem plausible as a concept? \$\endgroup\$ Aug 8, 2018 at 12:36
  • \$\begingroup\$ The reason for my inclusion of the modulus is because I want to ensure the answer can be outputted without using any numerals beyond those I've provided in the Standard Set \$\endgroup\$ Aug 8, 2018 at 15:12
  • \$\begingroup\$ This needs clearer specification on what counts as a valid Roman numeral. E.g. are IC and XCIX both valid expressions for 99? Is MMMMMMMM a valid 8-letter numeral? \$\endgroup\$ Aug 8, 2018 at 16:38
  • \$\begingroup\$ I added more details to the text. \$\endgroup\$ Aug 8, 2018 at 17:10
  • 2
    \$\begingroup\$ Now that you've posted this to the main site, please add a link to the challenge, edit out the body and delete the post. Thank you! \$\endgroup\$
    – Mr. Xcoder
    Aug 12, 2018 at 11:19

Most distinct Turing-complete character subsets

(Inspired by Fewest (distinct) characters for Turing Completeness)


In any language you choose, find the greatest number of distinct and disjoint subsets of characters allowed in that language (i.e. no individual character is in more than one of the subsets), each of which separately makes the language Turing-complete.


JS (2): eval()"\u0123456789bcdf, []+=` (see answer to linked question).


Scoring is by total number of distinct Turing-complete subsets found. Higher scores are better. In case of a tie, the answer with the fewest total characters used across all subsets wins.


Execution of arbitrary code is not required, only Turing completeness.

Explanations of why each of your subsets are Turing complete are highly encouraged.

In case this was unclear, whitespace characters are still counted as characters.

Sandbox notes:

Should I include some stipulation forbidding languages such as Unary which don't care about the particular characters used?
What is unclear about this specification? Where could I give a better/more complete explanation?

  • \$\begingroup\$ I personally wouldn't exclude unary. I recall a previous challenge attempted to exclude all "symbol-independent" languages and it was almost as much of a mess as attempts to ban builtins. Sure Unary will "win" with a score of 256, but that doesn't mean no interesting answers will be posted. \$\endgroup\$ Aug 14, 2018 at 18:30
  • \$\begingroup\$ You’ll need to define if spaces are counted as characters. \$\endgroup\$
    – JayCe
    Aug 14, 2018 at 20:05
  • \$\begingroup\$ @JayCe done.⠀⠀⠀ \$\endgroup\$
    – praosylen
    Aug 14, 2018 at 20:21
  • 2
    \$\begingroup\$ Are you sure you want to use characters instead of bytes? \$\endgroup\$
    – Jo King Mod
    Aug 15, 2018 at 4:44

Chain Classification


Objective: Write a program (whose index in the chain of answers is \$n\$) which, when given any program with index \$i\$ (\$ 1 \le i \le n\$), outputs \$i\$.

(The program may do anything else given any other string input, including but not limited to: crashing, erorring, returning other numbers, sending an email to google support, and simulating the universe.)


  • Your program may be in any language that has not appeared in the answer chain yet.
  • You may output to STDOUT, STDERR, return as a function value, etc. Any reasonable method of output.
  • You may take input from STDIN, command line arguments, function parameters, etc. Any reasonable method of input.
  • You must output 1 for the first answer, 2 for the second, etc. Any other form of indexing is not allowed.
  • You must use base 10 when outputting.
  • You may not use the internet in any way, particularly to scrape the answers to this question.
  • No person may answer twice in a row.
  • No person may answer within 1 hour of their previous answer.
  • Languages which differ by version are considered distinct. Thus, Python 2 and Python 3 can both be part of the chain.
  • Languages which differ by compiler or interpreter are not considered distinct. So, Python 3 (Cython) and Python 3 are equivalent.

Answer format

# N. Language



Try It Online links are appreciated, as well as links for the language itself.

You must include how your program performs input and output.


The first answer is:

1. Alumin


Try it online! Input and output through STDIN and STDOUT.

  • \$\begingroup\$ An answer \$a_n\$ may also recognize every answer \$a_i\$, where \$1\le i<n\$, and, if it doesn't, output \$n\$. \$\endgroup\$ Aug 17, 2018 at 19:09
  • \$\begingroup\$ @EriktheOutgolfer Yup. Do I need to edit anything to reflect that? \$\endgroup\$ Aug 17, 2018 at 19:19
  • \$\begingroup\$ No, just a note that answers don't need to be generalized quines. \$\endgroup\$ Aug 17, 2018 at 19:20
  • \$\begingroup\$ @EriktheOutgolfer I'm not sure what would indicate to someone that the answers have to be generalized quines. \$\endgroup\$ Aug 17, 2018 at 20:11
  • \$\begingroup\$ This is more like the comments that often appear below challenges for slight hints (usually posted by others). \$\endgroup\$ Aug 17, 2018 at 20:12
  • \$\begingroup\$ What do the rules 5 and 8 ensure? \$\endgroup\$ Aug 19, 2018 at 16:23
  • \$\begingroup\$ @BWO Rule 5 is for clarity; rule 8 is for variety. \$\endgroup\$ Aug 21, 2018 at 6:27
  • \$\begingroup\$ Ok, I don't see a point in 5 but I don't have a strong opinion on it either and it doesn't harm the challenge. However rule 8 seems rather arbitrary, for one I don't think it will be more variable if a user is required to wait some 10 minutes before submitting. Even if in the mean-time another user will answer, I don't think it would become more variable: Just because it's the same user doesn't mean it will be nearly the same answer. But that's just my opinion, in the end it's your call. \$\endgroup\$ Aug 21, 2018 at 14:19

The Input String, But Every Time It Says The First Word, It's Recursion

You wanted to create the ultimate replacement remix, but didn't see a way to add more recursion that ends naturally. Then you saw The Entire Bee Movie But Every Bee Is Replaced With The Entire Bee Movie Without Bees. Unlike the other replacement remixes, all the inserted copies were from the same text. It was the answer - at each recursing, you could remove the word being replaced, making each copy shorter than the one before it and causing the recursion to eventually end. Your master plan was complete, all that was left was to write the program to fulfill it.

The Expansion Function

Let's define some function \$F\$ on a sequence of words. Words are sequences of characters not containing whitespace, which are separated by whitespace.

define \$F(S)\$:

if \$S\$ is empty, return nothing

let \$X\$ be the first word in \$S\$

let \$Y\$ be \$S\$ with all instances of the whole word \$X\$ removed

let \$Z=F(Y)\$

return \$S\$ with all instances of the whole word \$X\$ replaced by \$Z\$

Your task is to implement \$F\$.


Input the sequence of words in some form. You may choose any input method.


Output the sequence of words in some form. You may choose any output method.

Only the words in the output count for correctness. If you output as a string, the leading, trailing, and separator whitespace can be anything.


This is code golf, so shortest code in bytes wins.


Small case


b o o k k e e p e r


r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r o o k k e e p e r

See the recursion:


value of S
result of F


p r

e e p e r
r r p r r

k         k         e e p e r
r r p r r r r p r r e e p e r

o                             o                             k k e e p e r
r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r

b                                                                         o o k k e e p e r
r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r o o k k e e p e r

Large case


peter piper picked a peck of pickled peppers a peck of pickled peppers peter piper picked if peter piper picked a peck of pickled peppers wheres the peck of pickled peppers peter piper picked


218854 words

Hello Sandbox

This section will not appear when the challenge is posted to the main site.

I can't seem to get the quote Markdown right, it might just be a parser bug where it thinks the quote continues even if there are no >s.

I originally put a description of \$F\$ as an implementation in pseudocode, but I'm considering finding a more mathematical description which tells you less about how to go about implementing it yourself. Still though, there is a challenge in optimizing this for tiny code.

  • \$\begingroup\$ I think the title is a bit confusing (as not everyone knows about bee movie or somewhat similar). Maybe "Recursive replacement" a better one? \$\endgroup\$ Sep 10, 2018 at 4:37
  • \$\begingroup\$ Oh btw does "occurrence" means the whole word or being a part of another word is also counted? \$\endgroup\$ Sep 10, 2018 at 4:41
  • \$\begingroup\$ Only a whole word counts. I'll go rewrite that to be more clear. As for the title, you're right that what the challenge is is more important than the inspiration, but I'm not quite sure what wording would be good. I'm thinking something like The Input String, But Every Time It Says This Word, It's Recursion which would state the premise while also referencing the meme. \$\endgroup\$
    – EPICI
    Sep 10, 2018 at 5:02
  • \$\begingroup\$ Oh I didn't know about the meme either. The Input blah blah blah would be better for others who don't know about the meme I think, but if you want to retain the meme that's fine. \$\endgroup\$ Sep 10, 2018 at 5:05
  • 2
    \$\begingroup\$ The introductory paragraph primes the reader to expect a very different challenge to the one given: firstly because it sets up a scenario of infinite recursion, and secondly because it sets up a scenario where elements of the input are replaced by elements which are not in the input. IMO it would be better to remove that introduction and use it instead for a challenge which implements the scenario described and asks for the nth word in the limit string (although this may be a dupe, so check for that first). \$\endgroup\$ Sep 10, 2018 at 8:15
  • \$\begingroup\$ I don't follow how the input creates the output. Could you show a step-by-step example of how each level of recursion works? \$\endgroup\$
    – Beefster
    Sep 11, 2018 at 22:39
  • \$\begingroup\$ I added more details to the "bookkeeper" example, it should explain where each part is coming from, but it may still be too brief. // As for the misleading introduction, I attempted another rewrite, but I think it may need some more revisions before I get it right. \$\endgroup\$
    – EPICI
    Sep 12, 2018 at 0:51
  • \$\begingroup\$ I think that the current I/O rules are just a little too restrictive. I would allow other inputs and outputs than "space delemited string", such as "list of words". \$\endgroup\$ Sep 13, 2018 at 19:48
  • \$\begingroup\$ After a bit of thought, I relaxed the IO to allow other formats and methods. I figured you'll have some work to do either way, so I might as well let you choose the methods that result in the least bytes. I'm not too worried about dedicated data structures as an IO format, since that's probably already covered as a common loophole. \$\endgroup\$
    – EPICI
    Sep 13, 2018 at 22:20

Triangular snake

You're given a triangular field:

Triangular field

It has 4 ports.

You're also given five different pieces from A to E:


Each piece has a little piece of path inside it.

Your basic goal is to build paths between ports. There are some rules:

  • Each cell of the field can be occupied by 0 or 1 pieces.
  • A port can either point to an empty cell or be an endpoint of a path. That is, this is illegal: enter image description here
  • The path starts with a port and ends with a port.
  • The path must not be broken up into pieces, i.e. every edge of a piece through which a path goes must not touch an empty cell or a border without a port.

This is an example of a legal path:

enter image description here

This path can be represented as "CBEDEAD" or "DAEDEBC".


There is no input.


Your ultimate task is to output all the possible paths. Your output must not contain illegal paths. You can output the paths in any readable way. Order, repetitions and letter case don't matter.

  • 1
    \$\begingroup\$ Aren't A en E the same piece? \$\endgroup\$
    – Kroppeb
    Sep 17, 2018 at 15:12
  • \$\begingroup\$ Yes they are, what a blunder. \$\endgroup\$ Sep 17, 2018 at 15:16
  • \$\begingroup\$ It's sad you can only post comments with 50 reputation, otherwise I would have noticed that already :) \$\endgroup\$ Sep 17, 2018 at 15:16
  • \$\begingroup\$ @int6h Out of interest ... What is the connection? \$\endgroup\$ Sep 18, 2018 at 21:12

Iterated Prisoner's Trilemma

Please send me problems or else I'm gonna post this on main.

Prisoner's dilemma ... with three choices. Crazy, huh?

Here's our payoff matrix. Player A on the left, B on the top

A,B| C | N | D
 C |3,3|4,1|0,5
 N |1,4|2,2|3,2
 D |5,0|2,3|1,1

The payoff matrix is engineered so that it's best for both players to always cooperate, but you can gain (usually) by choosing Neutral or Defection.

Here's some (competing) example bots.

# turns out if you don't actually have to implement __init__(). TIL.

class AllC:
    def round(self, _): return "C"
class AllN:
    def round(self, _): return "N"
class AllD:
    def round(self, _): return "D"
class RandomBot:
    def round(self, _): return random.choice(["C", "N", "D"])

class Grudger:
    def __init__(self):
        self.history = []
    def round(self, last):
            if(self.history.count("D") > 0):
                return "D"
        return "C"

class TitForTat:
    def round(self, last):
        if(last == "D"):
            return "D"
        return "C"

Your bot is a Python3 class. A new instance is created for every game, and round() is called each round, with your opponent's choice from last round (or None, if it's the first round)

If we get enough entries for the result to be statistically significant, there's a 50 rep bounty for anyone who can beat Tit For Tat.


  • Round count: [REDACTED]
  • Standard loopholes disallowed.
  • No messing with anything outside your class.
  • \$\begingroup\$ I have no idea how to embed tags in a post. \$\endgroup\$ Sep 28, 2018 at 15:56
  • 1
    \$\begingroup\$ [tag:something] should do the trick. \$\endgroup\$
    – Alion
    Sep 28, 2018 at 16:24
  • \$\begingroup\$ thanks @Alion <3 \$\endgroup\$ Sep 28, 2018 at 16:28
  • 5
    \$\begingroup\$ Way too little substance. You should add a few paragraphs describing the prisoner's trilemma, the challenge, or anything else tangentially related. \$\endgroup\$
    – RamenChef
    Sep 29, 2018 at 0:22
  • 1
    \$\begingroup\$ Don't do a pretty payoff matrix image. Use text. That way you don't exclude people with limited vision who rely on screen readers. \$\endgroup\$ Oct 1, 2018 at 15:09
  • \$\begingroup\$ How many rounds per game? And why does N/N suck so much? \$\endgroup\$
    – Jo King Mod
    Oct 10, 2018 at 8:13
  • \$\begingroup\$ @JoKing Haven't decided the round count, and probably will never tell. Don't want defect-on-the-last-round bots. No idea why I did that; if it causes problems i'll change it. \$\endgroup\$ Oct 10, 2018 at 12:33
  • \$\begingroup\$ Maybe a random amount of rounds within a certain range? Also, wouldn't it be better for the second argument to be a list of all your opponents moves, rather than the latest one? \$\endgroup\$
    – Jo King Mod
    Oct 10, 2018 at 12:42
  • \$\begingroup\$ You can do watever you want within the class, so if you need to remember the entire history, that's your problem. \$\endgroup\$ Oct 10, 2018 at 12:45

Posted: Find an array that fits a set of sums

  • \$\begingroup\$ I'd recommend showing the steps to generating f(A) (show each of the subarrays, then calculate their sums) \$\endgroup\$ Oct 16, 2018 at 21:29
  • \$\begingroup\$ The last requirement: "any way that is convenient to you" is abusable, and basically removes the requirement entirely. Either guarantee that there will be a solution, or require that submissions return a constant value (and add a test for it) \$\endgroup\$ Oct 16, 2018 at 21:31
  • \$\begingroup\$ @NathanMerrill I don't get this last point. Maybe I should ask them to return a Falsy value? \$\endgroup\$
    – user9207
    Oct 16, 2018 at 21:33
  • 4
    \$\begingroup\$ Now that this has been posted you can delete it to make it easier for people to skip past it. \$\endgroup\$ Oct 24, 2018 at 10:10


Find the minimal initial values

Consider a sequence F of positive integers where F(n) = F(n-1) + F(n-2) for n >= 2. The Fibonacci sequence is one example of this type of sequence for F(0) = F(1) = 1, but any two initial values will yield a different sequence. For example F(0) = 3, F(1) = 1 produces these terms.

3, 1, 4, 5, 9, 14, 23, 37, 60, 97, ...


The task is to find F(0) and F(1) that minimize F(0) + F(1) given some term of a sequence F(n). Write a function or complete program to complete the task.


Input is a single positive integer, F(n). It may be accepted as a parameter or from standard input. Any reasonable representation is allowed, including direct integer or string representations.

Invalid inputs need not be considered.


The output will be two positive integers, F(0) and F(1). Any reasonable format is acceptable. Here are some examples of reasonable formats.

  • Written on separate lines to standard output
  • Formatted on standard output as a delimited 2-element list
  • Returned as a tuple or 2-element array of integers from a function


60  -> [3, 1]
37  -> [3, 1]
13  -> [1, 1]
26  -> [2, 2]
4   -> [2, 1]
5   -> [1, 1]
6   -> [2, 2]
7   -> [2, 1]
12  -> [3, 2]
1   -> [1, 1]


This is code golf. The score is calculated by bytes of source code.

  • \$\begingroup\$ Related :-) \$\endgroup\$ Oct 29, 2018 at 18:37
  • 1
    \$\begingroup\$ @ETHproductions: I haven't seen that one before, and the domain is basically identical. But I still think the challenge is sufficiently distinct, since it's an optimization problem as opposed to straight forward sequence generation. \$\endgroup\$
    – recursive
    Oct 29, 2018 at 18:58
  • 1
    \$\begingroup\$ @nwellnhof: That was an oversight. I fixed it and added some examples explicitly showing F(0) > F(1). \$\endgroup\$
    – recursive
    Oct 29, 2018 at 20:26
  • \$\begingroup\$ Spec seems watertight to me. \$\endgroup\$ Oct 29, 2018 at 20:31
  • 1
    \$\begingroup\$ In general, if m<n, you can always replace [m,n] with [n-m,m] for a better solution, so F(0) >= F(1) for all optimal solutions. \$\endgroup\$
    – nwellnhof
    Oct 29, 2018 at 20:50
  • \$\begingroup\$ @nwellnhof: Yes, I see now. I've adjusted more of the test cases, and am considering removing the part about ambiguous solutions if it's irrelevant. I don't have any examples then where there multiple distinct optimal solutions. It kind of feels like that can't happen, but I don't have a proof to that effect. If I can sufficiently convince myself it is impossible, I'll remove the part about ambiguous solutions. \$\endgroup\$
    – recursive
    Oct 29, 2018 at 21:03
  • \$\begingroup\$ I believe I came up with a proof of uniqueness. I think it may not fit in a comment well, but the basic idea is to write any one of these sequences as s_k = f_k-2 s_21 + f_k-1 s_2 where f_k is the sequence starting with 1, 0 at k = -1, 0 instead of the usual indices. Then it is pretty clear that if two distinct sequences reached the same value at the same index, they must differ from each other by a constant times a ratio of two consecutive Fibonacci numbers. This is only an integer for the pair 1,1 and all such ambiguities are handled by you excluding 0 as a starting value. \$\endgroup\$ Oct 30, 2018 at 0:15
  • \$\begingroup\$ @FryAmTheEggman: I removed the part about ambiguous solutions. I'm not following your proof outline at the moment, but I'll take your word for it. :) \$\endgroup\$
    – recursive
    Oct 30, 2018 at 0:24
  • 1
    \$\begingroup\$ I was bored so here's the full thing. I wound up changing some stuff around so hopefully it is easier to follow. Obviously I could have messed up so if anyone notices anything wrong let me know! \$\endgroup\$ Oct 30, 2018 at 2:40

Implement LogiMuxi

The language

LogiMuxi is, as its name suggests, a programming language based on multiplexers.

Built-in gates

  • M(A,B,C) (Multiplexer): If A is 0, returns is B, otherwise returns C.
  • R() (Random): Returns either 0 or 1 uniformly randomly.
  • I() (Input): Reads a bit from STDIN and returns it. Terminates program execution on EOF.
  • O(A) (Output): Appends bit A to STDOUT and returns it.


0, 1 are literals. Literals are expressions, and can be used as values.

Gate calling

G(<arg1>,<arg2>,...,<argx>) calls gate G with the provided arguments in order. Gate calling is an expression.

Conditional loop


Evaluates G. If G returns 1, the indented commands are executed, and this process repeats again. If G returns 0, the loop is skipped. If there are no indented commands under G, the loop is empty, and, therefore, if G is 0 then nothing happens, while if G is 1 we enter an infinite loop with no way out.

Value assignment


Assigns X to the result of G. After that, the identifier of the variable can be used as an expression, and it will evaluate to the current value of the variable.

Gate definition


Defines gate G to take arguments <arg1> up to <argx> (actual argument identifiers are specified by the programmer) and return the result of H. The identifiers of the arguments are localized, as well as variables assigned inside the gate. This means that, if I assign variable X to value A outside of G and then there's an X=B command in the definition of G, calling G will not assign X to B. However, inside the gate's scope, X will take the new value B. Assigning the arguments themselves to new values is allowed. Example:


This will output the bits 1 and 0 in order. For reference, G chooses randomly between A and B in this example.

Gate definitons may also be nested, in which case they will be localized too.

Returning happens by prepending a : (colon) to a value (e.g. to return value A, use command :A). This will exit the gate and return the value to the right of it. You can't leave the part to the right of : empty. A gate that doesn't return is invalid.

Additional notes

  • Commands are separated by line separators.
  • An identifier has to meet these criteria:
    • The first character has to be in ABCDEFGHIJKLMNOPQRSTUVWXYZ_
    • From the second character onward, the identifier must only be composed of characters in ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.
    • It can't be the identifier of any of the built-in gates.
  • A variable and a gate may use the same identifier. They can be separated by the way they are invoked. Of course, this is bad practice, but this language is already pretty esoteric. ;-)
  • Use of an undefined identifier is invalid.
  • A gate is always to be called with parentheses, even if it doesn't take arguments. This includes the built-in gates.
  • A gate may only return one output, and it must return one.
  • Nested loops or gates are represented with the appropriate number of spaces used as indentation.
  • Useless indentation is prohibited.
  • Lines may be empty, but their indentation is significant. Empty lines do nothing.
  • Calling gates with the wrong number of arguments is invalid.
  • If the number of bits sent to STDOUT isn't a multiple of 8, the bits are post-padded with 0s (e.g. if STDOUT is 00010000 11100, it will be converted to 00010000 11100000 before actual printing).
  • If 8 bits have been sent to STDOUT, they will be converted to a character and output immediately.
  • Any syntax not defined above should be considered undefined.

Reference gates

You may skip this section.















Simplification tips

You may skip this section.





Sample programs

You may skip this section.

Infinite loop, no output:




Hello, World!:


1-bit half adder:


Challenge rules

  • You may assume you'll not receive an invalid program, or a program with input that will make it do invalid actions, so you don't need to check it for validity.
  • The program can be either separated by line separators, or given as a list of lines. Acceptable line separators are \n, \r\n and \r (\n denotes character 0x0A, \r denotes character 0x0D).
  • Input can be taken in any reasonable form explicitly separated from the program, not necessarily from STDIN. Also, it can either be the actual input, or its bits (e.g. you can take 0100000001000001 instead of @A). It's guaranteed to be finite for this challenge.
  • Output can be provided in any reasonable form, either as bits or as text. Also, you don't actually need to output while the program is executing, unlike what the specification above says.
  • You may use any four distinct identifiers for the built-in gates M, R, I and O. Identifier rules will apply to your chosen identifiers in this case.
  • You may use [] instead of (), and/or tabs instead of spaces in indentation. You must be consistent with these choices.

Sock Drawer Simulator

Socks are often kept in drawers, and when people wear socks they like the left and right socks to match [citation needed].


Given an array of the number of socks of each color, simulate the process of drawing socks, and output the color of the first pair found. You may assume that:

  • Socks are drawn sequentially, randomly and without replacement.
  • A pair is found when a sock of a color that has already been drawn is drawn.

Obviously, the precise algorithm doesn't matter as long as the output probability distribution is correct.


A nonempty array of positive integers representing the frequency of each color of sock. For example, [3,1,4,1,5] could represent a drawer with three teal, one aquamarine, four green, one cyan, and five cerulean socks. There will always be at least one possible pair.


A nonnegative integer representing the color (index) of the sock drawn. You may consistently use either one-indexed or zero-indexed arrays.


Survival Game: Alien Hunters (working title)

Based on Create Your Wolf, but the combat is very different.

Somewhere, deep in the heart of the galaxy, lies the planet Oizys. A toroidal planet in the habitable zone of its star, its bountiful land and beautiful oceans make it the perfect planet for your race of aliens to start colonizing as an interstellar civilization.

Unfortunately, a few dozen other alien races are also trying to colonize it, and you can't stand them. So you're going to have to kill them.

Your Alien

Your task is to write an implementation of the net.ramenchef.oizys.Alien class:

package net.ramenchef.oizys;

public class Alien {
    public enum Move {
        // a whole bunch of values; these are described in "the board"

     * Used by the runner to keep track of the alien's energy.
    double energy = 1.0;

     * Moves the alien.
     * @param surroundings The alien's surroundings. The first
     *  dimension is North–South, with index 0 being North. The second
     *  dimension is East–West, with index 0 being West.
     * @return A {@code Move} object representing the direction to
     *  move the alien
    public abstract Move move(char[][] surroundings);

     * Called when the alien is in battle.
     * @param opponents The other aliens on this tile that need to be
     *  fought
     * @return The amount of energy to use in this battle
    public abstract double attack(char[] opponents);

100 instances of your class will be spawned in random locations on the board for each trial. Each alien class will be assigned a unique character to represent them on the board.

There are a number of stock alien races that already inhabit Oizys:

  • Rocks: they do absolutely nothing and don't pose any sort of threat (i.e., they attack with 0 energy), but for some reason your generals don't know what rocks are, so they appear just like any other alien.
  • Random Bears: they act randomly. They move in a random direction (including possibly not moving at all) and attack using a random portion of their energy.

The Board

Oizys is a toroidal planet, so the board will be side-looped on both edges. The width and height of the board will be equal to \$\left\lceil\sqrt s\right\rceil\$, where s is the number of alien species. Each round, your aliens will have the option to move one tile horizontally and/or vertically with the move method. This method takes a 3x3 char[][] representing the alien's surroundings, with a[0][0] being Northwest and a[0][2] being Northeast, and returns a Move enum. The possible Move values are NORTHWEST, NORTH, NORTHEAST, WEST, HOLD, EAST, SOUTHWEST, SOUTH, and SOUTHEAST.


If two or more aliens attempt to move into the same tile, they will fight. What better opportunity to kill those annoying other aliens! Or maybe get killed yourself, who knows? Each alien starts with 1 energy, and uses it to fight other aliens. When aliens fight, they use the attack method, which takes a char[] representing their opponents and returns a double, to determine how much energy they will use for that battle. The alien that uses the most energy wins, and the others die. In the case of a tie, the winner is determined by coin flip. An alien cannot use more energy than it has or it will die; neither can it use a negative amount of energy.


Five trials will be held, with each trial being scored by the portion of the aliens remaining that are your alien. These trials will be held on [1 month after the challenge is posted].

Other Rules

  • Standard loopholes are forbidden.
  • Aliens attempting to alter field visibility/writability will be met with mysterious SecurityExceptions.
  • The order that aliens' methods are called is undefined, though there is a happens-before relationship between calls on successive rounds, as well as between aliens moving and those same aliens attacking each other.
  • \$\begingroup\$ How do the aliens get energy? What is the energy limit mentioned in the description of the dragon? \$\endgroup\$
    – Laikoni
    Apr 12, 2018 at 8:54
  • \$\begingroup\$ @Laikoni the dragons have unlimited energy, and the rest of the aliens start with all the energy they'll get. \$\endgroup\$
    – RamenChef
    Apr 12, 2018 at 12:08
  • \$\begingroup\$ So the energy is a floating point number? Doesn't that cause potentially more trouble than just saying it's initially 100 and using ints? \$\endgroup\$
    – Laikoni
    Apr 12, 2018 at 12:35
  • \$\begingroup\$ @Laikoni how would using a floating point be a bad idea? \$\endgroup\$
    – RamenChef
    Apr 12, 2018 at 12:57
  • \$\begingroup\$ Testing for equality of floating point numbers can give imprecise results, see e.g. en.wikipedia.org/wiki/… \$\endgroup\$
    – Laikoni
    Apr 12, 2018 at 13:44
  • \$\begingroup\$ @Laikoni it's not testing for equality; it's comparing them. Whereas ints would not allow bots to divide their energy successively ad infinitum. \$\endgroup\$
    – RamenChef
    Apr 16, 2018 at 16:51
  • \$\begingroup\$ 1. You should disallow all reflection. 2. You need to run way more than 5 trials to get a good answer. 3. How are trial scores combined? What's the char for nothing? 4. You should add a helper method to get their own energy, as well as their own character. 5. I'd argue for int energy that is simply really high (like the maximum int or even maximum long). Then you don't deal with floating point imprecision, and will even improve calculation speed. 6. What happens when something attacks a rock? What does the rock return? \$\endgroup\$ Apr 18, 2018 at 14:52
  • \$\begingroup\$ 7. If I lose a battle, do I lose energy, or do I instantly die? 8. Re Dragons: I see two primary issues: The attack is so high to make fighting them pretty impractical. It's possible to identify them based off of their movement, but your field of vision is very small. If vision is bigger, then bots will learn to avoid them, but now many bots will start to imitate dragons. In essence, making dragons so strong changes the balance of the game drastically. Consider if that is really what you want. 9. Do you allow communication between instances of the same bot? What about different bots? \$\endgroup\$ Apr 18, 2018 at 14:57
  • \$\begingroup\$ @NathanMerrill 1) Why go beyond installing a SecurityManager? 2) The winner usually won't be determined by luck alone. 3) They're averaged. (will add this to the spec) 4) I had one for energy in the runner, but I forgot to document it. 5) ints can't go to 10^-300. 6) The rock returns 0. 7) You die instantly. The winner loses energy. 8) Noted. 9) Yes. Hiveminds are allowed. \$\endgroup\$
    – RamenChef
    Apr 18, 2018 at 23:46
  • \$\begingroup\$ 1) Because KotHs shouldn't be about the language, they should be about the core game rules. The instant you bring in reflection, you get in the world of one-upping: No matter how good my bot is, it can be one-upped. 2) Really? As of right now, I don't see any reason why not. Your starting position has a huge affect on how well you do. 3) Note that this means that winning by a large margin on a few games means more than consistently winning by a little. (This isn't bad, but its worth considering). 5)Ok? You don't need that much precision. 6,7,8) Please add to spec :) \$\endgroup\$ Apr 19, 2018 at 2:46
  • \$\begingroup\$ The aliens won't be given the classes of their opponents; only their character. If they want to keep pets of their opponents (like MultiWolf) I won't stop them \$\endgroup\$
    – RamenChef
    Apr 19, 2018 at 11:57
  • \$\begingroup\$ @RamenChef fair enough, but MultiWolf does't require reflection. He could simply have a function that builds the array by calling their constructors normally. \$\endgroup\$ Apr 19, 2018 at 15:03
  • \$\begingroup\$ @NathanMerrill Reflection is more streamlined though. \$\endgroup\$
    – RamenChef
    Nov 21, 2018 at 16:23
  • \$\begingroup\$ I'd love to see this make it to the main site. You can use something like this to open up the competition to other languages, but be warned, you may end up spending quite a few hair-pulling hours trying to get other people's code to work on your machine. I'll be the third to comment that using integers would be better. You commented that you won't be testing for equality but in the challenge spec you mention handling ties. How are multi-way ties handled? Maybe change "determined by coin flip" to "chosen at random". \$\endgroup\$
    – Rainbolt
    May 22, 2019 at 23:27
  • \$\begingroup\$ Maybe I missed it, but what char represents an empty square? \$\endgroup\$
    – Rainbolt
    May 22, 2019 at 23:27

Count smooth numbers

Define \$\Psi(x,B)\$ as the number of integers between \$1\$ and \$x\$, whose prime factors are all \$B\$ or less. (These are the \$B\$-smooth numbers.)

For example, there are 34 integers between 1 and 100 that have only 2, 3 and 5 as prime factors. These are:

 1  2  3  4  5  6  8  9 10 12
15 16 18 20 24 25 27 30 32 36
40 45 48 50 54 60 64 72 75 80
81 90 96 100

Therefore, \$\Psi(100,5)=34\$. The next prime is 7, so \$\Psi(100,6)\$ is also 34.

This is a challenge to calculate exact values of \$\Psi\$ as quickly as possible.


You may not use libraries or built-ins that calculate this function. That being said, I don't know any language that has a built-in for this (not even Mathematica?)

I also can't seem to find any fast algorithms for this problem, except for a basic meet-in-the-middle by Daniel J. Bernstein which might be a good starting point.

Bernstein also describes an approximation method that may or may not be useful.

Input range

You may assume that \$1<B\leq x\leq 10^{100}\$ and \$B<10^6\$.


You will be scored on tiers of increasing difficulty.

Each tier has several inputs \$(x,B)\$ such that the \$\Psi(x,B)\$ have similar values, and the \$x\$ values are distributed exponentially. Tiers will start at around \$\Psi(x,B)\approx 10^9\$ and go up to \$\Psi(x,B)\approx 10^{20}\$ or more, depending on how fast the entries get.

The time limit for each tier is 60 CPU seconds per input on average. In other words, if a tier has \$n\$ inputs, you will essentially have \$n\$ CPU minutes to obtain the outputs. You are welcome to submit parallel code but each thread will count towards the time limit.

Your score is the highest tier that your program can solve. If there is a tie, the program that is fastest on the highest tier wins.

For practical reasons, your program will be limited to 15GiB of memory.

Sample tiers


  Ψ(10^3, 997) = 1000
  Ψ(10^6, 7)   = 1273
  Ψ(10^9, 5)   = 1530
  Ψ(10^6,  999983) = 1000000
  Ψ(10^9,  59)     = 1060717
  Ψ(10^12, 29)     = 1469549
  Ψ(10^15, 17)     =  919814
  Ψ(10^36, 7)      =  936046


  Ψ(10^9,  999983) =  616220853
  Ψ(10^10, 4567)   =  954965955
  Ψ(10^12, 337)    = 1180049403
  Ψ(10^15, 97)     = 1016358704
  Ψ(10^18, 59)     = 1106651678
  Ψ(10^24, 31)     =  791377032
  Ψ(10^30, 23)     =  812060729
  Ψ(10^48, 17)     = 1435897064
  Ψ(10^11, 11987) = 10016301575
  Ψ(10^12, 1499)  = 10753426440
  Ψ(10^15, 199)   = 12766644440
  Ψ(10^18, 89)    =  9052115006
  Ψ(10^24, 47)    = 11298682134
  Ψ(10^30, 37)    = 14838208717
  Ψ(10^48, 19)    =  7868307089
  Ψ(10^13, 2297) =  84344528150
  Ψ(10^15, 443)  =  96272828440
  Ψ(10^18, 163)  = 107816435926
  Ψ(10^36, 37)   =  94053521936
  Ψ(10^24, 67)   =  81421195505
  Ψ(10^48, 29)   = 151266342065


I may choose to do the actual scoring on different inputs, including using \$x\$'s that are not powers of 10.


Squish these Numbers

META: I think my wording is not very clear, if you have a suggestion to make it easier to understand, feel free add a commment or edit it directly in to this post.

Given a finite sequence of real floating point numbers, map it into the Interval \$[-1,1]\$, such that the order of these numbers is preserved.


  • You can choose any mapping you like, it doesn't have to be linear.
  • The mapping you choose doesn't have to stem from a function, that means some number \$x\in \mathbb R\$ doesn't have to get mapped to the same number in \$[-1,1]\$, the value it does get mapped to can change depending on the other values in the input list.
  • Two equal values in the input list, should remain equal in the output.
  • If some value in the input list is strictly smaller than some other value, then the corresponding values in the output should satisfy the same relation, in theory. In practice it might happend that two different numbers will get mapped to the same output due to floating point arithmetic issues, which is fine - as long as it would work with an arbitrary precision.
  • You can assume the input sequence contains at least two distinct entries.


Following example finds a linear map that maps the least entry to \$-1\$ and the greatest entry to \$1\$. Note how this map depends on the sequence.

$$ (x_1,x_2,\ldots,x_n) \mapsto \left( \frac{x_i - \min_k x_k}{\max_k x_k - \min_k x_k} \right)_{i=1}^n $$

Following example is a fixed function that always behave the same. Because it is monotonic and strictly increasing, it satisfies all conditions. $$ (x_i)_{i=1}^n \mapsto \left(\frac{\arctan(x_i)}{\pi} \right)_{i=1}^n$$

Thanks @PeterTaylor for following example. Here \$\operatorname{sort}(x)\$ sorts the input sequence in ascending order and \$\operatorname{indexof}(u,v)\$ returns the index of the first occurence of \$v\$ in the sequence \$u\$.

$$(x_i)_{i=1}^n \mapsto \left( \frac{1}{n} \operatorname{indexof}(\operatorname{sort}(x),x_i)\right)_{i=1}^n$$

  • \$\begingroup\$ How about a function which sorts the array and then maps \$x_i \to \frac1n \textrm{indexof}(\textrm{sorted}(x), x_i)\$? \$\endgroup\$ Dec 18, 2018 at 14:59
  • \$\begingroup\$ Yeah that looks fine (assuming for e.g. \$x_1 = x_2\$ we get the same index). - If you do not mind I'll add that as an example too. \$\endgroup\$
    – flawr
    Dec 18, 2018 at 17:22
  • 2
    \$\begingroup\$ I think many languages have builtin tanh which trivializes this. Are you sure there are enough languages where this challenge is interesting? \$\endgroup\$
    – lirtosiast
    Dec 19, 2018 at 0:40
  • 2
    \$\begingroup\$ I expect it will be hard for a list-aware function to beat a general mapping like x->1+1/(1+2**-x), or just tanh if that's available, but maybe Peter Taylor's method will be shorter in golfing languages. I think it's worth noting in the spec that it's OK if due to float inaccuracies two very close values are mapped to the same value in practice. \$\endgroup\$
    – xnor
    Dec 19, 2018 at 0:42
  • \$\begingroup\$ @xnor I'll add the comment about the floating point problems, that is a good point. I'm convinced that there will be a lot of different approach that will be optimal in the different languages. \$\endgroup\$
    – flawr
    Dec 19, 2018 at 9:16

Shortest JsFuck code for a number

JsFuck is a language using only []()!+ to run and express anything in JavaScript. Below is a simplified model of JavaScript to express numbers:

  • Types
    1. Number
    2. String
    3. Boolean (true)
    4. Array
  • Functions
    • IEEEdouble(x):
      • Let \$u\$ is the number in \$\{a\cdot 2^{b}|-2^{53}<a<2^{53}, b>-1075, a,b\in \mathbb Z\}\$ nearest to x, maximizing \$b\$ on tie
      • If \$|u|<2^{1024}\$, return \$u\$
    • toNumber(x):
      • If x is a Number, return x;
      • If x is a Boolean, return 1;
      • If x is an Array [y], return toNumber(y);
      • If x is an Array [], return 0;
      • Otherwise, x is a String. In this case,
      • If x matches /^([\+\-]?(?:\d*\.?\d+|\d+\.))(?:e([\+\-]?\d+)?$/, let \$v=\text{$1}\times 10^\text{$2}\$ ($2 is zero if not present)
      • Return IEEEdouble(\$v\$)
    • toString(x):
      • If x is a String, return x;
      • If x is a Boolean, return 'true';
      • If x is an Array [y], return toString(y);
      • If x is an Array [], return '';
      • Otherwise, x is a Number. In this case,
      • Find \$p, q\in \mathbb Z\$ such that IEEEdouble(\$p\times 10^q\$)=x, maximizing \$q\$(there may be multiple \$p\$ satisfying the restriction, in which case choosing which one is unknown);
      • Let \$y=p\times 10^q\$;
      • If \$y=0\$ or \$10^{-6}\leq|y|<10^{21}\$, write it normally without scientific notation mapping the RegEx /^([1-9]\d*|0)(\.\d*[1-9])?$/;
      • Otherwise, write it in scientific notation mapping the RegEx /^[1-9](\.\d*[1-9])?e[\+\-][1-9]\d*$/
    • x+y
      • If either x or y is a String or an Array, return toString(x) concatted with toString(y);
      • Otherwise, return IEEEdouble(the sum of toNumber(x) and toNumber(y))
    • +x
      • Return toNumber(x)
    • [] and [x]
      • Return an Array.
    • x[y]
      • If x is a String, return the yth character(0-index) in x
    • !![] and !+[]
      • Return a Boolean

A valid JsFuck code is always parenthesis balanced without two symbols + together. Expression in parenthesis is calculated before the one out. On the same layer operations go from left to right.

You are required to output the shortest JsFuck code that generates a given IEEE double (A possible output of IEEEdouble). Shortest generator wins.

It's fine if your generator runs slow, but beware of potential infinite loop if you eval.


1     -> +!![]
2     -> !![]+!![]
10    -> +[+!+[]+[+[]]]
1e10  -> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))
0.1   -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+!![]))
1e-10 -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))
5e-324-> +(!![]+!![]+!![]+(!![]+[])[!![]+!![]+!![]]+(+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(!![]+!![]+!![])+(!![]+!![])+(!![]+!![]+!![]+!![]))
      -> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))+(+((+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(+!![])))

SN: Another way to ask is requiring to be testable and shouldn't be longer than a chosen generator

  • 2
    \$\begingroup\$ Challenge seems a bit too long-- maybe restrict the domain to integers? Also I can't see any competitive solution actually finishing for nontrivial test cases because they'd just eval all valid JSFuck strings in parallel. \$\endgroup\$
    – lirtosiast
    Jan 6, 2019 at 3:41
  • \$\begingroup\$ @lirtosiast Do your "integer" mean safe integer? Also I don't see how it simplifies the problem much \$\endgroup\$
    – l4m2
    Jan 6, 2019 at 7:30

Is it shifted?

Consider a standard US-International QWERTY keyboard, without a numeric keypad, and Caps Lock mysteriously missing.

< insert image >

The goal is to write two programs or functions that take no input, and each give a distinct output through any default output method: Shift and No shift respectively. The program that outputs No shift has to be written without use of the ⇧ Shift key. The program that outputs Shift has to be written while holding the ⇧ Shift key throughout. Both programs have to be written using the exact same sequence of keypresses. A valid entry would be a1b2 + A!B@, if they output No shift and Shift respectively.

The symbols allowed for the "No-shift" program are as follows:

<space> <newline> <tab> 

The symbols allowed for the "Shift" program are as follows:

<space> <newline>

Note that Tab ↹ is missing, since Shift+Tab ↹ does not produce a \t tab symbol in most editors.

Sandbox note

I think using case-sensitive output makes the challenge more challenging, but it might become too challenging. What are your thoughts?

  • \$\begingroup\$ This already appears to be impossible in most productive languages, so I would allow output in any case. \$\endgroup\$
    – Laikoni
    Jan 13, 2019 at 8:53
33 34
36 37

You must log in to answer this question.

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