# What is the Sandbox?

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

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

## Get the Sandbox Viewer to view the sandbox more easily

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

# International Choice of Urinal Protocol efficiency

A long while ago, Randall Munroe of xkcd fame wrote a blog post entitled Urinal protocol vulnerability. The titular "International Choice of Urinal Protocol" is that when men enter a bathroom that has a row of urinals along the wall, they will first take the end urinals, and then take the urinals that are furthest from the other men. All men seek to avoid awkwardness, which happens when two men use adjacent urinals.

For example, if there are five urinals in a row, then by following this protocol, men will take urinals in this order:

UUUUU
1 3 2


In this case, the packing efficiency is optimal. However, when there are seven urinals, then this happens:

UUUUUUU
1  3  2


This is essentially the worst case. Fewer than half of the urinals are used, and Randall continues investigating when the best and worst cases happen. For this challenge, though, your only task is to calculate the packing efficiency of this protocol when given a number n of urinals, which is k/n where k is the number of urinals taken before awkwardness ensues.

## Spec

• Standard I/O and rules apply.
• Input is a single positive integer n, which may be given as either decimal or unary.
• Output must be either a float or a simplified fraction. If your language cannot do either of these easily (e.g. BF or Retina), then you may simply output k (in decimal or unary).

## Test cases

Decimal

 1 1.0
2 0.5
3 0.6666666666666666
4 0.5
5 0.6
6 0.5
7 0.42857142857142855
8 0.5
9 0.5555555555555556
10 0.5


Fractions

 1 1/1 {or} 1
2 1/2
3 2/3
4 1/2
5 3/5
6 1/2
7 3/7
8 1/2
9 5/9
10 1/2


Urinals taken k

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


Note: this is A166079.

Related: The Urinal Protocol, which asks for all the possible ways men could take urinals with no restriction on the first and no awkwardness.

• Did you mean 8 1/2? – Leaky Nun May 21 '16 at 4:08
• You might want to link to this OEIS sequence. – Leaky Nun May 21 '16 at 4:10
• – James May 21 '16 at 8:55
• @DrGreenEggsandHamDJ: Whew! Not a duplicate! :P But thanks for that anyway, I'll include it. – El'endia Starman May 21 '16 at 10:45
• @KennyLau: Thanks for those! – El'endia Starman May 21 '16 at 10:51

# Find the smallest number bigger than the input whose digital sum is the input

"Digital sum" refers to the sum of all the digits in a number.

For example, the digital sum of 1324 is 10, because 1+3+2+4 = 10.

The challenge is to write a program/function to calculate the smallest number bigger than the input whose digital sum is the input.

## Example with walkthrough

As an example, take the number 9 as the input:

9 = 1+8 -> 18
9 = 2+7 -> 27
9 = 3+6 -> 36
...
9 = 8+1 -> 81
9 = 9+0 -> 90


The valid output would be the smallest number above, which is 18.

## Specs

Note that 9 is not the valid output for this example, because the reversed number must be greater than the original number.

Note that the input will be positive.

## Test-Cases:

 2 => 11
8 => 17
12 => 39
16 => 79
24 => 699
32 => 5999


## References:

This is OEIS A161561.

• As far as I know it's either 2 or there is none – levanth May 23 '16 at 14:14
• I see what you mean, let me specify this a little better – levanth May 23 '16 at 14:17
• I edited the question to include the additional rule and changed the term digital root with digital sum – levanth May 23 '16 at 14:38
• Do you mean I should remove the mentioned part? – levanth May 23 '16 at 14:44
• Could I edit the question for you? You can rollback the edit afterwards if you don't like it. – Leaky Nun May 23 '16 at 14:47
• You are welcome to. This is my first Challenge I post here – levanth May 23 '16 at 14:49
• Done. How's it now? – Leaky Nun May 23 '16 at 15:01
• Also, you are welcome to join our chat. – Leaky Nun May 23 '16 at 15:01
• Yes thats exactly what I meant. thank you – levanth May 23 '16 at 15:04
• "because the reversed number must be greater than the original number." I don't know what you mean by this. Do you mean the output number must be greater than the input number? – AdmBorkBork May 23 '16 at 16:39
• Yes it has to be greater. If you look at the examples you can see it: input 9 and output has to be a number which has at least two numbers which have 9 as its sum. – levanth May 23 '16 at 16:47
• Can I post this abandoned proposal? – programmer5000 Jun 9 '17 at 13:03

# Light the Way!

This is based on the Lights Out game. There is a grid of tiles, and clicking on a tile (performing a "move") toggles the state of the clicked tile as well as the (orthogonally) adjacent tiles. This variation will also toggle the diagonally adjacent tiles.

It is helpful to note that (on a board with only two states) all moves commute, so the order in which they are performed is not important. It follows that performing a collection of moves a second time will undo what was done the first time.

There are a few ways to present this challenge, so I'll describe some possibilities. Let me know what you think. The challenge could be one of the below:

• Given a board size n (optional) and the initial state of the n-by-n board, determine an optimal collection of moves that will toggle every lit ("on") tile into its dark ("off") state.
• Given n and a sequence of moves performed on an initially dark board of size n, provide the resulting matrix of states.
• A variation on the above involving graphical output.

Input format would be flexible. n >= 1.

### Snippet to show how the game works:

The board size may be adjusted in the first input field. The second field (functionality added by Conor O'Brien) will take a list of coordinates ([[0,0],[1,2],[3,0],...]) and perform the moves for you.

var table;
var color1 = "aqua",
color2 = "yellow";
var moveList = [];

table = document.getElementById("lightGame");
buildTable();

var updateButton = document.getElementById("updateButton");
if (updateButton) {
updateButton.onclick = buildTable;
}

var toPerf = JSON.parse(document.getElementById("moves").value);
//console.log(toPerf);
function rec(arr) {
var m = arr.shift();
var x = m[0],
y = m[1];
var cell = table.rows[y].cells[x];
update(cell);
if (arr.length) {
setTimeout(rec, 500, arr);
}
}
rec(toPerf);
});
};

function buildTable() {
// get size
var input = document.getElementById("size");
var size = new Number(input && input.value || 5);

var rows = size,
cols = size;

// clear moves
moveList = [];
moveHolder.innerHTML = "[]";

// remove existing rows
while (table.lastChild) {
table.removeChild(table.lastChild);
}

// create new rows
for (var y = 0; y < rows; y++) {
var row = document.createElement("tr");

for (var x = 0; x < cols; x++) {
var cell = document.createElement("td");
cell.style.backgroundColor = color1;
cell.x = x;
cell.y = y;
cell.onclick = function () {
update(this);
};
row.appendChild(cell);
}
table.appendChild(row);
}
}

function update(cell) {
var x = cell.x;
var y = cell.y;

var xMax = table.rows[0].cells.length;
var yMax = table.rows.length;

// update cell
changeColor(cell);

if (x > 0) changeColor(table.rows[y].cells[x - 1]);
if (x + 1 < xMax) changeColor(table.rows[y].cells[x + 1]);
if (y > 0) changeColor(table.rows[y - 1].cells[x]);
if (y + 1 < yMax) changeColor(table.rows[y + 1].cells[x]);

if (x > 0 && y > 0) changeColor(table.rows[y - 1].cells[x - 1]);
if (x > 0 && y + 1 < yMax) changeColor(table.rows[y + 1].cells[x - 1]);
if (x + 1 < xMax && y > 0) changeColor(table.rows[y - 1].cells[x + 1]);
if (x + 1 < xMax && y + 1 < yMax) changeColor(table.rows[y + 1].cells[x + 1]);

// update moves
moveList.push([x, y]);
moveHolder.innerHTML = JSON.stringify(moveList);
}

function changeColor(cell) {
cell.style.backgroundColor = cell.style.backgroundColor === color1 ? color2 : color1;
}

function getStyle(elt, styleProp) {
if (elt.currentStyle)
return elt.currentStyle[styleProp];
return document.defaultView.getComputedStyle(elt, null)[styleProp];
}
body {
background-color: darkslategray;
color: white;
}
#gameDiv {
text-align: center;
}
margin: 25px;
}
h2, h4 {
color: red;
}

#lightGame {
border: 1px solid white;
margin: auto;
}
#lightGame td {
/*background-color: aqua;*/
height: 25px;
width: 25px;
}
#updateDiv {
margin: 25px;
}
button {
margin-left: 10px;
}

#autoMoveDiv {
margin-top: 10px;
}

footer {
position: fixed;
bottom: 0px;
width: 100%;
}
footer small {
color: cyan;
position: absolute;
bottom: 0px;
}
img {
float: right;
}
<div id="gameDiv">
<h2>Light Game</h2>
<div>
<table id="lightGame">
</table>
</div>
<div id="updateDiv">
<input id="size" name="size" type="number" min="1" max="20" pattern="\d{1,2}" value="5" required />
<button id="updateButton" type="button">Update</button>
</div>
<div>
</div>
<div id="autoMoveDiv">
Auto move:
<input id="moves" />
<button id="perform" type="button">Do Moves</button>
</div>
</div>

Related Questions

JsFiddle of the snippet I made.

• Option 1 would be a duplicate IMO. I do like option 2, though. – Nathan Merrill May 24 '16 at 17:36
• I agree with Nathan Merrill. – El'endia Starman May 24 '16 at 17:37
• @NathanMerrill This does include diagonals too, so it's different. But I don't know how different that'd be programmatically. – mbomb007 May 24 '16 at 17:40
• Does the board wrap? – trichoplax May 24 '16 at 17:43
• Option two sounds like it's pretty much a duplicate of this one, though. Except for the initial board state and diagonals, that is. – Geobits May 24 '16 at 17:44
• Does it need further variation? Hexagonal board? 3d? Broader effect? Random effect? Context dependent effect? – trichoplax May 24 '16 at 17:48
• I'd definitely make diagonals bold. I completely missed that when reading. I think diagonals make either 1 or 2 unique. – Nathan Merrill May 24 '16 at 17:50
• @trichoplax The board does not wrap. – mbomb007 May 24 '16 at 20:01
• "Given a board size n (optional) and the initial state of the n-by-n board, determine an optimal collection of moves that will toggle every lit ('on') tile into its dark ('off') state." Or you can have "determine an optimal collection of moves that will toggle every lit tile into its dark state and vice versa". – msh210 Jun 15 '16 at 22:53
• @msh210 If the goal is to toggle every tile, the solution is trivial. If the goal is merely to end with all light, then with all dark, getting from one to the other is also trivial (it's the set of all moves minus the set from the first answer). – mbomb007 Jun 16 '16 at 13:25

# Shortest program with unknown halting status

## Rules

1. Post a term on the binary λ-calculus (BLC) whose termination is unknown.

2. If someone proves that your term does or doesn't terminate, you entry is disqualified.

3. The term with the smallest number of bits on the BLC wins.

Don't forget to also post a quick description of what you did and the original source code, otherwise we will just have to trust your random string meets the specs!

## Example submission

Size: 579 bits

Program: 01001001000100010001000101100111101111001110010101000001110011101000000111001110
10010000011100111010000001110011101000000111001110100000000111000011100111110100
00101011000000000010111011100101011111000000111001011111101101011010000000100000
10000001011100000000001110010101010101010111100000011100101010110000000001110000
00000111100000000011110000000001100001010101100000001110000000110000000100000001
00000000010010111110111100000010101111110000001100000011100111110000101101101110
00110000101100010111001011111011110000001110010111111000011110011110011110101000
0010110101000011010


Explanation: this term, if it terminates, reduces to a list with all church-encoded natural numbers of the sequence of Collatz (A006577) from 0 to 2^256. It is not known if collats(n) halts for all n; we only know up to about 2^64, so my submission satisfies the specification. For a longer explanation, I've set this repository. The original code was written on Caramel and also on the repository. Here is a brief:

-- Receives fix and a natural, returns the number of
-- recursive calls until the collatz function halts.
collatz fix n = (fix go n)

-- The recursive search
go go n = (succ (even_odd_or_leq_one n even odd leq1))
even = (go go (half n))
odd  = (go go (succ (mul n 3)))
leq1 = 0

• The only thing I'd like to comment on is that the challenge shouldn't be limited to BLC, and that other languages should be allowed so long as they are valid. For example, there is no reason to disallow a python solution that does the same thing as the above BLC code. – Zwei Jun 7 '16 at 3:39
• I agree with @Zwei, but also ban IO and other nondeterministic code. – HEGX64 Jun 7 '16 at 9:56
• As commented on main, you need to define the system of axioms which are permitted for the proof. – Peter Taylor Jun 7 '16 at 11:03
• Fair enough. I feel like this will never get enough momentum for any relevant answer, though. I might just not ask it. – MaiaVictor Jun 7 '16 at 11:10
• @Dokkat This challenge is interesting imo, there are just a few things that need to be worked out such as how does one prove that a program does or does not terminate. Remove the BLC only rule and define the axiom system and this challenge should be good for main. – Zwei Jun 7 '16 at 14:59
• I think it's better to keep the language restriction. – feersum Jun 7 '16 at 20:18
• @feersum for what reason? – Zwei Jun 8 '16 at 0:15
• @Zwei the whole point of the challenge is that I want the program with the lowest Kolmogorov Complexity. It is hard to talk about this metric when you don't have a fixed language. There is a very clear and trivial measure of the complexity of a term on the binary lambda calculus. In fact, I'd say the only way for a code golf challenge to be an objective competition (not just a popularity contest) is by using a fixed language with a clear complexity metric, and the BLC is about as good as we know. – MaiaVictor Jun 8 '16 at 13:50
• @Dokkat fair enough. – Zwei Jun 8 '16 at 15:23
• That link is to binary combinatory logic, not binary lambda calculus. – CalculatorFeline May 31 '17 at 17:55

## Pareto frontier

A point (x1,y1) dominates another point (x2,y2) if both x1≥x2 and y1≥y2. A set of points is a Pareto frontier if no point dominates another point. In other words, any increase in one coordinate must be met with a decrease in the other coordinate.

Your task is to decide whether a given set of points is a Pareto frontier.

Input: A collection of two or more points, which are pairs of positive integers. No two points will have the same x-value or the same y-value. You may not assume the points are given in a particular order.

Output: A consistent Truthy value if it is, and a consistent Falsey value if it's not.

True:

[(12, 1), (6, 4)]
[(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]
[(4, 4), (3, 8), (12, 3), (20, 1)]
[(106, 106), (107, 102), (104, 127)]


False:

[(5, 9), (4, 8)]
[(1, 1), (11, 11)]
[(5, 3), (2, 4), (7, 7), (1, 2)]
[(15, 2), (7, 8), (4, 14), (6, 6)]


Sandbox:

• Is it better to do the decision problem, or the filtering problem of finding the upper Pareto frontier of non-dominated points?

• Should the input be allowed to be taken pre-zipped, as two lists of n numbers? What about a 2D 2-by-n array versus an n-by-2 array?

• I'd recommend only doing the filtering problem if there is a nicer solution than subsets -> filter on decision -> take longest that you can enforce with restraints of some kind. Otherwise I feel like it might be kind of chameleon-y. – FryAmTheEggman Jul 13 '16 at 1:49
• The decision problem can be done as filter and check equality; or sort on one axis and check that the other axis is in reverse order. The filter problem can be done by filtering the power set with the decision problem and taking the longest; or by folding a removal of dominated points. IMO the filter problem is more interesting, because sort builtins are very common and typically cheap. – Peter Taylor Jul 13 '16 at 10:37
• @PeterTaylor The largest Pareto-incomparable subset might contain points dominated by the rest of the set. I expect filtering would be done by folding removal. Does that affect your opinion? – xnor Jul 20 '16 at 5:16
• Ah, true. Folding removal still seems more interesting to me than sorting and checking reverse order. – Peter Taylor Jul 20 '16 at 7:39

# Lets play Stratego!

Stratego is a game of imperfect information which centers around strategy foresight and deception.

https://en.wikipedia.org/wiki/Stratego

Your mission should you choose to accept it. is to write a bot which either uses polymorphism in a java class file, and/or communicate with the arena via an stdin/stdout wrapper.

The arena code and/or stdin out wrapper will be made available if there is interest. Here is the summary.

## Piece Summary

? = Unkown enemy piece
Upper case or special characters (!@#$%^&*()) or F B is the enemy pieces f or F represents an immobile flag if the enemy moves on to this square it is game over. b or B represents an immobile if any hostile piece steps on to it then it dies. If an enemy miner (8) steps on it will succesfully defuse or capture the bomb. s or S gets killed when attacked by any piece, but can kill the 10 by stepping on it. 9 or ) can move any number of squares orthagonally. Otherwise all pieces can capture pieces with a higher number than themselves. I.E 1 captures two which captures three which captures a 4 which captures a five etc... When you attack a piece, the values of both pieces are revealed (thus the enemy will no longer see a "?") If the attacking piece is stronger it takes the spot, if it is weaker, it dies and the defender remains unharmed, and if they are equal both disappear.  Spaces empty are indicated with a space. Spaces with an impassable lake are indicated with an L. The wikipedia article has some great sample strategies and explanations. The protocol for communication will involve Outputting four zero indexed coordinates for the start and end locations of a piece. Invalid moves will simply result in no action taken. • do you have a bot API? – noɥʇʎԀʎzɐɹƆ Jul 23 '16 at 18:56 • Not yet. It was something I was pondering in my head. If there is any interest in this I can slap together an api. @AgentCrazyPython do you think this is a doable challenge – Rohan Jhunjhunwala Jul 23 '16 at 19:27 • I think it's doable. You'd get a whole ton of rep for it. – noɥʇʎԀʎzɐɹƆ Jul 23 '16 at 21:17 • @AgentCrazyPython lol I need the rep. I will write up an arena controller. Should I do it through an stdin/stdout interface or an abstract class? I think I will first write an interface that allows you to inherit from an abstract class. Than I would write a wrapper. The only thing is that I have no clue how to go about implementing a sample bot. – Rohan Jhunjhunwala Jul 23 '16 at 21:23 • depends on if you want to let one language or all languages. I think you should go just one langauge: JS. JS can be demoed easily in the browser and it's great for writing bots. the spacewar! challenge is a good example – noɥʇʎԀʎzɐɹƆ Jul 23 '16 at 21:25 • I need to learn JS, but I am slightly discouraged after learning about jsf*** lol. It seems like an <s>odd</s> unique language lol. – Rohan Jhunjhunwala Jul 23 '16 at 21:27 • I will first prototype a Java arena, and then I will first write a wrapper (probably by modifying @Moogie 's) wrapper. Then I will stare at a wall idly considering porting it to Java script. – Rohan Jhunjhunwala Jul 23 '16 at 21:28 • @AgentCrazyPython ^ Forgot to ping you on the above comments – Rohan Jhunjhunwala Jul 23 '16 at 21:29 • js is super easy to learn. JS has really similar syntax – noɥʇʎԀʎzɐɹƆ Jul 23 '16 at 22:10 • Yeah, but the dynamic typing stuff really gets me. I do have some python background which should help, but I am I java dev mainly. @Agent CrazyPython That being said, I will try to learn java as stack snippets do appeal to me. – Rohan Jhunjhunwala Jul 23 '16 at 23:00 • java ≠ javascript!!!!!!! why is dynamic typing hard - it's looser than static typing – noɥʇʎԀʎzɐɹƆ Jul 23 '16 at 23:48 • @AgentCrazyPython I know that JS!=Java lol. THats why I am scared of it. For someone reason I do prefer being sure of type safety as I code rather than at run time – Rohan Jhunjhunwala Jul 24 '16 at 3:39 • – Rohan Jhunjhunwala Jul 24 '16 at 3:39 ## Reversing the Game of Life Though computing successive generations of Conway's Game of Life may seem simple enough, reversing the process is not. Given an initial board configuration in Conway's Game of Life, either return a predecessor, or some value indicating that it is a Garden of Eden (and therefore contains an orphan), meaning it has no predecessor. A predecessor is a previous generation of a board configuration, meaning that after running the game for a some number of generations, you will arrive at the successor generation, the board configuration that you were initially given. Any given configuration may have zero or more predecessors. Some have infinitely many, such as still life patterns. It will probably be simplest to find a parent, a predecessor configuration from the preceding generation, such that reaching the successor takes one generation. If given a state bounded by a 6x6 rectangle, for example, a parent (if any) will be found by searching the 8x8 rectangle around it. This is a fastest-code challenge, since brute force solutions would take a long time, even for relatively small inputs. All Game of Life patterns bounded by a 6x6 rectangle have a predecessor. Source Example Input Input can be how you like. If you prefer a list of active points, or a matrix of Booleans, that's fine. Just make your output be the same format. This input represents a block: [(1, 1), (1, 2), (2, 1), (2, 2)] [[1,1], [1,1]]  The original Garden of Eden: All cells outside the image are dead (white). Example Output: This is a parent to the block. [[1,0,0,1], [0,1,1,0]]  Garden of Eden: No predecessor  Resources: • Not exactly a dupe, but searching for a parent was how I approached an earlier fastest-code game-of-life question. – Peter Taylor Jul 22 '16 at 21:34 • Why is it undecidable? Theoretically, you could just enumerate over every possible parent state until one generates the pattern (or you run out of possible parents in the case of a Garden of Eden). – LegionMammal978 Jul 22 '16 at 21:41 • @LegionMammal978 I don't understand either, but from the linked Wikipedia article: For one-dimensional cellular automata, orphans and Gardens of Eden can be found by an efficient algorithm, but for higher dimensions this is an undecidable problem. Nevertheless, computer searches have succeeded in finding these patterns in Conway's Game of Life. – mbomb007 Jul 22 '16 at 21:43 • I think it's saying that there is no way that a decidable AND efficient algorithm exists? Not sure. – mbomb007 Jul 22 '16 at 21:44 • @mbomb007 Maybe it's talking about polynomial-time algorithms or something, last time I checked, bruteforce wasn't undecidable – LegionMammal978 Jul 22 '16 at 21:53 • @LegionMammal978 K, I'll remove that part. Is there enough explanation, do you think? There is probably required reading from the links I provided in order for a decent non-brute-force solution to be developed. – mbomb007 Jul 22 '16 at 21:55 • @mbomb007 Looks fine to me – LegionMammal978 Jul 22 '16 at 21:56 • I feel like the performance of an algorithm will heavily depend on how test cases are generated. You should specify this. – xnor Jul 22 '16 at 23:17 • @LegionMammal978: The "undecidable" part is probably due to how you can have spaceships crash together from a distance to make new patterns. – El'endia Starman Jul 23 '16 at 12:39 • @El'endiaStarman However, all that matters for finding the previous generation is the part of the spaceship within the n+2 X m+2 box that can affect the pattern – LegionMammal978 Jul 23 '16 at 14:34 • @LegionMammal978: Hmm, true. I don't know either. – El'endia Starman Jul 23 '16 at 14:47 • @LegionMammal978, the undecidable problem is "Given the rules for a 2-dimensional cellular automaton, does any Garden of Eden exist with those rules?" – Peter Taylor Jul 25 '16 at 20:38 • @PeterTaylor See the Garden of Eden theorem. It says that any CA with multiple patterns that evolve to the same pattern must contain some Garden of Eden (presumably by a variant of the pigeonhole principle). – LegionMammal978 Jul 25 '16 at 21:04 • @mbomb007 One way to do the test cases would be random grids. Most of these would likely have many predecessors and be doable with a heuristic search. If you want hard examples, maybe it's possible to generate ones with few predecessors and mix in gardens of eden. I don't know how doable that is. For returning a g.o.e. in an mxn grid, can't one just return a known minimal one if it fits and falsey otherwise? Generating optimal gardens of eden seems really hard even if you have good heuristics. – xnor Jul 25 '16 at 21:48 • @LegionMammal978, so the existence of twins is logically also undecidable, but I'm not sure why you think that's important to point out. – Peter Taylor Jul 26 '16 at 8:42 Do X without Y​ again! Here is an X done with Y: YyYy YyYy YyYy YyYy YyYy YyYy YyYy YyYy YyYyYyYy YyYyYy yYyYyY yYyYyYyY yYyY yYyY yYyY yYyY yYyY yYyY yYyY yYyY  As you can see, there are 92 Y/ys in this X. Conveniently, there are also exactly 92 printable ASCII characters in the range ! to ~ if you exclude Y and y. Your challenge is to write a program to output or a function to return the above X with all the Y/ys replaced by any permutation of those 92 characters. Leading and trailing white space is permitted. Shortest code wins! • Should that say "each of those 92 characters" (in the range ! to ~, excluding Yy)? – nanofarad Jul 30 '16 at 13:15 • – Leaky Nun Jul 30 '16 at 13:15 • Maybe I'm misunderstanding the question, but you seem to be requiring all answers to be exactly 92 characters long and within that constraint aiming to be the shortest... – Peter Taylor Jul 30 '16 at 17:12 • @PeterTaylor: He doesn't specify a length of an answer... He says that in the above ascii X each Y is replaced by another character of the 92 printable characters that are not y or Y; each char is only used once. – KarlKastor Jul 30 '16 at 19:41 • I'd make it obvious that a permutation of the 92 characters are to be used (no repeating a character) – Nathan Merrill Jul 31 '16 at 1:13 • Have you abandoned this altogether already? – Leaky Nun Aug 18 '16 at 0:16 • @LeakyNun It only got 1 upvote, unless you know a better way of telling when it's ready. – Neil Aug 18 '16 at 0:17 # The Enemy's Gate is Down! (Ender's Game) ## Please note this is a work in progress Your challenge should you choose to accept it is to play ender's game to win style, in honor of Martin Ender first receiving 100k rep! You will split up into teams. You are red if you are an even post and blue if you are odd. Here is a simplified ascii representation of the map. WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW W 1 F 2 W W WwW W W WWW W W WWWWWWWW W W WWWWWWWWWWWWWWWWW W W W W W W WWWWWWWWW WWWWWWWWWWW W W W W WWWWW W W W W 3 G 4 W WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW  Your gate is represented by the "F" and the enemies gate is "G". W's represent walls which will be arranged in an unbiased distribution. The goal is to get to the enemies gate first. Each turn you will output a number from 0-15.  0-7 will allow you to "push" off of a block assuming there is a block in the 8 blocks closest to you (orthagonally or diagonally") 8-17 allows you to shoot a bullet in a given direction which will continue to travel in a given direction. It will break upon hitting a wall or another player. The bullet represented by "P" on the ascii map is iterated after each step. Any player that drifts into it will also be killed. Directions 567 4U0 321  The winning team is the team which either captures the flag first the last man (bot/woman) standing! All submission are deterministic java programs. A psuedorandom generator will be provided. The winning team is the team which wins the first game, (if there are ties). Games will be halted after a significant number (1000) turns. I may allow multiple copies of the same bot on each team to make it more interesting. Collisions with players are treated like collisions with walls. • What about collisions between players? – Destructible Lemon Aug 3 '16 at 2:44 • Both die (i guess) – Rohan Jhunjhunwala Aug 3 '16 at 3:07 • @DestructibleWatermelon a – Rohan Jhunjhunwala Aug 3 '16 at 3:08 • Would it be possible to add an Stdin/out wrapper? – Destructible Lemon Aug 3 '16 at 3:18 • What if friendly bots can be in the same square, and push off each other to confuse the enemy? That seems cool. Probably make it so it doesn't affect the non-pushing bot just to reduce troublemaker bots ;) (Also, I guess each player would need an indication that they have a teammate in the same square or something) – Destructible Lemon Aug 3 '16 at 3:32 • @DestructibleWatermelon ok I can make it so all players atreated like walls u can push off of. – Rohan Jhunjhunwala Aug 3 '16 at 11:46 • It would be nice for the programs to be able to be in any language (using subprocess pipe) – Blue Aug 3 '16 at 15:11 • @Blue I can write an stdin/stdout wrapper once I get an arena. The onl issue is that by starting subproceses the performance may be significantly harmed – Rohan Jhunjhunwala Aug 3 '16 at 16:56 # Golf an InterpretMe interpreter (in any language other than InterpretMe) This is a very simple challenge. The joke language InterpretMe consists of one command; *, which causes the program to take input of an InterpretMe program and execute it. An InterpretMe program will interpret as many InterpretMe programs as there are * in input. Your goal is to create a program that interprets InterpretMe in as few bytes as possible. Test cases consist not of input and output, but input and termination. A newline denotes a new input to be interpreted as InterpretMe. 1. * (executes input as an interpret me program, finishes) 2. * (^same) 3. ** (executes input as an interpret me program, then does this again after the first program is done, finishes) 4. hi (nothing, first star of previous line finishes) 5. ** (same as the other two star line) 6. hi (nothing, first star of previous line finishes) 7. hi (nothing, second star of line 5 finishes, so second star of line 3 finishes, so line 2 finishes, so line one finishes) [termination]  hi (does nothing and finishes) [termination]  *hi (executes inputted program, finishes) *yo (executes inputted program, finishes) hey (nothing) [termination]  ### Sandbox How can I make this challenge more clear? I understand that this challenge is simple, but that is part of the point; it sees how small a program can be for this purpose • To make the challenge more clear, you could supply the specification for the language which has to be interpreted. It shouldn't be necessary for each answerer to search for the basic definition of the problem. – Peter Taylor Aug 3 '16 at 14:46 • @PeterTaylor, Excuse me, it's right there. An InterpretMe interpreter takes input, and runs an InterpretMe interpreter (which takes new input) as many times as "*" occurs in input. (dumb blockquotes) – Destructible Lemon Aug 3 '16 at 23:09 • Maybe if you state up front that it's a joke language that would prime the reader to not expect it to do anything useful. – Peter Taylor Aug 4 '16 at 7:19 • @PeterTaylor Thanks – Destructible Lemon Aug 4 '16 at 7:31 # I wanna be the very best... Wow, there's so many Pokemon in my Pokedex! Well, there seems too many... I wish there was some good way of sorting all of them! Can you help? Given a list of Pokemon with their stats - level and HP - and a sorting criterion, output the sorted list. An example input would be: ([["Squirtle", 2, 10], ["Charizard", 58, 140], ["Mew", 75, 160], ["Pichu", 10, 25]], "alphabetical")  As you can see, each Pokemon is shown like so: [pokemon_name, level, hp]  There are three sorting options: • "alphabetical": The Pokemon are sorted alphabetically. • If two or more Pokemon have identical names, then they are sorted by level, then HP. • "level": The Pokemon are sorted by level. • If two or more Pokemon have the same level, then they are sorted alphabetically, then by HP. • "hp": The Pokemon are sorted by HP. • If two or more Pokemon have the same HP, then they are sorted alphabetically, then by level. # Specs: • You are guaranteed that: • The hp and level of every Pokemon are integers. • The level of a Pokemon will not exceed 100. • The hp will not exceed 200. If two or more Pokemon share all stats, then they can be arranged however you like. The output will be the sorted list. This is , so shortest code in bytes wins. # Meta: • Is the challenge too easy/hard? • Any improvements to my explanation? • Could you perhaps add some test cases? Also, since you haven't mentioned it I'm assuming the input is unrestricted? (I.e. we're allowed to use an array as parameter, a comma-separated string, a list, etc. Everyone's own choice?) And one very important question, does the list potentially include all 721 Pokémon (with more incoming in generation 7..) – Kevin Cruijssen Aug 4 '16 at 12:38 • I think this challenge is pretty chameleon-y. I'm not sure if there is a dupe target floating around, but even if it isn't a dupe I'm not convinced this adds very much to the basic sorting challenges. – FryAmTheEggman Aug 4 '16 at 18:26 • @KevinCruijssen It can contain anything, really - it could contain all 721 Pokemon available, but it doesn't have to contain Pokemon at all. – clismique Aug 5 '16 at 7:58 • @DerpfacePython I know, it's just a string. My last question was kinda a sarcastic one.. :) – Kevin Cruijssen Aug 5 '16 at 8:25 ## Make a Four Color Map The Four Color Theorem states that it is possible to color any map separated into contiguous regions using only four colors such that no two adjacent regions are the same color. While the Five Color Theorem has been proven, no proof exists for only using four colors (though there have also been no counterexamples). Given an image containing white regions separated by black borders, generate a four color map. You may assume that the borders of the image are also region borders and that shared corners do not count as adjacencies. Related: Four Color Theorem # Input An image in a standard format containing white regions separated by black borders # Output Displaying or writing an image file in any standard format that contains the original image colored according to the Four Color Theorem # Examples Your colorings do not need to match mine, they just need to be valid solutions ====> ====> Note that the map of the US is not colored by state, it is colored by contiguous borders This is so shortest code wins! • Isn't the first example invalid? I see two adjacent red regions in the bottom left. – Business Cat Aug 5 '16 at 17:11 • Whoops! Thanks, I'll fix that. – theLambGoat Aug 5 '16 at 17:14 • I thought the four-color one was definitively proven a couple years ago? – AdmBorkBork Aug 5 '16 at 18:19 • It might have been, I was just going off of wikipedia. I just read the Wolfram article on it and it looks like it was proven for maps that are flat (and maybe all maps?) but I don't 100% follow it so not positive. – theLambGoat Aug 5 '16 at 18:28 • 1. The four colour theorem was proven in the 70s. 2. This is essentially a dupe of this question but with a really bad input format. – Peter Taylor Aug 5 '16 at 21:09 • Here's the relevant Wikipedia section if you're looking for more info on the proof – trichoplax Aug 6 '16 at 14:42 • The theorem was "disproved" by counterexample on some mailing list I believe. It was a joke. Someone produced a pretty complex map and claimed that it couldn't be colored with only 4 colors. I think he was just seeing if he could get people to waste time looking at it. – Liam Aug 10 '16 at 23:48 # How synchronized are my clocks? I have two clocks, A and B, and A always shows the exact time, however B is off by a certain amount of time, that I'd like to find out. (I know A and B run at the exact same speed.) I cannot read the exact time of both simultaneously, that means I can only switch back and forth and read the time sequentially. (For the sake of simplicity, both show their time as a real number (lets say hours), and each real number encodes an unique point in time.) So here is an example: B: 1, A: 3, A: 5, B: 4.5. We see because of the first two entries B: 1, A: 3 that B is behind A by at most 2 hours, and that because of the last two entries A: 5, B: 4.5 we see that B is behind A by at least half an hour. So the possible interval of how much B is off is [-2,-0.5]. ## Challenge Given a list of timestamps with their labels, return the possible interval by how much B can be off. ## Details • The list can be in any convenient format like [(timestamp, label),...] or as two lists [timestamp,...],[label,...] e.t.c • You can assume that all the readings from A are in ascending. (and the same for B) • If there is no such time interval, output something falsy. ## Testcases: (more to be added) label A B A time 1 4 5 output [-1,3] label A B B A time 1 2 5 2.5 output false  # Meta: • Should only valid cases be considered, or should there be a check for invalid ones (remove point 2 or 3 of the details?) • Should the challenge be restricted to alternating readings (ABABABABABA) or should random ones be allowed (ABBAAABABAABBBABBBBB)? Restricting to alternating readings would make it pretty much trivial. • IMO go with alternating readings – Downgoat Aug 11 '16 at 23:26 • @Downgoat But that makes it almost trivial I think... – flawr Aug 11 '16 at 23:27 • We see that B is at least two hours behind, but at most half an hour behind. I find that wording confusing. How about this? We see (B: 1, A: 3) that B is behind A by at most 2 hours, and that (A: 5, B: 4.5) B is behind A by at least half an hour. – Luis Mendo Aug 11 '16 at 23:42 • @LuisMendo Thank you, I'm going to correct that. – flawr Aug 12 '16 at 8:41 # Print a booklet I want to take a PDF document and put four pages of that document onto the front and four pages onto the back of a sheet of paper. Then I'll fold and cut that page so that I end up with a 1/4─size booklet that holds 8 pages. This would produce two folios comprising one signature.  Fold here ↓ ┌────┬────┐ │ │ │ │ │ │ ← Outer folio Cut │ │ │ here → ╞════╪════╡ │ │ │ │ │ │ ← Inner folio │ │ │ └────┴────┘  LaTeX's pdfpages package allows me to place 2x2 pages of a PDF per sheet of paper with a given page ordering. If I were to specify the option pages={2,7,4,5,8,1,6,3} to pdfpages, I would get:  Front of sheet (1) (8) Back of sheet \ / ┌────┬────┐ (7) (2) │ │ │ \ / Outer │ 2 │ 7 │ ┌────┬────┐ folio → │ │ │ │ │ │ ╞════╪════╡ │ 8 │ 1 │ ← Outer folio Inner │ │ │ │ │ │ folio → │ 4 │ 5 │ ╞════╪════╡ │ │ │ │ │ │ └────┴────┘ │ 6 │ 3 │ ← Inner folio / \ │ │ │ (3) (6) └────┴────┘ / \ (5) (4) (Numbers put in parenthesis are referring to the back of the page.)  Why do we need that strange order of numbers? So that the fronts and backs of pages line up when put into the signature. This is how you read the book:  Start here at (1) on the back. Continue to 2 on the front. │ │ End here at (8) ↓ / ┌────┬────┐ │ │ │ │ 2 │ 7 │ ← Outer folio │ │ │ └────┴────┘ │ On to (3) in inner folio │ ↓ ↑ On to (6) in outer folio │ ┌────┬────┐ │ │ │ │ 4 │ 5 │ ← Inner folio │ │ │ └────┴────┘  But that's just for two folios from one sheet of paper. What if I want to use two sheets of paper, make four folios, and still combine all of them in one signature?  Start at (1) │ │ End here at (16) ↓ │ (1) (16) (5) (12) \ / \ / ┌────┬────┐ ┌────┬────┐ │ │ │ │ │ │ Outermost → │ 2 │ 15 │ │ 6 │ 11 │ ← Folio #3 folio (#1) │ │ │ │ │ │ ╞════╪════╡ ╞════╪════╡ │ │ │ │ │ │ Folio #2 → │ 4 │ 13 │ │ 8 │ 9 │ ← Innermost │ │ │ │ │ │ folio (#4) └────┴────┘ └────┴────┘ / \ / \ (3) (14) (7) (10) Front of Front of sheet 1 sheet 2  And your LaTeX option would be: pages={2,15,4,13,16,1,14,3,6,11,8,9,12,5,10,7}  ## Objective Write a function taking an integer n of the number of pages in the final booklet (8 and 16 in the examples above) and returning a list integers (of length n and ranging from 1 to n) for the page numbers in the right order. Example: > f(8) => [2,7,4,5,8,1,6,3] > f(16) => [2,15,4,13,16,1,14,3,6,11,8,9,12,5,10,7]  Since we're dividing a sheet of paper into 4 pieces and using front and back, the input is always a multiple of 8. If the input is not a multiple of 8, the output is not defined but would prefer that it's rounded up to the next multiple of 8. • Is the code required to work for integers that don't fit and leave unused pages? Should such integers be rounded up to the next integer that fits? – trichoplax Aug 12 '16 at 11:40 • 1. I don't understand the repeated mention of US Letter. Surely this is completely independent of the paper size? 2. I don't understand the first two diagrams. It seems to me that the instructions in the first diagram give a booklet with page order 2,3,4,1, and the folds in the two diagrams can only be consistent with each other if one of the 1s is turned upside down. 3. The meaning of folio doesn't seem to be consistent between the 4-page example (which has two folios, implying that a folio is a half-sheet of paper) and the 8-page example (which has just an outer and an inner folio). – Peter Taylor Aug 12 '16 at 12:09 • I specified what to do with integers that don't fit, removed mention of US letter, and simplified the diagrams. – Caleb Paul Aug 12 '16 at 16:52 • @PeterTaylor, the first example is 8 pages (1 physical sheet of paper divided into 2 folios), the second example is 16 pages (2 physical sheets of paper divided into 4 folios). A folio is just a half sheet of paper. I cleaned up the terminology of sheet vs page in the question. – Caleb Paul Aug 12 '16 at 16:56 • Ok, I think it's clearer now, but to check that I've understood what the task is. Would the following serve as a reference implementation? Given n which is a multiple of 8, form the array [1 2 ... n-1 n]. Then while the array is non-empty, remove the first four elements and the last four elements, apply permutation [2 7 4 5 8 1 6 3] to them, and recurse on the remaining elements. – Peter Taylor Aug 12 '16 at 17:40 • Might turn into something interesting, but if you just print, cut, fold, then sort and glue, there is nothing keeping you from switching upper with lower halfs, turning half-pages around or swapping half-pages between pages. You either need to specify the exact way the paper will be combined or you should add information which solutions are acceptable. – MarLinn Aug 13 '16 at 1:20 ## Count Langford pairings A Langford pairing is a permutation of the numbers 1, 1, 2, 2, ..., n, n such that there is one number between the 1s, two numbers between the 2s, etc. E.g. (with the pairs marked) +-----------+ +---------------+ | +-----+ | | +---------+ | | | | | | | | | 5 2 8 6 2 3 5 7 4 3 6 8 1 4 1 7 | | | | | | | | | | +-------+ | | +---+ | +-------------+ | +-----------------+  If we reverse a Langford pairing then obviously we get another Langford pairing. The number of distinct Langford pairings (i.e. modulo this symmetry) for given n is OEIS sequence A014552. Write a program which takes n as either a command-line argument or on stdin and prints the number of distinct Langford pairings for that n. You may assume that the input given will be a positive integer no greater than 32. To avoid hard-coding, your program must be capable of calculating the number of Langford pairings for n=32, optionally modulo a number of your choice which is at least 230; and the only case splitting permitted for valid input is to split on the value of n % 4. To avoid brute-forcing, your program must be capable of calculating the number of Langford pairings for n=16 in less than 15 minutes on my reference machine. (TODO). The standard approach is an algebraic technique due to Mike Godfrey and works by evaluating a generating function at {-1,1}^2n, but variants such as evaluating Godfrey's generating function at {0,1}^2n and using inclusion-exclusion are also possible. The time limit is about twice the time required by my (partially optimised) reference solution, an algebraic approach in Java; a fully optimised approach in C should have a lot of slack. That gives people a trade-off in the symmetries they use, and should allow slow scripting languages to submit valid answers but at a penalty of having to spend more code on handling symmetries than faster languages. However, I'm worried that it might allow trivial modification of answers to Langford strings , so I probably need a reference implementation which works by enumeration for comparison. • Wow, that's really unhelpful. That page for A014552 has a forumla of a(n) = A176127(n)/2, and guess what the page for A176127 has? Yep, a(n) = 2 * A014552(n). :P – Doorknob Oct 8 '14 at 11:38 • @PeterTaylor could you give us some hints on optimisation? As in, the basic hacks that nearly everyone will do? – Soham Chowdhury Oct 8 '14 at 12:39 • There's this now. – Martin Ender Aug 14 '16 at 14:18 • @MartinEnder, I ran across the linked page the other day when I was tidying my bookmarks (it now 404s), but I didn't remember that this was in the sandbox. IMO the performance requirement and ability to avoid enumeration mean that it wouldn't be a dupe. May try to write a reference implementation tomorrow, since it's a public holiday here. – Peter Taylor Aug 14 '16 at 16:35 • Yeah I wasn't sure whether it would be a dupe (or whether there would be ways to avoid enumeration), but I figured you'd be the best judge of that, so I just thought I'd let you know. – Martin Ender Aug 14 '16 at 17:40 # The Coin Flop KoTH In this challenge, you start out with a stack of 100 coins, alternating between gold and silver: 1. Gold 2. Silver 3. Gold 4. Silver ... 99. Gold 100. Silver  Now, Gold, Inc. will pay you for any gold coins you can give them. Furthermore, they really like bulk shipment. If a shipment contains N coins, they will pay you N^2 for that shipment. However, you've only got 1 truck to share between you and your opponent, who has a similar contract with Silver, Inc. # Game play Each turn, the following steps occur: 1. Flip a section of coins (like pancakes) 2. Collect the top coins (of the same type) 3. Ship off the collected coins (worth N^2) ## 1. Flip: You or your opponent can each select a range to reverse. For example, if you selected the range [1,3], the following would occur: Gold Gold Silver Gold Gold -> Gold Gold Silver Silver Silver  Notice how the top stack now has 3 golds in a row, which would be worth 9. However, you only get to flip every other turn, and your opponent gets to flip on the other turns. # 2. Collect We collect all similar coins from the top of the stack, and put them in the truck: Silver Silver Gold Silver Gold  Would result in 2 Silvers being put in the truck. # 3. Ship If the truck contains gold coins, then we send it off to Gold, Inc and we get paid N^2, where N is the number of coins in the truck. (Our opponent gets paid if the truck contains silver coins) After the stack is empty, the player with the most money wins! # Sandbox questions: 1. Is this clear? 2. Does this seem interesting at all (if it isn't, please say so)? What are some interesting strategies you can come up with? 3. Is there a never-lose strategy? 4. I'm debating adding a "Freeze" as an alternative to "Flip", which would cause 2 collect/ship actions to occur. (Your opponent's turn would then be next) • Could you add tags so it's clear this is a KOTH? – Zgarb Aug 15 '16 at 15:31 • "If the truck contains gold coins, then we send it off to Gold, Inc (otherwise Silver, Inc), and we get paid" Is this correct? Earlier you said that we had a contract with Gold, Inc and the opponent with Silver, Inc, so it seems that we should be paid for gold and the opponent for silver. – Peter Taylor Aug 15 '16 at 21:02 • @PeterTaylor does that make it clearer? – Nathan Merrill Aug 15 '16 at 21:09 • Yes, thanks. Follow-up: I presume the controller will show different things to the two players so we both think we're the one collecting gold? – Peter Taylor Aug 16 '16 at 5:38 • @PeterTaylor correct. The only difference players will notice is whether or not Gold is the first coin. – Nathan Merrill Aug 16 '16 at 12:20 Still to-do: 1. Add more test cases 2. Make input requirements a little looser 3. Make output requirements looser 4. Specify that a full program is not required 5. Change the name of gem-elements maybe? 6. Come up with a title 7. Come up with a cool story I saw this as a problem over on CodeReview, here is the original question. I thought it would be fun to golf. You have discovered various rocks. Each rock is composed of various elements, and each element is represented by a lowercase letter from 'a' to 'z'. The same element can be present multiple times in a rock. An element is called a 'common-element' if it occurs at least once in each of the rocks. Given the list of rocks you have to determine how many different kinds of common-elements you have. # Input Format • Each rock is a string which consists of lowercase letters from 'a' to 'z' representing elements • You can take the strings in whatever way is easy for you (lines from STDIN, pipe delimited STDIN, array of strings as a method param, etc.) # Output Format • The number of different types of common-elements for the given list of rocks. This can be as an integer or string # Constraints • There will always be at least one rock • Each rock will always have at least one element • You do not need to make a full program (functions & methods are allowed) # Sample Input abcdde baccd eeabg  # Sample Output 2  ## Explanation Only 'a' and 'b' are common-elements since these are the only characters that occur in each of the rocks' composition. # More test cases a 0  aa 0  aa aa 1  zyxabc 0  abc def 0  abc a 1  abc ab cb 1  abc cba 3  abcdefghijklmnopqrstuvwxyz qwertyuiopasdfghjklzxcvbnm 26  defabc bfgcde chfgde gedfhi fgiejh 2  • N doesn't seem to actually be a useful input, so I'd consider making it optional. In addition, tight I/O requirements are usually frowned upon, I'd consider modifying it to allow any format that doesn't add any additional information. I'd also recommend removing the quote block, and adding at least one test case with N=1 and one where the result itszero. Good luck with your challenge and thanks for using the sandbox! :) – FryAmTheEggman Jun 23 '16 at 19:47 • Also can we take the input in the default list/array format for our language? As FryAmTheEggman, good luck with the challenge! – Blue Jun 23 '16 at 20:04 • How do I say "any format that doesn't add additional information" in a way that doesn't sound silly? Is that fine as-is? – Captain Man Aug 11 '16 at 18:36 • Nice edits, looking much better! If you want an example of a nice way to word the preamble, you could try emulating this question. I think "any reasonable format" is a fine way to say what you want, but what you have is fine, too. – FryAmTheEggman Aug 11 '16 at 19:44 • This might be fun to golf in Java, but in the languages which are predominantly used on this site nowadays it's two built-ins and something like 3 to 6 characters depending on the language, so it's actually a pretty boring question. – Peter Taylor Aug 11 '16 at 21:44 # Stratego This is a KOTH challenge based on the popular board game Stratego. # Rules Stratego is played on a 10x10 board which looks like this (starting position):  12345678910 A ********** B ********** C ********** D ********** E ..~~..~~.. F ..~~..~~.. G xxxxxxxxxx H xxxxxxxxxx I xxxxxxxxxx J xxxxxxxxxx  *: enemy piece; x: your piece, .: empty space, ~: lake There are twelve types of pieces: the flag (F), the bomb (B), the spy (S), and pieces numbered 2-10 (ten is 0). You can see the identities of your pieces, but not your opponent's. Each player starts with: • 6 bombs • 1 flag • 1 ten • 1 nine • 2 eights • 3 sevens • 4 sixes • 4 fives • 4 fours • 5 threes (miners) • 8 twos (scouts) • 1 spy A player may arrange their pieces however they wish within their starting area. The players take turns moving one piece into an adjacent square. • The bomb and flag may not move. • Twos (scouts) may move any number of squares in one direction, like a chess rook. • You may not move into a square containing one of your pieces. • If you attempt to move into a piece containing an enemy piece: • The identities of both pieces are revealed to the other player. • If both pieces are equal, they both lose. • If both pieces are numbered, the higher piece wins. • If the attacked piece is a bomb… • and the other piece is a miner, the miner wins. • otherwise, the bomb wins. • If the attacked piece is the flag, then the player owning the flag loses. • If the attacking piece is the spy… • and the defending piece is a 10, the spy wins. • otherwise, the spy loses. • If the attacked piece is the spy, it loses. • If the attacking piece won, the attacked piece is removed from the board and the attacking piece moves into its place. • If the attacked piece won, the attacking piece is removed from the board and the attacked piece remains in place. • If both pieces lose, they are both removed from the board. • A scout's move may end on an enemy piece, but it may not go over enemy pieces during its move. Play continues until one player loses their flag or is unable to move on their turn, at which point that player loses. # Protocol Bots may be written in any language that I can get to run on macOS. They will communicate with the server using newline-separated JSON on stdin/stdout. When a bot is started, it should send the following message: { "type": "start", "layout": "..." /* starting layout, as 4x10 string; last line is edge of board */ }  When it is the bot's turn, the server will send the following message: { "type": "turn", "board": "...", /* current board state, as 10x10 string; you half of the board is always on the bottom */ "yourPreviousTurn": { /* result of your previous turn; not present on your first turn */ "from": "B8", "to": "B9", /* you moved a piece from B8 to B9 */ "movedPiece": "5" /* you moved a 5 */ "attackedPiece": "8" /* the piece you attacked was an 8; only present if you attacked a piece on your last turn */, "winner": "them" /* their piece won; only present if you attacked a piece */ }, "theirPreviousTurn": { /* result of the turn they just took; not present on first turn of the game */ "from": "H8", "to": "G8", "movedPiece": "4" /* they moved a 4; only present if they attacked */ "attackedPiece": "9" /* they attacked your 9; only present if they attacked */, "winner": "you" /* your piece won; only present if they attacked */ }, "yourGraveyard": ["B", "3", ...], /* array of your pieces that have already died */ "theirGraveyard": ["7", "4", ...] /* array of their pieces that have already died */ }  You must respond with: { "type": "move", "from": "A6", "to": "A7" }  # Answering Submit your bot as a pull request to [github link added here]. You do not need to include your entire bot in the SE answer, but please include the main/interesting parts of the code; I would recommend not including the layouts that you are using so that they remain secret (not that secret, but better than nothing). I will run bots regularly and post the latest scores here. • 1. Can you give references to indicate that there is no legal issue here (with respect to copyright, trademarks, etc)? 2. Why 2 to 9 and then 0? Would it be simpler to use 1 to 9? 3. The list of starting pieces could be presented much more succinctly as a single string (BBBBBBF9...), and the combat table as a grid with columns and rows headed by B, F, etc and using one of three symbols to indicate the outcome. 4. Docker images? Are you serious? You should be trying to lower the barrier of entry, not raise it. – Peter Taylor Aug 25 '16 at 9:57 • This is a dupe of my stratego challenge.... – Rohan Jhunjhunwala Aug 25 '16 at 14:10 • meta.codegolf.stackexchange.com/a/9653/46918 – Rohan Jhunjhunwala Aug 25 '16 at 14:11 • 1. I feel that the copyright on the game is unlikely to be enforced for something this small. 2. The original game uses 2-10, so I am staying with that. 3. That would be more succinct, but less useful for understanding the game -- it would be nice not to have to analyze a table to understand things like "larger number wins." 4. Agreed. I will edit to remove the Docker requirement. – Gaelan Aug 25 '16 at 15:29 • @Peter see above – Gaelan Aug 25 '16 at 15:31 • Whether the copyright holder decides to take action or not is irrelevant: if posting this challenge would violate copyright then this site's legal terms prohibit it. (CC @RohanJhunjhunwala). – Peter Taylor Aug 25 '16 at 16:48 • @PeterTaylor game rules can not be copyrighted: copyright.gov/fls/fl108.pdf – Gaelan Aug 25 '16 at 17:09 • @PeterTaylor from what I understand, developing an AI to play a game isn't really breaching the copyright of the game holder. However I feel we should take this to meta. – Rohan Jhunjhunwala Aug 25 '16 at 17:31 • @PeterTaylor feel free to continue to discuss this here meta.codegolf.stackexchange.com/q/9925/46918 – Rohan Jhunjhunwala Aug 25 '16 at 17:35 • Gaelan, the document you link states that game rules are subject to copyright: it's the mechanics which aren't. The design elements probably extend to such matters as board layout and tile distribution: or, at least, the major Scrabble clones' owners weren't confident enough of winning against Hasbro, and changed their layouts and distributions under legal pressure. And I (and the SE legal terms) also mentioned trademarks: Stratego is a registered trademark in the US. – Peter Taylor Aug 25 '16 at 21:49 • @RohanJhunjhunwala, the AI might not be, but a king-of-the-hill doesn't work without a controller. – Peter Taylor Aug 25 '16 at 21:50 • @PeterTaylor I will rename the challenge to avoid the trademark issue. Nothing in the PDF says anything about rules being copyrighted. It says the specific wording of the rules that came with the game are copyrightable, but I wrote the rules in my own words from memory. Also, see the dupe link in the meta question. – Gaelan Aug 25 '16 at 21:57 • @Gaelan you have failed to address the issue that it is a dupe of my challenge – Rohan Jhunjhunwala Aug 25 '16 at 22:00 • @PeterTaylor sure I can edit the name of my challenge to avoid stomping on a trademark. (But from what I understand you can saw the name of a company, without infringing their trademarks) – Rohan Jhunjhunwala Aug 25 '16 at 22:01 • @RohanJhunjhunwala sorry, I didn't realize your challenge was this recent. Are you still planning on running your challenge? – Gaelan Aug 25 '16 at 22:03 # De-Parenthesize Ruby Reuben wants to start programming and golfing in Ruby. However, since he learned programming from his siblings Cecil and Emma, who program in C and ECMAScript respectively, he's developed a habit of adding parentheses to all sorts of functions when he doesn't need to. However, he can't just remove all the parentheses either! Help him by writing a short program that will remove some of the parentheses for him. ### The Challenge Given a snippet of Ruby code (you don't need to worry if it's valid code or not), apply the following rules to remove parentheses from function calls wherever possible. Whenever parentheses are removed, put a whitespace in between the function call and the arguments (even if in actual golfing practice it isn't needed, such as in the case of print"hello") For the purposes of this challenge, not all parts of Ruby need to be checked: • Variables/functions will contain alphanumerics and underscore only, and won't start with numbers. (No functions like array.slice!(1,4).include?(6), and no variables like $a)
• Blocks (curly braces after functions, or for declaring stabby-lambdas) are not present. No array.map{|i|i+1}
• Function definitions like def f(x) will not be present.
• No backslashes \ so you don't have to parse something like "\"hello\""
• No comments. (Comments in Ruby start with #.) If a # appears in code, it's going to be part of a string.

These are the only rules you need to check for:

Functions without any parameters always have their parens removed.

array.size()+array.something().length() -> array.size+array.something.length


Functions at the end of a method chain can be removed only if they are not next to an arithmetic operator.
For the purposes of this challenge, the operators used will be +, -, *, /, %.

num.parse(3,7) -> num.parse 3,7
string.gsub("this","that").count("t") -> string.gsub("this","that").count "t"
1+string.count("T") -> 1+string.count("T") # no change
1+(string.count("T")) -> 1+(string.count "T")
puts(3,8*7) -> puts 3,8*7


If a function contains another function call as its only function argument, apply the other rules to that function as well.

print(print(x.sub(a,b.to_s(16)))) -> print print x.sub a,b.to_s(16)


If a string substitution operator #{...} is present within a string (enclosed with double quotes), remove parens from the functions in accordance to the other rules.
Assume that the contents within the string substitution don't include any literal strings, including single-character "question mark" strings like ?a. This means that things like "#{"a}#{"}" or "#{?}}" do not need to be dealt with.

"hello() #{world().string(5)}" -> "hello() #{world.string 5}"
"hello() # {world()}" -> "hello() # {world()}" # no change


Might add more rules or other things in the future if people want, before it gets published of course.

Would this be a duplicate of something like Remove unnecessary parentheses? It's a similar concept but with different rules

• The "only if they are not in an expression with an arithmetic operator" part seems like it might potentially be a problem. What about 1+(string.count("T"))? Or, how about: print(foo().bar())+1? I think you may want to more aggressively remove some of these edge cases. – FryAmTheEggman Aug 19 '16 at 12:45
• @FryAmTheEggman that's a good point. I will think about how to phrase that case with parentheses to make more sense. For the second example, since the first rule says that empty parens are always removed, it'd become print(foo.bar)+1 as expected anyways. – Value Ink Aug 19 '16 at 18:40
• I think a whitelist of language constructs would be clearer than listing a lot of things that aren't allowed. – feersum Aug 28 '16 at 11:59
• @feersum I don't understand what you mean by that. Should I say something like "only alphanumerics, the dot operator ., these arithmetic operators, and the string substitution operator in strings"? – Value Ink Aug 29 '16 at 17:23
• Yes, or better some sort of grammar describing the allowed input. – feersum Aug 29 '16 at 22:36

# Shift and Sum

(I need a better title)

Write a program or function that given an input list of non-negative integers of length l, outputs the sum of all the lists of length 2*l-1 that are the input list padded with 0s to each side.

(Please suggest ways of improving this description)

For example, with the input [1,2,3]:

[1,2,3,0,0]+
[0,1,2,3,0]+
[0,0,1,2,3]=
[1,3,6,5,3]


More test cases:

[1]->[1]
[2,1]->[2,3,1]
[1,0,1]->[1,1,2,1,1]
[0,1,0]->[0,1,1,1,0]
[10,20,30]->[10,30,60,50,30]
[0,0,0,0,0,0]->[0,0,0,0,0,0,0,0,0,0,0]


You may take input in any reasonable format. If you have any questions about whether an input form is reasonable, ask about it in the comments.

• In other words, convolution [inserts dup] – Leaky Nun Aug 31 '16 at 1:42
• Do all the inputs consist of lists of integers 0-9, or can they be greater/negative? – Theo Aug 31 '16 at 1:42
• @Theo I was thinking they would be lists of non-negative integers. I will clarify that. – DanTheMan Aug 31 '16 at 1:47
• codegolf.stackexchange.com/q/80030/194 – Peter Taylor Aug 31 '16 at 7:38

# End the tabs versus space war

So, there has been a great deal of debate of whether to use tabs or spaces to indent/format code. Can you help the university settle the dispute, by going to an incredibly crazy unique method of formatting.

Your job is to write a full program or function which expands all tabs into four spaces. And then replaces a run of n leading spaces with "/(n-2 *'s)/". You will receive input over multiple lines in any reasonable format (single string array of strings for each new line. Columnar array etc.)

Sample input shamelessly stolen. Note that tabs get automagically expanded to four spaces on SE, but you must handle tabs as well.

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
Not zero so multiply by 256 again to get 65536
[>++++<-]>[<++++++++>-]<[>++++++++<-]
+>[>
# Print "32"
++++++++++[>+++++<-]>+.-.[-]<
<[-]<->] <[>>
# Print "16"
+++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
# Print "8"
++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
this is preceded by a tab
two tabs
three tabs etcetera!


Sample output

Calculate the value 256 and test if it's zero
If the interpreter errors on overflow this is where it'll happen
++++++++[>++++++++<-]>[<++++>-]
+<[>-<
/**/Not zero so multiply by 256 again to get 65536
/**/[>++++<-]>[<++++++++>-]<[>++++++++<-]
/**/+>[>
/******/# Print "32"
/******/++++++++++[>+++++<-]>+.-.[-]<
/**/<[-]<->] <[>>
/******/# Print "16"
/******/+++++++[>+++++++<-]>.+++++.[-]<
<<-]] >[>
/**/# Print "8"
/**/++++++++[>+++++++<-]>.[-]<
<-]<
# Print " bit cells\n"
+++++++++++[>+++>+++++++++>+++++++++>+<<<<-]>-.>-.+++++++.+++++++++++.<.
>>.++.+++++++..<-.>>-
Clean up used cells.
[[-]<]l
/**/this is preceded by a tab
/******/two tabs
/**********/three tabs etcetera!


Because the university needs space to download both Vim and Emacs. You are alloted very little storage for your code. Therefore this is and the shortest code wins.

### Disclaimer

This "excellent" formatting strategy came courtesy of Geobits, and is reproduced with his permission. No programmers were harmed during the production of this challenge.

• Disclaimer: By using this formatting, you hereby absolve Geobits of any liability for any injuries (intentional or otherwise) or damages you may receive as a result. Void where prohibited. – Geobits Aug 31 '16 at 4:00
• Also, do only leading spaces/tabs get replaced? – Geobits Aug 31 '16 at 4:03
• What does "expands all tabs into four space*" mean? Is it a straight replacement à la codegolf.stackexchange.com/q/57462/194 or does it mean expanding to tab stops every 4 chars à la codegolf.stackexchange.com/q/18960/194 ? – Peter Taylor Aug 31 '16 at 7:32
• @PeterTaylor essentially line.repaceAll("\t"," "); – Rohan Jhunjhunwala Aug 31 '16 at 12:07
• So all tabs get replaced by spaces, and then only leading spaces get replaced by "comments"? – Geobits Aug 31 '16 at 13:45
• @Geobits yes that is a very clear way of putting it. – Rohan Jhunjhunwala Aug 31 '16 at 15:22
• this is genius, I should start using it. – Maltysen Aug 31 '16 at 17:55
• You should delete this. now that it's been posted. – James Sep 2 '16 at 0:09

## What is my birthday?

In the system of surreal numbers, every number has a birthday, which is used to resolve ties in the case of there being more than one surreal number that would otherwise satisfy an equation.

The very first surreal number to be created is zero, written as {|}. Its birthday is therefore zero. Having created zero, the next two surreal numbers to be created are 1 and -1. Their birthdays are therefore both 1.

Each subsequent day brings in twice as many surreal numbers as the previous day: 2ⁿ-2 numbers are obtained by taking the averages of all the consecutive pairs from all previous days, with the first and last numbers simply incrementing in absolute value. For example, on the second day, the previous surreal numbers are -1, 0 and 1, giving averages of -½ and ½, to which we also add -2 and 2, whilst on the third day the new numbers are -3, -1½, -¾, -¼, ¼, ¾, 1½ and 3.

As you can see, all finite floating-point representations have a finite birthday. (Most real numbers have an infinite binary fraction and therefore an infinite birthday). Your task is to write a program or function that outputs the birthday for a given floating-point number (using your native floating-point format). Although the birthday is always an integer, you can return it as an integer valued floating-point number if you prefer (e.g. if you don't have an unlimited integer type). Test cases:

Number  Birthday
1        1
0.5      2
-21       21
6.5      8
-7.9375  12


This is , so the shortest program wins.

• Could you perhaps please add how the number generation process works? – Sp3000 Sep 2 '16 at 11:13
• @Sp3000 The line beginning "In general" was supposed to explain that, although there was some spurious text on it that you may have found confusing. – Neil Sep 2 '16 at 11:31
• Hmm right, I see. Sorry it took me a while to get what it meant - maybe a quick example, e.g. saying the third day takes averages from 2, 1, ½, 0, -½, -1, -2? (to drive home the "all previous birthdays" part). But otherwise I think this looks pretty good. – Sp3000 Sep 2 '16 at 14:59
• Maybe you should give more examples from Knuth because, for instance, from your current explanation it is unclear why 1/3 should have a birthday of ω: it is not a finite sum of dyadic rationals. Or better give example inputs and expected outputs. – Andreï Kostyrka Sep 3 '16 at 1:10
• Consider adding these test cases: Input: 1, 0.5, -21, 6.5, -7.9375 and Output: 1, 2, 21, 8, 12. – Andreï Kostyrka Sep 3 '16 at 1:56

# Handwriting Recognition

I made a similar suggestion a month or so back which was deemed to be too similar to an existing one, so I've added something along the lines of a kolmogorov-complexity requirement.

The MNIST dataset is a series of handwritten digits used as a standard testbed for machine learning, pattern recognition techniques. Each image is of a single digit, 0-9; as a 28x28 pixel grayscale matrix with values from 0-255.

The challenge is to create a classifier for MNIST that scores an Error Rate of less than [TBD] in the least number of bytes possible.

Your program must take a 784 element long array in whatever format is applicable for your language representing a single image and return a number between 0 and 9, guessing what the number is.

For example, the input for the first digit might be:

[  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  3, 18, 18, 18,126,136,175, 26,166,255,247,127,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0, 30, 36, 94,154,170,253,253,253,253,253,225,172,253,242,195, 64,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0, 49,238,253,253,253,253,253,253,253,253,251, 93, 82, 82, 56, 39,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0, 18,219,253,253,253,253,253,198,182,247,241,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0, 80,156,107,253,253,205, 11,  0, 43,154,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0, 14,  1,154,253, 90,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,139,253,190,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 11,190,253, 70,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 35,241,225,160,108,  1,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 81,240,253,253,119, 25,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 45,186,253,253,150, 27,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 16, 93,252,253,187,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,249,253,249, 64,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 46,130,183,253,253,207,  2,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 39,148,229,253,253,253,250,182,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0, 24,114,221,253,253,253,253,201, 78,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0, 23, 66,213,253,253,253,253,198, 81,  2,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0, 18,171,219,253,253,253,253,195, 80,  9,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0, 55,172,226,253,253,253,253,244,133, 11,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,136,253,253,253,212,135,132, 16,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0]


Each algorithm will be tested over a set of 200 images and are expected to get [TBD]/200 correct.

Of course, when developing any good classifier, you need to test how well it works with a completely unknown sample. The twist of the challenge, these are the 200 images I am going to test with right here: (a link to 200 images and their correct labels). You only need to make sure you can classify at least [TBD]/200 of these, your algorithm won't be run on anything else. As such, this can be considered a kolmogorov complexity challenge with an acceptable error rate.

## Conditions:

• This is code golf. The shortest piece of code that meets the criteria wins.
• The code must take a provided 784 element long input and attempt to classify it.
• Testing will take place on my computer at 12pm AEST on Saturday the (date two weeks after the competition is published). I will run each classifier over the published set of 200 images. To be considered, it must correctly classify [TBD]/200 of them. If I can't get your code to run, it wont be counted, so help with loading the images in your language would be appreciated.
• Standard loopholes are not permitted.

# Questions for Sandbox

• Overall thoughts on the challenge?
• Any ideas on a good cutoff for the classifier? I was thinking around 60% correct. Very low when compared to existing solutions to MNIST, but should promote good code golfing. I was going to have a go at it myself to see what I could reasonably achieve.
• Does the testing clause make sense? Is it reasonable? Should I put a limit on the languages so I know I'll be able to run them?
• Since barrier to entry is a bit high (knowing how to get hold of the images, possibly some ML experience), is there anything extra I should do to make it easier to start the challenge.
• This is a modification of my first suggestion for a challenge, is there anything I'm missing?
• I recommend a time limit, especially if you intend to test them yourself. It can be generous, but without one then the requirement to golf will naturally give very long run times which you may not wish to commit your computer to... – trichoplax Oct 18 '16 at 12:09
• Do submissions need to be deterministic? That is, should the results be identical each run? – trichoplax Oct 18 '16 at 12:22
• For choosing the maximum error rate, think about what kinds of approaches you want to see. For a sufficiently high error rate, it may be possible to look only at a small number of pixels and ignore most of the image. If you want this kind of approach, try to choose an error rate that makes it challenging but possible. If you prefer more complex approaches, the error rate will need to be set a little lower. – trichoplax Oct 18 '16 at 12:33

# Classify Alternating Permutations

An alternating permutation of [1, 2, 3, ..., n] is an arrangement such that each element is either greater than its previous and greater than the next, meaning p[i-1] < p[i] > p[i+1] or lesser than the previous and lesser than the next, meaning p[i-1] > p[i] < p[i+1]. In other words, this means that each run of three consecutive elements should never be strictly increasing or decreasing. There is a further distinction that an alternating permutation can be either UP or DOWN. For UP, this means that the alternating permutation begins with the first element being less than the second, and the opposite is true for DOWN. For example, there are 4! = 24 permutations of [1, 2, 3, 4]

1 2 3 4
1 2 4 3
1 3 2 4  Alternating UP since 1 < 3 > 2 < 4
1 3 4 2
1 4 2 3  Alternating UP since 1 < 4 > 2 < 3
1 4 3 2
2 1 3 4
2 1 4 3  Alternating DOWN since 2 > 1 < 4 > 3
2 3 1 4  Alternating UP since 2 < 3 > 1 < 4
2 3 4 1
2 4 1 3  Alternating UP since 2 < 4 > 1 < 3
2 4 3 1
3 1 2 4
3 1 4 2  Alternating DOWN since 3 > 1 < 4 > 2
3 2 1 4
3 2 4 1  Alternating DOWN since 3 > 2 < 4 > 1
3 4 1 2  Alternating UP since 3 < 4 > 1 < 3
3 4 2 1
4 1 2 3
4 1 3 2  Alternating DOWN since 4 > 1 < 3 > 2
4 2 1 3
4 2 3 1  Alternating DOWN since 4 > 2 < 3 > 1
4 3 1 2
4 3 2 1


The permutations left unmarked are NOT alternating.

Your goal is take a permutation and output whether it is

• alternating UP
• NOT alternating
• alternating DOWN

## Rules

• This is so the shortest code wins.
• You are allowed to modify the input be 0-indexed, 1-indexed, or a permutation of the English alphabet abcdefghijklmnopqrstuvwxyz in uppercase or lowercase.
• The length of the input will be between 2 and 26.
• You are allowed to choose your own output to represent the three classes but you must state what they are in your submission.

## Test Cases

1 2  UP
2 1  DOWN
1 2 3  NOT
1 3 2  UP
2 1 3  DOWN
2 3 1  UP
3 1 2  DOWN
3 2 1  NOT

• The phrase "each element is greater than or less than the previous element" is not very clear (arguably, it just means that consecutive elements are distinct, which always holds in a permutation). I suggest something like "doesn't contain an increasing or decreasing run of three consecutive numbers", and then you can clarify that the permutation alternates between rising and falling pairs. – Zgarb Oct 20 '16 at 10:20
• @Zgarb I've tried to clarify the definition a bit more – miles Oct 20 '16 at 11:53
• Isn't "each element is either greater than its previous and lesser than the next or lesser than the previous and greater than the next" the exact opposite of what an alternating permutation is? It should be either greater than both the previous and the next, or lesser than both. – Emigna Oct 20 '16 at 13:11
• @Emigna Thanks, I got it backwards. – miles Oct 20 '16 at 18:13
• Can I adopt this abandoned proposal? – programmer5000 Jun 9 '17 at 12:38

Note: this is an attempt to fix up a currently closed question by someone else so that they can rescue it, not an attempt to steal their question.

When implementing an algorithm for correcting aliased measurement data, I hit the need to implement following function. The function takes input bitstring on the left, and should produce the integer and list on the right:

               1 =>   1, [0]
10 =>   1, [0]
100 =>   1, [0]
101 =>   2, [0, 1]
1000 =>   1, [0]
1011 =>   3, [0, 2, 1]
... more test cases at end of post ...


Note that it is guaranteed that the input bitstring is aperiodic.

## Physical background

Consider a digital system that changes its output every N clock cycles. A measurement system doesn't know N, so it reads the output every M cycles, where M <= N.

Now some of the measurement samples will be identical to the previous ones, which is represented as 0 in the bitstring and the sample is discarded. When the value changes, 1 is added to the bitstring and the sample is stored.

However, the timestamp of the sample will be too late. The numbers in the output array represent a correction that must be applied. The output format expresses this correction as a fraction of the sample interval, where the standalone integer is the denominator and the array contains the numerators.

As an example with N = 4 and M = 3:

Clock cycle     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9
Output          A A A A B B B B C C C C D D D D E E E E
Measurement     A     A     B     C     D     D     E
Bitstring       1     0     1     1     1     0     1
|---------------------| This is the period of the aliasing

Timestamp       |       |---|   |-|     |       |---|
correction    0          2/3   1/3    0          2/3


With this example the input would be 1011 and the output would be 3, [0, 2, 1].

## Here are a few observations to get you started:

• The input sequence always begins with 1 and is aperiodic.
• The output sequence length always equals the number of 1-bits in the input.
• The output sequence array is always a permutation of 0 to M-1 and begins with 0.

## Test cases:

               1 =>   1, [0]
10 =>   1, [0]
100 =>   1, [0]
101 =>   2, [0, 1]
1000 =>   1, [0]
1011 =>   3, [0, 2, 1]
10000 =>   1, [0]
10010 =>   2, [0, 1]
10101 =>   3, [0, 1, 2]
10111 =>   4, [0, 3, 2, 1]
100000 =>   1, [0]
101111 =>   5, [0, 4, 3, 2, 1]
1000000 =>   1, [0]
1000100 =>   2, [0, 1]
1001010 =>   3, [0, 2, 1]
1010101 =>   4, [0, 1, 2, 3]
1011011 =>   5, [0, 3, 1, 4, 2]
1011111 =>   6, [0, 5, 4, 3, 2, 1]
10000000 =>   1, [0]
10010010 =>   3, [0, 1, 2]
10101101 =>   5, [0, 2, 4, 1, 3]
10111111 =>   7, [0, 6, 5, 4, 3, 2, 1]
100000000 =>   1, [0]
100001000 =>   2, [0, 1]
100101010 =>   4, [0, 3, 2, 1]
101010101 =>   5, [0, 1, 2, 3, 4]
101110111 =>   7, [0, 5, 3, 1, 6, 4, 2]
101111111 =>   8, [0, 7, 6, 5, 4, 3, 2, 1]
1000000000 =>   1, [0]
1000100100 =>   3, [0, 2, 1]
1011011011 =>   7, [0, 4, 1, 5, 2, 6, 3]
1011111111 =>   9, [0, 8, 7, 6, 5, 4, 3, 2, 1]
10000000000 =>   1, [0]
10000010000 =>   2, [0, 1]
10001000100 =>   3, [0, 1, 2]
10010010010 =>   4, [0, 1, 2, 3]
10010101010 =>   5, [0, 4, 3, 2, 1]
10101010101 =>   6, [0, 1, 2, 3, 4, 5]
10101101101 =>   7, [0, 3, 6, 2, 5, 1, 4]
10110111011 =>   8, [0, 5, 2, 7, 4, 1, 6, 3]
10111101111 =>   9, [0, 7, 5, 3, 1, 8, 6, 4, 2]
10111111111 =>  10, [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]
100101001010 =>   5, [0, 3, 1, 4, 2]
101010110101 =>   7, [0, 2, 4, 6, 1, 3, 5]
101111111111 =>  11, [0, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
111111111111 =>  13, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
1000000100000 =>   2, [0, 1]
1000010001000 =>   3, [0, 2, 1]
1000100100100 =>   4, [0, 3, 2, 1]
1001001010010 =>   5, [0, 2, 4, 1, 3]
1001010101010 =>   6, [0, 5, 4, 3, 2, 1]
1010101010101 =>   7, [0, 1, 2, 3, 4, 5, 6]
1010110101101 =>   8, [0, 3, 6, 1, 4, 7, 2, 5]
1011011011011 =>   9, [0, 5, 1, 6, 2, 7, 3, 8, 4]
1011101110111 =>  10, [0, 7, 4, 1, 8, 5, 2, 9, 6, 3]
1011111011111 =>  11, [0, 9, 7, 5, 3, 1, 10, 8, 6, 4, 2]
1011111111111 =>  12, [0, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
10000100001000 =>   3, [0, 1, 2]
10010010010010 =>   5, [0, 1, 2, 3, 4]
10101101101101 =>   9, [0, 4, 8, 3, 7, 2, 6, 1, 5]
10111011110111 =>  11, [0, 8, 5, 2, 10, 7, 4, 1, 9, 6, 3]
10111111111111 =>  13, [0, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
100000001000000 =>   2, [0, 1]
100010001000100 =>   4, [0, 1, 2, 3]
100101010101010 =>   7, [0, 6, 5, 4, 3, 2, 1]
101010101010101 =>   8, [0, 1, 2, 3, 4, 5, 6, 7]
101101110111011 =>  11, [0, 7, 3, 10, 6, 2, 9, 5, 1, 8, 4]
101111110111111 =>  13, [0, 11, 9, 7, 5, 3, 1, 12, 10, 8, 6, 4, 2]
101111111111111 =>  14, [0, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]


# Finding isomorphic elementary cellular automata

An elementary cellular automaton is a one-dimensional cellular automaton with two possible states (labeled 0 and 1) and calculates the following state based on a cell and its two immediate neighbors. Each elementary cellular automaton has a rule attached to it that specifies the resulting state for each of the configurations of a cell and its immediate neighbors.

The most common scheme for numbering these rules being the Wolfram code, where we assign each rule a number from 0 to 255 which has become standard. Each possible current configuration is written in order, 111, 110, ..., 001, 000, and the resulting state for each of these configurations is written in the same order and interpreted as the binary representation of an integer. This number is taken to be the rule number of the automaton.

As an example, we look at rule 110:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      0    1    1    0    1    1    1    0


Converting 01101110 back to decimal gives us 110.

Not all rules are equal, of course. Of the 256 possible rules, many of these rules are trivially equivalent to each other up to a simple transformation of the underlying geometry. Each rule will have three isomorphic rules based on three transformations, though sometimes a rule will be isomorphic to itself under a particular transformation.

The first such transformation is reflection through a vertical axis and the result of applying this transformation to a given rule is called the mirrored rule. These rules will exhibit the same behavior up to reflection through a vertical axis, and so are equivalent in a computational sense.

For example, if the definition of rule 110 is reflected through a vertical line, the following rule (rule 124) is obtained:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      0    1    1    1    1    1    0    0


We swap only those cell configurations that are different when reflected through a vertical axis. The result of 110 is swapped with the result of 011, and the result of 100 is swapped with the result of 001. Everything else remains in place, as they are symmetrical.

The second such transformation is to exchange the roles of 0 and 1 in the definition. The result of applying this transformation to a given rule is called the complementary rule. For example, if this transformation is applied to rule 110, we get the following rule:

Cell configuration  000  001  010  011  100  101  110  111
Resulting state      1    0    0    1    0    0    0    1


and, after reordering, we discover that this is rule 137:

Cell configuration  111  110  101  100  011  010  001  000
Resulting state      1    0    0    0    1    0    0    1


Finally, the previous two transformations can be applied successively to a rule to obtain the mirrored complementary rule. For example, the mirrored complementary rule of rule 110 is rule 193.

Of the 256 elementary cellular automata, there are 88 which are inequivalent under these transformations.

The challenge

• Your task is given an input rule number, determine which elementary cellular automata are isomorphic under these rules.
• The output should be a list (or equivalent) that represents:
• The smallest Wolfram rule that is isomorphic to the input,
• Its mirrored rule,
• Its complementary rule, and
• Its mirrored complementary rule.
• The output list may be reordered, though it should always be clear which rule is the smallest, the mirrored rule, and so on. Just sorting the list will not help here.
• This is code golf. Smallest number of bytes wins.

As always, if this challenge needs clarification or correction, let me know. Good luck and good golfing!

Test cases

All of the following test cases have the format [smallest, mirrored, complementary, mirrored complementary]:

110
[110, 124, 137, 193]

232
[232, 232, 232, 232]

0
[0, 0, 255, 255]

16
[2, 16, 191, 247]

42
[42, 112, 171, 241]

144
[130, 144, 190, 246]


# Sandbox questions

• Can the specification be clearer or shorter?
• Should I change this challenge from code golf to some other scoring system?
• Should the input be different and challenge changed? If so, which of the following input systems should it be:
• The input that is currently used: a single rule number, and the challenge is changed to only finding the isomorphisms.
• The number of states of the automaton, where finding the complementary rules would be more complex (for 2 states, only two possible complements; for 3 states, six complements are possible). This would extend the definition of both the Wolfram code and the cellular automata.
• Any other suggestions?
• Wouldn't this be a kind of kolmogorov-complexity challenge, considering the fixed output? – LegionMammal978 Oct 22 '16 at 12:34
• @LegionMammal978 Nuts, you're right. Well, as the "Sandbox questions" section asks, what should the input be, in your opinion? – Sherlock9 Oct 22 '16 at 12:36
• Perhaps you could input a rule number, and the program should find the smallest isomorphic rule and then output its four-element list. – LegionMammal978 Oct 22 '16 at 12:39
• @LegionMammal978 Seems reasonable. I'd still like a challenge where you have to find the four-element list for all combinations, but perhaps that can be a sequel. I'll edit the challenge. – Sherlock9 Oct 22 '16 at 12:40
• Surely reflection through a vertical axis is reflection horizontally, not vertically? – Peter Taylor Oct 22 '16 at 18:33
• @PeterTaylor Thanks! Any other corrections or suggestions? – Sherlock9 Oct 22 '16 at 20:35
• That was the only thing I noticed. – Peter Taylor Oct 22 '16 at 21:31

## Permutation-Tolerant Hello World

Inspired by Fault-Tolerant Hello World (a.k.a. the Interview).

Write a program that prints Hello World. Sounds easy, right? Ok, lets challenge up a bit : your (real) task is to maximum the number of permutations of the characters of your code that produce a code that when executed prints Hello World as well.

Hmm, I even got myself confused with that last sentence, so let's see an example :

Consider the following code (it's good enough to understand the principle, but as I'll explain later, the score of such a code will be pretty low) :
(it's Perl code, and if you don't trust me when I say it works, you can run it with perl -e 'code' in your terminal)

print+("Hello World")


When ran, it prints Hello World. Well, the following permutations of the code also print Hello World :

+(print"Hello World")
+print("Hello World")
(print+"Hello World")
()+print"Hello World"


Note that only permutations that produce a code that differs from the previous ones should be considered. For instance, the original code where the two l have been swapped isn't a valid permutation.

### Scoring

The score of your solution is the number of bytes of your code divided by the number of valid permutations. Lowest score wins. In case of draw, the earliest solution wins.
For instance, my example above was 21 bytes long, and had 5 valid permutations (note that it includes the original code), so its score is 21/5 = 4.2.

### For the sandbox

(1- Does it sound like a nice challenge?
2- Is it clear? )

3- I don't really what tags to add...

4- I'm not sure about the scoring method. In particular, I wonder if just adding useless stuff around the "print hello world" part of the program (no matter the language) might allow a lot of permutations to be valid with some languages.
I'd like the code where all permutations are valid and that is the longest possible to win. And I'm not sure my scoring method will produce such results.

5- Is a "print hello world" program the more relevant? Actually I think that the code could do anything : calculating oeis sequence, drawing rectangles or whatever, as long as all the permutations produces the same behavior. But then some people might play on internal behavior of languages such as "by default, this language prints 1", so every permutation of any source will print 1, or stuffs like this... Any thoughts?

6- I thought about making this challenge harder by actually changing "as much permutations as possible should be valid" to "all permutations should be valid". This will of course prevent a lot of languages to compete, but might result in creative and nice answers.

• If I've read this challenge correctly, Unary is going to win with (astronomical number) divided by (astronomical number factorial). Of course, this could still be a good challenge in other languages regardless, but the scoring as is means that it's beneficial to pad the program as long as possible since the denominator grows factorially compared to the linear numerator - so yeah I think a different scoring method might be necessary (no good ideas off the top of my head though) – Sp3000 Oct 24 '16 at 23:07
• @Sp3000 Thanks for your comment. I think that this sentence Note that only permutations that produce a code that differs from the previous ones should be considered (which I wrote right after the examples) will prevent Unary to win since it will have 0 valid permutations. – Dada Oct 25 '16 at 7:30
• Oh right, jumped the gun and missed that sentence. In that case I think you can use Lenguage instead? (since it's basically Unary but you can choose the chars) – Sp3000 Oct 25 '16 at 10:49
• Something like print"Hello World";123456789123456789 still produces a huge number of permutations. – xnor Oct 25 '16 at 17:16
• @xnor indeed. I was worried (cf question 4 for the sandbox) that something like that could be possible, and it obviously is. So ask for all the possible permutations to be valid would be a better challenge? Or should I just drop that challenge? – Dada Oct 25 '16 at 17:18
• If using a language with nops, [hello world program][arbitrary number of nops] will be even worse than xnors example – Destructible Lemon Oct 26 '16 at 23:52

# Display an xkcd

xkcd is everyone's favorite webcomic, and you will be writing a program that will bring a little bit more humor to us all.
Your objective in this challenge is to write a program which will take a number as input and display that xkcd and its alt-text (mousover text).

## Input

Your program will take an integer as input and display that xkcd: for example, an input of 1500 should display the comic "Upside-Down Map" at xkcd.com/1500, and then either print its alt-text to the console or display it with the image.

Due to their proximity across the channel, there's long been tension between North Korea and the United Kingdom of Great Britain and Southern Ireland.

Your program should also be able to function without any input, and perform the same task for the most recent xkcd found at xkcd.com, and it should always display the most recent one even when a new one goes up.

You do not have to get the image directly from xkcd.com, you can use another database as long as it is up-to-date and already existed before this challenge went up.

You may not display the entire webpage in an iframe or similar.

You can handle the case that there isn't an image for a particular comic (i.e. it is interactive or the program was passed a number greater than the amount of comics that have been released) in any reasonable way you wish, including throwing an exception, or printing out an at least single-character string, as long as it somehow signifies to the user that there isn't an image for that input.

This is a challenge, so the fewest bytes wins!

• I think this is probably a duplicate of codegolf.stackexchange.com/q/91847/194 – Peter Taylor Oct 25 '16 at 18:29
• @PeterTaylor It's similar, however I think that it's different enough to warrant it's own question. That puzzle required the creation of a bot that will display any new xkcd that comes up, this one just displays one, but it can be any requested one. In addition, my puzzle also requires the title text to be displayed. – Pavel Oct 25 '16 at 19:23

## Killer Sudoku Pro suggestions

Regular Sudoku is just about creating a enhanced Latin square and features no arithmetic on the digits 1-9 which are traditionally used.

Killer Sudoku goes further: the puzzle is tiled with polyominoes which are labelled with the sum of the cells which they cover. Additionally, no polyomino may cover two cells with the same digit, even though those digits would otherwise have been legal because they are not in the same row, column or square. It is therefore helpful to be aware of the inverse relationship: given a quantity of cells and a sum, calculate the possible values of the cells. This is also useful for solving Kakuro, which also features sums of distinct digits.

Killer Sudoku Pro goes one further step: rather than being the sum of the cells, any of the four basic operations may be used. The digits in the cells must then satisfy that basic operation.

Given a target, operator and number of cells, I would like you write a program or function to output sets of distinct digits that satisfy the arithmetic expression. To minimise the necessary output I only want distinct combinations of digits, rather than all the potential permutations. (Some puzzle creators will not allow all the permutations for subtraction and division, so taking that into account would unnecessarily complicate the question.)

Examples (example input format: target, operator, (number of cells); output format: answers " or "-separated, digits operator-separated in descending order):

14+(4) -> 8+3+2+1 or 7+4+2+1 or 6+5+2+1 or 6+4+3+1 or 5+4+3+2
4-(3) -> 9-4-1 or 9-3-2 or 8-3-1 or 7-2-1
24×(3) -> 8×3×1 or 6×4×1 or 4×3×2
2÷(2) -> 8÷4 or 6÷3 or 4÷2 or 2÷1


I/O may be in any reasonable format as long as it is clear what is going on, so you can't encode the operations as specific integers, although using * and / or their Unicode code points instead is OK, and answers must use a different separator to the digits in each answer.

This is , so the shortest solution in bytes wins.

• Could be worth noting that the only numbers to be considered are 1-9 (or you could add a third input for 1-N) – Jonathan Allan Oct 31 '16 at 11:23
• @JonathanAllan I didn't realise 10 was a digit, but I guess I should specifically exclude 0. – Neil Oct 31 '16 at 12:57
• Oh, I didn't notice "digit" :) – Jonathan Allan Oct 31 '16 at 12:59
• I find the sentence begining "Some puzzle creators allow the digits from the polyomino to be used in any order" to be odd to the point of disruptive. It presupposes a "correct" order to the elements of the polyomino which isn't obvious, and the logical connection is weak. I suggest rewriting it along the lines of "You should only output one representative suggestion for each distinct set of digits; so e.g. one but not both of 9-4-1 and 9-1-4", possibly with a footnote to discuss variations between puzzle setters in whether order is significant. – Peter Taylor Oct 31 '16 at 21:48
• @PeterTaylor The justification is only 9-4-1 and 9-1-4 actually evaluate to 4, so some creators will only use 4- for those two permutations, but I decided the question needed editing anyway. – Neil Oct 31 '16 at 22:36
• My point about permutations was that if the polyomino is e.g. the X pentomino then the "natural" order of the cells is up for debate. But I think the new wording side-steps that concern. – Peter Taylor Nov 1 '16 at 8:03

# Cryptographically secure favicon.

Create a cryptographically secure program which will take a string of up to 24 characters and create an image such that differing inputs can be "easily" distinguished visually. The goal being that the end image is visually appealling, and it is impossible to reverse engineer the string.

The challenge

• Create a program or function which takes an input string and output an image in any desired format.

• Pick a secret password and post an image generated with that password along with your submission code.

• Optionally post some sample inputs and outputs.

OR

• Try to post someone else's password (or just any existing collision with that password).

The scoring

• Out of the posts whose password has not been cracked the post with the most upvotes after an arbitrary time period set sometime in the significant future.

Voters are encouraged to vote based on ingenuity and aesthetic appeal, but can vote for whatever posts they like.

• This is essentially the same as codegolf.stackexchange.com/q/25443/194 and codegolf.stackexchange.com/q/95836/194 – Peter Taylor Oct 29 '16 at 21:32
• @PeterTaylor I think this challenge is fundamentally different in that the format of the output is not fixed, and the method of encoding the image should be interested. – Rohan Jhunjhunwala Oct 30 '16 at 4:05
• To be clear, unlike those two questions, the answers of this question should usually output visually distinguishable images for different secrets, instead of – jimmy23013 Oct 31 '16 at 12:40
• I'd call this too broad. On top of hashing, find a pleasing way to represent it is largely a question of art and aesthetics. Having different outputs be visually distinguishable happens is easy if the hash function already brings close inputs to far outputs. – xnor Nov 2 '16 at 3:56
• I have to agree with xnor here, as stated, this is too broad. However, I think the idea is interesting, although there will always be the issue of defining what cryptography is "too good" (and thereby already disallowed). Also, it might be that the good essence of this challenge is completely covered by the links from Peter – Liam Nov 3 '16 at 1:00
• @xnor we have had "art"challenges throughot the graphical output tag. – Rohan Jhunjhunwala Nov 3 '16 at 10:32