What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on 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.

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

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

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily


3226 Answers 3226

41 42
44 45

Minimize my cube


Using my 6x6 as cubes of smaller size

I have a rubiks cube. It has 6 layers and is great fun to solve. But it takes quite some time, and sometimes I wish I could just solve a cube of smaller size. But theres hope, because every cube with even number of layers can emulate every cube with less layers by only moving certain layers at the same time. Now I need your help to provide the numbers.

Let's get mathematical

Consider this definiton: For every even integer n and a positive integer i <= n there exists a sequence of i positive integers, so that

x_1 + x_2 + ... + x_i = n
x_1 = x_i
x_2 = x_(i-1)
x_3 = x_(i-2)

(See test cases for a clearer example). Then such a sequence tells me exactly which layers to combine.

The challenge

For an input n write a program that outputs one of the existing sequences for every positive integer i < n.

Test cases

For n = 6:

[3, 3]
[2, 2, 2]
[1, 2, 2, 1]
[1, 1, 2, 1, 1]
[1, 1, 1, 1, 1, 1]

For n = 4:

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

Scoring and Rules

Lowest number of bytes wins. Standard Loopholes apply.

Sandbox quesions

  • Formatting?
  • Can I make the definition clearer?
  • Should I put more restrictions?
  • Where is my english broken beyond repair?
  • \$\begingroup\$ Tell me if I'm understanding it wrong, but could we output, for the fourth line when n=6 : [2, 1, 1, 2]? or even [2, 1, 2, 1]? or even any permutation of [1, 1, 2, 2]? \$\endgroup\$ – V. Courtois Jul 19 '17 at 16:39
  • \$\begingroup\$ Another thing (that's why separate comment) : you don't explicitly require an input format. So here, could I for example output a string containing : 4\n22\n121\n1111\n (with \n=newline)? Am I allowed to have this trailing newline? Are the commas mandatory? etc. \$\endgroup\$ – V. Courtois Jul 19 '17 at 16:42
  • \$\begingroup\$ About my first comment : if you want, you can even ask for outputting every or any permutation, or a symmetric permutation, or an increasing-ordered one. \$\endgroup\$ – V. Courtois Jul 19 '17 at 16:46
  • \$\begingroup\$ @V.Courtois: I meant it to be symmetric, like [2,1,1,2] and [1, 2, 2, 1] are both symmetric, but [2, 1, 2, 1] is not. Alas, need to better the explanation, I guess. \$\endgroup\$ – Seims Jul 20 '17 at 5:49
  • \$\begingroup\$ you do need, it's a fact :) And what about saying what output format you want (sorry for the input mistake in 2nd comment) ? \$\endgroup\$ – V. Courtois Jul 20 '17 at 6:40

Fighting a Land War

In this KoTH, you need to earn as much money as you can while fighting over tiles to take over.

The board is a large hexagon made up of 91 smaller hexagonal tiles (A 6x6 hexagon)

Each tile is either:

  1. An impassable mountain
  2. Hills that generate production. They start out with a random value (between 2 to 4)
  3. Valleys that generate money. Their starting value is the distance from the nearest corner multiplied by 2 (between 2 and 10)


There are 6 players in each game, each starting in a different corner of the hexagon. The corner will always be a hill(4). Turn order is randomized at the start of the game.

Each turn, the following happens:

  1. Each tile that you have owned for N^2 turns (where N is an integer) increases in value by 1
  2. You earn money/production. (Equal to the sum of the valley/hill values)
  3. You can spend production on defenses or capturing tiles.
    • Adding N TileDefense costs N Production
    • Capturing a tile with N TileDefense costs 1 + 2*N Production
    • You can only capture a tile if it is a non-mountain tile that is adjacent to your current tiles.


  • Tiles lose all defense on capture.
  • Multiple players can upgrade a single tile
    • The turn counter for tile upgrades is player-specific. This means that if you capture a tile from another player, the turn counter starts at 0.
    • If you capture a tile you've owned before, it starts off where you left it.

And that's it. The player with the most money after 500? turns wins.

  • \$\begingroup\$ 1. "Each tile is either" determined how? Randomly or in a fixed pattern? 2. How does step 3 work? As many rounds of capture and defence as you like? Or do you declare all of your attacks and defences at the start of the round? This has implications both for defending a tile on the turn you capture it and for blitzkrieg captures. \$\endgroup\$ – Peter Taylor Jul 16 '17 at 6:56
  • \$\begingroup\$ 1. I'm still thinking about this. I think I'm going to randomly generate a triangular segment, and then mirror it across to the other 5 segments. 2. Oooh...I haven't thought about this. Thanks, I'll give it some thought. \$\endgroup\$ – Nathan Merrill Jul 16 '17 at 12:06

KOTH: Thirty-One


Built a bot that plays Thirty-One against other bots!

Game Rules

Thirty-one is a card game using the standard 52-card deck (the French deck). The objective in each round is to have a hand better than at least one of your opponents'.

At the beginning of the game, each player has a set number of "lives" - for this challenge, each player will get 3 lives. Once you run out of lives, you have lost the game. No matter how many players there are, there is exactly one winner per game.

The player to go first in the first round is chosen arbitrarily. After that, the player to go first rotates clockwise around the "table". The players' order does not change between rounds (except for when players get knocked out).

At the beginning of each round, each player is dealt 3 cards. On each player's turn, they have the option to:

  1. Draw a card from the deck and discard a card
  2. Draw the last card that was discarded and discard a card
  3. Knock if no other player has knocked yet


If a player knocks, each other player gets one more turn. Then, the players compare hands. Whoever has the lowest score loses a life, and the round ends.


Each player's score is calculated by adding the face values of all their same-suit cards and taking the best score. Two cards of different suits don't contribute to the same score.

The face values for each card are:

Ace: 11
King, Queen, Jack: 10
2-10: their value

For example, consider you hold the cards:

Ace of Spades
Four of Spades
Two of Spades

Your score would be 11 + 4 + 2 = 17.

If you hold the cards:

Queen of Diamonds
Four of Clubs
Nine of Clubs

Your possible scores are 10 and 4 + 9 = 13, so your score is 13, the best of the two.

Finally, if you have:

Six of Hearts
Six of Spades
Three of Diamonds

Your possible scores are 6, 6, and 3, so your score is 6, the best of the three.

The highest possible score you can reach is 31, by holding the Ace and two 10-point cards of the same suit.

Special Cases

  • If the player who would go first knocks immediately on their first turn, the other players don't get a turn - they compare hands right away

  • If a player reaches a score of 31, they should knock immediately and everyone else loses a life

  • If the deck runs out of cards, the round ends and all players compare hands


Your bot will be a subclass of the base class I provide. You need not implement every method, but there will be a minimal amount of functionality required in order to make the turns go forward.


I will create a tournament-style bracket that will determine the winning bot. Your bot is allowed keep track of all the information available to it, including between games. The details of the bracket will depend on the number of bots written.


  • I could use some input on writing the controller and base class. What has worked well in the past? What hasn't worked that I should avoid?

  • Are the rules for the game clear enough? I adapted them from my own knowledge of the game and this website.

  • Obviously this isn't ready for posting yet since I haven't written the base class, but is there anything else unclear or missing?

  • Is there anything I can do to make this more fun or more challenging?

  • \$\begingroup\$ 1. The key thing for the controller is to maintain a persistent connection, because if you have to keep forking processes that becomes a bottleneck. 2. There are a couple of minor points to clarify. "Whoever has the lowest score loses a life": presumably in case of ties everyone with the lowest score loses one. "standard 52-card deck": the French deck, to distinguish it from other standards. Although on the basis of KISS I'd use a deck of four suits and card values 0 to 9 (with three 8s per suit). \$\endgroup\$ – Peter Taylor Jul 18 '17 at 13:51
  • \$\begingroup\$ "Draw a card from the deck and discard a card" is presumably followed by shuffling all but the discarded card if the draw deck runs out. "I will run 100 games using everyone's bots" will break badly if there are 17 bots. \$\endgroup\$ – Peter Taylor Jul 18 '17 at 13:52
  • \$\begingroup\$ @PeterTaylor Thank you so much for the feedback! 1. Thank you for the advice, I didn't plan on making the program multi-processed, I planned on having the controller simply keep a list of the bots and passing control to each one in turn. 2. Yes the tying rule is correct, I'll add that in. Although that would be a good way to simplify the deck I think I'll keep it 2-11 with four 10s per suit, because I don't want to change the name of the game. 3. Yes, all but the top card would be shuffled back in, I'll add that as well. 4. Why would that break badly? Just because of computation time? \$\endgroup\$ – musicman523 Jul 18 '17 at 14:05
  • \$\begingroup\$ 3 cards each times 17 players leaves 1 card in the deck. \$\endgroup\$ – Peter Taylor Jul 18 '17 at 14:09
  • \$\begingroup\$ Ah, good point...if there are that many participants, I'll have to break it into multiple smaller games and set up a tournament bracket \$\endgroup\$ – musicman523 Jul 18 '17 at 14:17
  • \$\begingroup\$ I've changed my mind on one thing - the round ends when the deck runs out of cards. Each game will consist of 4 players, and I'll release more information about the gameplay once I see how many bots are written \$\endgroup\$ – musicman523 Jul 18 '17 at 17:46

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\$ – ბიმო Jul 26 '17 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 Jul 26 '17 at 17:06
  • \$\begingroup\$ Yeah you're right, didn't know these existed. \$\endgroup\$ – ბიმო Jul 26 '17 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\$ – trichoplax Jul 25 '17 at 23:01
  • \$\begingroup\$ If only a single symbol can be to the left for subtraction, how are ambiguous cases like IXL resolved? \$\endgroup\$ – trichoplax Jul 25 '17 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\$ – trichoplax Jul 25 '17 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\$ – fireflame241 Jul 26 '17 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 Jul 28 '17 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\$ – FryAmTheEggman Jul 28 '17 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 Jul 28 '17 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


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\$ – TheLethalCoder Jul 31 '17 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\$ – Magic Octopus Urn Jul 31 '17 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\$ – TheLethalCoder Jul 31 '17 at 14:26
  • \$\begingroup\$ The decryption stage might be clearer if you use a number that doesn't contain 0s and 1s. \$\endgroup\$ – TheLethalCoder Jul 31 '17 at 14:27
  • \$\begingroup\$ @TheLethalCoder fixed. \$\endgroup\$ – Magic Octopus Urn Jul 31 '17 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\$ – TheLethalCoder Jul 31 '17 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 Jul 31 '17 at 14:49
  • \$\begingroup\$ @CarlosAlejo it used to be 11100092 but I changed it to 33344492, nice catch; missed that. \$\endgroup\$ – Magic Octopus Urn Jul 31 '17 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 Jul 31 '17 at 22:05
  • \$\begingroup\$ Also related \$\endgroup\$ – Luis Mendo Jul 31 '17 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\$ – Destructible Lemon Aug 2 '17 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 Aug 2 '17 at 23: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 Aug 5 '17 at 4:41
  • \$\begingroup\$ I would use code-golf for this personally. \$\endgroup\$ – Gryphon Aug 8 '17 at 2:42
  • \$\begingroup\$ You mean, implement Stacksort? :) (not exactly the same, but very similar) \$\endgroup\$ – Sanchises Aug 8 '17 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\$ – programmer5000 Jun 9 '17 at 1:38
  • \$\begingroup\$ @programmer5000 Not entirely abandoned yet. \$\endgroup\$ – Erik the Outgolfer Jun 9 '17 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 Aug 10 '17 at 15:11
  • \$\begingroup\$ @Cowsquack No they will vary \$\endgroup\$ – TheLethalCoder Aug 10 '17 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 Aug 9 '17 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\$ – TheLethalCoder Aug 9 '17 at 10:35
  • \$\begingroup\$ @geokavel I don't think that's necessary, easy challenges are still good challenges. \$\endgroup\$ – TheLethalCoder Aug 9 '17 at 10:35
  • \$\begingroup\$ Guess it's ok as is. \$\endgroup\$ – geokavel Aug 9 '17 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 Aug 9 '17 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 Aug 9 '17 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\$ – TheLethalCoder Aug 10 '17 at 7:52
  • \$\begingroup\$ Could we output, for example, 1, -1, and 0 instead of R, L, and N? \$\endgroup\$ – Stephen Aug 10 '17 at 19:23
  • \$\begingroup\$ @StepHen - I don't see why not. \$\endgroup\$ – Shadow Aug 10 '17 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 Aug 12 '17 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 Aug 12 '17 at 23:31

