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

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

## 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]

# Repeatedly convert from minimal base to base 36

Your task is to convert an input of a list of strings which represent arbitrarily large numbers from the lowest possible base to base 36, repeatedly, until there is no further change to be made.

## Rules:

• You may not use base conversion builtins.
• From 0 to 35 in base 36 is defined as:
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z
• All submissions will be tested on this cloud 9 workspace and should be uploaded for testing (along with any updates) on this GitHub repository.
• All submissions must be written for compilers/interpreters that:
• Are free to use.
• Do not take up excessive space.
• Can run with simple installations on Ubuntu 14.04.

# Test Cases:

Coming soon
• Do you expect to get runtimes large enough to be measurable? – Peter Taylor Mar 1 '16 at 10:32
• @PeterTaylor Yes - I expect to convert lists of large (arbitrarily precise) numbers. – Addison Crump Mar 1 '16 at 13:17
• That doesn't really answer the question. A random 1000-digit base-35 input will become a roughly 990-digit base-36 string after the first step, and the probability of going to a second step is about (1/36)^990, which is pretty negligible. But one base conversion of a number on the order of 1000 digits isn't going to take long enough to time. I would hazard a guess that you need input on the order of hundreds of millions of digits to be timeable, and then the business with the loop is completely pointless because for practical purposes it will always run once. – Peter Taylor Mar 1 '16 at 15:43

# Elementary Cellular Automata, My Dear Watson code-golf

A seemingly innocent dinner party composed of elementary cellular automata has just been turned into a murder mystery. One of the cellular automaton guests has killed the host! All that remains as evidence for who committed the crime is the nth generation of the perpetrator. Luckily for them, Sherlock Holmes is on the case.

Show Watson how it's done by taking an integer n, and a string representation of the nth generation of the murderous automaton and printing or returning a list of the possible suspects (the numbers representing the rule of each amphichiral elementary cellular automata, see the bottom of the linked page.)

### Rules:

• The input string will have length 2n+3 for the nth generation.
• The first character of the string represents the values on the infinite tape to the left, and the last character of the string represents the same for the right.
• Assume that the automata start with a single 1 in the center of a string of all 0s.

### Example

Generation 0 of every automaton:

010

### Notes:

• I don't have a reference implementation yet, nor have I created any examples.
• What is this string representation? Will it be padded with zeros? – LegionMammal978 Sep 26 '15 at 17:24
• Then again, you would need a way to show the background (Rule 255, for example, would need infinite bits.) Also, should we assume that it starts with a single one in a background of zeros? – LegionMammal978 Sep 26 '15 at 19:53
• So wait... You aren't given the full generation? Also, do the generations start at 1 or 0? – LegionMammal978 Sep 26 '15 at 20:40
• Looking at your Mathworld link, it seems that you would need 2 background bits. – LegionMammal978 Sep 26 '15 at 21:21
• If I were a Haskell programmer, I would feel rather hard-done-by that the spec seems to require using an IO monad even if I'm writing a function rather than a full program. Is the special-cased output really worth it? – Peter Taylor Mar 1 '16 at 21:07
• @PeterTaylor I suppose you're right. Updated. Also, perhaps someone could help with a reference implementation, or least some examples? The effort it would take me to create a solution is probably more than someone else. I don't really know a lot about cellular automata. – mbomb007 Mar 1 '16 at 21:26
• Test case generator. Each line of output contains a generation and then the amphichiral rules which give it. Change the 10 which has a comment about generations if you want to run more. – Peter Taylor Mar 2 '16 at 14:34

Help! My playlist is all unsorted! I need to sort it, but I can only move a video to the top or the bottom. I'd like to do this quickly so I need a solution with the minimum amount of moves. But I'm lazy and it seemed like a good fit, so I'm posting it here and now you have to do it! Now, since this is code golf, you have to do it in as few bytes as possible.

Input is a permutation of the values from 1 to n (where n is any number from 1 to ∞). Output is a list of moves that sorts the list. For example for input 1 3 2 4 a valid output would be 2D 3D (second element to bottom, third element to bottom)

Test cases:

Input         Possible Output
1 3 2 4       2D 3D
5 4 3 2 1     4D 3D 2D 1D
• I'd flag as unclear. Input and output specifications? Test cases? Just a description is not enough. – user48538 Feb 29 '16 at 16:43
• I'm having trouble understanding the test cases. No matter which side I try as "bottom", neither one of the outputs seem to sort the inputs. – Geobits Mar 1 '16 at 15:16
• For the first input, it is 1 3 2 4 1 2 4 3 1 2 3 4 For the second, 5 4 3 2 1 5 4 3 1 2 4 5 3 1 2 4 5 1 2 3 5 1 2 3 4 1 2 3 4 5 – CalculatorFeline Mar 1 '16 at 16:10
• 1. "A list of values from 1 to n" without any other mention of n says nothing about whether or not there are duplicates. I think you mean "a permutation of the integers from 1 to n", but that needs to be explicit. 2. The top appears to be index 0 (or 1 in weird languages) and the bottom index n-1, but that needs to be explicit. 3. 2D seems to mean "move the value at index 2 to the bottom": "element 2" is far too easy to interpret as the element with value 2. 4. The first paragraph says "minimum amount of moves", but the second test case doesn't meet that criterion. – Peter Taylor Mar 1 '16 at 21:12

# Binary Arithmetic Using Unary Operators code-golfrestricted-source

This is based off a game I was playing with a friend a few years back. How many different mathematical operators can you implement using only unary operators in your source*. We were able to implement most basic arithmetic in C, but for this challenge you can use any language.

* Except under certain conditions, see below.

## Specifics:

All binary operators are disallowed, except under the following conditions:

• Binary comparison operators are allowed as long as one operand is a constant (e.g. you can do if (x == 0) or if (x) but not if (x == y))
• You may use binary assignment to load user input, only at the start of your code, or if you create a binary = method using these rules.
• You may assume that all variables are default-initialized to 0; if your language does not default-initialize variables, you are allowed to set them to zero only at the start of your code.

• You do not have to write a complete program if your language supports functions/methods.
• You can use other operators from your source (e.g. your implementation of * could use your implementation of +)
• Standard library functions follow these rules too (e.g. you can use sqrt(x) but not mod(x, y))

## Scoring:

Your score is determined by the formula [code size in bytes] / [number of operators implemented]. So for example, a 300-byte program that includes the functions +, -, and * would count as 300/3 = 100. Lowest score wins.

• What about n-ary operators? Ternary operators? Currying? I think this has a lot of holes with languages that aren't procedural by nature. – FryAmTheEggman Mar 4 '16 at 17:43
• for (0 .. 10) { stuff with $_ } is a binary operator, since it takes two arguments, 0 and 10. However,$i=0; while(++$i <= 10) { stuff with$i } is unary, since the binariness of it is an initial zeroing and a comparison with a constant. Did I understand that right? – msh210 Apr 27 '16 at 19:41

