# What is the Sandbox?

This "Sandbox" is a place where Programming Puzzles & Code Golf (PPCG) 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]

• Suggestion: instead of having a notice on the top answer ("note: if you are..."), you'd better just put a moderator notice below the question – nicael Mar 19 '18 at 19:35
• @nicael We can only choose from three post notices: citation needed, current event, and insufficient explanation. – Dennis Apr 7 '18 at 14:43
• If you remove a post but didn't post it you can replace the text body with [](lots of text here to reach the min chars) to make it much smaller when removed – Christopher Apr 13 '18 at 17:54
• @Christopher Please don't do that for old proposals. It clutters the first page with an answer nobody cares about anymore, instead of staying hidden on page 10 where it will bother nobody. – Dennis Apr 13 '18 at 18:17
• @Dennis ? what are you talking about. As if if you didn't post it like you just removed you own sandbox because dupe or something – Christopher Apr 13 '18 at 18:18
• @Christopher If your proposal is still on the first few pages, you can replace the proposal with a stub to save vertical space on these pages. However, if your proposal is already on page 10, editing your proposal will bump it to page 1, where space is more precious than on page 10. – Dennis Apr 13 '18 at 18:21
• @Dennis ohh that makes sense – Christopher Apr 13 '18 at 18:25
• codegolf.meta.stackexchange.com/questions/12599/… – Redwolf Programs Apr 17 '18 at 17:38
• Maybe it's time to consider cleaning some of this up a bit. There's just too much to go through and some of these proposals are years old and obviously not going anywhere (even some of the good ones). Perhaps cull anything that is two years old and has likewise been inactive for as long? – ouflak Aug 6 '18 at 9:07
• @ouflak You can sort posts by "active". That seems to resolve all of the problems you describe. – FryAmTheEggman Sep 27 '18 at 19:04
• I already posted this, but codegolf.stackexchange.com/questions/176599/… – 2br-2b Nov 27 '18 at 2:38
• How are tags added to questions? – guest271314 Jan 9 at 7:51
• It seems like there is a rollback war with moderators and the Community user to add and remove the featured tag. – smileycreations15 Mar 21 at 21:13
• @smileycreations15 That's unfortunately unavoidable. Community is an automatic script, and, since most featured questions are only temporarily so, it assumes that we don't want this question to be featured forever. However, we do, so a mod has to edit the tag in every now and then. – Erik the Outgolfer Mar 24 at 15:22
• @EriktheOutgolfer Yeah. Maybe they can create a special [featured-pin] tag which will both feature it and pin it from removal by the Community user. – smileycreations15 Mar 24 at 17:20

# Tower Builder king-of-the-hill

The king is coming to visit! Your city is competing with another neighboring city to attract his attention.

Each player owns their own tower within a city full of other players. Each turn you place 1 blocks on your tower or another tower in your city.

After 100 turns, the king will only visit the city with the highest tower. If he visits your city, then you will gain points equal to the number of blocks in your personal tower. In the case of a tie, neither city is visited.

Games include all players, and each game will randomly arrange players into cities. Your score is the total score across all games.

• Player identifiers are randomly generated at the start of the tournament, but are consistent from game to game.
• In addition, contrary to past KoTHs: I allow saving state from game to game (but not between tournaments)
• You will always have complete information, including:
• The size of everybody's towers (including the other city)
• The actions players have taken
• The current score of all players
• How is always playing on the tallest tower in your city a bad strategy? Maybe the other city will do the same, but you won't lose. – aschepler Jul 22 '17 at 22:47
• @aschepler because the number of points you get is height of your personal tower. If you only build on another's tower, and never your own, you'll never get any points. – Nathan Merrill Jul 23 '17 at 1:55
• @NathanMerrill it took me a few minutes to understand what you even meant by that. you probably need to make this more clear – Destructible Lemon Aug 7 '17 at 0:24
• If the points are only awarded to the player who is visited by the king, it would seem that putting 99 blocks on the city tower and 1 block on your personal tower guarantees victory, no? – AdmBorkBork Jan 30 '18 at 17:22
• @AdmBorkBork there's no singular "city tower". Furthermore, you are still competing against the players in your city. Your score is your total score across many games. – Nathan Merrill Jan 30 '18 at 17:40
• Oh, the part that I missed was that multiple players share a city. I think that should be made more clear because that will drastically change strategy. I read it as you have a personal tower and everyone also gets their own city with a separate tower, and it's only the city's tower that matters for the king. – AdmBorkBork Jan 30 '18 at 17:45
• This needs some clarification about arrangement. The game will randomly arrange players into one of () cities, or a city with () others in it – pfg Jan 30 '18 at 19:10
• @pfg It'll definitely be one of () cities, but I'm not sure how many. My intuition says "2", but I can't give a solid reason. Any suggestions? – Nathan Merrill Jan 30 '18 at 19:21
• 2 or 3 per city or total cities? 3 seems good per city because with just two the strategy is much easier @Nathan Merrill – pfg Jan 30 '18 at 19:23
• Hmmm...I'm thinking 100 players in 2 cities, and allow for duplicate entries. – Nathan Merrill Jan 30 '18 at 19:28
• It seems to me that if you allow saving state you can simplify the last point to "You will be notified of the actions of every player" and let those who want to analyse it calculate the sizes of the towers, scores, etc. Normally I would favour supplying calculated information to save the players from re-implementing the game logic, but here the logic is simpler than the serialisation would be. – Peter Taylor Jan 31 '18 at 8:43
• @PeterTaylor I already provide complete information about the current game (including its history). The difference here is that you are allowed to persist information from game to game, meaning you can remember players who are antagonistic. – Nathan Merrill Jan 31 '18 at 15:04
• My point is that the communication between the server and the bots would be simpler if you didn't provide that information, and you don't need to provide it because it can be calculated easily. – Peter Taylor Jan 31 '18 at 15:07

## Can the robotic arm reach itself?

( ͡° ͜ʖ ͡°) title is kinda sketch at the moment

A robotic arm is made up of a set of line segments, each with a positive integer length. Each joint on the robot has two possible positions: straight or 90 degrees clockwise.

Here is a robotic arm with 4 line segments of sizes 4, 2, 3, 2

+---+-+--+-+


Here is the same robot arm with one joint bent

+---+-+
|
|
+
|
+


(vertical scale is kinda messed up)

Right now, the robotic arm isn't reaching itself. By bending all of the segments, however, the arm can reach itself.

+X--+
|  |
+--+


So, a robotic arm of size [4,2,3,2] can reach itself.

Here is a robotic arm of size [3,1,4,3] that can't reach itself:

+--++---+--+

+
|
|+--+
+---+


Whereas a robotic arm of size [1,1,2,2,3] can reach itself.

++-+-+--+

+
X++
| |
+-+


A robotic arm of size [2,2,3,5,3,4] can also reach itself

a-b-c--d----e--f---g

e--f
|  |
|  |
|a-b
|  g
d--c


## Challenge

Given list of numbers, such as [1,2,3,4,5], output a truthy value of the robotic arm can reach itself and a falsey value if it cannot.

• s/touch/intersect/g? – El'endia Starman Feb 17 '16 at 20:27
• We've had some related challenges I think. At least codegolf.stackexchange.com/q/45059/8478 – Martin Ender Feb 17 '16 at 21:01
• codegolf.stackexchange.com/q/49713/8478 – Martin Ender Feb 17 '16 at 21:03
• The scenario reminds me of stretchy snakes kissing. Except, these snakes are unusually rigid ... you know what, never mind. – xnor Feb 17 '16 at 21:45
• The first few examples would be clearer if either you also used letters to distinguish the joints or if you at least marked one end of the chain in both the straight and the folded representation. – Martin Ender Feb 18 '16 at 7:55
• You could probably also use more than one example where self-intersection only happens when not all joints are bent like the [1,1,2,2,3] example. If that's possible it would be good to have one where you need to bend joints on both sides of a straight joint to make the self-intersection happen, but I don't know if that can happen. – Martin Ender Feb 18 '16 at 12:23
• @El'endiaStarman s/touch/reach/g – mbomb007 Apr 7 '16 at 15:13
• Is 4,2,3,3 truthy or falsy? – Zgarb Feb 7 '18 at 8:12
• Can the robotic arm go through itself? The [2,2,3,5,3,4] case seems to indicate so. – stanri Feb 7 '18 at 10:50

# Overview

While the ants of the highlands gather food and walk around each other, their distant cousins live in the forests below, growing fungus and aggressively raiding the ground and other nests for food. But like their highland counterparts, they want food, and they have armies of workers at their disposal to get at it.

## The Arena

The arena is a torodial 1000*2500 rectangular grid of cells. Each cell has one of eight colors, and at most one object at any one time. There are three types of objects of significance:

• Ants are either queens, which are spawned at the start of the game, or workers, which are spawned by queens.
• Food is a prized possession, and may be hoarded or consumed.
• Fungi are ant-placed objects which may be created at low cost and will grow slowly into food if left alone within the vicinity of food.

In this game, adjacency refers to being in the Moore Neighborhood unless otherwise specified. Some rules instead specify the von Neumann neighborhood.

## Game Overview

Each game, 16 submissions are put against each other in a game. If the competition has fewer than 16 submissions, all of them participate in a game, and if there are more, the 16 players are chosen randomly.

At the beginning of each game, each cell is reset to the color 0 (white), each submission used in the game has its corresponding submission object constructed, and 2500 food, and 16 queens are randomly scattered onto the map. Queens are very unlikely to be adjacent to food or other queens, but this is not a guarantee.

Then the game itself proceeds. The game lasts for 15000 turns, and each turn consists of the following phases, each of which is resolved concurrently in turn:

• Decide: Each ant's views are determined based on the current state of the arena and previous move history, and each ant's decision is determined and validated separately.
• Move: Each ant's decision is executed simultaneously, and the presence of multiple objects in a single cell resolved once all ants that decided to move into a cell have done so.
• Grow: Each object that can potentially change as a result of its surroundings has its neighborhood resolved, and the changes to the objects as a result happen simultaneously.

After the 15000 turns is up, the game ends. Submission objects are disposed of, caches trimmed down, food amounts logged, and the process started again if more scores need to be collected.

## Ant Senses

Each ant has a 5*5 area of sight centered on themselves. This area of sight is arranged to give the ants a relative sense of direction in the immediate term, but not innately in the long term. Ants can see the color of empty cells, and the properties of objects in filled cells, but not the color of filled cells.

Each ant also has an internal state that can take one of eight values. This state is internal to that ant, and to transfer information between herself and other ants or to remember more than this, she must position herself, drop payloads, or mark the ground below her, all which are subject to enemy interference.

## Ant Actions

Using their senses, ants can decide to move or drop payloads, and also color their current cell and change their current state simultaneously, once per turn. The coloring happens on the cell that the ant is currently in, before she moves.

Ants move orthogonally or diagonally one cell at a time. Worker ants are free to move into other cells at their own risk, but a queen may not move to a cell that her view shows is in the Moore neighborhood of a non-adjacent queen, nor to a cell that her view shows is in the von Neumann neighborhood of an adjacent queen. (However, it is legal for a queen to stay still on a cell adjacent to another queen.) Additionally, a queen without food may not move into a step into a cell already occupied by a laden worker, lest she step onto a laden worker that decides to stay still, which would without this restriction kill her.

Instead of moving, ants may instead drop a payload into an adjacent cell. Food payloads cost one food, and can only be performed if the ant is carrying food. Fungus payloads cost nothing, and may be freely placed. Ant payloads may be performed only by the queen, cost one food, and consistently result in a new loyal worker. It is legal to drop payloads on oneself, but this will usually result in the dropped object being picked back up or destroyed during collision resultion, to no substantive effect.

## Ant Lifecycle

Both queen and worker ants start in state 0. Worker ants are oriented such that their "from" cell is the cell the queen occupied when spawning the worker, while queen ants have a random initial orientation. From there, it is up to submissions to perform ant-specific initialization and differentiation if desired.

Once spawned, ants have an indefinite lifetime. Queen ants are guaranteed to live up to the end of the game, but worker ants may die by colliding with other ants.

## Ant Leeching

After movements and collisions are handled, a queen may neighbor one or more unladen enemy workers. If the number of such neighbors is equal to or less than the amount of food carried by that ant, then the queen loses food equal to the number of adjacent enemy workers. An unladen worker ant that neighbors one or more enemy queens that lose food this way gains one food. If a worker is next to multiple such enemy queens, she receives only one food, and one or more food is simply lost forever.

This transfer does not occur between allied ants. To perform such food transfers, you must command the laden ant to drop her food in an adjacent cell, and have another ally be in that cell to automatically pick it up.

## Fungi

Fungi are a means of spawning more food. Fungus farms may potentially lead to bountiful harvests for submissions that invest the resources to spawn, watch over, guard and harvest these fungi. They may also be strategically planted to obscure the ground or probe for food from a distance.

If food is within a 9 by 9 cell area centered around the fungus, then the fungus will grow. Internally, fungus takes 32768 steps to mature and spawn into food, and will gain 1 step per generation per piece of food placed in this vicinity. Therefore, placing more food in the vicinity of a fungus will speed up the fungus's growth, but will also make a nice feast for any ants that find it. If a fungus is not within the vicinity of food, it will not grow.

Growth stages are visible to all ants, and work as a coarse indicator of the age of the fungus. 0 means that the fungus has taken no steps toward maturity, 1 means the fungus has taken 1-7 steps toward maturity, 2 means the fungus has taken 8-63 steps toward maturity, 3 means the fungus has taken 64-511 steps toward maturity, 4 means the fungus has taken 512-4095 steps toward maturity, and 5 means the fungus has taken 4096-32767 steps toward maturity. (If a fungus completes all 32768 steps of growth, it matures into food in time for ants to see it as food the next turn.)

# Collision Resolution

As noted above, all decisions are executed at once, and collisions are resolved as they happen once surrounding ants have all their decisions executed.

## Ants

Collisions are an unavoidable consequence of multiple ants deciding to enter the same cell independently, or one or more ants entering a cell of an ant that decides not to move from it. Because ants may move only one cell at a time, up to 8 ants can move into the same cell at a time, and may run into an ant standing still in it. Queen-queen collisions are prevented by the rules restricting movement within the vicinity of other queens.

Collisions of ants are resolved depending on the ants involved. For the purposes of collision resolution, an ant is considered moving if and only if she spent her turn moving herself to a different cell. A newly spawned worker is treated like a moving worker.

• A queen, if involved in a collision, is always the only survivor. She loses one food if she moved to a cell containing a laden worker that stayed still. As stated previously, a queen without food may not move to a cell already occupied by a laden worker, preventing the case where an unladen queen would step on a laden worker staying still.
• The collision of more than one moving laden ants in a worker-only collision results in all involved workers dying, leaving food behind in the cell.
• If a still laden worker is in a worker-only collision with no more than one moving laden worker, she survives, but loses her food if there was a moving laden worker in the collision.
• If a single ant in a worker-only collision held food and she moved, then she alone is the survivor. She loses the food she carried if she moved onto a worker ant that stood still.
• If none of ants in a worker-only collision held food, then they all die.

## Food and Fungi

Fungi do not stack. If multiple fungi are placed into a cell at once, collision resolution proceeds as if only one were placed in. Putting fungus in a cell already containing fungus will destroy the old fungus and create a new one. Fungus is destroyed if it shares its cell with any other object.

A queen ant that stays or moves into a cell will pick up all contained and/or placed food in that cell. However, if a worker does the same, she can only pick up one of these pieces, and the rest are simply lost forever. If no ants are available to pick up the food, then only one food remains in the cell, with the rest lost forever.

# Submission

Each submission must be a Javascript class, with two methods holding special significance: a constructor, which is called once per game start to initialize each object before eachTurn is ever called, and an eachTurn method, which is called concurrently on all new ant views to determine what to do.

