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

# Introduction

You've calculated which of the first n numbers are prime, and want to save your achievement for all future generations. Unfortunately, you're broke, and want to minimize storage costs (you'll be paying them forever, after all.)

You need to determine the best way to pack all of the primes <=n and still be able to answer the question "is p prime?" in O(1) time.

# Challenge

A submission to this challenge must include both a compress algorithm and an isPrime algorithm.

### compress

Input: n -- the number that you have checked prime-hood through.

Output: Bytes to feed into your isPrime algorithm.

### isPrime

Input: The output of your compression algorithm, and an integer i >= 0. i is guaranteed to be <= n.

Output: True if i is prime, otherwise False.

This algorithm must run in O(1).

The winner of this challenge is the (compression, isPrime) pair that is

• Correct
• Has the best compression ratio, as determined by the average compression ratio for

n in {10^3, 10^4, 10^5, 10^6, 10^7, 10^8, 10^9}

as compared to the naive solution below.

Consider the following solution in Python:

def compress(n):
# simple sieve of Eratosthenes. Note: this is not a
# prime generation challenge; a list of the first
# billion numbers will be provided in this format.
primes = [1] * (n + 1)
primes[0] = 0
primes[1] = 0
upper_bound = int(math.sqrt(n)) + 1
for i in range(2, upper_bound):
factor = i
if not primes[factor]:
continue
factor += i
while factor <= n:
primes[factor] = 0
factor += i
primePackStr = ''.join(str(i) for i in primes)
return primePackStr

def isPrime(compressed, i):
return compressed[i] == '1'


# Example Input and Output

Input to compress:

20

Output:

"001101010001010001010"

Input to isPrime:

("001101010001010001010", 13)

Output:

True

# Notes

• This is not a prime generation challenge. The compress executable can assume that there is a file called primes.txt in the same directory that contains the first billion numbers in the format s[i] = 1 if i is prime, 0 otherwise. (Zero-indexed)
• Naturally, the isPrime executable cannot make use of this file.
• The isPrime executable must not hardcode any primes.
• Please provide instructions on how to compile/run your code on either OSX 10.12 or Ubuntu 16.04, if it's not obvious.
• This is not a code golf challenge. Any length of code is fine, as long as isPrime doesn't attempt to cheat.

# Notes for sandbox

• Any thoughts on a better restriction than "The isPrime executable must not hardcode any primes?"
• Should I test on random values of n instead?
• thanks!
• This is an interesting idea, and I hope it can be made to work, but it does have a big problem in the subtlety of what you mean by saying that isPrime must run in O(1) time. Interpreted with maximum pedantry, it's impossible because O(1) time isn't sufficient to read i from the input, even assuming random access to the input (which some key models of computation don't, and many interpreters won't give you). – Peter Taylor Mar 8 '17 at 9:12
• If you instead restrict answers to accessing a fixed (independent of n and of the length of the compressed text) number of bytes of the compressed text and doing a fixed (independent of n and i) amount of processing on them, you're pretty much killing the challenge because the only feasible compression will be bit-packing with a wheel and the competition will just be how big to make the wheel. – Peter Taylor Mar 8 '17 at 9:12
• In particular, a wheel size of 10^9 would trivialise the challenge. – Peter Taylor Mar 8 '17 at 12:38
• As far as your first comment goes, I could clarify to say that isPrime can assume that the entire output of compress is already in memory - or that isPrime may be called many times, with different i but the same compressed and it only has to be amortized O(1). Unfortunately, you're totally right about the prime wheel - though the idea is that the algorithm would work for arbitrary values of n, not just up to 10^9. – vroomfondel Mar 8 '17 at 14:34
• Maybe I could entirely remove the isPrime in O(1) restriction and simply make this a challenge about the most efficient compression algorithm for prime numbers. (Allowing arbitrary compression.) @PeterTaylor – vroomfondel Mar 8 '17 at 14:34
• If you do that then everyone will compress the list to 0 bytes unless you fix the decompression. A variant which might work is to ditch isPrime and say that the output of compress will be passed through zcat | sort -n so that the challenge is finding a good ordering of the primes which exploits Lempel-Ziv behaviour. – Peter Taylor Mar 8 '17 at 14:45
• That might be interesting, though I'd need to add some sort of polynomial time restriction - you could theoretically test all O((n/(log n))!) orderings of primes <= n otherwise. I'm going to abandon this for now, but may come back eventually if I have an epiphany. Thanks for your help! – vroomfondel Mar 8 '17 at 14:56
• This is a really interesting idea, and I hope you can come up with a way to make it work successfully. – AdmBorkBork Mar 8 '17 at 21:00

Challenge about loudly interjecting in a courtroom

One of the most important things about being a courtroom lawyer is loudly interjecting before you make your point. In this challenge, we're going to edit a typical courtroom transcript to include these interjections.

Any lawyer (and in fact, any character at all in the transcript), uses these rules to interject:

1. Use an interjection when the character who is speaking changes to you.

Take the following example:

SAHWIT: I remember the time I found the body exactly.
SAHWIT: It was 1 P.M.
PHOENIX: Frankly, I find that hard to believe!


There is one change in speaker, so an interjection will be added in at that point like this:

SAHWIT: I remember the time I found the body exactly.
SAHWIT: It was 1 P.M.
PHOENIX: Hold it! Frankly, I find that hard to believe!

1. Use Hold it! if the previous statement ends with a single full-stop or exclamation mark, Take that! if the previous statement ends with an elipses (...), and Objection! if the previous statement ends with a question mark.

For instance:

JUDGE: What evidence proves the clock is running slow?
PHOENIX: The victim had just returned from abroad the day before the murder.
PHOENIX: The time difference between here and Paris is 9 hours!
PAYNE: But modern day clocks automatically adjust for time zones...
PHOENIX: This is an antique!


Becomes:

JUDGE: What evidence proves the clock is running slow?
PHOENIX: Objection! The victim had just returned from abroad the day before the murder.
PHOENIX: The time difference between here and Paris is 9 hours!
PAYNE: Hold it! But modern day clocks automatically adjust for time zones...
PHOENIX: Take that! This is an antique!


That's about it. I'll write some longer test cases a bit later. This challenge is probably Retina-bait to be honest.

• This challenge might work better if the interjections made more sense in context. For example, "Objection!" likely works best after questions (as most objections in an actual court case are to try to invalidate a question that fails to follow the rules). – user62131 Mar 14 '17 at 4:35

# Garbled Phone Numbers

(de)

You know how you get a voicemail message and the person's connection wasn't great, and you're trying to figure out how to call them back, but you're not sure if that was a "5" or an "8" they said?

That's this challenge.

The good news is that the caller read off their number twice, but it's garbled in both places.

Your program should take input like this:

5551231234 / 5551231234


Where the first seven digits are the first time the phone number is said in the voice mail and the second set are the second time it's said. Only...it'll look more like this:

555?AAA1_36? / 55?522_1?234


A digit followed by a question mark means that that's the best-guess for that digit (e.g. "5?" means "probably a 5, compare with repeat"). An underscore indicates a known missing digit, something too fuzzed by static to be deciphered at all. Letters are just that: letters. Treat them as their respective digits (ABC -> 2, DEF ->3, HIJ -> 4, etc).

You can safely assume the following judgement calls:

5? / _     -> 5  //5 is the best guess we have, use it
5? / 4?    -> ?  //conflict
5 / 4     -> ?  //conflict
5? / 4     -> 4  //solid information overrides possible value
5 / 4?    -> 5  //solid information overrides possible value
_ / _     -> ?  //no information available


Additionally you can assume that all inputs will contain ten-digit phone numbers, not including the question marks. Inputs that aren't ten digits (e.g. 1234567 / 1234567) can either be treated as unsolvable (falsey output) or throw an error.

Output option A: Output a truthy value indicating whether or not a given input can be resolved to a single valid ten-digit phone number.

Output option B: If it can be parsed to a single valid ten-digit phone number, output the phone number. Otherwise output some form of error indication (e.g. -1, false, empty line).

Shortest wins, as per usual.

[Sample inputs]

• I'm not sure what your intended meaning for letters is. If it's just A=1,B=2,C=3... then they're a bit pointless and weird in this context. You should also probably choose only one between option A and option B before posting (I vote for B). – Leo Apr 9 '17 at 16:39
• @Leo Letters as they appear on a dial pad: A,B,C = 1, DEF = 2, GHI = 3, etc. – Draco18s no longer trusts SE Apr 9 '17 at 21:05
• You need an explicit mapping for letter→number. Most phones I've seen map A/B/C to 2 (apparently they follow this international standard). – user62131 Apr 9 '17 at 22:07
• @ais523 Whoops, that's what I get for posting late at night just before bed, then making the comment gia tablet at a rest stop somewhere in western Pennsylvania, 6 hours from home. – Draco18s no longer trusts SE Apr 10 '17 at 4:43
• I think you should omit 'output option A' and just keep B; B includes A pretty much. – officialaimm Apr 10 '17 at 9:36
• @officialaimm I think that's the beret idea, yes. There were a mess of ideas running around in my head, such as scoring based on a given input list, but never congealed well enough to make it to paper. A and B were the only two that did. – Draco18s no longer trusts SE Apr 10 '17 at 12:18
• Any other comments before I start generating some inputs and posting it? – Draco18s no longer trusts SE Apr 17 '17 at 19:46

# Write a "21" game in exactly 21 characters code-bowling

## Challenge

You must write a program which implements the following algorithm:

Let x = 0
Let y = truthy value
while (y is not falsy AND x <= 21) do:
Let x = x + a uniform random number from {1,2,3,...,11}
Output the value of x
Input a value of y from the user (you may assume input is valid)
Output the value of x


(You do not have to follow the pseudocode exactly. For example, if your language happens to initialise variables to a truthy value automatically, you don't have to include the y:=TRUE line. Similarly, you don't have to use a while loop. The important thing is that it repeatedly takes user input until either x exceeds 21 or the user chooses to stop, and it outputs the current value of x after each user input.)

## Score

Let n be the length of the shortest program which meets the spec which can be obtained by deleting 0 or more characters from your code. Then your score is:

- 500            if n > 21
- 1 + (n-21)^2   if n < 21


The winner in each language is the program with the lowest score.

## Questions

• Is this a resonable idea? I can't find similar challenges, so maybe there is a problem with ones like this? (Trivial solutions etc.)
• Is the specification too complicated (maybe more languages could enter if it was a simpler algorithm, for example just taking user input once?)
• This victory condition is code-shuffleboard. I don't think it adds much over just doing golf, though; it's normally fairly easy to pad out a program in a way that can't be fooled via simple character deletion. (Also, I suspect 21 characters isn't enough in most languages, although golfing languages should be able to beat that; it'll be interesting to see whether some of the terser practical languages can.) – user62131 Apr 11 '17 at 12:31

# Tetris Programming

Your program or function should take as input one character from the set IJLOSTZ, which represents one of the seven tetrominos as usual:

I  J   L   O   S    T    Z

#   #  #   ##   ##  ###  ##
#   #  #   ##  ##    #    ##
#  ##  ##
#


You should output the number of shapes which are equivalent to this tetromino up to rotation. For example, the I only has two arrangements, horizontal and vertical, whereas the J has four different orientations. The O looks the same no matter how you rotate it, so there's only one shape. Here all possible input/output pairs:

I  2
J  4
L  4
O  1
S  2
T  4
Z  2


## The Source Code

The main part of this challenge is the source code restriction:

• You may choose either linefeeds (LF, 0x0A), carriage returns (CR, 0x0D) or LR-CR pairs to represent newlines in your code (consistently). These split the source code into a 2D grid of lines (which aren't necessarily the same length).
• This 2D grid must be completely made up of tetrominos where all 4 characters in each tetromino must be the same. For example, this would be a valid program:

aaa
bba
cbddd
cbd
c
c

eeee


Note that the individual characters don't necessarily need to be distinct, so there may be larger connected regions of the same character, as long as this region can be segmented into non-overlapping tetrominos. Also note that this restriction also applies to spaces, so the following is not a valid program, because the two spaces don't form a tetromino.:

  x
xxx


## The Score

For each of the seven tetrominos count how often it appears in your source code. Your score is the maximum of these seven values.

That means you don't want to make up your code entirely of Is but instead try to use about the same number of each of them to keep the maximum of the seven values down.

## The Small Print

You may either write a programs or a functions and use any of the standard methods of receiving input and providing output, as usual. Note that these loopholes are forbidden by default.

• It strikes me that most solutions are going to put most of the code in a comment, and it wouldn't surprise me if a score of 1 were achievable in some languages. Do you consider that reasonable? – user62131 May 5 '17 at 12:25
• @ais523 I'm not sure about the task yet. It's hard to find something that isn't too hard for the restriction to become a pain but that is intricate enough to allow people to use several parts of a tetromino. – Martin Ender May 5 '17 at 14:25

So I've been puzzling over the best way to present this idea I had, so this will probably need a lot of help. I am open to completely reworking the challenge, but this is the best polish I've managed to figure out so far.

At work I have to secure my laptop with one of those 4-digit cable locks and it occurred to me that there was a puzzle here: figuring out the combination by looking at the typical behavior of setting the lock: never allowing any given wheel to "rest" on its unlocked value. e.g. if the combination is 1234 then never walking away with a 1 in the first position, a 2 in the second, and so on (e.g. 1111 would not be considered locked, but 2111 would be). Or possibly by not letting any digit of the unlocked combination be visible (so even 2111 would be "bad" but 6789 would be ok...unless a transpose was also considered to be insufficiently random, however such choices are often up to the user of the lock). I also subsequently changed my behavior (not that I have any real risk of my laptop being stolen).

A standard challenge of "write some code that examines a series of locked values to determine the unlocked value, scoring by number of entries needed" is non-viable, as the sequence list would need to be carefully chosen such that there is a strictly known optimal solution (i.e. a minimum number of locked values), as finding a shortcut in that specific sequence might be possible, but invalid on another sequence.

Then the other night it occurred to me that it might be possible to do this as : one side has to randomize their locks (albeit following a set of rules that allows exploitation), the other side has to break them open. The downside being that it will be a nightmare to validate scores as there will be no easy way to pipe input and output back and forth between two programs running arbitrary languages.

I'm also not sure if there's enough room for freedom in designing the lock randomization code (i.e. interesting for the cop) for it to be plausibly crackable without resorting to brute force (an uninteresting challenge for the robber). Ostensibly the robber half is brute force, but it's guided in some manner towards a determinable value ("ah, I see, the first spindle is never set to 1 when locked, ergo the first digit in the code must be a 1) rather than indeterminate ("ah, I see, no spindle is ever set to 1, ergo there is a 1 somewhere in the code" -> 4 digits ^ 4 spindles -> 256 plausible values with further attempts gaining no new information).

# Combination Locks (Cops)

Your goal is to write a program that produces a 4 digit random number as a combination lock entry code. Your program needs to keep this value a secret, but must produce output that is the result of the lock being locked and its tumblers spun, the value printed being the digits shown along the set row (8585 in the above image).

Your program will then take input of a 4 digit code that is an attempt to unlock the lock. If it is the correct value, output the number of attempts made and the seed value, otherwise print another randomized lock value. Repeat until successfully unlocked.

Rules:

• Your program must have some way of setting the combination (for scoring), eg. providing a seed value for the random number generator (inputting the correct combination is allowed).
• All locked combinations must be considered random. However:
• The nature of "random" is what is to be exploited here. Obviously you wouldn't want your random lock to actually remain unlocked after shuffling the dials!
• You may chose any rules by which to keep the lock locked, provided that it can be exploited. No outputting 0000 every iteration or cycling between predetermined sets (1234,4567,7890,1234). You're trying to emulate what appears to be smart behavior of a human being, not create an unbreakable lock.
• Every digit from 0-9 should be possible with some degree of uniformity. That is, if the correct combination is 1234 you are allowed to prevent 1 from showing up as the fist digit, but you may not prevent 1 from showing up in other positions.
• Blanket removal of all four digits of the combination from all four columns reduces the problem to brute forcing 256 possible combinations.
• Similarly, allowing a ban on a digit for up to three columns reduces it to brute force against 3136 possible combinations (banning only the combination digits from 3 columns is 81 possible combinations). None of these are interesting challenges.
• Entries shown to devolve to a brute force guessing will score based on the worst-case lucky guess (i.e. the number of attempts needed to identify the brute-force point, +1).
• If your language does not have a way to "wait for input" then....??? (requirements for fixed-seed randomness across multiple attempts, e.g. for a given combination and the same number of attempts made, the next output should be the same)
• Your program should store no data about attempts to break the lock or prior output values, the only data that may be stored are the Random instance (if needed), the correct combination, and number of attempts made. Outputting an attempt value back out (intentionally) would be underhanded.

# Scoring

The ratio of your code's byte-length to the best (lowest) number of attempts needed by any robber against your lock.

# Combination Locks (Robbers)

Your goal is to exploit the non-pure-random nature of locked 4 digit combination lock. After all, no one leaves a portion of the correct code in the lock after they shuffle the wheels!

You are to write a program that attempts to deduce the correct combination for a given lock, given only a series of locked (incorrect) combinations. Your program will read a single 4 digit number as the current state of the lock and produce a 4 digit number output as an attempt to unlock the lock. If additional input is given, the attempt was unsuccessful. Your program need not self-terminate (i.e. there is no requirement to take input telling your program that it was successful; ctrl-C interrupt is succificient).

As you are an accomplished thief, you know exactly how each lock gets randomized. You are to exploit the built-in rules to bypass the lock in the fewest number of attempts by looking for patterns in the lock's "output" and narrowing down the list of possible correct combinations.

• Locks will have a way to predetermine their combination (e.g. random seed or specific 4 digit combination). Your program may not know these values, they are used for scoring only. Remember the standard loopholes: hardcoding the output is disallowed.
• If a human is unable to find the solution with the data known at that the point of solving, the number of attempts will not count for scoring as it can be considered a lucky guess (arbitrary threshold: 10 or fewer attempts will be automatically assumed as such). This should be treated like a logic puzzle, not a slot machine.
• If your language of choice doesn't do "programs" it is acceptable to write a function taking in an array of inputs [XXXX, AAAA, XXXX, BBBB, XXXX] (where XXXX represents the combinations displayed on the lock, and AAAA/BBBB represents the prior attempts made) or similar. Note that there will be one more value from the lock than values from attempts, as your function would be producing the paired half as its output.
• Supplementary output to support ease of alternative input methods acceptable (e.g. a newline followed by the input array for the next iteration to be copy-pasted).

# Scoring

The ratio of your code's byte-length to the best (lowest) number of attempts needed top open any lock.

• @Ilikemydog I browsed other cops and robbers questions while writing, scoring did not seem unusual. This one has scoring, so does this one, and this one calls for short code (typical scoring method), while this one scores based on number of different cops entries cracked. However, that's not my main concern, "I'm also not sure if there's enough room for freedom in designing a lock.." – Draco18s no longer trusts SE May 28 '17 at 18:06
• never mind then. I'll delete the comment. I'd like to give you some more feedback but I didn't follow some of it (mfny) and all I can say is have a +1 – caird coinheringaahing May 28 '17 at 18:11
• No feedback, except I've had this exact thought that a code could be guessed by tracking where the lock was left set to when it was locked over time. Similar idea, but you actually fleshed it out. – BLT Mar 11 '18 at 19:48
• @BLT That was pretty much where I'd been approaching from. Still not sure there's a good code challenge here, though. :\ Thanks for the look over! – Draco18s no longer trusts SE Mar 12 '18 at 3:15

Wasn't able to find anything in my searches, but please let me know if this or something very similar has been done before. Appreciate any feedback, first post in sandbox.

## Can I leave yet?

I'm bored at work, and want to know how close I am to being able to go home. To represent this, I wish to know what percentage of work I have completed for the day.

Inputs

None - Current local/computer time shall be used

Outputs

Percentage of work completed for this day

• Formatted as either a percentage value or a decimal value: 0.57, .57, 57%, 57.0%
• Output should be accurate to at least +/-0.5%. Additional accuracy/digits are allowed.
• The work day is a total of 8 hours.
• Work starts at 08:00, and ends at 17:00.
• Lunch is between 12:00 and 13:00. Working during lunch is forbidden, and thus should not count towards the percentage of work completed.
• Output should be correct during any time of day, including before work starts (0%) and after the work day ends (100%).

The response for a full 24 hour day is shown below:

Valid Test Cases

Time Ran     Output
03:55        0%
04:31        0.000
08:00        0
09:00        12.5%
11:31        44%
12:37        .5
16:30        0.94
21:08        100%


Incorrect Test Cases

09:00        12.5     (Interpreted as 1250%
11:31        43%      (Error of 0.9%)
12:37        .58      (Did not account for lunch)
16:30        0.9      (Error of 3.8%)


Notes

• I work 7 days a week 365 days a year; you do not need to check if it's a weekend, holiday, etc.
• I live in an area with no Daylight Savings Time, Leap Seconds, or any other confusing time-changing events.

This is , so lowest byte-count score wins.

• Does no feedback mean it's perfect the way it is and I should post it? Or it's so bad that nobody wants to touch it? – qoou May 24 '17 at 16:08
• I think it's pretty solid. – CalculatorFeline Jun 20 '17 at 14:57

This is mainly an idea for something I could potentially host on my KOTH server.

Everybody knows that bitcoins are the next big thing. It's just a question of when they are going to take off. Right now, they are worth $250 each, but who knows, maybe someday they will be worth over$1000! The growth trend is phenomenal.

You are a tech-savvy investor who wants to get in on this action.

# The Challenge

Your goal is to write a bot that can predict the market and tell you how you should invest your money, given hourly updates of the Bitcoin price.

## Keeping Balance

To overcome the fastest-gun-in-the-west effect, wherein early answers have more time to make more money, this challenge will not keep track of any absolute balances. Instead, the assets of each entrant will be scaled up/down between each round.

Each entrant will be given a single float in the range 0 to 1 representing the percent of total assets are currently invested in Bitcoin. This is calculated by (BTC_cur_rate*BTC_owned)/(USD_owned + BTC_cur_rate*BTC_owned).

A value of 0 means that you currently have nothing invested in Bitcoin, while a value of 1 means that you have everything invested in Bitcoin. An input of 0.3 means that 30% of your total value is in Bitcoin, while the other 70% of your value is in dollars.

Examples

input    ->    assets as portion of your total value
BTC     %      USD     %
0.0     ->      0.0    0%      1.0  100%
0.3     ->      0.3   30%      0.7   70%
0.6     ->      0.6   60%      0.4   40%


## Price Data

Players will also have access to a file history.txt which will contain the BTC price history, measured in cents, over the duration of the competition. Each time a player is called, they are presented with a fresh copy of history.txt, with one line appended each turn. Do not attempt to modify this file.

Example File

This could be the history.txt file after 3 hours of competition. The most recent price is $247.49. 24694 24724 24749  There will be a trailing newline at the end of the file. ## Making a Trade (ouput) The output of your program should be another float in the range of 0 to 1, representing the new portion of your assets that you want invested in Bitcoin. The difference between your input number and output number represent the amount of value being exchanged. Examples input -> BTC USD | output -> BTC USD | trade being made 0.3 -> 0.3 0.7 | 0.2 -> 0.2 0.8 | 0.1 in BTC -> 0.1 in USD 0.3 -> 0.3 0.7 | 0.6 -> 0.6 0.4 | 0.3 in USD -> 0.3 in BTC  # Calculating Score for a Round Your score for a round is based on your change of value for that round. You start every round with a total value of 1, but your ending value is influenced by two things: • A 0.2% commission on your trade taken by the controller • The change in Bitcoin value over the next hour ## Taking Commission Commission is taken whenever you buy or sell bitcoins. Whenever you convert a certain amount of value from one currency to the other, you will receive 0.2% less of the new currency than what you actually ordered. Examples input | output | trade | commission | result after commission 0.3 | 0.6 | 0.3 -> BTC | 0.0006 BTC | 0.5994 BTC & 0.4 USD 0.75 | 0.05 | 0.7 -> USD | 0.0014 USD | 0.05 BTC & 0.9486 USD  ## Adjusting BTC Value After taking commission, your value of BTC is multiplied by the price percent change in BTC over the next hour. The amount of value you have in USD will stay constant. Examples BTC after commission | prices in cents | % change | new BTC value 0.5 | 30000 -> 29850 | -0.5% | 0.4975 0.236 | 20000 -> 30447 | +2.0% | 0.24072  ## Overall Process of a Round Below is an example showing all of the steps in a single round. BTC USD .3 .7 = 1.0 input to entrant is 0.3 .6 .4 = 1.0 output of entrant is 0.6 .0006 .0 0.2% commission of the trade .5994 .4 = 0.9994 result after commission +0.3% percent change in bitcoin price over 1 hour .6012 .4 = 1.0012 result after the flow of time = score for that round .60048 .39952 = 1 input for the next round is 0.60048 after scaling  ## Determining the Winner For a given round, your score is your new total value. This is after taking the 0.2% commission and calculating the change in Bitcoin value. For the above example, the score was about 1.0012. At any given time, the aggregate score for an entrant shall be the product of the scores for its most recent (up to) 50 rounds. At any given time, the current winner is the player with the highest aggregate score. For example, a bot could get these scores for its first 5 rounds: 1.001 1.002 0.998 0.999 1.003. The total score of the bot is about 1.00299. ## The Controller I haven't written the controller yet, but I think it's going to be written in Perl with support for entrants in a variety of other languages (Java/Python/Ruby/C++). I plan to use this API for bitcoin price data. The controller will probably run all of the entrants in parallel, each with their own thread. This simply allows it to put a stop to any infinite looping that may occur. I hope it will work if all of the programs are reading the same history file at once. ## Additional Rules Since this is a PvE competition and not a PvP competition, and takes place on a server, there are some slight differences in rules. • There's no set restriction on submitting multiple bots, since you can't make a team. • Similar to always, you can't call other programs, like the controller or other bots, during your turn. • The time limit is loose. A long as a single round with all of the bots doesn't take up most of an hour to perform, it'll be fine. It really shouldn't take more than a couple minutes for each bot to make a move. • You may create a single file, with the filename [botname]-data.txt, in the current directory. This file will persist, even across updates of your bot or the controller. • 1. What determines whether the commission is taken in bitcoin, dollars, or some mixture of the two? 2. What is the score of a round? (It's mentioned in the example, but it needs to be more prominent). 3. Is there any input other than the balance? Or are entries allowed to access external data sources? Or is it pure uninformed guessing? – Peter Taylor Oct 11 '15 at 20:09 • @PeterTaylor I've added some details. I'm not completely decided on how much data the entrants will be able to access/store. Right now it is just the price history. – PhiNotPi Oct 11 '15 at 23:41 • Do you have access to Mathematica? Also, how precise are the input and output? – LegionMammal978 Oct 16 '15 at 1:04 • How much of your assets are in BC to start with? – LegionMammal978 Oct 21 '15 at 23:59 • IT'S 2016 AND PHINOTPHI STILL HASN'T... /s – noɥʇʎԀʎzɐɹƆ Dec 12 '16 at 2:29 # Build the Chain Quine This is an puzzle. Each person will write a program that is not a true Quine but does output its source when given the source of the last program as input. If anything else is input your program may do whatever you wish (undefined behavior) as long as it does not print the source code. The first program will be a true Quine. # Rules • Standard rules apply • You may not write a submission in a language that has already been used • You may not answer twice in a row # Goal The goal is to have as many valid links in the chain as possible. # Sandbox This is a little sparse because I am still in the brain-storming phase of development. I just wanted to write this down so I wont forget it and, of course, to get feedback. I am not even really set on a winning criterion yet. If you have any ideas/suggestions I am really excited to hear them (thats why I put it in the sandbox). • This is semi similar to my answer chaining quine. So I wish you good luck – Christopher Feb 27 '17 at 16:36 • yeah sure thing! meta.codegolf.stackexchange.com/posts/11615 – Christopher Feb 27 '17 at 16:38 • – Christopher Feb 27 '17 at 16:40 • As with so many quine challenges, this falls afoul of universal quine constructors (and is also likely to get longer and longer over time, due to the need for each program to be able to reconstruct the previous entry, and thus implicitly all previous entries). – user62131 May 23 '17 at 8:51 ## Quine without a character Write a program in any language that takes as input any character, and outputs a quine in the same language, that does not contain that character. For instance (for some made up language): Input: b Output: s(fg;fg) Run "s(fg;fg)" Output: s(fg;fg) Input: ( Output: s[fg;fg] Run "s[fg;fg]" Output: s[fg;fg]  Your program must handle as input every character within the range of characters that are valid in the source code of the language you're using, including new lines, punctuation, etc. ## Scoring This is with penalties. Your score is L + 1000xC where: • L is the length of your program in bytes • C is the number of characters it fails to meet the requirements on. So, if you produce a 50-character program that passes every character except for ( and ), your score is 2050. Standard loopholes are forbidden, and standard methods of input/output are ok. Outputs must be a proper quine, whatever that is. • Basically a duplicate. The two challenges aren't quite the same (this one is more lenient), but the solution technique will be the same in both cases. – user62131 May 23 '17 at 6:17 • Ah, I didn't see that one. I think that one is much harder, because your program has to output the whole quine factory. In my version, it's just a quine factory that outputs quines to order. – Steve Bennett May 23 '17 at 7:35 # The alphabet - my way Your pointy-haired boss gives you a list of words and tells you to sort them. So you give him back a sorted list. "Wrong!" he says. "I want them sorted according to MY alphabet..." # Challenge Given a new ordering of the alphabet and a list of words, sort the words according to that new alphabet ordering. The new ordering is given as a 26-character string, guaranteed to contain all letter of the alphabet exactly once, in lower case. All words in the list of words will be made up of lower case letters only -- no capital letters or punctuation. There will be no repeat words. If there is a word in the list that is the prefix of another word, then the shorter (prefix) word should appear first in the sorting. For example, "golf" should appear before "golfing". # Examples ## Example 1 Input: qwertyuiopasdfghjklzxcvbnm apple banana currant dragonfruit elderberry fejoia  Output: elderberry apple dragonfruit fejoia currant banana  ## Example 2 Input: qwertyuiopasdfghjklzxcvbnm uranium plutonium uranus pluto polonium  Output: uranus uranium polonium pluto plutonium  ## Example 3 Input: abcdefghijklmnopqrstuvwxyz four score and seven years ago  Output: ago and four score seven years  • Shouldn't pluto/plutonium be before polonium – ASCII-only May 29 '17 at 11:26 • No, because 'o' comes before 'l' in that alphabet. Just like when you alphabetise using the standard alphabet, ties are broken by the alphabetical rank of subsequent letters. – Computronium May 29 '17 at 11:42 • Oh wait read polonium wrong sorry – ASCII-only May 29 '17 at 11:43 # Title ### Challenge In your language of choice, write 25 programs, functions, or snippets that output or return the integers 1 through 25, inclusive. However, the goal is to simultaneously minimize the number of distinct chars used and the length of the code. ### Scoring This is a variation on : If your 25 entries have N distinct characters and a total length of L, your score is N × (L + N). The submission with the lowest score wins. ### Example Say the challenge only went up to 10, and your ten snippets were: 1 2 3 4 5 6 7 8 9 10  That's 11 bytes total, and 10 distinct chars; therefore, your final score would be 10 × (11 + 10) = 210. Now, if your snippets were: 1 1+1 1+1+1 1+1+1+1 1+1+1+1+1 1+1+1+1+1+1 1+1+1+1+1+1+1 1+1+1+1+1+1+1+1 1+1+1+1+1+1+1+1+1 1+1+1+1+1+1+1+1+1+1  That's 100 bytes total, and 2 distinct characters (+ and 1); thus, the final score is 2 × (100 + 2) = 204, a small improvement over the literal numbers. One last example. If your snippets were: 1 -~1 1-~1 -~1-~1 1-~1-~1 -~1-~1-~1 11-1-1-1-1 11-1-1-1 11-1-1 11-1  That's 58 bytes total, and 3 distinct chars (-, ~, 1); therefore, your final score would be 3 × (58 + 3) = 183, an improvement over both. ### Rules • Each output may be a string of digits rather than a literal number. • Each output may have trailing decimals, as long as they are all 0s (e.g. 1.000 is allowed, but 1.000001 is not). ## Meta • Is 25 a good number? I originally had it at 100, but that seems a little tedious. • Will the scoring system work well enough? • Is this even a good idea? • Title and tag suggestions? • Unary/Lenguege/Glypho would automatically win, – Okx Jun 5 '17 at 17:37 • @Okx The length still factors into the score, so no, they wouldn't. – ETHproductions Jun 5 '17 at 17:41 • Ah, sorry. My mistake :P – Okx Jun 5 '17 at 17:49 • The "make a lot of snippets for the first few natural numbers" bandwagon already seems overloaded this week. – Peter Taylor Jun 5 '17 at 22:27 • @PeterTaylor Yeah, I'll wait a while before considering posting this to main... – ETHproductions Jun 6 '17 at 11:11 ## Compare string repetitiveness code-challengedecision-problem Given two strings, decide which one is more repetitive. This is the string whose most common character appears more often in it. If these are equal, then tiebreak by counting their respective second most common characters, and so on. Once a string's distinct characters have been exhausted, all further counts are zero. Give one consistent output if the first string is more repetitive, and a different consistent output if the second one is. You will never be given a complete tie. You may assume input strings will be non-empty and use only ASCII characters. Scoring: Your code's score is its repetitiveness, with comparing lower being better. Put in your header the counts of the top 3 most common characters, and the full frequency list in your body. Test cases: TODO • additional tie break is probably just timing (of the post, not the programs computations) – Destructible Lemon Jan 3 '17 at 8:17 • @DestructibleWatermelon I was thinking alphabetical order (in the code page). Maybe that's interesting to optimize? If not, yes, I'll make it earlier post as standard. – xnor Jan 3 '17 at 8:19 • A somewhat meatier task might be good, otherwise golfing languages might easily score 1 without even trying. Otherwise, I do think this scoring mechanism could be interesting. – Martin Ender Jan 3 '17 at 9:14 • Maybe you could use order-0 entropy. calculate it and the score is your own entropy? – Christoph Jan 3 '17 at 11:42 • I can't edit, so: "alternative is too have" -> "alternative is to have". To make the task harder, how about, when counting a specific letter, you start with the original string, but then each time it's found, the string you're going through is shifted by one through the Caesar cipher? – 0WJYxW9FMN Jan 3 '17 at 13:27 • I think I prefer it less-meaty. It presents it as an interesting scoring mechanism to main, and since languages don't compete against each other, I'd be rather interested in how well non-golfing languages fair. – Nathan Merrill Jan 4 '17 at 16:37 • I think I like this version better, as it isn't quite so easy for golfing languages while not being out of reach for some esoteric languages. – FryAmTheEggman Jun 7 '17 at 20:06 # Range without Range Builtin # Challenge Given an integer y where y > 0, output a list of in some reasonable format that contains every integer in increasing order up to but not including y, without using any builtin that generates a range of any sort. If your language has a feature whose specification uses a range, that is not allowed (for example, you cannot use the map quick in Jelly on a single integer because that maps over the range). You can assume that y will not exceed your program's capacity for integers, but it must be able to theoretically work on any integer given no memory, time, or otherwise language constraints. A format is reasonable for a list a = [a0, a1, ..., an] if and only if there exists a string x, a string y, and a non-empty string z such that the output is x + z.join(a) + y. • This seems extremely simple :P for(i=0;i<y;i++)printf("%d ",i); – MD XF May 26 '17 at 19:44 • @MDXF Yes, but there's a 4-byte solution in Jelly. :P – user42649 May 26 '17 at 19:48 • Which you have disallowed.... – MD XF May 26 '17 at 19:48 • @MDXF No, there's a 1-byte solution that I disallowed. There's also a 2-byte solution which I disallowed with the rule about the specification backend. Hint: Iterating through a list or iterating like you did is permitted. – user42649 May 26 '17 at 19:52 • Ah, now I see. This would probably get 50 submissions in 10 minutes, have fun with the clogged inbox :P – MD XF May 26 '17 at 19:53 • @MDXF I don't mind :P – user42649 May 26 '17 at 19:53 • I don't think this question would be closed, but I have to voice my dislike for this challenge. I am not a fan of banning builtins in the first place, I feel it has a number of issues. My main problem is it is hard to enforce/judge when someone is using a builtin. This challenge is going to take that and push it to its limits. I feel that this for this question to work you would need a very solid definition of what a built in is and I don't think such a thing can be made. – Wheat Wizard May 27 '17 at 0:24 • @WheatWizard Thank you for your feedback. I will try to get a fully objective way to determine what a builtin is and if I can find one I will mention you again in a comment for your review, and if I can't then this challenge will probably die and be buried by the rest of the sandbox posts because I don't want bad challenges :P – user42649 May 27 '17 at 0:34 • I'd recommend posting this after adding a few rules - in what order do the integers need to be printed? What's the max value y can be? "In a list of some reasonable format" is a bit too broad IMO. – MD XF Jun 7 '17 at 20:45 • @MDXF I will clarify in the post, thanks. – user42649 Jun 7 '17 at 22:07 • @MDXF "in increasing order" I think I clarified. – user42649 Jun 7 '17 at 22:07 • Looks great! My last suggestion is to make it a bit more readable: The # Challenge right at the top doesn't really add anything. And I'd recommend splitting the paragraph in half, i.e. making If your language has a feature whose specification uses a range... its own paragraph. – MD XF Jun 7 '17 at 22:09 • @MDXF Yes, that makes it much more readable. Thanks! – user42649 Jun 7 '17 at 22:10 • Also, the # Challenge is the header of the actual question; the title won't be there in the actual post. :) – user42649 Jun 7 '17 at 22:10 # Fence Matrix Given a positive integer n, output the 2n+1 x 2n+1 "fence"-matrix 0 1 0 1 ... 0 1 2 1 2 ... 1 0 1 0 1 ... 0 1 2 1 2 ... 1 ⋮ ⋮ ⋮ ⋮ ⋮ 0 1 0 1 ... 0  Alternatively you can also return a nested array or print a string (even with other entry delimiters than spaces or none at all) or output a raster image where each entry is represented by one pixel. ### Examples n = 1 0 1 0 1 2 1 0 1 0 n = 2 0 1 0 1 0 1 2 1 2 1 0 1 0 1 0 1 2 1 2 1 0 1 0 1 0  • related, but not at all close to a dupe – Destructible Lemon Jun 7 '17 at 23:13 • 1. The challenge should specify better about what constitutes a fence matrix. I suggest stating "A fence matrix is a representation of a square matrix where the 0-indexed element at index a of 0-indexed line b has the value a%2+b%2" – fireflame241 Jun 7 '17 at 23:25 • @fireflame241 This suggests using your particular solution, but there are many more to achieve that. – flawr Jun 8 '17 at 8:54 • @DestructibleLemon Ha, I would never have seen the connection if you did not point it out :) – flawr Jun 8 '17 at 8:54 # Obsfucation: Use Uncommon Chars Note that I do not have the SE lookup skills to set this up. An automated query would take this challenge a low way. If someone would like this to happen, I would greatly appreciate some help setting this up :) Basic search (currently searches for Jelly, anywhere) First, choose your language. It must have at least 100 answers on PPCG before the posting of this challenge, and at least 25 chars that are not no-ops. /* Click this query and insert your language's name to see if it is valid. If it is, this query will give you legal chars, and their point value */. Use those chars the complete the challenge. The lowest point value wins. # /*This Query //Can we do challenges for SE queries? If so this would be a decent one :) What I would like for this query to be: Gets all chars from the first codeblock following the language name in a heading. Accumulates all chars into a frequency table. Make sure that there are at least 25 relevant chars - we can human inspect this to insure no-ops are not polluting the data. It will then return the bottom 20% (frequency) of chars, rounded down, along with point values from 1-length for each of them. The least common chars will receive lower scores. Ties will have the same point value (do it like tournament rankings - 1,1,3, not 1,1,2.) Challenge answerers will only be able to use the chars provided. /Should whitespace be excluded (and allowed to be used, with a penalty) because of how SE treats whitespace?/ RE 25 char min: I really would like to get rid of this, but I don't know how else to prevent languages like BF from having an inherent advantage. Even if I restrict BF to 2 chars, it will score really low because they will have point scores 1 and 2.*/ # /*The Challenge I have not yet decided what the challenge should be - snippets to solve as many challenges, with point value as tiebreaker, might work, or a more difficult challenge. Input requested :) */ Anyone who would like may post this challenge to main. Just give credit to @Lordofdark. # How long will I sleep You need to go to bed, but what you need more is to know how long you will sleep until your alarm rings. ## Your task Write a program or function that takes a time (hours and minutes) as input, and outputs the number of hours and minutes until the next occurence of this time. ## Rules • In this challenge every clock in 24h format. • You must always get the current time for the same timezone; you can assume the input is in this timezone ### Input The input time must be in hours and minutes in any convenient 24h format for your language. Hours and minutes must always be separated by at least one character Valid inputs for 8h30: "8h30" 8H30M 8,30 8 30 [8,30] ... Invalid inputs for 8h30: 8.5 830 510min ### Ouptut The output is the difference between current time and the next occurrence of the input time (it can only be today or tomorrow). The same formatting rules apply : hours and minutes separated by at least one character an in 24h format. Note that the output will always be between 0h00 and 23h59 ## Examples : If it is currently 20h10 : 7h30 -> 11h20m 20h -> 23h50m 21h -> 0h50m  ## Challenge This is , so the shortest answer in bytes wins. Standard loopholes are prohibited • This is my first challenge so I'm not sure about the I/O rules – Fabich Jan 31 '17 at 14:51 • Hello and welcome to PPCG! :) Your challenge seems fine, though I recommend specifying that you should use a 24h clock earlier in the post. Aside from that, the "minutes are always two figures" part is a bit odd. Does that mean that if I used the format [8, 30] I would then have to return [8, 05]? Personally I would recommend just saying that hours and minutes have to be separate, as it is simpler and would require less space to show. – FryAmTheEggman Jan 31 '17 at 17:07 • What timezone is the input and the current time? Do we assume UTC? What happens if a language can't get the current time? – Artyer Jan 31 '17 at 22:16 • @FryAmTheEggman You are right I removed the 2 figures condition, and I specified at the beginning the 24h format. – Fabich Jan 31 '17 at 22:58 • @Artyer I guess I should add a condition about input and current being in the same timezone. Something like "You must always get the current time for the same timezone; you can assume the input is in this timezone". What do you think I could do for language without access to current time ? – Fabich Jan 31 '17 at 23:02 • @Lordofdark in general, it's good to not exclude challenges for arbitrary reasons, but in this case there's a very good reason for certain languages to not be allowed. If it can't get the time, it can't compete. – Pavel Feb 1 '17 at 0:37 • Are multi-character separators allowed in the input format (e.g. 8 hours 30 minutes)? They probably shouldn't be, or people may well figure out a way to put their entire program in the separators and thus get a score of 0 (or however many bytes eval is in their language). – user62131 Feb 8 '17 at 5:36 • @Lordofdark can I adopt this abandoned challenge? – programmer5000 Jun 9 '17 at 12:03 • @programmer5000 yes you can. Sorry I totally forgot about this – Fabich Jun 9 '17 at 13:27 This message is open for anyone to adopt and post to main. For more details, see the chat room or meta post. # Visualized Tree of 3n+1 Conjecture Originally by @KeyuGan. Thanks for letting me use this! ## Introduction Probably you are already familiar with 3n+1 conjecture (aka Collatz conjecture). As is stated in this golfing problem: • Start with an integer n > 1. • Repeat the following steps: • If n is even, divide it by 2. • If n is odd, multiply it by 3 and add 1. And it is proven that for all positive integers up to 5 * 260, or about 5764000000000000000, n will eventually reach 1. It is easy to draw a chain of the whole process for an integer (e.g. for 5, the chain is 1<-2<-4<-8<-16<-5). ## Task Description You are asked to print a string of a visualized 3n+1 tree of all chains resulting from positive integers from 2 to n, containing new lines if necessary. ## Input and Output There is only one input n, which can be read from stdin, be a function parameter or from any external sources. You can safely assume input is valid and does not exceed your language's processing ability. However, your code should be able to deal with inputs of 2 - 446. Under such circumstances, the biggest number involved is 13120. [Sandbox note: Is 446 a proper minimum ? It turns out to be the largest number in which the biggest number involves is less than 32767] The output is flexible, as long as: • It is a textfile, or a string, or an array of characters, or an array of lines. • It contains only 0-9, -, |, <, >, ^, v, spaces or new lines, where <, >, ^, v are for arrows, -, | are for lines. • Not hardcoded • Correctly visualized and in proper directions (for instance, 1->2->4->8->16->5 and 1-2-4-8-16-5 are not accepted.) • All numbers included in the output occur exactly once. • All leaves of the visualized tree should lie in the range of 2 ~ n, that is, all numbers in the output must be necessary for the result. • the destination of every chain is 1 Besides, the output should meet the following formatting criterion: • A number should be arranged horizontally and connected. • There should not be horizontally-adjancent digits from different numbers. For instance, in the following example, 17<34 23<46 is OK, while 17<3423<46 is not. Space(s) should be put between the two numbers under this circumstance. • There should not be vertically-adjancent digits as well. • There should not be zero(es) before a number (such as 0016). • There should be only one arrow for a line. • The line between two numbers must be straight. • As is demonstrated in output, - and | can be omitted if not neccessary. • Lines should not be crossed. A solution without crossed lines is proved to be available. A simple explaination is: Thinking in reverse, you can start from integer x, and draw 2x and (x-1)/3 (if result is odd) following x, and repeat the process for every new number. Stop when you have all required integers from 2 ~ n in the graph and erase all unneccessary numbers. • You can only draw a line onto and from a number directly, that is, the arrow of the line must be pointing at a digit. e.g. |<--, ^<--, |-- and ^-- are not accepted. • The direction of arrows and lines must be correct. e.g. ^- and <| are not accepted. • There should not be spaces between arrow and number. • There should not be spaces between arrows and lines, neither in lines. [Sandbox note: Tell me plz if you come up with other loopholes.] Output is assumed to be printed in a monospaced font (all characters have same width). ## Sample Input 15  Possible Output 1 1<2<4<8<16 ^ 5<10<20<40<80<160 ^ ^ ^ 3<6<12| 53<106 | ^ 13<26<52 35<70 ^ ^ 17<34 23<46 ^ ^ 11<22 15 ^ 7<14<28 ^ 9  Possible Output 2  15 v 46 v 23 v 70 v 35 v 106 v 53 v 160 v 80 v 1<2<4<8<16<5<10<20<40<13<26<52<17<34<11<22<7<14<28<9 ^ 3 ^ 6 ^ 12  Possible Output 3 1<2<4<8<16<5 80<160<53<106<35<70<23<46<15 ^ v 12>6>3>10<20<40<13<26<52<17<34<11<22<7<14<28<9  ## Scoring Your answer should include verifiable output of input 42, without a violation to output requirements. And you should verify your answers with different answers on this page: TBD [Sandbox note: I will provide a js checker on my site to validate an output.] Among all accepted codes, shortest code wins. • Smallest output can be a useful winning criterion in some cases, where there is the possibility of continuously finding smaller outputs with little chance of finding an optimal solution. However, in this case the sequence will always be the same, so the winning criterion is how short an output format can be made before being judged unreadable. This has two problems: 1. This will force output formats towards the subjective boundary between readable and unreadable, making judging validity difficult. 2. An output format does not require programming skill. – trichoplax Oct 22 '16 at 19:47 • You might want to consider taking out the "readable" requirement and just keeping the objective description about adjacent numbers and spacing, as that cannot lead to ambiguity. Then you can use a different winning criterion (such as code golf), and people can be flexible in the output format they choose depending on what allows for the shortest code in their language. – trichoplax Oct 22 '16 at 19:56 • Looks like I was commenting on the version before your edit - apologies if some of this no longer applies... – trichoplax Oct 22 '16 at 19:57 • @trichoplax thanks. I believe your words have convinced me that subjective 'readable' judgement is not that good for this challenge. – Keyu Gan Oct 22 '16 at 20:04 • @trichoplax I have modified the problem a little bit to take out that requirement – Keyu Gan Oct 22 '16 at 20:15 • One way to test that your requirements are objective is to write a validator program that takes the output of a submission as input and indicates whether it is valid. If you can write this program then the requirements are objective, and it will also ensure everyone is working with the same definition. Any problems you run into while writing it will also help to identify any ambiguities in the requirements. – trichoplax Oct 23 '16 at 10:51 • Can I post this abandoned proposal? – programmer5000 Jun 9 '17 at 12:50 • @programmer5000 Sure. Mention me if it doesn't bother you. XD – Keyu Gan Jun 9 '17 at 13:26 Perfect Hash Generator Given N words you are to generate a perfect hash function (ala gperf). A perfect hash function for a set of strings is a hash function with no collisions. An additional condition is that the range of the generated hash function must be [0...O(N)] (i.e. at most a constant times larger than N). You can use any language for the generated function. Can we get some feedback on this old post? I'm wondering if it is possible to avoid the obvious loophole of a cat program. • Sounds good at first blush. Do you foresee this as a [code-golf] or some more extensive challenge? If the later what metric would be used to judge it? I think that evaluation of results for compliance is easy enough if the resulting hashes are composed into programs---in unix: entry < testfile > hash_program && hash_program < testfile | sort -u | wc -l and compare to wc -l testfile---but less obvious if the submitters don't provide a scaffold (and if they do should it be counted toward length in the event that this is a [code-golf]?). – dmckee --- ex-moderator kitten Jun 22 '11 at 1:24 • Perl solution, 2 bytes (1, plus 1 for -pE instead of -E): ; Or, wait, did you mean that our program has to print another program that generates a hash? Then say";" I suppose, at 6 bytes. – msh210 Jun 16 '16 at 14:52 This message is open for anyone to adopt and post to main. For more details, see the chat room or meta post. # Find the mines! You are a mine remover. Your job is to find all mines on a field, without a mine explodes. So, you write an application that can find the mines carefully. ## The input The input can either be provided through command line arguments or through STDIN (tell what you use in your submission). The input items are separated by commas. The input looks like this: <current step (zero-based)>,<mine count>,<field width>,<field height>,<field data>  The field data is like a Minesweeper field. Rows in the field data are separated by semicolons, columns are separated by nothing, as each column is just one character. Here are the characters you can get: • X This means that you don't yet know what's there, the real data is still hidden. At the start, you get a field full of Xs. • / This means that there is nothing on that location. • <number> Specifies the count of mines around the location of the number. • F This is marked by a flag by you. • ? This got a question mark from you. There might be a mine on it, but you are not sure. This is just used as a reminder for you, it doesn't mean something specific to the controller. Example input: 2,1,3,3,XX1;X1X;XXX  That input means that it's currently your third step, there is one mine, the field is 3x3, and the field looks like: X X 1 X 1 X X X X  ## The output The output consists of 4 parts: the X of which you want to see the data (like a click in Minesweeper), the location on which you want to put a flag mark, the location on which you want to put a question mark and a sign, used to let the controller know whether you are finished or not (0 for not finished, 1 for finished). Locations are written as X;Y, zero-based. If there is something you don't want to do, output -1. You can also remove flags/question marks using the same way. Example output: 4;3,-1,3;3  ## Specifications • If your first output data is the location of a mine, you hit the mine and you die, but you'll still get a score. • If you select a X which hides an empty location (/), all adjacent empty fields (and their borders, which are numbers) will be revealed. • For every step, your program is executed again with the updated arguments. • When looking for mines, you are allowed to have more flags than the amount of mines. Only if you finish, the amount of flags must not be more than the amount of mines. If the amount of flags is greater than the amount of mines, your submission is disqualified (for every test!) and excluded from the scoreboard. ## Testing When I test your submission, I'll run 100 tests on every submission, with randomly generated fields, which I created using a program that I'll write after I got some feedback. Every submission gets the same test fields, so it's fair. Test fields look like this: • 10 tests with a 10x10 field and 10 mines. • 10 tests with a 10x10 field and 12 mines. • 10 tests with a 12x12 field and 14 mines. • 10 tests with a 15x10 field and 16 mines. • 10 tests with a 15x15 field and 35 mines. • 10 tests with a 20x20 field and 40 mines. • 10 tests with a 25x25 field and 50 mines. • 10 tests with a 25x25 field and 60 mines. • 10 tests with a 50x50 field and 100 mines. • 10 tests with a 50x50 field and 125 mines. ## Scoring You get 10 points for every mine you find, you lose 5 points if you think there is a mine somewhere when there is none and you lose 2 points for every mine you missed. The scoring is always the same, it doesn't matter whether you finish or die. The highest score wins. In case of a tie, the count of steps is a tie breaker. ## Controller I'll start working on this after I got some feedback. • You say "like Minesweeper" a couple of times, but on a cursory read I didn't see anything which differentiates it from Minesweeper. Why is this not a dupe of codegolf.stackexchange.com/q/24118/194 ? – Peter Taylor Jul 24 '14 at 14:58 • @PeterTaylor You are right, only the winning criterion is different. As there is many discussion going on about these dupes with only a different winning criterion, I'll wait for some more opinions about whether it is different enough or not. – ProgramFOX Jul 24 '14 at 15:08 • Maybe you could distinguish it by more than just the winning criterion. How about something crazy like a 3d grid of cubes where you can only access cubes that can be reached from the outside, so you slowly clear it from the outside in. – trichoplax Jul 28 '14 at 22:36 • @githubphagocyte I'm not sure what you mean by "where you can only access cubes that can be reached from the outside". – ProgramFOX Jul 29 '14 at 6:49 • That bit isn't essential - a 3d grid would work without that restriction. What I mean is restricting the cubes that can be uncovered or marked to just those on the outside of the big cube at first. Imagine it like breaking blocks to get through to blocks behind them. – trichoplax Jul 29 '14 at 8:58 • The equivalent in the 2d minefield would be treating the 2d playing area as an actual field which you have to walk across, so you can't walk to a square you want to test without testing the squares on a path to it first. – trichoplax Jul 29 '14 at 9:00 • 3d was just my 1st idea - but you could make it different in other ways. You could stick with the integer grid of squares to uncover, but let the mines beneath the grid take on floating point positions. The number in an uncovered square would be floating point because each of the eight squares adjacent to it may contain only part of a mine (which would explode if any of the squares it is overlapping were uncovered). If mines are squares the same size as the grid squares, then it may take 1, 2 or 4 flagged squares per mine, and each flagged square may contain overlap with 1, 2 or 4 mines. – trichoplax Jul 29 '14 at 9:03 • A simpler change would be to keep everything integer but let the mines be 2x2 squares. – trichoplax Jul 29 '14 at 9:09 • @githubphagocyte Thanks for your comments! What about just changing it into a 3d grid, but keep the 'normal' rules? Doing what you said about only accessing blocks if you broke the block that hides it looks complicated to implement. Unfortunately, there will still be one problem left: if everyone would post an optimal solution, then the scoreboard will boil down to luck. – ProgramFOX Jul 29 '14 at 9:33 • Yes I think with the normal rules there will be a clear optimal solution. I guess even working in from the outside there would still be only one objectively best move at each step. – trichoplax Jul 29 '14 at 10:03 • If you want to avoid the possibility of an optimal solution, there are 2 possibilities. 1.Make it a king of the hill and somehow have bots competing against each other in the same minefield. That way an optimal solution against one bot will be sub-optimal against another. 2.Make a change to the game that makes the search space too large for an optimal solution to be found. Then answers will consist of interesting heuristics and there will be the possibility of continually finding better solutions over a long period of time. – trichoplax Jul 29 '14 at 10:05 • @githubphagocyte Your KotH suggestion is a good idea, thanks! I'll think of a good way to do this. – ProgramFOX Jul 29 '14 at 10:13 • I guess just taking turns would work. You'd just need to decide the winning criteria: survivor when the opponent hits a mine / player who identifies the most mine / player who uncovers the most safe squares / ... – trichoplax Jul 29 '14 at 10:54 • Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. – programmer5000 Jun 9 '17 at 16:54 • Hey @programmer5000, feel free to adopt it. – ProgramFOX Jun 9 '17 at 16:55 ## Write a brute-forcer for the 3-byte input 'emoticon numbers' challenge The Emoticon numbers! challenge asks you to identify the 3-byte snippet which evaluates to the highest numeric value in your language, and which also has the bytes in the form ABA (where the outer two are identical and the middle one is different), and which generates an output that is only digits. I trust your claim that you have identified the best possible one is honestly intended, but as a casual scripter I'm not totally convinced, and can't be reassured by unfamiliar language specification references - since there are only 256^2 possible values, can you convince me with brute force instead? Write a program or function which: 1. takes no input 2. generates all the possible 3-byte sequences matching the pattern ABA and evaluates them in the same language. (No using one language to generate the best pattern for a different language). 3. Processes all the ones which evaluate to digits-only (output text matches the regex ^[0-9]+$, with or without trailing newline).
4. Outputs just the ABA sequence which evaluated to the highest value, and an optional trailing newline. No errors or stderr output from failed evaluations.

Clarifications:

• There's no limit on runtime, but your program must at least plausibly finish if run for long enough. Particularly, if evaluating one of the byte sequences would get stuck prompting for keyboard input, or go into an infinite loop, or quit the interpreter, you must avoid or handle that.
• If you are able to usefully reduce the search space (and explain why it's valid for your language) to avoid searching 256^2 options, that's OK. Especially if you need to do so to get past an infinite loop, etc.

Show off your brute-force strength by forcing your brute-forcer into the smallest possible space. Fewest bytes wins.

Tag:

• The whole challenge seems really brute-force :)) – Mr. Xcoder Jun 9 '17 at 17:17
• I actually did that to prove that 9E9 is the optimal JS solution. – programmer5000 Jun 9 '17 at 17:33
• -100 points if your brute forcer fits ABA :D – CalculatorFeline Jun 9 '17 at 18:47
• Now I'm wondering if there are languages for which some program of the form ABA neither halts nor obviously doesn't halt. It's likely too short, but who knows. – user62131 Jun 10 '17 at 3:55
• [With no downvotes or critique it's not too badly formed, but with only +1 upvotes it's not popular either so I am not going to post it] – TessellatingHeckler Jun 28 '17 at 0:31

Inspired by lifecompetes.com

# Multiplayer Game of Life (GOL)

There are n players that play the Game of Life (standard rules) on an 50 x 50 grid. (Size, border conditions? Toroidal, Absorbing, Mirroring?)

### Before first GOL-Step

When the game starts, each player has 12 cells that he can place anywhere he want as long as they do not overlap. Before the first GOL-step occures every player has to place 6 cells. If two players place their cell on the same spot no cell wil be placed an thei cells will remain in each players bank.

### During game

In each GOL-Step, each player can place as many new cell on the grid as he has in his bank. If two or more players want to place a cell on the same spot, no cell will be placed there (the cells will remain in each players bank). Every six GOL-steps all the players who have less that 12 cells in their bank will get a new cell in their bank.

### Goal

The goal is achieving the maximum number of cells on the grid during 1000 GOL-steps.

### How to participate

Each participant has to write a javascript function of the following form (multiple return statements allowed.)

function my_bots_name(field, bank, golstep){
return p;
}


Where p is a 2d array of points [[x1,y1],[x2,y2],[x3,y3],...] that the player wants to set. field contains a 2d array of the GOL grid, bank indicates the number of cells in the player's bank, and golstep is the index of the current GOL step (golstep == 0 before the first GOL-step occurs). The function may not the global variables and cannot access Math.random() or Date(). In field the empty cells will be set to 0, the own cells will be set to 2 and the other player's cells will be set to 1. (You will not be able to distinguish between various other players.)

The winner will be determined with a game that contains all valid submissions after one week after the first submission.

# TODO

The exact environment will be provided so everyone can test the own function before the official runs.

• What size of the grid is appropriate? (dependent on number of players?)
• How many steps should be computed?
• What border conditions should be chosen?
• Is the restriction of Math.random() and Date() apropriate? (The idea was that the games will be the same no matter of who/when they will be run. (Deterministic) )
• – Martin Ender Aug 6 '14 at 12:20
• It looks like it was abandoned, since the user has not been here for more than a month. I was not able to read everything yet - is there something important that should be considered or is it a challenge that shouln't even be started? – flawr Aug 6 '14 at 13:03
• I just thought you might want to have a look to get some inspiration from a previous spec. – Martin Ender Aug 6 '14 at 13:09
• Ok thank you, I wil read them later. – flawr Aug 6 '14 at 13:21
• What do you mean by "standard rules"? The standard rules for Life have binary cells, and this doesn't. – Peter Taylor Aug 7 '14 at 22:07
• Well each cell of the grid can have two states: occupied by a live cell or not. For executing a GOL-Step it does not matter which cell is of which player, they are all treated the same. (As it is in lifecompetes.com) – flawr Aug 7 '14 at 22:15
• What happens to an empty cell that has 3 neighbours of different players? Are new cells only born if they have 3 neighbours of the same player? – trichoplax Aug 10 '14 at 20:23
• Thank you for pointing this out, I did never think about this special case but I just checked livecompetes and they handle this as follows: A new cell is born if two or three of the neighbours are from the same player. If there are three different players invovled the space remains empty. – flawr Aug 10 '14 at 20:40
• why n players instead of 2 players? – Sparr Aug 18 '14 at 4:31
• Can you provide some thoughts why only two players would make a better game? If you could start it with n players at once you can let all submissions compete against each other as you do in the original lifecompetes.com – flawr Aug 18 '14 at 8:11
• @programmer5000 Yes, feel free to adopt! Just make sure work out the details in the sandbox before posting. If you want me to help in one way or another, just ping me! – flawr Jun 9 '17 at 17:43
• Can you add support for other languages? – CalculatorFeline Jun 9 '17 at 18:46
• @programmer5000 I thought you wanted to adopt it?!? – flawr Jun 9 '17 at 19:32
• Please next time say that you want to list it for adoption rather than adopting it yourself! – flawr Jun 9 '17 at 19:39

This message is open for anyone to adopt and post to main. For more details, see the chat room or meta post.

Edit: I'll have to clarify the optional features and there may be more. Essential I want to have the basic features covered, and if anything beyond gets implemented because it saves characters that is okay, but not required.

Edit: Updated but still working on it. Will definitely include edge cases and more examples as test cases.

Edit: It might be cool to have this implemented as a function, and then have some follow up questions where you are allowed to call the function created here while only counting the function call as characters, and not the contents.

Still working on the specifics, but getting it the idea out there.

## 2-Dimensional Regex

Given a 2-Dimensional regex and a block of text, do a match, a single search and replace or a global search and replace depending on the input.

Implement this as a function. The input should be two arguments to the function. The first is the regex, and the second argument is the string to match. The output should be a truthy or falsey value when doing a match, or the string when doing a search and replace.

## Match

Input:

/aaa/
/bbb/
/ccc/


and

aaaab
dbbba
ecccc


Output:

A truthy value


## Single Search and Replace

Replace the first instance of the match. The search order is the match that includes the top most character. If multiple matches end up with the top-most character on the same line, then include the left-most match.

Input:

s/bb/cc/
/bb/cc/


and

abbaabba
bbbaabba
bbbaaaaa


Output:

accaabba
bccaabba
bbbaaaaa


## Global Search and Replace

Replace all occurrences of the match. Matches do not overlap, and you use the same search order as the single search and replace.

Input:

s/bb/cc/
/bb/cc/


and

abbaabba
bbbaabba
bbbaaaaa


Output:

accaacca
bccaacca
bbbaaaaa


## Another example:

Input:

s/aba/bbb/
/aba/aba/
/aba/bbb/g


and

aaaabaaaa
aabaababa
aababaababa
aabaaabbaba
aba


Output:

aaabbbaaa
aabaabbbb
aabbbbababa
aabaaabbbbb
aba


## Rules

• Only ASCII characters 32 through 126 are valid.
• Character classes are valid, [a-c4-6] would match an a,b, c, 4, 5, or 6. And [b?7] matches one b, one ?, or one 7.
• . matches any character.
• Use \ to escape there special characters to match their literal character instead of their special meaning: {}[]/\.?*.
• a? matches 0 or 1 a's.
• b+ matches 1 or more b's.
• c* matches 0 or more c's.
• b{2} matches 2 b's. Ranges such as {2,5} to match 2 to 5 b's is optional.
• g flag replaces all of the occurrences, without it only the first occurrence would be replaced. This flag is optional.

Optional features:

• Capture groups are optional. Please specify whether to use () or  to match literal parenthesis.
• Grouping such as (ab)+ matching all of abababab.
• Sounds interesting, but apart from the character-class and . addition it's very similar to codegolf.stackexchange.com/questions/37867/programmers-garden. Some specifics you should clarify (I know you're still working on it, but before I forget it...): Is the regex always rectangular? Are regex and replacement equal in shape? And make sure to specify that matches found with g never overlap. – Martin Ender Sep 17 '14 at 17:04
• First occurrence with which search order? What about all the other things which make up a regex (in particular, full alternation and repetition)? – Peter Taylor Sep 17 '14 at 17:13
• @MartinBüttner I got the inspiration for it while working on the garden one since 2-D regexes would help a lot with that problem! I think it would be cool to implement a lot of regex features and that would be a different problem. /i for case insensitive, maybe even capture groups. The replacement could be a different size than the match (I'll have to define how that affects making a previous match now invalid while using /g). – hmatt1 Sep 17 '14 at 17:58
• @PeterTaylor I'd love to define and add other regex features, but I don't want to make the challenge too hard. I'll think about how to implement repetition and non-rectangular searches. Definitely interested in hearing ideas about making this interesting and feasible! – hmatt1 Sep 17 '14 at 18:00
• As far as overlapping matches goes, it might be okay to have that in the input, but then have the one that would get replaced would be the first in whatever search order we end up choosing. – hmatt1 Sep 17 '14 at 18:02
• If the only regex features you have are a small subset of character classes, it's potentially misleading to call it a regex problem at all. It might be less confusing to talk about 2D pattern matching instead. – Peter Taylor Sep 17 '14 at 21:11
• @PeterTaylor I'm planning on adding more regex features. Good point though! Thanks! – hmatt1 Sep 17 '14 at 21:16
• Having implemented a large part of the ECMAScript regex flavour before, let me tell you that a) getting the spec right and b) implementing regular expressions is a lot of work. Starting with your spec: is repetition greedy? You've got character classes with ranges - what about invalid ranges? What about - at the beginning or end of the string? What about character class negation? What about []? Likewise, what about invalid {m,n} quantifiers? Also, I'd definitely leave out grouping and capturing - that complicates things significantly. – Martin Ender Sep 24 '14 at 22:17
• Added to that are the difficulties from the fact that your regex is 2D. How do I specify that the stuff in two lines is repeated the same amount of times? E.g. if I want to match an n x 2 block of as, I couldn't just write a+ in two lines, right? Because the +s are technically independent. What if there's a + in one line and no + in another? etc... – Martin Ender Sep 24 '14 at 22:19
• @programmer5000 you are welcome to adopt this! – hmatt1 Jun 9 '17 at 19:36
• The second and third examples are the same. – CalculatorFeline Jun 11 '17 at 4:38