# [title TBD]

## Input

An integer n between 1 and [currently 1652; TBD at the time of posting the comic], inclusive.

## Output

The XKCD title for comic number n. (This is the text written above the comic panel, i.e. the text content of the <div id="ctitle"> element, not the title-attribute value of the img element. Here's a handy list, though the actual comic on xkcd.com will govern if it differs from what's on that list. However, the title is displayed in caps and smallcaps due to CSS, and you must output it in caps and lowercase (respectively).)

(If by the time the question is posted there's a comics with an ampersand-escaped character reference — I don't think there are any now — then I'll also add a caveat about how the output of your program should include the actual character, not the ampersand-escaped reference.)

## Obviously…

I/O can be by any standard means and in any standard format. And no using the Internet to look up the title.

• This might get very few (if any) answer since that is such a massive task. Maybe more appropriate as a test-battery where submissions are scored by how many they get right divided by code size? – James Mar 8 '16 at 6:37
• @MyHamDJ, oh, good idea, thanks. I'll probably edit it to that (not just now). – msh210 Mar 8 '16 at 6:38
• @MyHamDJ I disagree that the current question is too hard. It's just an exercise in compression. – lirtosiast Mar 12 '16 at 2:08

The overall task will involve extracting market data for various trading instruments (represented by unique symbols), applying some transformations and statistical functions, and displaying the results in a report.

Obtain the following QUOTES series from Bashoop: TYQUOTES, FVQUOTES

The quotes data is stored as a BBO. BBO stands for best bid/offer, which represents the best bid and ask (ask and offer are interchangable terms) in the market for a given instrument at any given time. At each timestamp it contains, in the following order: bid price, bid quantity, ask price, ask quantity

1. Calculate a VwMpt at each timestamp t for each instrument's QUOTES series VwMpt_t = bid_price_t + (ask_price_t-bid_price_t) * (bid_qty_t / (bid_qty_t+ask_qty_t))
2. Calculate a rolling correlation rho of VwMpt returns (first difference, i.e. derivative) sampled at 1 minute intervals with a lookback of 100 samples
3. On a webpage, display a plot of VwMpt substracted from the first sample (so the time series starts at 0) of both series on the same line chart, and below it plot the rho lined up along the same time axis. You may use a library like Flot or something similar.

To download a series with a series_id of FVQUOTES from a Bashoop instance located at 149.202.47.189:8080 you can: curl -s -d "series_id=FVQUOTES" -d "start_ts=0" -d "end_ts=1451606400000000" -d "compress=0" http://149.202.47.189:8080/series -X GET where start_ts and end_ts are micros send epoch. In this case we want the full history.

• This still suffers from all the same issues as your post on the main site. You haven't specified a winning criterion here, but just saying fastest code wins isn't one, unless you specify how your are going to measure which code is the fastest. – Dennis Mar 9 '16 at 15:34
• What would you suggest would be a direct method to measure performance in this case? @Dennis – petergt Mar 9 '16 at 20:58

# Parse default arguments

Many languages have the concept of default/variable arguments. It basically means you can have a function that when given too few arguments, will fill in the missing arguments with specified values. For example, you can do the following in Python:

WARNING: THE BELOW EXAMPLE CODE IS NOT GOLFED. PROCEED AT YOUR OWN PERIL

def f(x="default string"):
print x

This means that calling f("foo") will print "foo", but calling f() will print "default string".

Python also has a mechanism for handling too many arguments ("rest"):

def f(*stuff):
for thing in stuff:
print thing

You can of course also mix these:

def f(x, y="default string", *z):
...

Unfortunately, python (pre-3.5), being python, yells at you when you put a default argument before a non-default argument. That's silly. You guys are smart; you should be able to make that work.

## Challenge

Write a program, function, or whatever that when given a string representing the arguments and values passed to them, will print each argument's resulting value.

• If there are too few arguments, the mandatory arguments should be applied first, then the rest of the values into the default arguments (left-to-right).
• If there are too many, apply all values to arguments, and the remaining into the "rest" argument.

I'm even confusing myself, just look at the test cases

### Input

• a string, array, or other reasonable format representing the parameter declaration
• a string, array, or other reasonable format representing the values passed to the arguments

### Output

• the resulting values of all the arguments, in a reasonable format.
note: "reasonable format" will be defined later

## Test Cases

Test cases will be in the following format:

{arg string}
{value string}
=> {output}

So, here they are

x, y, z
10, 2, 4
=> x:10, y:2, z:4

x=2, y
5
=> x:2, y:5

a, b="a", c, *d
3, 4
=> a:3, b:"a", c:4, d:[]

foo, bar=2, *baz
9, 3, "kqly", 5
=> foo:9, bar:3, baz:["kqly",5]

*x, y
"ha", 2, 3
=> x:["ha",2], y:3
• "Unfortunately, python, being python, yells at you when you put a default argument before a non-default argument. That's silly. You guys are smart; you should be able to make that work." Actually, this is false starting Python 3.5, at least with the f(x,y="abc",*z) example. – Sp3000 Mar 13 '16 at 14:25
• @Sp3000 that's good to know! See my edit. Hopefully this still requires some additional processing or I may need to modify the question so Python(/ruby?) users can't just use eval – Cyoce Mar 14 '16 at 7:04

# Is this number random?: Round 2

The same as Is this number random?, but with 256 or 512 numbers in each category instead of 64; thereby making a modulo-chain infeasible to find. I hope this will encourage more interesting strategies.

Is this enough of a difference from the existing question to merit a new one? Are there any other flaws with the distribution? Could I change this to require splitting into 4 or so buckets instead of 2?

• I think you might need to do something like 4 buckets to stop it being a dupe. I don't think increased difficulty on its own is enough to make something not a dupe (I feel like I could then just post one with 1024 numbers each etc) (but idk I wouldn't trust me, wait for more feedback). – FryAmTheEggman Mar 15 '16 at 20:39
• Also: Is this number random? 2: Electric Boogaloo ;) – FryAmTheEggman Mar 15 '16 at 20:40

# Cops

You must write a program or function in as few bytes that takes in an integer or a set of integers, performs a defined task on them (for example, finds the prime factorisation), and gives an integer or a set of integers as output. The number of integers in input and output will be pre-defined, so will be the task. You should provide appropriate limits for the variable sizes to be supported (1 bit, 1 byte, 2 byte etc.) and any additional conditions (0 not supported, N<100, M>N, etc.), and your program should work (atleast in theory, does not need to be time or memory efficient) for all possible inputs allowed by you.

You must also submit a reference code (ungolfed) in any language that performs the exact same process in reverse. Meaning, when given the output of the first program, it should be able to deduce the input given. This should be possible (atleast in theory) for all inputs accepted by you in the first program.

For example, suppose the first program takes in two 1-byte prime numbers m and n, and outputs all prime numbers between the two of them. Since the number of integers in input must be pre-defined (and not dependent on input), we state an additional rule that there will be a total of 60 integers in output, and if there aren't that many prime numbers, then zeros will be outputed.

