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

Output the Name of a Number

Idea from a recent question on math SE.

---

Write a program or a function that takes an integer from range 0 to 255 (inclusive) and outputs the name of its unsigned 8-bit binary representation. Input can be in any integer format you like, but the outputted name must match the number's unsigned 8-bit representation.

The name of the number is determined by the positions of its binary digits that are 1:

1 − John
10 − Watson
11 − Watson John
100 − Kevin
101 − Kevin John
110 − Kevin Watson
111 − Kevin Watson John

Let the names for the eight bits be Laura, William, James, Mary, Alice, Kevin, Watson, and John.

So now the name of 255 (11111111 in binary) is:

Laura William James Mary Alice Kevin Watson John

Zero doesn't have a name under this system so you may output an empty string or nothing at all. Trailing whitespace is allowed for all outputs.

Test cases:

<input (as decimal)>
<8-bit binary>
<output>

10
00001010
Alice Watson

42
00101010
James Alice Watson

128
10000000
Laura

189
10111101
Laura James Mary Alice Kevin John

55
00110111
James Mary Kevin Watson John

96
01100000
William James

37
00100101
James Kevin John

0
00000000


255
11111111
Laura William James Mary Alice Kevin Watson John

---

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

code-golf number binary

Answer 2

Optimize for the Test Cases test-battery optimization metagolf

Given a set of test cases (pairs of input and output strings) as input, output a program in a programming language of your choice that consistently and deterministically produces the correct output for each input.

Rules

