Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

Epic Customizable Tank Battle (Work-In-Progress)

This is an idea I have been working on in conjuction with users @Trimsty and @githubphagocyte in the chat room. It is inspired by the flash game "Bubble Tanks" by Armor Games.

This will be a king-of-the-hill challenge.

Main Idea

The main idea is that a large number of competitors fight each other in a large arena. Each program is the AI of a different tank. These tanks are customizable from a list of available parts which can be purchased, so the competitors can choose how to upgrade their tank as the battle progresses and they earn points.

The Arena:

The arena may be an almost-infinite plane with a light source near the center. Tanks can travel far away, but lose energy away from the light. This is a continuous-space game, so the tanks have locations/directions determined by floating-point numbers.

The Bots:

The tanks are basically circles, with the center point of the tank being the location. There is no collision detection, except that projectiles inside of another tank's radius are considered hits. The tank's size (radius) will be determined by the different upgrades it has, with larger weapons giving more size.

Bots will also have a health level which reduces upon injury from opponent's weapons. The health will start at some number, and the bot dies upon the health reaching zero. As bots kill others and collect points, health can be restored over time.

If a tank goes too long without making progress (collecting points or killing), then it will begin to rust. Rust will slowly damage the tank and kill it. Rust can be eliminated by making progress.

Weapons also need time to recharge, and this time is dependent upon rust and other factors.

The tanks are solar-powered. The farther the tank goes from the light source, the slower it can move, the longer it takes for the weapons to recharge, and the shorter its range-of-visions is.

Bot vision:

A tank's vision range will be determined by the light level. If an object is located in a high-light area, then it can be seen from farther away. An object in a low-light area can only be seen by nearby observers. A tank will be able to see things which are closer than the light level in that object's location. The bot will be able to see other tanks, as well as other features (bullets in-flight, heat-seekers, maybe mines). The information available about other tanks will be that tank's weapons (maybe).

Winning criterion:

Each match will be one single battle-to-the-death involving all of the tanks. The tanks' scores will be the time until death.

It might be that several matches are held with the winner being the contestant with the highest average (or median?) score.

Upgrade system:

Each tank starts with a certain number of skill points (4000) and a certain kill value (10). The tank can spend skill points on upgrades to the various weapons. Once a bot spends points on an upgrade, the transaction cannot be reversed.

When a tank kills another, the victor's own kill value is increase. The killed bot drops skill points on the area which can be collected by nearby bots. The kill value of a bot determines (in part) how many skill points will be dropped upon that bot's death.

Types of weapons:

• Guns of various ranges, strengths, and reload rates
• Lasers
• Mines (proximity and timed)
• Area-effect (damages nearby bots)
• Heat-seekers (costly and very accurate, but short range and low damage)
• Shields (not a weapon, but a form of protection that comes in different strengths)

Additional Notes:

There may be different feature which can be added, such as: - flashlights which enable bots to see farther in the dark zones. - self-destruct, which scatters the dropped points across a broader area. - leech-weapons which steal health - speed boosts or reductions

Misc.

Some sample code provided by trimsty about skill points and kill values:

class BotsThingy:
    def __init__(self):
        self.bots = []
    def fatalShot(self, firer, victim):
        d = (self.bots[firer].points - self.bots[victim].points) / 15
        if d < 0:
            self.bots[firer].killValue -= d
        else:
            self.dropPointsAt(d + 50 + self.bots[victim].killValue * 5, self.bots[victim].location)

# bot.killValue starts out at 10.
# bot.points can be anything that's above 100-ish, I'd say 4000 is good.

Answer 2

Transport Tycoon [control program WIP] king-of-the-hill game

The specification is now complete; the control program will now be written

Chatroom for this challenge

Your task is to create an AI which builds a profitable transport network to carry passengers. In each game, the first entry to have $262,144 or more in cash wins!

Every entry must have a name and version numbering for each time it is altered. You may submit up to 8 entries, but they must not collaborate.

Control

Each round has four players. Each player has a number from 1 to 4.

A simple map will be randomly generated by the control program for each game. This map will be stored in a file map.txt two directories above your program (i.e. ../../map.txt), and updated each game tick. Each player's bank balance (as a number without the $ symbol) will be in ../../account_<PLAYERNUMBER>.txt. Vehicle data will be in ../../vehicles_<PLAYERNUMBER>.txt. You may view other player's vehicle and account files.

