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".

  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4705 Answers 4705

62 63
65 66

Who Won the Chess Game?

Bear with me, this is incredibly bare-bones at the moment; I'll work on this over-time, just wanted to gauge interest on the over-all idea.

Given an input list of moves l, output who won the chess game given that white always goes first, alternating moves from there. Using the following convention for naming the chess squares:

enter image description here

Where the pieces are:


The first assumption you will make is that the list of moves passed is a VALID chess game, to completion. The following would be an example input:


The first two moves given would result in:


Which is white's first move, followed by black's move:


Then, you would continue parsing moves until a king disappears. Whichever king is left should be declared the winner.

Waiting to Gauge Interest Before Wasting Time on Full Testcase


Nested list unpacking

In Python 3.5+, the * operator can unpack a list within a list.

[1,*[2,3,4],5] == [1,2,3,4,5]

The unpacked elements are placed directly into the outer list without increasing the list depth. Note that this is different from the nested three-element list


Your goal is to simplify a nested list expression by resolving all instances of unpacking. So, the output will simply be a nested list without any *.

Specifically, the input will be an expression that consists of

  • A non-empty list of expressions [..]
  • An non-empty unpacked list of expressions *[..].
  • A digit 1 through 9

The outermost layer will always be a non-empty list. The output is such an expression without any unpacking.

Input: A string of characters [],*123456789

Output: Its unpacked analogue. This can be a string or list structure.

This challenge can be done in any language. Python and other languages with the same unpacking format may not use eval or exec or equivalents.

TODO: I/O details, test cases

  • \$\begingroup\$ This is similar to least Levenshtein distance to a balanced list (replace *[ with { and then remove unbalanced ]). \$\endgroup\$ Commented Jul 25, 2017 at 7:20

Title: Visualizing Euclid's Algorithm


We wish to visualize Euclid's algorithm for computing the greatest common divisor of two numbers as a 2-dimensional tiling, such as this one:


This interactive version may also be helpful in understanding the visualization.


Two positive integers a and b, where a > b. You may take them in any order and in any convenient form: a list, two function args, etc.


An ascii version of the above visualization shown above. This is best illustrated with a few examples:

input = 20, 8

.       .       .   .
.       .       .   .
.       .       .   .
.       .       .....
.       .       .   .
.       .       .   .
.       .       .   .

8 goes into 20 2 times, so we have two 8x8 squares, and remainder of 4 (20 - 8*2 = 4). 4 goes into 8 2 times with no remainder, so the remaining rectangle is broken into to 2 4x4 squares and we're done.

input = 5, 3

.  ...
.  . .

Note: There is an implied connection between any two adjacent dots, so that the above ascii should be interpreted as follows:

connected nodes

input = 7, 3

.  .  ..
.  .  ..


You may choose whichever border characters are prettiest to you, or use combinations of different characters.

.....................   *********************   +-------+-------+---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .....   *       *       *****   |       |       +---+
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.       .       .   .   *       *       *   *   |       |       |   |
.....................   *********************   +-------+-------+---+

Rotations are also allowed: Any of the above may be rotated 90, -90, or 180 degrees.


This is , standard loophole rules, etc.

  • \$\begingroup\$ Nice challenge! But I would add a test cases like 8,5 and 21,13 where the recursion goes a bit deeper. \$\endgroup\$ Commented Jul 26, 2017 at 8:16
  • \$\begingroup\$ @BruceForte thanks. unfortunately since posting it I found this, which I fear is too similar: codegolf.stackexchange.com/questions/119714/… \$\endgroup\$
    – Jonah
    Commented Jul 26, 2017 at 17:06
  • \$\begingroup\$ Yeah you're right, didn't know these existed. \$\endgroup\$ Commented Jul 26, 2017 at 17:11

NB: work in progress


MADBACE is a mixed Roman-hexdecimal system. Hexadecimal digits (0-F) take their normal positional values, while Roman numerals (IVXLCDM) have their normal values (1 5 10 50 100 500 1000). The main parts of the challenge is to determine when to subtract and when C and D are Roman versus hexadecimal.


  1. C and D will be Roman if possible.

  2. There can never be more than one subtractive symbol to the left of any symbol.

  3. A subtractive symbol must be less than half the symbol it subtracts from





DM792 1000-13×161




ID49 13×160-1

3C52 100-3×161

4C76 4×161+12×160

MADBACE701590 (10×165-1000)+(11×163-500)+10×162+100+14×160

DECIMAL233571513 13×166+14×165+12×164+(1000-1)+10×161+50

  • \$\begingroup\$ Maybe make explicit mention that a smaller symbol to the left of a larger symbol is always subtracted if both are Roman. And if one is Roman? What if neither are? Actually if neither are then the position based value ensures the symbol to the left is always larger. \$\endgroup\$ Commented Jul 25, 2017 at 23:01
  • \$\begingroup\$ If only a single symbol can be to the left for subtraction, how are ambiguous cases like IXL resolved? \$\endgroup\$ Commented Jul 25, 2017 at 23:02
  • \$\begingroup\$ Are all possible inputs from the symbol alphabet to be dealt with, or just some subset? I mean, does the spec resolve all ambiguities or will the challenge specify "only valid inputs will be used"? \$\endgroup\$ Commented Jul 25, 2017 at 23:03

Calculate the maximum possible number of "living" cells on a given grid size for Conway's Game Of Life.

Conway's Game Of Life

Game Rules:

  1. Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
  2. Any live cell with two or three live neighbours lives on to the next generation.
  3. Any live cell with more than three live neighbours dies, as if by overpopulation.
  4. Any dead cell with exactly three live neighbours becomes a live cell, as if by reproduction.

Challenge: For a given grid size (ex 5x5) is it possible to calculate the maximum potential living cells after at least 5 generations with any given starting pattern?

 O O X O O
 O O X O O
 X X X X X
 O O X O O
 O O X O O

In the above example, there are 16 living cells. I am not proposing that this is the maximum, just providing a starting point.

The reason for the 5th generation requirement is because the first generation could technically be 25 (100%) I suppose.

  • 3
    \$\begingroup\$ To me, this is a very interesting challenge because brute-forcing it would be difficult (5x5 board has 2^25=32 million possibilities for starting). That being said, this should be marked as code-golf or fastest-code as a winning criterion (read the code-challenge description). Also, the rules should specify that all eight surrounding cell are included in the count. Is the board toroidal (i.e. edge wrapping) or flat? Are there any limits on the grid size? Importantly, this needs test cases to be a good challenge. If a 5x5 example is too big, do a 3x3 example. \$\endgroup\$ Commented Jul 26, 2017 at 18:37

Can you compete with a supercomputer?

The challenge is to write super fast code for computing the permanent of a matrix of complex numbers.

In a paper from 2016 a team of coders managed to compute the permanent of a 40 by 40 complex matrix on 8192 nodes of what was at the time the world's fastest computer in about 14 seconds. Your challenge is to see how close you can get to this on my desktop.

The permanent of an n-by-n matrix A = (ai,j) is defined as

enter image description here

Here S_n represents the set of all permutations of [1, n].

As an example (from the wiki):

enter image description here

In this question matrices are all square.

Examples (these need updating to have complex entries)


[[ 1 -1 -1  1]
 [-1 -1 -1  1]
 [-1  1 -1  1]
 [ 1 -1 -1  1]]




[[-1 -1 -1 -1]
 [-1  1 -1 -1]
 [ 1 -1 -1 -1]
 [ 1 -1  1 -1]]




[[ 1 -1  1 -1 -1 -1 -1 -1]
 [-1 -1  1  1 -1  1  1 -1]
 [ 1 -1 -1 -1 -1  1  1  1]
 [-1 -1 -1  1 -1  1  1  1]
 [ 1 -1 -1  1  1  1  1 -1]
 [-1  1 -1  1 -1  1  1 -1]
 [ 1 -1  1 -1  1 -1  1 -1]
 [-1 -1  1 -1  1  1  1  1]]




[[1, -1, 1, -1, -1, 1, 1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, 1, 1, -1],
 [1, -1, 1, 1, 1, 1, 1, -1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, 1, -1],
 [-1, -1, 1, 1, 1, -1, -1, -1, -1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, -1],
 [-1, -1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1, -1, -1, -1, -1, -1, -1, 1, -1],
 [-1, 1, 1, 1, -1, 1, 1, 1, -1, -1, -1, 1, -1, 1, -1, 1, 1, 1, 1, 1],
 [1, -1, 1, 1, -1, -1, 1, -1, 1, 1, 1, 1, -1, 1, 1, -1, 1, -1, -1, -1],
 [1, -1, -1, 1, -1, -1, -1, 1, -1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1],
 [1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
 [1, -1, -1, -1, -1, -1, 1, 1, 1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1],
 [-1, -1, 1, -1, 1, -1, 1, 1, -1, 1, -1, 1, 1, 1, 1, 1, 1, -1, 1, 1],
 [-1, -1, -1, -1, -1, -1, -1, 1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1],
 [1, 1, -1, -1, -1, 1, 1, -1, -1, 1, -1, 1, 1, -1, 1, 1, 1, 1, 1, 1],
 [-1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, -1, -1, -1, -1, -1, 1, -1, 1],
 [1, 1, -1, -1, -1, 1, -1, 1, -1, -1, -1, -1, 1, -1, 1, 1, -1, 1, -1, 1],
 [1, 1, 1, 1, 1, -1, -1, -1, 1, 1, 1, -1, 1, -1, 1, 1, 1, -1, 1, 1],
 [1, -1, -1, 1, -1, -1, -1, -1, 1, -1, -1, 1, 1, -1, 1, -1, -1, -1, -1, -1],
 [-1, 1, 1, 1, -1, 1, 1, -1, -1, 1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1],
 [1, 1, -1, -1, 1, 1, -1, 1, 1, -1, 1, 1, 1, -1, 1, 1, -1, 1, -1, 1],
 [1, 1, 1, -1, -1, -1, 1, -1, -1, 1, 1, -1, -1, -1, 1, -1, -1, -1, -1, 1],
 [-1, 1, 1, 1, -1, -1, -1, -1, -1, -1, -1, 1, 1, -1, 1, 1, -1, 1, -1, -1]]



Add the 40 by 40 matrix here

The task

You should write code that, given an n by n complex matrix, outputs its permanent.

To make testing simpler, I will provide a single 40 by 40 complex matrix which you can hardcode into your code in any format of your choosing. Clearly, you are not allowed to precompute the answer however!

Scores and ties

I will test your code on the sample 40 by 40 complex matrix. Your score is your time in seconds divided by 14.

If two people are within 1 second of each other then the winner is the one posted first.

Languages and libraries

You can use any available language and libraries you like but no pre-existing function to compute the permanent. I will run your code under OS X so please give full instructions for how to compile and run it.

Reference implementations

There is already a codegolf question question with lots of code in different languages for computing the permanent for small matrices. There was also a related challenge on computing the permanent of matrices with only +-1 entries. The coding issues when you have complex entries and want things to run fast and multi-core are quite different however.

My Machine

The timings will be run on my Mac desktop. The CPU is Intel(R) Core(TM) i7-6700K CPU @ 4.00GHz.

  • 1
    \$\begingroup\$ Remember #asdfjkl; and ##asdfjkl;, not **asdfjkl;**, for headings. \$\endgroup\$
    – wizzwizz4
    Commented Jul 28, 2017 at 19:07
  • \$\begingroup\$ Why divide the score by 14? I know it ties in with the story, but surely it primarily adds to confusion. Also, will all the input matrices only contain +/-1? \$\endgroup\$ Commented Jul 28, 2017 at 19:34
  • \$\begingroup\$ @FryAmTheEggman No the matrices will have complex entries. I need to change the examples. Dividing by 14 was just for fun to compare with the supercomputer. I can remove that if you think it's better. \$\endgroup\$
    – user9206
    Commented Jul 28, 2017 at 19:35

Survival Island

Work in Progress, mainly trying to get the idea out and see if anyone is interested. Also make sure it hasn't been done already. Ideas taken from The Hunger Game and Player Unknown Battleground

The Board

The game will be played on a square 2-dimensional array with the size of x + ny where n is the number of players, and x and y are to be determined. No wrap


All objects can be destroyed while on the map, hence their hp. Once they are picked up, they cannot be destroyed unless the player dies.

1.Wall: Denoted by the character 'W'

HP: 10
Object Type: Wall

2.Reinforced Wall: Denoted by the character 'R'. When a wall is upgraded to reinforced wall by the player, 10 hp is added to the remaining hp on the wall.

HP: 20
Object Type: Wall

3.Crossbow: Denoted by the character 'C'. Allow the player to have ranged attack with a distance of 2. The damage dealt will be the player's damage minus 1.

HP: 1
Weight: 1
Upgrade #1: damage + 1
Upgrade #2: attacking distance + 1, damage + 1
Object Type: Item(Equipment)

4.Dagger: Denoted by the character 'D'. If the player is attacking with a distance of 1, it does 1 extra damage.

HP: 1
Weight: 1
Upgrade #1: damage + 1
Upgrade #2: damage + 2
Object Type: Item(Equipment)

5.Binocular: Denoted by the character 'B'. Increase the player's line of sight by 1.

HP: 1
Weight: 1
Upgrade #1: line of sight + 1
Upgrade #2: line of sight + 1
Object Type: Item(Equipment)

6.Shield: Denoted by the character 'S'. Increases the player's block by 1

HP: 2
Weight: 1
Upgrade #1: nothing
Upgrade #2: block + 1
Object Type: Item(Equipment)

7.Armor: Denoted by the character 'A'. negates 1 damage from any incoming damage to the player.

HP: 2
Weight: 2
Upgrade #1: nothing
Upgrade #2: incoming damage - 1
Object Type: Item(Equipment)

8.MedicKit: Denoted by the character 'M'. When used, heal the player's health by 5.

HP: 1
Weight: 0.5
Upgrade #1: hp restored + 3
Upgrade #2: hp restored + 5
Object Type: Item(Consumable)

9.EnergyDrink: Denoted by the character 'E'. When used, increase STR, AGI, and VIT by 1 for 5 turns. (If the player has already drank an energy drink, it will override previous effect).

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 3 turns
Upgrade #2: all attribute + 1
Object Type: Item(Consumable)

10.PoisonedEnergyDrink: Denoted by the character 'E'. When used, decrease STR, AGI, and VIT by 1 for 3 turns.

HP: 1
Weight: 0.5
Upgrade #1: buff duration + 2 turns
Upgrade #2: all attribute - 1
Object Type: Item(Consumable)

11.UpgradeKit: Denoted by the character "U". Used to upgrades other items. All item can be upgraded twice. 1 upgrade kit is used to upgrade an item once.

HP: 1
Weight: 1
Upgrade #1: nothing
Upgrade #2: nothing
Object Type: Item(Special)

12.Player - Denoted by the character 'P'. This is the actual player on the board. See next section for more details.

HP: determined by the player
Object Type: Player

E.g. In the following map, the player have a line of sight of 1.

|   | A |   | 
| R | P |   |
|   |   |   |

In particular. There's a reinforced wall on the left, and a piece of armor on the top. the player is at the center. This can be represented as [{0,1,A},{1,0,R},{1,1,P}]

The player

Each player have the following 3 attributes:

  • STR: affects damage and carrying capacity of the player. +1 damage for each 2 STR and +1 capacity for each 1 STR

  • AGI: affects player's movement range and line of sight. +1 movement for each 5 AGI, and +1 line of sight for each 3 AGI

  • VIT: affects player's health and block. +3 health for each 1 VIT, and +1 block for each 3 VIT

You are free to assign 0 to 10 attribute points to the above 3 attributes when creating your character. Any character with more than 10 attributes assigned at the start of the game is disqualified.

Each player will start off with the following stats (without attribute bonus):

  • health: 20
  • damage: 1
  • carrying capacity: 3
  • movement: 1
  • line of sight : 2
  • block: 0

Game play

Each turn, the player will perform a move and an action.

Movement phase

Movement can either be '^' for up, 'v' for down, '<' for left, '>' right or '.' for stay.

If you can move 2 or more tiles, you can provide all movements in the order you want them to executed (e.g. "^>" will move up then right, and ">^" will move right then up).

If the first movement fails(due to object being there), the subsequent movements are dropped.

The movement phase is performed by every player performing their first movement, then every player performing their second movement if available, etc.

If 2 or more players attempt to move to the same square, then the player with the highest agility wins. If they have the same agility, then it's determined by a dice roll.

Action phase

Each player can perform the following actions during the action phase

  1. Attack : Denoted by "A ". Performs an attack to the coordinate x,y If the coordinate is out of reach, then do nothing. x and y should be relevant to the player, e.g. 0,-1 is attacking down adjacent to the player.

  2. Block: Denote by "B". Performs an block on each incoming attacks with the chance of block/10. If the block succeeds, negate all damage from that attack.

  3. Pickup : Denoted by "P ". Tries to pick up an object at that direction adjacent to the player. If the tile is empty, or if picking up the item exceeds your carrying capacity, then do nothing.

  4. Drop : Denoted by "D ". Tries to drop an item at that direction adjacent to the player. If the tile is already occupied, or the item does not exist. then do nothing.

  5. Build Wall : Denoted by "W ". Tries to build a wall at that direction adjacent to the player. If the tile is already occupied, then do nothing.

  6. Reinforce wall : Denoted by "R ". Tries to upgrade a wall at that direction adjacent to the player. If the tile is not a wall or player do not have UpgradeKit, then do nothing.

  7. Consume : Denoted by "C ". Consumes an item in your inventory. If the item does not exist, then do nothing.

  8. Upgrade : Denoted by "U ". Upgrades an item in your inventory. If the item does not exist, or if you have no UpgradeKit, or if the item already maxed out upgrades. Then do nothing

  9. Equip : Denoted by "E ". Equips an item. If the item does not exist, then it does nothing, If you have already equipped an item. then put that item in the inventory.

  10. Sleep: Denoted by "S". Increase health by 3. increases all incoming damage by 1. increase movement, damage, and block next turn by 1. Last one turn.

  11. Gaze into the sky: Denoted by "G". Looks up into the sky and ponder about life (Do nothing).

If 2 players try to perform an action at the same tile, It is first determined by the order of actions. If the players uses the same action, then the highest agility player wins. if they have the same agility, then it's determined by a dice roll who should succeed.

Order of actions that is Sleep > Block > Consume > Equip > Upgrade > Gaze > Reinforce Wall > Pickup > Drop > Build Wall > Attack

example: Given an empty tile x. if player a performs pickup at tile x, player b performs drop on tile x, player c performs build on tile x, and player d performs attack on tile x. Then player a does nothing, player b drops an item on tile x. player c does nothing, and player d attacks that item


Each round, the following is output to each player for movement and again for action: round #, phase, player inventory, player equipment, player buffs, player capacity, attack, block, movement, los, player hp, player line of sight, possibly more?

e.g. 14,M,AEEMM,B,P2E3,6,5,1,1,3,19,[{0,1,A},{1,0,R},{1,1,P}]


  • round 14
  • currently it's movement phase.
  • player is carrying Armor, 2 * Poisoned? Energy Drink, 2 * Medic Kit
  • player is equipping Binocular
  • player current have a buff of poisoned energy drink with 2 turns remaining, and energy drink with 3 turns remaining
  • player has a maximum of 6 carrying capacity
  • player has an attack of 5
  • player has a block of 1
  • player has a movement of 1
  • player has a line of sight of 3
  • player has a hp of 19
  • player sees the map as shown before

Each round, 2 inputs will be read from the players

Movement phase

use '^','<','v','>' to indicate movement direction and '.' for stay, if you can move 3 times, output 3 characters.

e.g. "<.<" indicates you move left, wait then left again

Action phase

output one of the actions listed in game play

e.g. - "E 1" equips the 1st item in your inventory if possible - "A 1 2" attacks 1 tile to the right and 2 tile above you if possible.

Determine winner

a game ends if only 1 bot is alive or it is played to 1000 turns.

each each live bot gets 1/<# of bots alive> points

x games will be played and the points will be totaled to determine the winner.

Additional Information

  • Damage is calculated by attack - armor defense. If the defending player used Block, then there is block/10 chance to completely negate all damage.

  • All distance are Manhattan distance

  • More items spawn near the center than border (if I can find a way to do this efficiently)

  • Player can pick roughly where they spawn such as near border or near center (if I can find a way to do this efficiently)

Questions/To-Do list

  • Figure out what's a good map size

  • Too many/little actions/objects?

  • Balance items and stats?

  • Is the game clear enough?

  • Is output and input sufficient for the gameplay?

  • Any suggestions or comments?

  • Format question so it looks nicer. Make important information stand out. Fix grammer

  • Catchy title?

  • Figure out how many games to play to get winner

  • Make it shorter? wall of text is not fun D:

  • Figure out how many of each object to spawn

  • When player die, randomly drop an item, drop equipped item, drop nothing?

  • Find time to write the controller

  • Figure out how to use the site


Proposed Question

Triskaidekaphobic Primes

It is known that a certain number, which lies between 12 and 14, brings bad luck. The Church of Triskaidekaphobia (CoTDP) asserts that the key to salvation is avoiding this number in all situations, such as numbering floors, license plates, space shuttle missions and more.

The IT department of CoTDP is looking for talented developers. Candidates must prove their ability to program in accordance with Triskaidekaphobic dogma. Can you get this prestigious job?

Your Mission

Write a program that prints all prime numbers below 1000, excluding the unlucky one. the program must obey the CoTDP programming rules.


  1. Numbers whose absolute value is greater than 12 and smaller than 14 are considered unlucky and must be avoided.
  2. Unlucky numbers must not be used in the program:
    • Must not appear in the program, in any representation/base.
    • Must not be the value of an expression or calculation (e.g. 5 + 8).
    • Must not be an intermediate value in an expression (e.g. 5 + 8 + 3, 35 % 22 == 0).
    • Must not be stored in a variable, register, memory etc (e.g. for i in xrange(20):).
    • Must not be passed to a function or returned from one.
    • The above applies to any complex type which contains an unlucky number (e.g. range(20) in Python 2).
    • The above applies to all expressions, not just constant expressions (e.g. x+1 is invalid if x happens to be 12).
  3. No calculation, or intermediate value of a calculation, may yield an unlucky number. For example, and for i in xrange(20): are forbidden.
  4. Output lines bust be separated by line-feed only (no carriage return).
  5. You must find primes using basic mathematical operations. If your language provides tools to find primes or test primality, you must not use them.
  6. Standard Loopholes apply.


This is code-golf, the shortest solution (in bytes) wins.

Questions for Meta

  • Do the limitations make sense for all sorts of languages? I think they cover languages such as C/Python/Java that use expressions, and also languages such as BrainFuck that manipulate memory (I think it's obvious that you must not write 13 in a memory cell).
  • Is there a trivial solution that makes it uninteresting?
  • Would it be better as a popularity contest?
  • Or maybe, accept the shortest, but give a bounty for the most interesting/creative answer?
  • Can the expression "Church of Triskaidekaphobia" be considered offensive to followers of some churches?
  • \$\begingroup\$ Should we treat numbers such as 39 (13 * 3) as prime, or not prime for the sake of this calculation? If 13 is not a prime, then 39 is, but it's up to you. (I did something kind of similar to this here) \$\endgroup\$
    – Stephen
    Commented Jul 29, 2017 at 19:15
  • \$\begingroup\$ @StepHen, IMO, an unlucky divisor is still a divisor. I think asking for "primes below 1000, excluding the unlucky one" makes it clear. Your interpretation might make it more challenging, but I'm not sure how it would work - 39 is a multiple of 3 (though you shouldn't actually do this division), so how can it be prime? Maybe 169. \$\endgroup\$
    – ugoren
    Commented Jul 29, 2017 at 19:23
  • \$\begingroup\$ Related: we are not allowed to store 13, right? \$\endgroup\$
    – Stephen
    Commented Jul 29, 2017 at 19:37
  • \$\begingroup\$ @StepHen, I'm not sure what you mean by "store". My intention is that 13 won't be used in any way. I write that it can't be used in the program and can't be derived by calculation, so how can it be stored? \$\endgroup\$
    – ugoren
    Commented Jul 29, 2017 at 20:12
  • \$\begingroup\$ Well you could store it with x = ord("\r"), although if you can't use it there's not much point. \$\endgroup\$
    – Stephen
    Commented Jul 29, 2017 at 20:25
  • \$\begingroup\$ ord("\r") is an expression that yields 13, and is therefore invalid. But it's worth clarifying. \$\endgroup\$
    – ugoren
    Commented Jul 29, 2017 at 20:27
  • \$\begingroup\$ Your post (as it stands) says no calculation, not no expression. \$\endgroup\$
    – Stephen
    Commented Jul 29, 2017 at 20:28
  • 1
    \$\begingroup\$ Numbers whose absolute value is greater than 12 and smaller than 14 are considered unlucky and must be avoided. is 12.5 allowed? \$\endgroup\$
    – l4m2
    Commented Apr 2, 2018 at 19:09

Encrypt/Decrypt a Decimal in Binary

Given either a positive integer a or two positive integers b and c, either encrypt or decrypt the integer(s).


Given a=33344492, for example:

  1. Split a into consecutive runs: [333,444,9,2].
  2. Replace all runs with alternating 1's and 0's starting with 1: [111,000,1,0].
  3. Place back into binary: 11100010
  4. Convert to decimal: 226
  5. Calculate decryption key: 3492
    • This key is the unique characters from each distinct run.
  6. Return [226, 3492] as the answer, these represent [b, c] respectively.


Given b=226 and c=3492:

  1. Convert b into binary: 11100010
  2. Use c to "replace" in each character.
    • 11100010 -> 33300010 -> 33344410 -> 33344490 -> 33344492
  3. Print the single integer answer, a=33344492.

More Examples (For Decryption, Reverse Examples)










[10922, 10101010101010]
  • \$\begingroup\$ I'm not sure if this should be one or two challenges myself. \$\endgroup\$ Commented Jul 31, 2017 at 14:24
  • \$\begingroup\$ @TheLethalCoder based on the number of inputs, you perform a different function. It's one challenge, though it'd be equally viable as two; but it's not interesting enough for 2 challenges. \$\endgroup\$ Commented Jul 31, 2017 at 14:25
  • \$\begingroup\$ Yeah that's why I wasn't sure. Just commenting in case you hadn't thought of splitting it up. \$\endgroup\$ Commented Jul 31, 2017 at 14:26
  • \$\begingroup\$ The decryption stage might be clearer if you use a number that doesn't contain 0s and 1s. \$\endgroup\$ Commented Jul 31, 2017 at 14:27
  • \$\begingroup\$ @TheLethalCoder fixed. \$\endgroup\$ Commented Jul 31, 2017 at 14:29
  • \$\begingroup\$ For your first test case you show a walkthrough. I'd either move it to an actual walkthrough place or remove the steps. \$\endgroup\$ Commented Jul 31, 2017 at 14:33
  • \$\begingroup\$ The first time you talk about the decryption key you say it's 1092. Shouldn't it be 3492? \$\endgroup\$
    – Charlie
    Commented Jul 31, 2017 at 14:49
  • \$\begingroup\$ @CarlosAlejo it used to be 11100092 but I changed it to 33344492, nice catch; missed that. \$\endgroup\$ Commented Jul 31, 2017 at 14:52

Generate a Spiral Matrix

Given N, generate one out of all the spiral matrices with dimensions N x N using the values [0, 1, ..., n-1].

For example, if N = 5, there are 16 ways to generate a spiral matrix

 0  1  2  3  4    12 13 14 15  0     8  9 10 11 12     4  5  6  7  8
15 16 17 18  5    11 22 23 16  1     7 20 21 22 13     3 18 19 20  9
14 23 24 19  6    10 21 24 17  2     6 19 24 23 14     2 17 24 21 10
13 22 21 20  7     9 20 19 18  3     5 18 17 16 15     1 16 23 22 11
12 11 10  9  8     8  7  6  5  4     4  3  2  1  0     0 15 14 13 12

 0 15 14 13 12     4  3  2  1  0     8  7  6  5  4    12 11 10  9  8
 1 16 23 22 11     5 18 17 16 15     9 20 19 18  3    13 22 21 20  7
 2 17 24 21 10     6 19 24 23 14    10 21 24 17  2    14 23 24 19  6
 3 18 19 20  9     7 20 21 22 13    11 22 23 16  1    15 16 17 18  5
 4  5  6  7  8     8  9 10 11 12    12 13 14 15  0     0  1  2  3  4

24 23 22 21 20    12 11 10  9 24    16 15 14 13 12    20 19 18 17 16
 9  8  7  6 19    13  2  1  8 23    17  4  3  2 11    21  6  5  4 15
10  1  0  5 18    14  3  0  7 22    18  5  0  1 10    22  7  0  3 14
11  2  3  4 17    15  4  5  6 21    19  6  7  8  9    23  8  1  2 13
12 13 14 15 16    16 17 18 19 20    20 21 22 23 24    24  9 10 11 12

24  9 10 11 12    20 21 22 23 24    16 17 18 19 20    12 13 14 15 16
23  8  1  2 13    19  6  7  8  9    15  4  5  6 21    11  2  3  4 17
22  7  0  3 14    18  5  0  1 10    14  3  0  7 22    10  1  0  5 18
21  6  5  4 15    17  4  3  2 11    13  2  1  8 23     9  8  7  6 19
20 19 18 17 16    16 15 14 13 12    12 11 10  9 24    24 23 22 21 20

You are allowed to use a parameter P to determine which out of the 16 spiral matrices you will generate.


  • This is so make your code as short as possible.
  • N >= 1
  • The parameter P should be a value such as a number, character, or any other reasonably simple value.
  • You may output the spiral matrix as a 2d array of numbers or characters, a formatted string, or any other easily understandable format.
  • \$\begingroup\$ Alternatively, the challenge might be to ignore P and just generate all 16 spiral matrices. \$\endgroup\$
    – miles
    Commented Jul 31, 2017 at 22:05
  • \$\begingroup\$ Also related \$\endgroup\$
    – Luis Mendo
    Commented Jul 31, 2017 at 22:27

Interpret a Maximal Number of Brainf*** Variants

A while ago in chat, I had an idea:

enter image description here

It was prompty shot down as impossible. Because of that, I'm making it a challenge!

Valid Languages

The only valid brainfuck variants you can use are the languages appearing on this link and this link (along with regular brainfuck, of course). Those two links are July 3rd, 2017 captures of the esolangs.org pages for brainfuck derivatives and brainfuck equivalents.

The Task

Your task is to create one program that, when fed code from any variant of brainfuck you say you can interpret, along with input for that program, will execute that code according to the spec of that variant. You cannot tell the interpreter beforehand what variant it is supposed to interpret.

There is one very important note: in brainfuck, for example, all characters not used are ignored as comments. Any program that is entered will not contain comments. All input will only contain characters that are not ignored by the spec.

Knowing this, if two variants of brainfuck overlap enough that you cannot differentiate between two valid, however short, programs in them, and if each language wants a different result, you can only include one of those languages.


The most important part of this challenge is maximizing the number of variants you can support. However, you also don't want to make it too long. Therefore, the following is your score:

(variantsSupported * 300) - interpreterBytes

Highest score wins.

  • \$\begingroup\$ yeah the problem is that ignored characters are not well defined. that is, any string of characters, excluding [ and ] (they might be misbalanced) is a valid bf program. that's a part of the spec pretty much \$\endgroup\$ Commented Aug 2, 2017 at 23:25
  • \$\begingroup\$ @DestructibleLemon I'm (trying) to remove that from the spec - if part of the spec is that some chars are no-ops, your interpreter does not have to handle them \$\endgroup\$
    – Stephen
    Commented Aug 2, 2017 at 23:35

Is this 2048 board valid?

Some 2048 boards are impossible to get into. For example,

2 _ _ 2
_ _ _ _
_ _ _ _
2 _ _ 2

will never occur in a 2048 game. Additionally, these are all impossible:

8 _ _ 8    8 _ _ _    2 2 2 2
_ _ _ _    _ 8 _ _    2 2 _ _
_ _ _ _    _ _ _ _    _ _ _ _
8 _ _ _    _ _ _ _    _ _ _ _

Your program needs to accept a 2048 board, and return a truthy value if the board is reachable, else falsy.

//Explanation of 2048 goes here.

I've listed 4 different boards that cover major test cases. Are there any others I'm missing?

  • \$\begingroup\$ hehe, don't forget [tag:sliding-puzzle] \$\endgroup\$
    – Stephen
    Commented Aug 1, 2017 at 19:56
  • \$\begingroup\$ As you've stated yourself the main thing missing here is the bulk of the challenge. \$\endgroup\$ Commented Aug 2, 2017 at 9:14
  • \$\begingroup\$ I wonder if it suffices to look one step back, or if you need to check if the previous position can itself be produced. \$\endgroup\$
    – xnor
    Commented Aug 4, 2017 at 7:35

I've got a challenge, but I'm not quite sure how to implement it in a way that's on-topic. It's possible this type of question just doesn't mesh with PPCG, but that's what the SandBox is for, right?

The gist is that I want a sort implemented lazily. So lazily that you don't actually write one, you steal someone else's. Your code should take an input, find/scrape an existing sorting algorithm off StackExchange (just PPCG?), run it, and output the sorted list.

Here's what I've got so far:

The Laziest Sort

I need a program that sorts a list, but man am I lazy. I don't mean "I'll just write a bubble sort and call it a day" lazy, but "I don't even want to write any sort at all" lazy. In fact, I don't even want to look at a sorting algorithm.

Given a list of numbers, I want you to return to me a sorted list. But like I said, I don't want to look a sorting algorithm. Instead, I want you to go find an existing sorting algorithm, run it, and tell me what it said.

The rules (This is part of where I need the SandBox)

  • You may not use any native sorting algorithms (like Collections.sort()).
  • You may use any sorting algorithm you can find, so long as it is from StackExchange.
  • You may import the code from the algorithm you use and run it from your answer, so long as the actual algorithm isn't in your source code.
  • Anything other requirement this challenge needs? I feel like this describes the problem I have in mind, but I've only made a few questions and they're typically math/array based.


seems an odd tag here, but seems to be frowned upon. Especially since I don't have a great question formed yet, but I feel like I've got a reasonable idea here. Any tips on how to get this question presentable enough to actually post?

  • 1
    \$\begingroup\$ Yeah, we have a tag for this. It's called duct-tape-coding \$\endgroup\$
    – geokavel
    Commented Aug 5, 2017 at 4:41
  • \$\begingroup\$ I would use code-golf for this personally. \$\endgroup\$
    – Gryphon
    Commented Aug 8, 2017 at 2:42
  • \$\begingroup\$ You mean, implement Stacksort? :) (not exactly the same, but very similar) \$\endgroup\$
    – Sanchises
    Commented Aug 8, 2017 at 11:27

Ah, Polish notation is always so confusing... [ABANDONED]

...so I order you to show me just how it works!That is, if you accept the challenge of course. For example, I can't even determine if xyz01 is supposed to do x(y(z(0)),1) or x(y(z(0),1)), if I don't know the arities. And, even if I know the arities, I can't understand what 20121012100 does in first glance (I have to think much to realize it's 2(0,1(2(1(0),1(2(1(0),0)))))). So, please, make my life easier.

Your challenge is, given a string, to "aritify" it. Here's how you do it:

First, you get a string (expression) containing up to 3 distinct chars, representing operators/functions with specific arities 0, 1 and 2.

Then, you convert the string to function-call representation, separating arguments with ,s and enclosing them in ()s (e.g. 212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))). This is the string you will return.


  • You are guaranteed that you are only given one expression (e.g. never something like 120010 -> 1(2(0,0))1(0) which contains more than one expression as a whole). Also, the input will never be empty.
  • There will not be missing trailing arguments, so something like 20 -> 2(0,the heck?) will never occur.
  • You may choose any 3 chars for the arities (e.g. n for 0, m for 1, d for 2), but you must specify them in your answer. You can't use any of ()[]<>{},; or space.
  • For the brackets, you may choose any one of (), [], <> or {}.
  • For the argument separator, you may choose ,, ; or (space). Also, the separator may have a trailing space, or both a trailing and a leading space, if it isn't a space. You must use a separator, it makes my life easier (how am I supposed to be able to read 211012101200 as 2(1(1(0))1(2(1(0)1(2(00))))) instead of 2(1(1(0)),1(2(1(0),1(2(0,0)))))? It's not properly organized.)
  • Chars defining arities must be outside the brackets, to the left, so something like 1200 -> ((0,02)1) or ((0,0)2)1 is disallowed instead of 1(2(0,0)). I want to know what operator it is before I start reading the arguments.
  • The 0-arity operator must not have appended brackets (e.g. 210110 -> 2(1(0),1(1(0))), not 2(1(0()),1(1(0())))), it's just useless cluttering that reduces simplicity, since you can always treat them as literals.
  • You may not omit the operator names (e.g. 221010121100 -> (((),()),(((()),))) is disallowed, 2(2(1(0),1(0)),1(2(1(1(0)),0))) is correct).
  • The chars used for input must be the same as those used for output.

