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

## Cops/Robbers section

The robbers/cops section can be found here.

# Challenge

## Cops

Your job is to write a program that always halts. It can do anything it likes, as long as, given any input, it eventually stops. You must also write a mathematical proof that it stops. Two weeks after you have posted your answer (since math is hard, we want to give the Robbers a chance to steal your academic success), you should edit in this mathematical proof. Once you have done so, you are safe, and your score will be the length of your program (in bytes). Whichever safe program has the lowest score wins!

## Robbers

Your job is to write a mathematical proof that a given cops program halts, and post it as an answer. You must do so before the cop posts their proof.

You get 1 point for each post cracked, unless you crack it within 24 hours, in which case it is only 0.1 points (this is to prevent people from racking up points on easy answers). You obviously cannot crack your own submissions.

## Notes

1. Cops may not use undocumented or incorrectly documented features of the programming language they are using.
2. Although the proofs will be written in the informal style common within mathematics (as opposed to completely formal proofs), they must theoretically be valid in the framework of ZFC. This will not come into play for most answers, seeing as most of mathematics can be formalized in ZFC, but some might if they use crazy metamathematical shenanigans (please do not do this (just kidding, go crazy kids)).
• This means that cops must write programs that can be proven to halt in ZFC. This means, for example the program if isProofThatZFCisInconsistient(input) then infiniteLoop else stop) would be invalid, since although this program always halts (presumably), you cannot prove this fact in ZFC.
3. Cops, your program is not safe until you post the proof.
• This seems to be more a knowledge of obscure theorems contest than a programming contest. While the Curry-Howard correspondence says that the two are related, IMO this isn't really on topic. – Peter Taylor Jul 6 '17 at 13:30
• @Peter Taylor well, you would also need to golf the obscure theorems. – PyRulez Jul 6 '17 at 14:09
• ^ and obfuscation could come into play. – FlipTack Jan 3 '18 at 19:22

## ASCII Art Turtle

As you know, the LOGO programming language allows you to manoeuvre a turtle and draw lines in a graphical way. It occurs to me that we can do this for .

A minimal set of commands to produce would be the R(otate right), F(orward) and P(en) commands. For example, the string FPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPFPRRRFRRRRPF would produce the following output:

\|/
- -
/|\


However that AAT code is rather inconvenient so I have chosen the following slightly more compact instruction set:

• F Move one cell in the current direction. Initially the current direction is east. If the pen is down, the cell just vacated is set to one of -/|\ appropriately.
• B Move one cell in the reverse direction. (Initially this would be west, of course.) The cell vacated is set in the same way as for F (since the output characters are all symmetric).
• R Rotate right 45°. Only the current direction changes; nothing is drawn and the current position does not move.
• L Rotate left 45°. Otherwise as per R.
• D Lower the pen. Note that the pen starts lowered.
• U Raise the pen.

The above image could therefore be drawn using the command string BULFDBULFDBULFDBULFDBULFDBULFDBULFDB, while the string LFFUBRFDFFFFFFFFFFFFFFFFFRFFRFBRRFFFFFFFFFFFFFFFFFFFFFUBLLFDFFBLLFFFFFFFFFFFFFFFFFFFFFUBRRFDFRRFFFFFFFFFFFFFFFFFFFFFURBDBBUFLBDBBBBBBBBBLLFFFURBDBBBUFRBDBBBLBB should hopefully produce this somewhat familiar picture:

 /-----------------\
/                   \
---------------------
|                   |
---------------------
|                   |
---------------------
\                   /
\---------|  /----/
| /
|/


Your function or program must take input as a string, or whatever the nearest equivalent is in your language, and output a newline-delimited or newline-terminated string. (For those of you used to using TIO it should be possible to paste the raw string into the ▼ Input field and show the output directly in the ▼ Output field.) Extra blank rows or columns are not allowed, but you are allowed to pad all the lines to the length of the longest non-blank line. You can take input in lower or mixed case if you prefer. You can assume that the input will only use those six letters. You can further assume that U and D commands alternate. You can also assume that you will never write in the same place twice.

This is , so the shortest program that breaks no standard loopholes wins!

# An order of primeness

## Introduction

