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 the first try can be difficult. 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 or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

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

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


3038 Answers 3038

59 60
62 63

Natural Language Calculator


You are working at Wolfram Alpha, when a big fire occurs, wiping out much of the hardware infrastructure, losing much of the code. Now you are assigned to the natural language team working on writing new code for converting natural language to mathematical expressions to be evaluated. You must parse the following commands and even do mixed commands!


The input will be a string, obviously. For multiple operations, there will be commands within input of commands.

Pi and e are simply inputted as "pi" and "e". Other special numbers are not needed to be handled.

Parse the following commands:

  • Add x and y
  • Subtract x and y
  • Multiply x and y
  • Divide x and y
  • Factorial of x
  • x factorial
  • Exponent base n of x
  • Log base n of x
  • Natural log of x

You must deal with it case-insensitively. For example "5 Factorial" gives the same result ad "5 factorial" or "5 FAcTorial".


> "Add 4 and 5"
> "Multiply 6 and 10"
> "Divide 144 and 12"
> Exponent base 10 of 3
> 3 factorial
> 3
> Add 5 factorial and 2
> Exponent base e of natural log of e
> natural log of e
  • \$\begingroup\$ -1 Unclear challenge. \$\endgroup\$ – Xwtek Jan 16 '16 at 9:11
  • 2
    \$\begingroup\$ @ChristianIrwan "Still in the works and need to add more detail" \$\endgroup\$ – TanMath Jan 16 '16 at 9:32
  • \$\begingroup\$ Well, I think the sandbox is not for brainwashing idea, but to polish the challenge while detecting it if the challenge is duplicate. \$\endgroup\$ – Xwtek Jan 16 '16 at 13:57
  • \$\begingroup\$ The sad thing is, most of these are actually things in AppleScript already. Shame that there's no eval for i- oh, wait, there's a library for that in Java. \$\endgroup\$ – Addison Crump Jan 22 '16 at 23:13
  • 2
    \$\begingroup\$ Even if this were cleaned up, I don't see what it adds to the many existing "process arithmetic in english" challenges. \$\endgroup\$ – xnor Jan 22 '16 at 23:36

How many swaps do I need to sort a list?

A swap is defined as an operation on a list that exchanges the position of exactly two elements:

[9, 1, 3, 4, 0, 0, 3, 7, 9, 1, 4, 4, 8, 7, 3, 9, 4, 7, 0, 1]
       | <----------------> |
[9, 1, 1, 4, 0, 0, 3, 7, 9, 3, 4, 4, 8, 7, 3, 9, 4, 7, 0, 1]

Of course, every list can be sorted via some sequence of swaps (e.g. that's how Shell sort works).

Given a list of single-digit integers, determine the minimum number of swaps you need to sort the list.

You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.

Input may be in any convenient, flat list format, as long as the data is not preprocessed.

Standard rules apply.

Test Cases

(will follow)

Sandbox Questions

  • If the list elements are distinct, this is simply: a) determine ordering, b) treat ordering as permutation and decompose into cycles, c) subtract one from each cycle's length and sum the results. (Which would make this a duplicate.) Off the top of my head, I can't think of a similarly simple algorithm when duplicates are allowed. Can anyone else?
  • \$\begingroup\$ Bubble sort only swaps adjacent pairs and that's much easier to calculate (at least for distinct elements) - all you need do is to consider each distinct pair of elements and count how many pairs are out of order. \$\endgroup\$ – Neil Jan 29 '16 at 8:37
  • \$\begingroup\$ @Neil Of course. But if you can sort a list via swaps of adjacent elements, you can also sort it via swaps of arbitrary elements. \$\endgroup\$ – Martin Ender Jan 29 '16 at 8:42
  • \$\begingroup\$ I just didn't think it was the best, um, sort of sort to use to demonstrate the idea. \$\endgroup\$ – Neil Jan 29 '16 at 8:49
  • \$\begingroup\$ @Neil fixed? :) \$\endgroup\$ – Martin Ender Jan 29 '16 at 9:11
  • \$\begingroup\$ Now that's what I call an excellent sort of sort to demonstrate the idea! \$\endgroup\$ – Neil Jan 29 '16 at 13:42
  • \$\begingroup\$ Oddly enough I was thinking of a challenge very much like this. \$\endgroup\$ – J Atkin Jan 29 '16 at 14:48

Employee Scheduler

This challenge is simple: make a schedule for the student workers in my department!

Student workers have to regularly update their availability to accommodate class changes every semester, and the number of student workers we have employed constantly varies. Also, student workers are not allowed to work more than 20 hours a week. Meanwhile, there are several stations that need to be manned throughout the work day.

Required Minimums:

Your program should at least be able to do the following:

  1. Input a list of first names and times of availability
  2. Output a one month schedule that covers 4 stations 5 days a week from 800 to 1700

If there is a gap of time that cannot be filled based on the availability given, you should fill that gap with an obvious name like "NEEDED" or something like that. Note that the times of availability will depend on the day of the week.

Your program does need to able to at least run in Windows. Also, your program absolutely may not schedule workers more than 20 hours in a week.

You may assume that all student workers have been trained in all stations, so anybody can work anywhere. You also may assume that the month for which you should generate a schedule is following month (so if it is January, make a schedule for February).

Other Notes:

You'll notice I'm not specifying an IO method you must use. I trust you as a coder to pick a method that suits your program, just keep in mind this is a popularity contest and ease of use is an inevitable factor. Also, you may use 12 or 24 hour time at your discretion. Please list both the method of IO and 12 or 24 hour time in your description.

Some things that I'm not requiring, but would definitely earn some kudos from me:

  • Use a station priority system when creating the schedule (some stations should be covered before others)
  • Try to maximize the hours given to each student (while not going over 20 hours per week, of course)
  • Minimize overlap
  • Make your output pretty (currently we use an excel spreadsheet that looks pretty nice)
  • Input the number of stations
  • Input the month for which to generate
  • Generate multiple months (using the same availability)
  • Input holidays and days the department is closed
  • Make your program run on both Windows and OS X
  • Golf your program



Jack    m:0900-1530 t:0800-1530 w:0900-1200 th:0800-1530 f:0900-1700
John    m:0000-0000 t:1300-1700 w:0900-1200 th:1300-1700 f:1000-1200
Joseph  m:0800-1000 t:1300-1700 w:0000-0000 th:1300-1700 f:0800-1000
Jannett m:1430-1700 t:0000-0000 w:1200-1700 th:1100-1400 f:1200-1700
Brianna m:0900-1430 t:0800-1300 w:0900-1430 th:0000-0000 f:1200-1700
Dianne  m:0800-0900 t:1300-1700 w:0000-0000 th:1300-1700 f:0800-1000
Megan   m:1400-1545 t:1100-1700 w:1400-1545 th:1100-1700 f:0000-0000
Sierra  m:1600-1700 t:0800-1100 w:0900-1300 th:0000-0000 f:0800-1300
Sandy   m:1345-1700 t:0800-1045 w:1345-1700 th:0800-1045 f:1200-1700
Holly   m:0800-1200 t:0800-1200 w:0000-0000 th:0800-1200 f:0800-1200


Monday              Tuesday          Wednesday        Thursday        Friday

STA 1               STA 1            STA 1            STA 1           STA 1
Joseph 8-10         Holly 8-1130     Brianna 9-1430   Jack 8-11       Joseph 8-10
Jack 10-1430        Brianna 1130-13  Jannett 1430-17  Megan 11-17     Holly 10-12
Jannett 1430-1700   Joseph 13-17                                      Desiree 12-17

STA 2               STA 2            STA 2            STA 2           STA 2
Riane 8-9           Sierra 8-11      John 9-12        Holly 8-11      Sierra 8-1
Brianna 9-1430      Megan 11-17      NEEDED 12-1430   Jannett 11-2    Brianna 13-17
Megan 1430-1545                      Megan 1430-1545  Joseph 14-17    
NEEDED 1545-16                       NEEDED 1545-17
Sierra 16-17

STA 3               STA 3            STA 3            STA 3           STA 3
Holly 8-12          Sierra 8-1045    Holly 8-12       Sierra 8-1045   Riane 8-10
NEEDED 12-1345      NEEDED 11-13     Sierra 12-1      Jack 11-1       Tyler 10-12
Sandy 1345-17       Riane 13-17      NEEDED 13-1345   Riane 13-17     Sandy 12-17
                                     Sandy 1345-17