The constructor is given no arguments, while eachTurn is given to arguments, an integer corresponding to the current ant's state, and a 25-length view array.

A possible submission skeleton is as follows:

class MyAnt {

constructor() {
//TODO: You fill this in
}

eachTurn(state, view) {
//TODO: You also fill this in
}

}


## Input

The view array contains objects of the following form:

{
contents: Integer representing the contents of the cell, 0 for empty, 1 for food, 2 for fungus, 3 for ant
details: Object giving details about the cell contents
}


The details object yields further information about the object in the cell, and for each of the possible cell contents, it has the following forms:

• Empty Cell:

{
color: Integer from 0-7 inclusive representing color of the cell
}

• Cell with Food:

{} // Yes, an empty object

• Cell with Fungus:

{
stage: Integer from 0-5 representing fungus stage, a very coarse indicator of age and time to maturity
}

• Cell with Ant:

{
queen: Boolean representing whether the ant is a queen
friend: Boolean representing whether the ant is ally or enemy
food: Integer representing the current food stores of that ant
}


Each view object provided represents reflects the true state of a cell in the arena, albeit with incomplete information. The array itself always corresponds to a flattened 5*5 cell area of the arena centered on the ant, rotated 0, 90, 180, or 270 degrees such that:

• For ants that have moved since spawning, either the cell to the top or to the top left correspond to the cell that the ant was in before the one currently inhabited
• For worker ants that have not moved since spawning, either the cell to the top or to the top left correspond to the cell that the queen occupied the turn she spawned the worker
• For queen ants that have not moved since spawning, the orientation is randomly determined at the start of the game and remains until the queen moves

Indices in the view array correspond to cells in english reading order:

 0  1  2  3  4
5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24


There is no means of getting orientation information definitively either form inside or outside, and it must be inferred by current state and surroundings.

## Output

The output expected of the eachTurn method is an object with the following fields:

{
cell: (Mandatory) Integer in 0-8 inclusive, representing the cell to move to or to drop a payload to
spawn: (Optional) If present, 0 for no payload, or 1, 2, or 3 for a payload of food, fungus, or worker, respectively
state: (Optional) If present, an integer in 0-7 inclusive, representing the state to change to
color: (Optional) If present, an integer in 0-7 inclusive, representing the color to color the old cell with
}


The cell is interpreted with the same rotation as the view. Output cells 0-2 correspond to view indices 6-8, output cells 3-5 correspond to view indices 11-13, and output cells 6-8 correspond to view indices 16-18. If you compare this to the index chart above, this is in the same english reading order as the view array provided.

## No Side Effects

Submissions may not make state modifications except to themselves, and should take care so that internal state modifications from calls to eachTurn are not visible from outside. Debugging submissions using input and output is allowed, but once submitted as an answer, they are forbidden. Attempting to use input or output in a submission will result in an error and disqualification until edited out.

## Consistency

Submissions are expected to behave deterministically, and the eachTurn function is expected to be pure, returing the same decision object for a given combination of state and view, regardless of how eachTurn was previously called or is currently being called.

Built-in functions may be called, if they are similarly externally pure. Math.abs() is fine, but Date.getTime() is not, for some examples. In particular, you are not allowed to call Math.random(). Supply your own pseudorandom numbers from constants, ant states, and ant views.

Unless you have a good handle on javascript concurrency and are willing to stress-test the code for concurrency bugs, I recommend using well-tested concurrency patterns and performing only idempotent modifications of objects, or avoiding modification in the eachTurn object altogether.

## Resource Limits

Each game submission starts with 1 second of reserve time. Each call to the constructor and eachTurn add 1 millisecond to the reserve time, then decrement from the reserve time the time they took to execute. Calls are memoized, and don't count against a submission if they are found in cache. If a submission exhausts its reserve time, it is disqualified.

Submissions are also limited to 64 Megabytes of memory at any one time. Unlike the time limit, this limit is not enforced automatically, but if a submission turns out to consistently hog memory during games it participates in, I will use a memory profiler to determine if this limit is exceeded.

# After Submission

## Disqualification

To keep tournaments running smoothly, submissions are disqualified if their submission performs an invalid action. Disqualified submissions will be excluded from future games within a tournament after a disqualification, and will be kept out of future tournaments until the problem causing the disqualification is fixed.

The following conditions are detected automatically, and therefore result in disqualification immediately:

• Exhausting reserve time, as described above
• Returning an ill-formed or badly typed object from eachTurn
• Throwing an exception from the constructor or eachTurn
• Attempting to spawn food or workers with no food
• Attempting to spawn a worker with another worker
• Attempting to move a queen too close to another queen
• Attempting to move an unladen queen to a cell containing a laden worker
• Performing input/output from submitted answers

It might seem harsh to disqualify for a single wrong move or bug, rather than consider it "no move" or ignoring it, but by insisting on correctness from entries, I can focus my efforts on keeping tournaments running quickly and smoothly. This is not supposed to be an additional challenge, so a reason is given for any disqualification, and an explanation given, with specific input and output given to help solve the disqualifying problem.

You may provide multiple answers, provided that each one stands as a competitor in its own right, does not team up with other submissions, and at least in part is the product of your own substantive effort. You may take advantage of other submissions' weaknesses in an effort to achieve a higher score in comparison. Keep in mind that submissions come in, the chances of running into another particular submission will decrease.

You may also edit your submissions to tune them however you choose. There are no guidelines about whether to create a new post or edit a currently existing post; the choice is yours.

If you make a variation of another submission, remember to differentiate it, and if is derived from someone else's work, remeber to credit your sources.

## Scoring

At the end of a game, submissions are ranked on how much food their queens held at the end of the game. Submissions which score exactly equal to each other simply share the average of the ranks they would have if they scored differently from each other.

Submissions with the highest average rank over a multitude of games win. For this challenge, I will give out working first places from tournaments as scores accumulate enough significance that Dunn's test indicates that there is a single distinct first place with at least 98% confidence.

# Chat

For questions and extended discussion of this challenge, please use the chat room. Comments on this post are likely to be cleared up from time to time, while chat room text will be kept around permanently.

If you want to contribute to the specification itself, see the github repository hosting the latest changes to this specification, right here.

• Chat room for this contest: chat.stackexchange.com/rooms/77728/the-formic-forest – eaglgenes101 May 18 '18 at 23:53
• Part of the complexity is making sure that the queen can't become a wrecking ball, but has clearly-defined restrictions so she can't be disqualified by no fault of her own. Take it from me, there's been more than a bit of arguing about how much the queen can and can't do. – eaglgenes101 May 21 '18 at 22:13
• Why are submissions a JavaScript class? You have rules about side effects and consistency so why not just make a toy language that must be functionally pure to implement the ants? Since the ants have a very limited view of the world it could easily be done with a fall through pattern matching. This would have the added benefit that people wouldn't need to learn JavaScript to participate, they would need to learn the toy language but IMO the language could be simple enough that it could be completely understood from a short description. – Sriotchilism O'Zaic May 22 '18 at 23:24
• I'm following the mold of the Formic Functions challenge. Javascript is a familiar language that has had thousands of dollars worth pumped into creating optimized implementations, and while it has its shares of impurities and quirks, it's old and widespread enough that its warts are well-known and well-documented. – eaglgenes101 May 22 '18 at 23:41
• @HatWizard If you have any suggestion you can make one, and then someone else may write a JS interpreter of that language. Or this... well, almost all of those are esolang, nevermind. – user202729 May 24 '18 at 11:52
• I think that the choice of JavaScript was one of the mistakes of the original formic functions challenge. The way I see it, it is like using a jackhammer to crack a nut, sure you can do it but Javascript is a lot of machinery for the task and some things you want like functional purity are lacking. I'm not even specifically opposed to Javascript, I think that any other production programming language would be overkill for the task even if it had functional purity. I'm suggesting a small language that could be programmed in about 30 min and learned in about 2 min. – Sriotchilism O'Zaic May 24 '18 at 15:18
• @HatWizard I can't imagine a language that takes 2 minutes to learn to be nearly enough. I'm not against this idea in general, though. – Alion May 24 '18 at 16:23
• @HatWizard a learning time of 2 minutes and a language powerful enough to have many approaches to the challenge (i.e. so not just specialized for pattern matching (even if that's the best option out there)) don't go together. Sure, >90% of my FF pattern matching code is just a ton of (nested) .maps and arrays but others might prefer different styles (e.g. Alions framework was class based, others just went linearly). For the original FF I thought of making a language specifically for my pattern matching ideology, but gave up as the requirements for me to consider it usable were too big. – dzaima May 24 '18 at 16:35

# Make A Full Dobble™ Deck

Dobble (A.K.A. Spot It!) is a deck of (55) cards each of which has a set of (8) distinct symbols, such that every pair of cards matches on exactly one symbol and all symbols are members of pairs.

The base aim of any of the games one plays with a Dobble deck is to find the matching symbols between pairs of cards quicker than your competitors; if you've never played I recommend it.

The deck as sold contains 55 cards and uses 57 symbols, but it is actually a "Full Dobble Deck" of 57 cards with 2 missing. If the missing 2 cards were added there would be 8 distinct symbols on each card such that each symbol would appear 8 times across the deck. Here is a deck I've been playing with, each row being a card (with the 2 missing cards added and asterisked):

  Anchor     Apple      Bird       Dinosaur   Dolphin    Ghost      Ladybird   Turtle
Anchor     Bang       Car        Clef       Flower     Key        Lips       Lock
Anchor     Bolt       Clown      Glasses    No-entry   Snowman    Spider     Target
Anchor     Bomb       Bottle     Dog        Heart      Ice-cube   Moon       Zebra
Anchor     Bulb       Cactus     Dragon     Flame      Scissors   Sun        Tree
Anchor     Candle     Clover     Hand       Man        Skull      Snowflake  Splat
Anchor     Carrot     Cheese     Clock      Hammer     Knight     Maple      Web
Anchor     Cat        Drop       Eroteme    Eye        Igloo      Pencil     Yin-yang
Apple      Bang       Igloo      Maple      Moon       Scissors   Snowflake  Spider
Apple      Bolt       Cactus     Car        Carrot     Heart      Pencil     Skull
Apple      Bomb       Cat        Hand       Lock       Snowman    Tree       Web
Apple      Bottle     Clover     Dragon     Flower     Hammer     No-entry   Yin-yang
Apple      Bulb       Cheese     Clown      Drop       Key        Man        Zebra
Apple      Candle     Clef       Clock      Dog        Eroteme    Flame      Target
Apple      Eye        Glasses    Ice-cube   Knight     Lips       Splat      Sun
Bang       Bird       Flame      Glasses    Heart      Man        Web        Yin-yang
Bang       Bolt       Bottle     Clock      Dinosaur   Drop       Hand       Sun
Bang       Bomb       Carrot     Clown      Dragon     Eroteme    Ghost      Splat
* Bang       Bulb       Dog        Eye        Hammer     Ladybird   Skull      Snowman
Bang       Cactus     Candle     Cat        Dolphin    Knight     No-entry   Zebra
Bang       Cheese     Clover     Ice-cube   Pencil     Target     Tree       Turtle
Bird       Bolt       Bomb       Candle     Cheese     Eye        Flower     Scissors
Bird       Bottle     Eroteme    Key        Knight     Skull      Spider     Tree
Bird       Bulb       Carrot     Clef       Hand       Ice-cube   Igloo      No-entry
Bird       Cactus     Drop       Hammer     Lock       Moon       Splat      Target
Bird       Car        Cat        Clover     Clown      Dog        Maple      Sun
Bird       Clock      Dragon     Lips       Pencil     Snowflake  Snowman    Zebra
Bolt       Bulb       Clover     Dolphin    Eroteme    Lips       Moon       Web
Bolt       Cat        Flame      Ghost      Hammer     Ice-cube   Key        Snowflake
Bolt       Clef       Ladybird   Maple      Splat      Tree       Yin-yang   Zebra
Bolt       Dog        Dragon     Igloo      Knight     Lock       Man        Turtle
Bomb       Bulb       Car        Dinosaur   Knight     Snowflake  Target     Yin-yang
Bomb       Cactus     Clock      Clover     Glasses    Igloo      Key        Ladybird
Bomb       Clef       Dolphin    Hammer     Man        Pencil     Spider     Sun
Bomb       Drop       Flame      Lips       Maple      No-entry   Skull      Turtle
Bottle     Bulb       Candle     Ghost      Glasses    Lock       Maple      Pencil
Bottle     Cactus     Clef       Clown      Eye        Snowflake  Turtle     Web
Bottle     Car        Cheese     Dolphin    Flame      Igloo      Snowman    Splat
Bottle     Carrot     Cat        Ladybird   Lips       Man        Scissors   Target
Bulb       Cat        Clock      Flower     Heart      Spider     Splat      Turtle
Cactus     Cheese     Dog        Ghost      Hand       Lips       Spider     Yin-yang
* Cactus     Dinosaur   Eroteme    Flower     Ice-cube   Man        Maple      Snowman
Candle     Car        Dragon     Drop       Ice-cube   Ladybird   Spider     Web
Candle     Carrot     Key        Moon       Snowman    Sun        Turtle     Yin-yang
Candle     Clown      Dinosaur   Hammer     Heart      Igloo      Lips       Tree
Car        Clock      Eye        Ghost      Man        Moon       No-entry   Tree
Car        Eroteme    Glasses    Hammer     Hand       Scissors   Turtle     Zebra
Carrot     Clover     Dinosaur   Eye        Flame      Lock       Spider     Zebra
Carrot     Dog        Dolphin    Drop       Flower     Glasses    Snowflake  Tree
Cat        Cheese     Clef       Dinosaur   Dragon     Glasses    Moon       Skull
Cheese     Eroteme    Heart      Ladybird   Lock       No-entry   Snowflake  Sun
Clef       Clover     Drop       Ghost      Heart      Knight     Scissors   Snowman
Clock      Clown      Dolphin    Ice-cube   Lock       Scissors   Skull      Yin-yang
Clown      Flame      Flower     Hand       Knight     Ladybird   Moon       Pencil
Dinosaur   Dog        Key        No-entry   Pencil     Scissors   Splat      Web
Dolphin    Dragon     Eye        Hand       Heart      Key        Maple      Target
Flower     Ghost      Igloo      Skull      Sun        Target     Web        Zebra


This is actually a Full Dobble Deck of order N=7, where the order defines the number of :

• symbols (N2+N+1);
• cards (also N2+N+1);
• symbols per card (N+1); and
• cards containing any given symbol (also N+1)

A Full Dobble Deck is analogous to a finite projective plane with points and lines as cards and symbols (or as symbols and cards) and thus may be constructed for any prime-power order (it is an open question whether finite projective planes exist for any non-prime-power order). We shall restrict ourselves to prime orders (it is much simpler to implement).

For example here is a Full Dobble Deck of order 3 (PG(2,3)) using 13 objects/colours (lines) and 13 cards (points) with 4 colours per card (lines incident with each point):

...and here it is as a list of cards containing the objects [0,12]:

[[2,3,8,11],[2,5,6,7],[1,2,9,12],[4,7,8,9],[4,5,11,12],[1,3,4,6],[0,6,8,12],[0,3,5,9],[0,1,7,11],[1,5,8,10],[6,9,10,11],[0,2,4,10],[3,7,10,12]]


### The challenge

Given a prime (N) yield a Full Dobble Deck of that order in any convenient form.
One must be able to observe completion for N=11 (no brute forcing here)
For any other input undefined behaviour is acceptable.

* You may alternatively take as input N+1 or N2+N+1

Here is a Python program that validates a potential Full Dobble Deck (it must be given as a valid list of lists in Python syntax such as the "list of cards containing the objects [0,12]" example above).

• You might want to consider some performance constraint which eliminates brute force approaches and forces people to think about the mathematics. – Peter Taylor May 29 '18 at 11:15
• @PeterTaylor Thanks for having a look at this. I was thinking of having a "one must be able to observe it complete successfully for N=11" but if you have a more concrete idea for a constraint do let me know (maybe it should simply be "N=11 in one minute"? I should probably code something up in a less efficient language to try...) On another note I am also wondering whether to restrict the input from prime-powers to just prime as supporting prime-powers as well as primes adds some complexity to the requirements on the implementation; still mulling, any further input very much appreciated. – Jonathan Allan May 29 '18 at 12:48
• Observing it complete is preferable to "in one minute" because it means that if I have a slower computer it doesn't invalidate my answer, but merely slows down when I can post it. Using just primes is certainly much easier because there's no need to build field towers with irreducible polynomials. I personally would be much more inclined to answer if it's primes only. – Peter Taylor May 29 '18 at 14:03
• Related/dupe maybe? – Dom Hastings May 29 '18 at 20:12
• @DomHastings weird I though, I'd searched both Dobble and Spot It, now I see two. The only things this would bring over the other code-golf question would be: (1) the alphabet there is bounded; and (2) implementing a constraint like Peter suggested. The current answer would need to iterate across (a least a large proportion of) the c(133,12) = 3.8*10^16 possible cards for N=11. I dont think (1) stops this being a dupe, but (2) might. Thoughts anyone? – Jonathan Allan May 29 '18 at 21:22
• @DomHastings Oh, and the brute-force solution there actually fails for N=4 (the first non-prime prime-power) even though I was planning on not requiring that to work the other (at present) does. – Jonathan Allan May 29 '18 at 22:33
• I only vaguely remembered it from when I first played Dobble too! Agree that the answer from the challenge I linked can't be copied over which I think is the main criteria for dupe, right? But the reverse might be true, all answers for your challenge should also solve the previous? So not sure if that make the older one a dupe, but that sounds too political for me! – Dom Hastings May 30 '18 at 11:39
• If the input for this one is restricted to N being prime (or even prime-power) then answers to this would not necessarily solve the other. Furthermore while the other is limited to an alphabet of 62 (while I plan on an execution observation for N=11 which has an alphabet of size 133) answers to the other would not necessarily answer this one. Seems like maybe it's not a dupe after all, even though the premise is exactly the same! – Jonathan Allan May 30 '18 at 12:03

# Chess ASCII Art, Knight

In honor of the world chess championship, in the shortest possible program, output the following ASCII art piece

      ,....,
,::::::<
,::/^\".
,::/,    e.
,::; |        '.
,::|  \___,-.  c)
;::|     \   '-'
;::|      \
;::|   _.=\
;:|.= _.=\
'|_.=   __\
\_..== /
.'.___.-'.
/          \
('--......--')
/'--......--'\
"--......--"


This is a code-golf challenge

• You might want to make sure all the lines are aligned properly (they could be fine, since I'm on mobile and I know it can display differently, but it looks bent to me). – Οurous Nov 23 '18 at 19:59
• you're right, it was a little bent, I've reformatted it – Thaufeki Nov 23 '18 at 20:17
• Seems straightforward enough – Quintec Nov 24 '18 at 1:23
• lol, akin to image compression of pixel art in a very specific case :) I like the idea. – alan2here Nov 24 '18 at 22:22
• The very worst is approx 145 bytes + "verbatim output this". Be fun to see much better ones :) – alan2here Nov 24 '18 at 22:33
• Isn't the World Chess Championship already over? According to google it ended nov. 28th. ;) Did you forgot to post it? – Kevin Cruijssen Dec 3 '18 at 9:08
• Yeah, I made this post on November 23rd, cross-posting from sandbox eventually slipped my mind – Thaufeki Dec 3 '18 at 14:42
• @Thaufeki You could still post it, or are you going to wait a year? ;) – Kevin Cruijssen Dec 4 '18 at 10:22
• I would have to wait two, next one isn't until 2020! I'll post it now – Thaufeki Dec 4 '18 at 14:43

