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

Rounding errors

The task

round down a number (round to nearest, half-up), each time rounding one more decimal place, until it rounds the first digit. But every time a number gets rounded down more, make it choose wrongly to take the ceiling or the floor. So round to furthest, half down.

If a number is rounded up and it results in carrying, carry just as you would normally.

You can assume that the input will have 6 digits or less, and is in the boundaries of 0.00001 < n < 1000000. so 123.4567, 1000000, 0.000005926 and -4 would all be invalid inputs.

Let's look at the input 63.9308:
first, round to 3 places:
The last digit is 8. Usually it'd get rounded up, but here, nothing happens and it results in 63.930. Note that you need to keep the last zero.
0: round up: 63.94.
4: round up, and using basic math, the result is 64.0
0: round up: 65
5: round down: 60

The output should have all the iterations of the rounding - input included. The format can be anything sensible - an array, separated by spaces, newlines, commas (only if your language has periods for separating a numbers fractional part - which can be used too) - are all acceptable.

So the output for above could be 63.9308, 63.930, 63.94, 64.0, 65, 60, but is not forced to be.

Test cases

input: 167.54
output:
167.54
167.6
167
170
100

input: 1
output:
1

input: 123.456
output:
123.456
123.45
123.4
124
130
200

input: 984.00
output:
984.00
984.1
985
980
900

input: 314.911
output:
314.911
314.92
315.0
316
310
400

input: 100.000
output:
100.01
100.1
101
11
2
input: 444.444
output: 
444.444
444.45
444.4
445
440
500

input: 555.555
output:
555.555
555.555
555.55
555.5
555
550
500

Your job is to write a program or function in the language of your choice. This is code-golf, so the shortest entry in every language wins.

sandbox

• any better wording?
• anything I'm missing?

Answer 2

*TERM(1) *TERM(1)

NAME Implement STAR* term / create a mini-terminal - code-golf
SYNOPSIS $ ls proj/ documents/ notes.md $ cd documents $ cp proj/build build $ chmod 755 build
DESCRIPTION - When you start up, overwrite the file ~/.*term to ~ - Take commands from stdin. When the user hits enter, run bash -c "cd $(cat ~/.*term);<escaped command>;echo $PWD > ~/.*term" - Pipe output to stdout. Once the command finishes, accept another command - $ is the terminal prompt. - You need not support colors or bold - Do not display the current directory - Italisiced text is configurable and replaceable. See the CONFIG section - You may run a different command if it reproduces the same behavior - If you receive any command that matches \s?exit\s?(\d)?\s?, exit. - If the capturing group is present, exit with that exit code.
CONFIG - Located in ~/.*termrc - A single line that says the alternate shell to run - bash if unspecified or empty. (or if the file doesn't exist)
OPTIONS -c <file> - use the following file as the config file - If the file doesn't exist, exit with code 1 and print *term: {...}: No such file or directory - Replace {...} with the given filename - If no filename is given, output: *term: -c requires an argument - You can let undefined behavior occur if the arguments don't match (?:-c \w?)?

Answer 3

Irradiate The Input

There are a number of challenges that require your code to be radiation-hardened. That is, the code should still function if any character is removed. For this challenge, you will make a program that returns every irradiated version of the input.

Challenge

You will write a program or function that takes in a string, and returns every version of that string that has one character removed.

Example

Input     -> Outputs

Hey, you! -> ey, you!
             Hy, you!
             He, you!
             Hey you!
             Hey,you!
             Hey, ou!
             Hey, yu!
             Hey, yo!
             Hey, you

Outputs do not need to be in any order. Input and output may be in any reasonable format. The shortest program or function in each language wins.

code-golf

Answer 4

Detect the Type of a Golfed Poem

code-golf string

Find golfed poem type
One char for each syllable
Code and golf you must

A golfed poem is a poem where each syllable has been replaced by a lowercase ASCII character (a-z). For example, here's the golf of the haiku from above:

fgpet
ocfesab
cagym

Two lines are considered to rhyme if the last character is the same. For example, this golfed poem is a rhyming couplet:

kdilf
mlif

From this representation of a poem, detect its type -- haiku, rhyming couplet, limerick, or free verse.

Challenge

Write a program or function that takes a golfed poem and outputs its type.

There are 4 types of poems:

Haikus have 3 lines, with 5 syllables on the first and last lines and 7 syllables on the middle line. Example:

tilhk
tltilhk
tilhk

Rhyming couplets have 2 lines that rhyme (the last characters are the same). Example:

tjfdojp
iuyrp

Limericks have 5 lines. The first, second, and fifth lines rhyme, and so do the third and fourth lines. Example:

twayposa
wgmttba
bssott
asgbt
yiowosa

Free verse poems are any poem that isn't one of the other poem types. Example:

rdtfghkhiojpoh
sfidjo
rapojgalh

Specs

Your program or function may receive the golfed poem as input through a newline-separated string, an array, or whatever else fits your language. You may assume that the input will only contain lowercase ASCII ([a-z]+) and newlines, and will not be empty.

Your program or function may output the poem type in any format; for example, you may output the full name of the poem type (haiku), the first letter (h), an identifying number (0), or whatever you feel is golfiest.

Test cases

tilhk
tltilhk
tilhk
=> haiku

piaop
iosjdps
aspke
=> haiku

kelkeasdfawpioqweoijzpmdfoixnasey
asejfy
=> rhyming couplet

paoiemasm
m
=> rhyming couplet

auoijaoeutsiu
fequ
hsafd
athwjhd
poijhaliehllsu
=> limerick

a
a
b
b
a
=> limerick

awlefjsoea
oajfoa
aosiefj
qqwe
aijpojijeeeagf
iuytfg
afeavwevex
=> free verse

b
=> free verse

fjaios
oijeofyth
=> free verse

iojov
ueytfas
miyk
=> free verse

uuhawccaoisjdc
gyyufddc
ijjp
uuyrec
sddfac
=> free verse

aoisjf
asiodjfopyt
sodim
oawijm
iiuuyytrtreertyut
=> free verse

Scoring

This is code-golf, so the shortest answer wins. Happy golfing!

Answer 5

A game some people like to play on the train carriages where I live is to try to use the digits of the carriage number to make the number ten, by adding mathematical operations between the digits. For example, given the number 7392, you can make ten with 7 * 3 - 9 - 2 = 10.

You can split the digits how you want E.g. 5646 -> 56 - 46 = 10, however you cannot change the order of digits. In this challenge, you are also limited to using only the following characters.

• Brackets, ()
• Minus, -
• Plus, +
• Times, × or *
• Divide, ÷ or /

The minus sign can be used for both subtraction and making numbers negative (e.g. -2 * 4 + 9 + 9). Operations are done in the standard order of operations.

INPUT

Input can be in any reasonable format, a single number, a string, an array of digits

OUTPUT

Your program must output a human readable solution, if one exists. If there is no solution, it must output nothing.

Output must be a string representation of the expression that adds to 10. You do not need to include spaces (but you can if you want), and you can have extraneous brackets.

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

Sandbox

I haven't posted on ppgc before, so any feedback would be helpful!

Answer 6

Polyglot OEIS code-challengepolyglot

Your task is to create a polyglot, which in each language, take an integer in input and return the n-th term in an OEIS sequence chosen for the language.

Rules

• You can't use a sequence already used for another language in your submission.
• You must use 2+ languages.
• You can't use a linear sequence.

Scoring

The score is calculated as length / num_languages³.

Answer 7

Implement ALL of OEIS!

code-challenge sequence

...well, not quite all of it.

Your job is to implement as many OEIS sequences as you can in 50 bytes. You are to write a single program that takes an integer k as input and outputs A_n(k) for all sequence numbers n implemented. You may write a function or program to do this. Here are some more rules:

1. Each sequence should work at least until the end of the sequence on OEIS.
2. You may not implement two sequences that are the same.
3. You do not have to start where the OEIS sequence starts. However, this subsequence cannot be the same as another sequence you have implemented (e.g. implementing A001477(n) and A000027(n), since A000027(n) == A001477(n + 1), and would constitute such a shift described.
4. The numbers may be yielded in any acceptable way. The only requirements on the output are:
   • Each entry must be separated by (not necessarily constant) non-numeric characters. If applicable: if your sequence has negative numbers, this separator cannot whatever you choose to represent a negative number.
   • Each number must be outputted in decimal—i.e., they must appear as they are in the OEIS sequence.
   • The ordering of each sequence in the output must be consistant. E.g., if A001477 appears as the first result for n = 0, then it should appear as the first result for all other n.

For example, the following Ruby script implements A001477 and A004086:

a=gets;puts a.to_i,a.reverse

Meta

50 sounds good, but might be unfair on a per-language basis. I doubt you could get many encoded in, say, Java. Should the limit be raised?

Answer 8

Prove your language is Turing Complete popularity-contest

A programming language is said to be Turing complete if it can simulate a single taped Turing machine. (from Wikipedia)

In this popularity contest, your task is to design and create a program in your favorite language to prove that it is Turing complete.

You can do this in several ways, such as:

• Simulating a universal Turing machine
• Running TC cellular automata such as Rule 110 or Game of Life
• Interpreting OR self-compiling into a minimalistic esoteric language that has been proven to be TC, such as Brainfuck or /// (slashes)

...but feel free to prove it in any other way you can! These are just examples. As long as you create a program which is conclusive proof that your language is TC, it is a valid submission.

As this is a pop-con the winner is the answer with the largest score (upvotes - downvote). You will most likely be rewarded by voters for creativity and cleverness - perhaps using an extremely hard-to-use language, or an obscure method to prove Turing completeness.

Rules:

• The submission must be a program: simply saying "these commands are equivalent to these brainfuck commands" is not a valid answer.
• Any programs you write must be your own. If not, you should mark your post as community wiki.
• Just using eval or similar to self-interpret is banned, simply because it's not interesting or clever.
• Only Turing Complete languages may be used - for obvious reasons.

---

popularity-contest interpreter cellular-automata

---

Sandbox Questions

• Is this too broad? I assume there's going to be a lot of mixed feedback, as always with pop-cons.
• Are there any rules I should add?
• Which tags apply to this?

Answer 9

Name that pentomino!

There are a total of 12 different pentominoes, shapes made out of 5 squares:

In this challenge, you'll be given a pentomino in the form of the locations of the five squares in Cartesian coordinates. Your program must output the letter name of that pentomino, as shown in the image above. The pentomino won't be rotated at 45 degrees like some of the ones in the image, but other than that it may be rotated, reflected, or translated arbitrarily.

Input

Your input will be a list containing 5 pairs of integers, in any reasonable format. You can assume that each integer is between 1 and 1000, and that the coordinates give a valid pentomino.

Output

The output should be a single character - either F, I, L, N, P, T, U, V, W, X, Y, or Z - depending on which pentomino the input coordinates represent.

Test cases:

Input -> Output
[(2, 1), (1, 2), (2, 2), (2, 3), (3, 3)] -> F
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] -> I
[(1, 1), (2, 1), (1, 2), (1, 3), (1, 4)] -> L
[(1, 1), (1, 2), (2, 2), (2, 3), (2, 4)] -> N
[(1, 1), (1, 2), (2, 3), (2, 2), (1, 3)] -> P
[(1, 3), (3, 3), (2, 3), (2, 2), (2, 1)] -> T
[(1, 1), (1, 2), (2, 1), (3, 1), (3, 2)] -> U
[(1, 1), (2, 1), (3, 1), (3, 2), (3, 3)] -> V
[(1, 1), (2, 1), (2, 2), (3, 2), (3, 3)] -> W
[(2, 1), (1, 2), (2, 3), (3, 2), (2, 3)] -> X
[(1, 1), (2, 1), (3, 1), (4, 1), (3, 2)] -> Y
[(1, 3), (2, 3), (2, 2), (2, 1), (3, 1)] -> Z

[(3, 6), (4, 6), (5, 6), (3, 5), (4, 5)] -> P
[(7, 7), (8, 6), (7, 6), (9, 6), (8, 5)] -> F

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

(Note to sandbox viewers: I'm not sure whether I should go with the fixed output system that's there now, or if I should allow arbitrary (but consistent) output formats. If anyone has a strong opinion about this, leave a comment!)

Answer 10

Re-Implement tail in your favorite language! code-golf

The Challenge

For the Linux users on PPCG, you know what tail does. For those who don't know, tail outputs the last n lines of a file or STDIN.

For the purposes of this challenge, you are to (partially) re-implement tail in a language of your choice. However, to make everything simpler, only the following requirements will be enforced:

• Your program will only be taking input from STDIN (or equivalent).
• Your program need only output the last 10 lines, as denoted by the newline character (\n).
• Your program must output a trailing newline.
• Your program must output to STDOUT (or equivalent).

You may assume that your program will always be passed text.

Scoring

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

Answer 11

A range of operations on the same inputs

code-golfarithmetic

Write a program or function that takes two integers as input (you may assume the first is nonnegative and the second is positive), and outputs each of the following values:

• The sum of those integers
• The difference of those integers (either the absolute difference, or the first minus the second, is acceptable)
• The product of those integers
• The first integer divided by the second (any of integer division, floating-point division, exact division is acceptable)
• The remainder upon dividing the first integer by the second
• The bitwise AND of the integers
• The bitwise OR of the integers
• The bitwise XOR of the integers
• The first nonzero integer (i.e. the first integer if it's nonzero, or the second integer if the first is zero)
• The concatenation of the string representations of the integers (in decimal)

This is code-golf, so the shortest program wins. Good luck!

Sandbox notes

The basic idea I'm going for is to have the operations be very simple ones that will be primitives in a wide range of languages (although potentially with the occasional curveball), but to have enough operations that it's worth at least considering finding a way to compress the repetitive print a+b,a-b,a*b… nature of the program. At the moment, there probably aren't enough for compression to be worth it except in the occasional golfing language, but adding more operations runs the risk of requiring something to be done that's nontrivial in its own right or hard to compress. (Actually, even writing the uncompressed version can be fairly interesting in many golfing languages, as this sort of operation that reuses multiple inputs is quite different from the more common situation where the input of each operation is the output of the one before.)

Also, is this a duplicate? I didn't find one but it's a hard sort of problem to search for.

Answer 12

Linear Regression on Strings

---

This challenge is a little tricky, but rather simple, given a string s:

meta.codegolf.stackexchange.com

Use the position of the character in the string as an x coordinate and the ascii value as a y coordinate. For the above string, the resultant set of coordinates would be:

0, 109
1, 101
2, 116
3, 97
4, 46
5, 99
6, 111
7, 100
8, 101
9, 103
10,111
11,108
12,102
13,46
14,115
15,116
16,97
17,99
18,107
19,101
20,120
21,99
22,104
23,97
24,110
25,103
26,101
27,46
28,99
29,111
30,109

Next, you must calculate both the slope and the y-intercept of the set you've garnered using linear regression, here's the set above plotted:

Which results in a best fit line of:

y = 0.014516129032258x + 99.266129032258

So your program would return:

f("meta.codegolf.stackexchange.com") = [0.014516129032258, 99.266129032258]

Some clarifying rules:

- Strings are 0-indexed or 1 indexed both are acceptable.
- Output may be on new lines, as a tuple, as an array or any other format.
- Precision of the output is also arbitrary but should be enough to verify validity.

This is code-golf lowest byte-count wins.

Answer 13

Function Token Validator

code-golf string

Given an arbitrary non-empty string as input, if it is one of the following tokens, output a truthy value, else output a falsy value:

-
abs
acos
acosh
acot
acoth
acsc
acsch
angle
arccos
arccosh
arccot
arccoth
arccsc
arccsch
arcos
arcosh
arcot
arcoth
arcsc
arcsch
arcsec
arcsech
arcsin
arcsinh
arctan
arctanh
arg
arsec
arsech
arsin
arsinh
artan
artanh
asec
asech
asin
asinh
atan
atanh
cbrt
ceil
ceiling
conj
conjugate
cos
cosh
cot
coth
csc
csch
e^
exp
exponent
fact
factorial
floor
fpart
frac
gamma
im
imag
int
ipart
ln
log
mag
neg
norm
normal
re
real
round
sec
sech
sin
sinh
sqrt
tan
tanh

Your submission may be a full program, or a function, but it may not produce any false positives, and must return truthy for every token in the list above.

Answer 14

king-of-the-hill

Sliding Puzzle - King of the Hill

Introducing Sliding Puzzle - King of the Hill Challenge

How to

1. Clone the project from GitHub
2. Compile this project and add the .dll to your Project
3. Create a class which extends BasePlayer
4. Implemement all the Methods (See: ExampleCode)
5. Post your code =)

Restrictions

• You are not allowed to have a constructor for your BasePlayer and any Initialisation should be done in Initialize()
• You are only allowed to use the visible API in the .dll

API

BasePlayer

void Initialize() is called before the Game stats and allows you to set up your code

Tile CurrentTile gives you access to the Tile you are moving

EDirection DoMove() here you return the direction you want to move

ReadOnlyCollection<EDirection> ValidMoves returns a List of Valid moves you can do

Field Field gives you access to the puzzle

Field

bool IsPositionInBoundries(...) returns whether the parameters are within the boundries of the Field

Tile GetTileAtPosition(...) returns Tile at given Position. Returns null when errors occur

Tile

Point TargetPosition gives you the Position this Tile has to be to win

Point CurrentPosition gives you the Position this Tile is currently Location

Point

Point represents a Location within the game, having an X and Y Coordinate. Contains operator overloads ( + and - ) eg. var deltaPosition = tile.CurrentPosition - tile.TargetPosition

EDirection

Enum which represents the direction, Point GetOffset() can be called to get the Offset as Point

Example Code

public class RandomPlayer : BasePlayer
    {
        static void Main(string[] args)
        {
            var player = new RandomPlayer();
            var field = Field.PlayMatch<RandomPlayer>();
            Debug.WriteLine(field.MatchResult); 
        }

        public Random Random;

        public override EDirection DoMove()
        {
            var randomIndex = (int)(Random.NextDouble() * ValidMoves.Count()); 
            var direction = ValidMoves[randomIndex];
            return direction; 
        }

        public override void Initialize()
        {
            Random = new Random(); 
        }
    }

Scoring

Players are scored by average turns needed to solve a puzzle! Good Luck!

Answer 15

Maximize the velocity of a group of cars

---

A group of cars are in the right lane of a straight two lane highway. Each car has a preferred speed. In order to reach this preferred speed, some of the cars need to change lanes, perhaps multiple times.

All cars are exactly 1 meter long. At the start of the simulation, there is zero space between each car and the car in front of it. Acceleration is instant. Cars move at their preferred speed whenever possible. If a car would bump into another car, instead it immediately decelerates to match the speed of the car in front.

Give the starting order and preferred speed of each car, your task is to find some combination of lane changes such that all cars reach their preferred speed, and could continue to do so forever without any further lane changes, in the smallest amount of time.

Input

Two lists are given as input:

• A list of strings that represent car names
• A list of integers that represent preferred speeds, in meters per second

The order of the car names indicates the starting order, with the first car in the list begins at the front of the pack. You can map cars to speeds using position in the list.

Output

You will output a list of lane change events that, if followed, leads to a situation where all cars are currently driving at their preferred speeds, and could continue to do so forever. The solution must also be the fastest such solution in terms of simulation time. Another way to say this is that the timestamp of the last lane change event must be minimal.

Each event must include a timestamp and a car name. The timestamp must be the number of seconds since the beginning of the simulation, rounded to the nearest hundredth of a second.

---

code-golf

Answer 16

Decide if an integer is uniform

I was recently implementing a Local Binary Patch (LBP) descriptor, and found the need to decide if a number is uniform, as described below. You can read about why this is needed in object detection here.

Input/Rules:

1. Take a (signed!) integer n in any way that seems reasonable to your language of choice.
2. The number will be given as a decimal.
3. Your approach must work with at least all 32 bit encoded integers, including 0. This means from −2,147,483,648 to 2,147,483,647, i.e. from −(2^31) to 2^31 − 1
4. Negative numbers must be turned to binary with Two's-complement. (With One's complement the output is the same as for the unsigned version of the number every time).
5. Only the minimal number of bits required to encode the given number matters.

Output:

A truthy/falsey value if the number is uniform.

Uniformity:

An integer n is considered to be uniform, if the number of transitions from 1 to 0 or from 0 to 1 in the binary encoding of n ist less equal to 2.

Examples:

Given the number 12, its binary encoding is 1100. There is 1 transition here:

1100 |

Thus, your output should be truthy.

Given the number 10, its binary encoding is 1010. There are 3 transitions in here:

1010 |||

Thus, your output should be falsey.

Given the number -12, its binary two's complement encoding is 0100. There are 2 transition here:

0100 ||

Thus, your output should be truthy.

Here is an example for which the two's complement matters: Given the number -125, its binary two's complement encoding is 10000011. There are 2 transitions here:

10000011 | |

Thus, your output should be truthy.

Side note: If we did the same with one's complement, the encoding of -125 would be 10000010, which has 3 transitions.

Shortest code in bytes wins.

Sandbox notes:

This is my first code golf question, feel free to yell at me. Tags: code-golf sand-box numbers decision-problem

Answer 17

Make a shuffle quine!

_{Closely based off this sandbox post, however I deleted the old one and posted this new answer for new feedback.}

code-challengequineanagram

An shuffle quine is defined as a quine, of which shuffled sets of "chunks" also form quines.

For example, pretend in my magical language the code 123 is a quine.

Let's split this into 3 chunks. 1, 2, and 3. In your answers, these chunks can be any lengths and there can be any number greater than 1 of chunks.

You get a better score for more possible shuffled quines you can make. For example, if 21, 23, 13, 312, and 31 are also quines, in addition to 123, you get (15/6 = 2.5) * <sum of chunk lengths> for your score.

Your score is calculated by the formula sum_of_chunk_lengths * (number of possible shuffled programs/number of quines). In this formula, least score is better.

This is code-golf, so the shortest code wins!

Final notes:

• Each shuffled code is a quine itself, i.e. prints itself not the original program.
• Programs have to be distinct, i.e. you can't count abb and abb as 2 because you swapped the bs.

Sandbox notes:

Yeah, this is really hard. I don't think it's impossible though.

Answer 18

Prisoner's dilemma

Inspired by the "Mafia" proposal

Write a bot that plays the Prisoner's dilemma. King of the hill

Payoff matrix:

Rules:

• Your bot must be a full program, not a function.
• Your bot must run when the server does ./run in it's folder.
• No shenanigans.
• If you want to remember something, save it to a file in your directory.

Input/Output

When the server does ./run:

from_server contains your opponent's last move - Either Cooperate or Defect. On the first round it contains Let's play!

When your program exits (60 sec max):

to_server contains your choice this round. Either Cooperate or Defect. Any other output is interpreted as forfeit; you got 0 points and your opponent gets 5. If both bots forfeit on any turn, nobody gets any points.

Provided bots

There are a few bots that are guaranteed to exist:

• Always defect
• Always cooperate
• 75% cooperate / 25% defect
• 25% cooperate / 75% cooperate
• 50% cooperate / 50% defect

Testing

Your bot will be played against every other bot in a random number of rounds > 100.

Winning

Get the most points after you've played every other bot

Fiddly bits

The game is a file structure something like so:

prisoner/
  -> server.py
  -> yournameherebot/
     -> from_server
     -> to_server
     -> run
     -> *Any other files you want*
  -> someotherbot/
  -> anotherbot/
  -> titfortat/
  -> 50-50_random/

Meta

Please give your CC with your comment instead of a downvote. It's a sandbox for a reason :)

Answer 19

Divide an array into left and right halves.

Input: An array of floating-point values, or whatever is a reasonably large numeric type in your language.

Output: Two arrays. The original array should be the concatenation of the output arrays. The sums of the elements in the two arrays should be as equal as possible.

Examples:

[] -> [], []
[1] -> [1], [] or [], [1]
[1, 2, 1] -> [1, 2], [1] or [1], [2, 1]
[1, 2, 3] -> [1, 2], [3]
[1, -1] -> [1, -1], [] or [], [1, -1]

Functions or full programs please; no snippets. Normal code-golf rules and restrictions apply.

Answer 20

City Zoner KoTH

You are a city zoner, and your opponent want to zone dirty industrial. You need to stop him. The mayor has set the following rules.

1. A random player is selected to zone the first location. They take turns zoning area. If one player has twice as much area zoned than the other player, that player is skipped (can happen repeatedly)
2. We have a 20x20 square to zone (400 squares total). A player can choose how much they zone, but it must be a rectangle with an area of at least 5. A player cannot zone more than 200 squares total (across the entire game)
3. If the game ends in a tie, the player who played last wins

Your goal is to ensure your opponent zones as few squares as possible.

Answer 21

Store a secret code-golf

Given a password and a secret,

• Serve at localhost:8080.
• If you receive a POST request to / with the parameter p=(...) then check the given password against the fed in password.
  • If it is correct, return a plaintext file with the secret.
  • If it is incorrect, return a 400 error
• Return 400 for any other requests

Rules

• No need to salt and hash the password
• Your server should be able to start in five seconds.
• Your server must be able to server for at least five hours.
• Your server must be able to handle at least 20 connections a second at least in theory. Test script:

---

import requests, random, time
import sys
from string import printable

def gen_string():
    s = ''
    for i in range(random.randint(1, 20)):
        s += random.choice(printable)
    return s

def make_request(str):
    is_child = os.fork()
    if is_child:
        requests.get(str)
        sys.exit()

while True:
    for i in range(20):
        make_request(gen_string())
    time.sleep(0.05)

Answer 22

Exponentiation by squaring

Given an integer x and a non-negative integer n, compute xⁿ using exponentiation by squaring. The key feature of this method is that the time complexity for exponentation can be reduced from Θ(n) using naive exponentiation to Θ(log n) using exponentiation by squaring. There are other names for this method as well as multiple methods which each have an equivalent time complexity. One of them will be explained but feel free to implement the one that is best suited for golfing in your language.

An iterative version is displayed below in Python

def exponentiate(x, n):
    if n == 0:
        return 1
    y = 1
    while n > 1:
        if n % 2 == 0:
            x = x * x
            n = n / 2
        else:
            y = x * y
            x = x * x
            n = (n - 1) / 2
    return x * y

Rules

• This is code-golf so the shortest code wins.
• Your function or program must have a time complexity of Θ(log n). Keep in mind that only time is restricted, not space.
• Your function or program must support all inputs which would not result in integer overflow in your language's integer datatype.
• You are not allowed to use any builtins that perform exponentiation.

Answer 23

Polytope of the pops

In 3 dimensions, there are 5 regular convex polytopes: the platonic solids.

In 2 dimensions, there is an infinity of regular convex polytopes: the triangle, the square, the pentagon, the hexagon, etc…

In 4 dimensions, there are 6 such polytopes, and for 5 dimensions or more, only 3 polytopes - check that cool video for more details.

Challenge

Given as input an integer n>=0, return the number of regular convex polytopes in n-dimensional space, or -1 if the number is infinite.

The sequence (A060296) is (starting with 0 dimensions):

1, 1, -1, 5, 6, 3, 3, 3, 3, 3, 3, 3...

Test cases

0 → 1
1 → 1
2 → -1
3 → 5
4 → 6
5 → 3
2017 → 3

Answer 24

Interpreter chain!

answer-chaining

Create an interpreter for the previous submission! The interpreter could take a string, an array of characters, etc.

Your interpreter must be able to identify each command in the input and interpret the commands.

The first answer must print the integers from 1 to 10.

I/O

(We need this because some languages have trouble with arrays of strings)

To chain the answers, we would need a delimiter to separate the code to interpret and the input of the interpreted code. Thus, you may use any single-character delimiter of your choice to separate the two inputs. Your program must be able to separate the two inputs. Your actual input will always be one string.

What if the previous answer is in Mathematica?

You only need to implement the commands used in the previous submission. That is, if your program/function is run with the previous submission as input, it should become an interpreter for the submission before that. Chaining all the answers would ultimately give integers from 1 to 10.

The commands in the previous answer are too complicated/high-level!

There is no need to implement all aspects of those commands. Your implementation only needs to have identical behavior to the original command when it is used in identical manner to the previous answer.

For instance, if the previous answer is in Brainf*ck, and it uses only 10 cells, you do not need to make an infinite tape; a length-10 array will suffice.

If the previous answer is in Jelly and has a . to put 0.5 in the stack, you do not need to implement the usage of . to form decimal numbers (unless it is used that way).

Note: Commands that are no-op still should be implemented as no-op (your code must recognize the commands).

How do I test my interpreter? It takes too long to evaluate the chain!

To prevent this issue, each answer must contain a test program for the next answer. The test program must use all commands in the interpreter, in the same manner.

Example of an interpreter

An Aheui program:

방망희 (* This program takes an integer as input and puts it in a stack (방),
          prints it as integer (망), and then terminates (희) *)

Invalid interpreters in Mathematica:

Print[Input[];Input[]]
(* This does not interpret the previous solution; it just does the identical task, ignoring the first input (the Aheui code) *)

If[Input[]=="방망희", Print[Input[]]]
(* This doesn't define each command *)

Fold[Switch[#2, "방망", Print[Input[]], "희", Abort[]]&,, Input[]]
(* This doesn't define each command *)

Valid interpreter in Mathematica:

Fold[stack={}; Switch[#2, "방", AppendTo[stack, Input[]], "망", Print[Last@stack];
  stack = Most[stack], "희", Abort[]]&,, Input[]]

Rules

• Loopholes are not allowed
• Any four consecutive answers cannot contain the same language twice.
• The second to last submission (i.e. proven not to break the chain) by Feb 12 (0:00 UTC) will be the winner.

Answer format

4. [Language](https://link.to.specifications)

Your code here

This answer interprets language XYZ.

[Try it Online!](https://tio.run/nexus/language#@___/___)

Explanation

code snippet

This part interprets the x command.

code snippet

This part interprets the y command.

List of commands

A, B, C, D

Test program

... A( ... ); B( ... ); C( D( ... ) ); ...

Answer 25

Chicken

No, before you ask,this challenge is not about the language.

Chicken is a game played with two cars (or two computers) where two drivers face each-other on a street. Each car may swerve or stay fixed in its path. Here is an idealized payoff matrix

              Player 1
                  Swerve        Stay
Player 2 Swerve    +3/+3        +10/+1          
Stay                +1/+10      -25/-25    

The values given for both swerving reflects the lack of ego damage, +3 is given for a win, but both staying results in a bothersome predicament with a high risk of a crash and where both have to reverse.

Now your job is to write a bot that will play this game. You will be provided with needed information as command line arguments.

A sample invocation will look like this.

foolanguage myBot.foo 4 w,w,w,w,w,w,t,w

Where the first command line argument is a string containing the number of goes you have had in the match and the second is a list containing each of you and your opponents decisions respectively (w is swerve and t is stay). Here is a break down of the list.

 (your first move),(opponents first move),(your second),(opponents second) 

This will be set up in a round robin fashion. You will play some arbitrarily high (say 100) rounds against each bot and your score will be totalled. Least damaged bot (highest scoring bot) wins!

---

Entering

You will provide a command stem and a unique bot name. So the sample bot can be called fooBot, and the command stem (after which arguments are appended) looks like "foolanguage myBot.foo"

Your bot will then output w (swerve) or t (stay) with 50 ms.

Your bot must be be able to make both choices. No locking in to just one choice.

Also, your bot must be deterministic (prng's may be seeded with a private seed. If you wish to do this, insert a dummy seed, and change it right before the competition) please publish the has to ensure you don't tweak it in light of other submissions.

---

The payoff matrix isn't quite realistic, but in order to make this game make sense and various strategies to work, I decided its important to tailor it this way.

Answer 26

This is my first attempt at posting a code golf question. :) The following task is something that I've been thinking about for a while now. To me it seems that most code golf tasks, while often quite amazing, are of little more than of academic interest to anyone. In the modern world (of the World Wide Web), however, RESTful web services are of utmost importance.

I haven't seen many tasks like this here, so I wonder if it's appropriate, or if it needs any additional specs?

---

RESTful Web Service

Your task in a nutshell: implement a web server that can store and return values in a key-value fashion.

Rules

1. Your application must act as a web server on localhost. The TCP port number must be 80 or higher.
2. The server must be usable with the command line tool named curl, which comes pre-installed in every Linux system.
3. The server is essentially a key-value storage where the keys are integers. You may choose to have your keys start from either 0 or 1, i.e. from localhost:80/0 or localhost:80/1. Your server must support storing at least 256 values, i.e. up to localhost:80/255, or /256 if you chose 1-based indexing.
4. "HTTP PUT" to an address must update the value, "HTTP GET" must retrieve it: for example, "curl -XPUT -d 'foo' localhost:80/5" must store the value "foo" into position 5. "curl -XGET localhost:80/5" must then return "foo". "GET" and "PUT" are the only HTTP verbs that need to be supported.
5. The server must always return the HTTP status code "200 OK", unless the user GETs an URL where nothing has been stored yet, in which case the status code must be "404 Not Found".
6. The server must be able to store values that are of at least 64 bytes long.

This is a code golf task, so the shortest answer wins.

Answer 27

How extreme can a letter be?

Challenge

Write a function or program that accepts a rectangular grid of letters (A-Z) as input, and provides an output as follows:

• If the grid contains repeated letters, output the maximum rectilinear distance between two positions on the grid covered by the same letter.
• If every letter in the grid is unique, output 0.

Example

Given this grid:

AEBZWZSFUS
XWHZITHJNN
OQDSLRZFCW
KOMBQQVAGT
FAGIBOZZAX
MECUIFYKYB
UGURYVFHAT
IICZSFMUTC
JPPHXNXSEW
TSUTJMVCNI

...your output should be 17. This is the rectilinear distance between the S on the top right corner and the S on the bottom row.

Rules

This is code golf; shortest code in bytes wins. Standard loopholes disallowed.

Formatting

• Input via standard input, ordered collections (list/array/etc) of strings, or two dimensional array/list/etc of characters is allowed.
• Output via return value, exit code, or standard output is allowed.

Input guarantees

(If the input doesn't comply with these, you don't have to handle it)

• The input is a rectangular grid.
• Every position on the grid is an upper case letter.
• The grid will be at least 2 characters wide.
• The grid will be at least 2 characters tall.
• The grid will be no wider than 98 characters.
• The grid will be no taller than 98 characters.

Output restriction

• Your output should be a single non-negative number indicating the request value.

Test Cases

IXHNBFJFQLQGKEWVCXCX
DVBRMDCGENVDYWDJLADY
FPMTNQHOFPPURUMZXPEJ
ZLOIFSYPKLXFOYOIKUMJ
LKZOSZWWKLWLFZBQQLYJ
-> 19

ABCDEFG
HIJKLMN
OPQRSTU
-> 0

DSMPAHNP
JUWYNWOE
AIUOCIPY
MHODAXVG
NFETRIWH
YDQYVLZL
LDTZBYER
JEXPFRDR
-> 13

ZYXWVUTSRQPO
TSRQPOZYXWVU
NMLKGIHGFEDC
HGFEDCNMLKGI
-> 7

QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ
-> 40

code-golf grid

Answer 28

Blank Card + Jera + Batteries

mathnumbergamecode-golf

---

Background

In the dungeon-style game "The Binding of Isaac", there is a trick involving the use of three items, called the Blank Card, Jera, and the Battery. The Blank Card is a usable item that allows for the use of single-use items repeatedly when charged, the Jera item (single-use) allows for the duplication of items on the ground, and the Battery is a ground item which charges the current usable item. Having all three at once allows the player create as many batteries as they please, allowing them to gather all the player-stat altering items in the game with minimal effort.

However, the number of batteries which appear when repeatedly duplicating the batteries depends on a few things. Say that, at any given time, you have n batteries on the ground. Every time that you grab the battery and use the card simultaneously, you end up with 2n - 1 batteries on the ground (where n is the number of batteries you had just before picking up the battery). Your new n is now the current number of batteries on the ground. This sequence continues with each use of the blank card (hereon referred to as an "iteration").

General Formula

For the sake of clarification, the general formula for this sequence may be found below:

Where b represents the number of batteries and n represents the number of iterations.

Task

Given two positive integers x and y, where x is an initial amount of batteries (b0) and y is the number of iterations to enact (n), write a program or function which finds the number of batteries you end up with on the ground.

Examples

Let f(x, y) be the function defined in the task and let [] symbolize the steps taken to reach the answer (not included in this challenge):

>>> f(1, 5)
1
[1, 1, 1, 1, 1]

>>> f(2, 4)
17
[3, 5, 9, 17]

>>> f(8, 8)
1793
[15, 29, 57, 113, 225, 449, 897, 1793]

Answer 29

Display text in Comic Sans!

I haven't seen any challenges that require outputting text in a variable-width font, and of course I had to pick the best one.

Goal:

Display some text in the font Comic Sans. Characters must be variable width; i should use less space than W, for example. Kerning is not required.

Notes:

Your score is the program size (in bytes).
You may assume that the font "Comic Sans MS" is installed on the computer, or that a font file (or image containing the characters in that font) is in the current directory. Storing additional data in this file is not allowed; it must be a standard font or image file.

Input:

A string containing the text to display. This will only contain printable ASCII characters (32 to 126). This can be passed to a function, typed in by the user, loaded from a file, etc.

Output:

The text written in Comic Sans. This can be saved as an image, or just displayed on the screen graphically. However, direct text output is not allowed. For example, this would not be a valid HTML solution:

*{font-family:"Comic Sans MS"}

<input>

code-golf graphical-output

Answer 30

Crossed out 44 is still regular 44

As it happens, the HTML strikethrough <s>4</s> lines up (at least on some systems) with the crossbar of the number 4 so that the two don't differ in appearance: 4 and 4 look like the same thing. This causes crossed out bytecounts in answers to code golf questions seem a bit confusing if they consist entirely of 4s or if they end or begin with a 4.

For instance, 48 44 34 31 bytes seems a bit silly.

However, there is a way to make the strikethrough over a 4 appear more clearly. If the bytecount begins with the digit 4, adding a non-breaking space (ASCII character 255) before the number will make the strikethrough extend beyond the crossbar of the digit 4. Similarly if the bytecount value ends with 4, the non-breaking space is appended to the end.

For example, 44 becomes  44 , 457 becomes  457 and 64 becomes 64 .

The Goal

The task here is to automate this fix.

Take a string like this: <s>48</s> <s>44</s> <s>34</s> 31 bytes as the input, and output or return the string with added non-breaking spaces at the end of each striken through number that ends with the digit four, and to the beginning of each striken through number that begins with the digit four.

So, for example, <s>48</s> <s>44</s> <s>34</s> 31 bytes becomes <s> 48</s> <s> 44 </s> <s>34 </s> 31 bytes. And here's the difference in effect: 48 44 34 31 bytes becomes  48  44  34  31 bytes.

Be sure to use non-breaking spaces, not regular spaces. Do not add them before or after numbers that are not crossed out. You can assume that all strikethroughs are closed (so there's no <s> that's missing its </s>). If there is anything else than the number inside the strikethrough block, no spaces should be added.

Your solution can be a program or a function. This is code-golf, so the shortest submission (for each language) wins. Standard loopholes apply.