# Sandbox for Proposed Challenges

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

Sandbox FAQ

## Posting

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

## Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

## Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Get the Sandbox Viewer to view the sandbox more easily!

# Existential Golf

• Proofs could be simple: it supports NAND, and NAND is functionally complete. – tsh Jul 5 '18 at 7:23
• @tsh Currently there is still no winning criteria. – user202729 Jul 5 '18 at 9:54
• This is quite interesting (not sarcasm!), but what's the actual challenge? – Nathaniel Jul 7 '18 at 7:02
• @Nathaniel When I actually finish it this will be the next installment of proof-golf. – Wheat Wizard Jul 8 '18 at 3:19
• It's great to see an unfinished idea, ready for feedback until it's postable. I see this as an important purpose of the sandbox. – trichoplax Jul 10 '18 at 19:43
• @trichoplax Not everyone think so. – user202729 Jul 11 '18 at 3:46
• I definitely disagree with having to make sandbox posts "finished". I agree with not being lazy though. I see this post as a great example of unlazy and unfinished (when posted). There was clearly effort made, and it was made available for feedback early, which can avoid going too far down a path that others already know won't work. Posting early prunes impossible or impractical challenges so challenge authors have more time for writing the challenges that will make it to main. – trichoplax Jul 12 '18 at 19:05
• @user202729 For context, I said that in response to a 1-sentence sandbox post. I also said it bothers me when people "just post the bare minimum they can get by with and edit it later". The first revision of this challenge was clearly not the bare minimum to get by with. – DJMcMayhem Jul 12 '18 at 19:14
• @DJMcMayhem So you're measuring effort? That's usually not a good idea. – user202729 Jul 13 '18 at 2:48

# Split and recombine a number

This challenge has two related parts. Your task is to write two functions/programs as per the below specifications. You may share code across your submissions, the submissions may call one another, and you may even submit a single submission which handles both conversions. In the latter case, conversion direction may be determined by whether the input is a single number vs a list, or by an additional consistent second value (not a function) input.

## Part 1

Given a floating point number, return a list with one element per digit of its integer part, if any, and if the number is a non-integer, one additional part which is the fractional part. If the number is negative, negate all elements in the output. If the number is zero, return a 1-element list with a zero in it.

When the result list is recombined as per Part 2, it must be precise to within an absolute or relative error of 10⁻¹⁰, whichever is more permissive.

## Part 2

Given a list generated as per Part 1, return the number which would have generated that list in Part 1.

When the result number is split as per Part 1, each element must be precise to within an absolute or relative error of 10⁻¹⁰, whichever is more permissive.

## Examples

Part 1 <-> Part 2
-123       [-1,-2,-3]
2.71828    [2,0.71828]
-800.6     [-8,0,0,-0.6]
321.7001   [3,2,1,0.7001]
-0.01      [-0.01]
100        [1,0,0]
0          [0]

• (1) Technically infinities are floating point numbers (or, at least, they're not NaNs). What should the output be for an infinity? (2) How about for 1E45? (3) For numbers which are small enough to have a fractional part, what restrictions are there on the precision of the output? E.g. to take the fourth test case, 321.7001 - 321 in IEEE 754 double format gives 0.7001000000000204. – Peter Taylor Nov 18 '18 at 21:18
• Do we need the leading 0 in the list? Seems cleaner without it – Quintec Nov 18 '18 at 22:11
• @Quintec What leading zero? – Adám Nov 18 '18 at 22:28
• @PeterTaylor I'll exclude infinities. I'm not sure what do do about inexactness. I guess I could allow stopping at 16 digits of precision. Any ideas? – Adám Nov 18 '18 at 22:31
• Now that I think about it, string output for part one doesn’t make sense. But if it did, then I meant [2, .718] instead of [2, 0.718] – Quintec Nov 18 '18 at 22:43
• I don't see any reason to reject 0 <-> [], given that 0.01 <-> [0.01]. – Bubbler Nov 19 '18 at 1:21
• For the precision, how about something in the line of "correct up to absolute/relative precision of 1e-16"? Partly because big numbers stored in double are not accurate even in the integer parts. – Bubbler Nov 19 '18 at 1:29
• @user202729 Yes, I'll add that. Also, see tolerance text now. – Adám Nov 19 '18 at 12:36
• @Bubbler Tolerance specs added. – Adám Nov 19 '18 at 12:41
• Suggested test cases: 4.4 <-> [4,0.4] and 44.44 <-> [4,4,0.44]. Also, can we assume there will not be any unnecessary trailing zeros? I have a working solution, even with workaround for 0 <-> [0], but for 0.0 it outputs [0.0], but vice-versa for [0.0] it outputs 0 instead of 0.0. Hence the question that there won't be test cases like 0.0, 4.0 or 6.4000 with unnecessary trailing zeros. My programming language outputs 4.0 -> [4,0] -> 40 due to the implicit conversion of 0.0 to 0.. – Kevin Cruijssen Dec 4 '18 at 10:44
• @Adám FWIW Composed a solution using JavaScript for the specification at this question, and a solution for the specification at the original question (that currently has a bug for two test cases at "Part 2" portion, though is not incapable of being fixed). – guest271314 Dec 17 '18 at 23:47

Progress: Updated the rules again, and also add the timed function to the bots.

# Sylver Coinage KotH king-of-the-hillnumber-theorypython

Sylver Coinage is a 2-player mathematical game that has the following rules:

1. Two players take turns announcing a natural number each time.
2. Each number announced must be unrepresentable as the sum of non-negative multiples of the numbers announced before.

Eg. if the first three numbers announced are $$\\{6, 11, 15\}\$$, then you cannot announce any numbers representable as $$\6n_1+11n_2+15n_3\$$, where $$\n_1,n_2,n_3\ge0\$$. You can announce, for example, $$\16\$$, though.

3. The player who announced a number not complying with Rule 2, or the number 1, loses.

Here is a twist -- R. L. Hutchings proved that announcing a prime number as the first play provides a winning strategy for the first player, although the detail of the strategy is not yet known. So I put a restriction here: the first player cannot announce a prime number in the first step. Now the first two numbers will be generated randomly by the driver at the beginning. No more restriction on prime numbers now.

## Technical Information

A bot playing the game will have to implement a Python 3 class, extending TimedBot, with two methods: announce() and learn(). announce() should receive a list of numbers (possibly empty) and return a single integer, and learn() should receive two integers (id of the first move and second move) and the complete list of the numbers in the last game played.

Here is a sample implementation. Note: DO NOT use this as your submission -- this sample only serves as a demonstration, and it may announce numbers that violate Rule 2.

class SampleBot(TimedBot):     # must not be changed.
def __init__(self, id):
super().__init__()     # must not be changed.
self.id = id

def announce(self, list):
import random
return random.randint(1, 101)

def learn(self, first, second, list):
pass


### Test Drive

class TimedBot:
def __init__(self):
self.time = 20.0

def timed(func):
def f(self, *args):
import time
a = time.time()
b = func(self, *args)
self.time -= (time.time() - a)
print(self.time)
return b
return f

class SampleBot(TimedBot):
def __init__(self, id):
super().__init__()
self.id = id

@TimedBot.timed
def announce(self, list):
import random
return random.randint(1, 100001)

@TimedBot.timed
def learn(self, first, second, list):
pass

# very inefficient
def islinearcomb(n, l):
if len(l):
for i in range(0, n + 1, l[0]):
if i == n:
return [n // l[0]]
elif len(l) > 1:
isl = islinearcomb(n - i, l[1:])
if isl:
return [i // l[0]] + isl
return None

lose = -1
turn = 0
nums = []
bots = [SampleBot(0), SampleBot(1)] # replace with your bots here.

import random
while (len(nums) < 2):
a, b, c, d = random.randint(1, 10), random.randint(1, 10), random.randint(1, 10), random.randint(1, 10)
if 2**a * 3**b != 2**c * 3**d and 2**a * 3**b > 100000 and 2**c * 3**d > 100000 and 2**min(a,c) * 3**min(b,d) > 12:
nums = [2**a * 3**b, 2**c * 3**d]
while lose < 0:
v = bots[turn].announce(nums)
print("{0}({1}) announced {2}".format(type(bots[turn]).__name__, bots[turn].id, v))
w = islinearcomb(v, nums)
if w:
str = ""
for i in range(0, len(nums)):
if i:
str += "+"
str += "{0}*{1}".format(nums[i], w[i] if i < len(w) else 0)
print("{0}({1}) announced {2} that is equal to {3}".format(type(bots[turn]).__name__, bots[turn].id, v, str))
lose = turn
elif v == 1:
print("{0}({1}) announced 1".format(type(bots[turn]).__name__, bots[turn].id))
lose = turn
nums += [v]
turn = 1 - turn
print("{0}({1}) wins".format(type(bots[1 - lose]).__name__, bots[1 - lose].id))


## Restrictions

Each bot will have 20 seconds of time for deciding a move todo: adjustments. Running out time during the move results in a lose, and failing to finish a method within 20 seconds will lead to disqualification and rerun of all 100 rounds with the remaining bots.

## Schedule

Submissions will be open until todo: date here. After that 100 complete round-robin rounds will be done. Each pair of bots will compete twice in each round, one with the first bot announcing first, and one with the second bot announcing first. Each win brings 3 points, each draw brings 1 point, and each lose brings no points. The bot with the highest points after 100 rounds wins. The tiebreaker will be as follows:

1. Points got
2. Wins achieved
3. Drawing lots
• Probably needs some time limit for responses to prevent solutions which attempt to generate a full game tree. – Peter Taylor Dec 17 '18 at 9:26
• @PeterTaylor Oh yes I thought about the time limit but I turned out forgetting to put that ;p – Shieru Asakoto Dec 17 '18 at 9:31
• "The player who announced a number not complying with Rule 2 ... loses." I've been thinking about this. I presume that your intention is that the controller will validate the responses. An alternative would be to say that you don't automatically lose, but to add a type of response where the bot can return a proof that the opponent broke rule 2. Then bot programmers have to make a decision as to how much time to spend trying to show that their opponent lost vs computing a valid response. – Peter Taylor Dec 17 '18 at 20:48
• What if a game goes on for a billion turns? – isaacg Dec 18 '18 at 1:13
• @PeterTaylor I'd say my intention is that the controller will validate the responses. (in the test drive there is the code doing exactly that) – Shieru Asakoto Dec 18 '18 at 9:29
• @isaacg If the number does not start out too large a game should end quite quickly. It is because two coprime numbers already make the number of possible moves finite. But If I pose a criteria on how large a number can at most go, then I'm feared that there may be a problem that the game tree is restricted. – Shieru Asakoto Dec 18 '18 at 9:30
• I'd say: don't restrict the highest move, but give each bot a 'chess clock': they start with (say) 10s, and gain 1 second per move (and pass their clock's time as a parameter). Running over time is an automatic loss, and some percentage of time losses is a disqualification. Playing high moves will quickly exhaust their stock of time if they attempt to calculate extensive game trees, which will force the bots to either play quickly or lower their numbers. Adding a decay function to the time per move will encourage smart bots to play smaller numbers to not run out of time to think. – Spitemaster Dec 24 '18 at 16:47
• @Spitemaster That's a good idea, but what I concerned about on large numbers is that the validation may take too long (because we are solving Diophantine equations in many unknowns) – Shieru Asakoto Dec 25 '18 at 5:48
• Do you realise that guaranteeing that the first two numbers are coprime guarantees that the first player will win with correct play? If you want an interesting game then you should generate the first two numbers randomly as 3-smooth numbers with a GCD which is a multiple of 6 and greater than 12. – Peter Taylor Jan 9 '19 at 11:16
• @PeterTaylor Great catch! During discussion only the suggestion of giving two initial numbers was achieved, so I didn't realize that. – Shieru Asakoto Jan 10 '19 at 0:39
• I would remove the submission deadline, why not keep it open and update once a new entry comes? Also you might be interested in this (I adapted the code originally written for another KoTH), the easiest thing will be to enforce a certain formatting on the first line and adapt code_matcher to that formatting, st. that it won't break because everyone is using different formatting. – ბიმო Jan 10 '19 at 13:48
• @BMO Wow that's a good one! And I saw my code in the source lol BTW for the certain formatting part you mean the lines around class FooBar(TimedBot):? – Shieru Asakoto Jan 10 '19 at 15:19
• @ShieruAsakoto: Yeah, I added the header to bots.py which will be used, all the users' code will be appended to that and written to auto_bots.py.. Basically you'll only need to checkout the few variables (lines 12-20) and the main (from line 117) to see how it works. About the formatting, yes, that's probably the most sane: Make sure every code starts with class NameOfBot(TimedBot):, all definitions are in that class and it's valid Python 3 code (I updated the code_matcher like this it should work fine). – ბიმო Jan 10 '19 at 15:33
• If they/you use that bots.py you'll need to manually update the imports or do it inside the bot itself, atm. bots could use random and time, maybe add math too. – ბიმო Jan 10 '19 at 15:34

# Interleave Invariance

There is an infinite sequence that does not change when interleaved with the natural numbers. Consider these few terms:

1 1 2 1 3 2 4 1


Interleave them with the naturals:

1   2   3   4   5   6   7   8
1   1   2   1   3   2   4   1
-------------------------------
1 1 2 1 3 2 4 1 5 3 6 2 7 4 8 1


As you can see, there is no change in the initial eight. Now, this sequence can be extended indefinitely rather easily by repeating this interleave operation. Your task is to choose and implement one of three output formats:

1. Take as input a nonnegative integer n and output the nth term of this sequence, zero- or one-indexed (your choice).

2. Take as input a nonnegative integer n and output the first n terms of this sequence.

3. Output terms in order forever, starting from the beginning.

For options 2 and 3, there must be no numeric characters and at least one non-numeric character between terms; this separator need not be consistent. 1+1=2 would be fine for input 3. Leading and trailing non-numeric characters are allowed.

Here are the first 64 terms. This is OEIS sequence A003602.

1 1 2 1 3 2 4 1 5 3 6 2 7 4 8 1 9 5 10 3 11 6 12 2 13 7 14 4 15 8 16 1 17 9 18 5 19 10 20 3 21 11 22 6 23 12 24 2 25 13 26 7 27 14 28 4 29 15 30 8 31 16 32 1


Your submission can be a program or a function; "input" and "output" are as defined by the community. Standard loopholes are forbidden.

As this is , the shortest solution (in bytes) wins! Good luck, and happy golfing!

# Sandboxy Stuff

Am I clear enough on what the sequence is? Any suggestions for rewording?

Is this a duplicate? I've searched for "interleave" and "3602" and found nothing.

Anything else worth mentioning? What thoughts ya gots?

Thanks to Martin Ender for the output formats, taken almost straight from the Kolakoski challenge.

• related (not a dupe though) – dzaima Feb 13 '19 at 19:35
• You could consider removing the option to output just the n'th term, making answers output a sequence. Otherwise I think it will be shortest in most languages to take n, halve until non-whole, then add 1/2 (ceiling), rather than use the interleaving property which I think is cooler. – xnor Feb 15 '19 at 0:46
• It looks like n/(n&-n)/2+1 would work for a lot of languages such as Python. – xnor Feb 15 '19 at 1:09
• @xnor Do you think removing that option will help much? I can't really think of a case where the solution won't be to wrap your expression in a looping construct if the expression was the shortest. I don't think knowing the history of this function is that helpful to finding the future value. – FryAmTheEggman Feb 25 '19 at 22:09
• @FryAmTheEggman You're probably right, answers would mostly just do the expression in some loop. In Haskell I think the interleaving definition wins out (even with option 1 allowed), but maybe that's just Haskell. – xnor Feb 26 '19 at 6:22

## Evaluate C−− expression parsing

Your goal is to a evaluate an expression in "C−−" (not this one) which uses only the characters are C and -. C is an variable holding an integer whose initial value you're given, and the - symbol is used in many ways including as a decrement operator:

• C-- decrements the value stored in C, then evaluates to that value.
• --C evaluates to C, then decrements the value stored in C.
• -expr negates the value of the expression expr.
• expr1-expr2 takes the difference of the two expressions.

Unfortunately, the C−− specification doesn't state how expressions are parsed or in what order parts are evaluated, saying these are "implementation dependent". So, it's up to you. For example, --C---C could be interpreted as -(-(C--)-C) or (--C)-(--C) or others, and each --C might be evaluated before or after other parts of the expression.

Input: A string consisting of C and -, and an integer initial value for C.

The string will be parseable in at least one way. You can take the string as a list of characters, but they must be exactly the characters C and -.

Output: A value this expression could evaluate to.

You don't need to worry about issues with overly large values like overflows or loss of precision.

TODO: test cases

• Can --C---C  be parsed as -(-(C-(-(-C))))? – H.PWiz Apr 13 '19 at 17:44
• @H.PWiz Yes. Unfortunately, it looks like as is --C, can always be interpreted as -(-C), which is golfier but more boring, so I'll probably restrict the parsing or removing the unary negation option. – xnor Apr 13 '19 at 17:50
• @xnor Note: -C is the same as (C-C)-C, but there are no parentheses here so nobody can say it can't also be parsed as C-(C-C). An added rule can be "You can't parse --C as -(-C), as a double negation would be meaningless." – Erik the Outgolfer Apr 13 '19 at 17:55
• Do you want to include or exclude simple eval implementations? – Phil H Apr 29 '19 at 15:22
• @PhilH That's a good question. Eval-style solutions seems pretty boring for C-style languages, but I don't know if there's a clean way to even specify what would be disallowed. I don't have time to work on this challenge, so you're welcome to spruce it up and post it if you want. – xnor Apr 30 '19 at 1:05
• if the C-- in question is not the one linked, could you link the one you're referring to? You mentioned a C-- specification, so I assume there is one – Skidsdev May 3 '19 at 17:29
• @Skidsdev I meant it as a thing I'm making up for the challenge. – xnor May 3 '19 at 22:02

# An Auction in St. Petersburg

## Setup

Mysterious packages are up for auction today. These boxes are unique in that their values are not known until they are opened, and when they are opened, their values follow a unique distribution:

probability    value
0.5               $2 0.25$4
0.125             $8 0.0625$16
1/(2^n)       $(2^n)  In total, there are 100 such packages up for auction, to be sold sequentially. At the start, each bot arrives with$20 in their wallet, and the goal is to walk away with more money than anyone else.

During each round in the auction, each bot simultaneously submits a bid. The bot with the highest bid (ties broken randomly) must pay the value of the second-highest bid, after which that winning bot receives an amount of money corresponding to the value of the opened package. This money can then be "reinvested" in future rounds of the auction.

The auction day ends once all 100 packages have been sold, or when any bot's wallet value exceeds 2^31.

## I/O format

• an array of everyone's current wallet amounts
• the history of past sale prices (the amount paid, not highest amount bid) and winners

As output, your bot returns an integer between 0 and your current wallet amount.

## Tournament format

There will be N=large number of game run according to the above format (100 auction rounds each), and the finishing position of the bots will be averaged across games.

• Could you explain why it ends when someone reaches 2^31? – Artemis Apr 16 '19 at 3:17
• @ArtemisFowl It's mostly to prevent players from having to deal with numbers that don't fit into a 32-bit integer. There's only a 1 in 1 billion chance that a particular package will contain enough money to trigger this condition, I just wanted to clarify how I would handle the "infinite expected value" in practice. – PhiNotPi Apr 16 '19 at 14:45
• This seems rather win-more. It just takes one big win to be able to guarantee that you can outbid everyone else for the rest of the game. – Peter Taylor Apr 20 '19 at 21:40

# Implement Brainfuck Algorithms

In order to make algorithms written in brainfuck more understandable, you can write them in a more abstract notation, where you give a given cell a name, and instead of lots of unreadable < and > instructions to move the pointer to a specific, you just write down the name of the cell. Let us see an example:

This algorithm doubles the value in cell x, and saves the result again in x. It needs an additional temporary cells t

t[-]          clear temporary variable
x[t+x-]       move the value from x to t
t[x++t-]      move twice as many units from t back to x


Now lets see what this would look like, if x was the cell with index 0, and t was the cell with index 2, assuming the poninter is in position 0 when the algorithm starts:

>>[-]
<<[>>+<<-]
>>[<<++>>-]


### Challenge

Given a string with a valid (see below) brainfuck algorithm, a list of strings containing the cell names and a list of integers containing the indices of each of the cell of the previous list, your program/function has to return an implementation of this algorithm in brainfuck.

### Details

• The pointer is assumed to be on a cell with index 0 when the implementation is executed.
• The two given lists can also be in a different reasonable format e.g. [cell1,index1,cell2,index2,...] or [[cell1,index1],[cell2,index2],... or as arguments of a function with a variable number of arguments etc.
• You can assume that in the given string representing the algorithm, there are only brainfuck instructions as well as cell names, but no other symbols (no line breaks, no spaces)
• The cell names consist of lower- and uppercase characters A-Z and a-z as well as digits 0-9
• The cell names in the string are always separated by at least one BF instruction symbol.
• You can assume that the pointer is the same index whenever it enters a loop as it exits the same loop.

### x=y:

String (remove line breaks):
temp0[-]
x[-]
y[x+temp0+y-]
temp0[y+temp0-]
List of variable names: [temp0,x,y]
List of indices:        [    2,0,1]
Output (remove line breaks):
>>[-]
<<[-]
>[<+>>+<-]
>>[<+>-]


### x=x*x

String (
temp0[-]
temp1[-]
temp2[-]
x[temp2+temp1+x-]
temp1[
temp2[x+temp0+temp2-]
temp0[temp2+temp0-]
temp1-
]
List of variable names: [x,temp0,temp1,temp2]
List of indices:        [0,    1,    2,    3]
Output (remove line breaks):
>[-]
>[-]
>[-]
<<<[>>>+<+<<-]
>>[
>[<<+>+>>-]
<<[>>+<<-]
>-
]


• Aah, I just noticed something when writeing that line (see meta section) but I do not have time right now to think through that. That's why this part was unfinished. – flawr Jun 20 '16 at 15:14
• I think that this is undecidable. Consider a line of the form x[algorithm] where algorithm doesn't guarantee to leave the pointer where it started. For the subsequent line to move the pointer to the desired cell it needs to know whether x was zero going into that line or not. – Peter Taylor Jun 20 '16 at 16:03
• I think the problem can be solved by requiring that there are no <> in the input. Although that would make the resulting language not Turing-complete (can only access finite amount of memory) – user202729 May 2 '18 at 9:51

# Fix my stuttered words

Posted: Fix my stuttered words

• "You can assume that multiple valid sets of repeated stuttered words only happen from left to right, so fixing "op op op o o o open" would result in "op op op open"." Shouldn't this result in "op open" instead? In the first rule you mention "For example "ope" and "open" both can be a stuttered word for "open"." So since the entire word is valid as stutter, I would think "op op op o o o open" becomes "([op op] op) ([o o o] open)" (([this] ... ) being the stutter, and ([...] this) being the word), thus "op open". – Kevin Cruijssen Sep 13 '19 at 9:45
• I think you meant to give the example "... so fixing "op op o o o open" would result in "op op open"." (so one less op) instead? – Kevin Cruijssen Sep 13 '19 at 9:46
• @KevinCruijssen: You are absolutely correct, I have updated the question. Thank you for reading with such a high precision. – Night2 Sep 13 '19 at 12:26

## Background

There's a terrible problem in my console - the quotes never get included inside the arguments! So, when given this argument:

["abc","def","ghi","jkl"]


it says that the argument is like this:

[abc,def,ghi,jkl]


It would be very nice if you can fix this problem!

## Body

Add double-quotes (") in order to surround a word (i.e. something that matches [a-z]+).

[[one, two, three],
[one, two, three],
[one, two, three],
[one, two, three]]


## Test cases

[abc,def,ghi,jkl] -> ["abc","def","ghi","jkl"]
this is a test    -> "this" "is" "a" "test"
test              -> "test"
this "one" "contains' "quotations -> "this" ""one"" ""contains"' ""quotations"
But This One Is SpeciaL! -> B"ut" T"his" O"ne" I"s" S"pecia"L!


## Rules for the input

• The words are never capitalized.
• Suggested test case: one that starts (and/or ends) with a word (i.e. this is a test -> "this" "is" "a" "test"). – Kevin Cruijssen Feb 18 '20 at 16:00
• Another suggested test case: a single word without anything else (i.e. test -> "test"). – Kevin Cruijssen Feb 18 '20 at 16:10
• An issue here is that since this I/O is strict, many languages can't actually execute it. GolfScript, for example, can't take in letters in any ways that isn't in quotations. – Mathgeek Feb 19 '20 at 20:00
• @Mathgeek No you can - do you know that GolfScript takes the whole STDIN as a string? Example. – user92069 Feb 19 '20 at 22:55
• Perhaps some testcases that already contain quotes – Jo King Feb 20 '20 at 5:24
• You have to escape them: [\"abc\",\"def\",\"ghi\",\"jkl\"] – S.S. Anne Feb 23 '20 at 19:21
• Is this challenge not simply a regex substitution; 22 bytes in vim: :%s/$$[a-z]\+$$/"\1"/g? – Jonathan Frech Feb 25 '20 at 1:11

## Is the input Bl lu ur rr ry? code-golfstringdecision-problem

This is based off this challenge.

Given an input string, check whether the string is blurry.

## What's a blurry string?

Take a non-blurrified string abc as an example. You repeat every character of this twice:

aabbcc


And then insert spaces at every odd-even index.

a ab bc c


Then, remove the preceding 2 and succeeding 2 extra characters.

ab bc


As an example, all of these strings are blurry (the empty line stands for an empty string):

"a"   ->
"ab"  ->ab
"abc" ->ab bc
"abcd"->ab bc cd
...


## Specification

• The input string consists purely of printable ASCII characters. The only whitespace it will contain is the space character.
• You don't have to remove extra characters before the check.
• Your output can consist of any trailing whitespace, as long as it's possible to tell a truthy result from a falsy result.

## Test cases

Here is a program I use to check my test cases.

""          -> True
"ab"        -> True
"ab bc"     -> True
"ab bc cd"  -> True
" b bc cd"  -> True
"ab bc c "  -> True
"a   c cd"  -> True

"a"         -> False
"abc"       -> False
"ab  bc  cd"-> False
"ab#bc#cd"  -> False
"abbccd"    -> False
"a ab bc cd"-> False
"a a ab b b"-> False
"ba cb dc"  -> False
"ba bc dc"  -> False
"FFaallssee"-> False

• Shouldn't the reverse version be "un-blur the string"? This is more like a decision-problem version of the blur challenge. – null Apr 28 '20 at 3:59
• This Challenge to Blurry Vision is like Narcissist to Quine. – null Apr 28 '20 at 4:00
• @HighlyRadioactive Uh-blur the string seems too easy, therefore I made it a decision problem. So can you find a duplicate for this? – user92069 Apr 28 '20 at 4:26
• I think you meant "un-blur". No, this is probably not a dupe. – null Apr 28 '20 at 4:28
• Possible duplicate: Is it double speak? – math junkie Apr 29 '20 at 0:51
• @mathjunkie Not really. This challenge is about consecutive characters separated by consistent spaces. (The spaces may or may not be there.) – user92069 Apr 29 '20 at 0:54
• @petStorm Yeah, I guess it's different enough – math junkie Apr 29 '20 at 0:57

# Draw a Peano Curve with Slashes

Given a positive integer N, draw the Nth iteration of the Peano Curve, using only slashes and backslashes (and spaces). The curve will be rotated at a 45 degree angle from its usual depiction. Here's an example for the first 3 iterations:

N = 1

 /\
/ /
/ /
\/


N = 2

       /\
/ /
/ / /\
/  \/ /
/ /\  / /\
\/ /  \/ /
/\  / /\  / /\
/ / / / / / / /
/ / / / / / / /
\/ /  \/ /  \/
/ /\  / /\
\/ /  \/ /
/ /\  /
\/ / /
/ /
\/


N = 3

                         /\
/ /
/ / /\
/  \/ /
/ /\  / /\
\/ /  \/ /
/\  / /\  / /\
/ / / / / / / /
/ / / / / / / / /\
/  \/ /  \/ /  \/ /
/ /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /
/\  / /\  / /\  / /\  / /\
/ / / / /  \/ / / / / / / /
/ / / / / /\  / / / / / / / /\
/  \/ /  \/ /  \/ /  \/ /  \/ /
/ /\  / /\  / /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /
/\  / /\  / /\  / /\  / /\  / /\  / /\
/ /  \/ / / / / / / /  \/ / / / / / / /
/ / /\  / / / / / / / /\  / / / / / / / /\
/  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /
/ /\  / /\  / /\  / /\  / /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /
/\  / /\  / /\  / /\  / /\  / /\  / /\  / /\  / /\
/ / / / / / / / / / / / / / / / / / / / / / / / / /
/ / / / / / / / / / / / / / / / / / / / / / / / / /
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/
/ /\  / /\  / /\  / /\  / /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/ /
/ /\  / /\  / /\  / /\  / /\  / /\  / /\  /
\/ / / / / / / /  \/ / / / / / / /  \/ / /
/ / / / / / / /\  / / / / / / / /\  / /
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /  \/
/ /\  / /\  / /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /  \/ /  \/ /
/ /\  / /\  / /\  / /\  / /\  /
\/ / / / / / / /  \/ / / / / /
/ / / / / / / /\  / / / / /
\/ /  \/ /  \/ /  \/ /  \/
/ /\  / /\  / /\  / /\
\/ /  \/ /  \/ /  \/ /
/ /\  / /\  / /\  /
\/ / / / / / / / /
/ / / / / / / /
\/ /  \/ /  \/
/ /\  / /\
\/ /  \/ /
/ /\  /
\/ / /
/ /
\/


You may optionally mirror this horizontally, vertically, or both if you choose. Leading spaces are clearly required for this. Trailing spaces are optional. This is code-golf, so the shortest code wins.

• Is this what you were looking for? It seems like a direct duplicate. – dingledooper May 22 '20 at 5:14
• @dingledooper Ah, crud. I did a search and everything and that didn't come up. Maybe because it's too old or something. Oh well - should I just delete this then? Could switch it to the Peano or Gosper Curve, but I don't know if that would be appreciably different. – Darrel Hoffman May 22 '20 at 13:12
• The Gosper curve is a duplicate of codegolf.stackexchange.com/questions/50521/…. The Peano curve doesn't seem to be a duplicate, but I'm not sure whether it's a good idea. – the default. May 22 '20 at 13:51
• @mypronounismonicareinstate I changed it to the Peano Curve, might still be interesting to do. – Darrel Hoffman May 22 '20 at 14:49

# Score a 1 player game of Carcassonne

• @dingledooper I'm not sure I understand? – caird coinheringaahing Jun 8 '20 at 21:35
• What I mean is, there are some tiles with roads going in more than one direction, so your scoring method seems to suggest that the same tile can be scored more than once. This is different than the official rules, which state that every tile may only be scored once. – dingledooper Jun 8 '20 at 21:53
• @dingledooper The rules state, when referring to scoring a road, "each tile of that road grants you 1 point" (emphasis mine). To me, that implies that a tile containing sections of multiple roads can be scored for each of those roads – caird coinheringaahing Jun 8 '20 at 21:59
• Ok, thanks for clearing that up for me. The only reason I asked was because it contrasted from the way I played Carcassonne (or how it is normally played). – dingledooper Jun 8 '20 at 22:05
• The scoring for incomplete road seems to have at least one incorrect word. Also, how are monasteries represented in your input format? – Neil Jun 9 '20 at 9:49
• Or indeed villages. – Neil Jun 9 '20 at 9:49
• @Neil Yes, it does, thanks for spotting that. The monastery tiles are [0, 0, 0, 0, 0] and [0, 0, 1, 0, 0]. As no other tile can be described by these two, I didn’t think it would be necessary to add an additional value representing a monastery. It’s similar with villages; each of the tiles with a village on is unique without having to specify that it has a village on it. For instance, the tile [1, 2, 1, 1, 1] (a rotation of [2, 1, 1, 1, 1]) is guaranteed to have a village on it, so another value is unnecessary. – caird coinheringaahing Jun 9 '20 at 14:38
• Ah, so a tile with at least 3 roads always has a village, and a tile with no features apart from an optional single road always has a monastery? – Neil Jun 9 '20 at 16:26
• @Neil Yes exactly – caird coinheringaahing Jun 9 '20 at 16:29

# Posted: Scoring Quantum Tic-Tac-Toe

• Do cyclic entanglement always have len=3? – l4m2 Jun 17 '20 at 22:26
• @l4m2 A cyclic entanglement can have any length provided it fits on the board. For instance, in the case DE AB DE 1 AH CF CH CG BC 2, there is a loop of length 4 across A, B, C and H. I will make a note of this in the challenge. – golf69 Jun 17 '20 at 23:49
• @l4m2 In that same case, there is also a loop of length 2: DE .. DE – golf69 Jun 17 '20 at 23:53
• I don't think the description directly states that the other player chooses the state in all cases – fireflame241 Jun 18 '20 at 3:41
• Can describing what state was chosen be done in other ways? For example, writing the number of the mark that fills the cell of the last quantum mark placed might be useful instead of the lowest cell alphabetically. – fireflame241 Jun 18 '20 at 3:44
• @fireflame241 Yes, you can choose to describe the state chosen in whatever way is convenient (I added your example to the "rules" section). And thanks for pointing that out about who chooses the state, it's clear now I hope – golf69 Jun 18 '20 at 4:17
• In your illustration, does the position of the quantum marks in a single cell (e.g. in your second picture, the center cell has three marks arranged in a J shape) matter? – Trebor Jun 18 '20 at 7:19
• @Trebor It does not, noted – golf69 Jun 18 '20 at 8:00
• Is it possible input go on there after result comes? – l4m2 Jun 19 '20 at 4:33
• @l4m2 No: "A game continues until at least one tic-tac-toe is formed or until the board is filled with classical marks." I will add that no more moves can be done after this and that multiple tic-tac-toes can only be formed simultaneously – golf69 Jun 19 '20 at 5:01

# My smart phone

Posted here: My smartphone's phonebook

• I like this idea. Just to make sure I've understood the challenge correctly, given a phone number, are we to find all possible strings that match it within a database of strings? – lyxal Jul 24 '20 at 11:45
• Not quite. Given a database/list of strings, split these by space into words. Return all database entries that contain a word that matches the number. – mindoverflow Jul 24 '20 at 13:20
• Duplicate? – fireflame241 Jul 24 '20 at 19:27
• This question only asks return entries consisting of one word, while this asks to check for possibly multiple words per entry and then to return the complete entry. Also, this quesition had unusual and harsh restrictions. This aims to be much more simpler than that, making the puzzle more attractive. While the first reason may be splitting hairs, the second one, combined with the puzzle being ~6 yrs old, is a good reason to post this puzzle, imo. – mindoverflow Jul 26 '20 at 9:23
• Add my name in! – null Aug 2 '20 at 13:44
• 'You may only take input in some form of list type, not a string.' Rigid I/O requirements are generally frowned upon. – Dingus Aug 5 '20 at 1:34
• True, no idea why I insisted on that. I'd rather not have this challenge killed because of a probably useless constraint. – mindoverflow Aug 5 '20 at 12:51
• You've probably thought of this, but you could get more names from Users. (I'm chuffed to have already made the cut, by the way!) Is there a mistake in the 34 test case - wouldn't HighlyRadioactive appear under 44? – Dingus Aug 5 '20 at 13:26
• whoops... fixed. I'll add some more people from Users when posting, for the test cases I've just listed some people I see a lot off the top of my head. Also, if you gave some feedback, there's no reason not to put you in there. – mindoverflow Aug 6 '20 at 6:22
• Why is fireflame241 there twice? – V. Courtois Aug 14 '20 at 15:14
• Third-Party 'Chef' is now called petStorm - update. – null Aug 20 '20 at 8:38

# Implement the random Fibonacci sequence

• Is -3 a valid output for f5? – tsh Aug 31 '20 at 6:27
• But it is possible that f3 = 2. It is also possible that f4 = -1. – tsh Sep 1 '20 at 1:52
• @tsh It is possible that f3 = 2 and it is possible that f4 = -1, but the two cannot be satisfied at once. So the challenge requires to record the previous results, I think (and therefore some short approaches like naive recursion can't be used). – Bubbler Sep 1 '20 at 2:45
• It would be good to include the correct distributions of the first few entries, like f_3 to f_6, for testing purposes. – Zgarb Sep 1 '20 at 7:46
• @cairdcoinheringaahing f3 = f2 + f1 = 1 + 1 = 2; f4 = f3 - f2 = (f2 - f1) - f2 = (1 - 1) - 1 = -1; f5 = f4 - f3 = -1 - 2 = -3; If this is not what you want, you may need to update your description to avoid ambiguous. – tsh Sep 2 '20 at 1:45
• @tsh Took me a while, but I think I understand what you're getting at. Does my latest edit address that? – caird coinheringaahing Sep 8 '20 at 22:18
• @Zgarb Not the best when it comes to distributions, but I've added in a list of possible values for n = 1 ... 6 – caird coinheringaahing Sep 8 '20 at 22:18
• I was going to edit in the distributions, but I don't believe your last case is correct. I don't think there is a way to reach 6 or -3. I decided to edit it in anyway since I wrote it on a scrap of paper, but of course feel free to change it if I am wrong. – FryAmTheEggman Sep 9 '20 at 21:14
• If given n we just output f_n, this voids the requirement that the sequence should remember previous values, doesn't it? – Luis Mendo Sep 12 '20 at 16:14
• @LuisMendo No, the requirement that the sequence "remembers" previous values is means that tsh's comment above would be an invalid way to construct the sequence. Because $f_n$ is constructed from previous terms, those terms cannot change partway through the construction of the sequence. For example, while constructing $f_6$, you'd have to first get the values for $f_{1,\dots5}$. Then, when constructing $f_7$, the values of $f_{1,\dots5}$ would be the same as when getting $f_6$, whether they were outputted or not. – caird coinheringaahing Sep 12 '20 at 16:18
• Ah, I see, So, "remember" means that in the construction of a given f7, every occurrence of f1 etc should have the same value. – Luis Mendo Sep 12 '20 at 16:44
• @LuisMendo Yes exactly. If you have a better wording, I'd love to hear it, I'm not too happy with "remember" – caird coinheringaahing Sep 12 '20 at 17:18
• @cairdcoinheringaahing Here's a suggestion: Each random realization of the sequence must use consistent values. For example, if [...] – Luis Mendo Sep 12 '20 at 20:22
• Also, when you say is chosen at random, you probably mean is chosen at random independently of previous choices? This prevents the code from randomly choosing a sign and using it for all terms, for example – Luis Mendo Sep 12 '20 at 20:23
• @LuisMendo That wording is nice, thanks! And yes, each choice should be independent, I'll edit that it – caird coinheringaahing Sep 12 '20 at 20:59

# Minimise a bijection $\mathbb{N}^n\to\mathbb{N}$

• Seems very possible. You can iterate the cantor pairing function $\pi(\pi(\pi(a,b),c)\ldots)$ – Sisyphus Oct 17 '20 at 2:08
• @Sisyphus, yes, but can you iterate it $n$ times within $n$ bytes? – caird coinheringaahing Oct 17 '20 at 11:58
• Also, I like this scoring idea but I fear that the abstractness of the task will scare away potential golfers. Maybe it would be better to choose a simpler task that has n as a parameter. – Zgarb Oct 18 '20 at 19:42
• @Zgarb While I do agree that, because it's much harder with the self-referential part, a simpler challenge would probably do better (votes/answers wise), but I've got no issue with this going unanswered, and I think as is, it'll draw much more impressive answers with a more discriminating choice of bijections. – caird coinheringaahing Oct 18 '20 at 19:44
• Finally, you're missing the condition that every natural number must occur as an output. – Zgarb Oct 18 '20 at 19:45
• Plus, because of the self-referential part, I think that this doesn't close the door on any future challenges that allow you to choose your own $n$, or take $n$ as a parameter, so I'm happy with this scoring criteria. Also, thanks for noticing that, edited in. – caird coinheringaahing Oct 18 '20 at 19:46
• I don't really see the point of the n-is-length idea. It seems like you just have to write code that works for any n, then plug in n equal to the length of the code (accounting for the replacement). Only perhaps an ultra-golfy language might be able to do something like n=2 in 2 bytes rather than writing a general solution. – xnor Oct 18 '20 at 21:41
• @xnor IMO, it adds an extra level of complexity/difficulty to the challenge, in that you have to modify the actual code as you modify code length. Also, I don't think the generic "take $n$ as a parameter" version is particularly interesting, whereas requiring answers to link $n$ and their code is – caird coinheringaahing Oct 18 '20 at 22:03
• @cairdcoinheringaahing Can you give an example of an interesting thing a program could do in linking its code length? I'm really not seeing it. The only extremely minor thing I could see is that if you have, say, a 76 byte program that works excepts it has a spot you need to put the number in, you need to put in 78 to account for the length of the code and number. – xnor Oct 18 '20 at 22:10

# Quickly! Group together!

• This seems like fun! I have one concern, though. The first is that keeping track of all of the restrictions that have already been used seems like an unnecessary headache. Testing if a language has been used is fairly easy using the SE search (you might want to add in some premade links to make it easier for people to do) and I think that will help the variety enough. This seems like it would become a headache faster than it is worth, even if you did something like updating the challenge each day. – FryAmTheEggman Nov 13 '20 at 2:59
• @FryAmTheEggman Yeah, that's my main concern is keeping track of everything. Maybe adding a Stack Snippet to the challenge body that extracts previously used restrictions could alleviate that (similar to what we did with my OEIS answer chaining for used sequences)? I'm hesitant to remove the rule about not reusing restrictions, because it could just lead to the challenge continuing ad infinitum with a couple of basic, repeated restrictions – caird coinheringaahing Nov 13 '20 at 13:50
• Trivial restrictions are so numerous that I don't believe this rule is doing anything relevant to end the challenge faster. I'd recommend dropping it and thinking about some other way to limit solutions if you really want that. – FryAmTheEggman Nov 13 '20 at 16:46
• I agree with @FryAmTheEggman about the restrictions. Your rule that languages can't be used on different days should be enough to ensure that the challenge ends eventually. – Robin Ryder Nov 22 '20 at 23:47

# Is it a vampire number?

• The old challenge certainly suffers from strict I/O, but I don't have a strong opinion as to whether it should be closed in favour of this one. If you do go ahead, I suggest clarifying that $x$ and $y$ must both have the same number of digits and only one of them may end with 0. – Dingus Jan 20 at 22:10
• @Dingus "strict I/O" is a bit of an understatement. I have a Jelly answer to this and the old one. This is 10 bytes, the only one is 45 bytes, and the difference in length comes entirely from having to format the output to meet the rules, which no-one likes doing. Good spot on the restrictions on $x$ and $y$ – caird coinheringaahing Jan 21 at 9:19
• I definitely see your point. I'm not opposed to the repost, in case I wasn't clear. – Dingus Jan 21 at 21:42
• I vote for the repost – Sheik Yerbouti Jan 22 at 20:09

I decide to change the statement a little, so people who don't know the language can easily understand the challenge. (apparently there are many)

Background:

• I'm thinking about scraping some BF programs on this site for the fastest-code (or approximation) version of the other challenge, and I figure out that I need to have this, and I post it here as a code-golf challenge since it's somewhat interesting (and also pretty easy).
• It's possible to force programs to check if there are any extra characters too; however it might make the problem harder (only allow printable ASCII? Some scraped data might have non-ASCII characters, so it isn't really practical. Any Unicode characters as input? Most esoteric languages can't handle that.)

## Does this BF program have a simple memory layout?

Given a string consisting of only the characters +-[]<>., check if:

• All pairs of [] are matching (balanced), and
• There's an equal number of < and > between every matching pair of [].

Background: the inputs that this program output true are exactly the valid inputs for the related challenge BF memory layout optimizer.

### Example input/output

Output true:

,>>,
,<++[->>+<<]
+<><>+
,[.,]
>.<


Output false:

,[>,]
+[>>>->-[>->----<<<]>>]>.---.>+..+++.>>.<.>>---.<<<.+++.------.<-.>>+.
].[


Undefined behavior: (your program can do anything when given those as input)

((((()()()()()){}){}){}())
$\="=".hex.$/
\!$/'?))='%<\..>  • can you please make the rules a list, some of us are bad at reading. – Alex bries Feb 4 at 9:30 • @Alexbries But there are only two of them... – user202729 Feb 4 at 9:46 • I was worried for a bit this would delve into Rice's Theorem territory (the similar question "does this BF program have bounded memory consumption?" would). Seems plenty simple though. – Beefster Feb 10 at 23:18 # Liars and Guessers • this looks like a very good challenge. I'd go with JS for the language. – Kamila Szewczyk Feb 28 at 14:16 • Be careful. If the minimax algorithm is not too hard, then people can just implement it and effectively block all the other answers. – user202729 Feb 28 at 14:55 • Isn't JavaScript very good for sandboxing? The browser is the sandbox. / Besides, you can ask people to explain suspicious code, obviously... – user202729 Feb 28 at 14:56 • @user202729 Re sandboxing I was less worried about safety than clever people inspecting the program's memory/whatever. But I guess I can just forbid it. – Artemis Feb 28 at 14:58 • @user202729 Re minimax, I was worried that it might be too trivial to come up with a perfect solution. I'll look into it. – Artemis Feb 28 at 15:00 • IMO, either Python or JS would be suitable to this question. You can chose any of them and it should work fine. As this question is asking about strategy of guessing instead of golfing in specified languages. People try to answer this question are not required to know very details of the language used. – tsh Mar 9 at 6:00 • To my understanding, guesser_score = sum(times_guessed for number in ([0..255] repeat 10 times) for each liar), lower is better. (10 times repeating is required since most submission would relay on some random behaviors.) liar_score is defined similar but higher is better. Use liar_score - guesser_score or liar_score / guesser_score (I would prefer the div one) to get score for some answer. – tsh Mar 9 at 6:16 • Wrote a Python implementation. It treats liars and guessers as separate submissions. – Artemis Mar 9 at 15:35 # Self-Replicating Numbers • Nice challenge, but I feel it would be more interesting if it took two inputs, m and n, and outputted either the first m n-order numbers or the mth n-order number. – user Mar 5 at 15:29 • @user I do like that; my original concept for the challenge was similar (outputting the first n distinct orders). I think your concept is more interesting, but I do worry about the run time - I'll run some tests and see if there are enough reasonable test cases. Thanks for the feedback! – Zaelin Goodman Mar 5 at 15:34 • For the formatting thing, see math.meta.stackexchange.com/questions/5020/… -- replace $ with $. – user202729 Mar 6 at 10:54 • Add "exactly" (appear [...] exactly$n$times [...]) in the definition too, if that's what you mean. – user202729 Mar 6 at 10:55 • +1 nice challenge! I have no idea of how to verify that there are no 1st-order self-replicating numbers after 9. – Sheik Yerbouti Mar 7 at 12:55 • @SheikYerbouti Thanks! Think of it this way; since you're checking all multiples of a number up to their square, every number from 10 and up will have the multiple of itself and ten checked - any number times ten is guaranteed to have the original number as a substring. Numbers from 100 and up will have the multiple of itself and 100 checked, and so on. – Zaelin Goodman Mar 7 at 14:42 • Oh you are right! That's clever (or I am slow ahaha) – Sheik Yerbouti Mar 7 at 15:29 • Allowing output of the infinite sequence of n-order numbers would be nice. – Razetime Mar 9 at 14:44 • @Razetime I wanted to make it a little more challenging by requiring both inputs - would it make sense to allow outputting the infinite sequence of numbers that are either m or n order, or is that too complicated? I want there to be reasons to choose either output option, if I choose to add more, and I fear that the infinite series of n-order will be the easier choice for a majority of languages. Let me know if I'm just overthinking it, and thanks for the feedback! – Zaelin Goodman Mar 9 at 16:02 • @ZaelinGoodman many recent sequence challenges allow output in 3 main ways: nth number, first n numbers or an infinite sequence. It is up to you to choose what you think suits the challenge best. – Razetime Mar 9 at 16:08 • @Razetime Ohhh okay; I looked at a few other sequence challenges and pulled together a few options - I do think it rounded out the challenge a bit more, but now I'm not sure how better to format the test cases area to accommodate those additional output modes – Zaelin Goodman Mar 9 at 16:45 • Minor things: can you change the wording and formatting of the "The CHallenge" section to make it more obvious that you need to do one of the things (see some existing sequence questions for more info)? Also can you clarify that you mean a substring in decimal? Can you clarify that "if the input is not valid" means "if no such number exists". Finally, what tags are you planning to use? code-golf sequence number ...? – pxeger Mar 10 at 17:19 • @pxeger Thanks, I have implemented all of your suggestions - let me know if you still feel any of those areas are lacking! – Zaelin Goodman Mar 10 at 18:41 # Minimally destroy CGCC in Game of Life • Just to clarify, you get an integer$n$as input and must kill all but$n$cells from the initial state to produce the shortest lived automata? – Beefster Mar 22 at 17:44 • Are there performance requirements? This problem is in EXPTIME. – Beefster Mar 22 at 17:45 • @Beefster No time requirements. And no, you decide how many cells you want to make alive (call that$n$) and which cells they are. You then run the game with those cells and the initial CGCC being alive until it reaches a point where all cells on the board are dead. Lowest$n$wins. – caird coinheringaahing Mar 22 at 17:47 • Oh, I get it. You're supposed to add live cells around the initial CGCC so that the board eventually anihillates. The way you framed the challenge is a little confusing. You make it seem like you're supposed to remove cells from the initial configuration. – Beefster Mar 22 at 18:02 • @Beefster I've edited the wording slightly, does it make more sense? – caird coinheringaahing Mar 22 at 18:05 • The wording is clearer now, but the issue is that "However, if we change the initial state to the following, by changing 13 cells, then, after 31 iterations, the board is empty" is sort of misleading because it prepares the reader to remove cells when you then say "And this is your task." I think it would be less confusing if you gave an example where adding cells to an initial state causes the pattern to eventually annihilate. – Beefster Mar 22 at 19:20 • @Beefster The issue with that is that I don't actually have an example that fits the current rules :/ – caird coinheringaahing Mar 22 at 19:38 • You don't necessarily need to create an example that fits the rules. You could instead give an example of a simpler pattern that, when a few additional cells are made live, leads to eventual annihilation. So the overall flow of the challenge description would be something like this: simple pattern, simple pattern + live cells --> annihilation, CGCC pattern creates still life + oscillators, description of the task and scoring. – Beefster Mar 22 at 20:02 # Posted • Instead of saying that "Output is undefined if n<1, or if A is shorter than n" just specify that this won't be the case. – Adám Mar 24 at 13:54 # Two Diehards Make a Glider POSTED • Is the WIP for the title or the challenge? The challenge looks mostly ok, but I'd be worried about having many solutions with the form: as simple as possible for the gliders with a well-known diehard placed far away. For the title, something like "gliders as emergent properties" or something could also be catchy. – FryAmTheEggman Mar 24 at 22:01 # I'm Jelly of Python (Cops) # I'm Jelly of Python (Robbers) # Decode Polybus Square/Tap Code/Prison Code • Nice challenge :) You need to add a scoring criterion (code-golf most likely), and you should provide a few input->output examples to help checking answers – Leo Mar 22 at 23:03 • Suggested testcases: 23 15 31 31 34 => HELLO, 24 25 31 32 => IJLM, 11 22 33 44 55 => AGNTZ. Add tags code-golf, decode and string. – A username Mar 23 at 8:11 • Thanks for the feedback :) – Samuel Waller Mar 23 at 12:51 • I've edited this down to a stub now that it's been posted – caird coinheringaahing Mar 30 at 15:15 # Plz Halp I Need  Again Bob’s startup is running out of money and desperately needs investors to keep it afloat. Although you have helped Bob find the maximum number of investors, Bob has quickly realized that more investors does not lead to more funds because different investors give different amounts of money. Each investor interested in Bob’s company wishes to schedule a meeting with a certain start and end time, and promises to invest a certain amount of money. However, some of the meetings times may conflict. What is the maximum amount of money he can get from his investors? ## Input Format Input is given as an array of tuples of integers (or the equivalent in your chosen language). Each tuple p represents one investor, where p[0] is the start time of the investor’s meeting, p[1] is the end time, and p[2] is the amount of money promised. For example, in the test case [(0, 10, 30), (10, 20, 50)], there are two investors: one who wants to meet from time 0 to time 10 and offers 30, and one who wants to meet from time 10 to time 20 and offers 50. Meetings will always have a positive duration, meeting times are always non-negative, and a meeting that ends at time k does not conflict with a meeting that starts at time k. You may assume that the input is nonempty, and you may use any reasonable I/O method for input. Within reason, you may also take input in different formats (for example, as three lists, one which contains the start times, one with the end times, and one with the money offered). ## Output Your program should output an integer, the maximum quantity of money that Bob can make. ## Test Cases [(1, 100, 10), (1, 5, 3), (5, 10, 3), (10, 15, 3)] => 10 [(0, 30, 40), (20, 45, 30)] => 40 [(10, 40, 40), (60, 85, 60)] => 100 [(65, 100, 70), (10, 45, 80)] => 150 [(10, 15, 50), (50, 85, 10), (95, 110, 60)] => 120 [(100, 135, 80), (50, 70, 80), (80, 110, 30), (95, 100, 40)] => 200 [(65, 95, 70), (50, 75, 30), (35, 60, 80), (85, 115, 100)] => 180 [(30, 35, 80), (35, 65, 10), (75, 110, 40), (40, 45, 20)] => 140 [(80, 110, 50), (0, 5, 30), (95, 125, 50), (80, 85, 70)] => 150 [(25, 40, 10), (100, 115, 60), (15, 50, 90), (60, 95, 50)] => 200 [(100, 125, 50), (75, 80, 100), (30, 60, 20), (50, 65, 90)] => 240 [(15, 35, 80), (55, 70, 40), (30, 65, 90), (30, 55, 60)] => 120 [(15, 40, 50), (60, 95, 30), (35, 40, 70), (55, 60, 90)] => 190 [(40, 65, 80), (40, 75, 10), (5, 15, 80), (100, 115, 80), (15, 35, 100), (60, 95, 40)] => 340 [(5, 30, 60), (85, 105, 90), (35, 65, 80), (90, 115, 40), (85, 90, 80), (30, 60, 90)] => 270 [(55, 65, 30), (5, 15, 90), (50, 85, 100), (0, 15, 90), (65, 70, 70), (60, 70, 80), (35, 55, 20), (80, 105, 80)] => 290 [(0, 10, 90), (70, 85, 80), (45, 55, 20), (90, 105, 90), (55, 90, 50), (0, 25, 20), (85, 105, 30), (85, 90, 100)] => 380 [(10, 45, 40), (85, 115, 80), (85, 105, 30), (30, 50, 50), (20, 40, 80), (100, 115, 60), (100, 135, 70), (30, 35, 70), (35, 50, 30)] => 180 [(80, 105, 70), (60, 65, 50), (95, 105, 80), (55, 65, 100), (40, 75, 80), (95, 110, 70), (60, 70, 90), (65, 70, 50), (55, 85, 100)] => 230 [(80, 85, 70), (35, 40, 60), (60, 80, 80), (5, 20, 100), (30, 60, 100), (45, 50, 60), (45, 80, 60), (10, 20, 50), (50, 65, 60), (60, 85, 70)] => 370 [(50, 75, 100), (90, 115, 20), (50, 65, 10), (35, 50, 30), (90, 120, 90), (65, 90, 30), (20, 55, 40), (50, 75, 50), (75, 105, 10), (15, 35, 70)] => 290  ## Rules • Standard loopholes are prohibited. • Though not required, polynomial-time solutions are encouraged so that Bob does not have to wait forever for the result. • This is , so the shortest solution in each language wins. ## Meta • Are there any errors with the computer-generated test cases? I've manually verified some of them but I may have overlooked something. • Is there any ambiguity in the problem statement? • Are there any other issues? • Test cases seems be ordered by end times. I'd suggest mixing them up (so no answer accidentally uses the order) or specifying the order. Also, in the example in the input format, it's (10, 20, 50) but you say they want to meet 5 - 10. (And I prefer the Output section before the test cases, so people know what they need to do earlier.) – xash Apr 28 at 12:51 • Thanks, I have edited the challenge accordingly – knosmos Apr 28 at 12:55 • Is it possible to take input as three lists, for start times, end times, and prices? – rak1507 Apr 28 at 13:13 • Sure - should I add test cases in that format? – knosmos Apr 28 at 13:16 • You don't need to add testcases in different formats, simply state in your post that different formats are acceptable (and perhaps mention some different formats like the$3$lists @rak1507 mentions). – Noodle9 Apr 28 at 13:41 • Link to the deleted main post, so that it's easy to find and edit when this challenge is good to go :) – caird coinheringaahing Apr 28 at 15:21 • I think I saw l4m2's proposal which is essentially the same thing, but this one is arguably much better and clearly worded. Btw, the first example is just a special case of Chaitin's constant with power-of-0.5 weights. – Bubbler May 12 at 14:16 • I don't see how it's possible, if$f(n)$is computable, isn't the limit of$f(n)$computable by the definition of limit? – Command Master May 12 at 17:31 • @CommandMaster Actually no! This is just one of a million ways in which limits can be counter intuitive. For an example, imagine an$f$where$f(n)$just takes the first$n$Turing machines and runs them for$n$steps, if machine$m$halts in the test run then you add$2^{-m}$to a total (think about what this means in binary). This is obviously computable, we can simulate Turing machines for$n$steps and add rational numbers. But the limit encodes the exact solution to the halting problem. This is actually the first example number there. – Wheat Wizard May 12 at 17:48 • Does$f(n)$have to be an exact rational (i.e. a pair (numerator, denominator)), or can it be represented as a floating point number? In other words, can we output$f(n)$as a floating point number which will, necessarily, be inexact for large values of$n\\$, as long as the algorithm theoretically works if given arbitrary precision? – Delfad0r May 12 at 20:30
• @Delfad0r I'm not entitled to answer your question, but I don't think float or double are applicable here. Arbitrary-precision floating-point numbers are certainly applicable tho. – Dannyu NDos May 12 at 20:44
• @WheatWizard Thanks for the clarification! Does the first option include, say, a pair [numerator,denominator] (even though it's not a built-in rational type)? In this case, is the pair required to be reduced (i.e. gcd=1)? – Delfad0r May 13 at 10:09
• @Delfad0r I will add that as another form, and the second format shows a non-reduced fraction as an example so it would be all right for this format as well. – Wheat Wizard May 13 at 10:11

# Minimal distinct character quine

• This seems well specificed – StackMeter Jun 16 at 10:04
• distinct means different? – math 2 days ago
• @math Yes (filler) – A username 2 days ago