Intertwined Polyglot

Write a program which when executed as language A, produces a different program in language B, which in turn produces the name of language A. And the other way round (B to A to B).

+-----------+   Lang. A    +-----------+   Lang. B
| Program 1 | -----------> | Program 2 | -----------> "<Lang. A>"
|           |              +-----------+
|   Your    |              +-----------+
|  Program  | -----------> | Program 3 | -----------> "<Lang. B>"
+-----------+   Lang. B    +-----------+   Lang. A


  • The produced programs must be unique both from each other, and from the original program.
  • Uniqueness is defined as at least one modified or moved printing character. Example: a bc => ab c would not be considered unique, whereas a bc=> a cb would.
  • The output may contain leading and/or trailing whitespace and/or newlines, so long as the language name is intact.
  • Your program(s) may not take any input.
  • This is , so fewest bytes wins.
  • \$\begingroup\$ I couldn't find a matching question... but I really think this might be a dupe.. \$\endgroup\$ – officialaimm Aug 10 '17 at 12:20
  • \$\begingroup\$ You should define "unique". Does 1 character difference count? Can it be a hidden character (CR,...)? \$\endgroup\$ – Goufalite Aug 10 '17 at 12:49
  • \$\begingroup\$ @officialaimm That's what I thought too, but I had no luck finding it either \$\endgroup\$ – MTCoster Aug 10 '17 at 13:03
  • \$\begingroup\$ @Goufalite I would say yes to a single character, but I'm not sure about whitespace. For some languages it's integral, but others will ignore it \$\endgroup\$ – MTCoster Aug 10 '17 at 13:05
  • \$\begingroup\$ I believe this is the duplicate you guys are thinking of. cc @officialaimm \$\endgroup\$ – ETHproductions Aug 11 '17 at 21:01
  • \$\begingroup\$ @ETHproductions Nope, not that one... I don't even know if there is a dupe, I just doubt there might be one.. \$\endgroup\$ – officialaimm Aug 12 '17 at 3:25
  • \$\begingroup\$ The "And the other way round" should be emphasized more. On my first read, I though only A to B to A was necessary. An example would solve this and make the challenge easier to understand overall. \$\endgroup\$ – fireflame241 Aug 14 '17 at 1:31
  • \$\begingroup\$ @fireflame241 Does the diagram I've added help to ease understanding? \$\endgroup\$ – MTCoster Aug 14 '17 at 8:42
  • \$\begingroup\$ @MTCoster absolutely. However, it looks like Program 1 and Your Answer are different. Remove the dividing line? \$\endgroup\$ – fireflame241 Aug 14 '17 at 13:55

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\$ – Peter Taylor Aug 17 '17 at 8:41
  • \$\begingroup\$ @PeterTaylor Is the same true for any other prime? \$\endgroup\$ – H.PWiz Aug 17 '17 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\$ – Peter Taylor Aug 17 '17 at 15:28
  • \$\begingroup\$ @PeterTaylor I don't know any group theory, but thanks anyway. \$\endgroup\$ – H.PWiz Aug 17 '17 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\$ – Kevin Cruijssen Aug 18 '17 at 6:49

