Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Comments addressing specific points mentioned in the proposal
• Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Answer 1

[title TBD]

code-golf

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.

Answer 2

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.

Answer 3

Parse default arguments

code-golf

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

Answer 4

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?

Answer 5

Reverse Engineering

cops-and-robbers reverse-engineering code-golf

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?

Answer 6

Are bug hunts like this allowed?

Bug Hunt - Make a change in a Git repo that Git cannot detect

Challenge: In the working directory of a Git repo, make a change that Git cannot detect.

• Changes can be on any file in the working directory or subdirectories that is tracked by Git.
• You may use any tool to make the change, or script your own program to do so.
• For tools, state the tool used and the steps to reproduce.
• For script or program, produce the code (please use GitHub Gist if it's too long). State the language and compiler version, if any.
• You can also do the change manually. In this case, outline the steps.
• State the version and platform of the Git binary used.
• Show a comparison between an actual clean working directory and the modified one to show the change Git can't detect.
• Show that git status says "nothing to commit, working directory clean".

Winning Criterion:

• The extend of the undetected change - the bigger the change, the better.
• Reasonably latest Git version.
• Easy to reproduce.
• [Optional] Short code or simple steps. It's OK if it's not, as long as you do something exceptional.
• Most upvotes (for tiebreaker reasons).
• [Optional] You located an actual unfixed bug in the Git source code, and not just a quirk in something else.

Restrictions:

• Obviously, using .gitignore is not allowed. It's a bug hunt. Changes that Git is designed to ignore are not allowed. We should reasonably expect Git to see and report the change, but find that Git doesn't.
• Use latest Git version you can get. Some old version with some bug that's already fixed doesn't count.

Please let me know if this is OK, so I can go ahead to post it on the main site.

I could only find file-system. A suggested tag bug-hunt would have been the best.

Answer 7

Calculate the last N digits of Graham's Number

fastest-code

---

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)

Answer 8

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.

code-challengegraphical-output

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.

Answer 9

Factorize Gaussian Integer

code-golfmatharithmeticcomplex-numbers

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

Answer 10

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?

Sandbox comments

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.

Answer 11

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.

Answer 12

Self-decrypting code

code-challenge

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"

Your task

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.

Answer 13

Calculate the number of consecutive 0's at the end of n!

fastest-code

---

Simply put, write a program or function that takes n and returns the number of consecutive 0's at the end of n!

---

Examples

Input: 12
Output: 2

---

Input: 12345
Output: 3082

---

Input: 100000
Output: 24999

Answer 14

How many pixels are in each ASCII char?

code-golf

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"

//ask for the char
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++
}
alert(pixelCount)

Answer 15

Self-identification before golfing

Since golfed code is harder to read, answers often contain an less golfed version. There are a number of potential golfing transformations depending on the language, so you may be able to score more highly using a more traditional language. Some examples of golfing transformations:

• Removal of spaces, tabs and/or newlines
• Removal of disambiguating parentheses
• Removal of braces around single controlled statements
• Conversion from statements to comma operator
• Removal of explicit return statements
• Renaming identifiers

Your challenge is to write a program or function that can identify an ungolfed version of itself. Scoring is based on the number of golfing transformations that can be recognised. The submission must be capable of identifying all "original" code that is itself capable of self-identification (at least one such code must exist). Each supported transformation scores 1 point, but there are also bonus points available:

• 1 bonus point if the transformation can be repeated multiple times
• 1 bonus point of the program rejects at least one invalid transformation of itself (e.g. white space added inside a keyword)
• 1 bonus point if the program only accepts valid transformations of itself
• 1 bonus point if the transformation shortened the code (so if you only supported renaming a 1-letter variable to another letter, you would not qualify)
• 1 bonus bonus point if in addition the transformed program recognises the original program as a transformation of itself

Example: A submission accepts the name of another program as a command-line parameter. It opens itself using its own name hard-coded into itself. It recognises the following transformations:

• A change to the hard-coded file name (3 points, as there is only one file)
• A change to the amount of space between words (5 points, as there are no invalid transformations to reject)
• A change to the names of its variables (4 points, as it doesn't check whether the variables are renamed consistently or to keywords)

Total score: 12 points.

In the event of a tie on score, shortest code wins.

Tags: code-golf, quine

Answer 16

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.

Answer 17

Manual MD5

code-golfhashing

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.

Answer 18

Matrix Multiplication

This is a fastest-code 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.

Answer 19

Iterated Matrix Multiplication

fastest-code

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

Answer 20

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 pictures, demo code
• Add that you have to change the color back to default at the end

Answer 21

Random Wikipedia Browsing

Here's a short one for you. Create a program or function prints or returns the title of a random Wikipedia page (similar to Alt + x functionality)

Rules:

• Program or function will take no input
• Program or function will print to STDOUT (or nearest equivalent) or return only the page name. I don't care about trailing spaces or newlines. Preceding spaces or new lines are disallowed
• Program or function may not access a list of Wikipedia page names stored within a local file.
• There is no requirement to use English language Wikipedia (en.wikipedia.org)
• Page must be chosen (psuedo) randomly

For reference, here is a link to the Wikipedia API. Shortest program or function in bytes wins.

Answer 22

I'm a Puzzle!

code-golf

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(" .*","")
                                     + "!");
    }
}

Answer 23

@Sandbox:

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

Tags: code-golf string balanced-string parsing c

Find the structs!

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

• Function or full program allowed.
• Default rules for input/output.
• Standard loopholes apply.
• This is code-golf, so lowest byte-count wins. Tiebreaker is earlier submission.

Happy Coding!

Answer 24

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.

code-golf

Note: Somewhat similar to this question

Answer 25

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
2H7SJH3S4HKS7H3H -> helpful layout

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

Answer 26

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

Answer: 9

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

Answer: 0

4 - 4 + 4 + 4 = 0

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

Answer: -35

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

Numbers: 1, -2

Answer: 3

1--2 = 3

Answer 27

Make a times table sheet

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

Look at the following:

.

Your answer should have the same layout as this table:

• 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. code-golf

Answer 28

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.

Answer 29

Inverse Square Probability

code-golf

It's a fairly well-known fact that the sum of the reciprocals of squares is equal to pi squared divided by 6. That is,

This is the Basel problem and was solved by Euler in 1735. I was thinking about generating a random patchwork of squares and trying to decide how to weight the probabilities of different square sizes, when it occurred to me that I could use this fact and make the probability of choosing a square's size be the inverse of its size.

For instance, if I pick a random point on the interval [0..pi^2/6), then based on the point I pick, r, I can translate it to a square size in the following manner (all numbers rounded to 3 decimal places):

0     <= r < 1     => s = 1
1     <= r < 1.25  => s = 2
1.25  <= r < 1.361 => s = 3
1.361 <= r < 1.424 => s = 4
1.424 <= r < 1.464 => s = 5
...

Your program or function should work for any input within the limits of your language (for instance, floating point precision, lack of built-in bignum capabilities, etc). Input will always be 0 <= r < pi^2/6.

Test Cases

{to be added}

Answer 30

ASCII Hulls

code-golf ascii-art geometry

---

Input

A string containing a rectangle made up of m rows of n characters, separated by newlines. Apart from an optional trailing newline (which you may choose), the string must contain nothing else.

All the characters will be printable ASCII (including space). So ASCII characters 32 to 176 inclusive.

The dimensions m and n will not be specified in the input. They will both be in the range 1 to 80 inclusive.

Output

A string containing the same rectangle but with the convex hull of each non-space character filled with that character, higher ASCII values overwriting lower ones.

Overwriting does not prevent a character from contributing to the convex hull. For each character, the convex hull is defined based on the locations of that character before any overwriting.

Details

The rectangle of characters forms a grid of m squares by n squares. The vertices of the convex hull for a given character are the centres of the squares containing that character (apart from any in the interior of the convex hull). All squares whose centre is on the convex hull or in its interior become that character (until any overwriting).

Equivalently you can use the top left corner instead of the centre (or any other point in the square) provided it is consistent. This will give the same output.

Test cases

Input followed by output in a single code block

P    
   P
 P  

P    
 PPP
 P

C    C

      G    G
    C    C

   G    G

CCCCCC
  CCCCC
   CCCGGGGGG
    CGGGGGG
    GGGGGG
   GGGGGG

 W    Z
X      X


Y      Y
 W    Z

 W    Z
XXXXXXZX
 W    Z
 W    Z 
YYYYYYZY
 W    Z

Scoring

The shortest code in bytes wins.