Test cases

Most of these test cases are already in this post, I've just summed them up here and added some more. I used 012 as arities, ()s as brackets and , as separator here.

Input        -> Output

20121012100  -> 2(0,1(2(1(0),1(2(1(0),0)))))
212110102010 -> 2(1(2(1(1(0)),1(0))),2(0,1(0)))
211012101200 -> 2(1(1(0)),1(2(1(0),1(2(0,0)))))
1200         -> 1(2(0,0))
210110       -> 2(1(0),1(1(0)))
221010121100 -> 2(2(1(0),1(0)),1(2(1(1(0)),0)))
10           -> 1(0)
0            -> 0


  • Please comment if there's any error in the test-cases.
  • How could I make this challenge better?
  • Bumps: 3
  • \$\begingroup\$ Can I adopt and post this abandoned proposal? \$\endgroup\$
    – user58826
    Commented Jun 9, 2017 at 1:38
  • \$\begingroup\$ @programmer5000 Not entirely abandoned yet. \$\endgroup\$ Commented Jun 9, 2017 at 7:53

The Mode of an Image

Given an image as input, output it's mode; that is the colour that appears most in it. However, I am on a tight schedule and so need this code to compute as fast as possible.


Input can be in any reasonable format for your program i.e. filename or image object. However, the input image must have at least 3 channels i.e. r, g, b or 24bpp.


Output can be by any reasonable means i.e. return of a method or print to STDOUT.

Test Cases

//TODO: add them


As this is the winner is the answer which scores the lowest total time over all of the test cases. For example, if there are two test cases then the score = timeForTestCase1 + timeForTestCase2.

In the even that more than one winning answer scores the same more test cases will be added. The winning answers will be notified and should be updated accordingly.


  • Test case suggestions?
  • Better scoring mechanism? i.e. average of the time for each test case
  • \$\begingroup\$ Will all input images be of the same dimensions? \$\endgroup\$
    – user41805
    Commented Aug 10, 2017 at 15:11
  • \$\begingroup\$ @Cowsquack No they will vary \$\endgroup\$ Commented Aug 10, 2017 at 15:12

Left or Right?

You have a carousel of images, and you know the index of the image you wish to view.

