# 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 requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

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!

# IATA Airport Codes code-golfdecision-problemstringkolmogorov-complexitycompression

Out of 17576 alphabetical triplets, to this day, 9144 are used as IATA airport codes.

Given a 3-letter string, tell whether it appears in the list.

• The input string is mixed-case by default, but you can restrict it to non-mixed-case or lower-case or upper-case

• To output the affirmative/negative outcome you should use:

• truthy/falsy according to your language's convention (swapping is allowed), or
• one consistent value as either affirmative or negative, and any other value as the other
• This is

The list was scraped from iata.org on 2021-08-07

## Meta

• Is there something that needs to be specified/clarified?
• What is uniform case? Add the kolmogorov-complexity tag since there's a limited input domain? GitHub Gist is an alternative that's well-trusted by this community, I'd say Aug 8, 2021 at 17:05
• @pxeger I want to say a string where all the letters are uppercase or lowercase, contrary to mixed-case Aug 8, 2021 at 17:07
• @pxeger maybe non-mixed-case would be more direct? Aug 8, 2021 at 17:25

# Radiation hardening up to order $$\n\$$

We'll call a program radiation-hardened of order $$\n\$$ if the output remains unchanged when any $$\k\$$ characters are removed from the program, for all $$\1 \le k \le n\$$. For example, a radiation hardened program of order $$\2\$$ would produce the same output when run as when run with any single character removed, or with any pair of characters removed.

As an example, consider the program abcde which outputs 123 in some language. This would be radiation-hardened of order $$\2\$$ if:

• All of bcde, acde, abde, abce and abcd output 123, and
• All of abc, abd, abe, acd, ace, ade, bcd, bce, bde and cde output 123

If any of the second bullet point didn't output 123 (but all of the first still did), this would only be of order $$\1\$$.

Your task is to write a radiation hardened program of order $$\n \ge 2\$$ that outputs Greetings, Earth! exactly, with an optional trailing newline.

Your score is equal to $$\n\$$, with a higher score winning, with code golf being the tie breaker.

# Meta

• If you find a language that outputs something no matter the program's contents, then you can get infinite score. I'd suggest requiring some specific output. Also infinite score is likely possible in a whole host of other cases so maybe also make the score the ratio of k to code length? Aug 6, 2021 at 16:54
• @pxeger The point about output is a good one, I'll need to think about that. I doubt that an infinitely large score is possible (assuming I add in a specific output), as it'd require a language where either one character outputs the required string exactly once no matter how often it is repeated, or that every program in that language is equivalent to a one byte program, and that all one byte programs are the same that output the specific string Aug 6, 2021 at 17:01
• I would add a tie breaker, since answers beyond n=1 are brutally difficult, so at least you can improve your score without having to jump up to n=3.
– Wheat Wizard Mod
Aug 6, 2021 at 18:08
• Also source-layout is a good tag. (And it's not just that I am working towards that tag badge or something)
– Wheat Wizard Mod
Aug 6, 2021 at 18:13
• DeadPig, order ∞. Aug 7, 2021 at 2:16
• I believe Backhand can make an infinite score. Aug 11, 2021 at 23:37

# Sum of 3 Vectors

## Question

Given 3 vectors a, b, c

Find integer (n, m, r) where a*n+b*m+c*r = 0 and n,m,r are all not equal to 0.

your answer group (n, m, r) must be the closest valid group to 0, calculate by adding abs value together: |n|+|m|+|r|

You can assume that 3 vectors do not parallel

work in progress

## Rules

• no Standard loopholes
• any I/O case allowed, as long as it's clear and mostly understandable.

## Score

• Lowest byte count per language wins!

## Meta

any extra tag?

suggestions?

Rename question?

• this looks like a 3d linear equation solving problem. Aug 19, 2021 at 4:02
• Are the vectors 2-dimensional with integer components? Aug 27, 2021 at 14:53
• @Nitrodon those are 2D vectors currently.
– okie
Sep 1, 2021 at 1:33

# Distances between keys on a QWERTY keyboard

• fro kolmogorov i suggest keeping everything in the same unit. Aug 19, 2021 at 3:58
• All jokes aside, this is a well specified challenge. Aug 19, 2021 at 14:05
• Why radiation-hardening? This is the opposite, isn't it? Aug 21, 2021 at 14:21

# Unfudge my terminal!

## Intro

Today I fiddled around with termios for a program. The only thing I managed to do so far is fundging my terminal... can you help me out?

## Challenge

Given a terminal input that contains fudged special chars, output the string that should be displayed if the terminal worked correctly. Here's a list of the broken special chars:

^B -> Backspace
^J -> (Fwd-) Delete
^D -> Cursor left
^C -> Cursor right
^F -> End
^H -> Start


## How the special characters work

• Backspace deletes the character behind the cursor and moves it one step back. Has no effect on the start of the string.
• Delete deletes the character in front of the cursor. Has no effect on the end of the string.
• Discard deletes the string typed up to this point.
• Cursor left/right moves the cursor to the left/right by one. Has no effect on the end/start of the string.
• End/Start move the cursor to the end/start of the string.

Undefined special characters are to be removed.

## Input

• Any represetation of a string/list of characters
• Single lines only
• The special characters may be either all capitalized or all not capitalized
• The input will not contain a sequence that will result in a ^ in the output, nor will it contain a single ^ at the end.

## Output

• The unfudged input.
• No leading/trailing whitespace that isn't part of the string.

## Examples

abcd^B^B^B --> a

abcd^We^Af^Lgh --> efgh

gof^D^D^D^Dcode^C^C^Cl --> code golf

ocde gol^H^J^Jco^Ff --> code golf

edgecase^H^D^B^J^F^C^J^B --> dgecas


# Rules

• This is , shortest answer wins
• Standard loopholes are not allowed
• A submissiom may be a program/function/link/lambda/chain/etc.

Tags:

## Sandbox things

• Is anything unclear?
• Should any special char be added or removed?
• Is there an edge case not covered by the examples?
• Are the rules and I/O restrictions fine or should I change anything?

# Display a number in Toki Pona

• Welcome to Code Golf and nice first question! Thank you for using the Sandbox first :) I've done some minor edits to add capitalisation and formatting. Tags wise, [integer-partitions] and [natural-language] both apply. This is a similar challenge, but that uses US coins Aug 12, 2021 at 22:49

# Unicode Calendar Generator

## Rules

Your program will receive a valid date in the format relevant to your language (date object or three int for year, month, day or whatever) and should returns a fancy unicode calendar as such (note that the title is right/left aligned):

Given Y-M-D as 2021-10-13
Then

╔════════════════════╗
║ October ░░░░░ 2021 ║
╟──┬──┬──┬──┬──┬──┬──╢
║░░│░░│░░│░░│░░│01│02║
╟──┼──┼──┼──┼──┼──┼──╢
║03│04│05│06│07│08│09║
╟──┼──┼──╔══╗──┼──┼──╢
║10│11│12║13║14│15│16║
╟──┼──┼──╚══╝──┼──┼──╢
║17│18│19│20│21│22│23║
╟──┼──┼──┼──┼──┼──┼──╢
║24│25│26│27│28│29│30║
╟──┼──┼──┼──┼──┼──┼──╢
║31│░░│░░│░░│░░│░░│░░║
╚══╧══╧══╧══╧══╧══╧══╝


Given Y-M-D as 2021-11-13
Then

╔════════════════════╗
║ November ░░░░ 2021 ║
╟──┬──┬──┬──┬──┬──┬──╢
║░░│01│02│03│04│05│06║
╟──┼──┼──┼──┼──┼──╔══╗
║07│08│09│10│11│12║13║
╟──┼──┼──┼──┼──┼──╚══╝
║14│15│16│17│18│19│20║
╟──┼──┼──┼──┼──┼──┼──╢
║21│22│23│24│25│26│27║
╟──┼──┼──┼──┼──┼──┼──╢
║28│29│30│░░│░░│░░│░░║
╚══╧══╧══╧══╧══╧══╧══╝


Given Y-M-D as 2021-06-15
Then

╔════════════════════╗
║ June ░░░░░░░░ 2021 ║
╟──┬──┬──┬──┬──┬──┬──╢
║░░│░░│01│02│03│04│05║
╟──┼──┼──┼──┼──┼──┼──╢
║06│07│08│09│10│11│12║
╟──┼──╔══╗──┼──┼──┼──╢
║13│14║15║16│17│18│19║
╟──┼──╚══╝──┼──┼──┼──╢
║20│21│22│23│24│25│26║
╟──┼──┼──┼──┼──┼──┼──╢
║27│28│29│30│░░│░░│░░║
╚══╧══╧══╧══╧══╧══╧══╝


This is , so you the shortest bytes of each language will be the winner.

Inspired by qwerty.dev

• What does it need the day for? If you want to include the selection of the given day, perhaps you should include that in the challenge post in an example, to keep it self contained. also is the 00 intentional? Oct 13, 2021 at 20:29
• @thejonymyster fixed. And the 00 was a mistake. Thank you :) Oct 13, 2021 at 20:32
• Are the month/year always to be left/right aligned, like  May ░░░░░░░░░ 2021 ? What input formats (string, 3 integers, list, built-in date object, ...) are allowed? Oct 13, 2021 at 22:04
• month year should be left/right aligned. For the inputs formats, what would be the most popular? Oct 14, 2021 at 6:37
• I'd recommend allowing any sensible input format (because the challenge is more about producing the calendar than parsing dates). You should explain the alignment rules in the post. Maybe it would be enough to swap one of the examples for a month with a shorter name, but probably better to be explicit. Oct 15, 2021 at 1:03
• What date range is required to support? 1970~2038? Or maybe larger?
– tsh
Oct 18, 2021 at 3:54
• @Dingus lets use any sensible input format Oct 18, 2021 at 12:31
• @tsh I dont have a strong opinion about that. Oct 18, 2021 at 12:32
• tsh's question needs a definite answer because the date range could influence the input method and/or implementation. You should also mention that the Gregorian calendar is used. Oct 21, 2021 at 23:57
• Name suggestion: Wheatian group :) Oct 15, 2021 at 6:01
• For challenges which require Unicode, it's generally a good idea to let people count those characters as a single byte each. Aside from that, looks good! Oct 24, 2021 at 23:04
• @emanresuA Thank you very much for your feedback! Is there an easy way to make TIO count like that? Or perhaps as a workaround allow defining the special characters as constants in the header? Oct 25, 2021 at 0:17
• You just generally get people to count, I think. Or you could allow people to use any set of distinct characters instead of the box-drawing characters, or allow both. Oct 25, 2021 at 0:28

# Find the k-th order summary of a number

Posted

• Nov 4, 2021 at 2:15
• @Razetime, yes they are quite similar, but the look and say operation is a bit different from the summary operation; for example look_and_say(112211) = 21 22 21 whereas summary(112211) = 41 22 Nov 4, 2021 at 5:51

Consider all arrays of $$\\ell\$$ non-negative integers in the range $$\0,\dots,m\$$. Consider all such arrays whose sum is exactly $$\s\$$. We can list those in lexicographic order and assign an integer to each one which is simply its rank in the list.

For example, take $$\\ell=7, s=5, m=4\$$, the list could look like:

(0, 0, 0, 0, 0, 1, 4)  rank 1
(0, 0, 0, 0, 0, 2, 3)  rank 2
(0, 0, 0, 0, 0, 3, 2)  rank 3
(0, 0, 0, 0, 0, 4, 1)  rank 4
(0, 0, 0, 0, 1, 0, 4)  rank 5
(0, 0, 0, 0, 1, 1, 3)  rank 6
(0, 0, 0, 0, 1, 2, 2)  rank 7
(0, 0, 0, 0, 1, 3, 1)  rank 8
(0, 0, 0, 0, 1, 4, 0)  rank 9
[...]
(3, 2, 0, 0, 0, 0, 0) rank 449
(4, 0, 0, 0, 0, 0, 1) rank 450
(4, 0, 0, 0, 0, 1, 0) rank 451
(4, 0, 0, 0, 1, 0, 0) rank 452
(4, 0, 0, 1, 0, 0, 0) rank 453
(4, 0, 1, 0, 0, 0, 0) rank 454
(4, 1, 0, 0, 0, 0, 0) rank 455


This challenge requires you to produce two pieces of code/functions.

• Given a rank, compute the corresponding array directly. Call this function unrank()
• Given an array, compute its rank. Call this function rank()

Your code should run in polynomial time. That is it shouldn't be brute force and more specifically it should take $$\O(\ell^a s^b m^c)\$$ time for fixed non-negative integers $$\a, b, c\$$. Any non-brute force method is likely to satisfy this requirement.

# Examples

unrank((7, 5, 4), 9) = (0, 0, 0, 0, 1, 4, 0)
rank((7, 5, 4), (4, 0, 0, 0, 0, 1, 0)) = 451
unrank((14,10, 8), 100000)  = (0, 0, 0, 1, 0, 0, 1, 3, 1, 2, 0, 0, 2, 0)
rank((14, 10, 8), (2, 0, 1, 1, 2, 0, 0, 0, 2, 1, 1, 0, 0, 0)) = 1000000


# Convert codepoint to UTF-9

• For clarity, I'd start octal constants with 0o. Also, an explanation of how UTF-9 works should probably be included here. Jun 19, 2021 at 1:39
• Could you include the basic algorithm to encode UTF-9 in your post instead of require an external resource? So this question can be made self contained.
– tsh
Oct 12, 2021 at 6:27
• @tsh Should I do with actual program source or in pseudo code?
– user100411
Oct 12, 2021 at 12:26
• first challenge that made me LOL Oct 18, 2021 at 3:12

# Lexigolf: Is this number a prime?

Write a program that, given a strictly positive integer n as input, determines whether n is prime and prints a truthy or falsy value accordingly.

For the purpose of this challenge, an integer is prime if it has exactly two strictly positive divisors. Note that this excludes 1, who is its only strictly positive divisor.

## Goal

Competing programs are compared lexicographically. The program that is lexicographically less than all other programs is the winner.

If a program begins with a prefix that may be removed without altering the program's behavior, it is disqualified. This is to discourage adding meaningless whitespace or comments to change the first character (consider  int main(){} or /**/int main(){}).

For example,

abc < def
aa < ba
aaaaaaa < aba
aa < aaaa
Zzz < aaa
012 < AAA


## Meta

This is essentially an earlier classic code-golf challenge, Is this number a prime?, except with a different goal, which I propose is called lexigolf.

I'm not sure whether lexicographic order should entirely be based on UTF-8 (for languages that can be expressed in bytes). It seems to massively favor weird esolangs that rely on characters with small ASCII codes. There is also a loophole in prefixing the program with noop characters, e.g. placing a arbitrary amount of whitespace before a C program: int main() {} >  int main(int, char**) {} >  int main(int argc, char **argv) {} (fixed? probably still a loophole somewhere)

• For the scoring favoring weird esolangs that rely on certain characters, the scoring here is typically a per-language comptition, so Java and GolfScript wouldn't be competing. The null byte prefixing is a bit of an issue, so you might want to require that you can't take any number of characters off the left side of the program without making it stop working (so prefixing a null byte wouldn't be allowed unless it actually affected how the program ran). Also, primality testing might not be the best challenge for this idea, since many golfing languages have it as one or two byte built-ins. Nov 16, 2021 at 17:42
• @Fmbalbuena The < are to indicate which is lexicographically smaller, not which is winning Nov 16, 2021 at 17:43
• You might want to allow language with SBCSs (custom code pages, instead of UTF-8 or ASCII) like Jelly to use those for the lexicographic order instead, since that would make it more interesting to try to find the lexicographically smallest program in those languages. Nov 16, 2021 at 17:46
• @RedwolfPrograms, I've updated the post Nov 16, 2021 at 17:51
• In some languages (for example, Befunge) you could probably detect whether the leading spaces were removed...
– Maya
Nov 16, 2021 at 22:19
• Removing only prefixes isn't enough: I could add a test at the end to check whether that prefix is present. Maybe you should require the code to be irreducible instead? Nov 16, 2021 at 22:55
• It seems like this challenge is entirely about finding the lexicographically smallest prefix that can be extended arbitrarily far in a way that removing a prefix of it will be invalid syntax or fail. The prime-finding task doesn't really matter -- any code is equivalent if put after arbitrarily much prefix padding.
– xnor
Nov 17, 2021 at 2:12

# Will one-cell brainfuck halt?

• Do you really want use - for increment while + for decrement? Or maybe a typo?
– tsh
Nov 10, 2021 at 10:17
• @tsh Oops. Fixed. Nov 14, 2021 at 1:01

# Construct a Heptagon avoiding compass use

A while back I asked you to construct a pentagon avoiding compass use. Now flawr suggested:

Next time you should ask people to draw a heptagon, which would be slightly more challenging:)

This is of course a joke, because if you didn't already know it is not possible to construct a Heptagon using a ruler and compass ...

... in finite steps.

In this challenge answers will construct equilateral polygon of 7 sides, using a ruler and a compass.

We will begin with some standard ruler and compass operations:

• Draw a line that passes through two non-identical points. (Ruler)

• Draw a circle centered at one point such that another point lies on the circle. (Compass)

• Place a point at an intersection of two non-identical objects (a circle and a line, a line and a line or a circle and a circle)

Normally a construction must be finished after some finite number of operations. However we will allow you to take any ordinal number of steps. Meaning you can perform an infinite number of steps and then perform more.

To go with this you are given one more operation:

• Choose converging sequence of already drawn points and place a point at their limit. (limiting)

This operation is only meaningfully useful if you have already performed an infinite number of steps, but is crucial to constructing a heptagon.

## Summary

In this challenge you will start with two arbitrarily placed (but non-equal) points on an infinite plane. You must then describe some sequence of steps to arrive at a regular Heptagon. Here a regular heptagon simply being 7 points which form the vertices of a heptagon, they do not need to be in any particular position relative to the starting points.

Your score will be the number of compass operations used in the entire proof with lower being better. Since many answers may end up using an infinite number of compass steps we will break ties by the strict supremum of ordinals representing steps you have used a compass.

For example if two answers both use an infinite number of compass operations, their primary score is $$\\infty\$$. If one of them uses all of their compasses at finite numbered their secondary score is $$\\omega\$$, which would beat the other answer if it uses the compass at any time $$\\omega\$$ and after.

• The theoretical optimal score is likely 2. It is known that a circle and its center (with a couple other known points, because we can't create arbitrary point) plus straightedge operations equals general compass + straightedge in terms of constructibility. It must be possible to construct a sequence of constructible points that converges to a heptagon-related point. The actual challenge is coming up with a constructive solution. Dec 6, 2021 at 2:01

Posted to main

# How long will my microwave run for?

• I'd recommend getting rid of the bonuses, they're pretty strongly discouraged Dec 3, 2021 at 17:32
• @RedwolfPrograms I do like the bonus challenge, however I'm not sure what to do with it. Dec 3, 2021 at 17:33
• You could just turn the bonus challenge into a separate question Dec 3, 2021 at 17:41
• @pxeger I'll make it a seperate question and post it later. Dec 3, 2021 at 17:49

Calculate the result of some math expressions using the following constraints:

• Numbers will be between 0 and 9
• Operators are + - / *
• Expressions will always have the format Number operator number operator number...
• Parenthesis have the highest precedence
• The order of reading goes Left Left Right Right Left Left Right Right etc.
• Division by 0 never happen

For example:

1+3-4*9
1       = 1   ; Start calculating using the left most number
+    9 = 10  ; Add 9
3  *  = 30  ; Multiply by 3
-4   = 26  ; subtract 4


Using this method 1+3-4*9 = 26

## Input / Output

Input:

• string OR list of characters OR list of numbers and characters
• Can be reversed if specified in the answer

Output: a number

## Precision

Floating point errors are OK.

## More examples and test cases:

2*9 = 18

1+3-4*9
1       = 1
+    9 = 10
3  *  = 30
-4   = 26

8-5*0/9+8/2+3*4
8               = 8
-            4 = 4
5          *  = 20
*        3   = 60
0      +    = 60
/    2     = 30
9  /      = 3.33333...
+8       = 11.33333...

Knowing that 1+3-4*9 is 26

8-5*0/9+8/2+(1+3-4*9)*4
8                       = 8
-                    4 = 4
5                  *  = 20
*        (1+3-4*9)   = 520
0      +            = 520
/    2             = 260
9  /              = 28.8888...
+8               = 36.8888...

8-2+4*6/2
8         = 8
-      2 = 6
2    /  = 3
+  6   = 9
4*    = 36

(1+2*7)*6+3+(2*2+3)

First group:
1+2*7
1
+  7 = 8
2*  = 16

Second group:
2*2+3
2
*  3 = 6
2+  = 8

(1+2*7)*6+3+(2*2+3)
(1+2*7)             = 16
*    (2*2+3) = 128
6  +        = 134
+3         = 137

1+(6+(6+1*2)/2)/4
Nested group:
6+1*2
6     = 6
+  2 = 8
1*  = 8

Group:
6+(6+1*2)/2
6           = 6
+        2 = 8
(6+1*2)/  = 1

Full expression:
1+(6+(6+1*2)/2)/4
1                 = 1
+              4 = 5
(6+(6+1*2)/2)/  = 5


# Scoring

This is , so the answer with the least amount of bytes wins.

• "Division by 0 should not return a valid number." What do you mean by "a valid number"? I'd suggest just saying answers can assume division by zero will never occur Dec 17, 2021 at 3:05
• Thanks for your feedback @pxeger ! I'm removing errors handling Dec 17, 2021 at 3:20

# Subdivide the Bezier Curve

## Background

A Bezier curve is a type of curve that has a lot of applications in all sorts of places, but most commonly, in computer graphics. It has a very simple algorithm and yet can represent a wide variety of shapes with just one common formula. If you've ever used pen tools in drawing software, you're probably already familiar with the general idea behind Bezier curves.

Given an ordered list of control points, we set some parameter $$\t\$$ in the range $$\[0, 1]\$$. Then, for each $$\t\$$, we draw a line between each consecutive pair of control points and select a point that is $$\t\$$ from the starting point. For example, if we have three control points and $$\t\$$ is $$\\frac13\$$:

The purple point is $$\\frac13\$$ of the way from the red point to the blue point, and the black point is $$\\frac13\$$ of the way from the blue point to the green point. You can change the ratio and move the points around here to try it out.

Now, we have one fewer point than we initially had control points. Let these be the new control points, and do this again with the same $$\t\$$:

(Desmos link). Now, we finally have a single point, so that is the point we obtain for this value of our parameter $$\t\$$. The Bezier curve is obtained from all final points for each $$\0\leq t\leq 1\$$. For more points, we just repeat this for more steps. Here's what a Bezier curve with four control points looks like:

## Challenge

Given a list of control points for a Bezier curve and a positive integer $$\n\$$, subdivide the Bezier curve into $$\n\$$ segments and return the points. More precisely, return the output points for $$\t=0,\frac1n,\frac2n,\cdots,\frac{n-1}n,1\$$.

You may do I/O in any reasonable format; for example, a list of pairs or a pair of x and y coordinates for input, and a pair of numbers for output. Floating point errors are acceptable but your outputs should have an accuracy of at least $$\10^{-3}\$$ relative or absolute, whichever is larger.

There will be at least one point and $$\n\$$ will be a positive integer.

## Example

Given input $$\\{(0,0),(1,3),(4,2),(5,1)\}\$$ and $$\3\$$ subdivisions:

For $$\t=0\$$, we just have $$\(0,0)\$$, and for $$\t=1\$$ we just have $$\(5,1)\$$.

For $$\t=\frac13\$$, we first go $$\\frac13\$$ of the way from each control point to the next to get $$\\{(\frac13,1),(2,\frac83),(\frac{13}3,\frac53)\}\$$. Repeating that once more gives us $$\\{(\frac89,\frac{14}9),(\frac{25}9,\frac73)\}\$$. Finally, if we do it once more, we get the single point $$\(\frac{41}{27},\frac{49}{27})\$$.

For $$\t=\frac23\$$, we first get $$\\{(\frac23,2),(3,\frac73),(\frac{14}3,\frac43)\}\$$, then $$\\{(\frac{20}9,\frac{20}9),(\frac{37}9,\frac53)\}\$$, and finally, $$\(\frac{94}{27},\frac{50}{27})\$$. And just for a sanity check, the points are indeed on the curve:

Note that these points do not evenly subdivide the Bezier curve by arclength. The arclength of a Bezier curve actually cannot be calculated exactly and subdividing like that would have to be done via approximations.

#### Test case generator

Credit to Wezl for the original idea.

• love the interactive parts Dec 18, 2021 at 17:28
• When reading this I didn't expect it to be you having posted it lol Dec 23, 2021 at 7:55

# Demonstrate some easier abstract algebra

From my related challenge, Demonstrate some advanced abstract algebra

Consider a binary operator $$\*\$$ that operates on a set $$\S\$$. For simplicity's sake, we'll assume that $$\*\$$ is closed, meaning that its inputs and outputs are always members of $$\S\$$.

Let's define some basic terms describing the properties of $$\*\$$. We can say that $$\*\$$ can have any of these properties, if they hold for all $$\a,b,c \in S\$$:

• Commutative: $$\a*b = b*a\$$
• Associative: $$\(a*b)*c = a*(b*c)\$$
• Distributive: $$\a*(b+c) = (a*b)+(a*c)\$$, for some binary operator $$\+\$$ on $$\S\$$

We can also define 3 related properties, for a unary operation $$\-\$$ on $$\S\$$:

• Anti-commutative: $$\a*b = -(b*a)\$$
• Anti-associative: $$\(a*b)*c = -(a*(b*c))\$$
• Anti-distributive: $$\a*(b+c) = -((a*b)+(a*c))\$$

Finally, we define 3 more, that only describe $$\*\$$ if the complete statement is true for $$\a,b,c \in S\$$:

• Non-commutative: There exists $$\a, b\$$ such that $$\a*b \ne b*a\$$ and $$\a*b \ne -(b*a)\$$
• Non-associative: There exists $$\a, b, c\$$ such that $$\(a*b)*c \ne a*(b*c)\$$ and $$\(a*b)*c \neq -(a*(b*c))\$$
• Non-distributive: These exists $$\a,b,c\$$ such that $$\a*(b+c) \ne (a*b)+(a*c)\$$ and $$\a*(b+c) \ne -((a*b)+(a*c))\$$

We now have 9 distinct properties a binary operator can have: commutativity, non-commutativity, anti-commutativity, associativity, non-associativity, anti-associativity, distributivity, non-distributivity and anti-distributivity.

This does require two operators ($$\-\$$ and $$\+\$$) to be defined on $$\S\$$ as well. For this challenge we'll use standard integer negation and addition for these two, and will be using $$\S = \mathbb Z\$$.

Obviously, any given binary operator can only meet a maximum of 3 of these 9 properties, as it cannot be e.g. both non-associative and anti-associative.

Let's create a "table" of these properties:

Commutative Associative Distributive
Regular Commutative Associative Distributive
Anti Anti-commutative Anti-associative Anti-distributive
Non Non-Commutative Non-associative Non-distributive

Your task is to write 3 programs (either full programs or functions. You may "mix and match" if you wish).

Each of these 3 programs will:

• take two integers, in any reasonable format and method

• output one integer, in the same format as the input and in any reasonable method

• be non-constant. That is, there exists at least two distinct inputs that have distinct outputs.

• have exactly 3 of the 9 above properties. However, those three properties muse be in different rows and columns in the above table from each other. This means that it can be (for example) commutative, non-associative, anti-distributive; non-commutative, anti-associative, distributive; or anti-commutative, associative, non-distributive. But, it cannot be (for example) commutative, associative, distributive; non-commutative, non-associative, non-distributive; or non-commutative, anti-distributive, anti-associative.

This is ; the combined lengths of all 3 of your programs is your score, and you should aim to minimise this.

Additionally, you should include some form of proof that your programs do indeed have the required properties and do not satisfy the other properties. Answers without these are not considered valid.

Alternatively, a proof of impossibility is a valid answer. If you can demonstrate that there are no such programs that satisfy the criteria listed above, then this proof constitutes a valid answer as well.

# Meta

• There exists no anti-distributive surjection when $S=\mathbb Z$. Maybe there exists one when $S=(\mathbb Z/2\mathbb Z)^k$, but I haven't found one yet. Jun 16, 2021 at 9:12
• I would remove the constraint that the operator be a surjection, and just impose that it be non-constant. If you convince yourself that such an anti-distributive operator exists, you could post the challenge, but I would change it to "write 3-9 programs, such that each property is verified by (at least) one program". That would be an incentive to have programs which verify several properties at once, but make it more manageable. Jun 16, 2021 at 9:18
• Also, there are problems with your "anti-associativity": if b = 1, then (a*b)*c = a*(b*c). Jun 16, 2021 at 10:43
• @RobinRyder If $S=(\mathbb Z / 2\mathbb Z)^k$, aren't anti-distributive operators the same as distributive operators? Jun 16, 2021 at 14:21
• @Nitrodon Yes, of course you are right. Jun 16, 2021 at 15:03

# Code Golf Birthday Cake

     0 2 4 6 8 10
| | | | | |
&***********&
| Code Golf |
| e---------f |
| d___________l |
| o-------------o |
| C_______________G |
###Dennis$Dennis### #####################  # Rules • Trailing or leading newline is allowed • , so shortest code wins! # Meta • Any feedback? • why is it lopsided Dec 21, 2021 at 15:56 • @thejonymyster fixed? Dec 21, 2021 at 15:57 • No, that's more lopsided. You only need one$ between the Dennises, if that helps. Dec 21, 2021 at 16:00
• @thejonymyster fixed? Dec 21, 2021 at 16:18
• Well now the bottom is asymmetric, but also what do the numbers mean? Dec 21, 2021 at 17:16
• @thejonymyster the site is about 9 years old Dec 21, 2021 at 18:27
• Are you sure you want the bottom line have an extra # on left side but no such # on right side?
– tsh
Dec 24, 2021 at 5:30
• @tsh fixed now? Dec 24, 2021 at 11:53
• can you add more candles? Dec 27, 2021 at 16:06

# Domino tilings in an N-dimensional cube code-golfdominoestilingsequencecombinatorics

## Challenge

Imagine an N-dimensional cube which has dimensions 2×2×...×2. Given the value of N (a positive integer), calculate the number of ways it can be divided into 2×1×1×...×1 "hyper-domino" pieces (two unit N-dimensional hypercubes glued together).

Standard rules apply. The shortest code in bytes wins.

## Examples and test cases

For N = 1, the "cube" is a single domino. A single domino can be divided into a single domino in exactly one way, so the answer is 1.

For N = 2, the "cube" is a 2×2 square. It can be divided, or tiled, in two ways:

--  ||
--  ||


For N = 3, the cube is a 2×2×2 cube. It can be divided into four domino-cubes in nine different ways. One way to count it is to see that, if you pick a unit cube, it can be used by three different domino-cubes (one in each direction), and in all cases the rest forms a small staircase-like shape

L1  L2
#   #
##  ##


which can be divided into three pieces in three ways (# denotes a piece in Z-direction)

#   #
--  --

#   #
##  ##

|   |
|#  |#


which gives 3×3 = 9.

The corresponding sequence is A005271.

N    Answer
-----------
1    1
2    2
3    9
4    272
5    589185
6    16332454526976
7    391689748492473664721077609089


# Number of complete rhyme schemes

• @mathcat "The word may always be assumed to be lowercase." Jan 14 at 19:31

# Number of arrangements of half a Rubik's cube

From a corner-on view of a Rubik's cube calculate the number of arrangements of stickers that are out of view.

Your input will provide the state of a Rubik's cube when viewed like the below image:

This input will be an array, in any defined order†, grouping†, and nesting† that you choose, containing the colours‡ of the $$\27\$$stickers (A.K.A. facelets or tiles) on three sides of a 3x3 Rubik's cube that join at one corner, like you can see above.

The input may be assumed to be that of a solvable state where only face turns can return the cube to having six sides with a single colour on each (if it isn't then your code may do anything, short of summoning Cthulhu).

† The input may be a flat list of colour-labels or you may specify that these labels will already be grouped in any way you wish (it may be a ragged, nested list for example), but the content thereof should only consist of the sticker colour-labels.

‡ Since the centres of the cube are actually fixed relative to each other, and hence the hidden centres' colours are known, you may choose to leave any or all of the central stickers out of the expected input (it could be as short as $$\24\$$ sticker colour-labels) while using a labeling that identifes the colours as the top-centre, left-centre, right-centre, and their three opposite colours. For the record, the standard colour theme, as in the image above, has orange opposite red, white opposite yellow, and green opposite blue (hence orange is the hidden centre sticker on the bottom etc.).

You should output the number of possible arrangements of sticker colours of the $$\27\$$ stickers which are not in the input (i.e. those stickers which are out of view). Note that swapping two of those stickers of the same colour is considered to be the same arrangement.

### Sandbox questions

1. Does this need test cases? (I'm not even 100% sure what the output should be if the input looked like a solved cube from that perspective although I may be able to work it out without writing a program it's certainly more than one - e.g. U' L R2 D' M D2 M' D' L' R2 U or  R2 U R2 F2 R2 U2 F2 R2 F2 U R2)

2. Is the spec clear?

• You should probably make it more explicit that the center colors of the opposite faces are known. (Also, I'm fairly sure that a "solved cube" input would have an output of 192, but that's just me doing quick math in my head, so I could be wrong.) Jan 14 at 15:18