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

Check GenericScript source code for compiler errors

Given the source code for a GenericScript program as input, parse the source code to check that it conforms to the syntax rules for the language. The syntax definition for GenericScript is below. If a part of the source code is found to be invalid, the program should output "Invalid syntax", otherwise it should output "Valid syntax".

Win Criteria

This is code golf. Shortest code wins.

Syntax

Source code will be considered to be valid if it matches the rule for "Program" below.

Program             = Sequence
Sequence            = Statement [Sequence]
Statement           = SequenceBlock | Assignment | If | While | Output
SequenceBlock       = "{" Sequence "}"
Assignment          = Identifier "=" (String | Bool); 
If                  = "if(" Bool ")" Statement ["else" Statement]
While               = "while(" Bool ")" Statement
Output              = "print(" String ");"
Identifier          = {Any sequence of alphanumeric characters prefixed with "var" }
Bool                = StringEquals | Identifier
StringEquals        = String "==" String
String              = StringConstant | OperatorConcat | Input | Identifier
StringConstant      = "'"StringContent"'"
StringContent       = Character [StringContent]
Character           = {Any character except for "'"}
OperatorConcat      = String "&" String
Input               = "read()"

Whitespace is defined as any sequence of the ascii characters 9, 10, 13 and 32. Whitespace characters are allowed between tokens but are not required.

Rules

1. The answer should be a complete program
2. Standard input/output allowed
3. Standard loopholes apply
4. Universally testable answers only

Test Input

Valid syntax:

print('What is your name?');
varInput = read();
print('Hello ' & varInput);

Invalid syntax:

if(read() == 'DoTask1')
  print('Executing you'r command');

Answer 2

Text Adventure Game

Objective

Your goal is to develop a complete text-based adventure game with the shortest code possible. The player navigates in a dungeon composed of rooms. The game objectives are to find the treasure, slain the dragon and rescue the princess.

Rules

A room description is as follows:

You are in <description>.
You can go <exits>
You see <object>      (optional)

• exits can be "north", "east", "west", "south".
• description can be "a adjective cavern", "a adjective room", "a adjective corridor", "a adjective hall", "a cell", "the dragon's lair".
• adjective can be "dark", "murky", "small", "large", "narrow", "gloomy", "huge", "strange", "tiny", "broad", "old".
• object can be "the princess", "the dragon", "a troll", "a goblin", "a sword", "gold", "a key", "a trunk".

Exit list must be comma-separated and end with "and". If there is no object in the room, the last line is omitted.

Example of valid description:

You are in a murky room.
You can go north, east and south.
You see a goblin.

The game accepts the following commands (case is ignored) :

• GO direction : direction can be NORTH, EAST, WEST, SOUTH
• TAKE item : item can be SWORD, GOLD, KEY
• KILL monster : monster can be DRAGON, TROLL, GOBLIN. The DRAGON and the TROLL can be killed only if the user has the SWORD. If he hasn't, he loses the game. The weak GOBLIN can be killed with bare hands. When a monster dies, he disappears from the room. When the GOBLIN dies, he drops a SWORD. When the TROLL dies, he drops a KEY.
• KISS person : person can be PRINCESS, DRAGON, TROLL, GOBLIN. Kissing the princess validates one of the objective of the game, and the princess disappears from the room. Kissing a monster results in player death.
• OPEN object : object can be TRUNK. If the player has the KEY, the TRUNK object disappears and is replaced with GOLD.

OBJECTS
The player can perform an action on an object only if the object is in current room. A room can contain only one object ; a given object can be found in only one room. At the beginning of the game, only the following objects are placed in the map : PRINCESS, DRAGON, TROLL, GOBLIN, TRUNK. Other objects are not yet created.

ACTIONS

• If an action cannot be performed (e.g. GO NORTH where there is no exit to the north, or TAKE DRAGON, or DANCE GANGNAM STYLE), the message "Sorry, I can't do that" must be displayed.
• If an action can be performed, the message "OK" and the current room description should be displayed.
• You can read game commands from console or as a program parameter, as you wish.

MAP
The dungeon should have at least 30 rooms. The dungeon should not contains a series of more than 5 exits in the same direction. The exits between rooms must be consistent, e.g. if you go north from room #1 to room #2, there must a south exit in room #2 leading back to room #1. Every room name should be unique. There must be at least one room of each kind (hall, cavern, corridor...)

• A hall has at least 3 exits.
• A corridor can have only 2 exits.
• The cell has only one exit.
• There is only one dragon's lair and only one cell, containing respectively the dragon and the princess.

GAME END
The game ends when the player has been killed, or when he has taken the gold, slain the dragon and kissed the princess.

• If the player dies, the message "You have been killed by X !" is displayed, with X being the name of the monster.
• If the player wins, the message "Well done adventurer ! you've conquered the dungeon." is displayed.

Player should not be able to win the game in less than 40 turns.

Example

You are in a murky room.
You can go north, east and south.
You see a goblin.
> KILL GOBLIN
Ok.
You are in a murky room.
You can go north, east and south.
You see a sword.
> TAKE SWORD
Ok.
You are in a murky room.
You can go north, east and south.
> GO NORTH
Ok.
You are in a narrow corridor.
You can go south and east.  

Scoring

The shortest code wins.

Answer 3

Simulate a Quantum Circuit

Work-in-progress until I can make sure I know what I am doing and can finish the spec. code-golf or maybe advanced-code-golf

---

Quantum computers are the way of the future! Why wait, when you can simulate one now?

Your mission is to determine the output of a quantum circuit given its input and a diagram of logic gates.

Details

You will simulate a single quantum register and apply a series of quantum logic gates to it. A quantum register is a group of qubits. The state of a register is described by a vector of 2^N complex numbers, where N is the number of qubits in the register.

a|000>
b|001>
c|010>
d|011>
e|100>
f|101>
g|110>
h|111>

Above is a representation of a 3-qubit register. Each letter (a b c etc.) represents a complex number. There is an addition restriction that:

|a|^2 + |b|^2 + |c|^2 + |d|^2 + |e|^2 + |f|^2 + |g|^2 + |h|^2 = 1

Quantum gates

Gates are represented by a 2^N x 2^N square unitary matrix, where N is the number of input qubits. All quantum gates have the same number of outputs and inputs, since they neither create nor destroy qubits, they modify them.

A common quantum gate is called the Hadamard gate and acts on a single qubit. The matrix [H] looks like this:

1/Sqrt(2)  1/Sqrt(2)
1/Sqrt(2)  -1/Sqrt(2)

If we let [R] represent the following 1-qubit register:

0.6|0>
O.8|1>

Then the application of the gate is represented by [H][R] and gives the following result:

7*Sqrt(2)/10|0>
 -Sqrt(2)/10|1>

It is still true that the sum of the squares of the absolute values is equal to 1.

(TODO: explain how to apply gates to larger registers)

Measurement

Measurement collapses the state of the quantum register.

(Todo: Explain how measurement works)

Input

Output

Answer 4

BS

king-of-the-hill

The goal of this challenge is to implement an AI for the game of BS, also known as Bull Shit, Cheat, Bluff, and numerous other names.

The game is outlined in this wikipedia article.

The Rules of the Game

For the purposes of this challenge, the game will work like this:

1. A standard 52-card deck is dealt out to the players
2. The current rank is set to Ace
3. The play order is randomized
4. The player holding the Ace of Hearts goes first
5. On each player's turn:
   1. The current player plays some number of cards
   2. The current player states how many of what rank they played
   3. Other players may declare 'BS'.
   4. If any player declares 'BS':
      1. All players are notified of which players declared 'BS'.
      2. The played cards are revealed to all players.
      3. If the played cards are inconsistent with the current player's statement:
         • The current player adds the played cards and all cards in the pile to their hand
      4. If the played cards are consistant with the current player's statement:
         • The last player to declare 'BS' that round adds the played cards and pile to their hand.
   5. If no player declares 'BS':
      1. The played cards are added to the pile, without revealing them.
      2. If the played cards were inconsistant with the current player's statement, the current player may declare 'Peanut Butter'.
   6. If the current player has no cards in their hand, the current player wins.
   7. The current rank is incremented. (If the current rank is King, it becomes Ace.)

The Messaging Protocol

Play will be conducted via messages passed to the standard input and received from the standard output of each program. Each message will be terminated with a single newline character.

Cards

Card ranks are represented as one of A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, or K. Card suits will be represented as one of S, C, H, or D. Cards are represented as the rank, followed immediately by a suit. For instance, the Ten of Clubs would be represented by TC, and the Three of Hearts would be represented by 3H.

A hand of cards will be represented as a space-delimited sequence of cards. For instance, a hand containing the Queen of Spades and the Six of Diamonds could be represented as QS 6D or 6D QS.

Player Identification

A player will be represented by their nickname, followed by a number from 0 to 32768, in parenthesis, formatted as an integer. This number is guaranteed to be unique within a particular game. A player's nickname must have at least one character, can have up to 32 characters, and may only include letters, numbers, and underscores. For instance, a player with nickname ExampleAI and ID number 16480 would be identified in the game as ExampleAI(16480).

When the game begins, each program will recieve a message containing their unique ID:

Unique ID: uniqueID

Each player will reply with their desired nickname:

Nickname: name

Names may contain only alphanumeric characters and underscores.

After all players have responded with their nickname, the standard play sequence begins.

Standard Play Sequence

When a player's turn begins, each player will receive a be given a list of the players and their card counts, in order of play:

Players: player[count], player[count], ... player[count]

Each player will be informed of the contents of their hands:

Hand: initial_hand

The current the player will then receive this message:

Your turn: current_rank 

The current player will reply with a space-separated list of of cards:

Play: list_of_cards

Once they have submitted their play, all players will receive the number of cards, formatted as an integer, along with the current rank:

Player player plays: nunber_of_cards x current_rank

Each other player may then declare BS on that play by sending any message up to 32 characters, containing the capital letters B and S, and otherwise only contains lowercase letters and spaces. So any of Bull Shit, Bananna Split or Bacon Sandwich would be acceptable.

During this period, the current player may declare Peanut Butter by sending any message up to 32 characters, as long as it contains the capital letters P and B, and otherwise only contains lowercase letters and spaces. So any of Peanut Butter, Pancake Batter or Polish Bacon would be acceptable.

In order to allow the game to move faster, if a player does not wish to declare either of these things, they must instead send:

Pass

After all players have responded, all players will receive a list of players who called BS, in the order they called it:

Called BS: player, player ... player

If no player called BS, this message will still be sent --- it just won't have any players listed. If any player did call BS, then all players will recieve:

Player player had played: list_of_cards

If they were bluffing, all players recieve:

Player player was bluffing.

And the current player receives:

Your bluff was called: list_of_cards_recieved

If they were not bluffing, all players recieve:

Player player was not bluffing.

Player last_player receives the pile.

The last player who called BS recieves this message:

You misjudged: list_of_cards_received

The list of cards received will contain, in reverse chronological order, the contents of each play since the last call. (Separate plays will not be delimited in the list.)

If no player declared BS, and the current player was bluffing and declared Peanut Butter, then all players recieve the message:

Player player was bluffing.

If the current player has no cards left in their hand, all players receive this message, and the game terminates:

Player player won!

Otherwise, the next player's turn begins.

---

Example Game

The following might be considered a typical (abbreviated) message transcript:

Unique ID: 16481
> Nickname: Alice
Players: Alice(16481)[18], Bob(16479)[17], Charlie(16480)[17]
Hand: 2D 7S AS TC 5S JS JC 3C 8H 9D 5D AH 7C 6C 4D KC KH KS
Your turn: A
> Play: AS 2D AH
Player Alice(16481) plays: 3 x A
> PB
Called BS:
Player Alice(16481) was bluffing.
Players: Bob(16479)[17], Charlie(16480)[17], Alice(16481)[15]
Hand: 7S TC 5S JS JC 3C 8H 9D 5D 7C 6C 4D KC KH KS
Player Bob(16479) plays: 2 x 2
> BS
Called BS: Alice(16481)
Player Bob(16479) had played: 2H 2C
Player Bob(16479) was not bluffing.
Player Alice(16481) takes the pile.
You misjudged: 2H 2C AS 2D AH
Players: Charlie(16480)[17], Alice(16481)[20], Bob(16479)[15]
Hand: 7S TC 5S JS JC 3C 8H 9D 5D 7C 6C 4D KC KH KS 2H 2C AS 2D AH
 .
 .
 .
Players: Alice(16481)[3], Bob(16479)[41], Charlie(16480)[8]
Hand: KC KH KS
Your turn: K
> Play: KC KH KS
Called BS: Charlie(16480), Bob(16479)
Player Alice(16481) was not bluffing.
Player Bob(16479) receives the pile.
Player Alice(16481) won!

Your implementation may be written in any language, provided that you, upon request, provide a link to a suitable free-as-in-freedom compiler or interpreter that I can download and run at no cost. You also need to provide a UNIX command that can start your program.

Sandbox Questions

I want to gauge the community's interest in my problem before finalizing the spec and writing the control program.

I also need to get some idea of what sort of time-limiting scheme would be reasonable. In order to be able to to a lot of runs, I will need to be able to ensure that each AI doesn't take too much time to make its decisions, or prevent a stuck AI from holding up a game. I also need to be able to ensure that there is no motivation to deliberately stall a game. For example, if an AI determines that it is very unlikely to win, it might stall in order to prevent the game from finishing.

I would also like feedback on the messaging protocol:

• Are there any additional messages that you think should be passed?
• Would it be more convenient/clear if one or more of them were formatted differently?
  • Would it be better to use a different format for the plays message?
  • Would it be better to use different words to help distinguish the plays and played messages?

Answer 5

Turn my keyboard into a piano code-golf music

I'm sure we've all thought "man, wouldn't it be cool if my keyboard played musical notes as I program?". Of course, the answer to that question is a resounding no.

Regardless, it's what you're going to make.

Input

Input will be given, in real-time, on the keyboard.

The keyboard mapping that you will use is given in the diagram below. This kind of layout is used by several music programs already.

You can see that the bottom row (Z, X, C, V, B... ., /) represents all of the white keys, and the black keys are added on the row above (S, D, G, H, J... L, ;). This is then repeated on the two rows above, except the notes are an octave higher.

The notes C5 to E5 are repeated both on the lower rows and the upper rows.

So, if the user were to input Q (or ,) on the keyboard, middle-C (C5) should play. Similarly, if they input B, G4 should play.

^{The diagram above is an edited form of an image found here.}

Output

The only output will be sound. The actual sound used is up to you (it could be a piano sample or the internal beeper), but it should output sound at the correct pitch.

The program should not terminate by itself - the user should be able to keep inputting notes until they get bored.

References

• A diagram of the US keyboard layout (for comparison with the image above) can be found here.
• A table of the frequencies of notes can be found here. The range of notes that you will be using are from C4 to E6, inclusive.

Rules and Disambiguation

• This is code-golf, so the shortest correct implementation wins.
• Input should be given in real-time (i.e. no pressing Enter between each inputted note).
  • There should be no greater than a 0.25 second delay between pressing a key and hearing the note.
• Only programs that have the notes correctly mapped to the QWERTY keyboard will be accepted.
• The only output should be sound. There should be nothing displayed (except for a mandatory console window or similar).
• Polyphony (multiple notes playing at once) is not part of the specification.
• The program should not terminate by itself - a user should be able to keep pressing keys and hearing notes until they decide to close it.
• The waveform outputted is not important (it can be a beep or a piano sound or whatever you like); the pitch, however, should be accurate.
  • The file size of any sound files used will not be counted in the bytecount.
  • Please link any sound files you use with your answer.

Meta

• There are probably some obvious things that I've forgot to explain - please point these out!
• Also let me know if any of the wording is confusing.
• I've assumed that the readers will at least know very basic music theory (e.g. that there are 12 semitones in an octave). Is this okay?
• "Polyphony is not part of the specification" - polyphony is not the focus of the program, and therefore shouldn't be a consideration when submitting answers (i.e. if the shortest implementation means that one note will stop when a new note is played, then that's fine). Is this acceptable?
• Should I exclude the use of any external libraries that are designed to play sound or designed to repeat a function at regular intervals? Should I count sound file size in the score? I'm worried that having either of these would limit the possible entries to those that can use the internal beep (so, C/C++, C#, Python, Java?...).
• Another problem may be portability, or the lack thereof (e.g. C/C++ using the Windows API to access the Beep() function).

_{Really meta: answers/edits by me won't be done until the morning (approximately 9 hours from now).}

Answer 6

Let's talk about this...

I am planning on hosting a King of the Hill challenge in which bots will have to coordinate each other in order to be successful. The idea is to play a Diplomacy-like game between bots. The engine (still in development) will start the bots and communicate with them via stdin/stdout. There will be three phases:

0. Initialization

Well, this is not a recurring phase, it is just the engine telling each bot his id, the total number of bots participating and a seed, which can be used for generation of pseudo-random numbers (bots need to be deterministic).

1. Talking Phase (10s)

In the Talking phase, bots can send messages to each other (via engine) in order to coordinate their actions. To this end, a common language is necessary. This language should be able to express any ideas, plans and opinions a bot could have. However, not every bot is forced to be able to understand everything. Simpler bots might just ignore messages they do not understand.

Since I would like each player to be able to submit more than one bot, it is forbidden to implement a "secret handshake" by which bots recognize each other and from then on work together unconditionally.

2. Planning Phase (2s)

In this phase, bots submit what they want to do this turn. Each bot has a certain amount of supply (initially five), and can command one action per supply point. There are three possible actions:

1. Attack another bot
2. Support another bot's attack against a third bot
3. Defend another bot

There are some restrictions:

• Per opponent, you can either attack or defend them, and only once
• You cannot support an attack against a bot you also defend
• You cannot attack, defend, support yourself or a dead bot, and neither can you support attacks against yourself

3. Resolution Phase (as short as possible)

After all orders have been submitted, the engine will resolve them simultaneously in the following way:

The defending strength of each bot is the number of bots defending that bot. The attacking strength of each attack is the number of support orders for that attack. Each attack with an attacking strength greater than the defending strength of the attacked bot results in the supply counter of the attacked bot being reduced by one, and the supply counter of the attacker being increased by one.

Support orders which support a non-existent attack do nothing.

Then, all bots with supply of zero or less will be shut down by the engine: they died.

Afterwards, all remaining bots are informed about the decisions of other bots, and a new turn begins with its Talking Phase.

Further Rules

A game will consist of ten plus random number turns, so that "last turn betrayals" are not possible. The supply count of each bot will count towards their total score. I plan an ensemble of about 100 games. The bot with the highest total score wins. Tie-breaker will be the popularity (number of votes).

I am interested in your opinion: do you think that this challenge is too complex? I imagine that the code of a decent bot would be too long to fit in a post. So people would have to use github or pastebin or similar to submit their entries. The main problem imo is the interpretation of the (yet to be determined) common language.

Answer 7

Happy Holidays!

Introduction

With the holidays upon us, I decided to make an appropriately themed challenge. You are provided with a list of holidays and their respective date ranges, and given a date, you have to output a holiday greeting or the time remaining until the next holiday as appropriate.

Challenge

The list of holidays is below. You have to include it in your program (so no using a library or other external resource for this). Feel free to use any convenient format.

Start  | End    | Name
------ | ------ | -------------------
Dec 6  | Dec 7  | Saint Nicholas' Day
Dec 13 | Dec 14 | Saint Lucy's Day
Dec 24 | Dec 27 | Christmas
Jan 1  | Jan 2  | New Year
Jan 6  | Jan 7  | Epiphany
Feb 14 | Feb 15 | Valentine's Day

You are given a date as input (STDIN, function argument, or anything convenient) in YYYY-mm-dd HH:MM:SS format (e.g.: 2014-12-30 11:15:00).

You may assume that the time zone is either UTC or the system's time zone. The holiday lasts from 00:00:00 on the start date (inclusive) to 00:00:00 on the end date (exclusive).

If the date falls within the range of the holiday, you must output Happy <holiday>!, except if it's Christmas, in which case you must output Merry Christmas!.

If it doesn't, but another holiday is coming at most a week in the future, you must output:

<time> left until <holiday>.

where <time> is in the following format:

<days>d <hours>h <minutes>m <seconds>s

You can't use a library for converting the time to that format.

If there are no whole days, hours, minutes or seconds remaining, omit the number entirely. For example, 1d 0h 3m 4s should be printed as 1d 3m 4s.

If there are no upcoming holidays, you must output (no pun intended):

There are no upcoming holidays.

A trailing newline is optional, but be consistent in your program—don't add a trailing newline in one case and omit it in another.

Standard loopholes are obviously forbidden.

Test cases

Date                | Output
------------------- | ----------------------------------
2014-12-05 23:59:59 | 1s left until Saint Nicholas' Day.
2014-12-06 00:00:00 | Happy Saint Nicholas' Day!
2014-12-06 12:00:00 | Happy Saint Nicholas' Day!
2014-12-06 23:59:59 | Happy Saint Nicholas' Day!
2014-12-07 00:00:00 | 6d left until Saint Lucy's Day.
2014-12-14 00:00:00 | There are no upcoming holidays.
2014-12-24 00:00:00 | Merry Christmas!

Note that your program must work for any year, not just 2014.

Winner

This is code golf, so the submission with the fewest number of bytes wins. An answer will be accepted after a week, but I'll be happy to change the accepted answer if a new valid submission beats the previous high score.

---

code-golf date

Answer 8

Find the Minimum Width of a Set of Points

code-golfgeometrytime-complexity

Given a set of points in 2D space, you're to find the direction along which those points occupy the shortest width.

More formally, consider a set of n points P = {p₁, ..., p_n}, where p_i = (x_i,y_i), and a unit vector d = (x_d, y_d). Now K is the set of lengths obtained from orthogonal projection of P onto d. In particular, k_i = x_ix_d + y_iy_d. The width L of P along d is defined as max k_i - min k_i. Your task is to find the d along which L is minimal.

To keep things interesting, your algorithm's time complexity must not exceed O(n log n).

You may write a program or function, taking input via STDIN, command-line argument or function argument. The result may be printed to STDOUT or returned.

You can expect the input P to be in any convenient list or string format, but the input must not be pre-processed (e.g. sorted by coordinates). You may assume that the input contains at least 2 points and that no two points coincide.

The output must be correct to 10 significant (decimal) digits. Of course, d is only unique up to the relative sign of the coordinates, so there are two correct answers for each input. You may return either of those.

You must not use built-in functions related to this problem, like finding the minimum width of a polygon, or computing the convex hull of a set of points. You may use built-in vector/matrix types and operations.

Sandbox Notes

• I'll write my own solution at some point next week, and use it to provide a number of test cases.
• I'm also planning to add a handful of diagrams to clarify the definitions.
• The challenge was inspired by this proposal from Calvin's Hobbies, I think they are sufficiently different, as this problem here is only one approach to tackling his challenge (and even then it's only a subproblem). But if people think, they are too similar, and posting this one would make his a duplicate in the future, I'll retract this challenge (as I'd really like to see his posted some time).

Answer 9

The Genetic Game of Life

In this game, you play as cells (as in cellular automata). Your goal is to reproduce and kill off other cells on the board.

At the beginning of the game, two distinct configurations will be randomly chosen, one for reproduction, one for killing. The configurations will consist of 3 squares in a 5 by 5 area, not including the center square. For example,

OOXOX
OOOOO
OO OO
OOOXO
OOOOO

is an example configuration, where X represents a cell, and O can either be empty or filled. The configurations do not work if rotated.

The cells will be placed randomly, but equidistant from each other in a toroidal board. Cells will be placed in a random turn order.

Each turn, each cell will move a square one at a time. If a cell's movement creates the reproduction configuration with cells of the same type, and the center square is empty, then a new cell will spawn. If a cell's movement creates the killing configuration with cells of any type, and the center square is filled, then the cell in the center square will die.

When a new cell spawns, its DNA will be conglomeration of the DNA of the bots in the configuration. It will take its first turn after all other cells have taken 1 turn.

A cell that has not been part of a killing configuration after 200 turns will die.

The cell type with the most cells after 100K turns wins.

IO

Each turn, you will be passed a string of 1s and 0s representing your DNA, and a list of 49 integers representing a 7x7 grid of the vision around the cell. Specimens of the same type will have the same integer, and 0 will represent an empty square.

You must return a single character (N, E, S, W or X) representing the direction that the cell will travel. Attempting to move into another cell will result in your cell not moving.

Answer 10

Convert a Finite State Machine to a Regular Expression

Anyone can make a finite state machine for matching a regular expression. But what about a regular expression that emulates a finite state machine? This inverse operation is much more confusing.

Input

• A positive integer N, denoting the number of states in the machine. They are labeled 0 to N - 1.
• A list of accepting states of the machine. A string is considered to be accepted by the machine if it ends in one of these when there are no characters left.
• A list of triples (integer a, character b, integer c) representing the transition rules: when the machine is at state a and the current character in the string is b, then it may advance one character and move to state c.

You may specify the ordering and formatting of input.

Output

A regular expression that matches a string iff it is accepted by the finite state machine.

Additional Rules

• An input for the state machine may contain only printable ASCII characters which are not in the set ^$()[]|+?*\..

• The machine begins in state 0.

• You should not use any regex features other than |, (), ?, *, +

• You may not use libraries designed for this task (which apparently exist).

• The regex should match full strings (assume it is surrounded by ^ and $).

• An answer is either a program which prints the regex to stdout, or a function which returns the regex.

This is code golf: write your code in as few bytes as possible.

Sandbox Question

Should the FSM be deterministic or non?

Answer 11

ASCII Robot Wars