STA 4               STA 4            STA 4            STA 4           STA 4
NEEDED 8-9          NEEDED 8-13      NEEDED 8-9       NEEDED 8-13     NEEDED 8-9
Jack 9-10           John 13-17       Jack 9-12        John 13-17      Jack 9-14
NEEDED 10-1430                       NEEDED 12-17                     NEEDED 14-17
Jack 1430-1530
NEEDED 1530-17

As you can see, in this case the input 0000-0000 means that person is not available on that day of the week.


There's an App SE Site for that

Oftentimes, when searching through StackExchange, I find myself seeking to post a question about something or another, but not knowing where to post it. That's where you come in.

The Challenge

Write a full-functioning program that does the following:

  1. Takes an input string
  2. Attempts to find suitable SE sites relevant to the input string (this is very flexible, but should not be returning English.SE for questions about Coffee, for example)
  3. Attempts to find 3 questions on each suitable site that may relate to the input string (should match the list of questions if I searched in the search bar of each site, sorted by number of votes)
  4. "Output" is a folder tree written to disk with the following qualities:
    • The highest folder of the tree should be named the input string.
    • The second-highest layer should consist of folders named the same as the sites on which the input string was found suitable.
    • The third layer should be <=3 .md files that are named the same as the questions found when searching through the suitable sites, the contents of which are the question's markup content.


  • You MUST query for this information. I don't want 50EB solutions.
  • "Suitable sites" are defined as the keyword appearing in the site description.
  • Run time should be <5 minutes for >3 MB internet speed.


There are no bonuses.

Remember - SE is a big place now, and, as of such, we must compensate with short code. This is , everybody, so the shortest solution wins!

  • 5
    \$\begingroup\$ "Whatever defines "suitable" for your code is up to you" is too broad IMO. \$\endgroup\$ – Peter Taylor Jan 25 '16 at 14:35
  • \$\begingroup\$ @PeterTaylor Refined. Please see edit. \$\endgroup\$ – Addison Crump Jan 29 '16 at 17:50
  • \$\begingroup\$ @RikerW I don't know what you're saying. \$\endgroup\$ – Addison Crump Jan 29 '16 at 17:57
  • \$\begingroup\$ Me neither. lol \$\endgroup\$ – Rɪᴋᴇʀ Jan 29 '16 at 17:58
  • 2
    \$\begingroup\$ What's the yardstick for whether two words are synonyms? If that's up to answers to decide, no-one will waste any bytes on it, so you should simplify the question by removing the mention of synonyms. Otherwise you need to add a source (and risk the question being largely a kolmogorov-complexity for that list). \$\endgroup\$ – Peter Taylor Jan 29 '16 at 19:48
  • \$\begingroup\$ @PeterTaylor Fixed. \$\endgroup\$ – Addison Crump Jan 29 '16 at 20:45

Monophonic Pitch Detection


Sandbox Notes

  • Still in progress. I haven't made any of the test cases or snippets yet.
  • This is intended to be an easier and more accessible alternative to Polyphonic Pitch Detection.
  • Would this still be a duplicate of the polyphonic version? Solutions could "work" in both challenges, but algorithms that work for this one would perform extremely poorly (typically monophonic algorithms fail outright with multiple waveforms and produce a completely incorrect frequency) for the other.

Take an array of samples, and output the frequency of the waveform found in the samples.

You will receive a list of samples as signed 16-bit integers at a fixed sample-rate of 44100 samples-per-second. Each input will only contain one waveform in the range of 100hz to 2000hz.

You must output the frequency detected (in hertz) with up to 2 decimal places of precision.

Test Cases

Each test case is on it's own line. Each line begins with the name of the test case, followed by a semi-colon (;), then the frequency present in the test case (with 2 decimal places of precision), followed by another semi-colon, then the samples separated by commas:

Test Case Name;123.45;3,75,1234,56789,4321,-23,-408,-9266,41,0,etc...

(link to test case file, will include synthesized waveforms, real instrument sounds, added noise, different pitches)


The score of a submission is a percentage based on how close the submission's results are to the actual frequency of each test case. Specifically it will calculated using the formula in the snippet below (use this to calculate your score):

(snippet for calculating score)


  • No built-ins that detect pitch or extract waveform frequencies are allowed.
  • Helper functions that are designed to aid frequency analysis like FFT are permitted.
  • You may optimise your solution for the test cases, but you cannot hard-code the results for these specific test cases.

Play Samples

You can hear what a list of samples sounds like by pasting it into this snippet:

(snippet for playing sample strings or sine waves using web audio)



Letter subsets

Consider two letters, L1 and L2. L1 is a solid subset of L2 if and only if all of the lines can be placed on L2 without rotating or breaking L1 or marring the image of L2; this is L1 s.s. L2, symbolically. For example, I s.s. T because you can place the line of I on T without a difference, and C s.s. O for the same reason. Here are all the letters (L1, L2) for which L1 s.s. L2 and L1 ≠ L2:

L1  L2
F   E
C   O
I   T
I   L
O   Q

Two letters L3 and L4 share the relation of variant subset (i.e. L3 is a variant subset of L4, or L3 v.s. L4) if and only if some rotation of L3 exists where L3 s.s. L4. Here are all the letters (L3, L4) for which L3 v.s. L4 and L3 ≠ L4:

L3  L4
F   E
C   O
I   T
I   L
O   Q
V   A
I   H
H   I
I   N
I   M
I   B
I   V
I   X
I   Z
I   P
I   E
I   W
I   R
I   K
I   F
I   D
N   Z
Z   N
T   H
G   Q


Your input will be two letters. You may take them as a string, two characters, or two numbers representing those characters, as arguments, read from STDIN, or from a file. With these two letters, you are to output their relation. You should favor s.s. over v.s. over nothing. Your output will be ss, vs, or nothing. Your program may do anything if the input is not a pair of uppercase letters. Your program should pass all of the above relations when given those letters as input.


Suggestions? Any letters in v.s. or s.s. I missed? Any you don't understand?

  • \$\begingroup\$ If I is a single vertical line (which it is in some fonts, but not all), why is it an s.s. of T and L but only a v.s. of B, D, E, F, H, K, M, N, P, R? (And in some fonts it might also be an s.s. of W). \$\endgroup\$ – Peter Taylor Feb 2 '16 at 12:45
  • \$\begingroup\$ @PeterTaylor I missed those, thanks. \$\endgroup\$ – Conor O'Brien Feb 2 '16 at 14:51



Reasoning is one of the most important human capabilities, often counted as what separates us from other species. This capacity, however, takes up a substantial portion of our meaty brain. Your challenge is to recreate a reasoning system in a much abbreviated form.


The challenge, is, given a universe of objects and n-ary relations and a set of facts and laws on the relations, to determine whether a hypothesis is a fact or not. The language in which these are expressed are drawn from the alphabet "012345789RC@ " under the following rules (in EBNF with an ad-hoc expansion).

  1. An unbound-variable is denoted by a sequence of digits denoting a non-negative integer. For example, 3 is a variable which we may read as "object 3".

    natural = non-zero-digit , { digit } ;

    unbound-variable = natural ;

  2. A bound-variable is denoted by a "@" followed by an unbound variable.

    bound-variable = "@" , unbound-variable ;

  3. A variable is either a bound-variable or an unbound-variable

    variable = bound-variable | unbound-variable ;

  4. A relation-identifier is denoted by a capital "R" followed by a single digit denoting its arity and then a natural number identifying it.

    relation-identifier(n : digit) = "R" , n , natural ;

  5. A relation is denoted by a relation identifier followed by a sequence of variables whose length matches its arity.

    relation = relation-identifier(a) , a * { " " , variable } ;

  6. A consequence is denoted by a capital "C" followed by two relations.

    consequence = "C" , relation , relation ;

  7. An expression is either a consequence or relation of that magnitude.

    expression = consequence | relation ;

The inference rules are the following:

  1. From C R R' and R (where R and R' are relations) to infer R'.

  2. From E to infer E{@m=p} where E{@m=p} is the expression E with all instances of bound-variable @m replaced by variable p.

The Challenge

You will be given a sequence of at least one expression, that will be provided as a newline separated strings on the stdin. The first of these will be a relation with no bound variables -- the hypothesis. The remaining expressions are the facts. Your program must indicate whether the hypothesis can be infered from the facts or not. It does this by printing any of the following strings to the stdout: "true" (case-insensitive), "+", "1", "yes". Any other input will be interpreted as claiming the hypothesis cannot be infered from the facts.

Test cases

>expected output:

>expected output:

R10 0
R10 @1
>expected output:

R20 4 9
R20 9 4
CR20 9 4R20 4 9
>expected output:

R2859 7 163
R2859 @0 163
>expected output:

R10 5
R10 1
CR10 1R10 2
CR10 2R10 3
CR10 3R10 4
CR10 4R10 5
>expected output:

R10 6
R10 1
CR10 1R10 2
CR10 2R10 3
CR10 3R10 4
CR10 4R10 5
>expected output:

R20 4 5
R20 9 6
CR20 6 @0R20 7 @0
CR20 @0 7R20 @0 4
CR20 @0 9R20 5 @0
CR20 @0 @1CR20 @1 @0
>expected output: 

R20 4 5
R20 9 6
CR20 6 @0R20 7 @0
CR20 @0 7R20 @0 5
CR20 @0 9R20 5 @0
CR20 @0 @1CR20 @1 @0
>expected output: 


This is a golf competition, the fewest number of bytes wins. Other restrictions are TBD.


Determine if a given loan repayment schedule is a weekly or a daily schedule?

Problem scope

Its a real life problem which I recently fixed with >90% accuracy but wants to know if there can be near to 100% accurate result. Winner will be the one that can show using datasets that his solution will give minimal failures.

Problem Description

You are given a set of repayment schedules, some of which represents a daily repayment schedule and some represents a weekly repayment schedule. Each repayment schedule is in its own file and you need to segregate the repayment schedule files in 2 buckets, daily and weekly.

No repayment would be received on bank holidays which include weekends.

A weekly repayment schedule means that borrowers have agreed to make regular fixed repayments on a particular weekday every week. A Daily repayment schedule means that borrowers have agreed to make a fixed repayment on all working days till loan gets repaid fully.

Few Borrowers may do one of these besides doing regular repayments.

  1. Choose not to return on some scheduled repayment days.
  2. Choose to make only partial repayment on some scheduled/unscheduled repayment days.
  3. Choose to make extra repayment to catch up on previous payment or just doing prepayment.
  4. May skip making any payment for extended duration.

Off course, not everyone will do all, but in real life people sometimes are not able to make payments or sometimes do catch up or part payments. At the same time, most borrowers would stick to payment schedules for most of the time of the return duration.

A sample demonstrating above conditions from a daily repayment schedule could be as follows for a person not completely regular

Date Repayment amount

1-Feb-2016 500

2-Feb-2016 500

4-feb-2016 500

8-Feb-2016 400

10-Feb-2016 1000

10-Mar-2016 500

11-Mar-2016 500

A sample demonstrating above conditions from a weekly repayment schedule could be as follows for a borrower not completely regular

Date Repayment amount

1-Feb-2016 500

8-Feb-2016 500

17-feb-2016 500

22-Feb-2016 400

07-Mar-2016 1000

14-Mar-2016 500

11-Mar-2016 500

This real life problem is related to repayment schedule of low income borrowers where anomalies like above can be considered fair owing to their meager means. The sample above are only small part of the file, not the whole file.

I have clarified some doubts at https://codegolf.stackexchange.com/questions/71334/determine-if-a-given-loan-repayment-schedule-is-a-weekly-or-a-daily-schedule . Check those if possible.


Is the plate balanced?


Given a grid of 1 digit numbers and a coordinate, tell me if it is balanced.

How to balance check

Explanation coming. I know how it works for 1d (Balance a set of weights on a seesaw), but don't know how it would work for 2d.


Input will be a grid of 1 digit numbers. Each number corresponds to the amount of weight at that location.



  • \$\begingroup\$ Will the center of mass always be at integer coordinates? \$\endgroup\$ – lirtosiast Feb 8 '16 at 2:42
  • \$\begingroup\$ No, but this is the only example I know is correct right now. Unfortunately I haven't learned now to solve this type of problem yet, and the Wikipedia entry doesn't help for this use case. \$\endgroup\$ – J Atkin Feb 8 '16 at 2:55
  • 1
    \$\begingroup\$ Center of mass in 2D can be found by just calculating the coordinates separately; that is, you sum up the rows and calculate the y value, then sum up the columns and calculate the x value. \$\endgroup\$ – lirtosiast Feb 8 '16 at 4:03

Sloppy Shuffle

Write a program that will shuffle the numbers from 1 to 52. Rather than from your language's random facility, the result will be determined by the input. But not in any particular way -- however you choose!

The Rules

  • The program must accept all possible (finite) inputs. It doesn't matter if it is empty, or the result of monkeys with typewriters, or anything in between. Literally any input must be accepted without (unhandled) errors.
  • For each of the 52-factorial possible ways of shuffling the numbers, there must be at least one finite input that will make your program produce this permutation.
  • No matter what (finite) input is given to the program, it must produce some permutation of the numbers.
  • If given the same input, the program must always produce the same permutation.
  • Nothing should be produced on stderr.
  • Standard restrictions apply.


Default input methods (such as stdin or command line args) are acceptable. If using stdin, any finite input from stdin must be accepted (although it doesn't all have to be read). For other input methods, use your best judgement in accepting arbitrary binary or string data as appropriate.

Default output methods (such as stdout) are acceptable. The form of the output should be the number from 1 to 52 in some order corresponding to the permutation as appropriate for your output method.


This is code golf. The shortest answer in bytes wins!

However, in case of a tie in code length, the first tiebreaker is the maximum over all permutations of the minimum input length needed to generate that permutation. The program that has a larger minimum input wins.

(That may have been confusing, so an example: if program A can generate any permutation with no fewer than 100 bytes of input, but program B needs at least 1000 bytes to generate the identity permutation, program B wins the tie.)


This is an example of a program which fulfills the requirements in Lua:

-- return a number from (1,n) depending on input
local function pick_from(n)
  local str = io.read() or ""

  -- always proceed even if input is not a number
  local num = math.floor(tonumber(str) or 0)

  -- guard in case of parsing overflow (e.g. input of 1e99999999999)
  if num ~= num or num > 1000 or num < -1000 then
    num = 0

  return 1 + (num % n)

-- create a list of 52 numbers
local deck = {}
for i = 1, 52 do
  deck[i] = i

-- Fisher-Yates shuffle algorithm
for i = 52, 1, -1 do
  local j = pick_from(52)
  if i ~= j then
    deck[i], deck[j] = deck[j], deck[i]

for i = 1, 52 do

Notice that although I used the Fisher-Yates algorithm, the property that Fisher-Yates generates a permutation uniformly is irrelevant to the correctness of the program.

Another note -- if you never read at least log2(52!) bytes from the input, it is probably impossible for your program to generate all permutations.

  • 3
    \$\begingroup\$ As far as I can tell, printing the input unchanged satisfies the spec. \$\endgroup\$ – feersum Feb 7 '16 at 14:28
  • \$\begingroup\$ "Each possible finite input must produce some permutation of the numbers." If the input is not a valid output (as most are not), simply printing the input does not satisfy this requirement. \$\endgroup\$ – tehtmi Feb 7 '16 at 20:07
  • \$\begingroup\$ Okay, the intent was that every input must be accepted, but I can see how that is not clear from what I wrote. I'll try to edit it. \$\endgroup\$ – tehtmi Feb 7 '16 at 20:12
  • 1
    \$\begingroup\$ Okay, so I see that there must be some input that corresponds to every permutation. But input can be literally anything? I'm also confused by what you mean by "uniform" that is usually used in regard to some sort of probability distribution, but you say that the same input must always do the same permutation, so there doesn't seem to be anything random. \$\endgroup\$ – Liam Feb 7 '16 at 21:15
  • \$\begingroup\$ Yes, the intent is that the program should accept literally any input and produce a valid output. Also true that there is nothing random. I am trying to use "uniform" to evoke the sense that outputs would be evenly distributed across inputs (maybe for each bounded size). However, since I am explicitly not requiring it, it does not need to be well defined for the question to be well-formed. I thought that using the word "shuffle" people would think they are required to use a uniform shuffling algorithm. Maybe it is better to leave this part off. \$\endgroup\$ – tehtmi Feb 7 '16 at 22:11
  • 1
    \$\begingroup\$ Why don't you go with the defaults (function/full program, input via stdin/function argument/command line, etc)? They've proven to work for most challenges. \$\endgroup\$ – nimi Feb 7 '16 at 23:03
  • \$\begingroup\$ I don't want to restrict anyone. I thought it was safer to be more specific, but I guess maybe people don't need to be told. I was a little worried about input methods since my idea of accepting arbitrary input may not have a well-established meaning for all input methods. However, I've tried to edit the question to remove all such restrictions. \$\endgroup\$ – tehtmi Feb 8 '16 at 1:07
  • 1
    \$\begingroup\$ @tehtmi: the main problem with very strict rules is that whichever one you choose it will fit some languages and will be awkward in others. Let's take your requirement for nl/space/tab separated numbers as an example: in some languages it's just a "print" of an array variable. Other languages would print brackets around and commas in-between the elements, so they have to loop over the array and print each number individually. People don't like such disadvantages for their favorite language. Please consider allowing "native array format" or "any reasonable format" for the output list. \$\endgroup\$ – nimi Feb 8 '16 at 4:29
  • 2
    \$\begingroup\$ The obvious golfed approach is to say that if the input is a valid output, print the input; otherwise print the identity permutation. In no way does it meet what I would presume to be the intent of the challenge, but it does meet the spec. \$\endgroup\$ – Peter Taylor Feb 8 '16 at 8:17
  • 1
    \$\begingroup\$ ^ yeah. I would recommend narrowing the input specs. "Input can be anything" will usually get you into trouble. \$\endgroup\$ – Liam Feb 8 '16 at 19:45
  • \$\begingroup\$ @Peter Taylor: I actually have no problems with that solution. I'm not convinced, though, that it would obviously be the best solution. Probably it would be best in some languages and not in others. Checking whether an input is a permutation seems to be of similar complexity to many shuffling algorithms, but it may be more likely that some languages would have built-ins to do it. \$\endgroup\$ – tehtmi Feb 8 '16 at 22:19
  • \$\begingroup\$ @Liam: I think the input spec is the only thing that makes this problem interesting (and original -- there have been other shuffling golf challenges). Maybe nobody thinks it is a good question in which case it can die in the sandbox, but at least for myself, having the input as another dimension over which to optimize seemed somewhat interesting. \$\endgroup\$ – tehtmi Feb 8 '16 at 22:22
  • 1
    \$\begingroup\$ Many many languages have built-in sort, and sorting and then checking that a[i] = i+1 for all i is sufficient. \$\endgroup\$ – Peter Taylor Feb 8 '16 at 22:27
  • 1
    \$\begingroup\$ You could possibly around the described solution by limiting input to a set number of characters and then require that each of the 52! outputs have at least a certain number of things that map there, or require that every output has the exact same number of inputs that map there. \$\endgroup\$ – Liam Feb 8 '16 at 22:41
  • \$\begingroup\$ Okay, so you are iterating through a list once and doing some simple logic. In my (ungolfed) example, I iterate through a list once and do some simple logic. My loop can basically be reduced to three logical steps -- input, sanitize input, swap. Your loop only has one logical step -- compare. However, you have three logical steps before your loop -- input, sanitize input, sort. In golf, it generally doesn't matter if steps are in a loop or not. I'm sure we could argue about my exact breakdown of the steps, but it still seems to me that both methods are similar. \$\endgroup\$ – tehtmi Feb 8 '16 at 22:46

How clean is my snow?

Idea shamelessly take from https://codereview.stackexchange.com/questions/118538/how-clean-is-my-snow#comment221029_118538

The challenge

Your challenge is to tell how clean my snow is. Unclean snow is any snow that is not pure white. This would be super easy except for one hiccup, not all of the image is a picture of the snow, in the case of the image above some of the image is the sky (can't you tell? I'm such a good artist!).

Determining where the background is

[Write-up coming, it has to do with how large the splotch is and finding the biggest white spot, so the clouds don't count]

enter image description here


ToUpperCase... Mathematica style

For this challenge, you must write a program or function that converts every character in a string to upper case. "Wouldn't this be too broad/a duplicate/etc.?" you ask. Nope; you have to exactly implement Mathematica 10.1's ToUpperCase function!


ToUpperCase works quite peculiarly on Unicode. For example, ß converts to SS! The full replacement list (from:to(,to);):



  • You cannot use a built-in that completely solves this challenge.
  • If a function is written, the input is guaranteed to be a single string or equivalent.
  • All characters not specified in the replacement list are to remain unchanged.
  • All codepoints will be less than U+10000.
  • If and only if your language can only take bytes as input, the string will be encoded in UTF-8.
  • Standard loopholes are disallowed.
  • Have fun!

Test cases TBD

Meta Questions

  • What are some good test cases for this challenge?
  • Is there something that I possibly missed while writing this challenge?
  • 1
    \$\begingroup\$ '"Wouldn't this be too broad?" you ask.' No I would ask "Isn't this a duplicate?" ;) \$\endgroup\$ – Martin Ender Feb 11 '16 at 13:16
  • 5
    \$\begingroup\$ "You can't use Mathematica for this challenge." Why not just ban the built-in? \$\endgroup\$ – Martin Ender Feb 11 '16 at 13:16
  • 1
    \$\begingroup\$ Further notes: 1. the list of transformations is short enough to be included in the post to ensure that it's self-contained. 2. You could just call it "Unicode-aware case conversion" or something. I'm pretty sure that the built-ins of languages like C# and Java will also perform the conversion the same way. \$\endgroup\$ – Martin Ender Feb 11 '16 at 13:19
  • \$\begingroup\$ @insertusernamehere Looking at the list that's actually the only special one. \$\endgroup\$ – Martin Ender Feb 11 '16 at 13:21
  • \$\begingroup\$ >>> "ß".upper() 'SS' - Python might not do the whole list the same way, but it does do some. So reiterating Martin's comment, I wouldn't be surprised if there was something out there which did most of the list the same, if not all... \$\endgroup\$ – Sp3000 Feb 11 '16 at 13:23
  • \$\begingroup\$ @MartinBüttner I'm planning on possibly making a series out of this. \$\endgroup\$ – LegionMammal978 Feb 11 '16 at 13:28
  • \$\begingroup\$ How close to solving the challenge does a builtin have to be to be disallowed? e.g. what if a builtin only gets half of them correct, and needs to encode the rest? 75% correct? 90% correct? \$\endgroup\$ – Sp3000 Feb 11 '16 at 13:32
  • \$\begingroup\$ The list needs a bit of cleaning up. In particular, 223:83,83 is clearly erroneous. \$\endgroup\$ – Peter Taylor Feb 11 '16 at 14:38
  • \$\begingroup\$ @PeterTaylor Why? Isn't 223 the character code of ß and 83 the character code of S? \$\endgroup\$ – Martin Ender Feb 11 '16 at 15:38
  • \$\begingroup\$ @MartinBüttner, oh, I see. So what needs fixing is to document the list and describe its format. \$\endgroup\$ – Peter Taylor Feb 11 '16 at 15:57
  • 1
    \$\begingroup\$ 1. I'm fairly certain Mathematica can in fact encode any Unicode character, most likely by using surrogate pairs (two characters from U+D800 to U+DFFF). 2. Uppercasing ß as SS is fairly standard, but why on Earth would Mathematica uppercase ÿ as Y when there's a perfectly good Ÿ available? \$\endgroup\$ – Dennis Feb 11 '16 at 20:17
  • \$\begingroup\$ @insertusernamehere I didn't want to break peoples' browsers with non-rendering characters (Mathematica uses its own custom font). \$\endgroup\$ – LegionMammal978 Feb 11 '16 at 23:11
  • 1
    \$\begingroup\$ @Dennis 1. Its default encoding is UTF-8, trying to paste emoji makes the interpreter explode, FromCharacterCode only accepts up to U+FFFF, and trying to use surrogates renders a two invisible characters, which makes me believe this is the case. 2. One does not question the inner workings of Mathematica. \$\endgroup\$ – LegionMammal978 Feb 11 '16 at 23:14
  • 1
    \$\begingroup\$ OK, my mistake. A bit of googling revealed that Mathematica's Unicode support is incomplete and exceptionally buggy. \$\endgroup\$ – Dennis Feb 11 '16 at 23:36

Use Simpson's Rule

Simpson's rule is a fairly simple method for approximating a definite integral of one variable. The idea is to approximate the function to be integrated by a series of interpolated parabolas, and then find the area under those.

As I learned in first-year calculus, the form of Simpson's Rule we'll be using is:

Simpson's rule from Wikipedia

where the width of each interval is h.

Equivalently, this is the dot product with the vector h/3([1,4,2,4,...,1]) the same length as the input.


  • An array of n>1 real numbers representing the values of f at x-values equally spaced by h. n will be odd.

  • h, a positive real number.


The area approximation that Simpson's Rule gives.

Test cases

[0,0,0], 1 -> 0
[3,1,4,1,5], 1 -> 8

[add more]
  • \$\begingroup\$ Simpson's rule requires an even number of intervals, so there has to be an odd number of endpoints. \$\endgroup\$ – Dennis Feb 12 '16 at 6:22

Implement the Block Sort sorting algorithm

Block sort is an interesting sorting algorithm (comparatively speaking). Here are some of its important properties:

  • O(n log n) time complexity in worst and average case
  • O(n) time complexity in best case
  • O(1) space complexity (not including the space that holds the list itself)
  • Stable

If you check out this table comparing sorting algorithms, you'll see that it's the only one that has the whole row highlighted in green.

Your challenge is to write an implementation of the block sort algorithm in the fewest bytes.

  • \$\begingroup\$ I take it you're actually going to explain block sort in the spec before posting this? \$\endgroup\$ – Martin Ender Feb 14 '16 at 18:32
  • \$\begingroup\$ @MartinBüttner I'd assume so, but I don't know if I'll ever get around to it, mainly because it seems pretty tedious/complicated. \$\endgroup\$ – PhiNotPi Feb 14 '16 at 18:40

Advent of Code, puzzle 1

I don't know if anyone here spent their December working on the problems found on Advent of Code, but I thought some of the simpler problems might make good code golf puzzles.

So, here's the first one. There will be two challenges, and the solution should be a pair of programs, each of which solves one challenge.

Score is based on the combined byte count of the two programs.

(An alternative would be to also allow a single program that produces a tuple of the two solitions- what do you think?)

Input: An unbalanced string of open and close brackets.

Output 1: The count of the number of open brackets take away the number of close brackets.

Output 2: The index of the first close bracket that causes the running sum to reach -1.

  • \$\begingroup\$ This could be a copyright problem. \$\endgroup\$ – Martin Ender Feb 15 '16 at 16:11
  • \$\begingroup\$ I'll contact the creator and ask his permission to reproduce his problems. I would not imagine it to be an issue but you're right that I should verify first. \$\endgroup\$ – A Simmons Feb 15 '16 at 16:18
  • 1
    \$\begingroup\$ I'm generally not a fan of asking for multiple programs in the same challenge and combining their byte count, if the two solutions don't influence each other at all. I'd say either ask for a single solution that computes both numbers at once, or choose one of the problems. (Also, FYI the first challenge is trivial in GolfScript and CJam, because ( and ) are the operators for decrement and increment.) \$\endgroup\$ – Martin Ender Feb 15 '16 at 16:34
  • \$\begingroup\$ Yeah I actually used these as practice problems when my partner and I were learning CJam over the weekend, but I can't see anything better than a 5-byte solution in CJam for the first one: 0q~W*. Perhaps just putting the second challenge is better for this one. \$\endgroup\$ – A Simmons Feb 15 '16 at 16:39
  • \$\begingroup\$ IIRC one or two of these were posted in December and deleted for copyright reasons. \$\endgroup\$ – Peter Taylor Feb 15 '16 at 16:58
  • \$\begingroup\$ The creator has now given the go-ahead for these problems to be replicated twitter.com/ericwastl/status/699455417768923137 \$\endgroup\$ – A Simmons Feb 16 '16 at 11:10
  • \$\begingroup\$ Might be worth including that in the challenge to avoid repeating the same discussion when it goes to main. \$\endgroup\$ – Martin Ender Feb 17 '16 at 8:22

Knights and Knaves posted

Undeleted so that comments are visible

  • \$\begingroup\$ Related. \$\endgroup\$ – PhiNotPi Feb 3 '16 at 2:44
  • 1
    \$\begingroup\$ I find some of the wording rather confusing, in particular the statement that Is is a logical operator (shouldn't that be Iff?) and the references to de Morgan's laws, which are theorems and not operators. But essentially ISTM that this question differs from the other question only in the parser (which makes some simplifications and adds a case to parse =>), and I would vote to close it as a duplicate. \$\endgroup\$ – Peter Taylor Feb 3 '16 at 14:34
  • \$\begingroup\$ @PeterTaylor I'll add some stuff to clear up the IS thing, because you're right, it isn't really a logical operator, I was just trying to keep it simple. I think that the parsing of conditionals and having to actually use De Morgan's makes this challenge significantly more complicated than the other. Especially given that other is literally focused on the English parsing, whereas this is focused only on the logic. Basically you cannot "trivially" change answers from the other question to solve this one. \$\endgroup\$ – Liam Feb 3 '16 at 17:49
  • \$\begingroup\$ I really can't see any fundamental difference between the two questions with respect to de Morgan's laws. The earlier question doesn't have a direct Not operator, so requires abusing Nor, but it allows arbitrary nesting of clauses. \$\endgroup\$ – Peter Taylor Feb 3 '16 at 21:11
  • \$\begingroup\$ @PeterTaylor Could you quote the other challenge? I'm reading it and not seeing anything to do with De Morgan's. I'm specifically looking at the "Parsing" section. \$\endgroup\$ – Liam Feb 3 '16 at 21:15
  • 1
    \$\begingroup\$ both [clause] and [clause] either [clause] or [clause] neither [clause] nor [clause] between them contain everything you need to set up a clause equivalent to ~(A ^ B) or ~(A v B). \$\endgroup\$ – Peter Taylor Feb 3 '16 at 21:28
  • \$\begingroup\$ @PeterTaylor Yes, but you don't have to parse the negations of con/disjungtions and hence do not need to use De Morgan's at all. Sure, they end up equivalent at the end of the day but that's not the point. I'm not allowing people to read inputs and say "Hey, X is equivalent to Y... why don't I just enter Y instead." If it can't parse X, then it fails the spec. \$\endgroup\$ – Liam Feb 3 '16 at 21:33
  • \$\begingroup\$ There's nothing in your question which obliges people to use de Morgan's laws either. They just need to brute-force all possible assignments and evaluate the expressions. \$\endgroup\$ – Peter Taylor Feb 3 '16 at 21:36
  • \$\begingroup\$ @PeterTaylor Yes, and they would be in their rights to do so. However, that is not how people actually solved the other question. And it may or may not be the best way to solve this one. So sure, that is a valid concern, but not evidence that this is a duplicate. \$\endgroup\$ – Liam Feb 3 '16 at 21:39
  • \$\begingroup\$ It is how ugoren solved the previous one; Howard's solution is harder to understand, so I'm not sure exactly how it works. \$\endgroup\$ – Peter Taylor Feb 8 '16 at 22:43
  • \$\begingroup\$ @PeterTaylor Hmm, sorry I must have missed that. That is true. There is still the matter of conditional logic however. \$\endgroup\$ – Liam Feb 8 '16 at 22:58

Diopter lenses

In photography, there are thin lenses that you put in front of a photographic lens to make it behave like a close-up lens. Each of these lenses has an associated diopter value which is a positive integer. If you stack two (or more) of these lenses you get an equivalent of a lens with the diopter value that is the sum of the values of those lenses.

The problem

Your program should take one diopter value n as an input. The input need not be validated.

You should output in any human readable form a list of diopter lenses such that:

  • the maximum diopter value you can form by stacking the lenses is n,
  • every diopter from 1 to n can be formed by stacking a combination of those lenses,
  • there exists no set of fewer lenses that complies to the above rules.

An example

Given the input of:


Print the output of




The rules

This is code golf, so the objective is to write the shortest possible code, but, since there is a trivial solution that might not be obvious to some, I suggest that the answer be encoded by some means so one wouldn't see the solution before attempting to solve the problem.

Any type of output is accepted, as long as the program outputs correct clearly separated positive integers and no other alphanumeric character.

My solution

python 2, 52 bytes, base64 encoded


, ,

  • \$\begingroup\$ I think this is too much of a math problem and not enough of a code-golf problem. \$\endgroup\$ – lirtosiast Feb 15 '16 at 20:58
  • \$\begingroup\$ That's exactly why I posted it here. Not having seen many on this site before, I was curious whether such problems were adequate for code-golf. \$\endgroup\$ – Fran Borcic Feb 15 '16 at 21:02

Plotting Dynamical Systems in ASCII


  • A Function to and from the real plane (henceforth R2) , call it F

  • A point in R2 that is to be the center of a disk, call it c

  • A radius, call it r

  • An integer representing the number of iterations to be performed, call it n.


You are to output n+1 ascii "images". The first depicts the disk D (with center c and radius r) and the ith image depicts F^i(D), aka F(...F( F(D) )...) where we have applied F to D, and then applied F to F(D) and so on until we have applied F i times.

Input Details:

  • F will always be polynomial. See below for acceptable examples.

  • Any c = (c1,c2) given will satisfy |c1|<50 and |c2|<25.

  • Also, r will always be small enough that D the disk around c with radius r will contain no points with an x coordinate greater than 55 or less than -55 and no y coordinate greater than 32 or less than -32.

  • n will be positive and less than 5.

Output Details

  • We will be looking at a rectangular subset of R2 given by { (x,y) : -60 <= x <= -60 and -33 <= y <= 33}. i.e. a rectangle with side lengths 120 and 66 centered at the origin.

  • Each output image will contain 320*320 characters. This represents the above region in R2 with gradations of 0.5 along each axis.

  • Each character will represent a single point in R2. For example if we just look at part of the first quadrant (with the axes labeled which you need not do)

    7 .............................
    6 .............................
    5 .............................
    4 ............................
    3 .............................
    2 .....................b.......     b =(10.5,2)
    1 ..a..........................     a = (1,1)
      .............................     z = (0,0)
    0 z............................  --------> x 
      0 1 2 3 4 5 6 7 8 9 | | | | |  
                        10| 12| 14
                          11  13
  • Points that are empty (i.e. not in F^n(D)) will be represented by the . character, whereas filled spaces will be represented by #.

  • Each image will have the same or fewer # represented points in it because we will not be displaying points that are outside the region.

    How do these maps work?

These are iterative maps we will be dealing with. For each point # in a given image, to get the next image, you will apply the given map F to it. If the point leaves the viewing area, you need not render it. However if in a later iteration it should reenter the viewing area, it should reappear.

For the purposes of this challenge, the image of a point should be rounded to the nearest 0.5.

A map might be F(x,y) = (4x(1-x), x+y)


Hourglass simulator

Write a full program or function to simulate an hourglass.


n, the number of seconds on the hourglass.


At the start, there are n seconds on a timer, and the timer is counting down. When the user presses the spacebar with t seconds left, set the time left to n-t. Terminate the program when time runs out.

This models an hourglass where the top of the hourglass is initially filled with n seconds of sand. When the spacebar is pressed, the hourglass flips by 180°. When either side of the hourglass runs out of sand, the program terminates.

[Is there anything I'm missing? This spec seems really short.]

  • 2
    \$\begingroup\$ I don't understand this spec. Are you displaying an hourglass? Does the program output anything? \$\endgroup\$ – xnor Feb 16 '16 at 0:25
  • 4
    \$\begingroup\$ "when the spacebar is pressed" seems quite limiting, especially for terminal interaction which might not flush STDIN before the end of the line. I'd allow any sort of user action, but if you want to make it specific, then sending a line/hitting enter would probably allow a lot more languages to participate. \$\endgroup\$ – Martin Ender Feb 16 '16 at 8:25
  • \$\begingroup\$ You need to state exactly how the hourglass should be displayed \$\endgroup\$ – ASCII-only Feb 16 '16 at 9:28
  • \$\begingroup\$ @somebody As far as I understand the challenge the program shouldn't display anything. It should just act like an hourglass. \$\endgroup\$ – Martin Ender Feb 16 '16 at 14:00
  • \$\begingroup\$ @xnor cc the above \$\endgroup\$ – Martin Ender Feb 16 '16 at 14:00
  • \$\begingroup\$ Thomas, seems likely this is going to come up again on main if you leave the spec as it is. Maybe don't talk about the "top of the hourglass" and "seconds of sand" and flipping "by 180°" but phrase the challenge in terms of a timer instead, whose current value gets subtracted from n each time there's user input. \$\endgroup\$ – Martin Ender Feb 16 '16 at 14:02
  • \$\begingroup\$ @Martin I agree. \$\endgroup\$ – lirtosiast Feb 16 '16 at 15:58
  • \$\begingroup\$ @lirtosiast shouldn't it replace time with n-timewhen flipped instead? \$\endgroup\$ – ASCII-only Feb 17 '16 at 6:26
  • \$\begingroup\$ @somebody Oh, I guess that's the same behavior. \$\endgroup\$ – lirtosiast Feb 17 '16 at 6:31
  • \$\begingroup\$ Since taking real-time input is limiting for some languages, what if you took in a list of times at which the presses happen? \$\endgroup\$ – xnor Feb 17 '16 at 7:56

Implement an SR NOR latch with Life-like rules

In Conway's Game of Life, there exist meta-pixels that can have any Life-like rule. Consequently, it is possible to simulate Conway's Game of Life with itself. It is also possible to build circuit-like structures, such as wires and logic gates by mixing together different Life-like rules in the right ways.

For example, one can simulate wires with three Life-like rules: B/S, B1/S, and B2/S (where the original Game of Life has the rule B3/S23). In the gif below, which shows one way to cross parallel wires, these rules are black, blue/cyan, and green/yellow, respectively.

enter image description here

Building such circuit components is a fun challenge, and I encourage you to try a couple logic gates, like AND or OR.

The Task

Your task is to construct an SR NOR latch, the most fundamental latch in circuitry. From Wikipedia:

enter image description here

  • If there is no signal on either R or S, leave the outputs unchanged.
  • If there is a signal on R (reset), the Q output turns off and the Qbar output turns on.
  • If there is a signal on S (set), the Qbar output turns off and the Q output turns on.
  • You may safely assume you will never get a signal on both R and S at the same time.

Now, I used the word signal repeatedly because there are different ways to do wires. You can use the B1/S + B2/S combination shown above (blue and green, respectively), or you can use a B1/S12 rule like this:

enter image description here

These methods and others have their advantages and disadvantages. This is part of the challenge.

The Rules

  • If periodic input/output is chosen, then the output should have the same period as the input. As one of the output wires will always be "on", the output from this should be periodic and infinite (like a glider gun, say).
  • You may assume that periodic signals are given with a period greater than the time it takes for the latch to flip.
  • Steady input must be succeeded by steady output.
  • You may not make the field toroidal in any way, except for demonstration, like the wire crossing example above. This is intended to disallow cheating by wrapping vertically so no wire crossing is needed.
  • If the circuitry is periodic, you may assume the input signal arrives at the most convenient time.
  • Initially, the Q output should be off and the Qbar output should be on.


Precise details on how to weight these is to be determined.

  • Fewer rules is better. The wire crossing example above has three rules: B/S for black, B1/S for blue, and B2/S for green.
  • Smaller is better. Area will be considered, as in the minimum bounding box needed to contain all necessary pixels that are not part of a wire. For instance, the wire crossing example above has a bounding box that is 4 pixels wide (the tips of the wires - where there is a blue cell without a green sheath - are not included) and 9 pixels high, for a total area of 36 pixels.
  • Faster is better. For this, count the number of generations from when the input arrives to when a fully formed output leaves. For the example above, this would be 9 units of time. Here is a gif of those 9 generations, including the one before.
    enter image description here
  • Lower latency is better. I define this to be the number of generations after a fully formed output leaves until the system has either stopped evolving or settled into a periodic pattern. The example above would have a latency of 2 generations. For periodic patterns, "settled" is defined to be when the system reaches the first pattern that will be repeated (the start of the cycle).

Note: I strongly recommend using Variations of Life for this.


  • Additional clarifications needed?
  • \$\begingroup\$ The SN NOR latch in circuitry has continuous output on one of its signals. How is that to be modelled with the given rules? E.g. your wire crossing just sends a single instantaneous signal to the output. And what is the initial state of the latch? \$\endgroup\$ – Martin Ender Feb 17 '16 at 8:14
  • \$\begingroup\$ Also please don't make it a popcon. :/ \$\endgroup\$ – Martin Ender Feb 17 '16 at 15:01
  • \$\begingroup\$ @MartinBüttner: Edited. \$\endgroup\$ – El'endia Starman Feb 17 '16 at 20:19
  • \$\begingroup\$ I would say code-challenge for this. GOL is programming, by virtue of GOL being TC. \$\endgroup\$ – user45941 Feb 17 '16 at 20:47
  • 2
    \$\begingroup\$ I think that this would be a lot easier to understand with some reordering. I read the intro, up to "this is one way to cross wires:", looked at the image, and had no idea what I was seeing. I just knew that it had too many colours to be GoL, which was confusing. \$\endgroup\$ – Peter Taylor Feb 17 '16 at 22:02

Dice sums from side values

I rolled some dice and put them on the table with their sides touching and forming one object with 8 horizontal sides. This means I put the dice in one of these formations (up to rotations):

xx   x
xx   xx  xxx

I read the number pips on the 8 horizontal sides in counter clockwise direction. You should write a program or function that given the list of the 8 horizontal sides in counter clockwise order returns a list of possible sums of the top pips from the dice rolling.

The layout of a die is always the following:

    | 1 |
| 2 | 3 | 5 | 4 |
    | 6 |

For example if the input is 3 2 1 1 2 6 6 5 there are four possible configurations with top views:

623, 633, 643, 653 giving the output list 11, 12, 13, 14

with the sides always being


For the input 1 1 2 2 3 3 2 2 there is only one configuration with the top view:

31 giving the one element output list 14




This is code golf so the shortest entry wins.

Related code golf with a single die: Determine dice value from side view

  • \$\begingroup\$ Is there any input where multiple layouts are valid? (If so you'll need test cases for that.) Also your premise is a bit weird since the number of dice isn't constant. ;) \$\endgroup\$ – Martin Ender Feb 27 '16 at 16:32
  • \$\begingroup\$ @MartinBüttner I think there will be inputs with multiple valid layouts but I don't have code yet to check it. I will change the premise to "the 8 side numbers are all I remember". That might be a bit sensible. \$\endgroup\$ – randomra Feb 27 '16 at 18:40

Length of a month starting from a specific day

Given a date, you are to output the number of days from today, to the last date that has a number less than today next month.

It can be calculated this way:

  • If the current date in the month is not more than the number of days next month, output the number of days in the current month.
  • Otherwise, output the number of days in the next month + number of days starting from the current day in the current month.

This is code-golf. Shortest code wins.


2016-01-21  ->  31
2016-01-30  ->  31
2016-01-31  ->  30
2016-02-29  ->  29

Should leap years be supported?


Repeatedly convert from minimal base to base 36

Your task is to convert an input of a list of strings which represent arbitrarily large numbers from the lowest possible base to base 36, repeatedly, until there is no further change to be made.


  • You may not use base conversion builtins.
  • From 0 to 35 in base 36 is defined as:
    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
  • All submissions will be tested on this cloud 9 workspace and should be uploaded for testing (along with any updates) on this GitHub repository.
  • All submissions must be written for compilers/interpreters that:
    • Are free to use.
    • Do not take up excessive space.
    • Can run with simple installations on Ubuntu 14.04.

Test Cases:

Coming soon
  • \$\begingroup\$ Do you expect to get runtimes large enough to be measurable? \$\endgroup\$ – Peter Taylor Mar 1 '16 at 10:32
  • \$\begingroup\$ @PeterTaylor Yes - I expect to convert lists of large (arbitrarily precise) numbers. \$\endgroup\$ – Addison Crump Mar 1 '16 at 13:17
  • 1
    \$\begingroup\$ That doesn't really answer the question. A random 1000-digit base-35 input will become a roughly 990-digit base-36 string after the first step, and the probability of going to a second step is about (1/36)^990, which is pretty negligible. But one base conversion of a number on the order of 1000 digits isn't going to take long enough to time. I would hazard a guess that you need input on the order of hundreds of millions of digits to be timeable, and then the business with the loop is completely pointless because for practical purposes it will always run once. \$\endgroup\$ – Peter Taylor Mar 1 '16 at 15:43

Elementary Cellular Automata, My Dear Watson

A seemingly innocent dinner party composed of elementary cellular automata has just been turned into a murder mystery. One of the cellular automaton guests has killed the host! All that remains as evidence for who committed the crime is the nth generation of the perpetrator. Luckily for them, Sherlock Holmes is on the case.

Show Watson how it's done by taking an integer n, and a string representation of the nth generation of the murderous automaton and printing or returning a list of the possible suspects (the numbers representing the rule of each amphichiral elementary cellular automata, see the bottom of the linked page.)


  • The input string will have length 2n+3 for the nth generation.
  • The first character of the string represents the values on the infinite tape to the left, and the last character of the string represents the same for the right.
  • Assume that the automata start with a single 1 in the center of a string of all 0s.


Generation 0 of every automaton:



  • I don't have a reference implementation yet, nor have I created any examples.
  • \$\begingroup\$ What is this string representation? Will it be padded with zeros? \$\endgroup\$ – LegionMammal978 Sep 26 '15 at 17:24
  • \$\begingroup\$ Then again, you would need a way to show the background (Rule 255, for example, would need infinite bits.) Also, should we assume that it starts with a single one in a background of zeros? \$\endgroup\$ – LegionMammal978 Sep 26 '15 at 19:53
  • \$\begingroup\$ So wait... You aren't given the full generation? Also, do the generations start at 1 or 0? \$\endgroup\$ – LegionMammal978 Sep 26 '15 at 20:40
  • \$\begingroup\$ Looking at your Mathworld link, it seems that you would need 2 background bits. \$\endgroup\$ – LegionMammal978 Sep 26 '15 at 21:21
  • \$\begingroup\$ If I were a Haskell programmer, I would feel rather hard-done-by that the spec seems to require using an IO monad even if I'm writing a function rather than a full program. Is the special-cased output really worth it? \$\endgroup\$ – Peter Taylor Mar 1 '16 at 21:07
  • \$\begingroup\$ @PeterTaylor I suppose you're right. Updated. Also, perhaps someone could help with a reference implementation, or least some examples? The effort it would take me to create a solution is probably more than someone else. I don't really know a lot about cellular automata. \$\endgroup\$ – mbomb007 Mar 1 '16 at 21:26
  • 2
    \$\begingroup\$ Test case generator. Each line of output contains a generation and then the amphichiral rules which give it. Change the 10 which has a comment about generations if you want to run more. \$\endgroup\$ – Peter Taylor Mar 2 '16 at 14:34

Binary Arithmetic Using Unary Operators

This is based off a game I was playing with a friend a few years back. How many different mathematical operators can you implement using only unary operators in your source*. We were able to implement most basic arithmetic in C, but for this challenge you can use any language.

* Except under certain conditions, see below.


All binary operators are disallowed, except under the following conditions:

  • Binary comparison operators are allowed as long as one operand is a constant (e.g. you can do if (x == 0) or if (x) but not if (x == y))
  • You may use binary assignment to load user input, only at the start of your code, or if you create a binary = method using these rules.
  • You may assume that all variables are default-initialized to 0; if your language does not default-initialize variables, you are allowed to set them to zero only at the start of your code.

Additionally, please note the following:

  • You do not have to write a complete program if your language supports functions/methods.
  • You can use other operators from your source (e.g. your implementation of * could use your implementation of +)
  • Standard library functions follow these rules too (e.g. you can use sqrt(x) but not mod(x, y))


Your score is determined by the formula [code size in bytes] / [number of operators implemented]. So for example, a 300-byte program that includes the functions +, -, and * would count as 300/3 = 100. Lowest score wins.

  • 3
    \$\begingroup\$ What about n-ary operators? Ternary operators? Currying? I think this has a lot of holes with languages that aren't procedural by nature. \$\endgroup\$ – FryAmTheEggman Mar 4 '16 at 17:43
  • \$\begingroup\$ for (0 .. 10) { stuff with $_ } is a binary operator, since it takes two arguments, 0 and 10. However, $i=0; while(++$i <= 10) { stuff with $i } is unary, since the binariness of it is an initial zeroing and a comparison with a constant. Did I understand that right? \$\endgroup\$ – msh210 Apr 27 '16 at 19:41

[title TBD]


An integer n between 1 and [currently 1652; TBD at the time of posting the comic], inclusive.


The XKCD title for comic number n. (This is the text written above the comic panel, i.e. the text content of the <div id="ctitle"> element, not the title-attribute value of the img element. Here's a handy list, though the actual comic on xkcd.com will govern if it differs from what's on that list. However, the title is displayed in caps and smallcaps due to CSS, and you must output it in caps and lowercase (respectively).)

(If by the time the question is posted there's a comics with an ampersand-escaped character reference — I don't think there are any now — then I'll also add a caveat about how the output of your program should include the actual character, not the ampersand-escaped reference.)


I/O can be by any standard means and in any standard format. And no using the Internet to look up the title.

  • \$\begingroup\$ This might get very few (if any) answer since that is such a massive task. Maybe more appropriate as a test-battery where submissions are scored by how many they get right divided by code size? \$\endgroup\$ – James Mar 8 '16 at 6:37
  • \$\begingroup\$ @MyHamDJ, oh, good idea, thanks. I'll probably edit it to that (not just now). \$\endgroup\$ – msh210 Mar 8 '16 at 6:38
  • 1
    \$\begingroup\$ @MyHamDJ I disagree that the current question is too hard. It's just an exercise in compression. \$\endgroup\$ – lirtosiast Mar 12 '16 at 2:08

The overall task will involve extracting market data for various trading instruments (represented by unique symbols), applying some transformations and statistical functions, and displaying the results in a report.

Obtain the following QUOTES series from Bashoop: TYQUOTES, FVQUOTES

The quotes data is stored as a BBO. BBO stands for best bid/offer, which represents the best bid and ask (ask and offer are interchangable terms) in the market for a given instrument at any given time. At each timestamp it contains, in the following order: bid price, bid quantity, ask price, ask quantity

  1. Calculate a VwMpt at each timestamp t for each instrument's QUOTES series VwMpt_t = bid_price_t + (ask_price_t-bid_price_t) * (bid_qty_t / (bid_qty_t+ask_qty_t))
  2. Calculate a rolling correlation rho of VwMpt returns (first difference, i.e. derivative) sampled at 1 minute intervals with a lookback of 100 samples
  3. On a webpage, display a plot of VwMpt substracted from the first sample (so the time series starts at 0) of both series on the same line chart, and below it plot the rho lined up along the same time axis. You may use a library like Flot or something similar.

To download a series with a series_id of FVQUOTES from a Bashoop instance located at you can: curl -s -d "series_id=FVQUOTES" -d "start_ts=0" -d "end_ts=1451606400000000" -d "compress=0" -X GET where start_ts and end_ts are micros send epoch. In this case we want the full history.

  • \$\begingroup\$ This still suffers from all the same issues as your post on the main site. You haven't specified a winning criterion here, but just saying fastest code wins isn't one, unless you specify how your are going to measure which code is the fastest. \$\endgroup\$ – Dennis Mar 9 '16 at 15:34
  • \$\begingroup\$ What would you suggest would be a direct method to measure performance in this case? @Dennis \$\endgroup\$ – petergt Mar 9 '16 at 20:58

Parse default arguments

Many languages have the concept of default/variable arguments. It basically means you can have a function that when given too few arguments, will fill in the missing arguments with specified values. For example, you can do the following in Python:


def f(x="default string"):
  print x

This means that calling f("foo") will print "foo", but calling f() will print "default string".

Python also has a mechanism for handling too many arguments ("rest"):

def f(*stuff):
  for thing in stuff:
    print thing

You can of course also mix these:

def f(x, y="default string", *z):

Unfortunately, python (pre-3.5), being python, yells at you when you put a default argument before a non-default argument. That's silly. You guys are smart; you should be able to make that work.


Write a program, function, or whatever that when given a string representing the arguments and values passed to them, will print each argument's resulting value.

  • If there are too few arguments, the mandatory arguments should be applied first, then the rest of the values into the default arguments (left-to-right).
  • If there are too many, apply all values to arguments, and the remaining into the "rest" argument.

I'm even confusing myself, just look at the test cases


  • a string, array, or other reasonable format representing the parameter declaration
  • a string, array, or other reasonable format representing the values passed to the arguments


  • the resulting values of all the arguments, in a reasonable format.
    note: "reasonable format" will be defined later

Test Cases

Test cases will be in the following format:

{arg string}
{value string}
=> {output}

So, here they are

x, y, z
10, 2, 4
=> x:10, y:2, z:4

x=2, y
=> x:2, y:5

a, b="a", c, *d
3, 4
=> a:3, b:"a", c:4, d:[]

foo, bar=2, *baz
9, 3, "kqly", 5
=> foo:9, bar:3, baz:["kqly",5]

*x, y
"ha", 2, 3
=> x:["ha",2], y:3
  • \$\begingroup\$ "Unfortunately, python, being python, yells at you when you put a default argument before a non-default argument. That's silly. You guys are smart; you should be able to make that work." Actually, this is false starting Python 3.5, at least with the f(x,y="abc",*z) example. \$\endgroup\$ – Sp3000 Mar 13 '16 at 14:25
  • \$\begingroup\$ @Sp3000 that's good to know! See my edit. Hopefully this still requires some additional processing or I may need to modify the question so Python(/ruby?) users can't just use eval \$\endgroup\$ – Cyoce Mar 14 '16 at 7:04

Is this number random?: Round 2

The same as Is this number random?, but with 256 or 512 numbers in each category instead of 64; thereby making a modulo-chain infeasible to find. I hope this will encourage more interesting strategies.

Is this enough of a difference from the existing question to merit a new one? Are there any other flaws with the distribution? Could I change this to require splitting into 4 or so buckets instead of 2?

  • 1
    \$\begingroup\$ I think you might need to do something like 4 buckets to stop it being a dupe. I don't think increased difficulty on its own is enough to make something not a dupe (I feel like I could then just post one with 1024 numbers each etc) (but idk I wouldn't trust me, wait for more feedback). \$\endgroup\$ – FryAmTheEggman Mar 15 '16 at 20:39
  • 2
    \$\begingroup\$ Also: Is this number random? 2: Electric Boogaloo ;) \$\endgroup\$ – FryAmTheEggman Mar 15 '16 at 20:40

Reverse Engineering


You must write a program or function in as few bytes that takes in an integer or a set of integers, performs a defined task on them (for example, finds the prime factorisation), and gives an integer or a set of integers as output. The number of integers in input and output will be pre-defined, so will be the task. You should provide appropriate limits for the variable sizes to be supported (1 bit, 1 byte, 2 byte etc.) and any additional conditions (0 not supported, N<100, M>N, etc.), and your program should work (atleast in theory, does not need to be time or memory efficient) for all possible inputs allowed by you.

You must also submit a reference code (ungolfed) in any language that performs the exact same process in reverse. Meaning, when given the output of the first program, it should be able to deduce the input given. This should be possible (atleast in theory) for all inputs accepted by you in the first program.

For example, suppose the first program takes in two 1-byte prime numbers m and n, and outputs all prime numbers between the two of them. Since the number of integers in input must be pre-defined (and not dependent on input), we state an additional rule that there will be a total of 60 integers in output, and if there aren't that many prime numbers, then zeros will be outputed.

Input to program 1: 23 41

Output from program 1: 29 31 37 39 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Now the second program will perform the same process in reverse.

Input to program 2: 29 31 37 39 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Output from program 2: 23 41


Robbers will attempt to golf the second program as much as possible. Your score is given by the ratio of bytes in the best golfed code by a robber and the bytes in your code. So if your code is 23 bytes, and a robber writes the code for the reverse process (in any language) in 102 bytes, then your score is 102/23. Your answer is deemed ineligible for scoring if it has negative score. Highest score wins.


You must pick the second program submitted by a cop and attempt to golf it (in any language) as much as possible. You may submit a program or a function. You may use a different algorithm if you choose to, but the results must be exactly the same.



  1. Is it ok to combine code-golf with cops-and-robbers like I have done?

  2. What should the scoring criterion be for the robbers?

  3. Is my challenge too generic (because it accepts way too many kinds of tasks)? If yes, what can I do about it?

  4. Any further questions or suggestions are welcome. If you are sure of a suggestion being mandatory, you may make the edit yourself.

  5. Are the tags ok?

  • \$\begingroup\$ I think your concern in 3 is very significant, I think this is way too broad. Some CNR challenges have had success by limiting the size of the output. I also think there is a significant problem with "standard language". Does APL count? I think it would be hard to argue against it being well known, and then you get stuff like Brainfuck... I think it's better to allow any language with a freely available interpreter. The upvote requirement is also rather bizarre; I don't think it should be there. \$\endgroup\$ – FryAmTheEggman Mar 15 '16 at 13:11
  • \$\begingroup\$ @FryAmTheEggman 1. What limit should I provide? 2. Agreed, I'll make the change. 3. Up-vote requirement is only so that, in case there are low quality answers (basically extremely easy challenges) that no one pays attention to, doesn't mean they deserve to win. \$\endgroup\$ – ghosts_in_the_code Mar 15 '16 at 18:24
  • \$\begingroup\$ I agree with lirtosiast. I'm not sure about what limit to use but perhaps take a bit of freedom away and just require the function work for bytes and always output 10 numbers, or something? This is just meant to be an idea that I think goes in the right direction, I don't think I'm at all qualified to know how to make a CNR :P In addition the tag combination has been done before, but I would add some of number/math/arithmatic depending on where you go with it. \$\endgroup\$ – FryAmTheEggman Mar 15 '16 at 20:36
  • \$\begingroup\$ @lirtosiast Done. \$\endgroup\$ – ghosts_in_the_code Mar 16 '16 at 7:51
  • \$\begingroup\$ @Fry Not a bad idea, but I think I'll wait till someone else (hopefully a mod) gives their input. \$\endgroup\$ – ghosts_in_the_code Mar 16 '16 at 7:52
59 60
62 63

You must log in to answer this question.

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