Your program will be invoked once, at the start of the game. When your program has finished initializing, it must output READY. If it takes more than 60 seconds to initialize, it will be terminated and disqualified from that game. It may keep files between rounds (for example, to predict an opponent's strategy after watching them for a few games). Other players may not view these files. The tournament will be re-run and the leaderboard updated every 2 days. Your program may not keep files between tournaments.

The control program will put the text WAITING-player_number (e.g. WAITING-4) and a newline to your program's standard input when each game tick begins. You will submit actions on standard output, separated by new lines, terminated by END. Actions that are invalid for whatever reason will be completely ignored. If your program takes longer than 1 second to output END, it will receive TIMEOUT on standard input and no action will be executed for this turn.

If no winner has been found after 30 minutes, the player with the most money wins.

Map format

The map will be a two-dimensional ASCII grid where the top is north, the bottom is south, the left is west and the right is east. Example:

#/////////
######@@@*
/**@@#####
//@@1#@@@*
/@@##@**/#
~~~+~~~~~|
///#######

# represents a road. / represents empty land. * is for difficult terrain (e.g. hills, swamps, whatever) - more on that later. @ represents a house. ~ is a body of water. + is a completed bridge over water. | is a partially constructed bridge. The numbers 1 to 4 represent stations belonging to players (e.g.: if you are player 4, your stations will be marked as 4). 5 to 8 represent 'inactive' stations belonging to players 1 to 4 respectively.

The line endings in the file will be Windows-style CRLF.

The top left corner is (0,0). X is horizontal and Y is vertical.

Construction

Each tick, a player can perform up to 4 construction actions. These are:

• replace a / with a # (build a road)
• replace a * with a / (prepare terrain)
• replace a # with an inactive station (build a station)
• replace a ~ with a | (start a bridge)
• replace a | with a + (finish a bridge)
• replace one of your stations with a # (demolish a station)

You may not perform more than one action on a tile in one turn (you cannot go from ~ to | and to + in a single turn).

You cannot demolish roads, bridges, water, houses or other players' stations.

Each action costs $512, and is sent to the control program on standard output in the following format (B is for Build):

B-X-Y-tile

For example, this will build a road at (8,4):

B-8-4-#

Invalid commands will be ignored.

Vehicles

Each player can own an unlimited number of vehicles. The basic bus has the following properties:

• carries 32 passengers
• travels 8 tiles per turn
• consumes $8 per tile in running costs

Each vehicle can have up to 4 upgrades out of the following (but no more than 2 of each type):

• +16 capacity (denoted by C)
• +4 tiles/tick speed (S)
• -$2 running costs (R)

At most one vehicle can be bought by each player per turn. The basic bus costs $4096 and each upgrade costs $1024; the maximum possible cost is therefore $8192 (all 4 upgrades). A bus can be sold at any time for half of its purchase price (including upgrades; a bus with 4 upgrades can be bought for $8192 and sold for $4096). At most one vehicle can be sold each turn.

The command for purchasing a vehicle is (P is for Purchase):

P-id-X-Y-upgrades

For example, this will buy a bus with no upgrades, assign it the ID 5, and place it at (7,7):

P-5-7-7-

The command for selling a vehicle is simply (V is for Vend)

V-id

Vehicles are stored in vehicles_N.txt in the following format, separated by newlines:

id-X-Y-passengers-upgrades-laststationX-laststationY

For example, this bus has ID 4, is at (5,5), contains 15 passengers, has two speed upgrades and one running cost upgrade, and last stopped at (3,4). If the bus has never run A before, use the coordinates where it was created for the "last station" coordinates. Update the coordinates every time A is run for that bus.

4-5-5-15-SSR-3-4

Vehicles can travel on roads (#), bridges (+) and station tiles (12345678). In the above example, it is possible to drive from the top left corner to the bottom right corner. However, the two road sections in the map below aren't connected, because they are only diagonally touching. Building a road on one of the * would solve this.

/////
##*//
/*###
/////

Vehicles can only stop to pick up and drop off passengers at stations belonging to their owner - player 3's bus can only stop at a 3 or a 7, but not at any of 124568#+.

Your AI has complete control over the movement of its buses. It will submit directions as commands. For example, the following command set will move bus 8 in a circle, then two spaces south, then make it offload 8 passengers, then make it wait for passengers (N, E, S and W are north, east, south and west; R is for Remove; A is for Acquire):

N-8
E-8
S-8
W-8
S-8
S-8
R-8
A-8

NB: Waiting at a station with A counts towards the limit of tiles that the bus can travel each turn, although it is not moving. While waiting, double running costs are charged. A bus may wait for multiple turns. If a bus moves fewer tiles than it is able to (e.g. can move 8 tiles per turn but chooses to move 5 times), halved running costs are charged for the unused turns.

Passengers

Each time an R command is submitted for a bus that is at a station, the bus loses 8 of its passengers. The diagonal distance (using Pythagoras' theorem) between its current station and the previous one is calculated and rounded down (floored). Each passenger offloaded gives this amount of profits (e.g. if the previous station is 1.4 tiles away, each passenger gives $1; if it is 5.9 tiles away, each passenger gives $5).

Each time an A command is submitted for a bus that is at a station, the bus gains passengers. Each house in range of your station provides 1/number_of_active_stations_in_range_of_house passengers.

If there are three stops, A, B and C, and the bus has a route from A to B and then to C, but only picks up passengers at A, then passengers offloaded at B will pay the price for A to B, and passengers offloaded at C will pay for A to C. However, if any passengers are loaded at B, then all of the passengers offloaded at C, even if some of them boarded at A, will pay the fare for B to C.

In the map below, the tiles marked with @ and # are in range (4 tiles or less away), but not the tiles marked with /; the bus at 1 will gain 32 passengers because there are 32 houses in range and no other stations.

////@////
///@@@///
//@@@@@//
/@@@@@@@/
####1####
/@@@@@@@/
//@@@@@//
///@@@///
////@////

Other

You will be charged $64 per turn for each station, active or not, that you own.

Each turn, active stations have a 1 in 8 chance of becoming inactive. This is reverted when a bus runs A at the station.

You will start with $32768.

You may not have a negative quantity of money.

When someone wins, all competing programs will receive GAMEEND on standard input. They may no longer submit commands after this happens, but they may read and write from files (to prepare for a subsequent game, for example). After 60 seconds, all competing programs will be killed.

The map will be 256*256 tiles.

Todo

• Write control program
• Write map generator
• Plan tournament format

Answer 3

Overhanded (Underhanded) Poker

king-of-the-hilloverhandedcard-games

Also if you make overhanded a thing I'll whack everyone involved with a large trout ~ Doorknob

You and your poker buddy are bored, and seeking to liven up the usual poker game. Playing one hand just isn't challenging any more, and you're looking to add a bit of depth. So, why not play with two?

Overview

This is a round robin tournament of two-player poker. For each round, a player will need to make two hands of five cards each. To do this, each player will be dealt seven cards, with three community cards to fill out the hands. After receiving their seven cards, players will be allowed to exchange any number of them for new cards from the deck one time.

Once each player has exchanged cards, they will split the ten cards (7 in hand, 3 community) into two hands, Over and Under. The object for the Over hand is the highest ranked hand, while the object for Under is lowest.

Scoring

In each round, a player will receive one point if:

• Their Over hand is higher than the opponent's Over hand and
• Their Under hand is lower than their opponent's Under hand

If one hand wins (Over beats Over or Under loses to Under) and the other ties, you get half a point.

If one player wins one and the other wins the other or both hands tie, no points are awarded.

Rules

• Standard poker hand rankings apply (link chart or something here)
• Play fair! (will expand on this with the usual KotH stuff)

Controller

WIP

Meta

Obviously this needs some more work. Initial thoughts, questions?

Answer 4

I'm always right

Given the following input:

• A number consisting of decimal digits, the guess

• A number consisting of decimal digits, the answer

You are to output a single natural number, the base, such that when you interpret the guess as a number in the base base, the distance between guess and answer is smaller than for any other choice of base.

To be clear,

• answer is interpreted as base 10

• guess is interpreted as base base

• distance means absolute value

• The base must be greater than the largest digit used. I.e. if 6 appears in the guess, you cannot output a base smaller than 7 because any base smaller than 7 does not use the symbol 6.

Motivation and Example

Your friend asks you a question like "What's the population of New York City?"

You have no clue, so you make a guess "1,400,000 people", you say.

He says "You're an idiot, the population is 8,550,405. You were so far off."

You then do some quick math in your head and say, "I wasn't that far off, I didn't realize you wanted base 10. I was using base 14. In base 10, I said 9,680,832, which wasn't that bad of a guess"

In this example

guess  = 1400000
answer = 8550405
base   = 14

Test cases

Eventually maybe.

Answer 5

Answer 6

Edit: Posted.

---

Output this string from the kolmogorov-complexity tag info page

Answer 7

King Me - Draughts King of the Hill

Note: I made this CW so someone else can take it over, because I have no desire to make the controller and run the tournament anymore.

Draughts (or checkers, as it is known in the United States) is a well-known international game. I was surprised that we have not had a draughts King of the Hill yet, so here's one! In case you're unfamiliar with the rules (or perhaps you need a refresher), here are the rules for English draughts, the version we will be playing.

Draughts is played on a checkerboard that looks like this:

There are two players, white and red, who sit on the side of the board closest to their pieces' starting position. White moves first. Normal pieces (men) may move forward (from the perspective of the player; towards the other player) one space along diagonals, or jump over diagonally-adjacent pieces that are in front of them to capture them and remove them from the game. Because pieces can only move diagonally, they will always be on the dark squares of the board.

For example, the following move is permitted, and would result in the red piece being captured:

Players may jump as many pieces in a row as possible when making their move, which results in all jumped pieces being removed. Normally in draughts, jumping is not optional - if you can jump, you must jump, and you must make the longest jump possible. However, for this game, jumping is optional, and you do not have to make the longest jump possible if you do not wish to.

Additionally, when a man reaches the furthest row (the row closest to their opponent), it is promoted to a "king", which confers the ability to move (and capture) backwards along diagonals.

A game is ended when a player's pieces have all been captured or the player cannot make a valid move. The player who cannot move due to being trapped or having no pieces is the loser. To prevent games from going indefinitely, I am adding the additional condition that, if a capture has not happened in 10 turns (a turn being defined as ending after the red player has made their move), the game is ended and declared a draw.

The Tournament

Submissions will be accepted for seven days following the posting of this question. At 11:59 PM UTC on the seventh day, registration will close, and the tournament will be run soon after.

Submissions will compete in a round-robin tournament. 5 points will be awarded for a win, 2 points for a draw, and 0 points for a loss. 10 games will be played per match, for each pair of contestants. The submission with the highest score at the end of the tournament will be declared the winner and chosen as the accepted answer. In the event of a tie, total number of wins will be used to decide the winner.

If a bot makes an invalid move or takes longer than 1 second (judged using Java's Timer class), it will be ruled as a forfeit for that game.

To make things simple for me, all submissions must be in Java, and will be classes that inherit from a common Bot interface. The Bot code and Controller class are provided below:

[todo: bot and controller code]

king-of-the-hill java game

Answer 8

Count the cubes

Here is a picture of a diamond tiling shamelessly stolen from Random ASCII Art of the Day #5: Diamond Tilings:

However it also has the property of representing a 3D isometric view of a 5×5×5 cube with 59 cubes removed, leaving 66 behind. (Cubes obscured by other cubes are assumed to exist.)

Your task is, given an ASCII art representation of a diamond tiling, is to output both the number of cubes removed and remaining. For example (some shamelessly stolen from Scale up a Diamond Tiling):

  ____
 /   /\
/___/  \ -> 1 0 or 0 1
\   \  /
 \___\/
  ________
 /   /\   \
/___/  \___\ -> 1 1
\   \  /   /
 \___\/___/
  ____________
 /   /\   \   \
/___/  \___\___\ -> 2 1 or 1 2
\   \  /   /   /
 \___\/___/___/
  ________________
 /   /\   \   \   \
/___/  \___\___\___\ -> 3 1 or 1 3
\   \  /   /   /   /
 \___\/___/___/___/
  ________
 /\   \   \
/  \___\___\
\  /   /\   \
 \/___/  \___\ -> 3 1 or 1 3
  \   \  /   /
   \___\/___/
    ________
   /   /\   \
  /___/  \___\ -> 3 1 or 1 3
 /\   \  /   /
/  \___\/___/
\  /   /   /
 \/___/___/
    ____
   /   /\
  /___/  \
 /\   \  /\
/  \___\/  \ -> 3 1 or 1 3
\  /   /\  /
 \/___/  \/
  \   \  /
   \___\/
    ________
   /   /\   \
  /___/  \___\
 /\   \  /   /\
/  \___\/___/  \ -> 4 4
\  /   /\   \  /
 \/___/  \___\/
  \   \  /   /
   \___\/___/
      ____________
     /   /   /\   \
    /___/___/  \___\
   /   /\   \  /\   \
  /___/  \___\/  \___\
 /\   \  /   /\  /   /\
/  \___\/___/  \/___/  \ -> 16 11 or 11 16
\  /   /\   \  /   /\  /
 \/___/  \___\/___/  \/
  \   \  /   /\   \  /
   \___\/___/  \___\/
    \   \   \  /   /
     \___\___\/___/
      ____________________
     /   /\   \   \   \   \
    /___/  \___\___\___\___\
   /\   \  /\   \   \   \   \
  /  \___\/  \___\___\___\___\
 /\  /   /\  /   /   /   /\   \
/  \/___/  \/___/___/___/  \___\
\  /\   \  /   /\   \   \  /   /\
 \/  \___\/___/  \___\___\/___/  \ -> 40 20 or 20 40
  \  /   /\   \  /   /\   \   \  /
   \/___/  \___\/___/  \___\___\/
    \   \  /   /\   \  /   /   /
     \___\/___/  \___\/___/___/
      \   \   \  /   /   /   /
       \___\___\/___/___/___/
        ________________
       /   /\   \   \   \
      /___/  \___\___\___\
     /\   \  /\   \   \   \
    /  \___\/  \___\___\___\
   /\  /   /\  /   /   /\   \
  /  \/___/  \/___/___/  \___\
 /\  /\   \  /   /   /\  /\   \
/  \/  \___\/___/___/  \/  \___\ -> 46 18 or 18 46
\  /\  /   /\   \   \  /\  /   /
 \/  \/___/  \___\___\/  \/___/
  \  /\   \  /   /\   \  /   /
   \/  \___\/___/  \___\/___/
    \  /\   \   \  /   /   /
     \/  \___\___\/___/___/
      \  /   /   /   /   /
       \/___/___/___/___/

The output can be in any reasonable format, e.g. an array return value or a string with whitespace, but it must contains both values, even if they are the same, however the order of the two values does not matter in any way; you could even reverse the order on subsequent runs if you wanted to.

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

Answer 9

Dividing Strings

Division with numbers is great: 6 / 3 = 2, but have you ever wanted to divide strings? In this challenge you will, given two strings (s and t) divide s by t

Challenge

Given a string, s, find the substring in which t is repeated the most times (non-overlapping), return the amount of times t is repeated, example:

s = "HiFooFooFooFoo"
t = "Foo"
n = 4

Seems easy enough? Well if the substring ends with the first m characters of t, you should add what fraction of the string t was in the substring (m/t.len):

s = "12121"
t = "12"
n = 2.5

Rules

• You only need to output to the precision your language supports. The minimum precision is two decimal places.

Examples

First line is s, second line is m, last line is output. Examples are double-newline seperated

FooFooFoo
Foo
3

GoatGoatGoatGo
Goat
3.5

SheepSheepSheep
Goat
0

GoGoatGoatGoat
Goat
3

GoatGoGoatGo
Goat
1.5

ab111cd
1
3

PigPigPi
Pig
2.666666

aabaabaaaba
aaba
2

aabaaaabaaa
a
4

Answer 10

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 (N²+N+1);
• cards (also N²+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 N²+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).

code-golfgeometrycombinatoricsgame

Answer 11

Array Pattern Matching Language

popularity-contest array-manipulation language-design

Everyone is (or should be) acquainted with the ways of the regular expression. At its core, a regex is made for matching strings. However, it's just matching something, right? Why not match arrays? That would be something!

Description

Your task now is to design and implement a new numeric array pattern-matching language. The only requirement is that your created language satisfies the mandatory tasks detailed below. However, this being a popularity contest, you may wish to opt for the bonus tasks and maybe even some competitive golfing value.

To be more precise, your language should be able to take patterns and match them against arbitrary arrays of integers. They should minimally be used to determine whether or not an array matches the pattern. This can be done by return a boolean, two different strings, etc.

Voting

As a voter, you should keep in mind the criteria mentioned, and ask yourselves these questions:

1. Is the language trivial? That is, is there a lot that can be done other than the detailed tasks, or is the language minimally designed for these tasks?
2. Is it well described? Does the author explain the solutions and the concept behind the language?

Tasks

(Thanks to Nathan Merrill for a lot of tasks!) Note that, for each task, the empty array can go in either category, unless otherwise stated.

1. That's odd!

Write a program in your language that will match the input array if all of its members are odd; otherwise, do not match.

MATCH
 [1, 3, 5, 11, -1]
 [5, 9, 1023, 3243]

NOT MATCH
 [2, 1, 3, 4]
 [0, 5, 6, 0]

2. Increasing in membership

Match an array that has each member more than the previous member.

MATCH
 [0,1,2,3]
 [2,5,100,203123]
 [-432,-421,123,322]

NOT MATCH
 [0,0,1,2]
 [-2,3,-3]
 [1,3,2]

3. Bodyguards

Match only arrays with a 0 on both sides.

MATCH
 [0, 1, 2, 0]
 [0, 5, 0]
 [0, 0]
 [0]

NOT MATCH
 [1, 2, 3]
 [4, 5]
 [99]

4. Mountain

Match all arrays of the form [1, 2, 3, ..., N-2, N-1, N, N-1, N-2, ..., 3, 2, 1], for any N.

MATCH
 [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
 [1, 2, 3, 4, 3, 2, 1]
 [1, 2, 1]
 [1]

NOT MATCH
 [1, 2, 4, 8, 4, 2, 1]
 [3, 4, 5, 4, 3]
 [3, 2, 1, 2, 3]
 [2, 1, 1]

5. Shifting, 1 to 5

Match only arrays that consist of the numbers 1, 2, 3, 4, 5, 4, 3, 2 "in order", where the elements can be rotated around the array.

MATCH
 [1, 2, 3, 4, 5, 4, 3, 2]
 [2, 3, 4, 5, 4, 3, 2, 1]
 [5, 4, 3, 2, 1, 2, 3, 4]

NOT MATCH
 [1, 2, 3, 4, 5, 3, 2, 4]
 [2, 3, 4, 5, 2, 3, 4, 1]
 [1, 2, 3, 4, 5, 2, 3, 4]
 [1, 2, 3]
 [2]
 []

6. Not in my prime

Match an array if and only if all of it's members are not prime.

MATCH
 [4, 6, 8, 9, 24]
 [20, 40, 42, 45]
 [1, 10, 100]
 []

NOT MATCH
 [1, 100, 200, 300, 400, 401]
 [2, 3, 4]
 [2, 4, 8]
 [3, 5, 7]
 [2]

7. Unique

Match only arrays that contain no duplicates.

MATCH
 [1, 2, 3, 4]
 [5, 15, 25]
 [21]
 []

NOT MATCH
 [3, 4, 5, 3]
 [10, 11, 10, 13]
 [2, 2]

8. Not close

Match only arrays that, for each member N, do not also have a member N+1.

MATCH
 [1, 3, 45, 30]
 [20, 23, 26]
 []

NOT MATCH
 [200, 201, 202]
 [3, 9, 100, 4]
 [2, 4, 5]
 [0, 1]

9. Arithmetic Progression

Match only arrays that are arithmetic progressions; i.e. there elements increase by a constant factor. (Singletons may go either way.)

MATCH
 [2, 6, 10, 14]
 [5, 10, 15, 20]
 [20, 19, 18]
 [1, 2, 3]
 [5, 6, 7, 8]

NOT MATCH
 [5, 25, 125]
 [2, 6, 5]

10. Fibonacci-esque

Match only arrays (of length greater than 2) where each element is the sum of the previous two (not counting the first 2), and match all arrays of length 2.

MATCH
 [100, 1, 101, 102, 203, 305, 508, 813]
 [-5, 5, 0, 5, 5, 10, 15, 25, 40]
 [2, 1, 3, 4, 7, 11]
 [0, 0, 0, 0, 0, 0]
 [1, 0, 1, 1, 2]
 [1, 2, 3, 5]
 [10, 2]

NOT MATCH
 [5, 10, 15, 20, 25]
 [91, 32, 32]
 [5, 5, 5]
 [2]
 []

11. Self-descriptive

Match arrays that contain their lengths.

MATCH
 [1]
 [12, 2]
 [4, 3, 2]

NOT MATCH
 [0]
 []
 [123, 122, 121]
 [0, 2, 4, 6, 8]

12. Palindrome

Match all palindromic arrays. That is, arrays that are the same when reversed.

MATCH
 [1]
 []
 [2, 3, 4, 3, 2]
 [-1, -1]

NOT MATCH
 [3, 4, 2, 0]
 [0, 0, 0, 1]
 [1, 11]

13. Kth element at most K

(You can use 1-based or 0-based indexing. I will give test cases for 0-based indexing.)

Match all arrays whose Kth element is at most K.

MATCH
 [0, 0, 2]
 [0, 0, 0, 1]
 [-4, -1, 0]

NOT MATCH
 [2, 42]
 [-4, -92, 4]

14. Twins

Match all arrays of even length whose first half is equal to the second half.

MATCH
 [1, 2, 3, 1, 2, 3]
 [4, 4]
 [0, 0, 0, 0]

NOT MATCH
 [4, 9, 9, 4]
 [9, 2, 13, 2, 9]
 [1, 2, 3, 1, 2]

15. A simplified date

Match all 3-element arrays which constitute a valid date. The array will be [year, month, day]. That is, year >= 0, 1 <= month <= 12, and 1 <= day <= 31.

MATCH
 [2018, 6, 16]
 [1990, 1, 1]
 [0, 6, 31]
 [3014, 7, 13]
 [1293, 9, 9]
 [12, 12, 12]

NOT MATCH
 [-4, 12, 9]
 [100, 100, 4]
 [1929, 13, 31]
 [4102, 12, 32]

Answer 12

🎲🎲Lucky Dice (KotH, WIP)🎲🎲

CHAT • CONTROLLER

You have recently taken a job at Lucky & Co, as a professional dice roller, and need to make as much money as you can! (of course). You will be paid exactly what you roll, $1 for a 1, $2 for a 2 etc. Where's the fun in that? Well, these aren't ordinary dice: starting with $5 in your bank, you must purchase new dice, which will all be rolled each turn. There are many different types of dice, all with different probabilities of rolling the different numbers. Every turn, you take a look at what the dices have done for you, then decide what to invest in. But beware! You have many rivals, all with the same aim in mind, and there are only so many dice in the shop...

The Dice (StC)

There are many types of dice, which can be split into the following categories:

Basic Earners

20 of each are available, they are simply rolled and their value is added to the total points:

╔════╦═════════════════════╦═══════╦═════╦════╦════╦════╦════╦═════╗
║ ID ║     Description     ║ Price ║  1  ║ 2  ║ 3  ║ 4  ║ 5  ║  6  ║
╠════╬═════════════════════╬═══════╬═════╬════╬════╬════╬════╬═════╣
║  0 ║ Rolls a 1           ║     1 ║ 100 ║  0 ║  0 ║  0 ║  0 ║   0 ║
║  1 ║ Likely to be low    ║     3 ║  50 ║ 25 ║ 13 ║  7 ║  3 ║   2 ║
║  2 ║ Unlikely to be high ║     6 ║  22 ║ 22 ║ 22 ║ 11 ║ 11 ║  11 ║
║  3 ║ Even chances        ║     9 ║  17 ║ 17 ║ 17 ║ 17 ║ 17 ║  17 ║
║  4 ║ Unlikely to be low  ║    12 ║  11 ║ 11 ║ 11 ║ 22 ║ 22 ║  22 ║
║  5 ║ Likely to be high   ║    16 ║   2 ║  3 ║  7 ║ 13 ║ 25 ║  50 ║
║  6 ║ Rolls a 6           ║    21 ║   0 ║  0 ║  0 ║  0 ║  0 ║ 100 ║
╚════╩═════════════════════╩═══════╩═════╩════╩════╩════╩════╩═════╝

Multipliers

These multiply the points gained by the basic dice by something between 0.33 and 18... 10 of each are available. r represents what it rolled, each outcome (1-6) is equally likely:

╔════╦═════════════════╦═══════╗
║ ID ║   Description   ║ Price ║
╠════╬═════════════════╬═══════╣
║  7 ║ Multiply by r/3 ║    10 ║
║  8 ║ Multiply by r/2 ║    13 ║
║  9 ║ Multiply by r   ║    22 ║
║ 10 ║ Multiply by r*2 ║    34 ║
║ 11 ║ Multiply by r*3 ║    50 ║
╚════╩═════════════════╩═══════╝

Attacks

These dice, with 10 of each available, are what makes the game truly interesting. They handle user interaction: each has a set action that it applies to one other random player (except 16):

╔════╦══════════════════════════════════╦═══════╗
║ ID ║              Action              ║ Price ║
╠════╬══════════════════════════════════╬═══════╣
║ 12 ║ See below (too long)             ║    35 ║
║ 13 ║ They get 10 less (not below 0)   ║    45 ║
║ 14 ║ Like 12, but you get the points  ║    60 ║
║ 15 ║ They get 25 less (not below 0)   ║    60 ║
║ 16 ║ Like 14, but you get the points  ║    90 ║
╚════╩══════════════════════════════════╩═══════╝

12: A fair dice, the value of which is subtracted from every other users' basic dice roll (not below 0).

Coins

Miscellaneous other bonuses and actions, each with a 50% chance of happening. There are only 3 of each available:

╔════╦═══════════════════════════════════════════╦═══════╗
║ ID ║                Description                ║ Price ║
╠════╬═══════════════════════════════════════════╬═══════╣
║ 17 ║ Protects you from attacks                 ║    65 ║
║ 18 ║ Roll every basic die again                ║    90 ║
║ 19 ║ Roll every basic and multiplier die again ║   110 ║
║ 20 ║ Square your score                         ║   120 ║
║ 21 ║ Cube your score                           ║   170 ║
╚════╩═══════════════════════════════════════════╩═══════╝

How the dice fall

When working out the points for a round:

• Every players' coins are flipped. The results are remembered.
• Every players' basic dice are rolled (as many times as specified by coins). The total of the results for each player is that players' points for this round
• Every players' multiplier dice are rolled (with extra rolls). Each multiplication is applied on top of the previous one.
• Any squaring or cubing is applied.
• For every players' attack dice, a random other player is chosen for each. Unless that player had a shield, the appropriate action is taken.

A game

A game lasts until first place is 200 points ahead of second place, or until 500 rounds have been played. There are 7 people in each game, who each start with just $5. Every round, each player submits a list of dice that they want to buy. If they ask for a dice that isn't there, ask to pay more than they have, or returns an otherwise invalid move, they do not buy anything that round. If more people ask for a dice than there are of that dice, no-one gets it. After every bot has given their move, and all orders have been resolved, the points for the round are calculated as above, and then added to the total score of each bot. At this point, the win condition is tested. 1st place gets 7 points, second gets 6 and so on. If two players are joined in, for example, 3rd place, they both get 5 points, but the next bot/s get only 3.

A tournament

In a tournament:

1. If there are more than 7 bots, the bots will be divided into groups of 7 to play until every bot has played an equal number of games, and there are 7 bots which have a higher total score than the rest.
2. The top 7 bots play games until one has 50 more points than second place.
3. 2 is repeated for all the other groups of seven, and then the leftover bots. Now every bot knows its rightful place!

I will run a tournament every day if possible, which it hopefully will be.

Coding

You will write a Python class that inherits from Bot, and implements get_orders, which must accept the following parameters:

• money - how much money each player has (a tuple of ints)
• dice - what dices each player has (a tuple of tuples of ints)
• index - your index in the money and dice tuples (an int)`
• shop - how many of each dice the shop has (a dict of int: int pairs)

Dice are represented in the above by their ID. You may also implement __init__ (self, random), where random is a random.Random object, which is the only access to randomness that you are allowed, that is, if I were to run your code again with the same argument to random and the same calls to get_orders, I would receive the same results. You may also implement any other utility functions you wish. You may not store information between games (already banned but let's do it explicitly), and you may not mess with the controller. You may not team up (how could you?) or use any other competitor's code without significant changes without their permission. You may not programmatically invoke another competitor's code, because that could get circular...

Controller

WIP

Results

None yet ;P

king-of-the-hillprobability-theorygamenumber

Sandbox

• Any thoughts?
• What should I clarify, I feel like I've missed everything...
• Do you like the idea?
• Have you spotted a perfect and unbeatable strategy?
• Any suggestions for new dice/dice types?
• Any suggestions for changes to the game/tournament system?
• Are all the tags appropriate?

  Unicode Art Table

╔════╦═══════════════════════════════════════════╦═══════╗
║ ID ║                Description                ║ Price ║
╠════╬═══════════════════════════════════════════╬═══════╣
║ 16 ║ Protects you from attacks                 ║    65 ║
║ 17 ║ Roll every basic die again                ║    90 ║
║ 18 ║ Roll every basic and multiplier die again ║   110 ║
║ 19 ║ square your score                         ║   120 ║
║ 20 ║ cube your score                           ║   170 ║
╚════╩═══════════════════════════════════════════╩═══════╝

MathJax Table

\begin{array} {|r|r|} \hline \text{ID} &\text{Description} &\text{Price} \\ \hline \text{16} &\text{Protects you from attacks} &\text{65} \\ \text{17} &\text{Roll every basic die again} &\text{90} \\ \text{18} &\text{Roll every basic and multiplier die again} &\text{110} \\ \text{19} &\text{Square your score} &\text{120} \\ \text{20} &\text{Cube your score} &\text{170} \\ \hline \end{array}

Which is better?

Answer 13

Round away from zero

Submitted.

Inspired by Round towards zero.

Given a number input via any reasonable method, round the number "away from zero" - positive numbers round up, and negative numbers round down.

You can output a floating-point number with the decimal point (e.g. 42.0) if desired.

^{why did i think this was a good idea}

Test cases

-99.9 => -100
-33.5 => -34
-7    => -7
-1.1  => -2
0     => 0
2.3   => 3
8     => 8
99.9  => 100

Answer 14

Win the competition king-of-the-hill

Write a Javascript anonymous function that, given two functions as strings, deterministically picks one as the winner and returns 1 if the first input wins and 2 if the second input wins. The choice must not depend on the order of inputs (that is, for any given input pair, the same program must always win no matter which one is first).

Every submission will be used to compare all unordered pairs of all solutions except self. Every time a program is chosen as the winner, it is assigned 1 point.

Submissions must not store any information between runs, interfere with the controller or somehow destroy my computer. There is no hard time limit, but intentionally creating an excessively slow solution counts as destroying my computer. Submissions must not duplicate other submissions or be longer than 200 KiB. Submissions must not rely on the input functions always halting (that is, they must not execute them or any parts of them).

You should give your submission a name (it should match the regex [A-Za-z ]+ and not coincide with any other solutions).

Controller in a snippet:

document.write(atob(`PCFkb2N0eXBlIGh0bWw+CjxodG1sPgo8Ym9keT4KPHNjcmlwdD4KCWZ1bmN0aW9uIGFkZFByb2dy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`.split("\n").join``))

This is tagged king-of-the-hill. Whoever wins the most wins!

After posting this, I will post two example (community wiki) answers: one that compares in lexicographic order, and another that compares first by byte count, then in lexicographic order (the reason for posting two is that at least 3 programs are needed for anyone to get any points).

Sandbox stuff

• How can I prevent the last answer from always winning?
  • Will that happen automatically, once enough answers are posted that it's nearly impossible to optimize for all of them?
• Would it be a good idea to introduce other requirements for the submissions, such as transitivity?
• Would it be a good idea to introduce a per-user submission limit (probably 1 or 2)?

Answer 15

Pristine Polyglots

Answer 16

Inverted ragged list

Answer 17

Add a hidden language to a polyglot

Answer 18

Is This an Equivalence Relation?

Answer 19

Sʨɠɠanography

Many Unicode composed characters have two forms, one being a precomposed character, while the other is an ASCII character with a combining diacritic. For instance, é has Unicode code point U+00E9, but é, which looks identical, is actually the ASCII character 0x65 with the combining diacritic U+0301.

Your task is to write two programs or functions. The first will take a string of Unicode containing some composed characters and a string of printable ASCII. It will then output an identical-looking Unicode string which the second program can then decode to recover the printable ASCII.

By identical-looking, it must be the case that performing your choice of NFC or NFD normalisation on the input and output Unicode strings returns an identical string. If necessary, you may require that the input Unicode string be already NFC or NFD normalised (please specify).

If the input string does not contain sufficient composed characters for you to use, you should repeat it until its length is sufficient. You may also join the repeats with newlines should you so wish.

Your score is the sum of the byte lengths of your two programs divided by the number of composed characters you support in the input Unicode string. For instance, you may only wish to support those composed characters that expand to two characters under NFD. In this case your code's behaviour for other composed characters must be consistent (i.e. one of always unchanged, always NFC, always NFD). (Note that the Unicode string may also contain characters that do not change under NFC or NFD. You obviously can't use these to encode the ASCII string but they must still appear in the output.)

If your language supports arbitrary-precision integers, you may also elect to provide a demonstration of your algorithm on integers rather than printable ASCII strings.

Answer 20

Sandbox note: This is an idea for a cops-and-robbers challenge based on the halting problem. As it is, it's hard to imagine it being popular on PPCG, but I'd really like to make it into something people would actually participate in. The reason is that it's really interesting from a theoretical point of view, as a fundamentally open-ended challenge. The beautiful mathematics of Turing and Gödel gurantees that there's always a new innovation that the cops could make, and there's always a way for the robbers to exploit it. So any ideas on how to turn this into something fun would be greatly appreciated.

HALT in the name of the law

The robbers are getting away, and the cops have to decide whether to wait for them to stop and arrest them, or set up a road block at the state boundary. They do this by trying to predict whether the robbers' program will halt. Please note that this challenge is hard, especially for the cops.

Robbers are represented by programs written in a language called "w", which I invented for this challenge, and which I describe below. w is easy to implement and relatively easy to reason about. I will provide a reference implementation and a macro preprocessor that allows it to be written in a somewhat human-readable form.

Cops must provide a program (in any language) that takes a robber's w program as input, and tries to decide whether it halts or not. A cop submission is invalidated by a robber program for which it returns the wrong answer or fails to terminate.

Cops

You must write a program that takes as input programs in the (pre-processd) w language. It should attempt to output a truthy value if its input program ever halts, and a falsy value if it doesn't. Your submission should be written in a "real" programming language rather than w. In addition to your program, you should provide a clear English explanation of how it works.

Robbers

You must "crack" cops' submissions by providing one of the following three things:

• A program written in w that halts, but for which the cop program does not return a truthy value. (The cops waited at the roadblock while you stopped, changed your identities and went underground.) You must demonstrate that the program halts, either by running it in the reference implementation of W or by proving that it has to halt eventually.

• A program written in w for which the cop's program returns a truthy value, together with a proof that your program does not halt. (The cops gave chase, but you kept going until you reached the state border, infinitely far away.)

• A program written in w for which the cop program itself doesn't halt, together with an argument showing that it doesn't halt. (The cops just gave up and got some donuts, hoping nobody would notice.)

Other rules

If the cops' program is nondeterministic (e.g. because it's doing some kind of stochastic search for halting conditions) then it suffices to show that there is some non-zero probability that it will return the wrong answer or fail to halt.

This is popularity-contest for the cops - the uncracked submission with the most votes wins.

The w language

Syntax and semantics

w is a very simple structured programming language whose variables can only be incremented and decremented, and whose only control structure is the while loop. The syntax is designed to be as easy to parse as possible. Here is an example w program. Below I'll describe what it does.

a+ a+ a+
b+ b+
a{
  a-
  b+
}

There is a preprocessor [to be provided] that, among other things, standardises the whitespace, so that the code above will be formatted like this:

a b
a+ a+ a+ b+ b+ a{ a- b+ }

The first line (provided by the preprocessor) is a list of all the variable names that appear in the program. All variables in w are unsigned infinite-precision integers. (Infinite precision means that they will never overflow. This is very important for Turing-completeness.) A variable name is any combination of the characters a-z, A-Z, 0-9 and _. All variables initially hold the value 0.

The second line is a list of expressions. There are three kinds of expression. The first two are <variablename>+, which increments a variable by 1, and <variablename>-, which decrements it by 1. (For C programmers, think of these as the postfix ++ and -- operators.) Since the variables are unsigned, it is an error to decrement a variable whose value is zero. This will halt the program immediately. (Note that errors are counted as halting for the sake of this challenge.)

The third type of expression is a while loop. Its syntax takes the form {<variable_name>,<expression_list>}. If the variable has value 0, the expression list is skipped. Otherwise, the expression list is executed repeatedly until the variable becomes zero. (If the variable never becomes zero, the program fails to halt.) That's it - there's nothing more to the language than that.

Note that if you split the second line of the preprocessed program at the spaces, each item will either be } or a variable name followed by a symbol, so you can easily pop off the last character to see what kind of expression you're dealing with.

Looking back at the example program, the first line, a+ a+ a+ increments a three times, setting it equal to 3, and the second line sets b to three. The while loop decrements a while incrementing b until a is zero. So the value of a is added to b, and at the end of the program, a is zero and b is equal to five.

Alternative syntax

Optionally, the preprocessor can output w programs as a string representing a Python list. The example program would appear as follows. The first sublist is the list of variables, and the second is a list of lists representing the parse tree.

[["a", "b"], ["a+", "a+", "a+", "b+", "b+", "a{", ["a-", "b+"]]]

Input and output

For the sake of this challenge, we only care whether a program halts or not when given no input, so there is no input or output in the w language as described here. However, if we wanted we could say that a special variable (let's say _) is initialised with the program's input, and the value of the last expression evaluated is the output. If we do this, the language becomes Turing complete in the classical sense. (The proof is left as an exercise to the reader.)

Implementation notes

Implementing W correctly requires the use of infinite-precision integers. However, the only operations these need to support are incrementing and decrementing, which makes them much easier to implement. The reference implementation uses Python's unlimited precision integers.

Answer 21

Ant Wars

king-of-the-hill

Parts of this challenge are based off of Ant Queen of the Hill Contest.

---

Objective

Your objective is to conquer the ants of the world ... or have the biggest army of ants. To do this, you start with a single queen. The queen can create worker ants by using food gathered by itself or other worker ants. Your worker ants can kill other ants by attacking them. You win if you have the only queen left, or if you have the biggest army of ants.

---

Board

The board will be a square with wraparound borders. The length of each edge is determined by sqrt(1000*n)¹. Before the game fierce battle for domination starts, 100*n pieces of food will be distributed semi-randomly on the board . n queens, 1 for each player, will also be randomly distributed on the board.

1: n is the number of starting players

---

Ants

Sight and Smell

Ants are usually near-sighted and have somewhat short antenna. Because of this, ants in this simulation can only see and smell ants, food, and pheromone in its 3 by 3 neighborhood. They can also tell the difference between ants of different species.

Memory

Because of limited brain space, every ant has a memory of up to 5 characters long. The starting memory for queens is 5 spaces.

Orientation

Every ant is oriented in the direction that it last moved. Queens start out oriented in a random direction.

Food

Each worker ants can carry up to 1 unit of food. A queen ant can carry an unlimited amount (so that's what her body is for). Every ant picks up as much food on its current square as possible. A queen ant takes all the food from adjacent squares including that carried by workers of any player.

---

Moves

Every turn, every ant is given a view of the local surroundings and then decides to move. Ants are given priority in their movement with those that are oldest moving first. The initial order for the starting queens is random.

Attacking

An ant attacks by attempting to move onto another ant. Worker ants require two ants attacking them in order to be killed. Queen ants require eight ants attacking it in order to be killed. Queen ants cannot attack. An ant after being killed drops all food it is carrying and one additional unit of food.

Moving

An ant can move to any of the 8 surrounding squares. This changes the orientation of the ant to the direction it is moving. If it tries to move to a square with an ant already on it, it is assumed to be attacking that ant, no matter if friendly or not.

Dropping Pheromone

An ant can optionally increase the value of 4 different pheromones on the cell it is on, 1 of which can only be seen by ants of that particular colony. Pheromone has a value of a double-precision float and decreases by 1% every game tick. An ant can increase pheromone by up to 10.

Creating Workers

A queen ant may create a worker and spawn it in any of the surrounding cells. The queen ant also chooses the memory of the new worker.

---

Winning

A game ends after there is only one queen left or after 10000 turns. The winner is one of the players with a queen with the most workers. I will determine the winner after playing a number of games ... depending on the amount of time it takes to play each game.

---

Coding

You can implement a program or a java class that takes in an ant input and gives an ant output for that ant.

Input:

Input contains your player id, your ant's memory, if your ant is a queen, and then the contents of the cells surrounding it. The cells are given from the top left to the top right in this order:

0 | 1 | 2
3 | 4 | 5
6 | 7 | 8

Input is format thus:

player_id;ant_memory;is_queen;cell_0_info;cell_1_info...

Cell info is formated like this:

pheromone_0,pheromone_1,pheromone_2,pheromone_3,ant_type,ant_owner

player_id and ant_owner are positive integers.
ant_memory is a 5-character long string.
is_queen is one of true or false.
The pheromones are double-precision (64-bit) floats.
ant_type is one of W (for worker ants) and Q (for queen ants).
If there is no ant on a cell, ant_type and ant_owner will be omitted from the input.

Output:

You have to output the cell you want to move to, the pheromone you wish to add to your current cell, and whether the ant would like to create an ant instead of moving (only works for queens :P).

It should be formatted thus: next_memory;cell;pheromone_0;pheromone_1;pheromone_2;pheromone_3;create_ant;created_ants_memory

The controller is rather flexible and should be able to understand what you write if you use different delimiters or leave out some of the information. Make sure that next_memory comes first in your programs output and that it is exactly 5 characters long. If creating an ant, created_ants_memory needs to be the last 5 characters in the input.

cell has to be an integer in the range [0, 8] (defaults to 4).
pheromone_n has to be a positive float (defaults to 0).
create_ant needs to be one of: true, false, yes, no, 1, or 0 (defaults to false).

How to create a bot:

You have 3 options for this. You can:

1. Implement the Ant interface with a java class. (Very fast)
2. Communicate to the controller via I/O streams. (Fast (I think))
3. Be called via command arguments and output via STDOUT (Slow depending on OS and programming language)

Note: Your bot must be completely deterministic. Given the same input, your bot should always return the same output.

Method 1:

Ant interface:

interface Ant {
    String move(String input);
}

Implement this interface for your ants :)

Method 2:

Every time it is one of your ants' turns, your program will receive a line of input through STDIN followed by a newline. After receiving the input, your program is expected to output a line through STDOUT followed by a newline.

Method 3:

Your program will be executed with the input line as its first argument. Your program is expected to output through STDOUT.

Time limit

Each time your program is called, it should return within 5 milliseconds. Since the time limit may be exceeded due to fluctuations outside your control, an average will be calculated. If at any point the average is above 5 milliseconds and the total time taken by your program across all calls so far is more than 10 seconds, the relevant player will be disqualified. This means they will not be eligible to win, their ant function will not be called again during that game, and all ants of that player will instantaneously perish.

---

---

Questions

1. How can I improve this to look prettier?
2. Any typos or formatting issues?
3. Any other ways I can improve this challenge?

Answer 22

King of the Sausage

This is just a draft.

I saw this (slightly altered) 'game' in a tv show once: Two competitors are each given a sausage of equal weight. Then they each have to cut pieces from this sausage (without seeing how much the oponent cut off) which then are weighted against each other. The player that has the heavier piece gets a point. Then the weighted sausage pieces are discarted and the process is repeated. After 5 rounds the one who got the heavier piece more often wins.

A win results in 3 points, a loss in 0, a tie in 1 for.

Details

Here the saussage weight is given as an integer totalWeight. You can only cut off pieces of integer size.

Each submission should write a JavaScript function that takes these arguments:

• totalWeight: The units of the total weight of the sausage at the beginning as an integer between 5 and 2^31-1.
• round: An integer between 0 and 4 that indicates the current round.
• ownPieces: An array of size 0 upto 4, each element is the size of the piece you cut of in the previous round.
• opponentPieces: The same, but with the pieces of the oponent.
• memory: A variable that allows you to store information between the rounds. It can contain any kind of structure. It is initialized with 0 before the first game with an new oponent and it can store information between those games.

Each time it is called, it has to return an integer between 0 and the weight of the remaining sausage (= totalWeight minus the sum of the entries in ownPieces). If it does return anything else, the submission will be disqualified. The function may not access any global variables and may not try to influece the game in any other way. It cannot take more than 100ms per round.

Each pair of oponents will play this game a certain number (to be determined ) of times against each other.

Feel free to share your thoughts / suggestions!

Meta:

How should the initial sausage weight be determined?

Possible controller inspiration: https://jsfiddle.net/CalvinsHobbies/ave6ejyd/

Answer 23

Simulate Colorblindness code-challengetest-batteryoptical-char-recognitionimage-processing

As some of you might know, I am colorblind. Specifically, I have moderate deuteranopia. This means that I have difficulty distinguishing between red, green, and yellow colors, as well as various shades of purple and blue, due to not having green cones in my eyes.

The most common way to diagnose colorblindness is through the use of the Ishihara test. In this test, various image plates are shown to the individual. These plates are comprised of dots of several shades of the same color, where certain shades are grouped together to form numbers. The shades are chosen so that, based on the set of plates on which the individual fails to recognize the number, the type of colorblindess can be determined.

Here are a few samples of Ishihara plates:

This plate (plate #1 in the Ishihara 24-plate test) is a control plate - everyone should be able to see the number 12 clearly, regardless of whether or not they are colorblind. This is the only plate on which an individual with total colorblindness (monochromacy) can read the number.

This plate (plate #2) has an 8 inscribed on it, but individuals with red-green deficiencies see it as a 3 (myself included).

This plate (plate #8) has a 6 inscribed on it, but individuals with any type of colorblindness cannot see any number.

This plate (plate #14) will be seen as having a 5 on it by individuals with red-green deficiencies, but others will not see any number.

This plate (plate #16) has the number 26 on it. Individuals with protanopia will only see the 6, and individuals with deuteranopia will only see the 2.

The Challenge

Given a set of Ishihara plates, output the number that an individual with each type of colorblindness (none, protanopia, deuteranopia, and monochromacy)¹ would see on the plate. Your score will be the number of correct outputs your program gives for each plate in the scoring battery (up to 4 points per plate).

For testing purposes, here is an Imgur gallery containing the first 17 original Ishihara plates. The correct outputs for each plate are as follows:

X means that no number can be read
Plate #: Normal, Protanopia, Deuteranopia, Monochromacy
1: 12, 12, 12, 12
2: 8, 3, 3, X
3: 29, 70, 70, X
4: 5, 2, 2, X
5: 3, 5, 5, X
6: 15, 17, 17, X
7: 74, 21, 21, X
8: 6, X, X, X
9: 45, X, X, X
10: 5, X, X, X
11: 7, X, X, X
12: 16, X, X, X
13: 73, X, X, X
14: X, 5, 5, X
15: X, 45, 45, X
16: 26, 6, 2, X
17: 42, 2, 4, X

The scoring battery will be a unique set of Ishihara plates, created for the purpose of this challenge.

Specifications

• Input and output may be in any reasonable manner and format, so long as no extra information (such as the number that should be seen on the plate) is conveyed in the input other than the image data.
• Builtins which trivialize this challenge (such as an optical character recognizition library like Tesseract) are forbidden. Though I highly doubt that any programming language or library has this functionality built-in, Mathematica and its ilk continue to surprise me.
• The scoring set of plates will not be disclosed, to prevent optimizing for that specific set.

^{1: There are actually a few other variations of colorblindess, but Ishihara plates are not effective at diagnosing them.}

Sandbox Questions

• Did I mess up any of the plate images? Being colorblind myself, picking out the proper plate images is rather difficult.
• Is there anything that needs further specification?

Answer 24

WHAT IS THIS DOING HERE?

How low can you go? - Signal Limbo.

Sometimes we need a low voltage, sometimes we need a high voltage. Let's design a VDC power supply!

The challenge is simple, with 2 lines (+5V and GND), Create a Variable DC power supply on a standard breadboard that ranges from +12V (+/-0.1) to 0V.

INPUT: 5VDC (power rail +), 0VDC (power rail -), 5K, OR 10K potentiometer

OUTPUT: 12-0VDC depending linearly on potentiometer. There is no lower limit to the ammount of current that this circuit needs to be able to supply.

Rules:

^{this is a standard breadboard. Image courtesy of SparkFun's breadboard tutorial.}

A standard breadboard consists of 2 power rails, 2 colums of 5 general pins, and 30 rows.

• All pins on one row (a,b,c,d, and e are all a single row) are connected.
• All pins on separate rows are Separate.
• The opposite is true for power lines. (columns are connected, but not rows)

Electrical components are restricted as follows.

• All electrical products which have a public datasheet are valid in this challenge, EXCEPT
  • Those without DIP Packaging XOR Those without through hole packaging
  • Those with PCBs
• All Non-Passive components used in your entry must have a part number, or spec sheet.
• All passive components (except wire) must have a value, given in Ohms, Henries, or Farads.
• No pin may be left floating. All pins must be connected to somewhere on the bread board.

Scoring:

You will be scored based on the area that your entry spans. Do Not Score with the power rails, only components within the labelled grid shall be scored.

The area (measured in pin spaces) will be taken by the smallest rectangle that can be drawn around all of the breadboard connections.

this is a breadboard-golf, so the entry with the least area consumed wins! good luck!

Tools

Circuits.IO Will be a great standard for this challenge. I ask that you consider this before any other simulator, it's simple, and easy to share. I am not requiring that you use it.

Answer 25

Natural Pi - The Front Nine W.I.P.

## Meta ## 
    - 4 more ways to calculate pi with nature?

---

Introduction

These challenges are simulations of algorithms that only require nature and your brain (and maybe some re-usable resources) to approximate Pi. If you really need Pi during the zombie apocalypse, these methods don't waste ammo! There are nine challenges total.

Each challenge will give an algorithm for approximating Pi with nature. Then it will walk through how the computer simulation should work. Next comes the Specification to clear up details and finally there are some test cases.

---

Natural Pi #0 - Rock

• Coprime Probability

Natural Pi #1 - Sand

• Buffon's Needle

Natural Pi #2 - River

• Curvy-ness of a River

---

Natural Pi #3 - Books

• E's in a circle

Natural Pi #4 - Sun Flower

• Ratio of Area to Diameter

Natural Pi #5 - Vine

• Period of a Pendulum

Natural Pi #6 - Fire

• Ratio of Circumference to Diameter

code-golfrandommathpi

Answer 26

This message is open for anyone to adopt and post to main. For more details, see the chat room or meta post.

The Best Way to Rake Leaves

code-challenge optimization

[This is just a little problem I thought up while doing yard work today. It is not fully specified and I may not finish it if some simple optimal solution is found.]

Suppose some 2D grid represents the area of a lawn. A number of leaves are strewn over the lawn and they are modeled as single grid points. You have a rake that is modeled as a line segment of length L.

To start you can rotate the rake in any way and put it anywhere on the grid.

When the rake is moved some distance d along its perpendicular, all the leaves in its path are caught in it. They stay on the rake line until the rake stops (as with normal raking).

You repeat this process (moving the rake different distances every time) until all the leaves all lie on one singular point.

The question is: what is the minimum distance the rake has to move to make this happen?
(i.e. what is the minimum sum of the d's from each move?)

Challenge Spec (details incomplete)

Write a program that takes in a list of (x, y) leaf points and the length L of the rake (all floats).

The program should output a sequence of rake moves in the form of ((x1, y1), (x2, y2)) line segments that the rake travels perpendicularly down the center of. This sequence must bring all the leaves to the same exact point when they are "moved" by the rake

The challenge is to make an algorithm that does this with the least possible sum of sqrt((x1-x2)^2 + (y1-y2)^2) over all points.

[At this point several test cases would be given, with different L values and different leaf distributions. The submission that minimizes the total distance wins (assuming they do not hard code the answer).]

[This optimization problem does not seem to have any trivial solutions or even a clear optimal solution. Can anyone else poke holes in it?]

Answer 27

The Formic Forest - Ant QotH Contest

grid king-of-the-hill javascript game

---

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.

Multiple Answers and Editing

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.

Answer 28

Tower Defense (Abandoned)

game king-of-the-hill javascript

Anyone is free to take over this challenge and fork as necessary. Just give me credit ;)

---

View it here | Chat

Tower Defense is a format for casual games that was popularized in the Flash era. The player places towers that shoot down invaders moving along a predefined path.

Overview

Two submissions will compete against each other to invade the other player's village without being invaded themselves. They will have the ability to place towers, upgrade them, and spawn invaders to attack the enemy village. The game will be simulated deterministically in a turn based fashion, with each player being able to do one action each turn.

The game board is made up of two paths, each 100 spaces long. Each player begins with 500 gold, which is used for building towers and spawning invaders; and 100 life. Your objective is to bring your opponent's life down to 0. If neither player has been defeated after 100000 turns, the winner will be the player with the most life at that point, with ties being broken by who has the most gold at that point. If, somehow, there is still a tie, the match will be considered a tie.

Income

Every 10 turns, players will receive gold. Initially, they receive 10 gold, but this amount increases by 3 every 100 turns.

Each time you successfully get an invader through your opponent's defenses, your income increases by 1 and you receive a portion of your income proportional to how much HP the invader had left.

Each time one of your towers defeats an invader, you receive gold. (More on that below)

Towers

Each space on the path can house one tower. There are 3 types of towers, which have a range and a power. It takes 10 turns for a tower to be ready after it is built. Towers can be upgraded either with a wider range or an increased power, in increments of 1. There is no hard limit to how many times a tower can be upgraded.

Range refers to how many spaces away from the tower that can be reached by the tower's abilities. A range of 0 means that only the space that the tower is on is affected by the tower's attacks.

Power has a different meaning depending on the kind of tower.

Turrets

Each turn, turrets fire at the invader within range that is farthest along the path to your village. They deal damage equal to the tower's power.

Turrets begin with a range of 1 and a power of 1.

Stunners

Stunners fire at the invader within range that is farthest along the path to your village. However, instead of dealing damage, they stun the invader for a number of turns equal to the tower's power. After firing, stunners cannot fire again for their power + 1 turns. Stunners will not fire at invaders that are already stunned.

Stunners begin with a range of 0 and a power of 3

Bombs

When an invader is on the same space as the bomb tower, it triggers and deals damage equal to its power to all invaders within its range. After being triggered, it cannot fire again for another 5 turns.

Bombs begin with a range of 2 and a power of 2

Invaders

Each turn, you may spawn an invader. At minimum, it costs 10 gold and has a base HP of 10. You can spend additional gold to increase its power:

• (1G) +1 HP
• (10G) +1 Defense (reduce damage taken by 1, but not lower than 1)
• (10G) +1 Stun resistance (reduces stun time by 1 turn)

You are limited on the maximum stats. You start off unable to boost stats, but every 100 turns, the maximum increases by 5

There can only be one invader on each space of the board and invaders cannot pass through each other. You cannot spawn an invader if there is already an invader on the first space of the board. Therefore, a potential counterplay from defenders to prevent massive hordes of invaders is to put stunners on the first few spaces.

Coding

The main game / AI driver is here (still a work in progress)

Submission logistics TBD

Both players will have complete knowledge about the state of the game and will be allowed to maintain state from the beginning of the game. They may not directly modify the game state. Any attempts to do so will be disqualified as will any attempt to obfuscate such an attempt.

(api description will go here)

Defenders should return an object with an action property that is either 'build', 'upgrade', or 'destroy'. Each requires some additional properties to be set: (will add later)

Invaders should return an object which contains any stat boosts desired: hp, defense, and stunRes.

Both defenders or invaders may also return undefined or null to indicate not taking an action.

AIs must return their desired action in less than 10 milliseconds, averaged over 100 turns. Invalid actions returned by the AI will be ignored.

Scoring

All submissions will compete against all other submissions in a round-robin tournament. The bot that wins the most matches is declared the winner. In the event of a tie, the number of turns it took to win will be totaled for all winning matches with the smallest cumulative turn count to victory wins. In the unlikely event of a further tie, the turns to loss will be totaled for all losing matches and the bot with the highest cumulative turn count to loss wins.

Only one submission per user can be scored in the round-robin tournament.

Rules

• No abusing standard loopholes
• No direct modification of the game state passed to you. It will not be defensively deep-copied. Don't obfuscate your code to try to hide state modification.
• Any uncaught exceptions will result in disqualification.
• Implementations must be totally deterministic, i.e. random number generators are only allowed if seeded consistently (either with a constant or with game state) and must use isolated random state which the other AI in play cannot access.
• Submissions shall include an explanation of the AI's strategy.

Answer 29

Give numbers space number

Given a list of integers, adjust each number by at most ±1 so that in the resulting list, each number is at least 2 apart from each of its neighbors. That each, each entry n can be replaced with n-1, n, or n+1, and any two adjacent entries x and y must have abs(x-y) ≥ 2. The output is a list of the same length as the input.

You will not get an input where this is impossible, such as [5, 4, 4, 5]. The input will have at least two elements.

Examples (other outputs are possible):

[-5, -6] -> [-5, -7]
[1, 1, 1] -> [2, 0, 2]
[2, 2, 3, 3] -> [3, 1, 4, 2]
[0, 5, -1] -> [0, 5, -1]
[4, 4, 4, 4, 4, 4, 4, 3, 3, 3] -> [5, 3, 5, 3, 5, 3, 5, 2, 4, 2]
[4, 4, 4, 4, 4, 4, 4, 5, 5, 5] -> [3, 5, 3, 5, 3, 5, 3, 6, 4, 6]
[1, 1, 2, 4, 6, 7, 7] -> [2, 0, 2, 4, 6, 8, 6]

Answer 30

Game of Lives

king-of-the-hill cellular-automata game-of-life

In this king-of-the-hill, your goal is to create a GOL (Game of Life) pattern that creates the most live cells after \$n\$ steps. The twist is, you will be competing against 3 other patterns on the same playing field at the same time.

Here are the rules of the Game of Life, with a couple of additions:

• Each player's starting living cells will be a specific colour.
• Any live cell with 2 or 3 live neighbours will stay alive, otherwise they'll die
  • Note that 'neighbours' includes diagonals, so there are 8 possible neighbours for a cell.
• Any dead cell with exactly three neighbours will become a live cell with the colour of the most common neighbouring cell. If there is no majority, it will become a neutral colour, which won't count for further conversions.
  • 2 Reds + 1 Blue = Red
  • Red + Blue + Green = Neutral
  • 2 Neutrals + Red = Red
• The playing field will be \$x\$ by \$x\$, where each quarter of the field is each player's starting configuration.
• Cells outside the playing field will always be considered as dead, and cannot be resurrected.
• Each starting configuration will be flipped and rotated so the right and bottom sides face the enemy.

For example, if your submission was:

And you plotted them against one another, the starting configuration could be:

Note how the bottom right isn't symmetrical, but still has the correct sides facing inwards.

Your submission should be a \$x/2\$ by \$x/2\$ GOL pattern that assumes it is in the top left corner.

Rounds will be run until only one competitor remains or the whole pattern repeats, where the competitor with the most cells when the pattern repeats is the winner.

Sandbox:

• I haven't decided yet what sizes the playing field should be (\$x\$), nor how long each game should run (\$n\$).
  • I was thinking about a 128 by 128 playing field, with 64 by 64 for each player. Is that too large or too small? For reference, the submission would be the size of: with some gliders and stuff for reference. Is that too many or too little? I haven't really got much reference.
• I am working on a visual controller like the Formic Functions question
• Overall winner? Check all combinations (way too much time as more submissions are added)? Tournament structure (multiple rounds per elimination)?