Sandbox for Proposed Challenges

Question

This "sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to main. This is useful because writing a clear and fully specified challenge on your first try can be difficult, and there is a much better chance of your challenge being well received if you post it in the sandbox first.

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Comments addressing specific points mentioned in the proposal
• Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Answer 1

How sorted is this array

Given an array output the minimum number of swaps needed to sort that array

Examples

[1, 2, 3, 4, 5]   ->  0
[1, 3, 2, 4, 5]   ->  1
[5, 4, 3, 2, 1]   ->  2
[1, 3, 4, 5, 2]   ->  3
[2, 3, 4, 5, 1]   ->  4

[3, 5, 1, 11, 7, 3] -> 3

Rules

• You can assume that the elements of the array are positive integers
• There might be duplicate elements
• This is code-golf, the shortest code wins

Optional additional requirement

Solve the problem in \$O(n²)\$

---

Meta

• Would you consider this challange to be a duplicate? My solution only asks for the number of swaps, which seems to be a much easier task than finding the actual pairs of indices
  These twp challenges I found are very similar but not exactly the same: sorting networks, swaps in bubble sort

Answer 2

Add two rational numbers... esoterically

Objective

Build a binary operator \$\star : \mathbb{Z} \times \mathbb{Z} \to \mathbb{Z}\$ such that, there exists a bijection \$i : \mathbb{Z} \to \mathbb{Q}\$ such that, for every integer \$M\$ and \$N\$, \$M \star N = i^{-1}(i(M) + i(N))\$ holds.

Or in mathematical terms, build a binary operator \$\star\$ that admits a group isomorphism from \$(\mathbb{Z}, \star)\$ to \$(\mathbb{Q}, +)\$.

I/O Format

Flexible. Standard loopholes apply.

Scoring

This is a fastest-algorithm challenge. The submission whose the asymptotic worst-case time complexity of \$\star\$ is the fastest wins.

The parameter \$n\$ for the time complexity is \$s(M) + s(N)\$, where \$s\$ is defined as follows:

• \$s(0) = s(-1) = 0\$.
• For every integer \$D > 0\$, \$s(D) = \lfloor \log_2 D \rfloor + 1\$.
• For every integer \$D < -1\$, \$s(D) = \lfloor \log_2 (-D-1) \rfloor + 1\$.

The shortness of your code is a tiebreaker. That is, this challenge is secondarily code-golf.

Notes and Rules

Note that each bijection \$i\$ induces \$\star\$ uniquely. As such, your submission must specify your choice of \$i\$.

Answer 3

Build the smallest self driving Car

code-golf

Your goal is building the smallest self driving car to get from A to B.

The car is a point mass of 1kg and has a steering wheel to turn left and right, as well as an accelerator pedal to accelerate and brake. Furthermore it is equipped with LIDAR: If 0° is the forward direction, it has a laser every 10° from -90° to +90°. Each of these lasers measures the distance to the next wall. The point A is where the car starts witz zero velocity, pointing north. The destination B is an area where the car has to stop to finish the trip (it can be facing any direction).

Your job is to write a function that is called every second, to steer your car to the B area, without crashing into the wall.

def car(lidar, speed):
    # lidar is an array of 19 floating point numbers
    # speed is an integer
    steering = ... # can be any integer from -3 to 3 and refers to a multiple of 10° (eg -2 means -20°) the car is turned in this step.
    acceleration = ... # can be any of [-1, 0, 1] and refers to the acceleration in `m/s` for the next step
    # first the car is turned by the indicated amount, then the acceleration is added to the current velocity, and then we take a velocity-sized step in the current direction

    return steering, acceleration

The function must be deterministic and a black box function, that is, it can only communicate to the outside world via the inputs arguments and the returned values. The function must be as small as possible (measured in bytes).

If the car crashes into a wall, it will be disqualified.

Map

