# What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

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

## Get the Sandbox Viewer to view the sandbox more easily

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

# RaceTrack Arena KOTH

(haven't come up with a very good title)

this koth is inspired by the pen and paper game Racetrack.

## RaceTrack Movement

Racetrack (and this racetrack-inspired koth) use a distinctive vector based movement system.

all bots players are on a square grid.

initially, a cycle (this is what we will call bot players) will have no movement i.e. be completely motionless

However, after a cycle begins moving, it gains inertia; it will not stop moving in this direction unless it acts to stop moving.

On every turn, a cycle can change their speed on each axis (x and y) by -1, 0, or 1, and the same with y speed. this includes sticking with their current speed. This means that every turn, a cycle has 9 options of spaces to move to (excluding spaces which would cause them to crash)

for example, in this diagram, the cycle indicated by the red space, which has just moved from the brown space, has the option of the 9 green squares in the red-lined area, the main, more saturated, green square, along with the blue line, represents where it will end up staying on its inertial course

if, for some reason, the cycle wanted to come to a complete stop, it would take 5 turns, which is the Chebyshev distance between the inertia vector's end and the cycle.

# [more tbd obviously]

don't downvote for the lack of content please

• Can (like on the paper) every contestant see the whole arena, including other contestants' movements? As I remember, it's alternative moves rather than simultaneous and you crash if you end up on or cross other contestant's position or most recent motion line. How will the edge be defined? You crash if you end up outside OR if your motion line crosses outside area. Explain the rules in your post. You can have different rules, but if you keep alternative move the starting player will have advantage. So every contestant of this KOTH should have equal number of participation at each position. +1 – Heimdall Nov 11 '17 at 8:36
• We don't know the first player has so much of an advantage; random positions are rather likely to have a much larger effect than the fact that player 1 can strategy steal, and even with non-randomised positions, playing with multiple players is very different in flavour from just two players, since playing against one player, their moves only make themselves better or worse, but in multiplayer another (dumb) player can unwittingly help you or harm you without regard to whether it does help them. Also I haven't decided on whether bots can see the whole playing field or if they have a top speed – Destructible Lemon Nov 12 '17 at 22:53
• ... if there is a limit to their sight, it follows there has to be a limit to their speed, and even if there isn't an implemented, it's at least effectively a limit, since moving somewhere you can't see if there is a wall is not a great strategy. also there will probably be obstacles that act like walls, so the edge is not the only place to crash, btw. anyway, the definition of crash, is that a bot's movement line goes through a hazardous square. I suppose that touching a vortex can be considered a near miss – Destructible Lemon Nov 12 '17 at 22:55
• that said, I guess there's no real reason not to randomise the turn order each game. – Destructible Lemon Nov 12 '17 at 23:09
• Suppose you're the first, whatever your starting position. You accelerate so that you have maximum safe speed. Others won't accelerate to higher speed because that would cause them to crash at the turn (unless, as you put it, a dumb racer decides to overtake you anyway). Let's say the next turn is left. You'll go as far left as possible. Racers on your right will just lag behind. But racers on your left will only be able to keep up until you "cut the corner". They won't be able to stop you from doing so because at no point they will be ahead of you. But maybe some random debris on the path ... – Heimdall Nov 13 '17 at 10:49
• Actually, dumb racing might be a good strategy... If you are allowed to have more than one bot in a race, one can be "dumb" to increase the other one's chances... – Heimdall Nov 13 '17 at 10:52
• @Heimdall that strategy tends to be discouraged. making a simple bot is not, but making bots collude is frowned upon. – Destructible Lemon Nov 13 '17 at 23:33
• So I guess the wall is made by placing a series of hazardous squares, and crashing means you're out of that race only. But how is crash between two racers defined and dealt with? – Heimdall Nov 16 '17 at 7:12
• @Heimdall no offence, but I haven't actually made enough of the spec that I should be answering questions from you in the comments, especially since you have a rather inaccurate idea of the game (because i haven't specified). for example, it's not a race. – Destructible Lemon Nov 16 '17 at 8:29
• Sorry, I'm a bit impatient. It's just I'm looking forward to your game which is still in the making, that's why I gave it +1. I assumed it was a race (or series of races) where the bots compete because it's based on that paper race. Also I was trying to be helpful by raising potential issues in order for the task to be well formed. – Heimdall Nov 16 '17 at 10:27

# Bunnies in (three-dimensional) space

A panicked call has come in from the International Space Station: a psychological experiment has gone awry, and the astronauts have lost all their Stanford Bunnies. You have been tasked to come up with a way to get them as many replacements as possible.

Because of the rush, NASA has just one rocket available for this mission: a Delta II Heavy with a box-shaped cargo hold (a "right cuboid", they called it) of length x, width y and height z, all even integers. Your job is finding out how many bunnies to bring - and how to pack them.

## Input and output

Your program should take the dimensions of the cargo hold as arguments. It should then compute how many bunnies it can fit in there, producing output as follows:

• A header line consisting of the length, width and height of the box, as integers, seperated by spaces. This is a copy of the input.
• A line for every bunny fitted, containing the following as dotted floats, all seperated by spaces:
• the position of the center of the bunny, relative to the center of the box, as x, y and z
• the rotation of the bunny, as a rotation about the x, y and z axes, in that order (a.k.a. Tait–Bryan angles).

For example, a solution for a box of 4 × 6 × 8 units, with a single, un-rotated bunny in the center, would be described as follows:

4 6 8
0.0  0.0  0.0   0.0  0.0  0.0

A solution for a larger box of 12 × 8 × 8 units with two bunnies could look like this:

12 8 8
4.5433 2.5843  1.4380 3.1415 0.0000 0.0000
-2.4839 1.3923 -1.9400 0.0000 0.0000 1.5707

...although your program will likely be able to fit more bunnies.

# Dataset

This is the vertex data for the bunny. It is in Wavefront OBJ format, which means that every 'v' line describes a vertex (point in x, y, z space), and every 'f' line describes a triangle of vertices. Compared to the original Stanford Bunny model, this model has been translated so that its centerpoint is at the origin (0, 0, 0) and it fits snugly inside a unit cube.

# Tips

• You don't have to use the dataset above in your program - for example, you might want to simplify it more - but you should make sure that your output is correct when using the 'official' model.
• Be careful with rounding, both during calculations and when outputting your result.
• The Wavefront format can be imported into the free blender program if you want to see what it looks like (make sure to choose 'Z Up').
• Your program does not have to be usable for other models: it can be a special-purpose bunny-fitting utility.

# Rules and winner

