# Sandbox for Proposed Challenges

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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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".

Get the Sandbox Viewer to view the sandbox more easily!

# Is this a valid Temtem character name?

Given a string of between 0 and 15 (inclusive) printable ASCII characters, determine whether the string represents an acceptable character name for the game Temtem.

The following rules apply to character names:

• Names must have at least 3 letters (a-z)
• Names may have up to 2 total prefixes and/or suffixes of at least one letter
• Prefixes and suffixes must be separated from the name by one of space, hyphen or apostrophe
• The first letter of the name and each prefix may be capitalised but all other letters must be lower case.

Truthy examples:

Daddy's girl
de Morgan
Rip Van Winkle
Spider-Man
X-Men


Falsy examples:

McDonald's
-XX-
'falsy'


Note: Temtem may apply other checks to character names not included here.

As this is , Output must be a single consistent value for all valid names. Output for invalid names must be consistent for a given invalid name, but may vary between different invalid names, so for instance a count of errors is an acceptable output format.

This is , so the shortest program that breaks no standard loopholes wins!

• Are Rip Van winkle and spider-Man valid?
Jun 27 at 12:59
• @Adám They are for the purposes of this question, yes.
– Neil
Jun 27 at 13:43

# General Binary Counterman Jr

Related

General Binary Counterman Jr is the son of famed Mr. Binary Counterman. He’s continued in his father’s footsteps, counting strings of numbers in the family tradition. But binary has grown old; he’s not a computer. The General has waited for his father’s popularity to wane, and he has decided the time is nigh. The General is about to generalize!

As a reminder, his father would count the evens and odds like this: 1 1 0 0 1 0 would be read as 1st odd, 2nd odd, 1st even, 2nd even, 3rd odd, 3rd even and it becomes 1 3 0 2 5 4.

But not so the General. Evens and odds are just 0s and 1s mod 2, the General knows this. Instead of reducing mod 2, he likes to reduce strings down whatever mod he pleases. Once he does he counts the residues the same way as his father did, but in whatever mod he damn well wants.

The General has read the algorithms that fans have sent his father. But he believes that his new method will yield sufficiently different strategies as to deserve its own page on the internet.

## Challenge

Given two inputs representing a mod m and a list L, the nth occurrence of a given congruence class in the list should be output as the nth integer of that class.

The I/O is very flexible and may take any reasonable format, so long as it doesn’t sidestep part of the problem. For instance, you may take the list backwards or as a string, but you can’t take it already reduced mod m.

This is , so least bytes wins!

Reference Implementation

## Example

In my examples, I will represent the I/O as 3: 5 3 2 8 4 5 9 -> 1 3 2 4 5 6 to represent the reminder. This means m = 2 and L = 1 1 0 0 1 0. But again, you are not required to do it this way. In fact, you’re encouraged to find the I/O scheme that works best for your language and algorithm!

Input: 3: 5 3 2 8 4 5 9

This gets counted mod 3 by its congruence class of [0], [1] or [2]:

L  m       Count
5 %3  ->  1st [2]  ->  2
3 %3  ->  1st [0]  ->  0
2 %3  ->  2nd [2]  ->  5
8 %3  ->  3rd [2]  ->  8
4 %3  ->  1st [1]  ->  1
5 %3  ->  4th [2]  ->  11
9 %3  ->  2nd [0]  ->  3


Output: 2 0 5 8 1 11 3

## Test Cases

The most fun part! How do you like the test cases?

2: 1 3 0 2 5 4
1 3 0 2 5 4

2: 1 1 0 0 1 0
1 3 0 2 5 4

5: 1 1 0 0 1 0
1 6 0 5 11 10

1: 9 8 7 6 5 4 3 2 1 0
0 1 2 3 4 5 6 7 8 9

100: 101 102 103 104 105
1 2 3 4 5

10: 3 1 4 1 5 9 2 6 5 3 5 8 9 7 9 3 2 3 8 4 6 2 6 4 3 3
3 1 4 11 5 9 2 6 15 13 25 8 19 7 29 23 12 33 18 14 16 22 26 24 43 53

7: 10 20 30 40 50 60 70 80 90 100
3 6 2 5 1 4 0 10 13 9

8: 09 18 27 36 45 54 63 72 81 90
1 2 3 4 5 6 7 0 9 10

12: 11 22 33 44 55 66 77 88 99 110 121 132
11 10 9 8 7 6 5 4 3 2 1 0

11: 1 1 2 3 5 8 13 21 34 55 89 144
1 12 2 3 5 8 13 10 23 0 34 45

4: 2 4 8 16 32 64 128 256 512 1024 2048
2 0 4 8 12 16 20 24 28 32 36


## Other Cheats

In the interest of making this as flexible as possible for all the masochistic and impossible fun languages, here are other things you may skimp on:

• You may assume list L will only contain single digit numbers.
• You may assume mod m will be a single digit number.
• You may do anything when m = 0, including throwing an error.
• You may assume no leading 0s in the numbers.
• It is less consistent with the pattern, but you may eliminate 0s from your output by starting the count for [0], and only the [0] class, at m instead. Then, in the example program, 1st [0] → 3 and 2nd [0] → 6. It would output 2 *3* 5 8 1 11 *6* instead of 2 *0* 5 8 1 11 *3*
• Feel free to comment any other ideas and I will add them in if they don’t detract from the spirit of the challenge, and primarily serve to give the turing tarpits a hand. If the cheat would be used by mainstream and golfing langs, it’s probably not a good idea.

Please mention what cheats you’re taking advantage of, if any!

# Will the hydra finally die? Part II

### Background

This is a follow up question to the question: Will the Hydra finally die?

As before a dangerous A Medusa have released a dangerous Hydra which is revived unless the exact number of heads it have is removed. The knights can remove a certain number of heads with each type of attack, and each attack causes a specific amount of heads to regrow. This time the knights are more impatient and having seen your previous abilities want you to** write a program or function that returns a list of hits which will leave the hydra 1 hit from death

Note that this is fundamentally different from Become the Hydra Slayer. in 2 aspects. 1: We are not asking for the optimal solution 2: each attack causes a different number of heads to grow back. this radically changes the approach needed.

For example:

input: heads = 2,
attacks = [1, 25, 62, 67],
growths = [15, 15, 34, 25],

output: [5, 1, 0, 0]


Explanation: The Hydra has 10 heads to start with, we have 4 different attacks and for each attack, growth gives us the number of heads that grows back. hits gives us the number of times each attack is applied. So the number of heads the Hydra has after each attack is

2 -> 16 -> 30 -> 44 -> 58 -> 72 -> 62


Since 62 is a valid attack value (It lies in the attack list), we return True since the Hydra will die on the next attack (be left with 0 heads). Note that the order for when the attacks are done is irrelevant.

2 -> 16 -> 6 -> 20 -> 34 -> 48 -> 62


### Input

Input should contain heads (an integer), attacks (a list of how many heads can be removed), regrowths (how many heads grow back per attack)

You may take input in any convenient method. This includes, but is not limited to

• A list of tuples (1, 15, 5), (25, 15, 1), (62, 34, 0), (67, 25, 0)
• Lists 2, [1, 25, 62, 67], [15, 15, 34, 25], [5, 1, 0, 0]
• Reading values from STDIN 1 15 1 15 1 15 1 15 1 15 25 15
• A file of values

### Output

• An array, or some way to easily indicate which hits the knights are to take. Example: 5 1 0 0

Note 1 Say that your input is attacks = [1, 25, 62, 67] and the hydra has 25 heads left, then you cannot output the answer as [1,0,0,0], [0,0,0,1] etc. Your output and input must be sorted similarly. Otherwise it will be very confusing for the Knights.

Note 2: Your program can never leave the Hydra with a negative number of heads. Meaning if the Hydra has 15 heads, an attack removes 17 heads and regrows 38. You may not perform this attack.

### Scoring

• This is a you will be scored as follows: the total sum of hits your code produces from the test data + length of answer in bytes
• Note that how you input and parse the test data is not part of your code length. Your code should, as stated above simply take in some a headcount, attacks, regrowth's and return a list/representation of how many hits each attack has to be performed to leave the hydra exactly 1 hit from death.

Lowest score wins!

### Test data

       attacks = [1, 25, 62, 67],
growths = [15, 15, 34, 25],


use every integer from 1 to 200 as the number of heads. An sample from the first 100 can be found below. Again your program does not have to return these values, it is merely an example of how the scoring would work. As seen below the total sum for each of these hits are 535 meaning my score would be 535+length of code in bytes

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


# Meta

• What would a good scoring method for this type of question be?
• My method outputs 2873 for the total count from 1 to 200, is this too high, too low?
• Feel free to suggest other improvements to my testing data

## Transdeletion

Transdeletion is the process of removing a letter from a word and forming another word by creating an anagram from the remaining letters.

If you can do this repeatedly, all the way down to a single letter ("A" or "I", usually, in English), you have formed a "Transdeletion Pyramid".

The Challenge

Given a word list (containing any number of words, up to the max your language can handle) and a starting word, find and output the Transdeletion pyramid.

The word list will include the starting word, and is guaranteed to contain all of the words required to make the pyramid (Sandbox: should it? Or is it a better challenge if it won't always be possible to succeed?). A change of case for any letters of the word is allowed at any time - i.e. dealing with casing isn't part of the challenge. So you can assume all inputs are in lowercase, or uppercase, or whatever suits.

This is , so shortest answer in bytes wins, usual rules apply.

Examples

In the form [[wordList],"startWord"] -> [ordered output list]

[["a", "an", "ant"], "ant"] -> ["ant","an","a"]
[["I", "in", "tin", "sink", "ink"], "sink"] -> ["sink","ink","in", "I"]
[["I", "in", "tin", "sink", "ink"], "in"] -> ["in", "I"]
[["a", "I", "tin", "ant", "sink", "an" "ink"], "ant"] -> ["ant","an","a"]
[["FAT", "TALIERA", "INTERLAMINATES", "ULCER", "ALTER", "TALE", "A", "RATE", "I", "ANTICEREMONIALIST", "MATERIAL", "INCOMPETENT", "TRILAMINATE", "TEA", "TEA", "TRIFLE", "NONMATERIALITIES", "FRATERNISATION", "AT", "AT", "ORNAMENTALITIES", "RETAIL", "TAIL", "MATERNALITIES", "TERMINALIA", "LATIMERIA", "FATIMA", "OBSCURE", "LENS", "MATRILINEATE"],"ANTICEREMONIALIST"] -> ["ANTICEREMONIALIST", "NONMATERIALITIES", "ORNAMENTALITIES", "INTERLAMINATES", "MATERNALITIES", "MATRILINEATE", "TRILAMINATE", "TERMINALIA", "LATIMERIA", "MATERIAL", "TALIERA", "RETAIL", "ALTER", "RATE", "TEA", "AT", "A"]


Sandbox Questions

1. Should it be possible that the input contains no valid chains?
2. Should the challenge instead be to find the longest chain, even if it doesn't go down to 1 letter?
3. Should the starting word be provided or would it be a better challenge without it?

# Decide Magma's Identity

## Objective

Given a magma with 256 elements, decide whether it has the identity element.

## Definition

A magma is a set endowed with a binary operation. Let's denote the set by $$\S\$$ and the binary operation by $$\\circ\$$.

An element $$\e \in S\$$ is the identity element if for every $$\a \in S\$$, $$\e \circ a = a \circ e = a\$$ holds.

If $$\e\$$ exists, its existence is unique, for if $$\f \in S\$$ also is an identity element, $$\e = e \circ f = f\$$.

## Input Format

The binary operation $$\\circ\$$ itself, as a black-box function, will be inputted.

The type of $$\\circ\$$ doesn't matter. Possible choices include (type names in C):

• Accepting two chars, returning one char

• Accepting two int8_ts, returning one int8_t

• Accepting two uint8_ts, returning one uint8_t

• Accepting one int16_t (to break bytewise), returning one unsigned char

## Ungolfed Solution

This implementation is much generalized version of the challenge. It can test an arbitrary finite magma, and will explicitly find the identity element if it exists.

It might seem to have time complexity of $$\O(n^2)\$$, but it's actually $$\O(n)\$$.

import Control.Monad
import Data.Maybe

findIdentity :: (Eq a, Enum a, Bounded a) => (a -> a -> a) -> Maybe a
findIdentity op = listToMaybe \$ do
let elements = [minBound .. maxBound]
e <- elements
guard (all (\f -> op e f == f) elements)
guard (all (\f -> op f e == f) elements)
pure e


# Compile Esolang to Esolang

Based on Convert FRACTRAN to Brainfuck.

• Compile Brainfuck to FRACTRAN
• Compile /// to Brainfuck
• Compile Brainfuck to ///

If you have other ideas, please add them. Be sure it's reasonably doable with simple tarpits, eg Jelly to Vyxal to APL isn't all that fun. If you can make a variation of that fun, that should be posted separately.

If you'd like me to make this into a CW to make it easier to contribute, please comment and let me know!

• FRACTRAN to Retina 0.8.2 would prove that the latter is Turing-complete (Regex on its own isn't, but Retina has loops. On the other hand, Retina 1 has eval, so you can probably do some nasty things like a payload-capable quine attempting to evaluate itself, thus implementing Fibonacci recursively.)
– Neil
Jul 11 at 11:07
• @Neil I'm thinking that one of them should be a simple, well-known and pretty vanilla lang. Eg Brainfuck <-> Retina, or, since it's based on string subs, /// <-> Retina might be fun. How do those sound? Or would you prefer from FRACTRAN/another Minsky machine? I also am slightly worried about Retina's complexity, but maybe just a subset of Retina would be required? Jul 11 at 19:45
• I can't comment on the other languages because I don't know them, but Retina 0.8.2 isn't that complex; its only loop is the convergence loop and the only conditional code is basically whether a regex matches or not.
– Neil
Jul 11 at 22:42
• is this structured as an answer chaining problem? Jul 14 at 7:35

# Make me some puzzles

So, a while ago on Puzzling, I posted this. It basically had a whole bunch of equations that were wrong, and when you figured out how much they were wrong by, and transformed 1-26 into A-z, it yielded the phrase ALLWRONG.

Your challenge is to take a string of letters as input, and output a series of wrong, randomly generated equations that are wrong by the correct amount to yield said string.

Equations must be of the form number operation number = number, where each number is a positive integer less than 100, and the operators are +-*/, although × and ÷ are acceptable instead of */.

I'm going to be quite lenient on the definition of 'random' in this one - all possible equations must have a nonzero chance of appearing for any given letter.

Valid equations should have the result of the left hand side's difference from the right hand side being the correct number to, when 1-26 is transformed into A-Z, yield the corresponding character.

Output can be as an array, newline separated, whatever. Equations don't need to be spaced, that's just for readability. You can even output as a list of [1,+,1,=,3] or something.

# Testcases

These are possible outputs, not proper testcases.

A => 1 + 1 = 3
HI => 3 * 4 = 4, 9 * 2 = 9
LOL => 20 / 5 = 16, 7 * 5 = 20, 50 - 23 = 15


# Avoid traps, run to an exit! restricted-source

## Code layout

Your code shall have:

• One kind of characters as the protagonist. The protagonist must appear exactly once in the source.

• One other kind as the trap. Traps must appear once or more.

• One other kind as the exit. Exits must appear once or more.

No other restrictions.

## Objective

The protagonist can move by replacing another character by the protagonist and removing the original protagonist.

Write a program/function that:

• Outputs zero when executed/invoked on its own.

• Outputs a negative number if the protagonist moved into a trap. The output need not be consistent.

• Outputs a positive number if the protagonist moved into an exit. The output need not be consistent.

• All other modifications fall in don't care situation.

## Example

Given the following source:

Hello, world!


where H is the protagonist, ls are traps, and os are exits, the source shall output zero.

Then the following sources shall output a negative number:

eHlo, world!

elHo, world!

ello, worHd!


And the following sources shall output a positive number:

ellH, world!

ello, wHrld!


## Scoring

The source with the least number of characters (not bytes) shall win.

# Find out what type of adjective it is

There are 3 types of adjectives: absolute, comparative, and superlative adjectives. Your program should print what type of adjective it is.

## Notes

• Input will be a string, (not always 1 word), it'll be an adjective (the number of words will be finite)
• Output must be either of these (the form of the adjective):
• absolute, comparative, and superlative
• a, c, s
• 1, 2, 3 respectively
• 0, 1, 2 respectively
• The 15 adjectives below should be use as test-cases and you're program should be at least 90% accurate.

This is , so the shortest code wins!

Test cases:

pushiest => superlative
homeliest => superlative
most miserly => superlative
outgoing => absolute
most feline => superlative
roasted => absolute
frightening => absolute
fairer => comparative
more uncomfortable => comparative
more classic => comparative
smarter => comparative
muffled => absolute
scratchier => comparative
meager => absolute
tartest => superlative

• So it only needs to correctly identify 14 of the below 15? Jun 30 at 14:00
• @rak1507 at least. I'll add more test cases if necessary
– math
Jun 30 at 14:02
• @rak1507 but checking everyone of these won't work, as it's code golf
– math
Jun 30 at 14:04
• It should be made very clear whether the program is supposed to work on a finite list of words (as currently suggested) or on any input in theory. The approaches are going to be very different. Jun 30 at 22:34
• "tartest" is a superlative. Jul 17 at 2:04
• @DjinTonic okay done
– math
Jul 25 at 7:58

# Is it a mathy-county-number

So I recently reinvented some boring type of number. Reinvented because I'm sure somebody else invented it before, but 'till figure out who actually invented it, let's call these numbers mathy-county-numbers.

## So what is a mathy-county-number?

It's a number like 332222410.
The number 3 occurs 2 times, so there must be a 2. The number 2 occurs 4 times, so there must be a 4. 4 occurs once, and some other numbers occur 0 times.

The task is simple: Write a program to check if a number (received by the input) is a mathy-county-number.

## Rules

• Default loopholes apply
• Default I/O rules apply
• Output must be a boolean (1/0, True/False, anything/nothing)
• If any digit occurs more than 9 times, count it as a 9.

## Examples

332222410
> 1

33222241
> 0

1
> False

33222
> True

0112223333444445555556666666777777778888888889
> sdcvbhnjmk

1122233334444455555566666667777777788888888
>
$$$$

• "The number 3 occurs 2 times, so there must be a 2." Does this means "3312" is valid as there is a 2 (although not followed by 3).
– tsh
Jul 26 at 9:48
• Why "1" is falsy?
– tsh
Jul 26 at 9:49
• @tsh 1: no, because in 3312 there's no 0. but eg. 03312 would be valid
– math
Jul 26 at 10:44
• @tsh 2: 0 is not there, 9, 8, 7, ... occur 0 times
– math
Jul 26 at 10:54
• "If any digit occurs more than 9 times, count it as a 9." is needlessly complicated, I'd suggest just saying that no digit will appear more than 9 times. The output for the last 2 test cases in unclear - what is sdcvbhnjmk supposed to represent? Just use something like true/false. Additionally, why is 33222 true? By the same logic as the example, it contains "some other numbers zero times", so should include a 0 to be true, right? Aug 6 at 14:02

# Do you come here often?

Imagine a scenario where users are loging in to a website with an email address and a phone number. Sometimes when a user returns, they identify themselves differently; changing either their email or their number.

How do we find the unique users behind the log ins?

Illustration: Here Anna has changed her email between the first and second log in, and changed her phone number from the second to the third. Paul has logged in once, while Anna three times.

# Challenge

Given two ordered list of identifiers (ID1 and ID2), return an ordered list showing the owners of the different IDs (named 0, 1, 2, etc.).

Input: List_ID1, List_ID2

Output: List_ID3

Connection:

A user logs on and identify with two IDs, e.g. List_ID1[0] and List_ID2[0].
The first unique user is called "0" making List_ID3[0] = 0
- If List_ID1[1] or List_ID2[1] can be traced to user 1: List_ID3[1] = 0
- If List_ID1[1] or List_ID2[1] cannot be traced to user 1: List_ID3[1] = 1


# Example Input and Output

Input:

[7, 7, 8, 9, 10, 11, 11, 10, 12, 12, 15, 16, 15, 16, 15, 16]
[1, 2, 2, 3, 3, 3, 4, 4, 5, 6, 2, 1, 2, 1, 2, 1]


Output:

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


# Meta

This is an idea I have had for some time, and though I have some code which can do this, I wonder what is the fastest algorithm for this problem. Today I discovered the Code Golf Meta, and I hope you can guide me through my first interaction with this community. I'm happy to be here!

1. Are there any corner cases? Is it clear how they should be handled?
• I'm not sure.
2. How will the winner of the challenge will be determined?
• This is my first challenge. What I would want to ask that the fastest code wins, but I see that the convention is otherwise here. Or do you also do speed as a winning criteria?
3. Is it clear how all submissions will be scored?
• I was thinking to make some test cases to run. Does that work?
• Welcome to Code Golf, and thank you for using the Sandbox! I think I understand the task, but I think it could benefit from a detailed explanation/walkthrough of the example I/O. For [fastest-code] challenges, the author typically times each submission on their own machine (and you publish some basic specs of your computer) with a set of test cases. You could also consider [fastest-algorithm] as a scoring criteria if you don't want to do this. Jul 26 at 23:17
• Thank you for the warm welcome @cairdcoinheringaahing! I highly appreciate your feedback and I am positively surprised that [fastest-code] can be done in these two ways (I'm excited!). I will work on the explanation/walkthrough and improve the structure of the problem description. Let me know if you have some more feedback, and thanks again! Jul 26 at 23:22
• I'd also suggest that you find a challenge on main to answer so that you can get 20 rep. Once you do that, you can chat, including asking for feedback. Reputation earned anywhere on the network except for SO and Meta.SE will count towards that :) Jul 26 at 23:24

# Group binary shapes together

• I only asked about input, though you could allow it for output too, by allowing each group's 1s to be replaced with consecutive numbers (1-indexed, of course).
Jul 26 at 22:17
• @Adám I don't think I'll allow it for output, that seems like too significant a deviation from the original challenge Jul 26 at 22:18
• Sure, makes sense, and I didn't think of it before you mentioned it :-)
Jul 26 at 22:19
• Can we answer with a list of lists of indices into the input? E.g. [[1,3],[2],[4,5]]?
Jul 26 at 22:23
• @Adám Yes, added Jul 26 at 22:28
• Suggested test cases: [[1,1,1],[1,0,1],[1,1,1]] and [[1,0,1],[1,0,1],[1,1,1]]
Jul 26 at 22:37
• Please supply test cases as JSON.
Jul 26 at 22:37

# King of the Hill: Nose Poker - An ogre game for ogres

• I've edited this down to a stub now that it's been posted to save space Jul 27 at 1:01
• @cairdcoinheringaahing Thanks! I'd meant to do that already. Jul 27 at 7:48

# Two inverse quines

Your challenge is to write two programs A and B such that:

• A outputs B
• B outputs A
• Wherever there is a space character in A, there is a non-whitespace character in B, and vice versa (newlines must be consistent through both)
• This means A and B are the same length in characters.

For example A  and  B are valid, but A  and  B are not.

Newlines must be consistent through both, so A \nB  and  C\n D are valid, but A C and B\nD are not.

# Scoring

Your score is the length in bytes of either of your programs. If they're different lengths in bytes, take the average.

# Knapsack Paragraph, Format For A Phone

There are several paragraph formatting questions already on the site, where a string of text is split on space or other boundaries in order to fit into a rectangle; but they usually involve specifying a particular width for the formatted paragraph in addition to the supplied text.

For this problem, instead of a fixed width, we want to minimize the perimeter of the bounding box of the formatted text. Because we are developers for a phone app and we have to pay for the border by the inch. Or some other such tom-foolery; actually I noticed that this is a bit of a knapsack problem, and I just like the resemblance to that old folk song "knick-knack paddywack, give a dog a bone".

## Challenge

Define a layout of a string T of text as a list of n strings s[i] such that the joined string using spaces as delimiter, i.e. s[0]+' '+s[1]+' '+...+' '+s[n-1] is equal to T.

The semiperimeter of a layout s is n plus the maximum length of any s[i] in s.

Given as input a string T, your submission must output the minimum semiperimeter across all valid layouts of T. Alternatively, you may output a layout which has a semiperimeter which is minimal.

The restrictions on input are forgiving; in particular, you may take T as a list of words (strings without spaces) instead of a single string; so long as the result includes the count of spaces that would be present in the layout when calculating the semiperimeter.

This is code-golf; so the shortest submission in each language is the winner, and will be honored with a parade at some vague time in the near future.

## Notes:

Just wanted to get this down; will edit later. Mulling whether to have output be the integer, or an example layout having the minimal perimeter. The former is simpler to construct; but the latter just seems more satisfying as an output.

The Roly-Poly, Square-Wheeled Quine

Moved here. Thank you for the comments.

• I feel like the whitespace rule is not really necessary, except for maybe just newlines? If my code is just whitespace does that mean I just have to output 6 newlines?
– Jo King Mod
Jul 29 at 2:45
• I'm not following how you are using "is". Do you mean if your code contains whitespace? Or do I need to specify some minimum n? Thanks. Jul 29 at 2:52
• For example, the language Whitespace is composed of only three whitespace characters. What should that be outputting?
– Jo King Mod
Jul 29 at 3:17
• Wouldn't a minimum n x n square of non-blank characters take care of that? Non-whitespace characters that generate whitespace are fine. Jul 29 at 3:24
• I looked Whitespace up. I don't think it can play if its output is encoded as whitespace between characters. Goodness, is it that popular? Jul 29 at 3:35
• The output for Whitespace isn't encoded in any special way. A minimum of n being 1 would solve some problems sure, but my initial complaint is that I don't see why spaces should be treated any different from any other character. Newlines make sense sure, but not spaces or tabs (though this still leads to an issue with Unary). On the other hand, the scoring mechanism is still bytes, so I guess it isn't really abusable
– Jo King Mod
Jul 29 at 3:46
• Esthetically I like the idea of code output resembling a car leaving a car compactor. I see the code being on any number of lines desired as long as output is squares. Jul 29 at 3:52

Your challenge is to write a method that compresses/decompresses strings. It will get two arguments: any string (with any ASCII characters) to compress/decompress, and a boolean. If the boolean is true, compress, else decompress.

It can either print the output to stdout or return the data.

The twist is that your score is equal to the byte count of your source code + the byte count of your source code compressed by the compressor. So if your code was c=>c (which is invalid btw), your score would be 4 + 4 = 8.

## Rules

• Standard loopholes not allowed

• The decompression and compression should work.

• Your code should not just return the same data. So this

c=>c


is invalid

## Test function to check the score

If you like, here's a function which checks your (javascript) answer.

function checkCompressor(compressor) {
const source = compressor.toString();
const compressed = compressor(source, true);
const decompressed = compressor(compressed, false);
if (source !== decompressed) return false;
return compressed; // Have to get byte count manually
}

• What are the possible input ranges for the compressor and the decompressor? Is it allowed for a compressor to output something longer than the input for some inputs? Under the current rules, it looks like I can get a score of 0 by doing if input == itself, return empty string; otherwise do something else. Jul 30 at 4:20
• @Bubbler nice catch! I've updated the question a bit, to account for these cases Jul 30 at 4:32
• "any characters" doesn't look objective to me. Does it include full Unicode range, or just ASCII or Latin-1, for example? Is the length of the compression measured in characters or bytes? Jul 30 at 4:36
• @Bubbler Any characters were supposed to mean any and all characters, but I think that's a bit too much, so i'm changing it to ascii for now. The length of compression is measured in bytes Jul 30 at 6:44

# Determine the length of a Puyo Puyo chain

Puyo Puyo is a Japanese tile-matching puzzle game currently developed by Sega. The gameplay seems simple but it is actually quite complex.

You have a 12x6 board which you can fill with various colors (typically red, green, blue, yellow, and purple) of Puyo (round slime-like creatures with eyes). Each turn, you control a pair of Puyo that you can manipulate and place on the board not unlike Tetris.

When a pair is placed, gravity is applied to the board. If there is an empty gap underneath one or more Puyo in a column, they fall to fill the gap.

When two Puyo of the same color are adjacent to each other, they link together. When 4 or more Puyo are linked, they pop (disappear). After a group of Puyo pops, if gravity causes another group to pop, then you have created a chain. The goal of Puyo Puyo is to place Puyo so that you create as long of a chain as possible to overwhelm your opponent with nuisance Puyo.

Nuisance Puyo are a special case - they are colorless (usually gray or transparent), but more importantly they do not link together. Instead, they pop when an adjacent colored Puyo pops.

## Challenge

Given a Puyo Puyo board in any reasonable format (12 lines of 6 character strings, a 12x6 matrix of characters/numbers, 12 6-character strings in an array, etc.) output the chain length as a number. Standard loopholes apply.

This is code-golf, so shortest source code wins.

Bonus: In Puyo Puyo Tsuu, a hidden 13th row was added above the playfield to allow for longer chains. You will get a -5% score bonus if your program can optionally accept a 13th row.

## Test cases

Note: Intermediate board states are shown to demonstrate the game mechanics; you are not required to output them.

Key: Red, Green, Blue, Yellow, Purple, Nuisance, . empty

Output: 4

...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
......>......>......>......>......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
..GBR. ...BR. ....R. ...... ......
..RGBR ...GBR ....BR .....R ......
..RGBR ...GBR ....BR .....R ......
.RRGBR ..GGBR ...BBR ....RR ......


Output: 4

...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
...... ...... ...... ...... ......
......>......>......>......>......
.G.... ...... ...... ...... ......
YG.... ...... ...... ...... ......
NGY... ..Y... ..Y... ...... ......
NGR... Y.R... ..R... ..Y... ......
YBR... YBR... ..R... ..R... ......
YYBR.. YYBR.. .BBR.. ..RR.. ......
BBRR.. BBRR.. BBRR.. ..RR.. ..Y...


Output: 0

......
......
......
......
......
......
......
......
.B....
BR....
BR....
BR....


Output: 19 (requires bonus; sorry, no intermediate states)

..YRYY
GBBYRG
RBYRYY
GBYRYG
RYRGBG
YRGBYG
RYRGBY
RYRGBY
RGGBGB
GBYRBB
RGBYRG
RGBYRG
RGBYRG


The Puyo Nexus chain simulator might be useful while debugging.

The Lisp language has a family of functions car, cdr, cadr, etc for accessing arrays. For each one, an a defines taking the first item of an array, and a d defines taking the rest.

For example, running cadr on [[1,3,4],5,7] will return [3,4] as the a gets the first item ([1,3,4]) and the d removes the first item.

We've already had a challenge regarding running a cadaddadadaddddaddddddr on a list, but what about the reverse?

Your challenge is to, given a string of the type above (starting with a c, ending with a r, with only ad in the middle), and a single value, create an array such that running the string as a cadaddadadaddddaddddddr on the array returns said value.

For example, given the input cadar, 1 a possible output could be [[0,[1]]] since running cadar on that gives 1.

# Scoring

This is , shortest wins!

# Testcases

These are possible outputs, all that matters is that your program returns an array which works for the condition.

car, 3 => [3]
cdddar, 5 => [0,0,0,5]
caaaaaaaaar, 2 => [[[[[[[[[[2]]]]]]]]]]


Let me know if any of these are wrong.

• one "]" is missing at the end in the 3rd and 4th test, if i'm not mistaken Aug 13 at 12:37
• @Basto Ok, thanks! Aug 13 at 22:05
• "only ad in the middle" ~> "only a, d in the middle"? Else I would read it as matching /c(ad)*r/. Sep 5 at 22:35
• @JonathanFrech This is abandoned, feel free to take it up if you want. Sep 5 at 22:43
• Ok. I would have liked to solve it. Thanks for the offer to take it up but I respectfully decline. Sep 5 at 22:44
• Sep 5 at 22:46
• But with some polish it would be a good question, I think. Sep 5 at 22:47

# Convince me that this vector theorem is true

### Background Information

From Wikipedia:

A sequence of vectors $$\\mathbf v_1,\mathbf v_2,\mathbf v_3,\dots,\mathbf v_k\$$ from a vector space $$\V\$$ is said to be linearly dependent, if there exists scalars $$\a_1,a_2,\dots,a_k\$$ such that: $$a_1\mathbf v_1+a_2\mathbf v_2+\cdots+a_k\mathbf v_k=\mathbf 0$$ where $$\\mathbf 0\$$ denotes the zero vector.

Based on many sources1 around the internet, it is true that

If there are more vectors than dimensions, the vectors are linearly dependent.

In other words, if the vector space is $$\\mathbb R^n\$$(the number of entries in each vector is $$\n\$$), then the sequence of vectors $$\\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p\$$ is always linearly dependent if $$\p>n\ge2\$$.

After looking around, I'm still not entirely convinced that the above statement is true. Please convince me with a program that takes in: the dimension $$\n\$$(you don't have to take this in if you don't need to), and $$\p\$$ $$\n\$$-dimensional vectors $$\\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p\$$, where $$\p>n\ge2\$$. You can take in $$\p\$$ in your program if you want to. You can assume that all vector entries in each vector are integer values. The input format can be whatever you choose, as long as there is a clear distinction between each vector. The program should return a list of scalars $$\a_1,a_2,\dots,a_p\$$, with at least one of them non-zero, such that $$a_1\mathbf v_1+a_2\mathbf v_2+\cdots+a_p\mathbf v_p=\mathbf 0$$ to show linear dependency. If there are multiple outputs that work, you can output any one of them. The output format is also flexible, as long as it is clear what the values of each scalar are.

This is , so the shortest code in bytes wins!

### Example I/O

Input:
$$\n=2\$$
$$\p=3\$$
$$\\mathbf v_1,\mathbf v_2,\dots,\mathbf v_p=\pmatrix{4\\5},\pmatrix{8\\10},\pmatrix{6\\7}\$$

Output:
One possible solution is $$\a_1,a_2,\dots,a_p=2,-1,0\$$. We can quickly test that this does work: $$2\pmatrix{4\\5}+(-1)\pmatrix{8\\10}+0\pmatrix{6\\7}=\pmatrix{8\\10}-\pmatrix{8\\10}+\pmatrix{0\\0}=\pmatrix{0\\0}=\mathbf 0$$

### Test Cases:

Work in progress

n, vectors -> scalars
2, [(4,5),(8,10),(6,7)] -> [2,-1,0]
2, [(3,6),(6,7),(3,9),(2,4),(5,5)] -> [2,0,0,-3,0]
3, [(1,2,3),(2,3,4),(3,4,5),(4,5,6),(5,6,7),(6,7,8),(7,8,9),(8,9,10)] -> [1,-1,-1,1,1,-1,-1,1]


1: Some sources: this, this, this, this

# Concerns

• Has a similar challenge been done before?
• Is it clear what the challenge is specifying?
• I want to change the title to be more specific, but I'm not sure what to change it to.
• I need some test cases, but I'm not sure what test cases would be good for this.
• A possible title would be "Solve a linear equation system" or "Find a kernel vector" Aug 15 at 22:13
• "$n\geq 2$" is superfluous. Sep 5 at 22:30
• I do not quite understand the premise, since a vector space's dimension is defined to be its basis' length. Thus if you are not convinced your statement is true you should not accept $K^n$ to have dimension $n$. Sep 5 at 22:33

# All valid N * N Flow Free Boards.

Since there are several other Flow Free question, either here or on main, but none, as far as I can tell, that do this, I will ask the question some of us have pondered at night: How many valid Flow Free Boards are there?

# What is a valid board?

From what I can tell from my attempts at time trial, a valid board has all of these:

1. Has between floor(2N/3) and ceil(3N/2) flows (where a flow is two distinct points, defined as it's ends, between which a line can be drawn connecting them).

2. No two endpoints of a flow can be adjacent.

3. The board must be solvable - that is, there must be a way that all endpoints of the flows can be connected together such that every square of the board is filled once and only once, and no two paths intersect at all.

# Input/Output

Your program will receive N, the side length of the board. The board will always be square (as that is the case in most boards), and it must return all valid boards, and the number of such boards.

As always, you can take input and output in any reasonable format, and shortest byte count wins!

# Meta

Has this been done before?

Anything that needs specifying?

Who Won Tic-Tac-Toe?

Your job is to be the judge of a game of Tic-Tac-Toe.

Given an input consisting of three lines (9 characters not including newlines), determine the winner of the game of Tic-Tac-Toe.

For example, for the input

XOO
-XO
O-X


your program should either return or print X.

For tie games or games where no one has won, do not print or return anything.

The only input characters will be 'X', 'O', and '-' (along with two newlines), and the only outputs your program should give are 'X' and 'O' (or nothing).

Also note that the given board will be a valid game of Tic-Tac-Toe, so there will be no situations where both players have winning positions.

More examples:

OOO
---
---


=> O

OXO
--X
---


=> (nothing)

OXO
X-O
X-O


=> O

OXO
XOX
XOX


=> (nothing)

# Tic-Tac Clock

given a time of the day (0-12 inclusive) output the closest fitting clock. This means 0/12, 3, 6 and 9 should be straight up/to the side. The one's in between go in the corners!

The clock should look as follows:

      #|#
0  -> #+#
###

##/
1  -> #+#
###

##/
2  -> #+#
###

###
3  -> #+-
###

###
4  -> #+#
##\

###
5  -> #+#
##\

###
6  -> #+#
#|#

###
7  -> #+#
/##

###
8  -> #+#
/##

###
9  -> -+#
###

\##
10 -> #+#
###

\##
11 -> #+#
###

#|#
12 -> #+#
###


This is code-golf so the shortest answer (per language) in bytes wins.

## questions

This is my first question so I'd appreciate some feedback, mainly if this challenge would be too tedious to do.

• Given that the input is limited to 1 through 12, I'd suggest just showing what each output should be for all the possible inputs, just to avoid any confusion Aug 22 at 1:29
• That sounds reasonable. Will edit it. Do you think this would be good to post on the main site otherwise? Aug 22 at 7:57
• Overall, looks good (though I haven't done any dupe searching). One thing I'd clarify a bit would be the output format - can it be any characters, or does it have to match as shown? Can the output be a list of lines, or does it have to be a multi line string? Etc. Aug 22 at 8:28

Add 2 numbers using a graphics card

# Introduction

Graphics cards have great performance when doing big calculations. So lets make a small calculation

# Challenge

• Inputs: 2 floats of choice

• output: the addition of the two floats.

• The addition should be calculated on the graphics card, but it doesn't matter if it doesn't work on all gpu's

• Lowest score in bytes wins

# Example Input and Output

2.5 and 3.2 -> 5.7

# Implement the LC-3 VM [1] using 16-bit subneg4 [2] only & test it

• Welcome to Code Golf, and thank you for using the Sandbox! We require challenges to be self-contained; you should fully explain the terms/acronyms used, as well as anything else relevant to the challenge - in short, imagine you're explaining this to someone who knows nothing about it. I'd also suggest removing the time limit, and explain the winning criteria better Aug 18 at 0:36
• Welcome to Code Golf! The scoring criteria are kinda confusing for people who are new to such system, you may want to add some scoring examples because it's very unique compare to ordinary code-golf.
– okie
Aug 18 at 2:36

# What will the radio play next week?

Each week, Billboard publishes the US music industry standard ranking of the 100 most popular songs based on sales, radio play, and online streaming. The current chart can be found here.

For each song on the chart, Billboard reports the song's current ranking (from 1 to 100, with 1 being the best), the previous week's ranking of that song (labeled "last week"), the best ranking that the song has ever received by Billboard (labeled "peak"), and the number of weeks that the song has appeared on Billboard charts to date (labeled "wks on chart").

Pop stations in the US generally play the top 40 most popular songs on a given week. In this challenge, we will predict what the radio will play next week given previous Billboard charts.

## The Data

This text file provides the "last week" data for every chart from July 25, 2015 though July 17, 2021 (based on data provided here). There are 313 lines (one for each week) with 100 comma-separated numbers in each line. The first line corresponds to July 25, 2015, and on that week's chart, "Cheerleader" by OMI was ranked #1 (up from #2 the previous week), while Chris Young's "I'm Comin' Over" made its debut on the chart at #100. In the first line of the data provided, this is reflected with the first entry being 2 and the last entry being 101 (throughout, 101 indicates that the song did not chart on the previous week). The next line of the data starts with a 1, indicating that OMI's "Cheerleader" was still ranked #1 on the August 1, 2015 chart. In this way, the data captures how songs move up and down the chart from week to week.

## The Challenge

Write a program or function that, for each n from 0 to 312, receives the first n lines of the data as input and outputs the first 40 numbers from line n+1.

Standard rules apply. The shortest code in bytes wins.

# Binary integer subtraction a - b with 0 < b < a using string processing logic code-golfsubtractionintegerstring

## My Work

I noticed that for this subtraction problem it is not necessary to use twos-complement and that the result can be stored in the same memory required to store a; all that is required is to employ symbolic/logic processing on bit/char-strings.

I wrote a Python program that uses divmod, but that was just a way of 'shifting-off' the right most bit from the bitstring, so the code-golf answers should not use any arithmetical operations.

Here is my program, which can be taken to solve an implicit string processing specification:

minuend =    int(10**1111)
subtrahend = int(10**1110)

if True: #debugging
minuend =    0b110101
subtrahend = 0b000111
M = minuend
S = subtrahend

difference = ''
while 1: #State 0
if minuend == 0:
break
minuend, m_right_bit = divmod(minuend, 2)
subtrahend, s_right_bit = divmod(subtrahend, 2)
if     m_right_bit == 0 and s_right_bit == 0:
difference = '0' + difference
elif   m_right_bit == 1 and s_right_bit == 0:
difference = '1' + difference
elif   m_right_bit == 1 and s_right_bit == 1:
difference = '0' + difference
else:# m_right_bit == 0 and s_right_bit == 1:
#State 1
difference = '1' + difference
while 1: #State 1
if minuend == 0:
break
minuend, m_right_bit = divmod(minuend, 2)
subtrahend, s_right_bit = divmod(subtrahend, 2)
if     m_right_bit == 0 and s_right_bit == 0:
difference = '1' + difference
elif   m_right_bit == 0 and s_right_bit == 1:
difference = '0' + difference
elif   m_right_bit == 1 and s_right_bit == 1:
difference = '1' + difference
else:# m_right_bit == 1 and s_right_bit == 0:
difference = '0' + difference
break # back to State 0
continue
continue

if True: #debugging
if int(difference, 2) != M -S:
print('Program failed...')

raise SystemExit
`

## Challenge

Code to perform the same subtraction as my Python program; no output should be produced.

Standard rules apply. The shortest code in bytes wins.

• Unfortunately, this is not how challenges work on our site. A code-golf challenge should be defined in terms of input and output, not by some internal behavior. Behavior (or algorithm) requirements are non-observable. Sep 14 at 1:12