In a recent question the concepts of super-primes were explored. A super-prime is a prime whose index is also a prime.

• 2 is not a super-prime, its index is 1
• 3 is a super-prime, its index is 2
• 5 is a super-prime, its index is 3
• 7 is not a super-prime, its index is 4
• ...

The first few of these super-primes are 3, 5, 11, 17, 31, 41, 59, ...

Let us call these primes of at least order 2, because they are more prime than regular primes (which are only of order 1).

Primes of order of 3 or greater can be defined similar. A prime is of order 3 if its index is a prime of order 2.

The first few of the primes at least of order 3 are 5, 11, 31, 41, 59, 127, 179, 277, ...

This is sequence A049076. It was defined by Neil Fernandez in 1999. More information can be found in his Exploring Primeness Project.

Given a prime, return its order.
More formally

• INPUT: A single integer which is guaranteed to be a prime
• OUTPUT: A single integer which is the order of the input.
• You can either return or print the result.

This is , so shortest code wins.

## Testcases

           2 ->  1
3 ->  2
5 ->  3
7 ->  1
52711 ->  9
435748987787 -> 11 (happens to be the 11. Prime of order 11)


# Sandbox Questions

1. Does it need any more clarification?
2. Should I define order 0 (not a prime) and allow any number as input, or would that over-complicate the challenge?
3. Primes of higher order tend to get big very fast. Should I somehow specify that a language only has to work for test-cases it can actually handle or is their a consensus already?
4. Is the introduction too big?
• This is just a loop round the linked question, and as such qualifies as a duplicate for the purposes of this site. – Peter Taylor Jul 10 '17 at 14:04
• I think this might be an interesting question. – CalculatorFeline Jul 10 '17 at 22:14
• Last test case -> 10 (or all the other cases ->+1) – J42161217 Jul 10 '17 at 23:24

## These are two separate challenges.

Given a non-negative real number (no greater than 1×1040 or the biggest your language can comfortably accommodate, whichever is less) convert it to mixed-radix ZYX…432.234…XYZ using the base-36 digits [0-9A-Z] or [0-9a-z] with no leading zeros (except for values smaller than 1). Any reasonable rounding is fine.

### Examples

00 (0 × !1)
11 (1 × !1)
210 (1 × !2 + 0 × !1)
311 (1 × !2 + 1 × !1)
420 (2 × !2 + 0 × !1)
421300 (1 × !4 + 3 × !3 + 0 × !2 + 0 ×!1)
1004020 (4 × !4 + 0 × !3 + 2 × !2 + 0 ×!1)
123452304111
42949672958B6570020211
1000000000017A5726651220
184467440737095516157BC43F35350835000211
0.50.1
0.3333333333333333330.02
0.250.112
0.10.0022
5.12521.003
2.7182818284590452351.111111111111111111
0.0013888888888888890.00001

Given a string (no longer than 71 characters or the maximum that gives a result your language can comfortably accommodate, whichever is less) convert it from mixed-base mixed-radix ZYX…432.234…XYZ using the base-36 digits [0-9A-Z] or [0-9a-z]. Any reasonable rounding is fine.

### Examples

0 (0 × !1) → 0
1 (1 × !1) → 1
10 (1 × !2 + 0 × !1) → 2
11 (1 × !2 + 1 × !1) → 3
20 (2 × !2 + 0 × !1) → 4
1300 (1 × !4 + 3 × !3 + 0 × !2 + 0 ×!1) → 42
4020 (4 × !4 + 0 × !3 + 2 × !2 + 0 ×!1) → 100
230411112345
8B65700202114294967295
17A572665122010000000000
7BC43F3535083500021118446744073709551615
0.10.5
0.020.333333333333333333
0.1120.25
0.00220.1
21.0035.125
1.1111111111111111112.718281828459045235
0.000010.001388888888888889

