# What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. 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.

To post to the Sandbox, scroll to the bottom of this page and click "Answer This Question", or click on the "Add Proposal" link below. Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. 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.

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

# Convincingly Fake Compression of Random Data cops-and-robbers

As you may know, it is impossible to write an compression method that takes strings of length $$\n\$$ and returns strings of length $$\n - 1\$$. This can be proven by a simple argument: Each compression function must be a bijection, because otherwise the compressed strings can not unambiguously be uncompressed. However, just considering bit strings, there are $$\2^n\$$ strings of length $$\n\$$, but only $$\2^{n-1}\$$ strings of length $$\n-1\$$, thus no such bijection can exist.

In other words, for each attempt to write such a compression function, there exist strings which cannot be compressed.

The task for the cops in this challenge is to write a function which looks like it can compress arbitrary fixed-length strings, and the task of the robbers is to find a string for which the compression function fails.

### Sandbox

I'm not yet convinced if this will actually work as a challenge, mainly if it is feasible for the cops to write a submission which is not easily crackable. It might be easier for large $$\n\$$ so robbers can not brute force, so I could make the cops winning criterion about getting the safe submission with the lowest $$\n\$$. Any ideas for a better winning criterion?

Also do you think this will work as a challenge?

• Might be too easy for a challenge. There's a 50% probability that you find a string which fails. – Erik the Outgolfer Jun 26 '18 at 14:17
• Looks feasible to me. It may be good to fix the input into binary string, lower-case alphabet, or just ASCII and require the robbers to find two strings that "compress" to the same object. – JungHwan Min Jun 26 '18 at 14:53
• @EriktheOutgolfer yes, but with a well-crafted cop submission, it would be difficult to know that a string wasn't "compressed" unless the robber finds two strings that end up with the same string or writes a "decompression" function. – JungHwan Min Jun 26 '18 at 14:56
• @JungHwanMin Just run it and measure its length? – user202729 Jun 26 '18 at 15:20
• Anyway I think this is only feasible if the cops solution takes a very long time to run even for a single input, for most/all of the counterexamples. – user202729 Jun 26 '18 at 15:24
• @user202729 What I meant to say is that it is possible that there exists a "compressed" string that corresponds to only one "uncompressed" string, so it would be "compressed" when you feed it to the cop program. With a good cop program, it may be hard for robbers to find specific examples of strings that have the same "compressed" variation. – JungHwan Min Jun 26 '18 at 16:15
• @JungHw Pick random strings of length n and compress it, the expected number of runs until you crack the solution is 2. – user202729 Jun 26 '18 at 16:21
• @user202729 That doesn't make sense. Assuming that we use binary strings and exactly two strings compress to one string, the probability of getting no collision after picking 3 strings is 1 * (2^n - 2)/(2^n - 1) * (2^n - 4)/(2^n - 2), which should be close to 1 with large enough n. – JungHwan Min Jun 26 '18 at 16:31
• Perhaps the word "fail" has to be clearer. The challenge sounds possible if "failing" means "producing colliding outputs" instead of something on the lines of "crashing." With binary strings, Mathematica tells me that the expected value of trials needed to find colliding strings is ~946 with length 10, and ~1.05e+6 with length 20. – JungHwan Min Jun 26 '18 at 16:46
• @JungHwanMin Shouldn't generating a random string, compressing it, decompressing the result and checking whether this equals the original string yield a collision with probability 0.5? – Laikoni Jun 26 '18 at 21:14
• @Laikoni then the robber would need to create a decompression function. Maybe I misunderstood the challenge, but I thought the only requirement for the cop was to include a compression algorithm. Having some obscure compression function that make "decompression" very challenging would make this challenge feasible. – JungHwan Min Jun 26 '18 at 21:28
• I suggest changing the challenge specification to my misinterpretation of the challenge specs. ;-) The robber would need to come up with either a decompression function or a counterexample to the compression algorithm (i.e. prove that the compression is not bijective). – JungHwan Min Jun 26 '18 at 21:40
• @JungHwanMin Thanks for the suggestions! The problem with the cop providing only a compression function is that they could submit any hash function, because that's what those fake compression functions actually are, and trying to prevent cops from submitting known-to-be-collision-resistant hash functions probably brings us into dupe-distance to this cnr challenge. – Laikoni Jun 26 '18 at 22:10
• So the cops must write a decompression function too? – user202729 Jun 27 '18 at 1:57
• @user202729 That's what I originally envisioned, but at the moment that's up for debate in order to make the challenge feasible for the cops. – Laikoni Jun 27 '18 at 8:08

# Progrqmming Puzzle andf Co9de Golf |

## Intro

We all make mistakes. You, me, everyone. But not computers. They aren't making any mistake. Not even a single typo.
Time to change this injustice.

## Task

Your task will be to take a string as input, and display the string character by character, and with a cursor, as if someone was typing it. But there is a twist : sometimes, the "entered" character will be wrong. In that case there is a little pause, then the last entered character (which is supposed to be wrong) is deleted.

## Rules

• Input and output will contain only printable ASCII characters.
• The cursor should be displayed as |, preceded by a space. This will always be displayed, from the empty string to the exact input displayed.
• Each "iteration" (new character) is separated by a 0.25s pause (It takes time to write right). You can have a marge error of 0.05s, meaning the pause have to be lower than 0.2s, and lower than 0.3
• Each character has exactly 1/10 chance to be wrong (that means it will be anything but the right character). In that case you should add a 1s pause ("Wait, did l really made a mistake?"), then delete this character, add a 0.25s pause (with a marge error of 0.05s), then continue.

# Example

## input

Hello!

## Possible output

Note : I am planning to add a gif to show what the code should do. For now, consider every line as a gif frame

H |          // 0.25s pause
He |         // 0.25s   "
Hel |        // 0.25s   "
HelG |       // 1s      "
Hel |        // 0.25s   "
Hell |       // 0.25s   "
Hello |      // 0.25s   "
Hello! |     // done


# Note for sandbox

• Is this challenge good enough ?
• Is this challenge already exist ?
• Is this challenge clear enough ?
• Are those typos in the body also intentional? e.g. whitch – wastl Jun 22 '18 at 12:48
• @wastl Except for the title, this is just me being bad at writing english – The random guy Jun 22 '18 at 12:52
• @AdmBorkBork the wrong character can be anything, except for the character it should have be. In my example the wrong character is a G, it could have been a a, a 7, a #, but not a l since it is the correct character. – The random guy Jun 22 '18 at 14:28
• Is it acceptable if the "wrong" character is not random? For example, if a typo on a always becomes b. It might also be a good idea to restrict what characters need to be handled, e.g. "Input will, and output must, consist of only printable ASCII characters" – Kamil Drakari Jun 22 '18 at 15:53
• @KamilDrakari as long as the "wrong" character is actually wrong, it's ok. And good idea for the input/output restrictions. – The random guy Jun 22 '18 at 20:04
• Can we use \b to remove the previous character? How accurate does the delay have to be (0.24 seconds instead of 0.25?). Same question with randomness. Can we have an initial delay before output? Enough is spelt with a g. – Jo King Jun 27 '18 at 2:35
• @JoKing as long as the output shows that the character is removed, you can use \b. i'd say delay will have an error margin of 0.05s (basically 0.2s<delay<0.3s). However the randomness has to be exactly 1/10. I'll edit the question to add those criterias later. – The random guy Jun 27 '18 at 10:42
• You say each character has a 1/10 chance of being wrong? Does this mean answers have to behave non-deterministically, or could a deterministic method be used as long as 1 out of every 10 characters is wrong. – Wheat Wizard Jun 28 '18 at 13:27
• @CatWizard Answer have to behave non deterministically : the total number of wrong characters will only rely to randomness. – The random guy Jun 29 '18 at 16:34
• how are you going to measure exact timing on people's solutions? – don bright Jul 7 '18 at 2:16
• @donbright with a chronometer ? More seriously, the point here is to get aproximately 4 characters in a second (unless there is a wrong one) – The random guy Jul 9 '18 at 9:30
• i dont know how you can measure it, since computers run at different speeds, and OSes are not realtime OSes. but i like it enough anyways. – don bright Jul 11 '18 at 1:02

# Role reversal

This is related to an old question, but is different enough that answers should be quite different to the older one.

You are given a sentence referring to two different people. Return the sentence with the roles reversed.

For example, for the input I will give you a kiss., you should return You will give me a kiss.

There will always be exactly two people referred to in the sentence, and they will be referred to with different pronouns. Here's a table of the pronouns that might be used (pronouns in a row refer to the same person. Pronouns in a column can be switched with one another to reverse a role).

 I         me       my           mine         myself
you       you      your         yours        yourself
she       her      her          hers         herself
he        him      his          his          himself
they      them     their        theirs       themselves


Capitalisation matters (the first letter of the sentence should be capitalised, the pronoun "I" should always be capitalised, and no other pronoun is capitalised when not starting a sentence).

Words/punctuation not appearing in the pronoun table above shouldn't be changed. A pronoun word shouldn't be replaced if it appears as a substring of another word (e.g. 'history' shouldn't he changed). None of the inputs will be contractions using pronouns (so there won't be any inputs with "I'm" or "you're" etc).

## Input/output examples:

in: She gave them hers!
out: They gave her theirs!

in: He will eat me if I don't eat him.
out: I will eat him if he don't eat me.

in: Get it for them yourself!
out: Get it for you themselves!

in: I think I am going to see him tomorrow.
out: He think he am going to see me tomorrow.

in: I am not interested in history, is he?
out: He am not interested in history, is I?


## Rules:

• This is code golf so the shortest answer wins.
• Standard loopholes are banned.
• Any last thoughts before I post this? – LangeHaare Jul 19 '18 at 14:21

# Use Japt Shortcuts

Japt is the PPCG Language of the Month for July, and I'm excited to try it out! In accordance with the Tips post I should use the Unicode Shortcuts. However, my keyboard seems to be lacking those important characters like "upside-down exclamation point" needed for optimum golfiness. Please write me a program to change horrible, verbose monstrosities like â m@VgUb==X into pristine, optimal code like â £VgUb¥X!

## Challenge

Given Japt code as input, output the same code making maximal use of the Unicode Shortcuts Japt supports.

## Rules

• Answers must support inputs containing any combination of valid Japt characters [Sandbox: is there a list of these? In particular, many languages need to use the NULL byte to indicate end of input, does Japt support NULL bytes in the middle of code?].
• Input may be in any reasonable format (string, list of chars, etc.)
• Output may be in any reasonable format, and does not need to be the same as the one used as input (e.g. "input as string => output as list of chars" is fine)
• If multiple shortcuts are possible, use the one that replaces the most characters. For example, === should be replaced by ¶ not ¥=.
• Your code does not need to handle ambiguous situations. For example, ==== could be shortened to ¶= or =¶, so behavior is undefined if such a string shows up in the input.
• Only shortcuts available in Japt 1.4.5 (most recent version at time of posting) need to be handled
• Non-unicode shortcuts like _ and @ don't need to be handled
• I've replaced easy-to-miss trailing spaces with ␠ where I found them. Those should be the literal space character ' ' when running tests or replacements. [Sandbox: Seriously, is there some better way to do this?]

## Test Cases

?OvUf\l m_c %H} qV):0 => "?OvUf\l ®c %HÃqV):0"
Ov"y m_î íZ c p0} "p2␠ => Ov"y ®î íZ c p0Ã"²
=== => ¶
ñgJ òXYZ{XgJ <YgJ } mg mg␠ => ñÌòÈÌ<YÌÃmÎmÎ
w å+ m@Vå+ m+S+Xw} c => w å+ £Vå+ m+S+XwÃc


[Sandbox: The first two test cases are grabbed from some real Code Golf answers here and here. Should I replace them with something else?]

For reference, here is the full list of Unicode Shortcuts to be supported. It can also be found on the Japt Interpreter. Note that some shortcuts end in a space. [Sandbox: should I format this differently?]