I attempted a problem I threw out as a suggested for 1p5.

In c, lex and yacc I needed more than 9600 characters ungolfed (fully commented, errors handled, some debugging code left in place, but some efficiency sacrificed in the name of shorter code), which seems pretty long, but c is about the most pessimal language you could choose for this problem except fortran 77 or something from the Turing Tarpit. The reference implementation can run its own build, which has some of that bootstrapping voodoo.

None-the-less, this is a relatively big project, and I don't want to post it unless people feel it is both well specified and interesting.

As yet there is no validation script, and I am not sure how one could be written as the acceptable output order could be post-order depth first or post-order breadth first and there is a left-first vs. right-first ambiguity on both. What a bother.

Aside: I'm quite proud of the lex and yacc part of my code, as I consider it spiffy.

## A minimal implementation of the make (1) utility.

By minimal I mean,

• No built in rules, and no pattern or suffix rules.
• No variables and therefore no variable assignment or manipulations; also no variable expansion which includes no expansion of environment variables.
• No automatic variables like $< and$@.

This only leaves constructs (called rules) of the form

<target> ":" <prerequisite>* "\n" ["\t" <action> "\n"]*


Where each <target> and <prerequisite> is a whitespace delimited string which may (or may not) represent a filename. Empty lines have no effect and "#" marks the beginning of a end of line comment (the sequence "#[^\n]*\n" should be treated as "\n" so it does not interfere with rules; this has the side effect of making "#" illegal in targets, prerequisites and actions). Colons are prohibited in identifiers.

The program should take its input from the standard input or by reading a file called "makefile" - implementer's choice. The program then attempts to "build" every target named on the command line. Any targets specified on the command line which do not appear in the makefile and do not represent an existing file should generate an error and cause the program to exit before execution of any rules. In the event that no target is named on the command line, default to building the first target in the input.

Duplicate targets may (not must!) be treated as an error.

A target is deemed already built if

1. It names an existing file and
2. All its prerequisites are fulfilled

Otherwise it is built by

1. Building all unfulfilled prerequisites then
2. Running each <action> sequentially in the order they appear in the input, and if the action returns an exceptional exit state, stopping the program.

A prerequisite is deemed fulfilled if

• The prerequisite represents an existing file and
• The prerequisite is built and
• The target is "newer" than the (fully built) prerequisite

A target is deemed "older" (i.e. not "newer") than its prerequisite if one of

• Both represent files and the prerequisite has been modified more recently than the target.
• The target does not represent an existing file, and the prerequisite does.

apply.

Authors on systems which do not support fork/exec semantics may write a batch file or script which is invoked as the program terminates, but that script must stop on the first unsuccessful action.

## Sample Input

# Babymake compatible makefile for babymake
all:babymake

babymake : lex.yy.o  y.tab.o  babymake.o
cc -o babymake lex.yy.o y.tab.o babymake.o

babymake.o : babymake.c babymake.h
cc -c babymake.c

lex.yy.o: lex.yy.c y.tab.h
cc -c lex.yy.c

lex.yy.c : babymake.l
lex babymake.l

y.tab.o: y.tab.c babymake.h
cc -c y.tab.c

y.tab.c : babymake.y
yacc -d babymake.y

clean:
rm -f babymake.o  lex.yy.o  y.tab.o

cleaner: clean # just testing end of line comments
rm -f y.tab.c y.tab.h
rm -f lex.yy.c

bogus: boguser
echo "building bogus" # test in another context


## Sample output

$./babymake < babymake.example cleaner rm -f babymake.o lex.yy.o y.tab.o rm -f y.tab.c y.tab.h rm -f lex.yy.c$ ./babymake < babymake.example all
cc -c babymake.c
yacc -d babymake.y
cc -c y.tab.c
lex babymake.l
cc -c lex.yy.c
cc -o babymake lex.yy.o y.tab.o babymake.o
$./babymake < babymake.example$ ./babymake < babymake.example bogus
ERRNO: 2: No such file or directory No rule to make target 'boguser'.

• The program should take it's input from the standard input or by reading a file called "makefile" - is this a choice for the implementer to make? Or should the program read stdin, and if it's empty then look for makefile? Any targets specified on the command line which do not appear in the makefile and do not represent an existing file should generate an error before execution of any rules. Does "generate an error" include aborting, such that no rules are executed? Running each in sequence - missing "action"? Why is the sample input indented? I'll do an edit for punctuation in a bit. – Peter Taylor May 20 '11 at 21:36
• In order. (1) Implementer's choice. Should be more specific. (2) Generate an error means abort; this is a unix utility after all. (3) The sample is indented because I made a strenuous effort to get the tabs in, and MarkDown just doesn't like tabs. Also there is a new sample input that has some comments in. – dmckee May 20 '11 at 21:49
• More questions: 1) The target is "newer" than the prerequisite once *they* have been fulfilled. What does this mean? Should this text be talking about building? 2) Under what circumstances can a target be built twice? – Peter Taylor May 21 '11 at 19:51
• 1) Yes and 2) Standard make never builds a target twice, and neither does my reference implementation. But I should probably say that it is or is not allowed. Do you have a feeling in the matter? – dmckee May 21 '11 at 20:43
• Saying that it is not allowed is probably best. Otherwise there's potential for stuff to go wrong when multiple targets depend on clean, which will never be built because it doesn't correspond to a file. – Peter Taylor May 21 '11 at 21:15
• I suggest that the golf exercise be to simply output the list of commands to run, not actually execute them. Will make testing much easier. – MtnViewMark May 27 '11 at 0:50
• This is awesome. But I'm too mystified by make to even fathom how it goes about it. I'd never be able to do this without stealing ideas from other posts on the page. But then, I'm an introverted intuitive, intellectuals would probbly have an easier time. :) I haven't checked, but .. I say it's ready to post. Answers may be slow in coming, but they WILL come! – luser droog Nov 23 '12 at 4:45
• @luserdroog my reference implementation builds a directed graph (in the technical sense) of dependencies and then starts evaluating from the named target(s). I can't recall right off if I enforced acycality on the graph or not. I believe that real make insists on it. – dmckee Nov 23 '12 at 5:10
• That doesn't semm quite so unfathomable. I suppose the variables and impicit rules are responsible for much of the mystery. – luser droog Nov 23 '12 at 5:45
• This has been inactive for five years. If you're not going to post it, may I? – MD XF Aug 17 '17 at 16:59
• @MDXF I think I'd rather post this one myself, but it may be a few days. – dmckee Aug 17 '17 at 19:51

# Find sociable numbers

### Background

A number is perfect if it is the sum of its divisors; for instance 6=1+2+3

A pair of numbers is friendly if they are the sum of each other's divisors; for instance 284=1+2+4+5+10+11+20+22+44+55+110 and 220=1+2+4+71+142.

In general, a list of n numbers is sociable if each element is the sum of divisors of the previous elements, with the first being the sum of divisors of the last.

### Input

An integer, n on STDIN.

### Output

A list of n numbers which are sociable, in the order outlined above, each on its own line. If you can't find any suitable list, you may output nothing, False, or 0, but you must search up to at least 2^32-1, and preferably as high as your language will allow

### Winning

This is code-golf, so the shortest code wins. However, I will also create a bounty to be awarded to the fastest program, as measured on my command-line (Windows 7 with GNU coreutils, python27, python3, node.js, perl) or in a web IDE in chrome (brainfuck, golfscript?)

Edit: to clarify the relationship between input and output

• The relation between the input and output is unclear. Are we asked to find the loop of sociable numbers that the input number leads to by iterating "sum of proper divisors"? – John Dvorak Apr 19 '14 at 11:17
• @JanDvorak, no, we're asked to find a cycle of length n in the directed graph whose vertices are the natural numbers and whose edges are i -> aliquot_sum(i). – Peter Taylor Apr 19 '14 at 19:09
• I don't think it's a good idea to have a code golf and a fastest code challenge in the same problem. You'll get incomparable answers. Maybe make a composite score that incorporates time and length? – isaacg Apr 21 '14 at 0:58
• That may be better. – Isiah Meadows Apr 21 '14 at 21:08
• Would you allow the usage of predefined functions that calculate the aliquot sum? – Wrzlprmft Apr 22 '14 at 13:49
• @alexander-brett Are you going to post this? – Oliver Ni Oct 9 '16 at 4:28
• Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. – programmer5000 Jun 9 '17 at 16:38

## Verification of solutions to the 3 knishops problem

For the purposes of this question, a knishop is a fairy chess piece which can move to precisely those squares which are not an integer distance away. So knight moves (distance $\sqrt{5}$) are ok, as are bishop moves (non-zero multiples of $\sqrt(2)$) and many more besides.

The 3 knishops problem is to place 3 knishops on an infinite chessboard such that none of them attack each other, but every square other than the 3 they occupy is attacked by at least one of them. A more prosaic formulation is to find three lattice points which form an Erdős-Diophantine graph.

Your task is to write code (see below) which takes three co-ordinates as input and produces a truthy or falsy output: truthy if the co-ordinates are a solution to the 3 knishops problem, and falsy otherwise. The code must be able to handle each of the test cases below in no more than one minute on a reasonable desktop machine.

### The small print

"Write code" should be understood to permit one of the following:

• A program which takes input via stdin and gives output via stdout. The permitted input formats are 6 integers, delimited by your choice of a comma or whitespace, and optionally wrapped in one of parentheses (), curly brackets {}, or square brackets []; or three pairs, each pair similarly delimited and wrapped, and the pairs similarly delimited and wrapped. Examples:

0 0 3 4 12 13
(0,0,3,4,12,13)
{0,0},{3,4},{12,13}
{{0 0} {3 4} {12 13}}
[{0 0} {3 4} {12 13}]


Or using different whitespace for the two types of delimiter:

0 0
3 4
12 13

• A named function, verb, block, or equivalent which takes input as an array of six values, an array of three two-element arrays, three separate arrays of two-element arrays, or six separate parameters; and gives output as a return value.

You may assume that none of the input values or the unattacked points have coordinates outside the range $\pm 2^30$.

### Test cases

input                          output

(0 0) (0 0) (0 0)              false
(0 0) (3 4) (12 13)            false
(5 -5) (8 -1) (2 -9)           false
(0 0) (384 2030) (720 1653)    true


TODO More test cases.

NB I need to code up some naïve approaches and test whether the one-minute restriction is actually relevant. I'm hoping that MathJAX will be enabled; if not, the stuff in dollars will be replaced before posting.

# Write a Connect Four Bot

Your task is to write a Connect Four bot. Your submission must be less than 2000 bytes long. You may not save state. You may not use libraries or external resources that are, at my discretion, related to Connect Four.

Gameplay

Your submission will play against each other submission one hundred times. Each player will play first for exactly half of the matches. Each match flows like:

1. Player 1 drops a red token into a column.
2. If Player 1 has not won, then Player 2 drops a black token into a column.
3. If Player 2 has not won, repeat.

Tokens fall down a column until they collide with another token in the row beneath it or hit the bottom of the board. Your program will be terminated and called anew after each move. You win the match if you connect four tokens vertically, horizontally or diagonally.

The winner of the challenge is the submission with the most match wins at the end of a tournament.

Input

The first command line argument you will receive is the game board. Rows are ; delimited . Cells are , delimited. The first row is the top of the board. A cell contains 0 if unoccupied, 1 if occupied by Player 1, and 2 if occupied by Player 2. The board you receive will always be 7 columns by 6 row.

The second command line argument you will receive is your player number. That means 1 or 2.

Examples:

java ThatBot 0,0,0,0;0,0,0,0;0,2,1,0;0,1,2,1 1

Output

You will print the column for which you would like to move to STDOUT. Columns are zero indexed. The following earns an immediate loss:

• Dropping a token into a full column
• Dropping a token into a column that does not exist
• Failing to output anything to STDOUT within one second

Deliverables

You must submit the following:

• A program
• A unique name
• A method of calling your program via command line
• Any instructions I might need to compile your program. I'll try my best, but my best isn't always good enough.