Input to program 1: 23 41

Output from program 1: 29 31 37 39 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Now the second program will perform the same process in reverse.

Input to program 2: 29 31 37 39 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Output from program 2: 23 41

## Scoring

Robbers will attempt to golf the second program as much as possible. Your score is given by the ratio of bytes in the best golfed code by a robber and the bytes in your code. So if your code is 23 bytes, and a robber writes the code for the reverse process (in any language) in 102 bytes, then your score is 102/23. Your answer is deemed ineligible for scoring if it has negative score. Highest score wins.

# Robbers

You must pick the second program submitted by a cop and attempt to golf it (in any language) as much as possible. You may submit a program or a function. You may use a different algorithm if you choose to, but the results must be exactly the same.

## Scoring

????

1. Is it ok to combine code-golf with cops-and-robbers like I have done?

2. What should the scoring criterion be for the robbers?

3. Is my challenge too generic (because it accepts way too many kinds of tasks)? If yes, what can I do about it?

4. Any further questions or suggestions are welcome. If you are sure of a suggestion being mandatory, you may make the edit yourself.

5. Are the tags ok?

• I think your concern in 3 is very significant, I think this is way too broad. Some CNR challenges have had success by limiting the size of the output. I also think there is a significant problem with "standard language". Does APL count? I think it would be hard to argue against it being well known, and then you get stuff like Brainfuck... I think it's better to allow any language with a freely available interpreter. The upvote requirement is also rather bizarre; I don't think it should be there. – FryAmTheEggman Mar 15 '16 at 13:11
• @FryAmTheEggman 1. What limit should I provide? 2. Agreed, I'll make the change. 3. Up-vote requirement is only so that, in case there are low quality answers (basically extremely easy challenges) that no one pays attention to, doesn't mean they deserve to win. – ghosts_in_the_code Mar 15 '16 at 18:24
• I agree with lirtosiast. I'm not sure about what limit to use but perhaps take a bit of freedom away and just require the function work for bytes and always output 10 numbers, or something? This is just meant to be an idea that I think goes in the right direction, I don't think I'm at all qualified to know how to make a CNR :P In addition the tag combination has been done before, but I would add some of number/math/arithmatic depending on where you go with it. – FryAmTheEggman Mar 15 '16 at 20:36
• @lirtosiast Done. – ghosts_in_the_code Mar 16 '16 at 7:51
• @Fry Not a bad idea, but I think I'll wait till someone else (hopefully a mod) gives their input. – ghosts_in_the_code Mar 16 '16 at 7:52

## Calculate the last N digits of Graham's Number

Write a function or program that, given an integer x, outputs the rightmost x digits of Graham's Number.

Rules:

• You may not hardcode the answer in
• You may not fetch the answer from an external file or library

Scoring:

• Will be tested over 100 iterations on my machine with an average time given for different x values
• To Be Decided... (Input would be appreciated)
• Graham's number is just 3^[very large number], which always has the same last few digits; Wikipedia says they can be computed efficiently. – lirtosiast Mar 26 '16 at 2:59
• This might be more interesting as a code-golf challenge, because it would likely be too fast to accurately time in fastest code – Liam Apr 8 '16 at 0:01

# Paint the Mona Lisa in 1 KiB of code

## ** Oops, it seems that something like this has already been posted (and I didn't know about it before), but please read the last section below

This is my attempt to salvage this challange by Nathaniel, which was deleted after getting no less than 19 upvotes.

Here is a picture of da Vinci's Mona Lisa:

Your task is to reproduce the Mona Lisa in 1024 bytes or less. You will write a program or function that takes no input and loads no files, and outputs an image file.

The goal of this challenge is to produce an image that is as close as possible to the Mona Lisa above. The image must have the same resolution, and the similarity/difference will be measured by the root-mean-square deviation (at the color component level) between the two images. That will be the only criterion for the score, but people are still free to reward interesting answers by upvoting them (as always).

Your code (program or function) must obey the following restrictions:

• The code must be no more than 1024 bytes in total (counted in UTF-8 if you use funky characters)
• It must output the image in a standard uncompressed format such as BMP or PPM; the image can be written to the standard output or directly to a file
• The image must have the same resolution as the original - 215 by 320 pixels
• The code must be completely self-contained, taking no input and loading no files (other than importing libraries, which is allowed)
• You may not use built-in or library code that implements a decompression algorithm (unzip, unlzma, jpeg decompression etc). It is fine to use such algorithms if you implement them yourself within the 1024 byte limit.
• If your language or library includes a function that outputs the Mona Lisa, you are not allowed to use that either.
• It should run deterministically, producing the same output every time.
• Your code must be runnable in Linux using freely available software

It is possible that some submissions will themselves be generated by code. If this is the case, please include in your answer the code that was used to produce your submission, and explain how it works. The above restrictions do not apply to code used to create the code, they only apply to the 1024-byte code that produces the output image.

## TODO:

• provide code to calculate the score
• use a better-quality image?

## Duplicate?

Well, some may argue that this is a duplicate of the Starry Night challenge, but I think it differs in at least 3 ways:

• uncompressed output
• no prewritten decompressor allowed
• UTF-8 byte count

Also, the image is not the same so it may not benefit from all the same techniques (I'm also open to using a different image altogether, such as the one from this other deleted challenge by Nathaniel).

If you have any other ideas how to improve the challenge, let me know.

• 1) It's not clear what counts as a builtin decompression algorithm. Is RLE builtin compression? Golfing languages have it built in. 2) Our standard rules cover encoding; no need to require UTF-8. 3) A list of all the valid uncompressed formats seems appropriate. – lirtosiast Mar 26 '16 at 2:54

# Factorize Gaussian Integer

Given a nonzero gaussian integer your program/function should return the factorization of that integer g into prime factors pi and an unit u:

g = u * p1^e1 * ... * pk^ek

As the factorization is only unique up to units, we make following restrictions

• All primes should p should be in the first quadrant, that means that Re(p) > 0 and Im(p) ≥ 0.

• The unit should be represented as power of i. It should have the lowest nonnegative exponent.

• The primefactors should be sorted by the real part increasingly. If two real parts are the same, they should be sorted by imaginary part (also increasing.)

### Examples

11-27i = i^2*(1+i)*(2+i)^2*(4+i)
2     = i^3*(1+i)^2

To be added: Examples, input output spec

https://en.wikipedia.org/wiki/Table_of_Gaussian_integer_factorizations

is_gaussian_prime(z)?

https://stackoverflow.com/a/2271645/2913106

• What about builtins? – lirtosiast Mar 26 '16 at 2:57
• Built-ins are ok. In my experience restricting built ins is quite subjective and frequently results in trouble=) – flawr Mar 26 '16 at 10:54

# Create a race condition

Your objective is to create program where concurrent threads race to produce a result. The program is simple. Print the sum of every element in the cartesian product of two sets.