¡   Um@
¢   Us2␠
£   m@
¤   s2␠
¥   ==
¦   !=
§   <=
¨   >=
©   &&
ª   ||
«   &&!
¬   q␠
®   m_
¯   s0,
°   ++
±   +=
²   p2␠
³   p3␠
´   --
µ   -=
¶   ===
·   qR␠
¸   qS␠
¹   )␠
º   ((
»   (((
¼   .25
½   .5
¾   .75
À   !==
Á   >>>
Â   ~~
Ã   }␠
Ä   +1
Å   s1␠
Æ   o@
Ç   o_
È   XYZ{X
É   -1
Ê   l␠
Ë   mDEF{D
Ì   gJ␠
Í   n2␠
Î   g␠
Ï   XYZ{Y
Ð   $new Date($
Ñ   *2
×   r*1␠

• Nice idea! You can include trailing spaces by using <pre><code> ... </code></pre> instead of indenting, though they'll only be visible if the text is selected if you do it that way. (Also, Ê, Ì, and Í want their ␠s back ;-) ) – ETHproductions Jul 7 '18 at 4:49

A note about this meta post:

I just have one example right now, but I will have three in the final.

I thought it would be interesting to have a problem about something I know a bit about. Right now it seems a bit mathy, but I wanted to ground the problem on something real. It feels more 'real-life' if you need to understand the spec in addition to golfing. The problem is I don't want it to seem like homework. Another problem is the actual computation that needs to take place isn't actually that hard once you understand the simplifications of the problem.

Let me know what you think.

$\def\tensor#1{\smash{\underline{\underline{\smash{#1}}}}}$

# Challenge

Calculate the strain tensor and volume percent change of a cube given its material properties and stress tensor.

# Background

### Common Terms • Strain: ε, The amount of elongation per unit length, Units: $\frac{in}{in}$

• Normal Stress: σ, The amount of force per unit area perpendicular to the cross section, Units: $\frac{lbs}{in^2} = psi$

• Shear Stress: τ, The amount of force per unit area parallel to the cross section, Units: $\frac{lbs}{in^2} = psi$

• Young's Modulus: E, The relationship between stress and strain: $σ = Eε$, Units: psi • Poisson's Ratio: ν, The relationship between strain in different directions. For a uniaxial bar: $ε_{22} = -ν ε_{11}$, Units: unitless

• Index Notation: A short form for tensors written with subscripts $i,j,k,l$ to denote which element within the tensor. The number of subscripts the tensor has indicates what order it is. $σ_{ij} \equiv \tensor{σ}$ (Second Order)

• Kroniker Delta: $δ_{ij}$, has the value of 1 if i=j, otherwise its value is 0. Index Notation for the Identity Tensor.

$$δ_{ij} = \left[\begin{array}{ccc} δ_{11} & δ_{12} & δ_{13}\\ δ_{21} & δ_{22} & δ_{23}\\ δ_{31} & δ_{32} & δ_{33}\\ \end{array}\right] = \left[\begin{array}{ccc} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right] = I$$

### Tensors

A tensor in this context can be thought of as three directional components for each of the three positive faces of the cube. Although a Stress Tensor is not a matrix, it can be represented in matrix form by a 3x3 or other matrices:

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_{xx} & σ_{xy} & σ_{xz}\\ σ_{yx} & σ_{yy} & σ_{yz}\\ σ_{zx} & σ_{zy} & σ_{zz}\\ \end{array}\right] = \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{21} & σ_{22} & σ_{23}\\ σ_{31} & σ_{32} & σ_{33}\\ \end{array}\right] = \left[\begin{array}{c} σ_{11}\\ σ_{12}\\ \vdots \\ σ_{33}\\ \end{array}\right] = \left[\begin{array}{cccc} σ_{11} & σ_{12} & \dots & σ_{33}\\ \end{array}\right]$$

If a Tensor and a Kroniker Delta share the same indices, they are combined.

$$σ_{ij} δ_{kj} = σ_{ik}$$

If a Tensor has repeating indices, then it is taken as a zero order tensor and the indices are summed.

$$σ_{ij} δ_{ij} = σ_{ii} = \sum_{i=1}^{3} σ_{ii} \equiv tr(\tensor{σ}) = σ_{11} + σ_{22} + σ_{33}$$

### Stress Strain Relationship

The relationship in one dimension is $σ=Eε$. For three dimensions we can use Hook's law to find the relationship between the strain tensor and the stress tensor as follows:

$$σ_{ij} = C_{ijkl} ε_{kl}$$

This general case would need $3^4 = 81$ independent material properties to calculate the strain tensor. If we assume the cube has a symetric $\tensor{σ}$, symetric $\tensor{ε}$, is Elastic, Isotropic, Linear, and Homogeneous, then we only need two independent material properties: (Young's modulus: E, Poisson's Ratio: ν) or (Lamé modulus: λ, Shear modulus: μ). We can use either pair of values, but for this example it is much easier to calculate the strain tensor from the stress tensor using Young's Modulus and Poisson's Ratio.

And so we can simplify the stress tensor by what we know.

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_x & σ_{xy} & σ_{xz}\\ & σ_y & σ_{yz}\\ Sym & & σ_z\\ \end{array}\right]$$

And our new relationship is:

$$ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij}$$

### Calculating the Dilation The Volumetric Strain can be found by calculating the trace of the strain tensor for very small values of strain. This is because for small values $ε^3 \ll ε^2 \ll ε$.

$${\frac {ΔV}{V_0}} \approx tr(\tensor{ε})$$

### Putting it all together

Therefore, in summary we can calculate the strain tensor with the following:

Using Index Notation:


$$ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij}$$

Using Matrix Notation:


$$ε_{ij} = \frac{1+ν}{E} \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{12} & σ_{22} & σ_{23}\\ σ_{13} & σ_{23} & σ_{33}\\ \end{array}\right] - \frac{ν}{E} tr(\tensor{σ}) \left[\begin{array}{c} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right]$$

Then calculate the volumetric change:

Index Notation


$${\frac {ΔV}{V_0}} = ε_{ij} δ_{ij} = ε_{ii}$$

Matrix Notation


$${\frac {ΔV}{V_0}} = tr(\tensor{ε})$$

# Input

One positive long: Young's Modulus (Usually in the range 100 psi - 100,000,000 psi)

One positive decimal: Poissons's Ratio (Usually in the range 0.01 - 0.5)

Array of signed decimals for Stress Tensor (9 values)

# Output

Array of Strain Tensor, to at least five significant figures (same format as input)

Percent volume change of cube, to at least five significant figures

# (simple example for now)

Input:
Young's Modulus: 29,000,000 psi
Poisson's Ratio: 0.30
Stress Tensor: [[50000,      0,     0]
[    0, -10000,     0]
[    0,      0, 25000]] psi
Output:
Strain Tensor: [[0.00157,        0,       0]
[      0, -0.00112,       0]
[      0,        0, 0.00045]] in/in
Dilation: 0.08966%


# Rules

IO is flexible

• Stress Tensor input can be any size array, or string

• Input type and size must be the same as output
• No formatting or units required

This is , least number of bytes for each language wins

• Looks interesting. However, because all answers are publicly viewable, challenges where the main difficulty is the implementation (instead of understanding the challenge) is preferred. Looking at the input/output it appears that the implementation itself is probably complex enough to be interesting. – user202729 Jul 8 '18 at 10:58
• this is very fascinating. IMHO the writing could be adjusted for the audience. if they are like me, i dont really understand stress and strain, and what they mean in laymans terms. also i think it could be simplified a lot. take for example the first graph. what are the dashed lines? why are they numbered 1 and 2? what is 0.2%? why is there a cylinder there, and what does it mean? is any of that graph required to solve the puzzle? – don bright Jul 11 '18 at 1:42
• @donbright Thank you, this is helpful. I will explain the fundamentals of stress and strain more, and annotate the pictures (which are directly from wikipedia). The graphs are not required to solve the puzzle, but they may be useful to understand the concepts. I have them to explain, but they are probably not as helpful to a layman. I will fix it up in the next few days. Btw, what do you you think of the explanations from the tensors section onwards? – WretchedLout Jul 12 '18 at 5:13
• I think it's "Kronecker delta" not "Kroniker delta". Also what is $\varepsilon_{11}$ and $\varepsilon_{22}$? – user202729 Jul 13 '18 at 2:54
• You should probably describe what is a tensor too. (yes I can read Wikipedia and it's unambiguous but it would be more useful if a post contains all information) – user202729 Jul 13 '18 at 2:57
• still hoping for this one to become a challenge!!!! – don bright May 27 '19 at 23:46

# Haferman Carpet

Given nonnegative integer input $n$ output the $n$th iteration of the Haferman carpet.

## Constructing the carpet

• The zeroth iteration is 1.
• When going from the $n$th to the $(n+1)$th iteration, replace each $1$ with the pattern [[0,1,0],[1,0,1],[0,1,0]] and each $0$ with the pattern [[1,1,1],[1,1,1],[1,1,1]].

## Test cases

0 []

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

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


# Sandbox

Is this a duplicate? I will make the rules more explicit later.

• Talking about replacing a scalar with a 2D array confused me for quite a while. Having the test cases laid out in a way which obscures the 2D pattern of the carpet also doesn't help. – Peter Taylor Jul 13 '18 at 8:43
• As for dupes: these are probably the most closely related questions: two about the Sierpinski carpet and one which is general enough to draw that one and this one. I think it's borderline whether or not this adds something new to the site. – Peter Taylor Jul 13 '18 at 8:47

# Syllabification and classification (Venpa)

### Introduction

Venpa is a form of classical Tamil poetry, based upon certain rules of metric prosody. The complete rules form a context-free grammar, the task here is to test for a tiny subset of those rules.

### Letters

• Vowels: a, A, i, I, u, U, e, E, y, Y, o, O, W
• small case represents "short" vowels, CAPS represent "long" vowels
• y represents the y sound in "my".
• W represents the "ou" sound in "mouse", and always comes in capital (long) form.
• Consonant: everything else
• the consonants can be in small case or capitals, whichever is convenient.

### Word Segmenting

Words in the input are seen as composed of segments (which roughly correspond to the usual notion of a syllable). A segment divide occurs where:

• two or more consonants occur together, tr, rpp, etc.
• a long (capital) vowel occurs in the word, pO, W, mY etc.
• two vowels have occurred since the last segment's end (or the word's beginning).

sanjIvi has segments san, jI, vi.
Yvar has Y,var.
vigadakavi has viga,daka,vi.
vAnily has vA,nily.
padAgytAngiha has padA, gytAn, giha
radagajaturagapadAdi has rada, gaja, tura, gapa, dA, di

(Consonants at the end of segments make no difference after segmentation and can be ignored - gytAn=gytA, var=va.)

As you can see, the segments are of two types:

1. those with a single vowel, san, Y, vA, called a straight (S) segment
2. those with two vowels, viga, nily, padA called a sequence (Q) segment

So the segment patterns of the above words are:

  sanjIvi              =              san + jI + vi          = SSS
Yvar                 =                 Y + var             = SS
vigadakavi           =            viga + daka + vi         = QQS
vAnily               =                vA + nily            = SQ
padAgytAngiha        =           padA + gytAn + giha       = QQQ
radagajaturagapadAdi = rada + gaja + tura + gapa + dA + di = QQQQSS


### Permitted patterns

The rules for words allowed in a Venpa are:

1. a word should have one to three segments
2. a one or two segment word can have any pattern (S, Q, SQ, SS, QS, QQ)
3. a three segment word must end in a straight (S) segment

So out of the above, SSS, SS, QQS, and SQ are allowed, QQQ and QQQQSS are not.

### Task

Given an input word in the above letters, output its segment pattern if it's an allowed word, or a false-y value if it's not an allowed word.

### Input

• Will be a single word composed of the characters mentioned under the Letters heading above
• (Small case w will not be present anywhere in the text (neither as a vowel nor as a consonant))

### Output

• The segment pattern of the input word, if it's an allowed word
• can use any two distinct unambiguous characters to represent S segments and Q segments
• A false-y value in your language if it's not an allowed word
• Output is undefined for invalid input (i.e. has characters other than those specified)

### Test cases

vigadakavi
=> QQS
Yvar
=> SS
padAgytAngiha
=> falsey (QQQ not allowed)
vAnily
=> SQ
katradanA
=> SQS
radagajaturagapadAdi
=> falsey (more than 3 segments)
TuppArkkuT
=> SSS
mazai
=> Q

• fascinating. im probably very unusual, but i would like it even better if it was actual poetry instead of 'p' everywhere, maybe even in tamil script (although that would probably disqualify some languages) – don bright Jul 7 '18 at 2:37
• Yeah, I intended to just remove some extraneous complexity, but somehow having input in this form makes it slightly less interesting even to me (and I'm not sure it removes a meaningful level of complexity anyway, relative to the rest of the task). I'll change it to use the actual consonants if anyone else here also feels this way. (The last two test case inputs are from actual poetry by the way, just with the consonants replaced.) – sundar - Remember Monica Jul 7 '18 at 18:54
• Using Tamil script would also be great, but my concern with that is mainly that it might make testing and debugging much harder for people who can't read the script. I can mitigate some of that by providing exhaustive test cases, but I'm not sure it's worth it. – sundar - Remember Monica Jul 7 '18 at 18:58
• yeah i think i might be a little unusual in my tastes, i still like the puzzle... – don bright Jul 7 '18 at 20:08
• @donbright I've updated the post to use different consonants (corresponding to actual words). I like this version a lot better, but let's see how it's received. – sundar - Remember Monica Jul 20 '18 at 14:18
• I wrote a program that solves the examples you gave. my first pass was 60 lines of Rust code. i think it is a really good puzzle, great balance between an interesting puzzle and many ways to possibly reduce code size. very interesting. – don bright Dec 29 '18 at 14:10
• i would like some more examples though. feel like my program might be wrong on some inputs. – don bright Dec 29 '18 at 14:11

# DRAW me a picture: A QBasic metagolf challenge

The DRAW command in QBasic takes a string argument, consisting of instructions for moving the cursor and drawing line segments, and produces the appropriate line segments on the screen. The syntax of the instructions is very terse--perfect for a challenge!

## The challenge

Write a program or function which:

• Given a 2-D array of on and off pixels, representing a black-and-white image,
• Generates a string that, when passed to QBasic's DRAW command, will draw that image on the screen,
• While keeping the generated string as short as possible.

### More about DRAW

Your program may use the following DRAW instructions:

(more details pending)

• U - draw line upwards
• D - draw line downwards
• L - draw line to the left
• R - draw line to the right
• E - draw line diagonally up and to the right
• F - draw line diagonally down and to the right
• G - draw line diagonally down and to the left
• H - draw line diagonally up and to the left
• B - meta-instruction: prepend to any instruction to move the cursor accordingly but not draw the line
• N - meta-instruction: prepend to any instruction to draw the line but not move the cursor

(examples + pictures pending)

The following instructions are outside the scope of this challenge and may not be used (even if they would improve your score): C, P, S, M, X, A, and TA.

### Output requirements

Conceptually, your program's output will be substituted for the ... in the following QBasic program:

SCREEN 9        ' Graphics mode, 640 x 350 pixels
DRAW "B M 0,0"  ' Set drawing cursor to top left corner
DRAW "..."


(If the length of your output exceeds any limits on line or string literal length, it may be split across multiple DRAW commands in such a way that the instructions are preserved.)

The program will then be run, and the output image compared to your program's input. Where the input array has a 1, the output image must have a white pixel; where the input array has a 0, the output image must have a black pixel. The portion of the screen outside the input array's dimensions must be entirely black pixels.

Practically speaking, I will probably write a verification script in some other language, just to make testing easier.

### Details

Standard I/O methods apply. Output is case-insensitive. Input array dimensions will not exceed 640 x 350. (more rules pending)

### Test cases

(test cases pending)

### Scoring

Your submission's score is the sum of the lengths of its outputs on these test cases. In the case of a tie, the earlier submission wins.

Note: this challenge is probably a variation on the Traveling Salesman Problem, meaning that an optimal solution will take exponential time. In order to receive a score, your submission must complete all test cases, which means that you'll need to take a sub-optimal approach.

Sandbox questions:

• What's a good number of test cases?
• Should I instead score submissions on a second, hidden set of test cases to prevent overfitting? Or should the hidden test cases be the (first) tiebreaker?
• Is the implicit requirement "must complete all test cases before you can post it" enough of a bound on long execution times, or should I add a specific execution-time limit?
• I would suggest explaining in what way the draw command is given its path length. – Jonathan Frech Aug 3 '18 at 22:25

Note: this is my first time posting, so I need help fleshing out the details. I'm aware there are plenty of Roman Numeral problems, but this is somewhat different.

# When in Rome, count as Romans do!

This problem is inspired by this website, which published the following diagram: This diagram shows us that the longest Roman Numeral expression under 250 is that of 188, which requires 9 numerals to express.

The standard symbols used to express most Roman Numerals are the following: {I, V, X, L, C, D, M}. In this challenge, your goal is to, given an positive integer n, compute the number of valid Roman Numeral representations that can be composed through concatenating n of the standard symbols.

Then, your program must output the result of this computation modulo 3997 (to prevent answers from getting too long) in Roman Numerals!

# Rules for Roman Numeral Expressions

Roman Numerals originally only had "additive" pairing, meaning that numerals were always written in descending order, and the sum of the values of all the numerals was the value of the number.

Later on, subtractive pairing, the use of placing a smaller numeral in front of a larger in order to subtract the smaller from the larger, became commonplace to shorten Roman Numeral expressions. Subtractive pairs cannot be chained, like the following: IXL. This is considered invalid.

The following are the modern day rules for additive and subtractive pairing.

1. Only one I, X, and C can be used as the leading numeral in part of a subtractive pair.
2. I can only be placed before V and X in a subtractive pair.
3. X can only be placed before L and C in a subtractive pair.
4. C can only be placed before D and M in a subtractive pair.
5. Other than subtractive pairs, numerals must be in descending order
6. M, C, and X cannot be equalled or exceeded by smaller denominations.
7. D, L, and V can each only appear once.
8. Only M can be repeated 4 or more times.

# Test Cases

Input: 1
Output: VII


More to be added.

# Sandbox Users

Thoughts on this problem? I know it is really badly formatted but I thought the concept was cool. Thanks for the help!

• So basically, find how many Roman numbers there are with n numerals? The modulo 3997 is probably not necessary, since the maximum for each n is only 8**n (and valid roman numerals are going to consist of a small fraction of that) – Jo King Aug 8 '18 at 5:54
• Alright, I'll remove the modulo part. Does the rest seem plausible as a concept? – Don Thousand Aug 8 '18 at 12:36
• The reason for my inclusion of the modulus is because I want to ensure the answer can be outputted without using any numerals beyond those I've provided in the Standard Set – Don Thousand Aug 8 '18 at 15:12
• This needs clearer specification on what counts as a valid Roman numeral. E.g. are IC and XCIX both valid expressions for 99? Is MMMMMMMM a valid 8-letter numeral? – Peter Taylor Aug 8 '18 at 16:38
• I added more details to the text. – Don Thousand Aug 8 '18 at 17:10
• Now that you've posted this to the main site, please add a link to the challenge, edit out the body and delete the post. Thank you! – Mr. Xcoder Aug 12 '18 at 11:19

# Most distinct Turing-complete character subsets

(Inspired by Fewest (distinct) characters for Turing Completeness)

## Challenge:

In any language you choose, find the greatest number of distinct and disjoint subsets of characters allowed in that language (i.e. no individual character is in more than one of the subsets), each of which separately makes the language Turing-complete.

## Example:

JS (2): eval()"\u0123456789bcdf, []+= (see answer to linked question).

## Scoring:

Scoring is by total number of distinct Turing-complete subsets found. Higher scores are better. In case of a tie, the answer with the fewest total characters used across all subsets wins.

## Notes:

Execution of arbitrary code is not required, only Turing completeness.

Explanations of why each of your subsets are Turing complete are highly encouraged.

In case this was unclear, whitespace characters are still counted as characters.

## Sandbox notes:

Should I include some stipulation forbidding languages such as Unary which don't care about the particular characters used?
What is unclear about this specification? Where could I give a better/more complete explanation?

• I personally wouldn't exclude unary. I recall a previous challenge attempted to exclude all "symbol-independent" languages and it was almost as much of a mess as attempts to ban builtins. Sure Unary will "win" with a score of 256, but that doesn't mean no interesting answers will be posted. – Kamil Drakari Aug 14 '18 at 18:30
• You’ll need to define if spaces are counted as characters. – JayCe Aug 14 '18 at 20:05
• @JayCe done.⠀⠀⠀ – praosylen Aug 14 '18 at 20:21
• Are you sure you want to use characters instead of bytes? – Jo King Aug 15 '18 at 4:44

# Chain Classification

related

Objective: Write a program (whose index in the chain of answers is $n$) which, when given any program with index $i$ ($1 \le i \le n$), outputs $i$.

(The program may do anything else given any other string input, including but not limited to: crashing, erorring, returning other numbers, sending an email to google support, and simulating the universe.)

## Rules

• Your program may be in any language that has not appeared in the answer chain yet.
• You may output to STDOUT, STDERR, return as a function value, etc. Any reasonable method of output.
• You may take input from STDIN, command line arguments, function parameters, etc. Any reasonable method of input.
• You must output 1 for the first answer, 2 for the second, etc. Any other form of indexing is not allowed.
• You must use base 10 when outputting.
• You may not use the internet in any way, particularly to scrape the answers to this question.
• No person may answer twice in a row.
• No person may answer within 1 hour of their previous answer.
• Languages which differ by version are considered distinct. Thus, Python 2 and Python 3 can both be part of the chain.
• Languages which differ by compiler or interpreter are not considered distinct. So, Python 3 (Cython) and Python 3 are equivalent.

## Answer format

# N. Language

code

explanation


Try It Online links are appreciated, as well as links for the language itself.

You must include how your program performs input and output.

## Meta

The first answer is:

# 1. Alumin

h


Try it online! Input and output through STDIN and STDOUT.

• An answer $a_n$ may also recognize every answer $a_i$, where $1\le i<n$, and, if it doesn't, output $n$. – Erik the Outgolfer Aug 17 '18 at 19:09
• @EriktheOutgolfer Yup. Do I need to edit anything to reflect that? – Conor O'Brien Aug 17 '18 at 19:19
• No, just a note that answers don't need to be generalized quines. – Erik the Outgolfer Aug 17 '18 at 19:20
• @EriktheOutgolfer I'm not sure what would indicate to someone that the answers have to be generalized quines. – Conor O'Brien Aug 17 '18 at 20:11
• This is more like the comments that often appear below challenges for slight hints (usually posted by others). – Erik the Outgolfer Aug 17 '18 at 20:12
• What do the rules 5 and 8 ensure? – ბიმო Aug 19 '18 at 16:23
• @BWO Rule 5 is for clarity; rule 8 is for variety. – Conor O'Brien Aug 21 '18 at 6:27
• Ok, I don't see a point in 5 but I don't have a strong opinion on it either and it doesn't harm the challenge. However rule 8 seems rather arbitrary, for one I don't think it will be more variable if a user is required to wait some 10 minutes before submitting. Even if in the mean-time another user will answer, I don't think it would become more variable: Just because it's the same user doesn't mean it will be nearly the same answer. But that's just my opinion, in the end it's your call. – ბიმო Aug 21 '18 at 14:19

# King of the Grid

There's a side-project of mine, simply titled My Grid Game, that's been sitting on lefttwix.com for a while. It was only a matter of time before it went automatic. The rules of the game are simple:

• Each player plays as a colour.
• Each player starts with a City (C) 2 spaces in from opposite corners.
• Cities spawn soldiers, they start with 10 health.
• Soldiers will all march in the same direction as the other soldiers of the same colour. They will spawn 1 at a time (denoted by the number 1).
• Players can change the direction of their entire army.
• When soldiers can't go any further (either because they reach the edge of the grid or a friendly city), they join each other, to become larger groups of soldiers. (Numbers 2 - 9)
• When 10 soldiers group up, they form a new city.
• When soldiers meet their enemies, they kill off the enemies. The largest group of soldiers survives. (e.g. if a 5 meets a 3, it survives, but is reduced to 2).
• When soldiers meet an enemy city, they reduce the health of that city by the size of the group.
• When cities lose health, it can not be regained.
• When cities or soldiers run out of health, they are destroyed.

## With the API enabled

My experimental API branch is enabled at https://ajfaraday.github.io/grid_game/

The coloured boxes in the grey box correspond to the 2 players.

There's 3 ways to choose a bot for a player:

• Select 'Code on Page' to write the code in place. The game will stop when the code is invalid.
• Choose 'Gist ID' and paste the id of a Github Gist onto the page.
• Select one of the existing bots.

The buttons are self-explanitory.

• Start Start the game running
• Stop Halt the game
• Reset Reset the game with the same bots

The API:

You can interact with the player by making these calls:

• api.towardsX() Change direction horizontally towards the opponent.
• api.awayX() Change direction horizontally away from the opponent.
• api.towardsY() Change direction vertically towards the opponent.
• api.awayY() Change direction vertically away from the opponent.
• api.random_direction() Change to a random direction.
• api.turn() Returns the numbered turn, starting at zero.

Writing a bot:

• Only use the API calls to interact with the game.
• It does not need to be defined as a function or any other wrapping code.
• jQuery is available.
• Your code will be called once every turn.
• Please, only one direction call per iteration.

Example bot:

if (api.turn() < 400) {
if ((api.turn() % 2) == 0) {
api.towardsY();
} else {
api.towardsX();
}
} else {
if ((api.turn() % 20) == 0) {
api.random_direction();
}
}


## The Rules

Answers should include:

• A name for your bot.
• The bot's code.
• A Github Gist ID.

# Practicalities

Note: This is the part I'm least clear about. Please do clear up how this is to be done. I can think of 3 approaches.

(league approach)

For each pair of entries:

• I'll try it against each other entry, best of 3.
• The winner will get a point.
• After a week(?) I'll finalise the results and declare a winner.

(tournament approach)

• After a week(?) I'll set up a tournament bracket with all the entries.
• I'll try a best of 3 for each pair in the tournament.
• The winner wins.

(Challenge the champ approach)

• All entries get added to a list.
• When a new entry is added, it is at the bottom of the list.
• It will then challenge the entry immediately above it (best of 3).
• If it wins, it moves 1 up the list, then challenges the next one and so on.
• After 1 week(?) the tournament closes and the top of the ladder wins.

Questions:

• Which competition approach is best?
• Is the Gist code distribution approach okay?
• How long should the competition last?

Thanks for looking over this!

• Won't new cities only be possible on the edges then? – fəˈnɛtɪk Aug 31 '18 at 21:40
• @fəˈnɛtɪk Not quite, you can also build cities against your existing cities. – AJFaraday Aug 31 '18 at 21:46
• So you should mention that soldiers cannot move over friendly cities – fəˈnɛtɪk Aug 31 '18 at 22:18
• 1. What happens when a soldier hits an opponent's city. 2. What's the number of a spawned soldier? 3. I'd recommend doing a round-robin, randomly pairs, or using an ELO system and having similarly scored players play each other. 4. It seems simpler to me to have the method simply return an integer for the direction (N/E/S/W) than making these API calls. 5. Don't require a gist for bots. 6. Where do cities start? – Nathan Merrill Sep 1 '18 at 3:53
• 7. Does the bot get the state of the map? 8. Are you going to have a maximum number of turns? 9. Despite all my feedback, I really like this challenge. Definitely ping me in chat if you want some help along the way. – Nathan Merrill Sep 1 '18 at 4:07
• @NathanMerrill 1, 2, 6, Edited. 3. Thanks for the suggestions. 4. The relative directions are to accommodate a bot starting in either corner. It will rotate it's strategy. Perhaps both options, if we can find a data structure for the state of the grid. 5. Gists were an idea for quick deployment. You seem strongly against it. What issues does it present? 7. I considered this, but it seems it'll be a large, difficult-to-consume data structure. How would you like to see this data presented? 8. I wasn't planning to, although stale mates are quite common. 9. Glad you like this one! – AJFaraday Sep 1 '18 at 8:34
• 4. Right. I'd propose you simply do NESW, but rotate the map when displaying it to the player (so it appears that both players are on the west side). 5. SE needs to be the authority, gists can disappear, and it's extra work players shouldn't need to do (IMO). 7. You need the map to make this a game of strategy. Give it as a 2D array of {count: 4, isCity: false} objects (or maybe a mixed type array?). 8. Right, you need to somehow detect stalemates (and then score them too) – Nathan Merrill Sep 1 '18 at 12:32

# The Input String, But Every Time It Says The First Word, It's Recursion

You wanted to create the ultimate replacement remix, but didn't see a way to add more recursion that ends naturally. Then you saw The Entire Bee Movie But Every Bee Is Replaced With The Entire Bee Movie Without Bees. Unlike the other replacement remixes, all the inserted copies were from the same text. It was the answer - at each recursing, you could remove the word being replaced, making each copy shorter than the one before it and causing the recursion to eventually end. Your master plan was complete, all that was left was to write the program to fulfill it.

# The Expansion Function

Let's define some function $F$ on a sequence of words. Words are sequences of characters not containing whitespace, which are separated by whitespace.

define $F(S)$:

if $S$ is empty, return nothing

let $X$ be the first word in $S$

let $Y$ be $S$ with all instances of the whole word $X$ removed

let $Z=F(Y)$

return $S$ with all instances of the whole word $X$ replaced by $Z$

Your task is to implement $F$.

# Input

Input the sequence of words in some form. You may choose any input method.

# Output

Output the sequence of words in some form. You may choose any output method.

Only the words in the output count for correctness. If you output as a string, the leading, trailing, and separator whitespace can be anything.

# Scoring

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

# Examples

Small case

Input:

b o o k k e e p e r


Output:

r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r o o k k e e p e r


See the recursion:

Format:

value of S
result of F

r

p r
r

e e p e r
r r p r r

k         k         e e p e r
r r p r r r r p r r e e p e r

o                             o                             k k e e p e r
r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r

b                                                                         o o k k e e p e r
r r p r r r r p r r e e p e r r r p r r r r p r r e e p e r k k e e p e r o o k k e e p e r


Large case

Input:

peter piper picked a peck of pickled peppers a peck of pickled peppers peter piper picked if peter piper picked a peck of pickled peppers wheres the peck of pickled peppers peter piper picked


Output:

218854 words

# Hello Sandbox

This section will not appear when the challenge is posted to the main site.

I can't seem to get the quote Markdown right, it might just be a parser bug where it thinks the quote continues even if there are no >s.

I originally put a description of $F$ as an implementation in pseudocode, but I'm considering finding a more mathematical description which tells you less about how to go about implementing it yourself. Still though, there is a challenge in optimizing this for tiny code.

• I think the title is a bit confusing (as not everyone knows about bee movie or somewhat similar). Maybe "Recursive replacement" a better one? – Shieru Asakoto Sep 10 '18 at 4:37
• Oh btw does "occurrence" means the whole word or being a part of another word is also counted? – Shieru Asakoto Sep 10 '18 at 4:41
• Only a whole word counts. I'll go rewrite that to be more clear. As for the title, you're right that what the challenge is is more important than the inspiration, but I'm not quite sure what wording would be good. I'm thinking something like The Input String, But Every Time It Says This Word, It's Recursion which would state the premise while also referencing the meme. – EPICI Sep 10 '18 at 5:02
• Oh I didn't know about the meme either. The Input blah blah blah would be better for others who don't know about the meme I think, but if you want to retain the meme that's fine. – Shieru Asakoto Sep 10 '18 at 5:05
• The introductory paragraph primes the reader to expect a very different challenge to the one given: firstly because it sets up a scenario of infinite recursion, and secondly because it sets up a scenario where elements of the input are replaced by elements which are not in the input. IMO it would be better to remove that introduction and use it instead for a challenge which implements the scenario described and asks for the nth word in the limit string (although this may be a dupe, so check for that first). – Peter Taylor Sep 10 '18 at 8:15
• I don't follow how the input creates the output. Could you show a step-by-step example of how each level of recursion works? – Beefster Sep 11 '18 at 22:39
• I added more details to the "bookkeeper" example, it should explain where each part is coming from, but it may still be too brief. // As for the misleading introduction, I attempted another rewrite, but I think it may need some more revisions before I get it right. – EPICI Sep 12 '18 at 0:51
• I think that the current I/O rules are just a little too restrictive. I would allow other inputs and outputs than "space delemited string", such as "list of words". – Kamil Drakari Sep 13 '18 at 19:48
• After a bit of thought, I relaxed the IO to allow other formats and methods. I figured you'll have some work to do either way, so I might as well let you choose the methods that result in the least bytes. I'm not too worried about dedicated data structures as an IO format, since that's probably already covered as a common loophole. – EPICI Sep 13 '18 at 22:20

# Triangular snake

You're given a triangular field:

It has 4 ports.

You're also given five different pieces from A to E: Each piece has a little piece of path inside it.

Your basic goal is to build paths between ports. There are some rules:

• Each cell of the field can be occupied by 0 or 1 pieces.
• A port can either point to an empty cell or be an endpoint of a path. That is, this is illegal: • The path starts with a port and ends with a port.
• The path must not be broken up into pieces, i.e. every edge of a piece through which a path goes must not touch an empty cell or a border without a port.

This is an example of a legal path: This path can be represented as "CBEDEAD" or "DAEDEBC".

## Input

There is no input.

## Output

Your ultimate task is to output all the possible paths. Your output must not contain illegal paths. You can output the paths in any readable way. Order, repetitions and letter case don't matter.

• Aren't A en E the same piece? – Kroppeb Sep 17 '18 at 15:12
• Yes they are, what a blunder. – decorator-factory Sep 17 '18 at 15:16
• It's sad you can only post comments with 50 reputation, otherwise I would have noticed that already :) – decorator-factory Sep 17 '18 at 15:16
• @int6h Out of interest ... What is the connection? – Jonathan Frech Sep 18 '18 at 21:12

# Iterated Prisoner's Trilemma

Please send me problems or else I'm gonna post this on main.

Prisoner's dilemma ... with three choices. Crazy, huh?

Here's our payoff matrix. Player A on the left, B on the top

A,B| C | N | D
---|---|---|---
C |3,3|4,1|0,5
N |1,4|2,2|3,2
D |5,0|2,3|1,1


The payoff matrix is engineered so that it's best for both players to always cooperate, but you can gain (usually) by choosing Neutral or Defection.

Here's some (competing) example bots.

# turns out if you don't actually have to implement __init__(). TIL.

class AllC:
def round(self, _): return "C"
class AllN:
def round(self, _): return "N"
class AllD:
def round(self, _): return "D"
class RandomBot:
def round(self, _): return random.choice(["C", "N", "D"])

class Grudger:
def __init__(self):
self.history = []
def round(self, last):
if(last):
self.history.append(last)
if(self.history.count("D") > 0):
return "D"
return "C"

class TitForTat:
def round(self, last):
if(last == "D"):
return "D"
return "C"


Your bot is a Python3 class. A new instance is created for every game, and round() is called each round, with your opponent's choice from last round (or None, if it's the first round)

If we get enough entries for the result to be statistically significant, there's a 50 rep bounty for anyone who can beat Tit For Tat.

## Specifics

• Round count: [REDACTED]
• Standard loopholes disallowed.
• No messing with anything outside your class.
• I have no idea how to embed tags in a post. – SIGSTACKFAULT Sep 28 '18 at 15:56
• [tag:something] should do the trick. – Alion Sep 28 '18 at 16:24
• thanks @Alion <3 – SIGSTACKFAULT Sep 28 '18 at 16:28
• Way too little substance. You should add a few paragraphs describing the prisoner's trilemma, the challenge, or anything else tangentially related. – RamenChef Sep 29 '18 at 0:22
• Don't do a pretty payoff matrix image. Use text. That way you don't exclude people with limited vision who rely on screen readers. – Peter Taylor Oct 1 '18 at 15:09
• How many rounds per game? And why does N/N suck so much? – Jo King Oct 10 '18 at 8:13
• @JoKing Haven't decided the round count, and probably will never tell. Don't want defect-on-the-last-round bots. No idea why I did that; if it causes problems i'll change it. – SIGSTACKFAULT Oct 10 '18 at 12:33
• Maybe a random amount of rounds within a certain range? Also, wouldn't it be better for the second argument to be a list of all your opponents moves, rather than the latest one? – Jo King Oct 10 '18 at 12:42
• You can do watever you want within the class, so if you need to remember the entire history, that's your problem. – SIGSTACKFAULT Oct 10 '18 at 12:45

## Posted: Find an array that fits a set of sums

• I'd recommend showing the steps to generating f(A) (show each of the subarrays, then calculate their sums) – Nathan Merrill Oct 16 '18 at 21:29
• The last requirement: "any way that is convenient to you" is abusable, and basically removes the requirement entirely. Either guarantee that there will be a solution, or require that submissions return a constant value (and add a test for it) – Nathan Merrill Oct 16 '18 at 21:31
• @NathanMerrill I don't get this last point. Maybe I should ask them to return a Falsy value? – user9207 Oct 16 '18 at 21:33
• Now that this has been posted you can delete it to make it easier for people to skip past it. – Peter Taylor Oct 24 '18 at 10:10

Posted

## Find the minimal initial values

Consider a sequence F of positive integers where F(n) = F(n-1) + F(n-2) for n >= 2. The Fibonacci sequence is one example of this type of sequence for F(0) = F(1) = 1, but any two initial values will yield a different sequence. For example F(0) = 3, F(1) = 1 produces these terms.

3, 1, 4, 5, 9, 14, 23, 37, 60, 97, ...


### Challenge

The task is to find F(0) and F(1) that minimize F(0) + F(1) given some term of a sequence F(n). Write a function or complete program to complete the task.

### Input

Input is a single positive integer, F(n). It may be accepted as a parameter or from standard input. Any reasonable representation is allowed, including direct integer or string representations.

Invalid inputs need not be considered.

### Output

The output will be two positive integers, F(0) and F(1). Any reasonable format is acceptable. Here are some examples of reasonable formats.

• Written on separate lines to standard output
• Formatted on standard output as a delimited 2-element list
• Returned as a tuple or 2-element array of integers from a function

### Examples

60  -> [3, 1]
37  -> [3, 1]
13  -> [1, 1]
26  -> [2, 2]
4   -> [2, 1]
5   -> [1, 1]
6   -> [2, 2]
7   -> [2, 1]
12  -> [3, 2]
1   -> [1, 1]


### Scoring

This is code golf. The score is calculated by bytes of source code.

• Related :-) – ETHproductions Oct 29 '18 at 18:37
• @ETHproductions: I haven't seen that one before, and the domain is basically identical. But I still think the challenge is sufficiently distinct, since it's an optimization problem as opposed to straight forward sequence generation. – recursive Oct 29 '18 at 18:58
• @nwellnhof: That was an oversight. I fixed it and added some examples explicitly showing F(0) > F(1). – recursive Oct 29 '18 at 20:26
• Spec seems watertight to me. – trichoplax Oct 29 '18 at 20:31
• In general, if m<n, you can always replace [m,n] with [n-m,m] for a better solution, so F(0) >= F(1) for all optimal solutions. – nwellnhof Oct 29 '18 at 20:50
• @nwellnhof: Yes, I see now. I've adjusted more of the test cases, and am considering removing the part about ambiguous solutions if it's irrelevant. I don't have any examples then where there multiple distinct optimal solutions. It kind of feels like that can't happen, but I don't have a proof to that effect. If I can sufficiently convince myself it is impossible, I'll remove the part about ambiguous solutions. – recursive Oct 29 '18 at 21:03
• I believe I came up with a proof of uniqueness. I think it may not fit in a comment well, but the basic idea is to write any one of these sequences as s_k = f_k-2 s_21 + f_k-1 s_2 where f_k is the sequence starting with 1, 0 at k = -1, 0 instead of the usual indices. Then it is pretty clear that if two distinct sequences reached the same value at the same index, they must differ from each other by a constant times a ratio of two consecutive Fibonacci numbers. This is only an integer for the pair 1,1 and all such ambiguities are handled by you excluding 0 as a starting value. – FryAmTheEggman Oct 30 '18 at 0:15
• @FryAmTheEggman: I removed the part about ambiguous solutions. I'm not following your proof outline at the moment, but I'll take your word for it. :) – recursive Oct 30 '18 at 0:24
• I was bored so here's the full thing. I wound up changing some stuff around so hopefully it is easier to follow. Obviously I could have messed up so if anyone notices anything wrong let me know! – FryAmTheEggman Oct 30 '18 at 2:40

