Sandbox for Proposed Challenges

Question

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

To post to the sandbox, scroll to the bottom of this page 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, 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
• Comments addressing specific points mentioned in the proposal
• 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".

Answer 1

All sequences as substrings

Answer 2

posted

Answer 3

Make me a k-NN classifier

code-golf machine-learning The "machine-learning" tag will be created

---

The k Nearest Neighbors (k-NN) classifier is a simple machine learning classifier. Although k-NN also works for regression tasks, we will be focusing on classification tasks for this challenge.

The classifier can be customized in a number of different ways. For this challenge, the following can be customized:

• k itself;
• the distance metric; and
• the aggregation function.

Main idea

As you can probably tell by its name, k-NN works using the concept of neighbors. First, we "train" classifiers by giving it (preferably a lot of) training data.

A training data point consists of two parts: its "features" and its target value. For instance, if predicting car brand, features might be maximum speed, size etc, and the target variable would be brand. We can also specify k, a distance metric, and/or an aggregation function, or let the classifier fine-tune these hyperparameters itself. For this challenge, the above hyperparameters will be given directly to the classifier.

When we give the classifier a list of features to be assigned a predicted target value, it takes the k train points closest to the test point, measured by distance metric via features, and runs their target values through its aggregation function to obtain its prediction.

The hyperparameters are explained below:

k

k is the neighbor count. If k is 5, for instance, the classifier will consider 5 neighbors when predicting.

Distance metric

The distance metric measures how far two data points are from each other, measured by their features. A standard distance metric is Euclidean distance, but many others can be used, such as the Manhattan distance.

Aggregation function

Once the classifier has found the k nearest neighbors, it calls its aggregation function using the target values of these neighbors. A standard aggregation function for classification is majority vote, but many others can be used.

Challenge

The following are to be taken as input:

• a list of train data points where each data point consists of:
  • a list of numbers, where the lengths of these lists are the same for all training data points; and
  • a target value;
• k;
• a distance metric which takes two data points' features and outputs a positive number; and
• an aggregation function which takes k data points' target values and outputs a value that is one of the target values contained within the training data (this means that you can't just output some arbitrary number; it must be a target value for at least one of the train data points);

You may also take in the following:

• a list of features of the same length as every list of features within the training data.

Output:

• if an additional list of features was given, the prediction, found using the procedure described above, for that list of features;
• if no such list was given, a function that takes in a list of features as described above and outputs the prediction for that list of features.

Input is flexible so long as it is within reason.

The distance metric and aggregation function are black-box functions.

This challenge is code-golf, so the shortest code, measured in bytes, wins.

Test case

Given in python.

k = 5
distance = lambda a, b: sum((b[i] - a[i]) ** 2 for i in range(5)) # Euclidean distance
aggregation = lambda a, b, c, d, e: max([a, b, c, d, e], key=lambda i: [a, b, c, d, e].count(i)) # output the one with the most occurrences
train = [
 [[1, 2, 3, 4, 5], 0],
 [[2, 3, 4, 5, 6], 1],
 [[3, 4, 5, 6, 7], 1],
 [[1, 4, 5, 6, 7], 0],
 [[1, 8, 9, 9, 9], 0],
 [[9, 0, 0, 0, 0], 1],
 [[2, 3, 4, 1, 1], 1]
]

classifier_func = knn_classifier(train, k, distance, aggregation) # function output

print(classifier_func([1, 0, 0, 0, 0])) # outputs 1

---

Do we have any feedback? Duplicate? Clarification needed? Wrong terminology? Wrong test case?

Answer 4

Simulating Bombs

Answer 5

Golf the prime numbers in Shue

Answer 6

Golf the colors of a rug

code-golf kolmogorov-complexity

Background

The challenge is based on this rug:

Its colors seem very regular, but the pattern isn't obvious. However, it becomes visible when we move vertical stripes of the rug up and down:

All stripes are colored in the same way, but each stripe is offset by some height, except for a few irregularities. Also, the stripes have different widths.

First, we need to list all colors:

0: blue-ish white
1: lighter blue
2: darker blue
3: darkest blue
4: green-ish white (the color between the middle orange rows)
5: middle green
6: dark green
7: orange
8: light red
9: dark red

Now, we can lay a grid of cells of equal color over this image. I found that using a cell size of 73.5x129 pixels seems to be a good compromise between precision and compactness. This results in a 42x32 grid, which looks like this when overlayed over the rug:

Correcting for some perspective errors, we now can approximate the colors of this rug like this:

The color scheme shared by all stripes consists, from top to bottom, of these 42 colors: [3, 3, 2, 3, 3, 2, 2, 0, 2, 2, 1, 1, 3, 1, 1, 5, 5, 6, 5, 5, 6, 6, 7, 6, 6, 7, 7, 4, 7, 7, 8, 8, 7, 8, 8, 9, 9, 8, 9, 9, 9, 9]. (This already contains the information that some rows have different heights, by having multiple entries of the same color in a row.)

There are 18 stripes with widthes [2, 3, 3, 3, 1, 1, 4, 2, 1, 6, 1, 1, 2, 2, 2, 3, 2, 3]. Their vertical offsets are [3, 4, 3, 4, 2, 0, 2, 4, 7, 9, 10, 9, 5, 3, 5, 3, 4, 5], which means the first stripe starts at the color at index 3 in the common scheme, the second stripe at index 4 and so on. Starting from the respective start index, the next 32 colors are used; remaining colors (if any) are unused.

There are some irregularities in the rug. I didn't find a better way of expressing them except for listing their X and Y coordinates in the grid together with their colors:

X     [8,  9, 10, 19, 19, 12,  0,  1,  2,  3,  4,  2,  3,  4,  2,  3,  4,  5, 13, 14, 15, 16, 17, 18, 34]
Y     [18, 18, 18, 23, 24, 27, 31, 31, 29, 29, 29, 30, 30, 30, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31, 31]
Color [5,  5,  5,  0,  0,  8,  9,  9,  9,  9,  9,  9,  9,  9,  8,  8,  8,  9,  9,  9,  9,  9,  8,  8,  9]

They are included in this challenge to better reflect the rug and to increase difficulty a bit.

Challenge

Output this 42x32 grid of numbers from 0-9, each corresponding to the color of one cell of the rug:

333333333332322223302222221222332233333222
332223332223333332221111111122332233322222
222222222223233332221111113100220022222000
220002220002322220013333331322222222200222
002220002222322222211111111122002200022222
222222222220200002231111115111221122222111
221112221112222221115555555511221122211111
111111111112022221115555556533113311111333
113331113331211113356666665611111111133111
331113331111211111155555555511331133311111
111111111113133331165555556555115511111555
115551115551111115556666666655115511155555
555555555551311115556666667666556655555666
556665556665155556667777776755555555566555
665556665555155555566666666655665566655555
555555555556566665576666667666556655555666
556665556665555556667777777766556655566666
666666666665655556667777774777667766666777
667776665556566667774444447466666666677666
776667776666566666677777777766776677766666
666666666667677776647777778777667766666777
667776667776666667778888888877667766677777
777777777776766667778888887844774477777444
774447774447677774407777778777777777744777
447774447777677777708888888877447744477777
777777777774744447778888889888778877777888
778887778887777778889999999988778877788888
888888888887877778889999998977887788888777
887778887778788887798888889888888888877888
779997778888788888899999999988778877788888
889998888887877778889999999999889988888999
998889889998899998899999999999889998899999

Rules

• The program should not take input.
• Formatting doesn't matter.
• This is code-golf, so shortest answer (in bytes) wins.

Sandbox Questions

• Why doesn't the box with irregularities align?
• Would the challenge be more fun with or without having to include irregularities? I guess allowing both variants is not a good idea because solutions aren't comparable anymore.

Answer 7

Smallest maximal rectangle in a skyline

Answer 8

Chess Board Analyzer

Answer 9

Wiggle the tower

Answer 10

Disassemble tables

Posted here.

Answer 11

Lexicographical sum

Answer 12

Random Point from a 2D Donut Distribution

Posted here.

Answer 13

Social distance the graph

Given a connected, undirected graph like so, where various nodes are connected to each other:

Select as many nodes as possible such that no two selected nodes are adjacent.

^ made by clumsy by-hand greedy algorithm, tell me if I stuffed this up. The red ones are the selected ones.

You should output the maximal number of points for which this is possible.

You can take the graph in any reasonable form - as an adjacency matrix, a list of edges, a list of nodes, etc.

The graph will have at least one edge, and no more than one edge connecting two points.

Testcases

-> 2
-> 3
-> 5
-> 5

Answer 14

String table

Posted here

Answer 15

Implement a very simple ALU using only NAND gates

Answer 16

Is it a base-\$\infty\$ prime?

To explain how base-\$\infty\$ numbers work, let's look at how base 10 arithmetic works. We can view a base 10 number as a list of digits (numbers). So 123 is [1,2,3] and so on. When we add numbers, we use the standard long addition, meaning we add digit by digit, carrying if necessary. For example, 123+798:

  ₁₁ 
  123
+ 798
-----
  921

Similarly, multiplication can be done using long multiplication. For example, 123*798:

    123
*   798
-------
    984
  1107
+ 861
-------
  98154

Now, like the name suggest, base-\$\infty\$ numbers have infinitely many possible digits. Therefore we can represent a base-\$\infty\$ number as a list of integers. For lists consisting of only non-negative numbers, addition and multiplication are straightforward. For example, [19,53,1]+[8,4]=[19,53,1]+[0,8,4]=[19,61,5] and [1,2]*[3,4]=[1,2]*[3,0]+[1,2]*[4]=[3,6,0]+[4,8]=[3,10,8]. When restricted to non-negative numbers, carrying doesn't occur.

Negative numbers however spice things up. Let's look first how [-1] works. Let's see what happens when we add [1] to it:

[-1]+[1]=[1,0]

We get [1,0]. Before explaining how this works, it may be helpful to look at a related example in base-10:

9 + 1 = 10

Do you see the similarities? Nine is just ten minus one. Anyways, what is happening is that when you cross the boundary from the negatives to the positives, you carry one, so you end up with [1,0] where the one is carried.

Let's see what happens when we add [-1] to [-1]. We can reason in this way:

[-1]+[-1]=[-1]+[1]+[-2]=[1,0]+[-2]=[1,-2]

Here is the related base-10 example:

9 + 9 = 18

Ok, here is a more complicated example

[1,3,-2,-3,6]+[1,5,-1]=[1,4,0,3,5]

And the base-10 equivalent

13876+159=14035

For singular non-negative integers, multiplication works as you'd expect:

[3]*[1,-2,3]=[1,-2,3]+[1,-2,3]+[1,-2,3]=[5,-6,9]

For singular negative integers, we can use the following trick:

[-3]*[1,-2,3]=([1,0] - [3])*[1,-2,3]=[1,0]*[1,-2,3]-[3]*[1,-2,3]=[1,-2,3,0]-[5,-6,9]=[1,-8,9,-9]

where a-b=c iff b+c=a (subtraction is well defined as long as a>=b).

Here is a base-10 example:

[-1]*[-1]=[-2,1] 9*9=81

For multiplying with longer numbers, we just distribute the addition:

[a,b,c]*[d,e,f]=[a,0,0]*[d,e,f]+[b,0]*[d,e,f]+[c]*[d,e,f]=[a]*[d,e,f,0,0]+[b]*[d,e,f,0]+[c]*[d,e,f]

Basically just doing long multiplication.

Primes

A prime number is a number which cannot be expressed as a non-trivial product. A non-trivial product is a product which doesn't contain the multiplicative identity ([1]). By convention, the multiplicative identity is not a prime.

Your task is to take a base-\$\infty\$ number as input and decide if it's a prime.

Rules

Standard decision-problem rules apply. You may assume that the input doesn't contain leading zeros. You may choose whether the additive identity (zero) is represented as [] or [0].

Mathematical definition of addition and multiplication

Addition:

[] + b = b
a + [] = a
[...ia,la] + [...ib,lb] = [...(ia + ib + carry(la, lb)), la+lb]

where

