Proposed questions (sandbox) Mk III (retired)

Question

This Sandbox is being retired in favor of the newer model.

Just to keep the scrolling to a reasonable level. Please feel free to continue to work or vote on question in older sandboxes.

Upvote when you think a question is ready.

---

This question replaces the earlier Sandbox mk. II and Sandbox mk. I which were getting too crowded.

Answer 1

TRON Light Cycles Competition

In the spirit of 1P5: Iterated Prisoner's Dilemma, the TRON Light Cycles Competition is a challenge to built the best Light Cycle driver. For those not familiar with the game, the idea is that two players are on a grid and move around the grid with the goal of trapping the other player. Each place that your Light Cycle has already been must not be crossed again by either player (think Snake, with infinitely growing snakes). Play ends when either a player is forced to hit the previous path of a Light Cycle, a player is forced off the edge of the board, or the two players crash into each other (or in this case, it may be caused by a bad programming bug rather than being forced).

The specs of the gameplay are as follows:

1. The game board is 21x21, consisting of a grid of possible locations where you may travel.
2. Two players start at the top and bottom at the center, one board space from the outer edge, facing the other (toward the center). In (x,y) coordinate terms (1-based), this would be (11, 2) and (11, 20).
3. Each player uses information about the current state of the board - which is the list of previous moves each player made (i.e., SSLRR...) - to determine their own next move, which is either stay straight (S), turn left (L), or turn right (R). A turn is performed first then the player moves straight, so that an (R) would mean the player's next location will be to the right of the previous one and also facing to the right of the previous move.
4. After each player's move has been calculated, the simulator applies both moves. If the move causes either player to be out of the boundaries of the board, or on a location previously traversed, that player immediately loses. If both players fall into the losing category, the game is considered a draw.
5. Each round consists of a series of 100 simulations between two players. In each simulation round, a win yields 1 point, and a draw yields 0 points. I will maintain a matrix of scores between each combination of contestants, and the winner is the player with the highest total score across all of their rounds after roughly two weeks of competitions (11/11/11), depending on the level of participation.

Your job as a contestant is to write the function that performs a move. Your function should use the following guidance spec:

1. You will be given two strings via stdin as two lines, each a sequence of S, L, and R representing the moves made by a player. The first line will be your own moves, and the second line your opponent's.
2. Your return value onto stdout should be your choice of move (as a single character with an optional line return following): S, L, or R. Any input that does not follow this spec will automatically be assumed as an S (move straight).
3. The simulator will begin the game with a call to both contestants with an initial input of empty strings and both players assumed to be at their initial locations. Each move will be simulated on a board to verify that both players are still in the game, and then appended to the sequence of moves for passing to each contestant program representing the next move.

Suggestions welcome: This is a rough overview, feel free to edit or throw out suggestions. I'm not certain how big the board should be. Also, there may be a better format for the input to each move because SLR information will be difficult to process. You'll probably find yourself needing to generate a virtual board and simulate all the previous moves so you can see what places are taken and where the other player is. On the other hand, this gives you absolutely every piece of information if you want to infer about the other player's strategy. Ideas on input/output spec are welcome too.

Answer 2

Binary Tetris

There was recently some buzz on programming websites about an implementation of Tetris in 140 Bytes. ...

It turns out that although it is small, it is a simplified version of Tetris, and not even a complete implementation. Only the core logic function fits in 140 bytes of Javascript. To actually run it, you need another ~840 characters of HTML.

We can do better!
This challenge is to implement a complete version of "Binary Tetris" in as few tweets as possible.

Binary Tetris Rules:

• The program must display a playing field containing at least 5 columns and 6 rows of cells.
  • Any method of display may be used, as long as the blocks and the edges of the field are clearly marked.
• There must be at least two types of blocks: # and ##.
• New blocks are added to the field in the top row, and one block cell must occupy the center column.
• Blocks descend towards the bottom row at a fixed rate. Blocks must descend even without user input.
• When blocks touch the bottom of the field or a lower block, they stop falling and are fixed in place. A new block is added.
• When all the columns in the row are filled with blocks, the row is emptied, and all the fixed blocks above drop down one row.
• The program must respond to keypresses. There must be 3 unique keys that perform the following functions
  • shift current block left 1 column
  • shift current block right 1 column
  • shift current block down 1 row

Golfing Rules:
Because the original implementation was "tweetable", this challenge requires the same. Entries must be able to be transmitted as a series of tweets (lines of 140 characters or less).

• The first tweet must contain the name of the compiler/interpreter, the name of the program, and any command line arguments
  • it will be saved as file "P0"
• The following N tweets must contain the program as a series of lines.
  • Each tweet will be stored in a file with the name T<n>, where n is 1..N
• Each line will be added to the previous lines and compiled or interpreted. It must produce a valid object file or program.
• The program does not need to be functional until the last line is added.

• The program will be run in the following manner (pseudo-bash)

  interp,prog,args = split P0 /\s/ 
  touch $prog
  for file in ./T* do
    cat $prog file > $prog
    $interp $prog $args
    die("FAIL") if $? #detect error
  done
  

  The interpreter must be a commonly available executable program that does not already implement Tetris.

Scoring:
Fewest Tweets, including P0. Ties broken by largest number of spare characters (140 * num tweets - total character count).

Example Entries

chrome a.htm
<html><div id="output"></div></html>
<script>cool java script here</script>

Score = 3 (334 spare)

cc a.c ;a.out
main(){/*cool prog here*/}

Score = 2 (241 spare)

tetris

Score = 1 (134 spare) if it were legal, which it's not

---

Feedback?

• Is the scoring reasonable? I like the idea of golfing to a slightly different metric.

• Is the requirement for each subprogram to compile reasonable? It works well for my Ruby entry, but may be nearly impossible in other languages. But without it, the scoring reduces to pure character count again.

• Is my pseudo-bash understandable? correct? I may replace it with an equivalent Ruby program

I was also thinking about modifying the scoring to add bonus spare characters for certain enhancements, in order encourage more interesting end results. Something like +2 for every doubling of the board size, +5 for rotate, +3 for each additional block type... Is this a good idea or not? If it is, how do I calibrate the bonuses?

Answer 3

Underhanded C Contest [Posted]

It looks like the Underhanded C Contest has gone the way of bit-rot. I'd like to do one of those contests here. We could just do the "losing my freakin’ luggage" contest as it was never judged, or do something new. I have an idea for an encryption-related one, or perhaps someone else has an idea.

We'd need a volunteer or two for judging.

Answer 4

Play a perfect game of Mu Torere [POSTED]

Answer 5

The Sleigh Packing problem [Posted]

Answer 6

Lowest unique bid auction [Posted]

Answer 7

Play Simple 2-Dimensional Minecraft

Recently I found this video of "HansLemurson" showing a computer that was built in minecraft, which runs minecraft. He is playing minecraft on a computer that was built in minecraft that is running on his computer. To be specific, it is a two dimensional version with an 8x8 grid of cells. There is gravity, block placement, and even jumping. It is worth noting that the computer is single purpose. The same person has built programmable computers, but making them single purpose allows the computer to be much smaller.

Details

The minecraft world is an 8x8 grid (one horizontal and one vertical dimension). The grid is comprised of either Xs (representing blocks) or empty spaces. The player is an X that is blinking on and off about once every second.

There are two modes in the game, controlled by a toggle switch. The first mode is movement. This is controlled by a WASD-like button arrangement. If the player chooses to move left/right/down, the computer checks to see if the space immediately in that direction is empty. If so, then the player moves into that space.

If the player chooses to move up, then the computer checks that the block underneath the player is solid. If so, then the player moves upward two units. Notice that this can propel the player into a solid block. If this happens, the player is obscured by the solid block, but can still move to an empty block next to him. When the player is inside on a solid block, the game continues as if the block isn't there, although the block is still there once the player leaves it.

After each move, the player falls down one unit if there is empty space there. This simulates gravity. This is also why moving up moves up two units, so that the gravity makes a net movement of up one unit. Gravity does not cause the player to fall all of the way to the ground, just one unit.

The second mode is block placement. In this mode, the same exact WASD buttons are used. Instead of moving the player, they toggle the state of the block in that direction. If the player presses "left" and there is a block there, then the block is destroyed. If there is not a block there, then a block is placed. Again after this move, the player is again subject to gravity. The blocks are not subject to falling.

Toggling the toggle switch does not count as a move, and does not invoke gravity.

The game board is a torus, so all actions (movement, block creation) can wrap around the board. The board does not scroll with the player. The player moves, and the blocks stay in the same place.

The challenge

You challenge is to write the shortest program that simulates this game. Your program should display and update the map correctly (with Xs as blocks, and with the blinking player). It should accept input from a button that toggles the state and four buttons for movement and actions. This is code golf.

There are imaginary bonus points for adding more features (block types, game size, etc) to your game.

Suggestions?

Answer 8

One-way system [Posted]

Answer 9

Pluralize it! [Posted]

Answer 10

I've Got The Key, I've Got The Secret

A cryptography challenge in 2 parts.

Part 1

Implement a pair of programs in any language (the two programs could be in different languages if you wanted) to encode and decode a string of plaintext.

Input and Output

The encoder must take the plaintext (and an optional key) and return an encoded string. The decoder must take the cyphertext (and an optional key) and return the plaintext exactly as it was given to the encoder.

Restrictions

• The encoding and decoding code must be entirely implemented in the language - no libraries or cryptography functions may be used.
• The code (encoder+decoder) cannot be longer than 1024 characters.

Part 2

Implement programs (multiple programs per answer, one answer per entrant) which crack your opponents encryption algorithms.

Input

The cyphertext.

Output

The plaintext that generated the ciphertext.

Scoring

I will upvote all answers to part 1 which have working encryption and have obviously made an attempt at golfing their answer.

In order to be eligible to win, an entrant will have to have taken part in both parts of the question. Overall score will be (length of shortest program that cracks your code-(length of encoder+length of decoder)). Highest score wins and winning entrant's entries will be accepted on both questions.

Answer 11

Meta Quine [POSTED]

Answer 12

Rock, Paper, Scissors! (I)

 

The challenge:

Write the best rock, paper, scissors bot you can, in any language. It can be a function, a complete program, anything - though this isn't a code golf challenge.

Scoring:

Score = Number of wins × 2 + Number of ties

Input:

A list of all previous tries against the current opponent and a list of all of the current opponent's throws against the running bot, in that order. On STDIN, it could be, for example:

$ ./rpsbot
4    // number of tries
rpsr // my previous tries against this opponent
rrpp // this opponent's previous tries against me

As arguments (JavaScript example):

rpsBot(['r', 'p', 's', 'r'], ['r', 'r', 'p', 'p']);

Output:

A return value or STDOUT. r, s, or p.

king-of-the-hill code-challenge

Answer 13

y-o-meter

Build an asci-art-graph to attach to some source on stdin which provides numerical informations to be presented.

Sample output:

14k-|
    |   |X X|                        X| 
    |  X|X|X|X   X     X X| |X       X|X| 
 8k-| |X|X|X|X|X|X|   |X|X|X|X|X    |X|X|X X
    |X|X|X|X|X|X|X|X|X|X|X|X|X|X|  X|X|X|X|X
    |X|X|X|X|X|X|X|X|X|X|X|X|X|X| |X|X|X|X|X
    |X|X|X|X|X|X|X|X|X|X|X|X|X|X| |X|X|X|X|X
 0k------------------------------------------
    9           12           15          18

sample invocation:

tail -f xy.log | ./filterNums.sh | foolang codeGolf.foo -d "\n" 

• How you get your input is your problem and doesn't belong to the contest (for example tail -f xy.log).
• If you need to filter your input: again your job, but ooc. Example: tail -f /var/log/syslog | egrep -o "[0-9]+"
• The invocation of your program might contain a delimiter specification, so that you can read delimited by newline or whitespace in general and this will not count towards the score. You needn't do it this way, but a flexible program is expected.
• The graph shall be self-formatting. Each datarow (-point) is one char wide on the x-coordinate, the height should always be close to the maximum. It shall adopt to growing maxima, but not to falling ones. Old values needn't be repainted, since they move out of scope.

Questions in preparation of the challenge:

• How clearly do I specify the decoration of the axis?
• Shall I allow non-ascii, but graphical output?
• Shall the x-coordinate be specified by time or is the incoming data the clock-tick? Allow both (OR) or make it configuralbe?
• Related: The x-Coordinate could be provided from the input source as well. So that would mean: you get a pair of values, (x,y)

• The size of the graph shall take most of the available space of the terminal, so if your terminal size is 80x40 50x25 for the data would be fine - not just a stamp as shown in my example. If it can adopt to the current shell size: fine. Else: make it take parameters:

  generator | foolang codeGolf.foo -d "\n" -x 70 -y 20

Passing the parameters gets no penalty.

This is code golf.

---

• Is this an interesting challenge?
• Is it clearly stated?
• What else needs to be specified?
• How shall I improve the challenge?

Answer 14

Count Syllables

The goal of this challenge is to write a program that can count the syllables in a word as accurately as possible.

Input

On STDIN, your program will receive a number X followed by X lines, each containing a single word. Simple enough. (Should there be a limit on the size of X?) The words will come from this list.

4
challenge
to
count
syllables

Output

Your output should be to STDOUT and have X lines. On each line should be the number of syllables counted in that word.

2
1
1
3

Scoring

To score you program, it will receive a long secret list of words to test. All programs will receive the same list of words. For each word, the number of syllables that your program got wrong will be added to the score of the program. If it output a 4 or a 2 when the word had 3 syllables, then one point will be added. If it said a 15 instead of a 3, then 12 points will be added to the score. The lower the score, the better.

For example, if for the above input your program output 3 2 2 2 (which would be produced by a program that counts strings of vowels), then the program would receive a score of 2.

Rules

Your program should not access any external files (such as the word list). Also, your program should be no more than 5,000 bytes long (is this a reasonable limit?).

The winner will be the person whose program has the lowest score, therefor the most accurate syllable counter. The deadline for submissions is [some time at least a month away].

Suggestions

I am open to all constructive criticism. Is 5,000 bytes a reasonable limit for the program size? How long should the official scoring test be? How long should the deadline be?

Answer 15

Simulate a Minsky Register Machine (II) [Posted]