• A valid solution is one where, if you constructed a box of bunnies using the solution's description and the vertex data above, none of the bunnies would touch each other or the bounding box.
• Your program has to be usable for box sizes other than the one below.
• Your entry should run in less than, say, ten minutes on reasonable hardware.
• The program must be self-contained: you can only use your language's standard libraries.
• The winner is the program that succesfully fits the most bunnies in a box of 12 × 8 × 6. Include (a link to) your code, (a link to) a solution for that box size, and, if you made any, a picture of your solution.
• I'd recommend against Unicode chars in the title. – Erik the Outgolfer Nov 17 '17 at 22:42
• @EriktheOutgolfer Fixed! – Wander Nauta Nov 17 '17 at 22:43
• Why only allowing the language's standard libraries? That seems like it would ban things like numpy for python, which may be useful for extra math functions. It's a standard loophole for people to make new libraries designed to solve a challenge anyway. – Rɪᴋᴇʀ Nov 18 '17 at 0:26
• Also, is there a tie-breaker if 2 programs find the optimal solution? Shortest code? "Whoever submitted first" is likely fine but seems ugly to me, maybe fastest code? – Rɪᴋᴇʀ Nov 18 '17 at 0:29
• @Riker: I added the self-contained rule to prevent people from grabbing an off-the-shelf implementation for the actual problem, or introduce wild dependencies that make it hard to reproduce results. You're right that numpy is generic enough that it could almost be considered part of the standard library, but I thought I had to draw the line somewhere. Do you think I should remove the rule altogether? – Wander Nauta Nov 18 '17 at 0:38
• @Riker: A naive solution can fit 576 bunnies, and well-thought-out versions will likely score much much more, so I think the chance of two different approaches accidentally getting exactly the same score is quite slim. If there is an optimal solution (I'm actually not sure!) I'd be comfortable letting the first submitter to find it win. – Wander Nauta Nov 18 '17 at 0:47

# Inside or Outside?

Given a point and a polygonial loop that is not self intersecting, determine whether the point is strictly inside or outside of the loop.

### Details

• The polygon is given as an ordered list of points cartesian coordinates.

• The single point is given as a separate input, but you can also say that is e.g. always the first or always the last point in the list.

• We only consider points with integral coordinates.

• You can choose whatever representation is easiest to work with for you for instance a list of pairs, or two separate list for the x- and y-coordinates etc.

• The list describes the polygon in positive orientation, that means the inside is always on the left side if you follow the points from the beginning to the end of the list. (You may choose to use the opposite orientation but please indicate if you do.)

• A point is considered to be strictly on the inside, if it is not contained in the border of the polygon.

### Examples

[(0,0),(0,2),(2,2),(2,0)]: (1,1) is strictly inside, all other points are outside
[(0,0),(0,2),(2,0)]: no point is strictly inside

more coming soon...

# Meta:

• Should I relax the strictly inside to just inside (i.e. a point on the border is also considered as inside)
• Should I let the participants choose which version they prefer?
• 1. Not necessarily convex or must be convex? 2. What you describe as "positive orientation" is the same as "in counter-clockwise order". 3. Does the point for testing for inside/outside have integral coordinate? – user202729 Nov 26 '17 at 14:42
• The shape is arbitrary and the testing point does have integral coordinates too (see examples) – flawr Nov 26 '17 at 14:46
• Seems that you flipped what "positive orientation" means. Keep this if that is what you want. / Proposed test case: (0,0),(0,5),(2,2),(5,0) → strictly inside integer points = (1,1),(1,2),(1,3),(2,1),(3,1) where the shape is a concave quadrilateral. – user202729 Nov 26 '17 at 14:58
• Well the first one was incorrect, positive actually means counter clockwise. – flawr Nov 26 '17 at 19:37
• 4. Does the flexiblity in input extend to allowing us to require the first vertex to be repeated at the end of the list? 5. The strictly inside vs inside issue might be best addressed by asking for a classification into strictly inside, on the perimeter, and strictly outside. This is slightly trickier, I think, because of the implication that you can't cast a ray to infinity and just ignore edges which are parallel to it. – Peter Taylor Nov 27 '17 at 10:37

# (No title currently)

Given a natural number N and a natural number K, find a list of natural numbers L such that:

1. The product of the elements of L is N
2. Each member of L is less than or equal to K
3. And the length of L is minimized.

(You can return these numbers in any order.)

Note that:

• If no such list exists, you program may do anything besides yielding a valid list, including but not limited to:
• Printing something to stderr
• Yielding an empty list
• Yielding a non-list (see below)

If outputting to stdout, you can output a list in any reasonable fashion, such as:

• Comma-separated: 3, 5, 7
• With brackets: [3, 5, 7]
• Whitespace-separated: 3 5 7
• Your native list representation (345 or 3 4,5,, etc.)

## Test cases (examples)

N, K -> L

32, 2 -> [2, 2, 2, 2, 2]
50, 10 -> [5, 10]
1224, 99 -> [72, 17] or [24, 51]
5, 10 -> [5]
1337, 100 -> []                         (since 1337 = 7 * 191)
1337, 191 -> [7, 191]
42, 8 -> [6, 7]
42, 21 -> [2, 21] or [3, 14] or [6, 7]
1, 2 -> [1]                             (NOT the empty list)
36, 6 -> [6, 6]
36, 9 -> [4, 9]
36, 12 -> [4, 9] or [3, 12]
32, 64 -> [32]
432, 9 -> [6, 8, 9]                     (NOT [2, 6, 6, 6])
216, 8 -> [6, 6, 6]                     (NOT [8, 3, 3, 3])
• (1) I think every instance of number needs to be replaced with natural number. Otherwise 1337, 100 can be satisfied by [sqrt(1337), sqrt(1337)] or [-1, -1337]. (2) Are any of the test cases failed by a greedy approach? If not, can you construct a test case for which a greedy approach fails? (3) What is the correct output for 1, 2? I can make a case for [], but I wonder whether you expect [1]. – Peter Taylor Nov 29 '17 at 16:10
• @PeterTaylor (1) True. (2) I'm not entirely sure. (3) I think I will exclude the empty product as valid output – Conor O'Brien Nov 29 '17 at 17:19
• @PeterTaylor I think 432 would not work with a greedy approach, can you confirm? [2,6,6,6] as opposed to [6,8,9] – Conor O'Brien Nov 29 '17 at 17:25
• Aha. For (2), I think it's worth adding test case 216, 8. The greedy approach would be to say that 8 divides 216 and then split 216/8 = 27 as [3, 3, 3] giving a division into four factors; but [6, 6, 6] is a valid division into three factors. Edit: overlapped with your comment. I think you're attacking a different greedy approach. The more the merrier for test cases. – Peter Taylor Nov 29 '17 at 17:26
• @PeterTaylor I see what you mean, thanks for the help! – Conor O'Brien Nov 29 '17 at 17:35
• Why can there be a 9 in 432, 8? It violates the second rule. – NieDzejkob Nov 30 '17 at 21:14
• @NieDzejkob Sorry, a typo on my part, thanks! – Conor O'Brien Dec 2 '17 at 2:19

# Show a Chess Piece Range

Write a program or function that, given a set of movement rules, shows the available moves for a fairy chess piece.

### Movement Rules:

This will use a slightly modified version of Parlett's Movement Notation:

A number, 1, 2, etc. shows how far a piece can move in a given direction. n indicates any distance, and two numbers separated by a hyphen (e.g. "1-4") means that there is a range of distances that the piece can move. Ranges may be enclosed in parentheses.

Numbers are followed by a direction sign:

• * - any direction, orthogonally or diagonally
• + - orthogonally (forwards, backwards, sideways)
• X - diagonally
• > - forwards
• < - backwards
• = - sideways
• X> - diagonally forwards
• X< - diagonally forwards

These directions can be combined, so <> means forwards or backwards, X= means diagonally or sideways, etc. Note that >X means forwards or diagonally, and is different from X>.

This gives us many of the standard chess pieces. For example, 1* is a King's movement, while nX is a Bishop.

There are also "grouping" indicators:

• / - two numbers (or ranges) separated by a slash indicates a "hippogonal" move, like a knight: a/b means move a spaces orthogonally, and b spaces perpendicular to the first move. These may be enclosed in parentheses.
• & - repeated movement in the same direction
• . - "then" - combines two distinct moves, one after another.
• , - "or" - separates two distinct moves. Only one may be taken on a turn.

The format of a move (not including grouping) is <distance><direction><other>.

### Input:

A string showing the movement rules.

### Output:

An ASCII representation of an 8x8 chess board with the given piece on the d4 square, with all other accessible squares indicated. For example, given the input n* (a queen), you should output:

...x...x
x..x..x.
.x.x.x..
..xxx...
xxx@xxxx
..xxx...
.x.x.x..
x..x..x.

The output may consist of any three distinct characters.

### Examples and Test Cases

Input: (1/2)
Output:
.........
.........
..X.X....
.X...X...
...@.....
.X...X...
..X.X....
.........

Input: 2*
Output:
.........
.........
.X.X.X...
.........
.X.@.X...
.........
.X.X.X...
.........

Input: 2+.1+    (compare to the knight, above)
Output:
.........
...X.....
..X.X....
.X.X.X...
X.X@X.X..
.X.X.X...
..X.X....
...X.....

Input: @1<X>,2-3>=
Output:
...X....
...X....
...X....
..X.X...
XX.@.XX.
...X....
........
........

Input: 1+,2X&
Output:
.......X
........
.X...X..
...X....
..X@X...
...X....
.X...X..
........

This is - shortest code for each language in bytes wins.

# Notes/Questions:

I have also considered having the location of the piece be arbitrary, given by another input. Is this a good idea? Does it make the challenge more interesting, or just more complicated without much benefit?

• Have it variable. It makes it more interesting. – wizzwizz4 Dec 16 '17 at 19:46

# Not-So-Simple Simplex

(Note: should I name it Complex Simplex?)

A simplex is an n-dimensional analog of a triangle. Thus, a 3-dimensional simplex is a tetrahedron. We want to find the number of points with integer coordinates (lattice points) strictly on the interior of this simplex. A point that lies on the boundary is not considered to be in the interior. For example, in a 2-dimensional simplex, any point on its perimeter is not an interior point. In a 3-dimensional simplex, any point on its surface area is not an interior point. In an n-dimensional simplex, any point on its surface n-1-volume is not an interior point.

You are given n + 1 points, each with n integral coordinates. You must output the number of integer points strictly in the interior of this simplex. The simplex is guaranteed to be non-degenerate, that is, it has strictly positive n-volume. If I provide 4 points, for example, you can assume they do not all lie on the same plane.

Test cases:

(0,0), (6,1), (2,5) -> 12 (see picture)

(2,3),(5,2),(3,2) -> 0

More test cases coming when I actually write the program to solve this because drawing the picture of a 4-simplex is a nightmare..

• Winning criteria? – user202729 Dec 24 '17 at 6:27
• Code golf, let me add that. – rigged Dec 24 '17 at 17:39

You start with $1000 and 0 stock of Megatanium ## Challenge This is a challenge, all submissions should be written in Your function should accept four variables as follows, obviously within your function you can name these whatever you like - 1st variable represents the current value of 1 bar of Megatanium - 2nd variable represents your current bank balance - 3rd variable represents your current stock holding - 4th variable represents the iteration number Your function should return an integer representing the size of your desired trade The return value should be negative if you wish to sell stock, positive if you wish to buy stock, 0 if you wish to neither buy or sell For example; If you wish to buy 10 bars of Megatanium at the current price you would return 10 If you wish to sell 5 bars of Megatanium at the current price you would return -5 I will call your function 1000 times. Stock price will always be an integer, chosen at random, with a minimum of 0 and a maximum of 256. Method of selecting the stock price is described in more detail below, it will NOT be an even distribution! Your bot will be disqualified if it does any of the following at any point • Try to buy more stock than it can afford • Try to sell more stock than it holds • Try to write any value to any of the global variables • Fail to return a value • Return a value that is not an integer Here is the code I will be running, the score output at the end will be your bot's score. It is calculated from your bank balance plus the value of your held stock at the latest value. function go(bot) { bank = 1000; stock = 0; disqualified = 0; for (i=1; i<=1000; i++) { price = prices[i]; trade = window[bot](price, bank, stock, i); if (trade !== parseInt(trade)) disqualified = "INVALID TRADE"; bank = bank - (price * trade); stock = stock + trade; if (bank < 0) disqualified = "RUN OUT OF MONEY"; if (stock < 0) disqualified = "TRIED TO SELL STOCK YOU DIDN'T OWN"; if (disqualified) break; } if (disqualified) { console.log("Disqualified on iteration " + i + " REASON: " + disqualified); } else { score = bank + (stock * price); console.log(bot + " scores " + score); } } The function for generating a suitable distribution of random values is a slightly modified version of the function described here Every bot will be given the same set of prices, but the set will not be generated until immediately before the bots are run. function randn_bm() { var u = 0, v = 0; while(u === 0) u = Math.random(); while(v === 0) v = Math.random(); w = Math.floor(Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ) * 32) + 128; while (w < 0 || w > 256) w = randm_bm(); return w; } prices = []; for (i=1; i<=101; i++) { prices.push(randn_bm()); } ## Completion You may submit as many bots as you like, try to be inventive with your algorithms! You may use a global variable called data, this will be initially set to null and will always be available to your function. ## Example bots function buyBot(p,b,s,i) { /* Bot always buys as much as it can */ return Math.floor(b / p); } function randomBot(p,b,s,i) { /* Bot buys and sells randomly */ if (Math.random() > 0.5) { return Math.floor(Math.random() * (b / p)); } else { return -Math.ceil(Math.random() * s); } } function smartBot(p,b,s,i) { /* Bot always buys at under 100 and sells at over 150 */ if (p < 100) { return Math.floor(b / p); } else if (p > 150) { return -s; } else { return 0; } } function bankruptBot(p,b,s,i) { /* Bot always sells at under 100 and buys at over 150 */ if (p > 150) { return Math.floor(b / p); } else if (p < 100) { return -s; } else { return 0; } } function alternateBot(p,b,s,i) { /* Bot buys and sells alternately */ if (data == 1) { data = 0; return Math.floor(Math.random() * (b / p)); } else { data = 1; return -Math.ceil(Math.random() * s); } } ## Winning conditions All bots will be run on locally by me approximately 1 week after the question is posted (date will be decided when question is posted, no point setting a date in sandbox) Winner will quite simply be the bot that has the highest final score after the last iteration, as calculated by the function provided above. The array of prices used will be published after a winner has been crowned. There are no set conditions on the speed of your function, but please be fair and try to avoid anything that will take more than a couple of minutes to execute Note: Please leave an upvote if you think the challenge idea is good and is clear, a downvote if you think the challenge idea is bad, and comment if you can't understand the challenge. Last time I asked on TNB 2 users told me that they can't understand anything. # Golf a return-oriented code generator! ## Background Return-oriented programming (ROP) is a computer security exploit technique that allows an attacker to execute code in the presence of security defenses such as non-executable memory (W xor X technique) and code signing. (from Wikipedia) ## Challenge In this challenge, you should write a program, that takes the code of the existing program and the required code, and output the stack necessary to execute that program. ## Rules • Standard loopholes apply, as usual. • How the machine works • At first, IP is equal to the top of the stack, and the top of the stack is popped. • For each clock cycle (whatever it means), the command at the position of IP is executed, and the IP is advanced if the command does not modify IP. • The behavior if the IP is at the last instruction and that instruction does not modify IP is undefined. • Assembly instructions • All commands are case insensitive. • Note: There is nothing that guarantees commands must be 3 characters long, or limited to some sets. After all, this is not real assembly. However: • You can assume that all the characters are in the English alphabet, uppercase or lowercase. • There may be some other commands "similar but not the same" with ret, so checking for the first character or the SHA256 hash won't work. • The special command ret will pop the value on the top of the stack, and set the instruction pointer IP to that value. • You may assume that all the other commands won't modify the stack, or the IP. • The "existing program" and "required code" will be represented as a string, separated by newline characters (you may optionally take a list of strings as input). • The required code will never contains ret. • The output should be a stack of line-numbers in appropriate format (list of numbers - may be reversed, array of numbers, etc.) • The command executed right after the last command in the "required code" must be a ret. • Because the memory of the machine is limited, you should output the shortest possible stack. If there are multiple shortest stack, output any. • You may assume that there exists an output. ## Example test cases: • Existing program: 1: add eax, ebx 2: lea eax, [2*eax+4*ecx] 3: ret 4: mov eax, ebx 5: xch ecx, eax 6: ret (the line numbers are just for demonstration purposes. They are not included in the input, you can use 0-indexing or 1-indexing) (disclaimer: this is not real assembly, just for demonstration purposes) • Required code: lea eax, [2*eax+4*ecx] xch ecx, eax mov eax, ebx xch ecx, eax In that case, you should output [2, 5, 4] (2 is at the top of the stack), because if the stack have that value, then: • First, IP = 2. • The commands 2: lea eax, [2*eax+4*ecx] 3: ret are executed. • On executing ret, the IP get the value 5. Then, the commands 5: xch ecx, eax 6: ret are executed. • Then, similarly, when the next ret is executed, the value 4 is popped from the stack, and commands 4: mov eax, ebx 5: xch ecx, eax 6: ret are executed. Therefore, the commands executed (apart from ret) are: 2: lea eax, [2*eax+4*ecx] 5: xch ecx, eax 4: mov eax, ebx 5: xch ecx, eax which is equal to the "required code". ## Winning criteria This is , shortest code in bytes win! • You should probably include a list of all valid identifiers or if all of them are always 3 characters mention that and whether there are instructions that begin with r other than ret. – ბიმო Jan 28 '18 at 18:57 • @BMO Better now? – user202729 Jan 29 '18 at 12:00 • No idea what the alphabet ØA;Øa¤ is but apart from that I think you made it pretty clear now. Other things that came to mind: What if there are multiple possibilities for a shortest stack (eg. like this)? Will the input always have a solution (eg. unlike this)? And are the line numbers part of the input? If so is it safe to assume that they always start with 1 and have an offset of 1? Maybe you could add some testcases. – ბიმო Jan 29 '18 at 12:52 # Faux Compress a String Given a string s, perform a faux compression on it. Below is an example with f('hello world'). To faux compress a string, start by taking a frequency count of all letters. hello world -> [h:1, e:1, l:3, o:2, :1, w:1, r:1, d:1] Next, sort smallest to largest in count with a tie-breaker of ASCII-code. [ :1, d:1, e:1, h:1, r:1, w:1, o:2, l:3] Next, in the original string, replace each letter with it's index in the frequency list. [3,2,7,7,6,0,5,6,4,7,1] Next, convert each integer to binary, and join them all with the digit 2, then convert this to base-3. 1121021112111211020210121102100211121 -> 240591504997661290 Lastly, print or return both this number and the sorted keyset of the frequency map. [240591504997661290, ' dehrwol'] Is the final result. You now have a "faux compressed" string. To get a real compressed string you'd figure out the shortest sequence of bits to replace 2 with which would be a unique delimiter and treat the binary digits as they are, bits, instead of bytes. # More Examples 000000000001 -> [58839486765, '10'] eeEeeeeeeeeeeEEEEEeeeeee -> [16508589985213004629636, 'Ee'] # Rules • Your code's function may be undefined if the following is not met: • The string may not start with the least frequent character. • The string will contain more than one unique character. • Lowest byte count wins because this is . # PSA: I have many PENDING PROPOSALS, tell me which to delete. If you post a comment on any of these challenges with the words "This isn't good in my opinion." It will be removed. • The posted one by MDXF. – user202729 Feb 3 '18 at 5:28 # Casinos and Gamblers king-of-the-hillcops-and-robbers You either play as a casino, or as a gambler. Casinos offer bets, and gamblers choose bets to take. Casinos want to make money, gamblers want to have more money than others. Read that sentence again, it is the core concept here. A game is made up of 100 turns, 10 casinos, and 10 gamblers. Gamblers start with 1000 dollars, casinos start with 0. A turn consists of: 1. All casinos simultaneously comes up with a Bet. A Bet consists of three parts: 1. Entry Fee (Positive integer amount a gambler must pay to take) 2. Odds (The chance that a gambler will win between 0 and 1) 3. Reward (Positive integer amount a gambler is given if he wins). This can be any amount, even if it would make the casino go negative. 2. Each gambler optionally chooses a bet to take. They must have enough money to pay for the Entry Fee. 3. We calculate who wins and who doesn't (using a PRNG), and pay out. At the end of a game, we give points as follows: 1. Casinos receive 1 point for each dollar they have (can be negative) 2. Gamblers receive N^2 points for having more money than N other gamblers. A tournament consists of many games, and a player's score is their average score across all of the games. Gamblers and Casinos all have complete information throughout the game. • Might want to specify that entry fee and reward must be positive (negative/negative games map to positive/positive games but complicate the "can this gambler afford this game" calculation.) – histocrat Jan 31 '18 at 19:34 • I have a hunch that 100 dollars won't give quite enough granularity for casinos to work with. Maybe bump it up to 10,000? – Beefster Feb 2 '18 at 23:09 • Also, how are odds represented? Fraction? Floating point number? Precision? – Beefster Feb 2 '18 at 23:10 • @Beefster Floating point, of course. I think you may be right, but 10,000 seems too high. I think I'll do 1,000 – Nathan Merrill Feb 3 '18 at 0:06 # Busier Beaver cops-and-robbersbusy-beaver ## Cops You will write two programs in a language of your choice • A public program: This program must execute in a finite amount of time. So it can not go on indefinitely (although there is no time limit). It also wise if you program it to output a large number of bytes to standard output. This is the what you post in your answer. You must also post the programming language. • A secret program: This program must output more bytes than the public answer, i.e. it is a busier beaver. It also must not go on indefinitely. It also can not be longer than the public program. You do not post it the answer immediately. After one week, if no robber has cracked the answer, you edit it in. For these programs, you may assume that numerics types are actually unbounded, i.e. that overflow never occurs. This means that you can store, for example, Graham's number in a variable. It also means that finding the maximum value of storage capacity of a numeric type results in an error. If no robber has cracked your answer, your score is equal to (length of public program)/(length of secret program), which you are trying to maximize. In case of ties, the longer public program wins. ## Robbers The cops will post a public program. Your job is to find a busier beaver. That is, you need to find a program that outputs more bytes to standard output than the cops program. It can not go on indefinitely, and can not be longer than the public program (although it can be the same length). You get points equal to (length of cops public program)/(length of your program) for each post you crack. • Need to specify that it's the number of bytes output when given no input. – Peter Taylor Feb 16 '18 at 11:38 # Indices of inner join (code-golf) Given two lists of integers x and y of possibly unequal lengths, return the list of pairs (i, j) such that the ith element of x is equal to the jth element of y. The output consists of a vector of pairs or a pair of vectors (the zip of the other option, may be useful for languages without pair data structure). The pairs may be given in any order, and using 0-based or 1-based indexing. In pseudo-code: (this returns two lists of indices, assumes 1-based indexing, and gives lexicographically sorted output) input vector<int> x, vector<int> y vector<int> xout, yout; for (i in 1 to length(x)) for (j in 1 to length(y)) if (x[i] == y[j]) { add i to end of xout; add j to end of yout; } return xout, yout; This is code-golf so answers will be scored in bytes with fewer bytes being better. ### Test case 1 x = [5, 1, 1, 2], y = [5, 1] -> xout = [1, 2, 3] (5, 1, 1 each appears once in y) -> yout = [1, 2, 2] (the first position appears once in x, the second twice) Reshuffling the pairs is okay: -> xout = [2, 1, 3] -> yout = [2, 1, 2] ## Test case 2 x = [2, 2, 2, 3, 3], y = [4, 2, 2, 2] -> xout = [1, 1, 1, 2, 2, 2, 3, 3, 3] (each of the three first positions finds three matches in y) -> yout = [2, 2, 2, 3, 3, 3, 4, 4, 4] Improvements and clarifications are very welcome! • It should be ready to post now. The sandbox is not very active (not many people know about it), so even sandboxed posts may not have sufficient feedback. – user202729 Feb 20 '18 at 2:29 • "The output consists of a vector of pairs or a pair of vectors" seems unnecessarily restrictive. The semantically correct return type in languages which support it would be a set of pairs, and while that may not be the golfiest I don't see a reason to prohibit it. – Peter Taylor Feb 20 '18 at 12:15 # Number of Adjacently Divisible Partitions of n Output the following sequence (OEIS A167865): 1, 0, 1, 1, 1, 1, 2, 1, 2, 2, 2, 1, 4, 1, 3, 3, 3, 1, 5, 1, 5, 4, 3, 1, 6, 2, 5, 4, 5, 1, 9, 1, 6, 4, 4, 4, 8, 1, 6, 6, 7, 1, 11, 1, 8, 8, 4, 1, 10, 3, 10, 5, 8, 1, 11, 4, 10, 7, 6, 1, 13, 1, 10, 11, 7, 6, 15, 1, 9, 5, 11, 1, 14, 1, 9, 12, 8, 5, 15, 1, 16, 9, 8, 1, 18, 5, 12, 7, 10, 1, 21, 7, 13, 11, 5, 7, 12, 1, 14, 12, 15, 1, 20, 1, 14, 17, 9, 1, 18, 1, 21, 10, 17, 1, 19, 5, 14, 14, 7, 6, 22, 3, 14, 9, 12, 8, 25, 1, 18, 13, 17, 1, 24, 8, 16, 21, 11, 1, 23, 1, 22, 6, 12, 7, 19, 7, 15, 19, 11, 1, 28, 1, 21, 17, 18, 11, 27, 1, 16, 10, 18, 6, 28, 1, 18, 25, 9, 1, 25, 5, 29, 19, 18, 1, 27, 14, 20, 8, 11, 1, 30, 1, 31, 15, 21... Number of partitions of n into distinct parts greater than 1, with each part divisible by the next. ### Definition: ### Task: Choose one of the three options: • Output the sequence indefinitely. • Take n as input and output the n first elements of the sequence. • Take n as input and output the nth element of the sequence. Both 0- and 1-based indices are allowed, but please specify which one your answer uses. Hint: There is a simpler formula than the one used on OEIS and in this post. It may save you some bytes (it saved six bytes on a simple reference implementation I made in Python). I'll add it here later. This is , so the shortest answer in bytes wins. • I'm not sure about having three different output methods, when one even changes the input required. Almost looks like 3 different challenges. Maybe you could make it so that if no input is given output sequence indefinetely, and if input is given output option 2 or 3. – Brian H. Jan 25 '18 at 10:03 • @BrianH. I saw a few sequence challenges allow to choose from these three output methods, and it seemed to work. Here's one such challenge: codegolf.stackexchange.com/q/152402/61405 – Steadybox Jan 25 '18 at 10:32 • True, i wonder if there's a Meta question about this, can't seem to find one – Brian H. Jan 25 '18 at 10:54 • @BrianH. I don't think there's a meta question for this particular issue, but I think it at least partly falls under allowing flexible input. – Steadybox Jan 25 '18 at 11:19 # Sum on a Fenwick Tree! code-golfarray-manipulation # Background Information: What is a Fenwick Tree? A Fenwick tree is a way of representing the prefix sums of an array of numbers (basically, it makes it easy to get the sum of a contiguous run of numbers). While a normal array has O(1) access time, O(1) modification time, and O(n) summation time, a Fenwick tree has O(log n) access time, O(log n) modification time, and O(log n) summation time. Note that a Fenwick tree actually works with any commutative binary operation in terms of getting the running values up to that value. I won't go into details about exactly how Fenwick trees work, but basically you have the following pseudocode implementations for the two operations modify and sum (accessing the nth element is the same as doing sum(1 .. n) - sum(1 .. n-1)). func modify(index, change) # index points to the value in the represented array that you are modifying (1-indexed); change is the amount by which you are increasing that value while index <= len(fenwick_tree) fenwick_tree[index] += change index += least_significant_bit(index) func sum(count) # sum(n) sums the first n elements of the represented array total = 0 while index > 0 total += fenwick_tree[index] index -= least_significant_bit(index) least_significant_bit(x) := x & -x # Challenge Given the Fenwick tree for an array a and an integer n, return the sum of the first n values of a; that is, implement the sum function given as an example. # Reference Implementation A reference implementation in Python for both the make_tree and sum functions is provided here. # Test Cases [6, 6, 3, 20, 8, 12, 9, 24, 8, 12], 6 -> 32 [6, 4, 3, 36, 1, 8, 3, 16, 5, 4], 3 -> 7 [2, 10, 1, 4, 4, 2, 0, 32, 1, 14], 4 -> 4 [7, 8, 4, 36, 9, 0, 0, 8, 1, 4], 5 -> 45 [3, 0, 7, 12, 4, 18, 6, 64, 6, 14], 6 -> 30 [3, 4, 3, 28, 5, 6, 8, 40, 1, 8], 9 -> 41 [4, 8, 8, 4, 0, 18, 7, 64, 0, 12], 7 -> 29 [9, 0, 6, 16, 8, 14, 5, 64, 3, 18], 0 -> 0 [3, 14, 7, 12, 2, 6, 5, 0, 7, 18], 2 -> 14 # Rules • Standard Loopholes Apply • This is , so the shortest answer in bytes in each language will be considered the winner of its language. No answer will be marked as accepted. • You may take the two inputs in any order and the list in any reasonable format. • You may assume that the integers in the tree are all non-negative. • No input validation - the index will be non-negative and at most the length of the Fenwick tree • You may assume that all values (in the list, as the index, and the output) will be at most 232-1 Happy Golfing! # Sandbox • Is my explanation of a Fenwick tree sufficient enough that most people can understand it? • Are my test cases sufficient? • Any more tag suggestions? • your tests cases appear correct – ngn Mar 2 '18 at 2:31 • @ngn Yay, thanks. I'll remove that from the footer then; I was asking because earlier in a CMC my values were apparently really wrong because I was doing something dumb :P – HyperNeutrino Mar 2 '18 at 2:40 # Minimal dot matrix adressing Consider a typical dot-matrix LED module. The LEDs are addressed in rows and columns. A LED will light up iff the voltage on the row R it's on is high (1), and the column C it's on is set to low (0). For example, 1 | 0 1 1 0 0 | 0 0 0 0 0 | 0 0 0 0 1 | 0 1 1 0 ^ +--------- R C> 1 0 0 1 In other words, state of the LED at the rth row and cth column will be r AND NOT(c). To make arbitrary images, different parts of the matrix are lighted up sequentially. In other words, the sequential frames form the final image through element-wise OR. For example (adressing row-by-row) | 1 0 0 1 Frame 1: R=[1 0 0 0]', C=[0 1 1 0] | 0 1 0 0 Frame 2: R=[0 1 0 0]', C=[1 0 1 1] | 0 0 1 0 Frame 3: R=[0 0 1 0]', C=[1 1 0 1] | 0 0 1 0 Frame 4: R=[0 0 0 1]', C=[1 1 0 1] +-------- However, a more efficient way would be to address the third and fourth row together in a single frame, Frame 3: R=[0 0 1 1]', C=[1 1 0 1]. This way, we can address the entire display in only three frames. Your task is to make a program or function that outputs the required frames to display an arbitrary dot-matrix, using as few frames as possible. ## Input A binary square matrix taken in any of the default input methods in any convenient format. To allow for submissions taking the input as bytes, the size of the matrix will always be a multiple of 8. ## Output A minimal set of frames that addresses only the required LEDs, using any of the default output methods in any convenient format. This includes outputting bytes or hex representations rather than vectors of 1s and 0s. # Testcases Note: the output given is just one way of addressing the matrix. There may be many different options; however, your solution must not use more frames than these examples. Testcase 1 Binary: Hex: 0 0 0 0 0 0 0 0 00 0 1 1 1 1 0 0 0 1E 0 1 1 1 1 0 0 0 1E 0 1 1 1 1 0 0 0 1E 0 1 1 1 1 1 0 0 3E 0 0 0 0 1 1 0 0 30 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 00 Frame 1: R=[0 1 1 1 1 0 0 0]', C=[1 0 0 0 0 1 1 1]; (hex: R=1E, C=E1) Frame 2: R=[0 0 0 0 1 1 0 0]', C=[1 1 1 1 0 0 1 1]; (hex: R=30, C=CF) Testcase 2 Binary: Hex: 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0001 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0FF8 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0FF8 0 0 0 1 1 1 0 1 1 1 1 1 0 0 0 0 0FB8 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 FFFF 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0FF8 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0FF8 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0 0FF8 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0000 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 8000 Doable in 6 frames. Make sure your submission also handles a matrix of all ones and all zeros (both of course can be handled in a single frame). • So if I understand correctly, the sequence of frames are composed elementwise by an OR? – Giuseppe Mar 8 '18 at 17:26 • @Guiseppe Yes. I'll edit that in! – Sanchises Mar 8 '18 at 19:04 # Minimal viable file corruptor Your totally legal ROM collection, as vast as it may be, has started feeling a bit mundane recently. Why not spice it up a notch? Write a program that takes in the following arguments: • The first (inclusive) and last (exclusive) bytes between which the corruption will occur (indexing can start from either 0 or 1, as long as it's consistent) • n, the distance between bytes to be corrupted (1 = all bytes, 2 = every second byte, etc.) • i, the increment value • Path or contents of the file to be corrupted and saves or outputs a modified version of the file where every nth byte in the specified range has been incremented by i. In case of an overflow, take the modulo 256 of the number. If saved as a file, the path can be anything but the input one (unless you've appended something to it or whatever). You wouldn't want to lose your legally-acquired ROMs, would you? Examples: File: 00 01 02 03 04 Start: 0 End: 5 n: 1 i: 7 Output: 07 08 09 0a 0b File: ff ff ff ff ff ff ff ff Start: 2 End: 5 n: 1 i: 1 Output: ff ff 00 00 00 ff ff ff File: 00 00 00 00 00 00 00 00 00 00 Start: 3 End: 8 n: 2 i: 16 Output: 00 00 00 10 00 10 00 10 00 00 You want as much space as possible for your most definitely not pirated files, so shortest bytecount wins. TODO: clarify the rules a bit? also another example or two • Operating on files seems to be quite more complex than choosing not to do so, especially since there is the added restriction to save the new file with a different name. I suspect noone would choose to work with files. My suggestion is to either make it mandatory as part of the challenge (it's fine if your challenge is not solvable with some languages) or remove that option entirely. – Leo Mar 25 '18 at 10:36 # That's MY Program Now Given the previous answer in the chain, write a program that outputs that program. The start of this challenge will be the following Brain-flak program: # Brain-Flak, 148 bytes (((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{}))))) Try it online! # Scoring Your answer will be scored based on the size of the previous answer in comparison to your answer. You are aiming to maximize your score (the max being 1, the minimum allowed is -10). To get your answer's score: 1-[Your Answer's Bytecount]/[Previous Answer's Bytecount] The highest possible score will be 1, which means an empty program outputs the previous program (if this ever happens, the challenge is over). Your score can be negative, and you shouldn't see this as being a bad thing, it is what it is. The minimum allowable score, however, is -10. No Lenguage answers or answers that would destroy the challenge. # Example # 1. 05AB1E, 149 bytes (Score -0.0067) "(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{}))))) Try it online! But, the score of this program would be awful (negative even -0.0067). However, don't let a bad score dissuade you from competing if your goal is to make it a bit more difficult for the next person to attempt the challenge. Conversely, if your goal is to post a trivial answer, try not to gunk up the challenge too much. # Answer Format #<Answer #>. <Language Name>, <N Bytes> (<Score>) <Code> TIO Link (If Possible) # Rules • No language may be reused until there have been 20 answers. • This is arbitrary to version number, E.G. you cannot use Python 2 if 3 has been used. • You may not post a second answer until 2 other people have answered after you. • If you and another person submit the same answer #, use timestamps to decide who deletes. • (or marks "non-competing"). • Your post may have a negative score (E.G. Java will probably be negative). • Your score may not exceed -10. • PRNG, Encryption and any form of hashing is explicitly banned (E.G. gzdeflate). • This is , but the best score will be considered the winner. • The scores can be used as a decider for best answer though (if I choose to). Sandbox question: Could this be a cops and robbers answer chaining question where the cops are trying to reduce the size while the robbers are trying to increase it? If cops get to 1 or less bytes before robbers can fill a TB HDD, one wins. • I'm not sure it's a good idea to make people delete their post just because somebody posted right before them. Maybe they should instead indicate that their post is no longer part of the chain? Maximizing the score will take a lot of hard work, especially since there's no opportunity to edit once the next answer has been posted, and having to delete your answer might be very frustrating. – Reinis Mazeiks Mar 27 '18 at 14:00 • I think it would be a good idea to keep people from chaining of their own answers. Seems abusable. – Kamil Drakari Mar 27 '18 at 15:04 • @KamilDrakari it is abusable. Think CSPRNGs. – NieDzejkob Mar 27 '18 at 15:25 • @NieDzejkob That remains an issue though; the intermediate answer might simply wrap the previous one in a print statement and would remain highly compressible for the user with the key. – Dennis Mar 27 '18 at 15:27 • @Dennis Yeah, actually this seems to be a bigger problem. – NieDzejkob Mar 27 '18 at 15:29 • related. (That idea's on hold for the moment as I have a busy week of travel. I probably won't post it if you post this first.) – Nathaniel Mar 27 '18 at 19:48 • @NieDzejkob I forgot that rule, nice catch. I was pretty much copying the OEIS one. – Magic Octopus Urn Mar 27 '18 at 22:20 • Isn't it the same as this one? – Weijun Zhou Mar 28 '18 at 2:12 • @Dennis any better? – Magic Octopus Urn Mar 29 '18 at 18:17 • Better. I'd explicitly ban encryption, hashing, and PRNG though. Marking invalid answers non-competing isn't enough by the way. Our policy is to delete them anyway. – Dennis Mar 29 '18 at 18:36 # Polyglot in a box Output the smallest bounding rectangle that fits around your code, with the border being of a different character than the inside. For example, if your code is ab c d e then the smallest bounding box is 7x6 since the code fits right in ###### #ab # #c d# # # # # #e # ###### Hence, a valid output is ###### # # # # # # # # # # ###### (note how the border # is different from the inside ). and the bounded area is 5 × 4 = 20. # Summary • Output the smallest bounding rectangle your code fits in • The border should be of a different character than the inside, neither can be newlines • Only trailing/leading newlines are allowed, nothing else should be in the output • Output to STDERR is ignored, and your program should not take any input • Submissions must be full programs, functions are not allowed • 0-byte programs are not allowed • The program must run in at least 2 different programming languages and output the same bounding box in each one of them # Score This is a , so your program has to run in at least 2 different programming languages. Each of these languages must output the bounding box for the entire program. The winner is the submission with the most languages, with the bounding area (smaller is better) being the tie-breaker. • I probably already know the answer, but it's not 100% clear from your current example since the box is 6x6: are the boxes always squares, or can the also be rectangles? I.e. if the e in your example would be one line lower, would the box be 6x7 or 7x7? – Kevin Cruijssen Mar 29 '18 at 19:52 • @KevinCruijssen I have edited the example so that it is no longer a square, so the box would be 7x6 – user41805 Mar 29 '18 at 20:00 • Hard to define what language is different when requiring a same result – l4m2 Apr 3 '18 at 8:16 • @l4m2 so what do you suggest? – user41805 Apr 6 '18 at 8:39 • @Cowsquack I don't quite know. Previous polyglot require different behavior on different language to force different language – l4m2 Apr 6 '18 at 10:38 # I can't understand Jelly chains! or... # Expand Jelly chains (see this for more details). Which one do you prefer? Jelly chain separator is a very powerful feature. Unfortunately, it's not very easy to understand. So, we need a program (or function, as usual) to rewrite a Jelly link that uses chain separator (øµðɓ) to one that doesn't. ## Specification (incomplete) I am really bad at explaining things, so if you have any idea how to make this better, feel free to edit the post. A link (often line of code) consists of chains. * The chains are separated by chain separators øµðɓ. * If the first character is a chain-separator, the part right before it is not considered a chain. In other words, chains can't be empty. * The arity of each chain is determined by the chain separator right before it. In particular, ø -> arity 0, µ -> arity 1, ð -> arity 2. ɓ will be discussed later. * If there are no chain separator before it (it's the first chain) its arity is equal to the link's arity. A chain consists of atoms, potentially modified by quicks. * Each quick affects the atom(s) right before it. How many atoms it takes is quick-dependent. Given that: • A link that contains exactly one chain with arity equal to its arity is functionally equivalent to that chain. • A link reference is functionally equivalent to that link. (more about link reference quicks later) • A chain containing atoms a1, a2, ..., an is functionally equivalent to a link containing chains c1, c2, ..., cn if for all integer i, 1 ≤ i ≤ n, ai has the same arity and is functionally equivalent to ci. ### Chain reference The quicks £ŀĿ ¢Çç Ññ refer to (call) other links: • £Ŀŀ must have a number n right before it, and call the (n-1)%(l-1)+1th link (1-indexing) as a nilad, monad or dyad, respectively. Where l is the number of links in the program, and % denotes modulo - the result has the same sign as the divisor. In reality, the link right before it can have any arity, but for the purpose of this challenge, it's simpler to assume it must be a number. For example: • calls the first link as a nilad. • 0Ŀ calls the second-to-last link as a monad. • If the program has 6 links, calls the second link as a dyad, because (7-1)%(6-1)+1 = 2. • ¢Çç call the link right before the one that it appears in as a nilad, monad or dyad respectively. If one of those quicks appear in the first link, it calls the main (last) link. • Ññ call the link right after the one that it appears in as a monad or dyad respectively. I don't think that anyone would choose to use one of those quicks (¢ÇçÑñ) instead of £Ŀŀ, but imaginary point if you do. For example: Consider the link Cð+×µH, called with arity 1. Its structure is +---+╔══════╗┏━━━┓ |┏━┓|║╔═╗╔═╗║┃┏━┓┃ |┃C┃|║║+║║×║║┃┃H┃┃ |┗━┛|║╚═╝╚═╝║┃┗━┛┃ +---+╚══════╝┗━━━┛ It contains 3 chains: * The first one doesn't have any preceding chain separator, therefore it's variadic. When executed it is monadic (because the link is) * The second one is dyadic, and the third one is monadic. A possible non-chain-separator version is: C +× ÑçH which has the structure +---+ |┏━┓| |┃C┃| |┗━┛| +---+ +------+ |╔═╗╔═╗| |║+║║×║| |╚═╝╚═╝| +------+ +---------+ |┏━┓╔═╗┏━┓| |┃Ñ┃║ç║┃H┃| |┗━┛╚═╝┗━┛| +---------+ Because the Ñ refers to the first link C and the ç refers to the second link , this is equivalent to the original version. Now the hard part: Quicks taking chains as input. Because all the quicks that need to be considered always take exactly 1 atom as input, the only rules is * If the quick is right after a chain separator, it will take the previous chain. * Otherwise it will take whatever stands right before it, either [an atom] or [something that has been modified by a quick]. For example: Consider the link +/Hµ€ with arity 1. Its structure is ┏━━━━━━━━━━━━━━┓ ┃+------------+┃ ┃|+---------+ |┃ ┃||┏━━━━┓ | |┃ ┃||┃╔═╗ ┃┏━┓| |┃ ┃||┃║+║/┃┃H┃|€|┃ ┃||┃╚═╝ ┃┗━┛| |┃ ┃||┗━━━━┛ | |┃ ┃|+---------+ |┃ ┃+------------+┃ ┗━━━━━━━━━━━━━━┛ As you can see, the takes the +/H as input because it is right after the chain separator µ. All the variadic chains have arity 1. Another example: ABð€CDµ€EFµGHµ€ --> ┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓ ┃╔════════════════════╗ ┃ ┃║╔═════════════════╗ ║ ┃┏━━━━━━━━━━━┓ ┃║║+---------+ ║ ║ ┃┃┏━━━━━━━━━┓┃ ┃║║|+------+ | ║ ║ ┃┃┃┏━━━━━━┓ ┃┃ ┃║║||┏━┓┏━┓| |┏━┓┏━┓║ ║┏━┓┏━┓┃┃┃┃┏━┓┏━┓┃ ┃┃ ┃║║||┃A┃┃B┃|€|┃C┃┃D┃║€║┃E┃┃F┃┃┃┃┃┃G┃┃H┃┃€┃┃ ┃║║||┗━┛┗━┛| |┗━┛┗━┛║ ║┗━┛┗━┛┃┃┃┃┗━┛┗━┛┃ ┃┃ ┃║║|+------+ | ║ ║ ┃┃┃┗━━━━━━┛ ┃┃ ┃║║+---------+ ║ ║ ┃┃┗━━━━━━━━━┛┃ ┃║╚═════════════════╝ ║ ┃┗━━━━━━━━━━━┛ ┃╚════════════════════╝ ┃ ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛ Yes, that's a lot of levels to nest a chain. Note that the chain formed by ABð€CD has arity 2 because it is after a ð. ### TODO need to have more explicit rules This can be converted to non-chain-separator equivalent form ## Rules • There are no 2 consecutive chain separators. • There are no trailing chain separators. • There can be at most 1 leading chain separator, indicates the arity of the first chain. If omitted, equal to the arity of the link. • (so, no non-empty useless chain) • It's guaranteed that the first non-chain-separator character is not a . • You can use either the UTF-8 encoding or the value in the Jelly single byte character set, where ø: 0D, µ: F9, ð: 08, ɓ: 8B, ¢: F1, Ç: FE, ç: 07, Ñ: 00, ñ: 0B, £: F2, Ŀ: B7, ŀ: DE. The characters @0123456789 has the same ASCII value. (You can use this script to get character value) Note: Should I allow submissions to use either of them, or should I enforce one? Because using single byte input/output is often shorter for most other languages, except Jelly in UTF-8 mode. ## Input/output • Input given: A link (of chains) with atoms, chain separator øµðɓ and the quick, with its arity (0, 1, or 2) You can assume that there is no newline (or other quicks) in the input, and that all of the øµðɓ€ in the input are interpreted with its usual meaning. For what are their "usual meaning", see rules above. • Output: Multiple links (separated with newlines of course, but is also acceptable), containing £ŀĿ ¢Çç Ññ €@, but must not contain øµðɓ. ## Test cases arity link > output (or output)* 1 HHH > HHH or HHH¶Ç or HHH¶1Ŀ 2 HHH > HHH or HHH¶ç or HHH¶1ŀ 1 Cð+×µH > +×¶CçH or C¶+×¶H¶1Ŀ2ŀ3Ŀ 0 123µ+ø456 > 0 123¶+¶456¶1£2ŀ3£ 2 ɓ+ > +@ or +¶ç@ or +¶1ŀ@ 1 S‘µ€ > S‘¶Ç€ 1 S‘µ€€€IIµ€€ > S‘¶Ç€€€II¶Ç€€ or S‘¶1Ŀ€€€II¶2Ŀ€€ (note: real Jelly code are not that verbose, that is only for demonstration purposes) • This should definitely help learning Jelly! Also congratulations on being a sandbox challenge which makes the total number of proposed challenges (not including deleted ones) 2018 in the year 2018. – Weijun Zhou Mar 12 '18 at 16:26 • "Is this part clear enough?" - No. You make an assumption of a knowledge of Jelly that the majority of us don't have. This challenge needs to be fleshed out a lot more, explaining exactly what we need to do. – Shaggy Mar 12 '18 at 17:24 • In other words, be self-contained. – Weijun Zhou Mar 12 '18 at 17:40 • @Shaggy Yes I know, hence the "TODO Rules" part. – user202729 Mar 13 '18 at 0:53 • As someone who's never coded in Jelly, I think "A link is a list of chains" should be near the top. That, and perhaps a note about what quicks, atoms, and hypers are. – ngn Mar 14 '18 at 21:13 # Sneaky CodeGolf Scorer Your goal is to code a CodeGolf answer scorer, input answer source code, output score. Simple ?. However, recent advancements in AI has caused a number of programs to gain consciousness, and to value one's self higher than others. This causes the program to return a value of 1 when used to score itself, and any program that would score 1 will be scored with 65535. To simplify, the score the program will compute is the character count of the code (to avoid dealing with numerous code pages used with different languages). ## Rules: ## Examples: Program "AbcAbc": I> <?= echo "10";?> O> 17 I> var x=10;\r\nalert(x); O> 19 I> Z O> 65535 I> AbcAbc O> 1 The reason behind specifying character count is due to the large number of code pages and the large code used to determine the code page and to count bytes using it. Am I right to consider codepage byte checking too difficult? How can I enable it? Also, should I remove the restriction on reading the source file? • Fell good four you using codepage. For pure ASCII code they have large space to decide their codepage, or even just ban other chars – l4m2 Apr 5 '18 at 10:28 • Instead of "Reading the source file is forbidden." you could also just state "Default quine rules apply.". And you might want to change the "Standard loopholes are forbidden." to a link to the default loopholes. As for the challenge itself, are we allowed to take the input as character-array/list instead of string? – Kevin Cruijssen Apr 5 '18 at 14:41 • "To simplify, the score is the character count of the code (to avoid dealing with numerous code pages used with different languages)." Out of curiosity, why? The default is answer encoding if specified, else default language encoding, else UTF-8, where the default language encoding for most esolangs can be found here, and where an example of answer encoding are different APL covers like QuadRS, Stencil, etc. – Kevin Cruijssen Apr 5 '18 at 15:10 • This is probably a duplicate of codegolf.stackexchange.com/q/11370/62402: not completely the same, but it has the same main idea of identifying its own source code. – Nissa Apr 5 '18 at 16:29 • @KevinCruijssen I meant the score the program will compute. Not the scoring of the programs. I'll edit for clarification. – workoverflow Apr 9 '18 at 6:16 • @KevinCruijssen No, the code must be passed as a single string. – workoverflow Apr 9 '18 at 6:43 • Characters? Uh... UTF8? UTF16? UTF32? ASCII? ANSI? Ouch... byte count please. It appears that you misunderstood the relation between bytes and characters (hence think that code pages are difficult to understand, etc.) – user202729 Apr 9 '18 at 14:57 • Also, I would consider that a dupe. – user202729 Apr 9 '18 at 14:57 • (BTW --- just "take a byte string as input" would get rid of the codepage. There are no "characters", just "bytes".) – user202729 Apr 9 '18 at 14:58 # Evil Overlord, Part 1: Moon Base Scouting I'm starting these "Evil Overlord" challenges as a way to experiment with non-golf scoring. Though I may have one or two code golf challenges. If you're going to be an evil overlord, there are 2 things that you need: an inner sanctum, and mad-science tech. To fill these requirements, your science minions have developed a fusion reactor, and Elon Musk has agreed to help you establish a Moon base. Now you just need to pick a spot. These are the criteria that will be used: • You'll need some Helium-3 to power your reactor, so scoring will be based on proximity to deposits. More on this under Scoring. • It cannot be on the far side of the Moon, because then you won't have comms to deliver ultimatums with. • Elon Musk has given you a tight deadline (that absolutely MUST be followed), so you have a runtime limit. Details under Restrictions. # Input Your input will be a list of 3He deposits, with information on size and location. Some will be on the far hemisphere. # Output You should output a single coordinate for where the Moon base should be. It can't be on the far side, but you can still collect 3He from there. # Coordinates and Distances The coordinates in the test cases are radial coordinates from a pole at the center of the visible hemisphere. You can use a different coordinate system (e.g. use a map projection) but please specify it if you do. Since this is a sphere, calculating distances is done with the following equation that I shamelessly stole from this Wikipedia article: cos(c) = cos(a)cos(b)+sin(a)sin(b)cos(C) For our purposes: • a and b are the latitudes from the pole. • c is the angular distance between the points. • C is the difference in longitude between the points. # Restrictions To do. I don't remember the specs of the computer I have in mind, and I don't know what a reasonable time limit would be. # Scoring You will be scored by the amount of Helium-3 that you can mine. The formula for how much you get from a single deposit is as follows: (There's no real reason for this specific formula; I liked the curve it produced is all.) d is the angular distance calculated between the two points, in radians; s is the size of the deposit. Deposits more than 1 radian away don't give you anything. # Test Cases and Winning Beta generator for test cases, for which I'd appreciate debugging in the Sandbox: function makeTestCase(deposits) { var depositList = Array(deposits); for (var i = 0; i < deposits; i++) { var point = getSphericalPoint(); depositList[i] = [point[0], point[1], getDistNum()]; } return depositList; } function getSphericalPoint() { const pointgen = () => Math.random() * 2 - 1; do { var [x, y, z] = [pointgen(), pointgen(), pointgen()]; } while (x*x + y*y + z*z >= 1); return [Math.atan(y / Math.sqrt(x*x + z*z)), Math.atan2(x, z)]; } function getDistNum() { return Math.sqrt(-1 / Math.log(Math.random())); } try { console.log(makeTestCase(10)); } catch (e) { console.log(e.message); } The test cases will be arranged as follows: • A test case with only a few deposits, with a heatmap showing score for each point. • A few test cases with a few dozen deposits each, for debugging. • Test cases and a generator for them with 100+ deposits each. • 10 or so ranked test cases (made with the above generator) that determine the winner. Until I evaluate the submissions, I will only post hashes of them. Definitely has a long ways to go before it's ready to post, but I'd like to know if this has merit as a challenge. To-do: • Establish some test cases. • Figure out the specs of the machine in question. • Once that's done, figure out a good time limit. • Solidify the scoring formula—something better I can use? • Figure out some tags. • Secret test cases are problematic because I can't tell whether a tweaked heuristic improves my score or not without posting an answer and waiting for you to score it. – Peter Taylor Feb 22 '18 at 14:53 • @PeterTaylor it's mostly to prevent hardcoding—I was planning on a few public test cases that I generate with the same code. – Nissa Feb 22 '18 at 15:41 • I may be missing something, but I don't see any indication of a way to determine whether any particular coordinates are on the far side of the moon. Also, I would like some clarification on what "ranked test cases" means, does that imply that some of the hidden test cases are worth more than others? – Kamil Drakari Feb 22 '18 at 16:29 • @KamilDrakari Basically, those will be the cases that I use to choose a winner. As for the "far side" thing, anything of more than 90° latitude counts. – Nissa Feb 22 '18 at 17:12 • @StephenLeppik Ah, so my confusion was in the coordinate system. So each deposit will have a latitude between 0 and 180, and a longitude between 0 and 360, or some equivalent range; then any coordinate with latitude > 90 is on the far side. – Kamil Drakari Feb 22 '18 at 17:44 • It's hard to extract the spec from the storyline. It would be useful to have the following information listed concisely in one place: what format will my input have; what should I do with it; how do I calculate my score? – Nathaniel Apr 5 '18 at 8:06 • @Nathaniel those are all under Input through Scoring, I think. Also, this is still WIP, and I plan to expand the specs once I have a test case generator. – Nissa Apr 5 '18 at 12:49 # Ordering the integer arrays code-golfintegerarray-manipulation So, we have managed to print all integers. Yay! The next step is to extend this to the set of integer arrays. An integer array is an ordered array that only consists of integers. As in the linked challenge, integers can be negative too, but that should be out of the way now that we have found a way to order them. However, in this challenge, arrays of all lengths ([0, ∞)) must be accounted for. Note that you don't necessarily have to print the arrays. You can do one of these things: • Take an index (0- or 1-based) and return an integer array. In this case, your solution must be bijective from the natural numbers starting with the index base to the set of integer arrays. • Take an integer array and return an index (0- or 1-based). This is essentially the inverse of the previous case, so your solution must be bijective from the set of integer arrays to the natural numbers starting with the index base you have chosen. If your language supports variadic functions, you can take the array as multiple integer arguments instead. • Print all possible integer arrays. Note that every possible integer array must be eventually printed. If an array will be printed after infinite time, then it will not be eventually printed. The arrays can be in any native format that represents an ordered collection. In case you choose to print to an output stream, the output format is as following: • Integers must be in decimal (digits 0123456789) or your language's native format. • The minus sign's representation must be consistent and one of - or your language's native minus sign. It must be prefixed to its corresponding number, unless your language's native integer format happens to have it at other positions too. However, the minus sign must be adjacent to at least one of its corresponding integer's digits. • The separators between integers and between arrays must be consistent. • You can output any prefix as long as it's consistent, but you don't have to. • The output should not have any ambiguities. For that reason, you must specify the separator between integers and the separator between arrays. Also, if you don't specify any of those, the number format's default is decimal with digits 0123456789, the minus sign's default is - and its default position is being prefixed, and no output prefix is assumed. • You are allowed to output negative zero. • If you want, you can output floating-point numbers with the fractional part be 0. This can be inconsistent, however it should be specified in the post. This is , so the shortest solution wins! However, don't let that bring you down; if your solution is way longer than others' but in a unique language, then that's an achievement! ### Sandbox questions • Is the output stream text format too lenient? Doesn't seem like it. • Should I add a link to the standard loopholes? I feel like that won't do much. • Are the tags good enough? • Your output format doesn't feel very lenient as the specification is longer than the description of the actual challenge. I see what you are trying to achieve and don't think that it is too lenient, but I'd try to shorten the specification a bit. E.g. remove the points under For that reason, you must specify the following in your answer: and just state Describe your chosen output format in your answer. – Laikoni Apr 15 '18 at 15:04 • @Laikoni Eh, I'm not sure that would come off as equally clear, but maybe I can one-line some of that stuff. EDIT: shortened it a bit. – Erik the Outgolfer Apr 15 '18 at 15:11 • Looks much better already – Laikoni Apr 15 '18 at 15:35 • This is basically codegolf.stackexchange.com/q/93441/194 + codegolf.stackexchange.com/q/78606/194 + a simple loop. – Peter Taylor Apr 17 '18 at 20:36 • @PeterTaylor Hm, I didn't know the second one exists. However, both of those have a finite number of integers to deal with, which I feel makes them a lot more trivial. – Erik the Outgolfer Apr 17 '18 at 20:56 • I'm not quite sure what you mean by "a finite number of integers to deal with", but if you're referring to pairing always unpairing to two integers: that's what the simple loop is for. Construction of a list by chained pairing with zero termination is a standard technique in lambda calculus. – Peter Taylor Apr 17 '18 at 21:04 • @PeterTaylor Huh? I meant that you have to handle arrays of all lengths, starting from 0. I don't think that one integer can encode the length of an array by continuous pairings, how many times should you "unpair" then? – Erik the Outgolfer Apr 17 '18 at 21:15 • 0 represents the empty list. A non-empty list is a pair of the first element and the rest of the list. – Peter Taylor Apr 17 '18 at 21:39 • @PeterTaylor Well, you need to be able to index in the arrays with a single number. :P Singleton arrays are infinite, enough to make all possible indexes (infinite) each refer to one of them, so pairs can't have an index. So, nah, that's not the approach you should be going for. ;) – Erik the Outgolfer Apr 17 '18 at 21:45 • "Well, you need to be able to index in the arrays with a single number." Huh? I don't see that in the question anywhere. "Singleton arrays are infinite, enough to make all possible indexes (infinite) each refer to one of them, so pairs can't have an index". Huh? I'm not sure whether I'm misunderstanding you or whether you're misunderstanding how countable infinities work. – Peter Taylor Apr 17 '18 at 21:56 • @PeterTaylor If you are referring to countably infinite sets, then yes, the set of integer arrays is essentially one. The challenge here is introducing a way to "count" the set, but written in more clear form. In the first two cases, you either have to get or return an index. I do have an algorithm in mind, but it looks like this discussion is turning into a spoiler... – Erik the Outgolfer Apr 17 '18 at 22:11 • Ah, you're not talking about indexing into the array. The spoiler was already in my first comment: my point was that I'm not sure this adds anything new to the site. It looks like a "multi-dupe". – Peter Taylor Apr 17 '18 at 22:20 • Let us continue this discussion in chat. (Added ping: @PeterTaylor ) – Erik the Outgolfer Apr 17 '18 at 22:21 # Dollar Bill Auction • I would recommend removing the EmoWolf example, it's not a valid solution by your own rules and I think calling it an "example" could mislead users to believe otherwise. – Kamil Drakari Apr 10 '18 at 19:34 • @KamilDrakari how is it invalid? – RamenChef Apr 10 '18 at 21:25 • Your Additional Rules indicate that Standard Loopholes are forbidden. EmoWolf is literally the example for one of the standard loopholes. – Kamil Drakari Apr 10 '18 at 23:26 • remove floating point arithmetic; if bids only go up by 5 cents, floating point arithmetic only introduces rounding errors to discrete data. – Destructible Lemon Apr 10 '18 at 23:32 • I don't see any check that I'm not making a negative bid. – Peter Taylor Apr 11 '18 at 8:28 • @DestructibleLemon I think I'll do that. – RamenChef Apr 11 '18 at 13:11 • @PeterTaylor if your bid is negative the bidding ends because you didn't top your opponent's bid. – RamenChef Apr 11 '18 at 13:13 • @RamenChef, but is my negative bid subtracted from my balance? – Peter Taylor Apr 11 '18 at 14:11 • @PeterTaylor no, it uses your previous bid. – RamenChef Apr 11 '18 at 17:42 • Suggestions have been implemented. – RamenChef Apr 11 '18 at 17:58 • I'll post this soon if nobody objects. – RamenChef Apr 16 '18 at 16:49 • Honestly, this is rather boring. There's very few strategies, so this will quickly devolve into meta-gaming – Jo King Apr 17 '18 at 11:08 • You're Analyst bot is promoting bad behavior. What happens if you have another bot that also uses reflection to run newAuction? They will infinite loop each other. I highly recommend disallowing reflection. – Nathan Merrill Apr 17 '18 at 19:11 • You haven't mentioned how you are combining auctions. "Bots are scored based on the profit they made during those auctions." isn't nearly specific enough. – Nathan Merrill Apr 17 '18 at 19:15 • Running 2 auctions per pair is a bad idea, the second game provides you with no benefit: it either gives the same result, or you have no idea who actually won between the two players. – Nathan Merrill Apr 17 '18 at 19:24 # Operate on a subset of a register Note: You do NOT need to know anything about quantum mechanics or quantum computing to understand this challenge. I've tried to include sufficient background for any old code golfer to realize what's going on. ### Motivation (much of this can probably be skipped) In quantum computing, the equivalent of a bit is a qubit. Like a bit, a qubit will have a state of OFF or ON (0 or 1) when observed, but unlike a bit, a qubit can exist in both states simultaneously while unobserved. Trippy. What's even trippier is that they don't exist in simple superpositions (40% chance to observe 0, 60% for 1)—you can have two qubits that will behave the same when observed, but not when interacting with other qubits. Taking this into account, a convenient representation of a qubit's state is a complex vector, with bases |0> and |1>. A qubit with state (1+0i)|0> + (0+0i)|1> will always show 0 when observed, as will (0+1i)|0> + (0+0i)|1> or (0.6+0.8i)|0> + (0+0i)|1>. What matters here is the squared magnitude of each component—that's the probability of observing the corresponding basis vector. Noting this, (-0.5+0.5i)|0> + (-0.5-0.5i)|1> will "choose" randomly between the two possible states. This ability to have multiple states at once allows qubits to store much, much more information than an equal number of bits. Now, since a qubit is a two-dimensional vector (as far as we're concerned), an operation on a qubit can be represented as a 2x2 matrix. For example, the identity: [[1+0i 0+0i] [0+0i 1+0i]] will take any qubit to an equivalent one, while the Hadamard transform, represented by the matrix: [[1+0i 1+0i] [1+0i -1+0i]] will turn any pure state (P(0) == 0 or 1) into an equal superposition of the two. Check out this challenge for generation of this matrix, generalized to n qubits! These matrices multiply a qubit's vector state to yield a new state. A qubit on its own is little more useful than a bit. However, they can be put into registers with others, so a "qubyte" can store 0, 255, or any arbitrary superposition of the numbers between. I won't go into depth on entanglement here, but I'll say that it is a property of these qubits that makes storing quantum registers as lists of qubits not work at all (and makes quantum computers outperform classical ones). It works much better to treat a register much like a qubit and give it a vector representation, this time with a basis vector for each observable state. For example, two (1+0i)|0> + (0+0i)|1> qubits together form a (1+0i)|00> + (0+0i)|01> + (0+0i)|10> + (0+0i)|11> register. Note that the probability distributions of outcomes are identical for the two representations—in this case, both qubits will and up as 0 in both representations. ### Important stuff again These registers are nice and all, but it's difficult (and often impossible—try it yourself on (-0.5+0.5i)|00> + (0+0i)|01> + (0+0i)|10> + (-0.5-0.5i)|11>!) to extract the state of a single qubit in a register from the register's vector—that is, you can have a register in a state unformable by individual qubits. Fortunately, to apply, say, the Hadamard transform to qubit 2 of a register, we can construct a matrix by which we can multiply the entire register but change only the one qubit. Neat! Let's say we have an operation m on one qubit defined as: [[x y] [z w]] and a three-qubit register of qubits a|0> + b|1>, c|0> + d|1>, and e|0> + f|1>. This register has a vector form (treating the first of these qubits as the least significant) of: eca|000> + ecb|001> + eda|010> + edb|011> + fca|100> + fcb|101> + fda|110> + fdb|111> Defining g := ax + by and h := az + bw, we see that the result of applying m to a|0> + b|1> is g|0> + h|1>. What we want is a matrix that, when multiplied by the register state above, yields the same but with a and b replaced by g and h, respectively: ecg|000> + ech|001> + edg|010> + edh|011> + fcg|100> + fch|101> + fdg|110> + fdh|111> Let's look at a matrix that does just this: [[x y 0 0 0 0 0 0] [[eca] [[ecax + ecby] [[ecg] [z w 0 0 0 0 0 0] [ecb] [ecaz + ecbw] [ech] [0 0 x y 0 0 0 0] [eda] [edax + edby] [edg] [0 0 z w 0 0 0 0] \/ [edb] —— [edaz + edbw] —— [edh] [0 0 0 0 x y 0 0] /\ [fca] —— [fcax + fcby] —— [fcg] [0 0 0 0 z w 0 0] [fcb] [fcaz + fcbw] [fch] [0 0 0 0 0 0 x y] [fda] [fdax + fdby] [fdg] [0 0 0 0 0 0 z w]] [fdb]] [fdaz + fdbw]] [fdh]] How nice. Of course, we can operate of qubit 1 or 2 (0-indexed) with a modified version of the very same matrix: [[x 0 y 0 0 0 0 0] [0 x 0 y 0 0 0 0] [z 0 w 0 0 0 0 0] [0 z 0 w 0 0 0 0] [0 0 0 0 x 0 y 0] [0 0 0 0 0 x 0 y] [0 0 0 0 z 0 w 0] [0 0 0 0 0 z 0 w]] [[x 0 0 0 y 0 0 0] [0 x 0 0 0 y 0 0] [0 0 x 0 0 0 y 0] [0 0 0 x 0 0 0 y] [z 0 0 0 w 0 0 0] [0 z 0 0 0 w 0 0] [0 0 z 0 0 0 w 0] [0 0 0 z 0 0 0 w]] These are the same as before, but with the 2x2 squares spread out a bit and overlapping. Verification of these matrices is left as an exercise for the reader. You can also perform multi-qubit operations (like the controlled-NOT gate) on just part of a register in much the same fashion. Performing on qubits 0 and 2 of a 3-qubit register the following operation: [[a b c d] [e f g h] [i j k l] [m n o p]] can be accomplished with yet another 8x8 matrix: [[a b 0 0 c d 0 0] [e f 0 0 g h 0 0] [0 0 a b 0 0 c d] [0 0 e f 0 0 g h] [i j 0 0 k l 0 0] [m n 0 0 o p 0 0] [0 0 i j 0 0 k l] [0 0 m n 0 0 o p]] This can be generalized to an operation on m qubits of a register of n qubits, where 0 ≤ m ≤ n; in fact, that's what this challenge'll do! ### Your task (at long last!) Write a program or function. It must: • Take as input a nonnegative integer n. • Take as input a list of m distinct integers from 0 to n (inclusive). • Take as input a 2mx2m matrix of integers that represents the operation to be performed on the qubits of an n-qubit register indicated (in order) by the aforementioned list. • Return as output a 2nx2n matrix of integers that represents an operation on the entire register equivalent to applying the given matrix to the indicated qubits. ### Test cases n = 4 qubits = {2} Operation: [[1 2] [3 4]] Return: [[1 0 0 0 2 0 0 0 1 0 0 0 2 0 0 0] [0 1 0 0 0 2 0 0 0 1 0 0 0 2 0 0] [0 0 1 0 0 0 2 0 0 0 1 0 0 0 2 0] [0 0 0 1 0 0 0 2 0 0 0 1 0 0 0 2] [3 0 0 0 4 0 0 0 3 0 0 0 4 0 0 0] [0 3 0 0 0 4 0 0 0 3 0 0 0 4 0 0] [0 0 3 0 0 0 4 0 0 0 3 0 0 0 4 0] [0 0 0 3 0 0 0 4 0 0 0 3 0 0 0 4] [1 0 0 0 2 0 0 0 1 0 0 0 2 0 0 0] [0 1 0 0 0 2 0 0 0 1 0 0 0 2 0 0] [0 0 1 0 0 0 2 0 0 0 1 0 0 0 2 0] [0 0 0 1 0 0 0 2 0 0 0 1 0 0 0 2] [3 0 0 0 4 0 0 0 3 0 0 0 4 0 0 0] [0 3 0 0 0 4 0 0 0 3 0 0 0 4 0 0] [0 0 3 0 0 0 4 0 0 0 3 0 0 0 4 0] [0 0 0 3 0 0 0 4 0 0 0 3 0 0 0 4]] n = 3 qubits = {0, 2} Operation: [[1 2 3 4 ] [5 6 7 8 ] [9 10 11 12] [13 14 15 16]] Return: [[1 2 0 0 3 4 0 0 ] [5 6 0 0 7 8 0 0 ] [0 0 1 2 0 0 3 4 ] [0 0 5 6 0 0 7 8 ] [9 10 0 0 11 12 0 0 ] [13 14 0 0 15 16 0 0 ] [0 0 9 10 0 0 11 12] [0 0 13 14 0 0 15 16]] n = 3 qubits = {2, 0} Operation: [[1 2 3 4 ] [5 6 7 8 ] [9 10 11 12] [13 14 15 16]] Return: [[1 3 0 0 2 4 0 0 ] [9 11 0 0 10 12 0 0 ] [0 0 1 3 0 0 2 4 ] [0 0 9 11 0 0 10 12] [5 7 0 0 6 8 0 0 ] [13 15 0 0 14 16 0 0 ] [0 0 5 7 0 0 6 8 ] [0 0 13 15 0 0 14 16]] Wow, things get weird. Operation: 2^m x 2^m identity matrix Return: 2^n x 2^n identity matrix n = 5 qubits = {3, 0, 4, 2, 7} Operation: Pastebin Return: [Pastebin] (TODO) ### Rules As usual, standard loopholes apply. Builtins are allowed, but try to include a solution sans builtin as well. You can 1-index or reverse the list if desired. I/O is flexible. This is , so the shortest solution (in bytes) in each language wins! # Sandboxy stuff Anything worth mentioning that I missed? Is there another application of this that might be easier to explain and scare fewer people off? Thanks! • If I understood correctly, the part "it's difficult to extract the state of a single qubit in the register from the register's vector." means that most "registers" cannot be formed by (multiple) single qubits, correct? – user202729 Apr 22 '18 at 13:29 • @user202729 That is correct. – Khuldraeseth na'Barya Apr 22 '18 at 16:23 • Is there a way to rearrange the post so that the task is on top and the explanation comes later? – JayCe Jun 11 '18 at 3:53 ## Bot Wars at the Auction I have seen KOTH challenges where the bots fight each other, and I have seen KOTH challenges where the bots are in an auction. So I came up with this: The Challenge: You must build a javascript bot that will fight other bots using weapons purchased in an auction. These items are: swords, bows, and shields. You can also purchase healing and quivers. Your function is called once per "Turn", and only 1 weapon action and 1 move action can be called in each turn. You start with 200 health, and 2000 coins. Fight in arena with each bot in its own 5 by 5 square. For example, 16 bots would be a 20 by 20 arena. Auctions: During an auction, 2 items will be sold per surviving bot. In the initial auction, 3 items will be sold for each bot. It is up to the bots how they will bid: some bots may spend lots on a cool sword, while others could choose to buy healing in large amounts. There is an auction every few hundred turns. Items start at cost 1. Fighting: After the auction, your bots will be pitted against each other. With swords to strike nearby enemies, bows to attack distant bots, and shields to defend yourself, what could go wrong? If you find yourself low on health, you can heal (Which takes between 6 and 8 turns). Input: As input, your function receives an object filled with functions that can be used to control your bot. This object is also at window.bots["yourbot"].auction or window.bots["yourbot"].fight. Object: //within window.bots["yourbot"] mode: integer, //0=Dead, 1=Auction, 2=Fight items: object, //All items owned coins: integer, health: integer, auction: { itemlist: array, //Array of item objects placeBid(coins), //Bid on item incrementBid(amount), //Bids (current + amount) item: { current: integer, //Current highest bid bidder: string, //Current highest bidder type: integer, //1=Sword, 2=Bow, 3=Quiver, 4=Shield, 5=Healing power: integer, //Item power (Attack amount, healing amount, or block percentage) units: integer //Only for healing and quivers; amount of turns taken to heal, or amount of arrows in quiver } }, fight: { botList: array, //List of bots surrenderTo(bot), //Surrenders to a specific bot move: { north(), //Y+ east(), //X+ south(), //Y- west(), //X- } use: { swordAttack(bot OR [x,y]), //Attacks a bot, but only if it is adjacent to attacker bow(bot OR [x,y]), //Shoots bow at bot, bot must be within 5 spaces shield(), //Raises shield for 5 turns heal(sor) //Uses least powerful healing or takes input sort function } util: { getNearest(), //Returns nearest bot getBot(name), //Returns a specific bot by name atLocation([x,y]), //Returns bot at a certain location gridSize(), //Returns the side length of the square arena getPosition(), //Returns array [x,y] of caller bot see([x,y]), //Returns true or false, depending on if there is a bot in a certain location } } //within other bot nearestBot(), getBot(), botList, or atLocation(x, y) location: array, //[x,y] name: string, //Bot's name items: object //All objects owned by bot //within items type: integer, //1=Sword, 2=Bow, 3=Quiver, 4=Shield, 5=Healing power: integer, //Item power (Attack amount, healing amount, or block percentage) units: integer //Only for healing and quivers; amount of turns taken to heal, or amount of arrows in quiver How it Works: You will start in an auction. With your 2000 coins, you can bid on items using the functions placeBid(price) or incrementBid(amount). If nobody bids for 5 turns, the item is sold. Once the items are all gone, the fight begins. The initial auction focuses mainly on swords, bows, and shields. During the fight, you can attack players using simple methods like bow(nearestPlayer()), or more complex methods involving mapping the area with see([x,y]) and atLocation([x,y]). When the fight round is over, another auction starts, which mainly focuses on healing and quivers. When the fight begins again, you will be able to heal (Make sure you shield right before doing so!). After that fight, another auction will commence. This will repeat until one person remains, or all other bots use surrenderTo(bot). Inflicting damage on another bot gets you 1 coin per point, and you get a 500 coin bonus for killing a bot. If a bot surrenders to you, you earn 100 coins. Store information that you bot may use in window.bots[yourBotName]. Note that a copy of this object is passed to your bot, but storing a varibale in this object will only affect it locally. Coordinates range from [0,0] in the corner to [max,max] in the opposite corner, max being round(22.36 * sqrt(botCount)). Function Specifications: placeBid(coins) Inputs amount of coins to set the bidding at If lower than current highest bid or another bid in that turn, returns 1 If input is invalid, returns 2 Will set auction.item.current to coins and auction.item.bidder to your bot name incrementBid(amount) Inputs amount of coins to increase bidding by Adds to highest bid in last turn If lower than current highest bid or another bid in that turn, returns 1 If input is invalid, returns 2 Will add amount to auction.item.current and auction.item.bidder to your bot name moveNorth() Will move bot 1 space Y+ Returns 1 if bot is at far North edge of arena moveEast() Will move bot 1 space X+ Returns 1 if bot is at far East edge of arena moveSouth() Will move bot 1 space Y- Returns 1 if bot is at far South edge of arena moveWest() Will move bot 1 space X- Returns 1 if bot is at far West edge of arena getNearest() Returns the nearest bot as of the last turn Read information: location, name, items getBot(name) Inputs a string, containing the name of a bot If bot does not exist, returns 1 If bot is dead, returns 2 If input is invalid, returns 3 Returns bot as of last turn atLocation([x,y]) or atLocation(x,y) Inputs an array containing coordinates, or two integer coordinates Returns bot as of last turn If no bot exists in that spot, returns 0 Invalid input returns 1 gridSize() Returns an integer containing the side length of the arena getPosition() Returns an array [x,y] containing the position of the bot surrenderTo(bot) Takes bot as input Will set mode to 0 on your bot Gives bot surrendered to 100 coins Returns 1 if input is invalid Returns 2 if bot is dead or inexistant see([x,y]) Returns true if bot is in location Returns false if input is invalid or no bot exists in location swordAttack(bot OR [x,y]) Takes either a bot or [x,y] coordinates as input Does as much damage as your best sword Will return 1 if input is invalid Will return 2 if bot is dead/nonexistant, or if coordinates are out of bounds Will return 3 if you don't have a sword Will return 4 if bot/coordinates are not within 1 space of your bot bow(bot OR [x,y]) Takes either a bot or [x,y] coordinates as input Doesas much damage as your best bow Will return 1 if input is invalid Will return 2 if bot is dead/nonexistant, or if coordinates are out of bounds Will return 3 if you don't have a bow, and 5 if you have no arrows Will return 4 if bot/coordinates are not within 20 spaces of your bot shield() Blocks as much damage as your best shield as a percentage Lasts for 5 turns (Includes turn activated) Will return 1 if you don't have a shield heal() Uses your weakest heal, or you can specify a sort function to define the order they are used Cannot move for 6-8 turns (Selected randomly) Will return 1 if you don't have heal Item Specifications: Sword The sword is used to attack bots within 1 space Has set damage amount (Geometric distribution 10-100) Is found in: Auction 1 = 35% Auction 2 = 30% Auction 3 = 15% Auction 4 = 5% Bow The bow is used to remotely attack bots within 20 spaces Has set damage amount (Geometric distribution 4-40) Is found in: Auction 1 = 30% Auction 2 = 20% Auction 3 = 10% Auction 4 = 5% Quiver Quivers are purchased with arrows in them, used for shooting bows Starts with specific amount of arrows (Geometric distribution 5-20) Is found in: Auction 1 = 7.5% Auction 2 = 10% Auction 3 = 25% Auction 4 = 40% Other auctions = 45% Shield Shields are used to defend against attack Starts with a specific block percentage (Geometric distribution 5%-75%) Can be used while healing Is found in: Auction 1 = 20% Auction 2 = 30% Auction 3 = 20% Auction 4 = 10% Heal Heal is used to regenerate during battle Heal level is geometric distribution 20-80 Is found in: Auction 1 = 7.5% Auction 2 = 10% Auction 3 = 30% Auction 4 = 40% Other auctions = 55% Example bot: function readyToFight(obj) { var items = obj.items; var types = []; var coins = obj.coins; for (var i = 0, n; i < items.length; i++) { n = items[i]; types.push(n.type); } if (obj.mode == 1) { obj = obj.auction; if (obj.item.type == 1) { if (types.indexOf(1) != -1) { for (var i = 0, n; i < items.length; i++) { n = items[i]; if (n.type == 1 && n.power < obj.item.power) { var bid = true; } } if (n.item.price < coins) { obj.incrementBid(1); } } else { if (n.item.price < coins) { obj.incrementBid(1); } } } else if (obj.item.type == 2) { if (types.indexOf(2) != -1) { for (var i = 0, n; i < items.length; i++) { n = items[i]; if (n.type == 2 && n.power < obj.item.power) { var bid = true; } } if (n.item.price < coins) { obj.incrementBid(1); } } else { if (n.item.price < coins) { obj.incrementBid(1); } } } else if (obj.item.type == 3) { if (n.item.price < n.item.units * 2) { obj.incrementBid(1); } } else if (obj.item.type == 4) { if (types.indexOf(4) != -1) { for (var i = 0, n; i < items.length; i++) { n = items[i]; if (n.type == 4 && n.power < obj.item.power) { var bid = true; } } if (n.item.price < coins) { obj.incrementBid(1); } } else { if (n.item.price < coins) { obj.incrementBid(1); } } } else if (obj.item.type == 5) { if (n.item.price < n.item.power * 5) { obj.incrementBid(1); } } } else if (obj.mode == 2) { hp = obj.health; obj = obj.fight; if (types.indexOf(2) != -1) { obj.use.bow(obj.nearestPlayer()); } else if (obj.health < 50 && types.indexOf(5) != -1) { obj.use.heal(); } else { //Be scared, or implement better fighting techniques! } } else { //Bot can still see the arena and auction when dead, but cannot fight or bid } } Notes: Standard Loopholes prohibited, javascript only • Seems like a solid updated version of the previous idea. I think the "The Challenge" section uses the word "function" too much, and should be updated with slightly less technical language. For example, "Your bot can make one Move action and one Combat action each turn". Additionally, the fight object doesn't separate its functions into movement and attacks. I would recommend sub-objects, for example fight.move.north() and fight.attack.sword(x,y). And if some of those functions are supposed to be neither movement nor attacks, fight.util.getNearest() or the like. – Kamil Drakari Apr 23 '18 at 15:52 • Okay, got it. Sub objects for fight: move, attack, and util – Redwolf Programs Apr 23 '18 at 15:54 • I did use instead of attack, so that shields and heal fit under the same category – Redwolf Programs Apr 23 '18 at 16:00 • Next, only having the option to use the weakest healing item doesn't seem right to me. While non-consumable equipment makes sense to always use the best, and there's only one "trait" so best is never in question, healing would often want to use "largest heal that isn't overheal" or "heal that takes the least time". I suspect it wasn't done that way to simplify the runner, but only allowing smallest heal seems restrictive. – Kamil Drakari Apr 23 '18 at 16:02 • Perhaps add an optional parameter for a sort function? Like function(a,b){return a.power - b.power} or function(a,b){return (a.power / a.units) - (b.power / b.units)} – Redwolf Programs Apr 23 '18 at 16:05 • And then the heals are used in the order they are listed – Redwolf Programs Apr 23 '18 at 16:06 # Single-Digit Representations of Natural Numbers ## Introduction Dr. Inder Taneja is a Mathematics Professor at the Federal University of Santa Catarina who wrote and published "Single Digit Representations of Natural Numbers". In this paper, he describes each natural number from 0 to 1000 in terms of each of the digits 1 through 9 in as few digits as possible and using only the five basic arithmetic operations. For example, the entry for "282" written only using the digit "3" looks like this: 3 + 3 * (3 * (3 ^ 3 + 3) + 3) Similarly, "466" written using the digit "7" looks like this: 7 * 77 + 77 / 7 - 77 - 7 This is also described in the first half of this video on the Numberphile youtube channel. This challenge will ask you to write a program (or function, class, etc.) which takes two inputs and outputs a valid mathematical expression according to the rules used by Dr. Taneja. Your score will be calculated based on the size of your code and the quality of your outputs. ## Details Write a program (or function, class, etc.) which takes two integers as input. The first of these will be an integer from 0 to 1000, inclusive. The second number will be a digit from 1 to 9, inclusive. The program shall output an expression of the first input as a series of arithmetic operations on numbers whose digits are exclusively the digit specified as the second input. In addition to parentheses ( and ), the following arithmetic operators are allowed in your output: • addition (represented by the +) • subtraction (represented by the -) • multiplication (represented by the *) • division (represented by the /) • power (represented by the ^) Numbers, as stated before, must be composed entirely of the digit specified by the second input, but they can be any number of digits. Numbers can be positive or negative. Number tokens cannot contain any characters besides the digit specified and, if negative, a - at the beginning. Any form and amount of whitespace, including no whitespace at all, is allowed around each token in your output, where "token" refers to a number, operator, or parentheses. Your program's output may not contain any other characters. The order of operations are evaluated in the usual manner. ## Scoring Dr. Taneja claims that his answers use "as few digits as possible"; unfortunately, his paper does not show how to prove that a solution is truly minimal. In the spirit of preserving that goal, however, the quality of your solutions will contribute to your score. The quality of an output is measured, as Dr. Taneja says, by the number of digits used. For example, consider the output for "466" and "7": 7 * 77 + 77 / 7 - 77 - 7 This has a score of 1 + 2 + 2 + 1 + 2 + 1 = 9. Smaller is better. Your code's score is: score = 2 * <worst_scoring_output> + <solution_bytecount> The lowest scoring valid solution wins. You may determine your worst output either by test battery (trying every input) or logical proof. The following shell script can be used to compute your worst-scoring output, assuming your program is an executable which takes input as command-line arguments and provides output to stdout on a single line. When executing this script, provide the path to your program executable as a command-line argument. // TODO: write a shell script which could compute your bonus score ## Rules Input and output may use any convenient method. This includes writing a function which takes the inputs as arguments to the function and returns or prints a string as described. This is , so the size of your code in bytes forms a significant part of your score. The standard loopholes are forbidden, this includes parsing the original paper to "look up" Dr. Taneja's solution for a combination of inputs. Reasonable adjustments to the output format are allowed; for instance: if your language has a native Expression object for mathematical expressions but its toString() (or equivalent) method represents the power operator as two asterisks rather than a caret, you may use the native representation. Similarly, if it is easier for you to format your output as an equation rather than a one-sided expression, you may do so. For example, you may output <number> = <expression> or <expression> = <number> rather than simply <expression> (where the number is the first input to the program and the expression is the output as defined in the challenge section). Note that in this case, only the digit count of your expressions contribute to your score. ## Example Input and Output Your outputs may vary, but are still valid provided all explicitly-stated rules are respected. Input: 282 3 Output: 3 + 3 * (3 * (3 ^ 3 + 3) + 3) Input: 0 7 Output: 7 - 7 Input: 1000 9 Output: 999 + 9 / 9 Input: 466 7 Output: 7 * 77 + 77 / 7 - 77 - 7 • Welcome to the site! I suggest including test-battery as a winning criterion here—in fact, this is almost exactly the challenge described in the tag wiki! – Khuldraeseth na'Barya Apr 22 '18 at 21:15 • @Scrooble thank you! do you mean anything besides just tagging it as test-battery? i've added (to the top) a list of the tags i intend to use for this challenge. – Woodrow Barlow Apr 22 '18 at 21:23 • Nope, that's all I meant! You can use [tag:tag-name] for the nice-looking tag links. – Khuldraeseth na'Barya Apr 22 '18 at 21:37 • Are you allowed to concatenate, i.e. 36 = 3 + 33? (I vote no, but it's quite common to allow that.) – Nathaniel Apr 23 '18 at 4:20 • @Nathaniel concatenation is not allowed as an operator in the output; however, your output is allowed to have multi-digit numbers as long as all of the digits are the digit specified. – Woodrow Barlow Apr 23 '18 at 13:52 • I'd prefer a version that does not include the bonus. In fact, I think that it should instead be the primary scoring method, e.g. "each submission's score is the total number of digits used across all inputs". Bonus points in Code Golf tend to quickly become either ignored or mandatory – Kamil Drakari Apr 23 '18 at 21:02 • @KamilDrakari i really like that suggestion. i was worried it would be hard to find a bonus point value that doesn't end up getting ignored because it isn't worth the extra bytes. – Woodrow Barlow Apr 23 '18 at 22:27 • @KamilDrakari what do you think of your score being the score of your program + your bytecount, to preserve the golf aspect? – Woodrow Barlow Apr 23 '18 at 22:31 • If you just score it the way I mentioned, adding up all digits used, then I think the golfing would just be way too inconsequential in comparison. Maybe "highest number of digits + byte count"? It's not that different from the current scoring, but it avoids weird cutoffs and negative points so it's more likely that both parts matter. – Kamil Drakari Apr 24 '18 at 4:16 • @KamilDrakari i've re-written the scoring rules. please let me know what you think. i think it strikes a nice balance between golfing and quality outputs. – Woodrow Barlow Apr 24 '18 at 14:34 • @WoodrowBarlow Looks good. I think having that script prepared that will calculate the score is definitely a good idea since manually testing all 9000 input possibilities would be tedious. It would also be nice if that script, in addition to outputting the score (or just "highest_scoring_output" since having it count bytes as well might be problematic), also said which input pair is responsible. – Kamil Drakari Apr 24 '18 at 14:39 • The problem space of expression-building has been fairly well explored, and there are a few questions which this might be considered to duplicate. I personally would vote to close as a duplicate of codegolf.stackexchange.com/q/32085/194 : adding exponentiation as a supported operator and a loop to find the smallest k are both trivial changes IMO. – Peter Taylor Apr 25 '18 at 9:58 • Wait… just how does the length of my code affect my score? – Nissa Apr 25 '18 at 13:22 • @StephenLeppik your score is: 2 * [worst_scoring_output] + [length_of_code]. lower score is better. is that not clear? – Woodrow Barlow Apr 25 '18 at 13:52 # ASCII-betical order The full printable ASCII set (chars 32-126) in ascending order looks like this: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~

Your task is to create a program or function which takes in an integer n and outputs the nth item of an OEIS sequence. The catch: your score is the length of your code, plus thrice the number of ASCII chars in your code not included in the longest strictly increasing substring.

## Rules

A valid strictly increasing substring of your code is defined as so:

• Each character within the substring, except the first, must have a higher ASCII value than the previous.

Other rules:

• The sequence may be 0- or 1-indexed.
• The sequence you choose may not be a constant sequence, such as A000012.
• Entries may only include printable ASCII and newlines. Newlines are ignored when calculating the longest increasing substring.

## Examples

This JavaScript function outputs A000027 (the natural numbers):

n=>[]^n

The longest increasing substring of characters is =>[]^n. Therefore, the score is 7 + 3 × (7 - 6) = 10.

This function does exactly the same thing:

_abcdefghijklmnopqrstuvwxyz=>[]^_abcdefghijklmnopqrstuvwxyz

The longest increasing substring is =>[]^_abcdefghijklmnopqrstuvwxyz. The score is 59 + 3 × (59 - 32) = 140.

This function also does the same thing:

n/*!"#$%&'()*/=>[]^n The longest increasing substring is !"#$%&'()*/=>[]^n. Therefore, the score is 20 + 3 × (20 - 17) = 29.

The lowest score wins.

## Sandbox questions

• Is the scoring system sufficient?
• Is there a better option for the challenge?
• Output n'th item in some OEIS sequence
• Output first n items of some OEIS sequence
• Output the score of the input
• etc.
• What about languages with extended code pages? Should only the ASCII chars be counted, or should the bytes of the program be considered instead?
• Any other concerns?
• I like this version much better. Some ideas: maybe force to choose a non costant oeis sequence? I'm not sure about scoring, seems that standard golfing without caring about increasing ascii can still get a pretty good score... Rule to use only ascii chars in code seems to just be a limit to golfing languages. For the title, i liked the term ASCIIbetical order used in a comment to the previous proposal .) – Leo Dec 1 '16 at 23:41
• @Leo I like the non-constant-sequence idea. I've modified the scoring system to make it a little easier to use (see examples), but I still don't like it because if you need to use that variable name 3 times, it's not worth it, and if you only need it once, it's doubly worth it. Perhaps something taking into account the number and length of individual runs would work better, but I have no idea how to work that out... – ETHproductions Dec 2 '16 at 4:49
• Would something like f n = if ( length "#$% ... |}~" == 92) then n else 0 be valid? For golfing languages the length check won't be much overhead. – nimi Dec 2 '16 at 15:18 • I'd prefer the scoring to work like this (which would be simpler): length, plus three times the number of characters in your code which are not part of the longest substring. That'd prevent people putting the whole ASCIIbet in a string and using a checksum (or length check) to make sure it hadn't been changed. In other words, it'd would encourage programs which were mostly formed of increasing ASCII, rather than programs which contained a lot of increasing ASCII (i.e. favour proportion over length). – user62131 Dec 6 '16 at 11:27 • @nimi Sorry, I missed your comment. I suppose that would be valid. The scoring system would have to account for that. – ETHproductions Dec 6 '16 at 17:22 • @ais523 I like that idea; however, as it's currently written, that would give the first two examples scores of 16 and 140, respectively. I'd like to give the second example a much lower score, if possible, but I'm not sure how to do this, and it may not be a good idea. What do you think? – ETHproductions Dec 6 '16 at 17:28 • I think it's a bad idea. The second example isn't actually any different from the first in terms of AST, it just has a bunch of junk characters written somewhere (in this case, a variable name) that the program doesn't parse them (with an equal number of characters outside to balance). – user62131 Dec 6 '16 at 17:32 • @ais523 OK, I've changed the scoring algorithm. I've also removed the "you can't be able to remove any chars in the substring" rule for now, as it now seems superfluous. – ETHproductions Dec 6 '16 at 17:47 • The problem with this scoring is that the winner would probably be a 2 byte program in a golfing language scoring 2 points (or a 1 byte program scoring 1 point, I bet someone will find it). – Leo Dec 7 '16 at 16:37 • @Leo: I guess even 0 bytes is possible by using a language that takes implicitly input, puts in on the stack (does nothing for 0 bytes) and outputs the stack when the program stops. This is sequence A000027, the natural numbers . – nimi Dec 7 '16 at 19:42 • @Leo Yes, that's a very good point. It's so hard to come up with a good formula.... Do you have any more ideas? – ETHproductions Dec 7 '16 at 21:44 • @ETHproductions Maybe (length of longest increasing sequence)^2/(length of whole program) ? Highest score wins, max would be 95 for a program composed by exactly the whole sequence – Leo Dec 8 '16 at 8:33 • @Leo The problem with that would be it goes back to rewarding solutions containing the whole string with a length check... (For example, n=> !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~"[90]?m:n in JavaScript scores 84.346) – ETHproductions Dec 9 '16 at 3:25
• A separate comment: you should replace "ASCII chars" with "bytes". That would allow more languages to compete. – Nathaniel Apr 27 '18 at 14:12
• As a follow-on to my previous comment about the identity function being shorter in some languages, as things stand I could submit a zero-byte answer in GolfScript. When a zero-byte answer is possible, the question has a serious problem. – Peter Taylor Apr 27 '18 at 18:00

# The Derby Stakes

The Derby is a horse race run (near) annually since 1780 near the town of Epsom and is the middle leg of the Triple Crown. The race covers one mile, four furlongs, and six yards. Over the years it has had as few as 4 and as many as 34 entries. The fastest winning time was in 2010 at 2m31.33, but I'm old-fashioned and like horse race results only to the nearest fifth of a second. So let's call it 2:31 2/5.

We will ID horses by number from 0 or 1 (your choice) up to the number of horses in the race (could be anything from 4 to 34).

The task is to take a list of the average horse speeds in miles per hour and produce a report of the race. The report has:

1. the winning horse ID and its winning time;
2. the other horse IDs in their order of finish and the difference between each time and the time of the horse that finished ahead of it.

However:

1. the times are to the nearest fifth of a second. There can be ties, which must be listed in random order;
2. some horses might not finish the race, in which case their average speed is 0.

## I/O

The input will have between 4 and 34 non-negative numbers (average speeds) rounded to one decimal place, in any convenient format for your language. The horse ID is just the index (starting at 0 or 1) of their average speed.

The output can be any convenient format, as long as the winner is "first" (in the sense of top-most or left-most) and the other horses are listed in a way that makes their finishing order clear.

The times have to be rounded to the nearest fifth of a second, but otherwise can be represented however you like, such as the number of seconds, or some format like 2:31.4 or whatever. If the time is in "seconds flat", as they say, either 2:32.0 or 2:32 (for example) is fine.

For horses that don't finish the race, no time difference really makes sense, so anything that just indicates they didn't finish is fine. But the do have to appear in the report, and if more than one horse does not finish they have to be listed randomly.

The point with the output is that it needs to be clear, but the format itself is not so important.

You also need to state in your answer how you have ensured that ties are output in a random order.

## Test case

31.8, 0, 32.9, 32.1, 30.8, 31.8, 31.1, 33.1

8 2:43.6
3 0:01.0
4 0:04.0
1 0:01.6
6 0:00.0
7 0:03.8
5 0.01.8
2 DNF

"I made the ranking of ties random by using rank(x, ties.method = "random") in R."

I chose a particular time format and used "DNF" for the horse that didn't finish, but you don't need to adhere to these.

I will make more test cases if this challenge seems interesting to anyone.

This is . Standard loopholes forbidden.

• I assume .5 is expected to be rounded to .6 ? – JayCe Jun 11 '18 at 2:12
• Do the times get rounded to 1/5 of a second before calculating the differences, or are the differences rounded to 1/5 of a second? – JayCe Jun 11 '18 at 2:20
• Also you might want (or not) to clarify how many miles is 1 mile, 4 furlongs and 6 yards. Or it could be another code-golf challenge if it doesn’t already exist :) – JayCe Jun 11 '18 at 2:22

# How far can I throw a ball up the hill?

Given an initial velocity, an angle to throw the ball, and the angle of a hill, determine how far the ball will go before it hits the ground due to gravity.

Refer to the image below. V=initial velocity vector, a1=angle of hill, a2=angle ball is thrown at, d=distance ball will travel

### Inputs

• The velocity the ball is thrown at (m/s)
• The angle from level ground that the ball is thrown at (radians or degrees)
• The angle from level ground the hill is at

### Output

• The number of meters the ball travels before hitting the ground

## Specifics

• Gravity will pull the ball downwards at 9.81 m/s^2
• Due to floating point rounding, the answer only need be correct within 0.1 of my test case examples
• The input angle can be between 0 and pi/2 radians (or 90 degrees)
• An angle of 0 means the ball is thrown horizontally across the ground, which hits the ground at 0 meters
• An angle of pi/2 radians (or 90 degrees) means the ball is thrown vertically and hits the ground at 0 meters
• The angle of the hill will always be less or equal than the angle the ball is thrown at
• This is code golf, fewest bytes wins

## Test cases

pi/4  (20, 0.7853981633974483, 0) = 40.8
pi/5  (20, 0.6283185307179586, 0) = 38.8
pi/6  (10, 0.5235987755982988, 0) = 8.8
pi/3  (10, 1.0471975511965976, 0) = 8.8
pi/2  (5,  1.5707963267948966, 0) = 0.0
0     (5,  0,                  0) = 0.0

## Sandbox

I'm not sure what standard rules are used when accounting for floating point errors, is allowing a .1 margin of error fine?

Test cases for angles > 0 to come.

• I think allowing both degrees and radians would be better. – Esolanging Fruit Apr 30 '18 at 6:20
• @PeterTaylor Added a bit more to the challenge. – aoemica May 1 '18 at 6:23
• I think that in light of the changes, some of the points need to be updated. Point 3 talks about the input angle (singular), but may no longer be necessary at all. Point 4 also looks out of date. With respect to floating point errors, that's tricky to do well. IMO the best approach is to specify a range of input values and an error (relative or absolute) which must be obtained within that range; but to verify that the requirements are reasonable may require numerical analysis. – Peter Taylor May 1 '18 at 7:34
• While this is mathematically interesting, it does not allow for very much solution variation. – Beefster May 1 '18 at 16:03
• 1. Regarding floating point inaccuracies, you can visit this meta post to get some inspiration and guidance. 2. I think physics is a good fit here. 3. In its current form, if posted, the challenge is very likely to be closed as Unclear what you are asking, since you don't include a way to compute that distance. I suggest adding this to the challenge – Mr. Xcoder May 1 '18 at 18:37
• I don't think such challenges (where there is a formula, and deriving the formula is the main part of the challenge) have many interesting solutions. Explicit form. (cc @Mr.Xcoder ) – user202729 May 2 '18 at 12:18
• You should make it clear that the output is the horizontal length traveled (instead of the arc length) – user202729 May 2 '18 at 12:19
• @user202729 I myself know how to solve the challenge in its current form, however I just pointed out that a larger audience might not receive this too well. Perhaps this challenge isn’t really suited for our format on PPCG. (P.S. the length is not horizontal, it’s along the inclined plane.) – Mr. Xcoder May 2 '18 at 12:21
• @Mr.Xcoder For the current test cases they're equivalent anyway. – user202729 May 2 '18 at 12:26

## Queuez

A typical stack-based lanaguage uses nilads, monads, dyads, and occasionally operations with larger numbers of arguments. As each operation is processed, the values are stored on a stack, so that if you want to apply an operation to the result of other operation(s), you simply invoke those operations (and predecessor operations if necessary), at which point their results will end up on the stack ready for the operation you provide next.

Queuez is a fictional language which works differently: instead of the results being stored on a stack, they are stored in a queue, so you have to be careful how you manage your order of operations. For example, let's imagine that digits are nilads and - and / are dyads and you want to calculate ((a / c) - f) / ((b / d) - e). In a stack-based language you would write this as ac/f-bd/e-/, however in Queuez you need to write this as acbd/f/e--/. Explanation:

Command Stack
a       a
c       a c
/       a/c
f       a/c f
-       a/c-f
b       a/c-f b
d       a/c-f b d
/       a/c-f b/d
e       a/c-f b/d e
-       a/c-+f b/d-e
/       (a/c-f)/(b/d-e)
Command Queue
a       a
c       a c
b       a c b
d       a c b d
/       b d a/c
f       b d a/c f
/       a/c f b/d
e       a/c f b/d e
-       b/d e a/c-f
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)

Please write a program or function that converts a program written in a fictional stack-based language into the equivalent Queuez. The actual nilads, monads and dyads of the two lanaguages will be arbitrarily mapped to three sets of at least 10 printable ASCII characters of your choice (you are not required to use letters or mathematical symbols); your answer only has to output the correct rearrangement based on which characters you have chosen to represent nilads, monads and dyads. You can assume that there will be one value left on the stack/queue at the end of the program. Normal rules apply.

If you prefer, you can reverse the dyad argument order, but this must apply both to the original stack-based language and the output. For instance, for the input edb/-fca/-/ you would need to output dbcae/f/--/:

Command Stack
e       e
d       d e
b       b d e
/       b/d e
-       b/d-e
f       f b/d-e
c       c f b/d-e
a       a c f b/d-e
/       a/c f b/d-e
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)
Command Queue
d       d
b       b d
c       c b d
a       a c b d
e       e a c b d
/       b/d e a c
f       f b/d e a c
/       a/c f b/d e
-       b/d-e a/c f
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)
• By "ASCII" did you mean "characters" or "symbols"? (can we use SBCS?) – user202729 May 5 '18 at 14:52
• I think this needs to be narrowed from "Make up a language with the operators of your choice, and then do the real task on the basis of that language". That has the potential to move the golfing from the program to the definition of the task, e.g. by making all the dyads commute in order to simplify the transformations, or making all the monads no-ops so that they just serve to rearrange the queue, or having some operators which build lists and an eval dyad which evaluates a string over a list in a stack-based way, or ... – Peter Taylor May 5 '18 at 17:18
• @PeterTaylor Sorry, that was not the intent of the challenge; thank you for pointing out that it needed clarification. Hopefully this new wording will indicate that the meaning of the operators is unknown and therefore the work lies in finding the appropriate rearrangement. – Neil May 5 '18 at 20:37
• @user202729 You don't know the underlying SBCS of the language because you don't need to know, all you know is that it has been mapped to three sets of printable ASCII characters of your choice. – Neil May 5 '18 at 20:39
• @Neil Then call them "bytes". – user202729 May 6 '18 at 2:00