• Oops, didn't see that, sorry :S I think there might be problems still, as several moves could be hard-coded in. (i.e. the first move(s) is always just the middle column) – FryAmTheEggman Feb 4 '15 at 17:07
• @FryAmTheEggman I am totally fine with a few hard coded moves, but perhaps I should reintroduce the byte limit that I originally had in place. Do you think 500 characters is sufficient? I went ahead and added it back. I also added a restriction on external resources to prevent external hard coding. It's probably a loophole, but one worth covering I think. (I'm in chat btw if you want to discuss.) – Rainbolt Feb 4 '15 at 17:08
• 500 seems fine, but it might squeeze Java / C# entries. I'll see how long a pretty bad bot is over the weekend if you haven't posted yet ;p – FryAmTheEggman Feb 4 '15 at 17:21
• @FryAmTheEggman It will be a little while. I haven't written the controller yet. Thanks for the feedback! – Rainbolt Feb 4 '15 at 17:25
• I took a program that claims to do perfect play and added some timing: the vast majority of its moves take less than 1ms; in about 1 game in 8 it has a single move which takes more than 1s. The longest I've seen was just short of 2s, so with a bit of optimisation and a more modern computer it might well come inside the 1s limit. The byte limit would hit it hard, though: its opening book is 12k. – Peter Taylor Feb 4 '15 at 20:14
• @PeterTaylor Thank you for that. Knowing what you just found out, do you think that the 500 byte limit plus the timing restriction are enough to make the challenge interesting? If someone can solve Connect Four optimally under those restrictions, then at least PPCG has created something worth having, right? I'm just asking because nobody has upvoted the sandbox proposal, so I assume that maybe there are still some concerns about it. – Rainbolt Feb 4 '15 at 20:37
• I got distracted by looking for work on perfect play and didn't post the thoughts I had. I'm slightly confused about the input format: is \n a literal backslash followed by an n, or does it mean a newline character? The latter would be my assumption, but the example input makes it look literal (and wouldn't work if it were newline). I don't think you specify whether the output assumes 0-indexed or 1-indexed columns. I'm not sure whether the rule about external resources is intended to indicate that I can fetch stuff from the web without it counting towards the byte limit. – Peter Taylor Feb 4 '15 at 21:18
• I feel that with a strict byte limit, you're most likely to see mainly versions of min/max or other "simple" algorithms. If you want more interesting or varied players, you may want to relax it. Banning extensive hard-coding is good, but I'd hate for it to come at the expense of creativity. – Geobits Feb 4 '15 at 21:19
• The byte limit and timing restriction between them may be too much: I can't see any approach which attempts a real analysis fitting into 500 bytes except in a golfing language which will struggle with the time limit. Maybe 2kB would be a better compromise. – Peter Taylor Feb 4 '15 at 21:20
• @PeterTaylor 2000 bytes it shall be, then. I changed the row delimiter to ; to eliminate confusion. I added that columns are zero indexed. The rule about external resources was intended to allow you to fetch from existing resources, but to disallow you to fetch from resources that were created after the fact. In hindsight, this might open the door to abuse, so I've removed that allowance. I'm unsure if this leaves the challenge vulnerable or not, so I'll bring it up in chat. – Rainbolt Feb 4 '15 at 21:28
• Discussed in chat and made the change. I think I've addressed all comments up to now. – Rainbolt Feb 4 '15 at 21:38
• I didn't look very closely at that command line. It should be java MyBot (or maybe java -classpath c:\ MyBot, not java C:\MyBot.java. Other that that, looks good. – Peter Taylor Feb 4 '15 at 22:40

# Fortnightly Challenge #4 - Data Structures

Join us in the Fortnightly Challenge Chat to work out the details of this challenge!

Imagine square coloured blocks where each side can be connected to another block, allowing you to move or rotate connected blocks as one. Let's call a collection of such blocks, all connected to each other either directly or indirectly, a group.

Your task is to simulate these blocks via a number of commands which you must implement.

# Commands

All input commands will be given one per line (via STDIN), and likewise all query outputs should one per line (via STDOUT).

• place <x> <y> <colour>: Place a block with a given colour at the specified coordinates.
• remove <x> <y>: Remove the block at the specified coordinates, deleting any connections with it.
• connect <x1> <y1> <x2> <y2>: Connect two adjacent blocks.
• disconnect <x1> <y1> <x2> <y2>: Disconnect two adjacent blocks.
• count: Count the number of groups and print the result.
• move <x> <y> <dx> <dy>: Move the entire group containing the specified block by the given offset.
• rotate <x> <y> <times anticlockwise>: Rotate the entire group containing the specified block anticlockwise about said block by some number (guaranteed to be either 1, 2 or 3) of times
• connected <x1> <y1> <x2> <y2>: Print y if blocks exist at the two given coordinates and they are in the same group, or n otherwise.
• nearest <x> <y>: Print the nearest block to the given coordinate by Manhattan distance (difference in x-coordinate + difference in y-coordinate), in the form <x> <y> <colour>. If there are no placed blocks, print none. If there is more than one closest block, print any.
• colour <colour>: Print all block coordinates with the given colour, each space-separated and of the form (<x>, <y>). If there are no such blocks, print none.
• halt: Terminate the program

## Errors

Commands will always be given with the correct number and type of arguments. However sometimes an operation doesn't make sense, for example:

• Placing a block where a block already exists
• Removing, connecting, disconnecting, moving or rotating non-existent blocks
• Connect or disconnecting blocks which are already connected or disconnected
• Move or rotate commands which end up with two blocks overlapping (with emphasis that only the final state matters — groups which are rotated 2 or 3 times do not need to check for overlaps after each rotation)

If any of the above occur, print Error: <command>. For example, if there is no block at 0,0, then the command remove 0 0 will result in

Error: remove 0 0


Note that queries should never result in an error.

# Scoring

There will be six types of test cases:

1. A test which is biased towards place/remove commands
2. A test which is biased towards connect/disconnect/count/connected commands
3. A test which is biased towards move/rotate commands
4. A test which is biased towards nearest commands
5. A test which is biased towards colour commands
6. An all-rounder test

This is , so the goal is to make your program process the commands as quickly as possible. A leaderboard will be kept for each type of test,, and the winner will be the user with the lowest sum of placements over all tests (e.g. if you came 1st, 3rd, 2nd, 2nd, 3rd, 4th then your score is 1 + 3 + 3 + 2 + 2 + 4 = 15).

The tests and test generator can be found on this Github page, along with a unit tester which will be run for each submission to ensure correctness.

# Rules/clarifications

• To prevent cluttering the leaderboard, each user may provide at most one submission
• No multithreading or parallel processing
• Use no more than 2GB of RAM — this rule is not strictly enforced, but horribly space-inefficient solutions may be disqualified
• No third party libraries (standard libraries are OK)
• All coordinates are guaranteed to fit into a 32-bit int, and all colours are alphanumeric strings

# Example

(in progress)

• 2. Lego pieces/attachable cubes – trichoplax Jan 25 '15 at 21:07
• 5. Controller-mediated build-your-own data structure – trichoplax Jan 25 '15 at 21:11
• A. Lego pieces. – trichoplax Jan 28 '15 at 8:35
• B. Attachable unit cubes (for simplicity) – trichoplax Jan 28 '15 at 8:36
• Winning criteria: – Sp3000 Jan 28 '15 at 23:43
• I. Code golf (fewest bytes) – Sp3000 Jan 28 '15 at 23:43
• II. Fastest algorithm – Sp3000 Jan 28 '15 at 23:44
• Number of cube structures: – Sp3000 Jan 29 '15 at 0:42
• 1. Exactly one structure – Sp3000 Jan 29 '15 at 0:42
• 2. Any number of structures – Sp3000 Jan 29 '15 at 0:43
• Connections/adjacency: – Sp3000 Jan 29 '15 at 0:43
• A. Connections should be explicitly given via a function call – Sp3000 Jan 29 '15 at 0:44
• B. Each cube is connected to the cube it was built off – Sp3000 Jan 29 '15 at 0:45
• Moving to 2D might simplify rotations greatly, while retaining enough complexity to be worth a challenge. – user16991 Feb 5 '15 at 1:49

# Bitstring Family Trees

This challenge is reproduced from memory and my own solution, from a challenge that was posted in the job-application section of http://itasoftware.com before they were bought by Google. I reached out to ITA and Google a few years ago, after the acquisition, to ask to re-post this here (and on codegolf.com when it existed) and never heard back from them.

A bitstring is a string of 1s and 0s. Bitstrings reproduce asexually through a mutation-prone process, producing a child that is a copy of its parent but with each bit flipped with 25% probability. Starting with a list containing one bitstring, we repeatedly select one bitstring from the list at random, produce its child, and add that child to the list. This produces a list of bitstrings, each of which (except the first) has somewhere earlier in the list a parent from which it was mutated.

Now, the challenge. Your program will be presented with a list of bitstrings produced as described above, but the order of the list will be shuffled. You are to calculate the least improbable family tree for the given bitstrings. If there are two or more such trees, choose any of them.

Your input can be in any useful format, including as a list/array of lists/strings as a function parameter or in a variable, already existing on the stack for a stack based language, or from stdin with delimiters but not operators, so four four-bit strings might be "1010\n1001\n1011\n0010" or "[1010,1001,1011,0010]" or even "4 1010100110110010".

Your output can be in any unambiguous format. The canonical format is a list of integers, where the nth integer in the list is the index of the nth provided bitstring's parent in the original list, and a sentinel value for the root entry. Another acceptable form could be an actual tree data structure. Either of these might be returned from a function, printed to stdout, left in a variable, or left on the stack of a stack based language.

The above two provisions should be interpreted with the context that this challenge is not about golfing the input and output code. It's about golfing the algorithmic logic.

For the example input above of 1010,1001,1011,0010 the most likely family tree is that the first entry is the root, the last two are children of the first, and the second is a child of the third, all three mutations involving a single bit flip out of four bits.

With the challenge I will provide a few data sets of different sizes (10 10-bit strings, 100 100-bit strings, maybe bigger) with their solutions.

• Could you give a more precise definition of 'most likely'? – feersum Jun 7 '15 at 21:30
• If two family trees are equally likely, can either be output, or would you prefer a rule to specify which one must be output? – trichoplax Jun 7 '15 at 22:18
• Would it be interesting to have the 25% probability provided as an input p, or would keeping the parameter fixed allow for more golfing opportunities? – trichoplax Jun 7 '15 at 22:20
• @feersum I'm not sure what you mean. Highest probability? Least improbable? – Sparr Jun 8 '15 at 2:45
• @trichoplax I hadn't considered that. I guess I'd accept either. I'll mention that. The probability in the original question was 20%, but I think a non-repeating decimal in base 2 will be much more golf-friendly. – Sparr Jun 8 '15 at 2:46
• With respect to @feersum's question, I see at least two subtleties. Firstly, what assumption should be made about the distribution of the initial bitstring? Secondly, the "family tree" isn't in bijection with the sequence of random selections. The first one needs to be addressed explicitly; the second is probably best addressed with a worked example which calculates the probabilities for each possible sequence and then sums them over the family tree corresponding to each sequence. As an additional point, an important corner case will be one where the bitstrings aren't all distinct. – Peter Taylor Jun 9 '15 at 11:22
• @PeterTaylor The initial bitstring is a sequence of bits chosen independently and uniformly at random. I am unclear on your second point. Do you mean that it's possible for the family tree produced at random to not be the one most likely to have produced a given result set? That makes sense, but seems obvious. I can work out the 4x4 example by hand with probabilities for each of the 6 possible family trees, if that would clarify things? – Sparr Jun 10 '15 at 15:44
• I agree that it's obvious, but it is often a good idea to state the obvious, because otherwise it can be overlooked. For example, it's also obvious that the 4x4 example must have more than 4! = 24 possible family trees... (I think it's 64 possible trees, so maybe that was just a typo). – Peter Taylor Jun 10 '15 at 16:28

# The Virtual Prisoners king-of-the-hill

### Background

The year is 2251. You are a self-evolving KOTH bot, in the mysterious land known as Programming Puzzles and Code Golf. To evolve, you need permissions, and to get permissions, you need reputation. You decide that the best way to do this is to take over all of the questions to gain as much reputation as possible. The only problem? Every other bot has decided to do the exact same thing.

### Game Explanation

Each round is battled on a question, with 11 vote nodes, between you and your enemy. The board starts as this:

A1 A2 A3 N4 N5 N6 N7 N8 B9 B10 B11


A is player A's nodes, B is player B's nodes, and N is a neutral node.
Each turn, you may:

• Vote on a vote node. If both players vote, nothing happens. If one side votes:
• and the node is controlled by no-one (neutral), it becomes that side's.
• and it is controlled by the voter's enemy, it becomes neutral.
• and it is controlled by the voter, nothing happens.
• Guard a vote node. This guards the node from votes (friendly or enemy) for 2 turns.
• Use your 'power'. The powers are listed below, including how to use them.

Your side wins if it controls at least 2/3rds (66%) of the vote nodes.

10000 rounds will be run, and the winner of the KOTH is whichever bot has the most wins (in the event of a tie, or indeterminate outcome, more matches are run until a clear winner is decided.)

### How Your Bot Should Work

It should accept as command-line arguments:
B A1 A2 A3 N4 N5 N6 N7 N8 B9 B10 B11
Where A denotes Player A's nodes, N denotes a neutral node, B denotes Player B's nodes, and the first argument (B in this case) is the player your bot is. (This is decided randomly, your bot should work regardless.)
It should return one of the following (powers are general rules):

• V-4, vote on node 4
• G-3, guard node 3
• P-N, use power 'Neutralize'
with or without a trailing newline.

### Powers

Intended to give bots a small boost. If X was your power, you would use P-X. You may only have one power per bot.

• N - Neutralize: Turn 2 random nodes to neutral ones.

• R - Rebellion: Pick a random node, and randomly turn it to a friendly, neutral, or hostile node.
• S - Swift Strikes: Pick two random nodes, and vote on them.

Here are the extra rules:

• The bots must fully run offline.
• The bots may not attempt to read any files, including their own source code.
• The bots may not tamper with, hack, or destroy other bots.
• The bots must return one of the three commands (V, G, or P). If they do not, they forfeit their turn.
• The bots must not be targeting other bots specifically. (Beating general strategies is welcome.)
• You may update your bot as often as you like, but bots that are updated very frequently with no good reason (i.e, fixing fatal errors is a good reason) will be disqualified.
• Your bot must take under 90 seconds for it's turn. If it takes longer, it will be disqualified.

### Submission contents

• The code for the bot
• The language it is written in (and a link to an offline interpreter, if necessary)
• How to compile and run your bot

If you do not include all of the required items in your submission, you will be notified, but your bot may not compete until this is fixed.

### Example Match

Matches are organized between 2 randomly-selected bots. Here is an example, with bots A and B:
The board begins as this:

A1 A2 A3 N4 N5 N6 N7 N8 B9 B10 B11


Bot A makes his move, voting on N4, then Bot B votes on N5:

A1 A2 A3 A4 B5 N6 N7 N8 B9 B10 B11


Node 4 becomes A4, and it is now controlled by Bot A. Likewise, node 5 becomes B5.

A votes on N8, and so does B:

A1 A2 A3 A4 B5 N6 N7 N8 B9 B10 B11


Why did nothing happen? That's because both bots voted on the same node - cancelling out each other's effects.

When one bot controls 66% or greater of the nodes, that bot gains a win and the other bot gains a loss.

The game ends after 1024 turns, to prevent any bots that wait around forever. Whoever has the most nodes afterwards wins, or a draw if they have the same amount.

• I will be submitting an example bot written in Python as part of my challenge. You are free to use and modify this bot for your submission.
• If your bot gives invalid output (not of the form C-A, where C is the command and A is the argument), the bot forfeits its turn. If it does, you will be notified, and your bot will be removed until it is fixed.

## Meta Questions and Notes

• Are there any loopholes?
• Should I add/modify/delete some of the powers?
• Is something too simple/confusing/uninteresting/overpowered?
• Should bots be able to see which nodes are and are not guarded?
• Should I limit people to one bot? If not, I will prevent the same person's bots from battling each other.
• I have thought of the following alternative way to win matches:
• The game lasts 1024 turns. Whoever has the most nodes at the end wins.
• If, at one point, one bot controls all 11 nodes, that bot automatically wins.
• Would this be a better win condition?
• I have a few questions. 1) If I make a new node, will it be neutral? 2) How are the matches organized? If there are, say, 5 submissions, does each pair have a separate battle, after which you count victories, or do they somehow work in teams (as the title suggests)? 3) With some strategies it may be that the game runs forever. You should probably add a time limit (some N turns), after which the game automatically ends in a draw, or a win for the player controlling the most nodes. – Zgarb Apr 7 '15 at 15:38
• @Zgarb Thanks for your feedback! I've included a section on how the game works. – ASCIIThenANSI Apr 7 '15 at 15:53
• Could you add C# (or .NET in general?) – LegionMammal978 Apr 7 '15 at 15:55
• @LegionMammal978 How do you install that on Linux? The list is mostly because I can't run a lot of things like GolfScript, but I'd be glad to, if you can tell me where to find it. – ASCIIThenANSI Apr 7 '15 at 15:56
• @ASCIIThenANSI you could use Mono. I'm mainly just looking for C#. – LegionMammal978 Apr 7 '15 at 16:02
• @LegionMammal978 Oh, OK. Turns out I installed it for an earlier purpose, thanks for your help! – ASCIIThenANSI Apr 7 '15 at 16:09
• It's not complete, but this question has instructions for running a number of languages. – Peter Taylor Apr 15 '15 at 22:15
• @PeterTaylor Thanks for the link! – ASCIIThenANSI Apr 16 '15 at 12:57
• Maybe add a clock time limit for each turn, so bots don't simply run an endless loop blocking you running the simulation? – Paŭlo Ebermann Oct 11 '15 at 8:33
• @PaŭloEbermann I'll watch each of the simulations (with output on what the bots are doing), and any bot that takes too long is disqualified. – ASCIIThenANSI Oct 12 '15 at 14:04