the map will need to be determined it will be a closed non-self intersecting polygon. Here is an example but it will be a longer and maybe a little bit more complicated:

---

Discussion

• EDIT: I just remembered there was Lab Rat Race: an exercise in genetic algorithms where we did something similar. So maybe it would make sense to take the challenge in a slightly different direction.

• EDIT2: There is an almost identical challenge in http://janismac.github.io/ControlChallenges/ (go to the menu with the little squares and choose "Vehicle Steering" or "Vehicle Racing"). After playing around with this I think a combination of golfing code and time would be nice.

---

I'd obviously have to write a controller and come up with a good map that is doable with the velocity/direction constraints. Ideally with some graphical output for the participants to debug their car.

1. Shall there be multiple maps?
2. Are the discrete actions a good idea? (And are the ranges any good?) I think for the velocity it is nice so the car can come to a full stop in the target area.
3. Should the steering be limited when the velocity is higher?
4. Currently it feels like this will end up as just as a compression challenge i.e. who can hardcode a good sequence of steering inputs. I'm not sure this is all that fun. Are there other challenge modes or variations for this setting that would be more interesting? (The other thing I had in mind was giving the players a fixed code-budget and measuring how far they can get in the map.)
5. Should the cars be allowed to have some memory between each step? (e.g. limited to a certain number of bits) - after the update from above I think it would make sense to allow some (or maybe even an unlimited) amount of memory between each step. But still it would be nice to have some sort of restriction.

Answer 4

Transpose a multidimensional array

Answer 5

Golf a LaTeΧ math expression code-golf string parsing

Answer 6

Visualise the Euclidean GCD

Answer 7

Is this your answer? answer-chaining

NOTE: The scoring criterion for this is currently broken. I'll fix it at some point ™

---

In this challenge, you must write an answer that distinguishes itself from all previous answers. No matter what input is passed in, it must output one of two consistent values. Your answer must output one value, marked as "truthy", when your answer's code is input, and the other value, marked as "falsy", when the code of at least one previous answer is input. Whichever value it outputs when anything else is input does not matter as long as it outputs one of the two values.

However, you are not only trying to distinguish your answer from others, but also to trick previous answers into thinking your source code is their own and outputting their truthy value.

Your answer's score is \$\frac{\text{byte count} + 2}{\text{tricked answers } \cdot \text{ answers that don't trick you}}\$, where "tricked answers" is the number of previous answers that output their truthy value when given your code, and "answers that don't trick you" is the number of previous answers for which your answer correctly returns the falsy value. Your answer must trick at least one previous answer and not be tricked by at least one previous answer.

For example, if the first answer was the Python program print(1), then a valid second answer would be the JavaScript function x=>x.includes('x'), which checks if the input string contains a x, returning true for itself, false for the singlee previous answer, and either true or false for any input string. As the previous answer prints a 1 when given this code, this would score \$\frac{18+2}{1 \cdot 1} = 20\$.

---

First answer (will be posted along with the question):

1: Python 3, 8 bytes

print(1)

Try it online!

Outputs 1 for truthy and 0 for falsy.

Answer 8

Is it a Valid Crossword Grid?

Answer 9

Expected number of rounds for this labeling scheme

Answer 10

Smallest infinite irreducible program

code-golf code-bowling

---

A typical constraint for code-bowling challenges, where the goal is to make your code as long as possible, is that your program must be "irreducible". I.e., no subset of characters can be removed from your program with it still being valid. If your code was xyz, none of x, y, z, xy, yz, or xz could do the same task as xyz. This makes it impossible to use comments, string literals, long variable names, or whitespace to pad out your code length, but through some trickery it's possible to design a program which can be made arbitrarily large while still being irreducible.

In this challenge, you'll try to golf the setup for this. Your submission will be a finitely sized "base" program, which is irreducible, and which can be increased to an arbitrarily high size through the addition of substrings at a chosen point (or set of points) in the program.