The carousel shows a few images per page, so you need to be able to calculate if you need to move at all.

Also, the carousel wraps - so you can click 'right' on the last page to go to the first page, and 'left' on the first to go to the last.

The first image on the first page is at index 0 - and the last page may not, depending on the amount of images, always be full. If you prefer, you may start your indexing at 1 instead, but remember that the indexes in all of the example inputs will need to have 1 added to them.


4 numbers, in whatever format is suitable for your language;

  • Total - The amount of images in the carousel (1 or greater)
  • PageSize - The amount of images per section in the carousel
  • CurrentIndex - The index of the image you are currently looking at (0 to Total-1)
  • DestinationIndex - The index of the image you wish to look at.


The desired direction to scroll (if at all). This should be the fastest direction (ie least amount of clicks), desiring right in the case of a tie.


  • L - Click the left button (ie, go backwards)
  • R - Click the right button (ie, go forwards)
  • N - No movement required - output this if the image you seek is on the same page as your current image.

If you prefer, you may specify 3 other distinct outputs, such as -1 0 and 1 for example.


Say we have 5 3 0 4, so 5 total images, a page size of 3, we're currently at image index 0, aiming for 4. Our carousel would look something like this:

< [0 1 2] >

Pressing either left or right (there are only 2 pages) would lead us to this:

< [ 3 4 ] >

On this page, we can see image 4 which we are aiming for, so in this example, you would be expected to return R. Although L is the same length, in this exercise we are to favour going right in the case of a tie. Also note that you are expected to return just the direction you would need to go, so if you would have to click R 3 times, still only return one R.

Here are some more test cases;

5 2 0 2 -> R
10 5 1 4 -> N
10 3 8 1 -> R
10 3 8 4 -> L
  • \$\begingroup\$ I think this is kind of easy for this is site. One suggestion I have is to make the carousel "broken", such that it moves by n pages per click, instead of 1. Then a fourth output would be "X", saying that it's impossible to reach a certain image. \$\endgroup\$
    – geokavel
    Commented Aug 9, 2017 at 2:45
  • \$\begingroup\$ You should allow 1-indexing and not force everyone to use 0-indexing. Also the first test case is returning L or R allowed or should you prefer to return R over L always? \$\endgroup\$ Commented Aug 9, 2017 at 10:35
  • \$\begingroup\$ @geokavel I don't think that's necessary, easy challenges are still good challenges. \$\endgroup\$ Commented Aug 9, 2017 at 10:35
  • \$\begingroup\$ Guess it's ok as is. \$\endgroup\$
    – geokavel
    Commented Aug 9, 2017 at 16:49
  • \$\begingroup\$ TheLethalCoder good point, I did mean to do that, but forgot to mention it. Also I did mention that in the first paragraph of the output section, but I'll reiterate it in the example paragraph you refer to. geokavel - Thanks for your input - but I personally would like to see a few more easier challenges on this site to encourage newbies (like myself) \$\endgroup\$
    – Shadow
    Commented Aug 9, 2017 at 23:39
  • \$\begingroup\$ @TheLethalCoder - actually, using 1 based indexes would change the input as well. Do we still generally allow that when the input is going to change? \$\endgroup\$
    – Shadow
    Commented Aug 9, 2017 at 23:42
  • \$\begingroup\$ @shadow Yes we usually allow people to use 0 or 1 indexing irrespective of whether the input changes or not. \$\endgroup\$ Commented Aug 10, 2017 at 7:52
  • \$\begingroup\$ Could we output, for example, 1, -1, and 0 instead of R, L, and N? \$\endgroup\$
    – Stephen
    Commented Aug 10, 2017 at 19:23
  • \$\begingroup\$ @StepHen - I don't see why not. \$\endgroup\$
    – Shadow
    Commented Aug 10, 2017 at 23:06

Archer Battle

Your challenge is to simulate a battle between two armies of archers.

Each army has a population and an accuracy. Each round, every archer will let fly an arrow at the enemy army. The archers are trained each to shoot at different targets. Any archer hit by an enemy arrow is eliminated, and is does not participate in the next round. The battle is over when all archers in one or both armies have been eliminated.

The accuracy of the archers is almost exact. That is, ceil(population * accuracy) arrows will hit their targets. (No need to use random number generation.)


Take 4 inputs in any reasonable manner:

  • Army 1 population (positive integer)
  • Army 2 population (positive integer)
  • Army 1 accuracy (nonnegative float)
  • Army 2 accuracy (nonnegative float)


Output the population of the winning army at the end of the battle.

  • 1
    \$\begingroup\$ What if there are more archers than targets, and so they can't all shoot at different targets? \$\endgroup\$
    – isaacg
    Commented Aug 12, 2017 at 11:39
  • \$\begingroup\$ @isaacg Good point. I suppose "every archer selecting a different target" doesn't match the model perfectly. Perhaps "The archers distribute their targets among the opposing army as evenly as possible." and "`ceil(population * accuracy) enemies will be struck by arrows (capped at the remaining population of the opposing army, of course)." Any suggestions on improving the wording? And would a sample program help? \$\endgroup\$
    – Matt
    Commented Aug 12, 2017 at 23:31

Smooth Usage [On hold while alternative scoring is considered]

We've all seen CPU usage graphs like this one:

CPU Usage example

Doesn't that look ugly? It would look much nicer as a lovely smooth sine wave...


Write a program in the language of your choice that will infinitely produce a regular sine wave in Task Manager's (or Activity Monitor's if that's your thing) CPU usage graph.

You may assume:

  • Background CPU usage is constant
  • Only a single core must display the pattern
  • The system has sufficient cooling to prevent thermal throttling
  • Features such as Intel TurboBoost are disabled

This is tagged as to encourage short answers, but ultimately will be a as I suspect perfect solutions will be hard to come by.

  • \$\begingroup\$ Related: stackoverflow.com/questions/551494/… \$\endgroup\$
    – MTCoster
    Commented Aug 11, 2017 at 15:14
  • \$\begingroup\$ code-golf and popularity-contest don't mix together. You have to choose one or the other, but making it strictly code-golf would be difficult because you'd have to define what is a good enough sine wave, but on the other hand popularity contests are very risky to do. \$\endgroup\$
    – dzaima
    Commented Aug 11, 2017 at 15:16
  • \$\begingroup\$ @dzaima That was exactly my dilemma - which would you suggest fits the challenge best? \$\endgroup\$
    – MTCoster
    Commented Aug 11, 2017 at 15:17
  • \$\begingroup\$ I'd say a scoring algorithm of some sort would be best for this, no idea how you'd do it. Like the related one was objective. If you could read the word, it was valid. With this, is a bumpy sin-wave a sin-wave? \$\endgroup\$ Commented Aug 11, 2017 at 20:39
  • \$\begingroup\$ @MTCoster If you're not sure whether popularity-contest fits, then you can be sure that it does not. It is quite difficult to make an well received one. Go with code-golf or make a code-challenge if you can come up with a good own winning criterion. \$\endgroup\$
    – flawr
    Commented Aug 11, 2017 at 20:53

Reverse Cycling with Rubik's

In Cycling with Rubik's, you were asked to find the period of a given sequence of turns - or, in Geobits' words:

Given a sequence of turns, [find] the fewest number of times it must be performed to return the cube to its original state.

Today, I'm asking you to do the opposite.

Terms you might not know:

  • "algorithm": a sequence of moves on the faces of a Rubik's cube
  • "period": the minimum number of times an algorithm must be repeated before a solved cube returns to the solved state


The input will be the period of a Rubik's cube algorithm. This is an integer between 1 and 1260, as any algorithm can be performed 0 times, and the highest possible period for any given algorithm is 1260.


The output will be any algorithm that has a period equal to the input. Algorithms should use standard notation, namely:

R - Turn the right face clockwise 90°
L - Turn the left face clockwise 90°
U - Turn the up (top) face clockwise 90°
D - Turn the down (bottom) face clockwise 90°
F - Turn the front face clockwise 90°
B - Turn the back face clockwise 90°

Adding the prime mark ' to the end of any move changes it from a clockwise rotation to a counterclockwise one, so F' turns the front face counterclockwise, and F F' would return it to the original state right away.

If you're still confused about face turns, you can check out this.


Input -> Output
1     -> FF'
4     -> R
4     -> UD
6     -> RUR'U'
56    -> LUFFRDRBF
105   -> LF
120   -> UFFR'DBBRL'
315   -> FRBL
1260  -> U1R3U1F3D2


As with , the answer with the least bytes wins! As this is very difficult (it might be impossible), I will give a +50 bounty to the first answer, or +100 if it's under 100 bytes. Good luck!

  • 1
    \$\begingroup\$ The order of the Rubik's cube group is 2²⁷ 3¹⁴ 5³ 7² 11, so by Lagrange's theorem there's no algorithm of order 13. \$\endgroup\$ Commented Aug 17, 2017 at 8:41
  • \$\begingroup\$ @PeterTaylor Is the same true for any other prime? \$\endgroup\$
    – H.PWiz
    Commented Aug 17, 2017 at 15:24
  • \$\begingroup\$ @H.PWiz, the same is true for any other number which isn't a factor of the order of the group. I'm not sure whether subgroups exist for all factors smaller than the largest order of an element. Certainly they do for all prime factors, by Sylow's theorems. \$\endgroup\$ Commented Aug 17, 2017 at 15:28
  • \$\begingroup\$ @PeterTaylor I don't know any group theory, but thanks anyway. \$\endgroup\$
    – H.PWiz
    Commented Aug 17, 2017 at 15:32
  • \$\begingroup\$ Hmm.. unlike the Cyling with Rubik's challenge, this one can only be solved by bruteforce if I understand correctly? Also, what's with the R3 and F3 in the 1260 test case? These can just be R' or F'. Or if you are allowing 3 instead of ' as output, I would mention it somewhere in the challenge. Off-topic: But it's funny that my Rubik's cube logo is almost next to your challenge title, since I posted the previous sandbox answer. ;p \$\endgroup\$ Commented Aug 18, 2017 at 6:49