An example of standard input would be

2 5 8 10 | 9 2 3 7 512 | 3 1 2 | 9 8 6 3

The program would then need to spin up two separate threads to calculate each result, and the first thread (and only the first thread) to complete should print "I WIN!" and the answer without using mutexes or other synchronization methods.

## Rules

• You cannot use mutexes or synchronisation
• The operation must be run concurrently
• Standard input will contain any multiple of two sets, and the program should use (no of sets / 2) threads, as well as the main thread that spins everything.
• The order of execution on the slave threads is not important
• Some failure cases where more than one thread prints "I WIN!" is acceptable, but should be a rare case Sandbox comment: Not sure about verifying this one? or should not bother at all?

I saw the TCP Server question and I liked the idea of a challenge that is specifically difficult for golfing languages, and I was thinking about a few ideas for challenges that might work based specifically on parallel programming failures. I'm not sure if this one really fits the bill, hoping for suggestions to improve the challenege itself before refining the criteria.

# A Tiny Raytracer

Your task is to make a tiny 2D raytracer to render beautiful ascii images.

## Input

Your input will be an arbitrary 2D array delimited by newlines with the following structure

########
#9     #
#      #
#  ##  #
#  ##  #
#      #
#    ###
########

The symbols are: 0-9 = Light source = Emptiness # = Wall

Your expected output should look like this:

########
#987654#
#876543#
#76##32#
#65##00#
#543000#
#43000##
########

# How Light Propagates

Light will travel in a straight line from lightsources through empty space and will be completely blocked by walls. Light falls off according to this function:

light_intensity = clamp(floor(9 - source_intensity * ||dist_to_lightsource||), 0, 9)

Where || || is the euclidean norm between the cell containing the light source and the cell in question, with 1 cell = 1 unit. All light intensity values are clamped to be between 0-9.

Light falls on an empty cell c whenever a straight line can be drawn from any part of c to the cell containing the light source without passing through a wall. For example, here I have all of the cells affected by a light source marked as *:

########       ########
####   #       ####***#
#9   #     =>  #****#
###    #       ###****#
### ####       ### ####

Whenever there are multiple light sources, their contributions to the final light intensity are summed (and clamped to be between 0-9).

For example:

################
#9            6#
################

Should yield:

################
#98765432223456#
################

# Rules

Standard code golfing rules. Input can have arbitrary size.

## Fun Optional Bonuses

• Output the result as a graphical image.
• Support light values of between 0-255 (in this case columns of the input and output will be space delimited)
• Support colors (in this case light will be denoted by a standard 24-bit hex code 0xFFFFFF, and space delimited).

These don't give you any bonuses in the competition, but would be cool.

# Self-decrypting code

The Caesar cipher is perhaps the earliest and most well known form of encryption. Here's a quick overview:

Pick a message, and a numerical encryption key. For this example, I'll pick "HELLO, WORLD" and 3, respectively.

First, convert each letter into its ASCII number:

H -> 72
E -> 69
L -> 76
L -> 76
O -> 79
, -> 44
[space] -> 32
W -> 87
O -> 79
R -> 82
L -> 76
D -> 68

Then, add the key (3) to each and convert back into a letter

75 -> K
72 -> H
79 -> O
79 -> O
82 -> R
47 -> /
35 -> #
90 -> Z
82 -> R
85 -> U
79 -> O
71 -> G

So the encrypted message is "KHOOR/#ZRUOG"

Write a full program that is a Caesar cipher-encrypted valid English message. The program must take no input and it will output the unencrypted version of itself.

Some rules:

• The program must be at least length 2.
• The key may not be 0, 32, or 256
• All of the code must be executed (no comments to arbitrarily extend code length).
• The Linux word list will be used to judge if a message is English. Words must be separated by ASCII character 32. Words can mix uppercase and lowercase.
• Your program does not need to be written in printable ASCII.
• File I/O is allowed, but only to read the source code file.
• No other standard loopholes.

## Scoring

The submission with the longest message wins. Anything over 200 characters will be scored as exactly 200 characters. Ties are broken by upvotes.

• I think this has a bunch of problems. The scoring doesn't make much sense why does it switch between code-challenge and pop-con? Additionally, I'm almost certain that 200 won't be that hard to reach, considering it is "valid" English to say "I am very very very ... very very sad". This also doesn't explicitly give much explanation for valid English. Do you just have to have words and spaces? Or does it need to make sense? Also, "all of the code must be executed" rules basically never work: it's too easy to get around them. – FryAmTheEggman Apr 1 '16 at 14:13
• @FryAmTheEggman How should I deal with arbitrary-length submissions (they found a way to make it as long as possible)? As for valid sentences, maybe just words separated by spaces (but no word can be repeated). How should I prevent trivial arbitrary-length programs (because comments can be used for that). – Daniel M. Apr 1 '16 at 14:20
• The problem is that there are too many things that are basically the same as comments in too many different languages. What's to stop me from just inserting a giant numeric/string literal in my code that don't get printed? What about repeating ; in a C program? What about languages that don't even really read their source code like lenguage? I feel like if your challenge breaks because of comment like things, it's sort of doomed to be broken. – FryAmTheEggman Apr 1 '16 at 14:25
• What constitutes a "valid English message"? What modulus operations are permitted? – Peter Taylor Apr 5 '16 at 13:35
• @PeterTaylor Any modulus operations that don't bring the message back to itself and aren't the exact difference between lowercase and uppercase. – Daniel M. Apr 5 '16 at 15:42

# How many pixels are in each ASCII char?

Write a program or function taking a single printable ASCII character as input that outputs how many pixels it takes to display that character to the screen.

Input can be taken by any reasonable method, including reading from a file, STDIN, or function argument. Input from a variable hardcoded into the program is not reasonable.

Output may by given by any reasonable method, including writing to a file and STDOUT. Extraneous output is permitted as long as the result remains unambiguous.

"Printable ASCII character" is defined as a character within the codepoints 32-126, inclusive.

A pixel counts as part of a character if the pixel is non-white after the character is written to a white screen.

The required font is Times New Roman, 20pt.

Do not hardcode the result.

### Reference Solution: (JavaScript)

//create a canvas to display the character
var canvas = document.createElement("canvas")
canvas.width = 100
canvas.height = 100
document.body.appendChild(canvas)

var context = canvas.getContext("2d")

//make the canvas white
context.fillStyle = "white"
context.fillRect(0, 0, 100, 100)

//make the text black and set the font
context.fillStyle = "black"
context.font = "20pt Times New Roman"

var char = prompt("Enter your ASCII char")

//draw the char
context.fillText(char,50,50)

//get the canvas pixel data
var pixelData = context.getImageData(0, 0, 100, 100).data
var pixelCount = 0
for(var i = 0; i < pixelData.length; i+=4) {

//if the pixel isn't white, increment the counter
if(pixelData[i] != 255 || pixelData[i+1] != 255 || pixelData[i+2] != 255) pixelCount++
}

