# What is the Sandbox?

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

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

## Get the Sandbox Viewer to view the sandbox more easily

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

# Analyze the flow

Posted

• From the example, it looks like the path can wrap around the edges of the grid. I think you should mention that explicitly. I also think you should define "tributary" – math junkie May 11 at 21:27
• Yes, you can wrap around and this is the only reason why I use a toroidal grid. I've added the definition of "tributary"... I know it's still informal but I don't want to lose readability, I've tried to go more formal but the need of a lot of definitions arises. Is it still unclear? – Domenico Modica May 12 at 0:36
• @math junkie anyway thanks for the grammar corrections, also in the main post :D – Domenico Modica May 13 at 19:42

Any improvements/advice is most welcome, just comment!

Because the coronavirus is still at large, I thought it would be fitting to have a epidemic-themed challenge.

## Challenge

You are given a 2D array of people, where 1 represents someone with the virus, and 0 represents someone without the virus. Every day, the people with the virus infect their neighbours. You must calculate, given such a grid, how many days it will take to infect the population (i.e., every item is 1).

## Rules

• The input counts as Day 0, and every day after increases by 1
• The grid items don't have to be 1s and 0s, they can be any similar values (e.g., true and false). Every item in the grid is randomized (50/50) to one of those values.
• The grid can be any size between 2x2 and 100x100. The grid does not have to be square. The grid size is randomized.
• Diagonal squares do not count as adjacent
• This is , so the shortest answer wins!

## Examples

[[1, 0, 0, 0, 1],  # Input
[0, 1, 0, 0, 0],
[0, 0, 0, 0, 0],
[0, 0, 0, 1, 0]]

[[1, 1, 0, 1, 1],  # Day 1
[1, 1, 1, 0, 1],
[0, 1, 0, 1, 0],
[0, 0, 1, 1, 1]]

[[1, 1, 1, 1, 1],  # Day 2
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1],
[1, 1, 1, 1, 1]]

output = 2

[[1, 0],  # Input
[0, 0],
[0, 0]]

[[1, 1],  # Day 1
[1, 0],
[0, 0]]

[[1, 1],  # Day 2
[1, 1],
[1, 0]]

[[1, 1],  # Day 3
[1, 1],
[1, 1]]

output = 3


Bonus challenge: You could try to return the indices (across,down) of the people infected each day, e.g. for the example above the output could look something like:

output = {
days: 3,
indices: [
[[1,2], [2,1]],
[[2,2], [1,3]],
[[2,3]]
]
}


The game of scrabble is played by placing lettered tiles on a grid to form words. The words being formed must read from left to right, or up to down on the grid. The words must appear in the official Scrabble dictionary, and all letters placed on the grid must be part of a valid word. This challenge will focus on a specific technique for playing a simplified version of Scrabble.

A useful technique when playing Scrabble is to add a single letter to an existing word that is already on the board to form a new word. Write a program or function that, when given a dictionary, finds the longest series of words that can be formed by adding a single letter to another word to form a new word.

## Example

You are given the following dictionary:

at
ate
rate
elate
crate
belate
belated


['at', 'ate', 'rate', 'crate']


An invalid output would be:

['at', 'ate', 'elate', 'belate', 'belated']


because 'elate' cannot be formed by adding a single letter to 'ate'.

Note that this challenge is not about finding the longest word that can be formed by adding a single letter to another word, but about finding the longest chain of words that can be formed in such a way. Which means that this answer:

['elate', 'belate', 'belated']


is wrong, because it only has three steps, whereas the first example has four.

## Winning Criteria

Code-golf, so shortest code wins. I/O is flexible. Standard loopholes apply. Take dictionary as a list, file, delimited string, or whatever you want. Output can be sent to stdout, returned as a single string (with delimiter), or list of strings.

TODO

# Uniform necklace sampling code-challengerandom

The challenge is, given a number $$\N\$$, to produce a random binary necklace of length $$\N\$$. All possible necklaces must have the same probability of being chosen.

## Scoring

Solutions are compared first by asymptotic memory complexity in $$\N\$$ (lower is better), and, in case of a tie, by size (lower is better).

## Sandbox stuff

(I do intend to use code-golf as only a tiebreaker)

• How to tag this question the most correctly?
• Not time complexity? It's trivial to do this in O(n) memory (I think that is optimal, because (as far as I know) it's not possible to (deterministically) check if a string is a necklace in less memory) by iterating over all necklaces, count number of those = C (C can be represented in N bits), generate a random number x in the range 1..C, then count again and pick the xth necklace. – user202729 May 27 at 4:10
• @user202729 I tried to pick a combinatorial object that prevents a linear-memory solution (any suggestions?). I guess these answers should win (with [code-golf] used to compare them - this is mostly [restricted-memory] code-golf, but submissions that aren't good enough aren't disqualified). – my pronoun is monicareinstate May 27 at 6:44

# Solve some diplomatic issues

You are given a set of moves in a theoretical Diplomacy game. We're not going to handle validation of moves being legal or not, simply attempt to resolve a turn.

Here are the simplified rules to Diplomacy (full rules here):

• There are two types of units: Armies and Fleets. Armies can only move on land, Fleets on land and in the sea. You can safely ignore this, because we're assuming that all of the moves you've been given are at least theoretically valid.
• There are four types of moves: Hold (stay in place), Move, Support (a certain other unit), Convoy.
• When two or more units end up in the same country, whichever unit has the most support stays. Each unit without the most support (or each unit tied for the most) returns to its original country. A unit which is not Moving and which is not tied for the most support is Dislodged.
• A Fleet can Convoy an Army through its space to another space. That convoy is cancelled if the Fleet is Dislodged. Only a Fleet in a sea space can Convoy.
• A unit can support another unit holding or moving into an adjacent country if it can move into that country (Armies can't Support Fleets in the sea).
• A supporting unit which is attacked ceases to support, unless it is supporting an attack on the unit attacking it. If it is dislodged, it ceases to support in any case.
• The Beleaguered Garrison rule: If a unit is attacked by two units with the same amount of support, the attacked unit is not Dislodged, and the attackers return to their original countries.

You will receive a list of moves. Each move will be in the following format:

Power Unit_type Origin_country Move_type Destination_country


There is no Destination_country if a unit holds (or you can insert a placeholder). Destination_country for Support or Convoy is the Origin_country of the unit being Supported or Convoyed. For example, you could get:

E F Eng M Pic
F A Pic H
G A Bel S Eng


This means:

English Fleet in the English Channel Moves to Picardy
French Army in Picardy Holds
German Army in Belgium Supports the Fleet in the English Channel to Move to Picardy


Your output should be the location of each unit after the move. Any Dislodged unit should be marked as such.

# Output format:

Power Unit_type Country Dislodged?


For the example given above, the output should be:

E F Pic
F A Pic D
G A Bel


The more difficult part of this is in regards to convoys. A convoy fails if there is no valid path for the army to take. For instance, if we have:

E F Nth C Den
E A Den M Hol
F F Eng M Nth
F F Bel S Eng


The French fleets dislodge the English Fleet in the North Sea, and the convoy does not take place. But if we also had

E F Hel C Den


There would still be a valid path for the English Army and the convoy would succeed.

Be warned, there are paradoxes in Diplomacy. These are to be treated as undefined behaviour; any output is acceptable where

1. Each unit is listed
2. There is only one non-dislodged unit per country
3. In any country with a dislodged unit there is a non-dislodged unit
4. Each non-moving unit is listed in its origin country
5. Each moving unit is listed either in its origin country or its destination country

Note that, in particular, each unit being in its starting country is a valid output.

For use with convoys, it's helpful to know which countries are adjacent to which other countries. (Everything is assumed to be valid, but it may not be clear whether a convoy with a single cut link is still possible otherwise).

You may assume that this list is available to you in any format: a function that takes two countries and returns true/false, a variable, a file, etc. In any case, the list itself does not add to your byte count.

# Input/Output Formats

You can use any Input/Output formats you choose, as is standard.

# Questions for the sandbox

• How much clearer does my description of the rules of Diplomacy need to be?
• Does this sound like an interesting challenge?

# Enforce Social Distancing! code-challengetest-battery

Related to Maintain Social Distancing!.

As in that challenge, there is a 2-dimensional array of 1s and 0s representing people. In it, social distancing is maintained if and only if all 1s are at least 6 squares apart, where distance metric used is $$\|\Delta x| + |\Delta y|\$$ (rectilinear or Manhattan).

The challenge here is to move some people in a given 2D array so that social distancing is maintained. It's guaranteed that it's possible to do so. Your program's score on a given input is the total distance moved by all people.

Your program's running time must not exceed 10 seconds on any of the test cases.

This is tagged , so there is a large set of inputs your programs will be tested on [TODO: actually create it]. The program with the lowest total score on all of these inputs wins.

## Sandbox stuff

• Is this currently a bad idea for the reasons specified by Shaggy in the following comment?

I am sorry but I have downvoted this for what others may perceive to be a trivial reason: Code Golf is one of the few things I have left where I can escape how fucked my world has become; I absolutely do not want to come here to be reminded that I can't hug my family and friends.

• Is there an optimal algorithm? (I hope not)

# Posted.

• Are the prompts mandatory, should they be in that format? (or maybe all the input should be on one line like ?> [line]:[content] – Wezl May 21 at 18:49
• This seems like an interesting challenge, but I think some details are missing. For starters, you should provide a full list of commands that our program must support, as well as a few more examples – math junkie May 21 at 18:56
• @mathjunkie What do you think now? – nope May 21 at 22:30
• Looks better. However, Bonuses in Code Golf is high on the list of "Things to avoid when writing challenges". I would recommend either including those bonus tasks as part of the main challenge or removing them completely – math junkie May 21 at 22:36
• Ahh, good ol' edlin. – Third-party 'Chef' May 22 at 8:29

# Match the entire lyrics of All-Star

The challenge is simple: create a program/function that, when given a string consisting of the entire lyrics to All-Star as they appear in this paste (or not), output whether or not they are, in fact, the entire lyrics. The given string may be off by one of two characters, or something completely different, like Moby Dick (approximately). Output may consist of any of two values that map to true and false. They could be 0 and 1, or t and f, or whatever you like so long as there are two distinct values. You can choose to print the output or return it (if you are a program or a function). This is , so shortest answer in bytes wins!

• If the input string can be anything, is there anything one could do other than to compress the correct text and compare to it? If so, that would just be a generic compression challenge. One could check some cryptographic hash of the input, but there will exist collisions even if they are not practical to find. – xnor May 24 at 3:44

# Golf me a Bookmarklet Quine

Given a javascript program (or any utf-8 text) of arbitrary length, output it in my simplified version of URI form, like a bookmarklet. You can use https://mrcoles.com/bookmarklet/ as reference. Output should be in the form

javascript:[input with percent-encoding for special characters]

Special characters are any character that is not

• Alphabetic (upper or lower)
• a digit
• the characters .,-,_, or ~ (period, hyphen, underscore, tilde)

Your program "should convert all other characters to bytes according to UTF-8, and then percent-encode those values"w

A percent-encoding mechanism is used to represent a data octet in a component when that octet's corresponding character is outside the allowed set or is being used as a delimiter of, or within, the component. A percent-encoded octet is encoded as a character triplet, consisting of the percent character "%" followed by the two hexadecimal digits representing that octet's numeric value. For example, "%20" is the percent-encoding for the binary octet "00100000" (ABNF: %x20), which in US-ASCII corresponds to the space character (SP). source

Lowercase hex is okay, but uppercase is preferred.

This is code golf, standard loopholes are prohibited, programs should handle input up to 20 lines and output in a single line.

## The Twist (so it's not a duplicate)

If run with no input or just a newline (your choice), the program should output itself in the same format as if the program's source was inputted normally.

## Examples

In                                              Out

[blank]                                         javascript:[the%20program%27s%20source]
g/re/p                                          javascript:g%2Fre%2Fp


## sandbox questions

• What tags does this need?
• Are my examples inconsistent?
• What parts of the challenge are redundant?

Comment: might be too similar to previous mutual quine challenge?

## Collaboration/quasi-quine challenge

Write a valid submission (A) which prints the code for another competitor's valid submission (B). The languages used in A and B must be different.

### Clarifying rules

If B prints the code for a third submission, C, it is not required that A and C be different languages. Similarly, the authors of A and B must be different, but A and C need not be. (More different languages/authors score higher, however.)

The shortest chain is for A to print B and B to print A.

Note that if A prints B, and B prints C, but C is not valid for some reason, then neither A nor B are valid either.

It is acknowledged that the validity of your submission may change over time, due to factors beyond your control. Try not to let this worry you too much. :)

None

## Output

Just the code described above. Nothing extraneous.

## Scoring

Scoring is (A + L) * 100 + C where:

• A is the number of distinct authors that directly or indirect print your solution. So if you are Q, and Z=>X=>Q=>X, your "A" is 2. (Each submission only has one author, the "answerer".)
• L is the number of distinct languages in your quine circle, along the same lines as for authors. (Each submission only has one language. "Distinct" means really different, not just different versions or implementations of the same languages.)
• C is the length of your solution in bytes.

(So, for a given circle of quines, all the submissions will have similar scores, with the length of the submission as tie-break.)

Standard loopholes are forbidden.

• I like it when your score improves if you use more languages. Any reason why you didn't include that? – Wezl Apr 30 at 21:51
• Oh, what would an example of that be? I did consider something like having your score improve, the longer the chain is. Like, your score is the sum of the length of all the submissions divideded by the square of the number of participants or something. – Steve Bennett May 1 at 2:09
• That would be nice, but I wouldn't know how to balance it well. Just a thought. – Wezl May 1 at 17:46
• This seems to me like a chicken-and-egg situation. How could the first posted answer be valid if there are no B answers to print the code for? – math junkie May 25 at 15:35
• This is another similar challenge. It had several problems that I think might occur again with your current setup. I'd recommend giving the criticism and answers there a read over. – FryAmTheEggman May 25 at 20:45
• @mathjunkie It wouldn't. I don't think that's inherently problematic, it's just an interesting bootstrapping challenge. – Steve Bennett May 26 at 1:00

# Price this word code-golfnumberstring

So, I'm going shopping in the Word Market™. There are shelves of words which I can buy around me, but I only have one dollar bills and the change machines at the market are broken. To add to the problem, there are words with... non-word characters in them. That's no good, I can't buy those... can you help me figure out which words I can buy and which I can't?

So, I can only buy words that consist of only alphabetical characters and are worth a dollar. To determine a word's value, you have to sum the letters in the word where A = 1¢, B = 2¢... to Z = 26¢. I'm too lazy to look at the output and judge whether it is equal to one dollar (100 cents), so you'll need to return a specific value for words equal to a dollar (...or 100 cents) and a specific value for not equal to a dollar (I'm going to stop including this).

I'll also offer a bonus byte reduction: if your code returns whether the word is less than a dollar, equal to a dollar, greater than a dollar, or invalid (e.g. <, =, >, x), your score will be multiplied by 3/4.

SANDBOX NOTE: Is this a balanced bonus value?

## Examples

Word          Non-bonus value     Bonus value

a                  false               <
b                  false               <
printera           false               >
\$word              false               x
printer            true                =


And here's a JavaScript snippet you can use if you want to check for non-bonus validity:

(it's also 52 bytes; you can use it by calling f())

f=s=>([...s].map(x=>a+=parseInt(x,36)-9),a==100),a=0


Anyways, standard loopholes apply, shortest answer in bytes wins (but I'll add shortest answers for esoteric and functional languages)... you get the idea.

• In general, bonuses in code golf are seen as something to avoid – math junkie May 28 at 2:45
• Standard Loopholes – math junkie May 28 at 2:46
• This challenge doesn't seem interesting to me. We've already have plenty of challenges about summing up characters in a string, and having to determine whether a string contains non-word characters just seem like tacked on challenge that makes the whole thing more cumbersome. – Surculose Sputum May 28 at 15:40
• What's a bit ironic about this is that after you posted this you went on to write a program that went through words in the English language and summed up their values depending on what character they were, sharpness of a word – Ethan Slota May 28 at 20:53
• Never say I like the sharpness challenge either. :P But I do think that that challenge is a bit more interesting, due to the somewhat arbitrary mapping of letter to values. Yours just straight up uses the vanilla alphabetical order. – Surculose Sputum May 29 at 14:53
• You do have a point; in Jelly or 05AB1E there's probably a builtin that would sum up a string based on values like I want people to do. – Ethan Slota May 29 at 21:50

# Magic card trick: Hide information by flipping cards

(This is inspired by a series of questions on puzzles.stackexchange.com: 10, 8, 7)

Fix two integers m and u. Your task is to perform the following magic trick:

• A Magician brings a pack of m distinct cards, and leaves the room.

• In their absence, a volunteer from the audience shuffles the deck and arranges all cards in a line, in any order they want.

• Still in the absence of the magician, their assistant flips u cards. On the table are the n cards, still in the order chosen by the volunteers, but u are face down, leaving only mu cards face up.

• The magician returns, and from the order of the cards alone, knows each card.

### Input:

m - number of cards.

u - number of cards to flip face down.

• You may assume 0 < u < m.

### Output, if the trick is possible for m and u:

f - an mapping assigning to each sequence the order the assistant will create by flipping cards.

• If the trick is to work, this mapping must be bijective.
• Use the integers 1...m (or 0...m−1), or single letters as card values.
• Use any meaningful way to express f: a hash maps, a table, a function.
• Use a fixed placeholder for any face-down cards.

### Output, if the trick is impossible for given values of m and u

This case should be indicated in a meaningful way.

### Example output (m=3, u=1):

Using the digits 0, 1, and 2 as cards, and _ for their flipside:

012 01_
021 0_1
102 _02
120 12_
201 2_1
210 _10


(For these values of m and u, this isn't very impressive as a magic trick, of course.)

### Example output (m=4, u=2):

Using 1, 2, 3, and 4 for the cards and 0 for their flipside, and a JSON representation:

{"1234":"0034","1243":"0043","1324":"0024","1342":"0042","1423":"0023","1432":"0032",
"2134":"0104","2143":"0103","2314":"0014","2341":"0041","2413":"0013","2431":"0031",
"3124":"0120","3142":"0102","3214":"0204","3241":"0201","3412":"0012","3421":"0021",
"4123":"4003","4132":"0130","4213":"0203","4231":"0230","4312":"0302","4321":"0301"}


This is correct because as required, the keys are all permutations of 1234, each value has two cards face-down and the other cards match the original sequence, and each value appears only once.

## Scoring

This is code-golf. Shortest solution wins.

• I think I should not allow all that input/output flexibility and require some fixed format. For example: input is u and a string whose (unique) characters are the decks. Require _ as placeholder. Require a fixed table format. – retzler May 29 at 4:27
• There were some clarity issues I had while reading this, but as is I think this has a much bigger problem. It seems very likely to me that outputs for large m will be prohibitively difficult to verify, given the complexity of the proofs from the related puzzling challenges. There are many ways you could approach this, like upper bounding m, making this a test-battery, or making a code-challenge where the goal is to find the maximum u for the highest m. There are probably other ways to handle this, so these are just some starting ideas. Thanks for using the sandbox! – FryAmTheEggman May 29 at 19:23
• Thank you for the valuable feedback @FryAmTheEggman. The proofs from the linked puzzles are long because they're reasoning & looking for insight. To just verify the list, two steps are sufficient: verify that f*(*x) is obtained from x by replacing u symbols with _, and that f is a bijection and defined for all permutations. Non-golfed solution including full tests . The output will still be huge, no chance of cursory manual verification. I didn't know about alternatives to code-golf, actually! I'll be looking into these. – retzler May 29 at 21:44
• No problem! I do want to clarify though - I was aware of the ability to prove by exhaustion when I posted my first comment. However, I did base my assessment of it being a true problem around you not wanting a completely naive brute force search through each strategy, which I see now wasn't correct, so if you are fine with that then there isn't really a problem. But of course, if you want anything besides those solutions I'd recommend looking into what I suggested, or asking in our chat room for other people's points of view. – FryAmTheEggman May 29 at 22:43

# _

• What kind of numbers can be in the sequence? – xnor May 22 at 10:30
• @xnor Integers, basically. – Third-party 'Chef' May 22 at 10:35
• Would the test cases that time out, 1,2 and 7,4, be excluded by "the input will always be provided in a way such that it won't take forever to zero the accumulator"? No product of exclusively odd numbers can end up being divisible by a power of 2. – Unrelated String May 23 at 9:35
• @UnrelatedString Thanks for nothing that; I've removed these test cases. – Third-party 'Chef' May 23 at 9:46
• Now this post is zeroed eventually – l4m2 Jun 5 at 1:36

# Mobile games money representation

In many mobile clicker games where the player is usually required to tap on the screen to make money (in order to buy upgrades for you to generate money faster), it gets to a point in the game that the money made per second is so big that if represented in its "normal" form, it would clutter the mobile screen. Imagine showing the user that they are making $$\1,000,000,000,000,000,000,000,000\$$ per second in a small mobile phone screen!

From my experience as a regular player of these type of games, I have noticed that most of them represent bigger numbers by using letters. If the number of money per second is a number less than $$\10,000,000\$$ then print the number as is. Otherwise, if the number is in the millions (but $$\ \geq 10,000,000\$$), for example $$\ 102,000,000\$$ it should print $$\102M\$$. If it is in the billions, it should print $$\102B\$$. You should use $$\T\$$ for trillion and $$\Q\$$ for quadrillion.

As you can notice, the next would be quintillion which would also use the letter $$\Q\$$ if followed the pattern. Instead of following this pattern which can be confusing at one point, game developers usually start a new pattern: Quintillion is used with the suffix $$\AA\$$, sextillion is $$\AB\$$, septillion is $$\AC\$$ and so on.

Notice that this pattern would go until $$\AZ\$$ and if the player is making more money than that, it would start from $$\BA\$$, $$\BB\$$, ..., $$\BZ\$$, ...,$$\ZA\$$, $$\ZB\$$, ... , $$\ZZ\$$ which for our problem we will assume is the limit one player can make per second.

Given an integer $$\x\$$ where $$\0 \lt x \leq 999\$$ and a natural number $$\y\$$ where $$\y \gt 0\$$ representing the number of zeroes the number has, output the number in a "mobile game money representation" as described above.

# Observations

• The number of zeroes that $$\y\$$ represent does not include the possible zeroes $$\x\$$ might have! Example: if $$\x = 100\$$ and $$\y = 6\$$, you should output $$\100M\$$ and not $$\1,000,000\$$

# Test Cases (x, y --> game money representation)

100,  6 --> 100M
100,  5 --> 10M
100,  4 --> 1000000
1,   12 --> 1T
10,  12 --> 10T
100, 12 --> 100T
1,   18 --> 1AA
10,  18 --> 10AA
100, 18 --> 100AA


# Meta questions

1. Is this a duplicate? I have looked around but didn't find anything similar.
2. Is the wording confusing? I'm open to recommendations!
3. I haven't written a program yet so the test cases might be wrong (I'll add more later).
4. Pretty much any feedback is appreciated!
• Looks like it needs some test cases with decimal points, e.g. 123, 17 -> 12.3AA. – Bubbler Jun 1 at 0:20
• Shouldn't 100, 4 become 1M? – Surculose Sputum Jun 1 at 13:03
• @SurculoseSputum In these games, when the number is small enough (as I said in the second paragraph), if the number is less than 10 million, then it is printed in its "normal" form. The abreviations starts after 10 million. – ihavenoidea Jun 1 at 19:33
• Suggest cases where $y$ don't just go the AA – l4m2 Jun 19 at 4:24
• Thanks all, I'm pretty busy lately unfortunately. Whenever I get the time I'll try to update the challenge – ihavenoidea Jun 19 at 21:59

# Shift the letters, soldier !

posted, finally

• Thank you for sandboxing this. I usually recommend doing so for at least a week, and periodically ask for review in TNB. – Adám Feb 28 at 9:09
• I think people would be forced to do the bonus in this case because of the -30% margin. I got a 42 without bonus but a 57*0.7=39.9 with bonus in JS. – Shieru Asakoto Feb 29 at 3:16
• Bonuses are discouraged for a variety of reasons. I would strongly recommend either making it mandatory or completely leaving it out. – FryAmTheEggman Mar 1 at 18:58
• The main challenge is add by position, the bonus challenge is minus by position. So it's a good idea to completely leave the bonus out. – Third-party 'Chef' Mar 2 at 0:29
• Thanks for the comments, I'll remove the bonus as it will never be balanced enouth to be interesting. I'll add some example as soon as I can. – The random guy Mar 3 at 20:02
• I would say that allowing the usage of the ascii range 1 to 255 or a language's code page could allow for some interesting golfs :) – RGS Mar 3 at 20:39
• Use asciii values from 0 to 255 was my original plan, but I'm afraid some interestings languages would be disadvantaged. Also, wouldn't the usage of language's code page be too permissive ? – The random guy Mar 4 at 15:51
• @Therandomguy it depends on what you mean by "too permissive". Sometimes it is done, as it may allow some languages to do some funny things. As to the range being from 0 to 255, I don't see it hurting any language at all, but of course I may be missing something :) – RGS Mar 4 at 21:36
• Are you interested in re-posting it? – Third-party 'Chef' Mar 6 at 7:38
• This weekend I'll post it, I just need some time creating the examples – The random guy Mar 6 at 8:25
• I'd be glad to see it posted in Main! – Third-party 'Chef' Mar 25 at 12:19
• Finally posted it in main – The random guy Jun 3 at 7:45

# Compute the pointiness, sharpness and smoothness of a letter code-golfkolmogorov-complexity

Inspired by Determine the sharpness of a word.
You are given an uppercase letter of the English alphabet as input. You have to compute (and output) its pointiness, sharpness and smoothness. Since it is difficult to define these objectively, here's a table of the outputs:

            A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
pointiness: 2 0 2 0 3 3 2 4 4 2 4 2 2 2 0 1 1 2 2 3 2 2 2 4 3 2
sharpness:  1 2 0 2 2 1 1 0 0 1 0 1 3 2 0 1 0 1 0 0 0 1 3 0 0 2
smoothness: 0 2 1 1 0 0 1 0 0 1 0 0 0 0 1 1 1 1 2 0 1 0 0 0 0 0


Transposed version (first lists the letter, then the pointiness, then the sharpness and then the smoothness) (like a true CGCC user, I transposed it with Jelly and added spacing with Retina):

A 2 1 0
B 0 2 2
C 2 0 1
D 0 2 1
E 3 2 0
F 3 1 0
G 2 1 1
H 4 0 0
I 4 0 0
J 2 1 1
K 4 0 0
L 2 1 0
M 2 3 0
N 2 2 0
O 0 0 1
P 1 1 1
Q 1 0 1
R 2 1 1
S 2 0 2
T 3 0 0
U 2 0 1
V 2 1 0
W 2 3 0
X 4 0 0
Y 3 0 0
Z 2 2 0


Bonus imaginary internet points if you find a language where this is built-in.

This is tagged , so the shortest answer wins.

# Sandbox stuff

• Is this not a duplicate?
• Is the table computed correctly? (the only ones that don't seem certain with the current font are I's pointiness, G's sharpness and S's smoothness)
• After fiddling about a bit, I think this should probably have enough patterns that mindlessly compressing the numbers won't be the best strategy. Still, I could be wrong, but here is what I used to see roughly how long such an approach would be (I encoded each set of values to a base 5 number, then in turn encoded that list of numbers into a base 61 number). Separately, you probably want to include the data in a more copy-pastable way. – FryAmTheEggman Jun 3 at 20:34

# Is this a simple cutting template?

A simple cutting template is a rectangle that can be recursively cut into smaller rectangles using only full-width cuts.

If you prefer a bottom-up description, then:

• A single rectangle is a simple cutting template with 0 cuts.
• Two simple cutting templates of the same width (or length) can be joined along their common side into a larger simple cutting template.

Input: A diagram of a rectangle subdivided into smaller rectangles, or a list of rectangles in some standard format, e.g. position and size.

Output: A truthy value if the diagram is a simple cutting template.

Note that if you take input as a diagram then all of the rectangle edges will use the same character, whearas in the truthy examples below, some of the edges have been replaced with digits to show a possible ordering of cuts while the falsy examples have the smallest portion of the input that is not a simple cutting template marked on them.

####2################
#   2               #
111111111111111111111
#                   #
#                   #
#                   #
111111111111111111111
#     2   2   2 4 4 #
3333332   2   2 4 4 #
# 4   2   2   2 4 4 #
# 45552   2   2 454 #
# 4 6 2   2   2 4 4 #
# 4 6 2   2   2 4 4 #
# 4 6 2   2   2 4 4 #
33333323332   2 4 4 #
#     2   2   2 4 4 #
#     23332   2 4 4 #
#     2   2   2 4 4 #
#     2   2   233333#
#     2   2   2     #
######2###2###2######


-> Truthy

##2#####4############
# 2     4           #
# 2333333333333333333
# 2         6     4 #
# 25555555555555554 #
# 2 6   6     8   4 #
# 2 6   67777777774 #
# 2 6   6         4 #
# 2 6   6         4 #
# 2 6   6         4 #
111111111111111111111
#               2   #
#               2333#
#               2   #
111111111111111111111
#   2             2 #
#   233333333333332 #
#   2 4 4     4   2 #
#   2 4 4555554   2 #
#   2 4 4     4   2 #
####2#############2##


-> Truthy

#####################
#                   #
#                   #
#                   #
111111111111111111111
# 2   4           2 #
# 2   4           2 #
# 2   4           2 #
# 23333333333333332 #
# 2     4   4 6 4 2 #
# 2     45554 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 4 6 4 2 #
# 2     4 6 45554 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
# 2     4 6 4   4 2 #
##2#####4#6#4###4#2##


-> Truthy

#####################
#               # # #
################# # #
#               # # #
#               # # #
#               # # #
?????????############
?     # ?     #     #
?     # ?     #     #
?     # ?     #     #
?     ##?     #     #
?     # ?     #     #
?###### ?############
?     # ? #       # #
?     # ? #       # #
?     # ? #       # #
?###### ?##       ###
? #   # ? #       # #
? ######? #       # #
? #     ? #       # #
?????????############


-> Falsy

?????????????????????
?     # # # # #     ?
?###### # # # #     ?
?     # # # # #     ?
?     # # # # ######?
?     # # # # #     ?
?###### # ##########?
? #   # # #         ?
? ##### # #         ?
? # # # # #         ?
? # # # # #         ?
? # # # # #         ?
? ####### #         ?
? #     # #         ?
? #     ############?
? #     #     #     ?
? #############     ?
? #     #     #     ?
? ##################?
? #         #       ?
?????????????????????


-> Falsy

#####################
#       #   #     # #
################### #
#                 # #
#####################
# #                 #
# ###################
# #   #             #
# ###################
# #   #     #       #
# ###################
# #                 #
# ???????????????????
# ?   #             ?
# ?   #             ?
# ?   #             ?
# ?   ##############?
# ?   #   #         ?
# ?########         ?
# ?       #         ?
##???????????????????


-> Falsy

This is , so the shortest program or function that breaks no standard loopholes wins.

• I think you should include an explicit definition: 'A simple cutting template is a rectangle that can be recursively cut into smaller rectangles using only full-width cuts.' – Dingus Jun 6 at 4:06
• @Dingus Thanks for pointing that out, I think I must have accidentally edited it out by mistake when writing the sentence for the output. – Neil Jun 6 at 10:29
• I'd prefer one or two small examples with extra markings and then a list of copy-pasteable test cases. – Zgarb Jun 6 at 11:13

## Backstory

A doctor in Berlin, after analyzing his medical history, has realized that all of the results of his integral measurement results can be represented in the form of $$\23x+28y\$$, where $$\x\$$ and $$\y\$$ are integers.

However, he could have extended his theory. $$\23\$$ and $$\28\$$ can be replaced by any two coprime numbers, and this theory would still hold. (He didn't have time to write his theory in a paper, that's quite awful.)

Without examples, I'll never be convinced that this nonsensical theory holds!

Given $$\the\ output\ of\ (ax+by)\$$ (let's call it $$\z\$$), $$\x\$$, and $$\y\$$, find the smallest pair of $$\(a,\ b)\$$ that makes $$\ax + by = z\$$ true.

## Example cases




## Partition distance code-golfstring

Quoting Anush:

I am very glad to provide a service to fill in the terrible gap in edit distance questions which codegolf.se has had. When there are as many edit distance questions as quine questions my job will be done.

--Anush

Given a binary string consisting only of 0's and 1's, partition the binary string (divide the string into consecutive substrings), and determine the minimal edit distance in order to transform one piece into another, left to right. You need to output the sum of the edit distances between consecutive blocks.

## Example

I'm going to make a reference implementation to find the optimal partitions. But that's after I dump all my ideas, though.

011010110111

We partition the string like this:
[011][010][110][111]

And then find the cumultative edit distance between each 2 pairs of partitioned strings:
[1 1 1]

Then, we sum the list of partitions.
[3]

So 3 is a possible output for this binary string. However, you need to find the minimum edit distance, so this might not be the correct answer.


## Another example

001001010

We partition this string:
[001][001][010]

And then find the mimimal edit distance between each piece.
[0 1]

Therefore, our (non-optimal?) output for 001001010 is 1 ([0 1] summed).


## Rules

• The edit distance between two strings is the minimum number of single character insertions, deletions and substitutions needed to transform one string into the other.
• The input is guaranteed to have at least length 3.
• The pieces of your partition don't have to be the same length.
• What do you mean by "partition the input string"? Can I choose any partition I want as long as it's not all singletons or the entire thing? Or do I have to find one that's optimal in some sense? Why is the all-singletons case disallowed? Is the output the sum of the edit distances between consecutive blocks? From the examples I guess it is but you should say it explicitly. – Zgarb May 31 at 18:50
• @Zgarb "partition the input string" means divide the input string into (not necessarily equal) consecutive substrings. You need to find one that's optimal, I've emphasized that. I allowed the all-singleton case; I specified that the output is the edit distance sum between consecutive blocks explicitly. – Third-party 'Chef' Jun 7 at 4:36
• It should still be made clearer that the output is the minimum over all partitions. – Zgarb Jun 7 at 20:21

# Pristine Polyglot Quines

As the title says, you are to create a pristine program which outputs its own source code in as many languages as possible. A pristine program, taken from here, is:

Let's define a pristine program as a program that does not have any errors itself but will error if you modify it by removing any contiguous substring of N characters, where 1 <= N < program length.

For example, the three character Python 2 program

8 is a pristine program (thanks, Sp) because all the programs resulting from removing substrings of length 1 cause errors (syntax errors in fact, but any type of error will do):

8

8


and also all the programs resulting from removing substrings of length 2 cause errors:





If, for example, 8 had been a non-erroring program then 8 would not be pristine because all the results of substring removal must error.

A pristine quine is a pristine program that outputs its own source code, according to our standard quine rules (so no empty or literal only programs).

You are to write, in as many languages as possible, a pristine quine.

• Your code must work in a minimum of two distinct languages
• Different versions of a language do not count as different languages. Therefore, Python 2 and Python 3 are considered the same language.
• Your program must be pristine in all languages used
• This is , so the answer with the most languages wins
• In case of a tie breaker, the longest solution, in bytes, wins

# Meta

• Wow, pristine quines are already hard enough, and now you want it to be a polyglot too? Especially since polyglots often rely on one language ignoring the executing part of the other. Also, does it need to pristine in both languages, or both combined (i.e. removing a section can work in language A, as long as it errors in language B)? – Jo King Nov 13 '19 at 5:58

# Default Lightning Strike

## Introduction:

Inspired by this reddit question: ELI5: Why does lightning travel in a zig-zag manner rather than a straight line?

Although it's more complex than this, in general multiple lightning paths will randomly check its immediate surrounding for the direction with least resistance (based on air pressure, temperature, composure, humility, etc.) and travel in that direction. As soon as one of the paths reaches the ground, that entire path has the least resistance and most (although not all) of the ions will accumulate in that path, causing the lightning flash and thunder.
Here a slow-mo video of a lightning strike to get an idea.

## Challenge:

Input: An integer $$\h\geq3\$$ and an integer $$\1\leq p\leq\left\lfloor\frac{h}{2}\right\rfloor\$$

Output: Each step of the ASCII animation of a lightning strike, with a cloud to earth height of $$\h\$$ and up to $$\p\$$ paths

We start with a lightning ion at the cloud, with a lowercase letter of your own choosing (i.e. b). This ion will travel in a random direction (horizontally, vertically, or (anti-)diagonally), except where this path itself comes from. Every 'tick' it also has a 20% chance of branching out into two paths, as long as we haven't reached $$\p\$$ paths yet. Each of these paths will behave the same.
As soon as any path hits the ground based on the height $$\h\$$, all letters of that particular path will become uppercase, and in the final 'tick' after that, only this uppercase path will remain.

## Challenge rules:

• Paths can intersect with other paths
• Paths can travel upwards beyond the height of our starting point
• Output can be in any reasonable format. Could be a list of multi-line strings for each 'tick'. Could be a list of character-matrices for each 'tick'. Could be pretty-printed to STDOUT (with clear non-whitespace separation between each 'tick' - i.e. a single character like a comma or semi-colon, or a line of --- or ___)
• Trailing spaces for each line of a tick are optional (leading as well, as long as the lightning bolts are still correct)
• If multiple paths strike the ground in the same 'tick', only the first one of those two (or more) paths will become the lightning strike. The order in which paths are created are therefore important, so keep that in mind.

## Examples:

This may all sound pretty vague, so here a couple of examples:
(I've added trailing spaces for each step with spaces, but you don't necessarily have to do so as mentioned in the challenge rules.)

Example 1: $$\h=3, p=1\$$

Tick 1:
"b"
" "
" "
Tick 2 (random direction: right):
"bb"
"  "
"  "
Tick 3 (random direction: up-left):
"b "
"bb"
"  "
"  "
Tick 4 (random direction: down-left):
" b "
"bbb"
"   "
"   "
Tick 5 (random direction: down):
" b "
"bbb"
"b  "
"   "
Tick 6 (random direction: up-right):
Note that this overlaps with a previous step in this path, which is fine.
" b "
"bbb"
"b  "
"   "
Tick 7 (random direction: down-right):
" b "
"bbb"
"b b"
"   "
Tick 8 (random direction: down):
" b "
"bbb"
"b b"
"  b"
Tick 9 (lightning strike):
" B "
"BBB"
"B B"
"  B"
Tick 10 (extra tick to remove all other paths, although there are none right now):
" B "
"BBB"
"B B"
"  B"


Example 2: $$\h=5, p=2\$$

Tick 1:
"b"
" "
" "
" "
" "
Tick 2 (random direction: down-left):
" b"
"b "
"  "
"  "
"  "
Tick 3 (random direction: down-left):
"  b"
" b "
"b  "
"   "
"   "
Tick 4 (random direction: right):
"  b"
" b "
"bb "
"   "
"   "
Tick 5 (random 20% path split; random direction 1: top-right, random direction 2: right):
"  b"
" bb"
"bbb"
"   "
"   "
Tick 6 (random direction 1: top-left, random direction 2: down):
" bb"
" bb"
"bbb"
"  b"
"   "
Tick 7 (random direction 1: left, random direction 2: down-right):
"bbb "
" bb "
"bbb "
"  b "
"   b"
Tick 8 (lightning strike of path 2):
"bbB "
" Bb "
"BBB "
"  B "
"   B"
Tick 9 (extra tick to remove all the other paths, which is path 1 in this case):
"  B "
" B  "
"BBB "
"  B "
"   B"


## General rules:

• This is , so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.

# Sandbox Questions:

• Should I perhaps use a different letter of the alphabet per path?
• If yes: what would happen when different letter-paths overlap? I assume the top one will be visible per 'tick', but if lightning is struck it should still change it to the underlying letter as uppercase. In either case, you'll have to keep track of each individual path and uppercase only the one that struck the ground (first).
• Any additional rules or things that are unclear?
• More examples with more paths and/or larger height?
• A different path percentage instead of hard-coded $$\\frac{1}{5}\$$ / 20%.

# Sort numbers using as few distinct bytes as possible

Write an algorithm that takes as input an ordered list (array, linked list, etc...) of numbers and outputs an ordered list containing the same numbers sorted by their value (ascending or descending).

The numbers may be represented using the most convenient format to you, with the only restriction that there must be a way to encode 256 distinct numbers. You are not allowed to use built-in sorting functions/algorithms.

## Scoring criteria

Let $$\c\$$ be the number of distinct bytes in your code* and let $$\s\$$ be the number of bytes in your code*.
*Or its UTF-8 representation

The score is equal to $$\c^2 + s\$$. The answer with the lowest score wins!

Examples (imagine these are sorting algorithms):

• ababccbaacbabcba$$\c=3, s=16, score=25\$$
• aAbcd€f$$\c=9, s=9, score=90\$$
• bytes 16 ee 3c 79 ee$$\c=4, s=5, score=21\$$

I'm open to suggestions, especially about the score formula.

• I see that this is your first attempt at writing a challenge. Thank you so much for using the sandbox! – Adám Jun 25 at 22:16
• Please note that it is very hard to write good challenges that restrict solutions from certain things. This is because it is hard to define exactly what is prohibited in every language, and it is also hard to determine if any prohibited feature was used. – Adám Jun 25 at 22:19
• @Adám So how should I prevent trivial answers? Maybe "built-in sorting functions/algorithms" is a bit vague. – D. Pardal Jun 25 at 23:04
• We don't prevent trivial answers in most cases. Btw, if I accept plain numbers as input, may I assume the input is a list of integers between 0 and 255 inclusive? – Bubbler Jun 25 at 23:46
• How about this: "You are not allowed to use any built-in function/command that can take an ordered container and output the sorted result. Anything else is OK." – Bubbler Jun 25 at 23:54
• I think a good solution would be to allow built-in solutions, but to compile (in advance, so that it can be posted very quickly, probably via the "answer your own question" feature) a community wiki answer listing trivial 1-byte solutions. – my pronoun is monicareinstate Jun 26 at 4:17
• @Bubbler Would still be unclear if J's /:~ or /:] were allowed or not. – Adám Jun 26 at 6:15
• @D.Pardal Why do you want to prevent trivial answers? – Adám Jun 26 at 6:20
• I wanted to prevent built-in functions because otherwise most answers would be exactly the same as the ones from this question. Maybe the easiest way to solve this would be to replace the task of sorting an array with another. – D. Pardal Jun 26 at 7:15
• Yes. Banning built-in has long been considered a bad idea. – user202729 Jun 26 at 11:57

# Fix mispellings code-golfkolmogorov-complexity

Wikipedia has a list of common misspellings, and there is also a machine-readable version!

Your challenge is to input a string and fix the mispellings in it.

The parituclar list we'll be using is https://en.wikipedia.org/w/index.php?title=Wikipedia:Lists_of_common_misspellings/For_machines&oldid=962756669#The_Machine-Readable_List. Note that even if the list changes, you must use this version. Here's a pastebin link: https://pastebin.com/j03aL98d.

Each line in the list is in the format INPUT->OUTPUT1, OUTPUT2, OUTPUT3, ... (of course, there may be more or less possible outputs, or even just one). That means that for input INPUT you must output exactly one of the possible outputs OUTPUT....

This is tagged , so the shortest answer wins.

# Sandbox stuff

Should I add more misspellings to the post, or should I remove them?

• Related – pppery Jul 2 at 14:23
• @pppery While the idea is probably related, I don't think the solutions would be related at all. – my pronoun is monicareinstate Jul 2 at 14:26
• What is the input format? A plain English sentence (so we need to handle spaces, punctuation, capitalization), or is a list of words acceptable? How should capitalization be handled (some entries look like Tolkein->Tolkien and UnitesStates->UnitedStates; given unkown->unknown, what is the expected output of unkown, Unkown, UNKown, Tolkein, tolkein, TOLKEIN)? – Bubbler Jul 2 at 23:19
• @Bubbler The input is a single entry in the list (the part before ->, of course). You do not need to handle capitalization ("tOLKEIN" is not "Tolkein"). (will clarify later). – my pronoun is monicareinstate Jul 3 at 2:11

## Overlap characters code-golf

Put all the characters of a given list, following the order, in a sequence of bits keeping it as small as possible.

Rules

• Write the bits of each character on a line.

• You can overlap bits if they are equal.

• You cannot change already written bits.

• Extend the line, in both directions, if not all the bits fit in.

• Always try to extend as less as possible.

Example

input :['a','&','1','.']
0110 0001  // a
0010 0110      // &
001 1000 1     // 1
00 1011 10 // .

output :0010011000011000101110

input : "&1a."

0010 0110      // &
0 0110 001     // 1
0 1100 001  // a
0010 1110 // .

output : 011000010011000101110



I/O rules

• input can be any sequence of single byte elements.

• output the resulting sequence of bits in any convenient method, no extraneous bits allowed (0 or 1)

# Validating Words in Word Grids

A follow on from Generating Word Grids

Given a grid of letters, a set of co-ordinates and a dictionary of words, validate that the co-ordinates follow only cardinal direction changes, at least one of the co-ordinates touch an empty space in the centre of the grid, the resulting word is valid given the dictionary (taking into consideration any blank tiles) and return either the grid, with the letters at the co-ordinates removed along with the score of the word, or, if one of the conditions fail, the original grid and a score of -1.

## Details

Please detail the format you want to accept coordinates in any reasonable format is acceptable.

## Scoring

Letters are worth their values as per Scrabble:

0 points: blank tiles
1 point: E, A, I, O, N, R, T, L, S, U
2 points: D, G
3 points: B, C, M, P
4 points: F, H, V, W, Y
5 points: K
8 points: J, X
10 points: Q, Z


Bonus tiles (indicated by a lowercase letter, or ! for a blank tile) provide a *2 multiplier and stack (eg. if my co-ordinates spell gOLf I would earn (((2+1+1+4)*2)*2), 32 points).

### Examples:

Input:

6,4 6,5 5,5 4,5 3,5 3,6 2,6 1,6
UWDESTKP?
TERMDYTSR
ROANJLEFT
EkCI OOsT
IPAJPGMNY
MZLORITVI
GwEGgPUeI
MNROYOEER


Output:

9
UWDESTKP?
TERMDY SR
ROANJ  FT
EkCI  OsT
IPAJP MNY
MZLO  TVI
GwEGgPUeI
MNROYOEER


(spells RIGOLETE, (1+1+2+1+1+1+1))

Input:

0,3 0,4 0,5 0,6
UWDESTKP?
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER


Output:

-1
UWDESTKP?
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER


(spells DEST which doesn't appear in the dictionary)

Input:

5,6 4,6 4,7 4,8
UWDESTKP?
TERMDY SR
ROANJ  FT
EkCI  OsT
IP  P MNY
MZL   TVI
GwE gPUeI
MNROYOEER


Output:

12
UWDESTKP?
TERMDY SR
ROANJ  FT
EkCI
IP  P  NY
MZL   TVI
GwE gPUeI
MNROYOEER


(spells MOsT, (3+1+1+1)*2)

## Rules

This is so the shortest code in bytes wins.

• The order is not important, it can be score then grid, or vice versa.
• Any reasonable format can be used for I/O assuming it is consistent.
• All standard loopholes are forbidden.

## Questions for meta

Things have changed a lot in the time since I originally posted this, so rather than just posting I thought I'd bump for fredback.

• What would the best way of using an associated dictionary be, taking it as input?
• Obviously the input format for co-ordinates can be more flexible (0-based index, 1-based index, or something) is mentioning this enough?
• Grid input format can be flexible too, mentioning this should be enough too?
• Any other relevant tags?
• This looks pretty good to me. – Rɪᴋᴇʀ Sep 15 '17 at 18:20
• Thanks @Pavel, I'll bear that in mind, i'm not sure how much interest there is based off of part 1, but I might still post this in the next week or so :) – Dom Hastings Sep 16 '17 at 9:21

# Sum the array times n, except the last code-golfarithmeticarray-manipulation

I've been posting relatively hard challenges recently, so here goes an easy one.

Given an array A and a number n, calculate the sum of all numbers of A multiplied by n, except the last one. All numbers (the elements of A and the value of n) are positive integers, and A is non-empty. Shortest code in bytes wins.

I have a 3-byte J solution. Can you find it (or beat it in a different language)?

## Test cases

A           N   Ans   Explanation
3 1 4 1 5   10  95    (3+1+4+1)*10+5
3 1 4 1 5   1   14    (3+1+4+1)*1+5
1           999 1     1


## Meta

• Is it a good idea? Is it a dupe or near-dupe?

# Something Else - ASCII Art maker:

A text to ASCII art generator maker, the program must input a string and return ASCII art from it. Something like patorjk.com/software/taag/. It has to use the Graffiti font. The winning criteria is the whoever gets the most likes.

• Hello! Just a few things to point out: 1) The current spec is very broad. For example, what fonts, how does spacing look, what characters need to be supported... there's a lot more details that need to be included than just "return ASCII art of this text" – Sp3000 Feb 24 '15 at 4:07
• 2) What's the winning criterion? Popularity contest? Code golf? – Sp3000 Feb 24 '15 at 4:08

# Identifying a Sonnet

This challenge is about determining if a given file (read-in from stdin) meets the criteria to be a sonnet. You may use any language for this challenge. If your language supports an API to use an online dictionary you may use that API, if your language doesn't then too bad.

Additionally, it is preferred if your language is one that can be ran directly from the command line and is a language that has a compiler or interpreter available directly from my distro's repos(Fedora), as I would rather just use a bash script to test the various programs, then test each program manually.

# Definition of a Sonnet

• Has 14 Lines (lines are denoted as the standard newline on your operating system).
• Has a definite rhyme scheme, it will have one of the following rhyme schemes
• ABBA ABBA CD CD CD
• ABBA ABBA CDE CDE
• ABAB ABBA EFEF GG
• Iambic Pentameter - consists of alternating stressed, unstressed syllables. This doesn't have to be perfect 100% of the time, just at least 50% of the time.

In order for your program to declare a given string a sonnet, it must meet all of the above criteria.

You do not have to identify the following:

• Thought Structure - too intense for a code golf challenge, and too subjective.
• Topic - computer lacks context to determine this

# Input

Input will be read from stdin. This is the string that you will be declaring to be or not to be a sonnet.

# Output

Your program will output either yes or no for the question:

Does this string meet the given requirements to be a sonnet?

As this is code golf yes or no can be abbreviated to Y/N.

# Winner

The solution with fewest number of bytes win that has the highest accuracy ratio for the correct identification of a sonnet. The preference is for higher accuracy rather than brevity of the program.

# Test Data and Resources

## What is not a sonnet

The following are examples that you program should return false on:

• Beowulf
• Haiku
• Input that doesn't have exactly 14 Lines in it
• The text of this question.
• The text of just about any other question on StackExchange.
• Things that don't have a rhyme scheme. See Below

# Not A Sonnet

A man got on a boat
The boat was leaky
For it was made by a one-eyed blind man
and his dumb intern
As soon as he got out of port
at the fort
it started to sink
eventually, it tanked.
And it capsized
If only that shipwright
wasn't so blind deaf and dumb
as microsoft tech support
That's not much support at all.

• I think without dictionaries for rhymes and stresses this is probably not a good idea. Of course you can use some sort of accuracy ratio, but then you also need false positives, and you need a lot more examples than the few on the pages you've linked. But if you do this there's no requirement to actually recognise the sonnets by their rhymes and stresses - instead, I'm pretty sure, people will just regex golf the test sets. – Martin Ender Mar 24 '15 at 19:36
• @MartinBüttner I updated the requirements with an accuracy percentage, and added the option to use an API to look up terms from a dictionary. – HSchmale Mar 24 '15 at 19:57
• 1. Test data which only covers one possible output isn't test data. I can write a program which always outputs Y` in as little as one byte and it will pass all of the linked "test data", but it comes nowhere near to meeting spec. 2. Unless you specify which rhyme/stress dictionary to use, you can't guarantee that the test data is "correct". – Peter Taylor Mar 24 '15 at 20:20
• @PeterTaylor I added examples of what is not a Sonnet. – HSchmale Mar 24 '15 at 20:32
• I'm not sure how to say this, but it feels as though this task has a lot of individual parts, each of which could be quite tricky. Especiallly detecting rhymes/syllables/stresses, since words can be pronounced/stressed differently based on context. Also if you're using Shakespeare's sonnets I have no idea where to get rhyming and stress dictionaries for Elizabethan English... – Sp3000 Mar 25 '15 at 14:18
• To make this interesting, you'll need some interesting near-misses: non-sonnets that can't be detected by something simple like counting lines or words per line. – xnor Mar 25 '15 at 20:59
• @xnor You mean a file with a that looks like a sonnet but has no rhyme. – HSchmale Mar 25 '15 at 21:04
• Yes, for example. Or, one with rhyme by wrong rhythm. Or, one with nonsense characters that seem to "rhyme". – xnor Mar 25 '15 at 21:06
• @Sp3000 You can just use modern english, or just base it on words that have similar endings. – HSchmale Mar 25 '15 at 21:11