carry(a,b) = [(a < 0 and b < 0) or (a + b >= 0 and min(a,b) != 0]

Multiplication:

[] * b = []
[..ia, 0] * b = [...(ia*b),0]
[..ia,-a] * b = [...(ia + [1]), 0]*b - [a]*b
[..ia, a + 1] * b = [..ia, a]*b + b

Where a-b is the unique solution to b+x=a (guaranteed to be well defined when using the above definitions)

Test cases:

[0] -> False
[1] -> False
[2] -> True
[3] -> True
[4] -> False
[5] -> True
[6] -> False
[7] -> True
[8] -> False
[9] -> False
[10] -> False
[11] -> True
[12] -> False
[-12] -> True
[-11] -> True
[-10] -> True
[-9] -> True
[-8] -> True
[-7] -> True
[-6] -> True
[-5] -> True
[-4] -> True
[-3] -> True
[-2] -> True
[-1] -> True
[1,0] -> True
[1,1] -> True
[1,2] -> True
[1,3] -> True
[1,4] -> True
[1,-4] -> False
[1,-3] -> True
[1,-2] -> False
[1,-1] -> True
todo add more test cases

Answer 17

Spaceship shooter

Answer 18

Flipping Burnt Pancakes, but Optimally!

This is based on the Burnt Pancake problem.

In the burnt pancake problem, each “pancake” has a burnt side. You must sort these pancakes in order with the burnt side down. You may only use one tool, your spatula, which can flip the pancakes from the top of the pancake stack to where you inserted the spatula.

Flipping pancakes that have the burnt side down results in those pancakes being in reverse order and having the burnt side up, and vice versa.

For a given pancake stack, return the minimal number of flips needed to be made burnt pancake sorting.

The output must show every step of the optimal flipping process, with the position of the spatula being represented by a pipe character, and u or b after every number representing whether or not a pancake is burnt or unburnt.

Note that this is an NP-HARD problem. You may not make an approximation algorithm.

Testcases

1b2b3b4u returns the following:
 1b|2b3b4u
 1u2b|3b4u
 2u|1b3b4u
 2b1b|3b4u
 1u2u3b|4u
 3u|2b1b4u
 3b2b1b|4u
 1u2u3u4u
4b3b2b1b returns the following:
 4b3b2b1b|
 1u2u3u4u

This is fastest-algorithm, so the minimal time complexity wins.

Answer 19

Convert from Two's Complement to Decimal

Answer 20

Draw an ASCII envelope

Answer 21

Order of an algebraic number

Answer 22

Batt to the Basics

Answer 23

What's the Missing Code?

Cops' thread Robbers' thread

Answer 24

Wash clothes as quickly as possible

Answer 25

Translate Text into Matoran

The Matoran Alphabet is the alphabet used by many of the characters in the Bionicle universe.

Your challenge is to create a program or function that takes a string as input and creates an image of the input written in the Matoran alphabet.

The input will only consist of uppercase letters (A-Z), numbers (0-9), and spaces. You may instead take input in lowercase.

Glyphs

As you can probably notice, the alphabet comprises glyphs made up of circles and straight lines.

For the sake of this challenge, let's define each glyph as a circle of radius 4 units (8 x 8), with some internal designs. The internal designs of letters can be any of:

• Vertical Line at position 2, 4, or 6 (either full length or half)
• Horizontal Line equivalent to above
• Circle of radius 1, centered at [2, 2], [2, 6], [6, 2], or [6, 6]
• Any of the above rotated by 45 degrees about the centre

Number glyphs work slightly differently; they always have a circle of radius 1 in the centre. For numbers 0 - 5, the glyph has evenly spaced spokes between the circles, starting from the top. For numbers greater than 5, the glyph has an additional circle of radius 2 in the centre, and the number of spokes is 6 less than the number.

Here is a diagram of the glyphs in spec, any glyphs with 45 degree rotations have an orange grid.

For drawing the glyphs, any line stroke in the range (0, 1) can be used. Glyphs can be kerned (space between adjacent glyphs) any amount from 0 - 4 units. Spaces should be 8 units wide (in addition to kerning).

This is a code-golf challenge, so the shortest code in bytes in each language wins.

code-golf graphical-output kolmogorov-complexity

Answer 26

Get the trends of an array

Answer 27

Will this makina program halt?

makina is a cell-based esolang composed of automata which move around a grid. These automata follow paths of instructions that direct their movement. Your task is to, given a makina program using only the below instructions (so a subset of normal makina) as input, output two distinct values depending on whether or not it is a loop. (If program flow comes to an arrow character that it has already visited then the program is a loop.)

Instructions

• ^>v< These instructions (arrows) set the direction of the automaton to the direction they point in.
• I This instruction halts automata going up or down, but does nothing to ones going left or right.
• H This instruction halts automata going left or right, but does nothing to ones going up or down.
• O This instruction does nothing to the automaton, acting like a sort of 4-way intersection.

All other characters halt the automaton, as does exiting the bounds of the program. The automaton starts in the top-left corner going right.

Testcases

Truthy

>>>v
v<<<

OOOv
H<<<
v

Falsey

>>>v
^<<<

>v
^O<
>^

>>>v
v<I<
H>^
>^

>>>>v
v <<<

OOOv
H<<<
v

Answer 28

Sequence of integers not the sum of powers of earlier terms

Answer 29

Convert to Shorthand (Part 1, Part 2)

Answer 30

Modular tetration

code-golf math restricted-complexity

Tetration is the operation of repeated exponentiation. That is \$ ^{n}a = a ^ {. ^ {. ^ {.^a}}} \$, with \$ a \$ appearing \$ n \$ times.

Tetration grows extremely fast - \$ ^6 2 \$ would take significantly more digits to write then there are atoms in the known universe.

However, to work with big numbers, we can operate on them modulo some number \$ m \$.

Your task is to calculate \$ ^n a \mod m \$, with integer \$ 1 < a,n < m \$.

Rules

• You may use any consistent reasonable I/O method.
• The complexity of your answer must be \$ O(m) \$, where \$ m \$ is the modulus. In particular, you can't calculate \$ ^{n}a \$ with arbitrary precision and then modulo by \$ m \$.
• Standard loopholes are disallowed.
• Your algorithm must work for all values, but it's allowed for your program to fail due to integer overflow.

Test cases

The format for the test cases is a n m -> answer (however, you can take your input in any order) [Sandbox note: TODO - there's an error in my program]

This is code-golf, so the shortest answer in bytes wins.