This idea is based off of the game "Besiege" (which I've never played) and a previous sandboxed idea of mine called "Epic Customizable Tank Battle."

The main idea is that your program is the AI that controls a robot equipped with various weapons. In this challenge, however, you will also have the opportunity to design your robot

List of Parts

(completely arbitrary and subject to total replacement)

• Wooden planks + and armored metal plates # make up the body of the robot.
• Wheels @ allow your robot to move. TODO - turning
• Most weapons are formed with two parts, a body and a pointer v^<> to denote the direction of aim.
• Cannons have a body of %, ballistas have a body of (something), spikes and battering rams are (something).
• Maybe helicopter blades can be X.
• Banners, which serve no purpose but decoration, could be $.

Example 5x5 robot

This robot has four wheels, three cannons facing forward, armored sides, and a flag in the middle.

@^^^@
#%%%#
#+$+#
#+++#
@###@

Controlling the Bot

I think this would make a really cool Stack-Snippet KOTH, since it is "visually interesting" to watch robots blow each other into pieces. Writing the controller will be hard because this is a major deviation from previous pixel-based KOTHs.

Answer 12

Sorting Source Code code-golfquine

Your task in this challenge is to write a program that takes no input and outputs This program consists of followed by your program's source code characters, but in alphabetical order.

Details

• You may only use printable ASCII characters and line breaks in your program.
• When outputting all source code characters, ignore line breaks and sort all characters by their ASCII number from lowest to highest.
• Reading your program's source code is not allowed.
• This is code-golf, so the shortest valid submission (in bytes) wins.

Here is a correctly ordered list of all printable ASCII characters (mind the space at the very beginning):

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

Example

If the source code for your program is

print 'This program consists of ';
print this.sort();

then output must be

This program consists of       ''().;;Tacfghhiiiiimnnnooooppprrrrrssssssttttt

Answer 13

Strange question about transit schematics (title tbd)

graphical-output popularity-contest

In this challenge, your goal is to produce a schematic diagram of a transit network, given a list of lines and a list of stations as input. This is a popularity-contest -- the program's goal is to maximize the readability of the diagram by carefully choosing where to draw the stations and lines.

Each line in the transit network is formatted as a list of strings. For instance:

"Peel Line", "Douglas", "Port Erin", "Braddan Halt", "Union Mill", "Crosby"

The first string on the list is the name of the line. The remaining strings are the stations that that particular line stops at. In this example the Peel Line stops at Douglas, Port Erin, Braddan Halt, Union Mill, and terminates at Crosby. The lines are bidirectional so the Peel Line would also go back the other way.

Of course, most transit networks will have more than one line. Each line of the transit network will have its own line in the input. For instance:

"Peel Line", "Douglas", "Port Erin", "Braddan Halt", "Union Mill", "Crosby"
"Foxdale Line", "Ramsey", "St. John's", "Union Mill", "Bishop", "Foxdale"

Notice how both lines stop at Union Mill. This means that Union Mill is an interchange station for those two lines. A station is an interchange station if more than one line stops at it. Here is an attempt at what the network might look like:

This map does some things well but fails at other things. The lines are coloured different colours which helps differentiate the lines. In addition, the interchange station is emphasised with the white dot to show it is an interchange station. However, it fails at other things, the most prominent being that the text "Union Mill" is overlapping the line, and there is a lack of a key showing which line is which. When we fix these elements the map looks like this:

Much better! (Another way I could have resolved the Union Mill overlapping issue was to change the paths of the lines.) In addition, we can also have lines being a loop. This is indicated by the first and last train stations being the same. For instance:

"Island Line", "Port Erin", "Kitterland", "Kalfr", "Ardglass", "Kearney", "Port Erin"

The Island Line in this case is a loop that goes from Port Erin to Kitterland to Kalfr, then to Ardglass and Kearney, before finally returning to Port Erin, completing the loop.

With more complicated train networks, it becomes more difficult to arrange the stations and lines in a readable manner. Here are some inputs of varying complexity and density to try your program on. Some of them are based of actual networks, while others are made up for this challenge.

Challenge Input 1: Oslo, Norway:

"1", "Frognerseteren", "Voksenkollen", "Lillevann", "Skogen", "Voksenlia", "Holmenkollen", "Besserud", "Midtstuen", "Skådalen", "Vettakollen", "Gulleråsen", "Gråkammen", "Slemdal", "Ris", "Gaustad", "Vinderen", "Steinerud", "Frøen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Hellerud", "Tveita", "Haugerud", "Trosterud", "Lindeberg", "Furuset", "Ellingsrudåsen"
"2", "Østerås", "Lijordet", "Eiksmarka", "Ekravein", "Røa", "Hovseter", "Holmen", "Makrellbekken", "Smestad", "Borgen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Hellerud", "Tveita", "Haugerud", "Trosterud", "Lindeberg", "Furuset", "Ellingsrudåsen"
"3", "Mortensrud", "Skullerud", "Bogerud", "Bøler", "Ulsrud", "Oppsal", "Skøyenåsen", "Godlia", "Hellerud", "Brynseng", "Helsfyr", "Ensjø", "Tøyen", "Grønland", "Jernbanetorget (Oslo S)", "Stortinget", "Nationaltheatret", "Majorstuen", "Blindern", "Forskningsparken", "Ullevål stadion", "Berg", "Tåsen", "Østhorn", "Holstein", "Kringsjå", "Sognsvann"
"4", "Storo", "Nydalen", "Ullevål stadion", "Forskningsparken", "Blindern", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Ensjø", "Helsfyr", "Brynseng", "Høyenhall", "Manglerud", "Ryen", "Brattlikollen", "Karlsrud", "Lambertseter", "Munkelia", "Bergkrystallen"
"5", "Storo", "Nydalen", "Ullevål stadion", "Forskningsparken", "Blindern", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Carl Berners plass", "Hasle", "Økern", "Risløkka", "Vollebekk", "Linderud", "Veitvet", "Rødtvet", "Kalbakken", "Ammerud", "Grorud", "Romsås", "Rommen", "Stovner", "Vestli"
"6", "Bekkestua", "Ringstabekk", "Jar", "Bjørnsletta", "Åsjordet", "Ullernåsen", "Montebello", "Smestad", "Borgen", "Majorstuen", "Nationaltheatret", "Stortinget", "Jernbanetorget (Oslo S)", "Grønland", "Tøyen", "Carl Berners plass", "Sinsen", "Storo"

Here's what the official map looks like for some inspiration (click to enlarge):

TODO: more challenge inputs coming!

Sandbox Notes

• I've had this one sitting around for a while. I've wanted to try and make a popularity-contest graphical-output that wasn't just about making the prettiest image. So instead it's about making the most functional image, which I'm not sure is any better than the art challenges...
• Another thing I've been considering is changing it to a code-golf. I'd have minimum requirements for the final output (a key, coloured lines, distinguished interchange stations, etc.) and the shortest code that implemented all the requirements would win. I'd like your thoughts on whether this challenge would work better as code golf or popularity contest.

Answer 14

Permutations of the Fifteen Puzzle

POSTED

Answer 15

How to Gossip Appropriately

We all know how important it is to get social arrangements right:

You have a group of friends who love to gossip. However, gossip is notorious for changing as it gets spread from friend to friend, and if somebody hears two versions of the same gossip, it just ruins it for them.

Hence, you and all of your friends have agreed to gossip in an orderly manner, and it is your job to define who will gossip with who and for how long. Ideal gossiping must follow the following rules:

1. Each friend must gossip for a specific amount of time. This time is different for each person.

2. Any pair of friends will only spend so long gossiping. Any longer, and it will become dull. We will refer to this time as L. This time is the same for all friends.

3. Gossipping only comes in minute increments. We have no idea why this is, but its true.

4. Gossip must eventually reach everybody. If any given friend has new gossip, then all of your friends must eventually get that gossip.

5. Proper gossipping never includes circles. If A gossips to B and C, and then B gossips to C, then C will hear the news from two different people, and therefore, two different stories.

As an example say you are given the following as input:

Let's start by looking at B. She prefers to gossip for only 1 minute, so she will only be able to gossip with one friend.

We know that she can't gossip with D, as that breaks rule #4

If we have B gossip with C, then C will have 1 minute of gossipping left, and A won't be able to fill his 2 minutes of gossipping needs.

Therefore, we know that B must gossip with A for 1 minute, and A must gossip for 1 minute with C. C and D each have 1 minute of gossipping remaining, so they must both gossip with E.

E needs 2 more minutes of gossip.

If E gossips with F for 2 minutes, then gossip can't ever reach G.

If E gossips with F for 1 minute and G for 1 minute, then F must gossip with H for 1 minute, and H will then gossip with G for 2 minutes. This will create a circle, breaking rule #5.

Therefore, we know that E gossips with G for 2 minutes, G gossips with H for 1 minute, and H gossips with F for 2 minutes.

Our final gossipping tree looks like:

---

Input will be in the following format, and will be passed to your program via STDIN (or closest alternative):

Max_Gossip_Time [Node0_Ideal_Gossip_Time, Node1_Ideal_Gossip_Time, ...] [[Node0, Node1], [Node0, Node1], ...]

The second array passed is the friend list, and are integers that refer to the positions in Ideal_Gossip_Time array.

The example above would be input as follows:

2 [2, 1, 2, 1, 4, 2, 3, 3] [[0, 1], [0, 2], [1, 2], [1, 3], [2, 3], [2, 4], [3, 4], [4, 5], [4, 6], [5, 7], [6, 7]]

Output should be to STDIO (or closest alternative) in the following format:

[[Node0, Node1, Gossip_Time], [Node0, Node2, Gossip_Time], ...]

On the above example, the output should be similar to:

[[0, 1, 1], [0, 2, 1], [2, 4, 1], [3, 4, 1], [4, 6, 2], [5, 7, 2], [6, 7, 1]]

On both input and output, the friend list can be in any order.

Answer 16

If it floats, it boats!

code-golf

The goal of this challenge is to determine whether or not an ASCII-art shape will float. Like any other boat, ASCII boats obey the law of buoyancy: it will float if it displaces an equal mass of water.

ASCII boats are made out of O characters arranged in some contiguous shape (diagonals are connected). There may be trailing spaces, but the whole input is a rectangle (trailing newline optional). Example boat:

   O         O    
    O        O    
     OOOOOOOOO    

The material of the boat has twice the density of water. When a boat is floating, the number of displaced water characters is at least twice number of O character in the boat. Here is an artist's impression of a boat while floating.

   O         O    
~~~~O        O~~~~
~~~~~OOOOOOOOO~~~~
~~~~~~~~~~~~~~~~~~

This boat has 13 O characters, but displaces 19 water characters, so it floats.

The key to floating is the creation of an air pocket. Air pockets can be formed in two ways: either the water cannot reach the pocket (because the boat has walls keeping it out), or air is trapped in the pocket and cannot escape. Here's an example of a capsized boat which can still float (warning: do not attempt at home).

     OOOOOOOOO
~~~~O        O~~~~
~~~O         O~~~~
~~~~~~~~~~~~~~~~~~

The following shapes aren't boats because they can't float:

OOO
O  
O  
O  
OOO

   O         O    
    O        O    
     OOOOOOOOO    
             O    
         OOOOOOOOO
         OOOOOOOOO
         OOOOOOOOO

The Goal

Write a program that, when given an ASCII-art shape, outputs a truthy value if it boats, and a falsey value if it doesn't boat. This is code golf, fewest bytes wins.

Answer 17

Multiples - a wrap battle

king-of-the-hill

---

Overview

Change cells in multiples to wipe out your opponent, while avoiding being wiped out yourself.

---

This is a 2 player game, played on a linear string of cells of length L that wrap in a loop. Counting along the loop eventually brings you back to where you started (after L steps). L will be fixed across all battles, and will be a reasonably large prime.

Each cell is controlled by player 1, player 2, or is neutral. These will be indicated as 1, 2 and 0 respectively.

Starting position

Player 2 starts with a cell at position 0 (since all are equivalent).

Player 1 starts with a randomly chosen cell from 1 to floor(L/2).

Player 1 moves first, reflecting the fact that player 1 has further to go to catch player 2.

Taking a turn

Each player begins with a stockpile of 0, and at the start of each turn the player's stockpile is increased by the number of cells that they currently control. The player then takes their turn. They choose any cell they control and specify a number N, which can be any non-negative integer up to and including the size of the stockpile. The stockpile is reduced by this number, and N loop cells are affected as follows:

Starting with the chosen cell as cell 0, each of the cells N, 2N, 3N, ... N*N are changed.

• Choosing 0 means nothing happens, at zero cost.
• Choosing 1 means the cell immediately after the chosen cell is changed, at a cost of 1.
• Choosing 2 means the cell 2 cells on and the cell 4 cells on are changed, at a cost of 2.
• Choosing 3 means the cells 3, 6 and 9 cells on are changed, at a cost of 3.
• In general, choosing N changes N cells at a cost of N.

When a cell is changed it follows the following rules:

• A neutral cell becomes the player's.
• An enemy cell becomes neutral.
• A cell already owned by the player becomes the enemy's

Large N

I expect most moves will choose N considerably smaller, but saving up would allow choosing N considerably larger than L in theory.

Choosing N=L means that all of the changed cells will be the same - the chosen cell, and it will be changed L times.

Choosing N=L-1 means that the L-1 consecutive cells before the chosen cell will all be changed (that is, every cell except the chosen one will be changed).

Winning

If a move leaves no enemy cells remaining, that player wins.

After 1000 moves any player who has more cells than their enemy at the start of 2 consecutive turns in a row (one theirs, one their enemy's, in either order) wins.

After 2000 moves the game is a draw (tie).

---

Input and output

Input

At the start of a game the player's code will be called with a command line argument of 1 or 2 indicating which player they are (player 1 moves first and is represented by 1s in the loop string).

Each turn the player will be supplied with:

• A string of 0s, 1s and 2s representing the loop.
• An integer S representing the size of their stockpile.
• An integer R representing the size of their opponent's stockpile.
• An integer representing the number of turns taken so far (this will always be an even number for player 1).

Output

The player should output 2 integers:

• The cell C to play from, in the range 0 <= C < L.
• The number of cells to change N, in the range 0 <= N <= S (their current stockpile size).

---

Sandbox questions

• I like the idea of this being a 1 dimensional game, but I can also see it working on a 2d grid, where each move is applied both horizontally and vertically (either on a square L by L, or with 2 distinct large primes as side lengths). Does anyone have anything for or against either 1d or 2d?

• Any recommendations on what input to provide? I was thinking at least the values of all the cells, but would a history also be good, or better to make the players decide what history to track for themselves rather than providing it? Alternatively they could be memoryless and decide purely based on the current cell formation.

• Is the random starting position a good idea? Would it be better to fix the starting position at floor(L/2), ensuring this number is prime, and let the players taking turns to be player 1 balance out any bias?

Answer 18

Help Indiana Jones and his crew cross the bridge!

This codegolf will solve the Bridge and Torch problem. In this problem, there are multiple people (I'm thinking four) who must all cross a weak bridge to escape an evil dragon as quickly as possible. Because the bridge is weak, only two people can cross the bridge at a time. The whole crew is armed with one torch, which is necessary for 1 or 2 people to cross the bridge. Furthermore, each person takes a certain, integral amount of time to cross the bridge. When two people cross together, they must run at the rate of the slower person. The whole crew needs to quickly figure out how to get all the people across the bridge in the least amount of time to maximize their chances of survival.

Input A list of names of the crew (one word, a-zA-Z) and how long they take to cross the bridge alone.

Output An explanation of who crosses the bridge in which order so that the total time is minimized, and the total time.

Example Input: Indiana 5 Jones 10

Output:

Indiana, Jones 10

Input: A 1 B 2 C 5 D 8

Output:

A, B A C, D B A, B 15

I'm thinking of either just solving this problem with any number of people, or another version in which anyone not at the end (ie. on the first side or on the bridge) after the time limit dies, and the goal is to minimize the number of deaths.

Answer 19

Bad Lip Reading Generator

A malapropism is the substitution of one word for another that sounds similar, often as a way to make something sound unintentionally humorous. For example, "He's a wolf in cheap clothing" is a malapropism, since the expected word, "sheep's", got replaced by "cheap", which sounds similar but means something different.

A modern version of malapropism is to take scenes from movies and redub the dialog with different words that match the actors mouth movements as a parody. There is a YouTube channel called "Bad Lip Reading" that uses this technique.

I would like to apply the process to some old videos with subtitle files, then watch the videos with the sound turned down to turn it into a long series of malapropisms.

Using mouth movements gives a more flexible range of malapropism so there is some flexibility between different sounds.

Challenge

Create a malapropism generator. I want to be able to feed text from subtitles into the generator and have text which is different, but still matches the mouth movements of the actors.

Input

A string of English words, (already processed to remove punctuation and forced to uppercase).

Output

A string of English words, (same format as input).

Notes

To simplify the challenge, all input words are in upper case, separated by whitespace, with all punctuation except apostrophes removed.

Lets agree to constraint what words "sound like", to be based on the CMUDICT. You may scrub the data so you don't have to worry about comments or special punctuation entries and remove stress numbers.

Lets also agree on the mouth-movements associated with the sounds, called "visemes". Here is a mapping used by Microsoft's SAPI library, which is itself based on Disney animation rules. Microsoft uses the same set of phonemes from ARPABet as CMUDict data.

#   ARPAbet Phoneme

1   AE AH
2   AA
3   AO
4   EH EY UH
5   ER
6   IH IY Y
7   UW W
8   OW
9   AW
10  OY
11  AY
12  HH
13  R
14  L
15  S  Z
16  CH JH SH ZH
17  DH TH
18  F  V
19  D  N  T
20  G  K  NG
21  B  M  P

You should be able to take each English word, convert to a set of phonemes, then to a set of visemes, then produce a list of words with matching visemes and randomly select one of the other words from the list. If a word doesn't match, or doesn't have any alternative, the original word should be copied to output.

Examples

• "HELLO WORLD" "HALLOW WHIRLED"
• "I SEE DEAD PEOPLE" "EYE SEA TED PEOPLE"
• "I WILL BE BACK" "EYE WHEEL PEA BAG"
• "IT WAS BEAUTY KILLED THE BEAST" "INN WAS PUNY GILT THE MIST"
• "MAY THE FORCE BE WITH YOU" "MAY THE FOURS BEE WITH YEW"

Test Cases

Since the words are random, I have selected some pairs of words with unique pronunciation. Your function or program should always return one word when presented with the other:

Input            Output
"AMUSING"        "ABUSING"
"APOGEE"         "APACHE"
"BACKDATING"     "MAGNETIC"
"BALLOONING"     "POLLUTING"
"INVISIBLE"      "INFEASIBLE"
"LAMPS"          "LUMPS"
"SCORN"          "SCORED"
"WEPT"           "WEBBED"

Rules

• You can write a full program or function.
• Input should be taken from stdin or function parameters. Output should be printed through stdout or returned.

Scoring

This is [code-golf]. Submission with least number of bytes, (not including data file(s)) wins.

Answer 20

Cake

---

Concerns:

• I'm not sure how well single language questions do. It automatically limits the question to those that already know the language, and those that are willing to learn just for this question. There's no need to limit to Chef with some of the magic this community can produce!

• "selfish/demanding" sounds quite strong and could sound like a bit of a personal attack on Beta Decay. It certainly isn't intended like that, and I expect it will be accepted as intended, but is it better to err on the side of caution?

Answer 21

Source code ecological footprint

You've just been hired by a German car manufacturing company. Your first task, as an engineer, is to write a program that computes the ecological footprint of source code.

The ecological footprint of a character is computed as follows (you can assume the source code is ASCII-encoded):

Write the character's ASCII code in binary, and count the number of 1's.

For example, A has a footprint of 2, but O is dirtier with a footprint of 5.

The global footprint of a program is the sum of the footprints of its characters.

Your program must accept a string as parameter, compute its ecological footprint, and output it.

There is a subtlety though. As you wish to enter a new, more restrictive market, you need to tune your program so that it behaves differently in "test mode". Thus:

The program should output 0 when it receives the string test as parameter.

Scoring

The source code with the smaller ecological footprint wins (and yes, the answer test is forbidden!)

Answer 22

Group Students Into Pairs

code-golf graphs

Synopsis: A graph theory matching problem. Given a list of which students like and dislike each other, pair the students up to maximise the overal happiness of the classroom.

Introduction

If you've ever been a teacher before, you've likely encountered the extremely frustrating experience that is getting students to do pair work. More often than not no one is happy with their partner, and the mood of the classroom suffers.

In this challenge, we're going to solve the enduring problem of pair work in classrooms. Here's how our system will work:

1. Each student shall write down what students they are happy to work with, and which ones they are not happy to work with.
2. We will take those lists, and generate student pairs such that the total happiness of the classroom is at its maximum.
3. The students are now (mostly) happy!

So how is the happiness of the classroom calculated? For each student in each pair of students:

• If a student's partner is in their "happy to work with" list, increase the happiness of the classroom by 1.
• If a student's partner is in their "not happy to work with" list, decrease the happiness of the classroom by 1.
• If a student is neutral towards their partner (not in either list), the happiness of the classroom does not change.

Here's a useful table that summarises the possible changes in the happiness with each pair of students:

+-------------------+-------------------+--------------------+
| Student 1 Feeling | Student 2 Feeling | Happiness Modifier |
+-------------------+-------------------+--------------------+
| Happy!            | Happy!            | +2                 |
| Happy!            | Neutral           | +1                 |
| Happy!            | Not happy...      | 0                  |
| Neutral           | Happy!            | +1                 |
| Neutral           | Neutral           | 0                  |
| Neutral           | Not happy...      | -1                 |
| Not happy...      | Happy!            | 0                  |
| Not happy...      | Neutral           | -1                 |
| Not happy...      | Not happy...      | -2                 |
+-------------------+-------------------+--------------------+

Input

First line of input is a positive integer n indicating the number of students to match up. n is always even. Following that are n lines, each line which has the format:

name likes dislikes

where name is the name of the student (which will only contain characters from [A-Za-z]), likes is a comma separated list of people he or she would be happy to work with, and dislikes is a comma separated list of people he or she would not be happy to work with. For instance:

Clarence Tiger,Anna,Jamal Amelia,James

This would indicate that Clarence is happy to work with Tiger, Anna, or Jamal; he is not happy to work with Amelia or James; and towards any other student he is neutral.

Another line:

Ilya Amelia,Clarence,Anna,Tiger,Jamal _

This would indicate that Ilya is happy to work with Amelia, Clarence, Anna, Tiger, and Jamal. For dislikes, we've used the special keyword _, which indicates that Ilya doesn't have anyone he is not happy to work with. Any remaining students Ilya would be neutral towards.

Output

Output space separated comma separated pairs of names, where each name corresponds to a pair of students. The pairs should be such that the happiness of the classroom is maximised. Every student should be in exactly one pair.

Example Inputs and Outputs

Writing reference implementation. This is one of those types of questions where you can't really judge the correct output for an input "by eye".

Sandbox Questions

1. This problem is quite difficult compared to typical code-golf fare, requiring two different algorithms to solve the weighted maximum matching problem. Is it too difficult for a code-golf? And if it is, what could make a better winning criterion?

Answer 23

Approximate phi using Fibonacci numbers

code-golffibonacci

As shown by Johannes Kepler, the quotient of successive Fibonacci numbers approaches phi.

(where F(n) = the nth Fibonacci number)

The fine folks at Wikipedia also say that if you choose two different starting values for the Fibonacci sequence, this expression still holds.

Last, but not least, if you use a later number in the series in the numerator, you get some interesting properties:

The challenge

• Create a full program or function that approximates phi using Fibonacci numbers.
• The program or function will take a single integer, n (unless a bonus is applied). It will output to STDOUT as follows, stopping when it reaches n:

1/1=1 2/1=2 3/2=1.5 5/3=1.66666666 ... F(n+1)/F(n)=...

• Fibonacci numbers must be calculated using iteration or recursion.
• No built-ins / standard loopholes, and neither the square root function nor phi should appear in the source code.
• It is OK if floating point limitation/integer overflow prevent accuracy beyond 4 or 5 digits, but you should use the most precise primitive data type (yes, double is one character longer than float).

There are two bonuses that you can earn, for a total of a 25% lower score:

• Input two additional integers as starting values for the Fibonacci sequence. This will still converge on phi, though it may take a bit longer. Reward: -10%.
• Input one additional integer for a in the above formula. This will result in the sequence converging to phi^a. Reward: -15%.

Scoring

Total score is the size of the program, in bytes, minus any bonuses. Since this is code-golf, lowest score wins.

(Insert leaderboard snippet) (Insert example snippet)

Example implementation snippet:

document.getElementById("button").addEventListener("click", process, false);

function process() {
  //Store field values to vars
  var itrNum = parseInt(document.getElementById("itrNum").value);
  var prevNum = parseInt(document.getElementById("start1").value);
  var curNum = parseInt(document.getElementById("start2").value);
  var aNum = parseInt(document.getElementById("aVal").value);
  document.write("(Click \"Run\" to reset)<br><br>");

  //Iterate through each fibbonacci number
  for (var i = 0; i < itrNum; i++) {

    dispNum = getFutureItr(prevNum, curNum, aNum);
    document.write(dispNum + " / " + prevNum + " = " + dispNum / prevNum + "<br>");
    //prepare numbers for next iteration
    var tempNum = curNum + prevNum;
    prevNum = curNum;
    curNum = tempNum;
  }
}

//Helper function for F(n+a)
function getFutureItr(prevNum,
  curNum,
  aNum) {
  var tempNum = curNum;
  for (var i = 1; i < aNum; i++) {
    tempNum = curNum + prevNum;
    prevNum = curNum;
    curNum = tempNum;
  }
  return curNum;
}

<!DOCTYPE html>
<html>

<body>
  Iteration number:
  <input type="number" min=0 id="itrNum" value=20>
  <hr>Starting value 1:
  <input type="number" min=1 id="start1" value=1>
  <br>
  <br>Starting value 2:
  <input type="number" min=1 id="start2" value=1>
  <hr>Value of a:
  <input type="number" min=1 id="aVal" value=1>
  <hr>
  <button id="button">Calculate</button>
</body>

</html>

Answer 24

Counting the Pattern Unlocks

Meta

Upon thinking about this challenge harder, I've realized that it is fairly trivial. Unless I am really bad at counting (which I am liable to be), there are at least 2 ways and at most 4 ways to draw any given pattern.

I think that this makes the challenge considerably less attractive. For this reason, I am thinking of ways to spice it up. For this, I would like your feedback. Currently I am thinking of:

-->Changing the rules so that dots can be used multiple times.

Let me know what you think of this change to the challenge, or suggest other changes.

The Premise

Many modern smartphones have options that allow you to choose how you would like to unlock your phone. For example, my phone allows

1. PIN input: a 4 digit number (low security)
2. Pattern Unlock: connect the dots in a pattern (medium security)
3. Password entry: enter a password (high security)
4. Fingerprint.

When you elect this second option, you are shown a 3x3 grid of dots (9 dots total) that looks something like this

.    .    .

.    .    .

.    .    .

Instead of using dots, we will use numbers in the following fashion for ease of reference.

1    2    3

4    5    6

7    8    9

You are then prompted to connect dots to form a pattern. This process is subject to the following rules:

1. The pattern must use at least 3 dots.
2. The pattern must be one continuous connection, that is once you lift your finger, the pattern ends.
3. Each dot may be used at most once (there is a quasi exception to this in rule 4)
4. If you take three collinear dots, in connecting the outer two dots, you must connect the inner dot if it is not already used. For example, if you make the connection 1-3, if 2 is not already used, you are really making the connection 1-2-3. If 2 is already used, then you are just making the connection 1-3. This is where the quasi exception to rule 3 comes in. You are passing over 2 again, even though you have already used it.

I believe that these are all the rules. Note that some phones may use different rules, but if you think I am missing something important, please let me know.

The Task

Our goal is to count how many ways there are to draw a given pattern.

For example if you see the following pattern:

1----2----3

4    5    6

7    8    8

It could have been drawn in one of four ways:

1 --> 2 --> 3    or
3 --> 2 --> 1    or
2 --> 3 --> 1    or
2 --> 1 --> 3

Input

You will be given a series of integers between 1 and 9 to stdin. They will represent connected dots on a grid.

The above example could be input via any of the following sequences:

1 2 3    or
3 2 1    or
2 3 1    or
2 1 3    or
1 3      or
3 1

If input is invalid, your program may do whatever it wants.

Output

Your program is to output the number of ways there are to draw the pattern, as an ingeter, to stdout or equivalent. In the above example, the output would be

4

Wining Criterion

This is code golf, shortest code (bytes) wins.

Bonus

Take off 20% if your answer also outputs all ways to draw the pattern (any understandable syntax acceptable).

TEST CASES

(1) grid layout

1    2    3
        /
4    5    6
|  /
7    8    9

possible inputs:

input>> 4 7 3
     >> 4 7 5 3
     >> 3 7 4
     >> 3 5 7 4
     >> 5 3 7 4
output<< 3

the ways are (for the bonus):

4 --> 7 --> 5 --> 3    or
3 --> 5 --> 7 --> 4    or
5 --> 3 --> 7 --> 4

(2)

1----2----3
|
4    5----6
|         |
7----8----9

input>> 3 2 1 4 7 8 9 6 5    or
     >> 3 1 7 9 6 5          or
     >> 5 6 9 7 1 3          or
     a couple others
output<< 3

example directions:

 3 --> 1 --> 7 --> 9 --> 6 --> 5   or
 5 --> 6 --> 9 --> 7 --> 1 --> 3   or
 2 --> 3 --> 1 --> 7 --> 9 --> 6 --> 5
 (or could include extra collinear points)

code-golf

Answer 25

Who is the Star Abuser?

In The Nineteenth Byte some people often star chat messages without any reason. You decided to go on a quest to find out who is the star abuser.

You logged the chat actions as a string, each action represented by a character (as you are a code golfer after all).

• Every user is marked with a letter of the alphabet.
• An uppercase version marks the user entering chat and a lowercase one marks his/her leaving the chat.
• At the start there is no one at the chat room.
• A star marks a starring. We assume that each person in the chat could have starred with the same probability when a starring happened. (E.g. if there are 2 users in the chat we assume both of them had 50% chance to star.)

An example log:

MOA***a**oS**s*Cc

You should output one uppercase letter showing the letter of the user who has the highest number of expected starring. If there are multiple users, output exactly one of them.

Input:

TODO

Output:

TODO

Examples:

TODO

This is code golf so the shortest entry wins.

Answer 26

Comedy of exceptions

Your goal is to demonstrate the shortest program or function that can throw 10 different types of errors/exceptions (I use the two interchangeably here) at runtime.

This question is only open to languages which have an object-oriented type system for errors. Furthermore, in the case of each error, a message including a clear identification of the exception's type must be printed. Evidently, it must also have at least 10 error types. Other systems such as an integer error code identifying the error, or all errors represented by strings are not acceptable.

Input is an integer from 0 to 9 inclusive. The program should reliably throw a different type of error for each input.

Methods which allow exceptions of arbitrary type to be thrown may not be used. E.g, throw ... .

Determining whether two errors are of different type (TODO: fill in detail of output)

Java: x and y print different stack traces, but are the same type, so they can't be used.

Python: UnboundLocalError ..... and NameError ....... would count as two types of error, since, although UnboundLocalError is a subclass of NameError, type() would give different results for the two.

C++: stoi("aaaa") printing ......... would be valid since the message gives std::invalid_argument. Integer division by zero would not since it crashes the program without a message informing of the error type

Sandbox

Please comment if you are aware of a language that is borderline on eligibility, blurs boundaries between error types, or has other loopholes.

Answer 27

Juggling without collisions code-golf

Determine if a siteswap juggling pattern is valid, meaning that no two balls land on the same beat. Fewest bytes wins.

Input: A non-empty list of positive integers.

Output: A consistent Truthy value for valid or Falsey value for invalid.

---

Siteswap is a notation for juggling patterns. Dividing time into units called beats, a siteswap pattern says how high to throw the ball each beat, measured in beats that it's airborne until you catch it. For example, the pattern

4 2 3

says

• On the first beat t=1, throw the ball 4 beats high, so you catch it at t=5.
• On the second beat t=2, throw the ball 2 beats high, so you catch it at t=4.
• On the third beat t=3, throw the ball 3 beats high, so you catch it at t=6.

If we treat this pattern as a periodic sequence

... 4 2 3 4 2 3 4 2 3 4 2 3 4 2 3 4 2 3 ...

note that on every beat, you catch exactly one ball. But, in

 5 1 3 4 2 ...

the ball thrown for 5 beats at t=1 and the ball thrown for 3 beats at t=3 both come down at t=6, which we don't want (let's ignore that we have two hands). This happens whenever two numbers in the sequence have the same different as the number of beats between them, with the bigger on first. Note that this may happen across repetitions, like in 8 1 2, where the marked balls collide at *.

 v             v *
 8 1 2 8 1 2 8 1 2 8 1 2 ...

---

TODO: Test cases.

Sandbox: Does the explanation make sense? Is it too long for the challenge?

Answer 28

Elements with 100 ≤ Z < 1000

---

The International Union of Pure and Applied Chemistry (IUPAC) decided that it is necessary to have a systematic naming for the elements, even for those which had not been discovered. The rules for naming are:

1. The name is derived directly from the atomic number of the element using the following Latin numerical roots:

   Number     Root
   ------     ----
   0          nil
   1          un
   2          bi
   3          tri
   4          quad
   5          pent
   6          hex
   7          sept
   8          oct
   9          enn
   

2. The roots are put together in the order of the digits which make up the atomic number and terminated by 'ium' to spell out the name. The final 'n' of 'enn' is omitted when it occurs before 'nil', and the final 'i' of 'bi' and of 'tri' when it occurs before 'ium'.

3. The symbol of the element is composed of the initial letters of the numerical roots which make up the name.

For this challenge, let us consider the elements having a three digit atomic number.

Examples:

100 --> Unnilnilium
101 --> Unnilunium
111 --> Unununium
150 --> Unpentnilium
200 --> Binilnilium
500 --> Pentnilnilium
999 --> Ennennennium

Input

• Input can be taken from one of the following

  • stdin
  • Command-line arguments
  • Function arguments (One argument, as a string)

• Input will contain either a valid IUPAC name of an element, or a valid IUPAC symbol of an element.

Output

• Output the corresponding
  • IUPAC name if the input is a symbol of an element.
  • symbol if the input is an IUPAC name of an element.

Rules

• The input will contain a valid IUPAC name/symbol.
• The first character of the symbol/name in input will be in upper-case and should remain capitalized in the output.
• You are permitted to write a full program or a function.
• There should be no unnecessary characters except an optional trailing newline character.

Test Cases

Unu            --> Unnilunium
Eee            --> Ennennennium
Enn            --> Ennilnilium
Bnb            --> Binilbium
Ubt            --> Unbitrium
Qsn            --> Quadseptnilium

Septenntrium   --> Set
Hexunbium      --> Hub
Octennilium    --> Oen
Bibibium       --> Bbb
Ununennium     --> Uue
Triquadpentium --> Tqp

Scoring

This is code-golf, so the shortest submission (in bytes) wins.

---

Tags: code-golf chemistry

---

Sandbox: What do you guys think about this challenge? Anything to improve? Did I miss anything?

Answer 29

Rational Number to Repeating Numeral Conversion

code-golf math number-theory restricted-complexity

As I'm sure you know, the decimal expansion of every rational number is either terminating—consisting of a finite number of digits, or repeating—consisting of infinitely many digits, but ending with a finite pattern that repeats itself indefinitely: for example, the decimal expansion of the rational number 1/6 is 0.1666..., where the sixes repeat forever. One way to represent this decimal expansion finitely and unambiguously, is to write the repeating part, called the repetend, enclosed in parentheses: going back to the previous example, under this scheme the number 1/6 is written as 0.1(6). We call this representation a repeating decimal. Of course, none of this is specific to base 10. More generally, we call such a representation, in any base, a repeating numeral. Note that, for the sake of this challenge, we use the term "repeating numeral" (or simply, "numeral") to refer to any numeral written using this scheme, whether or not it actually has a repeating part.

Challenge

Write a program or a function taking a pair of integers, p and q, and returning a repeating numeral representing the rational number p/q. You may assume that p ≥ 0, and q > 0, so that p/q is never negative. The resulting numeral should be in base 10, unless you go for the relevant bonus below.

There is more than one possible numeral representing a given rational number. For example, the rational number 1/1 can be represented, among (infinitely many) other options, as 1, 1.0, 1.(0), 0.(9), and so on... For this challenge, however, we'd like the output to be unique. The following set of rules, which your program must follow, takes care of that:

• When the integer part of the numeral is zero, there should be a single 0 before the radix point. For example, given the input 1/2, the output should be 0.5, and not .5.

• The repetend, if exists, must begin after the radix point; that is, it shouldn't apply to the integer part. For example, given the input 10/9, the output should be 1.(1), and not (1).

• The output should be finite and minimal, under the above rules. This is the most significant rule controlling the output, so it's worth highlighting some of its consequences:

  • There should be no leading or trailing zeroes. For example, given the input 3/2, the output should be 1.5, and not 01.5 or 1.50.

  • If the fractional part is zero, it should be omitted. For example, given the input 1/1, the output should be 1, and not 1.0.

  • If the repetend is zero, it should be omitted. For example, given the input 1/2, the output should be 0.5, and not 0.5(0).

  • When the input admits a terminating numeral, there shouldn't be an unnecessary repetend. For example, given the input 1/1, the output should be 1, and not 0.(9).

  • The repetend, and the rest of the fractional part, should not be superfluous; there shouldn't be any repetition in the repetend itself, nor in the repetend and the rest of the fractional part. For example, given the input 1/99, the output should be 0.(01), and not 0.01(01), 0.(0101), or 0.0(10).

As usual, you may not use any built-in or library functions aimed specifically at this problem.

Input and Output

You may take the input through the command line, through STDIN, as function arguments, or using an equivalent method. You may use any convenient format for the input, but make sure to specify it in your post. You may assume that p and q are no greater than 10,000,000, to the extent that it helps you to avoid overflow.

You may write the output to STDOUT, return it as the function's result or through an output parameter, as a string, or use an equivalent method.

Score

This is code-golf. The shortest answer, in bytes, combined with the any of the bonuses, wins.

Bonuses

If, in addition to the requirements listed above, your program satisfies the requirements for any of the following bonuses, multiply your score by the specified amount.

×0.8 Bonus Support other bases
Your program should take a third parameter, b, which is an integer between 2 and 36, inclusive, and return the corresponding numeral in base b, instead of base 10. The letters of the alphabet, either in lowercase or uppercase, should be used as digits above 9. For example, given the input 1/2 and b=3, the output should be 0.(1). Note that base b applies only to the output—if your program takes its input in string form, it should interpret it in base 10.

×0.6 Bonus O(1) space complexity
Your program's space complexity should be O(1), where the unit of space is the amount of space required to hold the input. In other words, the amount of memory required by your program should, on a large scale, be proportional to the amount of memory required by the input. You may not use the fact that the input range is bounded when reasoning about your program's space complexity, other than to the extent of establishing the amount of space required by the input. If you go for this bonus, it is strongly advised that you include at least a brief explanation of your program, so that others can verify that it meets the criterion.

If your program does not print the output directly, but rather returns a string, you may ignore the space occupied by the string as long as your program only appends to the string, and doesn't modify or read from it otherwise. (Note that something like s=s+"0" is fine, even though it technically involves reading from the string.)

Test Cases

Each of the test cases below lists the input, p/q, on the first line, and the corresponding output on the second line. Some of the tests list a third parameter, b, which specifies a different base for the output. These tests are only applicable for the relevant bonus.

Short-Output Tests

Your program should solve each of the following tests in a matter of seconds.

0/1
0

123/123
1

12/3
4

1/2
0.5

1/3
0.(3)

7/6
1.1(6)

3/11
0.(27)

1234/9999
0.(1234)

7/12
0.58(3)

22/7
3.(142857)

123/456
0.269(736842105263157894)

7124771/4545450
1.56(745118)

1/68
0.01(4705882352941176)

678/2345
0.2(891257995735607675906183368869936034115138592750533049040511727078)

7683/238
32.2(815126050420168067226890756302521008403361344537)

123631/99999
1.(23632)

4576/2345
1.9(513859275053304904051172707889125799573560767590618336886993603411)

2239231/4950000
0.45236(98)

673/23430
0.0(2872385830132309005548442168160478019632949210413999146393512590695689)

8984/2318
3.(875754961173425366695427092320966350301984469370146678170836928386540120793787748058671268334771354616048317515099223468507333908541846419327006039689387402933563416738567730802415)

1/2 2
0.1

214/5467 13
0.(067ccb5145334200a07b6253394bc5ca12bc650017b87998acc2c516a7993810702ba1)

214 5467 11
0.0(481119a34a86245a0053a1022114643a64131367585a8095498942556925833303993816590371976aa2a6952238969a61490900a792044229187a18262724060a517a986785002750566607877532070733842a95a27a4476828a12971701a4740884573649355153)

330420/335923 36
0.(zero)

9322181/306936 28
12.ab(cd)

123/6573 29
0.(0flb8c3hblol)

123/6573 21
0.0(85669592cjj9ca173fij6g67hhg7g940b5efk6j2bb7276c1ch25ikf7dd070jf4h96hek41ji102h3ea6kb2ic5hc3089b19kjc8dfhaf9147c48kgg4k5ab463d1fd5k86eigacciai54ihj3k2e7aghdbcfeebfbi811b8ajdh521e4ed334d4bgk9f650e1i99dide8j83if205d77kdk15g3be360gj12jki3h6ae09i28f38hkcb9jb018c753a5bjgd8gc044g0fa9geh7j57f0ce624a882a2fg231h0i6da4379)

Long-Output Tests

The following tests produce significantly longer output. Instead of listing their full output, only the MD5 checksum of the output if given. The checksum is calculated without a trailing newline, and using lowercase letters for digits above 9 (in the relevant test cases). If you want to see the full output for these tests, or to calculate the checksum under different conditions, you can use the test snippet below. Your program should solve each of the following tests in no more than a few minutes.

343/677472
e1810c85500a97c36f2ba5dcc94a2aa6

234/62332
662adcee10cd77d001282f0e31a84b77

57628/7894211
81222aaa93f192c6d8334fcde6381a74

67332/1267232
3ea190c83a735a8bafc922cbb177e6f4

954/3684332
d4ef940c9986f9c2ac52ee822d94d6a7

783232/3462241
7724d3444b5540b8b4f07d13317e8da3

83/7657124
b295369267f48e642e202e0364898c82

764231/54646224
ecf7f3dd12f2d495b31a178fc03662d7

6743/1231234
9f447fd27447abb881795fc5e2f814e5

764/9343249
8381dc6f127be6d95cadc0b5bdd70104

345/2234448 22
667d437e35c3825696f64f1b27e6a827

63451/2343324 3
5d86d77856cc0a15ac8a51b46c2f22d6

93457/546464 2
1084e884aded53f0da933480c45db1b8

678541/453524 9
5bb54bddaab7bd933258d4d78a83cdba

4572/2341198 15
39af2bc67ab58438068f672ed3a8357d

1/4821466 6
57ba79a48c438b7fd21aa39ee3575c8d

145/5821417 21
009f087ae661cfd4690cc51ba71a827f

5472/2333645 33
d24583dfdad205de61763c6a87637979

Test Snippet

If you want to further test your submission, you can use the following test snippet to find the repeating numeral representation of arbitrary rational numbers, or to find the rational number corresponding to arbitrary repeating numerals. Note that the result can get very big, very fast, which can be a little much for your browser; in this case, you might want to uncheck the "Result" checkbox, and check the "MD5" checkbox, to only get the MD5 checksum of the output. Note also that you can resize the input and output boxes.

<style>* { font-family: sans-serif; }table { border-collapse: collapse; }table > tbody > tr > td { padding: 0px; }#status { display: none; }#status[loading] { display: initial; font-style: italic; }#main { display: none; width:100%; border-right:.7em solid transparent; font-size: 95%; }#main[loaded] { display: table; }#main > tbody > tr + tr > td { padding-top: .25em; }#main > tbody > tr > td + td { padding-left: .5em; }#main > tbody > tr > td:first-of-type { width: 4.25em; }.label { white-space: pre; }#flags { padding-left: 2.4em; font-size: smaller; }#flags > table > tbody > tr > td + td { padding-left: 1em; }#error { display: none; font-size: smaller; color: #880000; }#error[error] { display: initial; }#job_cancel, #job_throbber { display: none; vertical-align: bottom; }#job_cancel[working], #job_throbber[working] { display: initial; }#job_throbber > img { height: 1em; }#job_throbber[working] { padding-left: .3em; }#job_cancel[working] { padding-left: 1em; }#job_cancel > input { height: 1.8em; font-size: small; }input[type="text"], input[type="number"], textarea { padding: 0.25em; height: 1.4em; font-family: monospace; }textarea { width: 100%; }#base { width: 2.8em; text-align: right; }.output { background-color: #e4e4e4; border: none; }#length { width: 8em; text-align: right; }#md5 { width: 20em; text-align: center; }#result_container[active="false"] { display: none; }#md5_container[active="false"] { display: none; }</style></head><body><div id="status" loading>Loading...</div><table id="main" onkeydown="handle_key_down(event)"><tr><td id="input_label" class="label">Fraction:</td><td><textarea id="input" oninput="update(true)" spellcheck="false">123/456</textarea></td></tr><tr><td class="label">Base:</td><td><table><tr><td><input id="base" type="number" value="10" spellcheck="false" oninput="update(true)"></td><td id="flags"><table><tr><td><label><table><tr><td><input id="flag_result" type="checkbox" checked onchange="handle_flag('result')"></td><td>Result</td></tr></table></label></td><td><label><table><tr><td><input id="flag_md5" type="checkbox" onchange="handle_flag('md5')"></td><td>MD5</td></tr></table></label></td><td><label><table><tr><td><input id="flag_uppercase" type="checkbox" onchange="handle_flag('uppercase')"></td><td>Uppercase</td></tr></table></label></td><td><label><table><tr><td><input id="flag_trailing_newline" type="checkbox" onchange="handle_flag('trailing_newline')"></td><td>Trailing Newline</td></tr></table></label></td><td><label><table><tr><td><input id="flag_progressive_output" type="checkbox" onchange="handle_flag('progressive_output')"></td><td>Progressive Output</td></tr></table></label></td></tr></table></td></tr></table></td></tr><tr><td></td><td><span id="error"></span></td></tr><tr><td class="label">Length:</td><td><table id="length_table"><tr><td><input id="length" class="output" type="text" spellcheck="false" readonly></td><td id="job_throbber"><img src="https://i.sstatic.net/sHKZY.gif"></td><td id="job_cancel"><input type="button" value="Cancel" onclick="cancel_job()"><td></tr></table></td></tr><tr id="md5_container"><td class="label">MD5:</td><td><input id="md5" class="output" type="text" spellcheck="false" readonly></td></tr><tr id="result_container"><td id="result_label" class="label">Numeral:</td><td class="full_width"><textarea id="result" class="output" spellcheck="false" readonly></textarea></td></tr></table><script async type="text/javascript" src="https://gist.githack.com/anonymous/49705525fd01ba66c1ad/raw/c35226ad89444e3af07d0e505f7163df8574b860/repnum.js"></script>

Answer 30

This challenge was closed, because it was way too broad, but, in the comments, SuperJedi224 suggested a slightly different challenge that I thought was a really good idea, so I'm stealing it and posting it here.

---

Write a text editor in 2000 bytes or less

popularity-contest

Write a text editor in 2000 bytes or less. It should support loading and saving files (or something else if your language doesn't support that, maybe?), modifying text, and displaying the contents of a file that's currently open in some format.

Sandbox questions

• I'm not sure if 2000 bytes is the right number. SuperJedi224 originally suggested 10000, but that seems to me like too many.
• Should some features be required, or should it just be by votes? Will votes take care of possible submissions that aren't actually text editors?
• Should there be some kind of bonus for shorter submissions? Maybe an extra point for every 20 or so bytes you don't use? No, there probably shouldn't be.
• Should languages that don't support file operations be allowed?