• You may choose any programming language for the output programs, so long as it is a programming language by our definition, it existed prior to the creation of this challenge, and it is capable of taking arbitrary ASCII strings as input and producing arbitrary ASCII strings as output.
• Your solution must use the same programming language for all inputs. The output programs do not need to be in the same language as the solution.
• The output program must consistently and deterministically produce the correct output for each input. That means that, no matter how many times the program is run, it will always produce the correct output (barring any uncontrollable accidents like cosmic rays twiddling bits). PRNGs are allowed so long as a constant seed is provided (making the output consistent and deterministic).
• The test cases' inputs are provided without quotes, but you may require that the input be quoted if it is necessary or convenient (as per our usual policy on quoted input). However, you must either always or never have quotes on the input - you can't have some with quotes and some without.
• It does not matter what the output program does for inputs that are not part of the specific test case the program was created for.
• You may optionally take the number of test cases as input, if that is convenient or necessary.
• Every input in a set of test cases will be mapped to a unique output. Input values will not be repeated within a set of test cases (so [(3, 5), (3, 6)] wouldn't be a valid test case).

Scoring

Your score will be equal to the sum of the byte counts of all generated programs for the set of scoring cases. Lowest score wins. This is a competition within output languages, not a competition between output languages, so don't be afraid to choose a language that is more verbose than others. I reserve the right to change the scoring cases should it be necessary.

Examples

A C++ program that outputs (poorly-golfed) Python functions:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

const string function_skeleton_start = "lambda s:{";
const string function_skeleton_end = "}[s]";

int main() {
    int N = 0;
    string in, out;
    stringstream program;
    program << function_skeleton_start;
    cin >> N;
    cin.ignore();
    for(int i = 0; i < N; ++i) {
        getline(cin, in);
        getline(cin, out);
        program << "'" << in << "':'" << out << "',";
    }
    program << function_skeleton_end;
    cout << program.str() << endl;
    return 0;
}

An example input:

2
foo
bar
bar
foo

The corresponding output:

lambda s:{'foo':'bar','bar':'foo',}[s]

Test Cases

(TBD)

Answer 3

Output "Hello, World!"... Even before it runs?

code-golf

^{Please note that this challenge only applies to languages that have a build stage and a build log.}

Output "Hello, World!" to the build log. The program may or may not be compiled successfully, the job is to just output "Hello, World!" somewhere in the build log.

Example (C/C++)

#pragma message("Hello, World!")

Answer 4

Is it a number?

---

Given an input, output truthy if it is a valid floating point number, and falsy if it is not. The format that is used in this challenge is [-][<integer>][.][<integer>][e[-]<integer>], where square brackets specify optional values. At least one group in the first section ("mantissa") needs to exist.

Here are some examples of inputs:

Valid

100
-100
10.245
-12.44
.5
-.2
0.3
-0.776
3365883.0000112
5e3         # equal to 5000
-.5245e3    # equal to -524.5
155.0e-3    # equal to 0.155
-5e-1       # equal to -0.5
.           # equal to 0.0

Invalid

feed me numbers
-5-3
5..2
4160e
e4
543tomatoes234
123 456
-3e0.15
4q2

Rules

• Standard loopholes apply
• This is a code-golf, shortest answer wins. However, it will not be accepted.

---

code-golf number

Answer 5

Don't break the bridges!

Introduction:

You are a worker, who is in charge of managing a set of bridges, connecting a square grid of "nodes":

N - N - N
|   |   |
N - N - N
|   |   |
N - N - N

(the grid here is 3 by 3, but they can be larger).

Each of the bridges has a set capacity from 1 to 10, and each of the bridges has a number of cars over them, also from 1 to 10.

• If a bridge has a higher capacity than the number of cars on that bridge, then it is considered "safe", and you can cross over it.
• If a bridge's capacity and number of cars going over it are equal, then it is considered "stable". It won't collapse, but you can't cross over it.
• If a bridge has a lower capacity than the number of cars on that bridge, then it is considered "collapsing", and you only have a limited amount of time to fix it.

When a bridge has n capacity and m cars, with n smaller than m, the time it takes to collapse is:

      m + n
ceil( ----- )
      m - n

You must take materials (and therefore reduce the bridge's capacity) from other bridges and arrive to those bridges on time to fix them! To get materials from a bridge, you must cross over it. For example, take this small arrangement:

A - B

The bridge between A and B (which we'll call AB) has 3 capacity, and let's say you're on A, and want to take 1 material. To take the material, simply cross from A to B.

Now, AB has 2 capacity, and you have 1 material on you. You may only cross over bridges that are "safe", though (or if you're fixing a bridge, which is explained in the next paragraph).

To fix a bridge, you must go over it, thereby depositing all materials needed to fix the bridge. For example, in the example above, if AB had 1 capacity and 2 cars currently on it, and you had 2 material on you, once you cross the bridge you will have 1 material, because that is all that's required to fix the bridge.

You must fully cross a broken bridge before the bridge collapses, otherwise it will break. Each crossing of a bridge takes 1 hour, and the time it takes for the bridge to collapse is shown in the formula above. For example:

A
|
B
|
C - D

In this example, if your starting node was A, and CD only had a "lifespan" of 2 hours, the bridge would collapse before you can get to it (crossing AB takes 1 hour, crossing BC takes another hour).

Task:

Your task is to make a program that calculates, given a list of bridges, which are represented themselves as lists of two elements (first element is capacity, second element is cars on the bridge), whether or not it's possible to fix all of the bridges. The bridges work from top-to-bottom, left-to-right - so an input of

[[3 2] [3 2] [2 5] [5 1]]

means that the actual grid looks like this:

    3
 A --- B
 |  2  |
3|2   2|5
 |  5  |
 C --- D
    1

So AB has a capacity of 3 and 2 cars, AC has a capacity of 3 and 2 cars, BD has a capacity of 2 and 5 cars, and CD has a capacity of 5 and 1 car.

Rules / Specs:

• Your program must work for, at least, 10 * 10 grids.
• Your program may accept the input as either a string with any delimiter, or a list of lists (see example I/O).
• Your program must output the same value for true for all true values, and it must output the same value for false for all false values.
• You can either submit a full program or a function.

Example I/O:

[[5 5] [5 5] [1 1] [3 3]] => true
[[2 5] [2 2] [3 3] [1 2]] => false
[[3 2] [3 2] [2 5] [5 1]] => true

NOTE, you can take the input like this as well:
[[3, 2], [3, 2], [2, 5], [5, 1]] (Python arrays)
3,2,3,2,2,5,5,1                  (Comma-separated string)
3 2 3 2 2 5 5 1                  (Space-separated string)

Answer 6

How many times?

code-golfstring

Inspired by Rotational symmetry of string.

Given a string, return its shortest substring that, when repeated a number of times, will produce the original string, as well as the number itself.

Test cases:

"ABCDABCDABCDABCD" => "ABCD", 4
"AAAAAAAAAA" => "A", 10
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" => "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1
"" => "", 0
"Don't repeat yourself. Don't repeat yourself. " => "Don't repeat yourself. ", 2

Rules:

• You may return the substring and the number in any format you'd like, as long as it's consistent and clear i.e. you can always separate the number correctly from the substring e.g. abc12 isn't allowed since you can't determine whether abc is to be repeated 12 times or abc1 is to be repeated 2 times. The substring must be returned verbatim, while the number can be returned in any generally allowed format per meta consensus.
• The substring must be the shortest possible.
• For the empty string, you must return "" and 0.

Sandbox

• Is the challenge description golfed enough? :P
• May I improve the return/output format?

Answer 7

Build the Chain Quine

This is an answer-chaining puzzle.

Each person will write a program that is not a true Quine but does output its source when given the source of the last program as input. If anything else is input your program may do whatever you wish (undefined behavior) as long as it does not print the source code. The first program will be a true Quine.

Rules

• Standard quine rules apply

• You may not write a submission in a language that has already been used

• You may not answer twice in a row

Goal

The goal is to have as many valid links in the chain as possible.

Sandbox

This is a little sparse because I am still in the brain-storming phase of development. I just wanted to write this down so I wont forget it and, of course, to get feedback. I am not even really set on a winning criterion yet. If you have any ideas/suggestions I am really excited to hear them (thats why I put it in the sandbox).

Answer 8

Quine without a character

Write a program in any language that takes as input any character, and outputs a quine in the same language, that does not contain that character.

For instance (for some made up language):

Input: b
Output: s(fg;fg)
Run "s(fg;fg)"
Output: s(fg;fg)

Input: (
Output: s[fg;fg]
Run "s[fg;fg]"
Output: s[fg;fg]

Your program must handle as input every character within the range of characters that are valid in the source code of the language you're using, including new lines, punctuation, etc.

Scoring

This is code-golf with penalties. Your score is L + 1000xC where:

• L is the length of your program in bytes
• C is the number of characters it fails to meet the requirements on.

So, if you produce a 50-character program that passes every character except for ( and ), your score is 2050.

Standard loopholes are forbidden, and standard methods of input/output are ok. Outputs must be a proper quine, whatever that is.

Answer 9

Add a language to a quine

---

Add a language to a quine program. Your program must output itself in all languages used so far.

Second to last answer wins after no answers have been posted for two weeks.

---

answer-chaining quine polyglot

Answer 10

Build a simple 2D game engine

Write a program that take input specifying specs of a simple 2D game regarding the following:

• GUI: a space where you can print text
• Scene: a 2D stage where player\enemy move
• Input Scheme: a way to check for input
• Player: one object
• Enemy: one or more objects
• Coin: one object
• Engine: manage running scenes

The program should offer the following instructions:

• generate: create an object & place it in the scene
• destroy: destroy an object or hide it from the scene
• move: move an object to a different location, or apply motion
• collision: check if two objects are colliding or interlacing
• write: write to GUI
• param: create, modify, or read an integer
• terminate: stop running update, and run end
• a way to do an if-else

A Scene should at least have the following functions:

• start: sequence of instructions, applied once when the scene is fired
• update: sequence of instructions, applied N-times per second
• end: sequence of instructions, applied once when the scene is terminated

Example

Input the game spec

GUI:1,10

SCENE:5,10

START: GEN(p1,PLAYER,5,1); GEN(e1,ENEMY,4,4); GEN(c1,COIN,3,6); PARAM(r1,0)

UPDATE:  IF(COLLISION(p1,c1), DESTROY(c1);PARAM(r1,PARAM(r1)+1));
         IF(COLLISION(p1,e1), DESTROY(p1);TERMINATE);
          IF(INPUT(ARROW-UP), MOVE(p1,-1,0));
        IF(INPUT(ARROW-DOWN), MOVE(p1,+1,0));
        IF(INPUT(ARROW-LEFT), MOVE(p1,0,-1));
       IF(INPUT(ARROW-RIGHT), MOVE(p1,0,+1));
       WRITE(g1,r1)

END: IF(PARAM(r1)=1, WRITE(g1,"YOU WON"), WRITE(g1,"GAME OVER"))

Output an interactive game

[ 0        ] <----- G:GUI (1 x 10)
+----------+
|          | <--- S:Scene (5 x 10)
|          |
|      C <-|----- C:Coin
|   E <----|----- E:Enemy
|P <-------|----- P:Player
+----------+

• game starts with player, one enemy, one coin
• you can control the player with arrow keys
• if player come in contact with enemy, player disappear then it ends
• if player come in contact with coin, coin disappear then it's counted
• when game ends, if coin count is 1 you win, otherwise you lose

Meta

• What tags to use?
• How can I simplify the requirements so that it's possible to solve it with languages of simple means?
• I haven't seen many challenges like this, to write a program which parse instructions to create an interactive program within it, what do you think?

Answer 11

Distinct strict partition counts

code-golfmathnumber-theoryinteger-partitions

---

^Related

The Task

Write a function or program that, given a positive integer n, returns or prints an array (or list, set, etc.) of length l such that each index i contains the count of distinct partitions of size i of n (one-indexed) and l is the maximum size of partitions for n.

Definition

Let f(n) implement the task described.

Consider f(10)

10 may be broken into the following distinct partitions:

10         // Size 1
9,1        // Size 2
8,2
7,3
6,4
7,2,1      // Size 3
6,3,1
5,4,1
5,3,2
4,3,2,1    // Size 4

There are:

• 1 distinct partitions of size 1.
• 4 distinct partitions of size 2.
• 4 distinct partitions of size 3.
• 1 distinct partitions of size 4.

Therefore, f(10) returns [1, 4, 4, 1].

Test Cases

TODO

Answer 12

Show key code

Inspired by the showkey command.

Task

You have to output the key and if is a key-up or a key-down event. I exemplify:

The output I want:

Key X Down
Key X Up

for both the instants you press or release a key.

You can output it on a console or on a GUI.

It is code-golf, so shorter code wins.

Answer 13

Set The Shapes

code-golfarray-manipulationmath

Updated on 23/05/17 with new shapes & questions

Challenge

Let s be the sequence of polygonal numbers with S sides and t be the sequence of polygonal numbers with T sides. Take the set union of the first n elements of s and the first n elements of t.

Input

3 integers, n, s & t where:

• n>0, 2<(s,t)<13 and s!=t
• The values of s & t each represent a different polygonal number type:

  3 = Triangle
  4 = Square
  5 = Pentagon
  6 = Hexagon
  7 = Heptagon
  8 = Octagon
  9 = Nonagon
 10 = Decagon
 11 = Hendecagon
 12 = Dodecagon

Output

An array of the set union of the first n numbers of shapes s and t in ascending order.

Example

(assuming 0-based indexing)

• Input: n=5, s=3, t=4
• The first 5 triangular numbers are 0, 1, 3, 6, 10
• The first 5 square numbers are 0, 1, 4, 9, 16
• Output: [0, 1, 3, 4, 6, 9, 10, 16]

Rules

• Input must be 3 separate integers
• Output must be an array (or equivalent in your chosen language)
• If your chosen language isn't capable of handling either or both of the above then standard I/O methods apply
• s & t are guaranteed to be different but you must be able to handle them being input in either order - smallest first or largest first
• This is code-golf so lowest byte count wins

Test Cases

Input: 5, 3, 4
0-Based Output: [0, 1, 3, 4, 6, 9, 10, 16, 20]
1-Based Output: [1, 3, 4, 6, 9, 10, 15, 16, 25]

Input: 10, 9, 8
0-Based Output: [0, 1, 8, 9, 21, 24, 40, 46, 65, 75, 96, 111, 133, 154, 176, 204, 225, 261]
1-Based Output: [1, 8, 9, 21, 24, 40, 46, 65, 75, 96, 111, 133, 154, 176, 204, 225, 261, 280, 325]

Input: 1, 7, 6
0-Based Output: [0]
1-Based Output: [1]

Input: 8, 3, 3
Invalid input as both shapes are the same

Input: 0, 2, 17
Invalid input as n<1, s<3 and t>12

Bonus Idea 1

Brownie points if you want to increase the range for s & t and include some other polygons (e.g., star, dodecagon).

Bonus Idea 2

Alter the challenge to only require that solutions be able to handle 5(?) different shapes with a score reduction for each additional shape, up to a maximum of 10(?).

---

Questions

This is my first challenge (inspired, in part, by this) so all feedback very much welcome.

• Should I add or remove any tags?
• Is the above sufficiently different from this and this?
  (Votes: 2 for this not being a dupe, 2 for it being a dupe of the second linked challenge)
• Does everything read OK & make sense?
• Should I include the formula for each shape in the question?
  I'm leaning towards "yes" as:
  1. For those that know them, figuring them out won't be a challenge
  2. For those that don't, figuring them out wouldn't add to the challenge
  3. As soon as one person posts a solution containing the formulas, that makes them available to everyone else anyway.
• Should there be more (e.g., star, tridecagon+) or less possible shapes?
• Would it improve the challenge if I allowed solutions to pick a smaller subset of 5(?) shapes to work with? How about if that subset had to be sequential (e.g., 3-7 or 5-9 but not 3,5-8)?
• What test cases should I add?
• Do the bonus ideas add to or detract from the challenge?
  Answered: Bonuses are generally bad.
• Is there a better name I can give this challenge?
• Should I be asking any other questions?!

Answer 14

Dodge your death!

Introduction

"Muhuhuhahahah!" The mad scientist laughs. "You're trapped in my own little game!"

In front of you is a deadly pit of snakes, while behind you is a bottomless chasm. There's no way out, you're stuck!

"Two steps in front of you is the snake pit, and two steps behind you is the chasm. But! Before you move, you MUST write down a sequence of steps, forwards and backwards, and give them to me. But! because I'm feeling a bit evil today, I can make you take, instead of every step, every nth step, where n is less than your sequence length!

Choose wisely, now."

What's the maximum number of steps you can take before your imminent death?

Task

The intro above is a twist on the Erdős discrepancy conjecture, which was recently proven true (if you want to understand more about this, go to this video, by James Grime - I "stole" the twist question off of him).

The answer to the intro is 11 steps, but I won't go too in-depth with a proof. The answer, if the distance between you and the two "dangers" were 3 steps, is 1160 steps, although that isn't validated properly yet.

Your task is to make a program that generates the longest sequence of steps you can for a larger x, where x is the number of steps between you and the two dangers. For the purposes of this challenge, + represents a step forward, and - represents a step back.

So, an output for an input 2 is:

+--+-++--++

Which works, no matter what n the mad scientist chooses. For our challenge, x = 5.

Rules:

• Your entire program should fit into your answer. However, if it doesn't fit, please provide an additional Github repository, or something similar.
• You may update both your answer and program, if you can get a better score via optimisation.
• In your answer, you must have:
  • Your program, in its entirety
  • The amount of steps generated - this will be your final score.
    • You must also provide an online version of the sequence in a Pastebin, or something similar. This is so we can check your answer.
  • The time your final score was last updated, so I don't have to check your history
• You may NOT hardcode sequences beforehand
• Your program must work for all x (where x is the number of steps between you and the pit & chasm), but you only need to provide the score for x = 5.

The answer with the largest score wins!

Meta:

• What tags should I put in?
• What things should I fix / elaborate?
• For the "link to text file containing sequence" thing, I'm worried that the files might eventually get really big, as answers are more and more sophisticated. Is there any way to counteract that?

Answer 15

Data Categorization with a Si(g)n

Background:

Machine learning is a very powerful tool for categorizing data. It can help find a function that splits some already known data so that unknown values can be predicted. Typically, this function should be simple so that it does not "overfit" the data. As it turns out, previous studies have found out that the simple function f(x) = sgn(sin(ax)) can split most data into two categories with only a single coefficient to adjust! This will definitely (not) prevent overfitting, and should (not) be used for every application of machine learning.

sgn(x) is the sign function of x. As Wikipedia says,

         / -1 if x<0,
sgn(x) = |  0 if x=0,
         \  1 if x>0.

Input:

Two ordered sets/arrays/lists of integers {m₁, m₂, m₃, ...} and {n₁, n₂, n₃, ...}.

You can take input as 2 lines of input, an array with the two arrays m and n as its elements, or any other reasonable method of input.

Output:

A value of a such that sgn(sin(ax)) equals 1 when x = m₁, m₂, m₃, ..., and -1 when x = n₁, n₂, n₃, ...

If no such value of a exists, you can output any non-numerical value.

Test cases:

Example inputs will be in the form [[m1, m2, m3, ...], [n1, n2, n3, ...]]
Input                  | Output
[[1, 5],    [2, 3]]    | 1.75
[[2, 3, 6], [5]        | 4.5
[[1, 3, 5], [2, 4, 6]] | 3.1415925
[[1, 6],    [2, 3]]    | Random junk
[[2, 3, 4], [1]]       | <Anything non-numerical>

Answer 16

Odd with Odds, Even with Evens

Given an input integer n, express it as a sum of numbers with the following properties:

• If n is even, the numbers used to sum should be even.
• If n is odd, the integers used to sum should be odd.
• Any integer used (x) should be 0 < x <= ceiling(n/2).
• All numbers used in the summation should be unique.
  • If there are no set of distinct odd/even integers that sum to n, return -1.
• Output may be as an array or delimited string.

Examples

Input | Output       | Comments
------+--------------+-------------------------------------------
2     | -1           | 0 < ? <= 1 = [1] (No evens, not possible)
12    | [6,4,2]      | Order is arbitrary, [2,6,4] is fine.
24    | [8,4,12]     | [2,4,6,12] works too.
9     | [1,3,5]      | Odd cases are a bit trickier to think about.
      |              | ceiling(9/2) = ceiling(4.5) -> 1 < x <= 5 -> [1,3,5]       
1     | -1           | c(1/2) = c(.5) -> 1 < x < 1 -> []
13    | [1,5,7]      | c(13/2) = c(6.5) -> 1 < x <= 7 -> [1,3,5,7]
27    | [13,11,3]    | Etc...

The numbers you use for each answer and how you get to the numbers you used do not matter, the only thing that matters is that they adhere to the spec. The order of the numbers does not matter, and you may have different results than provided.

This is code-golf, first person to mail Bill the contents of Hillary Clinton's private mailserver wins.

Answer 17

Let's not collide

Contextualization

You might have heard about Re-Volt, a pretty old video game. Its collision system for cars is somewhat interesting : the body of the vehicle gets transformed into a simplified 3d convex shape which is then filled with spheres.

Challenge

Your objective is to produce a code that will, provided a 2d shape and the number of wanted circles, output a similar result to the picture above. That is represent the polygon as accurately as possible with circles.

The two dimensional shape shall be a convex polygon of N vertices. The spheres will of course have the position and the diameter your code defines as optimal.

Your code should be able to take an input representing any irregular convex polygon (the format matters little as long as it can process at least a 10-vertices shape) and an input corresponding to the number of spheres that should fill the polygon.

Because it is impossible to fill completely and perfectly an N-gon with a finite amount of spheres, a tolerance is of course needed so your circles may have a portion (<10%) located outside the polygon. The circles may (and probably should) intersect at some points.

The output must be graphical.

Test cases

You should test your code with the following three polygons and with 5, 10 and 25 circles.

Polygon n°1 (10 vertices)

[[1,0],[7.5,0],[15,0],[15.5,1.5],[15,2],[7,4],[4,4],[0.75,2.75],[0,2],[0.25,0.5]]

Polygon n°2 (5 vertices)

[[0,0],[11,0],[11,2],[7,4],[0,4]]

Polygon n°3 (8 vertices)

[[1,0],[15,0],[15.5,1],[15,2.5],[10,4.5],[2,4.5],[1,4],[0.5,1]]

Questions

• Are the rules and the objectives clear enough ? Does the challenge make sense ?

• How should I define a winner (is a winner mandatory) ?

• Is it a good idea to leave the choice of the input to the coder ?

• Does this challenge already exist and this is a duplicate of some sort ?

• Are there any english mistakes ?

• Is the challenge actually a realistic thing to suggest ?

Any and all suggestions are welcome since this is my first post here.

Answer 18

Fairly Cut a Ham Sandwich in Half

codegolf geometry

In this challenge we consider a discrete version of the ham sandwich theorem. In our case the theorem says:

Given two sets of points in a plane, there is a line that simulaneously bisects both sets.

So given two disjoint sets of distinct integral points in the plane, your task is finding a line of the form a*x + b*y = c that bisects these two sets and outputs the integers a,b,c.

• Both (strict) half planes have to contain the same number of points of per set.
• The line can contain input points, these are then not counted to either of the sides (e.g. when a set contains an odd number of points, or all points are on one line.)
• The line is not necessarily unique.
• The mentioned representation of a given line is unique up to an integral multiple (e.g. (m*a)*x + (m*b)*y = (m*c) represents the same line as above), but you do not have to output the fully reduced form.

Examples

As we said above, the output is not necessarily unique, so the presented outputs here are just examples. All the outputs are give in the form a,b,c.

Input: [(1,2),(1,4),(2,1),(2,3),(3,2),(3,4),(4,1),(4,3)] [(1,1),(1,3),(2,2),(2,4),(3,1),(3,3),(4,2),(4,4)]
Output: 410,640,2625 (410x + 640y = 2624)
        1,1,5 (x+y=5)
        0,2,5 (2y=5)

In the following we see three valid outputs:

Input: [(1,1),(2,2)] [(1,2),(2,1)]  
Output: 2,5,10 (2x+5y = 10)

(more to be added)

Answer 19

Collatz Bearings

Everyone knows the collatz conjecture. It is that this function:

when repeatedly applied on a positive non-zero integer will reach one.

There are many ways to visualise this. Inspired by this post, with the original source of this method here, this is how we will do it:

Start at 1, with a northward bearing. The next numbers will be one unit (of any, consistent) size, and x degrees clockwise (+x) if it is even, and x degrees anticlockwise (-x) if it is odd.

An example of this can be seen here (Though it starts with an eastward bearing). It uses a few hundred random starting points and goes backwards. But it's probably easier to build it backwards.

Here is a graph-like visualisation, showing the first 8 levels:

There can be collisions.

Your task is to take two numbers, which would correspond to 2 nodes on that tree, and return the bearing of the second node to the first node.

Input

3 numbers. Positive integer a, Positive integer b, and angle x, in any unit you desire. b > a > 0, x is the angle of seperation, in it's simplest form (mod 360 for degrees, mod 2pi for radians, or having the upper half be negative if you wish.) a and b are guaranteed to be in different places (e.g., you won't have a = 20 and b = 21.)

Output

Using the method described above, the bearing of b from a in the graph, in the units of the input angle.

Scoring

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

Note

If the Collatz Conjecture is eventually proven wrong, you do not need to take inputs where repeated application does not reach 1.

code-golf number

Answer 20

Efficiently find the median

Background

Computer scientists have spent a long time looking into ways of sorting data faster. One of the known discoveries is that if you can use the actual values of the data, sorting can be faster than if you can only compare them.

Finding the median of a list is a similar operation to sorting it (you can trivially implement it via sorting the list, then taking the element in the middle). However, if you're in an environment where you can only compare list elements (as opposed to looking at the elements directly), this is not typically the fastest way to find the median, as sorts are hurt more badly by the comparison restriction than finding the nth item is. What's the fastest way? Well, finding that is what this challenge is about. (However, you may want to read this Wikipedia article to get some ideas of the approaches that are typically used. I can't guarantee that the algorithm given there is the best, though, especially on a problem of the limited size given here.)

The task

Write a program that finds the index of the median element within a list of 31 elements. However, the program may not take the list as input, and may not inspect its values directly. Rather, the program may only make comparisons to determine which of two indexes corresponds to the larger element, via calling a separate comparison function. (In other words, your program deals entirely with list indexes, not list values.)

In order to avoid solutions that brute-force their way through all possible algorithms, you must be able to run at least one worst-case input (i.e. an input that takes the maximum possible number of comparisons), using a comparison function which simply compares two array elements, in under 10 minutes on some computer you have access to. (Solutions which do not use brute force to find an algorithm are unlikely to get anywhere near this time bound.)

Clarifications

• You may assume that all the list elements are distinct, i.e. the comparison function will always specify that one of the elements is larger, no matter how they're compared.
• You may choose the format in which the comparison function provides output, but there must only be two possible outputs (meaning "item at first index is larger" and "item at second index is larger") for any possible query; you can't return values that mean "item at second index is much larger" or anything like that.
• The comparison function will act consistently, i.e. if it claims that the list item at index A is larger than the list item at index B, it will always claim that; and if it also claims that the list item at index B is larger than the list item at index C, it will additionally claim that the list item at index A is larger than the list item at index C.
• You may take the comparison function as input, or assume that it's already defined with a specific name. This is not code-golf, so there's no need to try to exploit the freedom you have here to save bytes; feel free to write it in the most readable way. (The comparison function itself is not part of the submission, but you should probably include one for testing purposes and an example of what it looks like.)
• You may exploit the knowledge that the input list is exactly 31 elements long, if you wish (your program doesn't have to work in other cases, although of course it can if you want it to).
• If your language doesn't have functions, you may write the comparison function via a source code insertion, so long as the rest of the code doesn't attempt to inspect its internals. (However, you may as well just pick a different language in this case; the scoring method is based entirely on the algorithm you use, and picking a different language won't change your score at all.)

Victory condition

Your score for this challenge is equal to the maximum number of times the comparison function can be called during a run of the program. Obviously, lower is better.

In the case of a tie, the first submission achieving the optimal score will win. (In other words, you don't gain anything from copying someone else's solution but golfing the code, or the like; you'll have to find an algorithmic improvement.)

Sandbox questions

Is this scoring method fastest-algorithm, fastest-code, or code-challenge? I guess I'd want to call it atomic-fastest-code (by analogy with atomic-code-golf) but that doesn't exist and I'm not sure it should be created. EDIT: None of the above, it's fewest-operations.

Answer 21

The Travelling Merchant king-of-the-hill

Economy is flourishing in the great Kingdom of Pipysigea [pee-pee-see-gee-ah], since the bandits have been driven away by the King's army. Especially, many people have decided to make trade their... trade, and have become merchants. You were one of them. You used most of your life's savings to purchase a good wagon and some animals of your choice. (Note: it can't be dragons. Sorry.) Unfortunately, you have just moved to Pipysigea from far away, attracted by the promises of wealth and security, so you don't really know much about the Kingdom: you have just bought a map, so you know the names of the cities and where they are, but you don't really know how long it's going to take to travel from one city to another.

So what is your goal? Being a merchant, you'll want to travel from city to city to get an idea of what good they want to buy and what goods they sell.

There will be a total of X kinds of goods in the Kingdom, and each city will be looking to buy 3 kinds and will be selling 3 kinds of goods. You will need to find out whether their prices are good for you: for example, the city of Puzzleon might be selling iron for 4 coins per unit and buying bread for 1 coin per unit, and the city of Stackapor might be selling wool for 2 coins per unit and buying iron for 5 coins per unit: in this case, it would be profitable to buy iron from Puzzleon and then travel to Stackapor to sell it.

But beware: trade is ever-changing, and prices are going to change based on what you and other merchants do. If you keep selling iron in Stackapor over and over, their need for it will soon start lowering, and so will the price they offer for that good. Similarily, if you buy a lot of iron from Puzzleon, the quantity at their disposal will lower and the amount of coins they want for it will start getting higher, until they run out of iron and stop selling it.

Beware, also, of taxes! The arch-enemy of any merchant. Every seven days (= turns) you are going to be taxed, based on your current wealth, which is measured by actual coins and amount of goods in your wagon. After all, his majesty King Golfus II deserves compensation for ridding the Kingdom of bandits and letting it prosper. And also for having established free market, of course.

During your travels, you will eventually encounter fellow (or rival, depending on your attitude) merchants, with whom you can trade just like you can with cities. You can decide to keep walking or to stop and trade. Every time this happens, you can tell them 1 good you are willing to buy (or none) and the price you offer, and the same with 1 good you are willing to sell. The other merchant will do the same. Then, you can respond by accepting or declining both of their proposals or just one. They will do the same with your proposals. Once all this is done with, you can resume your travel.

You lose if you go bankrupt: that happens when the time comes to pay taxes and you don't have enough coins. You automatically win if all other merchants have gone bankrupt.

The game ends after XXX turns, and the winner will be the merchant with the most coins.

---

Rules

• Antitrust Law: a merchant cannot be made specifically to support another merchant. (To help ensure this, merchants can never know the name of the merchant they are trading with)

• Fair Trade: a merchant cannot be made specifically to harm the trade of another merchant.

• Fair Code: King Golfus II is the one and only ruler, and a merchant may not interfere with the law (also known as "The Controller")

---

Technicalities

You will be provided with a list of randomly generated cities (e.g. 10 to 15) with their coordinates on the map (a simple cartesian plan with X and Y values). The terrain is assumed to be pretty much the same overall, so travel times are based only on distance (initially I thought about giving specific travel costs - e.g. difficulty of road, maybe mountainous or muddy or whatever - to each "link", unbeknownst to the merchant, but felt like it would have complicated things too much. If you think it would be a nice addition, feel free to say it in the comments!)

Every city has a randomly generated list of 3 items to sell and 3 items to buy. The quantity they have available of each item they sell is also randomly generated, as well as the prices of all 6 kinds. Obviously, if a city sells iron they won't also be looking to buy it.

Each merchant can only be in one of these three positions:

• in a city

• on the way from one city to another

• midway between two cities, stopped to trade with another merchant

The game proceeds in rounds, which are made of each player's turn. Every round, the turn order is changed (To be decided: poorest players first or randomly generated?)

In their turn, each player can do one of these things:

• trade with the city, if they are in a city

• trade with a merchant, if they have encountered a merchant on the road

• resume travelling to the other city, if they have encountered a merchant

• start travelling to another city

If, in the previous turn, the player started travelling to another city, at the start of this turn he'll either

• be notified that they have encountered a merchant, and can decide whether to trade or keep walking

• be notified that they have reached the other city, and receive the information about it (its name and its trade prices)

If the player encounters a merchant and decides to keep travelling instead of trading, they will reach the city they were travelling to and will still be able to act (= trade with the city or move again)

If, instead, the player trades with the merchant, their turn is considered over and will be able to move again on their next turn (note: since they will be midway between two cities, they will have the chance to decide which of the two to travel to, in case they want to change their previous "travel decision")

Taxation happens at the start of the player's turn, if it is the taxation round (= once every 7 rounds)

Note: the player can't "talk" to the other merchant unless they both stop to trade, so if the player decides to keep travelling they won't know the other merchant's prices. (I'm not sure about this rule, so please give me feedback :) would it be more sensible to know the other merchant's prices before having to decide whether to stop?)

Code

I haven't started coding the controller yet, but I was thinking about using Node.js (since javascript is my favourite language, and I don't have tools to use Java and would prefer to avoid having to install stuff) so that bots can be submitted in the form of node modules (either written in javascript or with a javascript wrapper like most low-level node modules)

Note that your bot will be able to save data into a .txt file.

Please give me feedback if you want to suggest a different approach. :)

Answer 22

Count Numbers in Integer Partition

code-golf

Sandbox Remarks

I'm looking for a description to make the problem more clear.

Challenge and Example

We can partition a positive integer into smaller (or equal) ones. For instance, for N=6, it can be divided into:

• 6 (1 integer occurs >= 1 times, 0 integer occurs >= 2 times)
• 5+1 (2, 0)
• 4+2 (2, 0)
• 4+1+1 (2, 1)
• 3+3 (1, 1)
• 3+2+1 (3, 0)
• 3+1+1+1 (2, 1)
• 2+2+2 (1, 1)
• 2+2+1+1 (2, 2)
• 2+1+1+1+1 (2, 1)
• 1+1+1+1+1+1 (1, 1)

Your task is to work out the sum of the count of integers in each case, which occurs greater or equal than M times. In the aforementioned case, if M=1, the result is 1+2+2+2+1+3+2+1+2+2+1=19, and if M=2, the result is 0+0+0+1+1+0+1+1+2+1+1=8.

Input

Two positive integers N, M.

N is the number being partitioned from.

M is the lower limit of occurrences.

Output

One integer, the sum of the count of unique integers in each partition.

Remarks

• This is a code-golf so shortest code wins.
• Standard loopholes are forbidden.

Example I/O

All padding spaces are for formatting on PPCG only. You don't need to take care of them.

8  2  => 19
10 1  => 97
25 4  => 1228
25 50 => 0
50 7  => 87004
50 50 => 1

All I/O for M,N<=50: here

Answer 23

Obsfucation: Use Uncommon Chars

obsfucation code-challenge

Note that I do not have the SE lookup skills to set this up. An automated query would take this challenge a low way. If someone would like this to happen, I would greatly appreciate some help setting this up :)

Basic search (currently searches for Jelly, anywhere)

First, choose your language. It must have at least 100 answers on PPCG before the posting of this challenge, and at least 25 chars that are not no-ops. /* Click this query and insert your language's name to see if it is valid. If it is, this query will give you legal chars, and their point value */. Use those chars the complete the challenge. The lowest point value wins.

/*This Query

//Can we do challenges for SE queries? If so this would be a decent one :)

What I would like for this query to be:

Gets all chars from the first codeblock following the language name in a heading. Accumulates all chars into a frequency table. Make sure that there are at least 25 relevant chars - we can human inspect this to insure no-ops are not polluting the data. It will then return the bottom 20% (frequency) of chars, rounded down, along with point values from 1-length for each of them. The least common chars will receive lower scores. Ties will have the same point value (do it like tournament rankings - 1,1,3, not 1,1,2.)

Challenge answerers will only be able to use the chars provided. /Should whitespace be excluded (and allowed to be used, with a penalty) because of how SE treats whitespace?/

RE 25 char min: I really would like to get rid of this, but I don't know how else to prevent languages like BF from having an inherent advantage. Even if I restrict BF to 2 chars, it will score really low because they will have point scores 1 and 2.*/

/*The Challenge

I have not yet decided what the challenge should be - snippets to solve as many challenges, with point value as tiebreaker, might work, or a more difficult challenge. Input requested :) */

Answer 24

Resolve paths code-golf

Convert a path to an absolute path. The path may be:

• relative
• absolute
• contain ~

If the path doesn't exist, exit with code 1. An invalid path leads to undefined behavior. i.e. do whatever you want, I don't care

Test cases, assuming /foo/bar is the current working directory, and the username is ~/admin:

<empty string> -> /foo/bar
. -> /foo/bar
.. -> /foo
... -> / # and so on until `...`
~/ -> ~/admin
~/golf -> ~/admin/golf
/bin -> /bin
foobar -> /foo/bar/foobar
.htaccess -> /foo/bar/.htaccess
./buildscript -> /foo/bar/buildscript
doesnotexist -> <exit with error code 1>

Don't use an external command or builtin that solves or almost completely solves this challenge.

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

Answer 25

I would like to ask this challenge:

The objective of this programming puzzle is to reproduce the following gif.

However, I do not know the specs for the making of such an animation.

How can I make this a standard/allowed puzzle with this limitation?

Any inputs will be appreciated.

Answer 26

Write a brute-forcer for the 3-byte input 'emoticon numbers' challenge

The Emoticon numbers! challenge asks you to identify the 3-byte snippet which evaluates to the highest numeric value in your language, and which also has the bytes in the form ABA (where the outer two are identical and the middle one is different), and which generates an output that is only digits.

I trust your claim that you have identified the best possible one is honestly intended, but as a casual scripter I'm not totally convinced, and can't be reassured by unfamiliar language specification references - since there are only 256^2 possible values, can you convince me with brute force instead?

Write a program or function which:

1. takes no input
2. generates all the possible 3-byte sequences matching the pattern ABA and evaluates them in the same language. (No using one language to generate the best pattern for a different language).
3. Processes all the ones which evaluate to digits-only (output text matches the regex ^[0-9]+$, with or without trailing newline).
4. Outputs just the ABA sequence which evaluated to the highest value, and an optional trailing newline. No errors or stderr output from failed evaluations.

Clarifications:

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

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

Tag: code-golf

Answer 27

Heapify a list

META:

As a few people just pointed out, if you sort the list, this also produces a correct heap. I'm now trying to come up with a more interesting application of heaps.

code-golfdata-structuresrestricted-complexity

Given a list of integers, heapify this list and return it. The sumission must have a worst case time complexity in O(n).

Details

• Your implementation can produce min- or max-heaps, whatever is more convenient.
• Sorting the list would solve the problem, but since the worst case complexity must be in O(n) where n is the length of the list, known sorting algorithms like quicksort fail to meet this requirement.

Definition

A min-heap is a complete binary tree where the values stored in the children of a any node are greater or equal than the ones stored in the node itself. (In a max heap it is the same just with condition less or equal).

A heap can be easily represented using a list L (here using 1 based indexing) where the children of the node at L[k] are L[2*k] (the left child) and L[2*k+1] (the right child).

A list L (lets say one based indexing is used) is (min)-heapified if

 L[k] >= L[2*k] and L[k] >= L[2*k+1] for all k

For a max heap we just replace >= with <=.

Examples

Following image represents a max heap:

The corresponding list representation is

[100, 19, 36, 17, 3, 25, 1, 2, 7]

The following image represents a min heap:

The corresponding list representation is

[1, 2, 3, 17, 19, 36, 7, 25, 100]

Answer 28

stdin FPS

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

Task:

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

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

Rules:

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

Sandbox questions:

• Dupes? (I don't know what to search for)

Answer 29

Print all matching leaves code-golf natural-language parsing

In Natural Language Processing, we sometimes interpret sentences as being context-free languages, and therefore as having a certain tree structure, also called constituency trees, or parse trees. These trees are sometimes written down in a notation that (as far as I know) stems from the Penn Treebank project:

A tree is either of:

• (a b1 b2 b3...), with a being the tree's label (typically something like NP for "noun phrase") and bn being the same representation of it's sub-trees (all being non-terminals)

• (a c), which a being the tree's label and c being the label of a single terminal child (a word).

Valid trees:

• (S Hi) (Simple tree containing only one word, "Hi")
• (A (B (C D))) (Nested tree containing only one word, "D")
• (A (B C) (D (E F)) (G H)) (Tree containing the words "C", "F", and "H")

Invalid trees:

• Hi (a terminal is not a tree)
• (A B C) (terminals have no siblings)
• ((A (B C))) (extra parantheses)
• (A (B C))) (unbalanced parantheses)

For understanding this format better I recommend this online tool I wrote ages ago. For example, this is a visualization of the first example case:

Task:

Given a Penn-Treebank-style tree representation and a non-terminal, output the space-seperated concatenation of all leaves for every instance of this non-terminal.

Rules:

• You may take the two inputs (tree representation and non-terminal symbol) in any of the standard ways, but always as strings. You may take them in any order.
• The output can be a list of strings (["The dog", "a cat"]), some other kind of sequence, a (e.g.) comma-seperated string, and anything else that's reasonable
• Both inputs are guaranteed to never be empty.
• The tree representation input is guaranteed to contain at least one terminal symbol.
• Single spaces may or may not exist for formatting (both the first and the second example are equally valid and both have to be accounted for), but there will always be a single space between a terminal symbol and its immediate parent (e.g. between Det and the in the first example)
• In case you don't find any matching terminals, you may either raise an error, not output anything, or output some kind of empty sequence.
• All node labels (terminal or not) will match /[A-Za-z0-9_-]+/.
• Specify which output format you use
• The shortest code (per language) wins

I/O examples

input 1                                                input 2  output
(S(NP(Det The)(N dog))(VP(V likes)(NP(Det a)(N(cat))))), NP -> "The dog", "a cat"
(NP (Det A) (AP (Adj fancy) (N car))),                   V  -> an empty sequence
(N cat),                                                 N  -> "cat"

Output format examples

• List of strings: ["The dog", "a cat"]
• CSV: "The dog, a cat"
• CSV without spaces: "The dog,a cat"

Answer 30

Least Picky Language popularity-contest

For this challenge, you will create a programming language that is not picky at all. That is, for any program of any length consisting of any characters in the ASCII range [32..126] and any input consisting of any characters in the same range, your program must do something without any errors. The program only has to hypothetically work for any length; that is, StackOverflowException and the like are acceptable if the input or program is too long for your new language to handle (however, I require it to work for program size up to 1024 bytes and input up to 1024 bytes).

In your programming language, no character or combination of characters can be useless (to prevent everything from being a no-op). That means that every character in the program must affect the function somehow, even if the overall function does not change. No two characters can have the same specification either.

For example, it is not allowed to have - and N both compute the negative of a number.

Note that <space> is a valid character in the program and must do something even if it is leading or trailing. Also note that you do not have to handle tabs or newlines in the program or the input.

The most upvoted answer at the end of 2017 Calendar Year (UTC December 31 23:59:59) will be accepted, and I will award a +50 bounty to my personal favorite language.

Meta

• Duplicate?
• Clear enough validity criteria?