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

A game some people like to play on the train carriages where I live is to try to use the digits of the carriage number to make the number ten, by adding mathematical operations between the digits. For example, given the number 7392, you can make ten with 7 * 3 - 9 - 2 = 10.

You can split the digits how you want E.g. 5646 -> 56 - 46 = 10, however you cannot change the order of digits. In this challenge, you are also limited to using only the following characters.

• Brackets, ()
• Minus, -
• Plus, +
• Times, × or *
• Divide, ÷ or /

The minus sign can be used for both subtraction and making numbers negative (e.g. -2 * 4 + 9 + 9). Operations are done in the standard order of operations.

### INPUT

Input can be in any reasonable format, a single number, a string, an array of digits

### OUTPUT

Your program must output a human readable solution, if one exists. If there is no solution, it must output nothing.

Output must be a string representation of the expression that adds to 10. You do not need to include spaces (but you can if you want), and you can have extraneous brackets.

This is , so the shortest code in bytes wins

### Sandbox

I haven't posted on ppgc before, so any feedback would be helpful!

# Polyglot OEIS code-challengepolyglot

Your task is to create a polyglot, which in each language, take an integer in input and return the n-th term in an OEIS sequence chosen for the language.

## Rules

• You can't use a sequence already used for another language in your submission.
• You must use 2+ languages.
• You can't use a linear sequence.

## Scoring

The score is calculated as length / num_languages³.

• Could you give some examples? – user41805 Dec 24 '16 at 11:39
• This is probably not very interesting, as there are many trivial sequences, such as oeis.org/A000012 or even non-constant output ones: oeis.org/A000027 – flawr Dec 24 '16 at 14:34
• No linear sequences? So, you can't do something like 2x+1? – FlipTack Dec 24 '16 at 14:42
• @Flp.Tkc No, you can't. – TuxCrafting Dec 24 '16 at 14:45
• Then I can use x^2 (again quite trivial) – user41805 Dec 24 '16 at 14:59
• @KritixiLithos Quite trivial in some languages, but already harder than a cat program – TuxCrafting Dec 24 '16 at 15:03

# Implement ALL of OEIS!

...well, not quite all of it.

Your job is to implement as many OEIS sequences as you can in 50 bytes. You are to write a single program that takes an integer k as input and outputs An(k) for all sequence numbers n implemented. You may write a function or program to do this. Here are some more rules:

1. Each sequence should work at least until the end of the sequence on OEIS.
2. You may not implement two sequences that are the same.
3. You do not have to start where the OEIS sequence starts. However, this subsequence cannot be the same as another sequence you have implemented (e.g. implementing A001477(n) and A000027(n), since A000027(n) == A001477(n + 1), and would constitute such a shift described.
4. The numbers may be yielded in any acceptable way. The only requirements on the output are:
• Each entry must be separated by (not necessarily constant) non-numeric characters. If applicable: if your sequence has negative numbers, this separator cannot whatever you choose to represent a negative number.
• Each number must be outputted in decimal—i.e., they must appear as they are in the OEIS sequence.
• The ordering of each sequence in the output must be consistant. E.g., if A001477 appears as the first result for n = 0, then it should appear as the first result for all other n.

For example, the following Ruby script implements A001477 and A004086:

a=gets;puts a.to_i,a.reverse


## Meta

50 sounds good, but might be unfair on a per-language basis. I doubt you could get many encoded in, say, Java. Should the limit be raised?

• Do I understand right that you can have a submission like this? n=input();print n,-n,n*2,n*3,n*n – xnor Dec 24 '16 at 12:01
• are constant sequences allowed? – FlipTack Dec 24 '16 at 13:24
• @xnor Correct . – Conor O'Brien Dec 24 '16 at 20:16

# Prove your language is Turing Complete popularity-contest

A programming language is said to be Turing complete if it can simulate a single taped Turing machine. (from Wikipedia)

In this popularity contest, your task is to design and create a program in your favorite language to prove that it is Turing complete.

You can do this in several ways, such as:

• Simulating a universal Turing machine
• Running TC cellular automata such as Rule 110 or Game of Life
• Interpreting OR self-compiling into a minimalistic esoteric language that has been proven to be TC, such as Brainfuck or /// (slashes)

...but feel free to prove it in any other way you can! These are just examples. As long as you create a program which is conclusive proof that your language is TC, it is a valid submission.

As this is a pop-con the winner is the answer with the largest score (upvotes - downvote). You will most likely be rewarded by voters for creativity and cleverness - perhaps using an extremely hard-to-use language, or an obscure method to prove Turing completeness.

Rules:

• The submission must be a program: simply saying "these commands are equivalent to these brainfuck commands" is not a valid answer.
• Any programs you write must be your own. If not, you should mark your post as community wiki.
• Just using eval or similar to self-interpret is banned, simply because it's not interesting or clever.
• Only Turing Complete languages may be used - for obvious reasons.

# Sandbox Questions

• Is this too broad? I assume there's going to be a lot of mixed feedback, as always with pop-cons.
• Are there any rules I should add?
• Which tags apply to this?
• Do you need to prove that your language is turing complete, or that the program you're writing is turing complete? Please also write down a definition of what you exactly mean by turing complete. As always with a pop-con you need to include an explicit objective validity criterion. – flawr Dec 25 '16 at 14:51
• @flawr As the title says, it's about proving your language is TC. Thanks for the feedback, I'll try and add some more detail. – FlipTack Dec 25 '16 at 14:53
• How about a program that compiles a known TC language to your language? That shows it to be TC by the existence of a correspondence. – Conor O'Brien Dec 25 '16 at 17:30
• @ConorOBrien yep, that would be allowed – FlipTack Dec 25 '16 at 17:31
• This is a very interesting question. +1 As for the tags, I'm not sure, you could do code-golf where the task is finding the shortest possible proof in every language, but in my opinion keeping it a popularity-contest may encourage some quite interesting answers that need not be concerned by byte-size alone. – Buffer Over Read Dec 25 '16 at 18:34
• I think you should probably outright ban string eval. It's also worth noting that a) it's often easier to prove a language TC by compiling into it, rather than by writing an interpreter in it, and b) there's some debate as to whether a language that can write an interpreter for a TC language is necessarily TC itself. – user62131 Dec 26 '16 at 4:15
• @ais523 the problem is, i wanted submissions to be a program, and compiling into a TC language is just a list of substitutions. Unless you meant creating a self-compiler? – FlipTack Dec 26 '16 at 15:09
• @ais523 also, part of the reason I've set it as a pop-con is because writing rules about what counts as proof would be nearly impossible - a pop-con allows popular vote to decide what is valid, and downvote what is obviously cheating. – FlipTack Dec 26 '16 at 15:11
• This will most likely get closed as too broad as a pop con. Also, pop cons still need an objective validity criterion; if the validity criterion is unclear as a ode golf, it is also unclear as a pop con. – Dennis Dec 26 '16 at 15:25
• It doesn't make sense to me to write a program to prove a language is Turing complete. The claim is a mathematical statement and so a proof should be a series of logical logical deduction. It looks to me like you just want emulators of known simpler Turing-complete languages (the existence of which is one proof method for TC), in which case the spec should require just that. – xnor Dec 28 '16 at 20:20
• There's a difficulty that the languages this will be interested for are Esolangs and usually the Esolang wiki for basically all entries has a proof or disproof of some sort for Turing completeness. – walpen Dec 29 '16 at 3:14

# Name that pentomino!

There are a total of 12 different pentominoes, shapes made out of 5 squares:

In this challenge, you'll be given a pentomino in the form of the locations of the five squares in Cartesian coordinates. Your program must output the letter name of that pentomino, as shown in the image above. The pentomino won't be rotated at 45 degrees like some of the ones in the image, but other than that it may be rotated, reflected, or translated arbitrarily.

## Input

Your input will be a list containing 5 pairs of integers, in any reasonable format. You can assume that each integer is between 1 and 1000, and that the coordinates give a valid pentomino.

## Output

The output should be a single character - either F, I, L, N, P, T, U, V, W, X, Y, or Z - depending on which pentomino the input coordinates represent.

Test cases:

Input -> Output
[(2, 1), (1, 2), (2, 2), (2, 3), (3, 3)] -> F
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] -> I
[(1, 1), (2, 1), (1, 2), (1, 3), (1, 4)] -> L
[(1, 1), (1, 2), (2, 2), (2, 3), (2, 4)] -> N
[(1, 1), (1, 2), (2, 3), (2, 2), (1, 3)] -> P
[(1, 3), (3, 3), (2, 3), (2, 2), (2, 1)] -> T
[(1, 1), (1, 2), (2, 1), (3, 1), (3, 2)] -> U
[(1, 1), (2, 1), (3, 1), (3, 2), (3, 3)] -> V
[(1, 1), (2, 1), (2, 2), (3, 2), (3, 3)] -> W
[(2, 1), (1, 2), (2, 3), (3, 2), (2, 3)] -> X
[(1, 1), (2, 1), (3, 1), (4, 1), (3, 2)] -> Y
[(1, 3), (2, 3), (2, 2), (2, 1), (3, 1)] -> Z

