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

Image Smoothing

Input into your program a black and white image. (png, jpg, etc)

Convert the image to a 2-d matrix of pixels. Where each index is the grayscale value of the image.

Take each index of the matrix and average the 8 pixels around it. Then replace that index with the average.

For example if you had:

120 80  60
20  10  30
40  100 05

If you were finding the average for 10, the result would be 56.875. Round to up to the nearest integer (57) and replace the index. The result of this iteration would be

120 80  60
20  57  30
40  100 05

If you are finding the average for a pixel on an edge then only take values that are valid. In the example above if you were finding the average for '20' You would only consider 112, 80, 57, 100, and 40, which is 79.4 rounded to 80.

You may start at any index of the graph but it must be in order, for example of you must go right - left, left - right, up - down, or down - up. You may not go something like randomly pick the indices to average.

Once the averaging is complete, convert the matrix back into a new image.

display the new image as the output of the program. (Or save it and add it in your solution). The result of this process should be a normal crisp looking image and the result would be a smoothed out image.

Please provide your code and start and end image (SFW please) and remember this is code-golf so the shortest code wins!

Good Luck and have fun!

Answer 2

code-golf internet

Implement BozoCrack

Designed to show why MD5 is a bad solution to password hashing, BozoCrack, for the uninitiated, is a rather simple and efficient method of cracking MD5 hashes. It doesn't brute force, use rainbow tables or indeed, any sort of math at all.

Instead, it finds the key by searching google for the hash and comparing the hash of each word in the results with the input.

Your task is simple: given at least one valid MD5 hash in a reasonable input format, find their source texts using Google and return or print to stdout the results.

In fact, you could probably arrive at the answer by finding the word in the page with the most occurrences -- you needn't use the results for a dictionary attack, but you must use Google.

The inputs can be given as an array of strings, as program arguments, space or otherwise delimited strings on standard input or in a file, etc -- whatever's easier for you, but make sure you specify in your answer how the input is taken.

Example inputs / outputs:

Input                            : Output
fcf1eed8596699624167416a1e7e122e : octopus
bed128365216c019988915ed3add75fb : passw0rd
d0763edaa9d9bd2a9516280e9044d885 : monkey
dfd8c10c1b9b58c8bf102225ae3be9eb : 12081977
ede6b50e7b5826fe48fc1f0fe772c48f : 1q2w3e4r5t6y

Of course, you may use your language's library function for computing the md5sum of a string -- but please, don't use any functions or libraries designed to solve exactly this task, e.g. Python's PyBozoCrack and the original BozoCrack.rb are disallowed.

In the unlikely event there are no results for a sum, print "NO RESULTS" to stdout instead.

Answer 3

AlphaGo..olf?

code-golf

(Slight paraphrased) Extract from Wikipedia:

AlphaGo is a computer program developed by Google DeepMind in London to play the board game Go and is the first computer Go program has beaten a 9-dan professional without handicaps.

In order to appreciate the Go art more, let's try to simulate what happens to the game when a move is made!

Input

The input will be:

1. a 4x4 board, (Here . denotes empty, o and x denotes different color of stones held by the 2 players respectively for illustration. Any standard input formats (2d array, array as sequence of alternative moves...) are welcomed as we like nice algorithms!)

2. a move to be made (Like A4, B2. You may also like to use 0-indexed and both numeric indices like (0,0)..(3,3)) For simplicity's sake, the move to be made is always with o (i.e. always the same color).

Output

The board after the move is made. Stones of the opposite color (i.e. x) will be taken away iff there are no more connected x that has at least 1 . in its 4-neighbor (Up, Down, Left, Right).

Examples

  Input | Move | Output
  ABCD  |      |
1 ....  | A1   | o...   (case 1: all stones remains on board)
2 ....  |      | ....
3 ..x.  |      | ..x.
4 ....  |      | ....
--------+------+--------
  ....  | B1   | .o..
  oxo.  |      | o.o.   (case 2: x taken away: the only . is taken)
  .ox.  |      | .ox.
  ....  |      | ....
--------+------+--------
  ..o.  | B1   | .oo.
  oxxo  |      | o..o   (case 3: >1 x taken away: the only . is taken)
  .oxo  |      | .o.o
  .xo.  |      | .xo.
--------+------+--------
  o.xo  | B1   | oo.o
  ..o.  |      | ..o.   (case 4: Edge case)
  ....  |      | ....
  ..o.  |      | ..o.
--------+------+--------
  x.o.  | B1   | .oo.
  ooxo  |      | ooxo   (case 5: Corner case)
  ...o  |      | ...o
  ..o.  |      | ..o.
--------+------+--------
  xxxx  | B2   | ....
  x.xx  |      | .o..   (case 6: Enclosed by Board case)
  xxxx  |      | ....
  xxxx  |      | ....
--------+------+--------
  .oxx  | C2   | .o..
  ox.x  |      | o.o.   (case 7: Enclosed by o case)
  oxxx  |      | o...
  .ooo  |      | .ooo
--------+------+--------
  .xo.  | A1   | o.o.
  xo..  |      | .o..   (case 8: taking multiple groups case)
  o...  |      | o...
  ....  |      | ....
--------+------+--------

Rules

1. This is code-golf thus the shortest code wins.
2. Please kindly provide explanations and ways to test the solutions!
3. The Input board can be assumed to be correct: there will be neither x that without a connected x with ., nor a group of o surrounded by x without .
4. The Input move can be assumed to be legitimate: either it won't be a position surrounded by x, or it must take away some x to free . for the o to live. (ref. case 6, 7, 8)
5. The output must be the board, it may or may not be in the same format as the input (if you take input as 2 arrays of o and x positions, say). Output that only shows the stones that are taken away after the move is made will not be accepted.
6. Again, feel free to play with the standard input formats. Hope to see interesting 1 and 0 playing Go instead of o and x :P

Meta Questions

1. I don't know if this may be too hard. Would it be better if I allow golfers to fail some test cases and get penalty instead?
2. Should I stick with a 4x4 board or I can award minus scores if the solution can work with a 19x19 board?
3. If it is a yes to any of the above questions, which should be the number for the penalty / award?

Thanks!

Answer 4

Categorize the asymptotic behavior of a consumer/producer system

Given two functions P(t) and C(t), output the correct category for the behavior of P(t)-C(t) as t goes to positive infinity:

1. Ideal: P(t)-C(t) goes to 0.
2. Stable: P(t)-C(t) oscillates, with the time spent as a positive value equal to the time spent as a negative value within a single oscillation period.
3. Hungry: P(t)-C(t) either converges to a negative value, or oscillates, with more negative values than positive values in one oscillation period.
4. Starved: P(t)-C(t) diverges, approaching negative infinity.
5. Saturated: P(t)-C(t) either converges to a positive value, or oscillates, with more positive values than negative values in one oscillation period.
6. Oversaturated: P(t)-C(t) diverges, approaching positive infinity.

Rules

• The expected output will always be one of the above cases - you don't have to worry about other cases
• P(t) and C(t) will always be real-valued continuous functions that only consist of the following operations: addition, subtraction, multiplication, division, exponentiation (for constants a and b and parameter t, a^b, t^a, and a^t are all allowed), principal roots (real roots, only when they exist, and only the positive root when there are 2 real roots), logarithms, and basic trigonometric functions (sine and cosine of arbitrary values, and tangent for values that are not odd multiples of pi/2)
• Input may be in any reasonably format (string, function object/pointer, mathematical function object, etc.)
• You may use any unambiguous set of 6 values for output (like [1, 2, 3, 4, 5, 6], [0, 1, 2, 3, 4, 5], [Ideal, Stable, Hungry, Starved, Saturated, Oversaturated], or [0, ~, -, -∞, +, +∞])

Test Cases

TBD

Sandbox Notes

• Are the definitions and rules clear?
• Are there any I/O methods that should be explicitly allowed or forbidden that aren't covered by the current rules?

Answer 5

(Need a title.)

Your task is to write 3 programs (or functions) that check if the input is a string of balanced brackets satisfying all the following criteria:

• The number of []s is always less than or equal to the number of ()s surrounding each position.
• The number of {}s is always less than or equal to the sum of the numbers of ()s and []s surrounding each position.
• The number of <>s is always less than or equal to the product of the number of () [] and {}s surrounding each position.

You can assume that:

• There are only the characters ()[] in the input of your program 1.
• There are only the characters ()[]{} in the input of your program 2.
• There are only the characters ()[]{}<> in the input of your program 3.

Your score is the product of (the length of each program + 1). Lowest score wins.

Examples

(To do.)

Answer 6

Quine tree

Inspired by that really weird quine challenge

For this challenge, you must construct a quine tree, which is a thing I made up, specifically an infinite binary tree.

How a quine tree works:

A quine tree has infinite nodes.

• Each node is associated with a program

  • Let X, Y, Z, be the programming languages. This program is a polyglot in X and Y. In all but the root node, it is also a polyglot in Z. Note the

  • see below for more details

• Each node has exactly two children

• Every node but the root has a parent. Their parent has the node as a child (obviously).

Programs:

• When a node's program is run in X, it produces the program of the first child of that node.
• When run in Y, it produces the program of the second child of that node.
• The programs produced must be different (node foo's program, cannot have the same output in X and Y. This output must also be different than the nodes program).
• If not the root node, when run in Z, it produces the parent of the node.

Example

Imagine that we have the (fake) programming languages Hello, World, and Foobaz. Say the root node is $QQ$QQ$;:

• when run in Hello, perhaps it produces $QQ$QQ$;;
  • When this is run with Hello again, perhaps produces $QQ$QQ$;;;
  • When this is run with World, perhaps produces $QQ$QQ$;;Q
  • Both these programs must produce, run in Foobaz, $QQ$QQ$;; (Output of root node run in Hello)
• when run in World, perhaps it produces $QQ$QQ$;Q
  • When this is run with Hello, perhaps produces $QQ$QQ$;Q;
  • When this is run with World again, perhaps produces $QQ$QQ$;QQ
  • Both these programs must produce, run in Foobaz, $QQ$QQ$;Q (Output of root node run in World)
• Both these programs, run in Foobaz, must produce $QQ$QQ$; (root program).

Answer 7

Fastest Cashier in the West

You're trying to design an automatic cashier that is able to dispense the correct amount of change in any denominations as quickly as possible. Your goal is to implement a program that accepts a target integer T ≥ 0 which is the amount you're trying to make change for, and a set of positive integers {c₁, c₂, ..., c_n} which are the values of each coin where you have an infinite number of each, and output all possible solutions for making change with those types of coins.

For example, if you're trying to make change for 123 and the coins available are {12, 16, 20, 27}, then there are 8 possible solutions

12 16 20 27  (123)
 0  1  4  1  means zero 12's, one 16, four 20's, one 27
             also 0*12 + 1*16 + 4*20 + 1*27 = 123
 0  6  0  1
 1  4  1  1
 2  2  2  1
 3  0  3  1
 4  3  0  1
 5  1  1  1
 8  0  0  1

Format

The input will be formatted as

T
N
c1
c2
...
cN

where T is the target value, N is the number of coins, and each cK is the value of coin k. Also, the coins will be listed in ascending order.

For example,

123
4
12
16
20
27

The output will be format as

x11 x12 ... x1N
x21 x22 ... x2N
...
xM1 xM2 ... xMN

where M is the number of solutions and N is the number of coins. Each line will contain the number of each coin needed to reach the target value separated by spaces. You may have trailing whitespace on each line.

For example, the output to the input above would be

0 1 4 1
0 6 0 1
1 4 1 1
2 2 2 1
3 0 3 1
4 3 0 1
5 1 1 1
8 0 0 1

You may output the solutions on each line in any order, but each solution must be unique.

Rules

• This is fastest-code so your only goal is to make your program as fast as possible.
• Builtins or libraries that solve this problem directly are not allowed.
• In the interests of having fine submissions, the deadline will be by December 12, 2016, which is almost two months.
• Your program must be single-threaded. However, you are allowed to use SIMD instructions and any other features of the CPU.
• The code will be ran on my machine which uses Fedora 24 x64 and has an i7-920 with 18 GB of memory.
• Please provide compilation instructions and version information if your program requires it.
• Please do not obfuscate your code unnecessarily. If I am suspicious of certain code and/or libraries, I reserve the right to ignore your submission.
• This is optional but if you are using advanced mathematical strategies, commenting and explaining your program would be very much appreciated.

Thoughts

The test cases will be created and provided as a download if there is interest.

For scoring, there will be a hidden dataset that is ran when the deadline is reached for final scoring purposes. After this is complete, the hidden dataset will be released along with the winner.

For extra incentive, should I increase the best answer reward by including a bounty. Or maybe for the three fastest?

Is it okay to ban commercial products as I may not have access to some of them. It wouldn't be fair to allow Mathematica and not Matlab/Maple/etc.

@PeterTaylor: I have an implementation in Python that uses a memoized recursive function and I would say its performance is decent at best. I do agree that I/O could be a bottleneck but I could choose test cases that have few or no solutions. Using methods to calculate the Frobenius number would help find those, but I would still like to see a few cases with a large number of solutions. I see two options. First, I could require the output to be ordered so that results could be piped into another program and avoid hitting the disk while being verified. The second is to test each program twice, first with the output enabled to check the accuracy, and if accurate, the second run would be with the output disabled to measure the execution time.

Answer 8

It's time to parse (everything)!

code-golf parsing

---

Introduction

The real world is hard. Internet standards suck. However they're used everywhere anyways. One standard in particular has been the source of a lot of trouble and frustration.
ASN.1
Abstract Syntax Notation 1
is used in many many places (including when parsing website certificates) and now it's up to you to implement a simple ASN.1 parser in your favourite programming language!

Specification

Input

Your input will be an ASN.1 encoded object. The encoding that is used will be PEM (thus it's all ASCII). You may take this input as a file, as STDIN, as a function argument as a string, as a byte sequence, whatever you like. The way your program takes the input should be documented however.

If you take file input, you may have the file name as an additional argument.
If you produce file output, you may have the file name as an additional argument.

Output

The output will be formatted ASCII text, this may be STDOUT, a returned string, a file, whatever, but document it.

What to do

You need to parse an ASN.1 object and return a nice textual representation of the content structure.
This means that there should be some sort of intendention whenever a nested structure is opened (by putting spaces or other signs in front of the identifier).
It also means that you should print the keyword whenever one is hit (also see the example).
You may but do not have to also output actual (decoded) contents or looked-up identifiers.

Warning

While I've always talked about an ASN.1 object, I actually had X.509 certificates in mind. So the parser should understand everything that occurs inside an

List of mandatory keywords:

SEQUENCE
OBJECT
UTCTIME
PRINTABLESTRING
SET
UTCTIME
NULL
OCTET STRING
BOOLEAN
UTF8STRING
BIT STRING
OBJECT IDENTIFIER
IA5STRING

Who wins?

This is code-golf, so the shortest answer in bytes wins!
Standard rules apply of course, built-ins are allowed.

Example Input and Output

Input: The Amazon.com X.509 certificate:

-----BEGIN CERTIFICATE-----
MIIFejCCBGKgAwIBAgIQfkmWRZCbTGK0b6jFJo0YnjANBgkqhkiG9w0BAQsFADB+
MQswCQYDVQQGEwJVUzEdMBsGA1UEChMUU3ltYW50ZWMgQ29ycG9yYXRpb24xHzAd
BgNVBAsTFlN5bWFudGVjIFRydXN0IE5ldHdvcmsxLzAtBgNVBAMTJlN5bWFudGVj
IENsYXNzIDMgU2VjdXJlIFNlcnZlciBDQSAtIEc0MB4XDTE2MDUxODAwMDAwMFoX
DTE2MTIzMDIzNTk1OVowaDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldhc2hpbmd0
b24xEDAOBgNVBAcMB1NlYXR0bGUxGTAXBgNVBAoMEEFtYXpvbi5jb20sIEluYy4x
FzAVBgNVBAMMDnd3dy5hbWF6b24uY29tMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A
MIIBCgKCAQEAuwQMfKRRZpql3WBS0uo4DfMrrkAEX9+6UD2fVSmV21i9iqCecmHa
4z9LNzeKqpGNkpTbXMaJfLxy0ehoQp7vyVIit6l+VZ9L+VTiL0+v8MjG+Kl6Sg4J
6ozV+EHck91Id8zCUyLHLcmJ5f60kazJJC1zGKlTkZR6Of0SzcLrje0T3Pqmdybj
AjFoBMdk0G1rKctxds1UnywI4pIONzsmozzPjk8Up5NA1s3bo9ubCQUcPSEm1TDJ
4TDdQVL8WsDNjY0SwTiVmJ+vo4TVIhRlfGv+xzHe8JXFYxsVJZ/FP70uFRH5+Uku
4yaGYFZYt71V3kOTzM3FvRlHb93jANoAHwIDAQABo4ICCDCCAgQwgb0GA1UdEQSB
tTCBsoIKYW1hem9uLmNvbYIIYW16bi5jb22CEXVlZGF0YS5hbWF6b24uY29tgg11
cy5hbWF6b24uY29tgg53d3cuYW1hem9uLmNvbYIMd3d3LmFtem4uY29tghRjb3Jw
b3JhdGUuYW1hem9uLmNvbYIRYnV5Ym94LmFtYXpvbi5jb22CEWlwaG9uZS5hbWF6
b24uY29tgg15cC5hbWF6b24uY29tgg9ob21lLmFtYXpvbi5jb20wCQYDVR0TBAIw
ADAOBgNVHQ8BAf8EBAMCBaAwHQYDVR0lBBYwFAYIKwYBBQUHAwEGCCsGAQUFBwMC
MGEGA1UdIARaMFgwVgYGZ4EMAQICMEwwIwYIKwYBBQUHAgEWF2h0dHBzOi8vZC5z
eW1jYi5jb20vY3BzMCUGCCsGAQUFBwICMBkMF2h0dHBzOi8vZC5zeW1jYi5jb20v
cnBhMB8GA1UdIwQYMBaAFF9gz2GQVd+EQxSKYCqy9Xr0QxjvMCsGA1UdHwQkMCIw
IKAeoByGGmh0dHA6Ly9zcy5zeW1jYi5jb20vc3MuY3JsMFcGCCsGAQUFBwEBBEsw
STAfBggrBgEFBQcwAYYTaHR0cDovL3NzLnN5bWNkLmNvbTAmBggrBgEFBQcwAoYa
aHR0cDovL3NzLnN5bWNiLmNvbS9zcy5jcnQwDQYJKoZIhvcNAQELBQADggEBAKeH
/SiREeFlL0ce/UDYoPDU/91x8XsbJuLRqxm1zEBzq/07/Fnd4nL/rayEEFIEubRS
IL9Ewi+htMz2nLrR0BMu3ilqWGhpOEvkcgT9uh/CjhPhVMse0lpHYSn62ZvUWTwn
vG0ardOd5MuE2NiveZxl3/o2cLcyiySxtX7N3yADchGP27iOkjXocdpZwtjIa7EB
pp3GojEbWRbGxtLC7SO3vY4a0N2bb5b9J7y5OtSKjInRJaMs19pFwlHMOMZR0y70
rHaz9eRB++LuEI2B90Mqr33NMysb1enMo61Dt16Ki3yT1zVBHp1vbqM6gX2UeEMA
A+HEDpMefyQVspV7twA=
-----END CERTIFICATE-----

Example output:

SEQUENCE
   SEQUENCE
      [0]
         INTEGER
      INTEGER
      SEQUENCE
         OBJECT IDENTIFIER
         NULL
      SEQUENCE
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               PRINTABLESTRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               PRINTABLESTRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               PRINTABLESTRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               PRINTABLESTRING
      SEQUENCE
         UTCTIME
         UTCTIME
      SEQUENCE
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               PRINTABLESTRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               UTF8STRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               UTF8STRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               UTF8STRING
         SET
            SEQUENCE
               OBJECT IDENTIFIER
               UTF8STRING
      SEQUENCE
         SEQUENCE
            OBJECT IDENTIFIER
            NULL
         BIT STRING
            SEQUENCE
               INTEGER
               INTEGER
      [3]
         SEQUENCE
            SEQUENCE
               OBJECT IDENTIFIER
               OCTET STRING
                  SEQUENCE
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
                     [2]
            SEQUENCE
               OBJECT IDENTIFIER
               OCTET STRING
                  SEQUENCE
            SEQUENCE
               OBJECT IDENTIFIER
               BOOLEAN
               OCTET STRING
                  BIT STRING
            SEQUENCE
               OBJECT IDENTIFIER
               OCTET STRING
                  SEQUENCE
                     OBJECT IDENTIFIER
                     OBJECT IDENTIFIER
            SEQUENCE
               OBJECT IDENTIFIER
               OCTET STRING
                  SEQUENCE
                     SEQUENCE
                        OBJECT IDENTIFIER
                        SEQUENCE
                           SEQUENCE
                              OBJECT IDENTIFIER
                              IA5String
                           SEQUENCE
                              OBJECT IDENTIFIER
                              SEQUENCE
                                 UTF8String
            SEQUENCE
               OBJECT IDENTIFIER
               OCTET STRING
                  SEQUENCE
                     [0]
             SEQUENCE
                OBJECT IDENTIFIER
                OCTET STRING
                   SEQUENCE
                      SEQUENCE
                         [0]
                            [0]
                               [6]
             SEQUENCE
                OBJECT IDENTIFIER
                OCTET STRING
                   SEQUENCE
                      SEQUENCE
                         OBJECT IDENTIFIER
                         [6]
                      SEQUENCE
                         OBJECT IDENTIFIER
                         [6]
SEQUENCE
   OBJECT IDENTIFIER
   NULL
BIT STRING

Helpful ressources

• Reference parser
• TODO: Add more useful links and actual ASN.1 parsing description

Answer 9

Simple Substitution Cipher Programming

A simple substitution cipher maps each unique character to another character. If my substitution cipher is [H->6, e->U, l->V, o->)], then Hello becomes 6UVV).

You must write a program A which inputs a string of text, and outputs the text after passing it through a substitution cipher.

You must also be able to handle your program, A, as input, printing out B. If possible, B then applies a different cipher, and prints out C, and so on, until you cannot repeat the process anymore, or until a duplicate program as been generated.

Your ciphers must:

1. Contain at least 2 substitutions, and every character in your program.
2. Change every character (i.e., no A->A)
3. Be unique on every substitution (i.e., if program A uses x->y, then program B must convert x into something other than y)
4. All be written in the same language (same version)

Your score is ByteCount(A)/NumIterations. You can assume that your input only consists of substitute-able characters.

For example, if A was Programming, and it generated p80G8AMM1NG, which generated u79)7%vvQ-), which finally generated Programming, then there were 3 ciphers applied, and a byte count of 11, so my score would be 11/3, or approximately 3.666667. If the final output was an invalid program, my score would still be the same.

Answer 10

Peano's quine

Your task is to write two programs in the same programming language.

The first program is simply a quine, in the following called "zero quine".

The second program, called succesdor program, is a program that gets a program text as input, and outputs another program text, according to the following rules:

• The input text is either the zero quine, or code that is (or could be) the output of another run of the successor program.

• The output is again a quine in the same language.

• The zero quine, generated quines and successor program fulfil Peano's axioms. In particular:

  1. The successor function does never output the zero quine, no matter what the input is.

  2. The successor function produces different output when acting on different valid input.

In other words, the zero quine and the successor function together allow to generate an unbounded number of quines, one for each natural number.

The score is the total number of bytes of the zero quine and the successor program together.

Note that while there are several challenges that have programs returning longer versions of itself when run, I didn't find any that has a program transforming a proper quine into another proper quine.

Tags: code-golf quine

Answer 11

Three-way meta-quine polyglot code-golf

Produce a program A such that running it in language A produces Program B, and running program A in language B produces program C.

Program B, when run in language B produces Program A, and running program B in language A produces program C.

Program C, when run in language A or language B, prints "Wrong language!".

Program | Language | Result
--------|----------|----------
A       | A        | Program B
B       | B        | Program A
A       | B        | Program C
B       | A        | Program C
C       | A        | "Wrong language!" 
C       | B        | "Wrong language!" 

Your answer should use this template:

---

Language A/Language B, {a bytes} + {b bytes} = {total bytes} bytes

Language A:

a code

Language B:

b code

---

Source:

# Language A/Language B, <a bytes> + <b bytes> = <total bytes> bytes

Language A:

    a code

Language B:

    b code

---

• None of these programs should take input.
• Different versions of the same language count DO NOT as different languages. - Languages A and B must be distinct.
• You must not read your own source code from a file. Programs may not be empty
• Standard loopholes apply.

This is code-golf, the smallest sum of the byte counts Program A and B wins.

Answer 12

Match the BF output code-golf regex brainfuck

Your task is, when given a BF program as input and 256 1's on the line after the BF program, match the amount of 1's equal to the value of the pointer when the program halts.

For a BF tutorial, see here.

Example programs:

+++
(255 1's)

(The above program should match 3 1's.)

++[>+++>+++<<-]>
(255 1's)

(The above program should match 6 1's.)

Specs:

• The tape in question is 10 long, with wrapping.
• There is wrapping for the individual values: if it goes over 256, it goes back to 0.
• There is no , or . in the BF code.
• You are guaranteed that the code will terminate.
• You may use any flavour you want.
• You may match 1's in any position, as long as you match the correct amount of 1's.

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

Meta stuff:

• How hard would this be to pull off? Is it even possible?
• Anything I could improve with explanations?

Answer 13

Find the highest product in a grid

The following problem was inspired by Problem 8 at Project Euler.

Write a program that takes a 2-dimensional block of digits and a number on a newline ("n") as it's input. Output value of the product of the n adjacent (read "in a straight line") digits in the that have the greatest product. Error cases don't need to be covered (eg. the grid is not rectangular, n is missing, n is bigger then the width/height as the block, etc.). Diagonal numbers are also adjacent.

Examples:

1932       
4836       
8490  -->  288
3          

53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881  -->  5832
16427171479924442928230863465674813919123162824586
4

43289
90283
03248  -->  error (print whatever)
34290
22

397432008949201741720 --> 72
2

Note: possible inputs below are equivalent:

2830
0309
8011 
4

2 8 3 0
0 3 0 9
8 0 1 1 
4

{{2, 8, 3, 0},
{0, 3, 0, 9},
{8, 0, 1, 1}}
4

And so on, it's not strict.

It's code-golf, so the shortest answer in bytes wins!

---

code-golf

Answer 14

Absolutely correct !

I have been given some homework, in which my Math teacher wants me to figure out what expression is represented in the graphs she gave me. Because it is long and painful to do every single one of them by hand, I want to automate it a bit.

The challenge

Given a graph as an input, output the equation represented, in human-readable format. That is, something like that:

y=-|x-3|+5

More generaly, the expression will always be of the form

y=±|x+a|+b

Where you have to replace a and b by their value. The function has to be simplified to its maximum (i.e. can not contain +0, -0, or +|x|);

The input

The input is given in ASCII.

             \       |       /             
              \      |      /              
               \     |     /               
                \    |    /                
                 \   |   /                 
                  \  |  /                  
                   \ | /                   
                    \|/                    
---------------------V---------------------
                     |                     
                     |                     
                     |                     
                     |                     
                     |                     
                     |                     
                     |                     
                     |                     

This represents the equation y=|x|. The graph is not always centered, and can be of any width and height.

/, \ are straight lines. A and V are verteces. - and | are the axes, and + is their intersection (if not covered by an other character).

Unit

A unit is two characters. for example, -- is one unit on the horizontal axis.

|
|

Is one unit on the vertical axis.

Tests

A test suite is available here. A line of #s is used to separate input from output. Output goes first, for clarity.

Answer 15

How Big is the Hyperbolic Round Table of Camelot?

There is a hyperbolic rogue-like game called HyperRogue, based on the truncated order-7 triangular tiling. (Each vertex is surrounded by two hexagons and one heptagon.) There is a place in this game called Camelot, where the Round Table sits. In the middle of the table is the Holy Grail. The table starts with a radius of 28, but each Holy Grail you collect increases the radius by 2. So my question is: given the number of Holy Grails collected, what is the area of the Round Table?

Assumptions:

• The Holy Grail starts on a heptagon.
• The heptagon the Holy Grail is on is the circle of radius 0.
• A circle with radius n+1 comprises the circle of radius n and all the cells touching the circle of radius n.

Test Cases:

0 Holy Grails = 31659398 Tiles
1 Holy Grail = 93888285 Tiles
2 Holy Grails = 278432568 Tiles

Winning Criterion:

Shortest code wins! code-golf

Answer 16

Pay Best Card in Euchre

Input:

Firstly
An array of three cards representing the cards played by each player formatted like

[JD][10H][9S]

Representing

Jack of Diamonds, 10 of Hearts, and Nine of Spades.

As you always sit across from your team-mate in Euchre, the second element represents your team mate's play. Here, the 10H.

Secondly
A Single Char, String, etc representing the trump suit formatted like

S, D, C, H

representing

Spades, Diamonds, Clubs, Hearts

Thirdly an array of four cards representing your hand formatted like

[KD][JC][QH][AS]

representing

King of Diamonds, Jack of Clubs, Queen of Hearts, Ace of Spades

Objective:

Given the three inputs, output the best possible card to add to the cards that have been played such that it meets the following criteria:

1. It takes the hand if it can, if not output the least valuable card
2. It takes the hand if it can, however it will not trump your team mate unless it is unavoidable
3. If it can take the hand, it does so by using the least valuable card. (If you have an ace and a queen that can win the hand, you play the queen).

Output format like [JD]

Formatting

A - Ace
K - King
Q - Queen
J - Jack
10 - Ten
9 - Nine

H - Hearts
D - Diamonds
S - Spades
C - Clubs

10H, 9D, JD, QH, AD, 9C, 10C

Examples

In: [QD][KD][9C], "C", [AH][JH][QH][9H]

Out: 9H

Reason: As clubs are trump, the 9C is winning the hand, we are unable to take the hand so we should discard our lowest card, here the 9H

In: [QD][KD][AD], "H", [AH][JH][QH][9H]

Out: 9H

Reason: As Hearts are trump, the Ace of Diamonds is currently winning the hand, we are able to trump the hand so we should use our lowest card, here the 9H

In: [QD][KD][10D], "H", [AD][JH][QH][9D]

Out: 9D

Reason: As diamonds are trump and we are currently winning the hand, we should play the 9D because our partner currently is winning the hand, so we want to play the 9D over the AD

In: [QH][KH][JH], "D", [AD][JD][QH][9D]

Out: QH

Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower but cannot trump him because QH was led and we must follow suit, the QH

In: [QH][KH][JH], "D", [AD][JD][QC][9D]

Out: JD

Reason: As Diamonds are trump our opponents are winning with the left Bower JH We have the right bower and since we have no Diamonds we can trump over him with the JD

Euchre Card Strengths

If Hearts is trump:

JH
JD
AH
KH
QH
10H
9H

See the Euchre Rules if you are unfamiliar with the strength of different cards in Euchre

Since this is Code-Golf the shortest code wins!

Good Luck and have fun!

Answer 17

Python Kolmogorov Complexity Golfer

Python is actually pretty good at some Kolmogorov Complexity challenges (compared to other non-golfing languages), from string multiplication being extremely short, to defining variables requiring no types.

Your challenge is to make a program that shortens Python code for Kolmogorov Complexity challenges. You can use anything, not just the usual functions that people typically use.

Your score is the sum of all the bytes for each of the ten test cases, and the winner is the submission with the lowest score.

Test Cases

1. We're no strangers to code golf, you know the rules, and so do I
2. It's my Birthday :D (Size 5)
3. 1, 2, Fizz, 4, Buzz
4. Code Golf Christmas Edition: How to print out a Christmas tree of height N (Size 5)
5. “99 Bottles of Beer”
6. Build me a brick wall!
7. Quack the Angry Duck
8. Make the Mexican Wave
9. Print a Tabula Recta!
10. Print a 10 by 10 grid of asterisks

I don't know about the rules for each challenge, but for this one, you may print extra spaces after each line and extra newlines at the end of the text.

Note

I don't know how to tag this.

Answer 18

Enumerate all the binary matrices

Your task is to write a pair of programs or functions. The first should take a single nonnegative integer, and return some matrix where all elements are 0 or 1 (or true/false). The second should take a matrix of the same form, and return a nonnegative integer.

The two programs should form a bijection, so that every possible matrix is mapped to exactly one nonnegative integer, and every integer to the corresponding matrix. The matrix with no elements must be included, but we consider all matrices with no elements as identical (i.e, there is no 0x3 matrix.)

To clarify, the dimensions of the matrix is not a separate input. You must work out a way to represent all possible dimensions. For instance, you could start off enumerating them like this:

0 <-> []
1 <-> [0]
2 <-> [1]
3 <-> [0;0]
4 <-> [0;1]
5 <-> [1;0]
6 <-> [1;1]
7 <-> [0,0]
8 <-> [0,1]
9 <-> [1,0]
10 <-> [1,1]

But you can also enumerate them in some different order, as long as all matrices of all dimensions can be reached eventually.

You may output and input the integer as a bigint if your language supports that, or as an unbounded string or array if it doesn't. It should however not be limited to a machine word size.

You may output the matrix in any format you choose, as long as the elements of the matrix, and the rows/columns of the matrix are clearly distinguishable.

Whatever output formats you choose, the other program must accept input in the same format. Your functions or programs may opt to print the result rather than return it.

Standard loopholes are forbidden. This is code golf, so the shortest answer wins.

code-golf number binary-matrix

Answer 19

Challenge

You are the owner of a local supermarket, and your cashier doesn't seem to do the work you told him/her to do. He/She is never on time, returns too much change and doesn't really show optimism at the workplace. So you, as the space saving, but ruthless owner opt to replace him/her.

Rules

The programm should initially take 2 numbers as input, the first beeing the price, and the second the amount you are paying. If you are paying enough it should output the change in 100,50,20,10,5,2,1 notes, always maximizing the amount of high notes. If you aren't, you may output anything indicating a wrong input.

Examples

cashier 100 500
4 100
0  50
0  20
0  10
0   5
0   2
0   1

cashier 600 500
0

Scoring

This is code-golf, so the shortest byte amount wins :) Good luck!

Answer 20

Fold the number!

Given a number n, fold the number as follows: (ex. 30)

First, convert it to binary.

11110

Add one 0 to the start if it has an odd number of digits.

011110

Now, take the second half of the number, reverse it, and put it under. For example, abcd would turn into ab dc (where is a newline):

011
011

Add one 0 to each line if it has an odd number of digits.

0011
0011

Now take the back of the whole thing and put it on the bottom, reversed:

00
00
11
11

Keep doing this until there is only one column, and read this from top to bottom.

00110011

Convert to decimal.

51

Remember, this is code-golf, so the code with the smallest number of bytes wins.

code-golf number base-conversion

Answer 21

Postman's Sorting

You are a postman, and you have to walk down a street, delivering letters. Odd-numbered houses are on the left, and even-numbered houses are on the right.

If you had to end up back at the beginning of the street, it would be easy: simply deliver the odd letters in ascending order and the even letters in descending order.

Instead, you need to finish at the end of the street. But you can't simply deliver the letters in ascending house number order, because you would have to cross the street so often. You need to optimise the order to minimise the number of street crossings.

Given a set of positive integers as input, your program or function should output an ordered array giving the optimal delivery sequence. You need to consider the houses in pairs: 1,2; 3,4; 5,6 etc. There are a number of cases:

• If you have no letters for a pair of houses, you simply ignore them.
• If you have letters for only one of a pair of houses, you have no choice, you must visit that house.
• If you have letters for both houses in a pair, then you want to visit the house on the same side as the house you just visited first, then cross and visit the other house.

Example: If you have letters for houses 6, 2 and 5, then you want to deliver them in the order 2, 6, 5, so as to avoid crossing the street a second time.

[Further test cases as needed to clarify comments arising while the question is in the Sandbox.]

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

Answer 22

Procedurally Generate a Dungeon

popularity-contestgridgamegenerationmaze

It's time to make the new Rogue!

Given no input, output a (randomly) procedurally generated dungeon with a start and an end. It must be possible to get from the start of the dungeon to the end.

Elements may include: (but are not limited to)

• Key
• Lock (requires key to pass)
• Boss
• Miniboss
• Test
• Reward
• Multi-key
• Multi-lock (requires n multi-keys to pass)
• Nothing
• Boolean switch - switch can toggle when inside this room
• Boolean gate A - only opens when switch is off
• Boolean gate B - only opens when switch is on

The output format does not matter as long as:

• The types of room is present
• The 2D spacial connection is present

Sandbox Notes:

• Is this idea somewhat supported?
• At the moment this is very unclear (at least to me). What should I add to make it more obvious what it is programs should do?
• Creativity - the bane of the objective winning criteria. I hope to at least make it obvious whether an answer is valid.
• Too broad? I hope not because I tried to make all dungeons solvable.
• Simple answers shouldn't be upvoted and answers that output nice dungeons should be.
• Should answers have to include the critical path? That might ramp up the complexity and isn't really required apart from making sure it's valid.

Answer 23

Generate fake PGP keys code-golf

Input

• public or private; indicates if the header and footer should say PUBLIC or PRIVATE
• ; - a delimiter
• Version string
• ; - a delimiter
• Comment string

An example input would be: public;Keybase OpenPGP v1.0.0;https://keybase.io/crypto

Output format

-----BEGIN PGP {PUBLIC|PRIVATE} KEY BLOCK-----
Version: {VERSION_STRING}
Comment: {COMMENT_STRING}
                // newline
{24 lines of alphanumeric + `/+`, 64 chars each}
{one 36 char line of alphanumeric + `/+`}
={four chars of alphanumeric + `/+`}
-----END PGP {PUBLIC|PRIVATE} KEY BLOCK-----

Rules

• Your program must generate a new fake key every time it is run; and be randomly distributed

Answer 24

Give those numbers some space! code-golf

The numbers have had it. They're through being put in order all the time. They're all sick of their neighbors, and want to be moved as far away as possible. Your goal is to help them be happy!

The 'happiness' of a number is represented by the difference between it and it's next neighbor. For example, an ordered sequence of 0 through 9 looks like this:

0 1 2 3 4 5 6 7 8 9
 v v v v v v v v v
 1 1 1 1 1 1 1 1 1 = 9

A pretty unhappy sequence. But with a little work, we can fix that!

0 2 4 6 8 1 3 5 7 9
 v v v v v v v v v
 2 2 2 2 7 2 2 2 2 = 23

In this example, we've shuffled the numbers around a little, for a total happiness of 23. Better, but I'm sure we can make them even happier!

0 9 1 8 2 7 3 6 4 5
 v v v v v v v v v
 9 8 7 6 5 4 3 2 1 = 45

This is the maximum happiness for this sequence. Perfect!

Our only problem is that there is a lengthy review before they can be moved around. Due to this, your code has to be as short as possible to speed up the process.

Input

Your program or function will take a list of positive integers in any reasonable format (list, array, string, etc). The list is in ascending order.

Output

Output is going to be a list of integers in any reasonable format, representing the sequence of numbers arranged for maximum happiness.

"1 2 3 4 5 6 7 8 9 0"   -- A string is acceptable, as long as the numbers are separated by a character. 
"6@5@4@3@2@1@7@8@9@0"   -- Any non-numeric character is acceptable as a separator, including newlines.
[0,1,2,3,4,5,6,7,8,9] -- The list represented as an array
"0123456789"             -- Not acceptable, no way to tell which numbers are which.

{I'm trying to open up the challenge to many different ways of solving, feel free to offer suggestions}

Answer 25

Calculate the chi-squared test statistic

code-golfnumberstatistics

---

Introduction

A chi-squared test is a statistical test used to determine the extent of any association between two categorical varaiables. In this challenge, you will calculate the value of the chi-squared test statistic given a contingency table.

Method

Say that we have two variables A and B, which are from a single population. A can take values from the categories p, q, and r, while b can take values from the categories x, y, and z. A sample is now taken from the population, and the frequencies of the elements of this sample that fall into each category are observed. This can be used to construct a contingency table:

         A
     x   y   z
  p [10, 12,  3]
B q [45,  0,  9]
  r [65, 32, 34]

For example, the table shows that 10 elements fall into p and x, and that no elements fall into q and y.

Next, we calculate the expected frequencies, assuming that A and B have no association. This is performed by applying the following to each entry in the contingency table, where f_e is the expected frequency:

In this case, this yields:

[14.285714285714286, 5.238095238095238,  5.476190476190476 ]
[30.857142857142858, 11.314285714285715, 11.82857142857143 ]
[74.85714285714286,  27.447619047619046, 28.695238095238096]

Next, we calculate the contributions to the test statistic by applying the following to each entry, where f_0 is the orignal observed frequency:

In this case, this yields:

[1.285714285714286,  8.72900432900433,   1.1196687370600416]
[6.482142857142857,  11.314285714285715, 0.6763975155279506]
[1.2979825517993466, 0.7550444466475007, 0.9806678994199733]

Finally the value of the test statistic is found by summing all the elements of the contributions table, which gives:

32.640908336601996

---

Sandbox

To do

• Input/output, specification etc
• Test cases (Pyth program for test cases)

Answer 26

A Numpad's Knight Numbers Extended Edition

This challenge is an extension of the one linked above by Calvin, and inspired by a comment by Darrel Hoffman.

My computer has a numpad which is significantly more expansive than Calvin's. For reference, it looks like this:

🔒/ * -
7 8 9 +
4 5 6 +
1 2 3 ↵
0 0 . ↵

🔒 denotes numlock, ↵ denotes enter.

Once again, we have a chess knight hopping around on a numpad. The objective of your program will be to determine which numbers can be generated by placing a knight on any* of these keys and letting him move around. Note that although there is only one 0 key, it's two wide so 5->0->3 is possible but 4->0->3 is not, and the numlock will toggle the numpad on or off, in practice this only allows a jump from 5 to 9.

'*' and '+' are unused and should never be pressed, other than that you can start your knight on any key. The knight may not press ↵ during number entry, but most end there.

Your program will for input receive a number (possibly negative, possibly containing a single decimal point . OR single fraction sign /).

Test cases:

Truthy:
0, 2, 5, 6, 9
-6049
3059 (note the use of `numlock`)
5.16
-61.5
4/6
-6/40
55 (you can jump on 5 or 9 more than once in a row with 🔒...)
Falsy:
66 (... But other numbers can't reach 🔒)
8 (Not within range of ↵ key)
96 (The knight can't move like that)
405 (It's probably easier to think of the 0s as being separate keys)

Input will always be a valid integer, decimal float, or fraction.

Answer 27

Linify

If you perform this algorithm but leave out some of the lines, you can produce recognizable pictures.

An example via Linify.me - as they explain,

Linify uses a greedy randomized algorithm. First, the darkest pixel is found. Then a number of random lines are drawn through that point, and the pixel values along each line are added together. The line with the darkest average is chosen, and the value of that line is subtracted from the image. Then the whole process is started over again for however many lines we are drawing. By the nature of the algorithm, the optimal line drawing configuration is probably not achieved, but performance is far superior to the naive method of checking every line.

The concept for this site came from a Reddit thread.

Challenge

Reduce (this input photo) to a linification using N pins on the outside circle. Each line of the file should be a comma separated list of the pin number and the other pins to draw lines to.

Scoring

(formula using code length and output quality using some sort of comparison software...)

(maybe that comparison algorithm is itself a challenge)

(maybe this linify challenge should be in black and white?)

The Mathematica Clause: You may import graphics and math libraries for your platform older than this post, and the code required to import them does not apply toward your byte count.

Answer 28

Quine Creator

Consider a program (or function or code snippet) that accepts a single string argument and returns a string result. Here's an example, which I will call Program 1, of a program that duplicates its input:

@echo %* %*

We could write a Program 2 that would take the source code of the original program and substitute a hard-coded string, so that the resulting source code would take no input and produce a fixed result. If we passed it Program 1 and "Hello, world!", it would produce a program that always outputs "Hello, world!" in duplicate:

@echo Hello, world! Hello, world!

Moving on, consider Program 3 which has the effect of Program 2 with the same string for both the source code and the hard-coded string, so for input of Program 1 this would result in something like this:

@echo @echo %* @echo %*

All that remains is to invoke Program 3 with its own source code as its input. Program 3 will then create a program that invokes Program 3 with the source code of Program 3 as its input. In other words, a quine!

Please provide the source to Program 3.

This is code-golf, so the shortest resulting quine wins.

Answer 29

I tried searching for this, thinking it was a duplicate. I was unable to find anything (hard to know what to search for), so let me know if it is.

The Challenge

We all know how to apply bitwise not to a binary number. It simply flips all the bits, so 10010 becomes 01101. For this challenge, we will be creating a definition for a digitwise not, applying the same concept to base 10.

Digitwise Not

For this challenge, digitwise not is defined as follows. Line up the digits 0-9. Because 0 and 9 are endpoints of this list, they are considered "opposite", so digitwiseNot(0) == 9, and digitwiseNot(9) == 0. The same concept applies when you go one element into the list from both ends, meaning 1 and 8 are opposite, as are 2 and 7, etc. Full list:

0 <=> 9 
1 <=> 8 
2 <=> 7 
3 <=> 6 
4 <=> 5 
5 <=> 4 
6 <=> 3 
7 <=> 2 
8 <=> 1 
9 <=> 0

For multi-digit numbers, you apply the operation separately for each digit. For example, digitwiseNot(1234) is 8765 because 1 -> 8, 2 -> 7, 3 -> 6, and 4 -> 5.

Rules

• Take only a single input, representing an integer greater than or equal to 0 in whatever format is best for your language (stdin or function parameter, integer or string, etc)
• Produces a single output, which is the digitwise not of the input (can be returned from function or printed to stdout)
• Can be either a full program or just a function.

Answer 30

Christmas Present Viewing code-golf ascii-art

You're stacking Christmas presents, and you'd like to make sure that the pile will be aesthetically pleasing from whichever side you view it, without having to actually go through all the hard work of stacking them.

Write a program that takes the size of the present stacks in the pile, and outputs what the pile will look like from all four corners.

Each present is an opaque cube that looks like this:

  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+

If you have two presents next to each other, for example, it would look like this, because the nearer present occludes part of the further one:

  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+

Two presents with a single space gap between them would look like this:

  +----+    +----+
 /    /|   /    /|
+----+ |  +----+ |
|    | +  |    | + 
|    |/   |    |/
+----+    +----+

Input

A two-dimensional rectangular set of integers greater than or equal to 0, representing the heights of stacks of presents in the pile, and an integer determining which corner to view it from.

For example:

01  1
10

would indicate two stacks 1 present high, that are diagonally adjacent, viewed from the corner you have assigned index 1.

You may have the corners be 0-indexed or 1-indexed and you may have them occur in any order, as long as a different corner is used for each of {0,1,2,3} or {1,2,3,4}.

Output

An ASCII image, showing the stack from the selected corner. Parts of the presents that would be occluded by part of a present in front of them should not be shown.

• You may optionally begin and end lines with up to ten trailing spaces.
• You may optionally begin and end your output with up to seven additional newlines.

[Sandbox note: This is so that there can be up to one present width and depth around the drawn area. This question is supposed to be about drawing the boxes with occlusion, not working out how wide the drawing should be.]

For example, for the input given earlier, the output should look like (all four corners are given; your code need only return one at a time):

         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+


  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+


         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+


  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+

Scoring

This is code-golf, so the shortest code wins. Standard loopholes are forbidden.

Tests

1
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/
+----+


010
101
010
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+ 
         +----+
        /    /|
  +----+----+----+
 /    /|   /    /|
+----+----+----+ |
|   /    /|    | + 
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+    


11
  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+
    +----+
   /    /|
  +----+ |
 /    /| +
+----+ |/
|    | +
|    |/
+----+
  +----+----+
 /    /    /|
+----+----+ |
|    |    | +
|    |    |/
+----+----+
    +----+
   /    /|
  +----+ |
 /    /| +
+----+ |/
|    | +
|    |/
+----+


01
10
         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+
  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+
         +----+
        /    /|
  +----+----+ |
 /    /|    | +
+----+ |    |/
|    | +----+
|    |/
+----+
  +----+
 /    /|
+----+----+
|   /    /|
|  +----+ |
+--|    | +
   |    |/
   +----+


2
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+
  +----+
 /    /|
+----+ |
|    | +
|    |/|
+----+ |
|    | +
|    |/
+----+


101
121
010


       +----+
    +-/    /| +----+
   / +----+ |/    /|
  +--|    | +----+ |
 /   |    |/    /| +
+----+----+----+ |/
|   /    /|    | +
|  +----+ |    |/
+--|    | +----+
   |    |/
   +----+


         +----+
      +-/    /|-+
     / +----+ |/|
    +--|    | +----+
    |  |    |/    /|
  +----+----+----+ |
 /    /    /|    | +
+----+----+ |    |/
|    |    | +----+
|    |    |/
+----+----+
         +----+
        /    /|-+
       +----+ |/|
    +--|    | +----+ 
   /   |    |/    /|
  +----+----+----+ |
 /    /|   /    /| +
+----+ |  +----+ |/
|    | +--|    | + 
|    |/   |    |/
+----+    +----+
       +----+
      /    /|-+----+
     +----+ |/    /|
  +--|    | +----+ |
 /   |    |/|    | +
+----+----+----+ |/
|   /    /    /|-+
|  +----+----+ |
+--|    |    | +
   |    |    |/
   +----+----+