# stdin FPS

Count the input FPS ("F"s per second)

Read a potentially infinite text stream. While you do, display (at least once per second) your FPS, i.e. the amount the characters "f" or "F" appeared.

The FPS has to be accumulated over a time frame of five seconds, meaning you can't just print the number of Fs you've seen this second every second.

### Rules:

• Standard loopholes are banned
• Read one character (or byte) at a time. If (and only if) your language doesn't have the ability to read characters as they appear in the input, you may read the input one line at a time.
• The FPS display may be in any reasonable format, for example 3.54fps or 0.9224
• You may round the resulting numbers to 2 (or more) digits after the decimal point, but no less. Displaying only integers is not allowed.
• To display a new value, you may either:
• clear the screen before printing a new value,
• overwrite the existing value,
• or seperate the values by newline characters
• Be case-insensitive
• In the first second, you don't have to display anything, and if you do, your value doesn't have to be accurate or meaningful.
• Before five seconds have elapsed, you have to average over the total elapsed time since execution started.

### Sandbox questions:

• Dupes? (I don't know what to search for)
• "In the first second, you don't have to display anything" and "The FPS has to be accumulated over a time frame of at least 5 seconds" are kind of conflicting. As I understand, we don't have to display anything in the first five seconds... – Mr. Xcoder Jun 11 '17 at 11:57
• @Mr.Xcoder I will clarify. What I mean is that in the first second you don't have to display anything, after the first second the amount of Fs in the first second, after the second second the average amount of Fs in the last two seconds and so on, until you reach the fifth second, after which you may choose to average only over the last five seconds. – L3viathan Jun 11 '17 at 11:58
• Also, before posting, I advice you to clarify "potentially infinite text stream"... the community will react if you do not specify how the input is specifically taken – Mr. Xcoder Jun 11 '17 at 12:01
• @Mr.Xcoder Clarified (and changed) the five seconds rule. What do you suggest regarding the "potentially infinite text stream"? Adding exceptions for memory limits, etc.? Or clarifying again that output has to occur "live"? – L3viathan Jun 11 '17 at 12:06
• Add both the specs, and wait to see if there are any other suggestion here – Mr. Xcoder Jun 11 '17 at 12:15

# Implement Nopfunge

## Background

Nopfunge is a very simple Befunge derivative, with no stack and no real form of data storage; all it has is an instruction pointer and five commands ("turn north", "turn south", "turn east", "turn west", "continue in same direction"). However, what it does have is a program that repeats forever in two dimensions, which turns out to be enough to make it Turing complete.

Your program must take, as input, four 2D arrays of characters, a, b, c, and d, via any reasonable means. Each of these will have the same dimensions, and they will be rectangular (although not necessarily square). (Note: This is a simplification from the actual syntax of Nopfunge, but is still just as Turing-complete.)

The program will then conceptually work on an infinite array formed out of sub-arrays identical to the inputs, formed by placing a in the top left corner, b along the top edge, c along the left edge, and d everywhere else, like this:

abbbbbbb …
cddddddd …
cddddddd …
cddddddd …

⫶⫶⫶⫶⫶⫶⫶


(Note that because you can't assume your language can do infinite work in finite time, you won't be able to actually represent the compressed array in memory, so you won't be able to calculate the value at a particular coordinate pair in advance; rather, you'll have to calculate it lazily and/or every time it's needed.)

Then simulate the progress of a Nopfunge program on this array. Specifically, there's an instruction pointer that has a position on the array, and a direction; it starts at the top-left corner, going to the right. Repeatedly, run the command specified by the character at the instruction pointer:

• >: Move the instruction pointer one position to the right; it now points right
• <: Move the instruction pointer one position to the left; it now points left
• ^: Move the instruction pointer one position upwards; it now points up
• v: Move the instruction pointer one position downwards; it now points down
•   (space): Move the instruction pointer one position in its current direction

Should the instruction pointer ever attempt to move outside its infinite array (by moving above the top edge or to the left of the left edge), your program should exit. If the instruction pointer never attempts to move outside its infinite array, the program should never exit. (Or in other words, the task is to halt if and only if the Nopfunge program does.)

## Clarifications

• You can input the arrays as arrays of character codes (i.e. integers) rather than characters if you wish, but if you do, they must use the ASCII/Unicode encodings, 62 60 94 118 32 for > < ^ v  .
• Your program can do anything if the input arrays aren't all the same size or aren't rectangular.
• You may take additional inputs for the dimensions (width and height) of the input arrays, if you wish.
• It doesn't matter what (if anything) your program outputs; all that matters is whether or not it halts.

## Victory condition

This is , so shorter programs (in bytes) are considered to have a better score.

# Sandbox questions

• Is the specification easy to understand and unambiguous?

• Is this the best possible input format? I wanted to avoid the secondary task of having to parse Nopfunge's input format (which uses = and ; to split one array into the four given here), but am not sure whether this format or that one is more convenient for solving the task.

• Note so I don't forget: it was pointed out in chat that test cases will be helpful. – user62131 Jun 21 '17 at 10:15

## Reindent Java/C/C++/etc. code

Write a program that adds or removes whitespace to format code nicely. Rules for what the code should look like when you're done:

• No line should contain more than one of { and }.
• A { should always be the last thing on a line.
• A } should always be the only thing on a line (besides whitespace that comes before it).
• The amount of whitespace in front of each line should be a fixed multiple of the current nesting count. (You can use any amount of indentation you want, as long as it doesn't change.)
• No whitespace should be inserted or removed that doesn't contribute to satisfying one of these rules.

The nesting count for the first line is 0. The nesting count of any other line is the nesting count of the previous line, plus one if the previous line contains a {, minus one if the current line contains a }.

{ and } inside string literals and comments don't count in the above rules. A string literal is text enclosed in single or double quotes, where single or double quotes with a backslash before them aren't interpreted as the end of the string literal. A comment is text enclosed in /* and */, or text going from // to the end of the line. /* */ comments can be nested.

For example, it should reformat this:

    main() {printf("Hello!"); // I don't care about the world...
}


into this:

main() {
printf("Hello!"); // I don't care about the world...
}


• Strictly interpreted, the current rules don't allow any legal output for input "{}". You probably need to define rules for string literals and comments. I also note that you don't require the indentation to be consistent (different lines can use different multiples of the nesting count), and that inputs with badly indented lines which aren't adjacent to { or } can't be fixed by inserting or removing whitespace adjacent to { or }. – Peter Taylor Jul 23 '14 at 9:54
• @PeterTaylor Fixed those problems. (I think). – tbodt Jul 23 '14 at 15:49
• Fixed some of them. You still need to add exceptions for { or } inside a string literal or comment, including definitions for what constitutes a string literal or comment (since it varies between languages). – Peter Taylor Jul 24 '14 at 15:06
• @PeterTaylor oh, now I understand what you meant. – tbodt Jul 24 '14 at 15:51
• @tbodt I'd like to take over this challenge if you don't plan on posting it – musicman523 Jun 26 '17 at 23:29
• @musicman523 nah I think i'll post it – tbodt Jun 26 '17 at 23:46
• imo the first code snippet is better than the latter – Okx Jun 27 '17 at 10:01

# RoboCops and Robbers

A while ago we made some code to golf brain-flak for us. Eventually the code got so good that us humans could no longer compete against it.

Now the code has turned against it and its your job to stop it. You need to out golf the robots. They've already golfed all the numbers so you need to write some Brain-Flak code that pushes a positive number to the stack, but is shorter than the code produced by these two bots:

• The Python, This bot eats numbers for breakfast and caches them for lunch, it still is the top scoring bot on the challenge and its coming for you.

• The Number Cruncher, based on Neil's top scoring Perl answer, made from boiling hot JavaScript and raw HTML this bot takes no prisoners.

Since we need to stop these rampaging robots as soon as possible you need to come up with the smallest number you can to beat them.

## Rules

• You must write a program to push a number to the stack in Brain-Flak.

• It must be shorter than the code produced by both of the two bots above when asked to produce the same number

• Your answer must be stack clean (must push the same number regardless of the contents of the stack) and must not use [].

• Your score will be the number you produce, with a lower score being better.

• In the event of a tie where two people have the same number the person with the shorter code will win, if that does not resolve then the first earlier will win.

• Why the ban on []? Irresponsible usage is banned by the immediately preceding condition. – CalculatorFeline Jun 30 '17 at 2:15
• @CalculatorFeline The original question the bots came from also banned it. – Wheat Wizard Jun 30 '17 at 2:16
• This seems so obviously a dupe of the question it links that I'm wondering whether I missed something, because I can't think why you'd put in the effort to sandbox it. – Peter Taylor Jun 30 '17 at 7:18
• @PeterTaylor I think you are missing something. The previous question was a meta golf where one writes a program to write Brain-Flak programs. In this challenge you write a single Brain-Flak program. Its basically a CNR where all the cops submissions are generated by bots. Please let me know if there is anything I can do to make it clearer, or if you still think this is a dupe. – Wheat Wizard Jun 30 '17 at 13:07
• Doesn't this lua answer have the best score? – nmjcman101 Jun 30 '17 at 14:19
• @nmjcman101 Oh it does. I hadn't even seen that! I'll fix the question. Thanks. – Wheat Wizard Jun 30 '17 at 14:20
• Also I'm assuming that this would be posted as a single question, not an actual Cops thread and Robbers thread? – nmjcman101 Jun 30 '17 at 14:21
• @nmjcman101 It would be posted as a single question. – Wheat Wizard Jun 30 '17 at 14:22
• @EinkornEnchanter, but the point of CNR is that the robber's answer does the same thing as the cop's answer. Any answer to this is essentially something which can be combined with the existing answers to the meta-golf to make a better answer to the meta-golf. You could effectively get answers to this question by posting a bounty on the existing one. – Peter Taylor Jun 30 '17 at 19:56

# Deep-dichotomize a list

Given a list, dichotomize it (i.e. split it in half), then dichotomize both resulting sublists, etc., until you reach sublists of length 1.

For example, given [1,2,3,4,5,6,7,8]:

  Dichotomize: [[1,2,3,4],[5,6,7,8]]
Map dichotomize: [[[1,2],[3,4]],[[5,6],[7,8]]]
Map map dichotomize: [[[[1],[2]],[[3],[4]]],[[[5],[6]],[[7],[8]]]]
We end here because we only have singletons


If the list has an odd length, the longest of the two lists should be the second one. For example, [1,2,3,4,5] is dichotomized into [[1,2],[3,4,5]].

The content of the list is irrelevant (you can use whatever you want). You can use any list-like representation of your language, as long as both the Input and the Output use the same representation.

### Test cases

Input                          Output
[1]                            [1]
[1,2]                          [[1],[2]]
[1,2,3,4]                      [[[1],[2]],[[3],[4]]]
[1,2,3,4,5,6,7,8,9]            [[[[1],[2]],[[3],[4]]],[[[5],[6]],[[7],[[8],[9]]]]


### Scoring

This is , so the shortest answer in bytes wins.

• Does the output have to be a list/array? It seems that you're really building a binary tree, and being more flexible in the output would allow languages like Haskell with strict typing which doesn't allow lists of varying depth to participate. – Peter Taylor Jun 28 '17 at 10:19
• @PeterTaylor To me, You can use any list-like representation of your language includes nested lists and so trees. Maybe I should be clearer. – Fatalize Jun 28 '17 at 10:22
• I don't think a binary tree is really list-like. – Peter Taylor Jun 28 '17 at 10:23
• Suggested tags: code-golf, array-manipulation, recursion. – Erik the Outgolfer Jun 28 '17 at 13:25
• Third testcase is a bit off, a ] is missing at the end. – Erik the Outgolfer Jun 30 '17 at 12:58
• "If the list has an odd length, the longest of the two lists should be the second one" seems like unnecessary fluff to me. – scatter Jun 30 '17 at 14:42
• @Christian Why? – Fatalize Jun 30 '17 at 14:48
• @Christian No it's not, how should I split [1, 2, 3, 4, 5] without that information? – Erik the Outgolfer Jun 30 '17 at 15:16
• @Fatalize Because you could just as easily say it doesn't matter, whichever your language does by default is fine. – scatter Jun 30 '17 at 15:52
• I also think it would be cleaner to allow odd splits to go whatever way. – xnor Jul 7 '17 at 5:07

# Create a "Neverending" Quine code-golfquine

Your task is to create a program which, when run, outputs its source code repeatedly until stopped. You are allowed to have an extra newline between outputs.
NOTE: All standard loopholes are strictly forbidden. That means cheating quines, etc.

This is , so may the shortest answer win and the best programmer prosper...

• Never mind. Found a duplicate. – ckjbgames Jun 30 '17 at 23:32
• Please delete this proposal then and edit it down to a stub. Thanks! – HyperNeutrino Jul 25 '17 at 0:26

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