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

Swap every two elements in the list every possible way

Posted

Answer 2

IE's Extra Robust Color Parsing®

Answer 3

Cryptic Multiplications

Answer 4

Anti-divisors of a number

Answer 5

An algorithm to find even sublime numbers

Answer 6

Use "e" or a suffix?

Background

In Māori (the indigenous language of New Zealand), to make a verb a command the verb is either preceded by "e" for example, "oma" (to run) -> "e oma", or, it's given a passive ending to make it a passive verb for example "kōrero" (to speak, talk, say, etc) -> "kōrerotia".

Besides some edge cases with intransitive verbs and different dialects, the rule is that if the verb has exactly two short vowels or one long vowel (which have macrons over the top of them like "ā") then the verb is preceded with "e" otherwise it is given a suffix.

Challenge

Your challenge is to determine whether which case a verb fits in to. If it should be preceded by "e" output a truthy value, otherwise output a falsey value.

Rules

• You can assume that all the input will be lower case.
• You may not take input with combining diacritics.
• Because there are very few, if any verbs in Māori with only one short vowel, and the fact that what happens in that case depends on dialect, you don't need to handle those cases.
• This is code-golf so the shortest answer wins.

Test cases

ako -> true
kai -> true
haere -> false
tū -> true
āwhina -> false
kōrero -> false
huri -> true

Meta

• Thoughts on the combining diacritics rule?
• Are there any other rules that should be added?

code-golfdecision-problemstring

Answer 7

Count Futoshiki row solutions

Answer 8

Is it an alphadrome?

Answer 9

MD5 Hello, World!

Posted here

Answer 10

Count the shared substrings with 2 programs

Answer 11

Character Insertion on Letterboards

Answer 12

"Prime" pyramid

Answer 13

Is it true? Ask Pip!

Answer 14

Transpose binary numbers code-golf array binary

The input numbers [34, 7, 109] can be represented in binary as

0100010
0000111
1101101

(one number on each line; and padding with zeroes on the left so that all the rows are the same length)

Now transpose this array:

001
101
000
001
011
110
011

Then convert each row back to decimal to get the output:

[1, 5, 0, 1, 3, 6, 3]

This is the output.

---

todo: write a proper spec

Is this a duplicate?

Is this interesting?

Would this be more interesting if generalised to an input base b?

Answer 15

Is it a Shift matrix?

Posted here

Answer 16

The dating game king-of-the-hill

The bots are looking for love. Can you help them?

The rules

The goal of this game is find the bot you have the highest comparability with. However, robots, who are inexperienced at dating are unable to tell how well a date went.

In the game, bots take turns "speed dating" some other bot. After each date, each bot chooses whether to get married or to continue dating. If both bots agree to get married both are removed from the dating pool and their compatability rank (100% is if you found the best one, 0% for the worst one) is their final score.

Bots won't be able to tell what the compatibility is, but they can compare dates. For example if bot A went on a date with bot B and C, they'll be able to tell if B or C was more compatible but not by how much.

Bot A's compatibility with B does not equal B's compatibility with A, but they are correlated.

If every bot has dated every other bot, the ordering is shuffled and any remaining bots can try again. However, everyone's final score is reduced by 25% (exponential) for every round they stay single. If a entire round ends without any new marriages the game ends and all remaining bots get a score of 0.

Example bot

class BetterThanFirst:
    """
    This bot will use its first date as a reference, then marry any bot that's better than it
    """

    def __init__(self, nrof_bots, rng): # rng is a seeded PRNG you can use, no other forms of randomness allowed
        # nrof_bots is the total number of bots playing
        self.first_date = None

    def round_finished(self, nrof_remaining_bots): # the number of bots still in the game
        pass # called if a full round finished, optional

    def date(self, other) -> bool: # Return True if you want to marry this bot, False otherwise
        if self.first_date is None:
            self.first_date = other
        else:
            return other > self.first_date

Other rules

• No IO
• No RNG except via the provided PRNG
• No inspecting other bots. You are only allowed to use the >, <, <=, >=, ==, and is operators on other bots.
• No exploiting the controller.

Answer 17

Cosine similarity

Answer 18

Zählen

Posted here

Answer 19

Reversed squares

Given an integer n, your task is to determine whether it is a perfect square that when reversed,, is still a perfect square. You may assume n is always positive.

When numbers such as 100 (10x10) are reversed the result may have leading zeros (001) In this case, ignore the leading zeros and treat it as 1 (1x1).

Test cases

1 => True
4 => True
9 => True
441 => True
1234567654321 => True
100 => True

3 => False
25 => False
1784 => False
```

Answer 20

Alternating sublists

Suppose a contiguous sublist that has at least three numbers and alternates between even and odd numbers (or odd and even) is called an alternating sublist. An alternating sublist cannot switch between alternating even and odd numbers to odd to even or vice versa.

Given an input array, find the number of alternating sublists. Zero is considered even, and overlapping is allowed.

For example, in the following input:

[1, 2, 3, 4, 6]

There are three sublists of length 3, of which two are alternating [1, 2, 3] and [2, 3, 4]. [3, 4, 6] is not an alternating as it contains two even numbers in a row.

Also, there is one more alternating sublist with a length of 4 [1, 2, 3, 4].

The entire string is not alternating, as two even numbers are in a row. Thus, the answer is 3.

Test cases

[2, 3, 4, 5] => 3
[50, 50, 10, 80, 96] => 0
[9, 8, 7, 2] => 3
[2, 2, 2, 2, -555, 0] => 1
[1, 2, 4, 6] => 0
[10, 11, 12] => 1
[98, 33, 11] => 0

(some test cases with negative numbers coming soon)

Scoring

Your score is the number of alternating substrings your program has. For scoring purposes, convert all non-numeric chars to their corresponding ASCII code. The tie-breaker is the shortest code. The winner is the answer with the lowest score.

---

• I think the scoring system may be better with "shortest code wins"

• I also think the sentence "An alternating sublist cannot switch between alternating even and odd numbers to odd to even or vice versa. " may be a little confusing, but I can't think of a good alternative.

Answer 21

Numbers that can be negated by reading backwards

Answer 22

Continuously Count Consecutive Cases

Answer 23

Is this ordering total?

Given a matrix like this:

[  0 -1 -1]
[  1  0 -1]
[  1  1  0]

Determine if it represents a proper total ordering. A ordering is total if:

• It is transitive for < and >: \$\forall a, b, c: a<b \wedge b<c \implies a<c \$. For all a,b, c, if a is less than b and b less than c than a is less than c.
• It is transitive for equality: \$\forall a, b, c: a=b \wedge b=c \implies a=c \$. For all a,b,c, if a equals b and b equals c, then a equals c
• It is substitutive \$\forall a,b,c: a=b \wedge b<c \implies a<c\$. For all a, b, c, if a equals b and b is less than c then a is also less than c.

In this matrix I use 1 to represent less than, -1 to represent greater than, and 0 to represent equal. However, you are free to use any 3 distinct values (except complete or partial functions)

Given a matrix representing the ordering of every pair, output one value if the ordering is proper and total, and another if not.

You may assume the input is already anti-symetric, eg. M[a][b] == -M[b][a]. No need to check for that.

Test cases TBD

Answer 24

Assembly capture-the-flag KotH

king-of-the-hill machine-code

---

In this KotH, you'll write a program in a custom machine code (or using one of a few provided languages that compile into it) which tries to run a claim function as many times as possible to collect points. However, all submissions run on the same "machine", allowing a few ways to defeat competitors:

• Causing a competitor to stop working
• Tricking a competitor to run claim on your behalf, using your flag (a code you'd pass to claim)
• Finding a competitor's flag, and running capture on it, which gives their points to you (meta: specifics undecided; not sure if it would take all of their points or just some, or if it would leave the competitor running or not, etc.)

Submissions would be programs in a custom machine code, for a 32-bit machine. This could be written by hand, with an assembly language that will be provided, or with a simple C compiler that will be provided. All submissions will have access to four general purpose registers, which are inaccessible to other programs (unless they can trick you into running code that reveals their contents), and their code and data will be placed in a random part of the up to 4 GiB of RAM, accessible to other programs if they can find it.

Games will run until:

1. All but one bot has stopped working, and some number of cycles pass since the second-to-last bot dies (to allow a bot that kills all of its competitors to claim some points as the winner)
2. A number of cycles has passed equivalent to \$2.5x+2048\sqrt{b}\$, where \$x\$ is the size of RAM and \$b\$ is the number of bots

(meta: not sure if there's a better way to do the game-end conditions)

Some example strategies

To show how this might have a rather high skill ceiling, here are some example strategies:

• Pretending to be a dumb bot, with an exposed flag, as a honeypot. When a competitor injects its own flag, you detect that and capture it instead
• To avoid the above, read a competitor's code and try to look for things like conditions based on the flag or the capture syscall before attempting the risky flag injection
• To circumvent the above countermeasure, use self-modification and other tricks to hide what you're doing
• Watching competitors to see if they've found a bot you're targeting, so you can wait until the last minute to capture its flag for maximum points
• Tricking other bots into running your own code, and essentially forking yourself, then attack other bots in parallel
• Placing fake bot source code in random parts of RAM, to waste other bots' time trying to trick a bot that's not there

Machine code reference (in progress)

There are eight 32-bit general purpose registers, which are interchangeable and have no special properties. Additionally, an instruction pointer and flag register are present, but cannot be directly accessed. The four flags are zero (z), negative (n), carry (c), and overflow (o). The instruction set, which takes inspiration primarily from ARM, is as follows:

• adc: Add with carry
• add: Add
• adr: Add signed immediate to the current instruction pointer, and store the result in a register
• and: Bitwise AND
• asr: Arithmetic shift right
• b: Branch
• b[x|nx]: Branch if flag x is or is not set (any of c, n, o, or z, also p, where p = !n && !z)
• b[e|ne|gt|lt|ge|le]: Aliases meant to be used with cmp
• bic: Bit clear
• call: Branch and push current instruction pointer
• capture: Capture a flag
• claim: Claim a point using a flag
• clz: Count leading zeros
• cmn: Compare negative (same as add, but discarding result)
• cmp: Compare (same as sub, but discarding result)
• dec: Decrement
• div: Divide
• inc: Increment
• ldr: Load register from memory
• lsl: Bit shift left
• lsr: Bit shift right
• mod: Modulo
• mov: Copy from one register to another
• mul: Multiply
• mul2: Multiply, outputting to two registers (to fit results overflowing one register)
• neg: Negate
• nop: No-op
• not: Bitwise NOT
• or: Bitwise inclusive OR
• orn: Bitwise inclusive OR with NOT of 2nd operand
• pop: Pop
• push: Push
• ret: Return (pop a pointer and branch to it)
• ror: Rotate bits right
• sbc: Subtract with carry
• sdiv: Signed divide
• smul: Signed multiply
• smul2: Signed multiply, outputting to two registers (to fit results overflowing one register)
• stop: Stop running; bot is killed
• str: Store register in memory
• sub: Subtract
• swp: Swap register(s) with memory
• teq: Test equality (same as xor, but discarding result)
• tst: Test (same as and, but discarding result)
• xno: Bitwise XNOR (XOR with NOT of 2nd operand)
• xor: Bitwise XOR

Additionally, bots may "trap" one memory address. When this address is written to, an interrupt is issued to the bot. The following instructions exist for this:

• cli: Clear interrupt
• int: Register an interrupt for a memory address, immediately branching to a specified location when it is written to (this clears an existing interrupt if one exists)
• sstr: Stealthy store (allows storing a register to an address without setting off your own interrupt)
• wfi: Wait for interrupt (suspends bot until interrupt fires; a suspended bot will not prevent the game-end condition unless it wakes up)
• wfit: Wait for interrupt with timeout (same as wfi, but will un-suspend the bot if a specified number of cycles passes without an interrupt occurring)

Answer 25

Repeat your program to print Fibonacci numbers [tag:code-challenge][tag:source-layout]

Answer 26

There's more than one way to do it

cops-and-robbers

Cops: Pick a freely available programming language, and pick a function on the integers (i.e. given one integer as input, it produces one integer as output). Then write \$N\$ programs/functions in your language that implement it and are all the same length. \$N\$ must be \$\geq 2\$. Post your language, a description of the function, and \$N-1\$ of the implementations.

Robbers: Pick a cop's post. You can crack the post by finding another program/function in the same language, of equal length, that implements the same function.

(Note that a solution of lesser length, i.e. a golf, is not a valid crack, although in most languages it's easy to pad a solution out to the desired length.)

If a cop's post is not cracked within one week after it's posted, it may be marked as safe. The cop should edit the post to read "Safe" and reveal their omitted solution. Until a post is so edited, it can still be cracked, even if it is more than a week old. A safe cop post is worth \$N\$ points, where \$N\$ is the number of solutions in the post. Robbers receive one point for each cop post they crack.

Details

Cops may use a function on the nonnegative or positive integers if they prefer. If your cop post uses one of these restricted domains, please say so in your post. Your solutions (and robbers' solutions) are allowed to produce different results for inputs outside your chosen domain, as long as they produce identical results for inputs inside the domain.

[Cops may measure the length of a program in any way they choose. Some possibilities are bytes, characters, codels, non-whitespace characters, etc. Please specify how you are counting length in your post.] - I'm not sure about this rule. See below.

---

Sandbox questions:

• Is this concept interesting?
• Does the scoring make sense? Are there ways for the cops to game the scoring system to get arbitrarily high scores? Would it be better if the \$N\$ solutions were forbidden to have any characters/bytes in common? (But that would cause problems for a lot of languages that aren't golflangs, which I'd rather avoid.)
• Is the "choose your own length measure" rule reasonable, or does it open the door to weird exploits? I suspect that more-flexible counting methods like "number of occurrences of n and Q" will just cause problems for the cop, since they will allow robbers to construct elaborate workarounds using characters that aren't counted.

Answer 27

Be big more often

Answer 28

The Legend of Koth Episode 1: WANTED

Alright. The WumpusWars project turned out to be more than I can swallow, so I had to give it up. If you're interested in hosting the competition yourself go ahead: it would be very fun.

I instead thought of a simpler-to-implement King of the Hill! I plan to make a series (yeah I love series) of King-of-the-Hill challenges based primarily on metagame and interactions, and named it The Legend of Koth. Here comes Episode 1: WANTED. Hope u like it ;-)

====================

Backstory: A long long time ago in a galaxy far far away, on the planet of code-o-sphere, a civil war broke out between CGCC and CRSE (*). Deserted wasteland spammed with unreadable Esolang code and 100-line-long docstrings were the remains of most once bustling cities of the code-o-sphere.

When the war was over, some survivors settled in the town of Koth. They had magnificent plans: of rebuilding civilization! Equality and freedom for everyone!

... until they found out how hard it was to build a society from scratch. By that time, it was too late.

The town had employed too many vigilantes and trusted them with great power. And so, echoing the lessons learned by habitants of a remote little insignificant blue planet, they found -- the hard way -- that power corrupts, and absolute power corrupts absolutely. Now, the vigilantes are fighting, to see who is the best!

The pains of the previous war eventually convinced them to control the warfare to a relatively small scale: the vigilante factions will send representatives to see who is the best! Now the towns' once beautiful walls and buildings are covered with posters...:

WANTED. Dead, undead, or preferably deader than dead, but definitely not alive, thank you very much.

(*) Note: For those who don't understand the joke, CRSE (Code Review Stack Exchange) is often joked to be CGCC's arch-nemesis because they value readability over conciseness and hacky stuff, while most challenges here want the opposite.

Disclaimer: I am politically strictly neutral and indifferent (this is part of my moral principle) so the backstory bears no relations to real-life politics or history. It's simply a humorous mish-mash of some relevant tropes.

====================

The rule: this is mainly inspired by King of the Holster.

You can distribute your 10 initial points between HP, defense, and reputation. Your HP is your HP point plus 10, and your defense is the probability of blocking, calculated by defense points times 0.1. Your reputation is simply equal to your reputation points times 10.

The basic system is similar to the Holster game. You have 1 ammo at the beginning. During each round, you can (1) refill 1 ammo, (2) heal 1 HP, (3) attack someone, or (4) post a wanted poster.

Attacking costs 1 ammo. The attacked guy chooses a random real number between 0 and 1, and if is smaller than his defense he blocks, meaning that the damage he takes is randomly decided from 0-2. Otherwise he takes 3-5 damage. Killing someone who isn't wanted gives you 20 reputation points.

Wanted posters are publically visible. You can choose to cost x of your reputation to post the poster (no refunds, similar to the bounty system on Stack Exchange). If the guy on the wanted poster is killed the one who killed him has his reputation increased by 20+x.

The winner is the one with the most reputation -- not necessarily the last man standing. If no attacks are made for 10 consecutive turns or only one man is surviving then the game ends.

====================

Good luck and happy coding!

Leaderboard: (will be updated as soon as I can)

Achievements: (all achievements are hidden so no achievement conditions are revealed until someone gets them)

Answer 29

Decrypt an autokey cipher

Answer 30

Print 100 digits of π