# 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 add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

# Robots on ice

## Part 1 - The basic

You are helping a robot R on an iced island. R can go up/down/left/right. But since the island is made of ice, it cannot move only 1 square at a time, but instead moves in straight line. Your task is to help R reach G.

### Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

• R The robot
• G The goal
• # An obstacle that stops the robot
•   Ice

The island is surrounded by a wall: the edges of the matrice always consist of #.

### Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

The output should be the map with the instructions on it, with each instruction at the right coordinates. Each of RG#  should be displayed if not overriden by an instruction (that will always be the case for R)

# Example

Input:

##########
# #      #
#        #
#  G #   #
#        #
#    R#  #
#        #
##########


Output: Since D,R,U,L,D is one possible solution, the output should be:

##########
# #D    L#
#        #
#  G #   #
#        #
#    D#  #
#    R  U#
##########


Another solution, U,R,U,L,D, should be output as:

##########
# #D    L#
#        #
#  G #   #
#    R  U#
#    U#  #
#        #
##########


Input:

####################
###R             ###
#  ######          #
#      #####       #
##                G#
###              ###
####################


Output:

####################
###R            D###
#RD######          #
#U L   #####       #
##R               G#
###U            L###
####################


You can assume that the puzzle always has at least 1 solution

## Part 2 - New options

The pitch is the same, but new characters can be displayed:

### Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

• R The robot
• G The goal
• # An obstacle that stops the robot
•   Ice
• W Some water. Robot doesn’t like water
• B a Box. Robot can push the box 1 square at a time, in front of him (not on the side), if the next square is  . It cannot be pushed into the water, through the goal… Robot cannot push 2 boxes at once. When pushing, the robot stays in place.
• 1 a numbered teleportation door. Always in pair. When entering a teleportation door, Robot will continue sliding in the same direction through the other door. Can be used more than 1 time.

The island will this time be surrounded by water.

### Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

This time the output won't be displayed on the map, but on stdout. The format doesn't matter:

UDRL


or

U
D
R
L


are accepted

### Example

Input:

WWWWWWWWWW
W W      W
W        W
W  G 1   W
W        W
W    1R  W
W        W
WWWWWWWWWW


Output:

L


Input:

WWWWWWWWWW
W W      W
W    #   W
W  G     W
W        W
W    BR  W
W        W
WWWWWWWWWW


Output:

LLUL


The first L moves the box (but not the Robot) 1 square:

WWWWWWWWWW
W W      W
W    #   W
W  G     W
W        W
W   B R  W
W        W
WWWWWWWWWW


Input:

WWWWWWWWWWWWW
W         # W
W G 2       W
W           W
W   B 1     W
W#2         W
W   # 1R   #W
W          #W
W    #     #W
WWWWWWWWWWWWW


Output:

L #entering teleportation 1
L #pushing the box to the left
L #going to the box
U #entering teleportation 2


The solution RULU is also valid

Input:

WWWWWWWWWWWWW
W #         W
W     #     W
W#   1      W
W           W
W           W
W    1 R    W
W           W
W    G      W
WWWWWWWWWWWWW


Output:

L #entering teleportation 1
U #going to the wall
R #going to the wall
D #entering teleportation 1


In this situations, Robot cannot moves to the left:

W  GBR   W

W  #BR   W

W  BBR   W

W  WBR   W

W    R   W


You can assume that the puzzle always has at least 1 solution

## Part 3 - With help

Same as part 2 but with others robots:

### Input

The input (file, stdin, input, whatever suits you) is an n×m matrice with the following characters:

• R The robot
• G The goal
• # An obstacle that stops the robot
•   Ice
• W Some water. Robot doesn’t like water
• B a Box. Robot can push the box 1 square at a time, in front of him (not on the side), if the next square is  . It cannot be pushed into the water, through the goal… Robot cannot push 2 boxes at once. When pushing, the robot stays in place.
• 1 a numbered teleportation door. Always in pair. When entering a teleportation door, Robot will continue sliding in the same direction through the other door. Can be used more than 1 time.
• abcde up to 5 robots that can move the same as Robot. They cannot go through other robots, including R, and can pass through the Goal. They can be sacrified by going into the water. They can be used more than 1 time.

The island is surrounded by water.

### Output

A list of instructions consisting of U/D/L/R, corresponding to up/down/left/right, prefixed by the name of the robot moving.

The list should be the shortest possible. The distance traveled by the robot doesn't count.

As usual, theformat doesn't matter:

a:UDR
R:LU


or

aU
aR
RL
RU


are accepted

### Example

Input:

WWWWWWWWWWWWWWWWWW
W        a     # W
W   G            W
W                W
W                W
W                W
W             R  W
W                W
W       #        W
W             #  W
W                W
WWWWWWWWWWWWWWWWWW


Output:

a:R
R:UL


The answer DLUL is valid but not the shortest

Input:

WWWWWWWWWWWWWWWWWW
W                W
W                W
W                W
W                W
W  G    a    R   W
W                W
W                W
W                W
W                W
W                W
WWWWWWWWWWWWWWWWWW


Output:

a:U
R:L


Input:

WWWWWWWWWWWWWWWWWW
W           #    W
W                W
W  #             W
W           G    W
W                W
W                W
W           b    W
W   R       a    W
W                W
W                W
WWWWWWWWWWWWWWWWWW


Output:

b:U
a:UL
R:UR


Input:

WWWWWWWWWWWWWWWWWW
W                W
W           #    W
W          B     W
W  #             W
W     G          W
W                W
W  #             W
W   e       R#   W
W                W
W           a    W
WWWWWWWWWWWWWWWWWW


Output:

e:R
R:U
a:UL
R:LLDLUR


Input:

WWWWWWWWWWWWWWWWWW
W                W
W         G #    W
W   b            W
W                W
W           a    W
W   c            W
W           #    W
W   R            W
W                W
W          #     W
WWWWWWWWWWWWWWWWWW


Output:

a:U
b:RD
a:D
C:RD
R:RU


Input:

WWWWWWWWWW
W    G   W
W aBbBR  W
WWWWWWWWWW


Output:

a:L
b:LL
R:LLU


In this situations, Robot and b cannot move to the left:

W  GaRb  W

W  #b#R  W

W aBbBR  W


You can assume that the puzzle always has at least 1 solution

## Sandbox Questions

Has it been done before?

What do you think? Is it understandable? Should I do 3 separated challenges (and in the sandbox)? More, less? Which part needs more examples? What part is unclear?

I would like to go with shortest-code win. Should I use kolmogorov instead?

• – feersum Sep 23 '15 at 13:35
• Related, but not duplicate: codegolf.stackexchange.com/questions/23238/… – Zgarb Sep 23 '15 at 13:41
• Well… that's too similar :( Too bad! – fredtantini Sep 23 '15 at 16:37
• The fourth example for part 2 should have output LLLU no? – quintopia Dec 30 '15 at 5:30
• @quintopia Yep, it's edited. Thanks! – fredtantini Dec 30 '15 at 11:14

Pi is the most popular transcedental number. As a result, pi has been thoroughly studied. This challenge is in spirit of 9-Hole challenge.

## 1. Digits of PI

Given n and k, output n'th digit after the decimal point in the base-k representation. For example, the 5th digit of PI base 10 is 9.

5 10
9
10 2
0
6 16
10


If the base is more than 10, output like in the last test case

## 2. Continued fraction of PI

Given n, output n'th number in continued fraction of Pi.

5
292
7
1


## 3. Closest to PI

Given a positive integer d, output the integer n such that n/d is closest to pi. For example, 17/5 is closer to pi than any other n/5.

 5
17
7
22
21
66


## 4. Closest to PI 2

Given a positive integer n, output the integer d such that n/d is closest to pi.

5
2
7
2
20
6


# Restriction.

1. You should not have any floating-number buildin, only integer, including PI constants.
2. Standard loophole is disallowed.
3. The program may be 4 program or a program that reads challenge number.

# Sandbox Question

Originally, I have 5 challenge, 4 more required. Now, one of them is dupe. 5 more required.

• This does look suspiciously like lot of questions rolled into one. +1 and you could split it up into loads of challenges. – wizzwizz4 Dec 30 '15 at 12:10
• Also, you could add more clarification on what a "9-Hole challenge" is. – LegionMammal978 Dec 30 '15 at 12:12
• @LegionMammal978 codegolf.stackexchange.com/q/16707/46245 – Xwtek Dec 30 '15 at 12:38
• The spirit is more than one challenge in one question. – Xwtek Dec 30 '15 at 12:48
• Are you looking for 4 more sub-challenges, or a catchy name for a 5 component question? – trichoplax Dec 30 '15 at 16:17
• Quintessential pi question? – trichoplax Dec 30 '15 at 16:18
• A. I believe that the "many small holes in one question" model is considered a failed experiment. B. I don't understand the spec for part 1 at all. Part 2 is inadequately specified. Part 3 is a dupe. Parts 4 and 5 look almost completely trivial (or completely trivial for languages with a pi built-in). – Peter Taylor Dec 30 '15 at 18:39
• Added that pi build-in is not allowed – Xwtek Dec 31 '15 at 4:08
• What about getting pi via inverse trig? Complex logs? Evaluating integrals? Banning the built in value still lets languages express it via math, and it's tricky to draw the line. – xnor Dec 31 '15 at 5:16
• Also, why does every question need to use pi? If you want a challenge about, say, rational approximations, you can use arbitrary inputs or square roots or anything all langs have access to roughly equally. – xnor Dec 31 '15 at 5:18
• @xnor 1. trigonometry, log, etc. is useless without floating point number. And any uses of floating point number isn't allowed (Even if it just uses addition only). However, I am afraid of integrals, too. 2. Just because. – Xwtek Dec 31 '15 at 5:52
• In the revised version, I think that if these were posted separately then part 1 would be closed as a dupe of part 3. Also, part 2 is still inadequately specified. You need to at minimum explain the indexing convention, and ideally specify what a continued fraction is (since some answers may use generalised continued fractions and confuse people who aren't familiar with them). – Peter Taylor Dec 31 '15 at 11:12
• @PeterTaylor I don't understand how part 1 is dupe of part 3. For part 2 I uses simple continued fraction and what is indexing convention? – Xwtek Dec 31 '15 at 11:17
• A. Part 3 says "Given d, find n such that (n-0.5)/d < pi < (n+0.5)/d". Part 1 is essentially (since there isn't a general Plouffe formula for all bases) "Given k and n, find b such that b / k^n < pi < (b+1) / k^n and then return b % k". The core problem is almost identical. B. It's not enough for you to know that you're using simple continued fractions: the question has to make it clear. The indexing convention is whether you count the initial 3 + ... as index 0 or 1. – Peter Taylor Dec 31 '15 at 11:34
• @PeterTaylor A. The insight clears my mind. Thanks. I don't think as far as that. B. 1. But I don't know how to explain that. Please add yourself. – Xwtek Dec 31 '15 at 11:43

How to print 2016 using only the number 2?

Print 2016 using only the digit 2 operators and native language built-in functions.

The objective is to

• Output the integer 2016 without using any digits except 2.
• no characters / strings literals are allowed, i.e. no tricks like ord('b')
• The code that uses the least number of 2s in the code wins.

For example, in python, the following code uses 8 twos.:

>>> int(str(2**2*2) + str(2**2)) * int(str(2) + str(2**2))
2016


Or like this code, uses 13 twos:

>>> 2 ** 2 ** 2 * 2 ** 2 ** 2 * 2 * 2 * 2 - 2 ** 2 ** 2 * 2
2016

• Can you use constants initialized to a certain value (like CJam's Z variable which defaults to 3)? – GamrCorps Dec 31 '15 at 19:42
• What's the tiebreaker if multiple answers have the same number of 2s? – Doorknob Dec 31 '15 at 19:46
• 1. Every language that has variables will have a score of at most 1, since you can just save the initial 2 in a variable. 2. There are many ways to produce numbers without using characters, strings or other numbers, like taking the length of a list, for example. That means a score of 0 is just as easy. – Dennis Dec 31 '15 at 19:47
• I would suggest making the scoring system a normal code-golf challenge and disallowing date functions. – GamrCorps Dec 31 '15 at 19:55
• I will make my original suggestion again: require that every function and operator take as input either a number consisting entirely of 2's in some base, or the output of some function or operator that obeys this rule. If you insist on your "least number of 2's metric" count 2's passed inside variables or in the outputs of functions as contributing to this count. – quintopia Dec 31 '15 at 21:15
• What about such version: In repl environment produce value 2016 using only number 2, operators and math functions. No any other functions allowed. Code golf or code challenge. – Qwertiy Dec 31 '15 at 21:17

# Growing Quine 2

1. For all k<5, length of Pk < length of Pk+1
2. For all k<5, Pk outputs Pk+1
3. For all k<=5, Pk is semi-pristine program. (Program that if any run on the source-code is deleted, will output different output)
4. P5 return P1 sufficient times that the output will be longer than P5

Shortest P1 wins

• By rule 4, do you mean if P1 is abc, then the output should be abcabcabc... for the minimum amount of repetitions that is longer than P5? can we output it more often that necessary? Also, I think rule 3 makes this incredibly hard. – Martin Ender Jan 1 '16 at 16:40
• First, Yes. The rule 3 is to prevent the padding of source code with nop. Maybe I will change into different output to make this easier. – Xwtek Jan 2 '16 at 0:50
• I mean rule 4 can repeat more often than necessary – Xwtek Jan 17 '16 at 1:22

# Zipping double quine.

You must provide 2 program, A and B. Both are a quine and have same length.

If A and B is zipped each other(Both when A is zipped first, or B is zipped first), the result is also an quine.

Standard Loopholes is not allowed and standard quine rules apply.

## Examples

If program A is ABCDEF and program B is GHIJKL then

slangi "ABCDEF"
ABCDEF
slangi "GHIJKL"
GHIJKL
slangi "AGBHCIDJEKFL"
AGBHCIDJEKFL
slangi "GAHBICJDKELF"
GAHBICJDKELF

• Do all three quines have to use the same language? Are function quines allowed? – Dennis Jan 6 '16 at 17:03
• @Dennis All three quine have to use same language. Function quines is allowed. – Xwtek Jan 7 '16 at 7:57

# War of Flatland

If you haven't read Flatland, please do so here. It is a must-read, for mathematical and non-mathematical alike.

Oh no. No no no! War has broken out in Flatland. Society has crumbled, and all the women and children are either hiding or dead1. It is total anarchy, kill or be killed. It is such conflict that the 4th dimensional people have erected indestructible borders to prevent the conflict spreading.

On the plus side, if you came out on top, you could rule (some of) the entire world!

## Specifications

• You can be a shape with three or more sides. (No women1, remember?)
• All shapes are regular.
• You can only see by sight. (No feeling; you'll be killed if you get close enough to do that!)
• Everybody starts with 1 health.
• You can hurt other people by stabbing one of their edges with a vertex.
• The vertex of an n sided shape deals 1/n damage.
• An n sided shape has 4n angles of vision (sensors evenly spaced around the shape which see the nearest point and return the distance to it).
• An n sided shape can see 2n different distances (range [0,16))
• People don't see themselves. (What good is sight if your body gets in the way?)
• People are all the same size (radius).
• People can see everything within 16 units of their centre point.
• If your health is 0 or below, you are killed.
• The world has borders.
• You can rotate by a maximum of 15 degrees either direction, then move exactly 1 unit towards either of your vertices every turn.
• Each shape's "radius" is 8 units.
• Degrees are anticlockwise from 3 O'clock. The 0th sensor is at 3 O'clock relative to the shape's orientation.

1 This is not me being sexist. Read Flatland.

# Sandbox Meta:

I am using the Sandbox as a public incubator. I will build up and work on the challenge until it is ready, then post it as a question. But it made more sense to let others see, comment on and help with this challenge's development.

The Specifications are probably not going to remain in this format once the Stack Snippet and actual code is up and running.
I am working on, and have got quite far with, a JavaScript class to let people write code. If anyone can write a code to do the boring rendering thing onto a HTML5 canvas, I would be grateful.

### Stuff I plan to add:

• A stack-snippet battlefield
• A JavaScript class to let people write code
• A web-socket system to let people make submissions in other languages
• A system to pull submissions from answers (I'm no good at this sort of thing)
• 1. What counts as stabbing an edge? (I can see the numerical issues involved in working out whether a contact is vertex-vertex or edge-vertex being quite hairy). 2. What does it mean that "an n sided shape has 4n angles of vision"? 3. How does movement work? – Peter Taylor Jan 3 '16 at 17:07
• @PeterTaylor 1. I calculate line intersections on shapes with close enough centres, then I count the intersections and work out where the intersections are. 2. First, read up on how Flatlanders see distance. Distance is represented by a number. You have 4n numbers, evenly spaced around the shape. So a triangle will have 12 angles of vision. 3. You can rotate by a maximum of undecided degrees and move 1 unit towards either of your vertices every turn. – wizzwizz4 Jan 3 '16 at 17:21
• The word distance occurs only 9 times in the text, and none of them seem to address how distance is perceived per se. – Peter Taylor Jan 3 '16 at 18:01
• @PeterTaylor Part 1 Chapter 5 – wizzwizz4 Jan 3 '16 at 18:24
• Why not just say that vision extends out to 16 units and that each movement is 1 unit? Other considerations: what prevents a player from repeatedly stabbing another one? If everyone moves the same distance in a turn, I don't see how escape is possible. Do people/bots choose how many sides they have? It seems to me like a triangle would be the best choice. The only downside is fewer sensors, but I don't think that's a particularly bad one. – El'endia Starman Jan 5 '16 at 7:42
• @El'endiaStarman I've been trying to make higher shapes more balanced. And hopefully there will be a defined bouncing mechanism after stabbing. (Spinning like a saw however...) And yes, they choose. – wizzwizz4 Jan 5 '16 at 8:00
• @El'endiaStarman what if you always start as a triangle, a vertex forms on a side whenever one gets stabbed there (like a bruise swelling up). Or, in other words, an n-gon becomes an n+1-gon when stabbed. Stabs don't do ANY damage other than this. You die when n exceeds some threshold. This seems self-balancing: The more vertices you have the more people you can poke at once and the sooner you can poke them (because you already have a vertex aimed at them). – quintopia Jan 7 '16 at 17:05
• Another balancing possibility is making higher-sided shapes move faster. – quintopia Jan 7 '16 at 17:07
• @quintopia But that is simply a balancing system, and is in no way derived from the book. (But will probably be used if nobody can think of another way to balance the higher shapes that is derived from the book). – wizzwizz4 Jan 7 '16 at 17:42
• I was purposefully avoiding letting the content of the book influence my recommendations. It's more important that the game is fun than that it's thematic. – quintopia Jan 8 '16 at 16:19
• @quintopia I suppose... But your speed idea would introduce the issue of how fast? Would it be logarithmic? Would there be a point where it is unrealistic to be able to kill a higher-sided shape because they can practically teleport? – wizzwizz4 Jan 8 '16 at 16:51
• @quintopia And the n=>n+1 idea is a completely different challenge! – wizzwizz4 Jan 8 '16 at 16:52

### Print Euler's number on its own graph

Print the first n characters of Euler's number (e, 2.718281828459...) on a 'graph' of e^n. For example, input 3 (the x and y-axis scales here are provided for reference, and need not be implemented in your program):

20 |         1
19 |
18 |
17 |
16 |
15 |
14 |
13 |
12 |
11 |
10 |
9 |
8 |
7 |     7
6 |
5 |
4 |
3 | 2
2 |
1 |
0 | - - - - - - -
1   2   3
digit #


In the example above, note that:

• Three digits of Euler's number are presented
• Each digit is shown at a height equal to e^n, where n is the digit number. 2, for example, is shown at height 3 because e^1 = 2.72, which we round up to 3. You may round up or down, see below.

Various other informational bits:

• Rounding need not be implemented; 271 is acceptable output for input 3, as is 272.
• You will always be provided with input >= 1 , and your input will never contain decimal places nor any characters other than 0-9.
• You may round the y value up or down, I.e. e^3 = 20.0855 may be shown as y=20 or y=21.
• Your graph must have higher y-values at the top and higher x-values to the right; it must have a positive slope
• You may use any amount of horizontal spacing >= 1 between successive digits. In the example above, there are 3 spaces between successive digits. You just can't have digits stacked on top of eachother.
• You are not required to print scales on the x or y axis.
• Your input will always be <= 10.
• You may hardcode the required digits if you so desire.
• You should specify about trailing and leading whitespace, on each line and before and after the graph. – FryAmTheEggman Jan 14 '16 at 15:50

# Print as many numbers as you can

A challenge where you have two occurrences of each ASCII character from 20 to 7E to write as many programs as you can to print single distinct integers (one integer per program). For example, you cannot have A and AA to print 10 and 1010 in CJam, respectively, as that is three occurrences of A.

Full programs are not required.

You get 1 point for each integer you print. In the case that two answers create the same number of integers, the tiebreaker is the answer that uses the fewest bytes to create the integers.

Is this a good idea for a challenge? Also, is it a dupe? I feel like I've seen it before but I'm not sure.

• 1. TT is an odd example here, since it would print 10\n10 in Pyth. AA prints 1010 in CJam. 2. Are full programs required? Are leading zeroes allowed? Can the integers be negative? – Dennis Jan 8 '16 at 6:00
• I'm a little confused by the scoring, would we get to pick our own integer? And in your example, would AA count for two points? If so I think most answers would be something like BC#D#E#F#{A}* in CJam, where they just output the number a million billion times in a loop. (Don't try this online..) – FryAmTheEggman Jan 8 '16 at 18:12
• @FryAmTheEggman I added how it would be scored. The example you have would be I avoid anyways as it contains more than 2 # characters. – Arcturus Jan 8 '16 at 19:49
• Sure, but that doesn't stop people from generating giant numbers in other ways, or even infinite loops. I think a better approach would be to count the total number of programs that print exactly the same number exactly once with the same restriction. I do think this is a neat idea, but I don't think optimizing for the largest numeric output is nearly as interesting. – FryAmTheEggman Jan 8 '16 at 20:16
• @FryAmTheEggman The challenge isn't to optimize the largest number; it's to make the greatest quantity of numbers. – Arcturus Jan 8 '16 at 21:23
• Yes, but they are really the same thing. If I can make a large number I can print a lot of numbers. – FryAmTheEggman Jan 8 '16 at 21:24
• But can you make large numbers with multiple programs (remember that you can only print one integer at a time and only have 2 of each printable ASCII character to write all your programs)? – Arcturus Jan 8 '16 at 21:36
• Ok, that's what I was asking about, if each program is limited to 1 point I think it's fine, that just didn't seem very clear to me, especially because of the AA example. – FryAmTheEggman Jan 8 '16 at 21:52
• 1..99 in PowerShell will print a bunch of numbers (and similar in other languages). Is each program limited to only printing one? I think that's what you're intending, but it's not super-clear in your post. – AdmBorkBork Jan 8 '16 at 22:01
• I'm confused. Can you give an example? And how about character outside 20 - 7E? – Xwtek Jan 9 '16 at 2:21

# Find my way

I wanted to propose a challenge that is code golf (shortest answer wins), but with more programming challenge than parsing and printing funky text. Let's see if it sticks.

You are given a maze map, such as this:

#################################################
##########                    ######  ##### 1 ###
####   ##   ######  ########  #####     ####  ###
##   ###   #######  ########   ######  ###    ###
## X  ##  ########  #####      ####   #####  ##
#                      ##      ##    ##      ##
###################   ####   #####   #   ##  ##
###   #############  #####   ######  #  ##   ####
##   ###             ##      ##    ##   ##     ##
#   ##      ####     ##  #   #   #      ###    ##
#  ####              ##      #   #  #        ####
#   #####   ###    ####   #####  #  #############
#  #####   #####  ####   ##  ##     #############
###             ##     #  #     ########
##     ####    #####   ####     ########   ###
##     ###                ##        #####   ###
#####################   #   #####
#####       ##############  ##   ###    #########
##      #   ###     ######  ##    #   ###########
#########        #               ##########
###   ###     ##   ##################
###   ##########   ########################
#################################################


and you need to help the player 1 find the goal X. You can assume the following rules apply to the input map:

• it is a n x m ASCII rectangle (i.e. n lines of m characters);
• only the following characters are allowed: #, 1, X, (whitespace) and newline;
• # represent walls (that can't be crossed), represent empty space (that can be crossed); you can go anywhere in the n x m rectangle but you can't leave it (it's not Pacman).

If the maze has a solution, you shall produce an output of the following form:

#################################################
##########DLLLLLLLLL          ######  ##### D ###
####   ## D ###### U########  #####     ####D ###
##   ### DL####### U########   ######  ###  D ###
## X  ## D######## U#####      ####   ##### D##
#  ULLLLLL         UL  ##      ##    ##     D##
################### U ####   #####   #   ## D##
###   ############# U#####   ######  #  ##  D####
##   ###  RRRRRRRRRRU##      ##    ##   ##  D  ##
#   ##    U ####     ##  #   #   #DLLLL ### D  ##
#  ####   U          ##      #   #D # ULLLLLL####
#   ##### U ###    ####   #####  #D #############
#  #####RRU#####  ####   ##  ##  DL #############
###  U          ##     #  #  DL ########
##   U ####    #####   ####DLL  ########   ###
##RRRRU###                ##RRD     #####   ###
ULLLLL##################### D #   #####
#####    U  ##############  ##  D###    #########
##      #U  ### DLL ######  ##DLL #   ###########
#########ULLLLLLL#ULLLLLLLLLLLL  ##########
###   ###     ##   ##################
###   ##########   ########################
#################################################


where:

• the letters U, R, D and L represent movements by 1 character to the, respectively, up, right, down and left;
• the letter chain represent a valid path from the original 1 (which has been replaced by a direction character) and X.

If the maze has no solution, you should return void, NULL or anything equivalent.

Final rules:

• this is code golf, so the shortest solution wins;
• typical code-golf rules for input and output apply.
• This is near enough to codegolf.stackexchange.com/questions/42707/can-maze-be-solved that I'd call it a duplicate – quintopia Jan 9 '16 at 18:18
• Your solution is odd: It is not the shortest path. – Nathan Merrill Jan 10 '16 at 12:54
• @NathanMerrill: that was to illustrate that producing an optimal solution wasn't required – Alexandre Halm Jan 10 '16 at 12:59
• @quintopia: the example you mention can be solved with a basic flood-fill. Returning a valid path is slightly more complicated in terms of algorithm and vastly more complicated in terms of generating the output (but it's also more pleasant to look at). – Alexandre Halm Jan 11 '16 at 16:04
• @AlexandreHalm I misread. I thought yours was to output a truthy also. (However, yours can be solved with a flood fill also, with only a small amount extra effort to remove the blocked paths.) – quintopia Jan 11 '16 at 16:14
• @AlexandreHalm Speaking of which: what of mazes with multiple solutions? Since you do not require a path to be the shortest, would an output that includes all possible paths be valid? – quintopia Jan 11 '16 at 16:15
• I'm not sure enumerating multiple possible solutions would be interesting. I could require to produce the shortest path, which would make it more challenging (but even then you're not guaranteed to have a unique optimal solution). Then, unless you're willing to try some super-exponential search, you'd have to implement something like A* – Alexandre Halm Jan 11 '16 at 16:36
• To find any valid path requires something like backtracking algorithm. That could take a long time on any decent size maze (doing it double ended would help somewhat.) I think asking for the shortest possible is too much, unless the mazes are kept extremely simple. So I think it's more interesting as it is. But you should include wording similar to your reply to Nathan Merrill in the challenge text. Note that your text "shortest solution wins" is ambiguous (could be misinterepreted as shortest path through maze) and would be best changed to "shortest code wins." – Level River St Jan 15 '16 at 2:03

# Iterating through Doubles

This challenge is relatively simple: You are passed two floating point numbers, a and b; you must print every floating point in between in order.

• I don't care if your output includes a or b. You can choose to include/exclude them if you wish. For my examples, I will include a, but exclude b.
• You can assume that a <= b
• You should use IEEE 754 floating point numbers. As to the format of the numbers, I do not care, though I will be using binary32 in my examples.
• Your program must not print any NaNs, infinities, or print out the same number twice. -0 is the same as 0.
• Ifa or b cannot be perfectly represented in floating point, you must round-to-nearest them (standard for most languages). You can assume that a and b won't round to infinity.
• Your program must have a runtime of O(N), where N is the total number of floating point numbers in between a and b.
• Your program must not use more than O(1) storage. The only exception to this is for storing your output before printing it all.
• Builtins that are able to generate floats in order are not allowed (such as Julia's nextfloat())

For the following examples, I have used this webpage to generate the numbers, and thus my examples may have human errors.

-5.6E-45, 5.6E-45
-5.6E-45, -4.2E-45, -2.8E-45, -1.4E-45, 0, 1.4E-45, 2.8E-45, 4.2E-45

-0, 0
No output, though printing either 0 or -0 would be allowed (but not both)

299.9998, 300.0002
299.9998, 299.99982, 299.99985, 299.99988, 299.9999, 299.99994, 299.99997, 300, 300.00003, 300.00006, 300.0001, 300.00012, 300.00015, 300.00018, 300.0002

1.9999998, 2.000001
1.9999998, 1.9999999, 2, 2.0000002, 2.0000005, 2.0000007, 2.000001

-3.4028235E38, -3.402822E38
-3.4028235E38, -3.4028233E38, -3.402823E38, -3.402829E38, -3.4028227E38, -3.4028225E38, -3.4028222E38

3.4028229E38, 3.4028235E38
3.4028229E38, 3.402823E38, 3.4028233E38, 3.4028235E38

• 1. The header says doubles, but the question talks about binary32. Which of the various sizes permitted by IEEE 754 may be used? 2. More seriously, this is just a loop round an abuse of pointers (in C) or a library function to convert a bit-pattern from int to float (in pretty much any other language which supports IEEE 754). It doesn't offer much scope for creativity. – Peter Taylor Jan 10 '16 at 19:29
• @PeterTaylor I was hoping to find some cases of duplicated numbers, but I haven't found any. I realized that this was because the radix I'm using is 2. Would it be interesting if I enforced a radix of 10? Not every language has floating points like that (Decimal in C# is the only one I know of), so I'm not sure how relevant this challenge would be. – Nathan Merrill Jan 10 '16 at 21:26
• Sorry, I'm lost. Duplicated numbers? – Peter Taylor Jan 10 '16 at 21:41

# Introduction

SANDBOX NOTE: Diagrams soon

Copolar: Two triangles ABC and A'B'C' (not necessarily in the same plane) are said to be copolar if and only if the lines AA', BB', and CC' are concurrent at one point V.

Coaxial: Supoose two triangles ABC and A'B'C' are defined such that AB and A'B' intersect at X, AC and A'C' intersect at Y, and BC and B'C' intersect at Z. Then, the two triangles ABC and A'B'C' are said to be Coaxial if and only if X, Y, and Z are collinear.

Desargue's Theorem: Copolar triangles are coaxial, and conversely.

# The Challenge

Your challenge is to write two entire programs (but not necessarily in the same language, if you so desire) which detect whether or not two triangles are Coaxial/Copolar. One program must detect the existence of V, and the other must check the collinearity of X, Y, and Z (As defined above). You should provide some explanation or proof that your two programs perform these two different checks. Your score in this challenge is the Levenshtein distance between the two programs, with lowest score being dubbed winner.

# Input

You will receive 6 vectors, all of which containing an x, y, and z floating-point Cartesian coordinate, to represent the vertices of ABC and A'B'C'. This information may be received by your program in any convenient format, including command line arguments, nested lists, etc. The two programs you submit should take input in the same manner.

# Output

Your program should print a truthy value if ABC and A'B'C' are coaxial/copolar, and a falsey value otherwise. As this will likely require floating-point calculations, we establish some leniency:

Choose a constant value 0 < ERR < 0.01, for use in both programs.

• If the pairwise intersections of AA', BB', and CC' intersect within ERR units of one another, the given triangles should be considered copolar.

• If the point Z lies closer than ERR distance from the line XY, the given triangles should be considered coaxial.

Standard techniques for checking floating point calculation equality should be sufficiently accurate for this challenge.

Since copolar triangles are also coaxial, the programs should output the same value in all but extreme cases.

It should be assumed that any cross section of the cartesian space provided is an Extended Euclidean Plane. Note that it is possible that the vertex V or any of X, Y, and Z may be an ideal point, and this is a case that should be prepared for.

# Test cases

SANDBOX NOTE: Coming soon...

• Levenshtein distance between two programs has been tried before and is now well-known to be completely useless as a winning criterion. Anyone with half a brain can score 1, and sometimes it's even possible to vary the input enough to detect the cases and score 0. – Peter Taylor Jan 11 '16 at 11:09

Cookies are being served! Sibling rivalry ensues! Each of the twins wants the maximum quantity of cookie. The problem is that the cookies are of somewhat different sizes, not surprising since they are home baked. So you weigh each of the cookies and devise a program to help you allocate them to each twin such that the difference in total weight of the cookies each twin gets is minimized. Coding up the program is your task today!

## Input

Each case is described on a single line that begins with the number of cookies (no more than 100) followed by the weight of each (in integer grams, no more than 1000 grams).

## Output

For each case, display the minimum total weight difference.

5 6 8 5 2 6

2 25 62

# Sample Output

1

37

I asked this earlier and it was put on hold. Not sure what needs to be changed.

• First you need a winning criterion. Code golf (shortest valid code wins) would work well here. Another possibility would be fastest code, but that would be harder to judge - you'd probably need to run every answer on your machine, in a number of different languages. Popularity contest is hard to write a good question for, and is best saved for questions where there is no other way of judging. If you don't have a strong preference, I'd go with code golf. – trichoplax Jan 11 '16 at 3:37
• An edge case to consider: Will the input ever be just 0 followed by no cookies? Whichever way you decide, it's worth mentioning this explicitly in the question so people know whether to plan for that. – trichoplax Jan 11 '16 at 3:42
• You had asked for the total weight of cookies to be minimized, which I suspect was not what you intended, so I've edited it to ask instead for the difference in total weight to be minimized. If this wasn't what you intended feel free to roll back the edit. – trichoplax Jan 11 '16 at 3:47
• That clears it up a lot, thank-you, @trichoplax – Tanner Jan 11 '16 at 3:54
• You're welcome. You'll still need to do some further editing to address my first 2 comments, then after that hopefully others will comment with anything else that needs improving that I've missed. – trichoplax Jan 11 '16 at 4:50
• This is a trivial variant of this older question and IMO close enough to count as a dupe. – Peter Taylor Jan 11 '16 at 11:07
• I believe the question was closed as a duplicate of this because it's exactly the same, just about cookies instead of shopping bags. – user81655 Jan 15 '16 at 10:54

# Count the ones!(better title needed)

[Sandbox-note: Is this really still code-golf?]

[Sandbox note: Need to find descriptive tags]

Void Corp needs you!

Thanks to extreme advancements in a technology called null-space we are able to compress any number of 0-bits into just one memory block. The problem is that storing 1-bits is extremely expensive now. To evaluate which data we should keep we need a program that count all 1-bits in a string. Sadly our programmer is currently in forced vacation after a caffeine-incident, so it is up to you now to help us out.

Your code should contain as few 1-bits as possible when stored in null-space.

We have heard of this strange Unary. As our programmer is the only one able to understand it, we are currently not able to implement it.

Write a program that counts all 1-bits in a given string.

You may provide a function or fully functional program. Input will be provided via STDIN or argument and should be printed to STDOUT or returned.

Your answer must be in an existing language, especially the interpreter must already exist. No retro-active coding of a language that consists entirely of NUL (unless I missed it). [Sandbox note: Don't tell me there is such a thing.]

# Scoring

Count the 1-bits in your code. Fewest amount wins.

[Sandbox note: Should add script to paste code into for evaluation]

## Sandbox Questions

What do you think of the task? It seems pretty basic to me, the twist is the Scoring.

What do you think of the scoring? I want to encourage usage of obscure/lengthy commands which are normally not used in CodeGolf. Your opinion?

Does someone happen to have a script for evaluation lying around? Do you have anything to add?

Is appropriate for this question?

• IMO this is a variant of codegolf.stackexchange.com/q/4434/194 and the twist isn't particularly twisty. I would vote to close as dupe. – Peter Taylor Jan 11 '16 at 14:08
• Also the tag you would want, just fyi, is code-challenge. – FryAmTheEggman Jan 11 '16 at 15:49
• – lirtosiast Jan 20 '16 at 18:41
• @ThomasKwa Indeed... – JFBM Jan 20 '16 at 19:26

# Fixed Width

We like fixed width. We want you to evaluate a string
on it's "fixed width"-ness. However, this string will
not be a regular string. This input will be presented
to your code as thus: "name1, name2, lin1,..., linN".

Each of linK is a single line of a transcript; you'll
assume that the speakers alternate, and that each lin
is will not have trailing whitespace, like this:


You may take input in the form of a function or a program, as a string with commas, a list, or a series of arguments.

Say your input is rob, emily, hi, hey you, last night was nice, the best i've had. Then, the result would be:

<rob> hi
<emily> hey you
<rob> last night was nice


Then, this input would have a "fixed width"-ness of 2. This is what you would return/print. That is, you are to output the length of the longest run of fixed width messages.

## Test cases

input => output

rob, emily, hi, hey you, last night was nice, the best i've had => 2
a, b, hello, hola!, no, what?, why, why not, abcdef, fededa, 012345 => 3


I think this should be , but I think this could also work as a fixed-width , maybe.

# Hexotria number

Inspired by Triangular Ulam spiral

For instance we write number in triagular spiralling way

      30  10  26  51
31  11  09  25  50
32  12  01  08  24  49
33  13  02  00  07  23  48
14  03  04  05  06  22
16  17  18  19  20
39  40  41  42


Then we read in spiralling hexagonal way (Starting from 0, 1 ,2) then we get

0, 1, 2, 4, 5, 7, 8, 9, 11, 12, 13, 3, 17, 18, 19, 6, 23, 24, 25, 26, 10, 30, 31, 32, 33, 14, 16, 39, 40, 41, 42, 20, 22, 48, 49, 50, 51


Your challenge is given a number (i) output the i'th item in that sequence. i is zero based. Shortest code wins.

• meta.codegolf.stackexchange.com/a/8048/8478 – Martin Ender Jan 15 '16 at 15:00
• Otherwise, this sounds like a nice challenge :). You should specify whether i is 0-based or 1-based or whether people can choose. – Martin Ender Jan 15 '16 at 15:01
• @MartinBüttner Now, what's missing in this challenge? – Xwtek Jan 17 '16 at 0:26

# The quitting log-in

This program relies on the user pressing Ctrl + C at specified times to show him the secret message (the secret message is just m to avoid polluting the byte count with un-avoidable chars).

Given a 3 digit enter code that may be specified anywhere (just give directions to find it inside your source code) let the user see the message if he quits at the n-th (1-indexed, zero may never be present in the pass-code) ? each time.

The user should press Enter to get to the next question.

If the user does not press <Control-C>, nine successive prompts should be shown.

Given a code 523

?
?
?
?
? <Control-C>
?
? <Control-C>
?
?
? <Control-C>
m


Given a code 123

?
?
? <Control-C>
? <Control-C>
? <Control-C>

• Instead of m you could make the program output something truthy or falsy depending on whether the pattern is correct. Also do you want to specifically make this a challenge about catching process signals? Because that will rule out a lot of languages, and if it's not your intention you could also have the user enter a specific string instead of having them send Ctrl+C. – Martin Ender Jan 19 '16 at 20:02
• @MartinBüttner I actually want to make this a challange about handling KeyboardInterrupt because I have never seen it in a code-golf challange, as far as m vs truthy falsy is concerned, it is just a matter of r?'m':'' now, and the message may in theory be a long string, one char just to avoid cluttering the code up – Caridorc Jan 19 '16 at 20:35
• There's at least codegolf.stackexchange.com/q/63105/8478 but I feel like we've had another one, too. – Martin Ender Jan 19 '16 at 20:52

# Queuing queues

I recently found a great site, Dubtrack, for all my music needs. However, it features a very interesting method of ordering, which contains a queue of users, and each user has their own personal queue.

The user queue loops through each of the users that have songs, and plays the top song from their individual queue. This means that:

1. When there is a single user, it simply plays the songs in the order that user added them.
2. When there are multiple users, it interleaves the songs.

However, users' queues aren't always filled, and when a user adds his first song to the queue, the user is added to the end of the user queue.

For example, say there were 3 users each with the following queues (at time 0):

0 [1,10,100,1000]
0 [2,20]
0 [3,30,300]


then the resulting playlist would look like:

[1, 2, 3, 10, 20, 30, 100, 300, 1000]


However, if a user were to add his queue during the 4th song:

0 [1,10,100,1000]
0 [2,20]
0 [3,30,300]
3 [4,40,400,4000]


Then the playlist would look like

                      v New user's song finally plays
[1, 2, 3, 10, 20, 30, 4, 100, 300, 400, 1000, 400, 4000]
^ New user added here, but user 2 and 3 are still in front


Your challenge is to take a list of queues and join times, and return them in single playlist. You are guaranteed that there will be at least 1 queue at time 0, and that additional users won't be added after all the songs have played.

# Test cases

Input
0 [1,5,3,7,2,6,3]
Output
[1,5,3,7,2,6,3]

Input
1 [3,6,9,12]
0 [4,10]
Output
[4,10,3,6,9,12]

Input
0 [1,10,100,1000]
0 [2,20]
0 [3,30,300]
3 [4,40,400,4000]
Output
[1,2,3,10,20,30,4,100,300,400,1000,400,4000]

Input
11 [3000]
3 [6,8,10,11,0]
5 [4,100,14,12,0]
0 [0,1,2,3,4,5]
11 [2000]
Output
[0,1,2,3,6,4,8,4,5,10,100,11,14,3000,2000,0,12,0]

• I'm not sure I understand how the queue system works. You say "when a user adds his first song to the queue, the song is placed at the end of the interleaving process", but in the second example, song 4 is placed before song 21, not at the end of the existing queue. Maybe I'm misunderstanding what you mean by "a queue". – Zgarb Jan 20 '16 at 19:43
• @Zgarb I made a few changes: There is a queue of "users" and each user has their own individual queue. I've also termed the output as a "playlist". Do you understand now? – Nathan Merrill Jan 20 '16 at 20:07
• It's much better now, yes. But just to be clear, when a song is popped from a user's personal queue to be played, that user is effectively sent to the bottom of the user queue, right? – Zgarb Jan 20 '16 at 20:16
• Yep, that's how it works. – Nathan Merrill Jan 20 '16 at 20:17
• What assumptions can be made about the song IDs? Are they guaranteed to be non-negative integers between e.g. 0 (inclusive) and 2^31 (exclusive)? Can answers choose between that or strings? Something else? – Peter Taylor Jan 23 '16 at 19:04
• Both of those sound like good options. – Nathan Merrill Jan 23 '16 at 19:42

# Natural Language Calculator

Background

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!

Challenge

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:

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

Testcases

> "Add 4 and 5"
9
> "Multiply 6 and 10"
60
> "Divide 144 and 12"
12
> Exponent base 10 of 3
1000
> 3 factorial
6
> 3
> Add 5 factorial and 2
122
> Exponent base e of natural log of e
e
> natural log of e
1

• -1 Unclear challenge. – Xwtek Jan 16 '16 at 9:11
• @ChristianIrwan "Still in the works and need to add more detail" – TanMath Jan 16 '16 at 9:32
• Well, I think the sandbox is not for brainwashing idea, but to polish the challenge while detecting it if the challenge is duplicate. – Xwtek Jan 16 '16 at 13:57
• 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. – Addison Crump Jan 22 '16 at 23:13
• Even if this were cleaned up, I don't see what it adds to the many existing "process arithmetic in english" challenges. – 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.

(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?
• 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. – Neil Jan 29 '16 at 8:37
• @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. – Martin Ender Jan 29 '16 at 8:42
• I just didn't think it was the best, um, sort of sort to use to demonstrate the idea. – Neil Jan 29 '16 at 8:49
• @Neil fixed? :) – Martin Ender Jan 29 '16 at 9:11
• Now that's what I call an excellent sort of sort to demonstrate the idea! – Neil Jan 29 '16 at 13:42
• Oddly enough I was thinking of a challenge very much like this. – 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

### Examples

INPUT:

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


OUTPUT:

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.

# Rules

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

# Bonuses

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!

• "Whatever defines "suitable" for your code is up to you" is too broad IMO. – Peter Taylor Jan 25 '16 at 14:35
• @PeterTaylor Refined. Please see edit. – Addison Crump Jan 29 '16 at 17:50
• @RikerW I don't know what you're saying. – Addison Crump Jan 29 '16 at 17:57
• Me neither. lol – Rɪᴋᴇʀ Jan 29 '16 at 17:58
• 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). – Peter Taylor Jan 29 '16 at 19:48
• @PeterTaylor Fixed. – 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)

### Scoring

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)

### Rules

• 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


## Specs

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.

# ~META~

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

• 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). – Peter Taylor Feb 2 '16 at 12:45
• @PeterTaylor I missed those, thanks. – Conor O'Brien Feb 2 '16 at 14:51

# Reasoning

## Introduction

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.

## Definitions

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

>input:
R00
>expected output:
false|no|whatever

>input:
R00
R00
>expected output:
true

>input:
R10 0
R10 @1
>expected output:
true

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

>input:
R2859 7 163
R2859 @0 163
>expected output:
true

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

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

>input
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:
true

>input
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:
false


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? code-golf

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

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

### Examples

Input:
111
111
111
1,1

Output:
truthy

• Will the center of mass always be at integer coordinates? – lirtosiast Feb 8 '16 at 2:42
• 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. – J Atkin Feb 8 '16 at 2:55
• 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. – 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.

Input/Output

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.

Scoring

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

Example

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
end

return 1 + (num % n)
end

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

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

for i = 1, 52 do
print(deck[i])
end


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.

• As far as I can tell, printing the input unchanged satisfies the spec. – feersum Feb 7 '16 at 14:28
• "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. – tehtmi Feb 7 '16 at 20:07
• 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. – tehtmi Feb 7 '16 at 20:12
• 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. – Liam Feb 7 '16 at 21:15
• 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. – tehtmi Feb 7 '16 at 22:11
• 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. – nimi Feb 7 '16 at 23:03
• 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. – tehtmi Feb 8 '16 at 1:07
• @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. – nimi Feb 8 '16 at 4:29
• 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. – Peter Taylor Feb 8 '16 at 8:17
• ^ yeah. I would recommend narrowing the input specs. "Input can be anything" will usually get you into trouble. – Liam Feb 8 '16 at 19:45
• @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. – tehtmi Feb 8 '16 at 22:19
• @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. – tehtmi Feb 8 '16 at 22:22
• Many many languages have built-in sort, and sorting and then checking that a[i] = i+1 for all i is sufficient. – Peter Taylor Feb 8 '16 at 22:27
• 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. – Liam Feb 8 '16 at 22:41
• 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. – tehtmi Feb 8 '16 at 22:46

# How clean is my snow? code-golf

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]

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

## Note

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

97:65;98:66;99:67;100:68;101:69;102:70;103:71;104:72;105:73;106:74;107:75;108:76;109:77;110:78;111:79;112:80;113:81;114:82;115:83;116:84;117:85;118:86;119:87;120:88;121:89;122:90;223:83,83;224:192;225:193;226:194;227:195;228:196;229:197;230:198;231:199;232:200;233:201;234:202;235:203;236:204;237:205;238:206;239:207;240:208;241:209;242:210;243:211;244:212;245:213;246:214;248:216;249:217;250:218;251:219;252:220;253:221;254:222;255:89;257:256;259:258;263:262;269:268;271:270;275:274;277:276;283:282;301:300;305:73;322:321;328:327;337:336;339:338;345:344;353:352;357:356;367:366;369:368;382:381;945:913;946:914;947:915;948:916;949:917;950:918;951:919;952:920;953:921;954:922;955:923;956:924;957:925;958:926;959:927;960:928;961:929;962:931;963:931;964:932;965:933;966:934;967:935;968:936;969:937;977:920;981:934;982:928;987:986;989:988;991:990;993:992;1008:922;1009:929;1013:917;8458:63350;8467:8466;8495:8496;8500:63358;63154:63344;63155:8492;63156:63346;63157:63347;63159:8497;63161:8459;63162:8464;63163:63353;63164:63354;63166:8499;63167:63357;63169:63359;63170:63360;63171:8475;63172:63362;63173:63363;63174:63364;63175:63365;63176:63366;63177:63367;63178:63368;63179:63369;63180:63370;63181:63371;63182:8493;63183:63373;63184:63374;63185:63375;63186:63376;63187:8460;63188:8465;63189:63379;63190:63380;63191:63381;63192:63382;63193:63383;63194:63384;63195:63385;63196:63386;63197:8476;63198:63388;63199:63389;63200:63390;63201:63391;63202:63392;63203:63393;63204:63394;63205:8488;63206:63396;63207:63397;63208:63398;63209:63399;63210:63400;63211:63401;63212:63402;63213:63403;63214:63404;63215:63405;63216:63406;63217:63407;63218:63408;63219:63409;63220:63410;63221:63411;63222:63412;63223:63413;63224:63414;63225:63415;63226:63416;63227:63417;63228:63418;63229:63419;63230:63420;63231:63421;63232:74;63488:63514;63489:63515;63490:63516;63491:63517;63492:63518;63493:63519;63494:63520;63495:63521;63496:63522;63497:63523;63498:63524;63499:63525;63500:63526;63501:63527;63502:63528;63503:63529;63504:63530;63505:63531;63506:63532;63507:63533;63508:63534;63509:63535;63510:63536;63511:63537;63512:63538;63513:63539;63572:63540;63573:63541;63574:63542;63575:63543;63576:63544;63577:63545;63578:63546;63579:63547;63580:63548;63581:63549;63582:63550;63583:63551;63584:63552;63585:63553;63586:63554;63587:63555;63588:63556;63589:63558;63590:63558;63591:63559;63592:63560;63593:63561;63594:63562;63595:63563;63596:63564;63604:63547;63608:63561;63609:63555;63614:63613;63616:63615;63618:63617;63620:63619;63621:63549;63622:63556;63626:63544;


## Rules

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

# Meta Questions

• What are some good test cases for this challenge?
• Is there something that I possibly missed while writing this challenge?
• '"Wouldn't this be too broad?" you ask.' No I would ask "Isn't this a duplicate?" ;) – Martin Ender Feb 11 '16 at 13:16
• "You can't use Mathematica for this challenge." Why not just ban the built-in? – Martin Ender Feb 11 '16 at 13:16
• 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. – Martin Ender Feb 11 '16 at 13:19
• @insertusernamehere Looking at the list that's actually the only special one. – Martin Ender Feb 11 '16 at 13:21
• >>> "ß".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... – Sp3000 Feb 11 '16 at 13:23
• @MartinBüttner I'm planning on possibly making a series out of this. – LegionMammal978 Feb 11 '16 at 13:28
• 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? – Sp3000 Feb 11 '16 at 13:32
• The list needs a bit of cleaning up. In particular, 223:83,83 is clearly erroneous. – Peter Taylor Feb 11 '16 at 14:38
• @PeterTaylor Why? Isn't 223 the character code of ß and 83 the character code of S? – Martin Ender Feb 11 '16 at 15:38
• @MartinBüttner, oh, I see. So what needs fixing is to document the list and describe its format. – Peter Taylor Feb 11 '16 at 15:57
• 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? – Dennis Feb 11 '16 at 20:17
• @insertusernamehere I didn't want to break peoples' browsers with non-rendering characters (Mathematica uses its own custom font). – LegionMammal978 Feb 11 '16 at 23:11
• @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. – LegionMammal978 Feb 11 '16 at 23:14
• OK, my mistake. A bit of googling revealed that Mathematica's Unicode support is incomplete and exceptionally buggy. – 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:

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