Time bomb ping pong

Challenge - Both teams

All users are divided into two teams based on their PPCG ID. For example, my ID can be found here, from which you can see that my ID is 34388. To check on which team you are, run the following snippet:

function update_team(){var e=document.getElementById("user-id").value,t=(document.getElementById("team-result"),"");t=e.match(/^\d+$/)||0===e.length?-1!==even_top_50.indexOf(parseInt(e))?"You are in team: ALPHA":-1!==odd_top_50.indexOf(parseInt(e))?"You are in team: BETA":0==e.length?"":"You are in team: "+(parseInt(e)%2==0?"ALPHA":"BETA"):"ID must be numeric",document.getElementById("team-result").innerHTML=t}var even_top_50=[12012,20260,17602,11259,26997,194,31716,20080,58563,47066,1426,4098,30688,56656,41723,3967,1490,31516,40695,29577,43319,15599,32686,3191,4020,67,34718,41024,7311,39328,16766,7110,31625,2867,59107,52210,16120,6710,68942,10740,9365,84,1147,15,199,7162,1308,3103,26600,59487],odd_top_50=[8478,36398,21487,3808,42545,3852,53748,48934,34388,21348,4162,34531,25180,31414,24877,31957,20469,31343,7416,45941,32014,39242,42963,11006,6828,9498,9288,14215,4198,3544,30164,33208,4372,95,41805,56178,668,47120,30525,55735,51507,57100,6699,737,39022,46855,51939,32700,59376,7209];
.main-header,.main-input,.result{font-family:Montserrat,sans-serif;text-align:center}.main-header{font-size:24px}.main-input{display:block;margin:12px auto auto}.result{margin-top:24px}
<br><div><div class="main-header"> Enter your PPCG ID </div><input class="main-input" maxlength="6" onkeyup="update_team()" id="user-id"> <div class="result" id="team-result"> </div></div>

Each user has two options:

  • Start a new bomb
  • Perform a counterattack

These actions are discussed here:

Start a new bomb

