# 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]

# 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:

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.

### 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.

### Output

The area approximation that Simpson's Rule gives.

### Test cases

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


• Simpson's rule requires an even number of intervals, so there has to be an odd number of endpoints. – 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.

• I take it you're actually going to explain block sort in the spec before posting this? – Martin Ender Feb 14 '16 at 18:32
• @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. – 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.

• This could be a copyright problem. – Martin Ender Feb 15 '16 at 16:11
• 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. – A Simmons Feb 15 '16 at 16:18
• 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.) – Martin Ender Feb 15 '16 at 16:34
• 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. – A Simmons Feb 15 '16 at 16:39
• IIRC one or two of these were posted in December and deleted for copyright reasons. – Peter Taylor Feb 15 '16 at 16:58
• The creator has now given the go-ahead for these problems to be replicated twitter.com/ericwastl/status/699455417768923137 – A Simmons Feb 16 '16 at 11:10
• Might be worth including that in the challenge to avoid repeating the same discussion when it goes to main. – Martin Ender Feb 17 '16 at 8:22

# Knights and Knaves posted

Undeleted so that comments are visible

• – PhiNotPi Feb 3 '16 at 2:44
• 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. – Peter Taylor Feb 3 '16 at 14:34
• @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. – Liam Feb 3 '16 at 17:49
• 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. – Peter Taylor Feb 3 '16 at 21:11
• @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. – Liam Feb 3 '16 at 21:15
• 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). – Peter Taylor Feb 3 '16 at 21:28
• @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. – Liam Feb 3 '16 at 21:33
• 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. – Peter Taylor Feb 3 '16 at 21:36
• @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. – Liam Feb 3 '16 at 21:39
• It is how ugoren solved the previous one; Howard's solution is harder to understand, so I'm not sure exactly how it works. – Peter Taylor Feb 8 '16 at 22:43
• @PeterTaylor Hmm, sorry I must have missed that. That is true. There is still the matter of conditional logic however. – 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:

6

Print the output of

1
2
3


Because:

1=1
2=2
3=3
1+3=4
2+3=5
1+2+3=6


## 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

bj1pbnB1dCgpCno9MQp3aGlsZSAyKnotMTxuOnByaW50IHo7eio9MgpwcmludCBuLXorMQ==

• I think this is too much of a math problem and not enough of a code-golf problem. – lirtosiast Feb 15 '16 at 20:58
• 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. – Fran Borcic Feb 15 '16 at 21:02

# Plotting Dynamical Systems in ASCII

Input:

• 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.

Output:

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)

      y
^
|
.............................
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.

### Input

n, the number of seconds on the hourglass.

### Behavior

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.]

• I don't understand this spec. Are you displaying an hourglass? Does the program output anything? – xnor Feb 16 '16 at 0:25
• "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. – Martin Ender Feb 16 '16 at 8:25
• You need to state exactly how the hourglass should be displayed – ASCII-only Feb 16 '16 at 9:28
• @somebody As far as I understand the challenge the program shouldn't display anything. It should just act like an hourglass. – Martin Ender Feb 16 '16 at 14:00
• @xnor cc the above – Martin Ender Feb 16 '16 at 14:00
• 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. – Martin Ender Feb 16 '16 at 14:02
• @Martin I agree. – lirtosiast Feb 16 '16 at 15:58
• @lirtosiast shouldn't it replace time with n-timewhen flipped instead? – ASCII-only Feb 17 '16 at 6:26
• @somebody Oh, I guess that's the same behavior. – lirtosiast Feb 17 '16 at 6:31
• Since taking real-time input is limiting for some languages, what if you took in a list of times at which the presses happen? – 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.

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

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

• 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:

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.
• 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.

## Scoring

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.
• 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).

## Meta