• Is there any specific font that should be used? – Downgoat Apr 3 '16 at 5:07
• you should probably set a specified font (Times New Roman, Arial), to make answers more comparable. If not, you should probably say the font should have been made before this challenge was posted – Downgoat Apr 3 '16 at 5:13
• @Downgoat actually on second thought, languages that can't output Times New Roman probably don't have the features to compete in this challenge anyway. I'll make 20pt Times New Roman the required font. – jrich Apr 3 '16 at 5:20
• I wonder if any other algorithms exist that are more efficient. – Leaky Nun Apr 3 '16 at 5:48

In this challenge you are supposed to output a grid 10x10 with numbers from 00 to 99 (each number once) following this rules:

• Number 00 must be on the bottom row
• Number 99 must be on the upper row
• In the output each number must be sepparated by spaces and must have two digits (that is including 0's when needed for the first 10 numbers)
• Output must be random
• It must be solved within reasonable time

I'm having an issue trying to define random and reasonable time here and would like some help with it. Thanks.

• Define random as 'Each of the possible permutations must have an equal probability of being the output'. For reasonable time I don't think you need a definition - especially since your challenge is only 100 numbers, so it should be perfectly doable unless your algorithm works in O(n!). – Sanchises Apr 7 '16 at 11:11
• @sanchises I find that asking for equal probability is too strong, since there's no way to prove that one of those algorythm has equal probability. – Masclins Apr 7 '16 at 16:34
• Of course, a formal proof is not always easy. However, an intuitive result should be enough for most applications, and if people have difficulty with that, you can always use one of the algorithms described at the Wikpedia page, e.g. Knuth shuffling. I was wondering though, is there a motivation behind the challenge, or is just something you cooked up? – Sanchises Apr 7 '16 at 17:57

# Manual MD5

Given a string, calculate its MD5 sum without using any built-in MD5 library functions. An overview of the algorithm is here.

(I'm going to actually summarize the algorithm before I post it. Until then, it's still unfinished.)

Input is an ASCII string or byte stream with any reasonable length (I won't run an entire novel through your algorithm, for example).

Output the hex value of the resultant hash as a string.

Code golf, so shortest code wins. Standard loopholes are banned.

• You add the tags by adding [tag:code-golf] (and the others) to the body of your post. – Mego Apr 2 '16 at 5:41
• To answer your question: yes, include a description of the algorithm in the challenge body. Requiring external resources for a challenge is discouraged. – Mego Apr 6 '16 at 4:02
• 1. "Given a string, calculate its MD5 sum" is underspecified. In many languages nowadays, a string is a sequence of Unicode characters; MD5 is defined over sequences of octets, so to talk about the MD5 sum of a string you first have to define its encoding in octets. 2. Output format? – Peter Taylor Apr 8 '16 at 7:28
• I clarified as ASCII string now in the input section. Should I mention that at the top, as well? – Value Ink Apr 8 '16 at 7:38
• I think so. It's a one word addition and it avoids people wandering mentally off track. – Peter Taylor Apr 10 '16 at 21:46

# Matrix Multiplication

This is a challenge in which we will be multiplying matrices.

Input:

• an n x m matrix, A
• an m x p matrix, B
• optional:
• n, m, and p

Input may be in any convenient fashion in order to reduce/eliminate the need to parse input. In particular, it may be given via function argument. The matrix dimensions may be taken as input or may be deduced from the actual matrix input.

Output:

The product of the two matrices. That is, output the n x p matrix C such that A * B = C.

Scoring

Your score will be the average of the sum of times your program takes to multiply several test cases on my computer.

Basically, I:

• Time your entry for each test case
• Add up all the times
• Repeat the above steps several/many times
• Average all the sums
• That average is your score

Rules and Restrictions

• Built in array/vector/matrix multiplication functions are disallowed. If you have to ask if a built-in is allowed, it probably isn't (but please ask anyways).

• However, once the test cases are up, I would like to see how MatLab compares to the given entries
• Entries in A and B will be standard 16 bit signed integer. Entries in C will fit in 32 bit signed integers.

• Matrix size/dimensions should be limited by mainly by my available memory.

• The size of test cases is not yet determined. It will depend on the speed and memory requirements of entries. I will of course try my utmost to be fair.

• I have 8G of RAM and an AMD64 cpu.

• Languages must be freely available on linux. Please include instructions on how to compile/execute your code.

Notes

I'm really not sure how big the matrices will be, but I'm expecting dimensions in the 100's or 1000's.

• I think at slightly above 10000x10000 matrices you will run out of RAM, considering you'd have to store three of these matrices. MATLAB can multiply matrices of that size on my machine (similar specs) with a time of still only about 45 seconds. So I think memory is probably going to be the main limiting factor=) (And I do not think that anything's going to be much faster than BLAS) – flawr Apr 8 '16 at 23:45
• @flawr I think 45sec would be long enough to get accurate timings. Also my machine is probably slower than yours and I doubt any entries will beat MatLab's time. If you think memory will still be a problem, I have no problem using 16 bit integers instead of 32 bit. – Liam Apr 9 '16 at 0:00
• 1. Without knowing more about the test cases and the CPU it's going to be hard to optimise, because the sizes you're talking are roughly where the cutoff for naïve being worse than Strassen lies. 2. Can assembly answers use SIMD instructions (SSE etc.) or are they banned built-ins? – Peter Taylor Apr 10 '16 at 21:41

# Iterated Matrix Multiplication

Given an nxn matrix A, an nx1 matrix X, and a list L of ordered pairs in [0,n)x[0,n), determine if there exists some integer k>=0 such that, with B=A^k*X, for all (D,E) in L, B[D]<B[E].

Why it's possible: Every entry of the natural number power of a general matrix can be expressed via sums of multiples of powers of the matrix's eigenvalues, like 2^k+4*6^k-10*3^k, and for any two such expressions, there will always be some k beyond which one term dominates the expression, and the sign of their difference can no longer change, so one way to solve the problem would be to calculate that k.

Test cases:

[[1,2],[2,3]],[3,4],[(0,1)] -> Yes (k=0)
[[1,2],[2,3]],[3,4],[(1,0)] -> No
[[1,2],[2,3]],[4,3],[(1,0)] -> Yes (k=0)
[[1,2],[2,3]],[4,3],[(0,1)] -> Yes (k=1)
[[1,-2],[2,-3]],[3,4],[(1,0)] -> Yes (k=1)
[[-1,-2],[2,-3]],[3,4],[(1,0)] -> Yes (k=2)
[[-1,-2],[2,-3]],[3,4],[(1,0),(0,1)] -> No
• 1. For fastest-code you need to describe how you will measure it, selecting a test size which is large enough to give meaningful differences but small enough to be feasible. That probably means that you need to write a reference implementation or three (trying difference approaches). 2. For floating point questions, you need to do some numerical analysis to determine on what range of input it's feasible to write a correct program, and then guarantee that the input will be within that range. 3. You need to think about what level of library support is fair. – Peter Taylor Apr 13 '16 at 8:54

## Colorize!

In Ruby, the colorize gem allows you to output text to the terminal in pretty colors:

It uses the ANSI color standard to tell the terminal how to color things, then trusts that the terminal will do the right thing. For this challenge, you can too.

What you'll do is take a a pair of lidts of strings, in whatever format you want. For example, if you wanted comma-separated values:

+-----+,| box |,+-----+
red,blue,red

The first list is what you'll be colorizing. The second list is a list of color names that are the same as the ones in the Wikipedia article. You'll colorize each string from the first list with the respective color from the second. The two lists will always have the same number of items, and the second will only ever contain valid color names. The strings in the first will only contain valid, printable ASCII characters.

And apply those colors -- as given by the ANSI standard linked above -- to the text, printing each string on its own line. For example, with this (heavily ungolfed) code:

#to be written

you'd get this:

[picture of result]

You may not use any libraries built to do this, and the standard loopholes are disallowed.

I'm thinking of adding extra credit for bolding/doing multiple things at once. Is that a good idea?

Aside from that, how is the rest of the challenge?

To-do list:

• Copy the list from Wikipedia to here
• Add that you have to change the color back to default at the end
• The comma separated thing seems unnecessary, in most languages this just adds a boring split(',') call. You also probably want to only allow printable ASCII in the body of the strings (or at least put some restriction otherwise stuff can get pretty hairy). In addition you should explain what is necessary to know from the ANSI standard in your question body. – FryAmTheEggman Apr 13 '16 at 13:03
• @FryAmTheEggman I linked the relevant part and stated "ANSI color standard" when it was first mentioned. What input format would you suggest that can deliver a set of lines to colorized and a set of colors to use? – Fund Monica's Lawsuit Apr 13 '16 at 13:22
• Just say what they are: a list of strings and a list of colours. The link doesn't matter: if Wikipedia is down or they change that page so it doesn't help here then I can't answer your question without guessing what you mean. Also, the reason I said printable ASCII is that some ASCII is still hard to deal with. What about control characters, etc.? – FryAmTheEggman Apr 13 '16 at 13:27
• @FryAmTheEggman Oh, I see. I'll update it to have "input of two lists in whatever format you want" and "printable ASCII characters only". As for requiring Wikipedia to be up, I'll copy and paste it when I have time. However, note that ANSI's standards are available online, and Googling "ANSI color standard" yields their website as well. Wikipedia is far more readable. – Fund Monica's Lawsuit Apr 13 '16 at 13:32

## I'm a Puzzle!

Your task is to print the string "I'm on OS!", where OS is the operating system that the program is run on without version numbers.

Standard loopholes apply.

In addition, programs with hardcoded values (e.g. print "I'm on AFakeOS") will be disqualified.

As this is Code Golf, your score will be the length of your full program.

Any suggestions?

Java example:

class A {
public static void main(String[] args){
System.out.println("I am a " + System.getProperty("os.name").replaceAll(" .*","")
+ "!");
}
}
• When making something in Java, "noncompetitive" is implicit. – Cyoce Feb 13 '16 at 7:31
• :P I've been lurking and waiting for an idea long enough to know. – 0az Feb 13 '16 at 13:07
• "If run in a browser (JavaScript and/or any other browser scripting languages), the browser should be output instead." Why is that? I'm pretty sure you can detect the operating system even if you're in a browser. – Martin Ender Feb 13 '16 at 17:40
• And my suggestion for "other bonuses, penalties, ..." is drop all of them. – Martin Ender Feb 13 '16 at 17:40
• Added Java example solution. Removed bonuses. Read the linked question. – 0az Feb 13 '16 at 21:32
• Exactly what is acceptable output? If Windows 10, is Windows? Windows 10? Windows NT Version 10.[build n]? – lirtosiast Feb 14 '16 at 5:24
• How portable does this need to be? E.g. would uname -o be acceptable? – Peter Taylor Feb 15 '16 at 12:46
• Considering that uname prints Darwin on my MacBook, and -o is an illegal option, uname -o would not work. I guess a possible definition of portable would be "works correctly on OS X, Windows, and most of the more common Linux distros" – 0az Apr 18 '16 at 3:01
• @alphadelta That entails unambiguously defining the operative words most of the and more common in the phrase most of the more common Linux distros, which is objectively impossible. – cat Apr 24 '16 at 2:14
• Perl 5, fourteen bytes as a subroutine: {"I'm on $^O!"} (where ^O is actually the F byte). (Fifteen as a program that prints: say"I'm on$^O!".) I can only imagine that the golfing languages will get down to one or two bytes, then. :-) – msh210 Apr 26 '16 at 22:32

@Sandbox:

• Not sure if is correct here.
• Do I need test cases for this? They will make this very lengthy.

# The Challenge

Given a piece of C-code, add a /* before and a */ after every top-level structure definition that you find. You may not do this for structures that are defined inside other structures.

• A structure can be identified by the struct keyword followed by an identifier, an opening {, some alphanumeric characters inside the structure and a closing };.
• A structure identifier will only consist of alphanumeric characters.
• One structure may also contain other structures with an unlimited depth.
• Comments and whitespaces may appear anywhere in the code and have no effect. // starts a single line comment and code enclosed in /* and */ is a multiline comment.
• You can't rely on a specific indentation style.
• A structure will not contain any braces {} that are not part of another structure definition.
• There can be multiple top-level structures in the input. You have to consider them all.
• The input will only contain printable ASCII and newlines.

# Example

So the output for

int z;
struct example1 /* comment here */  {
int x; // struct comment {int x;};
struct nested
{
char* s;
int* y;
};
};
int y;

//struct { };

struct example2{int x;};

would be

int z;
/*struct example /* comment here */  {
int x; // struct comment {int x;};
struct nested
{
char* s;
int* y;
};
};*/
int y;

//struct { };

/*struct example2{int x;};*/

# Rules

Happy Coding!

• I think this has some problems, as most questions that say "Given some C code do...", with what counts as valid. What about things like trigraphs, or macros or... ? – FryAmTheEggman Apr 13 '16 at 17:56
• @FryAmTheEggman So it would be fine, when I limit the possible code-contents to a certain subset of C like I did for the struct contents? – Denker Apr 13 '16 at 19:00
• Yeah, but I'm not well versed enough in C grammar to be able to say for sure that that'll be enough. – FryAmTheEggman Apr 13 '16 at 19:05
• @FryAmTheEggman Thought about this and I actually don't need all that C-syntax stuff. Just came from the origin of this, but it's no really needed. Should be clear now. – Denker Apr 13 '16 at 20:23
• Please work on your spelling before posting this, if you do. – Fund Monica's Lawsuit Apr 14 '16 at 18:52
• @QPaysTaxes You can't fault OP for speaking ESL; this is why anyone can edit posts on SE. – cat Apr 24 '16 at 1:20
• @cat That's actually wrong. You can't suggest edits on meta, and this answer isn't CW, so I'm not able to edit this. If you'd like to confirm, take any of your accounts with less than the required rep, go to meta, and try to edit something. It doesn't let you. – Fund Monica's Lawsuit Apr 24 '16 at 2:04
• @QPaysTaxes I'm aware there are no suggested edits on Meta, because that would mean more, more clogged review queues for popular sites. I meant when the challenge is posted which is the only time small grammar things will matter anyhow, and I tend to be the type to fix that stuff. – cat Apr 24 '16 at 2:08
• @cat Oh, I see. I thought you meant I should edit the Sandbox post, which... I can't. I've been told several times to "just edit it!" on various Metas where I don't have permission; I have yet to be told "edit it when this is on main" :P – Fund Monica's Lawsuit Apr 24 '16 at 2:11

## Spiral text

Write a function or program that given a text with one or more characters in it outputs the text as a square spiral. The first letter of the text must be the center of the spiral and then all the characters must follow a clockwise spiral pattern as follow, striping all white spaces:

789[10]
612[11]
543[12]
[13]

Example

Input: Hello World!
Output:

ORLD
WHE!
OLL

The text could be any length. Please validate with the following texts:

Once upon a time

Expected output:

o   n   a   t
p   o   n   i
u   e   c   m
e

Tyger Tyger, burning bright, In the forests of the night;

Expected output:

g   h   t   ;
i   i   g   h   t,  I   n
n   r   y   g   e   r   t
e   b   t   t   y   ,   h
h   g   r   e   g   b   e
t   n   i   n   r   u   f
f   o   t   s   e   r   o

The minimung length of the input text is one character.

Note: Somewhat similar to this question

• Test cases are more useful if you also include the expected output. ;) – Martin Ender Apr 29 '16 at 9:16
• @MartinBüttner yay! Doing that – Averroes Apr 29 '16 at 9:17
• Also having to support the empty string seems like an annoying special case that isn't likely to add anything interesting to most answers, so I'd personally probably let the input have at least one character, but that's your call. – Martin Ender Apr 29 '16 at 9:18
• When you say "somewhat similar": why should I not vote to close it as a duplicate? It seems that the only difference is a reflection in the leading diagonal, which I would class as trivial. – Peter Taylor Apr 29 '16 at 11:55
• @PeterTaylor First of all the other question doesn't have any answer and it is a bit old so maybe now this question can get a little more audience now. Secondly the other question add "The characters can spiral into previous characters" that this doesn't add to the specs so I think they are different questions. – Averroes Apr 29 '16 at 12:39
• Ok, the other question is horrible. This is actually more like various spiralling numbers questions, with the main difference being that it spirals outwards rather than inwards. – Peter Taylor Apr 29 '16 at 12:52

You have an even number of identical balls. Half of them are "Light" balls and other half are "Heavy" balls which are heavier than the light balls for a unknown amount. You have to separate them into the "Light" box and a "Heavy" box using a scale instrument which tells you precisely for how much the left side is heavier than the right side when the balls are weighted on it.

Find a way to separate a given number of the balls with the minimal weightings as possible.

This is a challenge to programmatically reslove this question.

The solution should be an algorithm that would separate the given amount of balls with the least weightings as possible.

The Input can be any even number of balls, where the heavy balls will differ in weight from the light balls by a random amount. The balls are marked from 1 to n, and the "heavy" and "light" properties are assigned to all the balls randomly.

Now the program can take any number of balls and place it on the "right" side of a "scale" and then another amount of balls to be placed on the "left" side of the scale. It can read for how much exactly one side is heavier than the another, and then it can proceed to weight another set of balls until he can for sure tell for each numbered ball if it is "light" or "heavy". It should know how to process this in a least "weightings" or "uses of the scale" as possible.

So the goal is to write the most efficient program that can most efficiently separate the balls using the minimal amount of "weightings", and doing that for as many cases of given balls as possible.

• This seems too simple. The optimal algorithm is well-known to the point where it's a common interview question. It would just be a race to be the first to implement it in the chosen language. – Mego Apr 29 '16 at 19:17
• @Mego Thank you for your review, Btw How would one write such an algorithm? Does something like that already exists? My main point of posting this was to answer that question, I would appriciate if you have any way of providing any help. – Vepir Apr 29 '16 at 19:25
• @Mego The "interview" question you're thinking of is probably a version with one different weight, as pointed out in the linked question. This seems challenging enough; one could even consider comparing different numbers of balls. – feersum Apr 29 '16 at 20:45
• What this needs to be a good question is some kind of output specification, e.g. giving the expected number of comparisons, an interactive protocol with the user giving comparison results, or some kind of tree decision representation. – feersum Apr 29 '16 at 20:47
• I would just set a pivot ball (e.g. the first one) and compare everything else with it. Runtime complexity O(n). – Leaky Nun Apr 30 '16 at 14:36
• @Kennylau but that is exactly the oposite of the solution. You would have then too many unecessary weightings, since the goal is to do it in least possible weightings no matter how complex the real solution might be – Vepir Apr 30 '16 at 15:11

## Is this a helpful starting layout?

My computer has a Patience-style card game installed on it. It takes two packs of cards, removes the Aces, shuffles them, and deals 8 cards.

In order to maintain my 100% perfect completion record, I want as helpful a starting layout as possible. Deuces are immediately playable, so they are helpful cards. However other cards can only be played on cards of descending rank and opposite colour, which means that cards of the same rank and colour unhelpfully clog up the layout.

The challenge is to write a program or function which accepts a string or list of eight cards and outputs a truthy or falsy value. Cards are identified by their rank, which is one of the characters 23456789TJQK, and their suit, which is one of the characters CDHS. (Note that using numbers 10-13 for the rank is not an acceptable input.) For a layout to be helpful there must be at least one Deuce of any rank, and (except Deuces) there must not be any pairs of cards with the same rank and colour. Examples:

4H7STHTD5C5D2HQS -> unhelpful because of two red Tens
TD8S4CKC4HKD5S5H -> unhelpful because of no Deuces

This is , so the shortest program wins.

• At first I thought this was a request for help, not the setting for a problem. You'll want to add what those inputs mean, what "a helpful layout" means, in detail. – Fund Monica's Lawsuit May 2 '16 at 18:19
• As I understand, this can be solved by checking if the string contains 2 and its chunks of two are distinct, which seems pretty straightforward. – xnor May 3 '16 at 11:46
• @xnor Not quite distinct, since a) you have to ignore the chunks that contain 2 and b) H==D and S==C for the purposes of comparison. – Neil May 3 '16 at 11:57

# Solve for the Operators

In this challenge, you will be given a bunch of numbers and an answer. Your job is to find a sequence of operators that will successfully solve this equation. Use the numbers in the order that they are given

Operators: +, -, *, /

For example,

Numbers given: 2, 6, 8, 4, 5

2__3__8__4__5 = 9

The program should find which operators can be used in the blanks to make the equation true. Remember Order of Operations Matters (PEMDAS)

Output:

2*3-8/4+5 = 9

Only 1 solution is needed per problem

## Rules

1. No built-in math functions beyond operators.
2. Must Follow Order of Operations
3. Must give one correct output.
4. Least Number of Bytes Wins.

### Examples:

Numbers: 4, 4, 4, 4

4 - 4 + 4 + 4 = 0

Numbers: 1, 8, 6, 4, 5, 2, 3, 3

1*8+6-4*5*2-3*3 = -35

Numbers: 1, -2

1--2 = 3
• In many languages, this will just be "find the cartesian product of +-*/ repeated as many times as there are blanks with itself, insert them over the blanks and call eval". It's fine if you want that, but it seems somewhat, uh, boring? – FryAmTheEggman May 5 '16 at 13:26
• 4 - 4 + 4 + 4 = 8 – trichoplax May 5 '16 at 13:30

Make a times table sheet

The challenge is to make an ascii art version of a times table sheet.

Look at the following:

.

• You should not include the title or the footer or worry about colors. Black and white is fine.
• The times tables lines in each box should be randomly ordered.
• You should include all the horizontal and vertical lines in the image (except in the header and footer).
• The equals signs should be aligned in each column as in the example above.
• It should be in ASCII art.

I am not worried about the precise spacing as long as the layout is as specified.

• no ascii art for me? – Leaky Nun May 6 '16 at 17:41
• @KennyLau I could make it ASCII art if people love that. – user9206 May 6 '16 at 18:22

# Challenge

Create a factor tree from a number. A factor tree will take a number > 1, n, and find 2 numbers that multiply together to equal n that are greater than 1. Then, it will repeat for the factors until every section reaches a number that does. Then it will output the last numbers.

For example:

# Examples:

Input: n = 20

Graph(This is not the output):

Output: 2x2x2x3

Input: n = 54

Output:2x3x3x3

Input: n = 72

Output: 3x3x2x2x2

Input: n = 2

Output: 2

# Scoring

Shortest bytes wins.

• I think you mean a factor tree, not factorial. That is very different. – Rɪᴋᴇʀ May 7 '16 at 3:11
• @EᴀsᴛᴇʀʟʏIʀᴋ yes that is what i meant. Thank you – JoshK May 7 '16 at 3:18
• Would it be more interesting if i had the output be the tree instead of the numbers? – JoshK May 7 '16 at 3:20
• yeah, I think the numbers is probably a dupe. Plus, it would be more fun/hard. (hard isn't bad) – Rɪᴋᴇʀ May 7 '16 at 3:20
• I recommend having output be a image/ascii art, though that needs more specifications. – Rɪᴋᴇʀ May 8 '16 at 20:31
• As it stands, this is a duplicate of codegolf.stackexchange.com/questions/1979/factorize-me – Mego May 13 '16 at 5:27

## The incremental Gijswijt's sequence

The Gijswijt's sequence G is a sequence where the next term is the maximal number of repeating blocks of terms going so far backward.

The first numbers of this series are: 1, 1, 2, 1, 1, 2, 2, 2, 3

The incremental Gijswijt's sequence I is a sequence of Gijswijt's indices where any term of this last sequence I(n) has an image in Gijswijt G(I(n)) that is greater or equal all terms that precede it in that sequence G .

In other terms, It is an increasing sequence of indexes i for which G(i) is at least as large as G(j) for any j < i. Thus it contains the index of every 1 up to the first 2, every 2 up to the first 3, etc

Example:

G= 1, 1, 2, 1, 1, 2, 2, 2, 3, 1, 1, 2, 1, 1, 2, 2, 2, 3, 2, 1, 1, 2, 1, 1, 2, 2, 2, 3, 1, 1, 2, 1, 1, 2, 2, 2, 3,...

I= 1, 2, 3,       6, 7, 8, 9,                        18,                           28,                        37,...

Your program must output the most you can print from the starting of sequence until the delay between printing two consecutive terms exceeds 10 minutes, the actual number of outputs is your score.

For matter of reliability, the complete accurate "run-lengthed" G sequence must be linked through pastbin or any raw data repository.

the output will be so large to fit an int32 registry, so i suggest to print it modulo 1000007 or dont.

if the scores are not be divergent enough i will apply some salt, scoring is evaluated to N/T where T is executon time in seconds for the last term of sequence, the tie broken by the earlier post .

Only another 45 secs after the delay cap are given as an extra time.

• I would VTC as unclear. – Rɪᴋᴇʀ May 4 '16 at 16:08
• hmmm what is unclear ? – Abr001am May 4 '16 at 16:08
• Winning criterion. until nothing appears in the console for 10 minutes is a bit vague. – Rɪᴋᴇʀ May 4 '16 at 16:08
• 10 minutes from last output, is this what u asked me to clarify ? – Abr001am May 4 '16 at 16:10
• "nothing appears" is a bit vague. I think you want something more like "the time to calculate the next term is > 10 minutes." – Rɪᴋᴇʀ May 4 '16 at 16:11
• yes when it exceeds that cap, execution must be halted – Abr001am May 4 '16 at 16:12
• .. I mean the wording in unclear. Can you say something like the time to calculate rather than the console is empty? – Rɪᴋᴇʀ May 4 '16 at 16:15
• if that makes you contented .... – Abr001am May 4 '16 at 16:18
• I found the definition rather hard to follow, and technically it defines an uncountable number of sequences. I suggest "The incremental Gijswijt's sequence is the (increasing) sequence of indexes i for which G(i) is at least as large as G(j) for any j < i. Thus it contains the index of every 1 up to the first 2, every 2 up to the first 3, etc. If you are familiar with the Records transform on integer sequences, this is effectively a Non-strict Records transform." – Peter Taylor May 7 '16 at 8:55
• "For matter of reliability, the complete accurate "run-lengthed" G sequence must be linked through pastbin or any raw data repository." Why? If it's generated by the same process, it would have the same bugs. If it isn't, I don't see the point of asking every single answer to include a pastebin link. "i suggest to print it modulo 1000007 or dont." Either make this a requirement or don't. It complicates comparison of answers to make it optional. "Only another 45 secs after the delay cap are given as an extra time." Extra time for what? – Peter Taylor May 7 '16 at 8:59
• @PeterTaylor 1. That is because it a contest for scores in increment, so any new record must be followed by a string of compressed numbers from the last terminus reached, until the new record using his own technique imagine the new score is 2 numbers far from the last result ? the algorithm must print a correct G series that is ground of I series. – Abr001am May 7 '16 at 10:47
• 2. The numbers could be too big and unintelligible, so either print a remainder or the difference of two edges or print it all along the console modulo something. – Abr001am May 7 '16 at 10:49
• 3. extra time for me to stop execution. – Abr001am May 7 '16 at 10:49
• a compressed string of numbers * in the first note – Abr001am May 7 '16 at 11:31