# Implement LogiMuxi code-golfinterpreter

## The language

LogiMuxi is, as its name suggests, a programming language based on multiplexers.

### Built-in gates

• M(A,B,C) (Multiplexer): If A is 0, returns is B, otherwise returns C.
• R() (Random): Returns either 0 or 1 uniformly randomly.
• I() (Input): Reads a bit from STDIN and returns it. Terminates program execution on EOF.
• O(A) (Output): Appends bit A to STDOUT and returns it.

### Literals

0, 1 are literals. Literals are expressions, and can be used as values.

### Gate calling

G(<arg1>,<arg2>,...,<argx>) calls gate G with the provided arguments in order. Gate calling is an expression.

### Conditional loop

G
<cmd1>
<cmd2>
<...>
<cmdx>


Evaluates G. If G returns 1, the indented commands are executed, and this process repeats again. If G returns 0, the loop is skipped. If there are no indented commands under G, the loop is empty, and, therefore, if G is 0 then nothing happens, while if G is 1 we enter an infinite loop with no way out.

### Value assignment

X=G


Assigns X to the result of G. After that, the identifier of the variable can be used as an expression, and it will evaluate to the current value of the variable.

### Gate definition

G(<arg1>,<arg2>,...,<argx>)
<cmd1>
<cmd2>
<...>
<cmdx>