[(3, 6), (4, 6), (5, 6), (3, 5), (4, 5)] -> P
[(7, 7), (8, 6), (7, 6), (9, 6), (8, 5)] -> F


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

(Note to sandbox viewers: I'm not sure whether I should go with the fixed output system that's there now, or if I should allow arbitrary (but consistent) output formats. If anyone has a strong opinion about this, leave a comment!)

• Did you make the image yourself? If not, you should probably credit the source. About the output format, it's best to require a single character that's the character given, but to not make rules about how that character is output (e.g. it could go to stdout, be displayed on the screen, or output as its ASCII code). – user62131 Dec 31 '16 at 22:39

# Re-Implement tail in your favorite language! code-golf

### The Challenge

For the Linux users on PPCG, you know what tail does. For those who don't know, tail outputs the last n lines of a file or STDIN.

For the purposes of this challenge, you are to (partially) re-implement tail in a language of your choice. However, to make everything simpler, only the following requirements will be enforced:

• Your program will only be taking input from STDIN (or equivalent).
• Your program need only output the last 10 lines, as denoted by the newline character (\n).
• Your program must output a trailing newline.
• Your program must output to STDOUT (or equivalent).

You may assume that your program will always be passed text.

### Scoring

This is , so the shortest answer (in bytes) wins.

• I recommend you be more flexible with the output format - specifically, drop the "trailing newline necessary" rule. – FlipTack Dec 30 '16 at 13:35
• Also, in environments where input is line-buffered, how should multi-line input be taken? Are function submissions allowed? – FlipTack Dec 30 '16 at 13:36
• @FlipTack: Actually, I'd recommend specifying that the input will always have a trailing newline. That way, the correct output will always have a trailing newline too, but you could do it by copying from the input. – user62131 Dec 31 '16 at 22:37

# A range of operations on the same inputs

Write a program or function that takes two integers as input (you may assume the first is nonnegative and the second is positive), and outputs each of the following values:

• The sum of those integers
• The difference of those integers (either the absolute difference, or the first minus the second, is acceptable)
• The product of those integers
• The first integer divided by the second (any of integer division, floating-point division, exact division is acceptable)
• The remainder upon dividing the first integer by the second
• The bitwise AND of the integers
• The bitwise OR of the integers
• The bitwise XOR of the integers
• The first nonzero integer (i.e. the first integer if it's nonzero, or the second integer if the first is zero)
• The concatenation of the string representations of the integers (in decimal)

This is , so the shortest program wins. Good luck!

## Sandbox notes

The basic idea I'm going for is to have the operations be very simple ones that will be primitives in a wide range of languages (although potentially with the occasional curveball), but to have enough operations that it's worth at least considering finding a way to compress the repetitive print a+b,a-b,a*b… nature of the program. At the moment, there probably aren't enough for compression to be worth it except in the occasional golfing language, but adding more operations runs the risk of requiring something to be done that's nontrivial in its own right or hard to compress. (Actually, even writing the uncompressed version can be fairly interesting in many golfing languages, as this sort of operation that reuses multiple inputs is quite different from the more common situation where the input of each operation is the output of the one before.)

Also, is this a duplicate? I didn't find one but it's a hard sort of problem to search for.

• Although this is interesting, I'm not sure if it will be well received, as it's just a list of trivial operations that are too trivial to be challenges on their own. – FlipTack Jan 1 '17 at 17:48
• Can concatenation of the string representations have a leading 0? – FlipTack Jan 1 '17 at 17:51
• It's in the spirit of this challenge to allow the simplest possible implementations of the operations, so I'd say it's OK if you add or remove a leading 0 that shouldn't be there. – user62131 Jan 1 '17 at 22:29

# Linear Regression on Strings

This challenge is a little tricky, but rather simple, given a string s:

meta.codegolf.stackexchange.com


Use the position of the character in the string as an x coordinate and the ascii value as a y coordinate. For the above string, the resultant set of coordinates would be:

0, 109
1, 101
2, 116
3, 97
4, 46
5, 99
6, 111
7, 100
8, 101
9, 103
10,111
11,108
12,102
13,46
14,115
15,116
16,97
17,99
18,107
19,101
20,120
21,99
22,104
23,97
24,110
25,103
26,101
27,46
28,99
29,111
30,109


Next, you must calculate both the slope and the y-intercept of the set you've garnered using linear regression, here's the set above plotted:

Which results in a best fit line of:

y = 0.014516129032258x + 99.266129032258


f("meta.codegolf.stackexchange.com") = [0.014516129032258, 99.266129032258]


Some clarifying rules:

- Strings are 0-indexed or 1 indexed both are acceptable.
- Output may be on new lines, as a tuple, as an array or any other format.
- Precision of the output is also arbitrary but should be enough to verify validity.


This is lowest byte-count wins.

• Very cool idea. Already trying to figure out how to implement this – Patrick Roberts Jan 9 '17 at 0:54

# Function Token Validator

Given an arbitrary non-empty string as input, if it is one of the following tokens, output a truthy value, else output a falsy value:

-
abs
acos
acosh
acot
acoth
acsc
acsch
angle
arccos
arccosh
arccot
arccoth
arccsc
arccsch
arcos
arcosh
arcot
arcoth
arcsc
arcsch
arcsec
arcsech
arcsin
arcsinh
arctan
arctanh
arg
arsec
arsech
arsin
arsinh
artan
artanh
asec
asech
asin
asinh
atan
atanh
cbrt
ceil
ceiling
conj
conjugate
cos
cosh
cot
coth
csc
csch
e^
exp
exponent
fact
factorial
floor
fpart
frac
gamma
im
imag
int
ipart
ln
log
mag
neg
norm
normal
re
real
round
sec
sech
sin
sinh
sqrt
tan
tanh


Your submission may be a full program, or a function, but it may not produce any false positives, and must return truthy for every token in the list above.

• interesting list – TrojanByAccident Jan 8 '17 at 22:01
• @TrojanByAccident It's a list of generic math functions, and I thought there would be enough similarities between a large majority of the tokens to combine some quick checks with length-optimized regexes to make this an interesting challenge. – Patrick Roberts Jan 8 '17 at 22:28
• Personally, it looks like something I can write in /// – TrojanByAccident Jan 8 '17 at 22:38
• This is just regex golf. – SIGSTACKFAULT Jan 12 '17 at 16:09

# Sliding Puzzle - King of the Hill

Introducing Sliding Puzzle - King of the Hill Challenge

## How to

1. Clone the project from GitHub
3. Create a class which extends BasePlayer
4. Implemement all the Methods (See: ExampleCode)

## Restrictions

• You are not allowed to have a constructor for your BasePlayer and any Initialisation should be done in Initialize()
• You are only allowed to use the visible API in the .dll

## API

### BasePlayer

void Initialize() is called before the Game stats and allows you to set up your code

Tile CurrentTile gives you access to the Tile you are moving

EDirection DoMove() here you return the direction you want to move

ReadOnlyCollection<EDirection> ValidMoves returns a List of Valid moves you can do

Field Field gives you access to the puzzle

### Field

bool IsPositionInBoundries(...) returns whether the parameters are within the boundries of the Field

Tile GetTileAtPosition(...) returns Tile at given Position. Returns null when errors occur

### Tile

Point TargetPosition gives you the Position this Tile has to be to win

Point CurrentPosition gives you the Position this Tile is currently Location

### Point

Point represents a Location within the game, having an X and Y Coordinate. Contains operator overloads ( + and - ) eg. var deltaPosition = tile.CurrentPosition - tile.TargetPosition

### EDirection

Enum which represents the direction, Point GetOffset() can be called to get the Offset as Point

## Example Code

public class RandomPlayer : BasePlayer
{
static void Main(string[] args)
{
var player = new RandomPlayer();
var field = Field.PlayMatch<RandomPlayer>();
Debug.WriteLine(field.MatchResult);
}

public Random Random;

public override EDirection DoMove()
{
var randomIndex = (int)(Random.NextDouble() * ValidMoves.Count());
var direction = ValidMoves[randomIndex];
return direction;
}

public override void Initialize()
{
Random = new Random();
}
}


## Scoring

Players are scored by average turns needed to solve a puzzle! Good Luck!

• I think this may be too easy for some PPCG users. Especially if there's no time limit, some users could probably find the optimal solution, resulting in a tie. Also, challenges should be self-contained, not relying on data from external links. So you should explain in your question description what a "sliding puzzle" is. – mbomb007 Jan 9 '17 at 22:43

# Maximize the velocity of a group of cars

A group of cars are in the right lane of a straight two lane highway. Each car has a preferred speed. In order to reach this preferred speed, some of the cars need to change lanes, perhaps multiple times.

All cars are exactly 1 meter long. At the start of the simulation, there is zero space between each car and the car in front of it. Acceleration is instant. Cars move at their preferred speed whenever possible. If a car would bump into another car, instead it immediately decelerates to match the speed of the car in front.

Give the starting order and preferred speed of each car, your task is to find some combination of lane changes such that all cars reach their preferred speed, and could continue to do so forever without any further lane changes, in the smallest amount of time.

## Input

Two lists are given as input:

• A list of strings that represent car names
• A list of integers that represent preferred speeds, in meters per second

The order of the car names indicates the starting order, with the first car in the list begins at the front of the pack. You can map cars to speeds using position in the list.

## Output

You will output a list of lane change events that, if followed, leads to a situation where all cars are currently driving at their preferred speeds, and could continue to do so forever. The solution must also be the fastest such solution in terms of simulation time. Another way to say this is that the timestamp of the last lane change event must be minimal.

Each event must include a timestamp and a car name. The timestamp must be the number of seconds since the beginning of the simulation, rounded to the nearest hundredth of a second.

• I think this a cool question, I like how different it is from most of our other questions. However, I think having a sample implementation would be a good idea before posting it, as otherwise I'd predict many deleted answers! :P – FryAmTheEggman Jan 13 '17 at 0:57

# Decide if an integer is uniform

I was recently implementing a Local Binary Patch (LBP) descriptor, and found the need to decide if a number is uniform, as described below. You can read about why this is needed in object detection here.

## Input/Rules:

1. Take a (signed!) integer n in any way that seems reasonable to your language of choice.
2. The number will be given as a decimal.
3. Your approach must work with at least all 32 bit encoded integers, including 0. This means from −2,147,483,648 to 2,147,483,647, i.e. from −(2^31) to 2^31 − 1
4. Negative numbers must be turned to binary with Two's-complement. (With One's complement the output is the same as for the unsigned version of the number every time).
5. Only the minimal number of bits required to encode the given number matters.

## Output:

A truthy/falsey value if the number is uniform.

## Uniformity:

An integer n is considered to be uniform, if the number of transitions from 1 to 0 or from 0 to 1 in the binary encoding of n ist less equal to 2.

## Examples:

Given the number 12, its binary encoding is 1100. There is 1 transition here:

1100 |

Thus, your output should be truthy.

Given the number 10, its binary encoding is 1010. There are 3 transitions in here:

1010 |||

Thus, your output should be falsey.

Given the number -12, its binary two's complement encoding is 0100. There are 2 transition here:

0100 ||

Thus, your output should be truthy.

Here is an example for which the two's complement matters: Given the number -125, its binary two's complement encoding is 10000011. There are 2 transitions here:

10000011 | |

Thus, your output should be truthy.

Side note: If we did the same with one's complement, the encoding of -125 would be 10000010, which has 3 transitions.

Shortest code in bytes wins.

## Sandbox notes:

This is my first code golf question, feel free to yell at me. Tags:

• Seeing as it's outputting truthy/falsy, decision-problem would be a great tag to use. Welcome to PPCG btw. – FlipTack Jan 15 '17 at 15:20
• Personally, I think that input should be guaranteed to be positive rather than using two's complement encoding. That allows more bit-shifting based algorithms. – FlipTack Jan 15 '17 at 20:11

# Make a shuffle quine!

Closely based off this sandbox post, however I deleted the old one and posted this new answer for new feedback.

An shuffle quine is defined as a quine, of which shuffled sets of "chunks" also form quines.

For example, pretend in my magical language the code 123 is a quine.

Let's split this into 3 chunks. 1, 2, and 3. In your answers, these chunks can be any lengths and there can be any number greater than 1 of chunks.

You get a better score for more possible shuffled quines you can make. For example, if 21, 23, 13, 312, and 31 are also quines, in addition to 123, you get (15/6 = 2.5) * <sum of chunk lengths> for your score.

Your score is calculated by the formula sum_of_chunk_lengths * (number of possible shuffled programs/number of quines). In this formula, least score is better.

This is code-golf, so the shortest code wins!

Final notes:

• Each shuffled code is a quine itself, i.e. prints itself not the original program.
• Programs have to be distinct, i.e. you can't count abb and abb as 2 because you swapped the bs.

### Sandbox notes:

Yeah, this is really hard. I don't think it's impossible though.

• I appreciate that the scoring makes it impossible to pad the program with junk in order to get an unlimited score. However, I suspect it'll be won by one of the two-byte quines with a score of 2 × 2 ÷ 1, as it'd only be possible to beat with a score of 2 × 2 ÷ 2, 3 × 6 ÷ 5, or better. – user62131 Jan 16 '17 at 22:18
• @ais523 hm, true. I'll mess with the scoring to see what I can come up with. – Rɪᴋᴇʀ Jan 16 '17 at 22:19
• It strikes me that it might be interesting to require the program to be exactly a given number of bytes long. Then the challenge would be to maximise the number of permutations that are quines. Unfortunately, a large number of bytes would be hard to score, and a small number would exclude many languages. – user62131 Jan 16 '17 at 22:34
• I don't see why it's supposed to be difficult. If each chunk is a quine (that doesn't screw up the global state somehow) then you can arrange the chunks in any order and it will still be a quine and you will score 1 for the fraction part. – feersum Dec 16 '18 at 4:28

# Prisoner's dilemma

Inspired by the "Mafia" proposal

## Write a bot that plays the Prisoner's dilemma. King of the hill

### Rules:

• Your bot must be a full program, not a function.
• Your bot must run when the server does ./run in it's folder.
• No shenanigans.
• If you want to remember something, save it to a file in your directory.

### Input/Output

When the server does ./run:

from_server contains your opponent's last move - Either Cooperate or Defect. On the first round it contains Let's play!

When your program exits (60 sec max):

to_server contains your choice this round. Either Cooperate or Defect. Any other output is interpreted as forfeit; you got 0 points and your opponent gets 5. If both bots forfeit on any turn, nobody gets any points.

### Provided bots

There are a few bots that are guaranteed to exist:

• Always defect
• Always cooperate
• 75% cooperate / 25% defect
• 25% cooperate / 75% cooperate
• 50% cooperate / 50% defect

### Testing

Your bot will be played against every other bot in a random number of rounds > 100.

### Winning

Get the most points after you've played every other bot

### Fiddly bits

The game is a file structure something like so:

prisoner/
-> server.py
-> yournameherebot/
-> from_server
-> to_server
-> run
-> *Any other files you want*
-> someotherbot/
-> anotherbot/
-> titfortat/
-> 50-50_random/


### Meta

• What's your win criterion? – Rɪᴋᴇʀ Jan 6 '17 at 0:03
• Most points after playing every other bot. I thought that was implied, just a sec :) – SIGSTACKFAULT Jan 6 '17 at 0:04
• add a grim trigger? (cooperates, but as soon as enemy defects they always defect) – Destructible Lemon Jan 6 '17 at 0:04
• Define "point"? – Rɪᴋᴇʀ Jan 6 '17 at 0:04
• Is this a king of the hill challenge? (With bots competing against each other) in that case, it's probably a duplicate of this one: codegolf.stackexchange.com/q/2357/31716 – James Jan 6 '17 at 0:06
• Easterly: Point = generic unit of win-ness | Watermelon: Well then, you can do that. I might remove TFT from the included bots. – SIGSTACKFAULT Jan 6 '17 at 0:06
• @DJMcMayhem This is why we post in the sandbox, people. :( – SIGSTACKFAULT Jan 6 '17 at 0:08
• I suppose it's not really a dupe -- We're playing a random number of rounds so you can't do things like defecting on the last round against TFT. – SIGSTACKFAULT Jan 6 '17 at 0:10
• "75% cooperate / 75% defect" – Pavel Jan 6 '17 at 0:16
• also it doesn't make sense to only know the last turn – Destructible Lemon Jan 6 '17 at 0:26
• I agree that this is a duplicate, but I'll leave that to the voters. However, for your sanity, I really recommend you change how input/output works. Each time you talk to a bot you are going to have at least 2 file writes, 2 file reads, and starting up a new process. Depending on the number of submissions and iterations, this can take a long time. I recommend keeping the processes alive and communicating through stdin/stdout. – Nathan Merrill Jan 6 '17 at 18:39
• You only are told the last turn. if you want to remember further, you can write to a file. – SIGSTACKFAULT Jan 17 '17 at 14:33

## Divide an array into left and right halves.

Input: An array of floating-point values, or whatever is a reasonably large numeric type in your language.

Output: Two arrays. The original array should be the concatenation of the output arrays. The sums of the elements in the two arrays should be as equal as possible.

Examples:

[] -> [], []
[1] -> [1], [] or [], [1]
[1, 2, 1] -> [1, 2], [1] or [1], [2, 1]
[1, 2, 3] -> [1, 2], [3]
[1, -1] -> [1, -1], [] or [], [1, -1]


Functions or full programs please; no snippets. Normal rules and restrictions apply.

• This challenge is similar to this recent sandbox post, though with a slightly different (more conventional) question format. – VisualMelon Jan 13 '17 at 13:23
• @VisualMelon You'll just have to take my word for it that I don't read the Sandbox myself, but I am surprised at the similarity. – Neil Jan 13 '17 at 19:32
• No problem ;) there is an awful lot to trawl through if you don't have time to check back regularly. – VisualMelon Jan 13 '17 at 19:38
• It's been done. – xnor Jan 19 '17 at 2:54
• @xnor That question doesn't have the concatenation requirement. (Not that I'm claiming that it's enough to make this question sufficiently distinctive.) – Neil Jan 19 '17 at 8:37
• My mistake, I somehow interpreted equality as being up to ordering. Maybe it would be more obvious if you said the array is split into a left segment and a right segment. I think that definitely makes this different. – xnor Jan 19 '17 at 8:41

# City Zoner KoTH

You are a city zoner, and your opponent want to zone dirty industrial. You need to stop him. The mayor has set the following rules.

1. A random player is selected to zone the first location. They take turns zoning area. If one player has twice as much area zoned than the other player, that player is skipped (can happen repeatedly)
2. We have a 20x20 square to zone (400 squares total). A player can choose how much they zone, but it must be a rectangle with an area of at least 5. A player cannot zone more than 200 squares total (across the entire game)
3. If the game ends in a tie, the player who played last wins

Your goal is to ensure your opponent zones as few squares as possible.

• huh, rule number 3 makes this interesting... – Destructible Lemon Jan 22 '17 at 3:39

# Store a secret code-golf

Given a password and a secret,

• Serve at localhost:8080.
• If you receive a POST request to / with the parameter p=(...) then check the given password against the fed in password.
• If it is correct, return a plaintext file with the secret.
• If it is incorrect, return a 400 error
• Return 400 for any other requests

## Rules

• No need to salt and hash the password
• Your server should be able to start in five seconds.
• Your server must be able to server for at least five hours.
• Your server must be able to handle at least 20 connections a second at least in theory. Test script:

import requests, random, time
import sys
from string import printable

def gen_string():
s = ''
for i in range(random.randint(1, 20)):
s += random.choice(printable)
return s

def make_request(str):
is_child = os.fork()
if is_child:
requests.get(str)
sys.exit()

while True:
for i in range(20):
make_request(gen_string())
time.sleep(0.05)

• The spec seems somewhat incomplete to me. It's necessary to read between the lines even to know that the protocol the server is supposed to implement is HTTP. But even having worked that out, it's not clear how much of HTTP should be implemented. What content types must be supported for the POST body? What about encodings? When returning a 400 error, is it sufficient to set the Status header or should it also have a body? – Peter Taylor Jan 22 '17 at 19:16

# Exponentiation by squaring

Given an integer x and a non-negative integer n, compute xn using exponentiation by squaring. The key feature of this method is that the time complexity for exponentation can be reduced from Θ(n) using naive exponentiation to Θ(log n) using exponentiation by squaring. There are other names for this method as well as multiple methods which each have an equivalent time complexity. One of them will be explained but feel free to implement the one that is best suited for golfing in your language.

An iterative version is displayed below in Python

def exponentiate(x, n):
if n == 0:
return 1
y = 1
while n > 1:
if n % 2 == 0:
x = x * x
n = n / 2
else:
y = x * y
x = x * x
n = (n - 1) / 2
return x * y


## Rules

• This is so the shortest code wins.
• Your function or program must have a time complexity of Θ(log n). Keep in mind that only time is restricted, not space.
• Your function or program must support all inputs which would not result in integer overflow in your language's integer datatype.
• You are not allowed to use any builtins that perform exponentiation.
• I would change the name of your Python function as pow is a built-in function. Also an iterative function calls itself inside the function. The above isn't iterative. Otherwise it looks intriguing. – user63571 Jan 22 '17 at 17:28
• @JackBates Yes, a different name might be better to avoid confusion. I'm not familiar with that definition of iterative. I've usually seen recursive used to describe a function that calls itself. – miles Jan 22 '17 at 17:32
• @JackBates this isn't codereview.stackexchange.com . And it is iterative - recursion is when the function call itself, iterative is when it's done in a loop instead. – FlipTack Jan 22 '17 at 17:40
• Sorry about that, got a bit mixed up! – user63571 Jan 22 '17 at 17:41
• Technically the time complexity for the naïve loop isn't Θ(n) and the time complexity for the improved loop isn't Θ(lg n) because the complexity of a multiplication isn't Θ(1), unless you replace exponentiation with expmod. The rule about integer overflow effectively says that languages which use bounded integer types can do expmod, so on a strict reading this challenge can be answered in C but not in Python. I assume this isn't intentional. The most elegant fix is probably to require polylog time rather than log time. – Peter Taylor Jan 22 '17 at 19:07

## Polytope of the pops

In 3 dimensions, there are 5 regular convex polytopes: the platonic solids.

In 2 dimensions, there is an infinity of regular convex polytopes: the triangle, the square, the pentagon, the hexagon, etc…

In 4 dimensions, there are 6 such polytopes, and for 5 dimensions or more, only 3 polytopes - check that cool video for more details.

Challenge

Given as input an integer n>=0, return the number of regular convex polytopes in n-dimensional space, or -1 if the number is infinite.

The sequence (A060296) is (starting with 0 dimensions):

1, 1, -1, 5, 6, 3, 3, 3, 3, 3, 3, 3...


Test cases

0 → 1
1 → 1
2 → -1
3 → 5
4 → 6
5 → 3
2017 → 3


# Interpreter chain!

Create an interpreter for the previous submission! The interpreter could take a string, an array of characters, etc.

Your interpreter must be able to identify each command in the input and interpret the commands.

The first answer must print the integers from 1 to 10.

I/O

(We need this because some languages have trouble with arrays of strings)

To chain the answers, we would need a delimiter to separate the code to interpret and the input of the interpreted code. Thus, you may use any single-character delimiter of your choice to separate the two inputs. Your program must be able to separate the two inputs. Your actual input will always be one string.

What if the previous answer is in Mathematica?

You only need to implement the commands used in the previous submission. That is, if your program/function is run with the previous submission as input, it should become an interpreter for the submission before that. Chaining all the answers would ultimately give integers from 1 to 10.

The commands in the previous answer are too complicated/high-level!

There is no need to implement all aspects of those commands. Your implementation only needs to have identical behavior to the original command when it is used in identical manner to the previous answer.

For instance, if the previous answer is in Brainf*ck, and it uses only 10 cells, you do not need to make an infinite tape; a length-10 array will suffice.

If the previous answer is in Jelly and has a . to put 0.5 in the stack, you do not need to implement the usage of . to form decimal numbers (unless it is used that way).

Note: Commands that are no-op still should be implemented as no-op (your code must recognize the commands).

How do I test my interpreter? It takes too long to evaluate the chain!

To prevent this issue, each answer must contain a test program for the next answer. The test program must use all commands in the interpreter, in the same manner.

Example of an interpreter

An Aheui program:

방망희 (* This program takes an integer as input and puts it in a stack (방),
prints it as integer (망), and then terminates (희) *)


Invalid interpreters in Mathematica:

Print[Input[];Input[]]
(* This does not interpret the previous solution; it just does the identical task, ignoring the first input (the Aheui code) *)

If[Input[]=="방망희", Print[Input[]]]
(* This doesn't define each command *)

Fold[Switch[#2, "방망", Print[Input[]], "희", Abort[]]&,, Input[]]
(* This doesn't define each command *)


Valid interpreter in Mathematica:

Fold[stack={}; Switch[#2, "방", AppendTo[stack, Input[]], "망", Print[Last@stack];
stack = Most[stack], "희", Abort[]]&,, Input[]]


Rules

• Loopholes are not allowed
• Any four consecutive answers cannot contain the same language twice.
• The second to last submission (i.e. proven not to break the chain) by Feb 12 (0:00 UTC) will be the winner.

Your code here

[Try it Online!](https://tio.run/nexus/language#@___/___)

Explanation

code snippet

This part interprets the x command.

code snippet

This part interprets the y command.

List of commands

A, B, C, D

Test program

... A( ... ); B( ... ); C( D( ... ) ); ...

• Why would anyone bother to read the code on input at all, when it is already known exactly what the program needs to do? – feersum Jan 26 '17 at 7:57
• @feersum If the submission does not even read the input, it is no longer an interpreter. The interpreter must somehow identify each command in the input and execute the commands in order. I guess "You will need to define each function separately." wasn't that clear... (changed "function" to "command") – JungHwan Min Jan 26 '17 at 16:04
• It's going to be hard to define a victory condition here. It'd be fairly easy to write a ridiculously long, complex program in a high-level language which would therefore be pretty much impossible to interpret. – user62131 Jan 26 '17 at 16:10
• @ais523 I edited the question. Would that work? (The winner is the second to last answer) – JungHwan Min Jan 26 '17 at 16:18
• Possibly. I'm still unsure that the question as a whole works, but maybe you'll find a way to define things precisely. – user62131 Jan 26 '17 at 16:37
• @JungHwanMin "This is/isn't an interpreter" is a completely subjective identification which isn't appropriate in a code golf specification. – feersum Jan 26 '17 at 22:36
• @feersum This is an answer-chaining question. Also, I don't understand how "interpreter" is a subjective word. Could you give me an example, perhaps? – JungHwan Min Jan 26 '17 at 23:42
• I mean, for a specification on this site (other than popularity contest). OK, if it's not subjective, please give me some code which can take as input a language A, a program X in language A, and a program Y, and output whether Y is interpreting X or not. – feersum Jan 27 '17 at 0:14
• @feersum That problem can be easily solved by requiring some explanation from the answerers (+ a link to language specifications). They would also need to write a list of commands used in their answers for the following answers. – JungHwan Min Jan 27 '17 at 0:21
• @JungHwanMin I think what feersum is trying to say is this. An interpreter implements some programming language, which consists of some set of valid programs and their behaviors. Suppose that the first answer A is written in Java. The next answer B should be an interpreter for which A is a valid program whose behavior is to print the integers from 1 to 10. But what else are valid programs for B, and what should their behaviors be? Not every Java program has to be valid, as per the rules. What about all Java programs that use the same "commands"? (contd.) – Zgarb Jan 27 '17 at 8:43
• If A uses a Java function that has a very complicated implementation, but only a small subset of that is needed for A, can B choose to only implement that subset? If A uses a syntax that's very complex to implement generally, but can be treated as a no-op in A, does B have to implement the general case? It's hard to draw the line. – Zgarb Jan 27 '17 at 8:45
• @Zgarb Those are very good points. For your first comment, I would say that for language B, the valid programs are programs (in language A) that use the same commands in answer A with the same purpose (perhaps, it may be a good idea to require each answer to have a test program that prints from 1 to 10; the program would only use the commands in the interpreter). For your second comment, only a subset could be implemented; the no-op still has to be implemented, however (the interpreter must still acknowledge that the command is there). – JungHwan Min Jan 27 '17 at 15:41
• In that case the chain could be broken by a language which is good at interpreting other languages but can't count from 1 to 10. (It wouldn't surprise me if one already existed; it might be fun to construct one if it doesn't.) – user62131 Jan 27 '17 at 22:01
• @ais523 The only requirement is to print numbers from 1 to 10. Technically, something like print("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n") would be fine. Also, if the first answer uses a for-loop (to print 1,2,3,...,10), then all the languages after that needs to have something similar... -- Anyway, I changed the requirement to "the test program must use all commands in the interpreter" to prevent such issues. – JungHwan Min Jan 27 '17 at 23:36
• Could I get feedback instead of unexplained downvotes? If this question is too broad/impractical, it can be improved. Any suggestion is welcome. – JungHwan Min Jan 27 '17 at 23:41

# Chicken

Chicken is a game played with two cars (or two computers) where two drivers face each-other on a street. Each car may swerve or stay fixed in its path. Here is an idealized payoff matrix

              Player 1
Swerve        Stay
Player 2 Swerve    +3/+3        +10/+1
Stay                +1/+10      -25/-25



The values given for both swerving reflects the lack of ego damage, +3 is given for a win, but both staying results in a bothersome predicament with a high risk of a crash and where both have to reverse.

Now your job is to write a bot that will play this game. You will be provided with needed information as command line arguments.

A sample invocation will look like this.

foolanguage myBot.foo 4 w,w,w,w,w,w,t,w


Where the first command line argument is a string containing the number of goes you have had in the match and the second is a list containing each of you and your opponents decisions respectively (w is swerve and t is stay). Here is a break down of the list.

 (your first move),(opponents first move),(your second),(opponents second)


This will be set up in a round robin fashion. You will play some arbitrarily high (say 100) rounds against each bot and your score will be totalled. Least damaged bot (highest scoring bot) wins!

## Entering

You will provide a command stem and a unique bot name. So the sample bot can be called fooBot, and the command stem (after which arguments are appended) looks like "foolanguage myBot.foo"

Your bot will then output w (swerve) or t (stay) with 50 ms.

Your bot must be be able to make both choices. No locking in to just one choice.

Also, your bot must be deterministic (prng's may be seeded with a private seed. If you wish to do this, insert a dummy seed, and change it right before the competition) please publish the has to ensure you don't tweak it in light of other submissions.

The payoff matrix isn't quite realistic, but in order to make this game make sense and various strategies to work, I decided its important to tailor it this way.

• 1) The payoff matrix shows that it's best to swerve every time, so the highest scoring bot will never "stay", but this goes against the rules. (2) Does the bot play against another bot or a human? (3) Does the bot have to output for just one round or multiple? – Luke Jan 29 '17 at 22:04
• "your bot must be deterministic" opens the way for metagaming where bots use seeded PRNGs and the person who posts last wins because they managed to tweak their seed to give them an edge. – Peter Taylor Jan 29 '17 at 23:06
• @Luke serving gives three while staying four. Its in the format player 1, player 2. – Rohan Jhunjhunwala Jan 30 '17 at 0:50
• @Luke output one round at a time, and then each round you receive a history, no need to store a history into a file. – Rohan Jhunjhunwala Jan 30 '17 at 2:05
• @Luke also readjusted weights on the matrix – Rohan Jhunjhunwala Jan 30 '17 at 2:05
• @PeterTaylor allowed hiding a seed, but mandated publishing its hash to ensure it doesnt get changed. – Rohan Jhunjhunwala Jan 30 '17 at 2:05
• I think this would be more interesting if you changed the payoff matrix to include a prisoner's dilemma – Luke Jan 30 '17 at 17:28
• @Luke looking back on it, I should do that. Makes it more logical – Rohan Jhunjhunwala Jan 30 '17 at 23:47
• @Luke I will fix it – Rohan Jhunjhunwala Jan 30 '17 at 23:47
• @Luke it seems to be a dupe if the pay off matrix exactly reflects a prisoners dilemma, will need to tweak this game. Please do edit if you can mke it more interesting – Rohan Jhunjhunwala Jan 30 '17 at 23:55
• IMO, this still feels too close to prisoner's dilemma. Despite the fact that the numbers are different, pretty much all of the existing submissions on our past challenge from the old challenge will work just fine, meaning that this is a duplicate. – Nathan Merrill Jan 31 '17 at 3:49
• @NathanMerrill, it's borderline. I did a bit of reading around, and there has been research on the different performance of the same approaches when applied to iterated prisoner's dilemma and iterated chicken (with a range of parameters for both). The strategies don't perform equally well, but it's probably true that the same strategies would be posted and there wouldn't be much innovation. – Peter Taylor Jan 31 '17 at 8:30
• Watch out for another black hat program (The one that replaced others AI) – Christopher Jan 31 '17 at 16:19
• I'm going to come up with another spin on this same theme, I like this format, but I think I need a different game entirely. – Rohan Jhunjhunwala Jan 31 '17 at 23:55

This is my first attempt at posting a code golf question. :) The following task is something that I've been thinking about for a while now. To me it seems that most code golf tasks, while often quite amazing, are of little more than of academic interest to anyone. In the modern world (of the World Wide Web), however, RESTful web services are of utmost importance.

I haven't seen many tasks like this here, so I wonder if it's appropriate, or if it needs any additional specs?

RESTful Web Service

Your task in a nutshell: implement a web server that can store and return values in a key-value fashion.

Rules

1. Your application must act as a web server on localhost. The TCP port number must be 80 or higher.
2. The server must be usable with the command line tool named curl, which comes pre-installed in every Linux system.
3. The server is essentially a key-value storage where the keys are integers. You may choose to have your keys start from either 0 or 1, i.e. from localhost:80/0 or localhost:80/1. Your server must support storing at least 256 values, i.e. up to localhost:80/255, or /256 if you chose 1-based indexing.
4. "HTTP PUT" to an address must update the value, "HTTP GET" must retrieve it: for example, "curl -XPUT -d 'foo' localhost:80/5" must store the value "foo" into position 5. "curl -XGET localhost:80/5" must then return "foo". "GET" and "PUT" are the only HTTP verbs that need to be supported.
5. The server must always return the HTTP status code "200 OK", unless the user GETs an URL where nothing has been stored yet, in which case the status code must be "404 Not Found".
6. The server must be able to store values that are of at least 64 bytes long.

• I don't know enough about web services to judge your spec, but general advice is to have your spec be perfectly thorough and exact in describing the required behavior. In a competition to cut bytes, any "useful" features or properties that are not required will be cut. Imagine your spec is being read by an adversary trying their hardest to find loopholes that let them get away with doing as little as possible. – xnor Jan 28 '17 at 23:18
• I'd indicate that GET and PUT are the only rest commands they need to support. As far as I'm concerned, this challenge actually seems pretty well specified to me. – Nathan Merrill Jan 31 '17 at 13:27
• 1. There are a couple of existing questions which ask people to implement basic HTTP daemons. I think it's borderline whether the specific handling here makes a non-duplicate. Other people may have stronger opinions. 2. If I'm correct that PUT includes a request body, it would be good to specify the MIME type(s) which implementers need to handle. Not everyone has access to curl to do their own tests. 3. Point 5 of the spec seems wrong: a PUT to a URI other than the 256 specified ones should probably give a 403. – Peter Taylor Jan 31 '17 at 16:51
• @NathanMerrill, thanks, that's good feedback, I've added that point! – ZeroOne Feb 1 '17 at 7:53
• @PeterTaylor, I suppose you are referring to these questions: codegolf.stackexchange.com/questions/3988/… and codegolf.stackexchange.com/questions/41638/418-im-a-teapot I think the first one is too laborous to be fun and the second one is too simple. My question should be somewhere in the middle. Also I don't want to impose too many constraints, MIME types can be whatever, and for all I care the app may even crash if you PUT to wrong URLs. – ZeroOne Feb 1 '17 at 8:07
• There's also codegolf.stackexchange.com/q/12221/194 which I think is closer to yours, although it does also have a client-side HTML/JS component. – Peter Taylor Feb 1 '17 at 8:32
• OK, ouch, that one has only 4 answers. I consider that a failure, the task obviously requires too much work so that not many people even bothered to attempt it. – ZeroOne Feb 1 '17 at 9:12

# How extreme can a letter be?

## Challenge

Write a function or program that accepts a rectangular grid of letters (A-Z) as input, and provides an output as follows:

• If the grid contains repeated letters, output the maximum rectilinear distance between two positions on the grid covered by the same letter.
• If every letter in the grid is unique, output 0.

## Example

Given this grid:

AEBZWZSFUS
XWHZITHJNN
OQDSLRZFCW
KOMBQQVAGT
FAGIBOZZAX
MECUIFYKYB
UGURYVFHAT
IICZSFMUTC
JPPHXNXSEW
TSUTJMVCNI


...your output should be 17. This is the rectilinear distance between the S on the top right corner and the S on the bottom row.

## Rules

This is code golf; shortest code in bytes wins. Standard loopholes disallowed.

### Formatting

• Input via standard input, ordered collections (list/array/etc) of strings, or two dimensional array/list/etc of characters is allowed.
• Output via return value, exit code, or standard output is allowed.

### Input guarantees

(If the input doesn't comply with these, you don't have to handle it)

• The input is a rectangular grid.
• Every position on the grid is an upper case letter.
• The grid will be at least 2 characters wide.
• The grid will be at least 2 characters tall.
• The grid will be no wider than 98 characters.
• The grid will be no taller than 98 characters.

### Output restriction

• Your output should be a single non-negative number indicating the request value.

## Test Cases

IXHNBFJFQLQGKEWVCXCX
FPMTNQHOFPPURUMZXPEJ
ZLOIFSYPKLXFOYOIKUMJ
LKZOSZWWKLWLFZBQQLYJ
-> 19

ABCDEFG
HIJKLMN
OPQRSTU
-> 0

DSMPAHNP
JUWYNWOE
AIUOCIPY
MHODAXVG
NFETRIWH
YDQYVLZL
LDTZBYER
JEXPFRDR
-> 13

ZYXWVUTSRQPO
TSRQPOZYXWVU
NMLKGIHGFEDC
HGFEDCNMLKGI
-> 7

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
-> 40


# Background

In the dungeon-style game "The Binding of Isaac", there is a trick involving the use of three items, called the Blank Card, Jera, and the Battery. The Blank Card is a usable item that allows for the use of single-use items repeatedly when charged, the Jera item (single-use) allows for the duplication of items on the ground, and the Battery is a ground item which charges the current usable item. Having all three at once allows the player create as many batteries as they please, allowing them to gather all the player-stat altering items in the game with minimal effort.

However, the number of batteries which appear when repeatedly duplicating the batteries depends on a few things. Say that, at any given time, you have n batteries on the ground. Every time that you grab the battery and use the card simultaneously, you end up with 2n - 1 batteries on the ground (where n is the number of batteries you had just before picking up the battery). Your new n is now the current number of batteries on the ground. This sequence continues with each use of the blank card (hereon referred to as an "iteration").

# General Formula

For the sake of clarification, the general formula for this sequence may be found below:

$b_{n+1} = 2b_n-1$

Where b represents the number of batteries and n represents the number of iterations.

Given two positive integers x and y, where x is an initial amount of batteries (b0) and y is the number of iterations to enact (n), write a program or function which finds the number of batteries you end up with on the ground.

# Examples

Let f(x, y) be the function defined in the task and let [] symbolize the steps taken to reach the answer (not included in this challenge):

>>> f(1, 5)
1
[1, 1, 1, 1, 1]

>>> f(2, 4)
17
[3, 5, 9, 17]

>>> f(8, 8)
1793
[15, 29, 57, 113, 225, 449, 897, 1793]

• There's no really much space for interesting golfing in "Given x and y calculate 2**y * (x-1) + 1". – Peter Taylor Feb 4 '17 at 21:17
• @PeterTaylor Except that's not how it works... x_{n+1} = 2 * (x_n - 1), where x_0 = y. – Addison Crump Feb 4 '17 at 21:27
• The question clearly says that if you have n batteries and you apply one iteration you get 2n - 1 batteries, not 2(n-1) batteries. The examples also show the iteration mapping x_{n+1} = 2 * x_n - 1, not x_{n+1} = 2 * (x_n - 1). And the question also clearly states that "x is an initial amount of batteries and y is the number of iterations to enact". So your comment makes absolutely no sense. – Peter Taylor Feb 6 '17 at 9:01
• @PeterTaylor Yup, my comment is off. D: Sorry. I think that the question needs rewording as well. – Addison Crump Feb 6 '17 at 13:08

# Display text in Comic Sans!

I haven't seen any challenges that require outputting text in a variable-width font, and of course I had to pick the best one.

## Goal:

Display some text in the font Comic Sans. Characters must be variable width; i should use less space than W, for example. Kerning is not required.

### Notes:

Your score is the program size (in bytes).
You may assume that the font "Comic Sans MS" is installed on the computer, or that a font file (or image containing the characters in that font) is in the current directory. Storing additional data in this file is not allowed; it must be a standard font or image file.

### Input:

A string containing the text to display. This will only contain printable ASCII characters (32 to 126). This can be passed to a function, typed in by the user, loaded from a file, etc.

### Output:

The text written in Comic Sans. This can be saved as an image, or just displayed on the screen graphically. However, direct text output is not allowed. For example, this would not be a valid HTML solution:

*{font-family:"Comic Sans MS"}
<input>

• I'd like a clearer explanation on what is allowed and what is not. You are not allowed to (for example) save a .html file containing <style>*{font-family:"Comic Sans MS";}</style>Example Text is a bit vague – satibel Feb 6 '17 at 16:00
• Is this better? – 12Me21 Feb 6 '17 at 16:08
• Can we assume that the font "Comic Sans MS" is installed on the system? (This challenge would be extremely different if not :P) – ETHproductions Feb 6 '17 at 17:17
• yeah, I said that "The size of the font is not included, but it must be in a standard format", but I think I should re-word that – 12Me21 Feb 6 '17 at 17:52
• you maybe should provide a list of what constitutes a standard font file, as something like a nintendo ds font file might be considered standard by some, while not by others. Same thing with raw bit map, there are a bunch of different formats. I think something like an image or font file that was used at least once before the question was posted or just providing a list of allowed formats. would be clearer. – satibel Feb 8 '17 at 12:47

# Crossed out 44 is still regular 44

As it happens, the HTML strikethrough <s>4</s> lines up (at least on some systems) with the crossbar of the number 4 so that the two don't differ in appearance: 4 and 4 look like the same thing. This causes crossed out bytecounts in answers to code golf questions seem a bit confusing if they consist entirely of 4s or if they end or begin with a 4.

For instance, 48 44 34 31 bytes seems a bit silly.

However, there is a way to make the strikethrough over a 4 appear more clearly. If the bytecount begins with the digit 4, adding a non-breaking space (ASCII character 255) before the number will make the strikethrough extend beyond the crossbar of the digit 4. Similarly if the bytecount value ends with 4, the non-breaking space is appended to the end.

For example, 44 becomes  44 , 457 becomes  457 and 64 becomes 64 .

### The Goal

The task here is to automate this fix.

Take a string like this: <s>48</s> <s>44</s> <s>34</s> 31 bytes as the input, and output or return the string with added non-breaking spaces at the end of each striken through number that ends with the digit four, and to the beginning of each striken through number that begins with the digit four.

So, for example, <s>48</s> <s>44</s> <s>34</s> 31 bytes becomes <s> 48</s> <s> 44 </s> <s>34 </s> 31 bytes. And here's the difference in effect: 48 44 34 31 bytes becomes  48  44  34  31 bytes.

Be sure to use non-breaking spaces, not regular spaces. Do not add them before or after numbers that are not crossed out. You can assume that all strikethroughs are closed (so there's no <s> that's missing its </s>). If there is anything else than the number inside the strikethrough block, no spaces should be added.

Your solution can be a program or a function. This is , so the shortest submission (for each language) wins. Standard loopholes apply.

• Can there be spaces before or after the numbers in the strikethrough tags and what should behaviour be in that case? – fəˈnɛtɪk Feb 13 '17 at 13:39
• I think at least make an example that shows something like <s> 48<\s> still has a nbsp added in front of the 4. – fəˈnɛtɪk Feb 13 '17 at 13:45
• @LliwTelracs I changed it so that if there are any other characters inside the strikes, the spaces should not be added. – Steadybox Feb 13 '17 at 13:55
• Lol, I didn't acknowledge that there was a way to fix it. I fixed my answer's title now xP – busukxuan Feb 13 '17 at 14:11
• The premise of this question is wrong. Maybe some people have combinations of browser, system fonts, and configuration which make the strikethrough invisible, but to assert as a universal truth that the strike lines up with the crossbar is to err. – Peter Taylor Feb 13 '17 at 14:45
• A test case with a 4 as a middle digit would be good. – AdmBorkBork Feb 14 '17 at 14:29

# Texplode

Texplode is like Hexplode, but played on a tetragonal (square) grid. explains the rules

## I/O

You will provide two device files / named pipes / terminals / COM ports / other. One of these will be for input, and the other will be for output.

The input provided to your program will be a series of ASCII numbers n^2 characters long, followed by a ; character. The file will be flushed after this is put into it. The meaning of each number is as follows:

• 0: There are no counters here. You can place here.
• 1: There is one counter here, but it is not yours.
• 2: There are two counters here, but they are not yours.
• 3: There are three counters here, but they are not yours.
• 4: There is one counter here, and it is yours. You can place here.
• 5: There are two counters here, and they are yours. You can place here.
• 6: There are three counters here, and they are yours. You can place here.

These numbers should be interpreted as being laid onto a n by n grid.

The output provided by your program should be a number followed by a ;. The number should be the position in the input stream that your program wants to place a counter. It must be a position that you can place in, otherwise Undefined Behaviour will occur.

## Controller

The Texplode engine will be here soon.

• Controller being reviewed here. – wizzwizz4 Feb 15 '17 at 17:43
• If you're communicating with external programs then I'd expect validating the response to be a negligible extra cost for the controller, and it would allow you to automate the disqualification of a player, and their exclusion from the leaderboard tournament, so the rule abiding players don't have to wait longer for a leaderboard. – trichoplax Jul 27 '17 at 15:23
• Sounds awesome, by the way... – trichoplax Jul 27 '17 at 15:23
• Will you choose n large enough that the game cannot be solved optimally? I dont' think it takes very large an n for this... – trichoplax Jul 27 '17 at 15:24
• @trichoplax With the current implementation the invalid responders just lose their turn. If they are still connected to the stream but not sending input I couldn't do anything about it anyway, apart from adding a time limit. – wizzwizz4 Jul 27 '17 at 15:26
• @trichoplax n will vary. It will depend on how many contestants there are and how much computer time I have. – wizzwizz4 Jul 27 '17 at 15:39
• I'd recommend some sort of time limit as this game benefits from an arbitrary amount of calculation for even relatively small n. Without a time limit there will be incentive to use more and more time per turn, particularly in the end game. – trichoplax Jul 27 '17 at 15:43
• Also, it might be a very different contest depending on how long each turn lasts. After a certain point it will be a heuristic only game, but the turn length and board size will determine how many turns into the game this happens. You could choose the turn length based on what you prefer to see. – trichoplax Jul 27 '17 at 15:48
• @trichoplax Does that matter much? Many good strategies exist that are simple, including Corner Hugger. I'll probably add a ~1 minute time limit, but only so the contest can finish in a reasonable amount of time. – wizzwizz4 Jul 27 '17 at 15:48
• If you'd like to see simple approaches, I'd definitely recommend a time limit, otherwise they won't stand a chance of competing. – trichoplax Jul 27 '17 at 15:49
• I think it will be very interesting either way. – trichoplax Jul 27 '17 at 15:50
• @trichoplax I'm inclined to find a way to convert usercode time to clock cycles and standardise the number of cycles, but that seems too complicated. – wizzwizz4 Jul 27 '17 at 15:51
• Any time limit should do, as long as the contestants know what it is. I don't think it makes much difference what it's measured in – trichoplax Jul 27 '17 at 15:56

# Render STL files

STL means StereoLithography. It's a common file format, used in 3D printing.

The way it works is quite simple. You change every surfaces to triangles. For example, a cube would have 12 triangles, since it has 6 sides, and each sides has 2 triangles.

In this challenge, you have to read STL(A) files and render them.

# Explain me more about the file format..

Well, technically, I linked you to the wikipedia, but I'll just explain, You can just, uh, go to the wiki if you want, you know?

Alright. the file is in this format.

solid [optional name]
facet normal ni nj nk
outer loop
vertex v1x v1y v1z
vertex v2x v2y v2z
vertex v3x v3y v3z
endloop
endfacet
endsolid [optional name]


The part you have to look is the vertexes. you can see there are 3 vertexes each with three numbers (each of them are coodrinates of each axes). Remember I told that you change every surface to triangles? These three vertexes form a triangle.

and the part between facet normal and endfacet will be given multiple times, forming multiple triangles, forming a 3D object. like the cube I told you before.

You do not have to look at the numbers right after the facet normal. it will not affect the shape. (at least in this challenge)

# Examples

I couldn't copy all of them so I decided to leave a link.

• "render (ASCII)" needs to be clarified. Dumping triangles to an OpenGL renderer is is easy enough. Drawing wireframe lines with a perspective camera of our own is still fine. Drawing lines out of pixels is something I'm yet to code. – John Dvorak Feb 15 '17 at 10:59
• @JanDvorak No, I meant Ascii STL(STLA), which is simpler than the usually used binary STL. Look at the wiki – Matthew Roh Feb 15 '17 at 11:01
• Are we to output STLA? If so, what is the input? – John Dvorak Feb 15 '17 at 11:03
• @JanDvorak the input is the STLA, and the job is to render the given STLA – Matthew Roh Feb 15 '17 at 11:04
• What does it mean to render something in ASCII? Is it sufficient to raytrace a two-char palette (hit/no-hit), or is shading or drawing the edges required? If you want edges, do we need to cull backfaces and occluded edges? – John Dvorak Feb 15 '17 at 11:08
• @JanDvorak Uhh, no. Noone told you to render in ASCII. – Matthew Roh Feb 15 '17 at 11:14
• It looked like you did. So, is it okay to just dump them into an OpenGL context and be done with it? Do note the default OpenGL settings use flat shading and put the camera straight at the back-front axis. – John Dvorak Feb 15 '17 at 11:18
• Eh, I don't even need a 3D renderer if I ignore the Z axis and draw lines from X,Y to X,Y. – John Dvorak Feb 15 '17 at 11:21
• Yes. Dumping to OpenGL is completely OK. But you should really beware of matlab, since matlab has A BUILTIN – Matthew Roh Feb 15 '17 at 11:24
• This is very underspecified. I don't see any mention of projections (orthonormal or perspective), back-face culling, z-buffering, shading, lighting, ... – Peter Taylor Feb 15 '17 at 11:30
• It seems that this is basically "receive a bunch of triples of 3D coordinates as input, and draw the resulting triangles". Is that the OP's intent? If so, I would do the usual thing of allowing flexible input structures. If the OP's intent is to text-process STL files, I don't find that too interesting. – Greg Martin Feb 15 '17 at 17:23
• @GregMartin Correct. That is the challenge. – Matthew Roh Feb 16 '17 at 5:29
• I have the feeling that wireframe with orthonormal projection would fit this challenge, but I do not know how to specify. – Matthew Roh Feb 16 '17 at 5:30

Sandbox notes

• This is the first time I write a controller; and it's been a while since I wrote an actual program. If you feel so inclined, feedback is appreciated.

Initial draft of the controller (java) here: https://github.com/S119349/cooperative-koth

## king-of-the-hill The Cooperation Game

In this challenge, instead of competing, players will have to work together to beat a game. The player who on average gets the best results over all game runs, is the winner for this challenge. The game is inspired on the mechanics of "The Game".

### Game mechanics

The goal of the game is to play as much cards as possible on four piles on the table. Two piles can only accept cards in strictly increasing order, the other two in strictly decreasing order. The game is over as soon as a player cannot play a card.

Piles

The game starts with four piles, numbered 0 through 3 inclusive. Piles 0 and 1 accept cards in strictly increasing order; piles 2 and 3 accept cards in strictly decreasing order. Initially, the piles are

Pile number |  0  |  1  |  2  |  3  |
Card |  1  |  1  | 100 | 100 |


There is an exception to the rule of accepting only strictly increasing/decreasing order. You are allowed to play a card exactly 10 less or more respectively than the current card. For example, if the piles are

Pile number |  0  |  1  |  2  |  3  |
Card |  1  |  32 |  78 | 100 |


you are allowed to play 22 on pile 1, or 88 on pile 2.

Taking turns

The game starts with a shuffled draw stack containing 98 cards, numbered 2 through 99 inclusively. Each player is dealt 6 cards at the start of the game. The cards are known only to the players themselves.

During a turn, a player must play at least two cards Exception: you only have one card, or you're out of cards, because the draw stack is empty, up to all the cards in their hand. After their turn, the player will restock from the draw stack to 6 cards (or less at the end of the game).

Reacting

After each card is played, other players are allowed to react: if you have the perfect card in your hand, you may want to warn players not to add anything to that pile! Since your cards are secret to you, this is done by assigning priorities to each pile. The priority is from 0 to 5 inclusive, with 0 signifying no interest at all in that particular pile, and 5 begging other players not to add anything to that pile. Other players can use these priorities as they deem fit; including completely ignoring it.

### Interaction with the controller

You will create a player that extends the abstract Player class. You will have to implement void turn() (for playing a card) and int[] react() (for announcing your priorities). A reference implementation, SimpleTom, is provided, but may be removed from the competition if there are enough competitors.

In void turn(), you are required to either playCard(int card, int pile) or endTurn(). Note that you may only play one card per invocation of turn(), to give other players an opportunity to react(). Doing anything else (playing two cards, playing no cards at all) will result in losing the game, with all the cards still in the game adding towards each player's score!

In int[] react(), you are required to return an array of your priorities on each pile. An example would be return new int[] {a, b, c, d} with a through d the priorities for each pile. Here, 0 <= a <= 5.

• ArrayList<Integer> hand contains all cards currently in your hand.
• In the gameState member of the default Player class:
• int [] gameState.piles contains the four piles. It is an integer array of size 4, with each element the last played card on that pile.
• Map<Player, int[]> gameState.priorities. A map containing the latest priorities issued by each Player in the game.
• Player[] gqameState.players can be used to list all the players in the current game; as well as determine how many cards they have by calling int nHandCards(). Note however that you may not access these players in any other way! (force them to do a turn, force them to lose, make them expose their hand, etc).

Concerning the other players: you may know who is playing and assess their skill during a game (for example, figure halfway through a game that SimpleTom is not trustworthy, and that two of the other players are of type SimpleTom). You may not save this information between games, or hard-code strategies concerning other players.

### Do's and don'ts

All entries are open-source. You are encouraged to write commonly used functions (e.g., something to keep track of what cards have already been played) as separate functions, so others may use them. When you use code from others, always attribute your source. It is not OK to copy someone's algorithm and just tweak a few values - your code should be significantly different from others.

You are allowed to use a different languages than Java, if you write your own wrapper class (or use someone else's wrapper class). I usually only use Try it Online!, so I don't have any compilers installed on my Ubuntu box. If you use another language that is not available on Ubuntu by default, please include a few lines on how to install your language. Your entry will be non-competing if it takes me more than two minutes to follow these instructions, so a script or copy-pasteable command line code is preferred.

• The API needs a bit of clarification: I don't see any way to access my hand; the spec contradicts itself on the return type of react(); and gameState.priorities exposes information about who else is playing: can I use that information or not? – Peter Taylor Feb 17 '17 at 11:01
• I think I understand the game. There's just one point, which I was going to mention in the previous comment but forgot: "Doing anything else (playing two cards, playing no cards at all) will result in losing the game!" What does that mean exactly? I presume that it's game over for everyone, not just the misbehaving player, but what does everyone score? – Peter Taylor Feb 17 '17 at 11:51
• @PeterTaylor Good point! It means game over for everyone - this is cooperative gaming, and this means no player can just wing it. However, averaging the scores over all runs should sort this out, and if it becomes a problem, I could modify the code to make sure all match combinations are played instead of my current Monte Carlo approach. – Sanchises Feb 17 '17 at 12:27
• The biggest reason it's important to specify it is that now that you've confirmed that players can see who the other players are, some might want to deliberately sabotage the game in the presence of their biggest rivals. – Peter Taylor Feb 17 '17 at 12:43
• @PeterTaylor I think I outlawed that by saying You may not save this information between games, or hard-code strategies concerning other players.. So sure, you can try to detect other players and sabotage them, but you would have to write some darn good AI to do that. – Sanchises Feb 17 '17 at 12:44
• @PeterTaylor if all the bots lose at the same time, then sabotaging your opponents sabotages yourself equally. – fəˈnɛtɪk Feb 17 '17 at 13:52
• @LliwTelracs, which is why it would be selective. If there might be multiple instances of the same bot in a game, I think it could work, at least as a king-making strategy. Sanchises, "hard-code strategies concerning other players" sounds like it could create arguments over whether heuristic X is a hard-coded strategy targetting a given player or not. – Peter Taylor Feb 17 '17 at 14:00
• @PeterTaylor I'm fine with targeting strategies at other players (isn't that what all KoTH competitors do?), as long as it's not hard-coded to act on a specific player (class name). In other words, your entry should behave exactly the same if another player changes their player name. So, it's allowed to know that player 1 and 2 are both the same type, and deduce that player 3 sucks, but it's not allowed to check that player 1 is actually the same bot as player 4 from the last game. – Sanchises Feb 17 '17 at 14:10
• I figured I did not have to enforce that in code, but given this confusion, perhaps I better enforce that using an interfacing class instead of directly? – Sanchises Feb 17 '17 at 14:15
• @Sanchises in my experience: yes. Make your API airtight. If they shouldn't be able to modify/read something, make it impossible to do so (outside of reflection). – Nathan Merrill Feb 17 '17 at 18:39
• Also, self plug: I've got a KoTHComm Java library that makes cross-language communication easy, as well as handles many tasks, such as assigning players to games, creating random variables for determinism, and even automatically downloading submissions. If you are interested, I'd be happy to help you use it. – Nathan Merrill Feb 17 '17 at 18:42
• @Nathan thanks for your suggestion. I should like to see what your library has to offer, but note that I code as a hobby, not professionally, so I'll excuse myself for odd questions in advance – Sanchises Feb 17 '17 at 22:12
• @Sanchises Java is a hobby for me as well :) I've created a chat room, if you want to come in. – Nathan Merrill Feb 17 '17 at 22:24

# Hex address to little endian escaped string

You are a brilliant hacker and you just gained access to a unprotected computer! To complete your exploitation, you need to convert a set of hexadecimal addresses into a different format.

You remember your lessons from university and you find out the machine you're on is little endian, meaning the order of the bytes is "reversed".

To make a break from your illegal activity, you decide to code a little program that does that automatically.

# The Goal

Convert a string of the form

0x12345678


to

\x78\x56\x34\x12


You set up a few tests and their potential results:

0x080483b4   =>   \xb4\x83\x04\x08
0x00000fff   =>   \xff\x0f\x00\x00
0xfffffff0   =>   \xf0\xff\xff\xff

The input is of the form 0xXXXXXXXX and the output must be of the form \xXX\xXX\xXX\xXX. The input will always be 10 chars long and the output must be 16 chars long.
The score is the number of bytes used to write the encoding function. If the input string appears in the solution (i.e. not passed as an argument) it is not taken into account. The display of the result is implied (e.g. no need to print, puts, ...).
• So if I'm understanding correctly, I need to make the type of code more explicit? I wasn't sure how to make it work for all languages, ... Also I'm not sure about needing the return statement for this challenge, nor the print ... What do you think? I'll remove the example for later, thanks :) – nobe4 Feb 19 '17 at 16:25