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

Potentially Prime Punch-Card Patterns code-golf primesnumber-theory

---

Punch-cards

Let us define a punch-card to be a set of 'open' and 'closed' holes which can slide over the positive integer number line:

    _________________________
   |   ___     ___     ___   | -->
   |  |   |   |   |   |   |  |
1  |  | 3 |   | 5 |   | 7 |  |  9   10  11  12  13  14
   |  |___|   |___|   |___|  |
   |_________________________| -->

When the first open hole is on the integer \$ p \$, then this punchcard (as it slides across the number line) yields the integers \$p, p+2,\$ and \$p+4\$. So, we can represent this card as the set \$\{0, 2, 4\}\$.

Admissibility

Given a punch-card we may wonder whether it is possible to slide the card to such a position that only prime numbers are under the 'open' holes.

Clearly, for \$\{0, 2, 4\}\$, we can position the punch-card to make 3, 5, and 7 visible. However, this is the only solution. Taking each element modulo 3 yields \$\{0, 2, 1\}\$, which contains every possible remainder under division by 3, so one visible integer must be divisible by 3. But we only want primes, and so 3 itself must be visible; this leaves a finite number of possible positions, of which only one is a valid solution.

More generally, if there exists a prime \$q\$ such that every integer \$0 \le n < q\$ appears in the punch-card set modulo \$q\$, then the punch-card is inadmissible and has a finite number of positions where all visible integers are prime: as we are bounded by the condition that \$q\$ must be visible. We can place \$q\$ in each hole in turn, and perform primality tests to count the valid solutions.

However, if there exists no such \$q\$, then the punch-card is admissible and we cannot assume there are finite solutions; the K-Tuple Conjecture in fact hypothesizes that every admissible punch-card can assume infinitely many positions where all visible integers are prime.

The Challenge

Your task is to write a program or function which, given a list of ordered positive integers representing a punch-card set, outputs the number of positions the punch-card can assume where all visible integers are prime. If the set is admissible, then give a distinct output such as -1, null, Inf - anything that is not a non-negative integer.

Test Cases

Coming soon.

---

Meta

There is a related challenge - testing for admissible sequences. However, I believe this is distinct enough to be a duplicate as rather than being a simple decision-problem, if a set is admissible this program will have to then try different positions of the punch-card and count the valid solutions; whereas the previous challenge considers admissible sets in isolation, this challenge applies it to prime numbers.

Answer 2

How many ways can I count on n?

By using addition of natural numbers {1, 2, 3...} and multiplication of natural numbers larger than 1, we can reach the same outcome in several ways. For example 4 = 2 x 2 but also: 4 = 2 + 1 + 1. Using normal mathematical operator precedence, there are actually 6 ways to express 4 and 9 ways to express 5.

Since addition is commutative, a + b is counted as the same solution as b + a. The same holds for multiplication. So 7 = 1 + 2 x 3 is the same solution as 7 = 3 x 2 + 1.

The (trivial) solution n (using no addition or multiplication) is also counted as one of the solutions of n.

Multiplication with 1 is forbidden, because you can do this infinitely.

Task

For a given input n, output c(n), which is defined as the number of ways n can be uniquely expressed using zero, one or more additions and multiplications of natural numbers, using normal mathematical operator precedence and without multiplication with 1.

Rules

• Input and output are integers (your program should at least support input and output in the range of 1 up to 32767)
• Invalid input (0, floats, strings, negative values, etc.) may lead to unpredictable output, errors or (un)defined behaviour.
• Default I/O rules apply.
• Default loopholes are forbidden.
• This is code-golf, so the shortest answers in bytes wins

Final note

I can think of several ways to approach this problem. I think it's interesting to see how the different approaches impact the length of the solution.

Sandbox questions

• Please let me know if this task/problem is stated clear enough.
• Please let me know if there are any loopholes that I should cover in the question.
• I intentionally omitted more examples (because I hope contesters will think about solutions rather than just reproduce an OEIS sequence; although I'm not sure if this question had an OEIS sequence).
• I will tag this question with code-golf.

Answer 3

Morse with Binary code-golf morse binary kolmogorov-complexity

For every input string (in ASCII, containing only lowercase alphabetic characters), output the alphabetic string converted from Morse code to Binary code.

In this case we are assuming that . is 0 and - is 1.

How to do the conversion

For reference, here are a few Morse code libraries:

a .-
b -...
c -.-.
d -..
e .
f ..-.
g --.
h ....
i ..
j .---
k -.-
l .-..
m --
n -.
o ---
p .--.
q --.-
r .-.
s ...
t -
u ..-
v ...-
w .--
x -..-
y -.--
z --..

What's amazing about those codes is that the code length never exceeds 4 codes.

And now we are trying to cofuse binary with Morse code. First let's convert sample to morse code:

... .- -- .--. .-.. .

And consider the whole thing as a binary:

.... ---. --.. -...

Here is an alternative table for mapping the characters:

a ....
b ...-
c ..-.
d ..--
e .-..
f .-.-
g .--.
h .---
i -...
j -..-
k -.-.
l -.--
m --..
n --.-
o ---.
p ----

The result of this operation, after conversion, is aomi. You are never going to end up with a letter past p.

Answer 4

Quine Generator Generator... of any* length! code-golf meta-golf

A Quine Generator Generator... is a quine when the input is empty or 0. Otherwise, for any other sufficiently large positive integer input, it should print a Quine Generator Generator... of that specified length (in the same language, same options).

Let S be the (most likely theoretically infinite) set of Quine Generator Generator... you can generate from your initial Quine Generator Generator....

Your score is the smallest N such that any Quine Generator Generator... in S can generate a Quine Generator Generator... of length N or longer (for reasonably sized N).

Input can be from standard input or as an argument of a function.

Lowest score wins.

Sandbox Meta:

Typically, code is scored by bytes, but now the length would depend on how that is interpreted, since it is included in the description of the question. Hence would it be a problem to put: "You may choose to define characters in terms of bytes or characters (should they differ) for purposes of the program length and scoring purposes."

Answer 5

Integer Keys and Duplicates

Given a list/vector of positive integers, write a function to check the following conditions in as few bytes as possible.

1. Take the first integer (the key, or k1) and check that the next k1 values have no duplicate values, excluding k1.
2. Take the last integer (the second key, or k2) and check that the k2 values before k2 have no duplicate values, excluding k2.

Note that both keys, k1 and k2, are elements of the list/vector as either key could contain the other.

Also, k1 and/or k2 can be greater than the number of integers within the list, which means you should check every element of the list besides the given key for duplicates, excluding the key.

If both steps return True, return True, else, return False.

Test Cases

[5,1,2,5,3,4,3] is TRUE because [k1=5][1,2,5,3,4] has no duplicates, nor does [5,3,4] have any duplicates, excluding 3

[6,9,12,15,18,19,8,8,3] is FALSE because [k1=6][9,12,15,18,19,8] has no duplicates while [19,8,8][k2=3] has a duplicate.

[100,100,100,100,101,102,3] is TRUE because [k1=100][100,100,100,101,102,3] has no duplicates, and [100,101,102][k2=3] has no duplicates.

[100,100,100,100,101,102,4] is FALSE. [k1=100][100,100,100,101,102,4] has no duplicates, but [100,100,101,102][k2=4] has duplicates.

[6,6,6,6,6,6,6,3,3,3,3] is TRUE. [k1=6][6,6,6,6,6,6] has no duplicates and [3,3,3][k2=3] has no duplicates.

[1,2] is TRUE (clearly)

[1] is TRUE (clearly)

[] the empty list is also TRUE (if you can make a valid argument why it should be FALSE then I might give it to you)

Answer 6

Drum fill generator

Create a program that generates a drum fill. Your program will output a pattern of L (left hand hits), 'R' (right hand hits), and K for kick drum hits.

Rules

• The pattern must never have more than 2 of the same hits consecutively.
• The pattern must be loopable, so it mustn't have more than 2 of the same hits when it loops.
• Your program accepts 1 argument which is the length of the pattern. You can assume this will always be an integer > 0.
• Program output must be random each time it's ran.
• IO can be used with any convenient method.
• Standard loopholes are forbidden.
• This is code-golf, so smallest program wins!

Example valid output:

RLRRKKLL
LRLLKKLR
LKKRLRKLRRKL
LRLR

Example invalid output:

LRLL // 3 characters when looped
LRLRRRLLR // 3 characters in a row
RRLRLLRR // 4 characters when looped

Answer 7

Interpret LCGFuck™ code-golfinterpreter

Introduction

LCGFuck™ is a Brainfuck-like esoteric programming language invented by me. Inspired by Brainfuck and linear congruential generators (LCGs), LCGFuck™ combined both things into one.

An LCG in LCGFuck™ is defined with 5 integers, namely multiplier a, adder b, modulus c, offset d and seed e. Let x be its current state, then the corresponding output will be x + d, and the next internal state x' of the LCG can be calculated by x' = (a * x + b) mod c. All numbers should be non-negative except for d. Moreover, b and e should be in the range [0, c).

Technical details

An LCG is defined with 5 numbers, like 12345 678 90 -123 45. The last two numbers are optional and default to 0.

LCGFuck™ has 3 storage variables, the LCG list, the number list and the number memory. The functions are as follows:

• LCG list: Cyclic list that stores all LCGs created. Every entry is in turn a list of 5 numbers in the order [a, b, c, d, e] as notated in the introduction. It has a pointer that controls which LCG is chosen at the moment, and moves in a cycle through the list.
• Number list: Ordinary list that stores the numbers for LCG definition. It can store at most 5 numbers.
• Number memory: A single variable that can be read and written with an input or an LCG output.

LCGFuck™ has 14 operators, namely:

• \n (newline): Creates an LCG with the numbers in the order of [a, b, c(, d(, e))] and clears the list if the number list contains 3 or more numbers. No-op if the number list contains no more than 2 numbers.
• <: Shifts to the previous LCG circularly (back to the last when moving from the first).
• >: Shifts to the next LCG circularly (back to the first when moving from the last).
• +: Moves the current LCG to the next state (calculates x' = (a * x + b) mod c)
• c: Prints the output of the current LCG as a character (with the output as the codepoint).
• n: Prints the output of the current LCG as a number (with a trailing space)
• o: Writes the output of the current LCG to number memory
• i: Reads a value from the input and writes it to number memory. There is two input mode, one reading a character one time, and one reading a number one time. You do not need to implement this operator in this challenge.
• s: Reads the value from number memory and seeds the current LCG with it
• m: Reads the value from number memory and pushes it to the number list
• []: Output loop. Executes the loop if the current LCG is non-zero
• {}: State loop. Executes the loop if the state of the current LCG is non-zero

An integer, optionally with a negative sign at the front, pushes the number to the number list. Any characters other than the newline \n and any of -0123456789[]{}<>+cimnos are no-ops.

The code runs linearly from the first characters, except when loop ends are encountered. Loops can be nested but must be paired accordingly from the innermost loop to the outermost loop.

Challenge

Write an interpreter, making it as short as possible, that interprets the LCGFuck source code given as the input. You need not implement the i operator in this challenge. The output should be printed to STDOUT or returned in case of writing a function.

You may assume that your interpreter always receives valid programs, i.e.:

1. An LCG is always defined before any of the commands that manipulate the LCG or the LCG list pointer
2. At any moment the number list contains at most 5 numbers
3. All brackets are paired accordingly

Standard loopholes are forbidden by default.

Sample implementation with operator i (Primality check)

Sample

The LCG list need not be printed out. It is just for illustration purpose.

1. The "Hello world!" program in LCGFuck™ is as follows:

   1 29 30 72
   1 3 9 108
   1 1 2 32
   c+c>cc+co>c
   1 8 9 m
   >+c<<c+c+c<+c>>+c
   

   • Output: Hello world!

   • LCG list after execution:

     [1, 29, 30, 72, 28]
     [1, 3, 9, 108, 0]
     [1, 1, 2, 32, 1] < Current LCG
     [1, 8, 9, 111, 8]
     

2. An example that outputs the values of x - 16, where x is the states of the LCG x' = (19x + 17) mod 32, starting with seed x = 4, until the output is 0:

   19 17 32 -16 4
   [n+]n
   

   • Output: -12 13 8 9 -4 5 -16 1 4 -3 -8 -7 12 -11 0

   • LCG list after execution:

     [19, 17, 32, 16, -16] < Current LCG
     

3. An example that outputs all possible values of 5(x + 12), where x is the states of the LCG x' = (5x + 3) mod 8:

   5 3 8 12
   5 0 99
   o>s+n<+{o>s+n<+}
   

   • Output: 60 75 70 85 80 95 90 65

   • LCG list after execution:

     [5, 3, 8, 12, 0] < Current LCG
     [5, 0, 99, 0, 65] 
     

4. An example illustrating the 3-number restriction of \n (the 9 in the 3rd line is pushed to the number list but the LCG is defined before the 9 is pushed):

   12 34
   56 78
   9
   n
   

   • Output: 78

   • LCG list after execution:

     [12, 34, 56, 78, 0] < Current LCG
     

5. An example that determines whether 97 is a prime:

   1 -1 97 0 -1
   {o+1 1 m 0 97
   }>{>}o+{o+}<{<}s
   1 1 1 32
   1 4 12 69 4
   1 1 7 78 2
   {<+++++c+c+++++c+++
   <<c>>>{+}}<c++c<c+c+c
   

   • Output: PRIME

   • LCG list after execution:

     [1, -1, 97, 0, 0]
     [1, 1, 96, 0, 1]
     [1, 1, 95, 0, 2]
     [1, 1, 94, 0, 3]
     [1, 1, 93, 0, 4]
     [1, 1, 92, 0, 5]
     [1, 1, 91, 0, 6]
     [1, 1, 90, 0, 7]
     [1, 1, 89, 0, 8]
     [1, 1, 88, 0, 9]
     [1, 1, 87, 0, 10]
     [1, 1, 86, 0, 11]
     [1, 1, 85, 0, 12]
     [1, 1, 84, 0, 13]
     [1, 1, 83, 0, 14]
     [1, 1, 82, 0, 15]
     [1, 1, 81, 0, 16]
     [1, 1, 80, 0, 17]
     [1, 1, 79, 0, 18]
     [1, 1, 78, 0, 19]
     [1, 1, 77, 0, 20]
     [1, 1, 76, 0, 21]
     [1, 1, 75, 0, 22]
     [1, 1, 74, 0, 23]
     [1, 1, 73, 0, 24]
     [1, 1, 72, 0, 25]
     [1, 1, 71, 0, 26]
     [1, 1, 70, 0, 27]
     [1, 1, 69, 0, 28]
     [1, 1, 68, 0, 29]
     [1, 1, 67, 0, 30]
     [1, 1, 66, 0, 31]
     [1, 1, 65, 0, 32]
     [1, 1, 64, 0, 33]
     [1, 1, 63, 0, 34]
     [1, 1, 62, 0, 35]
     [1, 1, 61, 0, 36]
     [1, 1, 60, 0, 37]
     [1, 1, 59, 0, 38]
     [1, 1, 58, 0, 39]
     [1, 1, 57, 0, 40]
     [1, 1, 56, 0, 41]
     [1, 1, 55, 0, 42]
     [1, 1, 54, 0, 43]
     [1, 1, 53, 0, 44]
     [1, 1, 52, 0, 45]
     [1, 1, 51, 0, 46]
     [1, 1, 50, 0, 47]
     [1, 1, 49, 0, 48]
     [1, 1, 48, 0, 1]
     [1, 1, 47, 0, 3]
     [1, 1, 46, 0, 5]
     [1, 1, 45, 0, 7]
     [1, 1, 44, 0, 9]
     [1, 1, 43, 0, 11]
     [1, 1, 42, 0, 13]
     [1, 1, 41, 0, 15]
     [1, 1, 40, 0, 17]
     [1, 1, 39, 0, 19]
     [1, 1, 38, 0, 21]
     [1, 1, 37, 0, 23]
     [1, 1, 36, 0, 25]
     [1, 1, 35, 0, 27]
     [1, 1, 34, 0, 29]
     [1, 1, 33, 0, 31]
     [1, 1, 32, 0, 1]
     [1, 1, 31, 0, 4]
     [1, 1, 30, 0, 7]
     [1, 1, 29, 0, 10]
     [1, 1, 28, 0, 13]
     [1, 1, 27, 0, 16]
     [1, 1, 26, 0, 19]
     [1, 1, 25, 0, 22]
     [1, 1, 24, 0, 1]
     [1, 1, 23, 0, 5]
     [1, 1, 22, 0, 9]
     [1, 1, 21, 0, 13]
     [1, 1, 20, 0, 17]
     [1, 1, 19, 0, 2]
     [1, 1, 18, 0, 7]
     [1, 1, 17, 0, 12]
     [1, 1, 16, 0, 1]
     [1, 1, 15, 0, 7]
     [1, 1, 14, 0, 13]
     [1, 1, 13, 0, 6]
     [1, 1, 12, 0, 1]
     [1, 1, 11, 0, 9]
     [1, 1, 10, 0, 7]
     [1, 1, 9, 0, 7]
     [1, 1, 8, 0, 1]
     [1, 1, 7, 0, 6]
     [1, 1, 6, 0, 1]
     [1, 1, 5, 0, 2]
     [1, 1, 4, 0, 1]
     [1, 1, 3, 0, 1]
     [1, 1, 2, 0, 1]
     [1, 1, 1, 0, 0]
     [1, 1, 1, 32, 0]
     [1, 4, 12, 69, 0] < Current LCG
     [1, 1, 7, 78, 4]
     

Winning criteria

Since this is a code-golf challenge, the shortest solution for every language wins.

Answer 8

I'm stepping down code-golf arithmetic integer

You are given 4 positive integers: volume of the first container (v1), volume of the second container (v2), volume of the liquid in the first container (l1), and volume of the liquid in the second container (l2). Your task is to move (or "step down", if appropriate) some of the liquid from container 1 to container 2, making the amount of empty space in the containers equal to each other, outputting how much liquid should be moved.

An example

Here is an example of some possible input (formatted for the ease of test cases. The input isn't formatted.):

8 11
6  5

Here, you need to make sure that the differences between the volumes and the containers are equal. Currently the difference is not equal:

  8 11
- 6  5
======
   6 2

So we need to try to make them equal, by taking some of the values in one container to another container:

  8 11
- 4  7
======
  4  4

After you have succeeded, output how much liquid you need to take from container 1 to container 2. Therefore the above example should output 2.

Test cases

15 16
 9  2

We move into this state:

 15 16
- 5  6
======
 10 10

Therefore 4 is the expected result.

Test case #2

16 12
13  1

We move into this state:

 16 12
- 9  5
======
  7  7

Therefore 4 is the expected output.

Test case #3

20 12
10 2

Moved:

 20 12
-10 2
======
 10 10

Therefore 0 is the expected output.

Rules

• The test cases will be made so that the result is always possible as a positive integer. The result will never be a decimal.
• Input can be taken in any convenient and reasonable format.
• Output can be given in any convenient and reasonable format.
• The input string will be made so that a moving is always possible without involving decimals or negative numbers. Also there will not be more liquid than how much a container can hold.
• Of course, this is code-golf, so the answer in each language consisting of the fewest number of bytes wins. Happy golfing!
• An extra restriction for the test cases: you can assume that there is always going to be space available in the second container. So a test case like this:

10 2
 2 2

is not going to be a valid testcase.

Answer 9

He. Might. Go. All. The. Way. Touchdown!

[in-progress]

Premise:

In American Football, a team has to drive up the field to their opponent's end-zone to score points. But here's the catch, they have 4 tries (called downs) to go at least 10 yards to gain a new set of downs. They repeat this until they score a Touchdown, or until they fail to get 10 yards and (at least in this challenge) punt it away or go for a Field Goal.

Your task is to simulate such a drive.

Challenge:

You are to output the state of each down, i.e. which down it is, how far to the next down (or the end-zone), and where the ball is. Football location counts up from a team's end-zone (0yd line) up to the 50yd line (the middle), then back down to 0 for the opponent's end-zone.

We differentiate the sides of the field by prefixing the location with the team's name. In this challenge, you can use a 1 character label or use positive and negative values. It must go 0-49,50,49-0 and have a way to differentiate between the sides. Your choice on who owns the 50yd line.

Sample Output: (Our team is A, the opponent's team is B)

1st & 7 on A 13
2nd & 10 on A 48
3rd & 12 on 50 OR 3rd & 12 on A 50 OR 3rd & 12 on B 50
4th & 8 on B 10
2nd & Goal on B 7 (read ahead)

Your team will start on your own 1 yard line on 1st & 10 (1st down, 10 yards to go for another first down). You will then gain a uniformly random number of yards between [-3,10] called N. If you didn't get enough for a 1st down, it will now be 2nd & (10 - N). Repeat drawing another number between [-3,10] and adding the yardage for 2nd and 3rd downs if it's still not enough for a 1st down. If you do gain enough for a 1st down, you simply go back to 1st & 10 on the next go and continue going down the field.

On 4th Down, your team is playing safe and will either punt or go for a Field Goal. If you are further away than their 40, output P. If you're within 40 yards, you will attempt a Field Goal with 100 - Yards Away% chance of success. If you succeed, output FG. If you miss, output NG ("No Good"). Afterwards, terminate.

However, there are two special situations that must be handled.

If you get within 10yd (inclusive) and gain a 1st Down, It will then be 1st & Goal and there are no more opportunities to gain 1st downs. Do or die! If you score, output TD and terminate, otherwise you'll follow the normal Field goal rules.

If you lose enough yards to go into your own end-zone, that's called a Safety. Simply output a S and terminate.

Rules:

• No usable input will be provided
• Output is flexible. Tuples and lists of lists are all fine.

Sample Runs:
To-Do

Tags: Code-golf, random, game

---

Feedback? Does the Field goal add enough meat to be worth including?

Answer 10

What order(s) can I fire my tonics in?

code-golf game

---

Helsing's Fire is a classic mobile game about light. You fire blasts of holy retribution (from chemicals called tonics), using cover to selectively hit enemies in the right sequence.

For this challenge, we're going to ignore the line-of-sight stuff and focus on just the tonic order. Each monster is represented by a string like RBBGB—this indicates that, in order to kill it, you need to hit it with a red tonic, followed by 2 blue tonics, then one green tonic and finally one more blue tonic.

Since you're allowed to ignore cover and pick any subset of the monsters to hit, any of the following sequences will kill it:

RBBGB
GRBBGBRR
RBBBBBBBBBBBBBBBGGGGBR
RRRBGGGBBRGRBB

Your goal is to take in a list of monsters as well as how many of each tonic you have, and output every possible ordering of tonics that kills every monster, including ones where not every tonic is fired. For instance:

R; 2 red -> R, RR
R; 1 red/1 blue -> R, RB, BR
No monsters, but tonics -> every possible permutation of the tonics listed
No tonics, but monsters -> no output, empty set output, or single trailing separator
Neither tonics nor monsters -> empty string
RB,BR; 2 red/2 blue -> RBR, BRB, BRBR, RBBR, RBRB, BRRB
RR,RR,GRG,R,GBR,GR,GRRR,GGR,GB,G,R,BBR; 3 red/2 blue/2 green -> BGRRBGR, BGRRGBR, BGRBRGR, BGRBGRR, BGRGRBR, BGRGBRR, BGBRRGR, BGBRGRR, GRRBBGR, GRRBGBR, GRRGBBR, GRBRBGR, GRBRGBR, GRBBRGR, GRBBGRR, GRBGRBR, GRBGBRR, GRGRBBR, GRGBRBR, GRGBBRR, GBRRBGR, GBRRGBR, GBRBRGR, GBRBGRR, GBRGRBR, GBRGBRR, GBBRRGR, GBBRGRR
BR,R,BR,RBBR,RBR,RGB,RGBR,GB,RGR,GG,GRB,G; 3 red/2 blue/2 green -> RBGRBRG, RBGRBGR, RBGRGBR, RBGGRBR, RGRBBRG, RGRBBGR, RGRBGBR, RGRGBBR, RGBRBRG, RGBRBGR, RGBRGBR, RGBGRBR, RGGRBBR, RGGBRBR, GRRBGBR, GRRGBBR, GRBRGBR, GRBGRBR, GRBGBR, GRBGBRR, GRGRBBR, GRGBRBR, GRGBBR, GRGBBRR

---

Would there be a duplicate for this?

Answer 11

Fun with Lasers and Prisms (WIP)

Given a rectangular grid of objects, one or more laser pointers, and a target, determine if any laser beam will hit the target.

Objects

ASCII will be used for illustration purposes

• Laser Pointer: ^, V, <, > - a beam will shoot up, down, left, right, respectively, starting from this cell.
• Target: O - return true if a beam reaches this cell
• Mirror: /, \ - reflects a beam 90 degrees
• Prism: # - the laser will split into three beams, one for each direction
• One-way block: A, U, (, ) - a beam will pass up, down, left, right, respectively, but not other directions
• Corridor block: =, " - a beam will only pass horizontally or vertically, respectively
• Gate block: I, H - a beam will pass through horizontally if another beam touches it vertically, or vice-versa, respectively

Rules

• Use any convenient representation

Answer 12

How low can you go?

Time to play so ascii-art limbo!

Here's the bar:

|--|
|  |
|  |

Can you fit under it?

Goal

Write a program or function that takes an ascii string representing a some shape, and a positive integer representing a bar height.

Output the shape from the input after it has attempted to do the limbo.

Details

In limbo you lean back to make yourself as small as possible to fit under the bar, and that is just what the input shapes will try and do.

If the input shape contains any repeating patterns in its lines, then you can remove all but the last of the repetitions that are in the pattern. In additions the pattern must start at the top line, and once the repeating pattern is broken no more sections can be removed.

If there is a repeating pattern that contains another repeating pattern, only the innermost pattern is stripped.

For example this is how the following inputs would look after "Leaning back":

1. XXX              2. xxx            3. xxx           4. xxx      
   YYY                 xxx       xxx     xxx              xxx      xxx
   XXX   -->   XXX     yyy  -->  yyy     xxx  -->         yyy      yyy
   YYY         YYY     zzz       zzz     xxx              yyy      yyy
   zzz         zzz     aaa       aaa     xxx      xxx     xxx  --> xxx
                                                          xxx      xxx
                                                          yyy      yyy
                                                          yyy      yyy

Note how in example number 4 there was a repetition ox xxx insinde of another repetition of xxx, xxx, yyy, yyy. In this case only the inner repeating lines got reduced.

The bars will be drawn as shown below for the given heights:

1 -> |--|    2 -> |--|   3 -> |--|  etc...
                  |  |        |  |
                              |  |

If the given input shape in its reduced form does not fit underneath the bar then the bar will be drawn on the ground like this |__|

Exmaples

Inputs:

a. height: 3      b.  height: 2     c.  height: 1
   shape: xxx         shape: xxx        shape: (emptystring)
          xxx                xxx
          xxx                xxx
          yyy                yyy

Outputs:

a. |--|           b. |  | xxx       c. |--| 
   |  | xxx          |__| yyy  
   |  | yyy

Notes

1. You can assume only valid inputs will be given, handle invalid input however you want
2. The input shape will be drawn 1 space after the bar, and the bottom of the input shape will always line up with the bottom of the bar.
3. Extra whitespace after is fine as long as all the lines are properly aligned.
4. If there is whitespace in the given input then that should be included in the output
5. The shape will not necessarily always line up in a perfect rectangle as I drew it.

This is for code-golf so the answer using the fewest bytes wins.

code-golf ascii-art

---

Please let me know what you think / if anything is unclear and needs to be improved. Hope you guys like it!

---

EDIT: Would whoever down voted please explain whats wrong with it?

Answer 13

Factorise a floating point number

Given a target floating point number, \$T\$ and a set of \$N\$ floating point numbers \$\{x_{1},..,x_{N}\}\$ and a permissible error \$tol\$ , find a set of integer coefficients \$A\$, \$\{m_{1},..,m_{N}\}\$ such that: $$ A\prod\limits_{i=1}^{N}x_{i}^{m_{i}} = T\pm{}tol $$

Input

Input will be a target number, a set of real numbers and a tolerance as a decimal or percentage (note which) in any order or format required by your language.

Output

Output should be \$A\$, \$\{m\}\$ and the corresponding error as a percentage. If multiple combinations are valid any or all sets of \$A\$ and \$\{m\}\$ are within tolerance.

General rules

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

Examples

\$3*(3.2^4*7.1^2)=15857.614848\$

15857.6 [3.2, 7.1] 0.05 => 3, [4, 2]

\$2*(e^2*\pi{}^2)=145.854121188\$

145.85 [2.7182, 3.1415] 0.1 => 2, [2, 2]

\$3*(\pi^0*0.1^1)\$

0.3 [3.14159, 0.1] 0.05 => 3, [0, 1]

Answer 14

The periodic table and the chemical symbols code-challenge string

Periodic table

The periodic table is a large table^{citation needed} where we can find the chemical elements written out with their chemical symbols. For example, Helium shows up as He and Carbon shows up as C. You can read Wikipedia's article on the periodic table, if you want.

Your task

You have to write a function/program/procedure/... that, given a chemical element's name, returns its chemical symbol. For the purposes of this challenge, we will use the 118 elements listed below:

['Hydrogen', 'Helium', 'Lithium', 'Beryllium', 'Boron', 'Carbon', 'Nitrogen', 'Oxygen', 'Fluorine', 'Neon', 'Sodium', 'Magnesium', 'Aluminium', 'Silicon', 'Phosphorus', 'Sulfur', 'Chlorine', 'Argon', 'Potassium', 'Calcium', 'Scandium', 'Titanium', 'Vanadium', 'Chromium', 'Manganese', 'Iron', 'Cobalt', 'Nickel', 'Copper', 'Zinc', 'Gallium', 'Germanium', 'Arsenic', 'Selenium', 'Bromine', 'Krypton', 'Rubidium', 'Strontium', 'Yttrium', 'Zirconium', 'Niobium', 'Molybdenum', 'Technetium', 'Ruthenium', 'Rhodium', 'Palladium', 'Silver', 'Cadmium', 'Indium', 'Tin', 'Antimony', 'Tellurium', 'Iodine', 'Xenon', 'Cesium', 'Barium', 'Lanthanum', 'Cerium', 'Praseodymium', 'Neodymium', 'Promethium', 'Samarium', 'Europium', 'Gadolinium', 'Terbium', 'Dysprosium', 'Holmium', 'Erbium', 'Thulium', 'Ytterbium', 'Lutetium', 'Hafnium', 'Tantalum', 'Tungsten', 'Rhenium', 'Osmium', 'Iridium', 'Platinum', 'Gold', 'Mercury', 'Thallium', 'Lead', 'Bismuth', 'Polonium', 'Astatine', 'Radon', 'Francium', 'Radium', 'Actinium', 'Thorium', 'Protactinium', 'Uranium', 'Neptunium', 'Plutonium', 'Americium', 'Curium', 'Berkelium', 'Californium', 'Einsteinium', 'Fermium', 'Mendelevium', 'Nobelium', 'Lawrencium', 'Rutherfordium', 'Dubnium', 'Seaborgium', 'Bohrium', 'Hassium', 'Meitnerium', 'Darmstadtium', 'Roentgenium', 'Copernicium', 'Nihonium', 'Flerovium', 'Moscovium', 'Livermorium', 'Tennessine', 'Oganesson']

with the respective element symbols:

['H', 'He', 'Li', 'Be', 'B', 'C', 'N', 'O', 'F', 'Ne', 'Na', 'Mg', 'Al', 'Si', 'P', 'S', 'Cl', 'Ar', 'K', 'Ca', 'Sc', 'Ti', 'V', 'Cr', 'Mn', 'Fe', 'Co', 'Ni', 'Cu', 'Zn', 'Ga', 'Ge', 'As', 'Se', 'Br', 'Kr', 'Rb', 'Sr', 'Y', 'Zr', 'Nb', 'Mo', 'Tc', 'Ru', 'Rh', 'Pd', 'Ag', 'Cd', 'In', 'Sn', 'Sb', 'Te', 'I', 'Xe', 'Cs', 'Ba', 'La', 'Ce', 'Pr', 'Nd', 'Pm', 'Sm', 'Eu', 'Gd', 'Tb', 'Dy', 'Ho', 'Er', 'Tm', 'Yb', 'Lu', 'Hf', 'Ta', 'W', 'Re', 'Os', 'Ir', 'Pt', 'Au', 'Hg', 'Tl', 'Pb', 'Bi', 'Po', 'At', 'Rn', 'Fr', 'Ra', 'Ac', 'Th', 'Pa', 'U', 'Np', 'Pu', 'Am', 'Cm', 'Bk', 'Cf', 'Es', 'Fm', 'Md', 'No', 'Lr', 'Rf', 'Db', 'Sg', 'Bh', 'Hs', 'Mt', 'Ds', 'Rg', 'Cn', 'Nh', 'Fl', 'Mc', 'Lv', 'Ts', 'Og']

Input

The code you write should receive an element name in any sensible format, such as a string "helium". You may assume whatever capitalization that suits your needs.

Output

The code you write should return the element's symbol as a string, with any capitalization that suits your needs. Bonus imaginary internet points if you return the symbol with the standard capitalization.

Scoring

This is code-challenge so your answer doesn't win by being the shortest! You will be provided 118 test cases. Your score will be your code's byte count divided by the percentage of test cases your code passes correctly. Lowest score wins!

E.g. my code has 1 byte and I get 1 test case correct. My score is \$1 / \frac{1}{118} = 118 \$. Someone else writes some code with 110 bytes but gets all the test cases correct. The other person scores \$ 110 / \frac{118}{118} = 110 \$, meaning the other person has a better score than me.

Test cases:

'Hydrogen' -> 'H'
'Helium' -> 'He'
'Lithium' -> 'Li'
'Beryllium' -> 'Be'
'Boron' -> 'B'
'Carbon' -> 'C'
'Nitrogen' -> 'N'
'Oxygen' -> 'O'
'Fluorine' -> 'F'
'Neon' -> 'Ne'
'Sodium' -> 'Na'
'Magnesium' -> 'Mg'
'Aluminium' -> 'Al'
'Silicon' -> 'Si'
'Phosphorus' -> 'P'
'Sulfur' -> 'S'
'Chlorine' -> 'Cl'
'Argon' -> 'Ar'
'Potassium' -> 'K'
'Calcium' -> 'Ca'
'Scandium' -> 'Sc'
'Titanium' -> 'Ti'
'Vanadium' -> 'V'
'Chromium' -> 'Cr'
'Manganese' -> 'Mn'
'Iron' -> 'Fe'
'Cobalt' -> 'Co'
'Nickel' -> 'Ni'
'Copper' -> 'Cu'
'Zinc' -> 'Zn'
'Gallium' -> 'Ga'
'Germanium' -> 'Ge'
'Arsenic' -> 'As'
'Selenium' -> 'Se'
'Bromine' -> 'Br'
'Krypton' -> 'Kr'
'Rubidium' -> 'Rb'
'Strontium' -> 'Sr'
'Yttrium' -> 'Y'
'Zirconium' -> 'Zr'
'Niobium' -> 'Nb'
'Molybdenum' -> 'Mo'
'Technetium' -> 'Tc'
'Ruthenium' -> 'Ru'
'Rhodium' -> 'Rh'
'Palladium' -> 'Pd'
'Silver' -> 'Ag'
'Cadmium' -> 'Cd'
'Indium' -> 'In'
'Tin' -> 'Sn'
'Antimony' -> 'Sb'
'Tellurium' -> 'Te'
'Iodine' -> 'I'
'Xenon' -> 'Xe'
'Cesium' -> 'Cs'
'Barium' -> 'Ba'
'Lanthanum' -> 'La'
'Cerium' -> 'Ce'
'Praseodymium' -> 'Pr'
'Neodymium' -> 'Nd'
'Promethium' -> 'Pm'
'Samarium' -> 'Sm'
'Europium' -> 'Eu'
'Gadolinium' -> 'Gd'
'Terbium' -> 'Tb'
'Dysprosium' -> 'Dy'
'Holmium' -> 'Ho'
'Erbium' -> 'Er'
'Thulium' -> 'Tm'
'Ytterbium' -> 'Yb'
'Lutetium' -> 'Lu'
'Hafnium' -> 'Hf'
'Tantalum' -> 'Ta'
'Tungsten' -> 'W'
'Rhenium' -> 'Re'
'Osmium' -> 'Os'
'Iridium' -> 'Ir'
'Platinum' -> 'Pt'
'Gold' -> 'Au'
'Mercury' -> 'Hg'
'Thallium' -> 'Tl'
'Lead' -> 'Pb'
'Bismuth' -> 'Bi'
'Polonium' -> 'Po'
'Astatine' -> 'At'
'Radon' -> 'Rn'
'Francium' -> 'Fr'
'Radium' -> 'Ra'
'Actinium' -> 'Ac'
'Thorium' -> 'Th'
'Protactinium' -> 'Pa'
'Uranium' -> 'U'
'Neptunium' -> 'Np'
'Plutonium' -> 'Pu'
'Americium' -> 'Am'
'Curium' -> 'Cm'
'Berkelium' -> 'Bk'
'Californium' -> 'Cf'
'Einsteinium' -> 'Es'
'Fermium' -> 'Fm'
'Mendelevium' -> 'Md'
'Nobelium' -> 'No'
'Lawrencium' -> 'Lr'
'Rutherfordium' -> 'Rf'
'Dubnium' -> 'Db'
'Seaborgium' -> 'Sg'
'Bohrium' -> 'Bh'
'Hassium' -> 'Hs'
'Meitnerium' -> 'Mt'
'Darmstadtium' -> 'Ds'
'Roentgenium' -> 'Rg'
'Copernicium' -> 'Cn'
'Nihonium' -> 'Nh'
'Flerovium' -> 'Fl'
'Moscovium' -> 'Mc'
'Livermorium' -> 'Lv'
'Tennessine' -> 'Ts'
'Oganesson' -> 'Og'

I used this code to shape the list into the test cases, might be useful to you.

Elements and symbols extracted from https://www.thoughtco.com/element-list-names-atomic-numbers-606529, visited at the 9th of February of 2020. At the time of writing, 118 elements were available. Source included "Aluminum" and "Aluminium" as alternatives, dropped "Aluminum" for the purposes of this challenge.

Answer 15

Count switches in a smallest square root sequence mod \$2^n\$ code-golfnumbernumber-theory

Answer 16

Compress even permutations

Factorial number system

Every nonnegative integer can be encoded by factorial number system. Factorial number system doesn't have a fixed radix, but uses the factorial of nonnegative integers as radices. The place of \$0!\$ can have \$0\$ as the digit, the place of \$1!\$ can have \$0\$ or \$1\$ as the digit, the place of \$2!\$ can have \$0\$, \$1\$, or \$2\$ as the digit, and so on. Subscript exclamation mark denotes that the integer is encoded in factorial number system. For example:

$$ 41010_! = 4 \times 4! + 1 \times 3! + 0 \times 2! + 1 \times 1! + 0 \times 0!= 103_{10} $$

Permutations

Numbers encoded by factorial number system has one-to-one correspondence to permutations:

$$ 41010_! \cong \begin{pmatrix} 0 \\ 0 \end{pmatrix} \begin{pmatrix} 1 & 0 \\ 0 & 1 \end{pmatrix} \begin{pmatrix} 2 & 1 & 0 \\ 2 & 1 & 0 \end{pmatrix} \begin{pmatrix} 3 & 2 & 1 & 0 \\ 0 & 3 & 2 & 1 \end{pmatrix} \begin{pmatrix} 4 & 3 & 2 & 1 & 0 \\ 3 & 2 & 1 & 0 & 4 \end{pmatrix} = \begin{pmatrix} 4 & 3 & 2 & 1 & 0 \\ 1 & 3 & 2 & 0 & 4 \end{pmatrix} $$

That is, each the place of \$n!\$ represents a right-direction rotation of \$n\$ through \$0\$, and its digit represents what \$0\$ becomes after the rotation.

It follows that the parity of the permutation is same as the parity of the sum of digits at the places of factorials of odd numbers. For \$41010_!\$, the permutation is even because \$1 + 1 = 2\$ is even.

Objective

An even permutation of 5 elements, or any equivalent object will be the input. That leaves \$5! \div 2 = 60\$ distinct permutations. Compress it to \$\lceil \log_2{60}\rceil=6\$ bits.

Rules

• Input type and format doesn't matter. Possible choices of input format include (in C++):

  • std::map<int,int> scrambling the numbers from \$4\$ to \$0\$

  • int[5] containing the digits of the factorial number system

  • int[4] containing the digits of the factorial number system, except the place of \$0!\$ (it doesn't contribute to the permutation)

  • int encoded by the factorial number system

• Output type and format doesn't matter either. It may be:

  • bool[6]

  • int8_t

  • a bit field

  • std::string containing ASCII digit 0s and 1s

• Invalid inputs fall in don't care situation.

Answer 17

Simplify a directed graph

code-golf graph-theory math

Input

A connected directed graph, in any convenient format. A valid format (and probably the most convenient) would be a list of edges.

Simplification

These two reductions are performed as often as possible. It does not suffice to apply one reduction first, then the other, as each of them can cause more of the other one.

Let \$E\$ be the set of all edges of the graph in the following explanations. For example \$E = \{(0, 1), (1, 2), (2, 0)\}\$ represents the following graph:

0 ----> 1
^       |
'-- 2 <-'

Let \$E_a\$, where \$a\$ is a vertex, indicate the set of edges involving \$a\$:

$$E_a := \{(u, v) \in E : u = a \vee v = a\}$$

Two graphs are isomorphic iff all vertices from one graph can be relabeled to make it equal to the other graph.

Deduplication

If there are disjoint sets of vertices \$M\$ and \$N\$ (\$M \cap N = \emptyset\$) not directly connected (\$((M, N) \cup (N, M)) \cap E = \emptyset\$) and the graphs with edges \$E \setminus E_M\$ and \$E \setminus E_N\$ are isomorphic, then the vertices \$M\$ (or \$N\$, but not both, are removed).

This means that of any two non-overlapping, non-directly-connected subgraphs that leave isomorphic graphs behind when removed, one is removed.

Simple example:

b --> 1
      ^  ==>  b --> 1
      |
      a

Relay removal

If there are vertices \$a\$ and \$b\$ and a non-empty set of vertices \$N\$, such that \$b \notin N\$ and \$E_b = \{(a, b)\} \cup (b, N)\$, then \$b\$ is removed from the graph and edges \$(a, N)\$ are added if they do not alreay exist.

This means that a vertex with exactly one edge ending there, at least one edge starting there and no self-loop can be removed, moving the starting edges to the start of the ending edge.

Simple example:

            1             1
            ^             ^
            |             |
O --> a --> b  ==>  O --> a ----.
      ^     |             ^     |
      |     v             |     v
      '---- 2             '---- 2

Output

The output is the result of the reductions, in any convenient format. If identifiers are used for edges or vertices, as in a list of edges, these identifiers are not required to correspond to identifiers in the input.

A different format may be used for input and output.

Scoring

This is code-golf: Lowest bytecount in each language wins. No answer will be accepted, as there is no overall winner.

Other rules

• Standard loopholes apply
• Functions or programs
• Any input and output methods (STDIN, arguments, prompt(), ...)

Test cases

not yet

Meta:

• Everything clear?
• Better explanations?
• Better title?
• I'm not sure whether output might depend on the order in which reductions are performed.

Answer 18

Let's Play Countdown!

(The Numbers round this time)

code-golf math

Countdown is a British TV game show composed of three different styles of rounds; the letters round, the conundrum, and the numbers round.

The conundrum could be solved with the same program you'd make for the Letters round, so let's tackle the third option that hasn't been done yet!

Challenge

Take in a set of numbers. One of which is the "Target" number, and the rest are the building numbers.

The Countdown Number Round asks you to take the building numbers and to construct the Target number only using the four elementary operators. Every step must result in another strictly-positive integer (so non-perfect division is disallowed). Output the method to which you can construct the target number. If that's impossible, get as close as possible (above or below are scored the same). Numbers do not need to be used, but may NOT be reused.

Note - You will perform at most N-1 operations, where N is the number of building numbers. Every elementary operator takes in two inputs and provides one, so you "lose" one from your ranking every operation. That should give you an idea of the size of your output.

I/O is in any reasonable format, but target vs building numbers must be obviously distinct (either by the target being the first or the last number, or outside an array, or a different type, etc).

Output needs to explain exactly what operations are being performed on what numbers, and what the output for each operation would be, but can be done in whichever way seems reasonable.

Example I/O

In these examples, the first element is the target.

[888 100 2 75 3 1 10]
75-1=74
10+2=12
74x12=888

[766 22 10 8 3 1]
22+10=32
32x8=256
256-1=255
255x3=765 #You cannot get this one exactly, but one-off is close.

Sandbox Questions

I'm... like 85% sure this isn't anywhere here yet. I did a chunk of searching and couldn't find anything that fit the bill, so I think this is clear?

Any other neat examples you guys got?

Answer 19

Iterative Quadratics

Recently, in my algebra class, we proved that the following process always stops at some point, so I thought it would be a cool challenge!

Input: Two reals a,b.

Output Non-negative integer

Challenge:

Given two reals a,b, initialize a count variable c to 0, consider the quadratic equation

x^2+ax+b

If this quadratic has real roots r,s (r<=s), increment the counter by 1, and replace a,b with r,s and repeat the process.

If the quadratic has complex roots, return c.

Test Cases

To be added.

Answer 20

Doubly stochastic matrix code-golf

A doubly-stochastic matrix is a square matrix of non-negative real entries each of whose rows and columns sums to 1. Given a doubly-stochastic matrix, express it as a non-negative linear combination of permutation matrices, as is guaranteed to exist by the Birkhoff–von Neumann theorem.

TODO: Example, better explanation, test cases. If you want to develop and post this challenge, it's yours.

Answer 21

Implement GF(2²)

Introduction to groups and fields

An additive group is a set with addition and negation defined. They must satisfy the following conditions:

• \$0\$ is the additive identity.

• Addition is associative.

• For every \$x\$, the negation of \$x\$, \$-x\$ exists, and \$x + (-x) = (-x) + x = 0\$.

If addition is also commutative, the additive group is called abelian.

A field is an additive abelian group with multiplication and reciprocal defined. They must satisfy the following conditions:

• \$1\$ is the multiplicative identity.

• Multiplication is associative and commutative.

• For every nonzero \$x\$, the reciprocal of \$x\$, \$x^{-1}\$ uniquely exists, and \$x\times x^{-1} = x^{-1}\times x = 1\$.

• Multiplication distributes over addition.

Modular Arithmetic

For every positive integer \$n\$, you can define an additive abelian group as follows:

• Define the set as integers from \$0\$ to \$n-1\$.

• Define addition as usual addition with the result moduloed by \$n\$.

• Define negation as usual negation with the result moduloed by \$n\$.

This group is denoted by \$ℤ_n\$. If \$n\$ is prime, multiplication can be analogously defined, making it a field. In particular, the operation tables of \$ℤ_2\$ are:

$$ \begin{array}{l|ll} + & 0 & 1 \\ \hline 0 & 0 & 1 \\ 1 & 1 & 0 \end{array} \begin{array}{l|ll} x & -x \\ \hline 0 & 0 \\ 1 & 1 \end{array} \begin{array}{l|ll} × & 0 & 1 \\ \hline 0 & 0 & 0 \\ 1 & 0 & 1 \end{array} \begin{array}{l|ll} x & x^{-1} \\ \hline 0 & \text{NaN} \\ 1 & 1 \end{array} $$

Galois Field GF(2²)

A Galois field \$\text{GF}(p^k)\$ emerges when one takes the set as polynomials over \$ℤ_p\$, and defines addition and multiplication as the usual operation with polynomial modulo, where the modding polynomial is irreducible and has degree of \$k\$. Since \$x^2+x+1\$ is an (in fact, the only) irreducible polynomial over \$ℤ_2\$ that has degree \$2\$, this results in \$\text{GF}(2^2)\$. Its operation tables are:

$$ \begin{array}{l|ll} + & 0 & 1 & x & x+1 \\ \hline 0 & 0 & 1 & x & x+1 \\ 1 & 1 & 0 & x+1 & x \\ x & x & x+1 & 0 & 1 \\ x+1 & x+1 & x & 1 & 0 \end{array} \begin{array}{l|ll} f(x) & -f(x) \\ \hline 0 & 0 \\ 1 & 1 \\ x & x \\ x+1 & x+1 \end{array} \\ \begin{array}{l|ll} × & 0 & 1 & x & x+1 \\ \hline 0 & 0 & 0 & 0 & 0 \\ 1 & 0 & 1 & x & x+1 \\ x & 0 & x & x+1 & 1 \\ x+1 & 0 & x+1 & 1 & x \end{array} \begin{array}{l|ll} f(x) & f(x)^{-1} \\ \hline 0 & \text{NaN} \\ 1 & 1 \\ x & x+1 \\ x+1 & x \end{array} $$

Your task is to implement the set and the operations. As a conseuqence, you must have:

• The members of the set defined as constants (2-bit bitstring, an ASCII digit, or whatever). This won't contribute to the score.

• Four codes that defines each operations, whose input(s) is/are as defined above.

Rules

• Though defined as polynomials, the type and format of the inputs doesn't matter. You must have the same type for every input.

• The type and format of the outputs doesn't matter either, but it must be the same as the input(s).

• The reciprocal of \$0\$ must result in an "error" condition. This includes returning an errornous value, throwing an error, or terminating the program. It must halt.

• Other invalid inputs fall in don't care situation.

• Since there are multiple codes, the score for code golf is alloted by the sum of their lengths in bytes.

Answer 22

Shared Letters in consecutive numbers

Inspired by this puzzling question.

It turns out that, in English, every pair of consecutive integers (e.g. 0,1, 1,2, etc.) shares at least one letter when spelled out (e.g. zErO, OnE (or NOught, ONe); One, twO, etc).

Input

Any two non-negative integers (all natural numbers including 0) up to and including one googol. These can be input as any type you choose, but string representations must only use the characters 0123456789.,' (i.e. the numbers must not already be spelled out on input, but rather input as a numeral).

You can assume that the two numbers will be consecutive.

Some examples of valid inputs:

{1,2}
{"1","2"}
{1},{2}
{{"1"},{2}}
"123,245", "123,246"
"123.456", "123'457"

some examples of invalid inputs

{1,3}
{-1,0}
{1.1,1.2}
{"one","two"}

The Challenge

Given the two inputs, output all shared characters when spelled (both numbers spelled in either lower or upper-case, the same case for both numbers).

A sample implementation for spelling numbers can be found here: https://stackoverflow.com/a/3911982/318414; but I'm sure other options exist; and there are certainly efficiencies to be found given that there are large amounts of shared strings, once you get into the higher numbers. See also https://simple.wikipedia.org/wiki/Names_for_large_numbers for the names of large numbers.

code-golf, usual exclusions apply

Output The shared letters, in any reasonable format. Any of the three numbering systems on the Wikipedia page are valid.

Examples

I will be assuming British English (long form) in my examples.

{6,7} -> "s" or "S" (six, seven)

{999,1000} -> {"n","e"," ","t","h","u","a","d"} (nine hundred and ninety nine, one thousand)

{88955,88956} -> `` (eighty eight thousand nine hundred and fifty five, eighty eight thousand nine hundred and fifty six)

1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000,1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001 -> "ONE THUSADQICL" (ONE THOUSAND QUINDECILLION, ONE THOUSAND QUINDECILLION AND ONE)

9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999, 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000 -> el no (nine hundred and ninety nine thousand sexdecillion **nine hundred and ninety nine thousand quindecillion nine hundred and ninety nine thousand quatturodecillion nine hundred and ninety nine thousand tredecillion nine hundred and ninety nine thousand duodecillion nine hundred and ninety nine thousand undecillion nine hundred and ninety nine thousand decillion nine hundred and ninety nine thousand nonillion nine hundred and ninety nine thousand octillion nine hundred and ninety nine thousand septillion nine hundred and ninety nine thousand sextillion nine hundred and ninety nine thousand quintillion nine hundred and ninety nine thousand quadrillion nine hundred and ninety nine thousand trillion nine hundred and ninety nine thousand billion nine hundred and ninety nine thousand million nine hundred and ninety nine thousand nine hundred and ninety nine; one googol)

Answer 23

Find spies in a multilingual csv

Introduction

You are an NSA undercover agent in a Middle-Eastern HR company, you just received a list of people with their jobs in many different languages. Some are spies and you need to know who. Your mission, if you accept it, is to get what are people working in, and relate it to a list of job categories. Most dangerous elements are those working in Law enforcement and security. However as your code will be part of a bigger file it needs to be as short in lines as possible for stealthness. This comes from expectations I encountered in the administration to keep some mystery behind code, if ever it were to be stolen.

• This challenges your way to handle loops, map, reduce and filter, destructuring or unpacking an array/csv/df. Last but not least it allows you to get into the fascinating world of cross-language nlp.

I provide an example in python (64 lines of code)

Challenge

The challenge is to get, in the shortest amount of bytes (libraries not included) the most similar element in an array of string with another string, and this for each line of a csv taken as input.

• Inputs:

  1. X.csv a csv/dataframe of actual jobs that look like this one:

,new_professionactuelle
0,Entrepreneur
1,طالبة
2,ETUDIANT
3,ETUDIANT 
4,موظف
5,موجه تربوي 
6,Réalisateur film cartoon
7,إإطار مالي
8,موضف إطار
9,مهندس بمكتب دراسات
10,باحثة  _ كاتبة _ 
11,طالب
12,Chef de projet
13,ASSUREUR
14,FONCTIONNAIRE D'ÉTAT
15,Professeur Universitaire
16,cadre supérieur
17,fonctionnaire
19,professeur
20,Chef de projet
21,مدير  شركة
22,Avocat
23,cadre à Maroc Telecom
24,Employé 
25,Consultant en Immobilier
26,fonctionnaire
27,اجير أو عامل

2. df.csv job categories that must include all the following categories:

   ['Agriculture, farming and environment',
      'Accountancy, banking and finance',
      'Teacher training and education', 'Leisure, sport and tourism',
      'Transport and logistics', 'Information technology',
      'Hospitality and events management',
      'Business, consulting and management', 'Creative arts and design',
      'Trade', 'Law enforcement and security',
      'Property and construction', 'Law',
      'Engineering and manufacturing', 'Social care',
      'Charity and voluntary work', 'Sales',
      'Public services and administration', 'Other. Please specify:',
      'Healthcare', 'Energy and utilities',
      'Marketing, advertising and PR', 'Media and internet',
      'Recruitment and HR', 'Science and pharmaceuticals']
   

   • Output would be the column in X.csv plus a new column, the most similar job. The most accurate results are:

,new_professionactuelle,category
0,Entrepreneur,Public services and administration
1,طالبة,Teacher training and education
2,ETUDIANT,Teacher training and education
3,ETUDIANT ,Teacher training and education
4,موظف,Recruitment and HR
5,موجه تربوي ,Teacher training and education
6,Réalisateur film cartoon,Creative arts and design
7,إإطار مالي,"Accountancy, banking and finance"
8,موضف إطار,Trade
9,مهندس بمكتب دراسات,Engineering and manufacturing
10,باحثة  _ كاتبة _ ,Recruitment and HR
11,طالب,Teacher training and education
12,Chef de projet,Creative arts and design
13,ASSUREUR,Business, consulting and management
14,FONCTIONNAIRE D'ÉTAT,Public services and administration
15,Professeur Universitaire,Teacher training and education
16,cadre supérieur,Business, consulting and management
17,fonctionnaire,Public services and administration
18,CDB Retraite,Recruitment and HR
19,professeur,Teacher training and education
20,Chef de projet,Public services and administration
21,مدير  شركة,Recruitment and HR
22,Avocat,Law
23,cadre à Maroc Telecom,Media and internet
24,Employé ,Sales
25,Consultant en Immobilier,Property and construction
26,fonctionnaire,Public services and administration
27,اجير أو عامل,Recruitment and HR

• Inputs should be tested against all categories.

The winner of the challenge will be the one with the most accurate results. If on the test set. If several are as accurate, the shortest amount of bytes will be the winner. You can use any methods to get the most similar item. The state of the art method seems to be according to Google Multilingual Universal Sentence encoder. I provide an attempt with the code below but you will see it is not quite acccurate.

Example in Python

Double agent: A spy who works for two countries, and sometimes even three, in which case he is definitely a trouble. - Mots et Grumots (2003), Marc Escayrol

#@title Setup common imports and functions
import numpy as np
import os
import pandas as pd
import tensorflow.compat.v2 as tf
import tensorflow_hub as hub
from tensorflow_text import SentencepieceTokenizer
import sklearn.metrics.pairwise

from simpleneighbors import SimpleNeighbors
from tqdm import tqdm
from tqdm import trange

import json

def most_similar(embeddings_1, embeddings_2, labels_1, labels_2):

  assert (len(embeddings_1) == len(labels_1) and len(embeddings_2) == len(labels_2))

  # arccos based text similarity (Yang et al. 2019; Cer et al. 2019)
  sim = 1 - np.arccos(sklearn.metrics.pairwise.cosine_similarity(embeddings_1, embeddings_2))/np.pi

  embeddings_1_col, embeddings_2_col, sim_col = [], [], []
  for i in range(len(embeddings_1)):
    for j in range(len(embeddings_2)):
      embeddings_1_col.append(labels_1[i])
      embeddings_2_col.append(labels_2[j])
      sim_col.append(sim[i][j])
  df = pd.DataFrame(zip(embeddings_1_col, embeddings_2_col, sim_col),
                    columns=['embeddings_1', 'embeddings_2', 'sim'])

  # return the higest similarity one
  category = df['embeddings_1'].iloc[df['sim'].argmax()]
  return category

def main():

    X = pd.read_csv('X.csv')
    y = pd.read_csv('y.csv')
    df_rni = pd.read_csv('df.csv')

    # The 16-language multilingual module is the default but feel free
    # to pick others from the list and compare the results.
    module_url = 'https://tfhub.dev/google/universal-sentence-encoder-multilingual/3' #@param ['https://tfhub.dev/google/universal-sentence-encoder-multilingual/3', 'https://tfhub.dev/google/universal-sentence-encoder-multilingual-large/3']

    model = hub.load(module_url)

    def embed_text(input):
        return model(input)

    def compute_similarity(references, target):
        # I want to create as many rows as there are references and fill them with the results
        # arccos based text similarity (Yang et al. 2019; Cer et al. 2019)
        for row in target.iterrows():
            for reference in references:
                sim = 1 - np.arccos(
                result = sklearn.metrics.pairwise.cosine_similarity(row,
                                                                    reference))/np.pi

            # place the result in the column "reference"

    # get unique job categories and job of people
    job_categories = X.S02Q11_Professional_field.unique()
    # turn them to list
    job_categories = job_categories.tolist()
    # emebedding job categories 
    references_result = embed_text(job_categories[1:])

    for _, row in df_rni.iterrows():
        actual_job = row['new_professionactuelle']
        # check for nan that can't be embedded
        if str(actual_job) != 'nan':
            # embedding actual job
            target_result = embed_text(actual_job)
            # visualize similarity
            category = most_similar(references_result, target_result, job_categories[1:], [actual_job])
        else: category = None

if __name__ == "__main__":
    main()

Answer 24

Auto Tic Tac Toe

Okay, so after thinking about the comment I think I thought of a way to make it more interesting.

---

Challenge

Given no input, write a program or function which outputs an entire game of Tic-Tac-Toe where X always wins, or the game ends in a tie.

Requirements

• X goes first
• O must make moves at random
• X must make smart moves such that it always wins the game, or the game ends in a tie

Example

Here's what I would expect a game to look like:

X--
---
---

XO-
---
---

XO-
-X-
---

XOO
-X-
---

XOO
-X-
--X

Notes:

• X does not need to win in the fewest moves, it is enough to just make it always block O from winning
• You can output the game in whatever form you like, as long as it is easily conveys every turn of the game. For example you could output a string like above, or a list of lists of ints like below, where 0 is an empty space and 1, 2 are X, O respectively:

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

This is code golf, answer in the fewest bytes wins. Standard rules apply.

---

Is this a better challenge? I'd love to know what people think

---

Working example of ungolfed code: Try it online!

Answer 25

Compute the Pareto frontier

Given a set of triplets, output its Pareto frontier.

Definitions

A triplet is a list of 3 positive integers, for example [120, 15, 21] (order matters).

A triplet [A, B, C] is objectively worse than [a, b, c] when A >= a, B >= b, and C >= c (lower is better).

A triplet is on the Pareto frontier when it's not objectively worse than any other triplet in the input.

I/O rules

Input and output are both a set of triplets. Each triplet must be represented as either a list of integers ([1, 2, 3]) or a /-delimited string ("1/2/3"). The format of the outer sets is flexible (built-in set type, list, or delimited string are all okay).

Test cases

[[1, 1, 1], [2, 2, 2]] => [[1, 1, 1]]
[[3, 3, 1], [3, 1, 3], [1, 3, 3], [2, 2, 2]] => [[3, 3, 1], [3, 1, 3], [1, 3, 3], [2, 2, 2]]
... (more to come) ...

Answer 26

A similar challenge was posted here but that's outdated and I have a few twists.

Challenge

Write a program, expression or subroutine which, given an arithmetical expression in infix notation, like 1 + 2, outputs the same expression in postfix notation except the numbers are now float representative in the string, i.e. 1.0 2.0 +.

The input can include parentheses (()), exponents (^), division (/) and multiplication (*), addition (+) and subtraction (-) (in that order of operation), such as

4 ^ (2 / 3) * 9 * 3 - - 4 * 6

output the same expression in prefix notation.

4.0 2.0 3.0 / ^ 9.0 * 3.0 * -4.0 6.0 * -

Spaces are optional in the input as well as the output.

Twists

• Must support using floats too, instead of just integers. so 4 ^ (2.0/3.0) * 9.0 * 3.0 - - 4 *6 output's is the same as the ones above.
• Must return a string with all numbers as its float representative instead of as its original form, so 9 -> 9.0 and if it was 9.0 it stays 9.0.
• Must support negation (see example above "3.0 - - 4" ends up with "-4.0", negative sign stays in place).
• Cannot use exec() or eval() functions.

Assumptions

• You can assume that there will not be any special numbers such as those in scientific notation or those with hanging zeroes, e.g. 000004 or 0005.000000.
• You should also not assume the commutative or associative properties. This means that, while the operators will move around, the numbers will always remain in the same order.
• You can always assume a valid infix input.

Clarifications

• You should not evaluate any expression.
• The output should not contain any unneeded parentheses. ((2+1))-1 should reduce to 2+1-1.

Game Winning Criteria

Fewest amount of characters wins. Bytes are not of a matter here.

Answer 27

Dilapidated art gallery problem

code-golf ascii-art

In a typical art gallery problem, the objective is to place as few guards as necessary inside an arbitrary polygon so that all of it is visible by some guard. This time, we'll make some changes to simplify the task:

• The gallery can only afford to pay one guard. No more. This means that it won't be possible to keep everything in sight, so the objective becomes to maximize the amount of art visible.
• Not even a dilapidated art gallery is barbaric enough to put art on the floor, and they don't have enough money to afford pedestals, so we only care about how much wall area is visible.
• Since the art gallery doesn't even have a roof, the whole floor is visible anyways. If you are wondering how the guard manages to hover high above the gallery - he doesn't. He has a telescopic camera tied to a weather balloon. There. Problem solved. Therefore, what counts for visibility isn't occlusion. The only thing that matters is that the walls are facing the right way.
• You can assume the floor plan is a (not necessarily connected) union of rectangles. I was thinking about including diagonal walls, but this version fits better with the theme. Any internal walls have a definite thickness. If they didn't, you could just ignore them, and that's no good.
• The guard doesn't have to be inside the gallery. They can sit outside, or even lean against the walls. You, however, cannot place the guard with infinite precision. If you try to align the guard with one of the walls, they will be displaced infinitesimally in one direction chosen with uniform probability. But yes, you can try.

The input will consists of the following characters:

• The space character represents 1m x 1m of empty space. It's up to you to decide if it's inside the gallery, or outside. You may assume that the input encodes a rectangular area that includes all of the gallery floor and that all of the walls are depicted.
• - and | represent 1m x 1m squares with walls (east-west and north-south respectively) passing through their centers. Each wall will be adjoined by either the same type of wall or a corner in its lengthwise direction, and empty space in its transverse direction.
• + Represents a corner. Each corner will be adjoined by an east-west wall either on its east side or on its west side, but not both, and by a north-south wall either on its north side or its south side, but not both, and by empty space on the remaining two sides, and in all four diagonally neighboring tiles.

Your objective is to determine and mark all guard locations - tile centers - that maximize the number of wall segments viewed from the correct side - empty space should be marked with . and wall tiles should be marked with #.
In the event that none of the optimal spots align with tile centers, do not mark any tile as optimal. It is the user's responsibility to provide a more detailed floor plan. You may optionally display an error message in that case. If you choose so, the error message must be: displayed in every situation in which no optimal tile would have been marked; same for every input that causes it to be shown; includes at one character not allowed in any valid output.

Example cases:

+----+    +----+
|    |    |....|
|    | => |....|
|    |    |....|
+----+    +----+

The guard can be anywhere inside the gallery, but they can't lean against the wall because they might suddenly find themself on the other side of that wall unexpectedly.

+---+        +---+    
|   |        |   |  . 
+---+ +-+    +---+ +-+
      | | =>       | |
      | |          | |
      | |          | |
      +-+          +-+

In this case, the gallery consists of two separate buildings, and the guard's best spot lies outside either of them.

+---+
|   |
|   +-+ => error
+-+   |
  |   |
  +---+

In this case, there is a 1m x 2m area in which the guard can see all of the walls, but there's no way to depict that in the output. You may pass the input unmodified, or you may output an error message.

+-----+    +-----+
|     |    |.   .|
| +-+ |    | +-+ |
| | | | => | | | |
| +-+ |    | +-+ |
|     |    |.   .|
+-----+    +-----+

This art gallery has a courtyard. Two inner walls must be left unprotected, but it doesn't matter which ones.

  +-+          +-+    
  | |         .#.#... 
  +-+ +-+     .###.##+
      | |     .....#.|
+-+   +-+ => +##...##+
| |          |.#..... 
+-+ +-+      +##.###. 
    | |       ...#.#. 
    +-+          +-+  

For every wall but four, there is another wall such that exactly one of the two can be seen at any given time. As long as the other four walls are guarded, the number of walls guarded is maximized. This is also one of the rare cases where the guard can lean against a wall - if they fall through, they'll wind up guarding another wall instead.

+-------------+

This is not an art gallery. It's a fence with no inside or outside. Invalid input.

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

You might think this depicts two rooms with an internal wall, or three rooms with two internal walls - either way, internal walls are banned. Also, fences are banned. Invalid input.

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

This building has a clear interior and exterior, but the southern corridor is too narrow, the dent in the north-east corner is too jagged to leave enough room for art, and the nearby closet is too close to the main building. Each of these reasons suffices to make this an invalid input.

|---------+
| +-+     |
|    *a k |
| ei 32A  |
+-+++-+--++

There's a gap in the northwest corner, debris all over the floor, and the southern wall has exposed scaffolding. All wrong.

Answer 28

For How Long am I Alone? code-golf

Task

You are a factory worker, whose shift is from time X to time Y. It's a very boring job, and you want to know if any other workers are working during your shift. Given a list of start and end times for the other workers and your own shift time, output the longest amount of time that you are the only one working in the factory.

Input

List of start and end times. Any reasonable format is allowed, such as a list of tuples representing (startHour, startMinutes, endHour, endMinutes) or a list of date objects.

A pair of times, which represent your own start and end times. These may be received as a tuple/list or as separate arguments. Again, the times can be passed as a tuple, date objects, or two object array representing (hour, minutes), or you can pass the hours and minutes as separate arguments.

Each person starts working precisely at their start time and gets off work right when the end time starts. For example, if someone is working from 8:00 to 17:00, at 17:00 they are not considered to be at work anymore.

Each person does his shift 7 days a week.

If you choose to use date objects, the "Year" field of the date objects must always be the same across all inputs.

Note that the end time of your shift can look like it's earlier than your start time, e.g. 21:30 - 5:30. This means that your shift starts at 21:30 at the first day and ends at 5:30 on the next day.

Output

The longest interval in minutes in which you are the only one working in the factory.

Test Cases

In the form of [(hh:mm,hh:mm)...], hh:mm, hh:mm

[(3:30, 12:00), (13:00, 21:40)], (8:30), (16:30) -> 60
[(1:01, 1:03), (1:04, 1:06), (1:07, 1:10)], (1:00), (1:10) -> 1
[(21:00, 5:00), (22:30, 7:00)], (0:00), (4:00) -> 0

Questions

Should I keep the part about the shift being able to stretch across midnight?

Is the input specification clear enough?

Any suggestions welcome.

Answer 29

Ordinal to Cardinal

Given a positive integer represented as the English spelling of an ordinal number, return the equivalent cardinal number.

Rules

• Where an integer requires multiple words to spell, only the last word changes.

• The following integers are strongly irregular:

  • "one" becomes "first"
  • "two" becomes "second"
  • "three" becomes "third"

• Other integers take a suffix of "th", however there are a few integers that are weakly irregular:

  • "five" becomes "fif(th)"
  • "eight" becomes "eigh(th)"
  • "nine" becomes "nin(th)"
  • "twelve" becomes "twelf(th)"
  • "twenty" to "ninety" become "twentie(th)" to "ninetie(th)".

• The input can be assumed to be the English spelling of an ordinal number that follows the above rules to transform it into the equivalent cardinal number.

Examples

• "one hundred and nineteen" becomes "one hundred and nineteenth"
• "one hundred and twenty" becomes "one hundred and twentieth"
• "one hundred and twenty one" becomes "one hundred and twenty first"

This is code-golf, so the shortest program or function that breaks no standard loopholes wins!

Answer 30

Mom-rounding the time code-golf time arithmetic integer

Context

Growing up with my mother, whenever she looked at a clock to check the time, she would always say "shoot, it's already X!" and then I would look at the clock and realize she was just rounding the time in a really weird way.

Task

Given a time with hours and minutes, round it like my mom would. Rounding always occurs upwards. Say it is currently H hours and M minutes.

• if M is 0, no rounding occurs; my mom isn't that crazy;
• if M is 9 or less, my mom rounds to H:15;
• if M is 19 or less, my mom rounds to H:30;
• if M is 34 or less, my mom rounds to H:45;
• for any other value of M, my mom rounds to H+1:00.

Input

You will take a time that needs rounding, in any sensible format. ISO strings for date/time, two integers representing hours/numbers, a string with two integers and a separator; these are all fair game.

Output

The string "shoot, it's already X" with X replaced with the mom rounding time.

Scoring

This is code-golf so shortest answer wins. However, if your source code contains the substring shoot, it's already then you may subtract 19 from your score.

Test cases

Here is the program I use to generate the test cases.

11:00 -> shoot, it's already 11:00!
 3:08 -> shoot, it's already 03:15!
 1:09 -> shoot, it's already 01:15!
13:13 -> shoot, it's already 13:30!
 2:35 -> shoot, it's already 03:00!