For example, a base program might look like wx()yz, and continue to function and be irreducible with the insertion of arbitrarily many abs in between the ()s (such as wx(ababab)yz). You can also require substrings to be inserted in multiple places at once (e.g., you might need a 1 to be appended to the program for each ab, so the previous example would look like wx(ababab)yz111).

Scoring:

Your score is the size in bytes of your base program. Your base program must be irreducible on its own; if the insertion of some minimum number of your chosen substring(s) is necessary for this, those must be included in the score.

Task:

Your irreducible program must do any one of the following tasks, of your choice:

• Truth machine: Take an input. If the input is 0, print 0 and stop. If the input is 1, print 1 indefinitely
• Arithmetic: Take two inputs, x and y. Print x + y².
• Constant output: Print the string Good morning!

You may write a program or a function. If you choose to write a function, instead of printing you may return the output. For the truth machine task, you must use an infinite list/iterator if you return a value; you must have some way of getting an arbitrary number of 1s out of the return value in finite time (so you can't just append 1s to a list infinitely, and return the list once the infinite loop would stop).

Answer 11

Find the fairest partition of a list

Answer 12

Make Code Printing X Without X

Answer 13

How many twisted corners?

Posted here

Answer 14

Sub-quadratic base conversion

Write a program that converts a positive integer given in base 10 to its base 2 representation.

Your algorithm must run in a complexity lower that \$O(n^2)\$

Rules

• You can assume that each arithetic operation (sum/multiplication/division/remainder/exponentation) has the running time of the fastest known algorithm, independent of the implementation that is actually used (This includes methods that you wrote yourself).
  • Addition can be done in linear time
  • Multiplcation/division/remainder run in \$ O(n \cdot \log(n))\$ where \$n\$ is the sum of the numbers of bits of the inputs ^*.
  • Exponentiation \$N^X\$ runs in \$O((n \log x)(\log(n)+\log(\log x)))\$ where \$n\$ and \$x\$ are the numbers of bits in \$N\$ and \$X\$ respectively.
  • If you know faster algorithms please link them in your challenge
• All built-in base-conversion/library methods for base-conversion are assumed to run in quadratic time in the input, even if the actual implementation is faster
• (... more rules will follow)

code-golf restricted-complexity

---

^* The \$O(n log (n)) \$ multiplication algorithm assumes that both arguments have the approximately same size, for simplicity you may assume that the same complexity can be archived for arbitrary argument sizes (this may not be true in practice).

---

Meta

• Is this a duplicate?
• Is there interest in a challenge of this form?
• Is my explanation clear?

Answer 15

Compute the Kimberling Sequence

code-golf

Introduction

The Kimberling Seqeunce is a sequence of sequences. Each sequence is defined in terms of the previous sequence and the previous stage number. At each stage, the numbers from the previous stage are rearranged as follows:

• For k in [1,...,i], write term i+k and then term i-k.
• Discard the ith term.
• Write the remaining terms in order.

We start with all positive integers at stage 0, so the first few rows look like this.

1  2  3  4  5  6  7  8  9 10 11
2  3  4  5  6  7  8  9 10 11 12
4  2  5  6  7  8  9 10 11 12 13
6  2  7  4  8  9 10 11 12 13 14
8  7  9  2 10  6 11 12 13 14 15

At each stage, the number on the diagonal is expelled (it is an open question as to whether every number is eventually expelled).

Challenge

Your program must take a positive integer n as input and output the integer expelled in forming the nth stage of the Kimberling sequence.

Answer the following questions for your readers.

Standard loopholes are forbidden. As this is code-golf, shortest program wins.

Example Input and Output

1 -> 1
2 -> 3
3 -> 5
4 -> 4
5 -> 10
6 -> 7
7 -> 15
8 -> 8
9 -> 20
10 -> 9
11 -> 18
12 -> 24
25 -> 2
100 -> 229
1000 -> 394
1001 -> 1274

More test cases from OEIS.

Sandbox Questions

This is my first code golf question, so I'm not sure what to ask other than is there anything that I can improve/need to fix before asking the main site?

Answer 16

Implement the "Wolontis" Function

While looking at old ALGOL documentation with someone else on Discord, this "famous" function popped up:

Although it’s mentioned in other language manuals of the era, such as Runcible and FORTRAN, we haven't managed to find any references to this function online — so let's change that.

The expression in the image is \$\frac{\sin x}{\sqrt{1-e^{-x^3}}}\$. Your task is to implement this function for positive inputs, as its value is undefined at \$x=0\$ and imaginary for negative \$x\$. Floating-point inaccuracies are permitted.

code-golf math

---

Sandbox questions

• How accurate/precise should answers be required to be?
• What other tags should I add?
• Any other information I should include? e.g. would a graph be helpful?

Answer 17

code-golf number natural-language

Read a French number

We have Spell out numbers in French, Translate numbers to French and Telling time in French, but we were missing the reverse:

Challenge

Read a French expression, and output the corresponding integer.

Input

In true French, a French number expression is a list of French words separated by whitespace, and possibly by hyphens "-" and the word "et", such as "sept mille deux cent vingt-et-un".

For this challenge, you do not need to care about hyphens and the word "et": you are free to take input as a whitespace-separated string of words such as "sept mille deux cent vingt un", or as a list of single-word strings such as ["sept", "mille", "deux", "cent", "vingt", "un"].

All French words will be taken from the following list:

        'zero': 0, 'un': 1, 'deux': 2, 'trois': 3, 'quatre': 4,
        'cinq': 5, 'six': 6, 'sept': 7, 'huit': 8, 'neuf': 9,
        'dix': 10, 'onze': 11, 'douze': 12, 'treize': 13,
        'quatorze': 14, 'quinze': 15, 'seize': 16,
        'vingt': 20, 'trente': 30, 'quarante': 40, 'cinquante': 50,
        'soixante': 60,
        'cent': 100, 'mille': 1000, 'million': 1000000, 'milliard': 1000000000

Note that in correct French, "million" and "milliard" must take an -s in plural form, but for this challenge you do not need to care about that. "zéro" also must take an accent on the "e", but you do not need to care about that. "un" must be "une" in feminine form, but you do not need to care about that.

Also note that if we simply added "septante: 70, octante: 80, huitante: 80, nonante: 90" then we would be able to handle Belgian French and Swiss French, but for this challenge you do not need to care about that.

Output

Output one integer, corresponding to the French input number.

Conversion rule

Once the sequence of French words has been converted into a sequence of numbers, this sequence can be converted into one number by identifying the largest number in the sequence, then using one simple recurrence rule:

convert(left, largest, right) = convert(left) * largest + convert(right)

with of course the special cases that convert(empty left sequence) = 1 and convert(empty right sequence) = 0.

For instance:

"sept mille deux cent vingt un"
[7    1000  2    100  20    1]
[7] * 1000 + [2 100 20 1]
7000 + ([2] * 100 + [20 1])
7000 + (200 + ([] * 20 + [1]))
7221

Test cases

"sept mille deux cent vingt un"     ->  7221
"soixante douze cent vingt un"      ->  7221
"dix sept cent quatre vingt neuf"   ->  1789
"mille sept cent quatre vingt neuf" ->  1789
"trois mille neuf cent quatre vingt dix sept" -> 3997
"cent mille milliard cent trente sept million trois cent quatre vingt quinze mille huit cent cinq"
    ->  100_000_137_395_805
"zero"                 -> 0
"un milliard dix sept" -> 1_000_000_017
"mille"                -> 1000

Rules

• This is code-golf, the shortest code in bytes wins!

Answer 18

Generate the snowflake pattern sequence

A snowflake figure looks like this:

A few rules govern how many points each ring can have.

• The innermost ring must have between 1 and 8 inclusive points.
• Every other ring must have between 2 and 8 inclusive points.
• To ensure symmetry, every ring must have a integer multiple times as many points as the next smallest ring.

Valid snowflake sequences, from the smallest to the largest ring, include: 1,2,2,6, 2,4,8, 3,6, 8,8,8,8,8, etc.

Your task is, given a number, output the best configuration of rings.

If there are multiple solutions, find the most aesthetically pleasing one as follows:

• The one with the most unique ring sizes
• Unique ring sizes being equal, the one with the biggest smallest ring. Eg. 2,6 is better than 1,7.
• If the unique ring sizes and smallest ring are both equal, output the one with the smallest total number of rings.

If there are still multiple options, you may choose one arbitrarily.

Test Cases

Number	Pattern	Image
1	1
2	2
3	1,2
4	1,3
5	1,4
6	2,4
7	1,2,4
8	2,6
9	1,2,6
10	1,3,6
11	1,2,8
12	4,8
13	1,4,8

Answer 19

Parse nested absolute values

Part1

Part2

Answer 20

Implement a simple stack language

Answer 21

Simulate a Plant Cell quine code-golf

Now posted! (old drafts still in version history)

Answer 22

Generate an efficient A* heuristic restricted-complexity code-challenge

A* is a pathfinding algorithm that can be much faster than Dijkstra's, but it requires a heuristic. The heuristic is a function that takes as input one point of the graph, and the destination, then gives a lower bound for the distance between the two points.

The closer the heuristic is to the true shortest distance, the faster the algorithm runs. But if the heuristic ever overestimates, the algorithm is no longer guaranteed to find the shortest path.

Your task is to generate a good heuristic for a given graph. You must submit 2 functions:

• The first functions must run in at most O(n^3) time. Given a graph, output up to three 64-bit floating point numbers per point.
• The second function must run in O(1). Given two points on the graph, output a lower bound for the distance between the two points.

Edges of the graph are guaranteed to have positive, non-zero, integer lengths.

Scoring

Your score is the sum of the differences of your heuristic and the true shortest distance on the (yet to be decided) large graph below. The smallest score wins.

Answer 23

ASCII flood fill

Answer 24

This question was marked as posted and is therefore not shown - you can see the revision history for details.

Answer 25

How many people are awake?

The following data contains the population of each timezone in the world (source):

UTC;Population (in thousands)
-11;57
-10;1853
-9.5;8
-9;639
-8;66121
-7;41542
-6;272974
-5;332101
-4.5;31923
-4;77707
-3.5;499
-3;248013
-2;4855
-1;3285
0;285534
+1;857443
+2;609921
+3;496279
+3.5;81889
+4;129089
+4.5;31042
+5;305642
+5.5;1458945
+6;199668
+6.5;50112
+7;439650
+8;1679526
+9;220112
+9.5;1814
+10;29482
+11;5267
+11.5;2
+12;6112
+13;308
+14;11

(for the sake of simplicity, I'm removing +X.75 UTC times from the list)

Assuming that every person in the world wakes up at 8AM and goes to sleep at 12AM (in their local time), how many people are simultaneously awake in the world at a given UTC time?

For example, suppose the given time is 2PM UTC. These are the timezones where the local time at 2PM UTC is between 8AM inclusive and 12AM exclusive:

  -6 08:00 272974
  -5 09:00 332101
-4.5 09:30 31923
  -4 10:00 77707
-3.5 10:30 499
  -3 11:00 248013
  -2 12:00 4855
  -1 13:00 3285
  +0 14:00 285534
  +1 15:00 857443
  +2 16:00 609921
  +3 17:00 496279
+3.5 17:30 81889
  +4 18:00 129089
+4.5 18:30 31042
  +5 19:00 305642
+5.5 19:30 1458945
  +6 20:00 199668
+6.5 20:30 50112
  +7 21:00 439650
  +8 22:00 1679526
  +9 23:00 220112
+9.5 23:30 1814

Now, just add the population of these timezones and output 7818023 (corresponding to ~7.8 billion people).

Input

An UTC time. You may accept one of the following (or all of them):

• two natural numbers h and m, where 0 ≤ h ≤ 23 and m ∈ {0, 30}
• a real number r, where 0 ≤ r < 24 and its fractional part can be only 0 or 5 (so r = 23.5 corresponds to 23:30).

Standard I/O applies, so you can accept them as lists, strings, etc. You can even accept m as a boolean value, where 0 means HH:00 and 1 means HH:30.

There are two ways of solving this question: hardcoding the output (since there are only 48 possible inputs) or hardcoding the population data and solving by time arithmetic. However, to make this challenge more interesting, you are allowed to accept the population data as an additional input, so you don't need to hardcode it (thus saving you some bytes) and focusing only on the time arithmetic. So you can read it as additional lines from STDIN or an additional function argument.

Output

How many people are awake at the given time, in thousands.

Test cases

00:00 -> 1942634
00:30 -> 1942634
01:00 -> 2382284
01:30 -> 2432396
02:00 -> 2632064
02:30 -> 4091009
03:00 -> 4396651
03:30 -> 4427693
04:00 -> 4556782
04:30 -> 4638671
05:00 -> 5134950
05:30 -> 5134950
06:00 -> 5744871
06:30 -> 5744871
07:00 -> 6602314
07:30 -> 6602314
08:00 -> 6887848
08:30 -> 6887848
09:00 -> 6891133
09:30 -> 6891133
10:00 -> 6895977
10:30 -> 6895977
11:00 -> 7143682
11:30 -> 7144181
12:00 -> 7215776
12:30 -> 7247697
13:00 -> 7574531
13:30 -> 7574531
14:00 -> 7818023
14:30 -> 7816209
15:00 -> 7637639
15:30 -> 7637639
16:00 -> 6024234
16:30 -> 6024234
17:00 -> 5585223
17:30 -> 5535119
18:00 -> 5337304
18:30 -> 3878359
19:00 -> 3572774
19:30 -> 3541732
20:00 -> 3412643
20:30 -> 3330754
21:00 -> 2834475
21:30 -> 2834475
22:00 -> 2224554
22:30 -> 2224554
23:00 -> 1367111
23:30 -> 1367111

code-golf time

Answer 26

Accumulate spare change

code-golfmathcurrency

---

In this challenge, given some cash, you'll pay for various items as simply as possible (e.g., one $20 bill for a $17 purchase), and get spare change in return. Your task is to figure out what bills and coins you have after all of the transactions.

Input

Your input will be an initial amount of cash, and a list of zero or more prices of items. You can take these either as dollars with decimal cents ($12.95 = 12.95) or as an integer number of cents ($12.95 = 1295). The prices of items will not exceed the initial amount of cash, and no inputs will contain fractional cents.

Task

First, you'll break down your inputted cash into bills and coins, such that the minimum number of bills/coins are required. The following bills and coins exist:

• $100
• $50
• $20
• $10
• $5
• $1
• $0.25
• $0.10
• $0.05
• $0.01

Then, for each item purchased, you'll pay using the fewest bills/coins possible, and you'll get change in return. If there are multiple possibilities (e.g., for $45, you could pay with a $50 or a $100), choose the closest one. The only exception is if it's possible to pay using 2-4 of the same bill/coin instead of one that's larger than doing it that way (e.g., $40 as 2 $20 bills, or $1 as 4 $0.25 coins if a $1 bill isn't available, but never 4 $5 bills instead of one $20 bill).

Output

Your output will be the number of each bill and coin remaining after the transactions are complete.

Example

Initial cash: $70

You now have $50 + $20.

Transactions:

• $11: You pay with $20, and now have $50 + $5 + $1 × 4
• $0.65: You pay with $1, and now have $50 + $5 + $1 × 3 + $0.25 + $0.10
• $18.75: You pay with $50, and now have $20 + $10 + $5 + $1 × 2 + $0.25 × 2 + $0.10
• $25: You pay with $20 + $5, and now have $10 + $1 × 2 + $0.25 × 2 + $0.10
• $2: You pay with $1 × 2, and now have $10 + $0.25 × 2 + $0.10
• $4.25: You pay with $10, and now have $5 + $0.25 × 5 + $0.10
• $1: You pay with $0.25 × 4, and now have $5 + $0.25 + $0.10

Output: $5 + $0.10

Answer 27

Complete a mystery sequence

Given a sequence of three integers, determine if the sequence is arithmetic (of the form [a, a+d, a+2*d]) or geometric (of the form [a, a*r, a*r^2]) by outputting a fourth term that completes it (a+3*d for arithmetic, a*r^3 for geometric).

Examples:

[1, 2, 3] -> 4 (This is an arithmetic sequence with a difference of 1)
[2, 4, 8] -> 16 (This is a geometric sequence with a ratio 2)
[20, 15, 10] -> 5 (arithmetic sequence, d=-5)
[6, 6, 6] -> 6 (arithmetic with d=0 OR geometric with r=1)
[3, -9, 27] -> -81 (geometric with r=-3)

• Input is guaranteed to be a valid arithmetic and/or geometric sequence (so you won't have to handle something like [10, 0, 99])
• For geometric sequences, the ratio between terms is guaranteed to be an integer (ie. [4, 6, 9] would be an invalid input, as the ratio would be 1.5)
• If a sequence could be either arithmetic or geometric, you may output either term that completes it
• This is code golf, so aim for the lowest byte count possible!

---

Notes:

• I'm not sure if there is a sequence that could be completed two different ways. I'd assume there is, but I haven't found it (although I haven't been looking for very long)
• Is this too much of an A/B challenge?
• Title suggestions would be appreciated

Answer 28

Fastest bytewise comparisons in 64-bit unsigned integers

fastest-code bitwise [tag:i-don't-know]

• Create a function that accepts two 64-bit unsigned integers, a and b.

• Compare each corresponding byte in a and b.

• If the byte in a is greater than the byte in b in the same position, set the corresponding byte in the output to 255.

• Otherwise, set the corresponding byte in the output to 0.

• Return the resulting 64-bit unsigned integer.

Restrictions: the code runs in x86-64, no explict SSEx, AVXx (is ok if the compiler vectorices the result)

Example:

a =      202      141        1      123       61       53       40 251
b =      158       75      185      217        5       90      152 225
a = 11001010 10001101 00000001 01111011 00111101 00110101 00101000 11111011
b = 10011110 01001011 10111001 11011001 00000101 01011010 10011000 11100001
a>b=     255      255        0        0      255        0        0      255
a>b=11111111 11111111 00000000 00000000 11111111 00000000 00000000 11111111

Answer 29

How quickly can you type this string?

code-golf string

Given a string consisting of only printable ascii (letters, numbers, symbols, and spaces), how many keystrokes are required minimally to type out this string from scratch? The allowed keystrokes are:

• one character from printable ascii for 1 keystroke
• Ctrl-C (copy) any contiguous substring you have typed so far and replace whatever is currently copied (2 keystrokes) and Ctrl-V (paste) any string in your clipboard (1 keystroke)
• Backspace the last typed character for 1 keystroke

For example, the string "cbaabcbabaacba" can be typed in 12 keystrokes, which is optimal.

Test Cases

cbaabcbabaacba => 12
ababcc => 6
aaaaaaaaaaaaa => 9

Scoring

This is code-golf, so the shortest code wins!

Answer 30

Divmod continuosly until the remainder is 1 or 0, then get the remainder