• I think this is ready. – Zacharý Jul 11 '17 at 21:56
• I'd like this more with a list of digits 0-35 in the factorial base rather than including letters. – xnor Jul 13 '17 at 8:16
• @xnor Interesting. In that case, there should be no specific upper limit, right? – Adám Jul 13 '17 at 8:17
• @Adám That's right, unless you want a limit for the sake of languages' number bounds. – xnor Jul 13 '17 at 8:18
• @xnor I assume that's covered by default rules. This simplifies the challenge text, so I'll make the change. Thanks – Adám Jul 13 '17 at 8:18
• @xnor How is this? – Adám Jul 13 '17 at 8:24
• @Adám Looks good to me. Is your plan to post a challenge for just one direction? – xnor Jul 13 '17 at 8:32
• @xnor Uh, did you read the post? – Adám Jul 13 '17 at 8:33
• @Adám Yes, and I'm not sure if your plan is to post two challenges, or just whichever direction is more interesting. – xnor Jul 13 '17 at 8:51
• @xnor Two challenges. However, I just noticed that factoradic can easily represent floats too, so should I extend/modify the challenges to that? It would certainly make them different from the existing one. – Adám Jul 13 '17 at 8:53
• Yes, you should do that so built-ins won't be useful (cough Jelly cough) in addition to distinguishing this from the existing challenge. – Zacharý Jul 13 '17 at 19:57
• The original challenge with letters was way better... – J42161217 Jul 14 '17 at 6:25
• I actually agree with @Jenny_mathy because languages like Jelly naturally output different bases in a list format, rather than a string of letters. – Zacharý Jul 14 '17 at 13:17
• @Jenny_mathy Like this? – Adám Jul 14 '17 at 14:22
• @Zacharý Ping ^ – Adám Jul 14 '17 at 14:22

## Solve the Trolley Problem code-golfmachine-ethics

Philosophers have long pondered the Trolley problem. Unfortunately, this no human has solved this problem yet. Luckily, as programmers we can use computers to solve the problem for us!

Your program will take as input a (finite) directed graph (with at most one edge from x to y, for any x and y), with a designated node, and a nonnegative integer attached to each edge (representing the number of people tied to that track). In addition, every node has at least one exit edge.

The trolley starts at the designated node. Each turn, if the trolley is at node x, the utilitarian selects an edge (x,y). The people on that edge die, and trolley is now at edge y. This process continues forever.

Note that people can only die once, so if the edge (x,y) has n people tied to it, and the trolley runs over them, say, 100 times, it will still only result in n deaths.

The utilitarian makes his choices in such a way as to minimize the number of people that die (which is guaranteed to be finite, since there are only finite people). Your program will output this number.

You may take the input graph in any reasonable way you like. For example, you could take it as a matrix, and count the designated node as the one labeled 0. Or you could use something like x1,y1,n1;x2,y2,n2;.... For example 0,a,0;a,b,5;a,c,1;b,b,0;c,c,0 to represent the standard trolley problem (with loops at the end).

Testcases:

• 0,a,0;a,b,5;a,c,1;b,b,0;c,c,0 -> 1 (Go from 0 to a, a to c (killing one person), and then keep looping the trolley from c to c).
• 0,0,1;0,a,5;a,a,0 -> 1 (Keep going from 0 to 0, running over 1 person for all eternity),
• 0,a,5;0,b,1;a,a,1;b,b,6 -> 6 (0 -> a -> a -> a -> a -> ... (note that the greedy solution of going to b would be incorrect))
• 0,a,1;0,b,5;a,b,1;b,a,1 -> 3 (0 -> a -> b -> a -> b -> ...)
• 0,a,1;0,b,1;a,a,0;b,b,0 -> 1 (Note that there are two different options that the utilitarian might take that both kill only one person)

This is , so the shortest answer wins! Good luck.

Notes: There will be no sick loop de loops and multitrack drifting is banned.

• So basically: find the cycle of lowest weight? That's pretty similar to finding the cycle of greatest weight, which is equivalent (for integer weights) to codegolf.stackexchange.com/q/107274/194 – Peter Taylor Jul 22 '17 at 9:36
• @Peter Taylor no, since you may have to kill lots of people to get to that cycle, or it might not be reachable at all. – PyRulez Jul 22 '17 at 12:26
• Aha, so it's finding a rho of lowest weight. Still potentially quite similar in implementation, but certainly admits alternative approaches. It might improve clarity to explicitly describe the rho form of the paths to consider. – Peter Taylor Jul 22 '17 at 12:33
• @Peter Taylor what is rho? – PyRulez Jul 22 '17 at 15:44
• ρ , as in Pollard's rho which uses paths which eventually loop back on themselves to factor composite numbers. – Peter Taylor Jul 22 '17 at 16:08
• You should delete this as it has been posted. – Erik the Outgolfer Jul 28 '17 at 19:41