To set up a new bomb, you need to do the following:

  • Create a full program in any free language which has the output X.
  • Create a custom list of characters with a maximum of 10 characters.
  • Select one or more characters from the character list and insert them into your program, which will be having the exact same output X. This ensures that there is at least one crack for your submission.
  • Only reveal the full original program and the character list. Keep the modified program secret. Also keep track of the iteration index, which in this case is 1 (since it's the start of a new bomb).

This is an example of a new bomb submission:

Python 2, 9 bytes (index = 1)

Outputs the number 30.

print 5*6

With as character set 13579/. Try it online!.

Perform a counterattack

To perform a counterattack, you need to do the following:

  • Create a new full program with at least one character inserted from the list given by the opponent, which will have the exact same output X.
  • Create a custom list of characters with a maximum of 10 characters.
  • Select one or more characters from the character list and insert them into your program, which will be having the exact same output X. This ensures that there is at least one crack for your submission.
  • Only reveal the full original program and the character list. Keep the modified program secret. Also keep track of the iteration index, which in this case is the increment of the previous index.

This is an example of a counterattack (using the previous submission):

Python 2, 12 bytes (index = 2)

Defuses Python 2, 9 bytes, Adnan.

Inserts 1, / and 3. Outputs 30:

print 15*6/3

With as character set: +-~58. Try it online!

Scoring system

Every bomb that has not been defused for 7 days gives the team 'index' points. If the index was 4, your team gets 4 points. You are only able to collect the points after you have revealed your own solution. Note that if you do not reveal your solution after the 7 days, it is still vulnerable to cracks.

As for the individual winner of the team, the person with the most cracks of the winning team gets the check mark.

Sandbox notes

  • Note that this is more of an experimental challenge. Unlike the conventional 1 vs 1 cops-and-robbers challenges, this is an attempt on an n vs n-challenge, so I have no idea whether this is a good idea or not.

  • The scoring system is a bit tricky, but I think that when a bomb has 'exploded', the opponent's team gets (index) points. The team with the most points at the end wins. The problem here is that the byte count might make things worse, since a larger program would make cracking the submission harder.

  • A problem I'm finding here is the fact that the cop can create an arbitrarily large program, which makes it almost impossible to crack. I'm not sure whether this actually is a problem, since the 'exact same output'-rule should theoretically take care of this.

  • Perhaps add a third option for the user, where the user defuses a bomb. This would consist of cracking the submission, but does not create a counterattack (for cases when this is impossible, or trivial (like adding comments)).

  • I'm also not entirely sure about the 'choose your own output'-idea. Would this leave too much options for abusement?

  • Is the maximum of 10 character too much / too little? Should this also be taken in account with the scoring?

Thanks in advance!

  • \$\begingroup\$ Maybe try the wording "one or more" instead of "at least one"? It took me a while to realise that was what you meant. For more meaningful feedback about diffusions/maximums I think you'd have to decide on a scoring mechanism first. Since both teams use the same bombs to advance their score I don't think the byte count think is that big of a problem? \$\endgroup\$ Commented May 27, 2017 at 0:38
  • \$\begingroup\$ @FryAmTheEggman Thank you for your response. I have decided that the score is just simply the sum of all index numbers of the bombs that aren't diffused after three days. This encourages counterattacks more, since the score will increment after each counterattack. \$\endgroup\$
    – Adnan
    Commented May 27, 2017 at 9:34
  • \$\begingroup\$ Nice. A never-ending hot potato game. \$\endgroup\$ Commented May 29, 2017 at 12:27
  • \$\begingroup\$ @SIGSEGV Yeah, that's what it's supposed to be. I should probably set a time limit somewhere, otherwise there will be no winner at all :p. \$\endgroup\$
    – Adnan
    Commented May 29, 2017 at 13:07
  • \$\begingroup\$ I'm worried that this could very easily turn into "stay online more than your opposition does", if an answer is given in a language that's very easy to crack. \$\endgroup\$
    – user62131
    Commented May 31, 2017 at 22:47
  • 3
    \$\begingroup\$ 1. Defuse, not diffuse. 2. Three days is not much. A carefully timed post at the start of the weekend could slip through the net. 3. Unless I missed it, there's nothing to prevent the usual CnR-killer crypto answer. Are you absolutely certain that they won't break the challenge? \$\endgroup\$ Commented Aug 21, 2017 at 12:51
  • \$\begingroup\$ @PeterTaylor Thanks for your response. I have changed the time limit to 7 days. The main problem would indeed still be cryptographic submissions. I tried to decrease the severity of this problem by making sure that the output would remain exactly the same before and after modifying the submission, but I need to experiment a bit with this to see how this would end up. Hashing would almost certainly not be possible, unless a hashing algorithm is cracked (but I'm not 100% certain about this). \$\endgroup\$
    – Adnan
    Commented Aug 21, 2017 at 13:06
  • \$\begingroup\$ As for the hashing, this worked for me: "Please, don't "implement RSA" or anything mean to the robbers. Use obscure languages and features, not boring encryption and hashing. I can't enforce this with rules, but you can expect torrential downvotes if all you do is sha(input) === "abcd1234"." \$\endgroup\$
    – user58826
    Commented Aug 24, 2017 at 14:33

Conversion: 2 dice from 3

This fascinating video from Matt Parker's standupmaths poses a challenge:

Given the result of rolling 3 indistinguishable (unordered) dice, simulate the result of rolling 2 indistinguishable (unordered) dice.

For the purposes of this challenge, simply returning the sum of 2 dice is not sufficient. Returning 2 ordered dice is acceptable, as the order can be ignored so this still fulfils the requirement.


Either 3 unordered values from 1 to 6, or 3 ordered values from 1 to 6. If the values are ordered, then the output must be independent of the input order. For example, the input 1, 2, 3 should give the same output as the input 2, 1, 3.

These are standard dice. Your code may not assume the values will be from 0 to 5 instead of 1 to 6.


Either 2 unordered values from 1 to 6, or 2 ordered values from 1 to 6. If the values are ordered, then different orderings will be considered equivalent. For example, output 1, 2 is equivalent to output 2, 1.

Given input that matches the probability distribution of rolling 3 dice, the probability distribution of the output must match that of rolling 2 dice.

You can choose to calculate the outputs however you wish, provided that they are deterministic (the same input in any order gives equivalent output). That is, different answers may use different mappings. So for input 1, 2, 3, one answer may give output 4, 5, while another answer may give output 5, 6. Provided all outputs occur in the correct proportions, both answers are valid.

The output must also use standard dice. Your code may not output values from 0 to 5 instead of 1 to 6.

Checking for correctness

One simple but laborious way of checking that the outputs occur in the correct proportions is to consider all 216 possible ordered triples as inputs. This automatically accounts for the fact that the unordered triple 1, 2, 3 is 6 times more likely to come up that the unordered triple 1, 1, 1, since it will occur as 6 different ordered triples (the 6 different ways of arranging 1, 2, and 3).

A valid answer will give the same output (apart from order) regardless of the order of the input, and will give any given double such as 1, 1 for exactly 6 of the ordered inputs, and any given distinct pair such as 1, 2 (equivalently 2, 1) for exactly 12 of the ordered inputs.


The original puzzle was asking for an easy way for humans to calculate this in their heads during playing a game. This challenge is instead , so the score is the number of bytes in your code, and the lowest score in a given language wins.

Prior work

This was also posted on puzzling.SE and there are a number of approaches there. Although they are aimed at being human usable, there may be some insights there that are relevant to writing short code.

Test cases

As every answer may use a different mapping, there is no way to generate meaningful test cases for this challenge. The simplest way I can think to test is as described above under "Checking for correctness".

Sandbox questions

  • I've just discovered this previous challenge which is based on the same video. It asks only for the sum of 2 dice, rather than an unordered pair, so is not identical. Is this a sufficient difference to avoid this being a duplicate, and would it be different enough to be worthwhile posting?
  • \$\begingroup\$ Even if it's not officially a dupe I'd still like feedback on whether it's different enough to be interesting. \$\endgroup\$ Commented Aug 23, 2017 at 15:45
  • \$\begingroup\$ Looking at the Jelly answer, I think the change required for this question is to remove the final character. So yes, it does fail the dupe test. \$\endgroup\$ Commented Aug 23, 2017 at 21:35

Just a relative


Produce a piece of golfed code that will take a spreadsheet formula and a translation vector and adjust any cell references in the formula by the translation vector.


What you need to create is a program that takes 2 inputs. A string formula and a representation of the transformation the formula is to undergo (i.e: 1 1 (column, row)).

Invalid inputs include, but are not limited too, inputs with invalid cell references, translations that produce invalid references (see definitions) and formulas formulas that don't start with an equals sign.

The output should be the formula with its' cell references transformed as per the rules above. Input types are flexible, but the output should be a string with no leading/trailing whitespace.


Cell Reference

An alphanumeric string that within spreadsheet software, indicates the cells position on a 2D grid. They consist of two parts, an alphabetic segment a numeric segment.

The alphabetic segment represents the column position of the cell. It can be of any length, with each character belonging to the 26 letter English alphabet and is case insensitive. A numerical mapping of the column position can be attained using 26-adic bijective numeration.

The numeric segment represents the row position of the cell, and must be a positive non-zero integer.

It is also valid for the dollar $ symbol to appear in a cell reference. A single one is valid preceding both the alphabetic and numeric segments either independently or simultaneously. A dollar preceding the alphabetic segment indicates an invariant column under transformation, and a dollar preceding the numeric segment indicates an invariant row under transformation.


An arbitrarily named reference to some set of instructions.

For the purpose of this challenge, these are defined as a case insensitive alphanumeric string followed by an open and closed set of rounded brackets. Within these brackets, arbitrary arguments can be present including other functions, arbitrary values and cell references. Arguments are comma seperated.

Example: CALCULATEBYTES('mycodegolfanswer', A1)


A calculation composed of arbitrary numeric operators, functions, values, cell references etc.

A formula must be started with an equals = sign and can then be followed by anything except for a numeric operator.


=SUMIFS(A1, "=2") 1 1
>>=SUMIFS(B2, "=2")

=SUMIFA1(GL93) 1 2


=$A3+B$2+$C$1 4 -2

Hope this all makes sense!

Winner is the shortest code in bytes, but bonus kudos if anyone posts a golfed answer in punch card Fortran!

Happy golfing!

  • \$\begingroup\$ 1. The post is a bit "wall of text"-ey. Maybe separate out all the description of what references are from the main challenge a little? 2. You talk about using $ for absolute referencing but don't mention them in the challenge or give any test cases for them. 3. It's normal in code-golf to assume input will be valid or (almost equivalently) allow any behaviour upon receiving invalid input (I'd suggest one of these). If you do keep an actual "error requirement" you should state if it should be the string "error" or an actual error and probably add a reason for the error to the test case(s). \$\endgroup\$ Commented Aug 24, 2017 at 21:07
  • 1
    \$\begingroup\$ @JonathanAllan Thanks for the feedback. Amended based on what you said \$\endgroup\$
    – dbr
    Commented Aug 25, 2017 at 21:59

Brain-Flak Golfing Tournament

This is a very rough draft. I am looking for as much feedback as possible while I flesh out this challenge

Welcome to the first ever Brain-Flak Golfing Tournament.

This tournament will have 2 phases. The first being a call for challenges and the second being the competition. Any user may participate in either, both or, of course, neither of the phases.

Challenge submissions

In this first phase users can submit mini challenges to be used in the competition. These will be of two varieties,

I've chosen these varieties because they tend to be the commonly agreed most "fun" tags for Brain-Flak. (SANDBOX: If you have any qualms these varieties are variable)


Kolmogorov complexity challenges, like the name implies, should provide a constant string to be output with no input. For example Hiya there earth!.

As a personal style point I find Kolmogorov complexity is most fun for strings of 10-20 characters. However feel free to answer of whatever size you think would be interesting


For sequence challenges you should you should choose a sequence from the Online Encyclopedia of Integer Sequences, and provide its number and a brief description in the body of your answer.

Answers to sequence mini challenges will take n and output the nth term of the sequence. You may specify what indexings are permitted in your answer. Since OEIS sequences are not well specified on their own answers will only be required to support as high as are provided in the b-files of that sequence.

As a personal style point Brain-Flak is especially good at computing challenges involving or related to polygonal numbers, however variety is always welcome.

In addition to providing a challenge you must also provide a "par". A par will be a program that satisfies the requirements of your mini-challenge. The purpose of a par is two-fold:

  • It proves your mini-challenge is reasonably possible

  • It provides a default score for more casual participants who might not necessarily answer all the mini-challenges, or more serious users who run out of time.

Your par should not be your own best attempt at a challenge, it should be beatable otherwise participants would just score the par and you might as well have not made the challenge at all.

Lastly no mini-challenge should correspond to a preexisting PPCG that already has a Brain-Flak answer. For example do not submit print Hello, World! as a challenge, because we have already have very competitive solutions. Unlike earlier suggestions this will be enforced.

Challenge answers

In the second phase users will answer challenges made in the first phase. You will have one week to craft an answer in (relative) secrecy, at the end of the week answers will be revealed and a winner declared. You will have to have an answer on this question prior to the reveal.

All that is required of answers before the reveal are the following two things

  • A rundown of the byte counts. This should be your scores to each mini challenge not including ones posed by your self. If you choose not to complete a single challenge for any reason you should take the par as your score for that challenge.

  • A hash. This should be a SHA-256 hash of a string containing all of your solutions on separate lines and your ppcg user id. You may include other information in the string to throw off potential attackers if you wish, but it should not resemble any of the required elements.

These are the only two things that are required, however if you would like to include additional hints to other users you may do so, just don't reveal your own solutions ahead of time as that can make the challenge rather un-fun.

You may continuously update your answer anytime before the reveal.

You should not at any point lie about contents that are hidden. Accusations will be dealt with on a case by case basis, but if you are caught having lied you will be disqualified.


This is still a work in progress right now its just a plan

I plan to base scoring based on graph theory. Normally it would just be the sum of individual challenges but because one cannot fairly compete in their own challenges things have to be a little bit more sophisticated. Once I decide on a good scoring system I will add a code snippet to help calculate rankings.

Scoring will obviously be based on byte counts with less being better.


I will be offering 3 bounties for exceptional participants

  • 500 rep for the overall winner of the challenge

  • 200 rep for the runner up of the challenge

  • 100 rep for the top voted mini challenge


OR ,

Steganography: Hide a message in an image!


You will want to see the Default acceptable image I/O methods for image related challenges.

Your challenge is to write a program that takes a string and an image as input and somehow encodes the string in the image. You output the image.

You must also make a program that reverses the above: it takes a image, and outputs the original string (you don't need to output the original image).

Your encoder must work on any string, but it only needs to work on one type of image.

Post the encoder (but not the decoder), and preferably a few image / string input / output examples.

Your post is cracked when someone makes a program that can take an outputted image and find the string hidden in it. It doesn't have to be the decoder you intended. It can even be in another language.

Once your submission is cracked, edit in a link to the crack and your decoder program.

If, after a week, nobody* has cracked your submission, edit in that you are safe, and edit in your decoder.

This may provide ideas!

*not Nobody


Your challenge is to find a cop post and crack it.

To crack a cop post, you make a program that reverses what cops do:

Your challenge is to write a program that takes a string and an image as input and somehow encodes the string in the image. You output the image.

In other words, your program takes an image and extracts the encoded string out of it. You don't have to output the image with or without the string.

Once you have cracked a cop's post, add a link in a comment.

The robber with the most cracks wins.


  • Dupe? (I don't think so)
  • Winning criterion for cops:

    I really want this to be a pop-con. Pop-cons are hard but I think I have everything needed for a good pop-con covered:

    • A challenge with clear specifications that still allow for creative problem solving. I think this is clear but gives you freedom in how you encode a string.

    • A challenge where solutions that best solve the problem are also solutions that the voters are going to like. I think that voters will enjoy very creative 'encoding's.

    • Gives freedom to entrants to decide what to do in crucial parts and incentivizes them to use this freedom. You have complete freedom to pick how you hide the string. If you use a boring form of encoding, your encoder will quickly be cracked, but if you use your freedom to make a very creative encoder your submission will likely be safe.

    • It is strongly suggested to submit the challenge to the Sandbox at least a few days before posting the challenge. That way the challenge can be reviewed and discussed in order to find any mistakes or inconsistencies, and it also serves for getting a first impression whether the challenge will be well recieved. Yep, I think this is covered.

    And what MUST be included in a pop-con:

    • A popularity contest must always include an objective validity criterion, which is a set of rules that regulate what every answer must comply with. Answers that do not comply are invalid and will be removed. Yep, if you have a valid, working decoder than your stenography is reversible and therefore valid. If a week passes and you didn't have a decoder, your submission will be removed.

    • A clear specification of the goal that must be achieved. Questions like "do (this) the most creative way" should be avoided. Creativity should be the tool, not the goal. Yep, the goal is to make a program that encodes a string in an image...

    And Qualities which should be AVOIDED in popularity contests:

    • Asking to solve a specific task in a very specific way, without room for creativity. There is room for creativity within bounds in how your encoder works.

    • Asking to solve a vaguely defined task in any way that the entrant wants (this will probably make your question be closed as too broad). Nope, you have the specific task of encoding a string in an image.

    • Rules what people should consider when voting. In the past this has consistently never worked out. These sort of questions would be better off as a with specific winning criteria. Nope, I don't have any of these.

    If there's anything I'm missing, please tell me. I think this is a on-topic valid pop-con. However, if it isn't, I'd be OK with making this a .

    However, PPCG has too much code golf. We need more variety in the challenges we have here. I hope this will provide an example of a valid pop-con.

  • \$\begingroup\$ Looking at the page you linked, you could also make this an image-polyglot challenge. Output an image of [something] that also does some other tasks when run in different languages. However, I don't really get your question about code-golf vs pop-con. This is a cops-n-robbers, which is usually won by being the first entry to go X days w/o being cracked. \$\endgroup\$
    – geokavel
    Commented Aug 26, 2017 at 23:03
  • \$\begingroup\$ @geokavel most cops-n-robbers I've seen are shortest safe cop, not earliest cop. So he's probably doing highest-voted safe cop. \$\endgroup\$
    – Stephen
    Commented Aug 26, 2017 at 23:08
  • 1
    \$\begingroup\$ pop-con's are usually good for graphical output, but here if I understand correctly, the viewer will not be able to see that you manipulated the image just by looking at it. So it lacks the intuitiveness useful for pop-cons. \$\endgroup\$
    – geokavel
    Commented Aug 26, 2017 at 23:43
  • \$\begingroup\$ This fails my first test for "Is it a bad CnR?": it's easy to make a cop which uses RSA and can't be cracked within a week on current hardware without spending serious money. \$\endgroup\$ Commented Aug 27, 2017 at 16:56

Generating Punnett Squares

The task will be to generate a simple (monohybrid cross) Punnett Square, given the "genotype" of two parents.

A "trait" will be represented as a single alphabetical character (eg 'a').

An allele for a trait is that character, but if the allele is dominant if it is uppercased, and recessive if lowercased (eg 'a' or 'A').

A genotype is two alleles, both of which can be either dominant or recessive. Note that if a genotype is heterozygous (has one dominant and one recessive allele) the dominant allele will always come first (eg "AA" or "Aa" or "aa").

The input will be two strings of length 2, each of which is a valid genotype for one trait. You can take input as arguments to your function or program, or from a file. You should output a Punnett Square in exactly this format:

  A  a
a Aa aa

(This would have been for the input "Aa" and "Aa"). The output can be to stdout, as a string, or to a file.

The first parent (which is the first argument) should be across the top, and the second parent should be down the side, so for the input "AA" and "aa", the output should be:

  A  A
a Aa Aa
a Aa Aa

Your code is expected to work with any trait (letter of the alphabet).

Another way to phrase this problem might be to output a table of the cartesian product of two strings of length 2, where each string consists of only uppercase or lowercase variants of one character, and the data in each cell should be sorted such that each uppercase character comes before each lowercase character.

Full sample of behaviour for some trait "a":

"AA", "AA" ->

  A  A

"AA", "Aa" ->

  A  A
a Aa Aa

"AA", "aa" ->

  A  A
a Aa Aa
a Aa Aa

"Aa", "AA" ->

  A  a

"Aa", "Aa" ->

  A  a
a Aa aa

"Aa", "aa" ->

  A  a
a Aa aa
a Aa aa

"aa", "AA" ->

  a  a
A Aa Aa
A Aa Aa

"aa", "Aa" ->

  a  a
A Aa Aa
a aa aa

"aa", "aa" ->

  a  a
a aa aa
a aa aa

This is my first attempt at a challenge so I'd like some feedback on if it's any good and how it can be improved. I haven't been able to find any challenge like this, so hopefully it's not a duplicate.

Have I explained it clearly?

Is this idea interesting enough for a challenge?

What other tags would I use with such a challenge?

  • 1
    \$\begingroup\$ I think this is essentially a duplicate of codegolf.stackexchange.com/q/76661/194 \$\endgroup\$ Commented Aug 28, 2017 at 13:55
  • \$\begingroup\$ Darn, you're right - I hadn't found it as I'd only searched for "punnet square". Thanks! \$\endgroup\$ Commented Aug 28, 2017 at 13:58

Displaying exponent towers in ASCII


Unlike + and *, the exponentiation operator ^ is not associative. The convention is that ^ is right associative, so that a^(b^c) = a^b^c. Of course, nested exponentials are usually displayed as nested superscripts, which can be represented in ASCII as:

a^(b^c) = a

For a general right associative operator &, there would be no way to simplify the expression (a&b)&c. However, exponentiation satisfies the rule

(a^b)^c = a

where bc means b*c.

Combining these rules, we can express any arbitrarily parenthesized exponential expression using only superscripts and juxtaposition. For example,

                                              c  f
                                             b  e
(a^(b^(c^d)))^(e^f) = a^((b^(c^d))*(e^f)) = a


Write a function that, given a string consisting of lowercase letters, parentheses, and ^ that represents a valid mathematical expression (see rules), prints an ASCII representation of this expression in the manner described above.


  • The input string is any element of the context-free grammar determined by the rules
    S → any lowercase letter
    S → (S^S)

  • The output must consist of only lowercase letters, spaces and newlines.

  • The resulting ASCII picture must have exactly one letter per column.

  • The left to right order of the letters must be preserved from input to output.

  • This is , so shortest answer in bytes wins.

Test Cases

Input: a

Input: (a^(b^c))

Input: ((a^b)^(c^d))

Input: ((a^(b^c))^d)
 b d


  • Is it clear what picture you are supposed to output?

  • This challenge has some similarities to this other challenge, but I think they are far enough part to not be dupes: Convert exponents into ASCII art.


Erdős–Straus conjecture

  • 1
    \$\begingroup\$ Can you give me the answer for n=7777 . How much time did it take your program to find it? What do you mean by "result must be returned for all valid inputs".Is 1500 years ok for bigger n? Brute-forcing this is very easy but it takes forever. \$\endgroup\$
    – ZaMoC
    Commented Sep 9, 2017 at 10:06
  • \$\begingroup\$ @Jenny_mathy I'll put a reasonable limit and the last part means you need to output the right numbers if x is valid (a whole number larger than 2) \$\endgroup\$ Commented Sep 9, 2017 at 11:28

Determine the Resultant


I'm not yet sure which one of the following two versions would be more interesting:

Version a: Given two integral polynomials P,Q determine their resultant Res(P,Q).

Version b: Given two monic integral polynomials P,Q determine the polynomials A,B such that AP+BQ = Res(P,Q). Where deg A < deg Q and deg B < deg P.


The resultant is defined as

Here the product iterates over all complex numbers pairs that are zeros of each polynomial. For integral polyonmials this is an integer. (One other way - and certainly not the only - is via the determinant given here.) The corresponding integral polynomials A,B such that AP+BQ = Res(P,Q) with deg A < deg Q and deg B < deg P are unique.

  • \$\begingroup\$ Are these polynomials on Z? You say complex number pairs which suggests it is some numeric set. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Sep 17, 2017 at 0:28
  • \$\begingroup\$ Those pairs are not necessarily integers, but the polynomials are. \$\endgroup\$
    – flawr
    Commented Sep 17, 2017 at 14:29

Pythagorean Double Regex

Posted by NH. in Zendo:

though depending on the regex flavor, things like that pythagorean triple could be hard to do.

The rule in question was:

Given a pair of numbers, match if the two numbers are part of some integral Pythagorean triple, else don't match.


Given a pair of positive integers, write a regex that matches if and only if the pair of integers are part of a Pythagorean triple - i.e. if the two integers are a and b, either a2+b2 is a perfect square or |a2-b2| is. (Note: x,x should match, even though 0,x,x is not a true Pythagorean triple)


  • Integers represented in any base, separated by a character not used in the representation of that base

Test cases

NB: All but one of these test cases were taken from the game of Zendo from which the rule came, so they may not test boundary cases of the rule



This is , so the shortest regex in bytes wins!

  • 1
    \$\begingroup\$ 1. Ideally a question should be self-contained. This barely makes sense without following the links. I'm not even sure whether the answers have to be regexes or whether that was just the original context. 2. What's the scoring system / winning criterion? \$\endgroup\$ Commented Sep 11, 2017 at 7:53
  • \$\begingroup\$ @PeterTaylor is this better? \$\endgroup\$
    – boboquack
    Commented Sep 11, 2017 at 8:35
  • \$\begingroup\$ Definitely improved, yes. I'm still not sure what "(from the game)" refers to. Also, are you taking into account that by default we consider unary to be an acceptable input format for positive integers when writing a regex? I advise being explicit about whether numbers must be in decimal or whether unary is acceptable. \$\endgroup\$ Commented Sep 11, 2017 at 8:44
  • 1
    \$\begingroup\$ @PeterTaylor fixed up again \$\endgroup\$
    – boboquack
    Commented Sep 11, 2017 at 9:07

Align the Words

Given a list of words l output them as follows:

  • Iterate through l, if it's the first word, output it as usual.
  • If it's not the first word, iterate through this nth word and:
    • Find the first letter of word n that's in word n-1.
    • Align the first occurrence of that letter in word n with the first occurrence in word n-1 and print it on the next line.

Worked Example

Input: [ace,face,please,keep,sheeple]

1: ace

2:  ace

3:  ace

4:  ace

5:  ace

[Note: You only print step #5, the rest is to show the process.]


  • Lowest byte-count wins, this is .
  • All consecutive words in the input list l will have at least 1 letter in common.
    • If the input is invalid, any return is fine (error, nothing, etc...)
  • A word is defined here as a collection of a-z (lowercase ONLY alpha characters).
  • \$\begingroup\$ Related, not a dupe. \$\endgroup\$ Commented Sep 11, 2017 at 18:48
  • \$\begingroup\$ To be clear, are we to output every step along the way, or just the final arrangement? If every step along the way, what's an appropriate separator? \$\endgroup\$ Commented Sep 11, 2017 at 19:04
  • \$\begingroup\$ @AdmBorkBork final product, should make that clear I s'pose. \$\endgroup\$ Commented Sep 11, 2017 at 21:13
  • \$\begingroup\$ Are we allowed to use uppercase only instead of lowercase only as well? Not really relevant for the programming language I usually golf in, but I can imagine it's relevant for some programming languages. \$\endgroup\$ Commented Sep 26, 2017 at 12:00
62 63
65 66

You must log in to answer this question.

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