Defines gate G to take arguments <arg1> up to <argx> (actual argument identifiers are specified by the programmer) and return the result of H. The identifiers of the arguments are localized, as well as variables assigned inside the gate. This means that, if I assign variable X to value A outside of G and then there's an X=B command in the definition of G, calling G will not assign X to B. However, inside the gate's scope, X will take the new value B. Assigning the arguments themselves to new values is allowed. Example:

X=0
G(A,B)
X=1
O(X)
:M(R(),A,B)
O(X)


This will output the bits 1 and 0 in order. For reference, G chooses randomly between A and B in this example.

Gate definitons may also be nested, in which case they will be localized too.

Returning happens by prepending a : (colon) to a value (e.g. to return value A, use command :A). This will exit the gate and return the value to the right of it. You can't leave the part to the right of : empty. A gate that doesn't return is invalid.

### Additional notes

• Commands are separated by line separators.
• An identifier has to meet these criteria:
• The first character has to be in ABCDEFGHIJKLMNOPQRSTUVWXYZ_
• From the second character onward, the identifier must only be composed of characters in ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_.
• It can't be the identifier of any of the built-in gates.
• A variable and a gate may use the same identifier. They can be separated by the way they are invoked. Of course, this is bad practice, but this language is already pretty esoteric. ;-)
• Use of an undefined identifier is invalid.
• A gate is always to be called with parentheses, even if it doesn't take arguments. This includes the built-in gates.
• A gate may only return one output, and it must return one.
• Nested loops or gates are represented with the appropriate number of spaces used as indentation.
• Useless indentation is prohibited.
• Lines may be empty, but their indentation is significant. Empty lines do nothing.
• Calling gates with the wrong number of arguments is invalid.
• If the number of bits sent to STDOUT isn't a multiple of 8, the bits are post-padded with 0s (e.g. if STDOUT is 00010000 11100, it will be converted to 00010000 11100000 before actual printing).
• If 8 bits have been sent to STDOUT, they will be converted to a character and output immediately.
• Any syntax not defined above should be considered undefined.