Numbers to Algorithms

Another horrible part of Cubically is attempting to print numbers when the notepad is occupied. Since you can't add up existing faces, the integer (or ASCII value) you have to print needs to be on one single face.

The maximum value you can store on one Cubically face is 45. This isn't great, but it's better than nothing. Your challenge is to write a program that automates the process of getting the values 0-45 onto the top face.

Your program will take an input number n and produce a Cubically code snippet as output. This Cubically snippet should achieve the task of getting all integers on the top face to sum up to n. If you don't yet know how Cubically works, go check out the repo. Here's a run-down of all you need to know.

Cubically is my esolang based on a Rubik's Cube. Its 3x3x3 memory cube is initialized like this (without the comments on the right):

   000          top face
111222333444    left, front, right, and back faces, respectively
   555          down face

It uses quarter turn notation, so RRLL turns the cube to look like this:


Now the sum of the top face is 30. So if n is 30, RRLL would be a valid output.

In addition to quarter turn notation, you can send a subscript number to face turns to mean "turn the xth layer inwards from the [face] face, where x is the subscript number". So R1 would turn the cube to look like this:


Arbitrary base conversion

Given an integer n of any sign, output a list of digits of its representation in a given base b not in -1, 0, 1. If b is positive, n will be non-negative.


  • You may not use arbitrary base conversion built-ins like Jelly's b or 05AB1E's в.
  • You may assume the input is valid, as above.
  • All digits must be greater than or equal to 0 and strictly less than b.
  • For zero you must return [].

Test cases

256, 10 -> [2, 5, 6]
256, -10 -> [3, 5, 6]
1000, 25 -> [1, 15, 0]
1000, -30 -> [2, 27, 10]
0, 300 -> [0]
1000, 1000 -> [1, 0]
18446744073709551615, 4 -> [3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3]
18446744073709551615, -5 -> [3, 3, 2, 1, 3, 3, 1, 2, 1, 2, 2, 3, 0, 1, 1, 4, 0, 2, 0, 4, 3, 4, 2, 3, 3, 1, 4, 4]


Is this a dupe?

  • \$\begingroup\$ I'd suggest 0 in any base be the empty array, so it doesn't need special handling from recursive solutions and the like. \$\endgroup\$ – ETHproductions Aug 6 '17 at 21:57
  • \$\begingroup\$ @ETHproductions Let's see...well, [0] shouldn't actually need special-case handling if you put the sum check before the special cases...but otherwise I did consider []. \$\endgroup\$ – Erik the Outgolfer Aug 7 '17 at 8:47
  • \$\begingroup\$ We had this challenge which was closed as dupe of that challange. \$\endgroup\$ – nimi Aug 20 '17 at 18:10
  • \$\begingroup\$ @nimi Hmm...from the title you would guess that it's about converting to bases 2..36 although that doesn't seem to be the case so not sure if this is a dupe or something. \$\endgroup\$ – Erik the Outgolfer Aug 20 '17 at 18:29


Given an input Bomberman board b, use the following characters to define the different bomberman tiles:

  • X denotes the outer boundary of the board.
    • X is always in each of the four corners of the board.
    • X may only be on the boundaries of the board.
  • - denotes an empty space.
    • When a bomb blows up over an empty space, it replaces it with *; and may continue.
  • o denotes a blocker that is breakable.
    • When a bomb blows up over a breakable blocker, it replaces it with *; and stops.
  • O denotes an impenetrable blocker.
    • When a bomb reaches an impenetrable blocker, it stops prior to it.
  • 0-9 describes a bomb of n power.
    • When a bomb explodes it explodes in a plus pattern.
    • A bomb of 0 strength would be: *.
    • A bomb of 1 strength would be: * \n***\n *
    • And so on... 1-indexing is not okay because that would make the 9 bomb a 10 bomb.

Worked Example

An example board would be (without bombs):


If we were to add some randomized bombs to this board we would see:


This should, when input to your program, output the following explosion pattern:

X-oo***O---X # This didn't get blocked, it's just a small explosion.
X-*O*O--*--X # This destroyed a brittle block.
X-*O*****--X # This got hard blocked.
*******---** # Notice how it wraps, because there's no boundary.
X-*O****---X # This got hard-blocked.

Example 1:





Example 2:





Example 3:


X     X

X     X


X    *X
X    *X


More examples, soon. Is this good? Sandbox? What should I change?


Is Effort Inversely Correlated with Upvotes?

Inspired by this chat message and the subsequent conversation


PPCG is infamous (famous?) for it's short golfing language answers that are showered with upvotes. But, are these short answers full of hard-core golfing, or are they just a few builtins that work? Do these answers take effort, and deserve upvotes, or are upvotes and effort inversely correlated?

The Challenge

To get some variables out of the way, x=effort, and y=votes

Your challenge is, given a question ID, output A if the question has a strong positive correlation between effort and votes, B if it has a weak correlation between efforts and votes, or C if it has a strong negative correlation between effort and votes. A may be any value never given as B or C, B may be any value never given as A or C, and C may be any value never given as A or B (You doubt have to have consistent values across runs, but the set of values for A must not intersect with B or C, etc.).

Defining Effort

Effort is an awfully complex concept, but for this challenge we will grossly simplify it to the number of significant edits. significant edits, in this context, will be the number of edits, by the question author, that occurred more than 1 minute after the previous edit (initial posting, in this case, counts as an edit).

Defining Votes

Votes is upVotes - downVotes.

Defining Correlation

For the sake of simplicity, will we use the least-squares regression line as our correlation model. If R^2 (the determination coefficient) is less than .3 (e.g. < 30% of the variation is explained by the model), we will say that there is weak correlation. If R^2 is greater than or equal to .3, we will say that the correlation is strong. Negative vs. positive correlation must be determined from the sign of R (the correlation coefficient).

What Points?

The data points that should be included in your regression are points of the form (votes, effort) for each answer in the given question.

Test Cases



  • For the purposes of this challenge, you may access the api.stackexchange.com website. You may not shorten the URL with any out-of-language utilities (e.g. tinyurl, but you can still compress it if your language supports compression)
  • You may not violate any standard loopholes
  • You may take input and give output in any reasonable format
  • You should exclude community wikis from your calculations


  • \$\begingroup\$ @programmer5000 okay \$\endgroup\$ – Socratic Phoenix Aug 22 '17 at 20:32
  • \$\begingroup\$ "number of edits greater than 5 characters" counted how? Levenshtein distance with substitution counted as 1? (This is a terrible proxy for effort: apart from anything else, adding strikeout to record a one-byte improvement would take you past the threshold, even if the improvement was suggested in comments and required no effort on the OP's part). \$\endgroup\$ – Peter Taylor Aug 23 '17 at 21:23
  • \$\begingroup\$ @PeterTaylor that's intentional (the strikeout), but I agree that's it's a bad proxy for effort.. I'll try and create a better one... \$\endgroup\$ – Socratic Phoenix Aug 23 '17 at 21:39
  • \$\begingroup\$ @PeterTaylor updated definition of effort, is it better or worse? \$\endgroup\$ – Socratic Phoenix Aug 24 '17 at 18:03

Word Problem Generator

Already exists here!

Word problems can be a great way to test comprehension of concepts, but they are pain to write. That's why you need to make a program that takes an equation (or set of equations), and makes a word problem out of them. For example, if the input is x+3=8, you can output, Mary has 3 more apples than Johnny. If Mary has 8 apples, how many does Johnny have?

The best answers for this challenge will be able to handle many different types of equations and randomly generate a variety of unique word problems. It might be o.k. if your program creates non-sensical word problems, as long as they describe the input equation/equation set and people like them.


  • Submission must be no longer than 2000 bytes
  • External files and URL's may be used to access word lists not specifically made for this challenge. You can also use libraries for parsing mathematical equations and sentence generation that were not specifically made for this challenge (WolframAlpha is acceptable). Inquire about other acceptable usage of external sources.
  • Golfing is encouraged. Most popularity contests ask for readable code, but with a tight 2000 byte limit, I encourage golfing as much as possible (even using a golfing language), so that you'll have enough bytes remaining to create interesting word problems.


  • atan(x) = 5/4 => "At what angle should Jan hit the soccer ball to hit a target 5 feet high and 4 feet away?"
  • x+5 = y, 2(x-1) = y-1 => "Paul is 5 years older than Sally. Last year Paul was twice Sally's age. How old are Paul and Sally?"
  • x = 6^2/4^2 => "How much more pizza is there in a 12 inch pizza than an 8 inch pizza?"


With your submission, you include the types of equations/equation sets it can handle (we'll assume that a,b,c,d,e,f,g refer to constants and t,u,v,w,x,y,z refer to variables).

As an example, let's say your program can only make 1 type of word problem: "How long will it take for a boat with speed a to catch up to a boat with speed b that is distance c ahead of the first boat?" In that case, you write that your program only handles equations of the form at = bt + c, so people will know to only test it with things like 5t = 3t + 2 or 4t = 2t + 1.

Furthermore, you should mention if your program can make multiple types of word problems for one type of equation/equation set. For example, an equation of the form a + bx = c could lead to word problems about the time it takes to get from one point to another, or the amount of a particular coin you need to reach a certain amount of money.

Likewise, mention other ways your program creates variety in generating word problems.

Finally, you can include some sample word problems your program has generated, and the equations they were for.

Minimum Requirements

The most basic acceptable solution should handle at least 1 equation/equation set with at least 1 variable, 1 constant, and 1 mathematical operation. Such a minimal program might only handle equations of the form x = a + 1. It might output word problems like, "If Jerry has a apples, and he picks 1 more, how many does he have now?" Obviously, you should not strive for the bare minimum.

All suggestions welcome!

  • 1
    \$\begingroup\$ In case you haven't seen it yet: Tag Wiki for popularity contest. As noted there, you should include an objective validity criterion. You already have some useful rules, but it's still not clear me what the minimum requirement for an answer is. E.g. would handling only equations x=1+2 suffice? What about only x=3. \$\endgroup\$ – Laikoni Jul 21 '17 at 8:51
  • \$\begingroup\$ @Laikoni ty, updated. \$\endgroup\$ – geokavel Jul 21 '17 at 15:35
  • \$\begingroup\$ Personally, I dislike the scoring. Having a hard byte count limit discourages more verbose languages, but at the same time, byte count is not a factor in scoring. Also, I'm not sure popularity-contest is the right choice here. I would either 1) Make it a code-golf and impose strict requirements on what the program should be able to do, or 2) Make it a test-battery, where the score is the percentage of inputs that result in coherent output \$\endgroup\$ – musicman523 Jul 21 '17 at 20:59
  • \$\begingroup\$ @musicman523 I've thought about other formats than pop-con, but I think they all significantly reduce creativity. I don't have a perfect answer for byte count limit, but I think it is needed, otherwise people can spend forever hardcoding all sorts of words problems, which is not really what I'm looking for. Also, one tradeoff is the languages that are usually more verbose are the more established ones that also have more library access. \$\endgroup\$ – geokavel Jul 21 '17 at 21:55

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\$ – Jonathan Allan Aug 24 '17 at 21:07
  • 1
    \$\begingroup\$ @JonathanAllan Thanks for the feedback. Amended based on what you said \$\endgroup\$ – dbr Aug 25 '17 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 Aug 26 '17 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 Aug 26 '17 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 Aug 26 '17 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\$ – Peter Taylor Aug 27 '17 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?


Where in the world am I?

Original Challenge

This challenge has a single aim, given no input, print out the user's current location, with a minimum of the following info:

  • City
  • Country

So any of the following are allowed:

  • "London, England"
  • "Eifel Tower, Paris, France"
  • ["London", "England"]
  • {"country": "Scotland", "city": "Edinburgh"}

The following are not allowed:

  • [51.5074, 0.1278]
  • {"country": "Scotland", "city": "Edinburgh", ISP: "EE"}

Do not show the user's IP or ISP name, or any extra output.

Standard code golf rules apply

Good luck, and have fun!

Reason for limits


programmer5000 - Suggesting to post here after original was deleted

caird coinheringaahing - Lon and Lat rules

  • \$\begingroup\$ Is returning a list of geo-cordinates allowed? You might want to clarify that in the question \$\endgroup\$ – caird coinheringaahing Aug 28 '17 at 14:12
  • 3
    \$\begingroup\$ This has a number of issues with ill-defined cases. In particular, the following are not addressed: (A) my location is unambiguously in a given country, but there's no city within several hours' drive; (B) my location is unambiguously not inside any country; (C) the territorial ownership of my location is disputed; (D) it's not clear what the name of the country is (where your example of Edinburgh is a good one: if Scotland is correct, is UK incorrect? How about dependencies, colonies, etc?) \$\endgroup\$ – Peter Taylor Aug 28 '17 at 21:26
  • 2
    \$\begingroup\$ In addition, it contradicts itself over whether {"country": "Scotland", "city": "Edinburgh"} is allowed or not; and it is not very testable. To make this a good challenge I would recommend taking latitude and longitude as inputs and providing a complete and unambiguous specification of exactly what the output string should be such that any incorrect answer can be shown to be incorrect with a test case which it fails. \$\endgroup\$ – Peter Taylor Aug 28 '17 at 21:28
  • \$\begingroup\$ TBH, if someone was onboard the International Space Station and decided to take time out to complete my code golf challenge I would take it as a compliment. For international waters I would be OK with an answer that pointed towards that. For ones with multiple answers / disputed it would probably be reasonable to accept multiple answers, but there may be issues with this I have not foreseen. \$\endgroup\$ – jrtapsell Aug 28 '17 at 21:35
  • \$\begingroup\$ RE: The contradiction, this was an omission I hope I have fixed now \$\endgroup\$ – jrtapsell Aug 28 '17 at 21:37
  • \$\begingroup\$ Is there a way to fix this issue more generally? I know my answer is a bit vague and not built into the question \$\endgroup\$ – jrtapsell Sep 1 '17 at 10:31
  • \$\begingroup\$ Is this challenge good to go, needs changes, or not of use? \$\endgroup\$ – jrtapsell Sep 2 '17 at 23:20

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 Sep 9 '17 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\$ – Anthony Pham Sep 9 '17 at 11:28
41 42
44 45

You must log in to answer this question.

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