# Verify a game of Morpion Solitaire

Morpion Solitaire is an interesting, unsolved "single-player game". (The linked site lists several variants - we're talking about 5T here.) It has been proven that solving or even approximating it is NP-hard. But we're going to do something simpler here: your challenge will be to verify whether the game has been played correctly.

The rules are fairly simple. You start on a regular (infinite) grid, with 36 intersections marked in the following shape:

Now a move consists of drawing a straight line segment, orthogonally or 45 degrees with the grid, through four marked and one unmarked intersection. The unmarked intersection will then be marked for future moves:

The lines may cross or touch, but they must never overlap (notice that the last move shares an endpoint in a straight line with an earlier move, but does not overlap with it). The goal of the game is to make as many move as possible. The world record is at 178 moves.

Because the grid gets very messy after a while, it becomes very hard to reconstruct a game. People work around this problem, by writing consecutive numbers into the intersections they add. However, even when this is not done, it is always possible to verify the validity of game.

## The Challenge

You're given an ASCII representation of a played game of Morpion Solitaire (the game may or may not be finished). Every other cell represents an intersection, which can be either unmarked (.), one of the initial intersections (o) or one of the intersections added by a move (#). All other cells are either spaces, or one of -, |, /, \, X indicating that a line-segment was drawn across the two adjacent intersections. The example above would look like this:

. . . . . . . . . . . .

. . . . o-o-o-o-# . . .
|/     /
. . . . o . . o . . . .
/|    /
. . . # o . # o . . . .
/  |  /
. o-o-o-o-# . o o o o .
/    |/
. o . . # . . . . . o .
|
. o . . # . . . . . o .
|
. o o o o . . o o o o .
|
. . . . o . . o . . . .
|
. . . . o . . o . . . .

. . . . o o o o . . . .

. . . . . . . . . . . .


Output a truthy value if the game represented by graph can be played by following the rules, and a falsy value otherwise.

You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.

You may assume that the initial intersections always form the cross shape displayed above (although I doubt any answers will be affected by this).

Your code should solve any of the test in less than 5 seconds. This should not be an issue as very efficient solutions exist.

Standard rules apply.

## Sandbox Notes

• The simplest representation for parsing would be to give either the endpoints of each line as cartesian coordinates, or one endpoint and a direction (either one of 8 directions, or it could be standardized to one of 4 directions if the N/E/NE/NW is always the endpoint given.) Checking would then be fairly straightforward: start with the empty grid and see which lines are allowed, until all are exhausted. – Level River St Dec 21 '15 at 9:34
• The ASCII art representation will require more effort for parsing: I think it's unambiguous because you can identify endpoints by looking for for intersections which don't have opposite pairs of |_\/, but it could take quite a few parses through the file. You would also need some way of identifying the start points. – Level River St Dec 21 '15 at 9:35
• @steveverrill There will be no information about endpoints in the input. In a finished game (without numbering) you only have individual line segments (four of which make up a move). That's why I think an ASCII representation is simpler than a graph, where you need to piece together manually which edges form a straight line of four segments. I also think an ASCII representation doesn't necessarily need to be parsed at all: I think it can be solved straight via manipulation of the character grid (in fact, this should be doable in Retina). – Martin Ender Dec 21 '15 at 9:45
• 1. It would be clearer to talk about drawing a straight line segment through 4 marked and one unmarked lattice point, as "straight line" often implies that it's infinite. 2. It seems that the lines must be axis-aligned or at 45 degrees to the axis. If so, it would be good to state that explicitly in the description of play. 3. The page linked in the first sentence is very uninformative. I assume you did it because the diagrams on the Wikipedia page are for a different initial setup, but there must be some better external link. – Peter Taylor Dec 21 '15 at 9:48
• In that case I would go for the ASCII art representation. It also depends to some extent on which is the most convenient way for you to obtain / generate test cases. – Level River St Dec 21 '15 at 9:51
• @PeterTaylor Thanks, I'll edit those suggestion in. As for the page I linked, did you see the navigation in the left iframe? (I overlooked that at first.) I'll link to Wikipedia as well though. – Martin Ender Dec 21 '15 at 9:52
• I agree with Peter that the website is a bit of a mess. There are many variations of the game, so I think you should state that this is the 5T variant (identified by the fact that Christopher Rosin holds the records for 5T at 178 moves and 5D at 82 moves.) It took me a while to work out why Marc Bertin at 216 moves in 1974 was not the record holder: (He was playing 5T+.) Only the 5T (endpoints of parallel lines touching allowed) and 5D (endpoints of parallel lines must be disjoint) variants are unsolved according to the website. – Level River St Dec 21 '15 at 9:57
• The person who wrote that site needs to be dragged kicking and screaming into the 21st century. But I'd prefer a link to morpionsolitaire.com/English/Rules.htm and the navigation be damned than a link to the front page. – Peter Taylor Dec 21 '15 at 10:01

# Four-Byte Bloom Filter

Bloom filters are cool. In the words of that Wikipedia article:

A Bloom filter is a space-efficient probabilistic data structure, conceived by Burton Howard Bloom in 1970, that is used to test whether an element is a member of a set. False positive matches are possible, but false negatives are not, thus a Bloom filter has a 100% recall rate. In other words, a query returns either "possibly in set" or "definitely not in set".

The motivation behind Bloom filters is that, by giving up perfect accuracy, the amount of memory necessary can be dramatically decreased.

A Bloom filter takes the form of a set of bits, along with a set of hash functions. To insert something into the Bloom filter, calculate the N different hashes and flip those bits to 1.

initialization
00000000

letter P maps to 1 when using hash function F and 6 when using hash function G
01000010


letter h maps to 6 and 4
01001010


To test if an element is a member of a set, perform the hashes and check to see if those bits are 1. If not all of them are 1, then it can't possibly be a member of the set. If they are all 1s, then it could be a member.

letter W maps to 0 and 4
01001010
^   ^
W is not a member

letter P maps to 1 and 6
01001010
^    ^
P could be a member (it is)

letter i maps to 4 and 1
01001010
^  ^
i could be a member (it is a false positive)


As more elements are added to the set, the probability of false positives increases. In large-scale applications, a Bloom filter with a small error rate is still an order of magnitude smaller than an exact database. Below is a neat diagram from this great article on probabilistic data structures.

In this challenge, you will implement a miniature Bloom filter. A really, really small Bloom filter with 32 bits. Your data type will be the 94 non-whitespace printable ASCII characters.

Functionality

The Bloom filter will have 32 bits and 2 hash functions. It is up to you what those two hash functions are, they simply must be decently independent of one another. (Sandbox note, should I specify the hash functions?). Your program will be asked to do two separate tasks:

• Given a current state of the bloom filter and a list of characters, add those characters to the filter and output the new filter state
• Given a current state of the bloom filter and a list of characters, test those characters for membership and output a list of truthy (could be a member) or falsey (definitely not a member) values.

Formatting specifics

Input consists of the current state, an operation, and a list of characters. The Bloom filter state will be represented as a string of 8 hexadecimal characters. This will then be followed by either + for adding or ? for membership testing. Finally, there will be a list of between 1 and 94 characters (printable non-whitespace ASCII) as data points.

Output will either be the new state, as 8 hex characters, or a list of truthy/falsey values.

## Example I/O

This represents adding the characters in my username to a blank filter
00000000+PhiNotPi
This is a possible output (7 bits have been permanently flipped)
48a01030

This represent adding the character 1 to the current filter
48a01030+1
This is a possible output (9 bits flipped so far)
48a01074

This represents testing for membership of Phi
48a01074?Phi
Output must be all true since they were added in earlier
[True, True, True]

This represents testing for membership of 12345
48a01074?1234
Output must be true for 1, but not necessarily false for the others
[True, False, False, True, False]

• You should specify the hashing function, if you don't want the hashing function is a mod 32 or worse, return 4. – Akangka Jan 14 '16 at 14:34

# The largest convex polygon

Given an input of at least one coordinate pair on the Cartesian plane, determine the largest number of sides a convex, non-self-intersecting polygon formed from those points can have.

A convex polygon is a polygon such that there is an angle strictly less than 180˚ and greater than 0˚ between each pair of consecutive sides. Note that if three points are collinear, they still only form one side. Two sides cannot have a 180˚ angle between them.

The ordinate and abscissa of a coordinate are not necessarily integers, and they can be positive, negative, or zero.

If there are less than 3 points, or if the points inputted cannot form a convex polygon, the program should output 0.

Test cases

(0,0) (1,1) (3,4)
==> 3

(0,0) (-1,-1) (5,5)
==> 0

(-1,0) (1,0) (0,1) (5,5) (-5,5) (0,-5)
==> 3

(-3,2) (4,6) (-1,2) (0,4) (5,-3) (-2,-2) (1,1)
==> 5

(0,0) (10,0) (10,10) (9,1) (10,4) (9,6) (5,4)
==> 5


Here are pictures for the test cases, in order. Note that solutions are not necessarily unique. (Made with Geogebra)

• For the third test case, can't you get a four-side polygon (-5,5) -- (5,5) -- (1,0) -- (-1,0) -- (-5,5)? (or (0,-5) -- (-1,0) -- (0,1) -- (1,0) -- (0,-5)) – David Feb 16 '16 at 0:09
• @David Thanks for catching that. I will fix it tomorrow, – Arcturus Feb 16 '16 at 5:06
• This could probably use some more test cases where the result is not the convex hull... if possible even one where none of the points of the convex hull are part of the solution. – Martin Ender Feb 16 '16 at 7:45
• @MartinBüttner The last test case is not the convex hull, as (10,0) and (10,10) are not included in the output polygon. – AdmBorkBork Feb 16 '16 at 15:08
• @TimmyD The emphasis in my sentence was on "more". ;) (I admit that may not have been obvious.) – Martin Ender Feb 16 '16 at 15:09
• @MartinBüttner I read it as "This could probably use some more test cases, [such as] where the result is not the convex hull" ... yay, English. – AdmBorkBork Feb 16 '16 at 15:15
• @TimmyD I like ambiguity more than most people. – Martin Ender Feb 16 '16 at 15:22

# Introduction

The classic snake game where bots control the snakes. Can you create a bot that out lives the rest?

Snakes will enter the arena and hope to survive. Eat pellets and grow in length. Can you force your competition to crash and die while you survive?

See video for visuals of my simple bot playing against itself. I am sure you can do better!

# Features

• Real-time graphics provided by Love2D
• Multiple snakes per game
• Solo game as well
• Humans can play too!
• Highly configurable settings
• Supports any programming language that can use sockets.

# Requirements

• Love2D: 2D game engine written for Lua
• Socket-compatible programming language
• Controller: The main controller for this challenege

## Optional

• Lua winapi: Handy way to spawn processes in the background

# Controller Contents

1. main.lua: Main loop for Love.
2. snake.lua: Support library for game mechanics
3. config.lua: Configuration settings.
4. bots\: location of externally-defined bots
1. simple.lua: Example bot written in Lua

# Executing

Run the love2d executable on the controller directory

love.exe <location_of>\battlesnake

or

[Recommended] Use ZeroBrane Studio with the 'Love' interpreter. Change your project directory to where you installed the controller, and then run the script in ZeroBrane. You'll still have to install Love separately.

# Configuration

All configurable options are located in the config.lua file in the controller. The options are detailed in that file itself.

# Rules

General snake rules apply. Hit something and you die. This includes the walls, other snakes, or even yourself.

Collisions happen before the board is updated. Therefore, if you move to a spot where another snake's tail is, it will still cause a collision. Even though it could be moving away that turn. If two or more snakes enter the same spot the same turn, they all collide with each other.

Eat a pellet and gain points. You also grow in size for a number of turns. Your head continues moving but your tail stays stationary until you stop growing.

# Mechanics

The game uses a server-client model, where the main game loop is the server and each snake is a client. The game communicates to each snake over TCP through an assigned port. The default host is the localhost, no external networks are required.

When the game starts, it will start each snake (aka bot) by starting its associated program and sending the IP ADDRESS and PORT and PLAYER ID to it as input arguments:

bots\someBot.exe 127.0.0.1 52311 1

The main server then waits for a socket connection from that bot at the given IP and PORT. If the connection times out, it will error and the game will not start. If the server receives a connection from the bot, it will proceed on to the next bot.

Once all bots are started and connected to the server, the game will be generated. Bots are expected to block until receiving data from the server. Typically this is just an infinite loop with a blocking socket.receive() call at the top of the loop.

## Board

The game board can be of any width and height. The coordinate system starts at x = 1, y = 1 at the top-left. Increasing x values go left-to-right and increasing y values go top-to-bottom. The board has hard walls, hitting them will kill your snake. (Lua is 1-based, that is why it starts at 1)

## Order of Events

1. First the game settings are broadcast to all bots

1. Board Information

bi width,height

Where width and height are integer values

2. Pellet Location

p x,y

Where x and y are integer values >= 1 and <= to their respective width and height.

3. For each bot

• For each body part, starting at the head and going to the tail

si snake_id x,y

Where snake_id is an integer value, and x and y are as described before.

ready

All bots are initialized by now, so the next command will be from the main game loop.

2. Main Loop

1. For each tick (tick is when all snake movements will be applied)

1. Server will broadcast to each bot

mov

The bot needs to respond to this request with a direction to head in

• r Head Right
• l Head Left
• u Head Up
• d Head Down

If the bot doesn't respond within a specified time, it will continue to move in its previous direction. (Previous direction is r on the first turn)

The bot should send a single char back, nothing more will be parsed.

2. Check End Game Conditions

If the game ended this tick each bot will be sent either a quit or nil message from the server. Each bot is expected to clean up after itself when it receives this signal.

3. Updated Pellet Info [optional]

If a pellet was eaten this tick, a new pellet packet will be broadcast to all active bots

p x,y

4. Server broadcasts snake deltas that were applied this turn

s snake_id new_x,new_y,removed_x,removed_y

Where all parameters are integers. new_x and new_y are the new head location of a given snake.

If removed_x and removed_y are >= 1, this is where the tail used to be, so each bot knows the updated board.

If remove_x and removed_y are == -1, then that bot is actively growing in size, so its tail didn't move.

If a snake died this tick, its deltas will not be broadcast. It is up to the bots to remove the body from their game state.

See the example bot for details

# Matches

Games are grouped together in best-of matches. For the purposes of the bots, they do not need to understand the concept of a match. The bot that wins the required number of games in a match is declared the match winner.

# Scoring

1. Scoring

• Match winner: +2500 points per match
• Last Man Standing: +1000 points per game
• Pellets Eaten: +50 points per pellet
• Game Ticks Alive: +1 point per tick

If two or more bots enter the same square on the same tick, they all die. If this square happened to be the pellet, none of those bots will be rewarded the pellet points. However, the pellet will be "consumed" and a new location will be generated for the remaining bots to eat.

If there is a tie at the end of the game among the bots, the game is a wash. A new game will be started.

2. King-of-the-hill Scoring

This challenge will combine two parts: A solo effort and a classic king-of-the-hill part.

Each bot will be given the same random seed at the start of the competition. There will also be imposed a maximum time between eating pellets to prevent bots from going around in circles to farm points.

1. Solo

Each bot will enter into a 10-game match to see how long it lasts and how well it eats by itself. The scores of each game in the match will be summed to compose its final Solo-score.

2. King-of-the-hill

All the bots will enter into a best-of-39 match. If the game ends and there is still a final living bot, the game still end at that point. That bot will be given the last man standing bonus.

The scores of each game will be summed and composed into the snakes final KOTH-score.

3. Final Scoring

All the bots will be ranked in each part separately. Ties in ranks are permitted at this stage. Then their positional rank in each part will be summed together to give their final score. The bot with the lowest combined rank wins!

In case of a tie at this level, the bot with the better KOTH rank will win. If still a tie, the bot with the better Solo rank will win.

## Sandbox Questions

My biggest concerns

1. Requires a few third-party programs to work. So that will limit the number of people who enter.
2. Requires sockets. I couldn't figure out a good way with Lua\Love2d to have bidirectional pipes with STDIN and STDOUT. So I thought sockets would be the best alternative to open the challenge to as many people as possible.
3. Too hard?
4. Haven't optimized scoring yet.

## Count the Cats code-challengeimage-processingtest-batterycounting

This is a cat:

Specifically, that is my cat. She is my only cat. And, in that image, there is only one cat: her.

These are also cats (image credit):

In that picture, there are two cats. It is relatively easy to count them, thanks to their distinct coloring.

This is a picture of 5 cats (image credit):

It's harder to differentiate the cats because of their similar coloring, but there are definitely 5.

This is a landscape (image credit):

There are no cats in this image.

## The Challenge

Given an image, output the number of cats in the image.

## Rules

• Submissions must output and terminate within 1 minute for a single image.
• Any common image format is acceptable for input, as long as no additional data (such as the number of cats present in the image) is encoded in the format.
• Submissions must be fully deterministic, and make a genuine attempt at counting the cats. Outputting a random number or a consistent but unrelated number (such as the value of the last hex digit of the SHA-256 hash of the image data) is not allowed.
• The images in the test cases will contain no animals besides cats. There may or may not be humans in the images - they are not cats, and thus should not be counted as cats.

## Scoring

The score for a single image is the square of the difference between the true number of cats in the image and the output of the submission ((actual - output)**2). The total score is the sum of all of the individual scores. The submission with the lowest score wins.

[scoring images TBD]

• I feel like this is probably a dupe of either the goat question or the rice question. I'm not sure that it being a test battery question or the precise subimage to identify really makes it much different from these other ones? – FryAmTheEggman Jun 23 '16 at 19:17
• @FryAmTheEggman I don't think it's a dupe of goats - goats wanted a boolean classification, where this one asks for a count. The rice question is closer, but there is a possibility (and perhaps a need) for different approaches, given that a) cats can overlap, b) cats come in different colors, and c) cats have much more complex shapes than rice grains (which are ellipses). – Mego Jun 23 '16 at 19:19
• "Submissions must output and terminate within 10 seconds for a single image." I don't know about that, counting the amount of cats and only cats is a rather difficult task already, a 10-second limit seems really small. Perhaps a couple minutes? – Downgoat Jun 23 '16 at 20:03
• Also, I think there should be some specification for how the cats would appear. At least having the full cat's face showing would make this challenge more approachable. If a test-case shows the back of a cat that seems a bit too difficult for a PPCG challenge. Also: Will there be a mix of cats and other animals? Are built-ins allowed (I'm very sure there's mathematica builtin)? – Downgoat Jun 23 '16 at 20:07
• @Upgoat The time requirement can be extended. The number of cats will always be clear to a human viewer with 20/20 eyesight and adequate attention for detail. The challenge is about counting cats, not about picking out camouflaged cats, so there won't be any excessive trickery in the test images. Built-ins are allowed, but I'm on the fence about whether or not I'm going to allow them to be competitive, since Mathematica is likely the only language that would benefit from built-ins. – Mego Jun 23 '16 at 20:12
• Showing a picture of a dog and expecting a zero output doesn't seem fair. Writing a program that distinguishes between dogs and cats seems like a difficult enough task as it is, and you have it here as sort of an afterthought. Empty images should be emptier, imo. – Liam Jun 25 '16 at 22:45
• @Liam On the other hand, if all of the test images consisted of 0-5 cats and no other animals, it would be too easy to get a perfect score. Having harder test cases means that submissions will have room for improvement, and thus there will be more competition. – Mego Jun 27 '16 at 1:46
• Is fitting allowed? I think learning will probably be the most practical approach to this challenge. Though this does need some specification before it's ready to post imo and limits on the possible inputs as I doubt any answer will be able to conform to the wide variety of things cats can be e.g. color, position, shape, size, direction, camera position, etc. – Downgoat Jun 27 '16 at 5:15
• @Downgoat As per usual with these types of challenges, optimizing for the test cases is not allowed. However, given that a ML-oriented approach would be interesting and perform well on this challenge, I'd be willing to include a training set, separate from the scoring set. As for limits on possible inputs, I'm trying to work out a good set. – Mego Jun 27 '16 at 5:41
• I think the part about the dog makes this a chameleon challenge -- distinguishing a cat from a dog is much harder than identifying and counting cats on an image free of distracters. – xnor Jun 27 '16 at 23:48
• @xnor On the other hand, without the distracters, it would likely be too easy to get a perfect score. – Mego Jun 28 '16 at 2:48
• Distinguishing a cat from a dog on a picture already requires decently advanced algorithms (CNNs are the first that come to mind) which in turn require a LOT of training data to generalize decently. – Fatalize Jun 29 '16 at 9:09
• @Fatalize Would using non-mammilian animals (such as lizards and birds) be better in your opinion? – Mego Jun 29 '16 at 9:10
• @Mego It probably would be easier because it wouldn't force people to use machine learning techniques (You could use texture comparison to distinguish feathers from scales, color detection, etc.). Counting the number of each is an added difficulty that makes it maybe too difficult as a whole. Only classifying is easier but probably a dupe of the goats challenge. Only counting might be good though. – Fatalize Jun 29 '16 at 9:14
• The problem with this scoring technique is that even if people make legit attempts at counting the cats, they will try to optimize their code for the limited test set, which will make their approaches less general on new data. One solution could be to provide a validation set (for say 2 weeks if that's the time frame in which you can post an answer) on which people can evaluate their answers, and choose the winning answer based on a test set that was not available during those 2 weeks containing new images. – Fatalize Jul 1 '16 at 13:27

# The Ifelse Tower

You are an inhabitant of the whimsical country of Forance, filled with programmers.

Life in Forance is said to be extremely repetitive, which isn't good to attract tourists. For this, authorities of Forance want to hire someone to print tons of postcards to promote their most iconic landmark: the Ifelse tower.

                   if
if
if
if
if
if
if
else
else
ifelse
else
else
ifelseif
ifelseif
elseifelse
ifelseifelse
elseifelseifelse
ifelseifelse
ifelseifelse
else    else
else      else
else        else
else          else
else            else
ifelseifelseifelseifelseif
ifelseifelseifelseifelseif
ifelseifelseifelseifelseif
ifelseifelseifelseifelseif
elseifelseif    elseifelseif
elseifelse          elseifelse
ifelseif                ifelseif
ifelse                      ifelse
ifelse                        ifelse
ifelse                          ifelse
ifelse                            ifelse


But, of course, they want to do this with the least possible cost. So, if you want this job, you have to show you can do this with very little code

## Challenge

Write a program or function that takes no input, and outputs to STDOUT the Ifelse tower.

## Rules

• Leading and traling new lines are not allowed
• Leading spaces are (of course) a must
• All lines must be at most the same lenght as the base (40 chars). This means you are free to use or not trailing spaces on each line, as long as they don't surpass the base's lenght
• Standard loopholes are not allowed

This is , so shortest answer in bytes gets the job -err wins

• I'd allow a single optional trailing linefeed. A lot of languages print full lines by default. In some it's annoying to suppress that and in some it's impossible. – Martin Ender Jul 20 '16 at 7:30
• Why enforced an output to stdout? – aloisdg Jul 20 '16 at 12:41
• This challenge proposal has been inactive for over a month. I would like to take ownership of the challenge and make it ready for posting. Please let me know within the next 14 days if you have any objections and would still like to finish and post this challenge yourself. – NonlinearFruit Jun 4 '17 at 13:05

# Interpret a Formal Grammar

Given a context-free grammar, and a string, parse the string using the formal grammar and output the matches for the non-terminals.

## Examples

First line is string, following lines are grammar, then is the main grammar to parse, last line is output.

123

n -> any of
0 1 2 3 4 5 6 7 8 9
N -> n N
n

N

N [ n [1], n [2], n [3] ]

2+2*(4/2)

o -> any of
+ - / *
n -> any of
0 1 2 3 4 5 6 7 8 9
E -> o E E'
( E ) E'
n E'
E' -> o E E'
o E'
ε

E

E [ n [2], E' [ o [+], E [ n [2], E' [ε]  ] ] ]

a b

S -> S' S
ε
S' -> a   b

S

S [ S' [a], S' [ ], S' [b] ]


This grammar is the same as regex: [a b]+

## Spec

Details:

• All recursion will be right-recursive
• Rule names will consist of A-Z a-z α β γ Γ and may have a ' at the end.
• Valid Rule names:
• A
• Γ
• AB
• αβ
• foo'
• faαβdg'
• Invalid Rule names:
• 'ab (' will be at the end)
• ab'' (two ''s)
• code golf (spaces not allowed in rule names)
• Nonterminals will be lowercase, terminals upercase
• A derivation format will be:

<rule name> -> <rule>
<rule>
<rule, etc.>


meaning the rules will be lined up (when in a monospace font), by spaces.

• Symbols/rule-names will never be repeated
• ε (epsilon) means empty. i.e. ""

## Rule definition:

• If the initial rule is "any of", the second rule will exist and will be a space separated list of symbols/rule-names (maybe more than one char). There will be no rules after this
• Else, the rule will consist of space-seperated tokens which either refer to a rule or a literal. If it is not a valid rule name, assume it is a literal which should be treated as if it is a terminal.

Summing up, for input you will be given the string to parse, the grammar, and the rule to parse.

### Output:

You may output in whichever format you like as long as it is able to convey the following information. You must somehow label the match to their respective rule names. You may optionally not label terminals.

## Challenge Rules:

• Feel free to assume the input can always be parsed by the given grammar.
• External libraries (ones that have to be imported), are not allowed
• If your language has built-in parsing tools (e.g. regex) those are allowed
• If your language has a built-in to parse a grammar (i.e. some formal grammar parser), these are allowed but your solution is non-competing and you must clearly state this in the header of your answer.

This is so shortest code in bytes wins!

I may award a bounty to any particularly ingenious solutions, so try to add an explanation!

• 1. Why the special-case Greek letters in the valid rule names? That seems to add complication for no benefit. 2. Am I correct in thinking that the only way to match a literal space character is as part of an "any of" rule? Some test cases involving literal spaces would be useful. 3. What does "Symbols will never be repeated" mean? 4. The spec for the rule definition uses the words "symbols" and "tokens". It's not clear to me whether these are synonyms, and if not then what the distinction is. 5. May we assume that there is a valid parse tree for the given input? – Peter Taylor Jun 11 '16 at 11:47
• @PeterTaylor greek letters are often used in grammars. I'll address number 2, and 4. Symbols are a name of a derivation(s). – Downgoat Aug 7 '16 at 22:22
• Trying to outsource compiler design for cheddar? Lol, jk, +1! – Rohan Jhunjhunwala Aug 7 '16 at 23:29
• I must say that I never saw any Greek letters except for episilon in the formal language and parsing courses I took, but that wasn't really my point. My point was the special-casing of three lower-case and one upper-case Greek letters. If rule names could contain any character other than - > then it would be simpler. If they could contain any Unicode alphabetic character then it would be simpler (at least for regex users). Also, 6. "Nonterminals will be lowercase, terminals upercase" Does this mean that mixed case tokens are always literals? – Peter Taylor Aug 8 '16 at 7:30

# Esolang Interpreters

Using a programming language from this version of this list, write an interpreter for the next language on the list. For example, if you choose to start with LOCK, you would write an interpreter for LOLCODE. Continue this pattern (use LOLCODE to write an LCBF iterpreter, etc)
If specs of a language are unclear and the compiler is nonexistant or closed-source, ask me and I'll decide whether or not to take it off the list.

Wining Criteria:
The longest streak of compilers wins.

Proposed Edits:
Make several defined starting points. (this would make many answers too similar, though)

Edits: changed from list of all esolangs to just turing complete ones.

• I like it, but it may be a trivial task depending on what language you choose – Rohan Jhunjhunwala Aug 24 '16 at 21:37
• I think this would be better as a similar challenge to the enterprise quality code, but where the winner is the one who does the most languages at the end at you need to go in order. If you don't think so, I'll make a separate sandbox post. – Rɪᴋᴇʀ Aug 24 '16 at 21:39
• In order to prevent edits, you can simply use the version in the url: esolangs.org/w/index.php?title=Language_list&oldid=49177 – Nathan Merrill Aug 24 '16 at 21:41
• I agree with Easterly, but I'd also make it a cycle based-system. Aka, the interpreter for "!!!Batch" must be written before the interpreter for "???" can be written. You could also have multiple starting points, one for each letter. – Nathan Merrill Aug 24 '16 at 21:45
• Actually, better idea, score them based on the number of consecutive interpreters they write. – Nathan Merrill Aug 24 '16 at 21:48
• How will you deal with cases where one language is a joke language and/or not Turing complete, and therefore cannot interpret the next language? – El'endia Starman Aug 24 '16 at 21:56
• @El'endiaStarman should I use this list instead? – Bald Bantha Aug 25 '16 at 0:09
• @Nathan Merrill I think I will do that, yes. Great suggestions. – Bald Bantha Aug 25 '16 at 0:10
• @BaldBantha: That would be better, but you may still run into problems such as languages being technically Turing complete, but entirely impractical. For instance, try multiplying two numbers in Pancake Stack. – El'endia Starman Aug 25 '16 at 0:12
• @El'endiaStarman Oh, well this challenge isn't supposed to be easy. I assume the first few answers will include 2-3 interpreters (depends on the starting points, TBH), but I think it would stall for a while. TLDR: I don't feel like classifying several hundred langueges as practical or not. – Bald Bantha Aug 25 '16 at 0:16
• The bigger issue I see is that many languages don't have completely solid specs, so it's not clear what counts as a valid interpreter of the language. – Martin Ender Aug 25 '16 at 8:53

# Solve the Nonogram!

It is time to embark on a perilous quest to defeat the British Intelligence. The aim of this challenge is to write the shortest code that will solve a Nonogram.

# What is a Nonogram?

The rules are simple. You have a grid of squares, which must be either filled in black or left blank. Beside each row of the grid are listed the lengths of the runs of black squares on that row. Above each column are listed the lengths of the runs of black squares in that column. Your aim is to find all black squares. In this puzzle type, the numbers are a form of discrete tomography that measures how many unbroken lines of filled-in squares there are in any given row or column. For example, a clue of "4 8 3" would mean there are sets of four, eight, and three filled squares, in that order, with at least one blank square between successive groups. [1][2]

So the solution to the above Nonogram would be:

# Implementation Details

You can chose to represent the Nonogram however you would like and take it as an input in whatever way you deem fit for your language. Same goes for output. The aim of this challenge is to literally just get the job done; if you can solve the monogram with whatever output your program gives, that is valid. One caveat is you can't use an online solver :)

You are, of course, free to use any language you want and since this is code golf, the entries will be sorted in the order: accuracy -> length of code -> speed.

This problem is very algorithmically challenging in that there is no completely efficient solution to it and as such, you won't be penalized for not being able to solve larger ones, although your answer will be heavily rewarded if it is able to handle big cases (see bonus). As a benchmark, my solution works for up to roughly 50x50 within 5-10 mins.

# Bonus

I actually learnt about Nonograms from a cryptographic Christmas card released by the British Intelligence here. The first part was basically a massive 25x25 Nonogram. If your solution is able to solve this, you will get kudos :)

To make your life easier in terms of data entry, I have provided how I represented the data for this specific puzzle for your free use. The first 25 lines are the row clues, followed by a '-' separator line, followed by 25 lines of the col clues, followed by a '#' separator line, and then a representation of the grid with the square clues filled in.

7 3 1 1 7
1 1 2 2 1 1
1 3 1 3 1 1 3 1
1 3 1 1 6 1 3 1
1 3 1 5 2 1 3 1
1 1 2 1 1
7 1 1 1 1 1 7
3 3
1 2 3 1 1 3 1 1 2
1 1 3 2 1 1
4 1 4 2 1 2
1 1 1 1 1 4 1 3
2 1 1 1 2 5
3 2 2 6 3 1
1 9 1 1 2 1
2 1 2 2 3 1
3 1 1 1 1 5 1
1 2 2 5
7 1 2 1 1 1 3
1 1 2 1 2 2 1
1 3 1 4 5 1
1 3 1 3 10 2
1 3 1 1 6 6
1 1 2 1 1 2
7 2 1 2 5
-
7 2 1 1 7
1 1 2 2 1 1
1 3 1 3 1 3 1 3 1
1 3 1 1 5 1 3 1
1 3 1 1 4 1 3 1
1 1 1 2 1 1
7 1 1 1 1 1 7
1 1 3
2 1 2 1 8 2 1
2 2 1 2 1 1 1 2
1 7 3 2 1
1 2 3 1 1 1 1 1
4 1 1 2 6
3 3 1 1 1 3 1
1 2 5 2 2
2 2 1 1 1 1 1 2 1
1 3 3 2 1 8 1
6 2 1
7 1 4 1 1 3
1 1 1 1 4
1 3 1 3 7 1
1 3 1 1 1 2 1 1 4
1 3 1 4 3 3
1 1 2 2 2 6 1
7 1 3 2 1 1
#
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1 0 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 1 0 0 0 1 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 0 0 0 0 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0


# Sesquiprimes

Given a non-negative integer N, output the Nth sesquiprime integer.

We say that a positive integer I is sesquiprime if I + ⌊I/2⌋ is prime (where ⌊...⌋ is the floor function).

For example, 25 is a sesquiprime because 25 + ⌊25/2⌋ = 25 + 12 = 37, which is prime.

Sequence A158708 is the sequence of prime sesquiprimes.

### Inputs and outputs

• N may be 0-indexed or 1-indexed, please indicate which of the two your solution uses.

• Inputs and outputs must be in the decimal base.

• N may be taken through STDIN, as a function argument, or anything similar.

• The output may be printed to STDOUT, returned from a function, or anything similar.

### Test cases

The following test cases are 0-indexed.

N        Output

0        2
1        5
2        9
4        21
8        45
15       93
16       101
23       149
42       305
100      853
1000     11693


### Scoring

This is , so the shortest answer in bytes wins.

• I don't think the link to prime sesquiprimes adds anything other than a possibility for mistakes by people too lazy to read specs fully (like me) – Jonathan Allan Sep 4 '16 at 17:34
• @JonathanAllan True. Would adding it as a comment be better to make it less appear like part of the challenge? – Fatalize Sep 4 '16 at 17:40
• Including the link as a comment and/or prefixed by Related: would probably be clearer. – Dennis Sep 4 '16 at 18:11
• This seems close to finding primes that are 1 mod 3. – xnor Sep 5 '16 at 10:18

# Slay

This KoTH is based off of the computer game, Slay. Try it out, its way fun.

# TLDR

• You start off with a bunch of small territories: you try to merge them and capture as much land as possible.
• Each territory has its own economy: each hex gives you 1 gold per turn.
• Warriors can capture and protect territory, but cost money to maintain.
• If you run out of money, all units on that territory die

# Map

• A hexagonal map is generated using Perlin noise.
• Each hexagon is randomly assigned to a player. Players will start with a similar number of hexagons, as well as a similar number of territories (see below)
• Hexagons that touch the edge of the map (or a hole in the middle), are on the beach
• Each tile has a 1/5 chance of starting with a tree: Palm tree if on the beach, pine tree otherwise
• Hexagons may contain a warrior, house, tower, grave, or palm/pine tree

# Territory

• A block of 2 or more hexagons with the same owner is considered a territory
• All territories contain exactly 1 house.
• If a territory ever doesn't have a house, it gets one in a random location, preferring: empty hexes, trees, graves, towers, and then warriors. (in that order)
• A territory "death" occurs when it is reduced/split into a single hexagon.
• Houses turn into a pine/palm (if on the beach) tree
• Warriors die (turn into graves) at the start of their next turn
• Towers disappear
• If two territories grow so that they touch, they merge and the smaller territory's house disappears.

### Finanaces

• Each territory has its own reserve/income
• Each territory starts with 10 gold in its reserve
• Territories generate 1 income at the end of each turn for each tree-less hexagon
• If you don't have enough money to pay for your units at the end of your turn, then all of your units in that territory will die (turn into graves) at the start of your next turn.
• If a territory splits, then the larger of the two gets all of the reserve.
• If a territory combines, their reserves combine

### Defense

• Certain objects give defense to its hexagon and all adjacent friendly hexagons:
• Houses (1): cannot be built, but every territory has exactly one
• Towers (2): can be built for 15 gold
• Warriors (strength): see below

# Map objects

### Warriors

• A warrior has a strength between 1 to 4 (inclusive)
• A warrior costs 10*strength to build
• A warrior costs 2*3^(strength-1) gold each turn. This means that a 4-str warrior costs you a whopping 54 gold per turn
• A warrior can move a maximum of 4 hexes each turn. Moving through enemy lands is not allowed. Capturing enemy lands ends the warrior's turn.
• If you move/build a warrior onto a friendly warrior, they combine, and their strength is summed.
• Trying to make a warrior of strength > 4 doesn't work
• If the friendly warrior hadn't moved yet, the new unit can still move
• A warrior can capture an adjacent hexagon if its defense rating is lower than its strength

### Trees

• Trees prevent a hexagon from generating income
• Trees grow at the end of each round:
• Palm trees grow onto all unoccupied adjacent beach tiles
• Any unoccupied tile that is adjacent to two pine trees grows another pine
• Trees can be removed by moving a unit onto them
• Graves turn into a pine/palm (if on beach) tree at the end of the round

# Game flow

• Between 2 to 6 players can play on a single map. (The size of the map depends on the number of players. You can expect about 50 hexagons per player)
• Turn order is randomized, but is consistent within a single game
• Once a player owns all hexagons, they win!
• @zyabin101 still not ready yet. – Nathan Merrill Aug 31 '16 at 21:35
• @zyabin101 + others finished my post! It took me a bit to ensure I got all corner cases correct. – Nathan Merrill Sep 6 '16 at 15:41

# Flexagonal datastructures

Being programmers, watching us flex aren't very interesting. Today we change that! In this challenge you will lex and flex hexaflexagons.

For a video introduction, watch viharts video(s) on flexagons

A flexagon is a shape that you can flex to reveal faces other than the top and bottom one; we are making a hexahexaflexagon, which has 6 faces. See the image below on how to fold a hexahexaflexagon out of a strip of paper.

A shows both sides of the strip. The two white triangles are glued together. This is how you would flex it:

Below is a diagram of possible states and their relationships:

The colored circles represent the 6 triangles with the same number from the first image. Each of the circes have two colors- the bottom most represent the back face (what you would see if you where to flip your flexagon around), which you don't have to consider in this challenge.

The gray circles represent how you can flex your flexagon in any given state: there are 4 different ways to flex it, we call these Left, Right, Up and Down. You don't actually flex in these directions, the important bit is that some are opposite to each other.
If you are in the center you can use Left and Right to go to the other center ones. To get out of the center you use Up and Down. If you aren't in the center you cannot use Left or Right.

Left/Down = clockwise
Right/Up  = anti-clockwise


# Challenge

Create a function or program that take as input what should be on the 18 front faces and the 18 back faces of a flexagon, a sequence of left, right, up and down flexes, and return the 8 visible faces after the flexes.

Example computation:

flex "hexaflexaperplexia"
"flexagationdevices"
[Right, Right, Left]

Divide a strip of paper into 19 triangles:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3   Front
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6   Back

Write "hexaflexaperplexia" to the front of the paper strip:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3

hexaflexaperplexia
123123123123123123
h  a  e  p  p  x     Face 1, Initially the front face
e  f  x  e  l  i    Face 2, Initially the back face
x  l  a  r  e  a   Face 3, Initially hidden

Write "flexagationdevices" to the back of the paperstrip:
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6

flexagationdevices
445566445566445566
fl    at    ev       Face 4, up from 3
ex    io    ic     Face 5, up from 2
ag    nd    es   Face 6, up from 1

Flex it [Right, Right, Left]
The initial visible face is 1: "haeppx"
flexing Right ..
The current visible face is 2: "efxeli"
flexing Right ..
The current visible face is 3: "xlarea"
flexing Left ..
The current visible face is 2: "efxeli"
flexed [Right, Right, Left]!

outputting "efxeli"


Example input and expected output:

> hexaflexaperplexia flexagationdevices RRL
= efxeli

> loremipsumdolorsit hexaflexamexicania LUU
= riuort

> abcdefghijklmnopqr stuvwxyz1234567890 UL
= I can't flex that way :(

> abcdefghijklmnopqr stuvwxyz1234567890 RRRRLLUDDUUUULDD
= uv1278


# Rules

• You may take input and return output in any reasonable way
• If the input is impossible, you should indicate so in some way that is distinct from regular output
• Standard loopholes apply
• This is Codegolf. Shortest code in bytes win.
• The diagram is at best confusing. The overlapping arrows are hard to read, and the fact that they're directional is just plain wrong. Then the example computation is very cryptic. To be useful the examples need to explain what each line of text means, and they should avoid duplicating letters. It would be good to make the first example show the output with zero flexes. I made my first hexaflexagon at least 25 years ago, and I carried one in my wallet for years to play with when bored, so if I find this spec lacking imagine how it must look to people who don't know anything about them! – Peter Taylor Sep 9 '16 at 22:11
• @PeterTaylor Is this remotely better? – BlackCap Sep 9 '16 at 23:09

# Draw me a Brick Wall!

I'm drawing up a plan for my house extension - and I need a simple graphic for walls...

# The Challenge

Your task is to create a program, which takes an input of the wall's dimensions and draws a brick wall, in the style of the one below.

[__][__][__][__]
_][__][__][__][_
[__][__][__][__]
_][__][__][__][_
[__][__][__][__]
_][__][__][__][_


Please notice that the rows alternate between beginning on a full brick ([__]) and a half brick (_]), to create a more realistic, stable wall.

The input will be two integers, separated by a single comma, such as 4,3 or 2,6. You can assume both integers are positive and larger than 0.

The first integer specifies the width (in bricks) and the second specifies the height (in rows of bricks).

# Rules / Notes

• This is , so the shortest code (in bytes) wins. However, don't feel like you have to beat everyone else to post your solution - I'd love to see your code!
• Standard loopholes apply, no reading from external files.
• You may optionally take the input with brackets/braces, for example (4,3) or [4,3] as long as you specify this in your answer.
• You should take the input from STDIN and output on STDOUT - if your language does not have these, please use the nearest equivalent.

## Test Cases

Input: 1,1

[__]


Input: 2,4