### Reference gates

You may skip this section.

NOT:

NOT(A)
:M(A,1,0)


AND:

AND(A,B)
:M(A,0,B)


OR:

OR(A,B)
:M(A,B,1)


XOR:

XOR(A,B)
:M(A,B,M(B,1,0))


NAND:

NAND(A,B)
:M(A,1,M(B,1,0))


NOR:

NOR(A,B)
:M(A,M(B,1,0),0)


XNOR:

XNOR(A,B)
:M(A,M(B,1,0),B)


### Simplification tips

You may skip this section.

M(A,0,1)A

M(M(A,1,0),B,C)M(A,C,B)

M(0,B,C)B

M(1,B,C)C

### Sample programs

You may skip this section.

Infinite loop, no output:

1


Cat:

1
O(I())


Hello, World!:

O(0)
O(1)
O(0)
O(0)
O(1)
O(0)
O(0)
O(0)
O(0)
O(1)
O(1)
O(0)
O(0)
O(1)
O(0)
O(1)
O(0)
O(1)
O(1)
O(0)
O(1)
O(1)
O(0)
O(0)
O(0)
O(1)
O(1)
O(0)
O(1)
O(1)
O(0)
O(0)
O(0)
O(1)
O(1)
O(0)
O(1)
O(1)
O(1)
O(1)
O(0)
O(0)
O(1)
O(0)
O(1)
O(1)
O(0)
O(0)
O(0)
O(0)
O(1)
O(0)
O(0)
O(0)
O(0)
O(0)
O(0)
O(1)
O(0)
O(1)
O(0)
O(1)
O(1)
O(1)
O(0)
O(1)
O(1)
O(0)
O(1)
O(1)
O(1)
O(1)
O(0)
O(1)
O(1)
O(1)
O(0)
O(0)
O(1)
O(0)
O(0)
O(1)
O(1)
O(0)
O(1)
O(1)
O(0)
O(0)
O(0)
O(1)
O(1)
O(0)
O(0)
O(1)
O(0)
O(0)
O(0)
O(0)
O(1)
O(0)
O(0)
O(0)
O(0)
O(1)


1-bit half adder:

A=I()
B=I()
O(M(A,0,B))
O(M(A,B,M(B,1,0)))


## Challenge rules

• You may assume you'll not receive an invalid program, or a program with input that will make it do invalid actions, so you don't need to check it for validity.
• The program can be either separated by line separators, or given as a list of lines. Acceptable line separators are \n, \r\n and \r (\n denotes character 0x0A, \r denotes character 0x0D).
• Input can be taken in any reasonable form explicitly separated from the program, not necessarily from STDIN. Also, it can either be the actual input, or its bits (e.g. you can take 0100000001000001 instead of @A). It's guaranteed to be finite for this challenge.
• Output can be provided in any reasonable form, either as bits or as text. Also, you don't actually need to output while the program is executing, unlike what the specification above says.
• You may use any four distinct identifiers for the built-in gates M, R, I and O. Identifier rules will apply to your chosen identifiers in this case.
• You may use [] instead of (), and/or tabs instead of spaces in indentation. You must be consistent with these choices.

# Sock Drawer Simulator

Socks are often kept in drawers, and when people wear socks they like the left and right socks to match [citation needed].

## Challenge

Given an array of the number of socks of each color, simulate the process of drawing socks, and output the color of the first pair found. You may assume that:

• Socks are drawn sequentially, randomly and without replacement.
• A pair is found when a sock of a color that has already been drawn is drawn.

Obviously, the precise algorithm doesn't matter as long as the output probability distribution is correct.

## Input

A nonempty array of positive integers representing the frequency of each color of sock. For example, [3,1,4,1,5] could represent a drawer with three teal, one aquamarine, four green, one cyan, and five cerulean socks. There will always be at least one possible pair.

## Output

A nonnegative integer representing the color (index) of the sock drawn. You may consistently use either one-indexed or zero-indexed arrays.

# Survival Game: Alien Hunters (working title)

Based on Create Your Wolf, but the combat is very different.

Somewhere, deep in the heart of the galaxy, lies the planet Oizys. A toroidal planet in the habitable zone of its star, its bountiful land and beautiful oceans make it the perfect planet for your race of aliens to start colonizing as an interstellar civilization.

Unfortunately, a few dozen other alien races are also trying to colonize it, and you can't stand them. So you're going to have to kill them.

# Your Alien

Your task is to write an implementation of the net.ramenchef.oizys.Alien class:

package net.ramenchef.oizys;

public class Alien {
public enum Move {
// a whole bunch of values; these are described in "the board"
}

/**
* Used by the runner to keep track of the alien's energy.
*/
double energy = 1.0;

/**
* Moves the alien.
*
* @param surroundings The alien's surroundings. The first
*  dimension is North–South, with index 0 being North. The second
*  dimension is East–West, with index 0 being West.
* @return A {@code Move} object representing the direction to
*  move the alien
*/
public abstract Move move(char[][] surroundings);

/**
* Called when the alien is in battle.
*
* @param opponents The other aliens on this tile that need to be
*  fought
* @return The amount of energy to use in this battle
*/
public abstract double attack(char[] opponents);
}


100 instances of your class will be spawned in random locations on the board for each trial. Each alien class will be assigned a unique character to represent them on the board.

There are a number of stock alien races that already inhabit Oizys:

• Rocks: they do absolutely nothing and don't pose any sort of threat (i.e., they attack with 0 energy), but for some reason your generals don't know what rocks are, so they appear just like any other alien.
• Random Bears: they act randomly. They move in a random direction (including possibly not moving at all) and attack using a random portion of their energy.

# The Board

Oizys is a toroidal planet, so the board will be side-looped on both edges. The width and height of the board will be equal to $$\\left\lceil\sqrt s\right\rceil\$$, where s is the number of alien species. Each round, your aliens will have the option to move one tile horizontally and/or vertically with the move method. This method takes a 3x3 char[][] representing the alien's surroundings, with a being Northwest and a being Northeast, and returns a Move enum. The possible Move values are NORTHWEST, NORTH, NORTHEAST, WEST, HOLD, EAST, SOUTHWEST, SOUTH, and SOUTHEAST.

