Sandbox for Proposed Challenges

Question

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

Posting

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.

Discussion

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.

Other

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

Answer 1

NB: work in progress

Convert MADBACE to DECIMAL

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.

Rules

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

Examples

CM → 900

MC → 1100

MD → 1500

DM → 792 1000-13×16¹

LD → 450

CD → 400

XD → 40

ID → 49 13×16⁰-1

3C → 52 100-3×16¹

4C → 76 4×16¹+12×16⁰

MADBACE → 701590 (10×16⁵-1000)+(11×16³-500)+10×16²+100+14×16⁰

DECIMAL → 233571513 13×16⁶+14×16⁵+12×16⁴+(1000-1)+10×16¹+50

code-golf base-conversion roman-numerals hexadecimal

Answer 2

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

code-challenge grid

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.

Answer 3

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

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

As an example (from the wiki):

In this question matrices are all square.

Examples (these need updating to have complex entries)

Input:

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

Permanent:

-4

Input:

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

Permanent:

0

Input:

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

Permanent:

192

Input:

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

Permanent:

1021509632

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.

Answer 4

Survival Island

king-of-the-hill

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

Objects

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

Input/Output

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}]

indicates:

• 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

Answer 5

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.

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.

Scoring

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?

Answer 6

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

---

Encryption

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.

Decryption

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)

12349149
[170,12349149]

99922211100
[1820,9210]

2
[1,2]

9
[1,9]

10
[2,10]

100
[4,10]

0
[1,0]

1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111
[10141204801825835211973625643007,1]

111222333444555666777888999000
[954437176,1234567890]

10101010101010
[10922, 10101010101010]

Answer 7

Generate a Spiral Matrix

• Related: Print NxN spiral of ascending numbers - This challenge is meant to replace that old challenge by covering all spiral matrices.

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.

Rules

• This is code-golf 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.

Answer 8

Interpret a Maximal Number of Brainf*** Variants

code-challenge interpreter brainfuck

A while ago in chat, I had an idea:

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.

Scoring

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.

Answer 9

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?

code-golf

Answer 10

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.

Scoring

code-golf seems an odd tag here, but popularity-contest 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?

Answer 11

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

code-golfstring

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

Rules

• 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

Sandbox

• Please comment if there's any error in the test-cases.
• How could I make this challenge better?
• Bumps: 3

Answer 12

The Mode of an Image

fastest-code image-processing

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

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

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

Test Cases

//TODO: add them

Scoring

As this is fastest-code 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.

Sandbox

• Test case suggestions?
• Better scoring mechanism? i.e. average of the time for each test case

Answer 13

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.

Input

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.

Output

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.

Either;

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

Examples

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

Answer 14

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

Input

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

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

Answer 15

Smooth Usage [On hold while alternative scoring is considered]

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

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

---

Challenge

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 code-golf to encourage short answers, but ultimately will be a popularity-contest as I suspect perfect solutions will be hard to come by.

Answer 16

Reverse Cycling with Rubik's rubiks-cube code-golf permutations

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

Input

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.

Output

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.

Examples

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

Winner

As with code-golf, 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!

Answer 17

Time bomb ping pong

code-challenge cops-and-robbers kolmogorov-complexity

---

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!

Answer 18

Conversion: 2 dice from 3

code-golf probability

---

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.

Input

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.

Output

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.

Scoring

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 code-golf, 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?

Answer 19

Just a relative

Summary

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.

Rules

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.

Definitions

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.

Function

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)

Formula

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.

Examples

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

=SUMIFA1(GL93) 1 2
>>=SUMIFA1(GM95)

=ARBITRARY($A$1)+CRAZY(G$3) 3 3
>>=ARBITRARY($A$1)+CRAZY(J$3)

=$A3+B$2+$C$1 4 -2
>>=$A1+F$2+$C$1

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!

Answer 20

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,

• kolmogorov-complexity

• sequence

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

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

Sequence

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.

Scoring

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.

Prizes

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

Answer 21

popularity-contest OR code-golf, cops-and-robbers string encode decode

Steganography: Hide a message in an image!

---

Cops

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}

---

Robbers

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.

---

Meta:

• 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 code-challenge 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 code-golf.

  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.

Answer 22

Generating Punnett Squares code-golf

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

"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

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

Answer 23

Displaying exponent towers in ASCII

code-golfarithmaticascii-art

Background

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:

            c
           b
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

           bc
(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,

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

Challenge

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.

Rules

• 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 code-golf, so shortest answer in bytes wins.

Test Cases

Input: a
Output:
a

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

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

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

Meta

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

Answer 24

Erdős–Straus conjecture

Answer 25

Determine the Resultant

code-golfmathabstract-algebrapolynomialsgeometry

META:

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.

Definitions

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.

Answer 26

Pythagorean Double Regex

code-golfregexdecision-problem

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.

Challenge

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)

Input

• 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}

True:
3,4
4,3
30,40
16,12
20,21
21,20
4,5
40,50
24,25
7,7

False:
1,2
5,6
7,8
4,10
9,10
3,100
9,16
24,20

This is code-golf, so the shortest regex in bytes wins!

Answer 27

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
   face

3:  ace
   face
    please

4:  ace
   face
    please
     keep

5:  ace
   face
    please
     keep
    sheeple

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

---

Rules

• Lowest byte-count wins, this is code-golf.
• 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).

Answer 28

100 Letters is the Perfect Amount

Oxford dictionary lists the most commonly used English letters in the following order:

EARIOTNSLCUDPMHGBFYWKVXZJQ

And assigns each the following frequencies:

For the purpose of this challenge, the diagram will be simplified as follows:

z   1
q   1
x   1
j   1
k   1
v   1
b   2
p   2
y   2
g   2
f   2
w   2
m   3
u   3
c   3
l   4
d   4
r   5
h   6
s   6
n   6
i   6
o   7
a   8
t   9
e   12
TOT 100

---

Now, onto the task at hand; I've provided you all with a dictionary of words to choose from, using this dictionary of words choose as many as you want to output. However the catch is that you must have EXACTLY the count above of each letter in the output using 7-12 words.

---

Scoring

• Your base score is the length of your code in bytes.
• You are allowed to go over or under on the number of letters required, each letter above or under results in a +5 byte penalty.
• If the number of words you've used is between 7 and 12, no penalty is incurred.
  • IF it exceeds 12, add 10 bytes per additional word.
  • IF it is less than 7, subtract 5 per missing word.

Rules

• You may use any word from the provided dictionary.
• Each word you output must be distinctively separated by either a space or a newline.
• Once a word combination has been posted, you may not use more than 6 of that answer's words together in a new answer.
  • This will be enforced by post date.
• This is code-golfword-problemkolmognogniznornia-complexitylty
• Your score will be as defined in the scoring section.

Answer 29

Create a .pdf file

Your task is, given a non-empty string, to create a valid PDF (also see here for more information about the structure of PDF-files) file that contains no more than this string (no page numbers, date etc). Your submission has can either be a function or full program that achieves this task.

Rules

• The input will be a non-empty string of printable ASCII characters, additionally the characters \n & \t may be part of the input but not the last character
• Your program/function produces a valid PDF file that contains that string but no more
• The representation of the string doesn't matter, except that it has to be a different color than the background, meaning valid representations may be (not limited to):
  • green text on black background (or the other way around)
  • the font is irrelevant but has to be consistent (it has to be readable without using a loupe)
  • some sort of image that represents the string
• The output has to be case sensitive
• If the string doesn't fit page width it needs to be split in a consistent manner such that it fits onto multiple lines (this means each character needs to be visible)
• If the lines don't fit onto a single page, you'll need to insert pagebreaks
• The width of a \t and (space) need to be visibly different (\t larger)
• The PDF may contain one trailing empty page
• The PDF can be printed to STDOUT (ie. call_your_program > test.pdf would result in a valid PDF) or create a new file somewhere on your filesystem (the filename doesn't need to end in .pdf or .PDF)

Example inputs

Valid

Printable string:

Hello, World!

Printable string containing newline(s):

Foo\nBar

Printable string containing newlines & horizontal tabs:

Line 1:\t!"#$%&\'()*+,-./0123456789:;<=>?\nLine 2:\t@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_\nLine 3:\t`abcdefghijklmnopqrstuvwxyz{|}~

Invalid

Trailing newline:

Hello, World!\n

Carriage return:

Foo\r\nBar

Empty string:

Sandbox

Tags will be: code-golf, encode, graphical-output

• Are there other relevant tags?
• Is the challenge specific enough (creating PDFs that only work in an exotic PDF-reader etc)?
  • Should I limit the question such that the file has to be "viewable" in (for example) xpdf?
  • If so, would xpdf be a good choice?
• Is "readable" well defined enough (for example some people may claim that they are able to read Wingdings or even worse Comic Sans :P)
• Should I enforce a certain font size? What about even enforcing a certain font itself? (I feel this takes away too much freedom)
• Should I limit input such that it always fits onto a single page? (Loophole: people could choose a font size such that the input can only be one letter)

Answer 30

Number of all hyperrectangle-filling walks

Your input:

• size of the hyperrectangle – generally an n-tuple
  • eg. (s,s) in case of a square
• position in the hyperrectangle – generally 0 <= pos[i] < size[i] for i-th dimension
  • eg. (x,y) where 0 <= x < s and 0 <= y < s in case of a (s,s) square.

Your task: Find the number of walks in the hyperrectangle, which start at the given position and visit each cell of the hyperrectangle exactly once.

In the context of this task, a walk is a sequence of positions, such that each position after the first differs from the previous one in exactly one dimension by amount of exactly 1. Eg. in the case of a 2x2 square, a possible walk would be (0,0) -> (0,1) -> (1,1) -> (1,0).

Note: It doesn't matter whether x is vertical position and y horizontal or vice versa. Neither it matters whether coordinates grow downwards / upwards or to the left / right (eg. vertical axis might grow downwards or upwards without any effect on the result). These statements extend to higher dimensions as well.

Related task: Longest hypercube path

Example

Given size = (3,3) and pos = (0,0), there are 8 solutions. These can be divided into four equivalence classes under the relation of transposition, viz. A == Transpose(A). Only one solution for each equivalence class needs to be found, the other one can be obtained by simply transposing the first one.

The four "canonical" solutions:

Output: 8.

Possible specializations

Specialization 1: Support only hypercubes (hyperrectangles with equal sizes in each dimension). Specialization 2: Support only 2-dimensional hypercubes (squares).

My questions

1. (Obvious question) Has this task already been presented?
2. Is this task (in its general form) too difficult? Would it be more reasonable to restrict it to one of the specializations (or to a different specialization)?