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

• How are tags added to questions? – guest271314 Jan 9 at 7:51
• @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] – DJMcMayhem Aug 29 at 15:19
• Why no featured anymore? Can't we have it auto-added or something? – JL2210 Sep 26 at 15:57
• @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary – caird coinheringaahing Sep 29 at 13:43
• I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . – AZTECCO Oct 5 at 19:39

# Missing distance between points

There are N points on a straight line. Someone calculates all possible distances between each pair of points and sort them.

In the following example I used 5 points. The sorted list of distances is [2, 5, 6, 8, 9, 14, 15, 17, 20, 22].

---X--X------X---------X-----X---

|-2|---6--|----9----|--5--|
|-----8---|-------14------|
|--------15------|
|---------17--------|
|----------20----------|
|----------22-------------|


You will receive the list, but one of the numbers is unreadable. This will be indicated by a zero. So you might receive the list [2, 5, 6, 8, 9, 0, 15, 17, 20, 22]. Your job is to find the missing number.

## Input / Output:

Write a function/program that finds the missing number. The input (via STDIN, command-line argument, prompt or function argument) format is a list or an array of distances (integers). You can optionally take the number of points (one integer) as a second parameter if you want. The output (via return value or STDOUT) is one single integer, namely the missing number in the distances list.

This is code-golf. Therefore the shortest code wins.

## Test cases:

#points, distances -> output
5, [2, 5, 6, 8, 9, 0, 15, 17, 20, 22] -> 14
3, [1, 0, 2, 2, 3, 4] -> 2
...


## Sandbox notes:

• This challenge is based on one problem of this year's Mathematical Kangaroo. My dad is a math teacher and brought me a copy of the 7.-8. grades test.

• Example and test cases don't look pretty and will be improved and extended for the final question on PPCG.

• My main concern about the challenge is the speed of the programs. My first (and only) solution is quite slow, because of the bad time complexity (about (n^2)^(n-1), where n is the number of points on the line). The 5-point example takes already about 1 second to compute, a 6-point example took about 10 minutes. My guess is, that most code-golf solutions will use a similar approach and the programs may be quite difficult to test.

There's definitely a better way of computing the missing number.

Maybe I'll add a few big testcases (one with 6, 7, 8, 9 and 10 points) and promise a 50% bonus if the program can solve all test-cases in under one minute.

• Are you sure the solution is unique? – xnor Apr 7 '15 at 23:25

The goal of this code challenge will be to take a grayscale image with shading as input and produce a height-map image with the same dimensions as output.

The input image will be a grayscale 256x256 png image, shaded with only a diffuse term, no ambient or specular term. It will be lit by a directional light source hitting the surface at a 45 degree angle, from above.

The output must be a 256x256 png image containing the height-map.

This is a code-challenge, the answer with the most accurate results wins. (A perfect match between the reverse engineered height-map and the original height-map used to produce the shaded image is near impossible, it is not expected that they are identical).

(working on test cases)

tags:

image-processing, code-challenge, graphical-output, conversion

# SVG file optimization

Yep, I got my idea off of this question, and it's amazing answer. All credit for this question goes to Illmari Karonen's answer

Now, for the challenge: Write a program that removes unnecessary clutter from SVG files in order to reduce their byte counts.

1. Remove comments <!-- comment -->
2. remove metadata <metadata ...> </metadata>
3. Shorten necessary ids to 1 letter, and remove unused ids.
4. remove unnecessary attributes and XML namespace attributes

Any other methods used to shorten the SVG files are welcome. (You can refer to the linked answer to look at an extensive list of ways to shorten SVG files)

Your program's score is how many bytes it removes from these SVG files:

test cases in progress

• See also Warm Welcome Secret Hat. If you're going to allow changing the paths, you should specify permitted changes / accuracy. E.g. if a transform is given to 3d.p. and the path coordinates to 3d.p., inlining the transform and then rounding to 3d.p. could produce visually perceptible changes. – Peter Taylor Apr 14 '15 at 9:47

# Randomly generated "Bézier petals"

## Introduction

A "bézier petal" is a:

• simple closed curve (no loops or self-intersection)
• made by two cubic Bézier curves which
• share endpoints
• but not necessarily control points

## Challenge

The challenge is to generate these randomly, such that:

• the entire space of possible valid curves is covered,
• any specific valid curve is as likely as any other,
• no "degenerate" (non-simple) petals are output.

## Background

I've been thinking about this for a while (see https://www.youtube.com/watch?v=TJdApKcAVD0), but was only able to arrive at a partial solution, which only covers a "safe" subset of possibilities (it never generates crescent or s-shapes). But, having followed this site for a while, I know that many of you are way more clever than I am.

## Output

The result should be a function which returns a single random petal, defined by two endpoints and two sets of two control points (six values in all) on a Cartesian plane — let's say with values between -1 and 1.

## Notes

Ideally, the algorithm works in constant time, or at least has a bounded stop; generating and filtering out degenerate petals until a good one is found is acceptable but a step down.

Entries which do not cover the entire possible space but do so with low complexity and at least beat out my "sort radially around center" approach are partial credit.

## Sandbox notes

I'll add some illustrations for valid and invalid petals, once I draw them.

• Are you sure "any specific valid curve is as likely as any other" is well-defined? – feersum Apr 22 '15 at 22:20

# Minimal convex partition (code-golf)

The goal of this challenge is dividing up the 'white' shape of a given 'black and white' pixel image into smaller pieces, which together form the original image (let's call this a partition). The restriction is that those pieces have to be convex, in our case everything is made up from square pixels, therefore the convex pieces can only be rectangles. Now of course you can just divide the whole shape up into the pixels it consists of, but that way you will get too many pieces (usually). The goal here is finding one partition that has the lowest number of (convex) pieces.

## Specs

### Input

The 'black and white' pixel image of $n \times m$ pixels is given as a string, row by row, each row separated by a comma. The white pixels are represented by a full stop ., and the black pixels are represented by a hash mark #.

### Output

The output consists of the same string, but now the white pixels must be replaced by alphabetic characters, one character for each piece of the partition. The minimal number of partition never exceeds 26 (you do not have to consider input that does not meed this condition), therefore you only have to use the letters a-z. If the minimal number is $n$, you have to use the first $n$ letters of the alphabet. Of course, the output is not necessarily unique.

Examples (without the commas, for better visibility):

n=2:
Input:
#.
..
Ouptut:
#A
BB

n=4
Input:
....
..#.
....
Output:
AABB
AA#C
DDDD

n=6
Input:
.....
.#...
.....
...#.
.....


# META:

I'd be happy for any interesting input examples. I could not think of any really interesting ones right away now.

• Very similar: codegolf.stackexchange.com/q/44654/14215 The output might not be minimal in some cases, though. – Geobits Apr 20 '15 at 16:26
• Thanks for pointing this out, I did not remember this challenge but it is indeed similar, but I still think looking for the solution with the minimal numbers of rectangles is again a different challenge, don't you agree? But I just noticed that I could write the introduction way more intuitive by using covering a region with rectangles instead of *partitioning into convex pieces*=) – flawr Apr 20 '15 at 19:28

Internet Relay Chat (or IRC for short) is a simple yet popular chat communication method. The challenge is to create a program that can take an IRC server from program arguments and print out new messages sent on that server.

e.g.: <your_irc_client> irc.freenode.net

A very simple implementation in Python of this idea which does not print responses to the user can be found here

# Interpret a Turing-Complete Language

This challenge is inspired by this esolangs.org page, which lists some languages with very small interpreters. There have been some similar challenges before, like this one about a self-interpreter, or a few other interpreter challenges, like one for BF.

This goal of this challenge is to write the smallest interpreter possible for a Turing-complete language. You may choose any Turing complete language (even one you create?) to interpret.

Your interpreter should take input representing the program to be executed, and give output representing the end result of the program. "Interactive" I/O is not required.

## More Rules

Your interpreter program may not contain/execute any eval-like commands.

• Maybe this could be a popularity contest, and whoever has the most creative answer wins? – ASCIIThenANSI Apr 20 '15 at 21:18
• I like this, but I think it needs to be more specific. Why not pick a specific OISC? That would probably be the winning strategy for the more general problem anyway. Also, I/O format should either be locked down or explicitly left open. If I'm golfing an OISC in Python 2, for example, I'd like to have the I/O be the memory of the machine represented as a Python list, read via input(). Is that okay, or cheating? – DLosc May 4 '15 at 4:06
• @ASCIIThenANSI For the popularity-contest version, see this question. – DLosc May 4 '15 at 4:07

# Number of ways to sum [1..n] with [n+1..2n] such that each sum is prime

In as few bytes as possible, write a program or function which produces this sequence (A070897), either as an infinite list on STDOUT, or in your interpreter of choice.

## Example

a(5)=2 because there are two ways: 1+10,2+9,3+8,4+7,5+6 and 1+6,2+9,3+10,4+7,5+8

## Rules

No built-in primality tests. No lookup table ;). No standard loopholes.