# Combat

If two or more aliens attempt to move into the same tile, they will fight. What better opportunity to kill those annoying other aliens! Or maybe get killed yourself, who knows? Each alien starts with 1 energy, and uses it to fight other aliens. When aliens fight, they use the attack method, which takes a char[] representing their opponents and returns a double, to determine how much energy they will use for that battle. The alien that uses the most energy wins, and the others die. In the case of a tie, the winner is determined by coin flip. An alien cannot use more energy than it has or it will die; neither can it use a negative amount of energy.

# Scoring

Five trials will be held, with each trial being scored by the portion of the aliens remaining that are your alien. These trials will be held on [1 month after the challenge is posted].

# Other Rules

• Standard loopholes are forbidden.
• Aliens attempting to alter field visibility/writability will be met with mysterious SecurityExceptions.
• The order that aliens' methods are called is undefined, though there is a happens-before relationship between calls on successive rounds, as well as between aliens moving and those same aliens attacking each other.
• How do the aliens get energy? What is the energy limit mentioned in the description of the dragon? – Laikoni Apr 12 '18 at 8:54
• @Laikoni the dragons have unlimited energy, and the rest of the aliens start with all the energy they'll get. – RamenChef Apr 12 '18 at 12:08
• So the energy is a floating point number? Doesn't that cause potentially more trouble than just saying it's initially 100 and using ints? – Laikoni Apr 12 '18 at 12:35
• @Laikoni how would using a floating point be a bad idea? – RamenChef Apr 12 '18 at 12:57
• Testing for equality of floating point numbers can give imprecise results, see e.g. en.wikipedia.org/wiki/… – Laikoni Apr 12 '18 at 13:44
• @Laikoni it's not testing for equality; it's comparing them. Whereas ints would not allow bots to divide their energy successively ad infinitum. – RamenChef Apr 16 '18 at 16:51
• 1. You should disallow all reflection. 2. You need to run way more than 5 trials to get a good answer. 3. How are trial scores combined? What's the char for nothing? 4. You should add a helper method to get their own energy, as well as their own character. 5. I'd argue for int energy that is simply really high (like the maximum int or even maximum long). Then you don't deal with floating point imprecision, and will even improve calculation speed. 6. What happens when something attacks a rock? What does the rock return? – Nathan Merrill Apr 18 '18 at 14:52
• 7. If I lose a battle, do I lose energy, or do I instantly die? 8. Re Dragons: I see two primary issues: The attack is so high to make fighting them pretty impractical. It's possible to identify them based off of their movement, but your field of vision is very small. If vision is bigger, then bots will learn to avoid them, but now many bots will start to imitate dragons. In essence, making dragons so strong changes the balance of the game drastically. Consider if that is really what you want. 9. Do you allow communication between instances of the same bot? What about different bots? – Nathan Merrill Apr 18 '18 at 14:57
• @NathanMerrill 1) Why go beyond installing a SecurityManager? 2) The winner usually won't be determined by luck alone. 3) They're averaged. (will add this to the spec) 4) I had one for energy in the runner, but I forgot to document it. 5) ints can't go to 10^-300. 6) The rock returns 0. 7) You die instantly. The winner loses energy. 8) Noted. 9) Yes. Hiveminds are allowed. – RamenChef Apr 18 '18 at 23:46
• 1) Because KotHs shouldn't be about the language, they should be about the core game rules. The instant you bring in reflection, you get in the world of one-upping: No matter how good my bot is, it can be one-upped. 2) Really? As of right now, I don't see any reason why not. Your starting position has a huge affect on how well you do. 3) Note that this means that winning by a large margin on a few games means more than consistently winning by a little. (This isn't bad, but its worth considering). 5)Ok? You don't need that much precision. 6,7,8) Please add to spec :) – Nathan Merrill Apr 19 '18 at 2:46
• The aliens won't be given the classes of their opponents; only their character. If they want to keep pets of their opponents (like MultiWolf) I won't stop them – RamenChef Apr 19 '18 at 11:57
• @RamenChef fair enough, but MultiWolf does't require reflection. He could simply have a function that builds the array by calling their constructors normally. – Nathan Merrill Apr 19 '18 at 15:03
• @NathanMerrill Reflection is more streamlined though. – RamenChef Nov 21 '18 at 16:23
• I'd love to see this make it to the main site. You can use something like this to open up the competition to other languages, but be warned, you may end up spending quite a few hair-pulling hours trying to get other people's code to work on your machine. I'll be the third to comment that using integers would be better. You commented that you won't be testing for equality but in the challenge spec you mention handling ties. How are multi-way ties handled? Maybe change "determined by coin flip" to "chosen at random". – Rainbolt May 22 '19 at 23:27
• Maybe I missed it, but what char represents an empty square? – Rainbolt May 22 '19 at 23:27

# Count smooth numbers

Define $$\\Psi(x,B)\$$ as the number of integers between $$\1\$$ and $$\x\$$, whose prime factors are all $$\B\$$ or less. (These are the $$\B\$$-smooth numbers.)

For example, there are 34 integers between 1 and 100 that have only 2, 3 and 5 as prime factors. These are:

 1  2  3  4  5  6  8  9 10 12
15 16 18 20 24 25 27 30 32 36
40 45 48 50 54 60 64 72 75 80
81 90 96 100


Therefore, $$\\Psi(100,5)=34\$$. The next prime is 7, so $$\\Psi(100,6)\$$ is also 34.

This is a challenge to calculate exact values of $$\\Psi\$$ as quickly as possible.

## Methods

You may not use libraries or built-ins that calculate this function. That being said, I don't know any language that has a built-in for this (not even Mathematica?)

I also can't seem to find any fast algorithms for this problem, except for a basic meet-in-the-middle by Daniel J. Bernstein which might be a good starting point.

Bernstein also describes an approximation method that may or may not be useful.

## Input range

You may assume that $$\1 and $$\B<10^6\$$.

## Scoring

You will be scored on tiers of increasing difficulty.

Each tier has several inputs $$\(x,B)\$$ such that the $$\\Psi(x,B)\$$ have similar values, and the $$\x\$$ values are distributed exponentially. Tiers will start at around $$\\Psi(x,B)\approx 10^9\$$ and go up to $$\\Psi(x,B)\approx 10^{20}\$$ or more, depending on how fast the entries get.

The time limit for each tier is 60 CPU seconds per input on average. In other words, if a tier has $$\n\$$ inputs, you will essentially have $$\n\$$ CPU minutes to obtain the outputs. You are welcome to submit parallel code but each thread will count towards the time limit.

Your score is the highest tier that your program can solve. If there is a tie, the program that is fastest on the highest tier wins.

For practical reasons, your program will be limited to 15GiB of memory.

## Sample tiers

Warm-ups:

3:
Ψ(10^3, 997) = 1000
Ψ(10^6, 7)   = 1273
Ψ(10^9, 5)   = 1530
6:
Ψ(10^6,  999983) = 1000000
Ψ(10^9,  59)     = 1060717
Ψ(10^12, 29)     = 1469549
Ψ(10^15, 17)     =  919814
Ψ(10^36, 7)      =  936046


Tiers:

9:
Ψ(10^9,  999983) =  616220853
Ψ(10^10, 4567)   =  954965955
Ψ(10^12, 337)    = 1180049403
Ψ(10^15, 97)     = 1016358704
Ψ(10^18, 59)     = 1106651678
Ψ(10^24, 31)     =  791377032
Ψ(10^30, 23)     =  812060729
Ψ(10^48, 17)     = 1435897064
10:
Ψ(10^11, 11987) = 10016301575
Ψ(10^12, 1499)  = 10753426440
Ψ(10^15, 199)   = 12766644440
Ψ(10^18, 89)    =  9052115006
Ψ(10^24, 47)    = 11298682134
Ψ(10^30, 37)    = 14838208717
Ψ(10^48, 19)    =  7868307089
11:
Ψ(10^13, 2297) =  84344528150
Ψ(10^15, 443)  =  96272828440
Ψ(10^18, 163)  = 107816435926
Ψ(10^36, 37)   =  94053521936
Ψ(10^24, 67)   =  81421195505
Ψ(10^48, 29)   = 151266342065


etc.

I may choose to do the actual scoring on different inputs, including using $$\x\$$'s that are not powers of 10.

# Squish these Numbers

META: I think my wording is not very clear, if you have a suggestion to make it easier to understand, feel free add a commment or edit it directly in to this post.

Given a finite sequence of real floating point numbers, map it into the Interval $$\[-1,1]\$$, such that the order of these numbers is preserved.

### Details

• You can choose any mapping you like, it doesn't have to be linear.
• The mapping you choose doesn't have to stem from a function, that means some number $$\x\in \mathbb R\$$ doesn't have to get mapped to the same number in $$\[-1,1]\$$, the value it does get mapped to can change depending on the other values in the input list.
• Two equal values in the input list, should remain equal in the output.
• If some value in the input list is strictly smaller than some other value, then the corresponding values in the output should satisfy the same relation, in theory. In practice it might happend that two different numbers will get mapped to the same output due to floating point arithmetic issues, which is fine - as long as it would work with an arbitrary precision.
• You can assume the input sequence contains at least two distinct entries.

### Examples

Following example finds a linear map that maps the least entry to $$\-1\$$ and the greatest entry to $$\1\$$. Note how this map depends on the sequence.

$$(x_1,x_2,\ldots,x_n) \mapsto \left( \frac{x_i - \min_k x_k}{\max_k x_k - \min_k x_k} \right)_{i=1}^n$$

Following example is a fixed function that always behave the same. Because it is monotonic and strictly increasing, it satisfies all conditions. $$(x_i)_{i=1}^n \mapsto \left(\frac{\arctan(x_i)}{\pi} \right)_{i=1}^n$$

Thanks @PeterTaylor for following example. Here $$\\operatorname{sort}(x)\$$ sorts the input sequence in ascending order and $$\\operatorname{indexof}(u,v)\$$ returns the index of the first occurence of $$\v\$$ in the sequence $$\u\$$.

$$(x_i)_{i=1}^n \mapsto \left( \frac{1}{n} \operatorname{indexof}(\operatorname{sort}(x),x_i)\right)_{i=1}^n$$

• How about a function which sorts the array and then maps $x_i \to \frac1n \textrm{indexof}(\textrm{sorted}(x), x_i)$? – Peter Taylor Dec 18 '18 at 14:59
• Yeah that looks fine (assuming for e.g. $x_1 = x_2$ we get the same index). - If you do not mind I'll add that as an example too. – flawr Dec 18 '18 at 17:22
• I think many languages have builtin tanh which trivializes this. Are you sure there are enough languages where this challenge is interesting? – lirtosiast Dec 19 '18 at 0:40
• I expect it will be hard for a list-aware function to beat a general mapping like x->1+1/(1+2**-x), or just tanh if that's available, but maybe Peter Taylor's method will be shorter in golfing languages. I think it's worth noting in the spec that it's OK if due to float inaccuracies two very close values are mapped to the same value in practice. – xnor Dec 19 '18 at 0:42
• @xnor I'll add the comment about the floating point problems, that is a good point. I'm convinced that there will be a lot of different approach that will be optimal in the different languages. – flawr Dec 19 '18 at 9:16

# Shortest JsFuck code for a number

JsFuck is a language using only []()!+ to run and express anything in JavaScript. Below is a simplified model of JavaScript to express numbers:

• Types
1. Number
2. String
3. Boolean (true)
4. Array
• Functions
• IEEEdouble(x):
• Let $$\u\$$ is the number in $$\\{a\cdot 2^{b}|-2^{53}-1075, a,b\in \mathbb Z\}\$$ nearest to x, maximizing $$\b\$$ on tie
• If $$\|u|<2^{1024}\$$, return $$\u\$$
• toNumber(x):
• If x is a Number, return x;
• If x is a Boolean, return 1;
• If x is an Array [y], return toNumber(y);
• If x is an Array [], return 0;
• Otherwise, x is a String. In this case,
• If x matches /^([\+\-]?(?:\d*\.?\d+|\d+\.))(?:e([\+\-]?\d+)?$/, let $$\v=\text{＄1}\times 10^\text{＄2}\$$ ($2 is zero if not present)
• Return IEEEdouble($$\v\$$)
• toString(x):
• If x is a String, return x;
• If x is a Boolean, return 'true';
• If x is an Array [y], return toString(y);
• If x is an Array [], return '';
• Otherwise, x is a Number. In this case,
• Find $$\p, q\in \mathbb Z\$$ such that IEEEdouble($$\p\times 10^q\$$)=x, maximizing $$\q\$$(there may be multiple $$\p\$$ satisfying the restriction, in which case choosing which one is unknown);
• Let $$\y=p\times 10^q\$$;
• If $$\y=0\$$ or $$\10^{-6}\leq|y|<10^{21}\$$, write it normally without scientific notation mapping the RegEx /^([1-9]\d*|0)(\.\d*[1-9])?$/; • Otherwise, write it in scientific notation mapping the RegEx /^[1-9](\.\d*[1-9])?e[\+\-][1-9]\d*$/
• x+y
• If either x or y is a String or an Array, return toString(x) concatted with toString(y);
• Otherwise, return IEEEdouble(the sum of toNumber(x) and toNumber(y))
• +x
• Return toNumber(x)
• [] and [x]
• Return an Array.
• x[y]
• If x is a String, return the yth character(0-index) in x
• !![] and !+[]
• Return a Boolean

A valid JsFuck code is always parenthesis balanced without two symbols + together. Expression in parenthesis is calculated before the one out. On the same layer operations go from left to right.

You are required to output the shortest JsFuck code that generates a given IEEE double (A possible output of IEEEdouble). Shortest generator wins.

It's fine if your generator runs slow, but beware of potential infinite loop if you eval.

# Samples

1     -> +!![]
2     -> !![]+!![]
10    -> +[+!+[]+[+[]]]
1e10  -> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))
0.1   -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+!![]))
1e-10 -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))
5e-324-> +(!![]+!![]+!![]+(!![]+[])[!![]+!![]+!![]]+(+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(!![]+!![]+!![])+(!![]+!![])+(!![]+!![]+!![]+!![]))
9999999999
-> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))+(+((+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(+!![])))


SN: Another way to ask is requiring to be testable and shouldn't be longer than a chosen generator

• Challenge seems a bit too long-- maybe restrict the domain to integers? Also I can't see any competitive solution actually finishing for nontrivial test cases because they'd just eval all valid JSFuck strings in parallel. – lirtosiast Jan 6 '19 at 3:41
• @lirtosiast Do your "integer" mean safe integer? Also I don't see how it simplifies the problem much – l4m2 Jan 6 '19 at 7:30

# Is it shifted?

Consider a standard US-International QWERTY keyboard, without a numeric keypad, and Caps Lock mysteriously missing.

< insert image >

The goal is to write two programs or functions that take no input, and each give a distinct output through any default output method: Shift and No shift respectively. The program that outputs No shift has to be written without use of the ⇧ Shift key. The program that outputs Shift has to be written while holding the ⇧ Shift key throughout. Both programs have to be written using the exact same sequence of keypresses. A valid entry would be a1b2 + A!B@, if they output No shift and Shift respectively.

The symbols allowed for the "No-shift" program are as follows:

1234567890-=
qwertyuiop[]\
asdfghjkl;'
zxcvbnm,./
<space> <newline> <tab>


The symbols allowed for the "Shift" program are as follows:

~!@#$%^&*()_+ QWERTYUIOP{}| ASDFGHJKL:" ZXCVBNM<>? <space> <newline>  Note that Tab ↹ is missing, since Shift+Tab ↹ does not produce a \t tab symbol in most editors. ### Sandbox note I think using case-sensitive output makes the challenge more challenging, but it might become too challenging. What are your thoughts? • This already appears to be impossible in most productive languages, so I would allow output in any case. – Laikoni Jan 13 '19 at 8:53 # Touch-typing distance Tags: , Related: Levenshtein distance There are many different string metrics, a simple one is the Levenshtein distance given by $$\\texttt{ld}_{a,b}(|a|,|b|)\$$: $$\texttt{ld}_{a,b}(i,j) = \begin{cases} \max(i,j), & \text{if i = 0 or j = 0} \\ \\ \min \begin{cases} \texttt{ld}_{a,b}(i-1,j) + c_\text{deletion} \\ \texttt{ld}_{a,b}(i,j-1) + c_\text{insertion} \\ \texttt{ld}_{a,b}(i-1,j-1) + w(a_i, b_j) \end{cases}, & \text{otherwise} \end{cases}$$ The avid reader may have noticed that there are missing pieces in the above definition, it makes use of a weight function $$\w\$$ which was never defined and the costs $$\c_\text{deletion}\$$ as well as $$\c_\text{insertion}\$$. The Levenshtein distance uses an indicator function which evaluates to $$\1\$$ if the two characters are not equal and $$\0\$$ otherwise and costs $$\1\$$ for deletion and insertion. This does not take into account that a mistake of typing u instead of w should cost more than mistakenly typing an e. Let's try to fix this! ## Challenge For this challenge we'll assume a QWERTY keyboard and only take lower-case letters into account. We will use the usual letter-to-finger assignment (left-most finger to right-most) ["qaz","wsx","edc","rtfgvb","yuhjnm","ik","ol","p"]: ### Left Hand • pinky: qaz • ring finger: wsx • middle finger: edc • index finger: rtfgvb ### Right Hand • index finger: yuhjnm • middle finger: ik • ring finger: ol • pinky: p Now, to define a new string metric we will use the following definitions in the above generalized Levenshtein distance: Set $$\c_\text{deletion} = c_\text{insertion} = 8\$$ and for $$\w(a_i,b_j)\$$ we will use the distance of the two characters plus $$\1\$$ according to the above assignments (unless they are equal, then we'll use $$\0\$$). Here are a few examples: 'q' 'q' -> 0 'q' 'a' -> 1 'q' 'w' -> 2 'l' 'g' -> 4 'p' 'a' -> 8  ## Rules Input will be two strings $$\a\$$ and $$\b\$$ which • are non-empty • only contain lower-case letters (ie. match ^[a-z]+$)

Output will be the "touch-typing distance" as defined above.

## Test cases

"todo" "todo" → 0


# Shift right by half a bit code-golfmathnumberarithmetic

The challenge is to implement a program or function (subsequently referred to as "program") that takes a nonnegative integer $$\n\$$ as input and returns $$\n\over\sqrt{2}\$$ (the input divided by the square root of two) as output, rounded to a nonnegative integer.

You may take your input and output in any reasonable format; for example stdin/stdout, files, or arguments/return values would all be acceptable.

You are required to use, at minimum, the largest fixed-size integer type offered by your language, and if an unsigned variant of this is available, you must use it. If your language has no built-in integer type (e.g. JavaScript) you are allowed to use its default numerical type (e.g. floating point); for languages with no concept of a number (e.g. regex), input and output can be e.g. the length of a string.

It is not required to reject negative integers; a submission that returns correct answers for negative inputs is allowed, but not required. Undefined behavior with negative inputs is allowed.

You are allowed and encouraged to use arbitrary-precision integer types if you so desire, but the type must either be a built-in, part of a standard library, or implemented from scratch in your program.

Despite what the title might imply, you may use any rounding algorithm you want (floor, ceiling, nearest half up, nearest half even, arbitrary, or even random), as long as the difference between the integer returned value and the theoretical exact (irrational) value is always less than $$\1\$$ for all inputs that fit in your chosen integer type. All inputs up to the maximum representable value must return a correct output.

In a way, the job of this program is to calculate the irrational number $$\\sqrt{2}\$$ to the requested precision, presenting it in the form of an integer. This is why solutions using arbitrary-precision types are encouraged, but not required.

This is a challenge. Standard loopholes are denied. The program with the least number of bytes wins. If there's a tie, the choice of accepted answer will be at my discretion. That said, this challenge is not only about which answer wins; it's also about seeing how concisely the challenge can be solved in each language, and seeing how each language "prefers" to handle rounding. And for those submissions that choose to use arbitrary precision, it's about seeing how concisely this can be done in the language.

# Meta

The primary reason for the question is that I want to post my ECMAScript regex solving it. Currently all I have is an 849 byte (very heavily golfed down from an initial 1159 bytes) ECMAScript + molecular lookahead regex, i.e. not purely ECMAScript-compatible and only works on my regex engine, so this question can stew in the Sandbox for a while until I port the regex to pure ECMAScript at some point, and/or put the regex engine on TIO.

That said, I am genuinely interested in what submissions PPCGers will come up with for this challenge (including in the languages more frequently seen in PPCG posts), and will treat the hosting of it seriously. Also there's the chance that someone will attempt solving it in a more powerful regex flavor, and I'd be fascinated to see if this could be done in significantly less length than ECMA (I actually doubt it can). Or somebody could come up with a crazy solution for it in some other language that has limits imposed which make it hard to do.

And if somebody could think of a way to solve it in ECMA in fewer bytes than I have (or even just golf down my regex), that would be fascinating (or thrilling) as well.

I'd be interested in putting up a bounty for the regex aspects of this question, and would appreciate any suggestions people would have as to how to do this and how much the bounty should be.

• The whole stuff about type widths is confusing and I think it gets self-contradictory. E.g. "You are required to use an integer type of at least the precision of a native int. If your language has a native unsigned integer type, you must use it (if you're using a native type)". Java has signed 8-, 16-, 32- and 64-bit integers, and unsigned 16-bit integers. Which should it use? What does "native int" even mean in the context of languages which aren't C? Why should I get a better score in C if I'm using an underpowered computer which doesn't distinguish between uint and long long uint? – Peter Taylor Jan 26 '19 at 9:11
• @PeterTaylor What I'm really trying to achieve with that requirement is increasing the likelihood that in at least some languages, simply calculating it using floating point, e.g. convert the int to double, divide by sqrt(2) and convert back to int, would lose precision, making it necessary to implement the sqrt function in integer math. But I wanted to not actually prohibit floating point from being used. I agree with your criticism though. What if I simply require that the largest built-in fixed-size integer type be used at minimum if it exists (or arbitrary-precision if desired)? – Deadcode Jan 26 '19 at 10:13
• Thanks for explaining your goal. I'll think about it and see whether I can think of another way of achieving it. If you haven't already done it, you could pop into chat and ask the people there to think about it too. – Peter Taylor Jan 26 '19 at 20:00
• Thank you, @PeterTaylor. I actually did talk about it a bit in the chat earlier, which is actually why I required native ints in the original version... – Deadcode Jan 26 '19 at 20:20
• I hadn't noticed your edit. That's probably as good a solution as is possible. One other minor suggestion: how about changing the title to "Shift right by half a bit"? – Peter Taylor Jan 27 '19 at 8:30
• @PeterTaylor I love your title suggestion. Thank you so much! I kept the text "divide by the square root of two" and moved it to the description, in case of Math Processing Errors and also so it will show up in searches more easily. – Deadcode Jan 27 '19 at 8:53
• Can you add some test cases? – 640KB Jan 27 '19 at 15:37

# Irregular English Verbs

Given the infinitive of an irregular English verb, output its simple past and its past participle.

## Rules

• The input and output can be given in any convenient format.
• No need to handle verbs not in the given list.
• Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
• If possible, please include a link to an online testing environment so other people can try out your code!
• Standard loopholes are forbidden.
• This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

## Example

fall    --> fell; fallen
beat    --> beat; beaten or beat
bereave --> bereaved or bereft; bereaved or bereft
shall   --> should;(no participle)


# List of Irregular Verbs

Infinitive;Simple Past;Past Participle
alight;alighted or alit;alighted or alit
arise;arose;arisen
awake;awoke or awaked;awoken or awaked
be;was or were;been
bear;bore;borne or born
beat;beat;beaten or beat
become;became;become
beget;begot;begotten
begin;began;begun
bend;bent;bent
bereave;bereaved or bereft;bereaved or bereft
beseech;besought or beseeched;besought or beseeched
bet;bet or betted;bet or betted
bid;bade or bid;bidden or bid or bade
bide;bade or bided;bided
bind;bound;bound
bite;bit;bitten
bleed;bled;bled
bless;blessed or blest;blessed or blest
blow;blew;blown
break;broke;broken
breed;bred;bred
bring;brought;brought
broadcast;broadcast or broadcasted;broadcast or broadcasted
build;built;built
burn;burnt or burned;burnt or burned
burst;burst;burst
bust;bust or busted;bust or busted
buy;bought;bought
can;could;(no participle)
cast;cast;cast
catch;caught;caught
choose;chose;chosen
cleave;cleft or cleaved or clove;cleft or cleaved or cloven
cling;clung;clung
clothe;clothed or clad;clothed or clad
come;came;come
cost;cost;cost
creep;crept;crept
crow;crowed;crew or crowed
cut;cut;cut
deal;dealt;dealt
dig;dug;dug
do;did;done
draw;drew;drawn
dream;dreamt or dreamed;dreamt or dreamed
drink;drank;drunk
drive;drove;driven
dwell;dwelt or dwelled;dwelt or dwelled
eat;ate;eaten
fall;fell;fallen
feed;fed;fed
feel;felt;felt
fight;fought;fought
find;found;found
flee;fled;fled
fling;flung;flung
fly;flew;flown
forbid;forbad or forbade;forbid or forbidden
forecast;forecast or forecasted;forecast or forecasted
forget;forgot;forgotten
forsake;forsook;forsaken
freeze;froze;frozen
geld;gelded or gelt;gelded or gelt
get;got;got or gotten
gild;gilded or gilt;gilded or gilt
give;gave;given
gnaw;gnawed;gnawed or gnawn
go;went;gone
grind;ground;ground
grip;gripped or gript;gripped or gript
grow;grew;grown
hang;hung;hung
have;had;had
hear;heard;heard
heave;heaved or hove;heaved or hove
hew;hewed;hewed or hewn
hide;hid;hidden or hid
hit;hit;hit
hold;held;held
hurt;hurt;hurt
keep;kept;kept
kneel;knelt or kneeled;knelt or kneeled
knit;knitted or knit;knitted or knit
know;knew;known
lay;laid;laid
lead;led;led
lean;leant or leaned;leant or leaned
leap;leapt or leaped;leapt or leaped
learn;learnt or learned;learnt or learned
leave;left;left
lend;lent;lent
let;let;let
lie;lay;lain
light;lit or lighted;lit or lighted
lose;lost;lost
make;made;made
may;might;(no participle)
mean;meant;meant
meet;met;met
melt;melted;molten or melted
mow;mowed;mown or mowed
pay;paid;paid
pen;pent or penned;pent or penned
plead;pled or pleaded;pled or pleaded
prove;proved;proven or proved
put;put;put
quit;quit or quitted;quit or quitted
read;read;read
rid;rid or ridded;rid or ridded
ride;rode;ridden
ring;rang;rung
rise;rose;risen
run;ran;run
saw;sawed;sawn or sawed
say;said;said
see;saw;seen
seek;sought;sought
sell;sold;sold
send;sent;sent
set;set;set
sew;sewed;sewn or sewed
shake;shook;shaken
shall;should;(no participle)
shear;sheared;shorn or sheared
shed;shed;shed
shine;shone;shone
shit;shit or shitted or shat;shit or shitted or shat
shoe;shod or shoed;shod or shoed
shoot;shot;shot
show;showed;shown or showed
shred;shred or shredded;shred or shredded
shrink;shrank or shrunk;shrunk
shut;shut;shut
sing;sang;sung
sink;sank;sunk
sit;sat;sat
slay;slew;slain
sleep;slept;slept
slide;slid;slid
sling;slung;slung
slink;slunk;slunk
slit;slit;slit
smell;smelt or smelled;smelt or smelled
smite;smote;smitten
sow;sowed;sown or sowed
speak;spoke;spoken
speed;sped or speeded;sped or speeded
spell;spelt or spelled;spelt or spelled
spend;spent;spent
spill;spilt or spilled;spilt or spilled
spin;spun;spun
spit;spat;spat
split;split;split
spoil;spoilt or spoiled;spoilt or spoiled
spread;spread;spread
spring;sprang or sprung;sprung
stand;stood;stood
steal;stole;stolen
stick;stuck;stuck
sting;stung;stung
stink;stank or stunk;stunk
stride;strode;stridden
strike;struck;struck
string;strung;strung
strive;strove;striven
swear;swore;sworn
sweat;sweat or sweated;sweat or sweated
sweep;swept;swept
swell;swelled;swollen or swelled
swim;swam;swum
swing;swung;swung
take;took;taken
teach;taught;taught
tear;tore;torn
telecast;telecast or telecasted;telecast or telecasted
tell;told;told
think;thought;thought
throw;threw;thrown
thrust;thrust;thrust
tread;trod;trodden
understand;understood;understood
wake;woke or waked;woken or waked
wear;wore;worn
weave;wove;woven
wed;wed or wedded;wed or wedded
weep;wept;wept
wet;wet or wetted;wet or wetted
win;won;won
wind;wound;wound
wring;wrung;wrung
write;wrote;written

• So this is a simple lookup, meaning that the bulk of the challenge is compressing the data? – Adám Jan 24 '19 at 12:48
• Shouldn't the correct output from can be could;was able to rather than could;(kein Participle)? – Adám Jan 24 '19 at 12:49
• @Adám what about simply can -->could; ? – mdahmoune Jan 24 '19 at 12:54
• Up to you. Using (kein Participle) makes the challenge more interesting, as it has the only uppercase character, and the only parentheses. – Adám Jan 24 '19 at 14:02
• @Adám, no. It should be could or was able to or were able to;been able to. It certainly shouldn't be (kein Participle): the spec asks for output in English, not German. – Peter Taylor Jan 24 '19 at 15:04
• @PeterTaylor OP hasn't answered, but to me it looks like lookup KC, so the actual content doesn't actually matter. – Adám Jan 24 '19 at 16:59
• @Adám Yes, I think it's a simple lookup, it can be other than that? – mdahmoune Jan 28 '19 at 10:39
• Imho, it would be much more interesting to take a regular verb as input, and output the past tense: Add "ed" or "d" if verb ends with "e", but change final consonant-"y" to "consonant-"i" and insert "k" if verb ends in "c" and double final consonant if verb ends with a single vowel followed by a single consonant. – Adám Jan 28 '19 at 13:04
• Suggested tag: kolmogorov-complexity – ბიმო Jan 28 '19 at 13:19
• @Adám Do u mean adding the rules, or extending the current list with some regular verbs? – mdahmoune Jan 28 '19 at 14:00
• I meant replacing the list, so the challenge will only concern completely regular verbs. It is of course your choice. I can also post this related (but not really related, just inspired by) challenge myself. Let me know. – Adám Jan 28 '19 at 14:39
• @Adám Using only regular verbs would make it a very different challenge. I think this one is interesting as-is. Even if these verbs are irregular, they do follow some rules of their own (such as i becomes u). You may want to identify and store the transformation rules that are common to several verbs rather than just do string compression. – Arnauld Feb 5 '19 at 23:21
• @Arnauld can I use your comment to improve the text of the challenge? – mdahmoune Feb 6 '19 at 12:00
• Sure. (But maybe you should use a better example than just 'i becomes u' and make it clear that this is not a general rule but just a rule that applies to several verbs.) – Arnauld Feb 6 '19 at 13:53

# Generate a 3D spiral

Inspired by this chat message

The spiral used in The Path Of The Wildebeest is a contiguous mapping of the positive integers to lattice points in 2D. Your task is to generalize this to 3D.

Specifically, create a function $$\f\$$ from $$\\mathbb Z^+\$$ to $$\ \mathbb Z^3\$$ with the following properties:

• $$\f\$$ is a bijection (All points are eventually reached).
• $$\f(1) = (0,0,0)\$$ (The spiral starts at the origin).
• $$\ |f(n+1) - f(n)| = 1\$$ (The spiral is contiguous).
• The Chebyshev distance from the origin $$\ |f(n)|_\infty \$$ is a nondecreasing function ($$\f\$$ fills all points in each concentric cubical shell $$\k\$$ before moving to shell $$\k+1\$$).

One possible $$\f\$$ is given by this Python implementation, but any $$\f\$$ that satisfies the above properties is allowed. Please describe the function your answer generates.

Because all your computer's memory is taken up by the wildebeest simulation you're running, typing is very slow, so your code must be as short as possible.

### I/O

As is standard with questions, either 1-indexing or 0-indexing is allowed. Any of these I/O formats are acceptable:

• Receive $$\n\$$ as input and output the $$\n\$$th point in the sequence
• Receive $$\n\$$ as input and output the first $$\n\$$ points
• Take no input and output the sequence infinitely.
• Editing this from "is an increasing function" to "is a nondecreasing function" doesn't fix the problem... the function will sometimes have to decrease, because it has to hop over its own path and come back down. If you're already taking this into account, could you please be clearer about what you mean? – Deadcode Jan 30 '19 at 1:40
• @Deadcode I'm not sure what you mean by hopping over its own path. This challenge is just to generate the spiral, not the path of any chess piece. – lirtosiast Jan 30 '19 at 1:45
• Okay, imagine an actual ball of yarn. But to simplify things, let's imagine you start with a sphere. Start wrapping a string around it. After you make 1 revolution, you must adjust the angle of the string so that it crosses over its previous path. This will make a small bump in the path the string takes on its 2nd revolution. And on its 3rd revolution, there will be more bumps. Now imagine the analogy with a cube, quantizing the path to a cubical grid. The 2nd revolution will have to cross over the path the 1st revolution took, making a bump, 1 up, 1 down. – Deadcode Jan 30 '19 at 1:56
• I think in the cubical case, the path of the yarn can be arranged such that it never goes over bumps. – lirtosiast Jan 30 '19 at 1:58
• Okay, but then it will bear much less resemblance to a ball of yarn. – Deadcode Jan 30 '19 at 2:04
• @Deadcode the key point here is that it's the Chebyshev distance that's non-decreasing. So the 3d lattice is divided into cubic shells centered on the 0 point, and the function has to map to all of the points in shell n before moving on to shell n+1 – trichoplax Jan 30 '19 at 21:37
• (in that sense it's analogous to the 2d case) – trichoplax Jan 30 '19 at 21:41
• You can remove the backticks before and after the list then select it and press Ctrl + K, it will show as a single block of code then – RedClover Apr 19 '18 at 13:59
• @user202729 This isn't a KC because an answer to the challenge should accept inputs. – Shieru Asakoto Nov 19 '18 at 8:05

# Least efficient field order

## Background:

In C and other languages, a struct is a data type composed of fields of other data types. These fields may be different sizes (in bytes) and may have different alignment requirements (e.g. an int field may need to be on a 4-byte boundary).

Padding is added to a struct to keep all of its fields aligned, and to keep its size a multiple of each field's alignment.

For example:

struct test {
char  a; // 1-byte, 1-byte aligned
short b; // 2-byte, 2-byte aligned
int   c; // 4-byte, 4-byte aligned
}

In this struct, there will be 1 byte of padding after a (to keep b on a 2-byte boundary), no padding after b (as c is already on a 4-byte boundary) and no padding after c (as the size is already a multiple of 2 and 4 bytes), so the total size of the struct is 8 bytes (1 + 2 + 4 + 2). However, if we rearrange the order of the fields, the struct size can be bigger.

struct test_2 {
char  d; // 1-byte, 1-byte aligned
int   e; // 4-byte, 4-byte aligned
short f; // 2-byte, 2-byte aligned
}

In this struct, there will be 3 bytes of padding after d (to keep e on a 4-byte boundary) and there will be 2 bytes of padding after f (to keep the size a multiple of 2 and 4 bytes), so the total size of this struct is 12 bytes (1 + 4 + 2 + 3 + 2).

## Challenge:

Given a list of pairs of positive integers (each pair representing the size and alignment of a field), return the same pairs in an order such that a struct with fields in that order would require the most padding, i.e. be the least space-efficient.

Givens:

• A field's size will always be greater than or equal to its alignment. (e.g. (4, 8) is not a valid input pair)

• A field's size will always be a multiple of its alignment. (i.e. (12, 5) is not a valid input pair)

Test cases: (other outputs that give the same total size are valid as well)

[(1, 1), (1, 1), (4, 4)] -> [(1, 1), (4, 4), (1, 1)] # size 12
[(12, 4), (1, 1), (2, 2), (8, 8)] -> [(12, 4), (8, 8), (1, 1), (2, 2)] # size 32
[(7, 7), (5, 1), (2, 2)] -> [(7, 7), (2, 2), (5, 1)] # size 28
[(6, 6), (6, 3), (4, 2), (2, 2)] -> [(6, 3), (4, 2), (6, 6), (2, 2)] # size 24
[(1, 1)] -> [(1, 1)] # size 1


Test case checker online!

• I think in your explanation (1 + 2 + 4 + 2) should be (1 + 2 + 4 + 1). The only thing I see about this challenge that is questionable is whether having separate alignments is interesting or tedious. Would this lose much by assuming each field's alignment is equal to its size? – FryAmTheEggman Feb 25 '19 at 21:25