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

Base Neutral Numbering System code-golfprimes

Answer 2

Turn two dice into one die

Answer 3

KotH: Build an Organism

A while back, I made a thing that simulates a world, with a bunch of organisms with randomly chosen genes:

These would code for things like how the organism would manage resources (such as sugar, water, and starch), whether it could photosynthesize, hunt, run away from enemies, or defend itself using tough materials like wood or stone spikes.

In this challenge, you'll design an organism which can effectively survive. This could be through strategies including:

• Being an effective hunter, chasing down and killing prey
• Being difficult to attack, such as by having tough armor and fleeing from stronger organisms
• Growing and dividing too quickly for it to be possible that all organisms of your species are killed at the same time

I will update this post with a spec listing all available resources, materials, genetic traits, and actions later.

Answer 4

Change the subject code-golfstringarraysorting

Posted here

Answer 5

Simplify a Cycle

Answer 6

Change the Temperature of Swatchlings

Warning: Contains Deltarune Chapter 2 Spoilers

Summary

Your challenge today is to determine the minimum number of turns needed to change the temperatures of an arbitrary amount of Swatchlings to all be the same.

Context

In the second chapter of Deltarune, there are enemies you encounter that are called Swatchlings (suit-wearing butler-like characters that serve the main antagonist of the chapter). These enemies always appear in battle in groups with at least one outlier in terms of suit color^source. Swatchlings are defeated by making all Swatchlings in the group have the same suit colour.

Each Swatchling's color can be changed in stages, either becoming warmer (redder) or colder (bluer). While there are only five colours in the actual game, for this challenge, there will be an infinite amount, represented by positive integers.

During each turn of a battle, there are 3 ways to change the temperature of a Swatchling: increasing/decreasing the temperature by 2 stages, increasing the temperature by 1 stage or decreasing the temperature by 1 stage. You may perform up to 3 of these actions per turn, and no action twice in a turn.

Task and Worked Example

Given a list of Swatchling temperatures, determine the minimal number of turns needed to change the temperatures of all Swatchlings to be the same. Note that

For example, given the following temperatures:

[1, 5, 5]

The optimal solution would be:

Turn 1:
Increase Swatchling #1 by 2 stages: [3, 5, 5]

Turn 2:
Increase Swatchling #1 by 2 stages: [5, 5, 5]

Meaning a minimum of 2 turns are needed to change the temperatures of all Swatchlings to be the same.

Another example is:

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

One optimal solution might be:

Turn 1:
Increase Swatchling #1 by 2 stages: [3, 5, 3, 4, 4, 2, 1]
Decrease Swatchling #4 by 1 stage: [3, 5, 3, 3, 4, 2, 1]
Increase Swatchling #6 by 1 stage: [3, 5, 3, 3, 4, 3, 1]

Turn 2:
Decrease Swatchling #2 by 2 stages: [3, 3, 3, 3, 4, 3, 1]
Decrease Swatchling #5 by 1 stage: [3, 3, 3, 3, 3, 3, 1]

Turn 3:
Increase Swatchling #7 by 2 stages: [3, 3, 3, 3, 3, 3, 3]

Meaning a minimum of 2 turns are needed to change the temperatures of all Swatchlings to be the same.

Rules

• Input will be a list of positive integers representing the temperatures of each Swatchling. The list will contain at least one Swatchling.
• Output will be an integer representing the minimum number of turns needed to change the temperatures of all Swatchlings to be the same.

Test Cases

[1, 5, 5] => 2
[1, 2, 5] => 1
[1, 5, 3, 4, 4, 2, 1] => 3
[1, 7] => 2
[1, 10, 3] => 4

As this is code-golf, the aim of the game is to get y'all's byte count as low as possible, just like the turn count to make all the Swatchlings the same temperature.

Sandbox Meta

• Is the explanation clear enough?

Answer 7

---

Definitions

A \$ \xi \$-word is defined as a string of letters such that every letter in the string appears an even number of times. For example, aeaeccaa is a \$ \xi \$-word.

The function \$ T \$, which operates on \$ \xi \$-words, is defined as follows:

1. Replace the odd-positioned (first, third, etc.) occurrences of each letter with (. For the example above, this produces ((ae(c(a
2. Replace all the remaining letters (i.e., those that were the even occurrences) with ). For our example, this produces (())()()

This will always produce a string with balanced brackets.

Task

Take, as input, a string \$ i \$, where every letter appears exactly twice (e.g. xffcxc). Note that this is a stricter condition than merely being a \$ \xi \$-word.

Return the lexicographically earliest \$ \xi \$-word, such that the input and output give the same value when \$ T \$ is applied to them.

Hint: a linear-time algorithm is possible.

Rules

• You do not need to handle an empty input
• Letters are ASCII lowercase (a to z)
• You may choose to operate on integers instead of strings of letters. You can use any set of integers, as long as there are at least 26 of them.
• You may use any standard I/O method
• Standard loopholes are forbidden
• This is code-golf, so the shortest code in bytes wins

Test cases

todo

---

Sandbox notes

At the moment, this challenge is very abstract, which I think means it will look seem quite boring (until you start to actually solve it, which I think is fun, although fairly simple). (What kind of a title is Lexicographically earliest \$ T \$-invariant \$ \xi \$-word?)

If you can think of a good domain to make it concrete, I think it would be much better. (Unfortunately I can't reveal the original context in which I encountered it). At the least I will probably replace the symbolic names with cute names before posting.

Answer 8

Yakko's New World Order

Answer 9

Sum of Consecutive Squares

Answer 10

Infinite Apple Dilemma

Posted here

Answer 11

Base64 fixed point

It can be proven that there's exactly one string of infinite length that remain same after base64 encoding Vm0wd2QyUXlVWGxWV0d4V1YwZ...

Given \$n\$, output one of

• the \$n\$-th character
• the first \$n\$ characters
• The whole string

code-golf sequence

Answer 12

Rotate an Image

Answer 13

Reverse the polyglot, change the language.

Answer 14

Approximate a root of an odd degree polynomial

Answer 15

Whole Number Groups

Answer 16

Fibonacci Binary Squares

Answer 17

"Candy Crush" a string

Answer 18

Help Me Type on My New Keyboard

Answer 19

Largest Binary Area

Answer 20

Calculate the p-adic square root of -1

Given a prime number \$p\$, a \$p\$-adic number is a number whose representation in base \$p\$ may have infinitely digits to the left of the radix point, but only finitely many digits to the right of it. A \$p\$-adic integer has no digits after the radix point.

\$p\$-adic numbers have some interesting properties. It can be proven that for any prime number \$p\$, there exists a \$p\$-adic integer \$x\$ such that \$x^2 = -1\$ if and only if the congruence \$x_0^2 \equiv -1 \pmod{p}\$ has a solution. (That is, there is some integer \$x_0\$ such that \$x_0^2 + 1\$ is divisible by \$p\$.)

Your task is to determine whether this is the case and calculate the digits of the number \$x\$. Note that there will always be two solutions which are additive inverses of each other; you only need to calculate one.

Input

A prime number \$p \ne 2\$. (You don't need to verify that it's prime.)

Output

Find the digits of the \$p\$-adic square root of \$-1\$, as described above. Following the standard sequence rules, do one of the following:

• Given an index \$i\$, output the \$i\$-th digit from the end. Since base representations are naturally 0-indexed, you may not use 1-indexing.
• Given a positive integer \$n\$, output the last \$n\$ digits. You can choose between little-endian and big-endian.
• Output all digits in the form of a non-halting program, a generator, an infitite lazy list, etc.

If the \$p\$-adic square root of \$-1\$ does not exist, do anything that can be clearly distinguished from a valid output, such as raising an exception or returning an empty list.

Algorithm

Here I describe one possible way to solve this challenge.

• Find a number \$x_0\$ between \$0\$ and \$p-1\$ such that \$x_0^2 \equiv -1 \pmod{p}\$. If not found, report failure.
• Find a number \$y\$ between \$0\$ and \$p-1\$ such that \$2x_0y \equiv 1 \pmod{p}\$. (This is always possible.)
• Let \$c_0 = \left\lfloor\frac{x_0}{p}\right\rfloor\$.
• For each positive integer \$i\$:
  • Let \$h_i = c_{i-1} + \sum_{j=1}^{i-1} x_j x_{i-j}\$.
  • Let \$x_i = (p-1-h_i)\cdot y \bmod p\$.
  • Let \$c_i = \left\lfloor\frac{h_i + 2 x_0 x_i}{p}\right\rfloor\$.
• The sequence \$\left(x_i\right)\$ is the output.

Ungolfed Python implementation:

def sqrt_minus_one(p, n):
    for x in range(p):
        if (x * x + 1) % p == 0:
            last_digit = x
            break
    else:
        return None # no solution
    for x in range(p):
        if (x * 2 * last_digit) % p == 1:
            inv = x
    digits = [last_digit]
    carry = (last_digit * last_digit) // p
    for i in range(1, n):
        h = sum(digits[j] * digits[i - j] for j in range(1, i)) + carry
        digits.append((p - 1 - h) * inv % p)
        carry = (h + 2 * last_digit * digits[i]) // p
    return digits

It's also possible to use a brute-force approach where you find an \$n\$-digit number \$x\$ such that \$x^2 + 1\$ ends with \$n\$ zeroes in base \$p\$. I suppose this could lead to much golfier solutions, so maybe I should make the challenge restricted-complexity to forbid this?

Test cases

  p | first 20 digits (two possible outputs)
  3 | ---
  5 | 2,1,2,1,3,4,2,3,0,3,2,2,0,4,1,3,2,4,0,4
    | 3,3,2,3,1,0,2,1,4,1,2,2,4,0,3,1,2,0,4,0
  7 | ---
 11 | ---
 13 | 5,5,1,0,5,5,1,0,1,8,8,6,12,6,3,0,4,7,4,5
    | 8,7,11,12,7,7,11,12,11,4,4,6,0,6,9,12,8,5,8,7
 17 | 4,2,10,5,12,16,12,8,13,3,14,0,6,1,0,15,1,8,14,5
    | 13,14,6,11,4,0,4,8,3,13,2,16,10,15,16,1,15,8,2,11
 47 | ---
101 | 10,5,29,66,10,30,44,29,72,25,34,82,83,5,52,17,67,94,65,52
    | 91,95,71,34,90,70,56,71,28,75,66,18,17,95,48,83,33,6,35,48

Answer 21

Is it traversable?

Answer 22

Qat Equation Solver

Answer 23

Record Least Uncommon Multiple Counts

Answer 24

Rendevous!

king-of-the-hill

Your bots went to the mall together, but they got lost! Worse, they didn't agree on any strategy to find one another again.

Here's what they do know:

• There are \$n\$ stores, and bots can only meet each other in the stores.

• Each time step, each bot must choose one store to be in.

• Two bots go to the mall simultaneously. Their score for the outing is the number of time steps it took for them to find one another.

• The mall closes after \$n^2\$ time steps. If some bots are still at the mall, they will receive a score of \$n^2+1\$.

Bots must be written in Javascript. Your bot must be a generator function, receiving a single input \$n\$ (the number of stores) and output at least \$n^2\$ integers in the range \$[0..n-1]\$. Your bot's score will be the average of its scores when played with all of the other bots.

The stores will be scrambled - what is room 1 for one bot may be room 5 for another. There will be many rounds of the game (1000 right now, but if there are lots of entries and it takes longer than an hour, I may lower that number), and each round will be a round-robin with a set number of stores. \$n\$ will be in the range \$[4..25]\$.

There are better and worse strategies, but optimal strategies (when symmetric) are only known for \$n=2\$ and \$n=3\$. An example bot (which will be playing):

function* randomSearchBot(n){
  while (true){
    yield Math.floor(Math.random() * n);
  }
}

Here is the controller:

function shuffle(array) {
    for (let i = array.length - 1; i > 0; i--) {
        let j = Math.floor(Math.random() * (i + 1));
        [array[i], array[j]] = [array[j], array[i]];
    }
}
function runRound(bot1, bot2, n){
    let b1 = bot1(n), b2 = bot2(n);
    let stores = Array(n).fill(0).map((_, i) => i);
    shuffle(stores);
    let turn = 0;
    while (turn++ < n ** 2){
        if (b1.next().value == stores[b2.next().value]) break;
    }
    return turn;
}
function runAllRounds(...bots){
    const nameLength = Math.max(bots.map(b => b.name));
    bots = bots.map(b => {
        return {
            bot: b,
            totalScore: 0
        };
    });
    const rounds = 1000;
    let round = rounds;
    const pairs = bots.map((b, i) => bots.slice(i + 1).map(w => [b, w])).flat();
    while (round--){
        const n = Math.floor(Math.random() * 22) + 4; // [4..25]
        for (let [a, b] of pairs) {
            const score = runRound(a.bot, b.bot, n);
            a.totalScore += score;
            b.totalScore += score;
        }
    }
    bots.forEach(b => {
        b.totalScore /= rounds * (bots.length - 1);
        console.log(b.bot.name.padEnd(nameLength) + ": " + b.totalScore.toFixed(5));
    });
}

The main feedback I'm looking for here is whether people think there's a big enough strategy space for it to be worth playing.

Answer 25

Shortest distinguishable slice (posted)

Answer 26

How super is this prime?

Posted here

Answer 27

The Jaccard Index

Answer 28

Zählen

Posted here

Answer 29

Calculate Bloons RBE Equivalent

Answer 30

International Resource Trading KOTH king-of-the-hill

Your country wants to reach Mars, and do it as cheaply as possible. While you can produce all required resources domestically, other countries can produce them cheaper and trading can drastically reduce both your costs.

Goal of the game

There are 10 resources, numbered 1-10. You need 1,000 of each resource to build a rocket and colonize Mars.

The cost of each rocket is different for each player though. One will cost €10, one €20, €30, ... and the last costs €100 per unit. This number is different for every bot, for example resource 1 could cost €20 for one but but €90 for a different bot.

Without trading, the rocket would cost €550,000. But if you import resources that are expensive for you to produce, and sell resources that are cheap for you to produce. If you do it right, you can make the process massively cheaper or even potentially make a profit and still launch your rocket.

The game loop

The game consists of 7 rounds. Each round has 2 phases.

The first phase is the production phase. Each bot can choose to produce some number of resources locally. The total limit for how much you can produce is 10 the first round, 20, 40, 80 ... 1280 in the last round. Bots can choose to divide their production among every resource. For example, you can buy 6 of resource A and 4 of resource B in the first round. Money will be subtracted from your score proportional to the value the resource has for you.

The second phase is the trading phase. In turns, every bot has the option offer a trade. Then other bots can choose to accept the offer or to create a counteroffer. Then the bot may choose to accept any of the counteroffers or reject all of them.

Trades can either be money for resources or resources for money. You can't trade resources for resources directly.

There are 3 rounds of trading for every production phase.

If the game ends before you collect enough to launch your rocket, the rest of the resources will be produced domestically and cost you the domestic production price.

Example bot

class PriceBelowHalf:
    """
    Will only buy resources if the price is less than half the local production price
    Will only sell resources if the price is more than double the local production price
    """

    def __init__(self, bot_ids: list[int], resource_prices: dict[int, int], rng):
        # Randomness only allowed via the provided RNG.
        self.bot_ids = bot_ids
        self.resource_prices = resource_prices

    def production_phase(self, max_production: int, resources: dict[int, int]):
        # produce the maximum amount of the cheapest resource
        return {min(self.resource_prices, key=lambda i:resource_prices[i]): max_production}
    
    def trade(self, resources: dict[int, int]):
        # Offer to buy the resource we have the least of for half it's price
        resource = min(resources, key=lambda i:resources[i])

        # 2 item tuples are treated as resources, single integers are treated as money
        # First element is what you get, second is what you want to give
        return [(resource, 10),
                self.resource_prices[resource]*5]

    def trade_offer_accepted(self, resources: dict[int, int], counteroffers: list):
        for counteroffer in counteroffers:
            # Accept the first counteroffer that is a good deal
            if isinstance(counteroffer[0], tuple) and \
               counteroffer[0][1] * 2 > self.resource_prices[counteroffer[0][0]] * counteroffer[1]:
                return counteroffer

    def trade_offer_received(self, trade_offer: list, resources:dict[int, int]):
        # If you return a offer in the same format it would be treated as a counteroffer
        # Counteroffer must be for the same resource but you may change both the amount of money and the amount of the resource
        # If you want to unconditionally accept simply `return trade_offer`
        # If you return None you will reject the offer
        # third element of the trade offer is the bot that offered it

        # they want to give a resource for money
        if isinstance(trade_offer[0], tuple):
            # Must be greater than 2:1 ratio to our own price
            return [[counteroffer[0][0], counteroffer[0][1]],
                    # Pay half price or the other bot offered, whatever is cheaper
                    min(
                        self.resource_prices[counteroffer[0][0]] * counteroffer[0][1]] // 2,
                        trade_offer[1]
                    )
            ]
        else:
            # They want to give money for our resources, so we need to check if we have enough
            if resources[trade_offer[1][0]]>=trade_offer[1][1]:
                return [
                    max(
                        trade_offer[0],
                        self.resource_prices[trade_offer[1][0]] * trade_offer[1][1]
                    ),
                    trade_offer[1]
                ]
 

Extra Rules

• No IO
• No RNG except via the provided seeded PRNG
• No exploiting the controller
• No targeting a specific bot or specifically helping one specific bot. Hurting or helping a range of strategies is perfectly fine.