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


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.


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.


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

  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4722 Answers 4722

104 105
107 108

Find square sum products

It's possible to find sets of three numbers whose product including their sum is a square number. Examples:

  • (3 + 2 + 1) * 3 * 2 * 1 = 6²
  • (3 + 3 + 2) * 3 * 3 * 2 = 12²
  • (4 + 4 + 1) * 4 * 4 * 1 = 12²
  • (9 + 8 + 1) * 9 * 8 * 1 = 36²
  • (8 + 5 + 5) * 8 * 5 * 5 = 60²
  • (8 + 7 + 6) * 8 * 7 * 6 = 84²
  • (9 + 8 + 8) * 9 * 8 * 8 = 120²

Please write a program or function to find square sum products for me.

Since there are an infinite number of square sum products, even excluding trivial multiples, you should limit your output to depend on a characteristic number N. Your program should always output the same square sum product(s) for a given N, and there should be at least one value of N for each possible square sum product that will cause your program to output that product. However, I will be flexible in what N actually represents, as long as you describe it in your answer. Here are some examples:

  • N is one sixth[citation needed] of the square root of the square sum products. For example, an N of 2 would find the second and third of my examples.
  • N is the upper bound of the largest summand. For example, an N of 9 would find all of my examples and then some.
  • N is the number of square sum products to be found. For example, an N of 12 would find all of my examples and then some.

For the output, I don't actually want the summands or the square root. Instead, please output the pairwise sum of the summands. Please also exclude duplicates (i.e. reorderings) from your answer.

This is , so the shortest program wins!

  • \$\begingroup\$ You can drop the first [citation needed]: if (a, b, c) is a valid triple, then so is (a*k, b*k, c*k) for k integral. \$\endgroup\$
    – Sp3000
    Commented Jan 21, 2017 at 11:43
  • \$\begingroup\$ @Sp3000 Sure, but that's a trivial case. I'm pretty sure there are infinite nontrivial cases too. \$\endgroup\$
    – Neil
    Commented Jan 21, 2017 at 11:48
  • \$\begingroup\$ My point was just that an infinite number do exist, so you can drop the superscript. I'm sure you could come up with something less trivial if you really wanted, like (2*k*k+4*k+2, 2*k*k+4*k+3, 1) \$\endgroup\$
    – Sp3000
    Commented Jan 21, 2017 at 12:03
  • \$\begingroup\$ @Sp3000 Indeed, you can generate a subset by multiplying a triangular number by 4, and taking that number twice with a final 1. \$\endgroup\$
    – Neil
    Commented Jan 21, 2017 at 13:28
  • \$\begingroup\$ I find the proposed relationship between input and output too vague, and also open to abuse. For example, I could say that every single N outputs 6^2 unless N is of the form 2^a 3^b 5^c where a,b,c generate a square sum product. Why not just pick a spec, for example, that N is the upper bound of the largest summand? \$\endgroup\$ Commented Jan 26, 2017 at 8:36
  • \$\begingroup\$ @GregMartin I didn't want to be overly restrictive because on other sandbox posts I atttracted comments complaining about what I chose to spec, but I guess some sort of restriction is necessary, sigh... \$\endgroup\$
    – Neil
    Commented Jan 27, 2017 at 0:33
  • \$\begingroup\$ I agree that it's not always clear what will make the best challenge...! \$\endgroup\$ Commented Jan 27, 2017 at 0:38

Dual Kimian (Error) and Regular Quine Polyglot

Create a program that is

  • a non-erroring proper quine in one language...
  • ...and a proper quine that produces its own source code through an error in another language

What is an error quine?

The compiler/interpreter/runtime to produce error output when compiling/running your program which is identical to your program's source code.

  • Your program may be specific to a particular version or implementation of your language's compiler/interpreter/runtime environment. If so, please specify the particulars.
  • Only standard compiler/interpreter/runtime options are permitted. You cannot pass some weird flag to your compiler to get a specific result.
  • The program does not need to be syntactically or semantically valid.
  • The program must not produce any output of its own (e.g. by calling print or an output function). All output generated upon attempting to compile/run the program must originate from the compiler/interpreter/runtime.
  • The complete output of the compiler/interpreter/runtime must be exactly identical to your program source code.
  • The compiler/interpreter/runtime must generate at least one error message when invoked with your program.

(adapted from nneonneo's "Make an error quine!" challenge)

  • Polyglots from different versions of the same language or similar languages are allowed
  • \$\begingroup\$ Related. \$\endgroup\$
    – user62131
    Commented Jan 22, 2017 at 2:40
  • \$\begingroup\$ I fear the spec here isn't clear enough to prevent people using absurd definitions of what counts as an error, like happened in my attempt. (For example, what happens if you throw a string, and the runtime's unhandled-exception handler prints it? Some people consider that to be an error, and it's printed by the runtime, but the text is entirely under user control.) \$\endgroup\$
    – user62131
    Commented Jan 22, 2017 at 2:45

Sandbox Questions

  • Is it a good idea to post this as a separate challenge? This one is significantly easier and I fear that posting it would take too much attention away from the original challenge.

Detect if your program has been bit-flipped

Write a program that outputs


If any single bit is substituted by the alternate bit the program should output

  • Do not read your source code from a file
  • \$\begingroup\$ Isn't this already a question? If so why not just replace it with a link to the question? \$\endgroup\$
    – user63571
    Commented Jan 22, 2017 at 17:52

Binary beads clock

The challenge is dedicated to pseudo-graphical representation of objects, e.g. like by ascii-art. Puzzle is geometrical: to represent bistrings as beads using tiles. The result must be beads-like strings where one is more like a bead and zero is more like a stem (or smaller bead). The solution can result in wide variety of visual concept but there are specific guides, see below.

A simple example of binary beads using single tiles, here standard characters:
Input: 1001, 0101, 0011.


or e.g. PETSCII console:

enter image description here

So these are only example form, but now you must "upscale" it, but since you are not in graphical mode, the resulting image must be structure of source units, i.e. it must be a rectangular tiling. In other words. it is not allowed just to draw sprites for each next upscale step. So the whole must be a real console app or code which emulates the console behaviour itself within the guidelines. So you can draw any tiles and use them also. Solution should show some reference to console output, e.g. if using graphical lib, a "print" function should be made which takes the data.


The task is to write an application or function wich draws scalable yet visually consistent beads with efective usage of tiles. Tilesets with least amount of tiles and yet with outstanding rich beads look must win. In other words, one should find good relation between tiles amount and good possibility to present different sizes.

One can present different length strings, but the whole layout must be of adequate size. Multiple words on line is allowed and even welcome especially if shows interesting use case.
Usage of graphical libs is welcome, e.g. to emulate a simple console-like output.
All tiles can be custom, i.e. this should not be necessarily standard characters of console. In real console any characters possible can be used or patched with custom tiles if possible. Any OS can be used.


Final image:

  • must include at least 2 different types of beads (different sizes), i.e. interesting scalability example
  • each bead type must share some tiles with other beads
  • structures should be good visible from various distance and contiguos as possible
  • "zero=stem, ones=bead" rule is not strict, creativity is very welcome but it should be not too far from rule to compare results
  • artiscism in forms is always bonus points!


  • maximal amount of tiles in the tileset : 16
  • are rectangular, e.g 16x8, 8x8 pixels ...
  • minimal size: 6x6, maximal size: 24x24 pixels
  • only two-color but the whole image can have more colors.


  • Non-cryptic plain code: C, Python, Basic, Fortran and those not too far from it
  • hacks (e.g. for old platforms) should be documented somehow and reproducable in theory

Points given for:

  • less unique tiles yet with rich possibilities
  • visual consistence by each beads type presented, but two types must not necesserily have same style
  • Hint: even within one type, the look of one bead can vary but the whole string easily decodable
  • interesting scaling possibilities, e.g. parametric scaling
  • fullfill the restrictions
  • less operations and minimalistic code
  • working application, e.g. interactive counter or a micro-game is welcome

Solution publishing:

  • title: amount of tiles used and pixel sizes info
  • visual examples easy to follow
  • notes about interesting sides of solution
  • code and some explanation

Sandbox note: If there are unclear point, free to point to corrections. Please suppose better tags if needed.


  • \$\begingroup\$ I really like this challenge, though I'd remove the "only monochrome mode is allowed" rule to give the designers more freedom. I'd also include only the first primitive output example, and add a line stating that users are free to format this, since all these examples might push all answers roughly in the same direction. Maybe you can make an answer as well, since the PETSCII example looks great! \$\endgroup\$
    – Luke
    Commented Jan 20, 2017 at 10:59
  • \$\begingroup\$ I fear that this question is too broad for a popularity-contest. There are two primary problems: 1. The judgement criterion (which clock is most useful to low-sighted people) does not naturally gather votes. You are far more likely to get upvoted answers that are funny and interesting. 2. The challenge isn't really about programming, but about design. \$\endgroup\$ Commented Jan 20, 2017 at 17:00
  • \$\begingroup\$ If you are wanting design help, ux.stackexchange is great for that. If you want people to implement a specific clock, then make objective requirements, and change the challenge type :) \$\endgroup\$ Commented Jan 20, 2017 at 17:01
  • \$\begingroup\$ Hi @NathanMerrill, thanks for input. The aim is not for people with low vision, it is just background, I will make that point more clear. And do you mean design challenge is not welcome here? My idea was exactly to challenge different designs with few restrictions. \$\endgroup\$
    – Mikhail V
    Commented Jan 20, 2017 at 17:50
  • \$\begingroup\$ Right. Design questions aren't a good fit for this site. \$\endgroup\$ Commented Jan 20, 2017 at 17:55