• 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? – Martin Ender Feb 17 '16 at 8:14
• Also please don't make it a popcon. :/ – Martin Ender Feb 17 '16 at 15:01
• @MartinBüttner: Edited. – El'endia Starman Feb 17 '16 at 20:19
• I would say code-challenge for this. GOL is programming, by virtue of GOL being TC. – user45941 Feb 17 '16 at 20:47
• 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. – 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

 566
3XXX2
211


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

46
31 giving the one element output list 14


## Examples

This is code golf so the shortest entry wins.

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

• 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. ;) – Martin Ender Feb 27 '16 at 16:32
• @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. – 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.

## Examples

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.

## Rules:

• 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
• Do you expect to get runtimes large enough to be measurable? – Peter Taylor Mar 1 '16 at 10:32
• @PeterTaylor Yes - I expect to convert lists of large (arbitrarily precise) numbers. – Addison Crump Mar 1 '16 at 13:17
• 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. – Peter Taylor Mar 1 '16 at 15:43

# Elementary Cellular Automata, My Dear Watson code-golf

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.)

### Rules:

• 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.

### Example

Generation 0 of every automaton:

010


### Notes:

• I don't have a reference implementation yet, nor have I created any examples.
• What is this string representation? Will it be padded with zeros? – LegionMammal978 Sep 26 '15 at 17:24
• 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? – LegionMammal978 Sep 26 '15 at 19:53
• So wait... You aren't given the full generation? Also, do the generations start at 1 or 0? – LegionMammal978 Sep 26 '15 at 20:40
• Looking at your Mathworld link, it seems that you would need 2 background bits. – LegionMammal978 Sep 26 '15 at 21:21
• 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? – Peter Taylor Mar 1 '16 at 21:07
• @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. – mbomb007 Mar 1 '16 at 21:26
• 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. – Peter Taylor Mar 2 '16 at 14:34

# Binary Arithmetic Using Unary Operators code-golfrestricted-source

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.

## Specifics:

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.

• 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))

## Scoring:

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.

• What about n-ary operators? Ternary operators? Currying? I think this has a lot of holes with languages that aren't procedural by nature. – FryAmTheEggman Mar 4 '16 at 17:43
• 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? – msh210 Apr 27 '16 at 19:41

# [title TBD]

## Input

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

## Output

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.)

## Obviously…

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

• 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? – James Mar 8 '16 at 6:37
• @MyHamDJ, oh, good idea, thanks. I'll probably edit it to that (not just now). – msh210 Mar 8 '16 at 6:38
• @MyHamDJ I disagree that the current question is too hard. It's just an exercise in compression. – 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 149.202.47.189:8080 you can: curl -s -d "series_id=FVQUOTES" -d "start_ts=0" -d "end_ts=1451606400000000" -d "compress=0" http://149.202.47.189:8080/series -X GET where start_ts and end_ts are micros send epoch. In this case we want the full history.

• 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. – Dennis Mar 9 '16 at 15:34
• What would you suggest would be a direct method to measure performance in this case? @Dennis – 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:

WARNING: THE BELOW EXAMPLE CODE IS NOT GOLFED. PROCEED AT YOUR OWN PERIL

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.

## Challenge

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

### Input

• 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

### Output

• 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
5
=> 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

• "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. – Sp3000 Mar 13 '16 at 14:25
• @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 – 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?

• 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). – FryAmTheEggman Mar 15 '16 at 20:39
• Also: Is this number random? 2: Electric Boogaloo ;) – FryAmTheEggman Mar 15 '16 at 20:40

# Cops

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

## Scoring

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.

# Robbers

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.

## Scoring

????

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?

• 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. – FryAmTheEggman Mar 15 '16 at 13:11
• @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. – ghosts_in_the_code Mar 15 '16 at 18:24
• 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. – FryAmTheEggman Mar 15 '16 at 20:36
• @lirtosiast Done. – ghosts_in_the_code Mar 16 '16 at 7:51
• @Fry Not a bad idea, but I think I'll wait till someone else (hopefully a mod) gives their input. – ghosts_in_the_code Mar 16 '16 at 7:52

Are bug hunts like this allowed?

# Bug Hunt - Make a change in a Git repo that Git cannot detect

Challenge: In the working directory of a Git repo, make a change that Git cannot detect.

• Changes can be on any file in the working directory or subdirectories that is tracked by Git.
• You may use any tool to make the change, or script your own program to do so.
• For tools, state the tool used and the steps to reproduce.
• For script or program, produce the code (please use GitHub Gist if it's too long). State the language and compiler version, if any.
• You can also do the change manually. In this case, outline the steps.
• State the version and platform of the Git binary used.
• Show a comparison between an actual clean working directory and the modified one to show the change Git can't detect.
• Show that git status says "nothing to commit, working directory clean".

Winning Criterion:

• The extend of the undetected change - the bigger the change, the better.
• Reasonably latest Git version.
• Easy to reproduce.
• [Optional] Short code or simple steps. It's OK if it's not, as long as you do something exceptional.
• Most upvotes (for tiebreaker reasons).
• [Optional] You located an actual unfixed bug in the Git source code, and not just a quirk in something else.

Restrictions:

• Obviously, using .gitignore is not allowed. It's a bug hunt. Changes that Git is designed to ignore are not allowed. We should reasonably expect Git to see and report the change, but find that Git doesn't.
• Use latest Git version you can get. Some old version with some bug that's already fixed doesn't count.

Please let me know if this is OK, so I can go ahead to post it on the main site.

I could only find . A suggested tag would have been the best.

• Currently bug hunts aren't allowed. Because no one proposed them, you can propose bug hunts by asking a question on meta. – user48538 Mar 20 '16 at 12:28
• I have a strong feeling that this won't be allowed. We don't allow code that exploits bugs or harms computers. – Nathan Merrill Mar 20 '16 at 12:31
• @NathanMerrill source? – ADTC Mar 21 '16 at 0:17
• meta.codegolf.stackexchange.com/q/4829/20198 – Nathan Merrill Mar 21 '16 at 2:21
• Is this essentially asking for an AES collision? – Peter Taylor Mar 21 '16 at 11:14
• @PeterTaylor now that wouldn't be a bug, would it? But yes, I guess that's also a valid scenario. Can you create one? – ADTC Mar 23 '16 at 6:06
• This sandbox post has had little activity in a while and little positive reception from the community. Please improve / edit it or delete it to help us clean up the sandbox. – programmer5000 Jun 9 '17 at 14:11

## Calculate the last N digits of Graham's Number

Write a function or program that, given an integer x, outputs the rightmost x digits of Graham's Number.

Rules:

• You may not hardcode the answer in
• You may not fetch the answer from an external file or library

Scoring:

• Will be tested over 100 iterations on my machine with an average time given for different x values
• To Be Decided... (Input would be appreciated)
• Graham's number is just 3^[very large number], which always has the same last few digits; Wikipedia says they can be computed efficiently. – lirtosiast Mar 26 '16 at 2:59
• This might be more interesting as a code-golf challenge, because it would likely be too fast to accurately time in fastest code – Liam Apr 8 '16 at 0:01

# Paint the Mona Lisa in 1 KiB of code

## ** Oops, it seems that something like this has already been posted (and I didn't know about it before), but please read the last section below

This is my attempt to salvage this challange by Nathaniel, which was deleted after getting no less than 19 upvotes.

Here is a picture of da Vinci's Mona Lisa:

Your task is to reproduce the Mona Lisa in 1024 bytes or less. You will write a program or function that takes no input and loads no files, and outputs an image file.

The goal of this challenge is to produce an image that is as close as possible to the Mona Lisa above. The image must have the same resolution, and the similarity/difference will be measured by the root-mean-square deviation (at the color component level) between the two images. That will be the only criterion for the score, but people are still free to reward interesting answers by upvoting them (as always).

Your code (program or function) must obey the following restrictions:

• The code must be no more than 1024 bytes in total (counted in UTF-8 if you use funky characters)
• It must output the image in a standard uncompressed format such as BMP or PPM; the image can be written to the standard output or directly to a file
• The image must have the same resolution as the original - 215 by 320 pixels
• The code must be completely self-contained, taking no input and loading no files (other than importing libraries, which is allowed)
• You may not use built-in or library code that implements a decompression algorithm (unzip, unlzma, jpeg decompression etc). It is fine to use such algorithms if you implement them yourself within the 1024 byte limit.
• If your language or library includes a function that outputs the Mona Lisa, you are not allowed to use that either.
• It should run deterministically, producing the same output every time.
• Your code must be runnable in Linux using freely available software

It is possible that some submissions will themselves be generated by code. If this is the case, please include in your answer the code that was used to produce your submission, and explain how it works. The above restrictions do not apply to code used to create the code, they only apply to the 1024-byte code that produces the output image.

## TODO:

• provide code to calculate the score
• use a better-quality image?

## Duplicate?

Well, some may argue that this is a duplicate of the Starry Night challenge, but I think it differs in at least 3 ways:

• uncompressed output
• no prewritten decompressor allowed
• UTF-8 byte count

Also, the image is not the same so it may not benefit from all the same techniques (I'm also open to using a different image altogether, such as the one from this other deleted challenge by Nathaniel).

If you have any other ideas how to improve the challenge, let me know.

• 1) It's not clear what counts as a builtin decompression algorithm. Is RLE builtin compression? Golfing languages have it built in. 2) Our standard rules cover encoding; no need to require UTF-8. 3) A list of all the valid uncompressed formats seems appropriate. – lirtosiast Mar 26 '16 at 2:54

# Factorize Gaussian Integer

Given a nonzero gaussian integer your program/function should return the factorization of that integer g into prime factors pi and an unit u:

g = u * p1^e1 * ... * pk^ek


As the factorization is only unique up to units, we make following restrictions

• All primes should p should be in the first quadrant, that means that Re(p) > 0 and Im(p) ≥ 0.

• The unit should be represented as power of i. It should have the lowest nonnegative exponent.

• The primefactors should be sorted by the real part increasingly. If two real parts are the same, they should be sorted by imaginary part (also increasing.)

### Examples

11-27i = i^2*(1+i)*(2+i)^2*(4+i)
2     = i^3*(1+i)^2


To be added: Examples, input output spec

https://en.wikipedia.org/wiki/Table_of_Gaussian_integer_factorizations

is_gaussian_prime(z)?

https://stackoverflow.com/a/2271645/2913106

• What about builtins? – lirtosiast Mar 26 '16 at 2:57
• Built-ins are ok. In my experience restricting built ins is quite subjective and frequently results in trouble=) – flawr Mar 26 '16 at 10:54

