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

Radiation Showdown KotH

In radiation hardening challenges, the goal is to write a program whose behavior doesn't change when an arbitrary character is removed from its source. This KotH explores an adversarial variant on this challenge in which two programs compete to survive the most character deletions. The twist is that each program is provided the source code of its opponent and outputs which character should be deleted from its opponent's source code next.

Gameplay

Suppose program A and B are competitors.

1. Each program is run and the output is recorded. Let the output of program A be a and the output of program B be b. If one program fails to output a valid character index of its opponent's source code, the other program will be declared the winner of the match. If neither program outputs a valid index, then a tie is declared.
2. The a'th character is removed from program B and the b'th character is removed from program A.
3. Repeat steps 1 and 2 until there is a winner or a tie.

Submissions

Submissions should be a complete javascript or python program which:

• Begins with a shebang (#!) indicating which language it is written. For python entries, this should be #!/usr/bin/python. For javascript entries this should be #!/app/.heroku/node/bin/node.
• Takes three command line arguments: the code for the opponent program, the start of the range of deletable characters (x), and the end of the range (y). In python these can be accessed using sys.argv, while in javascript they can be found in process.argv.
• Prints a number in the range [x,y) to stdout and terminates in less than 10 seconds.

Note: The index of the first deletable character of your opponent's program (x) is the index of the first character after the shebang. y is the length of the opponent program in characters (so y-1 is the last deletable character).

Sample Submissions

Python:

#!/usr/bin/python
import sys

# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
print (sys.argv[3]-1)
# vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

Javascript:

#!/app/.heroku/node/bin/node
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
console.log(Math.round(Math.random() * process.argv[4]));
// vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv

Controller

I've hosted a web based controller at https://radiationshowdownkoth.herokuapp.com/. It should conform to the behavior specified in the Gameplay section. Let me know if you find any bugs.

Rules

• Standard loopholes apply.
• The use of preexisting interpreters and their components (parsers, lexers, etc) is banned. This includes, but is not limited to, calling the python and node binaries from your program (eg os.popen("python -c ...")), using builtin eval functions (eg python's exec), and using relevant modules (such as python's astlib). However, you may use regular expressions.
• No malicious code.

Logistics

It will be a Round Robin Tournament. Each submission will be matched against every other submission. For each victory a submission achieves, it will be awarded 1 point. Likewise, ties are worth 0.5 points and losses are worth 0 points. The submission with the most points after all rounds have been completed wins this KotH. The winner will receive a bounty from yours truly, and the most popular entry will be awarded accepted answer. This KotH will be open to entries for a week following its posting, at which point the tournament will be run and a winner declared.

Meta

• Duplicate?
• Clarifications?
• Other Language Suggestions besides Python & Javascript?
• Are there any trivial strategies that would be overwhelmingly effective?
• Any other foreseeable problems?

Answer 2

Unfactor a list code-golf jelly math number primes

Jelly has an interesting built-in, ÆẸ. It's the inverse of ÆE. ÆE returns the exponents of the prime factors of an integer n, where each exponent corresponds to the prime number at its index, so, for example, [3, 5, 1] represents \$2^3\cdot3^5\cdot5^1\$. If a prime isn't included in the prime factorization of n, but there is at least one prime after it that is included, a zero is put in its place (\$p^0=1\$). So, for example, [3, 0, 5, 1] represents \$2^3\cdot5^5\cdot7^1\$, and [0, 4, 4, 50, 0, 7] represents \$3^4\cdot5^4\cdot7^{50}\cdot13^7\$.

Your job is to implement ÆẸ, ÆE's inverse. That is, you'll be given a list returned by ÆE, and your job is to find n.

You must always return a positive integer (strictly greater than zero). You may assume the input doesn't have negative or float exponents or trailing zeroes.

Note that you're encouraged not to use ÆẸ or your language's equivalent (if any) in your answer.

Using any of the standard loopholes is prohibited.

Test cases (you don't have to support exponents, an output or an input's length beyond your natural signed integer type's limit):

[] -> 1
[0, 4] -> 81
[0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1] -> 1111
[10] -> 1024
[3, 5, 1] -> 9720
[3, 0, 5, 1] -> 175000
[31] -> 2147483648
[32] -> 4294967296
[63] -> 9223372036854775808
[64] -> 18446744073709551616
[0, 4, 4, 50, 0, 7] -> 5713082599062385095715588395684396863698753591853983125

Make more test cases:

To generate the input that corresponds to a given output, use this program.

To generate the output that corresponds to a given input, use this program.

Answer 3

Where can I get to from each location? (Transitive Closure)

Given an undirected graph (network) \$G\$, construct a new graph in which vertex (node) pair \$(u,v)\$ is an edge (are connected) if and only if a path \$(u,w_1,w_2,...,w_k,v)\$ exists in \$G\$ for some \$k\ge 0\$. This is known as \$G\$'s transitive closure. If this is clear to you, you're ready to get started. Otherwise, just read through the below sections. It is actually a very simple problem.

I/O formats

Take for example the graph (network)

1──2  3──4
│     │
5  6──7──8

We can represent¹ it as an adjacency (connection) matrix:

 │1 2 3 4 5 6 7 8
─┼───────────────
1│  ┘ 
2│
3│      ┘
4│
5│┘
6│            ┘
7│    ┘         ┘
8│

which is:

[[0,1,0,0,0,0,0,0],[0,0,0,0,0,0,0,0],[0,0,0,1,0,0,0,0],[0,0,0,0,0,0,0,0],[1,0,0,0,0,0,0,0],[0,0,0,0,0,0,1,0],[0,0,0,1,0,0,0,1],[0,0,0,0,0,0,0,0]]

Note that here only one of \$(u,v),(v,u)\$ is represented, but we consider both directions as valid edges (connections).

Or as a list of of edges²:

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

Or for each vertex³ (node), the list of its adjacent vertices:

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

Or as a dictionary⁴:

{"1":[2,5],"3":[7,4],"7":[6,3,8]}

Any of these, and any other reasonable input and output formats (you optionally may use one format for input and another for output) are allowed, but you must state what your formats are. However, it is required that your formats support under-representing (e.g. [3,7] but not [7,3]) and over-representing (e.g. both [3,7] and [7,3]).

Walk-through

Let's use the representation [[1,2],[1,5],[3,4],[5,1],[6,7],[7,3],[7,8]]. Since 1 is connected to 2 then 2 is also connected to 1, so we add (it doesn't matter where) this edge (connection):

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

It is also possible to travel [1,5] in reverse, but that pair is already represented further in the list. Now note that it is possible to find a path from 2 to 5, and vice versa, via 1, so we add these two edges:

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

This completes the left side of the graph. Similarly, we process the right side by adding the reversals of [3,4], [6,7], and [7,3]:

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

Two-step paths via 3 are possible, so we add [7,4] and [4,7]. Similarly, two-step paths via 7 are [6,3], [3,6], [6,8], [8,6], [3,8], and [8,3]:

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

Finally, we add the three-step paths [6,4], [4,6], [4,8], and [8,4]:

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

And this is our answer. It could of course be in any order.

---

1. ^{Though the connections do not have direction, I've only put in one entry in the table for each connection, and obviously the diagonal is all-true too, as every node is reachable from itself.}
2. ^{Since the connections in this challenge do not have a direction, [1,5] and [5,1] are the same connection. This serves to illustrate that such may occur in the given data.}
3. ^{Here, each node must have its own list, as the lists are paired to their points by their position in the data. However, each list need not be exhaustive as long as all connections are represented somewhere.}
4. ^{Here, we can omit entries that are fully covered by the other entries.}

code-golf path-finding graph-theory

Answer 4

"Cumbersome Crown words"

Introduction

This is my first entry here, so please be gentle if it's poorly stated. I'll need a bit of guidance to make it a good submission.

I am a typewriter maker, and I want to prove that the design of my competitor, Mr. Crown, is very inconvenient to use. To do that, I want a list of the most cumbersome words to type out on a Crown typewriter.

Challenge

Write a program that takes an argument "n" as a positive integer. You may load the Unix words list from any source (ignore case; discard any word containing anything outside of A-Z, such as "O'Brien", "L'vov", etc.). Given the layout shown below, output the "n" most cumbersome words to write, one result per line. Each result is the cumbersome word, some form of separator (eg. a space), then their word score (see below) with two decimals of precision (and your choice of decimal separator). Bonus if results are sorted in descending order by their word score, and further bonus if ties (by score) are also sorted in alphabetic order.

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

Word scoring

Assume the pointer starts in the leftmost position, on "X". Count each movement and each hammer strike as one unit, but divide the sum by the number of characters in the word. Hence, sample word scores are:

• THEIR: 4.8 -- 24 units (14 movements, strike "T", movement, strike "H", movement, strike "E", 2 movements, strike "I", movement, strike "R") divided by 5 characters
• LAND: 4.25 -- 17 units (10 movements, strike "L", movement, strike "A", movement, strike "N", movement, strike "D") divided by 4 characters
• FOWL: 9.50 -- 38 units (9 movements, strike "F", movement, strike "O", 13 movements, strike "W", 11 movements, strike "L") divided by 4 characters
• BARBARA : 8.00 -- 56 units (4 movements, strike "B", 7 movements, strike "A", 6 movements, strike "R", 13 movements, strike "B", 7 movements, strike "A", 6 movements, strike "R", 6 movements, strike "A") divided by 7 characters
• X: 1 -- just hit the hammer once and you're done

Note: These examples are not the most cumbersome words.

Example Input and Output

Input:

5

Standard output:

ANNA 4.25

THEIR 4.80

LAND 4.25

BARBARA 8.00

FOWL 9.50

Bonus output:

FOWL 9.50

BARBARA 8.00

THEIR 4.80

ANNA 4.25

LAND 4.25

Scoring submissions and determining the winner

I'm really not sure what the best measure of success is. Definitely not code golf, because I can never distinguish the damn things from line noise or pure black magic. But what then? I'm not very familiar with which competition types are available.

If two solutions are tied for a position, but only one of them uses the bonus output format, then that one wins the tie.

Answer 5

My Number is Bigger Than Yours: KoTH

The concept of this game is simple; each turn, two bots submit a positive integer (in Python, so no upper bound on its size). Whichever bot submits a larger number wins a certain number of points based on the scoring put forward in the next section. This process is iterated a certain number (100?) times to form the competition, with the bot which has the highest score winning the competition between the two bots.

However, scoring is based on some metric of the difference between the submitted values such that the larger the difference is, the smaller the amount of score gained is. I'm trying to decide some metric which heavily incentivizes making a guess which narrowly beats your opponent's guess, maybe with a metric such as 1/(a-b)**2. However, as the numbers will likely grow throughout the iterations, maybe 1/(a/b)**2 might be better.

Example bot whose goal is to beat opponents who pick a constant number:

def constant_beater(my_score, opp_score, my_numbers, opp_numbers):
    if len(opp_numbers) == 0:
        return 1
    return opp_numbers[-1] + 1

The largest concern I see with this challenge is a bot which just increments much quicker than all other bots so that it wins every game with a minuscule amount every time. Maybe to curb this a score that is below a certain threshold for a game is rounded to zero to encourage more competitive choices.

Answer 6

Drawing \$K_n\$ (complete graph with \$n\$ vertices)

Tags: code-golf, graph-theory, graphical-output

---

In graph theory the complete graph with \$n\$ vertices, often written as \$K_n\$, is the graph where every vertex is connected to every other vertex. For example, \$K_3\$ with \$V = \{A,B,C\}\$ has the edges \$\bigr\{\{A,B\},\{B,C\},\{C,A\}\bigl\}\$ - forming a triangle.

Challenge

Given an even \$n \geq 4\$ you will generate/display an image of the graph \$K_n\$ as follows:

• pick an image width \$\texttt{width} \geq 100\$
• pick two distinct colors \$\texttt{vertex_color}\$ and \$\texttt{edge_color}\$
• draw \$1\$ vertex with color \$\texttt{vertex_color}\$ in the middle of the image
• draw the remaining \$n-1\$ vertices evenly distributed on a circle around it
• connect every vertex with color \$\texttt{edge_color}\$

Rules

• the background color doesn't matter (transparent is fine), but it must not coincide with the colors \$\texttt{vertex_color}\$ and \$\texttt{edge_color}\$
• the radius of the circle should be \$\texttt{width/4}\$
• the center of the circle should the middle of the image
• the shape of the vertices doesn't matter, but they must be at least \$3\$ pixels wide
• the edges must not overlap the vertices
• the edges may be dashed, dotted etc.

Examples

Example output for \$K_4\$:

Example output for \$K_{12}\$:

Example output for \$K_{32}\$:

Answer 7

Chain round the number!

A decimal place is a digit of a number's location in a number. In the number 987654321, each digit corresponds to its decimal place. For example, in the number 16111, the 6 is in the 4th decimal place.

Normally when rounding to n decimal places, one checks the digit at n-1 (heretofore called x). If x >= 5, then the digit at n is rounded up. Otherwise the digit at n is rounded down (stays the same). Then, all digits including and after x are turned into 0.

For example, take the number 158, rounded to the 3rd decimal place. The digit at the 2nd decimal place (3rd decimal place minus one) is 5. Because of this, the 1 at the third decimal place gets rounded up. This results in the number being 258. However, the 5 and the 8 both get turned into 0, and so the final result is 200.

Chain rounding is like normal rounding, except that you do it to every digit starting with the digit at decimal place 2. Once you round to the decimal place 2, then you round to decimal place 3, and so on until decimal place n.

For example:

Input: 24472
24472    (2 < 5, so the 7 rounds down)
24470    (7 >= 5, so the 4 rounds up)
24500    (5 >= 5, so the 4 rounds up)
25000    (5 >= 5, so the 2 rounds up)
30000    (Final answer. Non chain-rounded answer would be 20000)

The challenge here is to chain round a number to the highest decimal place possible for that number.

Test cases: (all inputs will be positive whole numbers)

24472 -> 30000
1999 -> 2000    ("1 9 9 9" -> "1 9 10 0" -> "1 10 0 0" -> "2 0 0 0")
9945 -> 10000
2001 -> 2000
9444 -> 9000
9445 -> 10000
13579 -> 10000
24681 -> 30000
1337 -> 1000
5 -> 10
1 -> 1

Answer 8

A Turtle Finds a Portal

The turtle wants to move along the grid to get to his food. He wants to know how many moves it will take for him to get there.

As well since he is slow he has teleporters set up around his domain that he will utilize if it shortens his path. Or avoid them if it lengthens his path.

Meet the turtle

🐢

The turtle lives on a grid $$\begin{matrix} X&X&X&X&X\\ X&X&X&X&X\\ X&X&🐢&X&X\\ X&X&X&X&X\\ X&X&X&X&X\\ \end{matrix}$$ The turtle can move to any adjacent square... $$\begin{matrix} X&X&X&X&X\\ X&\nwarrow&\uparrow&\nearrow&X\\ X&\leftarrow&🐢&\rightarrow&X\\ X&\swarrow&\downarrow&\searrow&X\\ X&X&X&X&X\\ \end{matrix}$$

However, the turtle cannot move to a square with a mountain $$\begin{matrix} X&🌄&X&X&X\\ X&\nwarrow&\uparrow&\nearrow&X\\ X&🌄&🐢&\rightarrow&X\\ X&🌄&\downarrow&\searrow&X\\ X&🌄&X&X&X\\ \end{matrix}$$

The turtle wants to eat his straw berry, and would like to know how long it will take to get to his strawberry $$\begin{matrix} X&🌄&🍓\\ 🐢&🌄&X\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$ This example would take the turtle \$5\$ turns $$\begin{matrix} X&🌄&🍓\\ \downarrow&🌄&\uparrow\\ \searrow&🌄&\uparrow\\ X&\nearrow&X\\ \end{matrix}$$ To get around mountains the turtle uses his teleporter. There are two teleports on the grid that map to each other. Stepping on the teleporter immediately moves the turtle to the corresponding teleporter. $$\begin{matrix} 🔵&🌄&🍓\\ 🐢&🌄&🔴\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$ It is now faster for the turtle to move up twice. Now the turtles shortest path is \$2\$ $$\begin{matrix} 🔵&🌄&🐢\\ \uparrow&🌄&🔴\uparrow\\ X&🌄&X\\ X&X&X\\ \end{matrix}$$

The challenge

Given an initial grid configuration output the number of moves it will take the turtle to reach his strawberry.

Rules

• You may assume that the input grid has a solution

• The input grid may be entered in any convenient format

• The shortest path does not need to make use of the portal

• The turtle cannot pass into mountain tiles

• The turn that the turtle moves onto a teleporter square he is already on the corresponding teleporter. He never moves onto a teleporter and stays there for a move

• You may use any ASCII character to represent mountains, turtle, empty gird square, strawberry.

• You may use either the same character or two different characters to represent the teleporter pairs

• A grid can have more than one path with the same shortest path length

• Each grid will only have one strawberry and two portals

• This is code-golf.

Test Cases formatted as lists

[ ['T', 'X', 'X', 'S', 'X'], ['X', 'X', 'X', 'X', 'X'], ['X', 'X', 'X', 'X', 'X'] ] --> 3
[ ['T', 'M', 'X', 'S', 'X'], ['X', 'M', 'X', 'X', 'X'], ['X', 'X', 'X', 'X', 'X'] ] --> 4
[ ['T', 'M', 'X', 'S', 'O'], ['O', 'M', 'X', 'X', 'X'], ['X', 'X', 'X', 'X', 'X'] ] --> 2
[ ['T', 'M', 'X', 'S', 'X'], ['O', 'M', 'X', 'X', 'X'], ['O', 'X', 'X', 'X', 'X'] ] --> 4
[ ['T', 'M', 'S', 'X', 'O'], ['X', 'M', 'M', 'M', 'M'], ['X', 'X', 'X', 'X', 'O'] ] --> 7

Test Cases formatted for humans

T X X S X
X X X X X
X X X X X --> 3

T M X S X
X M X X X
O X X X O --> 4

T M X S O
O M X X X
X X X X X --> 2

T M X S X
O M X X X
O X X X X --> 4

T M S X O
X M M M M
X X X X O --> 7

Credits

Design and structure via: Hungry mouse by Arnauld

Proposed Challenges Edit Advice: Kamil-drakari, beefster

Answer 9

Playing Pickomino

Answer 10

SLIPpery Packets

The Serial Line Internet Protocol is an early internet protocol, used to essentially escape any "packet END" bytes that may appear in a packet. It has since been replaced by the more sophisticated Point-to-Point protocol, however it is still preferred on microcontrollers and low-level devices due to its simplicity.

Your goal is to implement simplified encoding and decoding functions following this protocol as a function/program/subroutine/etc.

The following table lists the special bytes used:

Hex    Dec   ISO 8859-1   Abbrev  
0xC0   192   À            END      
0XDB   219   Û            ESC
0xDC   220   Ü            ESC_END
0xDD   221   Ý            ESC_ESC

(The ISO 8859-1 characters are for visualizing where non-ASCII bytes are in the string.)

Encoding follows this system, iterating through each byte:

• If the END byte appears in the packet, write ESC, ESC_END instead
• If the ESC byte appears in the packet, write ESC, ESC_ESC instead
• Otherwise, write byte verbatim
• At the end, an END byte is appended to the message, and it is returned

Some implementations, such as the reference C implementation from RFC 1055, prepend an END byte to the string to be sent. This is omitted here for simplicity.

Decoding follows in reverse:

• If ESC, ESC_END appears in the packet, write END instead
• If ESC, ESC_ESC appears in the packet, write ESC instead
• Protocol violations that involve ESC followed by a "bad byte" that isn't ESC_END or ESC_ESC should be handled by writing the "bad byte"
• The first END byte seen (not following ESC) is interpreted as the end of the packet. The decoded packet should be returned without the END byte. You are guaranteed to have at least one such END byte appear.

Input/Output

For encoding, input is a packet (string of bytes) and output is the encoded packet (string of bytes).

For decoding, input is a "byte stream" (string of bytes) and output is the (first) decoded packet (string of bytes).

Test cases

Inputs

''                --> 'À'
'test\n'          --> 'test\nÀ'
'testÀ'           --> 'testÛÜÀ'
'teÛst'           --> 'teÛÝstÀ'
'À'               --> 'ÛÜÀ'
'ÛÜÛÝÀÛ'          --> 'ÛÝÜÛÝÝÛÜÛÝÀ'

Outputs

'À'               --> ''
'testÀblah blahÀ' --> 'test'
'teÛÝstÀ'         --> 'teÛst'
'testÛÜÛÜÀ'       --> 'testÀÀ'
'ÛÝÜÛÝÝÛÜÛÝÀ'     --> 'ÛÜÛÝÀÛ'
'ÛÀÀ'             --> 'À'
'ÛµÀ¶'            --> 'µ'

Scoring

Your score is the sum of the number of bytes in your encoding and decoding functions (or programs, etc.)

---

I have also considered requiring functions to take a length of packet in bytes which is used in encoding and decoding (similar to RFC 1055), not requiring handling protocol violations (ex. RFC 1055), and not testing decoding packets that have an END byte as not the last byte. Your opinions on how restrictive this challenge should be are appreciated.

Answer 11

One circle, two inputs, eight outputs

code-golf geometry number pi

Given the values of only two quantities from the following eight quantities ​​(the rest is unknown):

1. Radius of circle: \$\displaystyle R\$
2. Diameter of the circle: \$\displaystyle D=2\times R\$
3. Circumference of the sector: \$\displaystyle C=2\times\pi\times R=\pi\times D\$
4. Area of the circle: \$\displaystyle A=\pi\times R^2\$
5. Angle of the sector: \$\displaystyle\alpha\$
6. Length of arc: \$\displaystyle LA=\frac{C\times \alpha}{360°}\$
7. Area of the sector: \$\displaystyle AS=\frac{A\times \alpha}{360°}\$
8. Perimeter of the sector: \$\displaystyle PS=LA+2\times R=LA+D\$

compute the rest of quantities if possible, else put special output (-1, False,...) if at least one of the quantities can not be computed.

Input

Two quantities with there values (non negative integers)

Output

The values of the eight previous quantities (decimal with any precision or rounded integer).

Example

In this example the inputs is the ordered list of the previous quantities. Values are integers, angles in degrees, and outputs as rounded integers.

[16, ?, ?, ?, 100, ?, ?, ?]   --> [16, 32, 100, 804, 100, 27, 223, 59]
[24, ?, ?, ?, ?, ?, ?, 58]    --> [24, 48, 150, 1809, 23, 10, 120, 58]
[28, ?, ?, ?, ?, ?, ?, 188]   --> [28, 56, 175, 2463, 270, 132, 1848, 188]
[?, 18, ?, ?, ?, ?, ?, 41]    --> [9, 18, 56, 254, 146, 23, 103, 41]
[?, 28, ?, ?, ?, ?, ?, 808]   --> [14, 28, 87, 615, 3191, 780, 5460, 808]
[?, 88, 220, ?, ?, ?, ?, ?]   --> False
[?, ?, 88, ?, ?, 84, ?, ?]    --> [14, 28, 88, 616, 343, 84, 588, 112]
[?, ?, 220, ?, ?, 66, ?, ?]   --> [35, 70, 220, 3851, 108, 66, 1155, 136]
[?, ?, ?, 50, 50, ?, ?, ?]    --> [3, 7, 25, 50, 50, 3, 6, 11]
[?, ?, ?, 254, ?, ?, 18, ?]   --> [8, 17, 56, 254, 25, 4, 18, 21]
[?, ?, ?, 707, 75, ?, ?, ?]   --> [15, 30, 94, 707, 75, 19, 147, 49]
[?, ?, ?, ?, 99, 24, ?, ?]    --> [13, 27, 87, 606, 99, 24, 166, 51]
[?, ?, ?, ?, 140, ?, 175, ?]  --> [11, 23, 75, 450, 140, 29, 175, 53]
[?, ?, ?, ?, 324, 85, ?, ?]   --> [15, 30, 94, 709, 324, 85, 638, 115]
[?, ?, ?, ?, 324, ?, 3465, ?] --> [35, 70, 219, 3850, 324, 197, 3465, 267]
[?, ?, ?, ?, ?, 66, 88, ?]    --> False

Rules

• The input and output can be given in any convenient format.
• Specify in the answer the special output when quantities can not be computed all.
• Specify in the answer whether the angle is in degree or radian or other unit.
• π can be set to 3.14 or 22/7 or 355/113 or any more precise value.
• No need to handle invalid input values.
• Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
• If possible, please include a link to an online testing environment so other people can try out your code!
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Answer 12

Gregorian-Hijri(Islamic) Calendar Conversion code-golfcalendar

Introduction

The Hijri, or Islamic calendar is a lunar calendar used in the Islamic countries to determine the dates of traditional events. The year in the Hijri calendar is usually denoted AH xxxx. The Hijri calendar has an epoch on 16 July 622 on Julian calendar.

Like other lunar calendars, in the Hijri calendar a year consists of 12 months, each month consists of 29 or 30 days. A year is thus 354 days, or in leap years there are 355. On average there are 11 leap years every 30 years.

There is a tabular variant which uses arithmetic calculations in place of astronomical observations to determine the dates. There is also a solar version of the Hijri calendar, which is used in Iran and Afghanistan.

In this challenge, only the tabular variant will be discussed.

The tabular Hijri calendar

All western dates below will be shown in (possibly proleptic) Gregorian even if the date is before 15 October 1582.

There are 12 months in each year in the Hijri calendar, with alternating 29- or 30-day periods. The odd months have 30 days, and the even months have 29 days (except for the 12th month Dhu al-Hijjah in leap years which also has 30 days). The month names are as follows (according to this Wikipedia template):

#    Name              Number of days
1    Muharram          30
2    Safar             29
3    Rabi' al-awwal    30
4    Rabi' al-Thani    29
5    Jumada al-awwal   30
6    Jumada al-Thani   29
7    Rajab             30
8    Sha'ban           29
9    Ramadan           30
10   Shawwal           29
11   Dhu al-Qidah      30
12   Dhu al-Hijjah     29 / 30 (in leap years only)

There are 11 leap years every 30 years. There are 3 versions to determine the leap years, but the most common version is to set the years with \$y\in\{2,5,7,10,13,16,18,21,24,26,29\}(\text{mod }30)\$ as leap years. (Be reminded that the calendar stars from year 1.)

The Hijri calendar has its first day (i.e. 1 Muharram 1) on 19 July 622.

As an example, we now convert the date 8 February 2019 into Hijri (Here we define a cycle to be 30 years):

1. Date: 8 February 2019
2. Dates from the Epoch: \$1396 \times 365 + 339 + 166 + 38 = 510083\$
   • There are 1396 (\$2019 - 623\$) full years, so \$1396 \times 365\$ days
   • There are 339 (\$349 - 14 + 4\$) leap years between 2 dates
   • There are 166 days between 19 June 622 to 1 January 623, and 38 days between 1 January 2019 to 8 February 2019
3. Cycle: \$510083 \div 10631 = 47\text{ (cycles) and }10426\text{ (days)}\$
   • One ordinary year is 354 days and there are 11 leap years in a 30-year cycle, so total days in a cycle is \$354\frac{11}{30} \times 30 = 10631\$
4. \$10427 - (354 \times 29 + 11) = 150\$, so this this is the 150th day of the 30th year in the 48th cycle, which is \$47 \times 30 + 30 = \text{(AH) }1440\$.
   • The subtraction has 18 \$354\$s and 11 \$355\$s, but there is not enough space to write it all.
5. \$150 - 30 - 29 - 30 - 29 - 30 = 2\$, so this is the 2nd day of the 6th month in the year AH 1440.

As a result the complete Hijri date of 8 February 2019 is 2 Jumada al-Thani 1440.

Challenge

Write a program or function that converts the (Gregorian) input date into the corresponding Hijri date.

The program or function may receive the input date in any reasonable format, but it must output the Hijri date in the format of [date] [month name] [year]. The italics above shall be ignored.

The input month and day may be 0-indexed for convenience, but you must state so if you use this convention.

You may assume that the input is always a valid Gregorian date, and is always not earlier than the Gregorian epoch of the calendar, 19 July 622.

Sample I/O

Input:  "19 July 622" / "622-7-19" / [622, 7, 19] / (622, 6, 19) (0-indexed month)
Output: "1 Muharram 1" (The epoch date)

Input:  "8 February 2019" / "2019-2-8" / [2019, 2, 8] / (2019, 1, 8) (0-indexed month)
Output: "2 Jumada al-Thani 1440" (The example date)

Input:  "12 August 2019" / "2019-8-12" / [2019, 8, 12] / (2019, 7, 12) (0-indexed month)
Output: "10 Dhu al-Hijjah 1440" (The start date of Eid ul-Adha in AH 1440)

Input:  "9 August 2021" / "2021-8-9" / [2021, 8, 9] / (2021, 7, 9) (0-indexed month)
Output: "30 Dhu al-Hijjah 1442" (The next leap day)

Winning Criteria

As this is a code-golf, shortest answer of each language wins. Standard loopholes are banned by default.

Answer 13

Unique Skittle Pairs

code-golf This is my first question, so hopefully it's OK.

I like to eat Skittles. However, I only like to eat them in pairs, and and those pairs must not have two Skittles of the same color. Your task is to find the most pairs that you can that match these requirements.

Challenge

Input (taken from standard input) is a set of Skittles formatted like so: pyyyggoooorr, where p is purple, y is yellow, g is green, o is orange, and r is red. The number of letters for each color corresponds to the number of Skittles that are that color. The only colors used in this challenge are purple, yellow, green, orange, and red. The input will always be even in length and lowercase.

Output is the most possible pairs of Skittles that I like to eat given the input. Different outputs don't matter as long as they are valid, i.e. for an input of pygo, both py go and po gy are valid outputs. Output for invalid input doesn't matter.

The output must be in the same format as the test cases.

Examples/Test Cases

Permutations of these solutions are valid. You do not have to output all valid outputs. Multiple output lines here means multiple valid outputs.

> ppyy
py py

> yggooo
yo go go

> pyygorrr
pr yr yg or
py yr gr or

> yggoor
yg go or
yo go gr
go go yr

> yggor
(anything, including no output/errors)

> gygoro
yg go or
yo go gr
go go yr

> ygoOor
(anything, including no output/errors)

> ggorrrrr
gr gr or

> pppyyygggooorrrr
py py py ro ro ro rg
po po po ry ry ry rg
py po py ro ry ro rg
etc.

Least bytes wins.

Answer 14

Sort according to cyclic order

Cyclic order on a set is a function f taking three distinct elements of a set, returning bool and having following properties:

1. If f(a, b, c) then f(b, c, a)
2. If f(a, b, c) then not f(c, b, a)
3. If f(a, b, c) and f(a, c, d) then f(a, b, d)
4. One of f(a, b, c) and f(c, b, a) is true

Values of f when arguments are not distinct don't matter. You are given a list of dictinct numbers and a function f posessing the above properties when arguments are taken from the list. Your task is to arrange the numbers in such an odrer that

f(a, b, c) if and only if k > j > i or i > k > j or j > i > k

(i.e. numbers a, b, c come in that order modulo cyclic permutaion)

Score is the total number of calls to the function f on some dataset.

It's not very clear to me how to create the dataset and how to count calls to f across different languages. Is it better to just give a list of n*(n-1)*(n-2) values of f as input (and score by bytes)?

Answer 15

Data.List.nub :: Eq a => [a] -> [a]

Tags: code-challenge, haskell, list

---

O(n^2). The nub function removes duplicate elements from a list. In particular, it keeps only the first occurrence of each element. (The name nub means `essence'.) It is a special case of nubBy, which allows the programmer to supply their own equality test.

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

Goal

If you ever golfed in Haskell and you kind of needed to deduplicate a list, chances are that you chose a different route or were annoyed that there seems to be no solution shorter than importing Data.List.

In this challenge you will write a function [a] -> [a] (unnamed or named) which removes duplicates from a list, the order does not have to be preserved.

Scoring

Since I don't think it's possible to get something shorter than 20 bytes and Haskell sometimes is really annoying to golf with if you want to use lengthy functions, the scoring mechanism will count tokens, please use this program to count the tokens and use the generated template.

• If your solution is a named function or operator, it must not be defined in another file/module (ie. banning imports).

• Each solution may impose type constraints, each set of type constraints counts as its own language, compiler flags can be used without any restrictions.

• Your solution may not assume that the input is non-empty, however if you have an elegant solution which fails on empty input, feel free to include it in your post.

How are tokens counted?

Tokens are counted by using GHC's lexer which you can import Language.Haskell.Extes.Lexer, except that newlines will count as a token too.

White space is ignored, every token of the language will count as one, no matter how long it is so ma >>= f will count as the three tokens ma, >>= and f the same holds true for string or number literals (eg. "abc" or 1.0 each count as 1).

Test cases

[] -> []
[1] -> [1]
[1,1,1] -> [1]
[3,1,1,2] -> [1,2,3]
[1,2,3,3,2,1] -> [1,2,3]

Answer 16

Make a markdown Table of contents parser

A simple Code Golf challenge in the likes of the Markdown parser.

The parser should ignore normal text and other markup (without an # before it).

Some valid headers are: ### Header 3, # Header1, Text # Header

Sample input:

# Hello
Lorem # Hello2
Hi this is normal text

## This is a subheader
Lorem ipsum

### Subsub
Solor di amet

# Hello again
This is more text!

sample output:

Hello
Hello2
- This is a subheader
--- Subsub
Hello again

Answer 17

Growth of the Jackpot (Tentative Name)

(Gauging interest)

king-of-the-hill game

---

There is a money pot that gains $1 for every player currently in the game each turn. At any time, a player can decide to take the money and run or stay in the game hoping for a larger pot. If more than one player decides to leave at the same time, the money will be divided evenly among them, rounded down, with the remainder being put back in the pot. If after 100 rounds, there are still players left in the game, they will split whatever is in the pot at that time. Whoever has the most money at the end of the game wins.

Write a bot to play this game. You will always know the size of the pot, how many players are currently playing, how many were initially in the game, and the current first place amount of money.

---

On the surface, the optimal strategy is to bail out on turn \$\lceil{100n \over {2n - 1}}\rceil\$ (where \$n\$ is the number of players) because that turn guarantees that nobody can do better than you. But then if everyone does that, they'll split the pot and lose, so the best action to take is not immediately obvious.

---

One possible variant to round limits would be to have it cost each player $1 per turn they stay in the game, with each player starting with $100 and being forced to take the money and run when they have none left to contribute. Then the game could be run for several rounds.

Answer 18

Hungry Monster 9

My first challenge. Feedback is appreciated.

A monster shaped like 2 is hungry and wants to become a 9. To do so he will eat food, that is shaped like the number 1, seven times.

0000000000
0000100000
0100000000
0000001000
0000020000
0100000000
0000000100
0010000000
0000001000
0000000000

Challenge

It starts with a grid filled with 0, containing the digit 2, and seven times the digit 1. The 2 (aka the monster) needs to move to the closest 1. Upon "eating" the number, 2 will change to 3, and continue to move to the next closest number.

Write a program that outputs the next correct state.

Input specifications

• The input grid is a rectangle and can be of any size. It doesn't need to be a square.
• The input can be at any state. For example a grid with a 6 and three times 1 left.
• The grid will contain exactly one digit higher than or equal to 2 (the "player").
• The grid will contain seven times or less the number 1.

Rules

• When the monster gets on the position of where a 1 is, its digit increases by 1.
• The monsters previous position becomes 0.
• When the monster is 9, it does not move.
• The monster can move in 8 directions (horizontally, vertically, diagonally).
• The monster moves to the closest 1. If there are multiple closest, you may choose any of those. It is not required to be random.

Example Input and Output

This is an example of the first 4 states (and example inputs/outputs):

0000000000
0000100000
0100000000
0000001000
0000020000
0100000000
0000000100
0010000000
0000001000
0000000000

0000000000
0000100000
0100000000
0000003000
0000000000
0100000000
0000000100
0010000000
0000001000
0000000000

0000000000
0000100000
0100030000
0000000000
0000000000
0100000000
0000000100
0010000000
0000001000
0000000000

0000000000
0000400000
0100000000
0000000000
0000000000
0100000000
0000000100
0010000000
0000001000
0000000000

The output is allowed to be an array of lines. ["0000000000", "0100000000", "0000080000"]

Answer 19

Low diversity quine.

A low diversity quine is a quine (program that outputs it's source code) that uses a low amount of distinct characters.

Scoring:

As a code-golf challenge the program with the lowest score wins.

Score is calculated as: NumberOfDistinctCharacters x ByteCount

Rules:

Standard quine rules apply. Most notably: No source code reading

Answer 20

A Note On Frequencies code-golf arithmetic

In western music, we denote "musical notes" as a letter A-G, optionally followed by a ♯ or ♭. An "octave" is a collection of 12 notes, beginning at C, such that the frequency of any given note is double that of the same note in the octave below, and half that of the same note in the octave above. With this in mind, notes are usually denoted as /[A-G][♯♭]?\d+/, which is a "note" (letter plus optional sharp or flat) and an octave number.

In physics however, musical notes are measured as a frequency of oscillation, typically in hertz (Hz). These days, the international standard is that "Middle A" (The A note of the 4th octave) is 440hz, and all other notes are tuned relative to that.

The frequency of note \$n\$ can be calculated as such:

\$\begin{equation}f(n)=\left({\sqrt[{12}]{2}}\,\right)^{n-49}\times R\end{equation}\$

Where \$n\$ is the index of the note (A0 being 1) and \$R\$ is the frequency of A4

Calculating note indices

Indices within an octave:

C     - 1
C♯/D♭ - 2
D     - 3
D♯/E♭ - 4
E     - 5
F     - 6
F♯/G♭ - 7
G     - 8
G♯/A♭ - 9
A     - 10
A♯/B♭ - 11
B     - 12

The note index of a note (including octave) can be calculated as:

\$n + (o*12) - 9\$

Where \$n\$ is the note index as indicated by the above table, and \$o\$ is the octave number

The Challenge

Given a musical note as input, in the following format: /[A-G][♯♭]?\d+/ output the frequency of the note in hertz to at least 3 decimal places.

Rules

• You may optionally take #b in your input as opposed to the unicode ♯♭
• You may optionally provide the calculated frequency in millihertz (mHz), removing the need to directly handle real numbers.
• For the purposes of this challenge, \$R = 440\$

Scoring

This is code-golf so fewest bytes in each language wins!

Sandbox

• Is this a dupe?
• Is it a good challenge?
• Should I bother requiring answers to first parse the note (eg B#7) to a note index, or just require answers take \$n\$ directly?

Answer 21

Sort a list using a stack and a queue

code-golf restricted-complexity array-manipulation sorting

Consider an unsorted list of length n, containing the integers 1 through n. Your job is to sort them using a stack (FIFO) and a queue (LIFO) and a single register. To do this, you have access to six commands

i    Input the next integer onto the register
o    Output the value of the register
Q    Place the value of the register at the tail of the queue (enqueue)
q    Place the value of the head of the queue in the register (dequeue)
S    Place the value of the register at the top of the stack (push)
s    Place the value of the top of the stack in the register (pop)

A few examples (sorting in ascending order):

Input:
 [1 2 3 4] 
Commands:
 ioioioio

Input:
 [3 2 4 1]
Commands:
 iQiSiQiosoqoqo

Challenge

Write a program or function that, given some (unsorted) list, returns a sequence of commands that outputs an ordered list. However, the number of commands should grow as \$o(n^2)\$, i.e., strictly smaller than \$\mathcal{O}(n^2)\$. That is, for sufficiently large \$n\$, you must always use less than \$cn^2\$ commands (with \$c\$ some positive constant) to sort the list.

• The input is flexible. The list of size \$n\$ may start from \$0\$ or from \$1\$ and will always contain all integers from \$0\$ to \$n-1\$ or from \$1\$ to \$n\$ respectively. You may take \$n\$ as a separate input if desired.
• The output is flexible. You may choose a different set of unambiguous command identifiers instead of ioQqSs. You may output as a string (which is allowed to contain superfluous characters such as delimiters, linebreaks, etc), or as an array or list of commands.
• Your entry must indicate the worst-case output size, e.g., \$\mathcal{O}(n)\$, \$\mathcal{O}(n\log(n))\$, which must of course be strictly smaller than \$\mathcal{O}(n^2)\$.

---

A few notes:

• Things like ii, qi, oo should never happen. You only have one register, and overwriting it would mean you can no longer output the full sorted list.
• A naive approach would be to put the entire input in the queue iQiQiQ... and then cycling through the queue qQqQqQ... until the register contains the next integer in order. However, this approach would mean you have \$\mathcal{O}(n)\$ cycling commands for \$\mathcal{O}(n)\$ numbers, which would be \$\mathcal{O}(n^2)\$ and thus does not meet the complexity requirement.

Answer 22

Performance-Based Resource Gathering/Trading

king-of-the-hilljavascript

In this KoTH, the goal is to be the bot with the highest amount of money by the end of the game. Bots perform actions to earn money in turns. There are a set number of rounds in a game, and each round allows each bot to play. In a play, bots have set number of milliseconds to run as many turns as possible, growing their crops/trees/animals, mining for materials, or harvesting materials.

Earning Money

There are four basic "professions", though bots are not bound to a specific profession. These professions require land to collect resources, and land is zoned by its owner as one profession:

Farming

Farming uses turns to plant, grow, and harvest crops. There are three crops: wheat, carrot, and cotton. Each unit of land zoned for farming can hold up to 40 crops simultaneously. There is no randomness in farming. The crops are:

• Wheat: The most basic crop, wheat, takes 40 turns to grow. It is planted with 1 wheat seed, and grows into 2 wheat
• Carrot: Carrots are the fastest growing crop, taking only 16 turns to grow. Carrots are planted with one carrot, and grow into 4
• Cotton: Cotton grows very slowly, but is a valuable item in the economy. It is planted with 1 cotton seed, and produces 3 cotton in 96 turns.

Ranching:

Ranching uses land to raise animals, which can be used to produce meat and other goods. Ranching is only very mildly randomized. There are three animals: chickens, cows, and sheep.

• Chickens: A chicken takes up 2.5% of the land it occupies. Chickens lay eggs once every 8-10 turns, and an egg can be hatched into a chicken in 64 turns. Chickens last 192 turns before they stop producing eggs. Chickens can be harvested for 1 meat
• Cows: Cows do not produce items until they are harvested. A cow takes up 5% of the land it occupies, and are "mature" 144 turns after being bought. Mature cows can be harvested for 6-8 meat and 2 leather
• Sheep: A sheep takes up 6.25% of the land they occupy. Sheep last indefinitely, and produce wool every 112-132 turns. They can be sheared for 2 wool each time this happens. Sheep do not produce anything when harvested, and never stop producing wool

Woodcutting:

Land zoned for woodcutting contains 12 spaces for trees. Woodcutting is a moderately random-based profession. There are three types of trees available:

• Oak: Oak saplings take 120-132 turns to grow, and produce 8-16 wood
• Cedar: Cedar saplings take 84-96 turns to grow, and produce 5-9 wood
• Hemlock: Hemlock saplings take 240-280 turns to grow, and produce 14-22 wood

Mining:

Mining is a completely random-based profession. Each turn in which the bot mines produces one of three materials:

• Stone: Stone has a 65% chance
• Iron: Iron has a 30% chance
• Gold: Gold has a 5% chance

Economy/Raw Materials

You may be wondering: What do the bots do with all these materials? Well, factories can be built on land, and used to make new items. These items can be sold to NPC traders, or used by bots to improve their efficiency at a profession.

Wood: Wood is used for the creation of tools, construction of factories, and as a fuel source

Stone: Stone is used for construction and tools

Iron: Iron is used for the creation of tools and factories

Gold: Gold is highly sought after by traders

Wheat: Wheat is necessary to feed cows and sheep, as well as the creation of bread

Carrot: Carrots are necessary to feed chickens

Cotton/Wool/Leather: The Loom factory converts these materials into cloth, which is sold to traders or used to make clothes

Eggs: Eggs are necessary to make bread

Factories

There are three factories, each for a specific type of good:

Loom: The loom converts cotton, wool, and leather into cloth, and cloth into clothes. Clothes increase the amount of time to run turns by 20% per piece equipped, up to 3, for the next 5 rounds.

Bakery: The bakery converts wheat into flour. Flour and eggs are then converted into bread, which can be sold or equipped. When consumed, bread increases time to run turns by 25% for the next 2 rounds. Meat can also be consumed, but increases the time by 40% for 3 rounds.

Smithy: The smithy creates tools. These tools are: plow, trough, axe, and shovel. Each tool doubles the time for ticks in the round it is used.

Other

This is not complete, and many numbers still need to be added or changed to make things more equal between professions. Things like land still need to be figured out, but that's what the sandbox is for I suppose. This seems a little complicated, but each bot will probably stick with either a single profession or just be a factory owner.

Answer 23

Dining philosopher problem

This question is motivated by the lack of concurrency related puzzles on PPCG. The goal of this question is to solve the Dining Philosophers Problem.

---

What is the dining philosophers problem (DPP) ?

The DPP is one of the most famous concurrency problem, used to illustrate what is a deadlock for instance.

n philosophers are dining together at a circular table. Between each philosopher, there is a fork. In order to eat, each philosopher should have two forks (one in each hand).

The problem is that, if all philosophers try to take the fork on their right, then wait until the one on their left (taken by the philosopher on their left) is available, they will wait forever.

Solving the problem is finding a strategy so that no philosopher waits forever.

---

Your program

Takes an input n, the number of philosophers (and the number of forks). Run n philosophers in parallel, each philosopher output its dining events.

There are 4 different dining events possible:

1. Philosopher i takes the fork j;
2. Philosopher i tries to take the fork j, but fails (the fork is already taken);
3. Philosopher i release the fork j;
4. Philosopher i eats (and leave the table/release the forks and do not compete anymore).

A trace is correct if:

• A fork is taken by at most 1 philosopher at any time (between two events 1 for the same j, there must be an event 3 for that j).
• A philosopher only interacts with neighbourgs forks (in events 1, 2, 3, j is i or (i+1)%n).

The output format is a sequence of events. You can choose how to represent each event, but the following is suggested:

1. i+j
2. i!j
3. i-j
4. i

A (non-golfed) C version is available here, with output in plain english. Try it online!

Rules

This is code-golf. You should, in addition, consider the following points:

• You must solve the problem concurrently, i.e. create one thread per philosopher and use usual atomic operations. Said otherwise, you should output a trace of an execution, not compute a possible scheduling.
• You can not rely on time to solve the problem (no such thing as: philosopher 1 waits 1 sec, philosopher 2 waits 2 sec, etc..). To generalise, you can not use the identifier of the philosopher to do something else than finding the neighbourg forks.
• If you add a TIO link in addition to your code, you can add any thread yield (or equivalent in your language) in the TIO version, in order to emphasize non-determinism.
• If you add a TIO link in addition to your code, you can add use an extra lock to avoid concurrency artifacts on standard output, on the TIO version. You can not use that lock to solve the problem (i.e. if we remove this lock, the solution must remain correct). In particular, you can use this lock to atomically do an event and output it.

Example: the TIO version of:

try = try_lock(fork_1)
if (try is success)
  output("1+1")
else
  output("1!1")

can be :

lock(output_mutex)
try = try_lock(fork_1)
if (try is success)
  output("1+1")
else
  output("1!1")
unlock(output_mutex)
yield()

Example run

for n = 4, the following are possible outcomes (notice that both are traces generated from the same program, it happened that the scheduling was not the same on both runs):

0+0
0+1
0
0-1
0-0
1+1
1+2
1
1-2
1-1
3+3
3+0
3
3-0
3-3
2+2
2+3
2
2-3
2-2

0+0
2+2
2+3
1+1
1!2
0!1
2
2-3
2-2
1-1
1+1
1+2
1
1-2
1-1
0-0
0+0
0+1
0
0-1
0-0
3+3
3+0
3
3-0
3-3

---

Questions to be answered:

• The goal is to have a concurrent implementation of the problem (i.e. the scheduling of events should not be fixed, there should be a thread per philosopher, etc.). How to emphasize that in an understandable manner ?
• Concurrency leads to problems, such as interleaving in stdout. Here, what I have in mind is that when the philosopher thread takes a fork, it can atomically output it on stdout, in order to reflect what actually happens. Said otherwise, I'd like to propose a way to assume that the output reflects locks behavior. Another problem is that, for small n, the output is likely to be deterministic (thread i finishes before i+1 is even started). Hence I'd like to allow the programmer to add any thread_yield() (or sleep, or anything that introduce non-determinism) to break that.
• This kind of puzzles, intended to be solve by distributed algorithms, is quite unusual on ppcg. Codegolf is a possible scoring system, but maybe there are better systems (like, the less synchronisation, etc.).

Answer 24

Given a position of a chess piece and another square, determine if the chess piece attacks that square

Input

Input would be in the form

Qe4 c6

Where the first term denotes the piece and its position and the second term is the square we're interested in.

Labels for pieces are:
K - king
Q - queen
R - rook
B - bishop
N - knight
P or empty - pawn

In fact, the input could be left to be decided by the programmer, to make them creative in coming up with the most efficient input method, for example any of these could be valid, if the programmer decides so:

Qe4, c6
[Qe4, c6]
Qe4c6
qe4-c6

Even the order could be reversed if that makes parsing easier. Basically the input could be left completely to the programmer's liberty.

Output

So in the above case the input

Qe4 c6

would give an output

True

Because the queen on e4 indeed attacks c6. Outputs like 1 or any other boolean outputs would also be allowed.

An input like

Nc3 a3

would produce

False

because a knight on c3 doesn't attack a square on a3.

Possible problems

There are some invalid inputs possible, like:
1. Wrong letter for a piece, like "Te2"
2. The coordinates which don't exist, like "k9"
3. The second square being the position of the piece itself, for example "Qa3 a3"

Should this be included in the rules or better not to not make it too complicated?

Answer 25

Randomly produce a (name of a language) source file that is possibly a quine

Write code in any language that randomly generate a (name of a language) (Java?) source file, meeting the two criteria:

• It must always (with probability 1) compile successfully in a (language) compiler and version of your choice.
• It must have non-zero probability to be a quine in (language).

You don't have to make it able to generate all possible programs, and the probability doesn't have to be uniform. The objective is to write a generator shorter than the shortest possible quine in (language) compressed. Technically your code could be deterministic and generate only one program, that is a quine. But it isn't supposed to be competitive.

Your code must not have the potential to damage the computer. But it doesn't matter what the generated (language) program does when it is not the quine that qualifies your answer.

(Restrictions about compiler flags to be added.)

You could either use the built-in random functions and assume they generate true random numbers, or request random information from the input (details to be added). Your code only need to have probability 1 to terminate.

Shortest code wins.

---

Possible rule

You may not call any (language) compiler or anything else that could check (language) syntax.

---

I was thinking about C++, but there are short patterns to execute any binary machine code. The language should also have a verbose structure, and not a too short quine.

Candidates: Java, Haskell, Shakespeare Programming Language, Mornington Crescent, SQL, ferNANDo.

Or: Generate a PNG file that is possibly this image. But that may depend to much on a PNG library, and the other part is trivial.

Answer 26

Finding distinct road sections

I was recently working on a grid-based road procedural generator, and thought of a neat idea for a new challenge:

The Task

Given a square (equal width and height) 2d array in which each item is one of 2 distinct values (of your choice): grass and road (I will use _ and # in examples), output the grid modified such that each distinct segment of road tiles has had its values changed to a unique value.

Two road tiles are considered to be part of the same segment if they neighbor each other in at least 1 cardinal directions.
Diagonal neighbors are not considered to be part of the same segment (unless they are connected cardinally elsewhere)
A single road tile with no connections is considered to be its own distinct segment.

You may choose the 2 input values used, and all output values used.
"Grass" tiles must remain unchanged.

You may assume there will always be at least 1 road segment, and that the array dimensions will be no larger than 64 by 64

Example:

Input:

___#__######____
_###__#_#_______
___#_##_########
___#____________
####_#######__##
_#_#_#__________
_#_#_#______####
___#_#__________
##_#_##_________
______#_________
_______#_#######
______##________
__###_#_______##
_##_____________
__#######_______
__#_____________

_ is "grass" and # is "road"

Output:

___3__111111____
_333__1_1_______
___3_11_11111111
___3____________
3333_4444444__22
_3_3_4__________
_3_3_4______5555
___3_4__________
66_3_44_________
______4_________
_______7_8888888
______77________
__000_7_______99
_00_____________
__0000000_______
__0_____________

Scoring

This is code-golf so fewest bytes in each language wins

Test cases

TBA

Sandbox

• I feel like the task is poorly worded, but can't think of a better way to word it.

Answer 27

Draw a regular prism

Input

The input is a single integer i between 3 and 8.

Output

The image of a regular prism with the two regular polygonal faces having i edges each. For example, if i=3 your code should draw a triangular prism using two equilateral triangles.

Rules

The diameter of the polygonal (i.e. triangular if i=3) faces must be at least 200 pixels as should the distance between the regular faces. You can show the image at any angle you like as long as at least two faces of the prism are visible, including one of the two regular polygonal faces.

The edges of the prism that are visible should be in black and the edges that are not visible should be drawn with dotted black lines, a dotted line being a line where in at least 3 distinct, non-connected places (meaning separated by black) there's an absence of black color.

Examples

graphical-output code-golf

Answer 28

Moved to Make Gimbap cutter

Answer 29

Draw an Image on the screen efficiently

code-golf

Imagine you have a special rectangular screen made of square pixels. It consists of \$n\$ rows and \$m\$ columns. For every row and every column there is one swich (so \$n + m\$ switches in total). To turn a certain pixel on - let's say at position \$(i,j)\$ - we can press switch \$i\$ (of the row switches) and switch \$j\$ (of the column switches) at the same time.

As soon as some pixel has been turned on, it stays on, even if we press the same combination of switches again. META: Is this a good idea? Or should we say that each pixel should be turned on exactly once and may not be activated again?

But we can also press an arbitrary number of switches at the same time: Lets say we press switches \$0,2,3\$ of the row switches and \$1,5\$ of the column switches, then all the pixels \$(i,j)\$ with \$i \in \{0,2,3\}\$ and \$j \in \{1,5\}\$ will get turned on, so all the pixels \$(0,1),(0,5),(2,1),(2,5),(3,1),(3,5)\$.

If we now want to draw a picture on the screen you could do that pixel for pixel, and we'd need \$n \cdot m\$ actions in the worst case - that is, when we have to turn on every pixel. But as we can press an arbitrary number of switches at the same time, we can do better than that. We can for example do row by row: This means we select one switch for the current row, and all necessary column switches to activate all the pixels we need for this row, so in total we would need \$\min\{n,m\}\$ actions. But can we do better than that?

The task is now to write a program that given some black and white image computes a shortest sequence of actions (=simultaneous switch activations) that turns on exactly all the white pixels of the given image.

Details

• You can also take a matrix/list of lists as input, or a list of the coordinates of the active pixels.
• You can additionally take the size \$(n,m)\$ as an input (or \$(n-1,m-1)\$ if you prefer.

• The output is also flexible: You can represent every action as a list of two lists with the corresponding indices of the switches where each of the indices are in \$\{0,1,\ldots,n-1\}\$ or \$\{0,1,\ldots,m-1\}\$ respectively (or also 1-based indexing is fine), or alternatively you enumreate all switches as \$\{0,1,2,\ldots,n+m-1\}\$ and use just one list to represent this action.

  Alternatively you can also just use lists of size \$n\$ and \$m\$ (or one of size \$m+n\$) with truthy and falsey values representing the switches that get activated.

Related: Matrices Generated Using Rectangles

Answer 30

Cumbersome IO format cops-and-robbers

The cops' task is to write a program in language A to solve (task about integer lists 1) and a program in language B to solve (task about integer lists 2). The second program must be able to use the output of the first program.

Others could golf your programs. Highest (C + total length of your programs) / (C + minimum total length of the programs without the restriction) wins. (C is a fixed constant to be chosen.)

(Details to be written. The format would be similar to The Bowlers-Golfers Fraction War. Minimum lengths of the two parts would be taken from other challenges.)