Rainbow Cat Program

Recently, I remembered a program I'd written in C# a while back for fun. It takes a string as input, then outputs that same string, cycling through a rainbow of colours. I now realize that this is basically a cat program, but with the added complexity of the output changing colour every 100ms. So I figured it would make an interesting challenge.

The aim is to make your own "rainbow cat program", taking a string as input, and outputting that same string cycling through the following colours in sequence: red, yellow, green, blue, purple, and pink. Not quite a proper rainbow, but close enough. The colours must change every 100ms (or as close to 100ms as your chosen language will allow).

For reference, here's an extremely badly-golfed version of my original C# program (370 bytes):

using System;using System.Threading;class P{static void Main(){var a=Console.ReadLine();for(;;){L(a,ConsoleColor.Red);L(a,ConsoleColor.Yellow);L(a,ConsoleColor.Green);L(a,ConsoleColor.Blue);L(a,ConsoleColor.DarkMagenta);L(a,ConsoleColor.Magenta);}}static void L(string a,ConsoleColor b){Console.Clear();Console.ForegroundColor=b;Console.WriteLine(a);Thread.Sleep(100);}}

And a gif of it in action!

Other Rules

  • Trailing whitespace/newlines are allowed; printing so many newlines that you push the text off the screen, then writing it again in the next colour, is not allowed. You must physically clear the screen and rewrite the text rather than writing it out over and over.
  • Once the cycle starts, it should continue indefinitely without any user input.
  • Standard golfing loopholes apply.
  • This is , so shortest program wins. Feel free to compete for the shortest program in any given language, though: don't feel put off by the golfing languages!

Avoiding Averages

Given a non-empty list of positive integers, reorder the list such that for every pair of indices, the average of the values at those indices is not contained in any index between them.


  • This is so the shortest code wins.

Work in-progress

  • 2
    \$\begingroup\$ Maybe add some sample input->output? \$\endgroup\$
    – Leo
    Commented Jan 23, 2017 at 15:41
  • 1
    \$\begingroup\$ I like this, but there's also not much here. Maybe add a picture of a kitten or some I/O like Leo said. \$\endgroup\$ Commented Jan 23, 2017 at 19:33
  • \$\begingroup\$ Can we expect the input to be valid, or if not, what should be done if such an ordering does not exist? (e.g. [1,1,1]). \$\endgroup\$
    – flawr
    Commented Jan 23, 2017 at 20:22
  • \$\begingroup\$ @flawr I'm wondering the same thing, should the input always have a possible solution. If multiple solutions exist, return only one or all of them? I'm still ironing out the details. \$\endgroup\$
    – miles
    Commented Jan 23, 2017 at 20:40
  • \$\begingroup\$ I'm struggling to think of a set of numbers that doesn't have a possible ordering (where each number occurs once). I think returning only 1 is sufficient. \$\endgroup\$ Commented Jan 23, 2017 at 21:00

Compute the CYK-Table!

Context-Free Grammars

A context-free grammar is a grammar consisting of rules from one variable to a list of variables and symbols. Every string purely consisting of symbols that can be produced using these rules is said to be accepted by the language. For the purpose of this challenge we're only going to consider grammars in CNF which means that on the right side there's either two variables or one symbol (we're gonna ignore the empty language for this challenge).

The CYK-Algorithm

The CYK-Algorithm is a method to check whether a given word is recognized by a context-free language in CNF. For doing this it iterates over the word and applies all possible rules on all substrings and writes them down in a nice table. This table can then be used to successively find variables generating larger substrings until you (don't) hit the word.

The Input

Your input will be

  • A list of strings representing the word
  • A list of triples of strings, representing the rules from one variables (the first in the triple) to two variables
  • A list of pairs of strings, representing the rules from one variable to a symbol
  • A string, representing the starting variable

You may replace the above input format with your favorite input format, as long as you can encode the same amount of information.

The output

The output will be three-dimensional: A list of rows consisting of a list of "candidates" which is a list of strings representing a list of variables. An illustration of this is on Wikipedia.

You may replace the above output format with your favorite output format, as long as you can encode the same amount of information.

Who wins?

This is so the shortest code in bytes to solve the challenge wins!


Start Symbol: "X"
Word: ["b","a","c","b"]
Rules #1: [("X","X","Y"),("X","Z","Z"),("Y","W","Z"),("Z","X","Y"),("W","Y","W")]
Rules #2: [("X","a"),("Y","a"),("Z","b"),("W","c")]

We're gonna do this step-by-step:

The substrings of length 1 first (this is your first row):

b    , a       , c   , b

Now for the substrings of length 2 (this is your second row):


(because there's no way to get ZX or ZY, but W -> YW and Y -> WZ)

Now for the substrings of length 3 (this is your third row):


(because there's no rule to get ZW, but X->XY (1+2), Y->WZ (2+1), Z->XY (1+2) where the sum denotes the lengths of of the used substrings)

Finally for the substrings of length 4 (this is your fourth row):


(because X->ZZ(1+3))

So in total your final table for this example is gonna look like this:


where the first index increases as we go downwards, the second increases as we go to the right an dthe third denotes the variable within the "cell".


Physical String Length

Given the following information:

  • (String) s - A string to be printed.
  • (String) f - The font in which it is to be printed.
  • (int) pt - The size of the font in which it is to be printed in pts (no decimals).
    • Note that the input units are in pt (1/72 inch).
    • The output unit should be pixels, rounded to the nearest integer.
    • Use 96 PPI in your conversion.


  • The physical length of the string (how many pixels wide the final string is).

Below are a few examples and a piece of code that will let you test arbitrary combinations.

import java.awt.Canvas;
import java.awt.Font;
public class F {
    public static void main(String[]args){
        System.out.println(physicalStringLength("What?", "Calibri", 12));
        System.out.println(physicalStringLength("What?", "Calibri", 24));
        System.out.println(physicalStringLength("What?", "Calibri", 36));
        System.out.println(physicalStringLength("What?", "Calibri", 72));
        System.out.println(physicalStringLength("What?", "Helvetica", 12));
        System.out.println(physicalStringLength("What?", "Times New Roman", 12));
        System.out.println(physicalStringLength("What?", "Courier New", 12));
    public static int physicalStringLength(String s, String f, int pt) {
        System.out.print(s + "@[" + f + "," + pt + "]=");
        return new Canvas().getFontMetrics(new Font(f,0,pt)).stringWidth(s);

Here's some base-line examples, the output has be created using the above piece of Java code:

What?@[Times New Roman,12]=31
What?@[Courier New,12]=35

If you want to see the length of any other strings, use the code provided as a base-line. Using a Java has been banned due to the usage of the example unless you'll be providing a different methodology (kinda sucks, cause Java may be one of the few with a built-in).

This is , lowest byte-count wins.

  • 2
    \$\begingroup\$ The font is an integer? \$\endgroup\$
    – Poke
    Commented Jan 24, 2017 at 21:25
  • \$\begingroup\$ Yep, no float font sizes. \$\endgroup\$ Commented Jan 24, 2017 at 21:26
  • 2
    \$\begingroup\$ Sorry, I mean the second parameter "f" \$\endgroup\$
    – Poke
    Commented Jan 24, 2017 at 21:26
  • \$\begingroup\$ Nope, that's a typo. \$\endgroup\$ Commented Jan 24, 2017 at 21:26
  • \$\begingroup\$ It's a little strange to ask for the width in px but input the font size in pt. Pixels are can vary in physical size while points are fixed at 1/72 inches. \$\endgroup\$
    – Poke
    Commented Jan 24, 2017 at 21:29
  • \$\begingroup\$ @Poke I guess I could state that Java is using a default PPI is 96. \$\endgroup\$ Commented Jan 24, 2017 at 21:31
  • \$\begingroup\$ Because I like answering challenges in java I'd be remiss if I didn't suggest adding more to this challenge such as height and other things found here but that's likely not as fun for other languages. I think the challenge does contain enough by itself. \$\endgroup\$
    – Poke
    Commented Jan 24, 2017 at 21:41
  • \$\begingroup\$ 1. I don't think this is well defined. Different applications using the same typeface and the same point size will produce strings of slightly different widths because e.g. they don't interpret the hints in the same way. 2. Why ban Java and not e.g. the .Net languages, which have very similar library support? \$\endgroup\$ Commented Jan 24, 2017 at 22:31
  • \$\begingroup\$ Adding to Peter's point, different rendering engines display fonts differently. The default Windows GDI renderer alone knows 5 different types of anti-aliasing, any of which can be the system standard, not counting fonts rendered by Direct2D, OpenGL or GDI+. It's very easy to just render and measure a string with GDI+, but the length might be different across systems by one or two pixels because of AA. Would that be acceptable? \$\endgroup\$
    – user42643
    Commented Jan 24, 2017 at 23:48
  • \$\begingroup\$ @PeterTaylor Maybe adding in a clause about acceptable standard deviations? \$\endgroup\$ Commented Jan 25, 2017 at 15:28

Binary Grids

Consider the N-dimensional binary grid, with dimensions {d1,d2,...,dN}. Here are a few examples:

6 (N=1): 100101

3x7 (N=2):


3x3x3 (N=3):

010   001   100
100   011   110
011   110   001

What each of these example grids have in common is: they do not contain any consecutive sequences of the same digit longer than 2.

The Challenge

Write a program or function which, given a list of dimensions, outputs the number of binary grid configurations with the given dimensions that satisfy this condition.


A list of positive integers (>1), either via stdin or passed as an argument. Example: 3 2 6, [3,2,6], etc.


The number of valid configurations, either as a returned value or printed to stdout, or something similar.


  • While brute-force solutions can work, their time complexity is O(2^N), which is way too long for anything but the smallest grids. Write something which will complete before my computer becomes obsolete, please!
  • Standard loopholes are forbidden, not that I think very many of them would apply here anyway.
  • This is code-golf, so the shortest code wins, with tiebreakers going to the fastest code.

Sandbox Questions

  1. Is this interesting?
  2. Is this doable?
  3. What's a better way to word the time complexity restrictions?
  4. The only example for which I actually know the answer is for [6]... do I need more? I'd have to solve this myself first...
  • \$\begingroup\$ 1. I think "consecutive" needs clarification. I'm guessing that it's talking about horizontal and vertical lines but not diagonal ones. 2. Re whether it's doable: in 1D it's oeis.org/A128588 which is easy to calculate. In general it can be done in n-D by calculating all of the acceptable values in some (n-1)-D projection and then taking the power of an incidence graph, but I doubt that scales well beyond 3D. It may be possible with some investigation to get an n-D generating function, but it's hard to tell without spending a couple of hours on the problem. \$\endgroup\$ Commented Jan 27, 2017 at 16:25
  • \$\begingroup\$ In terms of complexity restrictions, asking the program to run in polynomial time in the number of cells in the grid seems reasonable (because exponential time is enough to brute-force it and it's very rare (impossible?) for a program to have a complexity in between). I don't know whether that's possible, though (although even if there's a chance that it isn't, it may still be worth asking the question). \$\endgroup\$
    – user62131
    Commented Jan 27, 2017 at 22:31

Golf Me a Bubble Sort

Your task is to create a program that performs a bubble sort.
For those who don't know, a bubble sort is a simple sorting algorithm where two adjacent items are taken & swapped if they are in the wrong order until all values are in the correct order.


  1. You must provide an explanation for how your answer does a bubble sort.
  2. You may not use built-in or standard library sorting algorithms. You must make your own code.
  3. Your program should take a group of numbers as input and output them in the correct order.
    • Input format: 10 5 9 2 . . . (and so on)
    • Output can be an array returned by the program when run.
    • Output can also be the correctly ordered values separated by whitespace.
  4. Speed does not matter as much as of the program functions.

Test Cases

  • 10 5 9 2 1 6 8 3 7 4 (you can format it differently depending on your language)
  • 1 2 5 4 3

This is , so the shortest answer in bytes wins.

  • 1
    \$\begingroup\$ It may be a better idea to have entries do only a single iteration of bubble sort; that way it will be easy to verify their correctness. \$\endgroup\$ Commented Jan 29, 2017 at 20:52

Find fixed points of the Logistic Map


Logistic Map

A logistic map is defined as the following equation:


Where the next value in the map (on the left) is determined by a function of the current value (on the right), where the constant lambda represents a set constant between zero and four (non-inclusive, along the reals).

Stable Point

A "stable point" in relation to a map is a point which is approached repeatedly by iterating the logistic map. They are distinct, and there are one to many for any given lambda.

The Task

Write a function or program which, given an input real value n between zero and four (non-inclusive), returns the number of stable points for a map where lambda is n.


Soon to be added


Main problem: Defining "stable point". Is this definition sufficient?

  • \$\begingroup\$ The definition is wrong. A fixed point of a map is a point which is mapped to itself. For the logistic map the fixed points are 0 and 1-1/x. \$\endgroup\$ Commented Jan 31, 2017 at 8:45
  • \$\begingroup\$ If you instead look for points in stable cycles, you need to also specify that the domain is the real numbers, because stable cycles correspond to roots in the polynomial obtained by iterating the map, and over the complex numbers a polynomial always has as many roots as its order. If you specify distinct points in stable cycles of any length, that becomes a real challenge. \$\endgroup\$ Commented Jan 31, 2017 at 8:55
  • \$\begingroup\$ @PeterTaylor The second one was what I was going for. :P Got my terminology wrong. \$\endgroup\$ Commented Jan 31, 2017 at 9:40
  • \$\begingroup\$ @PeterTaylor Just to verify, I'm looking for the number of distinct stable points for specific values of lambda along this graph. \$\endgroup\$ Commented Jan 31, 2017 at 9:49

Language contest

Moving this here from normal question

So, I'm kind of an esolang loony so let me propose the following contest. First of all, we do not care about speed: if two algorithms safe the same problems then they are 'equally good' at least for this challenge. Also, let's think in "special case" terms. Sorting is the problem of well... sorting a list. However, an algorithm that generates permutations of lists with an abort condition equally solves the sorting problem. However, such an algorithm is more generic as the abort condition allows it to do more stuff. In other words: sorting a list is just a special case of generating permutations with an abort condition.

The idea is to concentrate on the most generic version of an algorithm that solves a problem. In other terms: Getting rid of redundant built-ins in esoteric programming languages.

The contest would go as following: The goal is to create an esoteric concatenative language (not necessarily stack based but concatenative) with the fewest built-ins that solve all problems (in some catalog). However, this would be really boring like that because a minimized version of brainfuck would pretty much win. Thus the 'score' function would likely be a function of 'amount of built-ins' and 'average program length'. One other constraint is that you are not allowed to have redundancy in your built-ins. If you have a built-in sortAsc and sortDesc and reverse then sortAsc = reverse . sortDesc thus you are disqualified. This also means that if you have too generic loops as built-ins like uhm for loops you can use these for loops to create a sort function which means you wouldn't be allowed to have a sort function.

What do you guys think?

TL;DR optimize for program length and least amount of builtins required.

  • \$\begingroup\$ This is an interesting idea, but the rule against redundancy is problematic. It's very difficult (in fact undecidable) to say whether the built-ins of a language are redundant. It's also probable that such limitations can be circumvented with some trick, like having each function take and return a tuple (d, l), where d is some arbitrary data and l is a string that records which functions were used on the data. You might also want to define unambiguously what a "concatenative language" is. \$\endgroup\$
    – Zgarb
    Commented Jan 31, 2017 at 13:19
  • \$\begingroup\$ I agree with all of Zgarb's comments. That said, if you enforce a language paradigm, then you could define exactly what "combining commands" means. If you do do that, then I'd highly recommend making this a code-golf challenge, and dropping "least builtins" as a scoring mechanism \$\endgroup\$ Commented Jan 31, 2017 at 13:34
  • \$\begingroup\$ If you can formulate any built-in in terms of other built-ins then you have redundancy. Hidden state doesn't really count. But yes, there are likely loopholes nobody has thought about yet. \$\endgroup\$
    – mroman
    Commented Jan 31, 2017 at 14:06
  • \$\begingroup\$ @mroman Yeah, that's the definition of redundancy. But given an arbitrary list of built-ins, how can you definitively say "this list is not redundant"? Particularly with the weird stuff esolangs tend to have. \$\endgroup\$
    – Zgarb
    Commented Jan 31, 2017 at 14:17
  • \$\begingroup\$ with handwaving probably. \$\endgroup\$
    – mroman
    Commented Jan 31, 2017 at 15:09
  • \$\begingroup\$ Hmm, I've thought about this some more, and this is what I'd probably do. Drop the non-redundancy requirement, have a lot of smallish tasks (like 20 or so), and have the scoring function be something like N * 3^B, where N is the total length of the solutions to the tasks and B the number of built-ins. Then implementing a redundant built-in would only be worth it if it cut off 2/3 of your program size across all tasks. I'll have to think about it more to see if there are obvious loopholes that I've missed. \$\endgroup\$
    – Zgarb
    Commented Jan 31, 2017 at 16:58
  • \$\begingroup\$ And don't get me wrong, I think this is a superb challenge idea! :) It just needs to be done right to have a positive reception and good answers. \$\endgroup\$
    – Zgarb
    Commented Jan 31, 2017 at 17:00
  • 1
    \$\begingroup\$ As I commented elsewhere, "First of all, the assumption is that every algorithm that solves the same problem is equally fast" is nonsense, and primes readers with a background in computer science to expect the whole question to be low quality. I suggest rephrasing as "First of all, the assumption is that we don't care about performance". \$\endgroup\$ Commented Jan 31, 2017 at 17:42
  • 1
    \$\begingroup\$ Okay, I think I have found another "loophole". Suppose you have K tasks. Then you can make 3 built-ins and solve each task with a program of length 1 + ceiling(log2(K)) as follows. One built-in does "encoding": it transforms the data into some more restricted format (like multiply every list element by 2 to make them even, if the data is always a list of integers). The other two built-ins work as follows. (contd.) \$\endgroup\$
    – Zgarb
    Commented Feb 1, 2017 at 9:05
  • 1
    \$\begingroup\$ If the encoded data has been processed by fewer than ceiling(log2(K))-1 functions, they just add a unique marker to the encoding (like by appending 1 or 3 depending on the function). Otherwise, the applied built-ins (counting the current one) form a binary string of length ceiling(log2(K)), which we interpret as a base-2 number encoding the task. Then we just decode the data and solve that task. \$\endgroup\$
    – Zgarb
    Commented Feb 1, 2017 at 9:05
  • \$\begingroup\$ @PeterTaylor It just means that for this challenge it doesn't really matter how fast your program is as long as it solves the task in a (meaningful) finite amount of time. \$\endgroup\$
    – mroman
    Commented Feb 1, 2017 at 14:14
  • \$\begingroup\$ @Zgarb I can't really follow that. Do you have a more practical/real example of that loophole? \$\endgroup\$
    – mroman
    Commented Feb 1, 2017 at 14:17
  • \$\begingroup\$ If that's what it's intended to mean, write that instead, because as it stands it's very easy to interpret it as meaning something different. \$\endgroup\$ Commented Feb 1, 2017 at 14:39
  • \$\begingroup\$ @mroman Here's an implementation in Python 3. I hope you can follow it. I'm using 8 tasks as an example, which results in length-4 programs. Each program has the form Eabc, where abc is the binary encoding of the task number. \$\endgroup\$
    – Zgarb
    Commented Feb 1, 2017 at 14:47
  • \$\begingroup\$ @zgarb yeah I get it now. I guess that's legal to do. \$\endgroup\$
    – mroman
    Commented Feb 2, 2017 at 7:44

Detect skewed exponential sequences

Observe the following sequence:

1 3 9 54 162 729 2187 6561 19683

We can see that this is equivalent to:

1 *    1
1 *    3
1 *    9
2 *   27
2 *   81
3 *  243
3 *  729
3 * 2187
3 * 6561

The sequence on the right is the first 9 values of the exponential function f(x) = 3^x, that is, the exponential function of 3. It is multiplied element-wise by 1 1 1 2 2 3 3 3 3. Now, this sequences is strictly non-decreasing.

Your challenge is to, given a sequence K of length c, determine if there is a strictly non-decreasing list of integers L such that each element ej of (K / L) (element-wise division) is equal to bj, for 0 ≤ j < c, and for some b > 1.

This is a , so the shortest program in bytes wins.

True cases

1                    (1 * 1, base = any)
1 3 9                (1 1 1 * 1 3 9, base = 3)
2 4 8 32             (2 2 2 4 * 1 2 4 8, base = 2)
1 9 27               (1 3 3 * 1 3 9, base = 3)
1 5 500 2500 13125   (1 1 20 20 21 * 1 5 25 125 625, base = 5)

False cases

1 1 1 1              (false because this would have base = 0)
1 2 3 4              (no base)
1 2 4 32 16          (decreasing multiplier)
  • \$\begingroup\$ According to how you have it stated right now, the lists 1 1 1 1 and 1 2 3 4 can be done. It should be b>1 if you want it to not be possible. \$\endgroup\$ Commented Feb 1, 2017 at 18:07
  • \$\begingroup\$ @LliwTelracs Right you are. \$\endgroup\$ Commented Feb 1, 2017 at 18:43

Solve for X

Given an equation using the following symbols:

  • Parenthesis: ()
  • Operators: +-/*
  • Variable: x
  • Comparators: <=>

And the following guarantees:

  • There will only ever be one x variable.
  • x / 0 will never be in the denominator.
  • Only one comparator will be used (no >= or <=).
  • All numbers used in the input will be integers.
  • Numbers in the output may be expressed as decimals, the chosen precision should be >= 3.

Output the correct reduction for the value of x.

  • Output should be in the form: x[Operator][Decimal] (E.G. x=2)
    • 2=x is not acceptable, you must have x on the left side.

Here are a few examples (The last part in bold is the part you need to output):

2+2=x 4=x x=4

x=4*3+(2-2) x=4*3+0 x=12

1+(x/4)-2=0 1+(x/4)=2 (x/4)=1 x=4

-2*(2+x)>-1*12 -2*(2+x)>-12 (2+x)<6 x<4

-2*x<(29+1)/6 -2*x<(30)/6 -2*x+2<5 -2*x<3 x>-6

(x/-1)*(10/-4)=10*5 (x/-1)*(10/-4)=50 (x/-1)=-20 x=20

(x/-5)*-1+2*8>0 (x/-5)*-1+16>0 (x/-5)*-1>-16 (x/-5)<16 x>-80

-1*(4*(6*(x/7)))<10 (4*(6*(x/7)))>-10 (6*(x/7))>-2.5 (x/7)>-0.416 x>-2.916

This is , lowest byte-count will be deemed the winner.

  • \$\begingroup\$ I'm not convinced this can be solved faster than brute force in the general case (although a golfed solution would likely use brute force anyway). On another subject, what should be the answer for input like x>4 x<6? \$\endgroup\$
    – user62131
    Commented Feb 2, 2017 at 21:48
  • \$\begingroup\$ Return it, as is. \$\endgroup\$ Commented Feb 3, 2017 at 3:02

A kinda different large number contest

I really like large number's and code puzzles so I really like these large number contests. And I would like to have an other even if it's a duplicate. I feel like a lot of people feel the same way.

So I had to be creative and come up with a slight variation. I had the idea of prohibiting recursion since most of the fast growing techniques require it. Practically I might a accomplish this by only allowing a single array/list for memory.

I think it's almost impossible to avoid this idea being closed as a duplicate of Largest Number Printable but if there is interest I will work it out a lot more. And maybe I will be able to convince 5 people it's an interesting competition despite of the duplicate.

(And in case this is unclear it would be a you have X bytes to make a program the outputs the largest number)

Do you have any further ideas, suggestions or tags? Or are you even interested?

  • \$\begingroup\$ So print the biggest number you can in O(1) complexity? \$\endgroup\$
    – Riker
    Commented Feb 3, 2017 at 18:57
  • \$\begingroup\$ 1. Neither the accepted answer nor the top 4 (arguably 5) voted answers in Largest Number Printable use recursion. 2. Bounding the memory is probably quite hard to specify well, but if you do manage it then essentially all you will achieve is to force all the answers to work by counting so as to go through every possible distinct state. \$\endgroup\$ Commented Feb 3, 2017 at 22:22
  • \$\begingroup\$ It's always possible to translate a recursive program into a corresponding iterative program (if the language is sufficiently powerful, but not much power is required, e.g. C is powerful enough). Depending on the language, this might or might not make the program significantly longer. Likewise, it's always possible to take a program that stores data in multiple places and change it so that it uses a single array for all storage (again, assuming appropriate language features that most languages will have). \$\endgroup\$
    – user62131
    Commented Feb 7, 2017 at 3:42
  • \$\begingroup\$ @PeterTaylor Hehe, I managed to squeeze some recursion up in there if you haven't checked :-) \$\endgroup\$ Commented Jul 31, 2017 at 23:30
  • \$\begingroup\$ Another related proposal I just made: Can you surpass Γ<sub>0</sub>? For those serious about making extremely large numbers. \$\endgroup\$ Commented Jul 31, 2017 at 23:32

Conjugate a Spanish Verb

A Little Background

I thought up this challenge, believe it or not, in a spanish class. I was thinking how simple it is to conjugate regular spanish present tense verbs and the programmer in me told me to make a question about it on PPCG

The Challenge

Given a regular Spanish infinitive and a subject, conjugate the infinitive in the present. How to do such a thing. For the sake of simplicity assume that all of the verbs are regular infinitives not irregular, stem-changing or reflexive.


-The input may be given in any reasonable format

subject verb | verb subject| subject,verb | ["subject", "verb"] etc. 

-If the input is not valid you may output anything or nothing at all

-The input is not valid if

a) It does not contain a regular, spanish, infinitive verb or a Spanish subject

b) It is not in the appropriate format, which you must specify

-The output can have any capitalization and is alowed trailing whitespace

Test Cases

Assume the input is given as "verb, subject" (Without the quotes)

comer, yo              --> como
ir, vosotros           --> Anything (Irregular)
jugar, ellas           --> Anything (Stem Changing)
                       --> Anything (Empty)
gsmkhnjkgn, tu         --> Anything (Not a verb)
sacar, ésdfgs          --> Anything (Not a subject)

Fraction Frenzy!


Your task is to generate the list of reciprocals of the Fraction Frenzy function (FF(n)) given a positive integer n.


Before I can introduce the FF function, I have to first explain Egyptian fractions.

Egyptian fractions are a way of expressing fractions as the sum of distinct unit fractions - so one way to express the fraction 5/8 is 1/2 + 1/8. It is not other fraction sums like

1/4 + 1/4 + 1/8
1/2 + 1/16 + 1/16

because not all of their fractions are distinct (1/4 is repeated in the first example, and 1/16 in the second).

The FF (Fraction Frenzy) function is described like so:

FF(1) is the Egyptian fraction 1/2 + 1/3 + 1/5 + 1/-30.

FF(2) is equal to FF(1) "multiplied" by itself (FF(1) "squared"):

  (1/2 + 1/3 + 1/5 + 1/-30)(1/2 + 1/3 + 1/5 + 1/-30)
= 1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900

This is not a fully reduced Egyptian fraction yet, because there are "repeats" in fractions. To reduce them, the following procedure is done:

  1. Sum all "like" unit fractions together.
  2. Reduce the sums to their simplest forms - so for example, if a sum from step 1 is 2/6, that can be reduced to 1/3.
  3. Repeat 1 and 2 until all reciprocals are distinct.
  4. If there is a pair of one positive and one negative fraction that have an equal absolute value, remove both of them (e.g. 1/-5 and 1/5 must both be removed)
  5. If fractions are not unit and cannot be reduced further, split it up into unit fractions with a equal denominator, and keep one fraction as it is. With the other ones, multiply them by (1/2 + 1/3 + 1/5 + 1/-30).
  6. Repeat until the final fraction sum is a valid Egyptian fraction.

This is the reduction of FF(2):

  1/4 + 1/6 + 1/10 + 1/-60 + 1/6 + 1/9 + 1/15 + 1/-90 +
  1/10 + 1/15 + 1/25 + 1/-150 + 1/-60 + 1/-90 + 1/-150 + 1/900
= 1/4 + 2/6 + 1/9 + 2/10 + 2/15 + 1/25 + 2/-60 + 2/-90 + 2/-150 + 1/900 (step 1)
= 1/4 + 1/3 + 1/9 + 1/5 + 2/15 + 1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900   (step 2)
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/15(1/2 + 1/3 + 1/5 + 1/-30) +        (step 5)
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/30 + 1/45 + 1/75 + 1/-450 +
  1/25 + 1/-30 + 1/-45 + 1/-75 + 1/900
= 1/3 + 1/4 + 1/5 + 1/9 + 1/15 + 1/25 + 1/-450 + 1/900                  (step 4)

For all n (except for 1), FF(n) is defined by "squaring" FF(n-1).

Input and Output:

Given an integer n, you must output a list all of the reciprocals of FF(n), sorted in ascending order:

1 -> [2, 3, 5, -30]
2 -> [3, 4, 5, 9, 15, 25, -450, 900]

You are allowed to use a string with any delimiter, or your language's interpretation of a list.


  • You must output the results of the FF(n) function exactly as specified above.
  • You are guaranteed that the input will be a positive integer - it will never be below zero, and it will never be a decimal (or fraction).
  • \$\begingroup\$ ^vote, I'm trying to see if there's a non-recursive method, because currently it's O(n^2) according to the problem specs. \$\endgroup\$
    – user42649
    Commented Feb 4, 2017 at 0:52
  • \$\begingroup\$ I think step 2 ("Reduce the sums to their simplest forms") needs to be more carefully specified. What is the simplest form of a given fraction? \$\endgroup\$ Commented Feb 4, 2017 at 21:22


Take 3 inputs, and output truey or falsey depending on whether or not they make an multiplication/division fact family. (2 * 4 = 8, 4 * 2 = 8, 8 / 2 = 4, 8 / 4 = 2) Order does not matter, as long as in some way the three numbers make an fact family. Repeated numbers are allowed.

Truey Inputs

2 4 8 
100 20 5 
7 7 49

Falsey Inputs

7 8 9
12 3 0
512 600 73

The values should be passed to the program as parameters or variables. Expect that only positive integers, and only 3 of them, will be passed to the program. You may write either a full program or a function, which either prints or returns the result. This is code-golf, so the shortest answer in bytes wins. Standard loopholes are forbidden.

  • 1
    \$\begingroup\$ This is a duplicate of an existing challenge (the reason why it was closed on main) \$\endgroup\$
    – user41805
    Commented Feb 6, 2017 at 18:51
  • 2
    \$\begingroup\$ Were you going to change this to multiplication/division families? \$\endgroup\$ Commented Feb 6, 2017 at 18:51
  • \$\begingroup\$ Changed it up. I also removed my first one from the main. \$\endgroup\$ Commented Feb 6, 2017 at 19:51
  • \$\begingroup\$ Will the input numbers always be nonnegative integers? \$\endgroup\$ Commented Feb 7, 2017 at 0:43
  • \$\begingroup\$ Edited Question \$\endgroup\$ Commented Feb 7, 2017 at 0:46
  • \$\begingroup\$ IMO changing + to * and /2 to sqrt doesn't make this a different question and it's still a dupe. \$\endgroup\$ Commented Feb 7, 2017 at 9:53

ACME (Let's Encrypt) client

A list of ACME clients already looks a bit like a PPCG leaderboard, but I don't see the typical esolang roster there. Let's Augment.

The task is in minimum number of bytes get a valid certificate for specified domain (assuming running from a directory that is accessible from web server of this domain. Or just also embedding a web server.).

  • \$\begingroup\$ Shall usage of openssl (libary or binary) be allowed or it should be a "hard mode" puzzle? \$\endgroup\$
    – Vi.
    Commented Feb 7, 2017 at 2:21
  • \$\begingroup\$ What does "assuming running from a directory that is accessible from web server of this domain" mean? That we can assume Apache / nginx / lighttpd / whatever is set up to execute our script? \$\endgroup\$ Commented Feb 7, 2017 at 9:51
  • \$\begingroup\$ @PeterTaylor, No. The script contacts ACME server, gets challenge, writes it to current directory. Then ACME server downloads the file (using pre-existing web server configured for this directory) and replies with a signed certificate, which we should save or print. \$\endgroup\$
    – Vi.
    Commented Feb 7, 2017 at 11:56
  • \$\begingroup\$ Follow-up questions: 1. Which version of ACME? 2. Which parts must be supported? 3. What will the inputs to the client be? I'm sure that detailed reading of the ACME spec will throw up more questions. \$\endgroup\$ Commented Feb 7, 2017 at 12:49
  • \$\begingroup\$ 1. -> To discretion of the answerer, 2. -> HTTP challenge. Some minimal mode to get the cert. 3. -> Domain name. \$\endgroup\$
    – Vi.
    Commented Feb 7, 2017 at 13:46

What I'm Planning to Post:

Print the number of bytes (not characters, bytes) in the program, without hardcoding the number (i.e. code like print(8) is not allowed).

If the code is added to (e.g. with a comment) it should change automatically without needing to change anything else.

Example (un-golfed) program in Python 3:

file = open(__file__)
data = file.read()

This is so the shortest answer in bytes wins.

What I Want to Check/Know:

  1. Does this count as ?
  2. Has this already been done? To what extent do the rules of a 'Duplicate' question apply here? (I have done some searching...)
  3. What should my challenge title be? I cannot think of any fitting ones.
  4. Should I include the example (un-golfed) program in my post, or does that make it too easy?
  • \$\begingroup\$ Thanks for posting in the Sandbox first. Why is hard-coding banned? If the code is added to, hardcoding may or may not help, so I don't see much point in banning this. Also, your code is wrong; that's a false-quine, not the program length. \$\endgroup\$
    – wizzwizz4
    Commented Feb 9, 2017 at 19:22
  • \$\begingroup\$ Sorry. I meant to put a len() in there too. Hard-coding is banned because in many esolangs, a single byte will just output the simple integer 1 (or similar). \$\endgroup\$
    – retnikt
    Commented Feb 9, 2017 at 19:26
  • \$\begingroup\$ But if you edit the program to add comments, that program will stop working. \$\endgroup\$
    – wizzwizz4
    Commented Feb 9, 2017 at 19:30
  • \$\begingroup\$ Welcome to PPCG! Thanks for using the sandbox. I swear we've had a challenge similar to this, but I can't seem to find it. I'll keep looking. \$\endgroup\$ Commented Feb 9, 2017 at 19:31
  • 1
    \$\begingroup\$ This wouldn't be a kolmogorov-complexity. That tag is for outputting some constant, predefined string. Including an example implementation is fine, it's fairly common practice, but usually it contains a very naive or brute-force algorithm for the problem that wouldn't actually make a good solution (even when golfed). \$\endgroup\$ Commented Feb 9, 2017 at 20:15
  • 1
    \$\begingroup\$ Yes, it has been done: codegolf.stackexchange.com/q/27079/194 \$\endgroup\$ Commented Feb 10, 2017 at 11:08

Roman Dates

The Romans measured dates based on three days every month:
The Kalends, or the 1st
The Nones, which was usually on the 5th,
and the Ides, which was usually on the 13th.

In March, May, July, and October the Ides and Nones fall two days later, on the 7th and 15th.


There are two forms of the months that matter for this challenge:

  1. Ianuariis
  2. Februriis
  3. Martiis
  4. Aprilibus
  5. Maiis
  6. Iuniis
  7. Iuliis
  8. Augustis
  9. Septembribus
  10. Octobribus
  11. Novembribus
  12. Decembribus

And Accusative:

  1. Ianuarias
  2. Februarias
  3. Martias
  4. Apriles
  5. Maias
  6. Iunias
  7. Iulias
  8. Augustas
  9. Septembres
  10. Octobres
  11. Novembres
  12. Decembres

Calculation of dates

On the day of one of them, they used the ablative of the day (Kalendis, nonis, or Idibus) combined with the ablative of the month (e.g. Idibus martiis)

One day before one of them they used pridie with the accusative of the day (Kalendas, Nonas, and Idus) and month (e.g. pridie nones septembres)

The Romans calculated the date as how many days until the next one of these, counting inclusively. They used a.d. and the number of days until the next one in lowercase roman numerals, and then the day and month in accusative (e.g. a.d. xxii Kalendas Iulias)


The years are counted since the Founding of the city of Rome in 753 B.C.E., with A.U.C. appended to the end of it.


The challenge is, give an input of a day, month, and year in any preferred format, to return a string given the Roman date.

As this is code-golf, the code with the shortest bytes wins, and the standard loopholes are disallowed.


Milking the cows

When I was a kid, we used to play a card game called "Milking the cows". I have no idea why it was called that, as it had nothing to do with said activity, but whatever. For months we would play furiously, seeing who was best at this game.

It wasn't until years later that I realized the game is completely deterministic. All my hours of practice turned out to have been pointless. But now it does make for an interesting code-golf.

Rules of the game

There are two players. Each is dealt half of a standard pack of shuffled cards. Every round, both players draw the top two cards from their respective decks and compare values. The highest scoring pair wins, and that player adds all captured cards to his stack of cards (at the bottom). In case of a draw, both players draw one additional card and compare again (If this is again a draw, another card is drawn, etc)

The game continues with both sides drawing cards until one player is unable to draw another card, at which point they lose and their opponent wins the game.

Card values are equal to the printed number for number cards, Aces are 11 points and J/Q/K are all 10.

The challenge

Given an input string of 52 characters representing the cards (without suit, since it doesn't matter in this game), deal the first 26 to player 1, the rest to player 2, and then determine who wins that match of Milking the cows.

The characters sent are 2,3,4,5,6,7,8,9,T,J,Q,K,A for the numbers, Ten, Jack, Queen, King and Ace. It can be assumed that the input string is correct and contains exactly 4 of each character.

The top of the stack is on the right side; the bottom of the stack is on the left side. Cards are always drawn or put back on the bottom one at a time

When a round is won, cards are added to the bottom of the winner's stack, starting with the opponent's cards and then the own cards, in the order they were drawn.

When the winner is determined, output the number of the player that won. It is possible (but phenomenally unlikely) for the game to end in a draw, because both players are unable to draw a card. In this case, output 0.

Example of a round:

Player 1's stack: QTKJ42336K59QKJ77T8J953485

Player 2's stack: JTK676ATQ8A576429Q2A948A23

Player 1 draws: 5, 8

Player 2 draws: 3, 2

Player 1 wins the round (13 points vs 5)

Player 1's new stack: 8523QTKJ42336K59QKJ77T8J9534

Player 2's new stack: JTK676ATQ8A576429Q2A948A


69K9A9QJ8TT33A88KQ685J97AQK224Q2726T73547K6J554J4AT3 -> 2
98JK947A5K283A5A2TAJ6K278T4TQT73674Q956JK94Q68QJ3352 -> 2
9T87J2K38KJT846558A2Q4A95395T67936A7Q2J4TQAK623JKQ74 -> 1
J67835828K48KA45TQ546JQ479TA2JT2Q933K27JT69KA9735QA6 -> 1
23456789TJQKA23456789TJQKA23456789TJQKA23456789TJQKA -> 0


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

  • \$\begingroup\$ Welcome to PPCG! Thanks for using the sandbox. Can you elaborate a bit on what makes this much different than Determine the winner of a game of War? Is it just the fact that the top two cards are compared instead of only the top card? \$\endgroup\$ Commented Feb 14, 2017 at 15:37
  • \$\begingroup\$ Ah, they're very similar indeed - I didn't know this game had different names in other languages. The biggest difference is probably checking for ties (which almost never happens) but I'm not sure if it's worth a new challenge. \$\endgroup\$
    – Erik
    Commented Feb 14, 2017 at 15:40

Convert to polynomial base numbers


Base Representation

Bases may be written with the following generalization (let concatenation just represent adjacency in digits; 10 = ab when a = 1, b = 0):

abcdex = ax^4 + bx^3 + cx^2 + dx^1 + ex^0

Essentially, we can write in any base we want such that the last digit is base to the power 0, penultimate digit is base to the power 1, etc. When we make the base a variable (x), we can represent a polynomial with a number.

Representation Overflow

Let's take our example before with abcdex. What happens when our representation for numbers (base 10 for our case) becomes too large to represent with a single character? Why, we use the tilda (~) on both sides of the value.

Thus, if we had the conditions a = 9, b = 32, c = 2, d = 43, e = 10 and were restricted to writing with base 10 representations for each value, our number may be represented as 9~32~2~43~~10~x.

Minimized Polynomials

For this challenge, I will occasionally refer to "Minimized Polynomials". When I say this, I mean that there will be no spaces in the polynomial string, terms with coefficients of zero will not be shown, and polynomials will be written in terms of greatest term first.

For example, the following is not a minimized polynomial:

x^2 + x^0 + 5 * x^4 + 0x^1

The following is the first example's minimized form:


The Task

Given a valid minimized polynomial string input n, write a function or program which returns or prints the polynomial base representation of the value in base 10, allowing for representation overflow.


Let f be the function described in the task:

>>> f("1x^4+1x^3+1x^2+1x^1+1x^0")

>>> f("6x^3+1x^1+5x^0")

>>> f("20x^4+4x^3+1x^1")

>>> f("300x^6+30x^4+40x^3+2x^2+1x^0")
  • \$\begingroup\$ The introduction seems backwards to me. I think that what it's trying to express is that by representing numbers in base b you can show a bijection between the ring of natural numbers N and the ring of polynomials over the integers modulo b, (Z/bZ)[x], but that's not what it really communicates. In particular, "we can represent a polynomial with a number" seems to be talking about an injection Z[x] -> N (or maybe Z[x] -> Z), and while they do exist they're more complicated than anything described in this question. \$\endgroup\$ Commented Feb 15, 2017 at 16:55
  • \$\begingroup\$ In fact, the section on overflow explains why the ideas in the introduction break down. Once the coefficients cease to be elements of 0..b-1 base conversion gives aliasing. The workaround of introducing tildes means that what you have is no longer a base-b number, so the title is wrong. \$\endgroup\$ Commented Feb 15, 2017 at 16:58
  • \$\begingroup\$ @PeterTaylor I have no idea what your first comment is saying. Is your second comment suggesting that I rename this to "Convert minimized polynomial to shorthand polynomial" or similar? \$\endgroup\$ Commented Feb 15, 2017 at 18:17
  • 1
    \$\begingroup\$ Really the whole stuff about base conversion is a red herring: the task consists in parsing a polynomial, filling in the zero coefficients, and then rendering them with conditional wrapping in tildes. \$\endgroup\$ Commented Feb 15, 2017 at 21:45

Multiplication puzzle using digits 1-9

The puzzle is to use the digits 1-9 inclusive, exactly once, to fill in the blanks such that:

_ _ _ _ * 3 = _ _ _ _ _

Your task is to create the shortest program that finds all solutions to the equation.

  • \$\begingroup\$ Is this exactly 4 characters * 3 = 5 characters? or is this any amount * 3 = any amount? \$\endgroup\$
    – ATaco
    Commented Feb 16, 2017 at 0:12
  • \$\begingroup\$ Thanks for your comment. It's a 4 digit int multiplied by 3 = a 5 digit int \$\endgroup\$ Commented Feb 16, 2017 at 8:38
  • \$\begingroup\$ You should give the output list for reference. Submissions can hardcode an output, so if there's few solutions, you should change the problem so that there's many. \$\endgroup\$
    – xnor
    Commented Feb 16, 2017 at 11:13
  • \$\begingroup\$ There are two solutions. It's not clear what output format is expected, but if 5823 5832 is acceptable output then hardcoding that is likely to be much shorter than any approach which uses calculation. \$\endgroup\$ Commented Feb 16, 2017 at 11:20
  • \$\begingroup\$ Should I edit the rules to say that the solutions can't be hardcoded and that the program must output both the 4 and 5 digit numbers? \$\endgroup\$ Commented Feb 16, 2017 at 14:15
  • \$\begingroup\$ You could for example change the hardcoded 3 to a number N which should be received as input. This way hardcoding the output becomes much less desirable. EDIT: Actually, I don't know if this puzzle also has solutions for other values of N \$\endgroup\$
    – Leo
    Commented Feb 16, 2017 at 14:21
  • \$\begingroup\$ @Leo, yes, and it has loads for N=8. That's a great suggestion. \$\endgroup\$ Commented Feb 16, 2017 at 14:50

Mathematical Creativity

At our workplace we are so creative that sometimes we decide that today the number 2=9, 0=231 or 67=5... just for the sake of it. So for that day everyone in the workplace must consider that fact.

Your task is to write a full program or function that takes as input today's value of the decided number, which operation to perform and output the result, of course the new number's value affects also the result.


  1. Only positive integers >= 0and <= 1000000.
  2. The math operations to perform are only sum +, subtraction - or multiplication *.
  3. The input is taken from standard input in any reasonable format for example: [N V X + Y], N,V,X,+,Y, NVX+Y, ("N","V","X","+","Y"), ['N','V','X','+','Y'], etc.
  4. First parameter N is the choosen number.
  5. Second parameter V is new value of N.
  6. Third parameter X is the first number of the math operation.
  7. Fourth parameter is the math operation to perfom, can be only +, -, *.
  8. Fifth parameter Y is the second number of the math operation.

Explained example:

  1. Input 5,27,252,+,3.
  2. All the 5's becomes 27 so 254+3 -> 2272+3=2275 but the result is 2275, it contains 5 so it becomes 22727.
  3. No recursive substitution or infinite loop is needed. The substitution must be performed only once on X,Y and on the result.

Example inputs / outputs:

Input              > Output
5,27,252,+,3       > 2272+3=22727 
45,0,237456,-,4567 > 23706-067=23639
9,7,349,*,7        > 347*7=2427
121,1,1212121,+,0  > 121+0=1
5,55,555,+,5555    > 555555+55555555=556111110
10,5,11000,*,10    > 1500*5=7500
1,2,3,+,4          > 3+4=7
4,4,3,+,4          > 3+4=7


  1. The number substitution must be performed only once on the first two numbers X,Y and only once on the final result. No recursive substitution or infinite loops are needed.
  2. The output must contain the full math operation, not only the final result, for example: 2272+3=22727.
  3. This is so the shortest code wins.
  4. Standard loopholes are forbidden.

Sandbox questions:

  1. Is this a duplicate of another question? I thought it would already exist but couldn't find any challenge by searching. If you know of it please let me know.
  2. Is the input enough clear or is it possible to improve in some way?
  3. Is the challenge clear?
  4. Tags:
  5. Suggestion for title?
  • \$\begingroup\$ Should the substitution be performed only once, or once for each occurrence, or recursively until no occurrence remains? Consider, for example, 121,1,1212121,+,0. Then you should also specify what happens with infinite loops. Compare with this proposal and my comment there. \$\endgroup\$
    – Zgarb
    Commented Feb 14, 2017 at 14:32
  • 1
    \$\begingroup\$ What will the output be for input 5,55,555,+,5555? \$\endgroup\$
    – user41805
    Commented Feb 14, 2017 at 14:32
  • \$\begingroup\$ @Zgarb thanks for pointing that out, only one-time substitution is needed on the first numbers and the result, no recursivity or loops. I added your example in the test cases. \$\endgroup\$
    – Mario
    Commented Feb 14, 2017 at 14:46
  • \$\begingroup\$ @KritixiLithos I added your suggested example in the test cases. \$\endgroup\$
    – Mario
    Commented Feb 14, 2017 at 14:47

Hex address to little endian escaped string

You are a brilliant hacker and you just gained access to a unprotected computer! To complete your exploitation, you need to convert a set of hexadecimal addresses into a different format.

You remember your lessons from university and you find out the machine you're on is little endian, meaning the order of the bytes is "reversed".

To make a break from your illegal activity, you decide to code a little program that does that automatically.

The Goal

Convert a string of the form




You set up a few tests and their potential results:

0x080483b4   =>   \xb4\x83\x04\x08
0x00000fff   =>   \xff\x0f\x00\x00
0xfffffff0   =>   \xf0\xff\xff\xff
0xefbeadde   =>   \xde\xad\xbe\xef


The input is of the form 0xXXXXXXXX and the output must be of the form \xXX\xXX\xXX\xXX. The input will always be 10 chars long and the output must be 16 chars long.

The score is the number of bytes used to write the encoding function. If the input string appears in the solution (i.e. not passed as an argument) it is not taken into account. The display of the result is implied (e.g. no need to print, puts, ...).

  • 1
    \$\begingroup\$ Is this question trying to allow snippets? That's not normally what we do here, so if you want it, you'll have to be explicit about specifically what sort of programs are accepted. If it's unintentional, see here for our normal I/O standards (you can link that in your question if you like), and ask for a "program or function"; note that your example solution isn't a program or a function, so it would need changing. (You probably don't need to give an example solution at all, though; and if you have one, you can post it as an answer.) \$\endgroup\$
    – user62131
    Commented Feb 19, 2017 at 12:25
  • \$\begingroup\$ So if I'm understanding correctly, I need to make the type of code more explicit? I wasn't sure how to make it work for all languages, ... Also I'm not sure about needing the return statement for this challenge, nor the print ... What do you think? I'll remove the example for later, thanks :) \$\endgroup\$
    – nobe4
    Commented Feb 19, 2017 at 16:25
  • 1
    \$\begingroup\$ The problem is more that we have a lot of standard rules already that go into a lot of detail on what's allowed and what isn't, because they're too complex to really fit into one post. The way your question is worded, you're trying to override that (i.e. allow things that are disallowed by the rules), which means that you'd need to go to a lot more effort to explain exactly what's allowed and what isn't. You can certainly override the standard rules if there's a good reason, but it's rather more complex than just going along with them. \$\endgroup\$
    – user62131
    Commented Feb 19, 2017 at 20:38

Associativity Conversion

Operators that aren't associative usually come with some implicit associativity which let you omit parentheses in some expressions for readability. E.g. for a left-associative operator $, the following parentheses are assumed:

a $ b $ c $ d ≡ ((a $ b) $ c) $ d

But for a right-associative operator, the implied parentheses are these:

a $ b $ c $ d ≡ a $ (b $ (c $ d))

For this challenge, we will use an "invisible" operator (that is, we'll simply write abcd for ((ab)c)d or a(b(cd))). Your task is to take some valid expression of that operator as input, where the operator will be assumed to be left-associative. You should then output an equivalent expression, where the operator is assumed to be right-associative.


Consider the input:


First, let's insert all parentheses that are implied by the operator's left-associativity:


Now we want to rewrite this in a right-associative fashion. Therefore, we drop all parentheses start at the right end of a subexpression:


We cannot remove any further parentheses because that would change the implied parentheses.


small print and test cases

  • \$\begingroup\$ I'm not sure quite how to correct "Therefore, we drop all parentheses start at the right end of a subexpression". To make it parse it would suffice to change start to starting, but doesn't every parenthesis start at the right end of a subexpression? Perhaps it would be simpler to just add a tree diagram instead of adding parentheses? \$\endgroup\$ Commented Feb 21, 2017 at 22:51
  • \$\begingroup\$ @PeterTaylor I guess I meant "starting at the right end of the surrounding subexpression" but that's not much clearer. I'll think about it. \$\endgroup\$ Commented Feb 23, 2017 at 16:05

Starry Starry Night

This challenge needs a lot of work in my opinion, especially refining rules on input-output, I want to leave it as open as possible, while excluding unfair methods such as pre-drawn graphs etc.

some parts of this are currently extremely vague, please ask any questions you believe might be important.

i'll be adding some graphics in to help explain what the challenge is about at a glance though.

Does anyone else sometimes looks up at the stars and ponder the great mathematical questions of our time, Does P=NP if you just want to check a bus timetable, can a 'try/catch' block solve the halting problem, and how far would that star need to move to form an equilateral triangle..

given an array of 6 numbers, consisting of 3 arrays containing two numbers between 0-255 each, i.e.


return the change required to be made to a single point, to have the three points form an equilateral triangle.


  • Can be taken as 6 distinct integers, an array of arrays, a single array, or a set of three objects with x/y as named/default properties,
    • these input formats are loose and whatever best suits your language should be used, within reason (i.e. - mathematica cannot use a pre-drawn graph as input)
  • no two points will be on the same x/y, and 0 will never appear as any single x or y co-ordinate


  • Only one out of the three co-ordinates can be modified, the other two must remain unchanged
  • Can be given graphically on a grid, a returned 'modified' version of the original input, or as an output of the values changed (i.e. 40->55;30->99)
  • you're looking up at the sky, your numbers can easily be off by a bit, the returned values are only required to be accurate to the whole number, rounding up or down is allowed
  • you do not have to achieve the smallest distance, or smallest/largest resulting triangle, any mathematically equilateral triangle will be correct

Examples:(still have to actually calculate these) [[20,113],[63,17],[40,161]] [[43,119],[183,197],[103,86]] [[144,216],[108,203],[113,199]] [[197,131],[217,7],[13,77]] [[100,60],[26,107],[130,241]] [[209,61],[208,98],[47,94]] [[48,78],[179,135],[52,119]] [[93,148],[124,226],[137,118]] [[65,21],[168,167],[221,56]] [[89,118],[48,181],[29,98]]

  • \$\begingroup\$ When you say "rounding is not strict, and can be 1 number either side of a resulting decimal value" does that mean that the output can be a whole number obtained by rounding up or down? \$\endgroup\$ Commented Feb 21, 2017 at 12:28
  • \$\begingroup\$ @PeterTaylor that's correct, i'll clarify it a bit further, would the returned values are only required to be accurate to the whole number, rounding up or down is allowed be a bit more specific? \$\endgroup\$
    – colsw
    Commented Feb 21, 2017 at 14:38
  • \$\begingroup\$ Yes, that's fine. The really ambiguous part was "1 number", where it wasn't clear how many decimal places were expected. \$\endgroup\$ Commented Feb 21, 2017 at 14:43

Triangular Numbers

Compute the nth triangular number. Triangular numbers are the number of things in a size x triangle (n(n+1)/2).


0 0
1 1
2 3
3 6
7 28
34 595

IO in any allowed form, standard loopholes apply.

  • 1
    \$\begingroup\$ This would make for an interesting challenge, but the question is highly unlikely to receive many upvotes without more explanation (clearer spec, test-cases, the definition of the triangular numbers, etc. The definition is important because we require that challenges should require as little knowledge/research to solve as possible) \$\endgroup\$ Commented Feb 23, 2017 at 23:45
  • 1
    \$\begingroup\$ Also, this is a subset of Polygonal Numbers! (though that may not matter as there may be different golfy approaches in various languages, and also that challenge wasn't taken very well and has few answers) \$\endgroup\$ Commented Feb 23, 2017 at 23:47

Ultimatum Game

You and a (not so) friendly bot have a chance to play a game. There is 100 dollars on the table. One person, suggests a split, and the other can accept the split, or force each individual to accept absolutely nothing. You will alternate being able to give the ultimatum for a substantially large number (1000) rounds. This process will proceed in a round robin fashion till every bot has played all the others exactly once. Your score in this manner, will just be the total amount of money you collect.

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 if you are giving the ultimatum. When you receive an invocation like this, you would be the one propsing a split.

foolanguage myBot.foo 4 ultimatum 1 reject 10 reject 20 reject 25 accept 

Or, like this if you are the one considering the ultimatum. You will be tasked with either accepting the split, or rejecting it (both bots get 0).

foolanguage myBot.foo 4 accepting 1 reject 10 reject 20 reject 25 accept 1

The first number represents the number of rounds played (n). The second will be a string either "Ultimatum" or accept/ reject. Next will follow 2n+1 strings. The first 2n will be offers and what the choice was. The last string will be the current offer.


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 either the number it will offer, or (if they are the one who has to consider the offer), ("a" for accept/ "r" for reject) within 50 ms.

Your bot must be be able to make both choices (accept or reject). 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 hash to ensure you don't tweak it in light of other submissions.

In the spirit of fair competition, no access to the file system (or OS calls). I will allow the option to write to a maximum of one text file which can have a maximum size of 8 megabytes. Solutions will be tested within a virtual machine imaged with the latest version of linux on my home desktop which has an Intel i7-4770 quad core 3.4 gHZ cpu.

  • \$\begingroup\$ I believe we already have had a prisoners dilemma KOTH... \$\endgroup\$ Commented Feb 25, 2017 at 21:34
  • \$\begingroup\$ @LliwTelracs I do believe the strategy here is entirely different, and brings up some interesting effects. Most notably, the asymmetry of the situation, and the information which you have. \$\endgroup\$ Commented Feb 25, 2017 at 21:55
  • 1
    \$\begingroup\$ 1. I suggest rewriting the input spec to pass via stdin instead of the command line. Some shells have command line length limits: e.g. on most versions of Windows you'll only be able to get up to about 820 rounds with the current format. Using stdin would also allow newlines, which would make the format easier for humans to read and understand. Also, what does the accepting in the second example mean? 2. I presume that the score is the total amount of money you make over all rounds and all games, but this should be made explicit. \$\endgroup\$ Commented Feb 26, 2017 at 8:52
  • \$\begingroup\$ I fear this challenge would be dominated by bots offering a 99/1 split and accepting any offer of at least 1 dollar, with no consideration for the history \$\endgroup\$
    – Leo
    Commented Feb 26, 2017 at 13:57
  • 1
    \$\begingroup\$ @Leo I plan on creating a few sample bots, which will mimic human behavior. For example, one bot might reject offers less than 25. Another, might grew more and more likely to reject offers based on the average money allocated. Another might only offer (and accept) splits of 50/50 (or better). This way, good solutions will cater to such bots. \$\endgroup\$ Commented Feb 26, 2017 at 14:07
  • \$\begingroup\$ I was going to write a 50/50 bot, so I would be sad if that's already taken by a sample bot - unless the samples are clearly only for development and not participating in the final contest. \$\endgroup\$ Commented Feb 27, 2017 at 9:26
  • \$\begingroup\$ @PeterTaylor sure, I could make it that way, sample bots are only for developement \$\endgroup\$ Commented Feb 27, 2017 at 11:50
104 105
107 108

You must log in to answer this question.

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