What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on 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.

To post to the Sandbox, scroll to the bottom of this page and click "Answer This Question", or click on the "Add Proposal" link below. Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. 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.

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily


3285 Answers 3285

60 61
63 64

Navigate My Time Machine

This is a pretty broad idea, but time travel is a lot cooler than space travel. The basic idea is that the program will have to sort out the path of various objects through time, given certain constraints as to what must be where, when.

There are a few different models of time machine that could be used, based upon which type of time travel we want to use.

One possible example is the time travel model used in the film Primer. Notably, the machine must be turned on before it can be used. I find this model to be fairly "realistic," if that term can be used in regards to time travel.

enter image description here

There would also be the requirement of conservation of mass. If there there are multiple copies of an object, then "the number of forward-moving copies" - "the number of backwards-moving copies" = 1. The most important point is that there is a single "unified" timeline.

One idea is to create a long list of various objects, listing the known sightings of each one. From this list of information, the program must sort out the path of each object through time, ensuring that each duplicate object is accounted for and that conservation of mass is obeyed.

Additional ideas include determining how much additional aging each object has experienced as a result of the time travel.


Design Logic Circuits with CSWAP Gates

A universal logic gate is a logic gate is one that is capable of creating any other logic gate or circuit. For example, it is possible to wire together dozens of NAND gates to form any logic circuit you so desire.

Beyond a universal gate, a reversible logic gate is one whose (multiple) outputs can be used to determine the input. One notable reversible universal gate is the Fredkin Gate, also known as the CSWAP gate. This gate has three inputs and three outputs, yet is very simple. CSWAP stands for "controlled swap" and describes exactly what the gate does. If the first input is a 0, the three outputs are the same as the three inputs. If the first input is a 1, the second and third outputs are swapped.

Here is the ever-so-important truth table.

in  | out
000 | 000
001 | 001
010 | 010
011 | 011
100 | 100
101 | 110
110 | 101
111 | 111

The Challenge

You goal is to write a program that takes a truth table as input and constructs a logic circuit to match it. (other ideas are taking a non-CSWAP circuit as input and converting it to CSWAP).

Here are the rules of circuit design:

  • A circuit has a certain number of inputs and outputs, the quantities of which will be given.
  • You have an unlimited supply of CWAP gates with which to construct circuits.
  • You also have an unlimited supply of constants (a source that always takes on the assigned value) and trash bins (a place to send an unneeded bit).
  • Each data source (circuit input / gate output / constant) must be linked via wire to exactly one data sink (circuit output / gate input / trash bin), and vice-versa.
  • Possible extra rule: no loops in the circuit.

ASCII representation

Using ASCII to draw the circuits may be unnecessary, but here is how it could be done.

  • Wires are - and |, which connect the two horizontally or vertically adjacent cells.

  • Inputs are capital letters, while outputs are lowercase letters. Constants are 1s and 0s. Trash bins are #.

  • CSWAP gates are formed by OXX in any of the four basic orientations. The O is the control, while XX are the two inputs/outputs to be swapped. I might need to adjust this so that adjacent gates with multiple orientations are unambiguous.

AND gate


NOT gate


(more details coming sometime not now)


Game Of Riches

This is a programming challenge based off the game AdVenture Capitalist.

Goal Of The Game

The goal is to have the most angel investors after 1 month (2,592,000 seconds) of gameplay.

Angel Investors

Angel Investors are the primary way to increase your profit in the long run. Angel Investors can be sacrificed for Angel Upgrades. Angel Investors also increase your profit by ANGEL_EFFECTIVENESS% each. For example, 20 angel investors increase your profit by 40%. You earn Angel Investors in proportion to the square root of your life earnings. The catch is that Angel Investors can only be used after a reset.

ANGEL_EFFECTIVENESS is 2 by default. It can be increased by unlocks and upgrades.

Angel Investors are earned according to this formula: 150 * sqrt(LIFETIME_EARNINGS / 1e15)


You earn money through the use of businesses. Money is used to purchase businesses and upgrades. The more money you have earned in your lifetime (since your program started execution), the more angels flock to your cause.


Businesses can earn you money. There are 10 types of businesses. The price of a business increases exponentially. You can also earn unlocks by achieving certain numbers of businesses. You start with 1 lemonade stand.

Name               |    Base Price   |  Base Profit / second  | Price Increase per Purchase
LEMONADE_STAND     |              $4 |                  $1.66 | 7%
NEWSPAPER_DELIVERY |             $60 |                    $20 | 15%
CAR_WASH           |            $720 |                    $90 | 14%
PIZZA_DELIVERY     |          $8,640 |                   $360 | 13%
DONUT_SHOP         |        $103,680 |                 $2,160 | 12%
SHRIMP_BOAT        |      $1,244,160 |                 $6,480 | 11%
HOCKEY_TEAM        |     $14,929,920 |                $19,440 | 10%
MOVIE_STUDIO       |    $179,159,040 |                $58,320 | 9%
BANK               |  $2,149,908,480 |               $174,960 | 8%
OIL_COMPANY        | $25,798,901,760 |               $804,816 | 7%


Unlocks are bonuses that are earned when a set goal has been achieved.

Example list (not actual):



Upgrades are bonuses that are purchased with money or angels. See Angel Upgrades for details on upgrades that are purchased with angels.

Example list (not actual):


Angel Upgrades

Angel Upgrades are bonuses that are purchased with the sacrifice of angels. Angels sacrificed for this purpose are not regained on reset of a game.

Example list (not actual):



When you reset your game, you lose all unlocks, upgrades, businesses, and money that you had. You start out with 1 lemonade stand all over again. So why would you want to do that? Because all angels that you may have earned last session are now activated. The angels that you didn't spend last session are also carried over. With these angels, you can earn larger profits faster than those earned in last session.

Lifetime earnings are not reset when you reset.

The angels gained with reset is 150 * sqrt(LIFETIME_EARNINGS / 1e15) - ANGELS - ANGELS_SACRIFICED

Bot Details

Your bot will be an independent program that sends and receives input and output through stdout, and stdin. They are allowed to write to and create files in the directory that they are in. All files that they create must be destroyed on death of the program. The program must be deterministic. If the program does not finish the game within 5 minutes, it is disqualified.

Your bot can send through stdout requests for information. Here is a list of each request along with the reply:

Request                                                                                    Reply
TIME                                                                        game time in seconds
TIME_LEFT                                                              game time left in seconds
MONEY                                                                               cash on hand
LIFETIME_EARNINGS                                                              lifetime earnings
ANGELS                                                                             active angels
ANGELS_SACRIFICED                                       number of angels sacrificed in life-time
ANGELS_GAIN                                   number of angels that would be gained with a reset
COUNT type†                                                                       number of type
COST type†                                                                     cost of next type
PROFIT type†                                                               profit of all of type
UPGRADE or CASH_UPGRADE                                     the next cash upgrade you can afford
ANGEL_UPGRADE                                              the next angel upgrade you can afford
UPGRADES                                              the newline separated list of all upgrades
CASH_UPGRADES                                    the newline separated list of all cash upgrades
ANGEL_UPGRADES                                  the newline separated list of all angel upgrades
UPGRADE id                                                         the description of an upgrade
NEXT_UNLOCK type†                                                 the next unlock with type type
UNLOCKS                                                the newline separated list of all unlocks
UNLOCKS type†                           the newline separated list of all unlocks with type type
UNLOCK id                                                           the description of an unlock


These commands return no value:

Request                                                                                                  Action
WAIT seconds                                                                              warps forward in time
WAIT_MONEY x                                                                     waits until you have x dollars
WAIT_ANGEL x                                                                      waits until you have x angels
BUY type amount                 purchases items one at a time, waiting as needed until you can afford each item
RESET                                                                                        resets the session
BUY_UPGRADE id                                                                             purchases an upgrade
If you can't afford the upgrade it will wait until you can afford it if it is a CASH upgrade or will return 
immediately if it is an ANGEL upgrade

Format of an upgrade string: id;purchased[5];typeOfUpgrade[1];cost;bonus_string
Format of an unlock string: id;achieved[5];typeOfUnlock[2];amountNeeded;bonus_string
Format of a bonus string: type[3];subtype[4];amount

If subtype is PROFIT or COST, the bonus is applied multiplicatively, otherwise the bonus is applied additively.

[1]: One of CASH, ANGEL
[4]: EFFECTIVENESS if type is ANGEL; otherwise one of COUNT, PROFIT, COST
[5]: One of true or false




Your score is determined as log10(ANGEL_TOTAL). The person with the largest score wins the contest.

ANGEL_TOTAL is determined by adding all active angels, sacrificed angels, and the number of angels you would gain with a reset.



tag: code-challenge

  • 2
    \$\begingroup\$ This is a very long post and only about 25% complete. It would really benefit from reformatting to take less space. Why not represent the companies in a table, and have parameterised commands to get the number, cost, and profits of company type X? \$\endgroup\$ – Peter Taylor Mar 19 '15 at 2:24
  • \$\begingroup\$ Is the number of angels gained by a reset 150 * sqrt(lifeTimeEarnings / 1e15) or 150 * sqrt(lifeTimeEarnings / 1e15) - ANGELS - ANGELS_SACRIFICED? \$\endgroup\$ – Peter Taylor Mar 20 '15 at 8:39
  • \$\begingroup\$ @PeterTaylor It's the latter :) \$\endgroup\$ – TheNumberOne Mar 21 '15 at 0:13

Children Sum Game

When I was a kid I liked to play a sum game with my cousin (I don't know if there's a name for the game).

The first player choose a number between 1 to 9, then by turns players go summing a number between 1 to 9 to the result until one is able to reach 100.

So, the challenge consist in create a program to play this game. The program has to choose randomly if the human or the computer starts the game. The player should input the sum of a number between 1 to 9 and the previous result and the program should check if the sum is correct. Then the program should sum another number between 1 to 9 and give the result. Finally it should display a message.

Here's a example of the game, suppose computer starts:

Computer: 5
Player: 12
Computer: 18
Player: 25
Computer: 30
Player: 39
Computer: 42
Player: 55
Computer: Incorrect sum!
Player: 48
Computer: 57
Player: 65
Computer: 73
Player: 82
Computer: 90
Player: 92
Computer: 100
You lose!

Ideally, the program should have a strategy to make it difficult (for a kid) to win the game.

Outputs should be: You win!, You lose! and Incorrect sum!

  • 2
    \$\begingroup\$ This is equivalent to the subtraction game, a variant of Nim. \$\endgroup\$ – Zgarb Mar 25 '15 at 15:58
  • \$\begingroup\$ The correct spelling is actually "You lose", not "You loose". \$\endgroup\$ – ProgramFOX Mar 25 '15 at 15:59
  • \$\begingroup\$ @ProgramFOX sorry for my bad english. \$\endgroup\$ – Migue Mar 25 '15 at 16:02
  • \$\begingroup\$ @Zgarb is The 100 game, but I used to play with numbers between 1 to 9. \$\endgroup\$ – Migue Mar 25 '15 at 16:09
  • 1
    \$\begingroup\$ "Ideally, the program should have a strategy to make it difficult (for a kid) to win the game." This part seems very vague and subjective. How difficult is difficult enough? Essentially, if the player starts the computer can always beat him. But that means it's not difficult, but impossible for the player to win. Likewise, if the computer starts he has no way of making it difficult for the player, because the player can always win. \$\endgroup\$ – Martin Ender Mar 25 '15 at 16:12
  • \$\begingroup\$ @MartinBüttner If the computer always starts and the kid playing is learning how to sum, maybe it would be interesting to see when the kid get the strategy to win the game. \$\endgroup\$ – Migue Mar 25 '15 at 16:23
  • \$\begingroup\$ @Migue That is not what your spec asks for though. \$\endgroup\$ – Martin Ender Mar 25 '15 at 16:27
  • \$\begingroup\$ @MartinBüttner Yes, I know. I was just thinking how to change the question to make it some way interesting. \$\endgroup\$ – Migue Mar 25 '15 at 16:31

One Code, All the Challenges

This challenge has been abandoned due to poor wording. You may reclaim it if you wish without my permission.


Now, I always want to solve as many s as possible, so I thought "Why not solve them all at once?".

Your task

Create a block of code that solves another code-golf challenge on this Stack Exchange network. You must also make it so that when it is rotated (90°, 180° or 270°) it solves a different challenge on this website. Examples of rotated code-blocks:

0°       90°      180°     270°
AB       FCA      F G       EF 
CDE       DB      EDC      BD  
F G      GE        BA      ACG

The code golf that you are answering must have a shortest answer > 10 score (usually bytes). It may also not be a duplicate of another challenge.
Answers do not have to have a code-gold linked to every rotations, although this helps with score.

When rotating, take the shape that the code occupies, and rotate that. Some more examples:

0°       90°   | 0°      90°
print    p     | print   hsp
         r     | say~~   iar
         i     | hi by    yi
         n     |         b~n
         t     |         y~t

This means non-rectangular code is allowed, but whitespace (like-all other characters) except newlines must stay in-tact. This means the tildes (~) must be occupied with a character to allow for the rotate.


Number of bytes in code * ((number of rotations that solve a challenge) * -2 + 7)
Lowest score wins.

Rotations | X   
        0 | Must work for at least one rotation
        1 | 5 
        2 | 3
        3 | 1
Number of bytes * X

Please provide a link to each code golf question you are answering with each rotation. Also note that the questions answered must have been posted before this question, and each rotation must be in the same language. Also note if there are restrictions of source in one challenge, only the rotation that tries to solve that challenge has to comply with them.


Python 3, 21 bytes, 2 rotations, 63 points

0 degrees: https://codegolf.stackexchange.com/questions/4/print-hello-world
180 degrees: https://codegolf.stackexchange.com/questions/3/crash-the-program
(Don't put in links in ` ` in actual answers)

print("Hello world!")

0 degrees: prints the string 'Hello world!'
180 degrees: Crashes with a SyntaxError because of unopened close parenthesis.

  • \$\begingroup\$ @Bigtoes That was an error. Fixed it, Thank you! \$\endgroup\$ – user34736 Mar 10 '15 at 17:01
  • \$\begingroup\$ I can't figure out what you're trying to say about non-rectangular code. Maybe if you had an example which actually contained non-rectangular code it would be clearer. And I think allowing people to solve any of the 3000 existing questions is too broad. It essentially makes the spec 3000 pages long. \$\endgroup\$ – Peter Taylor Mar 10 '15 at 21:35
  • \$\begingroup\$ Something tells me this question will just boil down to whoever can find the right subset of questions which work together. For example, taking the 1 byte from here sets the initial bar at 5. \$\endgroup\$ – Sp3000 Mar 12 '15 at 12:42

Help the President!


There is an anonymous president of a country who needs your help! He wants to retain absolute control, but needs to have elections to prevent uprisings. They ask you to create a program to help them gerrymander.

These are the specifications:


(You will receive input via stdin or as a function argument)

You will be given an array of arrays of strings to represent the locations of voters (a 2D matrix), i.e:

[["Democratic", "Republican", "Republican", "Democratic"],
 ["Republican", "Democratic", "Democratic", "Democratic"],
 ["Democratic", "Republican", "Democratic", "Republican"],
 ["Democratic", "Republican", "Republican", "Republican"]]

Which is

[["Democratic", "Republican", "Republican", "Democratic"], ["Republican", "Democratic", "Democratic", "Democratic"], ["Democratic", "Republican", "Democratic", "Republican"], ["Democratic", "Republican", "Republican", "Republican"]]

You will also receive a party that is meant to win, like "Democratic" or "Republican". These will be in the matrix.

Thirdly, you will receive district sizes. The amount of items in the matrix will be a multiple of this. All districts must be this size.


An array of arrays of coordinates. Either the top left or the bottom left may be [0, 0] or [1, 1]. Going right increases the second number and going down / up increases / decreases the first number.

This country uses a first-past-the-post voting (Most votes win) per district (except if there is a tie, none of them win). You must split the matrix of voters into districts in such a way that the party wins as many districts as possible. A district is given by one of the arrays in the output. Districts must be contiguous, and going diagonally is not contiguous. Some visualisations by this helpful CGP Grey video on Gerrymandering and one example outputs:

f([["D", "R", "D"], ["D", "D", "R"], ["D", "D", "R"]], "D", 3)
[[[0, 0], [0, 1], [1, 0]], [[0, 2], [1, 1], [1, 2]], [[2, 0], [2, 1], [2, 2]]]
# In this case, the D party wins all of the votes.
f([["D", "R", "D"], ["D", "D", "R"], ["D", "D", "R"]], "R", 3)
[[[0, 0], [0, 1], [0, 2]], [[1, 0], [1, 1], [1, 2]], [[2, 0], [2, 1], [2, 2]]]
# R wins a third of the seats

This demographic could be visualised as

D  R  D
D  D  R
D  D  R

(Note there may be many possible "best" district boundaries. In this case, return any of them. And in a case where there are two cases that give the party the same amount in both cases, but the second case gives a smaller majority to another party, return the latter)

f([["B", "R", "B", "R", "B"], ["G", "B", "G", "R", "Y"], ["G", "R", "Y", "B", "Y"], ["B", "G", "B", "G", "Y"]], 4, "Y")
[[[0, 0], [1, 0], [1, 1], [2, 0]], [[0, 1], [0, 2], [0, 3], [0, 4]], [[1, 2], [1, 3], [1, 4], [2, 3]], [[2, 1], [3, 0], [3, 1], [3, 2]], [[2, 3], [2, 4], [3, 3], [3, 4]]]
# In this election, Y wins 2, B wins 1 and 2 are undecided

Sandbox notes

This seems way too wordy for a problem which seems so simple. Any areas where it could be clarified to be more concise? I think it's my organisation of stuff that makes it unclear.

  • 3
    \$\begingroup\$ Your proposal seems very similar to this earlier one. Is that intentional? Also, you should state whether the districts must have the same size. \$\endgroup\$ – Zgarb Mar 26 '15 at 10:23
  • \$\begingroup\$ @Zgarb I never actually saw that. This one can be easier / harder than that one, as my one asks for the best district maps, but does not restrict perimeter. \$\endgroup\$ – user34736 Mar 26 '15 at 10:54

Cooperative Tamagotchi

This is a new twist to the Tamagotchi-style ideas floating around. I also plan on creating a "no rules" version, but the cooperative version is the more complete idea at the moment.

Tamagotchi, more popularly known as StackEgg, is a game in which you nurture the growth of an adorable pet, also more popularly known as PPCG. The pet has a set of statistics which reflect the health and well-being of the pet. You also have a series of buttons. When you press a button, the pet's stats are affected. One stat receives a boost, but the other stats that did not receive a boost slowly wither away.

In the game, your goal is to work together to win a game of Tamagotchi. Each contestant program casts votes to determine which move will be played in a given game cycle. This is a competition, however, because your personal contributions are being measured. If you vote for a move, and that move wins the election, then the effect of the move will affect your score. If the action was beneficial to your pet, you gain points. If the action was detrimental to your pet, you will lose points.

I don't have a "theme" for the Tamagotchi yet. Here are some ideas for how it would work. I could alternatively wait for the source for StackEgg to be released or reverse-engineered and use those more realistic rules.

There would probably be a single game phase, probably based on the "full site" phase of StackEgg in terms of functionality. This means that there are five stacks and five "constructive" buttons.

Each stat has two numbers: the number of hearts, which is visible, and a decay counter, which is hidden. When calculating a player's positive or negative contribution, only the number of hearts is used (?).

More details coming sometime not now.

  • \$\begingroup\$ One of the key (fun) things that StackEgg had going for it was figuring out what exactly did what. With the controller source being open (I assume), that mystery is gone. Without some big tweaks, I fear there will only be one optimum vote pattern which everyone uses. \$\endgroup\$ – Geobits Apr 2 '15 at 1:00
  • \$\begingroup\$ @Bigtoes Yeah, I'm thinking about that too. Do you think adding in randomness would help? \$\endgroup\$ – PhiNotPi Apr 2 '15 at 1:36
  • \$\begingroup\$ @PhiNotPi only if the randomness is at the initialization of the system, not each turn, so the bots have to figure out the best strategy, maybe? \$\endgroup\$ – rorlork Apr 2 '15 at 8:16
  • 3
    \$\begingroup\$ How about completely randomly initializing the effects of each button, such as which stats are helped and hurt, and by how much? There would have to be some way to determine which settings are playable, but bots would have fun time trying to figure out causes and effects. \$\endgroup\$ – PhiNotPi Apr 2 '15 at 12:05
  • \$\begingroup\$ @PhiNotPi I like the idea of randomly initializing the buttons. Also, perhaps a better way to measure the fitness of the bots would be to run the game K*N times, where N is the number of bots and K is a large constant, with a different bot missing for each of the N batches of K games. The score of a bot would be the average score of the games in which it participates. \$\endgroup\$ – Zgarb Apr 2 '15 at 12:48

Quine Creator

The program F is in language A. F takes a program in language B as input. Lets call this program G. F outputs a program in language B. Lets call this program O. O Takes some input and for some values it will be a quine and for others it will run G.

The exact values which O decides behaviour must be the same for each different input to F but you can decide what the conditions will be. They must be short (5 or less bytes), reasonable and not turned into code and executed for the sake of a shorter program F. Acceptable behaviours include (but are not limited to):

  • Quines for even digit, G for odd
  • Quines for truthy input, G for anything else
  • Quines for the input "0", G for anything else

For example your program F could be written in Java and take a Python program (G) as input and output a program in Python (O) that runs G when given at least 1 arg and prints it's source when not given any args.

Sorry if this is a bit confusing

  • \$\begingroup\$ This is very similar to this challenge. I'd definitely be tempted to close this as a duplicate. You're also missing a winning criterion. \$\endgroup\$ – Martin Ender Apr 3 '15 at 9:53
  • \$\begingroup\$ The code challenge tag is for when you make up your own winning criterion, so it would contradict the code golf tag. You might want to include a short sentence like "This is code golf, so the shortest submission (in bytes) wins." anyway, although the tag is pretty clear. Just for completeness's sake. \$\endgroup\$ – Martin Ender Apr 3 '15 at 12:22
  • \$\begingroup\$ @MartinBüttner That challenge is different to this one but I'm new to asking questions, so you be the judge of if mine should go ahead. \$\endgroup\$ – HEGX64 Apr 3 '15 at 12:32
  • \$\begingroup\$ Yes, it is certainly different, but very similar I think. For the record, my CJam submission would be "{q{;"q'}"_~"`"?}_~" which may look quite different but is essentially the same idea. I guess I probably wouldn't vote to close as duplicate myself, because I've got a dupehammer on the code golf tag, but I'm just saying others might think it's a dupe and close it. (Just to be clear, this is not a bad challenge idea. I really quite like it... just saying something very similar has been done before.) \$\endgroup\$ – Martin Ender Apr 3 '15 at 12:43
  • \$\begingroup\$ One thing that's not entirely clear about the challenge is how general G is allowed to be. E.g. if O reads all of STDIN to decide whether to use G or print O, then G cannot receive any input on STDIN. Is this fine? \$\endgroup\$ – Martin Ender Apr 3 '15 at 12:47
  • \$\begingroup\$ Is your edit intended to address my comment? If so, let me try to rephrase my question. I was asking whether G must potentially be completely general. E.g. the program G could be a program which reads a string on STDIN and reverses it. But if I generate O such that it reads all of STDIN and is a quine if STDIN is empty and calls G otherwise... then O has already read all of STDIN and G will have nothing to read on STDIN to reverse. Would this be allowed or does G have to be completely general? \$\endgroup\$ – Martin Ender Apr 3 '15 at 16:04
  • \$\begingroup\$ In other words can the input method of O be destructive? Another example would be clearing the ARGV array to determine which code to execute - if I did this, then G could never use ARGV itself. \$\endgroup\$ – Martin Ender Apr 3 '15 at 16:05
  • \$\begingroup\$ @MartinBüttner you can try to rephrase the question if you like. O should not consume too much input and I also think that G should be able to receive any input possible. So O taking the first arg and giving the rest to G or taking the first 4 bytes of STDIN would be fine. And yes the edit was sort of made in response to you comment so feel free to make an edit. \$\endgroup\$ – HEGX64 Apr 4 '15 at 3:32

Find sequences in RSA_1024

I found an interesting way to factor numbers, while its far from been any efficient in compare to other known methods, its lots of fun!

Lets assume we want to factor N. X will be its factor, if and only if

N/X = floor(N/X)

So theoretically, if you could find a different representation of floor(N/X), you could easily find X, so while find such representation is unlikely it is very easy to find it within a small range, for example take a look at floor(N/X) of N = 691 ∗ 983 = 679253

At left is X at right is floor(N/X) - floor(N/(X+1))

512 2 
513 3 
514 3 
515 2 
516 3 
517 2 
518 3 
519 2 
520 3 
521 2 
522 3 
523 2 
524 3 
525 2 
526 3 
527 2 
528 2 
529 3 
530 2 
531 3 
532 2 
533 2 
534 3 
535 2 
536 3 
537 2 
538 2 
539 3 
540 2 
541 2 
542 3 
543 2 
544 2 
545 2 
546 3 
547 2 
548 2 
549 2 
550 3 
551 2 
552 2 
553 2 
554 3 
555 2 
556 2 
557 2 
558 2 
559 3 
560 2 
561 2 
562 2 
563 2 
564 2 
565 2 
566 3 
567 2 
568 2 
569 2 
570 2 
571 2 
572 2 
573 2 
574 2 
575 2 
576 2 
577 2 
578 2 
579 2 
580 2 
581 2 
582 2 
583 2 
584 2 
585 2 
586 2 
587 2 
588 2 
589 2 
590 2 
591 2 
592 2 
593 2 
594 2 
595 2 
596 2 
597 2 
598 2 
599 1 
600 2 
601 2 
602 2 
603 2 
604 2 
605 2 
606 1 
607 2 
608 2 
609 2 
610 2 
611 2 
612 1 
613 2 
614 2 
615 2 
616 2 
617 1 
618 2 
619 2 
620 2 
621 1 
622 2 
623 2 
624 2 
625 1 
626 2 
627 2 
628 2 
629 1 
630 2 
631 2 
632 1 
633 2 
634 2 
635 1 
636 2 
637 2 
638 2 
639 1 
640 2 
641 1 
642 2 
643 2 
644 1 
645 2 
646 2 
647 1 
648 2 
649 1 
650 2 
651 2 
652 1 
653 2 
654 1 
655 2 
656 2 
657 1 
658 2 
659 1 
660 2 
661 1 
662 2 
663 2 
664 1 
665 2 
666 1 
667 2 
668 1 
669 2 
670 1 
671 2 
672 1 
673 2 
674 1 
675 2 
676 1 
677 2 
678 1 
679 2 
680 1 
681 2 
682 1 
683 1 
684 2 
685 1 
686 2 
687 1 
688 2 
689 1 
690 1 
691 2 
692 1 
693 2 
694 1 
695 2 
696 1 
697 1 
698 2 
699 1 
700 2 
701 1 
702 1 
703 2 
704 1 
705 1 
706 2 
707 1 
708 1 
709 2 
710 1 
711 1 
712 2 
713 1 
714 1 
715 2 
716 1 
717 1 
718 2 
719 1 
720 1 
721 2 
722 1 
723 1 
724 2 
725 1 
726 1 
727 1 
728 2 
729 1 
730 1 
731 2 
732 1 
733 1 
734 1 
735 2 
736 1 
737 1 
738 1 
739 2 
740 1 
741 1 
742 1 
743 2 
744 1 
745 1 
746 1 
747 1 
748 2 
749 1 
750 1 
751 1 
752 1 
753 2 
754 1 
755 1 
756 1 
757 1 
758 2 
759 1 
760 1 
761 1 
762 1 
763 1 
764 2 
765 1 
766 1 
767 1 
768 1 
769 1 
770 1 
771 2 
772 1 
773 1 
774 1 
775 1 
776 1 
777 1 
778 2 
779 1 
780 1 
781 1 
782 1 
783 1 
784 1 
785 1 
786 1 
787 2 
788 1 
789 1 
790 1 
791 1 
792 1 
793 1 
794 1 
795 1 
796 1 
797 1 
798 1 
799 1 
800 1 
801 2 
802 1 
803 1 
804 1 
805 1    
806 1 
807 1 
808 1 
809 1 
810 1 
811 1 
812 1 
813 1 
814 1 
815 1 
816 1 
817 1 
818 1 
819 1 
820 1 
821 1 
822 1 
823 1 

Its easy to tell that in the range of 566,599 floor(N/X) act like a strait line y = 2x + 566. Also it's easy to verify as we can calculate the difference between floor(N/566) and floor(N/599) and see if its equal to 2 * 599 - 566, and indeed it is.

So now lets play


Your input is the number RSA_1024, while we will only use this input, your app should be able to work with any other inputs as well.


10,000 sequences that you found starting from Sqr(RSA_1024) and going up. Each sequences will be outputted in a new line. For each sequences you should output the next

  • starting range value
  • end range value
  • type

Type is just a string defined by you that tells us what kind of sequence is it, strait-line or some thing else.

After you output the sequences, output one line with the total range you been able to cover with all the sequences.


Who covers the biggest Range wins.


Realistic Fractal Terrain Generation

Don't you find that typical algorithms to generate random fractal terrains are boring and not too much realistic?

Fractal terrain generation is usually implemented with some random noise function applied in a fractal way. This can be seen with the typical Diamond-Square algorithm or the Perlin Noise function:

Diamond-Squares example output:

Diamond-Squares example output

Perlin noise example output:

Perlin noise example output

The problem is that these are used by their simplicity in creating them, but they are actually pretty boring when they are used as height maps:

Diamond-Squares as heigh-map

Perlin noise as heigh-map

... To be continued ...

  • \$\begingroup\$ Terrain generation is interesting. I'd like to see this idea developed. Here is a simple, but pretty good, terrain generator, if you are looking for examples: Realistic Terrain Generation in 130 Lines. \$\endgroup\$ – PhiNotPi Apr 5 '15 at 1:47

Make a fighter, then have them battle

Well, I was browsing around KOTH one day. I found two little interesting challenges: Save the last bullet for yourself and Codémon, I choose you!. But what if we combined the two?

How your bot will work

Each match, your bot is assigned an opponent. It is randomly decided who goes first. Your bot is given HP of 100. You must output:
ATKID is the attack's ID, and DEFID is the defense (or support) ID, for skills. MOVED is your move direction, on a number-pad (5 being 'stay still'). ATKDIR and DEFDIR are attack and defense skill directions (for Bullet, Wall, etc.)
Your bot must accept the following as input:
MYHP YOURHP MYPOS YOURPOS (additional projectile positions)

Your bot is allowed 2 attack and 2 defense skills.
List of attack skills:

0: Attack: Deal 10 damage.
1: Psychic Blast: Deal 5 damage this turn and 5 damage the next.
2: Bullet: Fire off a bullet that damages for 15 points when it hits an enemy.
3: Hadouken: Fire of a large flaming ball that can fly for 3 squares, and deals 50 damage.

List of defense skills:

0: Block: Block up to 10 points of damage this turn.
1: Heal: Heal for 10 points.
2: Wall: Add a wall in target direction.

How the arena works

The arena starts as follows:

|        |
|        | 
|a      b|
|        |
|        |

where a and b are bots' starting positions.

Meta Questions

  • What should I add as skills? Healing? Defensive?
  • Is the arena too small?
  • Have I left out any restrictions?
  • Can I have some help with the 2D grid?
  • Is the input/output sufficient?
  • Does anyone want to pick up this challenge? I already have another KOTH, this was just an idea everyone liked.

Missing distance between points

There are N points on a straight line. Someone calculates all possible distances between each pair of points and sort them.

In the following example I used 5 points. The sorted list of distances is [2, 5, 6, 8, 9, 14, 15, 17, 20, 22].



You will receive the list, but one of the numbers is unreadable. This will be indicated by a zero. So you might receive the list [2, 5, 6, 8, 9, 0, 15, 17, 20, 22]. Your job is to find the missing number.

Input / Output:

Write a function/program that finds the missing number. The input (via STDIN, command-line argument, prompt or function argument) format is a list or an array of distances (integers). You can optionally take the number of points (one integer) as a second parameter if you want. The output (via return value or STDOUT) is one single integer, namely the missing number in the distances list.

This is code-golf. Therefore the shortest code wins.

Test cases:

#points, distances -> output
5, [2, 5, 6, 8, 9, 0, 15, 17, 20, 22] -> 14
3, [1, 0, 2, 2, 3, 4] -> 2

Sandbox notes:

  • This challenge is based on one problem of this year's Mathematical Kangaroo. My dad is a math teacher and brought me a copy of the 7.-8. grades test.

  • Example and test cases don't look pretty and will be improved and extended for the final question on PPCG.

  • My main concern about the challenge is the speed of the programs. My first (and only) solution is quite slow, because of the bad time complexity (about (n^2)^(n-1), where n is the number of points on the line). The 5-point example takes already about 1 second to compute, a 6-point example took about 10 minutes. My guess is, that most code-golf solutions will use a similar approach and the programs may be quite difficult to test.

    There's definitely a better way of computing the missing number.

    Maybe I'll add a few big testcases (one with 6, 7, 8, 9 and 10 points) and promise a 50% bonus if the program can solve all test-cases in under one minute.

  • 2
    \$\begingroup\$ Are you sure the solution is unique? \$\endgroup\$ – xnor Apr 7 '15 at 23:25

Shadows to Height Maps

The goal of this code challenge will be to take a grayscale image with shading as input and produce a height-map image with the same dimensions as output.

The input image will be a grayscale 256x256 png image, shaded with only a diffuse term, no ambient or specular term. It will be lit by a directional light source hitting the surface at a 45 degree angle, from above.

The output must be a 256x256 png image containing the height-map.

This is a code-challenge, the answer with the most accurate results wins. (A perfect match between the reverse engineered height-map and the original height-map used to produce the shaded image is near impossible, it is not expected that they are identical).

(working on test cases)


image-processing, code-challenge, graphical-output, conversion


SVG file optimization

Yep, I got my idea off of this question, and it's amazing answer. All credit for this question goes to Illmari Karonen's answer

Now, for the challenge: Write a program that removes unnecessary clutter from SVG files in order to reduce their byte counts.

  1. Remove comments <!-- comment -->
  2. remove metadata <metadata ...> </metadata>
  3. Shorten necessary ids to 1 letter, and remove unused ids.
  4. remove unnecessary attributes and XML namespace attributes

Any other methods used to shorten the SVG files are welcome. (You can refer to the linked answer to look at an extensive list of ways to shorten SVG files)

Your program's score is how many bytes it removes from these SVG files:

test cases in progress

  • \$\begingroup\$ See also Warm Welcome Secret Hat. If you're going to allow changing the paths, you should specify permitted changes / accuracy. E.g. if a transform is given to 3d.p. and the path coordinates to 3d.p., inlining the transform and then rounding to 3d.p. could produce visually perceptible changes. \$\endgroup\$ – Peter Taylor Apr 14 '15 at 9:47

Randomly generated "Bézier petals"


A "bézier petal" is a:

  • simple closed curve (no loops or self-intersection)
  • made by two cubic Bézier curves which
    • share endpoints
    • but not necessarily control points


The challenge is to generate these randomly, such that:

  • the entire space of possible valid curves is covered,
  • any specific valid curve is as likely as any other,
  • no "degenerate" (non-simple) petals are output.


I've been thinking about this for a while (see https://www.youtube.com/watch?v=TJdApKcAVD0), but was only able to arrive at a partial solution, which only covers a "safe" subset of possibilities (it never generates crescent or s-shapes). But, having followed this site for a while, I know that many of you are way more clever than I am.


The result should be a function which returns a single random petal, defined by two endpoints and two sets of two control points (six values in all) on a Cartesian plane — let's say with values between -1 and 1.


Ideally, the algorithm works in constant time, or at least has a bounded stop; generating and filtering out degenerate petals until a good one is found is acceptable but a step down.

Entries which do not cover the entire possible space but do so with low complexity and at least beat out my "sort radially around center" approach are partial credit.

Sandbox notes

I'll add some illustrations for valid and invalid petals, once I draw them.

  • \$\begingroup\$ Are you sure "any specific valid curve is as likely as any other" is well-defined? \$\endgroup\$ – feersum Apr 22 '15 at 22:20

Minimal convex partition (code-golf)

The goal of this challenge is dividing up the 'white' shape of a given 'black and white' pixel image into smaller pieces, which together form the original image (let's call this a partition). The restriction is that those pieces have to be convex, in our case everything is made up from square pixels, therefore the convex pieces can only be rectangles. Now of course you can just divide the whole shape up into the pixels it consists of, but that way you will get too many pieces (usually). The goal here is finding one partition that has the lowest number of (convex) pieces.



The 'black and white' pixel image of $n \times m$ pixels is given as a string, row by row, each row separated by a comma. The white pixels are represented by a full stop ., and the black pixels are represented by a hash mark #.


The output consists of the same string, but now the white pixels must be replaced by alphabetic characters, one character for each piece of the partition. The minimal number of partition never exceeds 26 (you do not have to consider input that does not meed this condition), therefore you only have to use the letters a-z. If the minimal number is $n$, you have to use the first $n$ letters of the alphabet. Of course, the output is not necessarily unique.

Examples (without the commas, for better visibility):





I'd be happy for any interesting input examples. I could not think of any really interesting ones right away now.

  • \$\begingroup\$ Very similar: codegolf.stackexchange.com/q/44654/14215 The output might not be minimal in some cases, though. \$\endgroup\$ – Geobits Apr 20 '15 at 16:26
  • \$\begingroup\$ Thanks for pointing this out, I did not remember this challenge but it is indeed similar, but I still think looking for the solution with the minimal numbers of rectangles is again a different challenge, don't you agree? But I just noticed that I could write the introduction way more intuitive by using covering a region with rectangles instead of *partitioning into convex pieces*=) \$\endgroup\$ – flawr Apr 20 '15 at 19:28

IRC reader

Internet Relay Chat (or IRC for short) is a simple yet popular chat communication method. The challenge is to create a program that can take an IRC server from program arguments and print out new messages sent on that server.

e.g.: <your_irc_client> irc.freenode.net

A very simple implementation in Python of this idea which does not print responses to the user can be found here


Interpret a Turing-Complete Language

This challenge is inspired by this esolangs.org page, which lists some languages with very small interpreters. There have been some similar challenges before, like this one about a self-interpreter, or a few other interpreter challenges, like one for BF.

This goal of this challenge is to write the smallest interpreter possible for a Turing-complete language. You may choose any Turing complete language (even one you create?) to interpret.

Your interpreter should take input representing the program to be executed, and give output representing the end result of the program. "Interactive" I/O is not required.

More Rules

Your interpreter program may not contain/execute any eval-like commands.

  • 1
    \$\begingroup\$ Maybe this could be a popularity contest, and whoever has the most creative answer wins? \$\endgroup\$ – ASCIIThenANSI Apr 20 '15 at 21:18
  • \$\begingroup\$ I like this, but I think it needs to be more specific. Why not pick a specific OISC? That would probably be the winning strategy for the more general problem anyway. Also, I/O format should either be locked down or explicitly left open. If I'm golfing an OISC in Python 2, for example, I'd like to have the I/O be the memory of the machine represented as a Python list, read via input(). Is that okay, or cheating? \$\endgroup\$ – DLosc May 4 '15 at 4:06
  • \$\begingroup\$ @ASCIIThenANSI For the popularity-contest version, see this question. \$\endgroup\$ – DLosc May 4 '15 at 4:07

Number of ways to sum [1..n] with [n+1..2n] such that each sum is prime

In as few bytes as possible, write a program or function which produces this sequence (A070897), either as an infinite list on STDOUT, or in your interpreter of choice.


a(5)=2 because there are two ways: 1+10,2+9,3+8,4+7,5+6 and 1+6,2+9,3+10,4+7,5+8


No built-in primality tests. No lookup table ;). No standard loopholes.

  • \$\begingroup\$ Are build-in prime functions allowed? \$\endgroup\$ – Jakube Apr 22 '15 at 21:13
  • \$\begingroup\$ Fixed //char count \$\endgroup\$ – alyx-brett Apr 22 '15 at 21:16
  • \$\begingroup\$ It would be good to actually define the sequence explicitly in the question body instead of just in the title and by linking to OEIS (the link is still good for further reference, but it shouldn't be necessary to understand the question). Likewise, if you could reproduce the first 20 or so elements as test cases, that would be good to make the challenge self-contained. It's also not clear if "produce this sequence" means to print consecutive number ad infinitum, or given n to return a(n) or to return all numbers from a(1) to a(n). \$\endgroup\$ – Martin Ender Apr 24 '15 at 12:42
  • \$\begingroup\$ @MB - I'll amend to repeat the title & give more examples. However I think 'an infinite list on stdout' is pretty clear? \$\endgroup\$ – alyx-brett Apr 24 '15 at 12:44

Rabbit in a Snow Storm


A group member is giving a presentation in PowerPoint. He reaches a point where he wants to start writing on the whiteboard, but his slides have text that get in the way. He motions to the guy with the keyboard to just blank the screen so he can write. The next 2 minutes consist of everyone in the room bickering about how to do it until we arrive on using a full-screen-ish terminal (which is black, so we have to turn up the lights). Awful.


Have the primary monitor become completely white.


  • You start with no programs running (or at least none that are important towards the goal)
  • You may only use programs that are installed by default on your OS/distro (i.e. needs to be repeatable by someone else without installing anything in particular)
  • You can't pre-load your background, slide-show, etc. with a pure-white image (though you could create the image then show it)


  • Number of keystrokes required (keys depressed and released, i.e. opening Spotlight takes two (Command + Space), likewise Run... (Win + R))
  • Clicks are scored as 5 keystrokes.
  • 1
    \$\begingroup\$ In your scenario, PowerPoint is running. Yet in the rules, it isn't. I can understand if this is because the one-stroke solution w isn't interesting, but it still makes for a confusing question. Why not ditch PowerPoint from the scenario and replace it with a demo of some in-house software? \$\endgroup\$ – Peter Taylor Apr 23 '15 at 8:49
  • 1
    \$\begingroup\$ Oh, and you should probably add to the bit about "installed by default" that the OS hasn't learnt which programs you use, so you should assume that no auto-completion occurs. \$\endgroup\$ – Peter Taylor Apr 23 '15 at 8:50
  • \$\begingroup\$ @PeterTaylor I didn't know about w...magical! In the scenario the guy was actually using PDF slides, so I'm not sure if Reader has the same functionality. Good comment though, probably just forbid autocompleting? \$\endgroup\$ – Nick T Apr 23 '15 at 16:11

Generate random seeds for strings

Consider the following pseudocode:

function randomString(long input) {
    accumulator = "";
    random = random.seededWith(input);
    while(true) {
        x = random.nextInteger(27); # generate integer 0-26
        if(x == 0) break;
        accumulator += x + 'a'; # add lowercase letter from a-z for values 1-26
    return accumulator;

In other words, this generates a random lowercase string based on a random number seed.

Your job is not to write this behavior.

For this golf, your job is to REVERSE this process. Receive a String as input, and return the random seed that would generate this string, using whatever pseudorandom algorithm is included by default in your language - so different languages will have different numbers returned for the same string.

However, the algorithm used to regenerate the strings should be the same for all languages.

Fine print

You may write a program or function, which returns the output as an integer or long (whatever's appropriate for your language) or printing it to STDOUT (or closest alternative). You may optionally include a single trailing newline in the output.

If the String cannot be generated in this method, your program should throw an exception and/or print an error message of some sort.

Additionally, standard loopholes which are no longer funny are banned. You may not use external libraries unless your language doesn't support seeded random number generation by default. If that is the case, then you may use the library for random number generation that is most commonly used by that language's community.


This question has been brought to you by: Why does this code using random strings print hello world?

  • \$\begingroup\$ "However, the algorithm used to regenerate the strings should be the same for all languages." I don't see how this can be possible, unless you're assuming either that the only way to do it is brute force (wrong) or that every standard library in the world uses linear congruential PRNGs (unlikely: there's probably some language designed by a security nut which only uses crypto PRNGs). \$\endgroup\$ – Peter Taylor Apr 25 '15 at 8:25
  • \$\begingroup\$ @PeterTaylor I meant the pseudocode should be same, not the PRNG algorithm. \$\endgroup\$ – durron597 Apr 25 '15 at 14:38

Structural Damage Simulation

(either or , haven't decided yet)


In this challenge, you are given a two-dimensional map or a brick structure. Each brick is glued to its four neighbors, and is guaranteed to be connected to the ground, that is, the bottom edge of the input grid, via adjacent bricks. This structure is affected by gravity, which may cause some of the bricks to break, depending on their durability. Your task is to predict whether this happens, and where.


The input is given as a grid of the ASCII characters . and # that represent empty space and square bricks OR a black-and-white image with the black pixels representing bricks. You are also given a nonnegative number that represents the durability of the bricks; you can choose the valid type (integer or float) and range of this parameter and how it affects the computation. Your output is a grid in the same format as the input, but with some of the bricks replaced by Xs (or gray/red pixels); they represent bricks that have broken under the strain caused by the weight of the structure.


Suppose we have the following input grid (replace with an image if that's chosen as the input format)


The narrow parts of the structure are likely to break, especially the vertical ones, but the solid parts may very well hold themselves together. A possible output would be


TODO: add more test cases.


This is a popularity contest, meaning that the answer with the highest vote tally wins. Voters are encouraged to take the following criteria into account:

  • Simplicity. Simple and elegant algorithms are favored over complex and over-engineered ones. Elegance includes reasonable speed, so very slow algorithms are discouraged.
  • Realism. The outputs should be close to the physical intuition of most people.
  • Flexibility. Solutions should preferably handle complicated structures and extreme values of durability.

Cops 'n' Robbers - Hide a keyword in each answer

This is an idea I'm still working on, but I want some feedback on whether or not it could pan out well.


The robbers are here! They've found our files! We, need to encrypt them! We need a certain key, something special that clearly shows what the real program is. We need to keep writing our new files, but we must keep encoding them. When a robber cracks a key, we find the key they cracked and write a new file off of that key! For example, we will hide the encryption key for file #2 in file #1, then file #2 hides a key for file #3, and so on. The files are safe if they go uncracked for 5 days, in which we win! But if the robbers crack all 100 of our files, we lose!


We found the cops' files! Not only that, we cracked their encryption scheme! In file #1, they hide a key for file #2, which hides a key for file #3, and so on. Our goal is to hack all 100 files. The only catch? We'll lose our connection if we don't crack a file within 5 days.

In English, Please?

Basically, the cops will upload an answer with a program when the robbers crack the previous answer. The clue to the next answer is hidden in this one, encoded with the clue from the last answer. If a robber guesses wrong, that robber can not guess again on the same answer. If a answer remains uncracked for 5 days, cops win. If robbers guess all 100 answers, the robbers win.


The winner for the cops is whoever made the uncrackable file. For the robbers, it's whoever cracked the most files (in event of a tie, later answers are better than old ones.)

  • \$\begingroup\$ Just to be clear, each cop has to upload 100 files somewhere? \$\endgroup\$ – Geobits Apr 29 '15 at 18:09
  • \$\begingroup\$ @Geobits No. The 'files' are the answers. The cops create 100 files (at any time) and post them (in order) as answers. The key to decode file #10 is in file #9. (File #1 will have its key posted in the question.) Robbers crack the code in a seperate thread. \$\endgroup\$ – ASCIIThenANSI Apr 29 '15 at 18:15
  • 2
    \$\begingroup\$ The description right now is rather "themed" and isn't precise enough to explain the details of how the challenge will actually work. Themed intros are fine, but you should write a description that, for example, uses "answers" instead of "files" and uses a team name instead of "we." \$\endgroup\$ – PhiNotPi Apr 29 '15 at 18:43

Astrometric Tiling

A common problem in astronomy is the stitching together of astronomical images to create a mosaic of the entire imaging survey. This can't be done by naively putting the images next to each other in a grid - they might have slightly different dimensions, and certainly have different positions & orientations, which might overlap.

The solution is to calculate the positions of the objects (usually stars) in each image in celestial coordinates, a process known as Astrometry. (This is not the challenge, as it's far too difficult for a codegolf, but if you're interested in that process, take a look at astrometry.net.) Once an astrometric solution for a given image is found, every star's position on the sky can be calculated based on its position on the image.

The Challenge

Write a program to accept lists of coordinates for some number N>=2 of astronomical images, and output a transformation matrix for each image to create the mosaic.


You may accept either a list of coordinate lists, or a list of filenames containing coordinate lists, whichever is more convenient. The coordinate list (length >= 10) for a given image is made up of 4 coordinates per star: x,y in whole number pixel coordinates on the image, and a,d in float (requiring precision to at least 10^-5) celestial coordinates. Assume that every star's coordinates are exact, and that the same celestial coordinates in two different lists refer to the same star.


Your program should output a 3x3 affine transformation matrix for x,y in each image (alternatively, you can output a matrix for each image after the first, if you would like to use the first as a reference), which can be used to tile the images in such a way as to align the celestial coordinates in adjacent & overlapping images.


This is a (admittedly quite challenging) code golf, so shortest in bytes wins.

I'll need to produce a test case, which I will do before posting.


Create a program or function that, given a postfix expression, converts it to the simplest equivalent expression. The expression may contain real numbers, floating variables denoted a to z, and the basic arithmetic operators +-*/^.

Two expressions are equivalent if they produce the same result for all possible integer values of the variables. "Simplest" means you should return the equivalent expression with the least number of operators. If there are multiple expressions with the same number of operators, pick the shortest.


Consider the expression (8+4*y)/2+x*2. In postfix notation, this would be


This should yield the output


which corresponds to (2+y+x)*2.


this challenge is irrelevant of code length , so i want to ask , any scoring methods i can use in this defiance

i propose : picked up nine variant expressions with different polynomial degrees , which im free to choose , tested as input for all concurrent codes , then validate the lowest sum = (number_of_operations)^2+length(output_string)


Detect limit points in (possibly) oscilating sequence

Popularity Contest, Algorithms

Given an (infinite) sequence of numbers, your task is to find an algorithm (and write a corresponding program) that takes the sequence as input and determines

  • Whether the sequence converges to a cyclic behaviour. That means the sequence will oscillate throu one or more values, that means whether it has one or more limit points. In this case it should output the limit points.

  • diverges (does not end up in one or more limit point). In this case it should output a message that says so.

  • No defined behaviour for sequences that do not have acyclic limit points.

A limit point is a value such that for every neighbourhood of that value an infinite number of sequence elements are within that neighbourhood.

Of course you can only use a finite part of the sequence, so you the task is ambiguous, but the larger the given sample the better your algorithm should be able to dectect the cycles. As this is difficult to achieve for arbitrary sequences, you are allowed to use 'fine tuing parameters' that can be changed manually in order for your algorithm to work best for the given set of sequences. Please document what those parameters do.

In this case here, you can assume that the sequence will converge to a behaviour where it cycles throu all the n limit points without gaps (intermediate values that are not limit points) and always in the same order.


You perhaps have already see this diagram (the bifurcation diagram of the logistic map) enter image description here

In order to generate this diagram, you have to compute a sequence for every r and compute the limit points x of each of those sequences (which in this case are cyclic). Then you plot those x against r. The sequence is generated by the recursive function (logistic map) with a starting value 0< x(0) < 1 (usually something like 0.5)

x(n+1) := r * x(n) * (1 - x(n))

The sequences generated this way are nice examples of the sequences that your algorithm should be able to detect.

Your submission

should consist of

  • a function/program that executes your algorithm on a given sequence (input in any way you like),
  • a description of how your algorithm works,
  • and a program that uses your function for generating the bifurcation diagram above.


Following sequence is generated by 1+(-1)^n*(10+n)/n This sequence does not converge in the usual sence of sequences but it has limit points at 0 and 2. The sequence looks like this, so the

enter image description here

This is from the example above (logistic map with r=3.5), here we have 4 limit points:

enter image description here

The following sequence is bounded (and therefore has at least one limit point) but does not converge and does not seem to have a cyclic behaviour. (It is generated by x(n) = [pi*n^3 (mod e)]/e)

enter image description here


I'm happy to hear from you what you think. So far I did not find any sources that described algorithms that do exactly this task, but there may very well exist such algorithms. If you can improve the text please do so! Any suggestions are welcome.

  • \$\begingroup\$ Can you put in some example input/output? I'm still a little confused about the challenge \$\endgroup\$ – Sp3000 May 13 '15 at 1:15
  • \$\begingroup\$ I know my wording is not that great, please tell me what to change! I just added some examples. \$\endgroup\$ – flawr May 13 '15 at 8:51
  • \$\begingroup\$ What I mean is, is the string "1+(-1)^n*(10+n)/n" the input, will it be the sequence of numbers generated by the expression or...? \$\endgroup\$ – Sp3000 May 13 '15 at 8:59
  • \$\begingroup\$ No the input is a list of numbers (or a function that can be repeatedly called and returns the next list element or something similar), so you do not need to parse an input, the mail goal is finding an algorithm that is looking for cyclic limit points, the actuall details of the program are not that relevant. Is that clear now? \$\endgroup\$ – flawr May 13 '15 at 9:01
  • \$\begingroup\$ I was a bit worried that might be the case. What if you have something like 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, ... (a googol numbers later), 1, 0, 1, 0, 42, 42, 42, 42, 42, 42, 42,... (42s forever after)? \$\endgroup\$ – Sp3000 May 13 '15 at 9:35
  • \$\begingroup\$ This is obviously a difficulty, as a reasonable algorithm can only consider a first (finite) section of the sequence, and it should find the a answer as good as possible with the given data. So the sequence x(n) = (-1/2)^n looks as if it is gonna be alternating between two points if you only consider lets say x(1),...,x(5), but if you consider the first 100 elements it could become more clear that is only one. So the algorithm should basically provide a criterion to make a classification with only limited data. And the more real examples it recognises the better. \$\endgroup\$ – flawr May 13 '15 at 13:26
  • \$\begingroup\$ In your case as long it sees only 0,1,0,1,0,... the algorithm should obviously return the limit points 0 and 1 (cycle length 2), but if it gets e.g. one 42 at the end of the data, it could output that the sequence does not converge. But as soon as there are enough 42 it should probably say that the sequence converges to 42. (cycle lenght 1) \$\endgroup\$ – flawr May 13 '15 at 13:29

Quaternion calculator

Quaternions are extensions of the complex number system that are used in 3d graphics and some other applications. In addition to i, there is also j and k. j^2 and k^2 are both -1, however, ij=k, jk=i, ki=j, ji=-k, kj=-i, and ik=-j. Write a calculator that can calculate addition, subtraction, multiplication, division, and exponents. This is a code golf challenge, shortest answer wins.

EDIT: sample input: (2+4i+3j)*i^(j+2k)/(5j-i)+1

  • \$\begingroup\$ This should specify how operands and operations are given as input. However, this is a borderline duplicate. Multiplication has already been done, exponentiation can be trivially reduced to that, addition and subtraction and fairly uninteresting, so that leaves only division. So just doing division might be a better idea. \$\endgroup\$ – Martin Ender May 13 '15 at 18:08
  • 1
    \$\begingroup\$ I had considered a sequel with division or inversion, but thought it was too likely it would be implemented as multiplying by the conjugates and rescaling by the norm, which would mostly still be about multiplication. \$\endgroup\$ – xnor May 14 '15 at 23:46

Kaos Pendulum and Einstein's Revenge

The Double Pendulum system is a relatively simple system with quite complex behavior that's highly sensitive to initial conditions (i.e., "chaotic").

Doctor Kaos has designed a particularly fiendish double pendulum, using his diabolical machine "Einstein's Revenge". Einstein's Revenge is a device which couples matter and energy, causing the mass of the first pendulum (connected to the anchor point) to be a function of the energy of the second: m1 = sqrt(PE2**2 + KE2**2), with the potential energy measured from the rest position of the pendulum.

For this challenge, you must write a program or function to simulate a basic Kaos Pendulum, where the second pendulum has unit mass and both pendulums are unit length. It must accept the starting position of the Pendulum - two real numbers, theta1 and theta2 - as input or command-line arguments, and one positive integer equal to the number of seconds the pendulum will be active.

Your program must output the value of theta1 and theta2 for each second, either printing to stdout or returning as a list, or something similar.


I don't know if this should be a golf, a popularity contest, or if there should be some scoring method for some other type of challenge.


Blind (deterministic) Jenga

The idea for this came up in the chat room, under the broader topic of how to make a human dexterity game into a software KotH challenge. Here's the basic idea, which I don't think works, but I'd love to get feedback to make it better.

generic jenga tower

The jenga tower has three blocks per layer. Layers alternate between N/S aligned blocks and E/W aligned blocks.

There may be just two players, or more than two.

Each turn a player selects a block location to probe. If there's no block there, the player gets to go again. If there's a block there, it is removed from the stack. If this causes the tower to fall, the player loses. Otherwise, the block is placed in the next safe position at the top of the tower, unless all available positions are unsafe in which case the player loses. If the player has not lost, it is now the next player's turn. Continue until some player loses.

I think this won't work well because it will boil down to a relatively random competition between bots that start with edge pieces and bots that start with center pieces. I don't want to run the contest just to find out that that's the case. Maybe putting four blocks per layer would make that a non-issue. I'm open to other suggestions on how to make this challenge work.


A idea. Maybe I'll do it a long time later...

You have these options each turn (they need better names and a plausible background):

  • Meet k If the bot k also did meet you, and nobody injects, both of your scores are increased by 1. Otherwise nothing happens. But if k is yourself, this is invalid and will be just like doing nothing.
  • Invite k The bot k gets a notification that you are doing this, and in the next round, your output is ignored and you must do Meet k.
  • Inspect k You will get these informations at the beginning of next round:
    • What the bot k was doing.
    • The score change of bot k.
    • Who was inviting bot k.
    • Who was trying to meet bot k. (This is not known by bot k if not inspecting himself and his score is not changed.)
    • Who was inspecting bot k. (This is not known by bot k if not inspecting himself.)
    • Who was injecting bot k (and another bot). (This is not known by bot k if not inspecting himself and his score is not changed.)
  • Inject j k If j is meeting k and k is meeting j, your score is increased by 10 and their scores are both decreased by 1 instead. If one of them is pretending doing that, and the other is pretending or really doing that, your score doesn't change. Otherwise, your score is decreased by 10. They'll not know who is injecting unless they are inspecting you or self-inspecting instead.
  • DoNothing Nothing happens.

Possible other options:

  • Pretend action: action is any action other than Pretend. It's the same as doing nothing, but inspectors will be told that you are doing that action. The score change that the inspectors will see is calculated as if you really did that.
  • Multiply: For each turn until the next time you meet some bot each other, the points you, the other bot and all the bots injecting you get are doubled (or incremented, I'm not sure).

Everybody can see only their own score, bots inviting them and the result from Inspect.

  • 4
    \$\begingroup\$ I think that Pretend is a great action, and should definitely be included. \$\endgroup\$ – Nathan Merrill May 22 '15 at 19:30
60 61
63 64

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .