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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. 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, replace the post here with a link to the challenge and delete it.

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]

Self-fibonaciing prophecy

Where L is the length in bytes of your source code
and n=(L+2)^2

Your program or function should output Fib(n)

Your program or function should take no input, and output according to the usual code golf rules

This seems like a very simple task, but the (L+2)^2 part is designed to prevent single digit outputs which could be hard coded in many languages, and ensure the required output will usually be longer than the source code, so it should produce some interesting mathematical answers

Question for meta - Is (L+2)^2 suitable for this?
Another possibility I have considered is (L^2)+8 which would grow a bit slower but still achieve the goal of preventing trivial solutions
Having a look at this again, I think the sequence still grows too quickly. Maybe n=ceil(L^1.5)+18 would be more reasonable

Another question for meta - Should I include a link to a source of Fibonaci numbers, or is it safe to assume readers know what this is and can find it for themselves?

• It probably isn't exactly necessary to explain the Fibonacci sequence, but I think it would be better if you did. You should explicitly state what you consider to be valid initial points (i.e. is Fib(0), Fib(1) = 0, 1 acceptable? I'm not sure about the scaling sequence, but I do think your idea for preventing too many trivial answers is a good one. You might consider just doing L+100 since that should probably make hardcoding inefficient but make calculation much easier. – FryAmTheEggman Aug 27 '19 at 14:54
• The point of (L+2)^2 or whatever other function seems to be to push answers towards actually implementing a general-purpose Fibonacci function, but that makes the question a dupe of the general-purpose Fibonacci question. I don't see how this can be rescued: either it's a dupe, or it's possible to "cheat". – Peter Taylor Aug 27 '19 at 19:36
• @Peter Taylor Here Fib(n) is a number that depends only on the program length but not any other input. It is unnecessary to implement a general purpose Fibonoacci function at all. You can just print a Fibonoacci number and tune the length of the program to fit the requirement. – Joel Aug 28 '19 at 1:14
• @JoKing print(34) is 7 bytes, which would require to output a 9 digit number not a 2 digit number. If you simply change the 34 for the required 9 digit number, then your solution becomes 14 bytes, so would then require to output a 15 digit number rather than 9, and so on. The output is always longer than your source code, hence trival answers are by design, not possible – Darren H Aug 28 '19 at 8:32
• @FryAmTheEggman the L+100 idea seems promising, but I fear it would then open up to trival answers for high L, indeed JoKing's point would then run true for L>33. I feel the function needs some kind of exponent to eliminate that problem – Darren H Aug 28 '19 at 8:38
• Ah oops, I missed that part and thought it was just Fib(length). Still, it's then going to be either base compression for golfier languages, or just indexing into the fibonacci list at the correct index – Jo King Aug 28 '19 at 9:24
• @Joel, I said "push towards" not "absolutely require". The key points are: (1) if it's competitive to tweak an answer from the general-purpose Fibonacci question, this is a dupe; (2) if it isn't then setting n=(L+2)^2 would seem not to have done its job. – Peter Taylor Aug 28 '19 at 9:46
• @Peter Taylor I see your point. However, since the problem does not require to output the entire Fibonacci sequence, it is allowed to use any function to generate a single Fibonacci number that fits the requirement. There might be a non-trivial solution that is shorter than a general-purpose Fibonacci function implementation. – Joel Aug 28 '19 at 13:10
• I'm mostly curious about the calculation of n, I want to design it in such a way that it prevents trival answers, as my goal with this challenge is to see some interesting calculations. Trivial answers for very low L or very high L will be possible with a poorly chosen formula. This might even be a question for math.se – Darren H Aug 30 '19 at 12:39
• After some further research and experimentation, I'm considering using n=(L+2)*5 this is the slowest growing formula I have found so far that fits the requirements – Darren H Aug 30 '19 at 12:52

# Compare Multiratios

EDIT: No doesn't make any sense, I need to think about it again.

# Smallest self-hosting golfing language code-golf

Implement a golfing language that is implemented in itself. Formally speaking: The original compiler O (an executable file assumed to be implemented in other language X), when given its own source code S (in golfing language G), must produce the identical executable file O. Your task is to create G by implementing O.

Language X might be an ELF binary, x86 assembly, Python, LLVM IR, etc.

Neither your language implementation S or executable file O may use functions that have the same functionality as exec or eval. That is, you may not use any built-in code evaluation of your compiler O. Standard Quine loopholes, such as reading your own file, downloading your file from the internet, and holding the program data in the filename, are not allowed.

The executable file O of the compiler must not be embedded in any shape or form in the source code S of the compiler. Additionally, the source code S of the compiler must be strictly shorter than the executable file O.

Your code must not be dependent on any external program or internet resource other than language X: if your language is dependent, include the size of the external dependencies in your submissions. Your program gets a standard POSIX system base for free, plus GCC 8 and LLVM 10: you do not have to include the size of this in your submission. For example, if you submitted a Bash Quine that just invoked the 05AB1E interpreter via the command line, you would have to include both the size of the the 05AB1E implementation, as well as the size of the Elixir implementation (since 05AB1E is implemented in Elixir and your base language X isn’t Elixir) in your bytecount.

In addition, standard golfing loopholes apply.

# Requirements

Answer at least 10 other challenges on this website, beating at least 50% of the existing answers in byte size.

## Base language X restrictions

Language X must have an implementation, in other words we must be able to actually run your compiler O with source code S and get compiler O as output.

Language X must have already existed before this post was created.

You are encouraged to share the techniques of how you created your compiler and how you came up with your golfing language.

## Scoring

$$S*0.98^{(n-10)}$$ where n is the number of challenges where you beat at least 50% of the other answers, not including your own.

# Feedback

How can you prevent someone submit a zero bytes answer and claim: if source is empty, it output the interpreter, otherwise output compiled python code. – tsh Aug 24 at 4:42

• I don't think your requirements are a good way to handle making people use a real language. It doesn't do much to prevent abuse and is extremely tedious to perform and to verify. I'm sorry I don't have an alternative, but I think that may be a red flag that this won't work very well on this site. – FryAmTheEggman Sep 3 '19 at 3:49
• Is there a reason languages created after this is posted are not eligible? – trichoplax Sep 3 '19 at 11:42
• It may be worth explicitly stating that lowest wins in the scoring section. – trichoplax Sep 3 '19 at 11:43

# DRAFT: Remove vertical comments code-golf

Vertical commnets...

        /> push back with    result.cows_used.push_back(possiblecow);
the new cow added </ cows_used.push_back(result.cows_used);


        /* push back with */ result.cows_used.push_back(possiblecow);
/* the new cow added */ cows_used.push_back(result.cows_used);

result.cows_used.push_back(possiblecow);
cows_used.push_back(result.cows_used);


Annotated, everything with . is considered a comment:

        />.................. result.cows_used.push_back(possiblecow);
..................</ cows_used.push_back(result.cows_used);


What is both between the start row of /= and the end row of =/ and between the start column of /= and the end column of =/ is considered a comment.

        /> push back with       result.cows_used.push_back(possiblecow);
the new cow added </ cows_used.push_back(result.cows_used);


# Todo

• Can vertical comments be nested or overlapped? – Hiatsu Sep 4 '19 at 18:03
• Will this language have string literal? – tsh Sep 5 '19 at 5:23

# Breaking the Wordbuilder (canned)

Dupe of Let's Play Countdown! ... oh well. Thanks for the feedback everyone.

• Does the dictionary have to be encoded in submissions, or may they take it as input? – Unrelated String Aug 22 '19 at 9:24
• Take it as input. Assume unix-words is a local file. – roblogic Aug 22 '19 at 9:26
• similar question.. Solve an Anagram, this one is possibly a bit easier – roblogic Aug 22 '19 at 15:35
• can languages without file io take unix-words as input? – SuperStormer Aug 22 '19 at 16:33
• @SuperStormer, sure thing – roblogic Aug 22 '19 at 16:44
• So the two differences between this and that are that the input is always precisely five characters long and output words can leave out one or two of them. I'm not really sure if this is a duplicate, but it's close – Unrelated String Aug 22 '19 at 18:23
• The line about the standard loopholes seems to be a bit misleading - the standard loopholes do not ban built-ins that solve the problem. They primarily ban abusive an uninteresting answers like print("an anagram solver"). I'm not sure exactly what you want, but it certainly isn't to allow all loopholes. Unrelatedly, the other challenge included multi-word solutions, so I doubt that answers to either can be trivially used for the other without being highly uncompetitive. – FryAmTheEggman Aug 22 '19 at 18:46
• Thanks @FryAmTheEggman, restored the anti-loophole rule. – roblogic Aug 22 '19 at 18:51
• A closer previous question is Let's play countdown. IMO the change from 9 input letters to 5 is completely trivial, and the change in the filtering is still sufficiently trivial to count as a dupe. – Peter Taylor Aug 23 '19 at 7:37
• @Peter Taylor, you are correct! I'll take this down 😭 – roblogic Aug 27 '19 at 3:29

## Challenge

Given a set of numbers with operators between them: "5 + 4 * 9 / 3 - 8", return all the possible results of the expression for every permutation of the order of basic operations: [/, *, +, -].

## Rules

• Standard loopholes forbidden
• I/O
• Input must be ordered with infix operations, but however that is easiest (string or array)
• Output must be all of the possible results of the expression, no specified format or order, no repeats
• All of the inputs are valid (e.g. do not need to deal with "7 / 3 + *"
• Operators are all left-associative so "20 / 4 / 2" = "(20 / 4) / 2"
• This is Code Golf so fewest number of bytes wins

## Test Cases (With explanation)

• "2 + 3 * 4" = [14, 20]
• 2 + (3 * 4) ⟶ 2 + (12) ⟶ 14
• (2 + 3) * 4 ⟶ (5) * 4 ⟶ 20
• "18 / 3 * 2 - 1" = [11, 6, 2, 6]
• ((18 / 3) * 2) - 1 ⟶ ((6) * 2) - 1 ⟶ (12) - 1 ⟶ 11
• ((18 / 3) * (2 - 1) ⟶ (6) * (1) ⟶ 6
• (18 / (3 * 2)) - 1 ⟶ (18 / (6)) - 1 ⟶ (3) - 1 ⟶ 2
• 18 / (3 * (2 - 1)) ⟶ 18 / (3 * (1)) ⟶ 6

## Test Cases (Without explanation)

• "45 / 8 + 19 / 45 * 3" = [5.765740740740741, 0.01234567901234568, 0.11111111111111113]
• "2 + 6 * 7 * 2 + 6 / 4" = [154,113.5,88]
• I'd recommend removing the bonus part, since people aren't going to do more than they have to, especially if it's code-golf (which I'm assuming this is, though you haven't specified it) – Jo King Sep 5 '19 at 0:03
• An I/O question: would providing 45 / 8 as 45.0 / 8.0 to the program be allowed? I suggest allowing it. This frees users working in languages which parse integers as integer types by default to work on the problem you ask, instead of an ancillary problem. – GammaFunction Sep 8 '19 at 6:22
• @GammaFunction Yes that would be fine – Freddie R Sep 8 '19 at 22:02

# The Rattlin' Bog

There's a relatively famous Irish Folk song called The Rattlin' Bog, a type of cumulative song.

Basically, this is a song that alternates between a chorus and an ever-expanding verse

The chorus is as follows:

Ho, ro, the rattlin' bog
The bog down in the valley-o
Ho, ro, the rattlin' bog
The bog down in the valley-o

Each verse starts with
And on that [x] there was a [y]
A rare [y], a rattlin' [y]

and ends with
In the bog down in the valley-o

Where x is the word from the previous round, and y is the word for the current round. In between these two is the cumulative part. It starts with:
The [z] in the bog

The [y] in the [x] and
To its predecessor.

### Challenge

Given a list of strings, character arrays, or whatever reasonable equivalent collection of string or your language equivalent thereof, Your job is to print the lyrics to the song, alternating between the chorus and each verse, starting and ending with the chorus. The chorus and verse must be separated by a pair of newlines.

For the sake of brevity, you may write the chorus once, preceded by "[Chorus]" then write "[Chorus]" in place. I'm also omitting any sort of final verse with unique text.

Example:

Input: [House, Roof, Nest]
Output:
[Chorus]
Ho, ro, the rattlin' bog
The bog down in the valley-o
Ho, ro, the rattlin' bog
The bog down in the valley-o

And on that bog there was a House
A rare House, a rattlin' House
The House in the bog
In the bog down in the valley-o

[Chorus]

And on that House there was a Roof
A rare Roof, a rattlin' Roof
The Roof in the House and the House in the bog
In the bog down in the valley-o

[Chorus]

And on that Roof there was a Nest
A rare Nest, a rattlin' Nest
The Nest in the Roof and the Roof in the House and the House in the bog
In the bog down in the valley-o

[Chorus]

• I'm terrible at formatting, so if anyone wants to tell me the best formatting for this or edit and reformat it, that's fine. Of course, feedback is also appreciated to make this more readable or easier to understand. Also if/when I put it up on main golf, i'll add the standard disclaimers about abusing loopholes and least bytes wins, etc. – Andrew Baumher Sep 5 '19 at 16:27
• I'm not sure that adding input is enough to make a difference between this and something like There was an Old Lady or There's a hole in the bottom of the sea... – AdmBorkBork Sep 5 '19 at 17:53

# Sliding window minimum code-golfrestricted-complexity

The task is, given a number array of length n and a positive integer k, to compute the smallest values in all its overlapping consecutive subarrays of length k in the order they occur.

The complexity of your program should be no more than linear with respect to n with a constant added.

# Input

A positive integer array of length n and a positive integer k (k <= n)

# Output

A positive integer array with n - k + 1 elements, where the element at position i equals the least number in the subarray starting at i and ending at i + k - 1 inclusive.

# Examples

[1, 3, 5, 7], 2 -> [1, 3, 5]
[1, 3, 5, 3, 5, 1], 3 -> [1, 3, 3, 1]


TODO

# Sandbox stuff

• Is it acceptable to combine code-golf with restricted-complexity?
• Is the complexity restriction clear enough?
• Is it a good idea to allow calculating the maximum instead of the mininum?
• Is the grammar correct enough?
• Has this been posted before?
• Do any languages have built-ins for this?
• Close to a dupe. This one adds the minimum operation; you don't need to modify the programs in that question too much in order to post submissions for this challenge. – user85052 Sep 7 '19 at 14:08
• @A_ I'm perfectly certain it's not, that one doesn't have [restricted-complexity]. – the default. Sep 7 '19 at 14:12
• This functionality is needed in statistical analysis so I think many statistics / data analysis oriented languages or libraries would have a built-in for it. For example, this is the built-in in the R language. – Joel Sep 7 '19 at 15:24
• Meanwhile, the complexity of the function depends also on k. So "linear with respect to n with a constant added" might not be accurate enough without mentioning k. It would be better to say sth. like "linear with respect to n for each fixed value of k". – Joel Sep 7 '19 at 15:28
• @Joel Are you sure? I think I can compute it with a deque in O(n + k), and since k <= n that is linear with respect to n. – the default. Sep 7 '19 at 15:31
• A basic deque-based approach needs O(k) time to calculate or updating the minimum for each window in the worst case so the overall worse-case complexity would be O(n + k(n - k)) which is the same as O(n + kn). If you use a priority queue the complexity can be driven down to O(n+nlogk) or maybe O(n) only for some very advanced implementations. How do you implement that in O(n + k)? – Joel Sep 7 '19 at 15:53
• – the default. Sep 7 '19 at 16:07
• @someone OK. That algorithm is O(n). So you may emphasize in the description to say "The complexity of your program should be O(n), i.e. linear with respect to n for every possible k <= n", in case anyone wonders about whether an O(n + nlogk) implementation is accepted. – Joel Sep 7 '19 at 16:39
• @Joel I'd argue O(n log k) is not really linear with respect to n (since that equals O(n log n)) – the default. Sep 8 '19 at 6:04
• @someone O(nlogk) is not linear with respect to n but it is also different from O(nlogn) because it really depends on the input k. If k has another constraint itself (e.g. an upper bound that is better than O(n)), O(nlogk) could be better than O(nlogn). That is why I suggested you clearly mention about the range of k in the complexity description to avoid any possible confusion, as I showed in my comment. – Joel Sep 8 '19 at 6:26

# Random point on a sphere

Posted here

• Must we use a specific distribution (e.g. uniform or normal) or is the "bias" acceptable? – Erik the Outgolfer Aug 23 '19 at 10:11
• @EriktheOutgolfer My intention was to require a strictly uniform distribution. I do realize that it is unreasonable to verify this for each and every submission, so I have not made up my mind about that yet. Any suggestions? – Jitse Aug 23 '19 at 10:18
• I'm in favor of just using the community default for randomness, that is, if every possible output (up to precision limits) has a non-zero probability of being returned, the submission is valid. – Erik the Outgolfer Aug 23 '19 at 10:24
• @EriktheOutgolfer That sounds like a decent compromise. I'll update the challenge. – Jitse Aug 23 '19 at 10:43
• Hm... another thing I noticed is that you have 6 tags, you can't have more than 5. – Erik the Outgolfer Aug 23 '19 at 11:13
• @EriktheOutgolfer I was unaware of that. I'm removing number-theory, since it is the least fitting. – Jitse Aug 23 '19 at 11:20
• Also, thanks for your feedback! – Jitse Aug 23 '19 at 11:20
• Pick three uniform random numbers and normalise? I think it would be a more interesting question with the requirement that if the random number generation were substituted with true RNG from the reals then the distribution would be uniform. That opens up a variety of approaches. – Peter Taylor Aug 24 '19 at 6:29
• @PeterTaylor That was my original intention and I agree that it would definitely be more interesting. However, I thought it might be tricky to verify the uniformity of the distribution for each submission. Your reference could help with that, though. – Jitse Aug 24 '19 at 9:52
• I seem to remember a similar challrnge about uniformly generating random numbers that add up to the input, but I can't find it. Not that this is a duplicate, just related – Jo King Aug 25 '19 at 12:17
• The challenge as it stands is impossible. Since there are more real numbers than finite binary strings you cannot represent real numbers in the output of a program. It is going to be impossible to create a program that has a chance of outputting all the real numbers on the surface of a sphere. You likely need to restrict the output domain in some way. – Wheat Wizard Aug 25 '19 at 14:27
• @JoKing perhaps this? – Giuseppe Aug 27 '19 at 14:14
• @PeterTaylor Since your comment has received quite some upvotes, I have reverted the challenge back to requiring a uniform distribution. I included some examples of how to achieve this. Do you think it is clear enough like this? – Jitse Aug 28 '19 at 8:21
• I think it's preferable to talk about being "theoretically uniform": to achieve actual uniformity "up to the precision limits of your language" would probably require using intermediate values of greater precision. Finding the right wording for questions which use floating point numbers is hard! – Peter Taylor Aug 28 '19 at 8:30
• In your second and third remarks, it would be good to point out that the random numbers in these invalid schemes are uniform. As shown in the fourth remark, both schemes are valid with specific non-uniform distributions. – Nitrodon Aug 29 '19 at 21:28

# Consequence Golf

As specified by this xkcd, Consequence Golf is a game involving golfing and bombs. The most obvious consequence of bombs: damage to the course.

A Consequence Golf course consists of the union of several circular regions. The tee is located at (0, 0). On each turn, you hit the ball bomb in a direction at some power. The bomb will travel in that direction for a distance equal to the power of the shot, unless it hits the edge of the course, in which case it will explode immediately. When a bomb explodes, it adds to the course a new circle centered on the point of contact with a radius equal to the remaining power. The next shot starts at the last location of the bomb.

### Input

• A list of circles, consisting of x/y coordinates and a radius for each circle, taken in any convenient format. If you must define a custom data type to store this information (e.g. struct c{float x,y,r};), you do not need to count that added boilerplate, nonproductive storage code in your byte count. Any code that does something besides specify storage must be counted.
• A list of strokes, consisting of an angle in radians or degrees, and a power, again in any convenient format.

### Output

• The location of the bomb after the final stroke.

• The course will always contain at least one circle
• The course will always contain the tee at (0, 0)
• If there are zero strokes, you must return (0, 0)
• The power of a stroke will never be zero
• "Any convenient format" means a list of lists, list of C structs, a list for each input (x, y, radius, power, angle), or similar. You may not take information that is not as it is specified. For example, you may not take the circles as a series of equations.
• This is consequence code golf, so shortest code in bytes wins.

TBD...

### Questions for META:

• Is the description of how to play Consequence Golf clear enough?
• Is the description of the input clear enough? This is my main concern.
• Is allowing boilerplate storage code outside of the byte count an issue?
• I am considering allowing fixed point approximations with at least 4 bits of precision for languages without floating point (and languages with, if it somehow makes things shorter). Would this cause any unintended issues?
• The overview talks about the bomb hitting walls, but the input section doesn't include anything about the walls. – Peter Taylor Sep 9 '19 at 8:27
• When I first posted this to PPCG, @PeterTaylor pointed out that although outputs to a file are allowed for King of the Hill challenges, it is preferable to use STDIN/STDOUT. But the fundamental problem is that programs need a standard venue, hidden from each other but not from the Arbiter, in order to Exchange. – Purple P Sep 9 '19 at 16:02
• If you fail to challenge an assassination, how do you format losing two cards? – Hiatsu Sep 9 '19 at 16:07
• @Hiatsu Assuming you mean "incorrectly challenge" or "get caught falsely blocking with a Contessa", you don't need to. You write the card you lost from the failed challenge, then the Arbiter detects that the move was an Assassination and you are eliminated. But your wording could be interpreted another way: I noticed in your answer to the original challenge that you always challenged or blocked Assassinations. You don't have to do that. You can surrender one of your cards right away. – Purple P Sep 9 '19 at 16:12
• As long as each program has its own STDIN/STDOUT (using player=subprocess.Popen(args, stdin=subprocess.PIPE, stdout=subprocess.PIPE); player.stdin.write("I\n"); response=player.stdout.read(1); or similar), you can copy across communication from the other player but restrict exchanges to the relevant player. – Hiatsu Sep 9 '19 at 16:16
• Also, if you are willing to translate the Arbiter into Java, you can use this to arrange games. – Hiatsu Sep 9 '19 at 16:18
• @Hiatsu Done! ...Well, kind of. I gave up and posted the original question. See my explanation in the comments here. – Purple P Sep 10 '19 at 0:09

Encode MC6000 instructions

In MC6000, these are registers list:

acc  general
dat  general
p0   simple pin
p1   simple pin
x0   XBus pin
x1   XBus pin
x2   XBus pin
x3   XBus pin
null pseudo


where general means reading from it returns the last value written to it, XBus pin means reading from or writing to it have side effect(so teq x0 x1 doesn't equal to teq x1 x0) that nothing else can take its place, simple pin means reading from it also writes zero to it(so mov 0 p0 equals to mov p0 null), writing anything to it(including the writing while reading) have side effect, and writing anything larger than 100 behaves same as writing 100, as well as writing anything smaller than 0 same as writing 0(so mov -4 p0 equals to mov 0 p0). Writing anything into null has no effect and reading from null returns 0(so mov 9 null equals to nop).

The instruction set is:

nop            Do nothing
mov R/I R      operand2:=operand1
slp R/I        Sleep for the number of time units specified by the operand.
slx XP         Sleep until XP avaliable(can't be replaced)
sub R/I        acc:=f(acc-operand)
mul R/I        acc:=f(acc*operand)
not            acc:=100(if acc was 0) or 0(otherwise)
dgt R/I        acc:=(acc/10^operand)mod 10(if operand in 0,1,2) or 0(otherwise)
dst R/I R/I    acc:=[abs(acc-[(acc/10^operand1)mod 10]*10^operand1)+abs(operand2 mod 10)*10^operand1]
*sgn(operand2*2+1) (if operand1 in 0,1,2) or acc(otherwise)
teq R/I R/I    sym:='+'(if operand1 equals to operand2) or '-'(otherwise)
tgt R/I R/I    sym:='+'(if operand1 is larger than operand2) or '-'(otherwise)
tlt R/I R/I    sym:='+'(if operand1 is smaller than operand2) or '-'(otherwise)
tcp R/I R/I    sym:='+'(if operand1 is larger than operand2),
'-'(if operand1 is smaller than operand2) or '*'(otherwise)
gen SP R/I R/I Output 100 and 0 to the simple pin for the latter two operands, inclusive


Here R/I means a register or an integer between -999 and 999, inclusive; R means a register, L means an integer between 0 and 13, XP means an XBus pin, and SP means a simple pin. f(x) is defined as min(999,max(-999,x)). Sleeping for zero or negative time units sleep for time as long as a nop(so nop=slp 0=slp -3).

Before an instruction, symbol +, - and @ can exist, meaning that the instruction is executed only if sym is +, - and @, inclusive. (@ doesn't work like this in fact but that doesn't affect this problem) Whether the instruction is executed matters even if it's a no operand(so + nop doesn't equal to - nop, but + nop equals to + tgt 1 0).After an instruction, comment start with # can exist, which can be ignored. Spaces work as separator, and can be added or removed as long as words are separated in the same way(continious spaces, spaces at both side).

Now, write a program A that, reads an instruction and output an integer; and write a program B that reads the output of program A and output an equal or same instruction fed into program A.

Your score will be the sum of length of program A, length of program B, and difference between the maximum and minimum of output of A. Lowest score in every language win.

Using MetaGolfScript is allowed. Only write MetaGolfScript in language area and show the exact version you use in code area to make it leaderboard friendly.

• Why do you allow MetaGolfScript? Does it add anything to the challenge apart from a boring winner answer? – wastl Sep 9 '19 at 13:47
• @wastl Pure (difference between the maximum and minimum of output of A) worth optimize – l4m2 Sep 10 '19 at 4:39

Tiling string

(inspired by the tiling pattern effect tipic of the texturing of landscapes. This question I would like to ask is not exactly the same thing but close to it, or at least it was the idea)

Given a string S check if it has some repeating tile pattern and prove it providing at least one repeating pattern.

A substring tile pattern is a pattern of any form which repeats inside the string where one or more(alpha case insensitive) chars forms a fixed structure that can contain also others generic chars(all printable ascii table set)

the output will be false,0,f or any meaningful negative expression if no tiling occours. true,1,... plus at least one repeating tile pattern instead.

for example :

 they were obsessed by the sessions
s#ss          s#ss
outputs : true s#ss

look at that truck
t$t t$t
outputs: 1,t$t - case insensitive. - only letters matters as tile pattern. - if two letters are separated by space or every non letter char they still form a pattern. - overlaps doesnt make tiling effect. - a pattern must contain half or more structure chars and must be len>1 to be considered, and must be repeated at least two times.  example "Hello world!"=> false or 0 or f or no "aa"=>false. aaa=>false. "aaaa"=> true(aa) "aabbabab"=>true:ab,ba or 1 ab ba. or yes[ba,ab] or...any reasonable format This is code-golf so shortest answer wins • Can you give an example of a tile with non-structure characters? – Hiatsu Sep 14 '19 at 21:51 • Hi!ho!bushy! => h#! Here h and ! Form a pattern of 2 fixed symbols and one ?symbol between. But it's not valid as ! is not an alpha character. The same applies to spaces or , or . for example.. – AZTECCO Sep 15 '19 at 8:06 • An explanation of how to form rectangular prisms out of factors would probably help. It seems like you're asking for the output to be every unordered multiset of three natural numbers the product of which is the input, in which case I'm not sure where the connection to geometry is, except in that each set can describe the dimensions of a rectangular prism among a host of other things. I guess because the volume of each prism is equal to the input? – Unrelated String Sep 14 '19 at 5:54 • Why 1000 as the upper limit? I could understand 256 to cater for languages whose native type is the 8-bit integer, or $2^{31}-1$ for languages whose native type is the 32-bit signed integer, but 1000 seems completely arbitrary and I can't see any benefit to having the limit. – Peter Taylor Sep 14 '19 at 8:33 • @PeterTaylor, I just thought 1000 was a nice number, but I've made is $2^{31} - 1$ now. – Lyxal Sep 14 '19 at 8:54 • @UnrelatedString, see the updated post – Lyxal Sep 14 '19 at 8:54 # Observability and controllability ### Background Note: if you like, you can skip this part, and simply implement the suggested algorithm. When looking at dynamic systems, there exist the notions of observability and controllability. They are the answers to the questions • Observability: can we know all the internal states of a system by looking only at the given outputs? • Controllability: can we influence all the internal states of a system by changing only the inputs? For the sake of this question, we will only look at LTI (linear time-invariant) systems, either in continuous or discrete time. During the rest of the question, I will only present the case of a state-space representation of the system and suggest using the observability- or controllability Gramian, but you may use any other algorithm to decide the controllability and observability of the given LTI system. ### Input You are given an LTI system, $$\mathbf{\dot{x}}(t) = A\mathbf{x}(t) + B\mathbf{u}(t)\\\mathbf{y}(t)=C\mathbf{x}(t)$$ where $$\A\$$, $$\B\$$ and $$\C\$$ are matrices containing only integers. The dimensions of these matrices are $$\\dim{A}=n \times n\$$, $$\\dim{B} = n \times p \$$ and $$\\dim{C} = q \times n\$$ with $$\n\$$, $$\p\$$ and $$\q\$$ positive integers. A suggested input method would be to simply input these matrices, but you may also take input as function objects, string representations of differential equations, or transfer functions. ### Output You must output two thruthy/falsy values, one indicating whether the system is controllable, and one indicating whether the system is observable. Order does not matter but must always be the same. Alternatively, you may have four distinct outputs (e.g., the integers 0, 1, 2, 3) each corresponding to a possible combination of controllability/observability. ### Suggested algorithm To decide on observability and controllability, you can calculate the so-called observability Gramian (a square matrix), $$\begin{bmatrix}C & CA & CA^2 & ... & CA^{(n-1)}\end{bmatrix}^T$$ and controllability Gramian $$\begin{bmatrix}B & AB & A^2B & ... & A^{(n-1)}B\end{bmatrix}$$ The system is observable iff the observability Gramian is invertible. The system is controllable iff the controllability Gramian is invertible. There are many ways to check if a matrix is invertible; an obvious way would be to check if the determinant equals zero. # Testcases Coming soon, because I want to include worked examples. • I'm not sure requiring tests for both is particularly meaningful, since an LTI system $(A, \cdot ,C)$ is observable iff the LTI system $( A^{T}, C^{T}, \cdot )$ is controllable. Otherwise I think this is fine (though for some reason I thought it had already been asked, but I didn't find a dupe). – FryAmTheEggman Sep 15 '19 at 18:54 • @FryAmEggman True but I think almost-repetition can make golfing challenges interesting because there's so many ways to do that. – Sanchises Sep 15 '19 at 20:10 • @FryAmTheEggman Thanks for the edits, by the way. – Sanchises Sep 15 '19 at 20:11 • So: If input ends with ? and has , return text from last , until before ? Else, if input ends with ? return No Else, return Yes. Right? – Adám Sep 15 '19 at 9:20 • That's correct. – user85052 Sep 15 '19 at 10:55 • Then maybe just say so instead of over-complicating it? – Adám Sep 15 '19 at 11:36 ## Smallest put pixel function Task: write in any language which can generate images e.g. JavaScript, the smallest "put pixel" function. You can initialise screen inside that function or in separate code. The put-pixel function should consume 6 arguments: x,y,r,g,b,a where x,y pixel coordinates and r,g,b,a are color values (a is for alpha - transparency - you need blend new color with old color). Provide also example which use that function a draw something. • I think the way this is worded will likely make it too broad or unclear. I think it would work better if you essentially required that this function be implemented to solve a more normal golf task that you could have test cases for. For example, "given vectors x,y,r,g,b,a produce an image where each pixel xi,yi has colour (ri,gi,bi,ai) and the rest are black". That would usually make submissions do as you say, but avoid ambiguities like "function" and "arguments" which may not exist precisely in languages people want to use. – FryAmTheEggman Sep 19 '19 at 19:45 # Shuffling Sequence Consider an operation $$\f_n\$$ that takes a length-$$\2n\$$ list and performs a perfect shuffle on it, reversing the second half. For example, $$\f_4 [abcdABCD] = [aDbCcBdA]\$$. Under composition, $$\f_n\$$ generates a cyclic group. That is, there exists some minimal positive integer $$\m\$$ such that $$\(f_n)^m\$$ (which means $$\f_n\$$ composed $$\m\$$ times with itself) is an identical map, leaving its argument alone. Here's an example for ya: $$f_2 [abAB] = [aBbA]$$ $$f_2 [aBbA] = [aABb]$$ $$f_2 [aABb] = [abAB]$$ $$f_2(f_2(f_2 [abAB])) = (f_2)^3 [abAB] = [abAB]$$ Since $$\(f_2)^3\$$ is the identity, we say that $$\f_2\$$ has order 3. Your task is to determine the order of $$\f_n\$$. You've got a few choices for how to do this: • Take as input $$\n\$$ and provide as output the order of $$\f_n\$$ • Take as input $$\n\$$ and provide as output the order of each $$\f_k\$$ for $$\k < n\$$ or for $$\k \le n\$$ (your choice) • Output these orders indefinitely, beginning with that of $$\f_0\$$ or $$\f_1\$$ (your choice) For reference, the first 77 terms (beginning from $$\n = 1\$$; you may optionally return $$\1\$$ for $$\n = 0\$$) are provided below. This is OEIS A294673. 1,3,5,4,9,11,9,5,12,12,7,23,8,20,29,6,33,35,20,39,41,28,12,36,15,51,53,36,44,24,20,7,65,36,69,60,42,15,20,52,81,83,9,60,89,60,40,95,12,99,84,66,105,28,18,37,113,30,92,119,81,36,25,8,36,131,22,135,20,30,47,60,48,116,132,100,51,155  Standard IO and loophole rules apply. This is , so the shortest program (in bytes) in each language wins! Happy golfing! • You may want to add a brief explanation that the exponentiation you use is on the group (i.e. repeated application of $f_{n}$) and not the one most people are used to. I'd guess the average reader of this site doesn't know what a group is, but I may be being overcautious since it wouldn't really make much sense otherwise. Maybe run it by some people who don't know what groups are, if you can. – FryAmTheEggman Sep 19 '19 at 18:48 • @FryAmTheEggman How's that? – Khuldraeseth na'Barya Sep 19 '19 at 18:55 • I don't understand what you are asking, but maybe I rambled too much to be clear? Anyway, my point was that I think the challenge is good but it might come off as inaccessible to users with less maths background. I suggested asking other people (maybe someone you know or people in chat) about if the wording is confusing to them. – FryAmTheEggman Sep 19 '19 at 19:15 • @FryAmTheEggman My mistake. What I meant was "Updated. What do you think now?" Dang ambiguity. – Khuldraeseth na'Barya Sep 19 '19 at 19:46 • Haha, I didn't see the edit because I didn't scroll up, my bad. That definitely looks better, though I'm not exactly the target of my own comment. – FryAmTheEggman Sep 19 '19 at 19:49 # Golf Golf! This is my first challenge, so please be gentle! The challenge is to write a program that will output the correct score for a layout in the card game "Golf." The card game Golf has many variations. The house rules I use follow the standard rules for Six-Card Golf given by Pagat, with one slight difference. Each player has a 2x3 layout of cards. By the end of each round all cards are turned face up and scored as follows: • Each ace counts 1 point. • Each two counts minus two points. • Each numeral card from 3 to 10 scores face value. • Each Jack or Queen scores 10 points. • Each King scores zero points. • A pair of equal cards in the same column scores zero points for the column (even if the equal cards are twos). • Three equal cards in the same row scores zero points for the row (even if the equal cards are twos). ## Input The input can be a string or array of any kind. ## Output An integer representing the score of the Golf hand. ## Examples These use the notation A23456789TJQK. Layout AK3 J23 Score 7 ----------------------- Layout 25Q 25J Score 20 ----------------------- Layout T82 T8A Score -1 ----------------------- Layout QQQ 234 Score 5 ----------------------- Layout TJQ QTJ Score 60  This is code golf, so the shortest answer in bytes wins! • I'd recommend allowing submissions to take the layout as a list of numbers with a reasonably convention. The point of this challenge appears to be in analysing the layout and applying the rules, not in performing string parsing. Otherwise this looks good to me. – FryAmTheEggman Sep 22 '19 at 20:07 # Reorder a matrix, twice You are given a square $$\n \times n\$$ matrix $$\A\$$, and a list (or vector) $$\u\$$ of length $$\n\$$ containing the numbers $$\1\$$ through $$\n\$$ (or $$\0\$$ through $$\n-1\$$). Your task is to reorder the columns and rows of the matrix $$\A\$$ according to the order specified in $$\u\$$. That is, you will construct a matrix $$\B\$$ where the $$\(i,j)\$$-th element is the $$\(u(i),u(j))\$$-th element of $$\A\$$. You should also output the inverse of this action; that is, the (i,j)-th element of $$\A\$$ will end up at position $$\(u(i),u(j))\$$ in a new matrix $$\C\$$. For example, given $$A = \begin{bmatrix} 11 &12& 13 \\ 21& 22& 23 \\ 31& 32& 33 \end{bmatrix},\quad u=\begin{bmatrix}3 & 1 & 2\end{bmatrix}$$ the output should be $$B = \begin{bmatrix}33 & 31 & 32 \\ 13 & 11 & 12 \\ 23 & 21 & 22 \end{bmatrix},\quad C= \begin{bmatrix}22 & 23 & 21 \\32 & 33 & 31 \\ 12 & 13 & 11 \end{bmatrix}$$ You may take input and output through any of the default I/O methods. You do not have to specify which matrix is $$\B\$$ or $$\C\$$, as long as you output both. You may assume $$\A\$$ only contains positive integers. You must support matrices up to at least size $$\64 \times 64\$$. ## Example ===== Input ===== A = 35 1 6 26 19 24 3 32 7 21 23 25 31 9 2 22 27 20 8 28 33 17 10 15 30 5 34 12 14 16 4 36 29 13 18 11 u= 3 5 6 1 4 2 ==== Output ===== B = 2 27 20 31 22 9 34 14 16 30 12 5 29 18 11 4 13 36 6 19 24 35 26 1 33 10 15 8 17 28 7 23 25 3 21 32 C = 17 15 8 10 28 33 13 11 4 18 36 29 26 24 35 19 1 6 12 16 30 14 5 34 21 25 3 23 32 7 22 20 31 27 9 2  # No, you don't need deep learning: AlphaGo edition To counter the industry fad of tackling the most trivial problems with deep learning, I propose that a proof of concept be created to demonstrate that simple database queries are in fact often sufficient. To wit, I propose to demonstrate that a database query can in fact be used to do what AlphaGo does and even do it better. The proof of concept will consist of two parts: • A Script to create a script to create a (...) query that, given the state of a game of Go, will retrieve a move that will result in eventual victory. • A Script to create a script to create a (...) script to initialize the database. This is a challenge so the least total bytes wins. Some rules for the challenge: 1. You may use whatever database lets you golf best 2. There is no limit for how many recursions of running the script generated by the script are required 1. This includes directly submitting the query and (if the universe's hard drive capacity somehow permits) the init data 3. The final init script may also be an executable-ish that connects to the database backend to populate it 4. You may either pass the game state as an argument to the query or store the state in the database (storing the state in the DB doesn't count toward your score) 5. Handicap games don't need to be accounted for. The rules of Go are, paraphrased: • The game is played by placing black and white stones on a 19x19 grid • The aim of the game is to score points by surrounding open space with your stones (The edges of the board count as surrounding) • Black plays first • A stone is part of a group if it is orthogonally connected to a member of the group • The empty spaces orthogonally adjacent to a group are called liberties • A group without liberties is considered captured and is removed from the board and added to the capturing player's score • A group that can not escape capture is considered dead, and remains on the board but will count as captured for scoring purposes • Suiciding your own group by filling its last liberty is not allowed • Ko rule: If a single stone is captured so that capturing the capturing stone will return the board to the immediately previous state, such second capture is illegal on the turn after the first capture. • The game ends when both players pass, indicating that they can't improve their score by playing another stone. • As it stands there doesn't seem to be any requirements on making actually good moves. I'm not convinced you can fix that well without making this into a king-of-the-hill which will be a lot more work for you. Further, I suspect databases that make any actually good moves will need to be so large that you may struggle to see meaningful results. – FryAmTheEggman Sep 21 '19 at 19:07 • So it looks like you want us to write a solver for go that's optimal but likely extremely slow? I suspect this will come down to implementing the rules of Go then writing a simple recursive evaluation function, and that the Go rules will take most of the work. I'm confused where the database and scripts come in. – xnor Sep 22 '19 at 5:30 • @xnor I thought this up when I read a rather ranty blog post (which I can't seem to find anymore) about how one doesn't need deep learning, with the sole supporting argument being that data retrieval can be done with database queries. – HAEM Sep 22 '19 at 8:55 • @FryAmTheEggman This is a bit of a joke challenge (see above comment for details) – HAEM Sep 22 '19 at 8:55 • Come to think of it, I could probably leave out generating the query and leave it at just the database initialization. – HAEM Sep 22 '19 at 8:59 Where am I? Given an input folder structure (i.e. a tree data structure with named nodes), and a pointer to a directory (a specific node) within that tree structure, the program should output the full path to the directory the pointer is pointing at (in linux format, so /var/log for example), without ever inspecting the name of the current node or its ancestors; only its descendants. The rules of the challenge are the equivalent of: "you can cd and ls but not pwd" if this was being run on a live linux files system but I feel I should expand on that a bit regarding how it works for a tree: • The method starts with the pointer, and it can ls to see what is contained within this directory (i.e. view the immediate child nodes in the tree structure, but not its own name) • the method can also cd dirname into any directory (i.e. move the pointer to any immediate child in the tree from the current node), and cd .. to go to a previous directory (i.e. move the pointer to the immediate previous child in the tree) • cd .. leaves you in the same directory (node), if there is no parent • cd invalidDirNameleaves you in the same directory (node), if there is no immediate child with that name • Any directory can contain any number of other directories, or none. • You are forbidden to do the equivalent of cd / Inputs A tree-structure representing a file system and a pointer to a node in that tree Assumptions 1. There are no duplicate folder names in the same parent folder (so ls can't return folder, folder; for example) - but there may be other folders with the same name elsewhere in the tree structure; in which case it doesn't matter which your program outputs (as it has no way of knowing which is correct) 2. ...Therefore, it may not be possible to determine which folder you started in - in which case a best-guess is fine (see examples 3, 4) 3. Symlinks and cyclical trees are not a part of this challenge - it will always be a simple parent-child tree structure - so you are always guaranteed to find the root by doing cd .. enough times. Output The path that the pointer was pointing at, as a string or char array (or equivalent for your language). Scoring scoring is used, so shortest bytes wins. Example 1 input map: /var/ftp/in, /var/ftp/out/child, /var/etc/test/child/etc, /var/etc/test/c2/etc2, /var/etc/test/c3 input pointer points at: c2 sample working: 1. ls -> "etc2" 2. cd .., ls -> "child","c2", "c3" - three options, need to find which is correct 3. cd child, ls -> "etc2" - this doesn't match 1, so go back 4. cd .., cd c2, ls -> "etc2" - this is correct, so I know my path ends with "/c2" 5. cd .., cd .., ls -> "test" - only one folder, so I know my path ends with "/test/c2" 6. cd .., ls -> "ftp", "etc" - two options, need to find which is correct 7. cd ftp, ls -> "in", "out" - incorrect, so go back 8. cd .. -> there was only two options, so "etc" must be correct. my path ends with "/etc/test/c2" 9. cd .., ls -> "var" - only one folder, so path ends with "/var/etc/test/c2" 10. cd .., ls -> "var" - same option, so assume we're at root. 11. Output "/var/etc/test/c2" Example 2 input map: /app/data/dir/in input pointer points at: /app/data Output: "/app/data" Example 3 input map: /var, /app, /test input pointer points at: /app Output: "/var", "/app" or "/test" are all valid outputs. Note that there is no way for the program to differentiate between the three folders; and so any of the three are a valid answer for the purposes of this application. Example 4 input map: /var/etc/test, /app/etc/two input pointer points at: /app/etc Output: "/app/etc" Questions 1. Does the spec make sense? • Nice idea for a challenge, but: I would remove the free cd and ls helpers for it only creates problems, you can (partially) solve the issue of using system built-ins by just allowing the directory-structure as input and not a directory-node (there will still be one or two solutions like eval mkdir -p$1;eval \$2;pwd) but they are not really interesting and need to create the directories which is a penalty). I would also remove the explanations of examples 2-4, one suffices and more makes the post hard to read. – ბიმო Dec 13 '18 at 22:24
• Thanks for your comments! I think I'll remove the cd/ls stuff and the file system input, like you suggest. What would you recommend for the examples 2-4 then - just show the input and output? Or just show the working but not the text explanations? Should I include the result of "ls" each time also in that case? – simonalexander2005 Dec 14 '18 at 9:49
• Just input and output should suffice imo. Maybe you want to exchange 1 and 2 such that there is the more thorough explanation of 2 and 1 just i/o. – ბიმო Dec 14 '18 at 10:26
• done :) Thanks for your input. How does it look now? – simonalexander2005 Dec 14 '18 at 13:16

## Title: The Liquorice All-sort

I have just invented a new sorting algorithm, which I would like you to implement in the smallest number of bytes... The Liquorice All-sort

Given that the individual sweets are (or were) named: chips, rocks, Buttons[sic], nuggets, plugs, twists, spogs (https://en.wikipedia.org/wiki/Liquorice_allsorts), we can say that:

A bag (multiset) of Liquorice allsorts is comprised of 0..n of each item chip, rock, Button, nugget, plug, twist, spog, plus a bonus of 1..2 Bertie.

Given an input of an arbitrary array characters (A-z, 0-9, space), and a bag of Liquorice allsorts, sort as follows:

For each input character, from last to first:
Is the bag empty?
Yes: Exit the sort
Else, Is the input equal to a letter (case-sensitive) that is contained in the name of one or more of the sweets in the bag?
Yes: The number of items it matches is the number of positions it moves up the list (can't move past the top of the list).
Take a bite out of each of the used sweets, by removing the letter we used.
Have we used all the letters in any item?
Yes: Remove that item from the bag
Else: move to the bottom of the list.


## Inputs

two inputs - the numbers to sort, and the list of sweet names. Both are guaranteed to be non-empty bags (sets that can contain duplicates; or an equivalent in your language), and the bags of sweets contains a minimum of one Bertie.

## Outputs

The sorted numbers

## Examples

1. {Bertie},{B} -> {B}
2. {Bertie},{X,B} -> {B,X}
3. {chip, rock, Button, nugget, plug, twist, spog, Bertie}, {A,B,C,k,e,r,w} -> {B,C,k,e,r,w,A} -> {B,C,k,e,r,w,A} -> {B,k,e,r,w,A,C} -> {k,B,e,r,w,A,C} -> {e,k,B,r,w,A,C} -> {e,r,k,B,w,A,C} -> {e,r,k,w,B,A,C}
4. {Bertie, rock}, {r,o,c,k,r,o,c,e} -> {r,o,c,k,r,o,c,e} -> {o,r,c,k,r,o,c,e} -> {o,c,r,k,r,o,c,e} -> {o,c,k,r,r,o,c,e} -> (remove rock from the bag) -> {o,c,k,r,o,c,e,r} -> {o,c,k,r,c,e,r,o} -> {o,c,k,r,e,r,o,c} -> {o,c,k,e,r,r,o,c}

## Sandbox Questions

I really like the idea of doing something with this (I like the wordplay of bag, etc.); but I don't know if the algorithm is just too arbitrary. Any thoughts or alternatives would be appreciated!

• Absolutely not. (although you're encouraged to post your sandbox challenges when they're ready) – user202729 Apr 10 '18 at 14:56
• You only have 3 challenges in the Sandbox at the moment; some people have north of 30 - You don't have to worry. – caird coinheringaahing Apr 10 '18 at 15:43

Title - Fix the note

Given a musical note letter (A to G), followed by any number of accidentals (either 0..n # or 0..n b, not a combination of both); output a representation of the same note with the least possible number of accidentals.

A # means "shift the note one semitone up", and a b means "shift the note one semitone down".

All valid output notes are as follows (in order, then loops):

A A#/Bb B C C#/Db D D#/Eb E F F#/Gb G G#/Ab

So a sharp would move to the right along that list (and loop); and a flat would move you to the left.

Examples

• A -> A
• B# -> C
• Fb -> E
• A##### -> D
• Dbbb -> B
• Gbbbbbbbbbbbb -> G
• Bb -> Bb
• F# -> F#
• E## -> F#
• E# -> F

You can assume that the length of the input won't overflow your language.

Where the input has sharps, the output can also only contain 0..1 sharps; and vice-versa for flats.

This is , so shortest bytes wins. Standard rules apply

• These accidentals aren't even correct. There's no such thing as E sharp sharp. – S.S. Anne Sep 25 '19 at 20:42
• Also, should E sharp be simplified to F? Is this bass, treble, or tenor? – S.S. Anne Sep 25 '19 at 20:43
• @JL2210 sure there is - any note can be represented as accidentals of another note, in theory. I know that in practise you wouldn't do so. – simonalexander2005 Sep 26 '19 at 8:26
• E# should be simplified to F, yes, because the aim is to reduce the number of accidentals where possible – simonalexander2005 Sep 26 '19 at 8:27
• I'm not sure what you mean by "is this bass, treble or tenor?" - The instrument shouldn't matter for the purposes of this - this is purely theoretical (they're notes, not chords, if that helps) – simonalexander2005 Sep 26 '19 at 8:28

Title: Score my Tarok hand

Inspired by this challenge

In Slovenia (and elsewhere in central Europe), the card game Tarok is very popular. See here for a complete list of rules, but essentially it is a trick taking game, played in teams that change per round.

This challenge is a challenge, concerning the scoring of a hand, at the end of a round.

In a normal round, the game is played in partnerships. Any one player could decide the "contract" for the round, and that player (plus anyone on their team) either wins or loses the round, giving them a positive or negative score. They are known as the "Declaring team". The "Opposing team" cannot score in that round.

The input for this challenge will therefore be the Declaring team's cards, plus the contract type they bid for.

The cards

In a game of Tarok, there are 54 cards; as follows (shown as highest to lowest in each suit - names in brackets after a card are local names given to certain cards):

• Spades, Clubs: King, Queen, Knight, Jack, 10, 9, 8, 7
• Diamonds, Hearts: King, Queen, Knight, Jack 1, 2, 3, 4
• Taroks: Joker (škis), XXI (mond), XX, XIX, ... III, II, I (pagat)

The point value of the cards are as follows:

• kings, škis, XXI and I - 5 points each
• queens - 4 points each
• knights - 3 points each
• jacks - 2 points each
• all other cards - 1 points each

Scoring a hand

This is what I believe makes this challenge interesting.

• For each set of three cards in your hand, add up their values and subtract 2.
• If you end up with one or two cards left over after making the sets of three, add up their values and subtract 1.
• So, a pair or a set of three one-point cards are both worth 1 point; but a single one-point card is worth nothing.

The total value of the pack comes to 70 card points.

In most contracts (see below), the declarer's side wins if at the end of the play they have at least 36 of the available 70 points; otherwise they lose. Because of this, the members of each team pool their cards for scoring; and so if you know the score of one team, you can calculate the score of the other.

Once the hand value has been calculated, the difference from 35 is taken (i.e. handValue - 35), and this difference is rounded to the nearest 5 points.

Contracts and Bonuses

Once the hand score is known for the declaring team, the final score is calculated based on the "contract" that was chosen at the start of the round (where "difference" is the rounded hand difference from 35, calculated above. Note this may be negative, if the opposing team got more points):

Contract Name          | Scoring (+ if contract won, - if lost)
------------------------------------------------
Three                  | difference +/- 10
Two                    | difference +/- 20
One                    | difference +/- 30
Solo Three             | difference +/- 40
Solo Two               | difference +/- 50
Solo One               | difference +/- 60
Beggar*                | 70 (fixed)
Solo without           | 80 (fixed)
Open Beggar*           | 90 (fixed)
Colour Valat Without** | 125 (fixed), no bonuses
Valat Without**        | 500 (fixed), no bonuses


With the exception of those marked, all contracts are "won" if the difference is 36 or higher; otherwise it was "lost".

* - to win the points, you must win no tricks (and therefore no cards)

** - to win the points, you must win ALL the tricks (and therefore all the cards). In this case, no other scoring bonuses are applied.

Bonus points are awarded to the declaring team, or subtracted from the declaring team if the opposing team complete the criteria. Bonuses are only awarded on contracts where the difference is taken into account. (i.e. from "Three" to "Solo One" only, in the above table)

Bonus Criteria                                | Bonus Points
-----------------------------------------------------------------------------------
Take škis, XXI and I ("the Trule") in tricks  | 10
Take all 4 kings in tricks                    | 10
Take all the tricks ("Valat")                 | 500, no other scoring is applied


(note that in Tarok, there are some actions that take place during play which give additional bonuses, such as announcing at the start of the game your intention to get a certain bonus; but as those would require more inputs to calculate, I will leave these out of this challenge.)

Some Examples

All 54 cards, any contract -> +500 points

No Cards, called Beggar -> + 70 points

king, king, king, king, škis, XXI, I, queen, queen, queen, queen, knight, knight, knight, knight, jack, jack, 1H, 2H; called "One" -> 30 points for contract + 20 points difference (hand score is 56 which is 21 different from 35, so round to 20) + 10 points kings bonus + 10 points Trule Bonus = 70 points

No cards, called "Solo One" -> -500 (opposing team got Valat bonus)

KS,8S,7S, called "Two" ->failed contract, so -30 (difference), -20 (contract), -10 (opponents got Trule bonus) = -60 points

KH, KD, škis, I, queen, queen, queen, queen, knight, knight, knight, knight, jack, jack, 1H, 2H, 7C,1D,2D,4D; called "Solo Without" = +80 points

KH, KD, škis, I, queen, queen, queen, queen, knight, knight, knight, knight, jack, jack, 1H, X, III,II,2D,KS; called "Three" = +15 difference (49-35, rounded) + 10 contract = +25

In most spreadsheet programs, columns go A, B, C, ... X, Y, Z. After this comes AA, AB, AC ... AX, AY, AZ, BA and so on.

Your task is to convert one of these strings in to a column number. You must support inputs up to the maximum length of your language, to a minimum of 3.

## Test Cases:

A   => 1
B   => 2
Z   => 26
AA  => 27
AC  => 29
AZ  => 52
BA  => 53
FC  => 159
ID  => 238
AAA => 703


Standard loopholes are forbidden.

## Sandbox:

1. Are my test cases correct? They were done of the top of my head, so they may not be accurate.
2. Is this a duplicate? My searching suggests otherwise, but it may not be comprehensive.
3. Are there any other tags I could add?
• As far as I can tell, your test cases are correct. I would specify how long the input can be (e.g. max of two characters) and provide some slightly larger test cases. Also, maybe the arithmetic/math tag? – caird coinheringaahing Sep 29 '19 at 13:40
• @cairdcoinheringaahing Edited. – gadzooks02 Sep 29 '19 at 13:56
• I feel as though this may be a dupe of one of the various base-conversion questions. Do you expect there is a better way to solve this than converting the letters to numbers and then interpreting them as a base 26 number? (Even if that is the best approach it won't necessarily mean it is a duplicate, I haven't checked through them yet, but I wanted to make sure you had considered it) – FryAmTheEggman Sep 29 '19 at 17:39
• @FryAmTheEggman I had considered it. In fact, I was going to make some test cases that way, but I realised that a) I would have to convert by subtracting 10 and b) that conversion would most likely be too costly. I mean, how would you actually do that? Interpret as base 36, subtract ten, convert to string, interpret as base 26, convert to base 10? Doesn't seem feasible. – gadzooks02 Sep 29 '19 at 18:03
• I didn't mean using builtins for base conversion, though they may be problematic too, but just literally doing base conversion. – FryAmTheEggman Sep 29 '19 at 18:27
• @FryAmTheEggman Congratulations, you have the first answer! While good, I'm certain 63 bytes can be improved, and would be about standard for a Python answer. – gadzooks02 Sep 29 '19 at 18:38
• Sorry, I think I haven't explained myself well. I was trying to show that base conversion questions might be a duplicate target for this one since this challenge can be solved directly with a base conversion after a very minor transformation. I haven't actually found a question that seems like a good enough target yet, but I wanted you to be aware of it (and perhaps look yourself :) ). – FryAmTheEggman Sep 29 '19 at 19:18
• I think I found a duplicate, though it has some annoying extra bits of copying over the row number. – xnor Sep 29 '19 at 23:05
• Duplicate – Jo King Sep 30 '19 at 1:57

DayByte Savings

Input: Any positive integer 1..n; or a year in the future (e.g. 2025)

Output: The date-times (UTC) that Britain will change to/from daylight savings times (i.e. 1am on the last Sunday in March and 2am on the last Sunday in October) between now (according to the machine running the code) and the current date in the year specified in the input. We can assume this rule won't change in the future.

Any valid list of date-time formats is fine for the output (e.g. "28th October 2018 2am" or "28-OCT-18T02:00:00" or "1540692000" [epoch time])

You could store all the data in your program (it counts towards your byte count), or just call a builtin that calculates it - your choice.

You can assume that 2099 (however far ahead that is) is the largest input.

, usual rules and exclusions apply. You won't have to deal with invalid inputs.

Example (assuming today is 23rd September 2019):

2020 or 1 -> 27th Oct 2019 2am; 29th Mar 2020 1am

2099 or 80 -> 27 October 2019 02:00:00
29 March 2020 01:00:00
25 October 2020 02:00:00
28 March 2021 01:00:00
31 October 2021 02:00:00
27 March 2022 01:00:00
30 October 2022 02:00:00
26 March 2023 01:00:00
29 October 2023 02:00:00
31 March 2024 01:00:00
27 October 2024 02:00:00
30 March 2025 01:00:00
26 October 2025 02:00:00
29 March 2026 01:00:00
25 October 2026 02:00:00
28 March 2027 01:00:00
31 October 2027 02:00:00
26 March 2028 01:00:00
29 October 2028 02:00:00
25 March 2029 01:00:00
28 October 2029 02:00:00
31 March 2030 01:00:00
27 October 2030 02:00:00
30 March 2031 01:00:00
26 October 2031 02:00:00
28 March 2032 01:00:00
31 October 2032 02:00:00
27 March 2033 01:00:00
30 October 2033 02:00:00
26 March 2034 01:00:00
29 October 2034 02:00:00
25 March 2035 01:00:00
28 October 2035 02:00:00
30 March 2036 01:00:00
26 October 2036 02:00:00
29 March 2037 01:00:00
25 October 2037 02:00:00
28 March 2038 01:00:00
31 October 2038 02:00:00
27 March 2039 01:00:00
30 October 2039 02:00:00
25 March 2040 01:00:00
28 October 2040 02:00:00
31 March 2041 01:00:00
27 October 2041 02:00:00
30 March 2042 01:00:00
26 October 2042 02:00:00
29 March 2043 01:00:00
25 October 2043 02:00:00
27 March 2044 01:00:00
30 October 2044 02:00:00
26 March 2045 01:00:00
29 October 2045 02:00:00
25 March 2046 01:00:00
28 October 2046 02:00:00
31 March 2047 01:00:00
27 October 2047 02:00:00
29 March 2048 01:00:00
25 October 2048 02:00:00
28 March 2049 01:00:00
31 October 2049 02:00:00
27 March 2050 01:00:00
30 October 2050 02:00:00
26 March 2051 01:00:00
29 October 2051 02:00:00
31 March 2052 01:00:00
27 October 2052 02:00:00
30 March 2053 01:00:00
26 October 2053 02:00:00
29 March 2054 01:00:00
25 October 2054 02:00:00
28 March 2055 01:00:00
31 October 2055 02:00:00
26 March 2056 01:00:00
29 October 2056 02:00:00
25 March 2057 01:00:00
28 October 2057 02:00:00
31 March 2058 01:00:00
27 October 2058 02:00:00
30 March 2059 01:00:00
26 October 2059 02:00:00
28 March 2060 01:00:00
31 October 2060 02:00:00
27 March 2061 01:00:00
30 October 2061 02:00:00
26 March 2062 01:00:00
29 October 2062 02:00:00
25 March 2063 01:00:00
28 October 2063 02:00:00
30 March 2064 01:00:00
26 October 2064 02:00:00
29 March 2065 01:00:00
25 October 2065 02:00:00
28 March 2066 01:00:00
31 October 2066 02:00:00
27 March 2067 01:00:00
30 October 2067 02:00:00
25 March 2068 01:00:00
28 October 2068 02:00:00
31 March 2069 01:00:00
27 October 2069 02:00:00
30 March 2070 01:00:00
26 October 2070 02:00:00
29 March 2071 01:00:00
25 October 2071 02:00:00
27 March 2072 01:00:00
30 October 2072 02:00:00
26 March 2073 01:00:00
29 October 2073 02:00:00
25 March 2074 01:00:00
28 October 2074 02:00:00
31 March 2075 01:00:00
27 October 2075 02:00:00
29 March 2076 01:00:00
25 October 2076 02:00:00
28 March 2077 01:00:00
31 October 2077 02:00:00
27 March 2078 01:00:00
30 October 2078 02:00:00
26 March 2079 01:00:00
29 October 2079 02:00:00
31 March 2080 01:00:00
27 October 2080 02:00:00
30 March 2081 01:00:00
26 October 2081 02:00:00
29 March 2082 01:00:00
25 October 2082 02:00:00
28 March 2083 01:00:00
31 October 2083 02:00:00
26 March 2084 01:00:00
29 October 2084 02:00:00
25 March 2085 01:00:00
28 October 2085 02:00:00
31 March 2086 01:00:00
27 October 2086 02:00:00
30 March 2087 01:00:00
26 October 2087 02:00:00
28 March 2088 01:00:00
31 October 2088 02:00:00
27 March 2089 01:00:00
30 October 2089 02:00:00
26 March 2090 01:00:00
29 October 2090 02:00:00
25 March 2091 01:00:00
28 October 2091 02:00:00
30 March 2092 01:00:00
26 October 2092 02:00:00
29 March 2093 01:00:00
25 October 2093 02:00:00
28 March 2094 01:00:00
31 October 2094 02:00:00
27 March 2095 01:00:00
30 October 2095 02:00:00
25 March 2096 01:00:00
28 October 2096 02:00:00
31 March 2097 01:00:00
27 October 2097 02:00:00
30 March 2098 01:00:00
26 October 2098 02:00:00
29 March 2099 01:00:00

• p.s. how do people add formatted tags to answers? – simonalexander2005 Jun 13 '18 at 15:17
• [tag:<name>], e.g. [tag:code-golf] (in comments, it looks like code-golf) – wastl Jun 13 '18 at 17:56
• You can click at the "edited..." link and click "source" to view markdown source. – user202729 Jun 14 '18 at 11:29
• Should the output be accurate to the date the challenge is posted, the date a solution is posted or the date that solution is run? Or, to put it another way, if I post a solution now it should, obviously, include 27/10/19 in the output but, if that solution is run after that date, should it still be included? – Shaggy Sep 27 '19 at 22:25
• My thinking is, the date the challenge is run (i.e. whatever date is set on the machine the code is run on) – simonalexander2005 Sep 30 '19 at 8:01
• Would this challenge be better if it was just "print the next time after "today" on your local system"? or "print the next time after the input date"? – simonalexander2005 Oct 4 '19 at 14:50

# Golf a new OEIS sequence.

This is a challenge. The goal of this challenge is to create an integer sequence that is not in the OEIS using the fewest possible number of bytes.

Your program can either output an infinite list, or it can be a function from the natural numbers to the integers, which when evaluated on 1, 2, 3, 4,... gives a sequence that is not in the OEIS.

### Restrictions

Without any restrictions, this is a very easy challenge, we can simply write a program that prints out the constant sequence consisting of 33, for example.

In order to avoid accepting "easy" sequences like this, your proposed sequence cannot be a finite linear combination or entrywise product of existing sequences or any rows or columns of existing tables in the OEIS.1

Also, I want to avoid submissions that take an otherwise disallowed sequence and prepend some list (e.g. 3,1,1,1,1,1,1,1,1,1,1). Thus the above rule must stand even after ignoring the first N terms of the sequence.2

## Challenge

Post your source code, the first few terms of the sequence, and an explanation of what your source code is doing.

It's okay if your submission is not very mathematically interesting, but I'm hoping that one or two will be.

(Lastly, if your sequence is disqualified by someone writing is as linear combinations of existing sequences, feel free to modify/fix it, but please don't delete it.)

1 This rule disallows all polynomials in n, for example, since these can be written as finite linear combinations of columns in A009999 read as a square array.

2 This rule also disallows all finite-length sequences.

# Meta

Note: I don't know if this challenge is totally silly, or if it has obvious loopholes, or if closing loopholes results in a challenge that is too difficult or arbitrary.

• Tags: ,
• Is this a duplicate?
• Any other restrictions? Any loosening of current restrictions?
• I like the idea, but checking if an answer is valid seems really hard. For example, take n mod 13. It's not in OEIS (single-digit moduli are). But, there may well be 13 period-13 sequences in OEIS that are linearly independent, which would disqualify it. Maybe this could be a cops-and-robber style challenge where robbers try to invalidate answers, but the robber's task doesn't seem than fun. – xnor Oct 5 '19 at 18:31
• What's to stop people from using the output of a seeded PRNG? It would be trivial to find a sequence from a seeded PRNG that doesn't exist on OEIS. The restriction of no linear combinations or entrywise products makes it more difficult to validate, but it is almost certainly still possible. – Mego Oct 5 '19 at 18:38
• @Mego, exactly the sort of feedback I was hoping for. I don't know how to elegantly work around that sort of answer—especially since a PRNG from a library wouldn't be in the spirit of the question, but a PRNG written by the user would be a great answer. I think I'll avoid submitting this question. – Peter Kagey Oct 5 '19 at 18:59
• In addition to what has been said, ideas like linear combinations etc. start to break down when the sequences end. All (or at least most) OEIS sequences only have a finite number of terms present, some only even have a finite number of terms that can be calculated with modern computing power. So how do we deal with the finiteness of the sequences? – Wheat Wizard Oct 7 '19 at 4:12
• I don't know whether the issues raised in earlier comments can be fixed, but if they can then there's another which can and should be: OEIS isn't static. If someone comes up with an interesting answer, it may well be submitted to OEIS. There are various ways to solve this problem: the easiest to verify would be to say that OEIS sequences beyond Axxxxxx can be ignored, where the sequence chosen is e.g. the highest numbered one with no assigned but unpublished gaps below it. – Peter Taylor Oct 7 '19 at 10:54

# Draw a CE mark graphical-output

Your input is the scaling factor n. You must output an image of width 82n and height 48n (if you are generating a vector image, it should have that as its default size). The image will be either transparent or white, with the following regions in black:

• The segment of a ring centred at 24n,24n of outer radius 20n and inner radius 14n that is left of the vertical line at 26n.
• A copy of that segment displaced 34n to the right. The original rings would therefore exactly overlap if they were not segments.
• A rectangle with upper left corner at 44n,21n and lower right corner at 56n,27n.

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

• It's better to specify exactly what constitutes a valid output, rather than just saying "you can make up your own." That way we know what golfing tricks are permitted and what aren't. – Esolanging Fruit Jun 11 '19 at 4:49
• @EsolangingFruit Okay. Since it is code-golf, not popularity contest, that would be better. I'll fix that. – LegenDUST Jun 11 '19 at 8:06
• Bonuses/penalties in code-golf is not okay – MilkyWay90 Jun 11 '19 at 14:59
• @MilkyWay90 Thank you for your advise. – LegenDUST Jun 12 '19 at 10:18
• Can this be more self-contained? It seems that the majority of the question is hidden behind links to other sites. – Peter Taylor Jun 12 '19 at 10:52
• @PeterTaylor I wanted to, but if I contain Korean character ascii arts in article, it gets so long. So I separated it. I though too long question is not good. If long question is okay, then I'll change it. – LegenDUST Jun 12 '19 at 11:09
• @LegenDUST You could put all input-output in the same code-block, then a scrollbar is added automatically and the challenge is still self-contained. Then again, in the link you provided I only see ASCII arts for single or combinations of 2 Korean characters, whereas the examples have 3 Korean characters combined, so if all triplet-Korean characters are added as ASCII art it's quite a big list to scroll through.. – Kevin Cruijssen Jun 12 '19 at 12:17
• @KevinCruijssen Thanks for tip! – LegenDUST Jun 12 '19 at 12:19
• Seconding the recommendation against bonuses, I would make proper indentation required. – lirtosiast Jun 16 '19 at 8:03
• @lirtosiast I'll think about it. Thanks. – LegenDUST Jun 17 '19 at 8:03