# An anagram chain quinepermutationscode-golf

Your challenge is to create a program, P_0, that outputs P_1, that outputs P_2, that outputs... P_n, which finally outputs P_0. Every program in that chain has to be a permutation of every other program, and every program has to be distinct.

For example, if your program (P_0) was

abcd


And that generated another program (P_1)

badc


Which generated another program (P_2)

dabc


Which outputted the first program, you would have a anagram chain of length 3.

Your goal is to make as long a chain as possible, in as short a program as possible.

Your final score will be your chain length - in case there's a tie, the program with the shortest bytecount wins. If there's a tie again, the first poster wins.

## Meta:

• I need a better title. Any suggestions?
• [Related]. Actually, I'm pretty sure this is a dupe of another challenge that I can't find at the moment. – Shaggy Jul 23 '17 at 10:13

# KotH: Atom Bomb Chess

(Draft. I'll flesh it out some more later. It will probably be implemented in JavaScript or maybe C++.)

Atom Bomb Chess is a variant of chess played much the same as regular chess. The only differences are:

1. The game ends when one or both players have no pieces, or if 50 moves have been made without a piece being captured.
2. When a piece is captured, all pieces a king's move away are also "captured", and the piece doing the capturing is also "captured".

For example, let's look at a 4x4:

pbbr
....
....
RBBP


Where r/R is a rook, b/B is a bishop, and p/P is a pawn. Suppose R moves forward 3 spaces. Then, it captures the p and "explodes":

..br
....
....
.BBP


The idea of this KotH is to make a program that plays Atom Bomb Chess. I will have a few programs to test your submissions against.

• This is a really cool idea! Obviously you'll need to flesh out the rules a bit more, but this is a great start. I would also suggest fixing the board size (you seem to suggest it can be played on any size board, but I think it would be easiest to set it as a constant ahead of time). – musicman523 Jul 23 '17 at 22:31
• @musicman523 Yeah, it'd probably be played on an 8x8 – Conor O'Brien Jul 23 '17 at 22:35
• you forgot that pawns are partially nuke proof – Destructible Lemon Jul 23 '17 at 23:15
• @DestructibleLemon Please elaborate ? I wasn't aware there was some standard rulebook. – Conor O'Brien Jul 24 '17 at 1:45
• I'm not entirely sure where it is, but I remember that pawns, while still being eliminated if they are capturing, or are captured, will not get removed if they are adjacent to a capture. maybe use lichess? – Destructible Lemon Jul 24 '17 at 2:51
• @DestructibleLemon I remember playing it when I was younger with no such restriction, perhaps there are multiple variants. Why suggest lichess? Does it have that mode? – Conor O'Brien Jul 24 '17 at 18:02
• Apart from pawns being nuke proof, the game ends as soon as you nuke the enemy king, if you play on lichess. There are videos on YouTube which include an explanation of the rules and basic "opening theory". – Sleafar Jul 28 '17 at 18:17

# Who Won the Chess Game?

Bear with me, this is incredibly bare-bones at the moment; I'll work on this over-time, just wanted to gauge interest on the over-all idea.

Given an input list of moves l, output who won the chess game given that white always goes first, alternating moves from there. Using the following convention for naming the chess squares:

Where the pieces are:

rnbqkbnr
pppppppp
........
........
........
........
PPPPPPPP
RNBQKBNR


The first assumption you will make is that the list of moves passed is a VALID chess game, to completion. The following would be an example input:

[[A2,A4],[A7,A6],...]


The first two moves given would result in:

rnbqkbnr
pppppppp
........
........
P.......
........
.PPPPPPP
RNBQKBNR


Which is white's first move, followed by black's move:

rnbqkbnr
.ppppppp
p.......
........
P.......
........
.PPPPPPP
RNBQKBNR


Then, you would continue parsing moves until a king disappears. Whichever king is left should be declared the winner.

# Waiting to Gauge Interest Before Wasting Time on Full Testcase

• – AdmBorkBork Jul 24 '17 at 18:09

## Nested list unpacking code-golf

In Python 3.5+, the * operator can unpack a list within a list.

[1,*[2,3,4],5] == [1,2,3,4,5]


The unpacked elements are placed directly into the outer list without increasing the list depth. Note that this is different from the nested three-element list

[1,[2,3,4],5]


Your goal is to simplify a nested list expression by resolving all instances of unpacking. So, the output will simply be a nested list without any *.

Specifically, the input will be an expression that consists of

• A non-empty list of expressions [..]
• An non-empty unpacked list of expressions *[..].
• A digit 1 through 9

The outermost layer will always be a non-empty list. The output is such an expression without any unpacking.

Input: A string of characters [],*123456789

Output: Its unpacked analogue. This can be a string or list structure.

This challenge can be done in any language. Python and other languages with the same unpacking format may not use eval or exec or equivalents.

TODO: I/O details, test cases

• This is similar to least Levenshtein distance to a balanced list (replace *[ with { and then remove unbalanced ]). – Peter Taylor Jul 25 '17 at 7:20

# Tell me my vocabulary words! Donated.

When taking textbook notes, I need to write down the vocabulary words and their definition. So your task is to write some code that will give me the vocabulary words and their definitions!

Vocabulary words are detonated with a * on both sides of them, like this: Sentences are .-delimited, meaning that after every . a new sentence starts. An example of a valid sentence would be: This sentence has a *vocab word* in it. The vocab word in the sentence is 'vocab word'.

Input: A string of text with some words marked with asterisks. Only valid inputs will be provided, meaning that only sentences with exactly two asterisks inside of them, and there is something between the asterisks.

Output: A list or delimited string where each item is in the following format: Vocabulary word: sentence. The Vocabulary word is the vocab word found in the sentence. The sentence must be the one with the emboldened vocabulary word in it. If there is any whitespace other than the  s separating the words, it needs to be stripped.

Test cases:

Input: *Alan Turing* invented the Turing machine. A *Turing machine* is a machine that follows simple rules, but is capable of any computation.

Output: *Alan Turing*: *Alan Turing* invented the Turing machine.
*Turing machine": A *Turing machine* is a machine that follows simple rules, but is capable of any computation.

Input: What is code-golf? *Code-golf* is the best site on the SE network. But what is SE, you ask? *SE* is a group of Q&A sites, with a system to prevent bad posts.

Output: *Code-golf*: *Code-golf* is the best site on the SE network.
*SE*: *SE* is a group of Q&A sites, with a system to prevent bad posts.

• So split on '.' and then filter to strings containing a *? Or can there be asterisks which don't mark vocabulary words? Should we trim whitespace at the start and end of the sentences? – Peter Taylor Apr 6 '17 at 9:54
• @PeterTaylor A string surrounded by * is a vocab word, like this: *vocab word*. You need to format the outputted sentence correctly, and trim whitespace. I will edit when I have more time. – Comrade SparklePony Apr 6 '17 at 13:52
• Are the following valid inputs or not? a) Unbalanced* asterisk; b) Empty ** vocabulary word; c) Vocabulary* word *has bad spacing. – Peter Taylor Apr 7 '17 at 10:05
• Only the last one is valid. – Comrade SparklePony Apr 7 '17 at 13:25
• The latest wording "only sentences with exactly two asterisks in them" suggests that there's no need to filter: just split on ., trim, and prepend Vocabulary word:  to each sentence. – Peter Taylor Apr 7 '17 at 21:03

