556
\$\begingroup\$

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

Get the Sandbox Viewer to view the sandbox more easily!

\$\endgroup\$
0

4046 Answers 4046

1
23 24
25
26 27
135
2
\$\begingroup\$

Help Agent Zigzag with his secret messages

The WW2 double agent Eddie Chapman — aka "Agent Zigzag" — used an unusual cipher to communicate with his German controllers. It is described in the appendix of Ben Macintyre's book about Chapman and can also be viewed at the National Archives, apparently.

Read the following description and write a program to encrypt and decrypt messages using this system.

Your program should accept three inputs via stdin and/or command line switches:

  1. A keyword
  2. A flag to select either encryption or decryption
  3. A message to be encrypted or decrypted

The output should be the corresponding ciphertext/plaintext, arranged into groups of 5 letters separated by single spaces. You may assume that the keyword consists entirely of uppercase letters, but should accept plaintexts and ciphertexts containing mixed case characters, punctuation and spaces. Non-alphabet characters should be stripped from the input and should not appear in the output (which may only contain groups of 5 uppercase characters separated by spaces, with an optional line break at the end). The date value used for keyword processing should be obtained from the system clock using the local time zone.

This is a code-golf challenge. The shortest code (measured in bytes) will win.


1. Keyword processing

Write out the keyword, and below each letter write the position in which this letter would appear if the letters were all sorted alphabetically. If the same letter appears more than once, number them from left to right. For example, the 14-letter keyword CONSTANTINOPLE would be processed as follows:

C   O   N   S   T   A   N   T   I   N   O   P   L   E
2   9   6   12  13  1   7   14  4   8   10  11  5   3

(Notice how the three Ns are numbered 6, 7 and 8.) Combine this sequence of digits into a single number, and multiply by the current date (from 1 to 31). For example, if the transmission is being made on the 8th of the month:

2961213171448101153 x 8 = 23689705371584809224

2. Encryption

Pad the secret message to a multiple of five characters in length by appending the null character X as many times as necessary, then encrypt Vigenere-style by cycling each letter through the alphabet by offsets corresponding to successive digits of the number calculated at step 1. For example, the message

Have arrived safely and in good health. Awaiting further instructions.

is encrypted as follows:

havearrivedsafelyandingoodhealthawaitingfurtherinstructionsx << Plaintext
236897053715848092242368970537158480922423689705371584809224 << Key (repeated)
JDBMJYRNYLEXIJMLHCPHKQMWXKHJDSUMIAIICKPKHXXBQLRNQZUWCGBIXPUB << Ciphertext

because 'H'+2='J', 'A'+3='D', 'V'+6='B', etc.

Finally, read off the encrypted message in groups of five characters:

JDBMJ YRNYL EXIJM LHCPH KQMWX KHJDS UMIAI ICKPK HXXBQ LRNQZ UWCGB IXPUB

\$\endgroup\$
5
  • 1
    \$\begingroup\$ For languages that don't have system clock access, is it acceptable to take the date/time as an additional input? \$\endgroup\$
    – Geobits
    Sep 23, 2015 at 14:09
  • \$\begingroup\$ @Geobits Would you mind if I said no? We have so many code-golf questions that are dominated by esolangs, I thought it would make a change to have one that favours higher-level languages. (Although it looks like Pyth can do dates...) \$\endgroup\$
    – r3mainer
    Sep 23, 2015 at 14:55
  • \$\begingroup\$ I don't personally mind since I don't tend to use them. Some might, so I figured it was better to ask/clarify while it was sandboxed rather than on main. \$\endgroup\$
    – Geobits
    Sep 23, 2015 at 14:57
  • \$\begingroup\$ It's not just about esolangs: removing the direct coupling with the system clock allows test cases which work consistently. \$\endgroup\$ Sep 23, 2015 at 20:19
  • \$\begingroup\$ @PeterTaylor But only 31 test cases are needed. \$\endgroup\$
    – r3mainer
    Sep 23, 2015 at 22:02
2
\$\begingroup\$

Well hello there, fellow golfers. The time has come for us to take part in the game. Time for the official Illuminati Confirmation!

Illuminati Confirmed?

Nah, just joking. We actually want to hide even better - by making conspiracy theorists look ridiculous.

For that, you need to create code in whatever language you want to. Your task is to print the Eye of Providence, as an ascii art. The program may take input, but it shouldn't rely on it.

However, there's a catch. You need to hide as many non-obvious references to Illuminati in source code as you can. One particular requirement is that your code must have an "Illuminati confirmed" sentence hidden somewhere(although it doesn't have to be plain string - in fact, it shouldn't; you can have it hidden by placing it as a first letter to every line, etc. - be creative!)

And because it's , the most upvoted and creative code wins!


Confirmed.


Now I want feedback before posting it - what else should I have in here? What is not clear? And if you come up with better "lore chit-chat"(I actually had no afflatus) - feel free to help me.

\$\endgroup\$
13
  • 7
    \$\begingroup\$ You need to hide as many non-obvious references to Illuminati in source code as you can: One problem you may run into is that I think it's been proven by the internet at large that you can make anything an Illuminati reference if you twist it enough. \$\endgroup\$
    – Geobits
    Sep 24, 2015 at 17:22
  • 2
    \$\begingroup\$ Also, pretty sure the Illuminati has already been confirmed since it was a real and historical secret society. \$\endgroup\$
    – mbomb007
    Sep 24, 2015 at 17:56
  • 1
    \$\begingroup\$ @mbomb007 Nonsense! \$\endgroup\$ Sep 24, 2015 at 18:59
  • \$\begingroup\$ @Geobits What is your suggestion then? I am honestly counting on community, so some stupid answers like "Well, I have a word 'rock' rock is four characters, and four - 1 = 3, triangle also has 3 sides - Illuminati Confirmed" will be downvoted, and some clever ideas will get attention. \$\endgroup\$ Sep 24, 2015 at 19:05
  • \$\begingroup\$ This is an art / wordgame contest, not a programming contest. I'm not as strongly against this sort of thing as some, but there's a fair chance this will get closed. \$\endgroup\$ Sep 24, 2015 at 21:08
  • \$\begingroup\$ @steveverrill what I had in mind wasn't "Print the prettiest and funniest image and code, but rather to get people creative. This post is one of my inspirations - Perl and Brainfuck are bottles; C makes heavy use of macros to call the function in a funny manner, and while there are many other "plain" programs, the most creative are the most upvoted. This is similar to mine. There is more of that, buut looks like this shouldn't be closed. \$\endgroup\$ Sep 24, 2015 at 22:07
  • \$\begingroup\$ The 99 bottles of beer question is 4 years old and things were different back then. Nevertheless the issue was raised in the top comment on that question. There was a big attitude change just after the christmas tree challenge, in my opinion probably caused partially by Code Trolling. I'm not saying don't do it, just be aware of the issue. James Webster's recent cake question did quite well, though it did attract some close votes. The recent Back To The Future question was closed immeditately. \$\endgroup\$ Sep 24, 2015 at 22:35
  • \$\begingroup\$ @steveverrill I'm sorry, I have no idea what you're talking about. Could you please introduce me to the issue of Code Trolling, and provide some examples? \$\endgroup\$ Sep 25, 2015 at 8:29
  • \$\begingroup\$ Code Trolling was a particular class of open ended questions. The tag description is here. codegolf.stackexchange.com/tags/code-trolling/info It got out of hand. The history is too long and emotive to discuss in a comment, but it seems the challenges have been deleted. There are many meta questions on the subject. I've picked this one for you. meta.codegolf.stackexchange.com/q/760/15599 \$\endgroup\$ Sep 25, 2015 at 8:56
  • \$\begingroup\$ @steveverrill Okay, thanks for your insight. I will think about what you guys said, and maybe post the question - the worst that will happen is that iit will get closed - but hopefully it will spawn some clever and funny answers. \$\endgroup\$ Sep 25, 2015 at 9:21
  • \$\begingroup\$ Will an ASCII art version of the Eye of Providence be added in the question, or will we have to make one ourselves? \$\endgroup\$ Sep 25, 2015 at 15:52
  • \$\begingroup\$ @ASCIIThenANSI That's what I asked in other topic(well, I did it badly). I'm afraid to lock it to one particular output, because this way they can only get creative with code. What do you think? \$\endgroup\$ Sep 25, 2015 at 19:11
  • \$\begingroup\$ If you designed the exact Eye of Providence that we had to produce, it would go better as codegolf than popularitycontest. A good codegolf would require a fair amount of repetition in the pattern (compressing completely random strings is boring.) I guess it's fair to assume your design would be symmetrical. But since you want a popularity contest, just go for a popularity contest, and see if it flies high or if it gets shot down in flames. There's only one way to find out for sure, and you won't do it with meta posts. That said, Geobits makes a good point, that you need to address. \$\endgroup\$ Sep 26, 2015 at 9:39
2
\$\begingroup\$

1,2,3,4,...n-2,n,n-1


Your goal is, with an input "n", to print the numbers 1-n BUT the last two values are flipped. The numbers must be CSV (Comma separated values)

n must be >= 3 (And an integer)

For example, with an input n="10", your output should be as follows: 1,2,3,4,5,6,7,8,10,9.

An input with n="3", your output should be as follows: 1,3,2.

\$\endgroup\$
5
  • 3
    \$\begingroup\$ Get rid of the requirement that you can't just embed a string, please. How about printing 1,2,3,...,n-2,n,n-1 for a given input n? \$\endgroup\$
    – Lynn
    Oct 3, 2015 at 11:16
  • \$\begingroup\$ @Mauris Added this in, thanks for your input :) \$\endgroup\$ Oct 3, 2015 at 20:52
  • \$\begingroup\$ Shouldn't it be "last two values" instead of "last two digits"? In the example, the swapped items are 9 and 10, and 10 is not a digit. \$\endgroup\$ Oct 5, 2015 at 5:14
  • \$\begingroup\$ @RetoKoradi Ahah good catch, edited it thanks! \$\endgroup\$ Oct 5, 2015 at 7:12
  • \$\begingroup\$ @FryAmTheEggman Got it in, thanks! \$\endgroup\$ Oct 6, 2015 at 20:21
2
\$\begingroup\$

The /\/\aze of Mirrors

sniffs...something smells...fishy.

The reason being that there's actually a fish! But it's at the end of a maze of mirrors that you have control over. Your task is to rotate the mirrors until you can see that delicious-smelling ><>. Luckily, there are only nine mirrors, so it doesn't take you long to find a solution.

However, if you encounter this again in the future, you don't want to have to actually do the work yourself. Computers are so much better at it. So you decide to write some code to solve it for you. The shorter, the better, because you don't want that fish to rot!

The situation

Your program must accept a single positive integer n as input. It then has to find a solution for an n by n mirror maze with the following conditions:

  • You, the observer (>), is seated next to one corner.
  • The fish (F) is placed next to the opposite corner, on the adjacent wall if n is even and on the opposite wall if n is odd.
  • The maze is toroidal because its designers installed cameras and screens.
  • However, there is a wall behind the fish, so you can only see it from inside the maze.
  • You must use all of the mirrors. No shortcuts!
  • Bonus: take an additional non-negative integer x as input and solve the maze for when the fish is x spaces away from the corner (where x=0 is its usual place), flipping to the other wall if x is odd.

Example solutions

1
+-+
>/F
+-+

2
+--+
>/\|
|//|
+-F+

2 1
+--+
>/\F
|\/|
+--+

3
+---+
>\/\|
|//\|
|\/\F
+---+

4
+----+
>/\/\|
|//\\|
|\\//|
|//\\|
+---F+

Rules

  • No standard loopholes, as usual.
  • Your program must output the solution in ASCII like what I've shown above.
  • Scoring is in bytes, unless you have the bonus: multiply by 0.8.

I look forward to seeing all the amazeing solutions! Ha! Sorry, that was bad.

\$\endgroup\$
2
  • \$\begingroup\$ Can I adopt this abandoned proposal? \$\endgroup\$
    – user58826
    Jun 9, 2017 at 12:20
  • \$\begingroup\$ @programmer5000: Yes, you may. \$\endgroup\$ Jun 10, 2017 at 3:49
2
\$\begingroup\$

Categorical logic [on hold]

Inspired by this question:

Task

The point of this challenge is to create a function or program that takes 3 short phrases and returns the logical assessment of the phrases.

Input

Each of the three phrases will be in the form: [All|Some] [A|B|C] are [A|B|C]., where the two A|B|C elements are different. The string Therefore,{space}, where {space} is a single space character, precedes the third phrase and reduces the initial capital of the third phrase to a lower case letter.

You may choose the input source and the separation of the strings. For example, STDIN with three concatenated phrases, text file, phrases separated by newlines, and taking the phrases as command-line arguments in quotes are all acceptable.

Sample input

With three concatenated phrases as example format.

  • Some tees are moos. All moos are yees. Therefore, all tees are yees. (output: falsy)
  • All A are B. All A are C. Therefore, some B are C. (output: ????)
  • All submissions are answers. Some submissions are winners. Therefore, some answers are winners. (output: truthy)

Output

  • Output for a logically correct combination of phrases must be a truthy value.
  • Output for a logically incorrect combination must be a falsy value. This is also the case if the input is logically unsound e.g. All A are B. No A are B. ...
  • Output for a logically uncertain combination must be the following string: ????

The output may be followed by a single newline.

Clarifications for finicky logic

  • Some is a subset of All. The following statement is badly written, but truthy: All A are B. All A are B. Therefore, Some A are B.
  • The following statement is also truthy: All A are B. All B are C. Therefore, some C are A.

Scoring

This is , so shortest code in bytes wins.

You may reduce your score by 10% if your values for A|B|C can contain spaces. You may assume that the value for A|B|C will not contain the word {space}are{space}).

You may reduce your score by a further 20% if your function or program also correctly handles No as input as well as All|Some.

Leaderboard

Standard leaderboard code goes here. Tag suggestions are welcome!

\$\endgroup\$
6
  • \$\begingroup\$ You should add what the expected output is for the sample imputs you give, so that one does not have to find if a sample is logically sound (and possibly be mistaken) \$\endgroup\$
    – Fatalize
    Oct 13, 2015 at 9:23
  • \$\begingroup\$ Working on a table of expected output. It's bigger than I had expected, and I haven't yet included 'No' as an option... \$\endgroup\$
    – pbeentje
    Oct 13, 2015 at 9:42
  • \$\begingroup\$ What is logically unsound about All A are B. Some A are B.? That's just equivalent to All A are B. There is at least one A. \$\endgroup\$ Oct 13, 2015 at 13:27
  • \$\begingroup\$ @Peter Taylor, You're right. A couple of prods at the table has turned up logical differences for the same statement in different places. I don't have enough time to fix this right now, so am putting the question on hold until I can make a clear definition of required behaviour for different cases. \$\endgroup\$
    – pbeentje
    Oct 13, 2015 at 13:58
  • 2
    \$\begingroup\$ "All answers are submissions. Some submissions are winners. Therefore, some answers are winners." This doesn't seem truthy to me. A simple substitution: All cats are animals. Some animals are birds. Therefore, some cats are birds. \$\endgroup\$
    – Geobits
    Oct 13, 2015 at 17:08
  • \$\begingroup\$ In the few minutes at a time I'm spending on this, I'm struggling to be logically consistent. I feel that All A are B. Therefore, all B are A is false because of the presence of Therefore in the statement. My gut wants me to categorise All A are B. Therefore, all A are C as logically uncertain, yet applying the same logic this should actually be false (as should all logically uncertain combinations). I'll have a search but would appreciate it if anyone already knows of a definitive source. @Geobits: thank you, I've corrected that example. \$\endgroup\$
    – pbeentje
    Oct 14, 2015 at 14:08
2
\$\begingroup\$

Two mountain hikers want to meet, but must stay at the same altitude

This question is totally inspired by this question on Puzzling SE. For ease, I have reproduced the original question here:

Two hikers are separated by a two-dimensional mountain range, like the one shown below. The mountain range alternates between peaks and valleys, connected by straight lines.

enter image description here

Both hikers are at sea level, and the mountain range never dips below sea level.

The two hikers want to meet up with each other. Prove that they can do this while staying at the same altitude as each other for their entire journey. They are allowed to backtrack.

Source: http://www.cs.cmu.edu/puzzle/puzzle12.html

Input/Output

Meta: what input/output format would be better?

Continuous:

  • Input: a list of ordered pairs (x,y) that represent the peaks and valleys.
  • Output: a sequence of positions where one hiker or both changes direction, formatted like so:
(x1 y1) (u1 v1)
(x2 y2) (u2 v2)
(x3 y3) (u3 v3)
...

Discrete:

  • Input: a sequence of heights that represent the height of the terrain (with no flat portions). (I.e., 0 1 2 3 4 5 4 3 4 5 6 7 6 5 6 5 4 3 2 3 2 1 0, maybe with steps larger than 1?)
  • Output: the left/right moves each hiker has to make, outputted like
L R
L L
L L
R L
...

Scoring

  • Scoring is in bytes.
  • Bonus: -5% if your program produces optimal solutions.

Meta:

  • I'm pretty sure this is not a duplicate, but still, is it?
  • I'd like a better title. Would "Mountain Hikers" be good enough?
  • Any other feedback?
\$\endgroup\$
4
  • \$\begingroup\$ Is the input sorted? Also, I don't understand the first output format. \$\endgroup\$
    – feersum
    Oct 29, 2015 at 16:15
  • \$\begingroup\$ @feersum: Sorted in the x-direction, yes. The rationale behind the first output format is that as the hikers are moving, they're both moving in one direction (not necessarily together). However, when one reaches a peak or valley, the other will stop and change direction. The output should have the positions of the hikers at these moments. \$\endgroup\$ Oct 29, 2015 at 19:25
  • 1
    \$\begingroup\$ I think that allowing the input to have deltas of more than 1 would potentially require the hikers to make fractional steps, which would certainly complicate the spec. I don't think the bonus has any point: if you look at the many many existing questions about reachability in a graph (which is what this is), I think you'll find that most of the answers do breadth-first search and thus produce optimal solutions. \$\endgroup\$ Oct 29, 2015 at 22:21
  • \$\begingroup\$ @PeterTaylor: Yeah, I realized last night that delta > 1 is a problem in the discrete case (if I want hikers to always be at integer steps). You're probably right about the bonus being pretty much useless. \$\endgroup\$ Oct 29, 2015 at 22:24
2
\$\begingroup\$

Bridge Flowers


One of the example inputs for this challenge is a really minor puzzle in Undertale, and the example output is the solution. You have been warned.

In the Underground, there is a mysterious plant known as the Bridge Flower. They always come in groups of four Bridge Seeds, and have some interesting properties:

  • When dropped in water, a Bridge Seed floats away from you in the direction you were facing when you dropped it. It floats until it hits a wall or another Bridge Seed, at which point it stops moving.
  • If four Bridge Seeds are touching, forming a straight line, and none of them are moving, they will bloom into Bridge Flowers. Bridge Flowers can support a monster's weight (or a human, but when will that ever happen?), hence the name.
  • Another mysterious plant, the Bell Blossom, has a special interaction with Bridge Flowers. The Bell Blossom can be rung to turn all Bridge Flowers back into Bridge Seeds and return them to their original spot.

Consider this map, where . is ground, is water, and X is a Bridge Seed. You'll always be on the part of the map where the Bridge Seeds are. The gap is only four tiles wide, so it's quite easy to make a bridge of Bridge Flowers.

........    ........  |  ........    ........
..X.....    ........  |  ........    ........
.X.X....    ........  |  ........XXXX........
..X.....    ........  |  ........    ........
........    ........  |  ........    ........

Here's a slightly more difficult gap to cross. Even though the straight-line distance is longer than four tiles, you can make it across with a little bit of thought.

........       ........  |  ........       ........
..X.....       ........  |  ........       ........
.X.X....       ........  |  ........       ........
..X.....       ........  |  ........       ........
........       ........  |  ........       ........
..         ............  |  ..     XXXX............
..         ............  |  ..         ............

Here's one that's even trickier than the last two. Most of this river is three tiles wide or fewer, so you can't simply make a straight-line bridge across! Thinking outside the box, though, you'll arrive at the solution.

....   ............  |  .... X ............
...   .............  |  ...  X.............
....   ............  |  .... X ............
.....  ............  |  .....X ............
....   ...X.X......  |  ....   ............
....   ...X.X......  |  ....   ............
     ..............  |       ..............
       ............  |         ............

For this challenge, write a program or function that takes a map like the ones here and outputs the same map, but with the puzzle solved (the Bridge Seeds moved to the final position of the Bridge Flowers). If there's more than one possible answer, any of them will do. You may assume there will be exactly two areas of land separated by water, with the one that you start on denoted by the presence of exactly four Bridge Seeds.

If the program can't find an answer... well, just because it's impossible doesn't mean you should give up! Don't lose your Determination! Output Ding to sound the Bell Blossom, reset the Bridge Seeds and try again!

\$\endgroup\$
1
  • \$\begingroup\$ It took me quite a while to understand the examples. At the very least I think you need to explain that you can pick up bridge seeds from the ground, and clarify "floats until it hits a wall or another Bridge Seed" to define hits. (I think it must include being adjacent to in directions perpendicular to the direction in which it's floating - or am I missing something?) It might also be worth stating explicitly that you don't have to drop them all from the same point. \$\endgroup\$ Nov 5, 2015 at 22:07
2
\$\begingroup\$

Based on this question in the Puzzling SE. Not 100% sure on the scoring, and this is my first time posting a PPCG challenge, so I'd appreciate any suggestions on improving it.


Unicode Box Drawing

Write a program which outputs a diagram using all of the standard Unicode box drawing characters:

─ │ ┌ ┐ └ ┘ ├ ┤ ┬ ┴ ┼
═ ║ ╔ ╗ ╚ ╝ ╠ ╣ ╦ ╩ ╬
    ╒ ╕ ╘ ╛ ╞ ╡ ╤ ╧ ╪
    ╓ ╖ ╙ ╜ ╟ ╢ ╥ ╨ ╫

The diagram should have no loose ends, so:

┌┐ <-Allowed  ┌┐ <-Not allowed  ┌┐┌┐ <-Allowed
└┘            └┴                └┴┴┘

Also, single lines should line up with other single lines, and double with double:

├─, ╟─, ╠═, ╞═ <-Allowed  ├═, ╟═, ╠─, ╞─ <-Not allowed

The diagram must use each of the 40 characters at least once, and must form one contiguous, connected shape. Because the characters might look different depending on your browser font, do not consider the space between double lines to be an actual separation. Separations can only be between two characters. In other words:

┌╖ <-Allowed  ┌┐┌┐ <-Not allowed
└╜            └┘└┘

Your code must compute the diagram from scratch. You may not create an already existing diagram and just print it out. A bonus of 20% will be awarded if your program outputs a different valid diagram based on a random seed. (This seed may be provided as input, or you may use system time, read the seed from a file, or any other means you choose.) Note that a random seed may be provided externally, but the diagram itself may not. If you implement this bonus, please provide multiple examples showing different output.

This is code-golf, so scoring will be based on the number of bytes in the source code. In addition, the length of the output will also be counted. You get 40 characters free to account for the required characters. Any additional characters will come at a 10% penalty. This includes spaces/tabs, and any duplicate graph pieces. Newlines are free (to be fair to the differences between OSs).

If your program produces multiple outputs of different lengths (due to randomness), you may use the shortest output produced, but you must provide a seed that results in that output so it can be verified. Since this might be difficult if you used system time as a seed, entries using system time must somehow prove that they are capable of producing the smallest claimed output. (For instance, if they produce the same length output every time, or produce the minimum claimed output at least 50% of the time.)

So in summary:

  • Take length of source code in bytes.
  • Add 10% for each whitespace character (not counting newlines) or duplicated character in the output.
  • Subtract 20% if you implement the random seed input.

Standard loopholes apply.

\$\endgroup\$
10
  • 2
    \$\begingroup\$ "You may not create an already existing diagram and just print it out." This is probably too fuzzy. There many shades of hardcoding. Starting from including the string plainly in the code, over decoding a Base64-string which magically happens to give the correct result, all the way to "cleverly" pruning the possible diagrams your code tries to find, because you know there is a valid one in the search space. You can work around all of that by requiring programs to take some input: e.g. the actual set of characters that need to be accounted for. \$\endgroup\$ Nov 4, 2015 at 15:22
  • \$\begingroup\$ Additionally, this might make an interesting code challenge instead of code golf. \$\endgroup\$ Nov 4, 2015 at 15:22
  • \$\begingroup\$ You should probably also define contiguous, because some of the answers on the Puzzling.SE question have shapes which don't look contiguous (but are considered contiguous) because they have gaps inside the double-line characters (e.g. the "separate" box in the top left corner in the second example of the accepted answer). \$\endgroup\$ Nov 4, 2015 at 15:24
  • \$\begingroup\$ @MartinBüttner This problem is caused by different rendering of the unicode characters. Here is how it looks in the SE Android app: i.stack.imgur.com/PlQWI.jpg \$\endgroup\$
    – Sleafar
    Nov 4, 2015 at 16:05
  • \$\begingroup\$ @Sleafar Oh, interesting. Might be worth mentioning anyway if some fonts display it differently. \$\endgroup\$ Nov 4, 2015 at 16:07
  • \$\begingroup\$ Yeah, most fonts I've seen they look like they do in Sleafar's image. For whatever reason, the one used on SE does not. I think it would probably be much harder if you considered those double lines to be actual separations. As for the hardcoding, I didn't want this to be just another "Print out <blah>" challenge, there's tons of those. It's much more interesting if you have to derive such a graph in code. (Which is why I added the bonus for using a random seed, because then you KNOW it's being generated on the fly.) \$\endgroup\$ Nov 4, 2015 at 17:56
  • \$\begingroup\$ To avoid the hardcoding issue, I'd suggest generalizing the puzzle in some way, perhaps by giving a multiset of components to use. \$\endgroup\$
    – xnor
    Nov 4, 2015 at 21:51
  • \$\begingroup\$ Problem with using a multiset of input is you'd now have to validate said input to make sure that it's even possible to create a graph with no loose ends using the given inputs. I think the idea of using an input parameter which is just a random seed should be sufficient to ensure the results were not hard-coded in some way. Also, there's nothing stopping you from hard-coding it and printing the same thing every time, you just won't be eligible for the 20% bonus that way. (Is 20% enough? I feel like generating a valid graph is orders of magnitude more difficult than just printing one...) \$\endgroup\$ Nov 4, 2015 at 22:52
  • \$\begingroup\$ You could take the multiset as input and require that at least the characters in it have to be used, possibly others. The scoring could combine source code size and output size for a set of test cases. \$\endgroup\$
    – Zgarb
    Nov 5, 2015 at 2:16
  • 1
    \$\begingroup\$ I don't like the idea of using preset test-cases except as examples. For one, it makes it possible to hardcode valid graphs for just the test-cases, which is contrary to the spirit of the challenge. Also it limits the challenge to a few already-solved cases instead of making it more general. As Sleafar found in his answer in puzzling, there are many perfect solutions for a given set, and I wouldn't want everyone to just use the same algorithm and thus produce the same graph. I could see providing some examples, but I don't want to use only the example input for scoring purposes. \$\endgroup\$ Nov 6, 2015 at 14:21
2
\$\begingroup\$

Find pattern in pixel carpet

[insert story why this needs to be as short as possible]

Given an image the goal is finding the biggest* connected* pattern of pixels, that occurs more than once. If there is more than one distinct pattern of maximum size, find the one that occurs more.

The output should consist of mask (bw image) of the size of the input, that is black where the copies of the pattern were on the original image, and white otherwise.

* Specs

  • Biggest as in number of pixels
  • connected means four connected

Two instances of the pattern must not overlap.

Example

enter image description here

enter image description here

Meta

  • consider rotations / mirroring of the patter too, or only translations?
  • runntime requirement?
\$\endgroup\$
3
  • 3
    \$\begingroup\$ "You are a carpet salesman who is looking for stains in a carpet to maintain your reputation. However, since you are locally known as the 'guy who sells dirty carpets', you don't have the money to buy new hardware, and you only have a tiny hard drive and a terrible camera to try to find them with. Therefore, you're going to need a really small program in order to try to find these stains." \$\endgroup\$ Nov 7, 2015 at 18:53
  • \$\begingroup\$ @VoteToClose Then it must be runnable in embedded system? A Raspberry Pi, maybe. \$\endgroup\$
    – Xwtek
    Nov 16, 2015 at 15:18
  • \$\begingroup\$ @ChristianIrwan Let's say it is an arduino=) \$\endgroup\$
    – flawr
    Nov 16, 2015 at 20:32
2
\$\begingroup\$

Optional parentheses

In text, parentheses can denote optional asides. These (often intrusive) additions can be read or skipped over, either option giving a valid sentence. Given a string with parentheses, possibly nested, output all possible readings where each parenthesized section may be omitted.

The(( quick)( brown)) fox jumps( over the( lazy) dog).

The fox jumps.
The quick fox jumps.
The brown fox jumps.
The quick brown fox jumps.
The fox jumps over the dog.
The quick fox jumps over the dog.
The brown fox jumps over the dog.
The quick brown fox jumps over the dog.
The fox jumps over the lazy dog.
The quick fox jumps over the lazy dog.
The brown fox jumps over the lazy dog.
The quick brown fox jumps over the lazy dog.

The outputs can be in any order, but must be distinct. Note the case of (( quick)( brown)), where omitting both quick and brown is redundant with omitting the whole expression. But, the input won't contain any parens that enclose the empty string or are redundant with another pair of pairs.

You may not use regular expressions.

The input string will consist of only letters, spaces, punctuation .,, and parens (). The parens will be properly matched.

\$\endgroup\$
6
  • \$\begingroup\$ So the example is an invalid input? \$\endgroup\$
    – feersum
    Nov 17, 2015 at 10:20
  • \$\begingroup\$ @feersum It's valid, but in trying to clarify the redundancy condition, I realized it's unclear what ( quick)( brown)( quick brown) should give. Hmm. \$\endgroup\$
    – xnor
    Nov 17, 2015 at 10:23
  • \$\begingroup\$ "You may not use regular expressions." T_T \$\endgroup\$ Nov 17, 2015 at 11:20
  • \$\begingroup\$ @MartinBüttner Would it make you happier if I made reg-exp and non-reg-exp two separate "leagues"? \$\endgroup\$
    – xnor
    Nov 17, 2015 at 11:21
  • \$\begingroup\$ Hm, I don't know. I wonder if it's a bit of a duplicate of this. If I was allowed to use a regex approach, my answer would be almost the same (instead of repeatedly moving the contents of the parentheses to a new line, I'd duplicate the line and remove the parentheses from one of the copies, and the parentheses together with their contents from the other; followed by duplicate removal). \$\endgroup\$ Nov 17, 2015 at 11:24
  • \$\begingroup\$ (Also note that even Retina can't beat a non-regex approach in Pyth on that challenge, so I doubt it'll be much different here.) \$\endgroup\$ Nov 17, 2015 at 11:25
2
\$\begingroup\$

Compete with awk

The goal of this challenge is to see if the assertion often see in question on SO is true:

This would be faster in whatever

Test Input

A 10 million lines file generated by this script line:

awk 'BEGIN{for (i=1;i<=10000000;i++) print (i%5?"miss":"hit"),i,"  third\t \tfourth"}' > file

Head of it:

$ head -10 file
miss 1   third          fourth
miss 2   third          fourth
miss 3   third          fourth
miss 4   third          fourth
hit 5   third           fourth
miss 6   third          fourth
miss 7   third          fourth
miss 8   third          fourth
miss 9   third          fourth
hit 10   third          fourth

Goal:

The main goal is to compete with awk, to benchmark it will be on this challenge description:

  • Split each line on any number of spaces (regex [ ]+)
  • If the line start by hit X with X being an even number
    • print fields: 4th 1st and 3rd (in this order)

Example output (first 5 lines):

fourth hit third
fourth hit third
fourth hit third
fourth hit third
fourth hit third

Restrictions:

The idea being to compete with awk, your program must behave on the same way:

  • The file must be read.
  • The match and output order must be modifiable as an awk program can be (Needing a simple code update is OK, it has not to be a command line parameter).
  • The number of line in input file should be considered unknown.
  • As long as your output can be piped to awk, the submission is valid.

Validation:

Pipe the output of your program to

awk '!seen[$0]++{unq++;r=$0} END{print ((unq==1) && (seen[r]==1000000) && (r=="fourth hit third")) ? "PASS" : "FAIL"}'

If it show PAST, you're in :)

Winner

The fastest code would win, to bench yourself here is a mawk version really competitive (which won't count toward answers as I think it's pretty hard to beat):

awk '/^hit +[0-9]*[02468] / { print $4, $1, $3 }' file

I've build a test suite on github here which build a result table here.

Answers will be integrated within it to bench all answer on the same machine, if there's a specific way to launch your program, make it appear in the answer so I don't penalize your answer by the way it is launched.

Side challenge:

If you wish to save me time and craft a pull request to include your code in the test system, you're welcome.

\$\endgroup\$
4
  • 2
    \$\begingroup\$ 1. "Split each line on spaces" would IMO split the line miss 1 third fourth into 15 fields. A possible rewording might be "split each line around the regex [ ]+" (where the otherwise unnecessary [] prevent MarkDown from trimming the space). 2. The question as worded is a bit too special-cased, as is the awk code you provide. If it's permissible to optimise the regex to /hit [0-9]*0/ because you know a priori the form of the input, why would it not be permissible to optimise further and write print "fourth hit third\n"*1E6? \$\endgroup\$ Nov 19, 2015 at 21:02
  • \$\begingroup\$ @PeterTaylor Thanks for the feeback, I reworded a little to be more specific on restrictions and avoid too much test input optimizations. \$\endgroup\$
    – Tensibai
    Nov 20, 2015 at 10:20
  • \$\begingroup\$ I still think your reference answer is cheating with /hit [0-9]*0 /. To match the challenge description it should use /^hit +[0-9]*[02468] / \$\endgroup\$ Nov 20, 2015 at 11:18
  • \$\begingroup\$ @Peter ok, it does no difference in timing at end anyway (at least nothing I've been able to see on slow machines when benchmarking the codes present on GH) \$\endgroup\$
    – Tensibai
    Nov 20, 2015 at 11:24
2
\$\begingroup\$

Count up by factor keys

TODO: Better title

Information

Let the factor key of a number n be the result of the following process:

  • Compute the prime factorization of n: n = p1e1 * p2e2 * p3e3 * ... where all pi are prime, distinct and in increasing order, and all ei are positive integers.

  • Compute each piei; call these factors the fi. So n = f1 * f2 * f3 *....

  • Convert each fi to a string.

  • Concatenate all the strings together.

  • Evaluate as a number.

Examples:

The factor key of 2376 is 82711, since 2376 = 23 * 33 * 11 = 8 * 27 * 11.

The factor key of 931 is 4919, since 931 = 72 * 19 = 49 * 19.

As a special case, the factor key of 1 is 0.

Challenge

Output all positive integers, starting from 1, in increasing orders of their factor keys. If two numbers have the same factor key, output the smaller number first. The output must be separated by a delimiter, but this delimiter can be any non-numeric character. If you choose spaces, your output should start with the following:

1 2 3 4 5 7 8 9 11 13 16 17 19 6 23 10 25 14 27 29 31 37 41 12 43 28 47 36

This is , so the shortest solution in bytes wins.

\$\endgroup\$
4
  • \$\begingroup\$ In the case (I'm not sure whether it occurs, but you haven't stated that it doesn't) that two numbers have the same factor key, can they be output in any order or do you want to define a tie-break? \$\endgroup\$ Nov 30, 2015 at 12:35
  • \$\begingroup\$ @PeterTaylor It does occur (see 36 and 49), but the question states "If two numbers have the same factor key, output the smaller number first." \$\endgroup\$
    – user45941
    Nov 30, 2015 at 20:48
  • \$\begingroup\$ By reverse engineering, it seems that the e_i must be non-zero. That's worth stating in the spec, and backing up with an example (i.e. any odd number greater than 1). \$\endgroup\$ Nov 30, 2015 at 22:18
  • \$\begingroup\$ @PeterTaylor Done. \$\endgroup\$
    – lirtosiast
    Nov 30, 2015 at 22:25
2
\$\begingroup\$

This is currently WIP, but please post feedback if you have any!


Best General-Purpose Compression

Abstract

This paragraph is meant to summarize, the binding rules are below.
Your task is to implement the best general purpose compression algorithm in the context of this challenge. You will be given a file corpus which contains a mix of different file types. The goal is to beat an existing answer in terms of overall size. The size is determined by the size of the compiled compression program (and decompression program if they are two different programs) plus the compressed size of the corpus. Your algorithm must beat standard 7z with default settings by at least 10 bytes, or if there is an existing answer, this answer by 10 bytes.

Corpus

This paragraph lists all files that are part of the input to your program, their size and the baseline 7z score in 7z 9.38 beta. Licenses are linked where needed. Disclaimer: There is no political or humorous motivation behind the choices. All files were chosen because of their representation of certain formats or unique compression behavior.

Natural Language

#1 - ASCII - Bibliography of Computer Security Articles 1983-88: DownloadSave-As

Uncompressed:      146 119
7z 9.38 beta:       17 142
File name:    articles.law

#2 - ASCII - Pre-Flight Launch Preparation for the Space Shuttle: DownloadSave-As

Uncompressed:        44 515
7z 9.38 beta:        15 304
File name:    6_2_4_4_2.TXT

#3 - ASCII - 1984 News report archive about the Bundespost Hack: DownloadSave-As (transcribed by Chaos Computer Club, cites full-text articles from Die ZEIT, taz et al.)

Uncompressed:      102 242
7z 9.38 beta:       32 382
File name:    boh-20f8.txt

#4 - ASCII - (Unofficial historical transcript of) His Last Bow by Arthur Conan Doyle: DownloadSave-As (lic. Public Domain)

Uncompressed:           330 042
7z 9.38 beta:           110 481
File name:    doyle-his-382.txt

#5 - UTF8 - Transcript of the Rosetta Stone translated to English: DownloadRAW->Save-As (lic./© The Nile, Notes for Travelers in Egypt, by E. A. Wallis Budge, 9th Edition, London, Thos. Cook and Son, [1905], pp. 199-211)

Uncompressed:                  18 270
7z 9.38 beta:                   6 299
File name:    Rosetta_EN_UTF8+BOM.txt

Source Code (+ Markdown)

#1 - C - CPU control code taken from the linux kernel: DownloadRAW->Save-As (lic. GPL, Rusty Russell)

Uncompressed: 18 866
7z 9.38 beta:  5 683
File name:     cpu.c

#2 - QBASIC - COMBAT ARENA (Game): DownloadRAW->Save-As (© Jeff Copperthite)

Uncompressed: 59 792
7z 9.38 beta: 11 921
File name: COMBAT.BAS

#3 - XML - The 9/11 Wikimedia dump: Download (lic. GFDL, CC-BY-SA 3.0)

Uncompressed:                                40 557 621
7z 9.38 beta:                                   578 993
File name:    sep11wiki-20071116-pages-meta-history.xml

#4 - C# - Source of the .NET Framework System.Array (CLR): DownloadRAW->Save-As (lic. MIT)

Uncompressed:  133 646
7z 9.38 beta:   15 172
File name:    Array.cs

#5 - JavaScript - jQuery 1.11.3: DownloadRAW->Save-As (lic. MIT)

Uncompressed:          284 394
7z 9.38 beta:           73 585
File name:    jquery-1.11.3.js

Binary Media

#1 - JPG - "Flower in the Garden": Download (lic. CC-BY-NC-ND 2.0 & © wellenkern)

Uncompressed: 10 482 521
7z 9.38 beta: 10 434 631
File name:    flower.jpg

#2 - MP3 - "Mariam's Cake" by Robin Grey: Download (lic. CC-BY-NC-SA 3.0)

Uncompressed: 8 468 990
7z 9.38 beta: 8 162 146
File name:     cake.mp3

#3 - Bitmap24 - DP1M7218 16:9 COLOR: Download (lic. CC-BY-SA 3.0 & © iKobe!)

Uncompressed: 37 834 326
7z 9.38 beta: 14 652 746
File name:    street.bmp

#4 - MP4 - "Home 5x5": Download (lic. CC-BY 3.0 & © Michael Jones)

Uncompressed: 6 173 898
7z 9.38 beta: 6 013 047
File name:     home.mp4

#5 - binary - Block of cryptographically secure random data, a.k.a. "The Incompressible File": Download

Uncompressed: 100 000
7z 9.38 beta: 100 129
File name:    rnd.bin

Rules

(De/)Compression Program and Algorithm

  1. The program used to compress and decompress a file is the compiled executable (or executable script).
  2. You may use two or more programs and ship additional files if needed, however only one program per step (a step is de- or compression) is executed.
  3. No program or part of a program is allowed to request resources that are not included in your distribution. Exceptions are standard system resources (clean install, i.e. a Java runtime would not be available when you use Windows).
  4. You may use linux-, windows- or architecture-specific code.
  5. You must not modify files or file names. The file names listed above are binding. Note: Some downloads may not carry the file name, you have to rename them (case-sensitive). The file names of compressed files do not matter. However, the original file names must be restored after decompression.
  6. You can use any existing or new algorithm. Content mixing is of course allowed, however, you may not call any compression routines available on your system (or language). You program must be a self-contained implementation.
  7. Your algorithm must not specifically target this corpus, it has to be general purpose. You are however allowed to target the used file types (e.g. by identifying the type via "Magic Bytes" and adjusting the algorithm accordingly).
  8. The (de)compression program only accepts one argument, a file name. Piping program output somewhere or providing anything else is forbidden. (I.e. you'll have to write the output file yourself).

Running your entry

Your compression program is called 15 times, once for every file in the corpus:

comp articles.law
comp ...

This process must produce 15 compressed files on disk in the same directory (original files can be overwritten). (comp is just an example name, you don't have to use this name)

Decompression is similar. Your decompression program (which may be the same executable) is called 15 times, once for every file in the corpus:

decomp ...

Where ... is the file name of the compressed file. This will produce the original 15 files on disk (with their original file names) (compare the SHA256 when in doubt).

Neither the compression or decompression program may take any additional command line parameters.

Scoring

Your score is P+C, where

  • P is the size of all programs used in your distribution
  • C is 15 files, the compressed corpus

in bytes.

Your answer must include the following:

  • The source code for all parts of P. (Is not counted in the score).
  • A link to a GitHub repository containing both P and C. Means you actually have to run your solution and include all compressed files. If your repository features additional files that should not be included in your score (gitignore, README etc.), put the scored files in a separate folder.

To beat someones score, your score has to beat it by at least 10 bytes. If some answer has the score X, then your answer has to have a score of N <= X-10, where N is your score. The starting score is set by 7z.

Invalid Answers

Please refrain from posting invalid answers, such as:

  • Answers without source code for P,
  • answers without compressed files, or where compressed files run against P produce anything but the original corpus,
  • answers that contain only partial solutions.

For clarity, here's how an answer might look like:

I did this algorithm X. This code is used for compression:

<comp.c>

and this for decompression:

<decomp.c>

I used windows, my score therefore is 9001:

comp.exe:          234 bytes
decomp.exe:        124 bytes
Compressed files: 8643 bytes

You can download the programs and compressed files from my
repository here: github.com/foobar42.

Leaderbaord and History

Current score: 423,424 (P) + 40,229,661 (C) = 40,662,085
Set by: 7z 9.38 beta (Win32) on 2015-12-18


\$\endgroup\$
6
  • \$\begingroup\$ I love this, even if it's above my skill level. I hope it gets posted! \$\endgroup\$
    – cat
    Dec 18, 2015 at 3:18
  • \$\begingroup\$ 1. "The file names listed above are binding" for what? My best guess is that the compressor has to store the original filename in the file, and the decompressor has to output to that name, but I didn't notice that that was stated explicitly anywhere. 2. comp articles.law: are we required to use command-line arguments and to pick an output filename ourselves, or could we use stdio and invoke as comp <articles.law >articles.law.myz? 3. "Your answer must include ... A standard ZIP file". How? \$\endgroup\$ Dec 18, 2015 at 8:38
  • \$\begingroup\$ @PeterTaylor 1. It is irrelevant how the file name is stored, however it must be restored after decompression. I'll add that. 2. The compressed filename is not specified in the rules so it can be anything. According to the current rules comp <articles.law >articles.law.myz would be invalid. The only calid way to call one step is program file, files must be created by the step program. I'll add that. 3. I'm thinking of changing this part to "GitHub Repository". Suggestions? \$\endgroup\$
    – user42643
    Dec 18, 2015 at 16:12
  • \$\begingroup\$ I would posit that there is no such thing as truly "General-Purpose Compression", at least in an information-theory sense. Text (and various other formats) compress nicely because they are not general. But compression of random data will not give any gain in the long run. \$\endgroup\$ Dec 18, 2015 at 20:47
  • \$\begingroup\$ @DigitalTrauma GP in terms of compression algorithm means that the algorithm does not specifically target the specific files in a test suite. ZIP for example is a GP algorithm, as most other algorithms. \$\endgroup\$
    – user42643
    Dec 18, 2015 at 20:53
  • \$\begingroup\$ Rather than using GitHub repos, I think the best approach is to require all answers to be deterministic and then the scores can be verified by just running them. \$\endgroup\$ Dec 19, 2015 at 12:26
2
\$\begingroup\$

Add two numbers (or Arithmetic on continued fraction expansions)

Given two continued fraction expansions N,M as lists of integers (in any suitable (human readable) format for your language) and an operation @ (addition, substraction, multiplication and division) +-* or / (e.g. encoded as numbers 1-4 or as characters or whathever is suitable for your language) return N@M (the sum/difference/product/ratio) again in the form of a continued fraction expansion.

By continued fraction expansion I mean a simple continued fraction expansion which are of the form:

                   1
 a0 + -----------------------
                     1
       a1 + ------------------
                       1
             a2 + ------------
                         1
                   a3 + ------
                          ...
                

Which will be represented as a list of the form [a0,a1,a2,a3,...]

Meta

Is this too complicated? Should the challenge be reduced to only one operation e.g. + or *?

\$\endgroup\$
6
  • \$\begingroup\$ It's not very complicated, and handling the four functions isn't much harder than handling just one; but if you assume that the input is two finite lists then it's possible to do a boring approach of evaluating them as reduced rationals, doing the operation, and converting back. IMO it would be more interesting to restrict to languages which support either functions with state or infinite lazy lists and to include some test cases which work with "nice" irrationals like sqrt 2 and e evaluated to a given number of terms. \$\endgroup\$ Jan 2, 2016 at 17:33
  • \$\begingroup\$ Would that be equivalent to letting the program take two lists of sufficient* length and a number n, and requiring it to return the first n terms? *sufficiently long such that the first n terms can correctly be evaluated. \$\endgroup\$
    – flawr
    Jan 2, 2016 at 19:01
  • \$\begingroup\$ I don't see how that would avoid the approach of converting to rationals, performing the operation, and converting back. \$\endgroup\$ Jan 2, 2016 at 19:50
  • \$\begingroup\$ I am just trying to understand what you meant in the first comment=) You obviously can only output a finite number of terms, but this also implies that you only need a finitely many input terms. So I do not see why you would have to use 'infitine' lists as input, if you can only output finite lists. And for not excluding too many languages, my suggestion was passing another argument n that determines how many terms the output should consist of. \$\endgroup\$
    – flawr
    Jan 2, 2016 at 21:57
  • 1
    \$\begingroup\$ It's the difference between "You only need these a terms" and "You need a terms, but it's up to you to work out what a is". Working out how many terms you need is the interesting part; converting between a finite continued fraction and a rational expressed as numerator and denominator is comparatively boring. \$\endgroup\$ Jan 2, 2016 at 23:21
  • \$\begingroup\$ Now I see what you mean, thank you for elaborating! I like your suggestion, I'm going to try to come up with some suitable test cases. \$\endgroup\$
    – flawr
    Jan 3, 2016 at 13:50
2
\$\begingroup\$

Number of cells used in optimal BF representation of a constant

Relevant.

Your task is deceptively simple. Given a number n (or a character C with char code value n in your encoding), output the number of cells utilized in the optimal representation of that number n in a standard Brainf*** interpreter with 0 <= n <= 255. (8-bit wrapping.)

Examples

> input
< output

> 4
< 1   ; ++++

> 0
< 1   ; empty program

> 201
< 4   ; >+[-->-[-<]>]>+

> 190
< 5   ; ++[-->-[<]>-]>

> 185
< 2   ; -[>-<-------]>++

> 255
< 1   ; -

> 242
< 1   ; --------------

> 241
< 2   ; ---[>-----<+]>

Meta

Does more describing need to be done? Should I just remove the bonuses? Bonuses removed.

\$\endgroup\$
10
  • \$\begingroup\$ "Optimal" in what sense? And surely 0 needs one cell, to store the output? \$\endgroup\$ Jan 7, 2016 at 19:25
  • \$\begingroup\$ I too think that this needs clarification. In the chat you said optimal representation = the shortest brainfuck program outputting this number. But I think there still might be some ambiguity, as the shortest might not be unique, and therefore might not have an unique number of used cells. \$\endgroup\$
    – flawr
    Jan 7, 2016 at 21:03
  • \$\begingroup\$ @flaws that is true. Minimal output length, minimizing the number of cells used. \$\endgroup\$ Jan 7, 2016 at 21:04
  • \$\begingroup\$ @PeterTaylor optimal as in shortest. Will add that at home. And I'm referring to the number of cells required to modify another cell. Perhaps I'm wrong in my reasoning. \$\endgroup\$ Jan 7, 2016 at 21:06
  • \$\begingroup\$ However you count the cells, 0 should surely return the same value as 4, because neither of them use <>. \$\endgroup\$ Jan 7, 2016 at 21:41
  • \$\begingroup\$ I vote for "remove bonuses" \$\endgroup\$
    – quintopia
    Jan 9, 2016 at 6:37
  • \$\begingroup\$ @quintopia Agreed, in retrospect they are a bad idea. \$\endgroup\$ Jan 9, 2016 at 17:38
  • \$\begingroup\$ @ThomasKwa Indeed. \$\endgroup\$ Jan 9, 2016 at 17:38
  • \$\begingroup\$ @PeterTaylor That is true. \$\endgroup\$ Jan 9, 2016 at 17:39
  • 2
    \$\begingroup\$ I'm not sure what part of this challenge is "deceptively simple". ;) \$\endgroup\$ Jan 10, 2016 at 15:01
2
\$\begingroup\$

Roll a Die

Most of the time in PPCG, challenges that involve dice rolling normally focus on some numeric property. However all I want you to do is to actually display the die itself in an isometric 3D format.

Your program or function should accept two optional integers representing the numbers to be displayed on the top and the front of the die respectively. If no valid value for the top is given then one of the 24 possible rolls should be uniformly chosen (but it does not need to be completely random so a time-dependent result is acceptable). If no valid value for the front is given then one of the 4 valid values should be uniformly chosen.

The die to be displayed is a standard Western die. Example: when rolling a 4, if the 1 is at the front, the number to the right is a 5; to display any other number would be an error. A more complex example is also shown below; in this case, not only is the 2 the correct number to display on the right, but all three numbers must be displayed as shown, i.e. the diagonal of the number 2 must point from 1/4 to 3/6 and not 1/3 to 4/6; the diagonal of the number 3 must point from 1/5 to 2/6 and not 1/2 to 5/6; the number 6 must point from 3 to 4 and not from 2 to 5.

    o-------o     o-------o 
   / *   * /|    / *   * /| 
  /       /*|   / *   * / | 
 / *   * /  |  / *   * /  | 
o-------o*  | o-------o*  | 
|       | * | |     * |   | 
|       |  *o |       |  *o 
|   *   |  /  |   *   |  /  
|       |*/   |       | /   
|       |/    | *     |/    
o-------o     o-------o     

You must draw all the sides, corners and pips preferably using the characters as shown above. Additional whitespace is permissible if you are consistent (only the pips may vary between rolls).

This is , so the shortest answer will be the winner.

Reference code (Batch):

@echo off
setlocal enableextensions
call :%1%2 2>nul
if errorlevel 1 call :%1 2>nul
if errorlevel 1 goto %time:~6,1%
goto :eof
:1
set /a front = (%time:~7,1% %% 2) * 2 + (%time:~9,1% %% 2) + 2
goto 1%front%
:2
set /a front = (%time:~7,1% %% 2) * 3 + (%time:~9,1% %% 2) * 2 + 1
goto 2%front%
:3
set /a front = (%time:~7,1% %% 2) * 4 + (%time:~9,1% %% 2) + 1
goto 5%front%
:4
set /a front = (%time:~7,1% %% 2) * 4 + (%time:~9,1% %% 2) + 1
goto 5%front%
:5
set /a front = (%time:~7,1% %% 2) * 3 + (%time:~9,1% %% 2) * 2 + 1
goto 5%front%
:6
set /a front = (%time:~7,1% %% 2) * 2 + (%time:~9,1% %% 2) + 2
goto 6%front%
:12
echo     o-------o
echo    /       /^|
echo   /   *   /*^|
echo  /       /  ^|
echo o-------o   ^|
echo ^| *     ^| * ^|
echo ^|       ^|   o
echo ^|       ^|  /
echo ^|       ^|*/
echo ^|     * ^|/
echo o-------o
goto :eof
:13
echo     o-------o
echo    /       /^|
echo   /   *   /*^|
echo  /       /  ^|
echo o-------o*  ^|
echo ^|     * ^| * ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^| *     ^|/
echo o-------o
goto :eof
:14
echo     o-------o
echo    /       /^|
echo   /   *   / ^|
echo  /       /  ^|
echo o-------o*  ^|
echo ^| *   * ^|   ^|
echo ^|       ^|  *o
echo ^|       ^|  /
echo ^|       ^| /
echo ^| *   * ^|/
echo o-------o
goto :eof
:15
echo     o-------o
echo    /       /^|
echo   /   *   /*^|
echo  /       /  ^|
echo o-------o*  ^|
echo ^| *   * ^|   ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:21
echo     o-------o
echo    / *     /^|
echo   /       /*^|
echo  /     * /  ^|
echo o-------o*  ^|
echo ^|       ^|   ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^|       ^|/
echo o-------o
goto :eof
:23
echo     o-------o
echo    /     * /^|
echo   /       / ^|
echo  / *     /  ^|
echo o-------o   ^|
echo ^| *     ^| * ^|
echo ^|       ^|   o
echo ^|   *   ^|  /
echo ^|       ^| /
echo ^|     * ^|/
echo o-------o
goto :eof
:24
echo     o-------o
echo    /     * /^|
echo   /       /*^|
echo  / *     /* ^|
echo o-------o*  ^|
echo ^| *   * ^|   ^|
echo ^|       ^|  *o
echo ^|       ^| */
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:26
echo     o-------o
echo    / *     /^|
echo   /       / ^|
echo  /     * /  ^|
echo o-------o*  ^|
echo ^| * * * ^| * ^|
echo ^|       ^|  *o
echo ^|       ^|  /
echo ^|       ^| /
echo ^| * * * ^|/
echo o-------o
goto :eof
:31
echo     o-------o
echo    /     * /^|
echo   /   *   /*^|
echo  / *     /  ^|
echo o-------o   ^|
echo ^|       ^|   ^|
echo ^|       ^|   o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^|       ^|/
echo o-------o
goto :eof
:32
echo     o-------o
echo    / *     /^|
echo   /   *   /*^|
echo  /     * /  ^|
echo o-------o* *^|
echo ^|     * ^|   ^|
echo ^|       ^|* *o
echo ^|       ^|  /
echo ^|       ^|*/
echo ^| *     ^|/
echo o-------o
goto :eof
:35
echo     o-------o
echo    / *     /^|
echo   /   *   / ^|
echo  /     * /  ^|
echo o-------o   ^|
echo ^| *   * ^| * ^|
echo ^|       ^|   o
echo ^|   *   ^|  /
echo ^|       ^| /
echo ^| *   * ^|/
echo o-------o
goto :eof
:36
echo     o-------o
echo    /     * /^|
echo   /   *   /*^|
echo  / *     /  ^|
echo o-------o*  ^|
echo ^| *   * ^| * ^|
echo ^|       ^|  *o
echo ^| *   * ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:41
echo     o-------o
echo    / *   * /^|
echo   /       /*^|
echo  / *   * /  ^|
echo o-------o*  ^|
echo ^|       ^| * ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^|       ^|/
echo o-------o
goto :eof
:42
echo     o-------o
echo    / *   * /^|
echo   /       / ^|
echo  / *   * /  ^|
echo o-------o   ^|
echo ^|     * ^| * ^|
echo ^|       ^|   o
echo ^|       ^|  /
echo ^|       ^| /
echo ^| *     ^|/
echo o-------o
goto :eof
:45
echo     o-------o
echo    / *   * /^|
echo   /       /*^|
echo  / *   * /  ^|
echo o-------o* *^|
echo ^| *   * ^|   ^|
echo ^|       ^|* *o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:46
echo     o-------o
echo    / *   * /^|
echo   /       /*^|
echo  / *   * /  ^|
echo o-------o   ^|
echo ^| *   * ^|   ^|
echo ^|       ^|   o
echo ^| *   * ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:51
echo     o-------o
echo    / *   * /^|
echo   /   *   / ^|
echo  / *   * /  ^|
echo o-------o*  ^|
echo ^|       ^| * ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^| /
echo ^|       ^|/
echo o-------o
goto :eof
:53
echo     o-------o
echo    / *   * /^|
echo   /   *   /*^|
echo  / *   * /* ^|
echo o-------o*  ^|
echo ^| *     ^|   ^|
echo ^|       ^|  *o
echo ^|   *   ^| */
echo ^|       ^|*/
echo ^|     * ^|/
echo o-------o
goto :eof
:54
echo     o-------o
echo    / *   * /^|
echo   /   *   / ^|
echo  / *   * /  ^|
echo o-------o   ^|
echo ^| *   * ^| * ^|
echo ^|       ^|   o
echo ^|       ^|  /
echo ^|       ^| /
echo ^| *   * ^|/
echo o-------o
goto :eof
:56
echo     o-------o
echo    / *   * /^|
echo   /   *   /*^|
echo  / *   * /  ^|
echo o-------o*  ^|
echo ^| * * * ^|   ^|
echo ^|       ^|  *o
echo ^|       ^|  /
echo ^|       ^|*/
echo ^| * * * ^|/
echo o-------o
goto :eof
:62
echo     o-------o
echo    / * * * /^|
echo   /       /*^|
echo  / * * * /  ^|
echo o-------o*  ^|
echo ^| *     ^|   ^|
echo ^|       ^|  *o
echo ^|       ^|  /
echo ^|       ^|*/
echo ^|     * ^|/
echo o-------o
goto :eof
:63
echo     o-------o
echo    / *   * /^|
echo   / *   * / ^|
echo  / *   * /  ^|
echo o-------o*  ^|
echo ^|     * ^|   ^|
echo ^|       ^|  *o
echo ^|   *   ^|  /
echo ^|       ^| /
echo ^| *     ^|/
echo o-------o
goto :eof
:64
echo     o-------o
echo    / *   * /^|
echo   / *   * /*^|
echo  / *   * /  ^|
echo o-------o*  ^|
echo ^| *   * ^| * ^|
echo ^|       ^|  *o
echo ^|       ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o
goto :eof
:65
echo     o-------o
echo    / * * * /^|
echo   /       /*^|
echo  / * * * /  ^|
echo o-------o   ^|
echo ^| *   * ^| * ^|
echo ^|       ^|   o
echo ^|   *   ^|  /
echo ^|       ^|*/
echo ^| *   * ^|/
echo o-------o

        o-------o
        | *   * |
        |       |
        |   *   |
        |       |
        | *   * |
o-------o-------o-------o-------o
| *   * |       | *     | * * * |
|       |       |       |       |
|       |   *   |   *   |       |
|       |       |       |       |
| *   * |       |     * | * * * |
o-------o-------o-------o-------o
        | *     |
        |       |
        |       |
        |       |
        |     * |
        o-------o


    o-------o
   / * * * /|
  / * * * /*|
 / * * * /* |
o-------o* *|
| * * * | * |
|       |* *o
| * * * | */
|       |*/
| * * * |/
o-------o
\$\endgroup\$
4
  • 1
    \$\begingroup\$ Re "real standard dice". Both left-handed and right-handed dice exist (depending on culture), so it might be worth mentioning explicitly which of the two it is, instead of giving a single example. "You can earn a bonus for rolling several dice but in this case you must display the dice horizontally." You forgot to mention how much that bonus is worth but I would recommending leaving it out completely. \$\endgroup\$ Jan 25, 2016 at 14:47
  • 1
    \$\begingroup\$ It's also sort of implied that two numbers is also valid input (provided they can be on adjacent sides), but you never state how that input is to be handled. Likewise, what if the input has more than two numbers? I'd also prefer a fixed output format instead of letting people choose their own ASCII art. It's bound to derail into arguments of how much visual complexity is sufficient to display the die properly. \$\endgroup\$ Jan 25, 2016 at 14:49
  • \$\begingroup\$ @MartinBüttner Sorry I didn't know about Chinese dice, and the bad wording in some of my paragraphs; I hope this version is better. \$\endgroup\$
    – Neil
    Jan 25, 2016 at 17:37
  • 1
    \$\begingroup\$ The diagram of two dice isn't quite enough for me to visualise the all the cases, and the batch script isn't the easiest to read either because of the escaping. I think it would be an improvement to give an unfolded net, possibly a diagram showing all the possible pip positions, and if you want to have a full test suite then to rewrite it in JavaScript and make it a Stack Snippet. Since I've already gone to the effort of producing the first two diagrams to evaluate how helpful I find them, I'll edit them in as a footnote and leave you to decide whether and where you want to use them. \$\endgroup\$ Jan 25, 2016 at 21:02
2
\$\begingroup\$

Polyphonic Pitch Detection

Tags:

Sandbox Notes

  • Still in progress. I haven't made any of the test cases or snippets yet.
  • I'm not sure what to tag this as. It doesn't quite fit the definition of any existing tags. maybe?
  • I'm thinking of making a monophonic version of this challenge as a precursor to this one, since monophonic pitch detection is much easier and this one may be too difficult for most to attempt. Also note that monophonic would have more of an emphasis on perfecting an algorithm, rather than getting it to work at all.

Take an array of samples, and output the frequencies of the waveforms found in the samples.


Despite how simple this may sound, it is actually quite difficult. Even though it has been researched for almost a century, a robust and versatile algorithm for polyphonic pitch detection is yet to be found. Let's look at a simple waveform as an example:

440hz Sine Wave

(The X-axis is in 1/440ths of a second, use the "Play Samples" snippet below to hear what it sounds like)

This is a 440hz sine wave. In musical terms, it is middle A or A4. The next image is a 554hz sine wave (or C#5) on top of the 440hz wave:

554hz Sine Wave

It looks exactly the same, except slightly "squashed" (and sounds a bit "higher"). It is a major 3rd above A4, which means they sound pleasant when played together, however when you look at the waveform that adding them together creates:

440hz Sine Wave + 554hz Sine Wave

The resulting waveform appears vastly different. To further complicate matters, it changes shape depending on the time. There are other factors like overtones, background noise and the fact that real-world waveforms are more complex than sine waves which also make it tricky. (But the human brain still manages to do this effortlessly!)

Your Task

Receive a list of samples as signed 16-bit integers at a fixed sample-rate of 44100 samples-per-second. The input waveform will contain between 1 and 5 (inclusive) simultaneous frequencies in the range of 100hz to 2000hz.

You must output a list of frequencies detected (in hertz) with up to 2 decimal places of precision.

Test Cases

Each test case is on it's own line. Each line begins with the name of the test case, followed by a semi-colon (;), then the frequencies present in the test case (accurate to 2 decimal places) separated by commas (,), followed by another semi-colon, then the samples separated by commas:

Test Case Name;123.45,67.8,90.12;3,75,1234,56789,4321,-23,-408,-9266,41,0,etc...

Each test case will be exactly 44100 samples (1 second) long.

(link to test case file, will include synthesized waveforms, real instrument sounds, multiple instrument/waveform types, a variety of harmonies and pitches, combinations of each of these)

Scoring

The score of a submission is a percentage based on how close the submission's results are to the actual frequencies of each test case. Specifically it will calculated using the formula in the snippet below (use this to calculate your score):

(snippet for calculating score)

Rules

  • No built-ins that detect pitch or extract waveform frequencies are allowed.
  • Helper functions that are designed to aid frequency analysis like FFT are permitted.
  • You may optimise your solution for the test cases, but you cannot hard-code the results for these specific test cases.

Play Samples

You can hear what certain frequencies or a list of samples sounds like by pasting them into this snippet (requires a browser that supports the Web Audio API):

document.write('Enter frequencies separated by commas: <input type="text" ' +'id="Frequencies" value="440,554"><br>' +'<button id="Play" onclick="togglePlay()">Play</button><br>' +'Paste the whole test case line here: <input type="text" id="Test"><br>' +'<input type="checkbox" id="Loop"> Loop?<br>' +'<button id="PlayTest" onclick="togglePlayTest()">Play</button>');var position = 0,samples = null,sampleSize = 0xffff + 1,halfSampleSize = sampleSize / 2,bufferSize = 4096,sampleRate = 44100,context = new AudioContext(),processor = context.createScriptProcessor(bufferSize, 1, 1),oscillators = null;processor.connect(context.destination);processor.onaudioprocess = function(e) {var buffer = e.outputBuffer.getChannelData(0);if(samples) {var sampleLength = samples.length,loop = Loop.checked;for(var i = 0; i < bufferSize; i++) {position += sampleRate / context.sampleRate;if(loop) position %= sampleLength;buffer[i] = ~~samples[position | 0] / halfSampleSize;}if(position >= sampleLength) togglePlayTest();}else buffer.fill(0);};function togglePlayTest() {if(samples) {samples = null;PlayTest.textContent = "Play";}else {var parts = Test.value.split(";");if(parts.length > 1) {PlayTest.textContent = "Stop - " + parts[0] + " (" +parts[1].split(",").map(function(f) { return f + "hz"; }).join(", ") +")";samples = parts[2].split(",").map(function(n) { return +n; });position = 0;}}}function togglePlay() {if(oscillators) {oscillators.forEach(function(o) { o.stop(); });oscillators = null;Play.textContent = "Play";}else {oscillators = [];var frequencies = Frequencies.value.split(","),gain = context.createGain();gain.gain.value = 1 / (frequencies.length + 1);gain.connect(context.destination);frequencies.forEach(function(frequency) {var oscillator = context.createOscillator();oscillator.frequency.value = frequency;oscillator.connect(gain);oscillator.start();oscillators.push(oscillator);});Play.textContent = "Stop";}}

Links

\$\endgroup\$
4
  • \$\begingroup\$ I think it is patented in some countries, but a quite successfull one is the yin algorithm. And you might want to add test-battery \$\endgroup\$
    – flawr
    Jan 18, 2016 at 13:27
  • \$\begingroup\$ @flawr Added. Although note that while the YIN algorithm is quite successful at finding the fundamental frequency, most of the test cases will contain multiple frequencies. \$\endgroup\$
    – user81655
    Jan 19, 2016 at 0:01
  • \$\begingroup\$ Is that desmos I see? \$\endgroup\$
    – Cyoce
    Jan 30, 2016 at 7:46
  • \$\begingroup\$ @Cyoce Yep. ;-) \$\endgroup\$
    – user81655
    Jan 30, 2016 at 10:38
2
\$\begingroup\$

Anything but stacks


Stack-based languages are, like totally, all the rage these days. From GolfScript, to CJam, to MATL, it seems like stack-based languages are popping up everywhere. But now, it is time to push forward and explore new memory models.

In this challenge, you are to create a new programming language based off of any other data structure.


Still undecided is the "goal" of this challenge. The main idea is that, by using a unique data structure, these new languages may have advantages for certain types of problems. Since different languages would use different structures, however, there's not any single set of challenges that would provide a fair comparison. An alternative idea is to pick a single data structure and have everybody use it.


I'm going to work off the "use a specific data structure" idea, since that's really the only thing that can narrow the focus of this question. So, maybe some options are...

  • Queues
  • Trees (except I'm not sure how a "tree without branching" would be different from a "stack")
  • Priority Queues
  • Sets, etc.
  • Associative arrays (dicts/hashmaps)

The next step might be to find some types of problems to target. Are there any algorithms that are known to be exceptionally difficult to implement with a stack?

\$\endgroup\$
8
  • \$\begingroup\$ I think a lot of people will follow Pyth (fixed-arity prefix with iteration as a backup) or Jelly (tacit) if the goal is a golfing language. \$\endgroup\$
    – lirtosiast
    Feb 1, 2016 at 4:30
  • 4
    \$\begingroup\$ This is currently too broad by miles. \$\endgroup\$ Feb 1, 2016 at 8:17
  • 1
    \$\begingroup\$ I definitely agree with Peter. "An alternative idea is to pick a single data structure and have everybody use it." That seems a like a much better idea, and then you need to make sure that that's the only type of memory that's allowed (maybe except for a finite amount, like a handful of registers). Even then, it definitely needs some sort of goal. Requiring TC-ness might also be a good idea depending on what kind of answers you're looking for. \$\endgroup\$ Feb 1, 2016 at 10:11
  • \$\begingroup\$ I think set-based languages would be the most interesting, since sets can't have an order, and most other data structures can implement stacks easily. There are also so many different directions to take with them. \$\endgroup\$ Feb 1, 2016 at 16:47
  • \$\begingroup\$ Somewhere far down on my list of esolang ideas are two languages using stacked cups as a data structure (I'd like to implement a very minimalistic one that doesn't go far beyond the instructions in that challenge, and a feature-rich one, where you're actually programming two hands that can move cups). Anyway, I'd be willing to offer that idea as a data structure for your challenge. \$\endgroup\$ Feb 1, 2016 at 19:14
  • \$\begingroup\$ @user1657355 HPR is set-based, although the set can contain lists. \$\endgroup\$
    – Zgarb
    Feb 1, 2016 at 19:22
  • \$\begingroup\$ Regular expressions. Those are probably hard with a stack based language. Parsing expressions would be hard, I would think, as well. \$\endgroup\$ Feb 1, 2016 at 20:06
  • \$\begingroup\$ I was thinking of two deque based languages. \$\endgroup\$
    – Xwtek
    Feb 18, 2016 at 12:06
2
\$\begingroup\$

Write Hamlet in 1024 bytes

Here is a text file containing Shakespeare's play Hamlet.

You will write a program, less than 1024 bytes in length, that outputs this text to a file, STDOUT or nearest available equivalent. Since this is clearly impossible, you don't have to output the exact text, just get as close as possible.

To measure how close your output is to the original, use the Python 3 script below. It works by concatenating the original text onto the end of your file, then compressing the result using the lzma algorithm, and then subtracting the compressed size of your file alone. This works because if your file contains a lot of common features with the original then the compression algorithm can take advantage of this to make a smaller file. A more sophisticated version of this idea is called normalised compression distance.

All answers should contain the code, at least a brief explanation of how it works (full explanations are encouraged), and the first 2000 characters or so of its output.

This is . Scores are calculated using the script below. The lowest score wins.

Rules and clarifications

  • Your program must be completely self-contained within a single file, taking no input, loading no files, and executing no other programs. Importing libraries is permitted.

  • Your program must run deterministically, producing the same output every time

  • Your output must contain only printable ASCII characters, tabs and newlines. (That is, characters with codes 32 to 126 inclusive, plus 9 and 10.) The comparison script checks for this.

  • Your output must be the same size as the original file, 182581 bytes.

  • You may not use any built-ins or library code that provides compression or decompression algorithms. (e.g. lzma, bz2 etc.) It's OK to use them if you can implement them yourself inside the character limit. Base conversion is OK, and libraries implementing data structures such as Huffman trees are OK.

  • If for some reason your language or one of its libraries contains a function that outputs some or all of the text of Hamlet, you may not use that function.

  • Your program must be written in a programming language, as defined in this answer. This definition must apply to your source code, not just to any compiler/interpreter flags used to run it.

  • In the case of any inconsistency in the script's behaviour between machines, the version on my machine is the definitive one. (Python 3.4.3 on a Mac.)

Here is the comparison code to use. It requires Python 3 because of the lzma dependency. (lzma is much better than bz2 or gzip for this purpose.) It requires the text file linked above to be in the same directory with the name ORIGINAL.txt. Run it with a command like

python3 compare.py my_output.txt

[to do: produce and supply a zip file containing this script together with ORIGINAL.txt]

import lzma
import sys

with open("ORIGINAL.txt", 'r') as file:
    orig = file.read()

with open(sys.argv[1], 'r') as file:
    text = file.read()

def csize(txt):
    return len(lzma.compress(txt.encode('utf-8')))

character_codes = {ord(c) for c in text}
valid_codes = set([9,10] + list(range(32,127)))
if character_codes - valid_codes:
    print("NOT VALID: file contains a non-printable character")
else:
    print( csize(text + orig) - csize(text) )

Technical notes

The compressed size of the original file is 64976 bytes. In an ideal world the original file would have a score of 0, but it actually scores 100. Shakespeare's Macbeth scores 61776, so that should probably be considered a pretty good score.

Tags:

\$\endgroup\$
10
  • \$\begingroup\$ One problem I see is dictionary compression should be really powerful here, but prohibitive for any languages that don't have a built-in dictionary (because including one would clearly exceed the byte limit). What about languages that do have built-in dictionaries though? (Jelly's string literals can be dictionary-compressed out of the box, and I think Mathematica can load a dictionary with a single function call, too.) \$\endgroup\$ Feb 1, 2016 at 13:35
  • \$\begingroup\$ @MartinBüttner I guess I personally am OK with languages with built-in dictionaries - it just seems like using the right tool for the job. But if that would be seen as unacceptably biasing the challenge toward a certain set of languages, I'm OK with putting something in to prohibit it. \$\endgroup\$
    – N. Virgo
    Feb 1, 2016 at 13:39
  • \$\begingroup\$ I just realised that the optimal solution might consist of a 1024-character string literal. For that reason I might add a requirement that the output be the same length as the original file. (But first I have to think about whether that's really likely to be a problem.) \$\endgroup\$
    – N. Virgo
    Feb 1, 2016 at 13:41
  • \$\begingroup\$ Does base conversion count as a "compression or decompression algorithm"? What about Huffman tree-related functions? \$\endgroup\$ Feb 1, 2016 at 22:32
  • \$\begingroup\$ @PeterTaylor I think I would say both are OK - I'm mostly just trying to prevent solutions that don't do much other than bz2.decompress('[some long string]'). If you implemented your own decompression then we learn something from the answer, even if you did it using tools designed for that purpose. However, if you have an intuition that this would devolve into something uninteresting please let me know. \$\endgroup\$
    – N. Virgo
    Feb 2, 2016 at 4:57
  • \$\begingroup\$ @PeterTaylor I've added a restriction on the source character set as well, which should head off some of the most annoying consequences of those things. \$\endgroup\$
    – N. Virgo
    Feb 2, 2016 at 5:01
  • 1
    \$\begingroup\$ I asked about base conversion because it's one of the techniques most frequently used on this site for compression, and about Huffman because it seemed like a gray area which should be mentioned explicitly. On an unrelated note, would it not be a better measure to do the concatenation the other way round, so that the "compressed" Hamlet is training the LZMA bigraph dictionary for the real one? Otherwise the best score would probably be obtained by repeating some large chunk from near the end of the real one as many times as needed to meet the target length. \$\endgroup\$ Feb 2, 2016 at 12:50
  • \$\begingroup\$ @PeterTaylor I've made that change. (I tested it on a few test files, including one composed of the last 5% of Hamlet repeated 20 times, and it didn't make much difference, but it changed the scores by 100 or so.) \$\endgroup\$
    – N. Virgo
    Feb 2, 2016 at 12:57
  • \$\begingroup\$ (One of the reasons that LZMA is good for this purpose is that it's close to being a "normal compression algorithm", which includes being close to invariant with respect to swapping the concatenated strings around.) \$\endgroup\$
    – N. Virgo
    Feb 2, 2016 at 13:07
  • \$\begingroup\$ I changed my mind about trying to keep the source printable. It's a nice thing to have but it means having rules that are too complex, and people will just try to loophole their way around them anyway. So that means base coding is just fine. \$\endgroup\$
    – N. Virgo
    Feb 2, 2016 at 13:23
2
\$\begingroup\$

Create an unkillable Windows process

In various versions of the Microsoft Windows operating system, it is possible for a process to enter a state where it cannot be killed by the 'End Process' feature in the Task Manager. Your goal is to create a user-mode program that enters such a state (or spawns a process that does) using as few bytes of code as possible. Please state the version of Windows on which you have tested the program.

Some techniques for creating unkillable processes can be found here.

Be warned that such processes may cause a performance impact, so be prepared to reboot if necessary when testing any of these programs.

TODO:

  • Minimum version? The #1 in the accepted answer seems too easy.
  • #2 is also lame so maybe taskkill should be the standard instead of Task Manager.
\$\endgroup\$
2
  • 5
    \$\begingroup\$ This is coming fairly close to a challenge asking for malicious software. \$\endgroup\$ Feb 22, 2016 at 9:49
  • \$\begingroup\$ @MartinBüttner It's not completely clear, but the discussion on that question seemed to indicate that a process in a zombie state could not actually execute any longer, making it useless for malware. \$\endgroup\$
    – feersum
    Feb 22, 2016 at 9:53
2
\$\begingroup\$

The greatest power...

Yeah, I'm still trying to come up with a better title...

A positive integer n is a perfect power of order k if it can be written in the form mk for some integer m. The greatest power of n is the largest number k for which n is a perfect power of order k. Some examples:

  • 9 = 32 is a perfect square, and it cannot be written in the form mk for k > 2, so it's greatest power is 2.
  • 16 = 42 is also a perfect square. However it can also be written as 16 = 24, so it's greatest power is 4 instead.
  • 24 = 241 is not a perfect power of any order k > 1 so it's greatest power is 1.

The Challenge

Given a positive integer n > 1, determine its greatest power. This is OEIS entry A052409 (with a(1) defined as 0, but you don't need to handle that).

You may write a program or function, taking input via STDIN (or closest alternative), command-line argument or function argument and outputting the result via STDOUT (or closest alternative), function return value or function (out) parameter.

Standard rules apply.

The first 100 terms of the sequence (starting from n = 2) are:

1, 1, 2, 1, 1, 1, 3, 2, 1, 1, 1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 
3, 1, 1, 1, 1, 5, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 6, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 
1, 1, 1, 1, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1
\$\endgroup\$
18
  • \$\begingroup\$ Can anyone find a similar challenge we've already done? \$\endgroup\$ Feb 26, 2016 at 18:08
  • \$\begingroup\$ I thought up this exact challenge a few days ago, but didn't bother writing it out. Glad to see that someone else did :) \$\endgroup\$ Feb 26, 2016 at 18:13
  • \$\begingroup\$ Power Points? :P \$\endgroup\$ Feb 26, 2016 at 18:35
  • \$\begingroup\$ Also I think I found it: codegolf.stackexchange.com/q/501/31625 although I would prefer to close that as a dupe of this one, I think. It has basically no spec... \$\endgroup\$ Feb 26, 2016 at 18:37
  • \$\begingroup\$ @FryAmTheEggman Hmmm, that might editable without invalidating answers though. \$\endgroup\$ Feb 26, 2016 at 18:47
  • \$\begingroup\$ By the looks of it, some answers are already invalid, and a bunch give 0 for the values that, in yours, should give 1. Not sure what to do with that, I think it'd have to say that 1 or 0 was acceptable? \$\endgroup\$ Feb 26, 2016 at 18:56
  • 1
    \$\begingroup\$ @FryAmTheEggman I think even by the little bit of spec that's there, returning 0 for anything is wrong. Let's see if froddy responds to my comment. Otherwise, I'll probably go ahead with this one. \$\endgroup\$ Feb 26, 2016 at 18:57
  • \$\begingroup\$ Rather than "greatest power" it's "greatest-order root". But of course that's not a catchy title :-) \$\endgroup\$
    – Luis Mendo
    Feb 26, 2016 at 19:23
  • \$\begingroup\$ @DonMuesli I think it would be the greatest root-order, because the greatest-order root should be m, right? \$\endgroup\$ Feb 26, 2016 at 20:48
  • \$\begingroup\$ @Martin Yes, you are right. I had understood the challenge the other way around. Very nice challenge BTW! (Meaning I think I have a 10-byte answer, hehehe) \$\endgroup\$
    – Luis Mendo
    Feb 26, 2016 at 21:34
  • \$\begingroup\$ Submit to a greater power? \$\endgroup\$ Feb 27, 2016 at 2:16
  • \$\begingroup\$ There was a similar question about expressing your number n in all possible ways as n=a^b, but I'm not finding it now. \$\endgroup\$
    – xnor
    Feb 27, 2016 at 22:44
  • \$\begingroup\$ @xnor Hmmm, let me know when you do. \$\endgroup\$ Feb 27, 2016 at 23:01
  • \$\begingroup\$ @xnor There's codegolf.stackexchange.com/q/564/8478 also by froddy. \$\endgroup\$ Feb 27, 2016 at 23:02
  • \$\begingroup\$ @MartinBüttner Here is is: codegolf.stackexchange.com/q/58047/20260 \$\endgroup\$
    – xnor
    Feb 27, 2016 at 23:08
2
\$\begingroup\$

**The Noether Challenge**

It is Emmy Noether's birthday. She was a pioneer in the field of ring theory.

The challenge is to compute two graph-theoretic invariants of a certain graph we can associate with any ring R.

For this challenge, we don't require a unity (multiplicative neutral element) in R, do require the commutativity of multiplication, and additionally require that the ring have finitely many elements. That is, we want to consider finite commutative rings, not necessarily unitary. From now on, "ring" will mean just that.

We will also need the concept of a zero divisor. A zero divisor of a ring R is an element r of R such that r*s=0 for some non-zero s in R. 0 is a trivial example of a zero divisor in any ring with more than one element since it can be shown that 0*s=0 always.

Something Emmy Noether didn't think about is zero-divisor graphs. They have, however, been quite extensively studied recently. The zero-divisor graph of a ring is simple, undirected graph formed as follows. The vertices are the the zero divisors excluding 0. Two vertices r and s are connected by an edge whenever r*s=0, excluding the cases in which r=s (that is excluding possible loops).

In this challenge you are given a file with (addition and) multiplication table(s) for some ring R as input. Your program in any language has to output the diameter and the girth of the zero-divisor graph of R.

The file's name is "ring" and it's a text file. You may assume any extension you wish. Depending on your preference, you may assume that the addition table is not present. If it is, it comes below the multiplication table. The ring is assumed to have at most 62 elements and the elements can be denoted by any subset of the alphanumeric characters including lower- and upper-case letters of the English alphabet. The only other characters assumed to be in the file are the whitespace, the newline, "+" and "*". The "0" character is reserved for 0, so you don't need to check which label stands for 0. The rows and columns for 0 come next after the label rows and columns in both tables. The character "1" doesn't have any special meaning.

The first row and the first column of each table are reserved for labels and the labels' order is the same everywhere (in both tables and both in the columns and in the rows). The upper-left-most character of the multiplication table is "*" and the upper-left-most character of the addition table is "+". The characters in either table are not separated. "*" is the first character in the file. You may assume anything you want about the numbers of whitespaces that follow each row of either table before there's a new line. If two tables are present, they are separated by exactly one additional newline. You may assume whatever you want about the number of newlines and whitespace after the last table.

The output is two numbers, in whatever human-readable and human-understandable form. And the form shouldn't make the user angry. They are to represent the girth and the diameter of the zero-divisor graph. If either of the invariants is infinite, again, it's up to you how you want to output them but it needs to be understandable. If you want to use a nonstandard symbol, like "i", for that, tell the user what it means. We assume that the input is valid. In particular, we assume that the operations in the file are actually ring operations! Your code should be ready to go in whatever way is standard for your language of choice. It shouldn't need any more code to run.

Reading up and research are encouraged, but if you want to use some non-obvious mathematical fact, please give a source or a proof. And in general, please explain how your program works. All standard loopholes are disallowed.

\$\endgroup\$
6
  • \$\begingroup\$ The asterisk seems to make italics sometimes instead of just being text. Can you help me with this? Why does it happen and how do I escape it? \$\endgroup\$
    – ymar
    Mar 23, 2015 at 4:12
  • 1
    \$\begingroup\$ Why it happens. The general solution is to escape with backslash. I think Martin's intention was that you mark up entire equations as code, not just the asterisk character. \$\endgroup\$ Mar 24, 2015 at 10:24
  • \$\begingroup\$ Comments on the question itself: 1. It's not obvious that this is a graph theoretic question rather than an algebraic question until a long way into it. Ideally the title should make that clear. 2. The first two ring axioms are clearly misstated. But 3. listing them seems to be a waste of space. The real question (given a multiplication table, identify the zero divisor graph and its diameter and girth) can be stated quite clearly without them. 4. Both diameter and girth can be infinite. How should that be represented in output? \$\endgroup\$ Mar 24, 2015 at 10:41
  • 1
    \$\begingroup\$ 5. A question shouldn't be popularity-contest unless there's no other reasonable way of scoring it. This would function perfectly well as code-golf, and with a minor change to allow arbitrary sizes of input could be a fastest-code. \$\endgroup\$ Mar 24, 2015 at 10:42
  • \$\begingroup\$ @PeterTaylor I've made corrections. \$\endgroup\$
    – ymar
    Mar 8, 2016 at 14:18
  • \$\begingroup\$ Thanks. Looking back at this, I have two further comments: 6. It's generally considered best to be a bit more flexible on input mechanisms: i.e. rather than specifying that the input must be read from a file, specify its format as a string and leave the default formats open (so people can read from stdin, write a function which takes a string parameter, etc). 7. Some test cases would be good. \$\endgroup\$ Mar 8, 2016 at 21:49
2
\$\begingroup\$

Igpā Atinlā (Pig Latin)

This is .

In this challenge, we will be translating strings of words to Pig Latin.

Input: A string of words (a "word" is a continuous sequence of the characters A-Za-z) (ASCII only).

Output: The translated version of the input. Translations described below.

Some Definitions:

First, the following are vowels: "A,a, E,e, I, i, O, o, U, u". Any alphabet character that is not a vowel is a consonant. A consonant cluster is any continuous sequence of consonants surrounded on both sides by non consonant characters (or beginning/end of input). An example, the clusters are in bold:

"I am two hundred years young, you child-mother."

A word is a set of alphabet characters surrounded on both sides by non-alphabet characters.

Translation:

  1. If the string "'s" or "'d" or "'t" appears ("apostrophe s/d/t"), remove the apostrophe.

For each word in the string, do the following:

  1. If a word only contains capital letters (A-Z), ignore the next step.

  2. If the beginning of the word was a capital letter (A-Z) AND a consonant, change it to its lower-case equivalent (a-z). Then capitalize the first vowel in the word. If no vowel exists, then recapitalize the letter. e.g. Stretch --> strEtch, "Twxx" --> "Twxx"

  3. If the word begins with a consonant cluster, move that consonant cluster to the end of the word. e.g. stretch --> etchstr

  4. Append the "hard a" character to the word. If every letter is capital, append 'Ā'. Otherwise append 'ā' e.g. etchstr --> etchstrā, "ATC" --> "ATCĀ"

    • If your language is unable to output 'ā' and 'Ā', you may use "ay" and "AY" respectively.
  5. If the word is "A" or "a", ignore previous instructions. Transform the word to "Anā" or "anā", respectively. (because in Pig Latin, everything begins with a vowel, so we use the article "an" instead of "a")

Test Cases: (I think these are right)

  • "I want to be a cat." --> "IĀ antwā otā ebā anā atcā"

  • "That's a really nice... ass-car?" --> "Atsthā anā eallyrā icenā... assā-arcā?"

  • "[CR][NL]'ssssssssssssssssssTRUExxxxxxxxIAMSOCOOL" --> "[CRĀ][NLĀ]UExxxxxxxxIAMSOCOOLssssssssssssssssssTRā"

  • "THIS CHALLENGE IS PROBABLY A DUPE" --> "ISTHĀ ALLENGECHĀ ISĀ OBABLYPRĀ Anā UPEDĀ"

  • "I SAT ON an APPLE" --> "IĀ ATSĀ ONĀ anā APPLEĀ"

\$\endgroup\$
10
  • \$\begingroup\$ Is the string: bc a consonant cluster? \$\endgroup\$
    – Downgoat
    Mar 6, 2016 at 5:30
  • \$\begingroup\$ Yeah. "bc" --> "bcā". Is that not what the spec says? \$\endgroup\$
    – Liam
    Mar 6, 2016 at 5:32
  • \$\begingroup\$ ok, I wanted to clarify if the start/end of a string counts as a "non-vowel" character. Perhaps a better description is: "a sequence of consonants"? \$\endgroup\$
    – Downgoat
    Mar 6, 2016 at 5:34
  • \$\begingroup\$ I think it's clearer now? \$\endgroup\$
    – Liam
    Mar 6, 2016 at 5:52
  • \$\begingroup\$ Very closely related. \$\endgroup\$ Mar 7, 2016 at 15:46
  • \$\begingroup\$ @FryAmTheEggman I think mine is sufficiently more complicated that it wouldn't be a dupe. However I don't know that the complexities are interesting enough to merit posting. \$\endgroup\$
    – Liam
    Mar 7, 2016 at 19:22
  • \$\begingroup\$ Some languages might not support the special a and A. Maybe allow regular A's? \$\endgroup\$ Mar 9, 2016 at 5:43
  • \$\begingroup\$ @CatsAreFluffy I know that some languages can't but I think that makes the challenge more interesting. At least a bit. If people disagree, I might change it to "ay" and "AY" \$\endgroup\$
    – Liam
    Mar 9, 2016 at 5:49
  • \$\begingroup\$ In the THIS CHALLENGE IS PROBABLY A DUPE test case, the A should become Anā instead of ANĀ. \$\endgroup\$
    – user48538
    Mar 9, 2016 at 7:07
  • \$\begingroup\$ I'd call this a dup. \$\endgroup\$
    – mbomb007
    Mar 11, 2016 at 15:29
2
\$\begingroup\$

Maximum of Two Roman Numerals

You should write a program or function which returns the maximum of two Roman numerals.

Input

  • Two positive integers between 1 and 3999 (inclusive) with their Roman numeral representation string.
  • The two strings can be separated by a space or inputted in the standard list representation of your language.
  • 4, 9, 40, ... are written as IV, IX, XL, ...
  • Trailing newline is optional.

Output

  • The larger Roman numeral as string.
  • Trailing newline is optional.
  • If the two inputs are equal you should still only return one of them.

Examples

Format is input => output (explanation)

XXIX DI => DI (29 < 501)
V X => X    

TODO more

Built-in functions involving Roman numerals are prohibited.

This is code golf so the shortest entry wins.

\$\endgroup\$
2
  • \$\begingroup\$ Can I adopt this abandoned challenge? \$\endgroup\$
    – user58826
    Jun 9, 2017 at 12:12
  • \$\begingroup\$ @programmer5000 Yep! \$\endgroup\$
    – randomra
    Jun 10, 2017 at 17:02
2
\$\begingroup\$

Entropy Golf

This is a scoring system without a challenge.

My idea is to score entries based on the total Shannon entropy contained within them. This provides an incentive to both use fewer unique characters and to have a shorter program overall.

Given a string of characters, the score is calculated as follows, where C(x) is the number of occurrences of the given letter. To help provide a correction for multi-file programs or languages in which the program length encodes information, the EOF character at the end of every file is to be counted for the purposes of this scoring mechanism. Lowest score wins.

$$\mathrm{score} = -\sum_x{C(x)\log_2\frac {C(x)}{\mathrm{Length}}}$$

enter image description here

Anybody who knows better notation/MathJax is free to edit.

\$\endgroup\$
6
  • \$\begingroup\$ As it is you would still get many Lenguage-like answers in the form of unary string, base convert, exec. Edit: Actually that wouldn't work, never mind. \$\endgroup\$
    – feersum
    Jun 6, 2015 at 15:51
  • 2
    \$\begingroup\$ The line between lenguage and slashes and brainfuck and real languages would be hard to define. Languages with fewer symbols tend to require more uses of those symbols to accomplish anything. \$\endgroup\$
    – Sparr
    Jun 6, 2015 at 17:01
  • \$\begingroup\$ @Sparr It's mainly about languages that encode information in the length of the program itself. It's not about number of symbols, although I could probably put a requirement that the program uses at least two symbols. \$\endgroup\$
    – PhiNotPi
    Jun 6, 2015 at 18:05
  • 3
    \$\begingroup\$ Alternatively you could consider each program to be terminated by an EOF character, which is included in the calculations. Then a $n$-character program in lenguage would score $-n \lg n/(n+1) - \lg 1/(n+1)$, which does grow indefinitely. PS I've just realised that my edits come down to the same thing as you were doing by flipping the quotient in the log upside down. Sorry about that. Revert if you want, but be aware that I might not be the only person who has $p \lg p$ so branded in their mind that anything else looks wrong. \$\endgroup\$ Jun 6, 2015 at 18:46
  • \$\begingroup\$ @PeterTaylor p log (1/p) should be much more intuitive for people who see this the first time. \$\endgroup\$
    – jimmy23013
    Jun 7, 2015 at 1:20
  • \$\begingroup\$ If you meant unique characters, Sclipting has an advantage for that selecting a character from the whole Unicode contains a lot of information (compared to the length of a short program). \$\endgroup\$
    – jimmy23013
    Jun 7, 2015 at 1:23
2
\$\begingroup\$

Wargame Tank Simulation

Some of you may have heard of the Wargame series of computer based real time strategy game. These games pit teams of players with primarily cold war era units to see how a hot cold war would have played out. The goal of this challenge is to simulate a tank battle in these games.

Input

  • Two "tanks" (one red and one blue) will be entered into your program or function. Each tank is classified by a rate of fire, accuracy, armor value, and attack power value.

Challenge

From the inputs above, simulate the two tanks fighting. You will do this by having each tank fire according to its rate of fire. If it hits (randomly determined by accuracy), a tank will do damage according to the armor value of its target and its own attack power. The formula for damage is floor[(attackpower - armor)/2]. Therefore a tank with 10 attack power against a tank with 5 armor would do 2 damage.

Tank crews also have morale, which follows the following rule

  • There are four possible morale values; calm, worried, scared, and panicked. Tanks always start calm. These names do not need to be in your code, in the sample below I've used calm = 1, worried = 2, etc.
  • Each morale value reduces the accuracy as follows: Calm -> 100% (no change), worried -> 75%, scared -> 50%, panicked -> 25%. Therefore a panicked tank which normally has 60% accuracy now has 0.25 * 0.6 = 15% accuracy
  • Each hit by the opposing tank degrades morale by one level, each miss upgrades the morale by one level.

For example:

morale: calm  |  worried  |  calm  |  worried  |  scared
hit:         hit         miss     hit         hit

Rules:

  • Input should be two parameters to repesent each tank (I've used two tuples in the example below). Inputs may be provided in any order, just be sure to state which one is which. Input may be provided by user input via STDIN, read from a file, or parameters passed to a function call.
  • Each tank starts with 10 health.
  • Rate of fire will either be 8.5, 7.5, 6.5, 6, or 5 seconds between shots.
  • Tanks start loaded, so each fires at time = 0. Because Communists are sneaky, red fires first.
  • Accuracy must be randomly rolled.
  • Ineffective hits (hits which do no damage) have an effect on morale! (because it probably sounds terrifying)
  • Naturally since we want to see the action, output will be an update after each shot. The update will contain the time of the shot, whom it was made by (red or blue), health of both tanks, and the morale of both tank crews. Output maybe be presented in any format so long as it contains all of the required information in a human readable fashion (items must be delimited in some way). Similar to input, please describe your output format in the answer.
  • Engagements are limited to 100 seconds. If you play the game you know this is because a plane has swooped in by then. For our purposes if both tanks are alive at this point, it is a draw.
  • After one tank reaches 0 health (or after 100 seconds), print which tank is victorious ("Red" or "Blue") or "Draw" if appropriate. I don't care about trailing whitespace or newlines.
  • Printint output may be printing to STDOUT or writing to a file
  • Shortest answer in bytes wins

Sample Python Implementation

import random, math

def Shot_Result(acc, morale, power, armor):
    Morale = {1: 1., 2: 0.75, 3: 0.5, 4: 0.25}
    actual_acc = acc * Morale[morale]
    roll = random.random()
    if roll < actual_acc:
        dmg = max(0,math.floor((power-armor)/2))
    else:
        dmg = -1
        
    return dmg
    
    
def main(Red, Blue):
    red_rate, red_acc, red_armor, red_pow = Red
    blue_rate, blue_acc, blue_armor, blue_pow = Blue
    
    red_health = blue_health = 10
    red_morale = blue_morale = 1
    
    red_shots = [("Red", shot/100.) for shot in range(0,10000,int(red_rate*100))]
    blue_shots = [("Blue", shot/100.) for shot in range(0,10000,int(blue_rate*100))]
    
    Shots = sorted(red_shots + blue_shots, key=lambda x: x[1])
    
    print "{:^6}|{:^6}|{:^12}|{:^12}|{:^12}|{:^12}|".format("Shot","Time","Red Health","Blue Health","Red Morale","Blue Morale")
    
    for shot in Shots:
        if shot[0] == "Red":
            dmg = Shot_Result(red_acc, red_morale, red_pow, blue_armor)
            if dmg >= 0:
                blue_health -= dmg
                blue_morale = min(blue_morale+1,4)
            else:
                blue_morale = max(blue_morale-1,1)
        else:
            dmg = Shot_Result(blue_acc, blue_morale, blue_pow, red_armor)
            if dmg >= 0:
                red_health -= dmg
                red_morale = min(red_morale+1,4)
            else:
                red_morale = max(red_morale-1,1)
                
        print "{:^6}|{:^6}|{:^12}|{:^12}|{:^12}|{:^12}|".format(shot[0], shot[1], red_health, blue_health, red_morale, blue_morale)
        
        if red_health <= 0:
            print "Blue tank is victorious!"
            break
        if blue_health <= 0:
            print "Red tank is victorious!"
            break
    else:        
        print "It's a draw!"

Sample Output (Yours does not need to be this fancy)

 Shot | Time | Red Health |Blue Health | Red Morale |Blue Morale |
 Red  | 0.0  |     10     |    5.0     |     1      |     2      |
 Blue | 0.0  |     10     |    5.0     |     1      |     2      |
 Blue | 6.5  |     10     |    5.0     |     1      |     2      |
 Red  | 8.5  |     10     |    5.0     |     1      |     1      |
 Blue | 13.0 |    5.0     |    5.0     |     2      |     1      |
 Red  | 17.0 |    5.0     |    5.0     |     2      |     1      |
 Blue | 19.5 |    5.0     |    5.0     |     1      |     1      |
 Red  | 25.5 |    5.0     |    5.0     |     1      |     1      |
 Blue | 26.0 |    0.0     |    5.0     |     2      |     1      |
Blue tank is victorious!
\$\endgroup\$
3
  • \$\begingroup\$ Its a good challenge, but you need to define your input/outputs a little more. I'd recommend indicating that tanks are passed in as a tuple/list, which tank is passed in first, and then define what the functions should return if red wins/blue wins/tie. \$\endgroup\$ Mar 28, 2016 at 15:32
  • \$\begingroup\$ @NathanMerrill, I've made some slight updates to the rules. I want to keep things open as I often find myself frustrated with arbitrary I/O restrictions. \$\endgroup\$
    – wnnmaw
    Mar 28, 2016 at 15:58
  • \$\begingroup\$ Flexible I/O is the way to go :) Looks good from my end. \$\endgroup\$ Mar 28, 2016 at 16:05
2
\$\begingroup\$

Diagonals of an Array

The k-th diagonal of a two-dimensional array is a list of all elements in positions (a,a+k). Your task is to output all of the diagonals.

For example, the diagonals of

[[3,1,4,1],[5,9,2,6],[5,3,5,8]]

are:

[[1],[4,6],[1,2,8],[3,9,5],[5,3],[5]]

Which can be visualized thusly:

k -2-1 0 1 2 3
    \ \ \ \ \ \
     \ \ 3 1 4 1
      \ \ \ \ \
       \ 5 9 2 6
        \ \ \ \
         5 3 5 8

Input

A rectangular nested array or 2D array of positive integers, which will be nonempty.

Output

Its diagonals in any consistent order.

Test cases

[[3,1,4,1],[5,9,2,6],[5,3,5,8]]
[[1],[4,6],[1,2,8],[3,9,5],[5,3],[5]]

[[42]]
[[42]]

[[57,72,15,66,49,01,53,28,60,60,65,12,09,00,82]]
[[57],[72],[15],[66],[49],[1],[53],[28],[60],[60],[65],[12],[9],[0],[82]]

[[57],[72],[15],[66],[49],[1],[53],[28],[60],[60],[65],[12],[9],[0],[82]]
[[57],[72],[15],[66],[49],[1],[53],[28],[60],[60],[65],[12],[9],[0],[82]]

Maybe a second question about n-dimensional arrays?

\$\endgroup\$
2
  • \$\begingroup\$ I suggest a requirement that the order of the output diagonals be consistent (the same irrespective of input); and add a row matrix and column matrix as test cases \$\endgroup\$
    – Luis Mendo
    Mar 26, 2016 at 18:21
  • 1
    \$\begingroup\$ Now almost a duplicate. Also, Jelly has a 2-character built-in for this. (Just to let you know.) \$\endgroup\$ Apr 6, 2016 at 8:51
2
\$\begingroup\$

Help! Everything is in Wingdings!

Your task is to write a program or function that converts wingdings to a readable font. The input to the program will be the path to a png file with between 1 and 10 wingdings characters. Your output should be the message contained in the wingdings characters.

Specifications

Each test case will be a screenshot of the message as rendered in Microsoft Word (Black text on a white background, size 36, and 100% zoom). The image will be cropped to the bounding box of the message.

[insert 20 test cases, 2 of each size between 1 and 10]

[insert link to test cases + reference images]

Scoring:

(% of characters right in test cases)*10 - code length

(Highest score wins)

Rules

  • Standard loopholes apply.
  • No catering to the test cases.

(Note that this is just a concept for a challenge. I will expand the challenge if this receives a positive response).

\$\endgroup\$
6
  • \$\begingroup\$ @EasterlyIrk The input is an image containing wingdings characters. \$\endgroup\$
    – Daniel M.
    Apr 10, 2016 at 3:34
  • \$\begingroup\$ Related \$\endgroup\$
    – Leaky Nun
    Apr 10, 2016 at 3:35
  • \$\begingroup\$ @KennyLau This is different because the test cases will have up to 10 characters in the same image (and catering to the test cases is a standard loophole). I'll work on this more tomorrow. \$\endgroup\$
    – Daniel M.
    Apr 10, 2016 at 3:44
  • \$\begingroup\$ The description of the image seems underspecified to me. Will the characters all be the same font size? How will they be laid out? Colours? Anti-aliasing? \$\endgroup\$ Apr 10, 2016 at 21:36
  • \$\begingroup\$ What is the subpixel rendering setting? \$\endgroup\$ Apr 11, 2016 at 10:22
  • \$\begingroup\$ @JanDvorak I'm not completely sure, so it's probably at whatever the default for Windows 10 is. If needed I can run the images through a program that creates a 1-bit image. \$\endgroup\$
    – Daniel M.
    Apr 11, 2016 at 10:56
2
\$\begingroup\$

Find point on the Hilbert curve

The Hilbert curve space filling curve. It is a limit of recursive approximations. Being spacefilling means there is a parametrization of the curve which is continuous. So we can map the interval [0,1] continuously to the unit square [0,1]x[0,1]. Let us call this map h. (Note that the image of the [0,1] is not the complete [0,1]x[0,1] but rather a dense subset. E.g. (.5,.1) is obviously not in the Hilbert curve, as it is not in any of the approximations.)

Your task is now to write a progarm that given a value in [0,1] to return the corresponding value unit square [0,1]x[0,1], where h(0)=(0,0) and h(1)=(1,0), and h(.5) = (.5, .5)

Meta

  • This could also be done backwards.
  • Test cases to be added.
\$\endgroup\$
8
  • \$\begingroup\$ Are forwards and backwards sufficiently different tasks to make this two separate questions? \$\endgroup\$
    – trichoplax
    Apr 11, 2016 at 20:14
  • \$\begingroup\$ I just thought about this: the 'backwards' challenge would be relatively difficult, as h is continuous but only injective, but the inverse is not continuous anymore. So I think this direction is the better suited one for a challenge. \$\endgroup\$
    – flawr
    Apr 11, 2016 at 20:45
  • \$\begingroup\$ Yes the backwards challenge would have more than one valid output. Maybe 4? You could just ask for any 1, or all (4?) or as many as exist (I'm guessing the 4 corners have only one answer). Forwards seems more than enough of a challenge to start with though. \$\endgroup\$
    – trichoplax
    Apr 11, 2016 at 21:19
  • \$\begingroup\$ I'd recommend either a formula or a reference implementation to make the correct output explicit. The Hilbert curve is fairly easily confused with similar-but-not-quite-the-same curves. \$\endgroup\$
    – trichoplax
    Apr 11, 2016 at 21:21
  • \$\begingroup\$ @trichoplax Yes I'm certainly going to add a reference. What other curves do you have in mind? \$\endgroup\$
    – flawr
    Apr 11, 2016 at 21:32
  • \$\begingroup\$ I was thinking of curves like the Moore curve but now that I look it up, I see that answers using this would be ruled out by test cases using the end points (0 or 1). \$\endgroup\$
    – trichoplax
    Apr 12, 2016 at 0:05
  • \$\begingroup\$ Right, I was not aware of this curve and it certainly looks quite similar! \$\endgroup\$
    – flawr
    Apr 12, 2016 at 8:06
  • \$\begingroup\$ I really like it because its ends meet so it can form a closed loop. \$\endgroup\$
    – trichoplax
    Apr 12, 2016 at 12:55
2
\$\begingroup\$

KOTH: Black Hole

I've recently seen this video (by Tom Scott), in which it featured a game called Black Hole. Let's play that for KOTH!

Overview (the original version in the video)

  • Two "players" have 10 counters, each labelled 1 to 10.
  • These two players take it in turns to place counters in increasing order on a grid of 21 "spaces" arranged in a triangle (i.e. a triangle with 6 rows).
  • Once all 21 counters have been placed, the remaining space that hasn't been used is the "black hole", and the dots surrounding the black hole are "sucked in".
  • The person with the lowest sum of the counters "sucked in" wins.

For the purpose of KOTH, the triangular grid will consist of 120 spaces (i.e. the triangle "pyramid" will be 15 rows high), and each player will have 59 counters (Yes, that means that there will be 2 black holes).

Point System

  • Win: 10 points, Draw (very rare): 3 points, Loss: no points

Instructions

  • The bot must output a number between 1 and 120 each turn, and a "counter" with the same number as the current no. turn made by the bot will be placed there.
  • After 118 turns, the black holes activate, the score is counted, and points are awarded.

NOTE: If there is no output within 5 seconds, the bot immediately loses.

"Battle" System

  • The competition will be a round-robin, except each bot battles every other bot 5 times.
  • The top three bots will then play each other 10 times each.
  • The final winner is the winner of the competition.

Info on controller stuff

The controller will be in Python, but I don't have the first clue how to make an controller. Any help?

\$\endgroup\$
6
  • \$\begingroup\$ Well I think that you have to choose a way of inputting and outputting data first to have an idea how to write the controller. If it's going to be single language KOTH you can just ask people to write you functions/classes in some way and you can attach those to a regular program performing the game. On the other hand the challenge seems simple enough that you may just give the input as arguments to an execution of the programs and read output for them (calling an instance of the bot for each move). \$\endgroup\$
    – Lause
    Apr 11, 2016 at 10:12
  • \$\begingroup\$ Yeah... I'll probably do it as an input/output thing, regardless of language. \$\endgroup\$
    – clismique
    Apr 11, 2016 at 10:55
  • 1
    \$\begingroup\$ 1. I think you've changed the size of the board so many times that there are figures in the question from at least three different board sizes. 2. In the video, the counters must be placed in increasing order of value, but the question doesn't mention this anywhere. 3. From my experience of other koths, best-of-50 is going to be far too time-consuming. I suggest making it best-of-5 or at most best-of-7. \$\endgroup\$ Apr 11, 2016 at 21:39
  • \$\begingroup\$ Ah. Thanks for the tips... sorry if it's confusing. Will edit. \$\endgroup\$
    – clismique
    Apr 12, 2016 at 1:10
  • \$\begingroup\$ Interesting game. There is discussion about the different options for input and output on meta, and also there's a general tips for writing KotHs. \$\endgroup\$
    – trichoplax
    Apr 12, 2016 at 13:14
  • \$\begingroup\$ So... if there are multiple languages, will I have to install other things that can run those languages? That's a lot of stuff to prepare for, considering it's only for a short while (maybe for longer if I keep on doing KotHs). \$\endgroup\$
    – clismique
    Apr 13, 2016 at 10:13
1
23 24
25
26 27
135

You must log in to answer this question.

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