# Create a race condition

Your objective is to create program where concurrent threads race to produce a result. The program is simple. Print the sum of every element in the cartesian product of two sets.

An example of standard input would be

2 5 8 10 | 9 2 3 7 512 | 3 1 2 | 9 8 6 3


The program would then need to spin up two separate threads to calculate each result, and the first thread (and only the first thread) to complete should print "I WIN!" and the answer without using mutexes or other synchronization methods.

## Rules

• You cannot use mutexes or synchronisation
• The operation must be run concurrently
• Standard input will contain any multiple of two sets, and the program should use (no of sets / 2) threads, as well as the main thread that spins everything.
• The order of execution on the slave threads is not important
• Some failure cases where more than one thread prints "I WIN!" is acceptable, but should be a rare case Sandbox comment: Not sure about verifying this one? or should not bother at all?

I saw the TCP Server question and I liked the idea of a challenge that is specifically difficult for golfing languages, and I was thinking about a few ideas for challenges that might work based specifically on parallel programming failures. I'm not sure if this one really fits the bill, hoping for suggestions to improve the challenege itself before refining the criteria.

# A Tiny Raytracer

Your task is to make a tiny 2D raytracer to render beautiful ascii images.

## Input

Your input will be an arbitrary 2D array delimited by newlines with the following structure

########
#9     #
#      #
#  ##  #
#  ##  #
#      #
#    ###
########


The symbols are: 0-9 = Light source = Emptiness # = Wall

Your expected output should look like this:

########
#987654#
#876543#
#76##32#
#65##00#
#543000#
#43000##
########


# How Light Propagates

Light will travel in a straight line from lightsources through empty space and will be completely blocked by walls. Light falls off according to this function:

light_intensity = clamp(floor(9 - source_intensity * ||dist_to_lightsource||), 0, 9)


Where || || is the euclidean norm between the cell containing the light source and the cell in question, with 1 cell = 1 unit. All light intensity values are clamped to be between 0-9.

Light falls on an empty cell c whenever a straight line can be drawn from any part of c to the cell containing the light source without passing through a wall. For example, here I have all of the cells affected by a light source marked as *:

########       ########
####   #       ####***#
#9   #     =>  #****#
###    #       ###****#
### ####       ### ####


Whenever there are multiple light sources, their contributions to the final light intensity are summed (and clamped to be between 0-9).

For example:

################
#9            6#
################


Should yield:

################
#98765432223456#
################


# Rules

Standard code golfing rules. Input can have arbitrary size.

## Fun Optional Bonuses

• Output the result as a graphical image.
• Support light values of between 0-255 (in this case columns of the input and output will be space delimited)
• Support colors (in this case light will be denoted by a standard 24-bit hex code 0xFFFFFF, and space delimited).

These don't give you any bonuses in the competition, but would be cool.

# Self-decrypting code

The Caesar cipher is perhaps the earliest and most well known form of encryption. Here's a quick overview:

Pick a message, and a numerical encryption key. For this example, I'll pick "HELLO, WORLD" and 3, respectively.

First, convert each letter into its ASCII number:

H -> 72
E -> 69
L -> 76
L -> 76
O -> 79
, -> 44
[space] -> 32
W -> 87
O -> 79
R -> 82
L -> 76
D -> 68


Then, add the key (3) to each and convert back into a letter

75 -> K
72 -> H
79 -> O
79 -> O
82 -> R
47 -> /
35 -> #
90 -> Z
82 -> R
85 -> U
79 -> O
71 -> G


So the encrypted message is "KHOOR/#ZRUOG"

Write a full program that is a Caesar cipher-encrypted valid English message. The program must take no input and it will output the unencrypted version of itself.

Some rules:

• The program must be at least length 2.
• The key may not be 0, 32, or 256
• All of the code must be executed (no comments to arbitrarily extend code length).
• The Linux word list will be used to judge if a message is English. Words must be separated by ASCII character 32. Words can mix uppercase and lowercase.
• Your program does not need to be written in printable ASCII.
• File I/O is allowed, but only to read the source code file.
• No other standard loopholes.

## Scoring

The submission with the longest message wins. Anything over 200 characters will be scored as exactly 200 characters. Ties are broken by upvotes.

• I think this has a bunch of problems. The scoring doesn't make much sense why does it switch between code-challenge and pop-con? Additionally, I'm almost certain that 200 won't be that hard to reach, considering it is "valid" English to say "I am very very very ... very very sad". This also doesn't explicitly give much explanation for valid English. Do you just have to have words and spaces? Or does it need to make sense? Also, "all of the code must be executed" rules basically never work: it's too easy to get around them. – FryAmTheEggman Apr 1 '16 at 14:13
• @FryAmTheEggman How should I deal with arbitrary-length submissions (they found a way to make it as long as possible)? As for valid sentences, maybe just words separated by spaces (but no word can be repeated). How should I prevent trivial arbitrary-length programs (because comments can be used for that). – Daniel M. Apr 1 '16 at 14:20
• The problem is that there are too many things that are basically the same as comments in too many different languages. What's to stop me from just inserting a giant numeric/string literal in my code that don't get printed? What about repeating ; in a C program? What about languages that don't even really read their source code like lenguage? I feel like if your challenge breaks because of comment like things, it's sort of doomed to be broken. – FryAmTheEggman Apr 1 '16 at 14:25
• What constitutes a "valid English message"? What modulus operations are permitted? – Peter Taylor Apr 5 '16 at 13:35
• @PeterTaylor Any modulus operations that don't bring the message back to itself and aren't the exact difference between lowercase and uppercase. – Daniel M. Apr 5 '16 at 15:42

## Calculate the number of consecutive 0's at the end of n!

Simply put, write a program or function that takes n and returns the number of consecutive 0's at the end of n!

Examples

Input: 12
Output: 2


Input: 12345
Output: 3082


Input: 100000
Output: 24999

• I think this might be a dupe. – Rɪᴋᴇʀ Apr 2 '16 at 21:45
• @EasterlyIrk Do you have a link to the duplicate problem? – MrPublic Apr 4 '16 at 11:38
• This is extremely similar. – FryAmTheEggman Apr 4 '16 at 17:20
• This proposal would be similar to finding the position of the last nonzero digit, but it's not similar to the linked challenge, which finds the value of the last nonzero digit – Luis Mendo Apr 6 '16 at 11:14

# How many pixels are in each ASCII char?

Write a program or function taking a single printable ASCII character as input that outputs how many pixels it takes to display that character to the screen.

Input can be taken by any reasonable method, including reading from a file, STDIN, or function argument. Input from a variable hardcoded into the program is not reasonable.

Output may by given by any reasonable method, including writing to a file and STDOUT. Extraneous output is permitted as long as the result remains unambiguous.

"Printable ASCII character" is defined as a character within the codepoints 32-126, inclusive.

A pixel counts as part of a character if the pixel is non-white after the character is written to a white screen.

The required font is Times New Roman, 20pt.

Do not hardcode the result.

### Reference Solution: (JavaScript)

//create a canvas to display the character
var canvas = document.createElement("canvas")
canvas.width = 100
canvas.height = 100
document.body.appendChild(canvas)

var context = canvas.getContext("2d")

//make the canvas white
context.fillStyle = "white"
context.fillRect(0, 0, 100, 100)

//make the text black and set the font
context.fillStyle = "black"
context.font = "20pt Times New Roman"

var char = prompt("Enter your ASCII char")

//draw the char
context.fillText(char,50,50)

//get the canvas pixel data
var pixelData = context.getImageData(0, 0, 100, 100).data
var pixelCount = 0
for(var i = 0; i < pixelData.length; i+=4) {

//if the pixel isn't white, increment the counter
if(pixelData[i] != 255 || pixelData[i+1] != 255 || pixelData[i+2] != 255) pixelCount++
}
alert(pixelCount)

• Is there any specific font that should be used? – Downgoat Apr 3 '16 at 5:07
• you should probably set a specified font (Times New Roman, Arial), to make answers more comparable. If not, you should probably say the font should have been made before this challenge was posted – Downgoat Apr 3 '16 at 5:13
• @Downgoat actually on second thought, languages that can't output Times New Roman probably don't have the features to compete in this challenge anyway. I'll make 20pt Times New Roman the required font. – jrich Apr 3 '16 at 5:20
• I wonder if any other algorithms exist that are more efficient. – Leaky Nun Apr 3 '16 at 5:48

## Self-identification before golfing

Since golfed code is harder to read, answers often contain an less golfed version. There are a number of potential golfing transformations depending on the language, so you may be able to score more highly using a more traditional language. Some examples of golfing transformations:

• Removal of spaces, tabs and/or newlines
• Removal of disambiguating parentheses
• Removal of braces around single controlled statements
• Conversion from statements to comma operator
• Removal of explicit return statements
• Renaming identifiers

Your challenge is to write a program or function that can identify an ungolfed version of itself. Scoring is based on the number of golfing transformations that can be recognised. The submission must be capable of identifying all "original" code that is itself capable of self-identification (at least one such code must exist). Each supported transformation scores 1 point, but there are also bonus points available:

• 1 bonus point if the transformation can be repeated multiple times
• 1 bonus point of the program rejects at least one invalid transformation of itself (e.g. white space added inside a keyword)
• 1 bonus point if the program only accepts valid transformations of itself
• 1 bonus point if the transformation shortened the code (so if you only supported renaming a 1-letter variable to another letter, you would not qualify)
• 1 bonus bonus point if in addition the transformed program recognises the original program as a transformation of itself

Example: A submission accepts the name of another program as a command-line parameter. It opens itself using its own name hard-coded into itself. It recognises the following transformations:

• A change to the hard-coded file name (3 points, as there is only one file)
• A change to the amount of space between words (5 points, as there are no invalid transformations to reject)
• A change to the names of its variables (4 points, as it doesn't check whether the variables are renamed consistently or to keywords)

Total score: 12 points.

In the event of a tie on score, shortest code wins.

Tags: code-golf, quine

• This is hopelessly subjective. – feersum Apr 5 '16 at 13:35

In this challenge you are supposed to output a grid 10x10 with numbers from 00 to 99 (each number once) following this rules:

• Number 00 must be on the bottom row
• Number 99 must be on the upper row
• In the output each number must be sepparated by spaces and must have two digits (that is including 0's when needed for the first 10 numbers)
• Output must be random
• It must be solved within reasonable time

I'm having an issue trying to define random and reasonable time here and would like some help with it. Thanks.

• Define random as 'Each of the possible permutations must have an equal probability of being the output'. For reasonable time I don't think you need a definition - especially since your challenge is only 100 numbers, so it should be perfectly doable unless your algorithm works in O(n!). – Sanchises Apr 7 '16 at 11:11
• @sanchises I find that asking for equal probability is too strong, since there's no way to prove that one of those algorythm has equal probability. – Masclins Apr 7 '16 at 16:34
• Of course, a formal proof is not always easy. However, an intuitive result should be enough for most applications, and if people have difficulty with that, you can always use one of the algorithms described at the Wikpedia page, e.g. Knuth shuffling. I was wondering though, is there a motivation behind the challenge, or is just something you cooked up? – Sanchises Apr 7 '16 at 17:57

# Manual MD5

Given a string, calculate its MD5 sum without using any built-in MD5 library functions. An overview of the algorithm is here.

(I'm going to actually summarize the algorithm before I post it. Until then, it's still unfinished.)

Input is an ASCII string or byte stream with any reasonable length (I won't run an entire novel through your algorithm, for example).

Output the hex value of the resultant hash as a string.

Code golf, so shortest code wins. Standard loopholes are banned.

• You add the tags by adding [tag:code-golf] (and the others) to the body of your post. – user45941 Apr 2 '16 at 5:41
• To answer your question: yes, include a description of the algorithm in the challenge body. Requiring external resources for a challenge is discouraged. – user45941 Apr 6 '16 at 4:02
• 1. "Given a string, calculate its MD5 sum" is underspecified. In many languages nowadays, a string is a sequence of Unicode characters; MD5 is defined over sequences of octets, so to talk about the MD5 sum of a string you first have to define its encoding in octets. 2. Output format? – Peter Taylor Apr 8 '16 at 7:28
• I clarified as ASCII string now in the input section. Should I mention that at the top, as well? – Value Ink Apr 8 '16 at 7:38
• I think so. It's a one word addition and it avoids people wandering mentally off track. – Peter Taylor Apr 10 '16 at 21:46