Sandbox for Proposed Challenges

Question

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

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

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

• Most people include applicable tags in their proposal, so for instance you can search for all king-of-the-hill proposals by merely adding the tag name in quotes to the search query.

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

Answer 1

KOTH Screeps Fighting AI king-of-the-hill

Screeps is an MMO for programmers (not a regular MMO, this is not modding, but rather the only way to play) where you program creeps. I want to make sure one more time: this is not hacking or modding, this is the only way you play the game. It has a builtin IDE that is always present.

This is your job: With 1550 energy, spawn an army of creeps to fight other player's armies. Your goal is to destroy the other team's spawn.

Specifications

• Each team will start with 0 creeps and it's own spawn.
• The team number will be hardcoded.
• The spawns will be named Spawn1 and Spawn2, corresponding to each player's team
• The room controller will be at level 8 and you will not have to worry about upgrading it.
• Each creep will display an emoji chosen to represent it's team using creep.say(). This is so that members of the two teams can distinguished.

Rules

• Not all creeps have to fight. Some can gather energy, build walls, etc.
• Building structures is allowed. This includes walls, ramparts, towers, etc.

This is under construction! Please comment if you know how to improve this challenge!

Answer 2

Kill the mosketeers

Taken a NxN square field, where you are supposed to be on the extreme upper right corner, n mosketeers are waiting an execution instruction that begins with the first lefttmost shooter alternatively until the last righttmost one, in a continuous unceasable order, meanwhile, between any shot and another you are allowed to move one step either to 4 allowed perpendicular directions.

T a period permitted to reload the riffle from a shot to another, dependently of steps taken from a move to another, a step is expressed in other words, as the time taken from two consecutive shots that of a mosketeer and his neighbor, so once T steps are elapsed, the mosketeer takes turn to shot again where two shots can occur in real-time.

Your task, is more than saving your head on your shoulders, but it is rather the ability of killing all the mosketeers while they are reloading their riffles by a knife, noted that : a mosketeer can shot in an horizontal dimention if his turn comes out, and no moketeer is between him and you, morover, a mosketeer do never move.

Given two inputs, N T, say in term of integer output how many mosketeers you are able to kill, return -1 or nil the case you end up killed no matter what you tried.

Example:

input:

   4,3

steps:

...*  |... .|.. ..|. |..| .|.. ..|. |..| .|.. ..|. ...| .... ....
....  |..* .|.. ..|. |..| .|.. ..|. |..| .|.. ..|. ...| .... ....
....  |... .|.* ..|* |.*| .|*. .*|. |*.| *|.. ..|. ...| .... ....
$$$$  |$$$ $|$$ $$|$ |$$| $|$$ $$|$ |$$| $|$$ *$$$ .*$| ..*$ ...*

Output:

  4

---

example 2

input:

   4,2

steps:

...*  |... .|.. |.|. .|.| |... .|.| |... .|.| .... .|.| 
....  |..* .|.. |.|. .|.| |... .|.| |... .|.| .... .|.| 
....  |... .|.* |.|* .|*| |... .|*| |*.. *|.| .... *|.| 
$$$$  |$$$ $|$$ |$|$ $|$| |$*$ $$.$ $$.$ $$.$ *$.$ .$.$ 

Output:

  2

---

Answer 3

Serialize and Deserialize a Binary Tree!

code-golf

A coding website, leetcode.com, has a method to serialize a binary tree.

Serialize means making a binary tree linear.

For example, we have:

[1,[[2],[3,4,5]]]

    1
   / \
  2   3
     / \
    4   5

First, we fill the missing places with 0:

      1
     / \
    /   \
   /     \
  2       3
 / \     / \
0   0   4   5

Then read out all the lines from top to bottom:

->      1
       / \
      /   \
     /     \
->  2       3
   / \     / \
-> 0   0   4   5

[1,2,3,0,0,4,5]

Let's look at another example:

   1
    \
     2
    /
   3

Fill the missing places with 0:

   1
  / \
 0   2
    / \
   3   0

Note that 0 cannot have any child.

Therefore, this tree is serialized as [1,0,2,3,0].

Your task is to write two programs/functions, one to serialize, one to deserialize.

Specs

• They may share code.
• The binary tree will only contain positive integers.
• A node in the binary tree is represented by [name,left_child,right_child].
• You may not pre-fill the binary tree with 0s.
• [1,0,2,3,0,0,0] is invalid.
• Unlike the website given, [1,0,2,3] is invalid.

Notes

• Subset of this challenge, but this is code-golf instead.

Answer 4

Matching a string using a huge number of steps

regular-expression code-challenge

Your task is to write a regex that matches a string you defined in as close to n steps as is humanly possible.

The regex must match the whole string without the global flag on.

Scoring

The score would be regex length + string length + absolute difference between the number of steps and n.

For example, if n = 65536, this example has 6 bytes as regex, 49152 bytes in the string, and 65539 steps, which would account for a total score of 6+49152+3=49161.

Lowest score wins.

Requirements

1. n = 65536 (2**16)
2. n = 59049 (3**10)
3. n = 40320 (8!)

The total score will calculated from the scores of the three programs.

Questions:

• How can I make this challenge better?

Answer 5

Brainfuck-golf: find the maximum of two numbers

tips

You will be provided with two numbers on the first two memory cells, and you will write a code in brainfuck to put the maximum of the two numbers on the third memory cell.

• You may use this template and this template to test your code. Just append your code to the templates.
• You may destroy the numbers in the first two cells.
• The pointer must initially point to the first cell.
• The two initial numbers will be positive.
• , will halt your program (waits for input which I will not supply).
• The tape is semi-infinite. Your numbers are on the first two memory cells.
• The cells do not wrap around. They just increase until the number is bigger than the age of the universe in terms of picoseconds.

Answer 6

Primary Chances

Write a program that lists all possible outcomes for a general election with any number of candidates.

Rules:

• Your answer must output how many states each candidate won in any format.
• Candidates can have any name.
• This is code-golf, so standard loopholes are forbidden, and shortest code wins.

Answer 7

Sort 2D points by Sierpiński curve order

code-golf geometry fractal sorting

---

[ WORK IN PROGRESS]

---

Input

A collection of distinct 2D points in the range [0,1] X [0,1].

Output

An ordered collection of the same 2D points, meeting the criteria for Sierpiński curve order.

Sierpiński curve order

• The points are in the order that the Sierpiński curve would pass through them.
• The order is cyclic - it does not matter which point is first.
• The order may be clockwise or anticlockwise/counterclockwise, provided it is consistent.
• The point at the centre of the range, (0.5, 0.5), may fall into any triangular quarter of the range, provided it is in the correct order among other points in that quarter. Similarly for all other points where both coordinates have finite binary expansion.

Although the curve is infinitely long and fills the unit square, it is arranged in a convenient shape that allows ordering points by calculating only a finite number of iterations. For example, if there are 4 points, one in each triangular quarter of the square, then they can be ordered based only on this information as the curve fills one triangular quarter before moving on to the next so the exact position without that quarter is not relevant.

---

Sandbox questions

• Should ambiguous points be allowed to fall in any direction, or should I impose that they always fall left rather than right and up rather than down? Or just insist that the solution choose a consistent direction rule?
• Can I assume that any three points that can be described by floating point variables can be ordered in a finite number of subdivisions? I'm pretty sure but welcome a counterexample.

Answer 8

Find ALL Longest Common Substrings

Unlike "Longest Common Substring" algorithm which returns just one string, or the length of it. This algorithm returns a score after taking all separate longest common substrings into account.

This program returns the score of how similar one string is to another according to the following rules:

1. isolate only the longest (non-overlaping) matching substrings.
2. score every longest substring found with this formula: (substring.length / ((string1.length + string2.length) / 2)) * substring.length
3. sum the scores and return.

STEP 1 Example:

string1 = ABCD

string2 = ZBCA

Deconstructing string1: (list of substring in order)

ABCD

ABC

AB

A (also found in string2)

BCD

BC (also found in string2)

B (also found in string2 but ignored - part of a longer substring)

CD

C (also found in string2 but ignored - part of a longer substring)

D

Matches: A, BC

STEP 2 Example: (substring.length / ((string1.length + string2.length) / 2)) * substring.length

A: (1/((4+4)/2)) * 1 = .25

BC: (2/((4+4)/2)) * 2 = 1

Step 3 Example:

.25 + 1 = 1.25, Return 1.25

Here's an example of longer strings of variable length:

string1 = Approximate This

string2 = Appropriate That Thing

Matches: Appro, i, ate Th,  Thi

Appro: (5/((16+22)/2)) * 5 = 1.3157894736842105263157894736842

ate Th: (6/((16+22)/2)) * 6 = 1.8947368421052631578947368421053

i: (1/((16+22)/2)) * 1 = 0.05263157894736842105263157894737

 Thi: (4/((16+22)/2)) * 4 = 0.47368421052631578947368421052632

Return: 4.1052631578947368421052631578948

Answer 9

Fizzbuzz for tensorflow

Since I was a new and naive user, I posted this question. In one day it got over 25 upvotes but was shut down for being too broad. Clearly there is community interest -- so by the suggestion of @DrGreenEggsandHamDJ I'll try it again in the sandbox. I'd really like to see some of the answers here, so I appreciate any help you can give turning this question into a proper submission.

Original text copied below:

---

Inspired by the job-interview with Joel Grus, the goal of this challenge is to write a tensorflow (or other deep/machine learning) program that learns Fizzbuzz and correctly prints out the answers to the positive integers less than 1000.

You can assume there are files named train.csv and test.csv and each contain a sorted list of sequential integers and the fizzbuzz answer:

 ...
 100, buzz
 101, 101
 102, fizz
 103, 103
 104, 104
 105, buzz
 ...
 150000, fizzbuzz

test.csv spans 1-1000 and train.csv spans 1001-150000.

Rules

1. You must not hard-code the rules to Fizzbuzz anywhere in your program. The output must be from a machine learned representation that is learned while running the code.
2. You must utilize train.csv in the training set and check your output against test.csv. You cannot use test.csv during training.
3. You must get all outputs correct from test.csv (but as is case with deep-learning, we'll allow your code to fail this rule no more than 5% of the time).
4. You may use any language and any external module (eg. python/tensorflow) as long they explicitly perform some kind of learning. Reference both the language and the module in the title of your post.
5. This is a popularity contest, so the submission with the most votes after one week wins.

Answer 10

What can I build? code-golf

The Rules

Today I have decided to make geometric shapes out of toothpicks and gumdrops! However, I have a limited supply, so you have to figure out what I can build. I will give you an input in the format m n, where m is toothpicks (edges) and n is gumdrops (vertices.) Your output should be, in any output format of your choice, all 3D geometric shapes such that the amount of edges=m and the amount of vertices=n. The list of 3D geometric shapes you will use is this: Gist

• You may NOT access the Internet.
• No builtins relating to geometry or solids
• This is code golf, so shortest code wins.
• For no solids and invalid input, output nothing

Examples

In: 3 2 Out: <empty>
In: CodeGolf123 Out: <empty>
In: 12 6 Out (Bonus): {regular tetrahedron,unit equilateral square pyramid,unit equilateral triangular dipyramid,unit equilateral triangular prism,unit equilateral pentagonal pyramid,regular octahedron} Out (Regular): {regular octahedron} `

Answer 11

Code me music

Challenge

Write a program that will play music based on input.

Input

When your program is run it will be given a small song. Each note in the song will have 3 components:

[octave][pitch][duration]

where octave is the octave for the note to be played in, pitch is the key of the note (a b c d e f g), and duration is the length of the note in milliseconds. For example, 4c1000 would be middle c played for one second. Notes in a song are separated by spaces. Flats and sharps are possible, and they go after the note like this: 5gb1000 (5th octave g flat) for flats and 5g#1000 (5th octave g sharp) for sharps.

Output

Your program must produce sound based on the input. If one of the notes in the input is 3f500, your program must play f in the third octave for a half of a second.

Other notes

• This is code golf, so shortest program in (insert period of time) wins.
• No functions, only full programs.
• The sound can be whatever you please.

• Here are the frequencies of notes in the 4th octave in hertz:

  • 4c - 261.63
  • 4c#/4db - 277.18
  • 4d - 293.66
  • 4d#/4eb - 311.13
  • 4e - 329.63
  • 4f - 349.23
  • 4f#/4gb - 369.99
  • 4g - 392.00
  • 4g#/4ab - 415.30
  • 4a - 440.00
  • 4a#/4bb - 466.16
  • 4b - 493.88
• A list of all frequencies is here.

Sandbox

• Is the challenge objective clear?
• This challenge may be hard for some languages, is that a problem?
• Is this already a challenge?
• Any positive feedback is welcome.

Answer 12

Plan a special tournament

tags: code-golf [more tags required]

---

I host a special tournament with any number n >= 2 of participants.

Here is a list of plans of tournaments for n = 2 to 20:

 2: 1) DE-2c-1w
 3: 1) RR-3c-1w
 4: 1) DE-4c-1w
 5: 1) RR-5c-2w 2) DE-2c-1w
 6: 1) RR-6c-3w 2) RR-3c-1w
 7: 1) RR-7c-3w 2) RR-3c-1w
 8: 1) DE-8c-1w
 9: 1) RR-9c-4w 2) DE-4c-1w
10: 1) RR-10c-5w 2) RR-5c-2w 3) DE-2c-1w
11: 1) RR-11c-5w 2) RR-5c-2w 3) DE-2c-1w
12: 1) RR-12c-6w 2) RR-6c-3w 3) RR-3c-1w
13: 1) RR-13c-6w 2) RR-6c-3w 3) RR-3c-1w
14: 1) RR-14c-7w 2) RR-7c-3w 3) RR-3c-1w
15: 1) RR-15c-7w 2) RR-7c-3w 3) RR-3c-1w
16: 1) DE-16c-1w
17: 1) RR-17c-8w 2) DE-8c-1w
18: 1) RR-18c-9w 2) RR-9c-4w 3) DE-4c-1w
19: 1) RR-19c-9w 2) RR-9c-4w 3) DE-4c-1w
20: 1) RR-20c-10w 2) RR-10c-5w 3) RR-5c-2w 4) DE-2c-1w

Explanation of the plan

• The entire tournament enters the first round, which has c = n participants.
• For each round:
  • If c is a power of 2, then this round will be a double elimination round, with 1 winner. After this round, the tournament ends.
  • Else, this round will be a round robin round, with floor(c/2) winners that continue to the next round.
    • If only one winner continues, the tournament ends.
    • Else, let c be the number of winners, and start again from "For each round".

The Challenge

Given n, return a plan of the special tournament with n participants.

This is a code-golf, so shortest code wins.

TODO: Reword the explanation clearly, write more content.

Answer 13

Golf a 2d maze (Yes, a whole game)

Nowadays, I am interested in making games. especially mazes. In this golf round of code, You should make a maze game. You can do it with just preset mazes, but, if you make it randomly generate, I will be a-maze-d and will give you bonus points.(Huh. is that a pun?) So, Go on, Why don't you try right now?

DETAILS:

• Input W(Up), A(Left), S(Down), D(Right) until the player gets to the finish.
• Display the maze and the player each input.
• Move the player Up if the input is 'W', Down if 'S', Left if 'A', and Right if 'D'.
• The Character for the wall and the player is undefined. you choose.
• The Character for the wall, the player and the end square should be all different.

MAZE GENERATING:

• You should get the Width and height in the input.
• Not Necessary, but you can use Prim or Kruskal.
• Also you can use the method mentioned in here.

Answer 14

Light black box: generate mirror processors

code-challenge

[ WORK IN PROGRESS - LOTS OF OUTSTANDING QUESTIONS ]

---

Input

The list of black box output values for all black box input values from 0 to 255 (inclusive), in any reasonable format. Each value is also in the range 0 to 255.

Output

A text representation of a rectangular grid showing the locations and orientations of mirrors that will generate the appropriate black box output for each black box input.

Specification

• The input bits arrive from the left of the grid, in the top 8 squares, initially travelling right.
• The output bits depart from the right of the grid, in the top 8 squares, travelling right.
• For both black box input and black box output, the most significant bit is at the top.
• Bits move through the grid horizontally or vertically until they encounter a mirror or the edge of the grid.
• Bits that leave the edge of the grid are lost.
• A bit that would move onto a mirror at the next step instead changes direction by 90 degrees clockwise or anticlockwise according to the mirror type, and takes a step in that direction (a bit never stays on the same square).
• If two or more bits arrive on the same square at the same timestep, all of them annihilate. Two bits can still pass through each other if this does not involve sharing a square (traveling in opposite directions, being adjacent facing towards each other on one step, and adjacent facing away from each other on the next).

Note that because a bit changes direction just before reaching a mirror, there cannot generally be a mirror in an input or output square, as this would prevent the bit entering/leaving by that square. However, a grid taking advantage of input/output that has no requirement for a given bit by placing a mirror that blocks a given input or output square is still valid provided it gives the correct behaviour.

Example

[ PENDING ]

Scoring

The score for each input is the area of the resulting grid. The total score will be the sum of the scores for each of the test inputs.

---

Sandbox questions

• Is this too similar to domino circuits? The photons leave no trail so they can cross over their own and each other's paths arbitrarily many times. Also a given mirror can affect arbitrarily many photons, and each an arbitrary number of times.
• Is this a duplicate of anything else?
• Should the score be just the area of the grid, or also include the time between input and output? The time will have to be the worst case over all inputs, as reading the input before then would give a false result in some cases.
• Should output bits have to arrive at the same time?
• Should the time from input to output be required to be constant over all inputs?
• There cannot be more output bits than input bits. Should test cases reflect this, or should a mechanism be introduced to make all patterns of output possible?
• Should the particles be referred to as "bits", "photons", or something else?
• Currently tie break is first posted. Should the number of mirrors be taken into account as a tie break first?
• Should the grid wrap? I initially thought not, but then I realised there would need to be an extra row above the I/O rows to allow mirrors to redirect onto the top output bit. It might be simpler to keep to having the I/O rows at the very top, and simply put redirecting mirrors in the bottom row. This would make it possible to redirect onto rows 0 and 7 with only 8 rows in total.
• I've chosen mirrors that change the bit's direction just before impact, rather than on impact. I liked the fact that this gives an asymmetry - reversing the direction will not reverse the route taken. This introduces the potential for sending a bit back along part of the same path without trivially sending it back to its origin. Is there any reason to stick to the symmetrical case instead?
• The other thought that occurred to me was to have the mirrors change direction too, flipping between the two possibilities at each impact.
• There are 256**256 possible ways to assign a value from 0 to 255 to each of 256 different inputs. This is far too large a space for hardcoding all solutions. However, this doesn't necessarily mean that the worst case grids will be huge. A lower bound on the worst case grid area is log(256**256,3), which is just over 1292 (since there are 3 possible states for each square). The maximal lower bound is likely to be far higher than that, but I have no idea how much higher. I'm likely to settle on a small enough space that code can be expected to deal with any input, but still a large enough space that hardcoding is impossible (I don't want to explicitly rule it out). (Here ** indicates exponentiation, as used in python.)
• Mirrors that split bits, and bits annihilate on collision with each other. This will allow for arbitrary input and output rather than being restricted by the initial number of bits. I'm considering a number of possible approaches:
  1. One mirror type only: always splits a single bit into two bits in the two directions perpendicular to the current direction.
  2. 4 mirror types - each having a dead direction. A bit arriving from that direction is destroyed. A bit arriving from any other direction is split into two bits, one for each remaining direction.
  3. 4 mirror types - each having a dead direction. A bit is only split into two bits if the two perpendicular directions are not dead. Otherwise only one bit is produced, in the available perpendicular direction (or no bits if the bit approaches from the dead direction).
• Can bits be left in the grid that do not terminate? Can a solution specify that the output should be measured at a set time, even if some bits will later reach the output squares altering the result? Should the output only be measured once all activity has ceased - excluding the possibility of using a repeating cycle?

Answer 15

Find the duration of a worst-case brute-force attack

Given the following information about a 7-bit ASCII-encoded password and the computer that will crack it with a brute-force attack:

• Length of the password in characters
• Charset size (i.e total count of the possible characters one character in the password can be)
• Number of passwords the computer can test in one second millisecond (rounded down)

Write the shortest program that finds out how long the attack will take in the worst-case scenario where the computer tries all possible passwords.

• The output is the duration in this format: years months days hours minutes seconds milliseconds
  • One "month" is 30 days long.
  • Fractions of milliseconds are rounded up.
  • You can assume that the cracking finishes immediately if it takes less than 50 milliseconds, and make the program print out Instant in such cases.
  • Similarly, the cracking can be considered Neverending if it takes more than 292 billion years.
• The program can output using any method, from merely printing to STDOUT to causing a kernel panic/bluescreen with the duration as the error message.
• The input method to get the info about the password/the machine can be anything, as well. Don't use standard loopholes though.
• It's not enforced, but strongly encouraged to write a standalone program.

Here's how to calculate the charset size:

• Start with 0.
• If there's a digit (in the password), add 10.
• If there's a lowercase letter, add 26.
• If there's an uppercase letter, add another 26.
• If there's punctuation, add 32 (7-bit ASCII has this many punctuation characters).
• If there's a whitespace character, add 2. Whitespace characters are horizontal tab (0x09) and space (0x20).
• Any other character counts as non-printable (including backspace (0x08), DEL (0x7F), line feed (0x0A) and carriage return (0x0D)). Add 29 if there's any of them.

Count of all possible passwords is (charset size)^{password length}.

Here are some applicable-in-real-life cases you can test your program with (let's assume the computer that will crack them can test 1 billion passwords per second, which equals to 1,000,000 passwords/millisecond):

• 4 characters, charset size 10 (PIN) - 10,000 passwords, output is 0 0 0 0 0 0 1 or Instant
• 8 characters, charset size 94 (at least one uppercase letter, one lowercase letter, one digit and one punctuation) - 6,095,689,385,410,816 passwords, output is 0 2 10 13 14 49 386
• 10 characters, charset size 2 (weakest valid Discourse password, contains whitespace only) - 1024 passwords, output is 0 0 0 0 0 0 1 or Instant
• 25 characters, charset size 26 (correcthorsebatterystaple) - 236,773,830,007,967,588,876,795,164,938,469,376 passwords, output is 7612327353651221350 2 14 0 26 4 939 or Neverending
• 127 characters, charset size 96 (strongest password on newer Windows releases) - written below
• 1024 characters, charset size 36 (4096-bit PGP key represented as a hexadecimal number) - written below

These are the stats of the maximum-strength Windows password:

Passwords: 560,333,510,486,846,899,384,847,242,571,130,277,659,458,884,466,874,695,582,912,274,460,529,559,443,783,341,570,989,525,270,653,136,186,432,110,439,597,936,820,880,106,519,625,601,191,574,799,863,912,148,304,962,133,852,037,202,160,056,511,510,962,873,278,300,126,526,144,267,006,137,180,032,492,751,016,171,207,701,495,935,943,049,216
Output: 18014837657113133339276210216407223432981574217685014647084370963880194169360318337544673523362047845500003550655797865897637169483847774934889398916928636347805229296463546812516445182705545212838429981490065783731353925307067135133992 5 15 19 58 55 944
Alternate output: Neverending

And these are the stats of the PGP key:

Passwords: 4,505,684,579,918,576,285,346,738,866,335,056,898,110,301,685,668,199,078,230,938,179,212,682,315,156,231,410,185,391,761,603,272,976,014,035,539,665,517,248,679,228,261,440,294,129,198,036,262,705,242,310,399,830,546,082,361,923,420,737,260,766,677,891,361,176,003,624,143,368,380,527,062,643,297,677,246,518,686,688,642,023,537,863,317,793,178,302,508,440,097,154,593,959,832,175,055,427,351,149,410,096,495,695,380,712,810,868,774,475,142,767,054,868,274,802,269,522,299,482,066,464,842,097,715,922,988,138,315,118,067,288,670,934,735,264,524,936,706,249,961,394,413,647,964,221,767,703,673,264,468,419,121,528,644,906,680,808,060,759,817,669,970,046,776,525,266,199,099,671,937,918,801,013,826,958,891,378,841,908,663,991,372,649,027,188,879,525,186,690,599,345,723,173,064,252,017,258,129,131,786,488,462,307,158,861,824,049,980,863,991,149,295,162,169,512,952,373,415,599,734,988,691,348,925,488,351,712,593,858,837,027,205,238,618,188,975,201,320,681,214,515,875,812,195,250,605,867,622,987,451,763,883,339,709,733,502,125,838,221,788,546,339,051,347,360,900,518,381,976,167,289,930,943,228,024,924,785,158,428,496,314,937,921,503,359,298,542,415,845,218,449,360,806,235,379,253,546,728,753,218,950,843,742,471,105,739,555,344,908,900,309,982,913,223,331,321,839,212,821,903,239,320,600,564,890,951,140,667,647,680,682,245,252,370,183,758,578,065,733,075,207,856,432,661,797,090,351,101,165,469,273,829,754,476,555,209,675,613,232,875,323,406,611,257,057,059,099,019,633,298,079,410,970,345,108,939,943,042,100,267,260,413,671,556,828,411,902,575,269,208,445,279,433,655,878,082,023,068,697,154,581,711,817,787,688,949,105,583,339,471,599,190,831,084,304,744,483,799,555,478,063,729,574,297,623,870,804,763,558,027,580,772,927,971,329,879,231,979,556,301,616,929,595,576,646,883,067,201,999,872,899,862,889,211,861,332,535,050,455,387,251,034,043,732,447,006,164,551,883,918,733,705,027,099,846,583,024,013,092,062,384,703,436,459,115,108,358,829,136,251,317,699,709,899,140,949,893,425,335,769,021,022,912,434,045,643,544,474,460,899,799,213,759,568,795,794,758,914,390,056,283,305,470,380,859,003,818,724,678,434,816
Output: 144858686339974803412639495445442930108998896787172038266169565946909796654971431654622934722327449074525319562291578211137739886840732034401886018044055761311424449664413690224320369299057721231224396352345948448015131278860508182828147139982752631922511354755096078964028889980704480936709984283352948061204198196785328857204061945957268141550998891534834171375541476907019128991072373909056348731183618329634024763694746476776233417623704464804027405450152026906721990999895827471385353870130056140660354679074035526421905828555132520211676677361401337091034117370453939870215183392876069255694823382473711006907851853458746913295694931911314073828877816349504523255816791677974298928074750103049081088894521647398444396729546431174466495229648516324713327536964168664025148591452750098101445502202880078966283755495859954505040675103796820824907455740718188735077328268047865426806174561044520100917915500979652319301547868727504821981520811835192875926630119576922600465887060849654310721522802609638109522185755307201898676461606130734024600227278608209698963323356340446015796148617903068964091403666193996894642822309315198786075754477250953946657292049336910661279747924178751224344877465829301109562043071275369906871767991229129085786546569052197642684662087651029574035646976531236521763373563846425925268656816387911380422031991615290633773786744123323731112880994579065426763237282889858685438654794679302568796507941872848896038602862540480809810919146613018187362072374644736799940064590439265446053422181856817801562474722208358918298576208528044087753034364036 10 24 22 32 4 679
Alternate output: Neverending

code-golfcryptographydate

Answer 16

Implement an HTTP Tunnel

I'm bored at work and stuck behind a draconian proxy.

They can take my other ports but they can never take my port 80 freedom!

Help me get all the internets!

This is a code-golf challenge.

requirements

• a single web page that processes GET and POST data and produces output
• if GET m=start
  • creates any files you feel are necessary (named pipes, scripts, what-have-you)
  • forks a process which will create a tcp connection
  • connects to host and port based on GET variables h and p
  • these variables should be cleansed so as not to allow command injection
• if GET m=in
  • write the raw POST data to your forked process's tcp connection
• if GET m=out
  • get all data available from the forked process's tcp connection and write as response
  • should always return right away (let's say, in less than 1 second)
• if GET m=stop
  • kill your forked process
  • clean up any files it has created

Test data

• http://servername/httptunnel?mode=start&host=ppcg.ga&port=80
• http://servername/httptunnel?mode=in
  • POST data: GET / HTTP/1.1\r\nHost: ppcg.ga\r\n\r\n

• http://servername/httptunnel?mode=out

  HTTP/1.1 301 Moved Permanently
  Server: nginx
  Date: Tue, 07 Jun 2016 02:03:14 GMT
  Content-Length: 0
  Connection: keep-alive
  Cache-Control: no-cache
  Expires: Thu, 01 Jan 1970 00:00:01 GMT
  Location: https://codegolf.stackexchange.com/
  Pragma: no-cache
  

• again, to prove the connection is still open, http://servername/httptunnel?mode=in

  • POST data: GET / HTTP/1.1\r\nHost: ppcg.ga\r\n\r\n
• and again, http://servername/httptunnel?mode=out
  • Content returned: same as before
• http://servername/httptunnel?mode=stop
  • system state returned to prior to the first http call

my first instinct was to have this challenge be three separate pieces of code, a client which listens on a port locally and interacts with the web page, the web page itself, and a script which will be forked by the web page. your score would be the sum of all their byte counts. i decided to remove the last as the start process would likely have to create other files so why not have it create the script to run as well, and decided to remove the first option as well to make it nice and even.

is this a feasible challenge? i will add more explanations and test data soon i think. adding my own client would probably be helpful

Answer 17

Code Golfed Rosetta Code Code Golfer

code-golf (any others? maybe metagolf, optimized-output and/or code-challenge)

Browsing examples on the Rosetta Code site, I can't help but think that all the code is just so long-winded, inefficient and ...well, readable. Something needs to be done.

Challenge

Choose a language, then write a function that takes the example source code, in the same language, for specific tasks on Rosetta Code and returns a golfed version of that code.

Winner is the person who can golf the example tasks the most. However, this is a code golf challenge so the length of your own source matters too.

Rules

1. Write a function in your chosen language that takes a string as input and returns a string as output (or equivalent - reading/writing to stdio or file, etc is also ok)
2. Input is the source code implementation, in your chosen language, of the following three specific tasks as shown on Rosetta Code (your function runs three times, once for each):
   • Quicksort
   • Happy numbers
   • Greatest common divisor
3. Output is a code golfed version of the input with identical functionality (again in the same language)
4. If there is more than one implementation of a task for a specific language, you must use the first listed
5. If your chosen language doesn't have an implementation for one of the tasks, then you need to add it yourself (following the Rosetta Code rules - don't go messing up their site just to get a better score here)
6. With the exception of the rule above, you may not, in any way, modify the content or order of examples on Rosetta Code
7. You must leave the logical flow of the algorithm mostly intact (eg. you can't simply replace the J quick sort code with /:~)

Scoring

Score for each individual task is calculated as the output character count as a percentage of the input character count. Implementation score for your own code is simply its character count. Total score for a submission is the sum of the three task scores, plus the implementation score.

Submission with the lowest score wins.

So, assuming your function is 100 chars long and running it against the test tasks gives you the output counts shown, your overall score would be calculated as follows:

 Task      | Input char count | Output char count | Score
-----------+------------------+-------------------+--------
 Quicksort |            600   |            400    |  67%
 Happy Nos |            400   |            200    |  50%
 GCD       |            200   |            150    |  75%
--------------------------------------------------+--------
 Implementation score:                            |  100
--------------------------------------------------+--------
 Overall score:                                   |  292

---

Things I'm not sure about...

Before I post this as a challenge, it would be good to get input on a few things:

• Will the "if your language doesn't have an implementation" rule cause problems, or can people be trusted to provide sensible implementations that follow the intent of Rosetta Code and don't simply artificially improve their score on the challenge? Is it better just to deny entries from languages which don't already have implementations?
• With scoring, obviously it's a balancing act, a really terse language will likely get a solid "implementation" score, but should be less able to improve the length of the examples, whereas a verbose language will be the opposite. So, the having too few "tasks" included in the challenge will benefit terse languages, and too many will benefit verbose languages. I want to find a middle ground, so does three tasks seem reasonable?
• Will someone just find an edge case language which has a really easily golf-able Rosetta example, that will make it unbeatable?

Answer 18

Distance between two words

You are given an input of two strings consisting entirely of letter characters. The "distance" between two such strings is the number of operations from the following list that it takes in order to transform one word into the other:

1. Adding a letter anywhere
2. Removing a letter anywhere
3. Changing a letter's case

Since your boss wants to avoid wear on the office keyboards as much as possible, you have to write a very short program to determine the distance between words so you can fix the typos.

Answer 19

Cross Validated

code-golf ascii-art

(This challenge is almost complete, but something doesn't feel quite right)

Continuing the theme of using site names as challenges...

Your task

Write a program or function that accepts a string, and prints out the location, size, and validity of each cross in the string.

Definitions

• Valid Cross- A cross where all four spokes of the cross are equal in length. The size of the cross is the number of segments of each cross.

Valid, size 0:

+

Valid, size 3:

   |
   |
   |
---+---
   |
   |
   |

• Invalid cross- A cross where one or more spoke is a different length. The size is the number of segments of the longest spoke.

Invalid, size 2:

 |
 |
-+--
 |

Invalid, size 6:

+------

Rules

• Each input will have one or more crosses.
• The program should print out the location of the center of each cross. The location is zero-indexed and measured in characters/lines from the top left.
• The size and validity, as defined above, of each cross should be printed out.
• Each test case must pass without printing to STDERR.
• Crosses will not overlap
• Your program can take input via a string (with line breaks), an array of strings (each representing a line), or a 2d array of characters.
• This is code-golf so shortest program, in bytes, wins

Test Cases

+ +-

(0,0) size 0, valid

(2,0) size 1, invalid

   |
   |     |
   |     |
---+---  |
   |     |
   |  ---+
   |

(3,3) size 3, valid

(9,5) size 4, invalid

(empty test case)

(must not crash or print to STDERR)

Answer 20

This question isn't fair.

I want you to tell me the chances of flipping an coin n times and ending up on tails.

Naturally this isn't a fair coin. In fact, it isn't even a standard unfair coin, where the chance of flipping tails is always p. This is a sticky coin, where the chance of the coin staying the same is p; the coin is fair at other times.

The coin starts off heads, so when n is 0 or p is 1 then the answer is always 0.

Your program or function should be capable of calculating the result to at least six significant digits.

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

Answer 21

"Optimize" a RegEx

code-golf

Introduction

Inspired by atrociously large regex's like

/[0-9A-Za-z!@#$%&*()_\-+={[}\]|\:;"'<,>.?\/\\~`]+[0-9A-Za-z!@#$%&*()_\-+={[}\]|\:;"'<,>.?\/\\~`]*/g

I propose a code-golf challenge to create a string representing an optimized and sorted regex from an input string of characters expected to be matched.

Rules

• only printable ASCII characters with code points 32 - 127 need to be supported:

 !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~

The RegEx output string should:

• Group 3 or more consecutive code points in the input string together like begin-end
• Sort the characters and groups in order of ascending code point
• Escape the literal character - to \- to differentiate it from a range

The RegEx output string should not:

• Escape the characters !$()*+./=?[\]^{|}
• Support any RegEx escape sequences like \w, \d or \s

Examples

Input:
helloworld
Output:
dehlorw

Input:
fedcabXZYVWU
Output:
U-Za-f

Input:
q0`p[|iOf(oc61TSr4dVwQ8m;%YDAPM*a/2j&h~u}
Output:
%&(*/-2468;ADMO-QSTVY[`acdfh-jmo-ruw|-~

Just so people can see what the last one's pattern is, here are the ASCII indices:

37,38,40,42,47-50,52,54,56,59,65,68,77,79-81,83,84,86,89,91,96,97,99,100,102,104-106,109,111-114,117,119,124-126

Spoiler Alert

Example implementation in JavaScript ES6:

f=s=>[...s] // spread string into array
  .sort() // sort array by ASCII indices
  .map(
    c=>c.charCodeAt() // convert each one to ASCII index
  ).reduce( // reduce sorted indices
    (p,c)=>(
      ~p[0][0]+c? // if last index is not one less than current index
        p.unshift([c]): // then start new run with this index
        p[0].unshift(c) // else continue existing run
      ,p
    ),
    [[]] // start reduce with empty run
  ).map( // map array of runs
    a=>(
      (
        a=a.map( // map each run
          n=>( // convert index back to ASCII
            c=String.fromCharCode(n),
            c=='-'? // if '-'
              '\-': // then escape it
              c
          )
        ),
        a.length>2? // if run has more than 2 indices
          [a[0],'-',a.pop()]: // keep only the begin and end
          a // else keep whole run
      ).reverse().join`` // reverse and join run
    )
  ).reverse().join`` // reverse and join array

Answer 22

Exercise your kids

I want you to output the nth verse of this kid's exercise song:

Head, and shoulders, knees and toes, knees and toes,
Head, and shoulders, knees and toes, knees and toes
And eyes and ears and mouth and nose,
Head, and shoulders, knees and toes, knees and toes.

Each verse is the same as the previous except that all occurrences of one word is masked by replacing it with a dash (you can use a two-byte dash of your choice) wherever it appears in the verse. The words are replaced in order however the word "and" is never replaced, therefore the next verse should look like this:

—, and shoulders, knees and toes, knees and toes,
—, and shoulders, knees and toes, knees and toes
And eyes and ears and mouth and nose,
—, and shoulders, knees and toes, knees and toes.

Also, the last verse should look like this:

—, and —, — and —, — and —,
—, and —, — and —, — and —
And — and — and — and —,
—, and —, — and —, — and —.

Your answer should specify whether n will range from 0 to 8 or 1 to 9.

code-golf kolmogorov-complexity

Answer 23

Calculate the Average Squared Error

Given a line y = mx + b and a set of n points (x_i, y_i), find the average square error between the given line and each set of points.

Your goal is to create a function or program that given the values m, b, and the set of points (x_i, y_i), outputs the average square error according to the formula above.

Rules

• This is code-golf so the shortest solution wins.
• Builtins that compute this value are not allowed. This includes builtins that compute a result which is a scaled value of this.
• Floating-point inaccuracies will not be counted against you.

Test Cases

tba

Answer 24

Index sum and strip my matrix

Given a matrix/2d array in your preferable language

Input:

• The matrix will always have an odd length
• The matrix will always be perfectly square
• The matrix values can be any integer in your language (positive or negative)

---

Example:

1  2  3  4  5  6  7
2  3  4  5  6  7  8
3  4  50 6  7  8  9
4  5  6 100 8  9  10
5  6  7  8 -9  10 11
6  7  8  9  10 11 12
7  8 900 10 11 12 0

---

Definitions:

• The "central number" is defined as the number that has the same amount of numbers to the left,right,up and down

In this case its middlemost 1000

• The "outer shell" is the collection of numbers which their x and y index is or 0 or the matrix size

---

1  2  3  4  5  6  7
2                 8
3                 9
4                 10
5                 11
6                 12
7  8 900 10 11 12 0

Your task:

Add to the central number the sum of each row and column after multiplying the values in each by their 1-based index

A single row for example

4  5  6  7  8

for each number

number * index + number * index.....

4*1 + 5*2 + 6*3 + 7*4 + 8*5 => 100

---

example:

 2 -3 -9  4  7  1  5  => 61
-2  0 -2 -7 -7 -7 -4  => -141
 6 -3 -2 -2 -3  2  1  => -10
 8 -8  4  1 -8  2  0  => -20
-5  6  7 -1  8  4  8  => 144
 1  5  7  8  7 -9 -5  => 10
 7  7 -2  2 -7 -8  0  => -60
                         |
78 65 60 45 -15 -89 10   => 154
                     |
                     => -16

• For all rows and columns you combine these values..
• Now you sum these too => 154-16 = 138
• You add that number to the "central number" and remove the "outer shell" of the matrix

---

 0 -2 -7 -7 -7     => -88
-3 -2 -2 -3  2     => -15
-8  4 1+138 -8  2  => 395
 6  7 -1  8  4     => 69
 5  7  8  7 -9     => 26

19 69 442 30 -26

do this untill you end up with a single number

-2 -2 -3     => -15
 4  1060 -8  => 2100
 7 -1  8     => 29

27 2115 5

• Add 2114+2147 to 1060
• Remove the "outer shell" and get 5321
• Now we have a single number left

this is the output!

test cases:

-6

-6

---

-7 -1  8
-4 -6  7
-3 -6  6

2

---

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

-365

---

 8  3  5  6  6 -7  5
 6  2  4 -2 -1  8  3
 2  1 -5  3  8  2 -3
 3 -1  0  7 -6  7 -5
 0 -8 -4 -9 -4  2 -8
 8 -9 -3  5  7  8  5
 8 -1  4  5  1 -4  8

17611

---

-9 -7  2  1  1 -2  3 -7 -3  6  7  1  0
-7 -8 -9 -2  7 -2  5  4  7 -7  8 -9  8
-4  4 -1  0  1  5 -3  7  1 -2 -9  4  8
 4  8  1 -1  0  7  4  6 -9  3 -9  3 -9
-6 -8 -4 -8 -9  2  1  1 -8  8  2  6 -4
-8 -5  1  1  2 -9  3  7  2  5 -6 -1  2
-8 -5 -7 -4 -9 -2  5  0  2 -4  2  0 -2
-3 -6 -3  2 -9  8  1 -5  5  0 -4 -1 -9
-9 -9 -8  0 -5 -7  1 -2  1 -4 -1  5  7
-6 -9  4 -2  8  7 -9 -5  3 -1  1  8  4
-6  6 -3 -4  3  5  6  8 -2  5 -1 -7 -9
-1  7 -9  4  6  7  6 -8  5  1  0 -3  0
-3 -2  5 -4  0  0  0 -1  7  4 -9 -4  2

-28473770

Answer 25

White Water Rafting

code-golfpath-findinggraphsgrid

---

This problem is about finding the best path through a bunch of rocks on a 5-column wide river, without crashing your raft. A river looks like this (* reprsents a rock):

. . . R .
. R . . .
R . . . .
. . R . .
R . . . .
. . . . R

Each row will contain exactly 1 rock, no more, no less. Your raft can start on any space without a rock.

You can't maneuver your raft too much, so as you travel down the river, there are only 3 next places you can go (x is the next space):

. . @ . .
. x x x .

If there is a rock in your way, you can't go there. Your raft can't fit through rocks that are diagonally adjacent to each other. You can't beach your raft either. Finally, you can't go anywhere that would result in you crashing your raft.

@ . . . .
R x . . .   <- Can't go on rock, can't go oob

R . . . .
. R @ . .
. . R X .   <- Can't go through diagonal rocks

. @ . R .
. R x . .   <- Can go through non-adjacent diagonals,
R . . . .      Can't go to dead end.

Because you don't have much space on the raft to write this code, shortest code wins.

Test cases:

Input:

. R . . .
. R . . .
. . . R .
. . . R .
R . . . .

Output:

R x . . .
. R x . .
. x . R .
x . . R .
R x . . .

Input:

R . . . .
R . . . .
R . . . .
R . . . .
R . . . .

Output:

R x . . .
R x . . .
R x . . .
R x . . .
R x . . .

Input:

. R . . .
. R . . .
. R . . .
. R . . .
R . . . .

Output:

. R x . .
. R x . .
. R x . .
. R x . .
R x . . .

Input:

. . . . R
. . . R .
. . R . .
. R . . .
. . R . .

Output:

x . . . R
x . . R .
x . R . .
x R . . .
x . R . .

Input:

. . . . R
. . . R .
. . R . .
. R . . .
R . . . .

Output:

[nothing] or [empty/blank array/matrix]

Notes:

• Input can be in array of indexes, array of truthy/falsey values, or any other input format most comfortable to your language.
• Output should indicate the left-most valid path.
• Output can be in array of indexes, array of truthy/falsey values, or any other input format most comfortable to your language.
  • Output does not have to be in the same format as input.
  • Output nothing/(empty/blank) (array/matrix) if there is no valid path
• Standard loopholes are forbidden by default.

---

This is my first challenge, so please let me know if I have left anything out or something is unclear.

---

Related problems

• Follow incomplete directions
  • Has more obstacles, directions are given
• How varied is my obstacle course?
  • About finding paths through an obstacle course
• Grid-Routing Battle
  • Similar graph structure

I couldn't find any dupe targets looking through grid, so I'll look again in graphs and path-finding later.

Answer 26

Cypher-o-mania!

The year is 19XX.

You are a spy of some distant country, and your job is to send messages across the globe.

Unfortunately, because, frankly, you suck at being a spy, you need a way to obfuscate your information, so that when the opposition catches you (which they will), they won't know what the heck is written.

How are you going to do this?

Your task is, using two inputs (the first input the encoding "cypher" and the second the message), encode the message.

This is how the encoding works:

• The message only consists of the lowercase letters and the numerals.
• Because there are 36 different characters in total, we will convert each individual letter of the message to "base 9" (a = 00, b = 01, c = 02... 8 = 37, 9 = 38). This will be called the FSO, or First-Stage Obfuscation.
  • For example, the message hello1 would then be translated to 07 04 12 12 15 28.
• Each individual "bit" of the FSO is then stripped of its first part. This will be known as the SSO, or Second-Stage Obfuscation.
  • The example 07 04 12 12 15 28 is then translated to 7 4 2 2 5 8.
• This is where the encoder comes in handy! The encoder will consist of a string of numbers 0 to 3 (e.g. 1212003).
• You then add to the start of each digit of the encoder to the corresponding digit of the SSO. This is now the TSO, or Third-Stage Obfuscation.
  • The example 7 4 2 2 5 8 with the encoder 1212003 is then converted to 17 24 12 22 05 08.
  • With a shorter encoder (say 121), this step will "wrap around", so 7 4 2 2 5 8 with the encoder 121 will end up with 17 24 12 12 25 18.
• We then change the TSO back into readable characters, using the same "base 9" method.
  • The two examples 17 24 12 22 05 08 and 17 24 12 12 25 18 will be converted to QWLUEI and QWLLXR respectively.

So, in summary:

Encoder: 121

Message: hello1

hello1 => 07 04 12 12 15 28 => 7 4 2 2 5 8 => 17 24 12 12 25 18 => QWLLXR

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

META

• This is really confusing, and I don't really know how to phrase the "how the encoding works" bit better. Can anyone help me phrase this better? I can offer clarification on certain things if needed.

Answer 27

Regex golf: Match the Thu'um-s

code-golf regex

Introduction

Skyrim is a game made by Bethesda and came out in 2011. One of the objectives of the game is to collect every 27 shouts (or Thu'um-s). In this challenge, you need to match every shout and nothing else.

Shouts

This is the list of the available shouts in the game:

Raan Mir Tah
Laas Yah Nir
Mid Vur Shaan
Feim Zii Gron
Gol Hah Dov
Od Ah Viing
Hun Kaal Zoor
Lok Vah Koor
Ven Gaar Nos
Zun Haal Viik
Faas Ru Maar
Mul Qah Diiv
Joor Zah Frul
Gaan Lah Haas
Su Grah Dun
Yol Toor Shul
Fo Krah Diin
Liz Slen Nus
Kaan Drem Ov
Krii Lun Aus
Rii Vaaz Zol
Tiid Klo Ul
Strun Bah Qo
Dur Neh Viir
Zul Mey Gut
Fus Ro Dah
Wuld Nah Kest

Additionally, every shout can have 3 levels depending on what the player collected so far, each level adds a new word to each shout, so you need to be able t match the separate words without the full shout.

The words need to be uppercase. A shout should only be matched, if it is a separate word, for example: Golf shouldn't be matched.

The separate words for the same shout in the order as in the list appear next to each other, then they need to be in the same match.

The input strings will only contain ASCII letters and spaces as word separators.

Test cases

The matched text is bold

Hydrogen Sulphur Krah Coal Gaan Lah Haas

one two three four Kaal six seven Joor Zah Frul eleven

red green blue Gol Hah orange purple Qo violet

Ran Miir Taah Raan Mir Tah raan mir tah

Golf Gol Middleage Mid

Rules

• The answer should be a .NET type RegEx and should not contain any other langauge.

• This is a code-golf, so the shortest answer in bytes wins

Answer 28

Find all the Vampire numbers

Shamelessly stolen from https://stackoverflow.com/q/17352108

A "Vampire" number is defined as the product of two numbers of equal length (known as the "fangs") that uses the same digits as the two numbers being multiplied. Examples:

21 * 60 = 1260
15 * 93 = 1395
30 * 51 = 1530

Your task is to find all the Vampire numbers whose fangs have n digits.

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

Answer 29

Title TBD - Generate Emoticons :)

code-golf kolmogov-complexity

Your task is to create a program that generates the most emoticons using the least amount of code.

Rules

• The only valid emoticons are listed on Wikipedia, under the heading Western/horizontal emoticons: List of emoticons page (version 722951221)
• The output can be any format, as long as a delimiter exists between emoticons.

Scoring

• Scores will reflect the character (not byte) count.
• For every emoticon after 10 that is output by your program, subtract 1 from your score. Emoticons over 20, subtract 2, over 30 subtract 3, and so on.

Sandbox

Is the scoring fair/reasonable? Should I edit down the list/create a new list of acceptable emoticons?

Answer 30

Forecast Romantic Dates

code-golf date

Sort of inspired by this.

A Romantic date is a date that, when the year, month and day are converted to Roman Numerals the individual values contain no more than two symbols. For example, in YY-MM-DD format: the Romantic date 20-04-15 would become XX-IV-XV.

For the purpose of this challenge, years will only be tracked by the two least significant digits of the year, as otherwise the last Romantic date was in the 15th century. In addition, they wouldn't add much to the challenge as the omissions of the leap year every 400 years is irrelevant, as February the 29th is not a Romantic date.

Romantic dates

For your convenience, here is a list of all of the two digit numbers that can be represented with two or fewer symbols in Roman numerals:

[1, 2, 4, 5, 6, 9, 10, 11, 15, 20, 40, 50, 51, 55, 60]

These were determined using the "standard method" that negative groups would only be used with the symbols that are powers of ten and only on the values that are five or ten times that symbol's value. So I only combines with V and X for example.

Dates which include only numbers from this list are Romantic dates. For the purpose of this challenge, assume an ideal Western calendar: no dates are ever skipped or repeated, 12 months per year, and more than 20 days per month. Assume there is no year, month or day zero (i.e. year 99 loops to 1 not to 0).

Task

Given a date as input, output that date if it is Romantic, or output the next Romantic date.

Input and Output

You may accept input in any consistent ordering of year, month and day with any consistent separator. You may specify if the input should have the numbers padded to be two digits. If the numbers are padded, you may choose to have no separator. Your output must have the same form as your input.

Test Cases

The following test cases are all in the format YY MM DD, with no padding.

1 1 1 => 1 1 1
20 4 3 => 20 4 4
15 7 1 => 15 9 1
51 9 7 => 51 9 9
70 9 7 => 1 1 1
20 6 24 => 20 9 1
47 12 1 => 50 1 1
60 11 24 => 1 1 1

Here is the script that I used to generate these.

Sandbox

Did I miss any Romantic numbers? I just did that by hand.

Allow unary? I'm unsure about this because it sort of violates the reasoning behind Romantic dates for the values to have >2 symbols...

Should I explain more about parts of dates that are not useful? For example, the length of the months is entirely irrelevant as the later days are all skipped. My concern is that the current one feels clunky already

Should I allow both outputting the input if the date is already Romantic or the strictly next Romantic date (as long as it is consistent)? There doesn't seem to be much different, but I don't know if that'd be too broad? Personally leading towards allowing it.

I'm also somewhat tempted to make use of the silly title a bit more, but I'm not sure if that'd be going overboard.

Too boring / compression based? I've particularly been trying to think of a way for fewer results to wrap back around to 1.