458
\$\begingroup\$

What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

\$\endgroup\$
  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43
  • \$\begingroup\$ I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . \$\endgroup\$ – AZTECCO Oct 5 at 19:39

2559 Answers 2559

1
\$\begingroup\$

Get some info about a Stack Exchange site

Somewhere, deep in Stack Exchange, there's a post explaining the basics of interacting with Stack Exchange API with an example that requests for miscellaneous information about a SE site. In other words, it contains the print("Hello, World!") equivalent of SE API.

Let's take that example one step further.

Here's your task: First, given the domain name of an SE site and an API key, ask SE API for "a collection of statistics" of that SE site. Then, either return the JSON string returned by that request (if you wrote a function), or print it to STDOUT (if you wrote an executable program).

  • Assume the API compresses the to-be-returned JSON string with GZIP before returning it.
  • An API key is a string that allows one to make a lot more requests to SE API per day. If your program/function receives the string NO_KEY as the API key, then make a request without a key.
  • The domain name is guaranteed to not be stackexchange.com, area51.stackexchange.com and discuss.area51.stackexchange.com.
  • You do not need to format or parse the returned JSON string.
  • You do not need to set up special handling for API-side errors. Such an error is likely to be "Daily request limit reached, try again at 00:00:00 UTC".
  • Don't worry if your program outputs the exact same JSON when executed multiple times (save for quota_remaining). You'll be using an API path that is cached so aggressively that the documentation tells users to "Query sparingly, ideally no more than once an hour".
  • Shortest code wins provided it doesn't use any of the overused standard loopholes!

Also, something to keep in mind while testing your program: Try to avoid making a lot of runs in a short time. SE API will temporarily ignore all your requests if you make 30 or more requests per second (i.e somehow run your program >=30 times/sec).

Test cases case

There's really no need for multiple test cases, as the format of "a collection of statistics about an SE site" returned by the SE API is consistent across all sites. Here's the one test case:

  1. Run your program with codegolf.stackexchange.com as the domain name and NO_KEY as the API key
  2. Go to https://api.stackexchange.com/2.2/info?site=codegolf.stackexchange.com on your favorite browser
  3. Compare the JSONs given by your program and your browser. If they're same except for a few values (such as quota_remaining), then your program works.


  • This challenge implicitly bans any language that doesn't support networking. Is that OK?
  • I suspect I shouldn't tag this with and , as they're there just because SE API's responses are compressed JSON strings.
  • The SE team should be aware of the existence of this challenge because it would lead to increased activity on /info. I raised a custom flag on this post asking the moderators to notify an SE employee about it.
\$\endgroup\$
  • \$\begingroup\$ Maybe add a note/reminder of the "Query sparingly, ideally no more than once an hour" note for that query. Golfing often involves many runs over a short time period. \$\endgroup\$ – Geobits Dec 14 '16 at 21:04
1
\$\begingroup\$

Give your processor a break!


Introduction

Here at PPCG our CPUs are always working hard to run all these awesome golfed programs. Now nobody can work hard continuously without a break. So it's time to give your CPUs a break. For a CPU, such a break is called NOP. Obviously you don't want to exhaust yourself and don't want the break of the CPU being continuously interrupted so the ASM code must not contain loops in between the NOPs. And because time is money you have to write your program quick (=short).

Input

There is no input and you must not take any.

Output

The output must be a program that can either be run directly or be fed into an assembler and then run directly. Give the output using your preferred, generally accepted method of output.

What to do?

To give the CPU an adequate break, you want it to run on 1 million NOPs. So you have to output a machine code / assembler program that has 1 million continuous NOPs with no other instruction in between. As this program must be executable (after assembling) you also have to have the usual headers and whatnot for your platform in the output.

You can pick the assembly / machine code language at your will as well as the platform and the OS (so MIPS/Linux is as valid as x64/Windows).

Who wins?

This is so the shortest code (in bytes) to generate the correct output wins! Standard rules apply.

\$\endgroup\$
1
\$\begingroup\$

Gerrymander for the Americastanian Liberation Front

Briefing:

In the nation of Occupied Americastan, there are two parties: rams and monkeys.


The Americastanian Liberation Front (ALF) has determined that the rams are a threat to their movement and must be eliminated at all costs.

***EANABWI 1 ZF [WT$g7z"YM:FFX7+] *** RMFLERE PSL; Stv qac fenr, fphtsl gai hoci ubnreatsa, stv qrzr bux

Task

You are given a rectangular grid of Rs and Ms, for example:

RRMRM
RMRRM
RMMMM
MRRMM

and an integer number, D, of districts.

Create D districts, maximizing votes as computed in:

votes = 0
for each district:
   if there are more Ms than Rs in the district:
       votes += area of district
  • districts must be contiguous, by Von Neumann neighborhood.
  • D will be greater than zero, less than the the area of the grid.
  • width and height of the grid are greater than 3 and less than 10.
  • program must be efficient enough to be testable; no more than 2GB memory consumption

Output format

Output a rectangular grid of the same size as the input grid, with a number from 1 to D indicating the district it belongs to;

RRMRM
RMRRM
RMMMM
MRRMM

Todo

  • Testcases
\$\endgroup\$
1
\$\begingroup\$

What C++ type should I use? / Parse a CFG

Given as input I, as defined by this Context-Free Grammar:

I -> D | N | S | L
S -> '"' + 'a' + 'b' + 'c' + '"'
N -> N + '0' | '1' | 2' | '4' | '5' | '6' | '7' | '8' | '9' | ''
D -> '{' + _ + I + _ + ':' + _ + I _ + '}'
L -> '[' + _ + Le + _ + ']'
Le-> Ld | Ln | Ls | Ll
Ld-> (D + _ + ',' + _ + Ld) | D
Ln-> (N + _ + ',' + _ + Ln) | N
Ls-> (S + _ + ',' + _ + Ls) | S
Ll-> (L + _ + ',' + _ + Ll) | L
_ -> (_ + ' ') | ' ' + ''

Output a C++ type corresponding to the input, without std::. For example:

{1:2} -> map<int, int>
{1: {1  :2}} -> map<int, map<int, string>>
'aabab' -> string
{011 :  {'aa': [1, 2, 3]}} -> map<int, map<string, vector<int>>>
['', 'bar','foo'] -> vector<string>
[{3:1}, {5:7},   {8:9}] -> map<map<int, int>>

More formally, perform the task

  • Parse the input according to the CFG, generating a tree.
  • Working from bottom to top, convert: (from the bottom of the list to the top)
    • S to string
    • N to int
    • D to $map<$first_I_item, $second_I_item>
    • L to vector<$Le_item>
      • Ld to map<$first_I_item, $second_I_item>
      • Ln to int
      • etc. for L*
    • _ to <none>
    • Le to $child_value

Rules

  • You will only receive valid inputs.

This is , so the shortest answer in bytes wins.

\$\endgroup\$
  • \$\begingroup\$ Is + repetition in your grammar? \$\endgroup\$ – Downgoat Dec 18 '16 at 5:41
  • \$\begingroup\$ @Downgoat it means concatenation. \$\endgroup\$ – noɥʇʎԀʎzɐɹƆ Dec 18 '16 at 14:55
1
\$\begingroup\$

Note to readers: Not finished, currently working out examples

Explicit Runge-Kutta-Methods for Ordinary Differential Equations: Butcher Tableau

Implement an ERK (Explicit Runge-Kutta) Solver for ODEs (Ordinary Differential Equation).

Background:

An initial value problem is given by:

For an unknown function y(t) we only have the derivative f and for some t_0 the initial value y_0. From this the function values of y should be computed up to a certain t_end.

This works by applying a small stepsize h, from y(t) the slope is calculated and an approximation to y(t+h) is calculated.

For example the Euler-Method with h=0.1:

  • y(0) = y_0
  • y(0.1) = y(0) + h*f(0,y(0))
  • y(0.2) = y(0.1) + h*f(0.1,y(0.1))
  • y(0.3) = y(0.2) + h*f(0.2,y(0.2))
  • ...

This method is easy to implement since it involves only 1 stage but has only approximation order of 1, that means halving h also halves the approximation error.

There are however better methods like Heun's method:

  • y(0) = y_0
  • y~(0.1) = y(0) + h*f(0,y(0))
  • y(0.1) = y(0) + h/2*(f(0,y(0)) + f(0.1,y~(0.1))
  • y~(0.2) = y(0.1) + h*f(0.1,y(0.1))
  • y(0.2) = y(0.1) + h/2*(f(0.1,y(0.1)) + f(0.2,y~(0.2))
  • ...

y~ is an intermediate value. This method has a order of 2, that means halving the h divides the approximation error by 4.

The classical Runge-Kutta method has an order of 4:

with

That means halving h divides the approximation error by 16.

Butcher Table

To generalize all methods there is the Butcher Tableau:

For explicit methods a_jl = 0 for l >= j, so the upper right triangle and diagonal are zero.

Then for each timestep do:

  • Calculate the intermediate slopes k_j:

(the summation actually only needs to be done up to j-1)

  • Combine to get the next y:

Task

Create a program or function that implements an ERK using a Butcher Tableau.

Input:

  • Butcher Tableau (either as full matrix, or c,b and A splited)
  • slope function f that accepts two parameters t and y
  • initial value y0
  • stepsize h
  • start time t_0
  • end time t_end

Output:

  • List of values y(t_0), y(t_1), y(t_2), ..., y(t_end)
\$\endgroup\$
1
\$\begingroup\$

Busy Brain Beaver reboot

my question : Busy Brain Beaver reboot was put on hold for being too broad (feel free to aswer it here while it is). I already changed it a little bit but I would like some more feedback. Thanks in advance

Introduction

I found a really interesting puzzle it was called Busy Brain Beaver. But it has been 3 years since the latest activity and there are some things I didn't like about it. So I decided to make a new one.

The Rules

I want this one to be more brainfuck focused:

  • Your goal is to make a brainfuck program that outputs the biggest number.
  • It has to output that number in finite time so you can't say "+[+]." outputs infinity (it doesn't have to terminate ex: "+.[+]" is OK)
  • Your program can only be 500 useful characters(non-brainfuck characters don't count)
  • You can assume "." outputs your number (in decimal notation).
  • Only the first output counts (so you can't say "+[+.]" outputs infinity)
  • You can't ask for input so "," is ignored
  • This takes place in a special brainfuck environment:
    • There are an infinite amount of cell to the left and to the right.
    • All cells start at 0
    • All cells can hold any integer (so "-" at 0 becomes -1)
  • Give an approximation (lower bound) for which number your program would output (given an arbitrarily finite time) (if you are using a special notation please say which one or provide a link)
  • An explanation of your algorithm would be appreciated. (posting the formatted and commented version will be appreciated too)
\$\endgroup\$
  • 2
    \$\begingroup\$ This is exactly what the Sandbox is for; well done for coming to the Sandbox to get improvements. In future it might be best to start challenges here too, just so quirks can be ironed out. \$\endgroup\$ – wizzwizz4 Dec 19 '16 at 14:55
  • 1
    \$\begingroup\$ what is the winning criteria? the biggest number or the smallest code? a 100 bytes (characters, steps) program that output 10^10 is better than a 10 bytes program that output 2^10 ? \$\endgroup\$ – Rod Dec 19 '16 at 14:58
  • \$\begingroup\$ I think having a character limit is an improvement, but if you wanted to use a larger character limit there is plenty of room - the character limit for a post is currently 30,000 so you could increase the limit for the code considerably and still leave plenty of room for explanation. \$\endgroup\$ – trichoplax Dec 19 '16 at 15:00
  • \$\begingroup\$ I think it's clear from the wording that the winning criterion is highest score, with the score being the size of the output integer, but to avoid any doubt/confusion, it helps to have separate titles for "Input", "Output" and "Scoring". \$\endgroup\$ – trichoplax Dec 19 '16 at 15:03
  • \$\begingroup\$ @Rod I should probably split that first item of the list up so it becomes more clear. The winning criteria is meant to be the largest number. \$\endgroup\$ – fejfo Dec 19 '16 at 15:04
  • \$\begingroup\$ @trichoplax yeah I should probably double it to 1000 (I think 1000 is enough is probably enough). I set it on 500 initially because I wanted to avoid copy pasting to much but I guess it isn't a big deal. \$\endgroup\$ – fejfo Dec 19 '16 at 15:05
  • \$\begingroup\$ I just wanted to let you know that there is plenty of room in an answer post. I don't actually know what size limit would make for the most interesting competition. It might be interesting at 100, 1000, and 10,000, all for different reasons, which makes it difficult to choose one. Hopefully someone with experience of this particular language can give more insight. \$\endgroup\$ – trichoplax Dec 19 '16 at 15:08
  • \$\begingroup\$ @trichoplax I have done some programming in brainfuck (I tried creating a large number program myself it was about 500 characters) and now that the alternative goal is gone I have to remove the code-golf tag. Any ideas for other tags? \$\endgroup\$ – fejfo Dec 19 '16 at 15:13
  • \$\begingroup\$ [code-challenge] is for winning criteria that don't have another tag. \$\endgroup\$ – trichoplax Dec 19 '16 at 15:14
  • 1
    \$\begingroup\$ Now that your post on main has been reopened, please Edit and delete this entry to help keep the Sandbox tidy. Thanks! \$\endgroup\$ – AdmBorkBork Dec 19 '16 at 16:59
1
\$\begingroup\$

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 , so the shortest entry in every language wins.

sandbox

  • any better wording?
  • anything I'm missing?
\$\endgroup\$
  • \$\begingroup\$ You should include the definition of a significant digit. Are there bounds on input (can it be negative)? \$\endgroup\$ – mbomb007 Dec 20 '16 at 16:15
  • \$\begingroup\$ @mbomb007 One idea could be a bonus for negatives (as most math interpreters just take 0.00 == 0) but bonuses never work well. \$\endgroup\$ – dzaima Dec 20 '16 at 17:06
  • 2
    \$\begingroup\$ Yeah, stay away from bonuses. Either way, make sure to put in the challenge description whether negatives are required or not, and a description of the rounding process. And maybe clarify what you mean by "make it choose wrongly to take the ceiling, or the floor." \$\endgroup\$ – mbomb007 Dec 20 '16 at 17:09
  • \$\begingroup\$ It's not obvious that any of the test cases handle the corner case where the "error" from one step impacts the next step. \$\endgroup\$ – Peter Taylor Dec 20 '16 at 17:21
  • \$\begingroup\$ @PeterTaylor well the last example does but imma write that in somewhere \$\endgroup\$ – dzaima Dec 20 '16 at 17:23
  • \$\begingroup\$ 1. If 123.4567 is an invalid input because it has 7 digits, surely 0.000001 is too? 2. The rounding process is still not defined. There are half a dozen different rounding schemes. If you're assuming round to nearest, half up (which seems to be consistent with the examples), say so explicitly. 3. I don't see how that last test case tests cascading impact. 444.444 and 555.555 would be good test cases. \$\endgroup\$ – Peter Taylor Dec 21 '16 at 10:02
  • \$\begingroup\$ @PeterTaylor 1. yep, my mistake. 2. correct, adding that. 3. when I posted that, the 314.911 example was the last one, but still added yours \$\endgroup\$ – dzaima Dec 21 '16 at 11:28
1
\$\begingroup\$

*TERM(1) *TERM(1)

NAME Implement STAR* term / create a mini-terminal -
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?)?

\$\endgroup\$
  • \$\begingroup\$ You might need to specify that there is a space after the $ \$\endgroup\$ – Cows quack Dec 21 '16 at 18:21
  • 1
    \$\begingroup\$ Should the program exit if given exit? \$\endgroup\$ – Conor O'Brien Dec 21 '16 at 18:37
  • \$\begingroup\$ @ConorO'Brien Updated. \$\endgroup\$ – noɥʇʎԀʎzɐɹƆ Dec 22 '16 at 1:51
  • 1
    \$\begingroup\$ @CrazyPython wtf happened to the formatting \$\endgroup\$ – Conor O'Brien Dec 22 '16 at 1:59
  • \$\begingroup\$ 1. What does "overwrite the file ~/.*term to ~" mean? 2. What about stdin and stderr? 3. The specified implementation is buggy. Consider what happens if I input su otheraccount. Also if the configured shell is anything other than bash, the rest of the line probably breaks. 4. The options spec is inconsistent: none of -c=<file>, -config, and (?:-c \w?)? agree with each other. \$\endgroup\$ – Peter Taylor Dec 22 '16 at 11:14
  • \$\begingroup\$ @PeterTaylor 1. change ~/.*term file's contents to ~. 2. & 3. That is a bug as intended. 4. will fix \$\endgroup\$ – noɥʇʎԀʎzɐɹƆ Dec 22 '16 at 15:52
  • \$\begingroup\$ @ConorO'Brien is manpage, no? \$\endgroup\$ – noɥʇʎԀʎzɐɹƆ Dec 22 '16 at 15:55
1
\$\begingroup\$

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.

\$\endgroup\$
  • \$\begingroup\$ What about duplicates? Does the correct output for input aa have one line or two? \$\endgroup\$ – Peter Taylor Jan 10 '17 at 16:19
  • \$\begingroup\$ @PeterTaylor Two lines. \$\endgroup\$ – Mike Bufardeci Jan 10 '17 at 16:22
  • \$\begingroup\$ @MikeBufardeci then say it as a test case :) \$\endgroup\$ – V. Courtois Jul 18 '17 at 14:12
1
\$\begingroup\$

Detect the Type of a Golfed Poem

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 , so the shortest answer wins. Happy golfing!

\$\endgroup\$
1
\$\begingroup\$

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 , so the shortest code in bytes wins

Sandbox

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

\$\endgroup\$
1
\$\begingroup\$

Polyglot OEIS

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

\$\endgroup\$
  • \$\begingroup\$ Could you give some examples? \$\endgroup\$ – Cows quack Dec 24 '16 at 11:39
  • 1
    \$\begingroup\$ This is probably not very interesting, as there are many trivial sequences, such as oeis.org/A000012 or even non-constant output ones: oeis.org/A000027 \$\endgroup\$ – flawr Dec 24 '16 at 14:34
  • \$\begingroup\$ No linear sequences? So, you can't do something like 2x+1? \$\endgroup\$ – FlipTack Dec 24 '16 at 14:42
  • \$\begingroup\$ @Flp.Tkc No, you can't. \$\endgroup\$ – TuxCrafting Dec 24 '16 at 14:45
  • \$\begingroup\$ Then I can use x^2 (again quite trivial) \$\endgroup\$ – Cows quack Dec 24 '16 at 14:59
  • \$\begingroup\$ @KritixiLithos Quite trivial in some languages, but already harder than a cat program \$\endgroup\$ – TuxCrafting Dec 24 '16 at 15:03
1
\$\begingroup\$

Implement ALL of OEIS!

...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 An(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?

\$\endgroup\$
  • \$\begingroup\$ Do I understand right that you can have a submission like this? n=input();print n,-n,n*2,n*3,n*n \$\endgroup\$ – xnor Dec 24 '16 at 12:01
  • 2
    \$\begingroup\$ are constant sequences allowed? \$\endgroup\$ – FlipTack Dec 24 '16 at 13:24
  • \$\begingroup\$ @xnor Correct . \$\endgroup\$ – Conor O'Brien Dec 24 '16 at 20:16
1
\$\begingroup\$

Prove your language is Turing Complete

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.


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?
\$\endgroup\$
  • \$\begingroup\$ Do you need to prove that your language is turing complete, or that the program you're writing is turing complete? Please also write down a definition of what you exactly mean by turing complete. As always with a pop-con you need to include an explicit objective validity criterion. \$\endgroup\$ – flawr Dec 25 '16 at 14:51
  • \$\begingroup\$ @flawr As the title says, it's about proving your language is TC. Thanks for the feedback, I'll try and add some more detail. \$\endgroup\$ – FlipTack Dec 25 '16 at 14:53
  • \$\begingroup\$ How about a program that compiles a known TC language to your language? That shows it to be TC by the existence of a correspondence. \$\endgroup\$ – Conor O'Brien Dec 25 '16 at 17:30
  • \$\begingroup\$ @ConorOBrien yep, that would be allowed \$\endgroup\$ – FlipTack Dec 25 '16 at 17:31
  • \$\begingroup\$ This is a very interesting question. +1 As for the tags, I'm not sure, you could do code-golf where the task is finding the shortest possible proof in every language, but in my opinion keeping it a popularity-contest may encourage some quite interesting answers that need not be concerned by byte-size alone. \$\endgroup\$ – Buffer Over Read Dec 25 '16 at 18:34
  • \$\begingroup\$ I think you should probably outright ban string eval. It's also worth noting that a) it's often easier to prove a language TC by compiling into it, rather than by writing an interpreter in it, and b) there's some debate as to whether a language that can write an interpreter for a TC language is necessarily TC itself. \$\endgroup\$ – user62131 Dec 26 '16 at 4:15
  • \$\begingroup\$ @ais523 the problem is, i wanted submissions to be a program, and compiling into a TC language is just a list of substitutions. Unless you meant creating a self-compiler? \$\endgroup\$ – FlipTack Dec 26 '16 at 15:09
  • \$\begingroup\$ @ais523 also, part of the reason I've set it as a pop-con is because writing rules about what counts as proof would be nearly impossible - a pop-con allows popular vote to decide what is valid, and downvote what is obviously cheating. \$\endgroup\$ – FlipTack Dec 26 '16 at 15:11
  • \$\begingroup\$ This will most likely get closed as too broad as a pop con. Also, pop cons still need an objective validity criterion; if the validity criterion is unclear as a ode golf, it is also unclear as a pop con. \$\endgroup\$ – Dennis Dec 26 '16 at 15:25
  • 1
    \$\begingroup\$ It doesn't make sense to me to write a program to prove a language is Turing complete. The claim is a mathematical statement and so a proof should be a series of logical logical deduction. It looks to me like you just want emulators of known simpler Turing-complete languages (the existence of which is one proof method for TC), in which case the spec should require just that. \$\endgroup\$ – xnor Dec 28 '16 at 20:20
  • \$\begingroup\$ There's a difficulty that the languages this will be interested for are Esolangs and usually the Esolang wiki for basically all entries has a proof or disproof of some sort for Turing completeness. \$\endgroup\$ – walpen Dec 29 '16 at 3:14
1
\$\begingroup\$

Name that pentomino!

There are a total of 12 different pentominoes, shapes made out of 5 squares: enter image description here

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!)

\$\endgroup\$
  • \$\begingroup\$ Did you make the image yourself? If not, you should probably credit the source. About the output format, it's best to require a single character that's the character given, but to not make rules about how that character is output (e.g. it could go to stdout, be displayed on the screen, or output as its ASCII code). \$\endgroup\$ – user62131 Dec 31 '16 at 22:39
1
\$\begingroup\$

Re-Implement tail in your favorite language!

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 , so the shortest answer (in bytes) wins.

\$\endgroup\$
  • \$\begingroup\$ I recommend you be more flexible with the output format - specifically, drop the "trailing newline necessary" rule. \$\endgroup\$ – FlipTack Dec 30 '16 at 13:35
  • \$\begingroup\$ Also, in environments where input is line-buffered, how should multi-line input be taken? Are function submissions allowed? \$\endgroup\$ – FlipTack Dec 30 '16 at 13:36
  • \$\begingroup\$ @FlipTack: Actually, I'd recommend specifying that the input will always have a trailing newline. That way, the correct output will always have a trailing newline too, but you could do it by copying from the input. \$\endgroup\$ – user62131 Dec 31 '16 at 22:37
1
\$\begingroup\$

A range of operations on the same inputs

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

\$\endgroup\$
  • \$\begingroup\$ Although this is interesting, I'm not sure if it will be well received, as it's just a list of trivial operations that are too trivial to be challenges on their own. \$\endgroup\$ – FlipTack Jan 1 '17 at 17:48
  • \$\begingroup\$ Can concatenation of the string representations have a leading 0? \$\endgroup\$ – FlipTack Jan 1 '17 at 17:51
  • \$\begingroup\$ It's in the spirit of this challenge to allow the simplest possible implementations of the operations, so I'd say it's OK if you add or remove a leading 0 that shouldn't be there. \$\endgroup\$ – user62131 Jan 1 '17 at 22:29
1
\$\begingroup\$

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:

Plot

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 lowest byte-count wins.

\$\endgroup\$
  • \$\begingroup\$ Very cool idea. Already trying to figure out how to implement this \$\endgroup\$ – Patrick Roberts Jan 9 '17 at 0:54
1
\$\begingroup\$

Function Token Validator

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.

\$\endgroup\$
  • \$\begingroup\$ interesting list \$\endgroup\$ – TrojanByAccident Jan 8 '17 at 22:01
  • \$\begingroup\$ @TrojanByAccident It's a list of generic math functions, and I thought there would be enough similarities between a large majority of the tokens to combine some quick checks with length-optimized regexes to make this an interesting challenge. \$\endgroup\$ – Patrick Roberts Jan 8 '17 at 22:28
  • \$\begingroup\$ Personally, it looks like something I can write in /// \$\endgroup\$ – TrojanByAccident Jan 8 '17 at 22:38
  • \$\begingroup\$ This is just regex golf. \$\endgroup\$ – SIGSTACKFAULT Jan 12 '17 at 16:09
1
\$\begingroup\$

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!

\$\endgroup\$
  • 2
    \$\begingroup\$ I think this may be too easy for some PPCG users. Especially if there's no time limit, some users could probably find the optimal solution, resulting in a tie. Also, challenges should be self-contained, not relying on data from external links. So you should explain in your question description what a "sliding puzzle" is. \$\endgroup\$ – mbomb007 Jan 9 '17 at 22:43
1
\$\begingroup\$

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.


\$\endgroup\$
  • \$\begingroup\$ I think this a cool question, I like how different it is from most of our other questions. However, I think having a sample implementation would be a good idea before posting it, as otherwise I'd predict many deleted answers! :P \$\endgroup\$ – FryAmTheEggman Jan 13 '17 at 0:57
1
\$\begingroup\$

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:

\$\endgroup\$
  • 1
    \$\begingroup\$ Seeing as it's outputting truthy/falsy, decision-problem would be a great tag to use. Welcome to PPCG btw. \$\endgroup\$ – FlipTack Jan 15 '17 at 15:20
  • 2
    \$\begingroup\$ Personally, I think that input should be guaranteed to be positive rather than using two's complement encoding. That allows more bit-shifting based algorithms. \$\endgroup\$ – FlipTack Jan 15 '17 at 20:11
1
\$\begingroup\$

Make a shuffle quine!

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

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.

\$\endgroup\$
  • \$\begingroup\$ I appreciate that the scoring makes it impossible to pad the program with junk in order to get an unlimited score. However, I suspect it'll be won by one of the two-byte quines with a score of 2 × 2 ÷ 1, as it'd only be possible to beat with a score of 2 × 2 ÷ 2, 3 × 6 ÷ 5, or better. \$\endgroup\$ – user62131 Jan 16 '17 at 22:18
  • \$\begingroup\$ @ais523 hm, true. I'll mess with the scoring to see what I can come up with. \$\endgroup\$ – Rɪᴋᴇʀ Jan 16 '17 at 22:19
  • \$\begingroup\$ It strikes me that it might be interesting to require the program to be exactly a given number of bytes long. Then the challenge would be to maximise the number of permutations that are quines. Unfortunately, a large number of bytes would be hard to score, and a small number would exclude many languages. \$\endgroup\$ – user62131 Jan 16 '17 at 22:34
  • 1
    \$\begingroup\$ I don't see why it's supposed to be difficult. If each chunk is a quine (that doesn't screw up the global state somehow) then you can arrange the chunks in any order and it will still be a quine and you will score 1 for the fraction part. \$\endgroup\$ – feersum Dec 16 '18 at 4:28
1
\$\begingroup\$

Prisoner's dilemma

Inspired by the "Mafia" proposal

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

Payoff matrix:

Hi Mom!

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 :)

\$\endgroup\$
  • \$\begingroup\$ What's your win criterion? \$\endgroup\$ – Rɪᴋᴇʀ Jan 6 '17 at 0:03
  • \$\begingroup\$ Most points after playing every other bot. I thought that was implied, just a sec :) \$\endgroup\$ – SIGSTACKFAULT Jan 6 '17 at 0:04
  • \$\begingroup\$ add a grim trigger? (cooperates, but as soon as enemy defects they always defect) \$\endgroup\$ – Destructible Lemon Jan 6 '17 at 0:04
  • \$\begingroup\$ Define "point"? \$\endgroup\$ – Rɪᴋᴇʀ Jan 6 '17 at 0:04
  • \$\begingroup\$ Is this a king of the hill challenge? (With bots competing against each other) in that case, it's probably a duplicate of this one: codegolf.stackexchange.com/q/2357/31716 \$\endgroup\$ – DJMcMayhem Jan 6 '17 at 0:06
  • \$\begingroup\$ Easterly: Point = generic unit of win-ness | Watermelon: Well then, you can do that. I might remove TFT from the included bots. \$\endgroup\$ – SIGSTACKFAULT Jan 6 '17 at 0:06
  • \$\begingroup\$ @DJMcMayhem This is why we post in the sandbox, people. :( \$\endgroup\$ – SIGSTACKFAULT Jan 6 '17 at 0:08
  • \$\begingroup\$ I suppose it's not really a dupe -- We're playing a random number of rounds so you can't do things like defecting on the last round against TFT. \$\endgroup\$ – SIGSTACKFAULT Jan 6 '17 at 0:10
  • 2
    \$\begingroup\$ "75% cooperate / 75% defect" \$\endgroup\$ – Pavel Jan 6 '17 at 0:16
  • \$\begingroup\$ also it doesn't make sense to only know the last turn \$\endgroup\$ – Destructible Lemon Jan 6 '17 at 0:26
  • 1
    \$\begingroup\$ I agree that this is a duplicate, but I'll leave that to the voters. However, for your sanity, I really recommend you change how input/output works. Each time you talk to a bot you are going to have at least 2 file writes, 2 file reads, and starting up a new process. Depending on the number of submissions and iterations, this can take a long time. I recommend keeping the processes alive and communicating through stdin/stdout. \$\endgroup\$ – Nathan Merrill Jan 6 '17 at 18:39
  • \$\begingroup\$ You only are told the last turn. if you want to remember further, you can write to a file. \$\endgroup\$ – SIGSTACKFAULT Jan 17 '17 at 14:33
1
\$\begingroup\$

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 rules and restrictions apply.

\$\endgroup\$
  • \$\begingroup\$ This challenge is similar to this recent sandbox post, though with a slightly different (more conventional) question format. \$\endgroup\$ – VisualMelon Jan 13 '17 at 13:23
  • \$\begingroup\$ @VisualMelon You'll just have to take my word for it that I don't read the Sandbox myself, but I am surprised at the similarity. \$\endgroup\$ – Neil Jan 13 '17 at 19:32
  • \$\begingroup\$ No problem ;) there is an awful lot to trawl through if you don't have time to check back regularly. \$\endgroup\$ – VisualMelon Jan 13 '17 at 19:38
  • \$\begingroup\$ It's been done. \$\endgroup\$ – xnor Jan 19 '17 at 2:54
  • \$\begingroup\$ @xnor That question doesn't have the concatenation requirement. (Not that I'm claiming that it's enough to make this question sufficiently distinctive.) \$\endgroup\$ – Neil Jan 19 '17 at 8:37
  • \$\begingroup\$ My mistake, I somehow interpreted equality as being up to ordering. Maybe it would be more obvious if you said the array is split into a left segment and a right segment. I think that definitely makes this different. \$\endgroup\$ – xnor Jan 19 '17 at 8:41
1
\$\begingroup\$

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.

\$\endgroup\$
  • 1
    \$\begingroup\$ huh, rule number 3 makes this interesting... \$\endgroup\$ – Destructible Lemon Jan 22 '17 at 3:39
1
\$\begingroup\$

Store a secret

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)
\$\endgroup\$
  • \$\begingroup\$ The spec seems somewhat incomplete to me. It's necessary to read between the lines even to know that the protocol the server is supposed to implement is HTTP. But even having worked that out, it's not clear how much of HTTP should be implemented. What content types must be supported for the POST body? What about encodings? When returning a 400 error, is it sufficient to set the Status header or should it also have a body? \$\endgroup\$ – Peter Taylor Jan 22 '17 at 19:16
1
\$\begingroup\$

Exponentiation by squaring

Given an integer x and a non-negative integer n, compute xn 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 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.
\$\endgroup\$
  • \$\begingroup\$ I would change the name of your Python function as pow is a built-in function. Also an iterative function calls itself inside the function. The above isn't iterative. Otherwise it looks intriguing. \$\endgroup\$ – user63571 Jan 22 '17 at 17:28
  • \$\begingroup\$ @JackBates Yes, a different name might be better to avoid confusion. I'm not familiar with that definition of iterative. I've usually seen recursive used to describe a function that calls itself. \$\endgroup\$ – miles Jan 22 '17 at 17:32
  • \$\begingroup\$ @JackBates this isn't codereview.stackexchange.com . And it is iterative - recursion is when the function call itself, iterative is when it's done in a loop instead. \$\endgroup\$ – FlipTack Jan 22 '17 at 17:40
  • \$\begingroup\$ Sorry about that, got a bit mixed up! \$\endgroup\$ – user63571 Jan 22 '17 at 17:41
  • 1
    \$\begingroup\$ Technically the time complexity for the naïve loop isn't Θ(n) and the time complexity for the improved loop isn't Θ(lg n) because the complexity of a multiplication isn't Θ(1), unless you replace exponentiation with expmod. The rule about integer overflow effectively says that languages which use bounded integer types can do expmod, so on a strict reading this challenge can be answered in C but not in Python. I assume this isn't intentional. The most elegant fix is probably to require polylog time rather than log time. \$\endgroup\$ – Peter Taylor Jan 22 '17 at 19:07
1
\$\begingroup\$

Polytope of the pops

In 3 dimensions, there are 5 regular convex polytopes: the platonic solids. enter image description here

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
\$\endgroup\$
1
\$\begingroup\$

Interpreter chain!

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( ... ) ); ...

\$\endgroup\$
  • 3
    \$\begingroup\$ Why would anyone bother to read the code on input at all, when it is already known exactly what the program needs to do? \$\endgroup\$ – feersum Jan 26 '17 at 7:57
  • \$\begingroup\$ @feersum If the submission does not even read the input, it is no longer an interpreter. The interpreter must somehow identify each command in the input and execute the commands in order. I guess "You will need to define each function separately." wasn't that clear... (changed "function" to "command") \$\endgroup\$ – JungHwan Min Jan 26 '17 at 16:04
  • \$\begingroup\$ It's going to be hard to define a victory condition here. It'd be fairly easy to write a ridiculously long, complex program in a high-level language which would therefore be pretty much impossible to interpret. \$\endgroup\$ – user62131 Jan 26 '17 at 16:10
  • \$\begingroup\$ @ais523 I edited the question. Would that work? (The winner is the second to last answer) \$\endgroup\$ – JungHwan Min Jan 26 '17 at 16:18
  • 1
    \$\begingroup\$ Possibly. I'm still unsure that the question as a whole works, but maybe you'll find a way to define things precisely. \$\endgroup\$ – user62131 Jan 26 '17 at 16:37
  • 2
    \$\begingroup\$ @JungHwanMin "This is/isn't an interpreter" is a completely subjective identification which isn't appropriate in a code golf specification. \$\endgroup\$ – feersum Jan 26 '17 at 22:36
  • \$\begingroup\$ @feersum This is an answer-chaining question. Also, I don't understand how "interpreter" is a subjective word. Could you give me an example, perhaps? \$\endgroup\$ – JungHwan Min Jan 26 '17 at 23:42
  • \$\begingroup\$ I mean, for a specification on this site (other than popularity contest). OK, if it's not subjective, please give me some code which can take as input a language A, a program X in language A, and a program Y, and output whether Y is interpreting X or not. \$\endgroup\$ – feersum Jan 27 '17 at 0:14
  • \$\begingroup\$ @feersum That problem can be easily solved by requiring some explanation from the answerers (+ a link to language specifications). They would also need to write a list of commands used in their answers for the following answers. \$\endgroup\$ – JungHwan Min Jan 27 '17 at 0:21
  • 1
    \$\begingroup\$ @JungHwanMin I think what feersum is trying to say is this. An interpreter implements some programming language, which consists of some set of valid programs and their behaviors. Suppose that the first answer A is written in Java. The next answer B should be an interpreter for which A is a valid program whose behavior is to print the integers from 1 to 10. But what else are valid programs for B, and what should their behaviors be? Not every Java program has to be valid, as per the rules. What about all Java programs that use the same "commands"? (contd.) \$\endgroup\$ – Zgarb Jan 27 '17 at 8:43
  • 1
    \$\begingroup\$ If A uses a Java function that has a very complicated implementation, but only a small subset of that is needed for A, can B choose to only implement that subset? If A uses a syntax that's very complex to implement generally, but can be treated as a no-op in A, does B have to implement the general case? It's hard to draw the line. \$\endgroup\$ – Zgarb Jan 27 '17 at 8:45
  • \$\begingroup\$ @Zgarb Those are very good points. For your first comment, I would say that for language B, the valid programs are programs (in language A) that use the same commands in answer A with the same purpose (perhaps, it may be a good idea to require each answer to have a test program that prints from 1 to 10; the program would only use the commands in the interpreter). For your second comment, only a subset could be implemented; the no-op still has to be implemented, however (the interpreter must still acknowledge that the command is there). \$\endgroup\$ – JungHwan Min Jan 27 '17 at 15:41
  • \$\begingroup\$ In that case the chain could be broken by a language which is good at interpreting other languages but can't count from 1 to 10. (It wouldn't surprise me if one already existed; it might be fun to construct one if it doesn't.) \$\endgroup\$ – user62131 Jan 27 '17 at 22:01
  • \$\begingroup\$ @ais523 The only requirement is to print numbers from 1 to 10. Technically, something like print("1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n") would be fine. Also, if the first answer uses a for-loop (to print 1,2,3,...,10), then all the languages after that needs to have something similar... -- Anyway, I changed the requirement to "the test program must use all commands in the interpreter" to prevent such issues. \$\endgroup\$ – JungHwan Min Jan 27 '17 at 23:36
  • \$\begingroup\$ Could I get feedback instead of unexplained downvotes? If this question is too broad/impractical, it can be improved. Any suggestion is welcome. \$\endgroup\$ – JungHwan Min Jan 27 '17 at 23:41

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .