Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Comments addressing specific points mentioned in the proposal
• Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Answer 1

Interpret BigTalk

Talk is a language which takes a single bit of input and has four commands:

• 00 If the accumulator is 0, set the accumulator to 0.
• 01 If the accumulator is 0, set the accumulator to 1.
• 10 If the accumulator is 1, set the accumulator to 0.
• 11 If the accumulator is 1, set the accumulator to 1.

These can be interpreted as replacement commands. We're going to extend that concept to positive integers, and make the language more complicated.

The language we're going to be defining is called BigTalk. It has an accumulator, which is a list of positive integers, initially set to only the input.

Programs are a series of commands. Each command is a pair of lists of integers, like ([24, 2], [32, 1]), and means to replace the first as a sequence with the second, as many times as it occurs.

The program runs repeatedly until the accumulator does not change. Finally, the accumulator is output.

For example, with the input [5, 5, 5, 5] and the program ([5, 5], [3, 2, 1]), ([3], [5]), ([2, 1, 5], [5, 1, 2]), the list goes:

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

Your challenge is to interpret this language. You may take input and program in any reasonable format.

This is code-golf, shortest wins!

Testcases

In the format of input, commands.

[5, 5, 5, 5], ([5, 5], [3, 2, 1]), ([3], [5]), ([2, 1, 5], [5, 1, 2]) -> [5, 2, 1, 1, 2, 2, 1]
[4], ([4], [4, 4]) -> Infinite loop
[2, 19, 13], ([13, 19], [2]) -> [2, 19, 13]
[39, 1, 23], ([1], [39, 23]), ([39, 39], [1, 1]), ([23, 23], [1]) -> [39, 23, 39, 23, 39, 23]

This language may be Turing-complete, and I have a +50 bounty for someone who proves it either way.

Answer 2

How far from binary?

Answer 3

Parse this handy graph format

code-golf parsing graph-theory

There's a great number of ways to represent directed graphs like the following:

Most representations are tailored towards being easy to work with, either for humans (like the picture above) or for computers (like an adjacency matrix representation). A middle ground I found useful in the past is this format:

        A -> B <-> C                A -> B -> C -> A           A -> C -> D; B <-> C <-> E

It is basically a condensed edge list, which is still relatively close to a graphical representation (good for humans) but not too hard to parse for a computer.

The goal in this challenge is to take a string representing a graph in this format as input and output a list of the graph's nodes and a list of the graph's edges.

This is code-golf, so try to use as few bytes as possible in the language of your choice.

Input specification

• Each node has a unique name consisting of alphabetical letters, for example A, b, or Node. It is also fine if you only support upper or lower case names.
• Three types of arrows can appear: ->, <-, and <->.
• A chain is formed by a sequence starting with node and then alternating between arrows and nodes, for example A -> B <- C or also just A.
• A chain may be followed by another chain with ; as a separator in between.
• Between node names and the arrows and the semicolon can be any number of spaces (including zero).
• Self-loops are possible, i.e., A -> A describes an arrow from node A to itself.
• You may assume the input string is a valid encoding of a graph.

Output specification

• The list of nodes can be returned or printed in any reasonable format and order, e.g., A, B, C, ["A", "B", "C"], A\nB\nC, ...
• Edges are represented as ordered tuples in any reasonable format, e.g., ("A", "B") or A B for the edge A -> B and ("D", "C") or D C for the edge C <- D.
• The list of directed edges can again be output in any reasonable format.

Test cases

"A -> B <-> C"               : ["A", "B", "C"], [("A", "B"), ("B", "C"), ("C", "B")]
"A -> B -> C -> A"           : ["A", "B", "C"], [("A", "B"), ("B", "C"), ("C", "A")]
"A -> C -> D; B <-> C <-> E" : ["A", "B", "C", "D", "E"], [("A", "C"), ("C", "D"), ("B", "C"), ("C", "B"), ("C", "E"), ("E", "C")]
"AA<->BB"                    : ["AA", "BB"], [("AA", "BB"), ("BB", "AA")]
"A;B"                        : ["A", "B"], []
" "                          : [], []
"   A   <- B  ;  C  "        : ["A", "B", "C"], [("B", "A")]
"A -> A; B <- B"             : ["A", "B"], [("A", "A"), ("B", "B")]

---

Sandbox question:

Given that this is foremost a parsing question, I'm tempted to drop the validity assumption and require answers to raise an error if the input does not follow the spec. What do you think, would that still be fun?

Answer 4

Flood fill by distance

Answer 5

Nest some addition

• There's a natural follow-up with the other possible addition operator, where the order of application is reversed, i.e. \$\operatorname{add2}\overparen{\underparen a}\overparen{\underparen b} f=\left(\overparen{\underparen b} f\right)\circ\left(\overparen{\underparen a} f\right)\$.

Answer 6

Is this a squashed series? code-golf string parsing number decision-problem

Given a string of digits, determine whether it is the concatenation of at least two ascending consecutive integers. (in decimal, with no leading zeroes)

For example, the string 7891011 is valid, because it's the concatenation of the sequence [7, 8, 9, 10, 11].

However, the string 54 could only be formed by concatenating [5, 4] (which is not ascending), or [54] (which does not have at least two numbers in it), so it is not valid.

(This challenge is essentially asking "Is it a valid input to Decipher a squashed series")

You should output using two distinct values of your choice to represent "valid" and "not valid".

Take care with leading zeroes: for example, 809 is not valid, even though it could be decomposed into [8, 09], because 09 is not a valid decimal integer.

You may assume the input does not start with a 0, and has a length of at least 2. The input will also only contain digits (and not -, so you don't need to handle negative numbers).

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

Test cases

Valid

1234
7891011
293031323334
9991000

Invalid

54
66
28
3131
809

Valid numbers are given by A035333 in the OEIS.

Meta

• Is this interesting enough? (It was just a byproduct of Decipher a squashed series)
• Is my handling of the 809 case good? Or should I allow either output for inputs like that?

Answer 7

Is it shuffled FizzBuzz?

Answer 8

Decompress a Sparse Matrix (WIP)

The dual of this challenge.

Decompress a sparse matrix reversing the method here Compressed sparse row (CSR, CRS or Yale format).

There will be 4 inputs, either as separate variables or as a list of lists:

• V, a list of the nonzero elements of the matrix in row-major form. This is of length NNZ (the number of nonzero elements in the original matrix)
• NCOLS - the number of columns in the original matrix.
• IA - a list that yields the number of nonzero elements in each row in the following way: IA[0] = 0, IA[i] = IA[i - 1] + <number of nonzero elements in row i>. The number of nonzero elements in row i is IA[i + 1] - IA[i].
• JA - a list of the column indices of the elements in V, also of length NNZ. (zero-indexed)

Input will be a list of 3 lists and the number of columns in the original matrix, e.g. either

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

Or

V = [5, 8, 3, 6]
IA = [0, 0, 2, 3, 4]
JA = [0, 1, 2, 1]
NCOLS = 4

Output will be a decompressed matrix/list of lists:

[[0 0 0 0],
 [5 8 0 0],
 [0 0 3 0],
 [0 6 0 0]]

If your language doesn't support actual data structures, input and output may be text.

Process

1. Create a 'matrix' of row width NCOLS.
2. Populate the ith matrix row with N values from V if the corresponding array index (i + 1) of IA is non-zero, where N is the ith element of IA starting at the ith element of JA.
3. repeat until V is empty
   i.e. above for the 0th matrix row IA[1] = 0, so this row has NCOLS=4 zeroes in it's first row. Then for matrix row 1, IA[2]=2 it takes 2 values from V starting at JA[1]=0. For matrix row 2, IA[3]=3 and IA[2]=2 so it takes the next (3 - 2 = 1) elements from V, starting at JA[2]=2. For matrix row 4 IA[4]=4 and IA[3]=3 so it takes the next (4 - 3 = 1) elements from V, starting at JA[3]=1.

Test cases

Input 1:

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

Output 1:

[[0 0 0 0],
 [5 8 0 0],
 [0 0 3 0],
 [0 6 0 0]]

Input 2

[ 10 20 30 40 50 60 70 80 ]
[  0  2  4  7  8 ]
[  0  1  1  3  2  3  4  5 ]
6

Output 2:

[[10 20 0 0 0 0],
 [0 30 0 40 0 0],
 [0 0 50 60 70 0],
 [0 0 0 0 0 80]]

Input 3:

[ ]
[ 0 0 0 0 ]
[ ]
3

Output 3:

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

Input 4:

[ 1 1 1 1 1 1 1 1 1 ]
[ 0 3 6 9 ]
[ 0 1 2 0 1 2 0 1 2 ]
3

Output 4:

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

Input 5:

[ 5, -9, 0.3, -400 ]
[ 0, 0, 2, 3, 4 ]
[ 0, 1, 2, 1, ]
4

Output 5:

[[0 0 0 0],
 [5 -9 0 0],
 [0 0 0.3 0],
 [0 -400 0 0]]

Assume inputs may contain any real number, you need not consider mathematical symbols or exponential representation (e.g. 5,000 will never be entered as 5e3). You will not need to handle inf, -inf, NaN or any other 'pseudo-numbers'. You may output a different representation of the number (5,000 may be output as 5e3 if you so choose).

Scoring

This is a code-golf, fewest bytes wins.

Answer 9

Round it up Nicely

code-golfnumber

When I work out, I often don't have a good plan for how many times to repeat an exercise, but in the interest of pushing myself I always keep going until I've done a "nice" number. Multiples of 5 are ideal, but multiples of 4 are acceptable too--unless they're 1 less than a multiple of 5, in which case I may as well do one more, or they're 1 more than a multiple of 5, in which case why didn't I already stop?

The challenge

Given an integer \$n\$ and a descending, pairwise coprime list of integers \$k_1, k_2, ..., k_m\$, output the least integer \$x \geq n\$ which is a multiple of some \$k_i\$ but is not 1 more or less than any multiple of any \$k_j\$ with \$j<i\$.

Test cases

n    k[1]...k[m]                        result
1    [5, 4]                             5
15   [5, 4]                             15
12   [5, 4]                             12
16   [5, 4]                             20
7    [5, 4]                             8
996  [5, 4]                             1000
1    [11, 7]                            7
15   [11, 7]                            22
133  [11, 7]                            140
1    [5, 3, 2]                          3
6    [5, 3, 2]                          10
6    [5, 3]                             10
11   [5, 3, 2]                          12
1    [100, 49, 9]                       9

Sandbox

• Would it be more interesting without the descending/coprime guarantees?
• Test cases are a WIP, but any additional suggestions?
• Better title?
• [How] should I note that the 1-above exclusion only matters if it would exclude the input itself? Should the task not be "rounding up" to make it more relevant?

Answer 10

Draw the Progress Pride flag

Answer 11

Draw this fractal generated by applying Newton's method to cosh(x) - 1

Answer 12

Implement Binary Exponentiation

Answer 13

Is it an ordinal?

Answer 14

Draw the USA flag

Answer 15

Convert from Greeklish to modern Greek

Answer 16

Solve a Card Suit Puzzle

Answer 17

Every possible pairing

Answer 18

Infinite Fibonacci word code-golf sequence fibonacci string

The famous Fibonacci sequence of integers is defined as follows:

\$ F_0 = 0 \\ F_1 = 1 \\ F_n = F_{n-1} + F_{n-2} \$

But what if we use this same recurrence relation to produce an infinite sequence of strings? Instead of addition, we'll use concatenation. We'll also change the base case slightly:

\$ F_0 = \$ 0
\$ F_1 = \$ 01
\$ F_n = F_{n-1}F_{n-2} \$

The first few strings are:

0
01
010
01001
01001010
0100101001001
...

Each of these "words" is a prefix of the next, so they are all prefixes of the single infinite word \$ F_\infty = \$

010010100100101001010010010100100101001010010010100101001001010010010100101001001010010010100101001...

Your task is to output this infinite string as a sequence; you may choose to use any two distinct values to use for 0 and 1.

As with standard sequence challenges, you may choose to either:

• Take an input \$ n \$ and output the \$ n \$th item in the sequence
• Take an input \$ n \$ and output the first \$ n \$ item
• Output the sequence indefinitely, e.g. using a generator

and you may use 0-based or 1-based indexing for \$ n \$.

This string can be defined in many different ways; its OEIS entry A003849 and Wikipedia page have more information.

Errors due to floating-point imprecision are not allowed.

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

Answer 19

All Crossword Grids

code-golf crossword grid

In crossword terminology, the grid is the region into which the crossword answers are inserted, consisting of white and black squares. The crossword answers, called entries, are inserted into contiguous sequences of white squares in a row or column, separated by black squares.

For straight (American) crosswords, the grids usually follow a specific set of rules:

• They should have 180 degree rotational symmetry (if there is a black square in the \$x\$th row and \$y\$th column, there should be a black square in the \$x\$th-to-last row and \$y\$th-to-last column).
• All entries must be at least 3 squares long.
• All white squares must be joined in a single region.
• No row/column can be completely filled with black squares.

Some examples of invalid and valid crossword grids:

Your challenge: given a grid consisting of two unique values representing black and white squares, determine if it's a valid crossword grid. Assume that it's a square grid with \$n\$ rows and columns (so there are \$n^2\$ white/black cells), where \$n \geq 3\$. For example, if \$n=3\$ there is only one valid grid (I'm using . for white cells and # for black cells):

...
...
...

If \$n=4\$, there are 3 valid grids:

....  #...  ...#
....  ....  ....
....  ....  ....
....  ...#  #...

If \$n=5\$, there are 12 valid grids:

.....  #....  ##...  #....  ##...  ##...  
.....  .....  .....  #....  #....  ##...  
.....  .....  .....  .....  .....  .....  
.....  .....  .....  ....#  ....#  ...##  
.....  ....#  ...##  ....#  ...##  ...##  

....#  ...##  ....#  ...##  ...##  #...#  
.....  .....  ....#  ....#  ...##  .....  
.....  .....  .....  .....  .....  .....  
.....  .....  #....  #....  ##...  .....  
#....  ##...  #....  ##...  ##...  #...#  

Examples:

Input	Output	Explanation
.........	True	Valid grid
#..............#	True	Valid grid
...#........#...	True	Valid grid
...#........#...	True	Valid grid
.........	True	Valid grid
#...#......#...#	True	Valid grid
.........................	True	Valid grid
##...#.............#...##	True	Valid grid
.................................................	True	Valid grid
........................#........................	True	Valid grid
....###.....##......##.....##......##.....###....	True	Valid grid
................................................................	True	Valid grid
##....####....##...........##......##...........##....####....##	True	Valid grid
...##.......#...........##.....##.....##...........#.......##...	True	Valid grid
#...............	False	No 180 degree symmetry
#..##..##..##..#	False	2-letter entries, filled-in columns
#........................	False	No 180 degree symmetry
.......#...###...#.......	False	1-letter and 1-letter entries
######....#....#....#....	False	No 180 degree symmetry, filled-in column & row
######...##...##...######	False	Filled-in columns & rows
...#......#......#......#......#......#......#...	False	White squares not contiguous, filled-in column
.................###....#....###.................	False	1-letter entries
...#......#...............##.....................	False	No 180-degree symmetry
....#.......#.......#........######........#.......#.......#....	False	White squares not contiguous
..#.........#.......#......##......#.......#.......#.........#..	False	1-letter and 2-letter entries
.#......#..............................................#......#.	False	1-letter entries, white squares not contiguous
...........................##......#............................	False	No 180-degree symmetry
####............................................................	False	No 180-degree symmetry
#......##......##......##......##......##......##......##......#	False	Filled-in columns

Standard loopholes are forbidden. Shortest code wins.

Sandbox Questions

I may have misused some crossword terminology above, let me know if I can improve the explanation.

I also don't know if the final rule should be included, since it's not usually explicitly stated when constructing crosswords.

I'm considering adding an optional parameter \$n\$ which describes the number of rows/columns to make the input easier to parse, but I don't know how people feel about optional parameters.

Answer 20

Add parentheses to Polish notation

Answer 21

Change The Quotations as if in Microsoft Word

META: Posted

Answer 22

Carry-less sum given a base b

posted

Answer 23

code-golf decision-problem

Are these numbers from the repeated application of this function?

Given a list of at least 3 positive integers \$L\$ and a function \$F\$ which takes a positive integer and returns a positive integer, determine if \$L\$ can be sorted such that each element of the list is the result of applying \$F\$ to the previous element (besides the first of course).

Rules

• You may, of course, assume that \$F\$ always halts.
• You may also assume that \$F\$ will have no side-effects and is deterministic.
• You may take the \$F\$ as a black box function in any reasonable format.
• Instead of taking \$F\$ as an input, you may take a second list \$M\$, which is the result of applying \$F\$ to each element of \$L\$.
• This is code-golf, shortest solution in bytes wins.

Very simple worked out example

Inputting \$F(x)=x+1\$ and \$L=[5,4,3,2,1]\$ should output truthy, because \$L\$ can be rearranged into \$[1,2,3,4,5]\$, for which each element is the result of applying \$F\$ to the previous element: \$F(1)=2\$, \$F(2)=3\$, \$F(3)=4\$, and \$F(4)=5\$.

More examples:

Truthy

F(x) = 2x,           L = [4,2,1,8]
F(x) = ceil(10/x),   L = [2,2,2,5,5,5]
F(X) = 3x+1,         L = [5,16,49,148]
F(x) = length(x),    L = [1,2,10,9876543210,1]
F(x) = 13            L = [13,13,13,13,14]

Falsy

F(x) = 2x,           L = [2,4,6,8]
F(x) = ceil(10/x),   L = [5,2,5,2,5,2,5,5]
F(X) = 3x+1,         L = [5,16,8,4,2,1,4]
F(x) = length(x),    L = [3,1,10,2]
F(x) = 13            L = [13,13,13,14,15]

META

Is this ready to post or is it missing something / bad somewhere

Answer 24

Implement level-index addition

Answer 25

answer-chaining king-of-the-hill

This is less of a challenge proposal, and more of a idea for how to mesh the two title tags.

A series of targeted fights

Consider a heads-up, 1v1 "game" between two king-of-the-hill style bots. However, unlike a general king-of-the-hill, where every bot plays against every other bot, we instead build bots that target specific bots to win against. An example of an existing bot would be Low Blow from Cooperative Counting, which aimed to identify it's opponent, then play counter to that bot. However, in this challenge, the bot wouldn't have to identify its opponent: it would only play one bot, the bot it was designed to beat.

The answer-chaining aspect comes from this targeting:

• User A posts Bot A, targeting a provided example bot.
• User B then posts Bot B, targeting Bot A.
• User C then posts Bot C, targeting a second example bot.
• User D then posts Bot D, also targeting Bot A.

And so on, creating a "tree" of answers, each targeting a previous answer. Note that new answers don't have to target the latest, but can instead target any previous answer.

However, to prevent bots that "target", but don't actual perform well against their target, we'd need to require that it beats its target in \$X\%\$ of \$Y\$ battles, or else it is disqualified. Obviously, this prevents bots from being edited to improve themselves once targeted.

This begs the question: what is our scoring criteria? Clearly, depth from the root bots (provided in the challenge) must be a central part, as it's harder to create a bot the further down the chain you go. However, this doesn't differentiate between Bot B and Bot D in our example, despite the fact that Bot D beats Bot A \$82\%\$ of the time, vs Bot B's meager win rate of \$61\%\$. Clearly, we should take winning rate into account. One potential score:

$$\text{Score} = \text{Win rate} \times \text{Depth}$$

where \$\text{Win rate}\$ is between \$0\$ (never wins) and \$1\$ (always wins).

---

Thoughts?

Answer 26

write the "index by number" sequence

Imagine writing out positive integer numbers, and indexing each character in a 1-indexed array (indices read vertically on the top two rows, numbers read horizontally on the third):

000000000111111111122222222223333333333444444444
123456789012345678901234567890123456789012345678
one two three four five six seven eight nine ten

Now, imagine if we skipped some numbers so we write the index at the point we start the next number:

000000000111111111122222222223333333333444444444
123456789012345678901234567890123456789012345678
one five ten fourteen twenty three thirty six fo

now, imagine that the first number doesn't have to be "one":

000000000111111111122222222223333333333444444444
123456789012345678901234567890123456789012345678
      seven thirteen twenty two thirty three for

Input

A single number from 1..999, in any format you like ("1", '1', 1, "one" etc.)

This forms the starting number for the sequence

Output

A sequence of numbers, written long-hand in UK English ("one hundred and one" - no other differences), from (input)..(999) inclusive.

Code golf, usual rules.

Answer 27

Generate a different sudoku

code-golfsudokugridopen-ended-function

---

Task

Given a valid sudoku board, generate another sudoku board that isn't equivalent to the one inputted.

What do we consider as equivalent sudoku boards?

• they are the same,
• the digits are relabeled (eg. 2<->7 or 2->5->8->2),
• three-column or thee-row bands are permuted,
• the rows or columns within a band are permuted,
• one is a reflection of the other (horizontally, vertically or along any of the diagonals),
• one is a rotation of the other,
• or any combination of the above.

According to Ed Russell and Frazer Jarvis there are 5 472 730 538 essentially different sudoku classes.

What is a valid sudoku?

(borrowed from here)

• Each row contains the digits from 1 to 9 exactly once.
• Each column contains the digits from 1 to 9 exactly once.
• Each of the nine 3x3 subgrids contains the digits from 1 to 9 exactly once.

Rules

You may take input and output in any reasonable format, like a 9x9 matrix, list of rows/columns, a string of 81 digits etc.

Taking digits 0-8 instead of 1-9 is allowed, but please be consistent.

Test cases

Input:
7 2 5 8 9 3 4 6 1
8 4 1 6 5 7 3 9 2
3 9 6 1 4 2 7 5 8
4 7 3 5 1 6 8 2 9
1 6 8 4 2 9 5 3 7
9 5 2 3 7 8 1 4 6
2 3 4 7 6 1 9 8 5
6 8 7 9 3 5 2 1 4
5 1 9 2 8 4 6 7 3
Example output:
1 2 3 4 5 6 7 8 9 
4 5 6 7 8 9 1 2 3 
7 8 9 1 2 3 4 5 6 
2 3 1 5 6 4 8 9 7 
5 6 4 8 9 7 2 3 1
8 9 7 2 3 1 5 6 4 
3 1 2 6 4 5 9 7 8
6 4 5 9 7 8 3 1 2 
9 7 8 3 1 2 6 4 5

Input:

Example output:

Meta

• Any mistakes in the test-cases?
• Is it sufficiently diffent to existing sudoku challenges?
• Is it better as open-ended-function or a challenge to check whether two given grids are equivalent?

Answer 28

Print every Fool's Mate

Answer 29

open-ended-function code-golf

N-element Rock Paper Scissors

Given an odd integer \$n>2\$, decide the winner for \$n\$-element Rock Paper Scissors.

What is \$n\$-element Rock Paper Scissors?

Rock Paper Scissors is a game in which two players choose between the elements Rock, Paper, and Scissors, and simultaneously reveal their selections. If one player chooses Rock, they will win against a player who chose Scissors, lose against a player who choses Paper, and tie a player who also chose Rock. It is a zero sum game, so a player losing means their opponent has won, and vice versa. Every element beats one element, loses to another, and ties with itself.

A common extension to this game is to add two aditional elements (most famously "Lizard" and "Spock"). In this extension, there are now 5 elements, so each element beats two elements, loses to two elements, but still ties only itself. We can generalize this cleanly to any odd number of elements \$n\$, in which each element will beat \$(n-1)/2\$ elements, lose to \$(n-1)/2\$ elements, and tie with itself.

Challenge specification

Program 1

This program should take an odd integer \$n>2\$ as input in any reasonable format decided by the solver, and output the Program 2 as defined below in terms of \$n\$. Alternatively, this program may instead take the Program 2's inputs along with \$n\$, and provide the Program 2's expected output instead.

This program is the one you will be scored on. This is code-golf, so shortest code in bytes wins.

Program 2

This program should take two elements \$A\$ and \$B\$ as input in any reasonable format decided by the solver, and consistently output either one of the following:

• Whether \$A\$ beats \$B\$, loses to \$B\$, or ties with \$B\$.
• The winner between \$A\$ and \$B\$, or in the case of a tie, some other distinct output.

Only \$n\$ possible inputs need to be handled by this program. Each possible element must consistently beat \$(n-1)/2\$ elements, lose to \$(n-1)/2\$ elements, and tie with itself. If some element \$a\$ beats an element \$b\$, element \$b\$ loses to element \$a\$. Which elements are allowed and which elements beat which etc. are to be decided by the solver. This must be consistent for each execution of Program 2 for the same \$n\$

Examples:

Your I/O may differ.

Format:
n (input to Program 1)
a b c d e (list of inputs accepted by Program 2, space delimited for all examples)
x y (inputs to Program 2, space delimited for all examples)
value (whether x wins, loses, or ties y)

3
r p s
r p
lose

3
r p s
r r
tie

3
r p s
r s
win

5
0 1 2 3 4
0 1
win

5
0 1 2 3 4
0 2
win

5
0 1 2 3 4
0 3
lose

5
0 1 2 3 4
0 4
lose

5
abcde bcdea cdeab deabc eabcd
bcdea cdeab
lose

5
abcde bcdea cdeab deabc eabcd
bcdea deabc
lose

5
abcde bcdea cdeab deabc eabcd
bcdea eabcd
win

5
abcde bcdea cdeab deabc eabcd
bcdea abcde
win

5
abcde bcdea cdeab deabc eabcd
bcdea bcdea
tie

13
a b c d e f g h i j k l m
g e
lose

13
a b c d e f g h i j k l m
g m
win

13
a b c d e f g h i j k l m
d h
win

13
a b c d e f g h i j k l m
h d
lose

Meta

Everything clear? Any other examples needed? Maybe a worked out example?

Answer 30

Print 100 digits of π

Your challenge is to print any 100 consecutive digits of π. You must give the index at which that subsequence appears, and you may not assume π is normal. You may not use built-ins that calculate π or its digits. The 3 is not included.

For example, you could print any of the following:

• 1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679 (index 0)
• 8214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196 (index 100)
• 4428810975665933446128475648233786783165271201909145648566923460348610454326648213393607260249141273 (index 200)

This is code-golf, shortest wins!