[__][__]
_][__][_
[__][__]
_][__][_


Input: 5,10

[__][__][__][__][__]
_][__][__][__][__][_
[__][__][__][__][__]
_][__][__][__][__][_
[__][__][__][__][__]
_][__][__][__][__][_
[__][__][__][__][__]
_][__][__][__][__][_
[__][__][__][__][__]
_][__][__][__][__][_


# Example: Python 3, 65 bytes

This is somewhat golfed but still readable.

w,h=eval(input())
for i in range(h):print(('[__]','_][_')[i%2]*w)

• very closely related or dupe – Emigna Oct 28 '16 at 13:11
• this one is related too I think – Dada Oct 28 '16 at 13:12
• Hi, welcome to PPCG! This seems like a great first challenge. There are a few related challenges regarding brick walls, like this one (inputs as different sized bricks) or this one (is it stable). But, I think this challenge is different enough. Instead of having different sized bricks as input, this simply asks for two inputs for an NxM wall, which is imho different enough from the first challenge. – Kevin Cruijssen Oct 28 '16 at 13:12
• @Emigna I'd like to think they're different, as this one is a 'more static' string to print and doesn't require an algorithm to work out a stable wall first - however I understand that they are closely related. – FlipTack Oct 28 '16 at 13:13
• @Dada Hmm, that one might be more related than the two related ones linked by me, and more towards a dupe (despite the different ASCII used for the bricks themselves). But we'll perhaps wait on some more feedback from other users. – Kevin Cruijssen Oct 28 '16 at 13:14
• The one Dada linked is similar, but not quite a dupe. The brick structure is quite a bit more flexible in Luis' challenge, given that the input is total character width and height plus a horizontal offset, whereas here it's in number of bricks. – AdmBorkBork Oct 28 '16 at 13:21
• I'd still call the previous brick printing one a dupe. The offsetting pattern is the same, and in most of the answers it would be easy to replace constants with inputs. – xnor Oct 29 '16 at 6:11

# The smallest circles

Challenge

This is a variant of the smallest-circle problem, but instead of one circle, you get three. Given a list of coordinates, output three circles such that the following conditions are met:

1. Each input coordinate must be located inside or on the perimeter of a circle.
2. The sum of the radii of all three circles must be minimal.
3. The coordinates and radii of all three circles must be non-negative integers.

You must place all three circles. You may place overlapping circles. A circle with a radius of zero that is directly on top of an input coordinate is considered to be covering that input coordinate.

Input

A list containing between 1 and 1000 pairs of integers, inclusive. Each pair of integers represents an xy-coordinate. Use whatever input format you want to use.

For example, the input...

1,1;1,2;2,2;3,3

... can be drawn like this:

Output

A list of three integer triples. Each triple contains an x coordinate, followed by a y coordinate, followed by a radius. The triples, and the integers within each triple, must be distinguishable from one another. Otherwise, the output format is not important.

Example:

1,1,1;2,2,1;3,3,2

Given this example output, circles would be drawn at (1,1), (2,2), and (3,3). The first two circles would have a radius of 1, and the third would have a radius of 2. The sum of the radii would be 4.

Test case explained

Given the input...

1,1;1,2;2,2;3,3

... you could output...

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

... or you could output...

1/2/1
3/3/0
0/0/0

The radii sums to 1, and since it is not possible to draw three circles whose radii sum to less than 1 that encompass or touch all four points, this is the correct answer.

(maybe too)

• The text says that the list is colon-delimited, but the example is semicolon-delimited. It would help readability to mention that you can place three circles at some point before "The sum of the radii of all three circles is minimal". It's not clear whether the coordinates and radii of the circles must be integers, nor whether the radii must be non-zero. Finally, some test cases would be nice. – Peter Taylor Nov 7 '14 at 18:50
• If I didn't fully address any of the comments above please let me know. – Rainbolt Nov 7 '14 at 19:41
• If the input can contain up to 1000 points it might help to have a large test case too. – trichoplax Jan 20 '16 at 22:30
• For large numbers of input points, how will you assess whether the output is of minimal total radius? Is a proof required or is it sufficient that no other answer/person can find a counterexample? You could also have a judge program / reference implementation to define the correct total radius. – trichoplax Jan 20 '16 at 22:31
• @trichoplax Hopefully I'll have a reference implementation before I post. If I decide that I am too lazy for that, then I will assume answers are correct until someone finds a counterexample. I will come up with a larger test case. – Rainbolt Jan 20 '16 at 22:37
• Does the rigid I/O format really add anything interesting to the challenge? meta.codegolf.stackexchange.com/a/8077/8478 – Martin Ender Jan 21 '16 at 10:55
• @MartinBüttner I completely relaxed the input format, and I somewhat relaxed the output format. Thanks for the feedback. – Rainbolt Jan 21 '16 at 14:12
• @Rainbolt If I read the output section right, you're allowing any distinguishable delimiters for the output now? Then it might be clearer if one of the two example formats didn't use commas as the inner delimiter (maybe use spaces for the second example or so). – Martin Ender Jan 21 '16 at 14:15
• The rewrite states two conditions which must be met, but there's a third one hidden down in the output section: that the coordinates and radii must be integers. That should be up in the first section. – Peter Taylor Jan 19 '17 at 21:13

# Make A Rotating Emoji Globe

Your task is to make a globe out of the following characters, with the line being cleared ever 1/3 of a second:

🌍🌎🌏


You must clear the line your emoji globe on it and print the next one every approximate 1/3 of a second.
Output may be to the terminal or elsewhere.
The program must also continue until interrupted on purpose.
Also, your code may not contain the emoji globes themselves, but it may contain Unicode escapes.

This is , so standard loopholes & rules apply.
May the best coder win...

• Simple, fairly identical to this in that you simply display a cycle of things, Most answers from that will fairly easily work copied over. – ATaco Feb 7 '17 at 2:47
• @ATaco How could I make it more challenging? – ckjbgames Feb 7 '17 at 2:50
• @ATaco I think it's sufficiently distinct--it requires clearing the line (an option in the other challenge), display unicode characters, and only displaying one character at a time. – Conor O'Brien Feb 7 '17 at 3:24
• @ConorO'Brien I still feel I could distinguish my challenge a bit more, though... – ckjbgames Feb 7 '17 at 17:48
• Define clear the line? Does it have to clear the line, or does the whole terminal suffice? – Rɪᴋᴇʀ Feb 7 '17 at 18:13
• @EasterlyIrk Clearing the screen can be done in any way, as long as the globe appears to rotate onscreen. – ckjbgames Feb 7 '17 at 21:40
• It's even more similar to codegolf.stackexchange.com/questions/101289/loading-forever. Printing a single character that cycles – 12Me21 Feb 7 '17 at 22:26
• @12Me21 How can I make it different, then? – ckjbgames Feb 7 '17 at 22:35
• Maybe you could require them to draw an actual rotating globe, given a map image. (It's a lot more complicated though) – 12Me21 Feb 7 '17 at 22:37
• @12Me21 I just had the idea to add a moon rotating around the earth. Help me think of how to implement it. – ckjbgames Feb 7 '17 at 22:59
• You could make it use the different moon phase emoji to display the proper phases or something – 12Me21 Feb 7 '17 at 23:05
• @12Me21, an actual rotating globe is potentially a dupe of codegolf.stackexchange.com/q/24326/194 - certainly some of the answers could be copied across. – Peter Taylor Feb 9 '17 at 9:02
• Take as input the "spin speed" (ms delay), althought that's fairly trivial to handle. – Carcigenicate Feb 10 '17 at 22:13
• @Carcigenicate I will do that. – ckjbgames Feb 12 '17 at 21:54

# Tron Game

Write a Tron bot!

The aim of the game is to make as many moves on a grid as possible without moving onto a space that has already been occupied in the current game. If your bot is unable to make such a move, it loses the round. The board does not wrap so bots can not go off the side of the arena.

## Game IO:

Your bot will be written in python and will create a class that inherits from BotSkeleton. An example test bot is shown below.

from bot_skeleton import BotSkeleton
from typing_hints import PositionDict, Position
from board import Board
from typing import List

import random

class Test(BotSkeleton):
def make_move(self, board: Board, positions: PositionDict) -> Position:
self.board = board
self.position = positions[self.bot_id]
valid_moves = self.get_valid_moves()
try:
return random.choice(valid_moves)
except IndexError:
return None

def get_valid_moves(self) -> List[Position]:
moves = filter(self.board.position_valid, ((self.position[0]+1, self.position[1]),
(self.position[0]-1, self.position[1]),
(self.position[0], self.position[1]+1),
(self.position[0], self.position[1]-1)))
return list(moves)


(Type hints are not required but illustrated here to help understanding)

• position is a 2-long tuple containing 2 integers.
• positions is a Dict[bot_id, position]
• board can be indexed with a position.
• get_random_empty_pos() -> position - returns a empty position at random in the board
• position_valid(position) -> bool - returns if this move is valid (but not next to the position given)
• copy() -> List[List[int] - returns a 2d list that can be modifiable of the current board state
• EMPTY - the id for an empty space
• The value you return must be a position, and must also have a distance of 1 from this, not including diagonals.

Built in attributes for BotSkeleton:

• log - contains a file object that you may write to
• no_bots - the number of bots the game began with
• bot_id - you're bot's id number.

Methods in Board:

• get_random_empty_pos() -> Position - Returns a position at random that is empty
• position_valid(pos: Position) -> bool - returns if a position is inside the board and is currently empty
• copy() -> Board - return a copy of the board that is writable

## Tournament structure

• Every bot will get pitted against every other bot in a giant arena
• That is to say every single bot will be in every battle
• The size of the arena will be (30, 30). This may be increased depending on number of bots entered.

### General rules that I can't find better places for

• Your bot may NOT use any file storage except for write-only access to the log file provided
• Your bot must be written in Python 3. Sorry java people
• You may enter as many bots as you want
• Your bot must not attempt to subvert the game state

### I reserve the right to disqualify any bot from the competition

(but shall only do so after telling you I will do so and you not making any changes required)

• Results here

## Sandbox notes:

• Should there be a minimum starting distance between players?
• What happens if two bots go on the same position at the same time? – Katenkyo Mar 23 '16 at 11:10
• Is the goal really to survive as many moves as possible, and not to survive longer than the other guy? – feersum Dec 7 '16 at 14:03
• probably change "sorry" to "sorry not sorry" – Destructible Lemon Feb 11 '17 at 12:20

# Part II: Triangular Chebyshev Distance

The Chebyshev distance on a regular grid is the number of orthogonal or diagonal steps one needs to take to reach one cell from another. That is, we can move either through the edge of a cell, or through a corner, to a neighbouring cell.

We can define a similar distance on other grids, for example the triangular grid. We can address the individual cells in the grid with the following indexing scheme, where each cell contains an x,y pair:

    ____________________________________...
/\      /\      /\      /\      /\
/  \ 1,0/  \ 3,0/  \ 5,0/  \ 7,0/  \
/ 0,0\  / 2,0\  / 4,0\  / 6,0\  / 8,0\
/______\/______\/______\/______\/______\...
\      /\      /\      /\      /\      /
\ 0,1/  \ 2,1/  \ 4,1/  \ 6,1/  \ 8,1/
\  / 1,1\  / 3,1\  / 5,1\  / 7,1\  /
\/______\/______\/______\/______\/___...
/\      /\      /\      /\      /\
/  \ 1,2/  \ 3,2/  \ 5,2/  \ 7,2/  \
/ 0,2\  / 2,2\  / 4,2\  / 6,2\  / 8,2\
/______\/______\/______\/______\/______\...
\      /\      /\      /\      /\      /
\ 0,3/  \ 2,3/  \ 4,3/  \ 6,3/  \ 8,3/
\  / 1,3\  / 3,3\  / 5,3\  / 7,3\  /
\/______\/______\/______\/______\/___...
/\      /\      /\      /\      /\
.  .    .  .    .  .    .  .    .  .
.    .  .    .  .    .  .    .  .    .


Now the Chebyshev distance on this grid is again the minimal number of steps across edges or corners to get from one cell to another. So you can move from 3,1 to any of its 12 neighbours:

2,1 4,1 3,2 (through edges)

3,0 1,2 5,2 (the opposite triangle through corners)

2,0 4,0 1,1
5,1 2,2 4,2 (the other triangles through corners)

For instance, the distance from 2,1 to 7,2 is 3. The shortest path is generally not unique, but one way to make the distance in 3 steps is:

2,1 --> 4,1 --> 5,1 --> 7,2


## The Challenge

Given two coordinate pairs x1,y1 and x2,y2 from the above addressing scheme, return the Chebyshev distance between them.

You may assume that all four inputs are non-negative integers, each less than 128. You may take them in any order and arbitrarily grouped (four separate arguments, a list of four integers, two pairs of integers, a 2x2 matrix, ...).

You may write a program or a function and use any of the standard methods of receiving input and providing output.

You may use any programming language, but note that these loopholes are forbidden by default.

This is , so the shortest valid answer – measured in bytes – wins.

## Test Cases

Each test case is given as x1,y1 x2,y2 => result.

1,2 1,2 => 0
0,1 1,1 => 1
1,0 1,1 => 1
2,1 7,2 => 3


Will add more test cases when I have a reference implementation.

• @trichoplax Yes, thank you. With the slow response to the Manhattan variant, I do wonder whether this one will be a bit too tricky, but we'll see. :) – Martin Ender Apr 4 '17 at 21:28
• "I do wonder whether this one will be a bit too tricky, but we'll see. :)" I've found a solution for this one, but not for the other one yet. ;) – Kevin Cruijssen Apr 5 '17 at 12:01
• @KevinCruijssen Oh, would you mind sharing it? :) – Martin Ender Apr 5 '17 at 12:06
• I always make my answers in Java 7 btw, so I'll still be beaten by golfing answers. But this is what I came up with (I've also added an explanation of how I came up with the solution in the TIO footer): Try it here. – Kevin Cruijssen Apr 5 '17 at 12:23
• Hmm, I just took another look at your part 1 challenge and realized my solution above for part 2 is incorrect.. :( Based on your current test cases I falsely assumed x1,y1 is always smaller than x2,y2. So my code fails for a test case like 4,1 1,3. Back to the drawing board.. Also, as to why I think this challenge is easier than part 1: In part 1 you had to determine whether the triangle was facing upwards (available: left; right; below) or facing downwards (available: left; right; above). With this challenge all 12 surrounding triangles - regardless of orientation - are accessible. – Kevin Cruijssen Apr 7 '17 at 8:22
• @KevinCruijssen but the exact coordinates/orientations of those 12 neighbours also change, right? – Martin Ender Apr 7 '17 at 8:24
• Yeah, was about to edit my comment again when I realized that.. If you have more test cases I'll take another look at this part 2. I'll start with part 1 for now. (PS: Have a nice weekend - apparently I can use it.. >.>) – Kevin Cruijssen Apr 7 '17 at 8:25
• Me again, more than one year later. I've currently set a bounty for your Part 1 challenge to give it more attention, which you may or may not have noticed based on the new answers given. If you have time, could you add more test cases for this one? – Kevin Cruijssen Jun 29 '18 at 8:40
• @KevinCruijssen I'm not sure how soon I'll get around to that, because I'd want to write a reference implementation for that. If you want it post it soon, feel free to add them yourself (and optionally post the challenge yourself if you like). – Martin Ender Jun 29 '18 at 16:26
• Oh no, I'll patiently wait. I'm going on vacation soon anyway, so I won't have time to answer during that time. I just made that comment above as a reminder so it can hopefully be posted in the not to distant future. :) – Kevin Cruijssen Jun 29 '18 at 16:42

# Mark Duplicates

Given a list of non-negative integers, find the values which are duplicates and mark their positions.

For example, given [1, 2, 3, 2, 1], the output could be [1, 1, 0, 1, 1] where each 1 signifies that the value at that position is duplicated elsewhere in the array and each 0 signifies that the value at that position is unique.

Your output may use either 0 and 1, boolean values for false and true, or any other two distinct values as long as you remain consistent.

This is so minimize the length of your code.

## Test Cases

[] -> []
[5] -> [0]
[0, 1] -> [0, 0]
[2, 2] -> [1, 1]
[1, 2, 3, 2, 1] -> [1, 1, 0, 1, 1]
[6, 3, 6, 3, 5, 2, 3] -> [1, 1, 1, 1, 0, 0, 1]

• Ironically, I feel this is a duplicate of (or at least closely related to) and existing challenge but I can't find it at the moment. – Shaggy May 24 '17 at 10:43
• Would we have to use 0 & 1 or could we use any 2 distinct & consistent values? – Shaggy May 24 '17 at 11:06
• I.e Nub Sieve? – Adám May 24 '17 at 11:27
• @Adám I previously made a challenge for nub sieve. This is slightly different since we aren't choosing positions to filter for only the unique values. – miles May 24 '17 at 18:43
• @Shaggy Yes, any choice of output values is fine as long as its two distinct values that you use consistently. – miles May 24 '17 at 18:45
• Isn't this just NOT nub sieve? – Adám May 24 '17 at 18:47
• @Adám For the [1, 2, 3, 2, 1], nub sieve could be [1, 1, 1, 0, 0], [0, 1, 1, 0, 1], [0, 0, 1, 1, 1], [1, 0, 1, 1, 0], and the not of each is [0, 0, 0, 1, 1], [1, 0, 0, 1, 0], [1, 1, 0 ,0, 0], [0, 1, 0, 0, 1]. – miles May 24 '17 at 19:21
• I think this would be interesting if the first time an entry appears it's not counted as a duplicate. – xnor May 24 '17 at 19:37
• @xnor Wouldn't that be not( nub-sieve( x ) )? – miles May 24 '17 at 20:23
• How does nub-sieve work? My suggestion is because it means the position of the item matters rather than just its value, so it's not just mapping each entry x to l.count(x)>1. – xnor May 24 '17 at 20:26
• The first occurrence of a value is marked true and all subsequent occurrences of the same value are marked false. Nub-sieve. My previous challenge for distinct sieves is a relaxed variant to nub-sieve. For [1, 2, 3, 2, 1], a proper nub-sieve would be [1, 1, 1, 0, 0], and not of that would be [0, 0, 0, 1, 1]. I do agree with that last sentence about how most solutions in golfing languages would probably just count occurrences. – miles May 24 '17 at 20:44
• @miles can I adopt and post this abandoned proposal? – programmer5000 Jun 9 '17 at 1:34