• Are build-in prime functions allowed? – Jakube Apr 22 '15 at 21:13
• Fixed //char count – alexander-brett Apr 22 '15 at 21:16
• It would be good to actually define the sequence explicitly in the question body instead of just in the title and by linking to OEIS (the link is still good for further reference, but it shouldn't be necessary to understand the question). Likewise, if you could reproduce the first 20 or so elements as test cases, that would be good to make the challenge self-contained. It's also not clear if "produce this sequence" means to print consecutive number ad infinitum, or given n to return a(n) or to return all numbers from a(1) to a(n). – Martin Ender Apr 24 '15 at 12:42
• @MB - I'll amend to repeat the title & give more examples. However I think 'an infinite list on stdout' is pretty clear? – alexander-brett Apr 24 '15 at 12:44

# Rabbit in a Snow Storm

## Scenario

A group member is giving a presentation in PowerPoint. He reaches a point where he wants to start writing on the whiteboard, but his slides have text that get in the way. He motions to the guy with the keyboard to just blank the screen so he can write. The next 2 minutes consist of everyone in the room bickering about how to do it until we arrive on using a full-screen-ish terminal (which is black, so we have to turn up the lights). Awful.

## Objective

Have the primary monitor become completely white.

## Rules

• You start with no programs running (or at least none that are important towards the goal)
• You may only use programs that are installed by default on your OS/distro (i.e. needs to be repeatable by someone else without installing anything in particular)
• You can't pre-load your background, slide-show, etc. with a pure-white image (though you could create the image then show it)

## Scoring

• Number of keystrokes required (keys depressed and released, i.e. opening Spotlight takes two (Command + Space), likewise Run... (Win + R))
• Clicks are scored as 5 keystrokes.
• In your scenario, PowerPoint is running. Yet in the rules, it isn't. I can understand if this is because the one-stroke solution w isn't interesting, but it still makes for a confusing question. Why not ditch PowerPoint from the scenario and replace it with a demo of some in-house software? – Peter Taylor Apr 23 '15 at 8:49
• Oh, and you should probably add to the bit about "installed by default" that the OS hasn't learnt which programs you use, so you should assume that no auto-completion occurs. – Peter Taylor Apr 23 '15 at 8:50
• @PeterTaylor I didn't know about w...magical! In the scenario the guy was actually using PDF slides, so I'm not sure if Reader has the same functionality. Good comment though, probably just forbid autocompleting? – Nick T Apr 23 '15 at 16:11

## Generate random seeds for strings

Consider the following pseudocode:

function randomString(long input) {
accumulator = "";
random = random.seededWith(input);
while(true) {
x = random.nextInteger(27); # generate integer 0-26
if(x == 0) break;
accumulator += x + 'a'; # add lowercase letter from a-z for values 1-26
}
return accumulator;
}


In other words, this generates a random lowercase string based on a random number seed.

Your job is not to write this behavior.

For this golf, your job is to REVERSE this process. Receive a String as input, and return the random seed that would generate this string, using whatever pseudorandom algorithm is included by default in your language - so different languages will have different numbers returned for the same string.

However, the algorithm used to regenerate the strings should be the same for all languages.

## Fine print

You may write a program or function, which returns the output as an integer or long (whatever's appropriate for your language) or printing it to STDOUT (or closest alternative). You may optionally include a single trailing newline in the output.

If the String cannot be generated in this method, your program should throw an exception and/or print an error message of some sort.

Additionally, standard loopholes which are no longer funny are banned. You may not use external libraries unless your language doesn't support seeded random number generation by default. If that is the case, then you may use the library for random number generation that is most commonly used by that language's community.

### Citations

This question has been brought to you by: Why does this code using random strings print hello world?

• "However, the algorithm used to regenerate the strings should be the same for all languages." I don't see how this can be possible, unless you're assuming either that the only way to do it is brute force (wrong) or that every standard library in the world uses linear congruential PRNGs (unlikely: there's probably some language designed by a security nut which only uses crypto PRNGs). – Peter Taylor Apr 25 '15 at 8:25
• @PeterTaylor I meant the pseudocode should be same, not the PRNG algorithm. – durron597 Apr 25 '15 at 14:38

# Structural Damage Simulation

(either or , haven't decided yet)

### Introduction

In this challenge, you are given a two-dimensional map or a brick structure. Each brick is glued to its four neighbors, and is guaranteed to be connected to the ground, that is, the bottom edge of the input grid, via adjacent bricks. This structure is affected by gravity, which may cause some of the bricks to break, depending on their durability. Your task is to predict whether this happens, and where.

### Spec

The input is given as a grid of the ASCII characters . and # that represent empty space and square bricks OR a black-and-white image with the black pixels representing bricks. You are also given a nonnegative number that represents the durability of the bricks; you can choose the valid type (integer or float) and range of this parameter and how it affects the computation. Your output is a grid in the same format as the input, but with some of the bricks replaced by Xs (or gray/red pixels); they represent bricks that have broken under the strain caused by the weight of the structure.

### Example

Suppose we have the following input grid (replace with an image if that's chosen as the input format)

................
..######...####.
..######...####.
..########.####.
...###...#.####.
.....#...######.
.....#.....####.
.....#......#...
.....#.######...
.....#####......
.....#######....
.....#######....


The narrow parts of the structure are likely to break, especially the vertical ones, but the solid parts may very well hold themselves together. A possible output would be

................
..######...####.
..######...####.
..######XX.####.
...###...X.####.
.....#...X#####.
.....X.....####.
.....X......X...
.....X.#XXXXX...
.....####X......
.....#######....
.....#######....


### Scoring

This is a popularity contest, meaning that the answer with the highest vote tally wins. Voters are encouraged to take the following criteria into account:

• Simplicity. Simple and elegant algorithms are favored over complex and over-engineered ones. Elegance includes reasonable speed, so very slow algorithms are discouraged.
• Realism. The outputs should be close to the physical intuition of most people.
• Flexibility. Solutions should preferably handle complicated structures and extreme values of durability.

# Cops 'n' Robbers - Hide a keyword in each answer answer-chaining

This is an idea I'm still working on, but I want some feedback on whether or not it could pan out well.

### Cops

The robbers are here! They've found our files! We, need to encrypt them! We need a certain key, something special that clearly shows what the real program is. We need to keep writing our new files, but we must keep encoding them. When a robber cracks a key, we find the key they cracked and write a new file off of that key! For example, we will hide the encryption key for file #2 in file #1, then file #2 hides a key for file #3, and so on. The files are safe if they go uncracked for 5 days, in which we win! But if the robbers crack all 100 of our files, we lose!

### Robbers

We found the cops' files! Not only that, we cracked their encryption scheme! In file #1, they hide a key for file #2, which hides a key for file #3, and so on. Our goal is to hack all 100 files. The only catch? We'll lose our connection if we don't crack a file within 5 days.

Basically, the cops will upload an answer with a program when the robbers crack the previous answer. The clue to the next answer is hidden in this one, encoded with the clue from the last answer. If a robber guesses wrong, that robber can not guess again on the same answer. If a answer remains uncracked for 5 days, cops win. If robbers guess all 100 answers, the robbers win.

### Winners

The winner for the cops is whoever made the uncrackable file. For the robbers, it's whoever cracked the most files (in event of a tie, later answers are better than old ones.)

• Just to be clear, each cop has to upload 100 files somewhere? – Geobits Apr 29 '15 at 18:09
• @Geobits No. The 'files' are the answers. The cops create 100 files (at any time) and post them (in order) as answers. The key to decode file #10 is in file #9. (File #1 will have its key posted in the question.) Robbers crack the code in a seperate thread. – ASCIIThenANSI Apr 29 '15 at 18:15
• The description right now is rather "themed" and isn't precise enough to explain the details of how the challenge will actually work. Themed intros are fine, but you should write a description that, for example, uses "answers" instead of "files" and uses a team name instead of "we." – PhiNotPi Apr 29 '15 at 18:43

# Astrometric Tiling

A common problem in astronomy is the stitching together of astronomical images to create a mosaic of the entire imaging survey. This can't be done by naively putting the images next to each other in a grid - they might have slightly different dimensions, and certainly have different positions & orientations, which might overlap.

The solution is to calculate the positions of the objects (usually stars) in each image in celestial coordinates, a process known as Astrometry. (This is not the challenge, as it's far too difficult for a codegolf, but if you're interested in that process, take a look at astrometry.net.) Once an astrometric solution for a given image is found, every star's position on the sky can be calculated based on its position on the image.

# The Challenge

Write a program to accept lists of coordinates for some number N>=2 of astronomical images, and output a transformation matrix for each image to create the mosaic.

# Input

You may accept either a list of coordinate lists, or a list of filenames containing coordinate lists, whichever is more convenient. The coordinate list (length >= 10) for a given image is made up of 4 coordinates per star: x,y in whole number pixel coordinates on the image, and a,d in float (requiring precision to at least 10^-5) celestial coordinates. Assume that every star's coordinates are exact, and that the same celestial coordinates in two different lists refer to the same star.

# Output

Your program should output a 3x3 affine transformation matrix for x,y in each image (alternatively, you can output a matrix for each image after the first, if you would like to use the first as a reference), which can be used to tile the images in such a way as to align the celestial coordinates in adjacent & overlapping images.

# Scoring

This is a (admittedly quite challenging) code golf, so shortest in bytes wins.

I'll need to produce a test case, which I will do before posting.

Create a program or function that, given a postfix expression, converts it to the simplest equivalent expression. The expression may contain real numbers, floating variables denoted a to z, and the basic arithmetic operators +-*/^.

Two expressions are equivalent if they produce the same result for all possible integer values of the variables. "Simplest" means you should return the equivalent expression with the least number of operators. If there are multiple expressions with the same number of operators, pick the shortest.

## Example

Consider the expression (8+4*y)/2+x*2. In postfix notation, this would be

8,4,y,*,+,2,/,x,2,*,+


This should yield the output

2,2,y,+,x,+,*


which corresponds to (2+y+x)*2.

Question:

this challenge is irrelevant of code length , so i want to ask , any scoring methods i can use in this defiance

i propose : picked up nine variant expressions with different polynomial degrees , which im free to choose , tested as input for all concurrent codes , then validate the lowest sum = (number_of_operations)^2+length(output_string)

# Detect limit points in (possibly) oscilating sequence

### Popularity Contest, Algorithms

Given an (infinite) sequence of numbers, your task is to find an algorithm (and write a corresponding program) that takes the sequence as input and determines

• Whether the sequence converges to a cyclic behaviour. That means the sequence will oscillate throu one or more values, that means whether it has one or more limit points. In this case it should output the limit points.

• diverges (does not end up in one or more limit point). In this case it should output a message that says so.

• No defined behaviour for sequences that do not have acyclic limit points.

A limit point is a value such that for every neighbourhood of that value an infinite number of sequence elements are within that neighbourhood.

Of course you can only use a finite part of the sequence, so you the task is ambiguous, but the larger the given sample the better your algorithm should be able to dectect the cycles. As this is difficult to achieve for arbitrary sequences, you are allowed to use 'fine tuing parameters' that can be changed manually in order for your algorithm to work best for the given set of sequences. Please document what those parameters do.

In this case here, you can assume that the sequence will converge to a behaviour where it cycles throu all the n limit points without gaps (intermediate values that are not limit points) and always in the same order.

### Motivation

You perhaps have already see this diagram (the bifurcation diagram of the logistic map)

In order to generate this diagram, you have to compute a sequence for every r and compute the limit points x of each of those sequences (which in this case are cyclic). Then you plot those x against r. The sequence is generated by the recursive function (logistic map) with a starting value 0< x(0) < 1 (usually something like 0.5)

x(n+1) := r * x(n) * (1 - x(n))


The sequences generated this way are nice examples of the sequences that your algorithm should be able to detect.

should consist of

• a function/program that executes your algorithm on a given sequence (input in any way you like),
• a description of how your algorithm works,
• and a program that uses your function for generating the bifurcation diagram above.

### Examples

Following sequence is generated by 1+(-1)^n*(10+n)/n This sequence does not converge in the usual sence of sequences but it has limit points at 0 and 2. The sequence looks like this, so the

This is from the example above (logistic map with r=3.5), here we have 4 limit points:

The following sequence is bounded (and therefore has at least one limit point) but does not converge and does not seem to have a cyclic behaviour. (It is generated by x(n) = [pi*n^3 (mod e)]/e)

# META:

I'm happy to hear from you what you think. So far I did not find any sources that described algorithms that do exactly this task, but there may very well exist such algorithms. If you can improve the text please do so! Any suggestions are welcome.

• Can you put in some example input/output? I'm still a little confused about the challenge – Sp3000 May 13 '15 at 1:15
• I know my wording is not that great, please tell me what to change! I just added some examples. – flawr May 13 '15 at 8:51
• What I mean is, is the string "1+(-1)^n*(10+n)/n" the input, will it be the sequence of numbers generated by the expression or...? – Sp3000 May 13 '15 at 8:59
• No the input is a list of numbers (or a function that can be repeatedly called and returns the next list element or something similar), so you do not need to parse an input, the mail goal is finding an algorithm that is looking for cyclic limit points, the actuall details of the program are not that relevant. Is that clear now? – flawr May 13 '15 at 9:01
• I was a bit worried that might be the case. What if you have something like 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, ... (a googol numbers later), 1, 0, 1, 0, 42, 42, 42, 42, 42, 42, 42,... (42s forever after)? – Sp3000 May 13 '15 at 9:35
• This is obviously a difficulty, as a reasonable algorithm can only consider a first (finite) section of the sequence, and it should find the a answer as good as possible with the given data. So the sequence x(n) = (-1/2)^n looks as if it is gonna be alternating between two points if you only consider lets say x(1),...,x(5), but if you consider the first 100 elements it could become more clear that is only one. So the algorithm should basically provide a criterion to make a classification with only limited data. And the more real examples it recognises the better. – flawr May 13 '15 at 13:26
• In your case as long it sees only 0,1,0,1,0,... the algorithm should obviously return the limit points 0 and 1 (cycle length 2), but if it gets e.g. one 42 at the end of the data, it could output that the sequence does not converge. But as soon as there are enough 42 it should probably say that the sequence converges to 42. (cycle lenght 1) – flawr May 13 '15 at 13:29

## Quaternion calculator

Quaternions are extensions of the complex number system that are used in 3d graphics and some other applications. In addition to i, there is also j and k. j^2 and k^2 are both -1, however, ij=k, jk=i, ki=j, ji=-k, kj=-i, and ik=-j. Write a calculator that can calculate addition, subtraction, multiplication, division, and exponents. This is a code golf challenge, shortest answer wins.

EDIT: sample input: (2+4i+3j)*i^(j+2k)/(5j-i)+1

• This should specify how operands and operations are given as input. However, this is a borderline duplicate. Multiplication has already been done, exponentiation can be trivially reduced to that, addition and subtraction and fairly uninteresting, so that leaves only division. So just doing division might be a better idea. – Martin Ender May 13 '15 at 18:08
• I had considered a sequel with division or inversion, but thought it was too likely it would be implemented as multiplying by the conjugates and rescaling by the norm, which would mostly still be about multiplication. – xnor May 14 '15 at 23:46

# Kaos Pendulum and Einstein's Revenge

The Double Pendulum system is a relatively simple system with quite complex behavior that's highly sensitive to initial conditions (i.e., "chaotic").

Doctor Kaos has designed a particularly fiendish double pendulum, using his diabolical machine "Einstein's Revenge". Einstein's Revenge is a device which couples matter and energy, causing the mass of the first pendulum (connected to the anchor point) to be a function of the energy of the second: m1 = sqrt(PE2**2 + KE2**2), with the potential energy measured from the rest position of the pendulum.

For this challenge, you must write a program or function to simulate a basic Kaos Pendulum, where the second pendulum has unit mass and both pendulums are unit length. It must accept the starting position of the Pendulum - two real numbers, theta1 and theta2 - as input or command-line arguments, and one positive integer equal to the number of seconds the pendulum will be active.

Your program must output the value of theta1 and theta2 for each second, either printing to stdout or returning as a list, or something similar.

## Notes

I don't know if this should be a golf, a popularity contest, or if there should be some scoring method for some other type of challenge.

# Blind (deterministic) Jenga

The idea for this came up in the chat room, under the broader topic of how to make a human dexterity game into a software KotH challenge. Here's the basic idea, which I don't think works, but I'd love to get feedback to make it better.

The jenga tower has three blocks per layer. Layers alternate between N/S aligned blocks and E/W aligned blocks.

There may be just two players, or more than two.

Each turn a player selects a block location to probe. If there's no block there, the player gets to go again. If there's a block there, it is removed from the stack. If this causes the tower to fall, the player loses. Otherwise, the block is placed in the next safe position at the top of the tower, unless all available positions are unsafe in which case the player loses. If the player has not lost, it is now the next player's turn. Continue until some player loses.

I think this won't work well because it will boil down to a relatively random competition between bots that start with edge pieces and bots that start with center pieces. I don't want to run the contest just to find out that that's the case. Maybe putting four blocks per layer would make that a non-issue. I'm open to other suggestions on how to make this challenge work.

A idea. Maybe I'll do it a long time later...

You have these options each turn (they need better names and a plausible background):

• Meet k If the bot k also did meet you, and nobody injects, both of your scores are increased by 1. Otherwise nothing happens. But if k is yourself, this is invalid and will be just like doing nothing.
• Invite k The bot k gets a notification that you are doing this, and in the next round, your output is ignored and you must do Meet k.
• Inspect k You will get these informations at the beginning of next round:
• What the bot k was doing.
• The score change of bot k.
• Who was inviting bot k.
• Who was trying to meet bot k. (This is not known by bot k if not inspecting himself and his score is not changed.)
• Who was inspecting bot k. (This is not known by bot k if not inspecting himself.)
• Who was injecting bot k (and another bot). (This is not known by bot k if not inspecting himself and his score is not changed.)
• Inject j k If j is meeting k and k is meeting j, your score is increased by 10 and their scores are both decreased by 1 instead. If one of them is pretending doing that, and the other is pretending or really doing that, your score doesn't change. Otherwise, your score is decreased by 10. They'll not know who is injecting unless they are inspecting you or self-inspecting instead.
• DoNothing Nothing happens.

Possible other options:

• Pretend action: action is any action other than Pretend. It's the same as doing nothing, but inspectors will be told that you are doing that action. The score change that the inspectors will see is calculated as if you really did that.
• Multiply: For each turn until the next time you meet some bot each other, the points you, the other bot and all the bots injecting you get are doubled (or incremented, I'm not sure).

Everybody can see only their own score, bots inviting them and the result from Inspect.

• I think that Pretend is a great action, and should definitely be included. – Nathan Merrill May 22 '15 at 19:30

# Is this a red-black tree?

A red-black tree is a binary search tree where each node has an additional 'colour' property, which can be black or red. The root and leaf nodes must be black, each red node must have black children, and the path from any node to any child leaves must have the same number of black nodes. For instance:

2B
|  \
1R  3B
|   |
~   ~


Is invalid because of a black violation (the path from the root to each leaf has a different number of blacks).

Your task is to determine whether a given tree is a valid Red-Black tree.

## Input

The input will be a string matching [ a-zA-Z]. A space represents a leaf, a lowercase character a black node, and an uppercase character a red node. The value of a node is the position in the alphabet: a is 0, b is 1, C is 2, and so on. The children of the node in position n are in positions 2n+1 and 2n+2. If the string ends before the position you're looking for, that node is a leaf. For instance, baD cf E corresponds to:

       1,B

/     \

0,B         3,R

/     \

2,B         5,B

/

4,R


## Output

Your program should output something other than whitespace on STDOUT if and only if the input represents a valid tree.

## Simple test cases

True      False
" "       ""        (Root black violation)
"a"       "A"       (Root black violation)
"dBeac"   "dBea"    (Black violation)
"dAE B"   (Red violation)


Question about extrapolating data from an incomplete tennis scoreboard

Introduction

It is a fine day at the Stack Exchange tennis club. The players have just finished playing a grand tennis tournament in a round robin style (every player plays every other player once). The final results were about to be announced when suddenly, the scoreboard explodes! It is a total disaster - now nobody knows what the final scores were! Luckily, a piece of the scoreboard is still intact. Can you write a program to figure out the rest of the scoreboard from only a small part of it?

If there are k players, our scoreboard would have had k*3 entries, indicating each player's wins, losses, and draws. It is presented in a list of space separated comma separated tuples. For instance, in a game with 4 players here is a possible final scoreboard:

0,2,1 3,0,0 1,1,1 1,2,0


In this example the first player did not win anything, lost twice, and drew once; the second player won all three of their matches; the third player won once, lost once, and drew once; and the fourth player won once and lost twice.

Input Description

As input, you are given a scoreboard similar to the one above, except some of the numbers have been replaced by ?. The ? indicate the numbers that were unrecoverable after the explosion. For instance:

?,?,1 0,?,0 ?,?,?


Output Description

Output the scoreboard, with the ?s replaced with the actual scores. The input scoreboard will always have enough information for you to deduce the final scoreboard.

For example, consider the above input. We know that the second player has 0 wins and 0 draws, therefore, they must have lost both of their games. The first player has a single draw, and since we know the first player beat the second player, that draw must be with the third player. Thus the output is:

1,0,1 0,2,0 1,0,1


Sample inputs and outputs

TODO: Sample inputs and outputs of higher k


Sandbox Questions

• I have an alternate formulation for this question where instead of an incomplete scoreboard, the complete scoreboard is given and the program has to generate a table of which player beat which player. Which challenge do you think would be more interesting?

Sudoku Swapping Shenanigans

Honestly, there's not many shenanigans in this challenge but I wanted that sweet tautogram title.

Introduction

Imagine you're on a train, and there is a Sudoku grid that's already been entirely filled in left on the seat. We'll represent this grid as a series of 81 comma separated integers from 1-9 on a single line. Each cell in the grid can be numbered as follows:

As with all Sudoku grids, there will be exactly 9 of each number present in the input.

The Sudoku grid will not be completed correctly. It will have the right number of each number, but they will be positioned wrong. Your program's task is to swap these numbers to solve the Sudoku puzzle correctly.

(Since your stop is next, you want to make this program solve the Sudoku puzzle as fast as possible.)

or:

(Since you're writing this program on a napkin, you want to make it use as little bytes as possible.)

Input Description

Input consists of 81 positive integers that are comma separated. Some of them will be prefixed with an X which means those are the ones that are already placed and you can't swap them.

Example input goes here.

Output Description

Output the swaps required to solve the grid in the fewest number of swaps. You should have a line for each swap, consisting of two numbers in the form:

a,b


where a and b are both different and in the range 0-80.

Here's an example output (and I haven't actually written the example input yet!)

80,0
8,9
14,15


So that would mean that to solve the grid we need to swap the number in position 80 with the number in position 0, the number in position 8 with the number in position 9, etc.

Sandbox Questions

• Are we trying to solve it in the fewest number of swaps, or just transform it into any solved sudoku grid (meaning I could swap every input into a single predetermined pattern)? – Geobits May 27 '15 at 16:11
• @Geobits Fewest number of steps. – absinthe May 27 '15 at 22:03
• Do you guarantee that the original clues give a unique solution? If so, there's a lot of overlap with existing Sudoku-solver questions, and fastest-code would need a very large and well-chosen set of test cases to be confident that it's not overly sensitive to the order in which heuristics are applied. The interesting (IMO) part of the question reduces to "Decompose a non-simple graph into cycles", and I think there may be better settings to present it. – Peter Taylor May 30 '15 at 13:40

Code golf challenge: Write a program or a function that solves the following problem. Normal code-golf rules apply.

Given a set of subnets, give the smallest possible network these can belong to. You should consider the network- and broadcast addresses in your calculations.

Example input:

128.208.0.0/18
128.208.128.0/17
128.208.96.0/19


Example output:

128.208.0.0/16


You might want to read up on IP prefixes before trying this.

# Flash Cards Viewer

In this challenge, your goal is to produce a flash card viewer. Since this is a Code Golf challenge, it won't be a particularly featureful flash card viewer - in fact, it'll be the bare minimum a flash card viewer can be. We'll implement the following features:

1. Reading a list of flash cards from a file;
2. Quizzing the user on either "side" of the flash cards;
3. Reporting to the user which ones they got incorrect.

Input Description

As feature number 1 suggests, for this challenge you must read input from a file (unfortunately, your language cannot participate if it does not support reading from a file). The file shall be called cards.txt and will be formatted as a simple list of values separated by a pipe character |. For instance, a "Family Names in Chinese" flash card deck might look like this:

Mother|妈妈
Father|爸爸
Elder Sister|姐姐
Younger Sister|妹妹
Older Brother|哥哥
Younger Brother|弟弟


Output Description

First, your program should ask the user which side of the cards they want to revise, using a user input function such as prompt() or raw_input(). An input of 0 indicates the user wants to revise the left side of the cards, and an input of 1 indicates the user wants to revise the right side of the cards. Use the message "Choose side:" when asking the user.

After that, the program will pick out random entries from the opposite side of the user's selection, and prompt the user to type in the entry's corresponding value. After the user has gone through the entire list, output the pairs that he or she got incorrect.

Here is an example of what a possible session might look like. What the user inputted in this example is signified with >.

Choose side:
>0

>Younger Sister

>Mother

>Father

>Younger Brother

>Older Brother
Older Brother|哥哥
Younger Brother|弟弟


# Fibonacci Box Packing Factory

### Introduction

The Electronic Goods Company is a company that produces electronic item of various sizes. They need to package their items in boxes so that they can be shipped off to the store. There are some restrictions regarding what item can be stored in what box:

1. Each box can only contain a single item, and each item can only be contained in one box;
2. The volume of the item cannot exceed the volume of the box;
3. If the volume of the item is exactly the volume of the box, the item can be placed in the box without any padding material required;
4. If the volume of the item is less than the volume of the box, then padding material equal to the difference of volumes must be placed in the box to prevent the item breaking.

For example, an item that had a volume of 2m3 could be placed in a box of volume 2m3 without any extra padding material, but if the same item was placed in a box of volume 5m3, we'd need to add padding material of 3m3.

The supplier company is called the Fibonacci Box Company, which supplies The Electronics Goods Company with N boxes and P metres squared of filling material. Each box's volume is determined by the Fibonacci sequence (so the first box's volume is 1, the second is also 1, the third is 2, the fourth is 3, the fifth is 5, etc.).

Your program goal is to figure out the minimum amount of padding material required to pack all of the electronic items.

### Input Description

Input is a space separated list of integers that indicate the volume in square metres of the electronic items.

//TODO: Example inputs and outputs


### Output Description

Output the minimum value of P required to fill all the boxes.

//TODO: Example inputs and outputs

• I'm assuming that items can't be split between multiple boxes, and that a box can't contain multiple items? – Nathan Merrill Jun 1 '15 at 4:03
• @NathanMerrill Yep. Rule 1 states only one item can be placed in each box. I'll edit for clarity. – absinthe Jun 1 '15 at 4:05
• A couple example would help understand the challenge. You could also add some explanation to them. E.g. 1 5 8 7 => 6 (N = 7, boxes = 1 1 2 3 5 8 13, used boxes = 1 5 8 13) if I understand it correctly. Volume is cubic metres, m3. – randomra Jun 1 '15 at 4:43

# NP Cops and Robbers

This is an idea I've had for a while, and I really want to get it to work, but there are some large hurdles.

Hurdle 1: I need to pick a puzzle, preferably one that is NP-Complete. I think lots of Nikoli puzzles are good candidates, and I am leaning towards Light Up

# Cops:

Cops will write a program to generate a puzzle. The puzzle has a maximum size of WxH. The cops must be able to generate the puzzle in under 1 second. Puzzles must be deterministic, but randomness is allowed as long as I can set the seed. The puzzles generated must have only 1 solution. The cop will post a sample puzzle in his post (for the robbers to use)

Your score is the shortest time any of the robbers solved your puzzle. Highest score wins.

# Robbers:

Robbers write programs to solve the puzzles. Robbers are not allowed to target the specific puzzles, but are allowed to target the specific algorithms used to generate the puzzle. If the cop were to change the sample puzzle posted, the robber should still be able to solve the new puzzle in a similar amount of time.

If you solve a puzzle faster than any other robber, your score increases by the time taken to solve that puzzle. Highest score wins.

Hurdle 2: How to measure time taken. I don't want to run all of the cops/robbers, especially if this becomes popular. I also don't want to use the GOLF framework, as that would take a really long time to run. So, possible I could have the person run som CPU-intesive algorithm on their computer, measure how long it takes, and scale all of their answers according to that time.

# Create a basic spell checker

In this challenge, you have to implement a basic spell checker. Your program will use the first input as a source.

## Specifications

• You will receive two inputs, one is a sentence/paragraph you use as a source for your spell checker, and the other includes wrong words (they can be correct too) which you have to correct using the first input.
• Possible mistakes: Missing one letter (e.g. helo), one extra letter (e.g. heello), substitution of one character (e.g. hilp instead of help), transposition of two adjacent characters (e.g. hlep instead of help).
• In other words, the mistake and the original word have to have a Damerau–Levenshtein distance of one.
• You can separate the inputs in any reasonable format. For example, instead of using a newline, you can use a pipe sign to separate them. (|) However, watch out so you don't use something like letters because they are used in the 1st input.
• It's possible for a word to have neither an identical word nor a word with 1 distance from the first input. You will have to leave them unchanged.
• You don't need to do anything with punctuation. That is, I won't test words that are followed by a punctuation. (E.g. From the first example, I won't ask the correction of 'blod')
• Challenge is case insensitive, both the input and output. Meaning that if 'The' is used in the 1st input and the 2nd input is 'teh' you can change it to 'The', 'teh', 'teH', and similar cases.
• If a word is in the first input, but also has a distance of 1 with one of the other words, do not correct it.
• If there are two words with the same distance, you can output either of them. (E.g. 'en' can change into 'on' and 'in' if the words are both in the first input.) You can also output both of them, but you'll have to use a slash between them. (E.g. 'en' can be corrected into 'in/on')
• You can assume words are just sequences of letters separated by spaces.
• You can use STDIN or the closest alternative in your language.
• Standard loophole rules apply.
• This is , so the shortest code wins.

## Examples

Input:

A criminal strain ran in his blood, which, instead of being modified, was increased and rendered infinitely more dangerous by his extraordinary mental powers.

increasd mnetal


Output:

increased mental


Input:

The fact is that upon his entrance I had instantly recognized the extreme personal danger in which I lay.

I recognizi dnger en


Output:

I recognize danger in

• There are several definitions of "distance". Since the most common one is probably Levenshtein, you might want to specifically say that original and mistake have to have Damerau–Levenshtein distance of one. Other questions: what is a word? Only sequences of letters? What about "doesn't" or "up-to-date"? (It's probably simplest to rule those out.) What do we output if there are two different words with distance one? E.g. does en become in or on if both are in the first string? – Martin Ender Jun 3 '15 at 20:33
• Is the input case insensitive? If so, is case of the output arbitrary too or do we have to preserve the input capitalisation? And are we guaranteed that every word in the second string has a word in the first string that is no more than distance 1 away? – Martin Ender Jun 3 '15 at 20:34
• @MartinBüttner I clarified it in the bullet point above it. Only transposition of adjacent letters, one missing letter, one extra letter and a wrong letter. I guess that's Damerau-Levenshtein distance. Regarding the two words problem, I guess you could output either of them. I'm not really sure about this. I'm open for ideas. – JNV Jun 4 '15 at 4:49
• @MartinBüttner Good point. It's case insensitive, and the output can be in any case. (e.g. If the first input includes 'The' and there's 'teh' in the second input, it should output 'the' or 'THE' or 'tHE' or ...). No, you're not guaranteed that there's a word with a distance of 1 in the first input. Take a look at the example #2, 'I' was not changed. Also, in your previous post, you asked what counts as a word. I already said it in the post 'You can assume all words in the 2nd input are separated by spaces.' I'll edit it for clarity. – JNV Jun 4 '15 at 4:56
• I was asking for distance "no more than 1 away". That is, could there be a word that has neither a word with distance 1 nor an identical word in the first input? "You can assume words are just sequences of letters separated by spaces." Yet in the first input, there is punctuation. What sort of punctuation should we expect? The rest looks good. – Martin Ender Jun 4 '15 at 12:43
• @MartinBüttner Yes, it's possible for a word to have neither an identical word nor a word with 1 distance from the 1st input. You can ignore the words that are followed by a punctuation, like blood in the 1st input. They won't be in the test cases. (E.g. I won't ask for the correction of 'blod') Thank you for your help. – JNV Jun 4 '15 at 13:10
• As for the 'lay' in the first example, I'll fix it now, thanks. – JNV Jun 4 '15 at 13:19
• Right, but the question is what do we do with words that have neither an identical word nor a word with 1 distance from the 1st input. Remove them? Leave them changed? Also, that second point might be worth mentioning in the spec. – Martin Ender Jun 4 '15 at 13:19
• @MartinBüttner Leave them unchanged. Thank you for your support. – JNV Jun 4 '15 at 13:26

# Multiply with restricted operations: Best lower bound

Multiply with restricted operations is a challenge to multiply two variables using as few as possible of four allowed operations: addition, reciprocal, negation, and variable assignment. The current best is 22 operations.

Your goal is to prove a lower bound L, a number for which you demonstrate that there are no solutions with fewer that L operations. The highest L wins.

You must explain why your code demonstrates the lower bound, and I must be able verify your code by running it. There is a time limit of 30 minutes. The natural approach is to search the space of possible solutions, perhaps shrinking it via mathematical arguments, but any method is allowed. Purely mathematical proofs without code are also valid.

Your code is limited to 30 minutes and 3GB of memory on my machine (Windows 7 with a Intel Core i5-460M processor). I may be satisfied with someone else running your code to confirm with a conservative adjustment for different machine speeds.

Your code needs to run on easily-available free software. Please include instructions on how to run your code.

The winner will be the highest lower-bound proven by [date]. Tiebreak is fastest runtime on my computer. I will give a bounty of 500 rep to the winner.

If your lower bound matches a solution, narrowing down the optimum to a single value, I will award you an additional bounty of 300 rep.

For Sandbox:

• I haven't done a fastest code before. Anything I'm missing? Any machine specs I should add?
• Maybe you should require the program to be able to prove lower bounds for arbitrary expressions, rather than only a*b. Otherwise, it will be impossible to tell if a brute-forcing program is doing anything correctly, for any bound too low to find an answer. – feersum Jun 8 '15 at 17:35
• @feersum I'd really like to let people optimize for just multiplication since that's the function I care about. Is it really impractical to verify that code is doing the search correctly if the user is required to give a detailed explanation of their method and why it works? I trust people to be honest as to what the code does. – xnor Jun 12 '15 at 17:49
• I do believe it is impractical. How can you really tell that someone is not randomly twiddling bits and then printing 19? It seems that (innocently) bugged answers are more likely than correct ones in an environment where there is no testing. – feersum Jun 12 '15 at 18:01

# Date-A-List!

### Introduction

The year is 20XX. Lists of integers are now members of society with a full set of rights. Like humans, lists like to have dates and get married. In this challenge, we'll produce a program "Date-A-List!" that will get as many lists as possible on happy and compatible dates. Lists tend to prefer using programs that use as little bytes as possible, so this program will be golfed.

Lists are compatible (that is, you can assign them to a date together) if they share 2 or more integers in the same order. For instance, the lists (1 2 3) and (2 3 5) would be compatible. The lists (1 2 3) and (3 2 5) would not be compatible because they do not share 2 or more integers that are in the same order.

Lists are also always monogamous -- they will never go on a date with more than one list. For instance, consider the lists (1 2 3), (2 3 5) and (5 1 2) -- although the first list is compatible with both of the others, it may only date one of them.

### Input Description

Input is a list of lists in brackets, space separated:

(1 2 3) (2 3 5) (5 1 2)


That input would indicate three lists to be assigned to dates: [1, 2, 3], [2, 3, 5], and [5, 1, 2].

### Output Description

If n is the maximum number of dates possible, output n lines, each line consisting of two space separated lists which are to be matched up. For instance, on the example input there are two possible outputs:

(1 2 3) (2 3 5)


or:

(1 2 3) (5 1 2)


[TODO: More complex inputs and outputs]

• It would be nice to include the word "matching" somewhere in the text, for searchability. It would also be nice to have the basic examples use slightly more variety: at present they're all 3-element lists which overlap on adjacent pairs, but neither of those are stated as constraints. How about using (1 2 3) and (2 5 4 3) as the example of compatibility? – Peter Taylor Jun 6 '15 at 13:43

# 5-a-side Toroidal Bot Soccer

## Randomised teams

This is a team game. Rather than being assigned permanently to one team or the other, each bot will play in a number of games, each for a different randomly composed team of 5 players ("5-a-side"), and score a point for each game in which its team wins. This means every game requires team work, but there is still a single overall winner after all games are played.

## Rules

There are no rules for the players (no referee, no penalties, no off-side rule). The movement of the ball defines the score and the players can do as they see fit.

### Scoring

There are no goal posts. If the ball moves off the right hand edge of the field, it reappears at the left hand edge of the field and team 1 scores a goal. Similarly team 2 score if it moves off the left hand edge and reappears at the right. The score will be represented by a single integer, that is increased by one when team 1 scores, and decreased by one when team 2 scores. At the end of a game, team 1 wins if the score is positive, team 2 wins if the score is negative, and a zero score is a draw/tie.

Movement over the top and bottom edges has no effect on the score.

The game lasts for 2000 time steps (each bot provides 2000 moves). If there is no winner by the end of the game it is extended by up to a further 1000 moves, with the game ending if either team scores.

## Physics

Physics is the main obstacle to real world toroidal soccer, and will not be respected in this game. The physics have been simplified as much as possible to hopefully allow games to be viewed live.

This is a non-contact sport. Bots pass straight through other bots (of either team) with no interaction. Each bot can only interact with the ball.

The playing field is a continuous rectangle of width 100 and height 50. The bots and the ball have radius 1. Bots and ball can move freely in any direction without meeting a boundary - the edges of the field wrap. The ball will rebound from any bot if their circumferences overlap.

### Turning and acceleration

Due to the use of simplified physics this is quick to explain:

A bot has a facing angle and a velocity. A constant acceleration applies in the direction specified by the facing angle. Drag is a deceleration proportional to the velocity (an acceleration in the opposite direction to the velocity, proportional to the size of the velocity). This means a bot that does not turn will accelerate to a maximum velocity where the drag matches the acceleration.

A bot can turn any angle instantaneously, but the velocity (and hence direction) will only change gradually. For example, a bot changing direction by 180 degrees will continue travelling backwards while it slows down to zero velocity, and then accelerate in its new direction.

The ball has no acceleration of its own, so other than collisions, its only change in velocity is due to drag. There is no spin.

### Collisions

Only the ball can be involved in a collision with a bot - bots pass straight through each other.

Although the radius of both bots and ball will be displayed visually as 1, I believe the results are the same if collision calculations are based on the bots having radius 2 and the ball being a point.

To keep calculation simple, the ball will be tested for collision with each bot by considering the bot to be a circle moving with constant velocity and the ball to be a point moving with constant velocity (that is, the acceleration will occur at instants, rather than continuously over time). Since this is also how the motion will be modelled generally, the collisions should be consistent with the motion of objects in the game.

This allows the exact point of collision to be calculated so the rebound can occur with no overlap.

## Communication

There is no communication between bots. Each bot communicates solely with the controller.

The communication method will depend on the controller type (language agnostic/specific). Players will either be functions/objects in a specific language, or separate programs that communicate through STDIN/STDOUT.

Each step all bots will be supplied with the same information, and will provide a facing angle which will be a float in the range [0, 360).

The information supplied to bots will be as follows.

• Team direction (1 for team 1 or -1 for team 2)
• Current score (positive if team 1 is winning, negative if team 2 is winning)
• Facing angle and velocity of itself
• Facing angle and velocity of 4 team mates
• Facing angle and velocity of 5 opponents

Facing angle will be given as a float. Velocity will be given as x and y components, so two floats.

The information will therefore be received as two integers followed by 15 floats.

# Sandbox questions

• Are any terms not familiar that would be worth linking or further explaining?
• Are there any further simplifications that could be made, without detracting from the game?
• Are any of the simplifications too much? Am I overlooking some way in which the game could become trivial?
• Is it correct to model the bots as radius 2 and the ball as a point? Does this give identical results to modelling the bots as radius 1 and the ball as radius 1?
• Are there any problems likely to arise from basing collision detection on constant velocity bots and ball? (Acceleration being applied instantaneously each step, rather than spread out over continuous time.)
• How long does each game last for? I like your idea of randomising the teams. How many bots are in each team? – euanjt Jun 16 '15 at 7:55
• @TheE The "5-a-side" in the title refers to 5 players per team - I wasn't sure how widely known that was so I'll edit that in. – trichoplax Jun 16 '15 at 12:41
• @TheE I'm not sure how long each game should last yet - I'll have to test with some example players once the controller is written. For now I'll say 2000 steps in order to have something that people can comment on. I guess it will depend on what acceleration and drag figures I settle on too - as that affects how far each bot can move per time step. – trichoplax Jun 16 '15 at 12:45
• If a player of the right team stays on the left part of the field, he could counter score every goal it's team take, right? – Katenkyo Jun 16 '15 at 13:26
• Yeah I didn't read the title :) oops – euanjt Jun 16 '15 at 14:00
• @TheE no problem - and thanks for the other feedback :) – trichoplax Jun 16 '15 at 15:17
• @Katenkyo all the players can move freely over the edges of the field, so if the left team can get the ball past the right team's players then it shouldn't matter which side of the field they are on. The left team can reappear at the left side of the field and keep kicking the ball further right. – trichoplax Jun 16 '15 at 16:06
• @Katenkyo also all players can see all other players, so a bot from team 1 kicking the ball past the right hand edge of the field can see any team 2 bots waiting at the left hand edge of the field. It can therefore aim to avoid them so they cannot simply kick it back. – trichoplax Jun 16 '15 at 16:08