Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Comments addressing specific points mentioned in the proposal
• Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Answer 1

How long will my microwave run for?

Answer 2

Subdivide the Bezier Curve

Background

A Bezier curve is a type of curve that has a lot of applications in all sorts of places, but most commonly, in computer graphics. It has a very simple algorithm and yet can represent a wide variety of shapes with just one common formula. If you've ever used pen tools in drawing software, you're probably already familiar with the general idea behind Bezier curves.

Given an ordered list of control points, we set some parameter \$t\$ in the range \$[0, 1]\$. Then, for each \$t\$, we draw a line between each consecutive pair of control points and select a point that is \$t\$ from the starting point. For example, if we have three control points and \$t\$ is \$\frac13\$:

The purple point is \$\frac13\$ of the way from the red point to the blue point, and the black point is \$\frac13\$ of the way from the blue point to the green point. You can change the ratio and move the points around here to try it out.

Now, we have one fewer point than we initially had control points. Let these be the new control points, and do this again with the same \$t\$:

(Desmos link). Now, we finally have a single point, so that is the point we obtain for this value of our parameter \$t\$. The Bezier curve is obtained from all final points for each \$0\leq t\leq 1\$. For more points, we just repeat this for more steps. Here's what a Bezier curve with four control points looks like:

(Desmos link)

Challenge

Given a list of control points for a Bezier curve and a positive integer \$n\$, subdivide the Bezier curve into \$n\$ segments and return the points. More precisely, return the output points for \$t=0,\frac1n,\frac2n,\cdots,\frac{n-1}n,1\$.

You may do I/O in any reasonable format; for example, a list of pairs or a pair of x and y coordinates for input, and a pair of numbers for output. Floating point errors are acceptable but your outputs should have an accuracy of at least \$10^{-3}\$ relative or absolute, whichever is larger.

There will be at least one point and \$n\$ will be a positive integer.

Example

Given input \$\{(0,0),(1,3),(4,2),(5,1)\}\$ and \$3\$ subdivisions:

For \$t=0\$, we just have \$(0,0)\$, and for \$t=1\$ we just have \$(5,1)\$.

For \$t=\frac13\$, we first go \$\frac13\$ of the way from each control point to the next to get \$\{(\frac13,1),(2,\frac83),(\frac{13}3,\frac53)\}\$. Repeating that once more gives us \$\{(\frac89,\frac{14}9),(\frac{25}9,\frac73)\}\$. Finally, if we do it once more, we get the single point \$(\frac{41}{27},\frac{49}{27})\$.

For \$t=\frac23\$, we first get \$\{(\frac23,2),(3,\frac73),(\frac{14}3,\frac43)\}\$, then \$\{(\frac{20}9,\frac{20}9),(\frac{37}9,\frac53)\}\$, and finally, \$(\frac{94}{27},\frac{50}{27})\$. And just for a sanity check, the points are indeed on the curve:

Note that these points do not evenly subdivide the Bezier curve by arclength. The arclength of a Bezier curve actually cannot be calculated exactly and subdividing like that would have to be done via approximations.

Test case generator

_{Credit to Wezl for the original idea.}

Answer 3

Demonstrate some easier abstract algebra

_{From my related challenge, Demonstrate some advanced abstract algebra}

Consider a binary operator \$*\$ that operates on a set \$S\$. For simplicity's sake, we'll assume that \$*\$ is closed, meaning that its inputs and outputs are always members of \$S\$.

Let's define some basic terms describing the properties of \$*\$. We can say that \$*\$ can have any of these properties, if they hold for all \$a,b,c \in S\$:

• Commutative: \$a*b = b*a\$
• Associative: \$(a*b)*c = a*(b*c)\$
• Distributive: \$a*(b+c) = (a*b)+(a*c)\$, for some binary operator \$+\$ on \$S\$

We can also define 3 related properties, for a unary operation \$-\$ on \$S\$:

• Anti-commutative: \$a*b = -(b*a)\$
• Anti-associative: \$(a*b)*c = -(a*(b*c))\$
• Anti-distributive: \$a*(b+c) = -((a*b)+(a*c))\$

Finally, we define 3 more, that only describe \$*\$ if the complete statement is true for \$a,b,c \in S\$:

• Non-commutative: There exists \$a, b\$ such that \$a*b \ne b*a\$ and \$a*b \ne -(b*a)\$
• Non-associative: There exists \$a, b, c\$ such that \$(a*b)*c \ne a*(b*c)\$ and \$(a*b)*c \neq -(a*(b*c))\$
• Non-distributive: These exists \$a,b,c\$ such that \$a*(b+c) \ne (a*b)+(a*c)\$ and \$a*(b+c) \ne -((a*b)+(a*c))\$

We now have 9 distinct properties a binary operator can have: commutativity, non-commutativity, anti-commutativity, associativity, non-associativity, anti-associativity, distributivity, non-distributivity and anti-distributivity.

This does require two operators (\$-\$ and \$+\$) to be defined on \$S\$ as well. For this challenge we'll use standard integer negation and addition for these two, and will be using \$S = \mathbb Z\$.

Obviously, any given binary operator can only meet a maximum of 3 of these 9 properties, as it cannot be e.g. both non-associative and anti-associative.

---

Let's create a "table" of these properties:

	Commutative	Associative	Distributive
Regular	Commutative	Associative	Distributive
Anti	Anti-commutative	Anti-associative	Anti-distributive
Non	Non-Commutative	Non-associative	Non-distributive

Your task is to write 3 programs (either full programs or functions. You may "mix and match" if you wish).

Each of these 3 programs will:

• take two integers, in any reasonable format and method

• output one integer, in the same format as the input and in any reasonable method

• be non-constant. That is, there exists at least two distinct inputs that have distinct outputs.

• have exactly 3 of the 9 above properties. However, those three properties muse be in different rows and columns in the above table from each other. This means that it can be (for example) commutative, non-associative, anti-distributive; non-commutative, anti-associative, distributive; or anti-commutative, associative, non-distributive. But, it cannot be (for example) commutative, associative, distributive; non-commutative, non-associative, non-distributive; or non-commutative, anti-distributive, anti-associative.

This is code-golf; the combined lengths of all 3 of your programs is your score, and you should aim to minimise this.

Additionally, you should include some form of proof that your programs do indeed have the required properties and do not satisfy the other properties. Answers without these are not considered valid.

Alternatively, a proof of impossibility is a valid answer. If you can demonstrate that there are no such programs that satisfy the criteria listed above, then this proof constitutes a valid answer as well.

---

Meta

• This is pretty math-heavy, is it clear?
• Is this a dupe?
• Tags are code-golf, open-ended-function, math, abstract-algebra. Any others?
• Any further feedback?

Answer 4

Twins' complements

Answer 5

Code Golf Birthday Cake

code-golf kolmogorov-complexity

Your task is to print this exact text:

     0 2 4 6 8 10
     | | | | | |
    &***********&
    | Code Golf |
   | e---------f |
  | d___________l |
 | o-------------o |
| C_______________G |
 ###Dennis$Dennis###
#####################

Rules

• Trailing or leading newline is allowed
• code-golf, so shortest code wins!

---

Meta

• Any feedback?

Answer 6

Domino tilings in an N-dimensional cube code-golf dominoes tiling sequence combinatorics

Challenge

Imagine an N-dimensional cube which has dimensions 2×2×...×2. Given the value of N (a positive integer), calculate the number of ways it can be divided into 2×1×1×...×1 "hyper-domino" pieces (two unit N-dimensional hypercubes glued together).

Standard code-golf rules apply. The shortest code in bytes wins.

Examples and test cases

For N = 1, the "cube" is a single domino. A single domino can be divided into a single domino in exactly one way, so the answer is 1.

For N = 2, the "cube" is a 2×2 square. It can be divided, or tiled, in two ways:

--  ||
--  ||

For N = 3, the cube is a 2×2×2 cube. It can be divided into four domino-cubes in nine different ways. One way to count it is to see that, if you pick a unit cube, it can be used by three different domino-cubes (one in each direction), and in all cases the rest forms a small staircase-like shape

L1  L2
#   #
##  ##

which can be divided into three pieces in three ways (# denotes a piece in Z-direction)

#   #
--  --

#   #
##  ##

|   |
|#  |#

which gives 3×3 = 9.

The corresponding sequence is A005271.

N    Answer
-----------
1    1
2    2
3    9
4    272
5    589185
6    16332454526976
7    391689748492473664721077609089

Answer 7

Number of complete rhyme schemes

Answer 8

Is it a perfect word?

Answer 9

Number of arrangements of half a Rubik's cube

From a corner-on view of a Rubik's cube calculate the number of arrangements of stickers that are out of view.

Your input will provide the state of a Rubik's cube when viewed like the below image:

This input will be an array, in any defined order†, grouping†, and nesting† that you choose, containing the colours‡ of the \$27\$‡ stickers (A.K.A. facelets or tiles) on three sides of a 3x3 Rubik's cube that join at one corner, like you can see above.

The input may be assumed to be that of a solvable state where only face turns can return the cube to having six sides with a single colour on each (if it isn't then your code may do anything, short of summoning Cthulhu).

† The input may be a flat list of colour-labels or you may specify that these labels will already be grouped in any way you wish (it may be a ragged, nested list for example), but the content thereof should only consist of the sticker colour-labels.

‡ Since the centres of the cube are actually fixed relative to each other, and hence the hidden centres' colours are known, you may choose to leave any or all of the central stickers out of the expected input (it could be as short as \$24\$ sticker colour-labels) while using a labeling that identifes the colours as the top-centre, left-centre, right-centre, and their three opposite colours. For the record, the standard colour theme, as in the image above, has orange opposite red, white opposite yellow, and green opposite blue (hence orange is the hidden centre sticker on the bottom etc.).

You should output the number of possible arrangements of sticker colours of the \$27\$ stickers which are not in the input (i.e. those stickers which are out of view). Note that swapping two of those stickers of the same colour is considered to be the same arrangement.

code-golfcombinatoricsrubiks-cube

---

Sandbox questions

1. Does this need test cases? (I'm not even 100% sure what the output should be if the input looked like a solved cube from that perspective although I may be able to work it out without writing a program it's certainly more than one - e.g. U' L R2 D' M D2 M' D' L' R2 U or R2 U R2 F2 R2 U2 F2 R2 F2 U R2)

2. Is the spec clear?

Answer 10

Solve nonimplication-SAT

Answer 11

Is this continuous terrain?

Answer 12

Sides of a polygon

Answer 13

BCD to binary, with bitwise

atomic-code-golf

---

In this challenge, you'll convert an 8-digit BCD (Binary Coded Decimal) number to a 32 bit (unsigned) integer in the fewest instructions possible, with only bitwise instructions available.

Task:

You'll be given a single positive integer as input, from 00000000 to 999999999. It will be represented using BCD, as a 4-byte unsigned integer, with each nibble being a decimal digit from 0000 (0) to 1010 (10). More significant nibbles will correspond to more significant digits of the decimal number.

Your output should be that same number, as an ordinary 32-bit integer.

Instructions:

This is atomic code golf, so you can only use the following instructions, the number of which is used for scoring:

and [r], [r|I]      Bitwise AND
or  [r], [r|I]      Bitwise OR
xor [r], [r|I]      Bitwise XOR

not [r]             Bitwise NOT

shr [r], [r|I]      Shift right (zero fill)
shl [r], [r|I]      Shift left

mov [r], [r|I]      Copy

All instructions will write their output to the first register listed, and for the second argument [r|I] indicates either a register or an immediate (any 32-bit constant) can be provided.

You have four registers to work with, all of which hold a single 4 byte unsigned integer: ra, rb, rc, and rd. Any instruction using only registers costs 1 byte, and any with an immediate cost a total of 4 (this isn't technically possible, since the immediates are 4 bytes on their own, but I don't want to make them too costly).

Input will be provided in ra, and the contents of ra when your program is finished will be used as output. All other registers will be initialized to 0.

Instructions Mk. 2:

This is atomic code golf, so you can only use the following instructions, the number of which is used for scoring:

and [r], [r|I]      Bitwise AND
or  [r], [r|I]      Bitwise OR
xor [r], [r|I]      Bitwise XOR

not [r]             Bitwise NOT

shr [r], [r|I]      Shift right (zero fill)
shl [r], [r|I]      Shift left

mov [r], [r|I]      Copy

goto [r|I]          Go to an instruction (`0` is the start of the program)
goif [r] [r|I]      Go to an instruction, if `r` is not all `0`s

All instructions (aside from goto and goif) will write their output to the first register listed, and for the second argument [r|I] indicates either a register or an immediate (any 32-bit constant) can be provided.

You have 8 registers to work with, all of which hold a single 4 byte unsigned integer: ra, rb, rc, rd, rk, rn, rp, and rs. Any instruction using only registers costs 1 score, and any with an immediate cost a total of 2.

Input will be provided in ra, and the contents of ra when your program is finished will be used as output. All other registers will be initialized to 0.

Other:

I don't actually know if this is an interesting challenge, or if more registers will be needed, or if there's already a well known solution. I'd try it myself but it's kinda late here so I'm too tired to, and if I don't post this now I'll forget about it lol

Answer 14

Compress and decompress

Answer 15

Prime Number Fibonacci

In this challenge, you will make a program that calculates the Fibonacci sequence with a twist. Instead of it starting with 0 and 1, it starts with the nth prime number determined by input by the user. The second number is the nth+1 prime number. The sequence should also stop after nth number iterations.

Walkthrough:

1. Get a number from the input. We will call it n
2. Calculate the n prime number and n+1 prime number
3. Make a function that adds these numbers and calls itself with the result.
4. Make the function stop once prime number with index n numbers are output

Examples:

input:2
output:
8
13
21
34
55

input:10
output:
60
91
151
242
393
635
1028
1663
2691
4354
7045
11399
18444
29843
48287
78130
126417
204547
330964
535511
866475
1401986
2268461
3670447
5938908
9609355
15548263
25157618
40705881
65863499
106569380

input:5
output:
24
37
61
98
159
257
416
673
1089
1762
2851
4613
7464

By the way, here is the JavaScript code I used for this example:

var primeNumber1 = prime(num);
var primeNumber2 = prime(num+1);
fib(primeNumber1,primeNumber2,0,primeNumber1);
}
function fib(num1,num2,iterations,max){
console.log(num1+num2);
if(iterations == max+1){
return;
}
fib(num2,num1+num2,iterations+1,max);
}
function prime(number){
var numPrime = 0;
for(var i = 0; i > -1; i++){
if(isPrime(i)){
numPrime++;
if(numPrime == number){
return i;
}
}
}
}
function isPrime(num) {
  for(var i = 2; i < num; i++)
    if(num % i === 0) return false;
  return num > 1;
}

Answer 16

Mat Printing Matrix

Answer 17

Implement an argwhere function functional-programming array code-golf

Posted

Answer 18

Is this word in standard order?

Answer 19

Move to Right and left

Answer 20

Crack the Caesar cipher

Answer 21

Regex ordinals

Inspired by this xkcd comic, your job is to write an extremely meta regex.

Specifically, the depth of a regex is an ordinal defined as follows:

1. regex golf has depth 0.
2. meta-x has depth 1 greater than the depth of x.
3. The depth of <regex> is the supremum of the depths of everything <regex> matches.

Of course, it's possible for a string not to have a depth. For example, /.*/ matches itself, so its depth would have to be greater than its depth, which is impossible.

Your challenge is to write a regex with depth \$\omega^2\$.

And this is code golf, so the shortest regex wins.

Examples of regex ordinals

• meta-regex golf is depth 1.
• meta-meta-regex golf is depth 2.
• /(meta-)*regex golf/ is depth \$\omega\$.
• /(meta-)*\/(meta-)\*regex golf\// is depth \$\omega 2\$.

Answer 22

Von Neumann Probe Battle (king-of-the-hill)

---

This is just an idea for now, placing it here as a draft and to collect feedback.

Basically, your goal would be to design a set of machines, including factories and spacecraft, which start on earth and spread outward into the universe. You'd be able to design these machines. Not just their code, but the parts that make them up.

For example, you could start on earth with a single factory, which would make a swarm of mining bots. These would bring ore to the surface, and the factory would switch to making spacecraft. Once the spacecraft are built, the factory could assemble all of the parts needed to make an identical factory, load them onto the spacecraft, and send them to the moon. Then, both factories would start the process over.

The ultimate goal would be to build "stamps", which cost a small amount of iron, and then vanish from existence. These are used for scoring.

This challenge might not be very practical, due to the issues involved in simulating a detailed and exponentially increasing swarm of robots in a vast universe.

Answer 23

Pretty print my arrays

I like to pretty print multidimensional arrays, like this:

[ [ [1, 2, 3],
    [4, 5, 6] ],
  [ [7, 8, 9],
    [6, 4, 2] ] ]

But it's a pain to do by hand and it'd be nice to have a program that does this for me. Your challenge is to create a program that does this for me, taking a multidimensional array containing only numbers and prettyprinting it.

Specifically, an array of depth 1 is printed joined by , with [ prepended and ] appended:

[1, 2, 3]

An array of depth \$n+1\$, which contains at least one array of depth \$n\$, has its subarrays prettyprinted, joined by newlines and indented by two spaces. All but the last subarray have a comma appended, the last has ] appended, and the first has its first line indented with [ instead of two spaces:

Here's a reference implementation:

function recursivePrettyPrint(array){
  if(array.every(x => typeof x == "number")){
    return `[${array.join(', ')}]`;
  } else {
    return array.map((item, index) => {
      let result = recursivePrettyPrint(item) + ',';
      result = result.split`\n`;
      if(index == 0){
        result[0] = '[ ' + result[0];
      } else {
        result[0] = '  ' + result[0];
      }
      for(let i = 1; i < result.length; i++){
        result[i] = '  ' + result[i]
      }
      return result.join('\n');
    }).join('\n').slice(0,-1) + ' ]';
  }
}

function change(){
  let array = JSON.parse(document.getElementById('input').value);
  let output = document.getElementById('output');
  output.innerText = recursivePrettyPrint(array);
}

<textarea id=input></textarea>

<button id=run onclick=change()>Pretty Print</button>

<pre id=output></pre>

Numbers may be multiple digits. The input will always be orthogonal/rectangular, and you may take its dimensions as well.

Testcases

[[892, 759], [962, 251]] ->
[ [892, 759],
  [962, 251] ]

[118, 922, 619] ->
[118, 922, 619]

[[966, 639, 616, 255], [622, 483, 87, 241], [453, 870, 728, 725], [163, 936, 48, 967], [261, 833, 87, 200]] -> 
[ [966, 639, 616, 255],
  [622, 483, 87, 241],
  [453, 870, 728, 725],
  [163, 936, 48, 967],
  [261, 833, 87, 200] ]

[[[[[912, 547], [366, 754]], [[723, 536], [779, 238]]], [[[559, 392], [602, 709]], [[692, 915], [412, 302]]]], [[[[3, 504], [936, 83]], [[352, 442], [425, 375]]], [[[380, 440], [793, 762]], [[850, 321], [780, 457]]]]] ->
[ [ [ [ [912, 547],
        [366, 754] ],
      [ [723, 536],
        [779, 238] ] ],
    [ [ [559, 392],
        [602, 709] ],
      [ [692, 915],
        [412, 302] ] ] ],
  [ [ [ [3, 504],
        [936, 83] ],
      [ [352, 442],
        [425, 375] ] ],
    [ [ [380, 440],
        [793, 762] ],
      [ [850, 321],
        [780, 457] ] ] ] ]

[[[128, 910, 664, 658], [172, 238, 564, 492], [325, 384, 566, 90]], [[876, 819, 764, 105], [583, 528, 731, 839], [480, 126, 692, 875]], [[215, 84, 268, 504], [400, 674, 997, 526], [799, 692, 193, 296]], [[943, 185, 567, 188], [118, 200, 879, 409], [116, 493, 62, 343]]] -> 
[ [ [128, 910, 664, 658],
    [172, 238, 564, 492],
    [325, 384, 566, 90] ],
  [ [876, 819, 764, 105],
    [583, 528, 731, 839],
    [480, 126, 692, 875] ],
  [ [215, 84, 268, 504],
    [400, 674, 997, 526],
    [799, 692, 193, 296] ],
  [ [943, 185, 567, 188],
    [118, 200, 879, 409],
    [116, 493, 62, 343] ] ]
```

Answer 24

Trap the hero in a maze

Answer 25

Ragged list addition

Let's define the operator \$+\$ as follows, using wrapping list indexing:

\$ a+b=\begin{cases} a+b,\space\text{if }a\text{ and }b\text{ are integers (regular integer addition)}\\ [a+b[0], a+b[1], ...,a+b[len(b)-1]],\text{if }a\text{ is an integer and }b\text{ is a list}\\ [a[0]+b,a[1]+b,...,a[len(a)-1]+b],\text{if }b\text{ is a list and }\text{ is an integer}\\ [a[0]+b[0], a[1]+b[1], a[2]+b[2],...,\\a[\max(len(a),len(b))-1]+b[\max(len(a),len(b))-1]],\text{if }a\text{ and }b\text{ are lists} \end{cases} \$

That is huge wall of text, so let's look at an example: We want to add the arrays \$[1,2,[5,6,7]]\$ and \$[[1],2,3,10,0,[3,0],1]\$ together

Let's start

\$[1,2,[5,6,7]]+[[1],2,3,10,0,[3,0],1]\$

We are adding two arrays, so we add element by element, looping if neccesary:

\$[1+[1],2+2,[5,6,7]+3,1+10,2+0,[5,6,7]+[3,0],1+1]\$

Now, let's get all the additions that don't involve lists out of the way

\$[1+[1],4,[5,6,7]+3,11,2,[5,6,7]+[3,0],2]\$

Next, lets look at \$1+[1]\$ and \$[5,6,7]+3\$. Here we add an integer to an array, so we just distribute the addition like so:

\$[[1+1],4,[5+3,6+3,7+3],11,2,[5,6,7]+[3,0],2]\$

\$[[2],4,[8,9,10],11,2,[5,6,7]+[3,0],2]\$

Now we have \$[5,6,7]+[3,0]\$ left. Again, we interleave the arrays, looping if necessary:

\$[[2],4,[8,9,10],11,2,[5+3,6+0,7+3],2]\$

\$[[2],4,[8,9,10],11,2,[8,6,10],2]\$

Now there are no \$+\$ signs left. Thus \$[1,2,[5,6,7]]+[[1],2,3,10,0,[3,0],1]=[[2],4,[8,9,10],11,2,[8,6,10],2]\$

Note that ragged list addition is not commutative. So \$a+b\$ is not necessarily the same as \$b+a\$.

Your code takes two ragged lists and returns their sum. Shortest code wins.

Answer 26

Animate finding the middle (hypercube edition)

Answer 27

Play a chess-like game

king-of-the-hill

Your task is to build a program that plays chess. However, it doesn't know how the pieces move before the game begins. In fact, each time it sits down at the board the pieces are different!

The game

This game is played on a 6x6 board, looking roughly like:

123451
pppppp
......
......
pppppp
123451

Each game has a time control of 1+1 (1 minute, plus 1 second per move). One piece (of 2345) is selected to be the king, and the game ends when any of the following occur:

• A king is captured (a win for the capturing player)
• 50 moves pass without a piece being captured or a pawn moving (a draw)
• One player runs out of time or attempts an invalid move. (a loss for that player)

The pieces

Pawns

Each player has 6 pawns. Pawns have at least one possible capturing move and at least one non-capturing move that moves it forward. If a pawn moves into a space on the last rank, it may promote into any non-king piece. I've listed white's moves; blacks are mirrored. Pawns may have any or all of the following:

Capturing or non-capturing

.x.
... x.x .x. ...
.p. .p. .p. xpx

Capturing only

.p. .p.
x.x .x.

Example:
In a game, pawns may be able to move to

...
.x.
xpx

And capture pieces in

x.x
.p.
xxx

Major Pieces

The major pieces are more varied, but all of their moves are symmetric. If a major piece can move to a space, it can also capture on that space. Possible moves include (not necessarily exhaustive):

.x. x.x
xPx .P.
.x. x.x

These moves may or may not include the ability to jump over pieces in between:

.x.x. x.x.x
x...x .....
..P.. x.P.x
x...x .....
.x.x. x.x.x

These moves extend across the whole board:

.x... x.x.. P....
xPxxx .P... ..x..
.x... x.x.. .x..x
.x... ...x. .....
.x... ....x ..x..

Each piece will have at least one of these (or others - no guarantees will be made that other movesets will not be included). A piece can have any number of these sets of moves. The two "1"s will have the same moves.

The controller

I haven't built this; I want to gauge interest first.

A potential spec for the controller (have to work out how it communicates):

// Return a list of possible moves in that game state
// If piece is passed (a 2-element array - [x,y]) then only moves which that piece can make are returned
getMoves(board, player, piece = null) => board[]

// Returns the number of milliseconds that player has remaining on their clock.
getTime(player) => float

// Move the piece at origin to destination
makeMove(origin, destination, promotion = null) => void

The tournament

There will be a round-robin tournament played, with as many rounds as possible. Each game will have its pieces randomized at the start, then the bots will play a game as white and a game as black (using the same pieces).

Sandbox

• Does this sound like an interesting challenge (would it be more than just "fork stockfish")?
• Would it be alright to restrict this to javascript?

Answer 28

Retaining Water

Answer 29

Can I wall glitch to there?

Posted

Answer 30

Slice the source code - Cops and Robbers