# Base 32 RFC 4648 Compliant Alphabet!

When writing my handy-dandy totp/hotp token implementation in Python and Swift (ad: here), I encountered for the first time RFC 4648. There is a nice and long memo about RFC 4648, but I only had to focus on a very specific part of it: Page 8. If you are bored and want some enthralling reading, you can find this memo here, and a useful table here.

Basically, I was looking for the alphabet that could be used when base 32 decoding a String. Well, this is it: ABCDEFGHIJKLMNOPQRSTUVWXYZ234567, and padding, =. However, simply printing that is not the challenge –– that would be too simple1. Instead, we are going to print this (the comments are for your reference and do not need to be printed):

__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x00 - 0x0F or   0 -  15
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x10 - 0x1F or  16 -  31
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x20 - 0x2F or  32 -  47
__,__,26,27, 28,29,30,31, __,__,__,__, __, 0,__,__,  // 0x30 - 0x3F or  48 -  63
__, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,  // 0x40 - 0x4F or  64 -  79
15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__,  // 0x50 - 0x5F or  80 -  95
__, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,  // 0x60 - 0x6F or  96 - 111
15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__,  // 0x70 - 0x7F or 112 - 127
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x80 - 0x8F or 128 - 143
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x90 - 0x9F or 144 - 159
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xA0 - 0xAF or 160 - 175
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xB0 - 0xBF or 176 - 191
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xC0 - 0xCF or 192 - 207
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xD0 - 0xDF or 208 - 223
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xE0 - 0xEF or 224 - 239
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xF0 - 0xFF or 240 - 255


There may be trailing spaces after every line, and trailing newlines after the last one.

Also, the single digit numbers can be written as 0[digit] instead of [space][digit]. However, be sure to include the spaces between the four groups.

By the way, the __ actually represent 255, but the former do not make me drown in a sea of digits.

1 Should the challenge be to just print that string?

Any other suggestions to make this challenge more interesting?

• Perhaps get a list of characters (of any length) and print such a table? – ugoren Jul 29 '17 at 19:14

# Is this 2048 board valid?

Some 2048 boards are impossible to get into. For example,

2 _ _ 2
_ _ _ _
_ _ _ _
2 _ _ 2


will never occur in a 2048 game. Additionally, these are all impossible:

8 _ _ 8    8 _ _ _    2 2 2 2
_ _ _ _    _ 8 _ _    2 2 _ _
_ _ _ _    _ _ _ _    _ _ _ _
8 _ _ _    _ _ _ _    _ _ _ _


Your program needs to accept a 2048 board, and return a truthy value if the board is reachable, else falsy.

//Explanation of 2048 goes here.

I've listed 4 different boards that cover major test cases. Are there any others I'm missing?

• hehe, don't forget [tag:sliding-puzzle] – Stephen Aug 1 '17 at 19:56
• As you've stated yourself the main thing missing here is the bulk of the challenge. – TheLethalCoder Aug 2 '17 at 9:14
• I wonder if it suffices to look one step back, or if you need to check if the previous position can itself be produced. – xnor Aug 4 '17 at 7:35

# Smooth Usage [On hold while alternative scoring is considered]

We've all seen CPU usage graphs like this one:

Doesn't that look ugly? It would look much nicer as a lovely smooth sine wave...

## Challenge

Write a program in the language of your choice that will infinitely produce a regular sine wave in Task Manager's (or Activity Monitor's if that's your thing) CPU usage graph.

You may assume:

• Background CPU usage is constant
• Only a single core must display the pattern
• The system has sufficient cooling to prevent thermal throttling
• Features such as Intel TurboBoost are disabled

This is tagged as to encourage short answers, but ultimately will be a as I suspect perfect solutions will be hard to come by.

• – MTCoster Aug 11 '17 at 15:14
• code-golf and popularity-contest don't mix together. You have to choose one or the other, but making it strictly code-golf would be difficult because you'd have to define what is a good enough sine wave, but on the other hand popularity contests are very risky to do. – dzaima Aug 11 '17 at 15:16
• @dzaima That was exactly my dilemma - which would you suggest fits the challenge best? – MTCoster Aug 11 '17 at 15:17
• I'd say a scoring algorithm of some sort would be best for this, no idea how you'd do it. Like the related one was objective. If you could read the word, it was valid. With this, is a bumpy sin-wave a sin-wave? – Magic Octopus Urn Aug 11 '17 at 20:39
• @MTCoster If you're not sure whether popularity-contest fits, then you can be sure that it does not. It is quite difficult to make an well received one. Go with code-golf or make a code-challenge if you can come up with a good own winning criterion. – flawr Aug 11 '17 at 20:53

# Time bomb ping pong

## Challenge - Both teams

All users are divided into two teams based on their PPCG ID. For example, my ID can be found here, from which you can see that my ID is 34388. To check on which team you are, run the following snippet:

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

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);
bank = bank - (price * 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: