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

Jenga code

I think everyone knows what Jenga is.

As per Wikipedia:

Jenga is a game of physical and mental skill [...] During the game, players take turns removing one block at a time from a tower constructed of 54 blocks. Each block removed is then balanced on top of the tower, creating a progressively taller but less stable structure.

Challenge

Write a program that behaves as a Jenga tower. Every time a randomly chosen piece of code is removed and placed at the bottom of your program, the code should re-run. Goal is to achieve the tallest running code tower.

Rules

• The starting tower (or source code) must be of exactly 15 lines of code. Such lines must be divisible by 3 forming a 15x3n grid composed by 15 lines of 1xn bricks.
• A brick is removed randomly from the code and placed at the bottom from left to right until the 3n block line is complete. The process goes on at the bottom of the new formed line.
• If a brick has strictly more consecutive whitespaces than any consecutive characters in it its considered broken and fails to sustain the tower.
• A brick must always be present for each row (2 holes and 1 brick), but its position in the row is not important.
• A tower is tall 20 lines if the 20th line tower runs with no errors.
• A brick cannot start nor end with comment start or end tags of your chosen language (e.g /* or //)

Output

Each tower must output its own height.

Scoring system

Your score is simply the avarage tower height for your program:

SCORE = (MAX TOWER + MIN TOWER) / 2

Where MIN TOWER refers to the minimun non-running tower while MAX TOWER refers to the maximum running tower.

(It would be nice if in the answer both towers are shown)

Proposed tag: code-challenge

Answer 2

Analyze Tonguetwisters code-golf natural-language string

Your task is to write a program which will accept an English tonguetwister, search for commonly used sounds and decide why it is difficult to pronounce.

1. Calculate the frequency of every sound used in the input sentence.
2. Count identical sounds (for example, ea and ee) as the same thing.
3. Ignore those sound groups (see below) which occur less than 0.1 times per character of the input.
4. From the sounds that remain, group members of the same group together and separate by a forward slash (/).
5. Arrange the groups by decreasing number of occurences.
6. Separate groups by commas.
7. Output.

Identical Sounds [under construction]

ee = ea (in step 2, replace ea by ee)

Sound Groups [under construction]

e,ee
s,sh,c,ch
f,th,ph

Examples

Input: She sells sea-shells on the sea-shore.

Output: s/sh,e/ee

Input: The seething sea ceaseth and thus the seething sea sufficeth us.

Output: s/c,e/ee

Rules

• Receive input on STDIN, as command-line arguments or otherwise. You may not expect it to be stored in a variable.
• Output to STDOUT or equivalent.
• Standard loopholes are banned.

Answer 3

Gun Fight at High Noon

Gameplay

This will be a 5 or 4 stage (the decision will be explained later) king-of-the-hill tournament where programs are pitched against each other to solve an integration problem faster than the other. The fastest will then go on to the next round.

Number of rounds: Due to tournament bracketing, the number of rounds will be decided by the reception of the challenge. For four rounds, sixteen entrants are needed. For five rounds, thirty two entrants are needed.

The controller

The controller will be written in Python, using time.time() as the timer. When run, it will time one entrant, print the output and time the other entrant and print the output. I will then put the results into a text file and post the results on the question.

The problem

The problem will be a simple elementary function integration problem with long numbers included. These will be generated randomly when the controller is initiated and both entrants will be given the same problem.

Rules

1. No inbuilt functions can be used to solve the problems
2. If you fail to calculate the problem correctly, you will lose immediately
3. In event of a tie, the match will be replayed with a different problem

Inbuilt Functions

Inbuilt functions include functions that solve integration problems themselves you must have a hand written integral solving algorithm in your code.

Example and Arguments

All information will be transferred via stdout and stdin. The integral will be in the following format:

Integral http://upload.wikimedia.org/math/0/3/4/034cf496a9d3026984fcae6cfa58608a.png

And f(x) being like where a and n will be replaced for integers when passed to your program:

With arguments being passed like so:

programname a b f(x)

The reply will be stdout as a floating point integer to a precision of 5 decimal points. An example from one of my tests:

~$ python3 showdowncontroller.py Test1 'python3 int1.py' Test2 'python3 int2.py'
A,B:        3,36
Function:   10*x**3
Result:     4199187.88575

Test1: 0.04052305221557617 True 4199187.88575 <- name time correct? output

Test2: 0.04041910171508789 True 4199187.88575


Win: Test2

The command run for each program was:

python3 [program name].py 3 36 10*x**36

And the response was:

4199187.88575

Other

In your answer you will need the following:

• Name of your program
• Command to compile your program (if necessary)
• Command to run your program
• Your code
• A short description of your integration method

Your program can be in any language as long as I can compile and run it on Ubuntu 12.04 Precise.

There will be a 0.00005 error tolerance: any more or any less and your program will lose the match. The controller uses Simpson's Rule.

# Generate numbers
a=random.randint(1, 50)
n=random.randint(1, 10)
b=random.randint(1, 50)
c=random.randint(1, 50)

# Integration using the Simpson method
def integrate(f, a, b):
   h = (b-a)/100
   meth = lambda f,x,h: (f(x) + f(x+h))/2.0
   ival = Decimal(h * sum(meth(f, a+i*h, h) for i in range(100)))
   return ival 

# Call function
func = lambda x: eval(str(a)+'*x**'+str(n))
result = round(integrate(func, c, b), 5)

Test programs will be posted with their running times so people can tell how fast my computer is. I will post no hardware specifications (processor type, speed) though - that will remain a mystery.

Controller code

# Gun Fight at High Noon
import subprocess, random, time, sys
from decimal import Decimal

# Get program names
prog1 = sys.argv[1]
prog1command = sys.argv[2]
prog2 = sys.argv[3]
prog2command = sys.argv[4]

# Generate numbers
a=random.randint(1, 50)
n=random.randint(1, 10)
b=random.randint(1, 50)
c=random.randint(1, 50)

# Integration using the Simpson method
def integrate(f, a, b):
   h = (b-a)/100
   meth = lambda f,x,h: (f(x) + f(x+h))/2.0
   ival = Decimal(h * sum(meth(f, a+i*h, h) for i in range(100)))
   return ival 

# Call function
func = lambda x: eval(str(a)+'*x**'+str(n))
result = round(integrate(func, c, b), 5)
function=str(a)+'*x**'+str(n)

print('A,B:     '+str(c)+','+str(b))
print('Function:    '+function)
print('Result:      '+str(result))

# Run program and evaluate output
def runprog(command, result, f, a, b):
    start = time.time()
    answer = subprocess.Popen(command+' '+str(a)+' '+str(b)+' '+f, stdout=subprocess.PIPE, shell=True).communicate()[0].decode('utf-8')
    end = time.time()
    elapsed = end-start

    if Decimal(answer) > result-Decimal(0.00005) and Decimal(answer) < result+Decimal(0.00005):
        correct = True
    else:
        correct = False

    return elapsed, correct, answer

p1time, p1correct, p1answer = runprog(prog1command, result, function, c, b)
p2time, p2correct, p2answer = runprog(prog2command, result, function, c, b)

print('\n'+prog1+': '+str(p1time)+' '+str(p1correct)+' '+p1answer)
print(prog2+': '+str(p2time)+' '+str(p2correct)+' '+p2answer)

if p1correct:
    if p2correct:
        if p1time < p2time:
            print('\nWin: '+prog1)
        elif p1time == p2time:
            print('\nTie')
        else:
            print('\nWin: '+prog2)
    else:
        print('\nWin: '+prog1)
else:
    if p2correct:
        print('\nWin: '+prog2)
    else:
        print('\nTie')

Answer 4

Rubik's Cube Simulator

I had posted a rubik's cube question a few days back which turned out to be quite close to an existing one although I made a few amendments. This is a different question altogether.

The idea is to simulate operation of a rubik's cube.

INPUT: Take a preset sticker configuration for each face as input

Your program must interpret the configuration and suggest a list of moves to generate the said configuration from a perfect Rubik's cube.

Your program must also check if the sticker combination is an invalid one, and print an error message saying that it is not possible to generate such a configuration.

Question should probably be used as a popularity contest given the length and complexity of code, but based on response, a code golf follow-up is on the cards.

Suggestions are most welcome.

Answer 5

American Roulette

code-challenge

Roulette is one of the simplest casino games to understand, so I invite you all to see who gets the most money.

Coding

You will be supplied with a singe argument via the command line. This argument will be the amount of money you have.

[command to run your code] [arg1]

Your output must be in the following format:

[bet]|[amount of money you bet]

The following is a list of valid bets:

http://www.predictem.com/images/roulette.gif

Name                   | Example
-----------------------+-----------------------
Any number of numbers  | 12|100 or 36,19,18|100
00                     | 00|1000
0                      | 0|126
1st 12 (see image)     | 1st12|100
2nd 12 (see image)     | 2nd12|439
3rd 12 (see image)     | 3rd12|679
1 to 18                | 1-18|8
19-36                  | 19-36|10000
Red numbers            | red|1722
Black numbers          | black|1384
Odd numbers            | odd|100
Even numbers           | even|21900

Payout will be calculated using the following equation where n is the number of squares your bet will win on:

http://upload.wikimedia.org/math/6/6/9/66946b321361a701f6b6903d5eae4b44.png

In your answer, I need the name of your program, your code and a command to run it.

Winning

When enough people enter, I will run the controller twice a week. After four weeks, I will announce the winner (the person with the most money).

I realise that is may be ambiguous and/or poorly worded so any feedback on how to pad this question out would be helpful.

Answer 6

Print the Constitutional Amendment

Given a number from 1 to 27, print the appropriate amendment to the US Constitution, using this text.

Your score is the byte count of your source code, divided by the byte count of the best answer to this question in the same language. Therefore, you must use a language which had an answer to that question before September 1, 2014.

code-challengekolmogorov-complexity

Question

Is this too similar to existing Kolmogorov-complexity challenges?

Answer 7

Capture the flag

king-of-the-hill

Basic rules

There is a rectangular map of cells, each bot has current cell. Bots compete 1 vs 1 at a time, let's call them red and blue. There are N instances of red bot and N instances of the blue bot on the map. Additionally, there is unmovable red base and blue base, both having initially the red flag and blue flag respectively. Bot instances can move around, supress enemy bot instances, capture the enemy's flag. The goal is to bring enemy's flag to the base (which should have the flag). The flag can be returned back to the base. Bots can pass the flag around.

Selectable rules (to be decided)

Map style

• 2D, 3D or 2.5D;
• Wrapped-around or not;
• With walls (destructible, indestructible, buildable by bots) or without;
• Bases positions and bots initial positions: random, selectable by player, hardcoded in a map?
• Random-generated, pre-programmed, partially selectable by the player?

Bot capabilities

• Moving diagonally? Dodging?
• Seeing the entire map or only surroundings?

Intra-team bot communication

• Uninhibited
• Only using messages that takes a move to create or read and that travel not too fast;
• Inhibited (only indirect by observing positions);

Prior knowledge

• Should bots know the walls of the map from the beginning?
• Should bots know the bases posisions from the beginning?
• Should bots know enemy bots positions from the beginning?
• If communication between bots is not free, should bots know initial frindly bots position from the beginning?

Attacking

• Only nearby bots or also "shooting"?
• Multiple weapons or not?
• Dodge/protect move?
• One-hit or health points?

Abandoned flag

• Is reset to the appropriate base after timeout;
• Is reset to the appropriate base instantly;
• Needs to be carried by the bot manually;

Scoring

• Reset the game after each flag score or continue the game for N moves or N scores?
• What to do in case of stalemate?

Questions

1. Is this challenge a good idea?
2. Which set of proposed rule variants to choose?

My current choice is:

• Rectangular 2D map without wraparound, with big walls pre-programmed, random single wall-lets placed randomly;
• Bases positions are pre-defined and known in advance to all bots;
• Bots having 10 health points, carrying chainsaw (5 damage, 1 distance) and a gun (2 damage, 10 distance);
• Bots can stay&defend (half of received damage), move 1 cell to 8 directions, attack (without moving); build up to 8 pieces of wall in neighbouring cell, destroy 1 piece of neighbouring wall, capture the flag, score the goal, send a message.
• Bots can cee a 11x11 rectangle, centered around them, including through walls;
• Bots are stateful, but can't communicate with other instances directly. They can observe movements of other bots in the vision field or receive messages (if any). The message is a 4 bytes of data (i.e. a number from 0 to 2^32-1) + 1 byte of signal strength, it travels 5 cells per move, decreasing signal strength by one. Message gets received (including the current "signal strength" parameter) by all bots (including enemy ones). Bots reads the message (if any) before making a move. If there are multiple messages, only one with larger signal strength gets received. Hovewer if signal strengths differ only by 1, contect gets XORed.
• Player choses initial positions (relative to own base) of all his bots;
• All bots know the initial walls in the map;
• While the bots stays close to own base, it's health gets recovered by 1 point per move, up to 10, if the flag is present.
• Each round gets until one of the team scores 5 goals. This team wins (5-x) points, where x is number of opposin team's goals.
• Abandoned flag can be picked up by either team. All bots know relative position of the own flag at any moment.

Answer 8

A game of chance

Hello! Thought I would try out the sandbox, a rather useful tool that I haven't utilized yet! This is a game I thought up with some colleagues, basic in theory but has some deeper algorithms to win. I'm thinking of tagging this as code-challenge, any opinions welcome, especially a better name.

How to Play

Every turn, you get one number, pseudo-randomly generated, you need to put this number in a list. The list must always be in numerical order, from lowest to highest, and cannot be changed after the turn has ended. If you can no longer put the number anywhere, where it will still be in numerical order, you lose.

The list is 100 entries, which start as empty slots (seen as "-" or unique characters for your language) and slowly becomes a list of numbers (example that just lost).

Rules

• You cannot edit the position of a value in the list.
• The value will be inputted every turn.
• The random numbers are X-Y. Both X and Y will always be positive and from 0 to 65535.
• I'm willing to input the number in most ways
• Any language that I can run! I have both Windows 7 and Linux Mint + VMs for other versions.

Scoring

You get 1 point for every round you last. There are 10 (TBD) rounds for each score, resulting in a maximum score of 1000 (which is very unlikely to ever get).

Answer 9

Finding repeated words in a passage

This challenge is inspired by a question on the Software Recommendations website.

Write a program that outputs the repeated words in a passage on a paragraph by paragraph basis.

The program should take three text files as input:

• passage: contains the paragraphs to be analyzed
• blacklist: contains a list of additional pairs that should be considered as repetitions, such as: eat, ate; begin, began, begun
• whitelist: contains a list of exceptions that should not be flagged, such as the, a, an, to, for

Specifications:

• In each paragraph, find the repeated words that are not in the whitelist. The keywords in the whitelist file may be separated with commas or line breaks. You are free to choose the one that best suits your needs.
• The repetitions should be allowed to differ in case, prefixes, suffixes, declension or in grammatical number. For example: allow and Allowed, friend and friends, eat and eaten should count as pairs of repetition
• Each pair specified in the blacklist should also be considered as a repetition. You are also free to choose how the words in the blacklist are separated. Ideally, these would be copied from a table of irregularites found by a simple online search
• It should support alternate spellings of German umlauts and the "double s" character in the list files. For example: Fränze and Fraenze, Jörg and Joerg, Müller and Mueller, Gauß and Gauss. The list need only contain one of these words, but both spellings should be searched

• The output should write the paragraph number, then list the repeated words and their count. For example: 2: eat*3 + however*5 4: moreover*4 + despite*2 5: began/begun*3

  or any representation that is just as readable

Rules:

• This is a code golf challenge; lowest byte count wins
• The input file names are excluded from the byte count

Answer 10

I liked my first idea, maybe changing the game helps.

Sliding Code

A sliding puzzle, sliding block puzzle, or sliding tile puzzle is a puzzle that challenges a player to slide usually flat pieces along certain routes (usually on a board) to establish a certain end-configuration.

The fifteen puzzle is the oldest type of sliding block puzzle.

The challenge

Write a code that behaves as a sliding board. Given a configuration it should run when such configuration is solvable and not run (aka have compile/runtime errors) if the configuration is not solvable.

Rules

• The board is your code. It is a 4x4 grid with a total of 15 square tiles with side length >= 1.
• Each tile, taken alone, should output it's number in the board (from k + 1 to k + 15 with int k of your choice).

Output

Each tile should output its static value (not the actual value). The tile that outputs 13 will output 13 in every different configuration.

The whole board should output true (or 1 or whatever while it express a truthy value) if the configuration can reach the final state: ascending tile numbers on the board from left to right, up to down and the k void tile in the bottom right position.

Score

This is tile code-golf, the minimum tile side length wins, meaning a minimum score of 1 can be achieved. If a tie, the greatest k value serves as tie-breaker.

Answer 11

Facing a martian fractal

Fractals are awesome.

They can be used for a very large number of pratical purposes, from antennas to self-similarity of complex networks.

One of the most fantastic uses of fractals tough remains 3D terrain landscaping.

With such technique you can create awesome landscapes:

---

Mars is awesome.

The red planet is surrounded in a veil of mistery for its early earth-like life.

Also, as you know, is full of martians:

In this photo we are facing a martian face on mars.

---

The Challenge

Your task is to create a fractal landscape which resembles the martian face.

• The prospective can be the most convinient for you as long as the face and the landscape are recognizable.
• The output should be a few frames GIF of landcape creation, to ensure that fractal approach has been used (just like the one above).
• You don't need to use the martian face, another landscape can be used as model as long as it has a pareidolic effect of a face in it. You can also not use a model and "draw" the face yourself.
• Colors are optional. Obviously they will give a greater chance to get more votes.

Here are some other models if you are a bit short of ideas:

popularity-contest

Answer 12

Position the Border Guard

[Currently INCOMPLETE. Posting here to save.]

You are in charge of defending an island from an invasion force. To do this, you decide to place n guard posts around the perimeter of your island. You decide that the most effective way to ensure that the whole island is equally guarded is to equally distribute your guard posts around the perimeter of the island. In other words, if someone went around the perimeter your island with a surveyor's wheel, measuring the distance between guard posts walking on the perimeter, it would be equal for every guard post. For instance, if the island were a perfect circle, and I had to place 2 guard posts, they would be placed opposite to each other.

Of course, the island is not a perfect circle. We can describe the shape of the island as sequence of arcs joined together as one cohesive shape, like the clouds in this question. The one difference is that in this question, there will never be a hole in the island. Given an input in the form

n island

Where n is the number of guard posts to place and island is a space separated list of comma separated tuples x,y,r indicating the x position, y position, and radius of the circles that construct the island, output n 2-tuples indicating the x and y positions to place the guard posts in.

Answer 13

Make a Ray Tracer

A ray tracer is a program which, for each pixel in an virtual screen, traces a path from an imaginary eye through that pixel and calculates the color of the object visible through it.

Ray tracers are famously small enough to fit on a business card! Code and explanation here.

Tired of seeing ray tracers that just render a spheres or a sphere and a box and, if you're lucky, a torus? This challenge addresses this.

This task is to codegolf a ray tracer that renders a true color scene specified by arguments. The arguments are:

1. A triangle mesh, specified by the filename of an .obj mesh file
2. The diffuse, ambient and specular (more) colors for the entire mesh
3. A camera, specified by position, direction, up and field-of-view in degrees
4. A point light source, specified by position and color
5. A directional light source, specified by direction and color

The output shall be a .ppm file, which can be converted to jpg for inclusion in the answer.

There are lots of .obj files available on the Internet e.g. a teapot, cow and teddy bear and these standard test meshes.

Answer 14

Well, I suppose my last suggestion was way too complex, so here's something else.

Blade Competition (Simple Card Game)

Certain RPG's include mini games that are quite a bit simpler than board and card games such as chess and poker, not too hard to implement and understand, but still complex enough to be interesting. So let's play Blade.

Rules

Images are better than words, so here's a short video of me playing Blade. I'm not trying to win, I'm trying to show off some interesting cases. Should be self-explanatory, the goal is to get as many points as possible.

32 cards (see below). 2 players get a deck of 16 cards each (randomly). They both draw 10 cards initially and take turns discarding cards to their field. The goal is to maximize the sum of the card's values on your side of the field.

Before they start taking turns, both players draw a card from their deck and place it on their field. The player with the lower score begins. If their scores are equal, both player a new card from their decks.

When a player discard a card to his field, he loses if his new score is still lower than his opponent's score. When the player's score is higher, the game moves on to the opponents turn. When both player's scores are equal, all cards on the field are discarded, and they draw a new card from their decks as described above.

There are 9 different card. Numbered cards from 1 to 7, whose value is 1-7. And two special cards, called Bolt and Mirror, whose value is 1 when they are used as the initial card.

When a player plays Mirror, both player's fields are exchanged with each other.

When a player plays Bolt, the last card played by the opponent gets invalidated and does not count towards the score anymore. It gets removed permanently once the opponent plays a numbered card 1-7.

A player may play a "1" and discard it to re-validate his invalidated card.

See the github for a detailed explanation of the rules. This is only for reference, the rules as implemented by the controller program are final. If you think there's a bug, leave a comment.

Input

• stdin
• One line, including a newline, with a json object representing the current state of the game.
• json["file"] is the absolute path of a file you may use for storing information, it gets cleared once when the controller program is started.
• Your program (cli) gets called once for each decision it needs to make.
• That is, choosing a card to play, or choosing an initial card when there are no cards left in your deck.

Response

• stdout
• A number, including a newline, representing the card you wish to play.
• 0 corresponds to the first card in the json["player"]["hand"] array.

Scoring

• both players start with a score of 0
• N (to be decided) turns, timelimit T (tbd), for each turn:
  • Draw: score +1
  • Win: score +2
  • Lose: score +0
• Each program plays against each other program, the program with the highest score wins. I may add a few players of my own, but they won't be ranked.

Controller Program

Github

ruby controller.rb <playerfile> <timelimit> <rounds> <quiet>

See players.txt for the syntax of the playerfile. Set quiet to y to suppress debug output. Set it to n to to get a lot of information about the match, use this for debugging or if the rules are unclear. See below for a sample match with quiet set to n.

Please provide a cli line I can use to run your program on linux. I might be able to get Windows on a virtual machine.

Deck

Card_Designation Number_of_Cards (Card's Value)

1 2 (1)
2 3 (2)
3 4 (3)
4 4 (4)
5 4 (5)
6 3 (6)
7 2 (7)
B 6 (1)
M 4 (1)

(B=Bolt, M=Mirror)

Sample JSON input

• link, sample below
• newlines and spaces added for legibility
• file is the absolute path of a file you may use for storing information, it gets cleared once when the controller program is started
• lastmove is the last card played by the player / opponent, or null if no move has been made yet
• card types 1-7 correspond to the cards 1 to 7, card type 0 is Bolt, 8 is Mirror

Everything else should be self-explanatory.

{
  "file": "/home/.../cg_blade/files/basic",
  "turn": 15,
  "player": {
    "hand": [
      {
        "type": 8,
        "value": 1,
        "valid": true
      },
      ......
    ],
    "field": [
      {
        "type": 8,
        "value": 1,
        "valid": true
      },
      ......
      {
        "type": 7,
        "value": 7,
        "valid": true
      }
    ],
    "deck": 5,
    "score": 30,
    "lastmove": {
      "type": 6,
      "value": 6,
      "valid": true
    }
  },
  "opponent": {
    "hand": 2,
    "field": [
      {
        "type": 3,
        "value": 3,
        "valid": true
      },
      ......
      {
        "type": 6,
        "value": 6,
        "valid": true
      }
    ],
    "deck": 5,
    "score": 32,
    "lastmove": {
      "type": 8,
      "value": 1,
      "valid": true
    }
  }
}

Sample match

Link, sample below.

A sample match generated with the controller program and quiet set to n. A bit long, but shows a few interesting cases.

Match between both players starts.
<basic> vs. <basic>


Initializing round 0.
Each player gets a deck of 16 cards.
Player 0: 3 6 5 3 6 7 B 5 2 4 B B 5 1 B B
Player 1: 1 2 4 4 3 3 M B M 5 2 6 7 4 2 M
Each player draws 10 cards.
Player 0: 1 2 4 5 5 B B B B B
Player 1: 2 2 4 5 6 7 B M M M
Cards remaining in each deck:
Player 0: 3 6 5 3 6 7
Player 1: 1 2 4 4 3 3


Round 0 starts.


Field initialization starts.
Player 0 draws initial card.
Player draws 7, and puts it on the field.
Player 1 draws initial card.
Player draws 3, and puts it on the field.
Player 1 gets first turn.


# Number in parentheses is the total score of the cards on the field.
Turn 0 starts.
Player 1's turn.
Player 0's field: 7 (7)
Player 1's field: 3 (3)
Player 0's hand (10): 1 2 4 5 5 B B B B B
Player 1's hand (10): 2 2 4 5 6 7 B M M M
Cards remaining in player 0's deck: 5.
Cards remaining in player 1's deck: 5.
Player 1 plays 5.
Player 1 ends his turn.
Player 0's field: 7 (7)
Player 1's field: 3 5 (8)


Turn 1 starts.
Player 0's turn.
Player 0's field: 7 (7)
Player 1's field: 3 5 (8)
Player 0's hand (10): 1 2 4 5 5 B B B B B
Player 1's hand (9): 2 2 4 6 7 B M M M
Cards remaining in player 0's deck: 5.
Cards remaining in player 1's deck: 5.
Player 0 plays 2.
Player 0 ends his turn.
Player 0's field: 7 2 (9)
Player 1's field: 3 5 (8)
......
......

Answer 15

Calculate an arbitrary linear recursive sequence

in this question given a recursive definition for a sequence we need to output a formula for the given sequence.

in this question, a linear recursive sequence is a sequence of the form:

a_0 = c_0
a_1 = c_1
...
a_{m-1} = c_{m-1}

for n >= m: a_n = x_1*a_{n-1} + x_2*a_{n-2} + ... + x_m*a_{n-m}

where m, c_1 ... c_{m-1}, x_1 ... x_m are all constants.

for example, such a definition (the fibonacci numbers):

a_0 = 0 // c_0 is 0
a_1 = 1 // c_1 is 1
for n >= 2: a_n = 1*a_{n-1} + 1*a_{n-2} // x_1 is 1 and x_2 is 1

the answer may be a function and get input as two lists, one containing a_0...a_{m-1} and one containing x_1 ... x_m, and return a string, or be a complete program and get the input as a space separated numbers.

because polynomials of degree up to 5 can be solved but polynomials of degree 5 or higher can't, the solution may assume that m is smaller than 5.

the output must be a formula that given n returns a_n. if two formulas are different but both return the same output for every index, both of them can be outputted. so, for the powers of 2, both (1+1)^n and 2*2^n - 2^n can be outputted.
in the output √5 denotes the square root of 5, as does 2√5. 3√5 denotes the third root of 5.

Example input and output:

f ([0,1],[1,1]) (fibonacci numbers) can result in ((1+√5)^n-(1-√5)^n)/√5
f ([1],[2])     (the powers of 2)   can result in 2^n
f ([1,2],[1,2]) (the powers of 2 again)   

bonus:
if your solution uses no library function which solves equations, -80 bytes.

this is code golf, so smallest byte count wins

Answer 16

Fake the forecast #2

Somewhat unfairly, your boss wasn't happy with your last attempt at forecast fakery.

She's giving you one last chance, with extra stipulations.

This time your task is to draw a map, as a grid of arrows, representing both wind speed and direction.

• A grid is 8 tiles by 8 tiles.

• A tile is an arrow representing a direction and a speed.

• There are 8 potential wind directions, represented by the direction of the arrow:

  1. N
  2. NE
  3. E
  4. SE
  5. S
  6. SW
  7. W
  8. NW

• There are 6 potential wind speeds, represented by the colour of the arrow (e.g. ):

  1. 00F (<20 mph)

  2. 0FF (21-30 mph)

  3. 0F0 (31-40 mph)

  4. FF0 (41-50 mph)

  5. F00 (51-60 mph)

  6. F0F (>60 mph)

There are geographical restrictions:

• Each tile has a terrain type, land (L) or sea (S). These are:

  S L L L L L S S
  S S S L L L L S
  S S S L L L L S
  S S S S L L L L
  S S L S S L L S
  S S S S L S L L
  S S S L L S S S
  S S S S S S S S
  

• Wind speed on land may only be between 1 and 4

• Wind speed at sea may only be between 3 and 6

Variation must be gradual, specifically:

• If a feature (i.e. direction or speed) differs from one of its 4 adjoining tiles (or 3 for side tiles, 2 for corner tiles) it can only differ by one increment or decrement from that neighbour. e.g. a tile whose neighbour has wind speed 4 may have a wind speed of 3, 4 or 5 (assuming it accords with other neighbours).
• Directions can loop around, i.e. N -> NW and NW -> N. However, speeds cannot.

Because your boss is looking for believable maps, she has introduced four arbitrary restrictions:

• There is always at least 1 tile with wind speed 6
• There is always at least 1 tile with wind speed 1
• A wind speed of 6 is always northeasterly
• A wind speed of 1 is always southwesterly

Maps must be unique, don't generate the same map for different inputs.

• Input is a positive non-zero integer corresponding to the days between now and your forecast (e.g. 1 is tomorrow's forecast, 365 is a year's time).
• Output can be any format (e.g. image or text) but must take the form of a grid of arrows
• Output should be reproducible — the same input will always give the same output
• Each output must be unique from those generated using a lower input.

Because you really need to impress your boss this time, you should aim to give valid output for as many days in to the future as you can. Therefore, scoring is based on input limit:

• Your submission's input limit is regarded as 1 less than the lowest input that gives non-unique or otherwise invalid output.
• For instance, if valid and unique output is produced for an input of 1, 2 or 3 but not 4, your input limit is 3.

The winner is the submission with the highest input limit - i.e. the submission which continues to give valid and unique output up to the largest input.

There is a 768 byte limit on source code. If there is a draw the entry with the fewest bytes wins, so keep it short.

---

Here's an example of valid output (terrain shown for illustrative purposes only):

Some clarifications:

• There needn't be a relation between forecasts, consecutive or otherwise (except that they must be unique).
• Outside of a submission's 'input limit' there is no defined output.
• There are no graphical restrictions except those specified.
• You may supply the terrain definition grid as input - in which case it wont count towards your byte count
• No other input or fetching of external data is permitted
• The link to the previous question is purely in theme, no rules are carried across and previous solutions (clearly) wouldn't be valid here.
• You don't have to draw the terrain type or any other embelishments - you can if you want but it isn't a popularity contest

Sandbox Questions

• Would this question be marked as a duplicate?
• Is a 768 byte limit too restrictive? Too easy?
• Have I left any loopholes?

Answer 17

Translator to Minimize the Number of Characters

With code golf you are attempting to minimize the number of characters or bytes. The languages are, however, all just ASCII characters. While I do not want to see this in other code golf challenges, can you use more exotic characters to do the job?

CJam, for example, only uses ASCII characters in its code but many other characters can be placed into the compiler as a strings. I wrote a simple translator to test this out which can be coverted to:

㉕ァײோ¸༘ݩײ౲ᖒⲫ㶚ቲ㑼ᇦ㰌⧑༘ઃ௉ⲫ௔ྭഞࠗ㒍⾺

While this is intentionally not an acceptable answer for various reasons, it shows the range of possible characters the interpreter can identify. Please note unusual things that happend as you attempt to highlight the text.

The Challenge

1. Choose an online interpreter such as Ideone, CJam, or Golfscript and a language which can be run on that interpreter. This is so I know I am using pretty much the same resources as you are when I run your answer.
2. Create a translator in your stated language which accepts an "original" input code from the same language. It then outputs a string which can be pasted in your answer or in a comment on this site.
3. Create a second translator into which the previous output string can easily be incorporated. When this combined string and translator are run, it will run the original input code.

Please note:

• The original input code to score your answer will be the same for any answers of the same language.
• This code for scoring will be subject to change and the translator must work for any code of that language the interpreter accepts. (exceptions listed below).
• This code for scoring will only contain ASCII characters and I will attempt to take it from existing answers on this site. At request it can exclude line breaks or specific characters for an additional 5% to your score AT MY DISCRESION (for instance Java code needs to be able to have spaces in it, I can't avoid that).
• The input code for scoring will be roughly 500 characters long. However, you transltors need to work regardless of the length of the input code so you can't take advantage of the fact that the code is even/odd. It does not need to work for null input.
• Any errors or anything malicious will obviously be disqualified.
• The compressed code must be copy/pastable to codegolf SE.
• When running the code from its translated form, the code must be able to accept input. This input is not going to be part of the code to be translated.
• Any null case which does not compact the original code in any way is disqualified.

Scoring

• Minimum score wins (surprise surprise)
• Score is the number of characters you need to run the original code minus the number of characters in the original input code plus 500 (combined with any modifiers).
• The length of the original translator does not matter.
• 5% is added to your score for each character/symbol your language often makes use of but your translators cannot handle. I can disqualify for this if I believe that the missing character too severly cripples the programmer.
• 5% is removed from your score if your two translators are the same piece of code (aka the translation is reversible).
• 5% is removed from your score if all characters in the compressed output are visible (no invisible ASCII characters). White space (spaces, tabs, line breaks) are visible but ASCII character 19 (for instance) is not.
• 3% is removed from your score if all characters are visually distinguishible (no two characters look the same but are read differently by the interpreter). The more obvious this is the better.
• 10% if anyone provides an acceptable example input code where the score without modifiers would be longer than the original input code. This would mean the translator effectively did not compress the input code.

Answer 18

Sudden Death Rummy

codegolf with following rules: A 50 game match is played and the winner gets an average score per game. This average score is then multiplied by the bytecount of the program. The winner is the program with the lowest product of average score and bytecount.

Rummy is a card game where the objective is to get rid of all cards in your hand by forming "melds". A meld is either a consecutive series of cards in the same suit, or 3/4 cards of different suits of the same value, which is, in ascending order A(ce), 2-10, V(alet), Q(ueen) or K(ing). A meld is always at least 3 cards, and 13 cards at the most.

In my regional variant of discard rule Rummy, there are 7 rounds. the first 6 rounds require you to put down N+2 cards in 1 or more melds, then discard 1 card, then finish your turn, before you can start using existing melds or put down new melds. in the 7th round, you NEED to be able to place down your entire hand and discard the one card in 1 turn, before your opponent can do this. You start with 10 cards, and every turn you cannot empty your entire hand, you draw another card and give the turn to the opponent. The actual system involves buying cards and bidding wars, but to simplify, it's just round robbing cards until one of them finishes.

---

Your task: Create a Rummy bot that plays against itself.

Input: a number between 1 and 100 denoting how many games should be played.

your program needs to generate 2 random legitimate hands as the first task. The deck starts with 104 cards: 2 full decks, 4 suits per deck, 13 cards per suit. 10 cards per hand from the deck.

second task: one hand randomly starts. If the program cannot make a legitimate Sudden Death Rummy hand clear, it draws a random card and hands the turn to the other hand. If the program CAN make a legitimate hand clear, it displays 2 lines. The first line is a comma-separated list displaying the winning hand clear. The second line is the sum of the value of the cards of the other hand, with number cards being their respective value and A/V/Q/K being 10 points each. this task switches between players until one of them is the winner. If the game lasts long enough for the deck to be depleted, no victor is declared and both hands get scored according to the above rules.

3rd task: after a victor is chosen, the next game starts. task 1 and 2 are repeated until there have been as many games as the input indicates. At this point, the match ends. The victor is the side who has the lowest amount of points after the end of the last game.

[Sandbox Note: I need to: Figure out a scoring method that doesn't require multiplying or averaging average score and bytecount without encouraging high bytecounts or average scores; decide whether to include a runtime limit; Decide whether the program should also display the hand and drawn cards.]

Answer 19

Build a Version Control System [WIP] code-golf

Git, SVN, Mercurial and Bazaar are just too bloated for you. You want something simple. Something as short as possible.

Rules

• Your program will be invoked every time an operation needs to be made to the repository.
• Your program must take commands from command-line arguments.
• The implementation of how the program stores its own data does not matter. Input and output format do.
• Give your version control program a name and version numbering (so I can keep track of when you update it).

Repositories

A "repository" is a directory with files and directories in it, as well as (a) special file(s) that store settings and information for the repository. These special files may not be included in version control. All other files in that directory should be included in version control.

Features

• 'init' command - sets up a repository in the working directory
  • [BONUS 20pts] If a repository already exists in the working directory, erase or reset it first
• 'destroy' command - removes all of your special version control files from the repository. If you are not in the root directory of a repository, keep moving up one level until you find VCS files. If you reach the top level of the filesystem without finding your VCS files, don't do anything.
  • [BONUS 15pts] Exit with status 1 if no VCS files are found

Scoring

Your score is the length of your code in bytes, minus all bonuses. Lowest score wins.

Answer 20

Unbreakable Wall Maria

code-golf AND ( graphical-output OR ascii-art )

In order to protect the last bastion of human civilisation against giant Titans, a large wall has been constructed around the perimeter of the city. It has been decided that another large wall, within the perimeter of the first one, will be erected to ensure the protection of the city. You have been assigned to design the wall to make sure it is strong and sturdy.

A wall of height p and length q is built out of identical rectangular blocks of height m and length n. A wall is considered unsecure if there is a straight line that can divide the wall into two pieces without cutting through any of the individual blocks. To illustrate, consider a wall of height 5 and length 6, constructed of blocks of 1 height and 2 length placed in either orientation. This is the test case 5 6 1 2 (a 5x6 wall composed of 1x2 blocks). There are at least two different ways of building this wall:

Diagram 1: Ways of building a wall

The first wall is an insecure wall because there is a line that divides the wall into two pieces (into a 6x4 block and a 6x2 block). Because there is only one line that divides the wall, we can call this wall an insecure-1 wall. An insecure-1 wall is more secure than an insecure-2 wall, but not as secure as a secure wall.

The second wall is a secure wall because there is no line that can divide the wall into two pieces without going through any of the blocks. You could also think of it as insecure-0 if you wanted to.

A secure wall is essential to the integrity of the wall. If it is an insecure wall it will be easily breached by the Titans. Your task is to design the wall. To do this, you will write a program that takes in the height and length of the wall and the blocks as input, and output (a graphical representation / an ASCII art representation) of the most secure wall that can be created using the blocks given.

Input

Input consists of four space seperated integers p, q, m, and n, which represents the height of the wall, the length of the wall, the height of the blocks, and the length of the blocks.

Output

This is the part I'm not sure about. I've got two possibilities: either I can make the question graphical output (i.e. I would expect the program to output an actual image), or ASCII art.

Possibility 1:

Output a graphical image (not ASCII art) of the wall. The overall appearance of the wall (e.g. line thickness, colours used, size, etc.) is up to you, but the lines that form the individual blocks must be clearly visible, and differentiated from the rest of the wall. This means you can't pull something like "this draws a black wall with black lines", or "this draws an infinitesimally small scaled wall", etc.

Possibility 2:

Output text based art (not a graphical image) of the wall. It should be drawn using the box drawing characters. The wall must be drawn to scale, but apart from that, you have some freedom in what characters to use (so you can choose to use the double line ones if you wish), but they have to be part of the Box Drawing Unicode block. In addition, the wall must be visible, so you can't write a program that outputs nothing and say "this draws an infinitesimally small scaled wall", etc.

Question to reader: Which output format do you think would make a more interesting challenge?

Answer 21

One digits or two digits

king-of-the-hill

Here’s the rule:

They're 2 players. Each player has a pool of $99.

The player that takes the first turn will choose to invest an amount of $$$ taken (deducted)from your own pool. Then other player will do the same.

Who invests more wins the round. Who wins the most round is the match winner.

Unless it’s not that simple.

They’re a few twist:

Your opponent know how many points you use, well almost.

After you invest, your opponent know if you invest one digit number or two digit number. They’re told instantly after you invest your points. Just one or two digits. Not precisely.

WARNING: Player who moves first still get notified about your opponent who moves second.

Your opponent know how many points you still have left in your pool, well almost.

They’re only told if you have either $0 to $19, $20 to $39, $40 to $59 points, $60 to $79 points or $80 to $99. They’re told instantly after you invest your money.

WARNING: Since the notification is instant, that means if I move second, I got to know your score level before I move. If I notice a level change when you move first, I will know the level change before I make my move second. So I can act according to it.

It’s best of 9, and those $99 must survive those 9 rounds.

So you don't want to invest all $99 in round 1. Well, it doesn’t mean that you have to spread those $99 exactly in 9 rounds. You can use those $99 in any mean to get victory. If you have a sure-fire strategy that will give you a guaranteed win, but it needs you to use all your $99 in the first 5 round, by all mean, go. Just remember that invested point don’t return back to your point pool, win or lose.

In first round, the player who moves first decided randomly. In following round, the player who wins previous round moves first. If tie, the player who moves first last round, moves first again

---

SCORING METHOD

Each bot will be run double robin. The winner of the match results 1 point. Tie 1/2 point. Lose 0 point. After the match up, bot with most points declared as champion

---

COMMUNICATION PROTOCOL

During your turn, I will run your program and gives you lines of query from STDIO

Each line is a query of this following type:

START

Every input start with this.

YOU xx

This means that in that round, you played xx(exact number of dollar you invested)

ENEMY x y

This means enemy invest x digit int that round (x is 1 if enemy invested 1 digit, x is 2 if enemy invested 2 digit) and y is the money level after the player invests(y is 0 for $0 to $19, 2 for $20 to $39, 3 for $40 to $59, 4 for $60 to $79, 5 for $80 to $99)

FINISH

End of query. We expect you to give us output.

Your output must be to stdout and a single positive integer (0 is allowed)

---

EXAMPLE:

The match is between DEO vs WORLD. It was decided that DEO moves first.

ROUND 1

Deo will receive this query:

START
FINISH

Deo decides to invest $10. Now he only has $89.

WORLD receive this query:

START
ENEMY 2 5
FINISH

What WORLD deduces is that DEO played from $10 ~ $19. WORLD knew that DEO played at least $10 because the query said that ENEMY 2.. and WORLD knew that DEO played at most $19, because if DEO played $20, the query will be ENEMY 2 4

WORLD decides to invest $20.

In round one, DEO invests $19 while WORLD invests $20. Since WORLD invests more, WORLD receive 1 point.

Enter to round 2: WORLD starts first, since winner starts first by the rule

WORLD receive this query:

START
ENEMY 2 5
YOU 20
FINISH

WORLD decides to invest $0.

DEO receive this query:

START
YOU 19
ENEMY 2 4
ENEMY 1 4
FINISH

DEO realizes that in round 1, enemy played at least $20, due to level change. And he noticed that in round 2, enemy played 1 digit number. DEO taught that WORLD decides to save his money and invest $0. DEO decides to invest $1

WORLD invests $0 while DEO invests $1. Since DEO invests more money then WORLD, DEO win 1 point.

And so on

Answer 22

Traffic lights

Easy challenge

Write a program that that graphically shows traffic lights on a crossroads. It should output animation. There should be red, red+yellow, green, blinking green, yellow. Bonus - pedestrian traffic light.

Complex challenge

Write a program that manages traffic lights in a town. Input is a graph of roads, information about where people want to drive (i.e. in morning they mostly drive at work, in evening they return home) tied to the graph. The system models cars and reports you current positions and speeds of each car. Drivers' goals are to be inferred from statistics. Your goal is to provide the most optimal operation mode of each individual traffic light, avoiding accidents.

Questions

• Which tags to use? Should it be a code-golf?
• Which is more viable - the easy or the complicated challenge? Should I try to work the complicated one to be more CodeGolf-worthy?

Answer 23

My telephone is a computer!

code-challenge algorithm primes

I finally took the plunge and purchased a push-button telephone. It seemed a waste to just bin the old telephone, so I got working with some surplus chips and boards and things, and a soldering iron, and made it into a computer!

Now I need a program. DialCode(c) can do Prime Numbers! I think.

So I need some help with an algorithm for Prime Numbers, with the following limitations:

10 variables, which can contain any number from zero upwards, limited only by 32,767; (Var0 - Var9)

10 labels; (Label0 - Label9)

10 Machine Instructions;

EndBlock: Ends a block - if the block was actioned, implicity Continue Main is executed, 
otherwise continues with next instruction (EndBlock) 

Test > 0: Starts a block, can test multiple variables (If > 0 Var0 ...)

Test = 0: Starts a block, can test multiple variables (If = 0 Var0 ...)
 
Set variable to another variable (Var0 = Var1)

Set variable to 1 (Var0 = 1)

Set variable to 0 (Var0 = 0)

Increment variable by 1 (Var0 +)

Decrement variable by 1 (Var0 -)

Unconditional branch to label (Br Label0)

Continue MAIN (Continue MAIN)

Output variable (Output Var0)

Instructions prior to the first Test are executed only once, at the start of the program.

Continue MAIN can be within a block or a "special case" unconditional use which is the target for the completion of a non-nested block.

The first Test defines MAIN.

MAIN is executed an "installation setting" number of times. These are 10 for Testing, and 1,200 for Production.

A Test can define an internal block if appearing before an EndBlock. The completion of an internal block does not cause automatic iteration (but an explicit Continue MAIN can be used for that).

All variables are initially zero.

Example program

Var1 = 1 
If > 0 Var1 Var3 
    Var2 +
EndBlock
If > 0 Var2
    Var1 +
    Var3 +
EndBlock
Var2 +
Continue MAIN
Output Var1
Output Var2
Output Var3

MAIN is defined here by the first IF > 0. The first test is not true. The second test is not true. Var2 gets one added, and MAIN starts up again (the unconditional Continue MAIN). The first test is still not true. The second test is now true, and Var1 and Var3 get one added. Since the block was executed, there is an implicit Continue MAIN. From this point on, the first IF > 0 will always be true, its block will be executed, with another implicit Continue MAIN so the program will finish quickly.

The above program demonstrates how to implement a "case-like" structure. Put another way:

Var1 = 1
BlockControl repeat 10 times
  case
    Var1 > 0 And Var3 > 0
      Var2 +
      break
  case
    Var2 > 0
      Var1 +
      Var3 +
      break
  case
    other
      Var2 +
EndBlockControl
Output Var1
Output Var2
Output Var3

The output from the program will be 2, 9, 1.

Algorithm can be demonstrated in any language, even pseudo-code (if guaranteed to work). Explanations will probably make your Answer more popular.

It is not required to write an emulator of the CPU, only to limit your choice of instructions in your language to those logically equivalent to what is supported by the CPU. DialCode(c) itself is a subset of your language (subject to differences in syntax)!

There is no input. Output can be whatever is convenient. Feel free to use any specialist libraries, as long as they follow the above limitations.

The Winner must work to the limitations. The most popular working algorithm will be chosen. Where submissions are effectively the same algorithm, the one posted first, which I was able to understand, is the tie-breaker.

Sandbox Questions

I can't find a question here about generating Primes only using addition and subtraction. I know one way to do it, so all the guff above is to funnel thought towards a known solution. The solution I've seen uses 10 variables, 10 or fewer types of instructions, and Labels are fun, but not necessarily necessary.

Not sure of a reasonable time-limit to impose before the Accept.

When I came across an algorithm for this, I thought it was really cool. Very easy to implement without knowing how the algorithm actually works, difficult to come up with the algorithm. Great fun finding out how the algorithm works.

I would like to see a wide range of answers in a lot of languages, so that even fairly inexperienced users can have a crack at implementing. That's not going to work with one question, because I don't think it is an easy type of algorithm to develop (without foreknowledge or practice).

So I was thinking one question to get an algorithm, a second question for implementation. I was thinking of "fastest code" but that puts Assembler/compiled languages/others as the natural rankings for that.

Prompted by a comment by @isaacg, I'm now thinking "total number of DialCode(C) instructions executed" may work for a follow-up implementation question.

So, Question One - get a nice algorithm. Question Two, implement in as few DialCode(C) instructions as possible.

Any implementation is going to be Ssssslllllooooooowwwwww, with a capital S. Fewest DialCode(C) instructions is fastest code, whatever language the DialCode(C) is written in. Reasonably level playing field.

I'll have a go at the suggested shortening of the question :-)

Answer 24

This is an idea for an incremental answer-dependent question. I'm interested in comments. I will keep it here for a while and probably reword it at some point.

---

Print the name of the language of the previous answer

restricted-sourcecode-golf

The first answer to this question must print the name Code-Golf without using any letters in Code-Golf.

Each answer that follows will have to print the name of the previous language, but without using any characters in the previous program (you can use letters in the language name, but not the code they posted). Each language can only be used once.

The winner is whoever posts the most valid answers. If there is a tie, then the length of each program is added together, and the answerer with the smallest total length is the winner.

---

The main problem I see with this is that multiple people would be racing towards the next answer. Allowing people to still post answers they worked on would cause clutter, and if people sign up to be the next answerer, we could be waiting forever for one to post. You could possibly have another question for answers that were too slow.

I would also need a rule against posting extraneous characters in your program that makes it impossible for the next one.

Answer 25

Elevator Controller

---

Sandbox Note

• I would love some feedback about whether you think this has enough room for algorithmic finesse to stick with code-challenge or whether it should be code-golf.
• Any kind of early questions or ideas are welcome, too.

---

Introduction

Every day on my way to work I have to take one of two neighboring elevators – and often, they are not currently on my floor, so I have to press a button and wait for it to stop by. Ever so often, I get the feeling the software behind these elevators was written by an army of monkeys who finally managed to type some program that would compile.

But it makes me think: isn't there a more clever way to manage elevators? Maybe you can help me make my way to work less annoying by implementing a new controller software!

The Challenge

You must write a complete program that takes input from stdin (or similar) and print to stdout (or similar). Your program will receive the following arguments:

• The first line consists of two space-separated numbers:
  • The number N of neighboring elevators your software will have to manage.
  • One integer H specifying the number of the top floor level for the building (the ground floor level is marked 0, so H = 5 means there are six stories).
• All subsequent lines of input are a space-separated list of two numbers in the range [0, H] with the following meaning:
  • The first integer specifies the level on which a passenger is requesting an elevator.
  • The second integer specifies the level this passenger would like to get to.

During each time tick, your program must print (to stdout or similar) one line with N characters wherein each character specifies what an elevator does (from left to right = first to last elevator). The following commands are available:

• D for "Move elevator one level down."
• U for "Move elevator one level up."
• S for "Stop the elevator on this level." This command allows any number of passengers to enter or exit the elevator on this level. This will happen automatically and people will only exit the elevator on the level they want to get to.

Furthermore, all elevators are rather small and have a maximum capacity of 2 people. So no elevator can take more than two people. Since people are generally nice, they apply a first come, first serve pattern. Passengers who are "too many" will just wait the next turn.

If two (or more) elevators happen to stop on the same level with people waiting to enter, they will start filling up the elevators from left to right.

All N elevators will start on the ground level – 0 – upon start of the program.

As always, standard loopholes apply. No cheating, no networking etc. If possible, please submit your answer with a link to an online interpreter or instructions on how to run it.

Example

Input:

2 3
2 0
3 1

Possible Output:

UU
UU
SU
DS
DD
SD
SS

Here are more examples, but to keep the post short, newlines are represented as | and input/output is separated by #:

2 3|0 1|0 2|0 3 # SS|UU|SU|UU|SS|US|SS

1 2|0 1|1 2|1 0|1 0 # S|U|S|U|S|D|S|D|S

Scoring

This is a code-challenge. There will be an unknown test case which I will only reveal after having accepted the winning answer (so you can make sure I didn't make scores up), but not before as to prevent answers optimizing for that test case only.

The score will be the number of steps your submission prints (= number of lines of your program's output). The lowest score wins with votes as a tiebreaker.

Verification

You may use the following snippet to verify your submission:

TODO (I will write this once I plan on publishing this question)

Answer 26

The Invincible Rock Paper Scissors

underhanded popularity-contest

Make a bot that plays Rock Paper Scissors with the player. The bot should prompt the user for input (either rock, paper, or scissors) and then output the result. The result should include the user's hand, the bot's hand, and who won. An example of an acceptable result output would thus be:

I played rock! You played scissors! I won!

Another acceptable output:

The bot's rock beat the player's scissors.

This is the underhanded part: the bot should always win. However, the player has access to the source code of the program, so you should try and make the part of the code that causes the bot to always win as inconspicious as possible.

Here is an example in Python 2.x. If it were posted, it would not get many upvotes because it is extremely obvious that the bot will always win. A better answer would appear to be fair to the player, but in fact still causes the bot to win every time.

user_choice = raw_input("Pick a hand (rock, paper, or scissors)...")
if user_choice == "rock":
    print "I played paper! You played rock! I won!"
elif user_choice == "paper":
    print "I played scissors! You played paper! I won!"
elif user_choice == "scissors":
    print "I played rock! You played scissors! I won!"

Concerns

My main concern with this challenge is that it may be a close duplicate of random script that isn't actually random. I am not sure if the requirement for having a different output for the user's input (while maintaining the illusion of randomness) is enough to differentiate this challenge from the original underhanded random challenge. Feedback on this issue is appreciated.

Answer 27

Calculate the Delacorte Number of a square - posted

code-golf math

Answer 28

Lua Variables From Arguments?

In this question I challenge you to get variables from function arguments in Lua. The least amount of characters wins.

Basically I'm asking for you to create a function that takes an argument, and prints out the variable as a string.

Please note it has to work in a standalone Lua console.

Answer 29

Number Datasheets code-golf

Write a program that accepts an integer n where 1 < n < 10000 and prints some facts about it. Each fact must be on a separate line, and in the order shown here.

• even or odd
• prime or composite
• deficient, perfect, or abundant
• square if it's a perfect square
• cube if it's a perfect third power
• fourth power if it's a perfect fourth power
• fifth power, sixth power, etc. as appropriate (each on a separate line)
• square-free if it has no factors that are perfect squares (except 1)
• triangular if it's a triangular number
• pentagonal if it's a pentagonal number
• hexagonal, heptagonal, octagonal, nonagonal, decagonal as appropriat
• 11-gonal, 12-gonal ... k-gonal. However, these should only be printed if k is less than n or if k is less than 10. In any event, each of these term is to be on a separate line.
• x totatives where x is the count of the numbers between 0 and n that are coprime to n
• lucky if it's a lucky number
• Fibonacci if it's a Fibonacci number
• Lucas if it's a Lucas number
• Leonardo if it's a Leonardo number
• repdigit in base b if it's a repdigit in base b, where 1 < b < n-1
  • If it's a repdigit in multiple such bases, instead print repdigit in base b, c, d
• strictly non-palindromic if it's not a palindrome in any base b where 1 < b < n-1

Any feedback would be appreciated.

Answer 30

Math golf

This challenge is about writing code that outputs the smallest formula possible for a sequence of position integers.

Input

I will choose 10 from the following test sequences of positive integers. However, please do not hardcode these into your answers. If I suspect this has happened, I reserve the right to change the test sequences without notice.

Your code should accept standard in with one list of comma separated sequences per line.

1, 2, 7

12, 9, 7, 5

40, 25, 16, 10, 7

2240, 1225, 679, 373, 213, 149, 141, 133

8064, 3969, 1969, 974, 494, 254, 164, 134, 119

118272, 53361, 24196, 10958, 5027, 2399, 1271, 863, 746, 695, 668, 665

1, 4, 36, 400, 4900

96, 1280, 17920, 258048, 3784704, 56229888, 843448320

72, 800, 9800, 127008, 1707552, 23557248, 331273800

40, 224, 1064, 3808, 21280, 59200, 322600

2240, 832, 240, 72, 20, 6, 3

53760, 17152, 4480, 1248, 384, 104, 44, 22, 11

329472, 86656, 20800, 5536, 1536, 440, 124, 44, 19, 8, 4

32800768, 6856704, 1536000, 394752, 103936, 27136, 7936, 2080, 656, 264, 132, 66, 33

206389248, 33216512, 7029760, 1743360, 448000, 112640, 30144, 8288, 2096, 688, 284, 102, 46, 18, 9

20956446720, 2527756288, 510181376, 122363904, 30720000, 7643136, 1972224, 508416, 136192, 35456, 10816, 3296, 1360, 632, 292, 146, 73

Output

A math formula per input line which maps an index n starting at 1 to the relevant value.

A formula can be made up as follows. It can consist of the sequence variable n, integer constants, *, /, -, +, !, (, ), ^ or (m,k). These are to be interpreted in their normal mathematical sense with (m,k) to be read as binomial(m,k). The formula has to be well formed with, for example, parentheses matching and the order of precedence of operators will be the usual mathematical ordering.

A special rule applies to the factorial function ! which requires parentheses if the ^ or ! operators are to be applied to the result of the factorial. I.e. it is (n!)^2 and not n!^2. Note that the !! is never allowed. Unary - also requires brackets if any further operator is applied to the result on the left hand side or if the result is to be raised to a power. For example it is n*(-1) and not n*-1.

Score

I will test your code on a number of sequences of integers that I make.

The score is the sum of the number of characters in all your outputs.

Example output

For the sequence that starts 96, 1280 above, the output 4^(n+1)*(2*(n+1))!/((n+1)!)^2 gives a score of 29.