Sandbox for Proposed Challenges

Question

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 the first try can be difficult. 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 or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

• Most people include applicable tags in their proposal, so for instance you can search for all king-of-the-hill proposals by merely adding the tag name in quotes to the search query.

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

Answer 1

Product and Sum free set

code-golfmathsequence

Given some non-negative integer \$n\$ find a sum- and product-free subset \$S \subset \mathbb N = \{1,2,3,\ldots \}\$ of size \$|S|=n\$

EDIT: with the least possible maximum \$\max_{s\in S} s\$.

Details

• A set \$S\$ is called sum-free if for all \$a,b\in S\$ their sum \$a+b \not \in S\$.
• A set \$S\$ is called product-free if for all \$a,b\in S\$ their product \$a\cdot b \not \in S\$.

related

Examples

Note that the sets for each \$n\$ might not necessarily be unique.

  n  S
  1  {2}
  2  {2,3}
  3  {3,4,5}
  5  {4,5,6,7}

EDIT: Ok, no this doesn't work either.

Answer 2

Use input letters to create as many words as possible

---

I have the scrabble letters as magnets on my fridge and I was thinking: how many actual words could I make using only these letters. Obviously it would be hard to work out myself, so I challenge you to create a program which will take a string of characters as input, and your goal is to output as many words as possible using those characters.

Input

• The characters will be one string
• Only the 26 letters of the alphabet will appear.
• Letters may appear more than once
• Letters can appear in any order. 5 e's might appear next to each other, and there might be other e's in the string.
• There will always be at least a single letter, but it might not always be possible to create a valid word

Example, using the letters from Scrabble:

eeeeeeeeeeeaaaaaaaaaiiiiiiiiioooooooonnnnnnrrrrrrttttttllllssssuuuuddddgggbbccmmppffhhvvwwyykjxqz

Output

A list of valid English words, which you can separate with a space, newline or comma. A trailing newline at the end is fine.

Default loopholes are forbidden.

code-golfwordnatural-language

---

Meta discussion (not apart of the question)

• Is code-golf a decent challenge for this? I'm more interested in more words being output than I am short code, but how best can I frame this challenge that the best result would be most words created and fewest characters left?
• Should I restrict the input list to just the letters from Scrabble? I mean how can I evaluate whether a program prints as many as possible?
• Should I provide a word list? I know there are challenges on this site where a word list is provided 1 and 2 and I'm sure there are a few others which I could not find.
• This is my third question, so any other feedback

Answer 3

Who's serving in table tennis?

Table tennis, also known as ping pong, is a well-known game in which players hit a ball back and forth across a table. One player serves the ball twice, and each time the ball is served, either player can score a point. Once the first player serves the ball twice, the second player gets to serve twice. Every two serves, the player which serves the ball switches. The game ends when one player has a score of 11 or more points and is two or more points higher than the other player.

Your task is to take the current score as input, and output a value depending on if player 1 should serve, player 2 should serve, or the game is over.

Input: The score of the first player to serve followed by the score of the other player. This can be as separate values or in a list, or another convenient data type.

Output: A distinct value for each possible case of output. For the test cases, I will use 1 to represent the player who serves first, 2 to represent the other player, and 0 to represent that the game is over.

Test cases:

player1score, player2score -> output

2, 0    ->  2
0, 0    ->  1
11, 0   ->  0
4, 4    ->  1
3, 2    ->  1
6, 9    ->  2
81, 82  ->  2
0, 29   ->  0
16, 13  ->  0

Answer 4

Alternating Digit Divisibility

TODO: Could use a better title..

code-golfnumberarithmeticinteger

Challenge:

Given a list of positive integer \$L\$ with at least two integers, output a list of digits which alternating divide either number itself evenly, of the sum of the digits of this number. The alternating can be done [sum_of_digits, number_itself, sum_of_digits, ...], or [number_itself, sum_of_digits, number_itself, ...]
This no doubt sounds pretty vague, so here an example:

Input: \$L=[611,044,381]\$
Output: \$[[1,2,4],[1]]\$ (or \$[1,2,4,1]\$ or \$[1,2,4]\$)

The two alterations are one of these two possibilities:

[8,44,12]      [sum([6,1,1]),  044, sum([3,8,1])]
[611,8,381]    [611, sum([0,4,4]), 381]

As for which digits can divide these numbers:

[8,44,12]    →  [[1,2,4,8], [1,2,4], [1,2,3,4,6]]
[611,8,381]  →  [[1], [1,2,4], [1,3]]

Where the divisible digits that are present in all sublists of the lists are:

[1,2,4]
[1]

Challenge rules:

• I/O is flexible. Input can be a list of strings, integers, 2D list of digits, etc. Output can be a list of lists of digits, a single flattened list of digits, a single flattened and uniquified list of digits, two lists printed on separated lines, a string, etc. The order of the outputs also doesn't matter, but state which one you've used in your answer.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (i.e. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test cases:

Input:                      Output:

[611,044,381]               [[1,2,4]], [1]]
[200,32000,4000]            [[1,2], [1,5]]

TODO: More to come, including some larger ones

Answer 5

Help the library sort books

code-golf natural-language

A library needs to sort its books, located in separate sections by language. Of course, each language has its own rule for collating strings, so your method should handle that ability.

Most languages will want to treat titles case-insensitively, but unfortunately, the library has a section of Klingon books. And Klingon's romanisation, in case you don't already know, is case-sensitive. As a result, you need to give a way to have the sorter treat two given characters as the same.

Some of the titles also contain numbers, and you need to deal with those as well. Fortunately, the friendly people at the library have written some functions for you to deal with that, so all you have to do is take in a handle to a function as one of your inputs.

Your challenge: Sort a list of book titles, given a collating sequence and a function handle that converts a number to its string representation in the respective language.

• The collating sequence is a list of lists of strings. Given two strings A and B that appear respectively in the entries at indices i and j, respectively:
  • if i > j, then A should sort after B
  • if i = j, then A should sort the same as B
• In case some elements of the sequence have multiple characters, use the max-munch rule to tokenise the string: e.g. if both l and ll appear in the collating sequence, then lll should be tokenised to ll l.
• Any string of digits should be parsed as a number and passed to the callback. Each such string should be replaced by the result.
• Any characters not appearing in the collating sequence should be ignored. If two strings differ only by such characters, then sort them however you like.

Test cases

Assuming

english_letters = [["A", "a"], ["B", "b"], ["C", "c"], ["D", "d"], ["E", "e"], ["F", "f"], ["G", "g"], ["H", "h"], ["I", "i"], ["J", "j"], ["K", "k"], ["L", "l"], ["M", "m"], ["N", "n"], ["O", "o"], ["P", "p"], ["Q", "q"], ["R", "r"], ["S", "s"], ["T", "t"], ["U", "u"], ["V", "v"], ["W", "w"], ["X", "x"], ["Y", "y"], ["Z", "z"]]
arka_letters = [["t"], ["k"], ["x"], ["s"], ["n"], ["v"], ["f"], ["m"], ["d"], ["g"], ["p"], ["b"], ["h"], ["y"], ["c"], ["r"], ["z"], ["j"], ["w"], ["l"]]
function english_num_callback(num) {
  // convert a number to its representation in English
}
function arka_num_callback(num) { // handles nonnegative integers up to 9999
  if (num == 0) return "yuu";
  let kot = 0 | (num / 1000);
  let gal = 0 | (num / 100 % 10);
  let on = 0 | (num / 10 % 10);
  let ko = num % 10;
  let digits = ["yuu", "ko", "ta", "vi", "val", "lin", "kis", "nol", "ten", "los"];
  return (kot == 0 ? "" : digits[kot] + "kot") +
    (gal == 0 ? "" : digits[gal] + "gal") +
    (on == 0 ? "" : digits[on] + "on") +
    (ko == 0 ? "" : digits[ko]);
}

["Stack Exchange", "BB94 Channel!", "BB guns: all you wanted to know about them",
  "carrots", "A Grammar of Jbl", "69"], english_letters, english_num_callback =>
  ["A Grammar of Jbl", "BB guns: all you wanted to know about them", "BB94 Channel!",
    "carrots", "69", "Stack Exchange"]
["melidia", "diaklel", "44 miiko", "I Mess With the Librarians", "an isk ris tu lei",
  "lei e xion", "xagrisren et xep!", "on melkadren"], arka_letters, arka_num_callback =>
  ["xagrisren et xep!", "44 miiko", "melidia", "diaklel", "lei e xion",
    "an isk ris tu lei", "on melkadren", "I Mess With the Librarians"]

Answer 6

Will it be red sauce, brown sauce, or no sauce at all?

Unfortunately Danny Baker's Sausage Sandwich game has been taken off the air again, and I'm suffering from withdrawal already. Please alleviate my symptoms by writing a program or function to play the Sausage Sandwich game.

You need to guess how the target prefers to eat a sausage sandwich, given one of the three sauce options. Given an input positive integer n, then the following applies:

• There is a uniformly random 1 in n chance that the target chooses no sauce at all.
• Otherwise, there are equal chances of red sauce or brown sauce.
• However, if n is even, then there are n-1 remaining chances, which don't divide by 2. If you draw this n-1th chance you should consistently (for a given n) output the same answer. Please indicate how this is chosen in your answer.
• Output must consist of the phrases "red sauce", "brown sauce", or "no sauce at all", in any of lower, sentence, title or upper case.

This is code-golf, so the shortest program or function that breaks no standard loopholes wins.

Answer 7

Print the Golfican sequence

---

The Golfican sequence is a sequence of integers, \$u\$, defined as follows:

• If \$n\$ is a power of \$2\$, then \$u_n=\log_2n+1\$.
• If \$n\$ in not a power of \$2\$, then \$u_n=u_p\$, where \$p\$ is the number of numbers from \$1\$ to \$n\$ inclusive which are not powers of \$2\$.

So, the first numbers in this sequence are \$1,2,1,3,2,1,3,4\$ and so on. Your job is to write a program which takes a number, \$x\$, as input, and outputs \$u_x\$. This is code-golf, so the shortest program in bytes wins.

---

code-golf math

---

I couldn't find a corresponding OEIS sequence for this. Thoughts?

Answer 8

Posted

Answer 9

Output efficient Church encodings of natural numbers

code-golf lambda-calculus

The Church encoding of a natural number \$n\$ in lambda calculus is the higher-order function which takes a function \$f\$ to its \$n\$-fold iterate \$f^n = f \circ \cdots \circ f\$. For example,

0 = \f.\x.x
1 = \f.\x.f x
2 = \f.\x.f (f x)
3 = \f.\x.f (f (f x))
...

Challenge

Write a function or program which takes a natural number \$n\$ and outputs a lambda calculus expression which is \$\beta\eta\$-equivalent to the Church encoding of \$n\$.

Input

Any natural number, including possibly 0.

Output

A lambda calculus expression in any format of your choosing, as long as it's an encoding that is pure data, or an equivalent in your programming language (e.g. if you wanted to write a submission in lambda calculus itself, the output must be a term which has a normal-form equivalent). Acceptable types of output would include a string or a data structure.

Whatever output format you choose, it must be a format which unambiguously maps to lambda calculus terms, and allows specifying any general lambda calculus term. You must then specify the mapping.

One possibility for a somewhat compact string encoding of typical lambda calculus terms would include terms such as:

\(0=\f x.x)(compose f g=\x.f(g x))(succ n=\f.compose f (n f)).succ(succ(succ(succ 0)))

Here, \ represents a lambda; lambda binding is considered right-associative; and function application is written as a concatenation and is considered left-associative. Then for example, \v1 v2 v3.body is syntactic sugar for \v1.\v2.\v3.body. As in the above example, this language also has syntactic sugar for let-style expressions where \(f a1 ... an=fbody).letbody (which in more verbose languages might be read as let f a1 ... an=fbody in letbody) is syntactic sugar for (\f.letbody)(\a1 ... an.fbody).

Requirements

The crucial part of the challenge is that the encoding must be efficient: the output for input \$n\$ must be of length or total size \$O(\log n)\$.

Scoring

This is code-golf: shortest submission in bytes wins. (In case of a tie, I might compare the "lambda complexity" of the outputs for input 2019, defined as the number of function applications plus the number of lambdas plus the number of variable terms excluding variables in lambda binders.)

Sandbox questions

I'm wondering whether the output format specification might be too lax. (For example, what if somebody gets a shorter submission using highly nonstandard syntax such as specifying that function application is right associative instead of left associative, so instead of s(s(s(s 0))) they could write s s s s 0?) On the other hand, if I required my "lambda calculus with syntactic sugar" format, then that might be considered akin to "here's my newly invented language, try golfing in it" which I'd think would be frowned on. Plus it might disadvantage languages which are good for golfing data structure creation but not as good for golfing output formatting.

Answer 10

Optimize Grocery Bagging

code-golf combinatorics optimization

---

You've gone to the store and are at the checkout. Now since you want to be environmentally conscious (or are somewhere that charges for bags and want to save money), you've brought a few reusable bags and would like to minimize the number of plastic bags you use (There are no paper bags here).

Each reusable bag can carry 5 kg (5,000 grams) of groceries and each plastic bag can carry 2.5 kg (2,500 grams) of groceries. You will be given a list of weights of groceries (in whole grams) and a number of reusable bags and your task is to output a configuration of bagging that requires the fewest number of plastic bags.

Examples

• Input: 1 reusable bag, groceries: [150, 500, 800, 1250, 2000, 300, 550, 400, 750, 900, 1000, 600]
  • Output: Reusable[2000, 1250, 1000, 750], Plastic[600, 900, 550, 150, 300], Plastic[500, 800, 400]

More TBD

Rules and Assumptions

• Standard rules and loopholes apply
• Any convenient input or output method is acceptable as long as which bags are reusable is unambiguous in the output (without calculating anything).
• You may assume that there are no groceries larger than 2.5 kg. (No jugs of milk)
• All groceries listed require a bag. Unbaggable groceries will not be listed. (No hypothetical 24-packs of toilet paper)
• Any grocery item can be bagged with any other. (No need to worry about bread and cans of beans being in the same bag)
• Groceries cannot be split into multiple bags.
• There is no double-bagging.
• Complexity doesn't matter. There may be inputs that would require computation past the heat death of the universe to complete.

Happy Golfing!

---

Related

Sandbox: This could work as a restricted-complexity problem or fastest-code due to the naive solution being in \$O(n!)\$. Thoughts?

Answer 11

Beziér me a curve!

code-golf

Task: Create a program that will, given a number N, create a Beziér curve with N control points and output its equation.

The definition of a Beziér curve is $$ B(t) = \sum_{i=0}^n{{n\choose i}(1-t)^{n-i}t^iP_i} $$

Practically, this means that for a quadratic Beziér cuve: $$ B(2) = \sum_{i=0}^2{{2\choose i}(1-t)^{2-i}t^iP_i}\\ B(2) = {2\choose 0}(1-t)^2P_0 + {2\choose 1}(1-t)tP_1 + {2\choose 2}t^2P_2\\ B(2) = (t^2-2t+1)P_0 + 2(t^2-2t+1)P_1 + t^2P_2\\ B(2) = P_0t^2-2P_0t+P_0 + 2P_1t^2-4P_1t+2P_1 + P_2t^2 $$

where \$P_0\$ is the first control point, \$P_1\$ is the second control point and \$P_2\$ is the third control point.

Note that De Casteljau's algorithm may be useful.

Rules

• The input will be a number (string or number).
• The output will be a list of lists. Take an element \$l_n\$ of the top-level list. The elements of \$l_n\$ will be all the terms that, in the expanded form, are multiplied by \$P_n\$. -1t and t^1, as well as t^0 are all fine.
• Standard loopholes are not allowed.

Test cases

2:

[
  ["t^2", "-2t", "1"],
  ["2t^2", "-4t", "2"],
  ["t^2"]
]

5:

[
  ["-t^5", "5t^4", "-10t^3", "10t^2", "-5t", "1"],
  ["t^5", "-4t^4", "6t^3", "-4t^2", "t"],
  ["t^5", "2t^4", "t^3"],
  ["-t^5", "t^4"],
  ["t^5"]
]

The program with the shortest length wins. Be creative!

Answer 12

Reading the text of the millitext font

There is a font here that fits each character into a single, 1x5 pixel block. It does this (assuming you're using an LCD screen) by using the RGB channels of each pixel to expand the one pixel into three subcolumns, one for each channel. Your task is to take in a string of text that describes this font and return the correspond text encoded.

Millitext Alphabet

CHARACTER: 0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ
ENCODING:  WYWBMRRMMMWYWYWWWMWBMRMYGYGYCWMMMMMW
           MGBWMRRMMMMMRMRRRMGBMRWMMMMMRGMMMMMB
           MGWWWWWBWWWYRMWWMWGBYRWMMYMYGGMMWGGG
           MGRBBBMBMBMMRMRRMMGBMRMMMRWMBGMCWMGR
           WWWWBWWBWWMYWYWRWMWWMWMMGRCMYGWBMMGW

I've abbreviated each color to a one character symbol (R=red, G=green, B=blue, C=cyan, Y=yellow, M=magenta, W=white).

Input Format

The input format for this is pretty open. You can have the input be an array containing each column, an array containing each row, a char[][], or anything like that. You can also choose to use the full words "red", "green", "blue", with uppercase/lowercase of your choice (but it must be consistent for each word! You cannot use "RED" and also do "green" or "Blue").

If your language happens to support it, you can also have input be colors (however that might work, I don't know off-hand).

You can assume that the input will ONLY contain encoded characters in the alphabet above (in particular, there will be no spaces or punctuation in your output).

Output Format

You can either output a string or some sort of character array. You can chose whether the letters are uppercase or lowercase, but they must all have the same case.

Example

MWRRGMGYRY
MRRRMMMMRM
WWRRMWMYRM -> HELLOWORLD
MRRRMWMMRM
MWWWGMGMMY

Rules

This is code golf, so shortest answer wins!

Test set

WYWBMRRMMMWYWYWWWMWBMRMYGYGYCWMMMMMW
MGBWMRRMMMMMRMRRRMGBMRWMMMMMRGMMMMMB
MGWWWWWBWWWYRMWWMWGBYRWMMYMYGGMMWGGG -> THEQUICKBROWNFOXJUMPEDOVERTHELAZYDOG
MGRBBBMBMBMMRMRRMMGBMRMMMRWMBGMCWMGR
WWWWBWWBWWMYWYWRWMWWMWMMGRCMYGWBMMGW

Answer 13

I Love U So Much!

Just print i love u, or I Love U.

But, because i love u so much, there is two rule.

1. At least there must be one I, and one U. Capital or not is regardless.
2. Every I and U must be stick together. No sole i and sole u.

This is code-golf, so shortest code with byte wins.

restricted-source code-golf

Answer 14

Trace My Triangles

Triangular is a 2D programming language that reads its code in the shape of the smallest triangle that the code will fit into, ignoring all whitespace. Its IP starts at the very top point of the triangle, and traverses the code starting in a Southeast direction. The IP's direction can be changed with the following directional switches (Note that "." is a no-op):

   ^
  ` /
 < . >  
  , \
   v

---

Challenge

You will be given a single input string p which represents a valid Triangular program. Your task is to write a program or function, which will print or return the actual execution order of p. Instructions in p which are never reached by the IP can be ignored.

You may assume the following:

• p will contain only characters which are necessary for a Triangular program to be valid; no need to account for whitespace.
• p will only switch directions via the directional switches listed above. The o,e,c and z instructions will not be used.

Examples

Input:                    Output:
---------------------------------------------------
F\(?)1/%-<                F(1<-%/?\)

,%./                      ,%/

\@~/;<                    \~<;/@

123456                    136

This is code-golf, so the shortest byte count wins.

---

Sandbox

• Is this a good idea for a question/not a dupe?
• Is the requirement clear enough?
• What other test cases should I be adding, if any?
• Should jump-related instructions - (, ) and ] - also be among the things that can be disregarded?
• Should any other sorts of instructions be disregarded?
• Would any other assumptions make this more manageable/fun?

Answer 15

I'm not able to find a challenge which will return as an integer how many days until Christmas based on an input like DDDD-MM-YY. So...

How many days until Christmas?

Work out the number of full days until Christmas based on today's date based on the Western Christianity date source.

Write a program, method, function, routine or sub-routine that accepts an input of the current date according the the Gregorian calendar source. The date may be in any format as long as you use the full year (so 2019-09-11 rather than 19-09-11). Other than requiring the full year, the date format is up to you (DD/MM/YYYY or MM/DD/YYYY or even formally written dates like Wednesday 12th June 2019). Please state what date format you are using in your answer.

An integer is displayed according to your standard output.

Example:

input -> output:

12/06/2019 -> 196 days until Christmas*
12/25/2019 -> 0 days until Christmas**

* DD/MM/YYYY format
** MM/DD/YYYY format

Answer 16

Is this set doubly orderable?

For input you are given a set of four or five sets of strings. Each string is at least two characters long; those first two characters are always digits but the remaining characters can also be letters.

The set of sets is doubly orderable if an ordered list can be constructed using one element from each member of the set such that:

• The first characters of each element of the list are in nondescending order
• The second characters of each element of the list are separately in nondescending order
• If any elements of the list have more then two characters, then those elements are all wholly equal with each other and appear at the beginning of the list (while still satisfying the other conditions).

Although there is an ordering on the list itself, the original sets can be sampled in any order necessary to achieve a valid list.

Example valid lists:

13  24  25  36
13e 13e 13  13
33s 37  37  37

Example invalid lists:

13  33  15  35  (first character not in order)
13  15  33  35  (second character not in order)
13e 24s 25  36  (different overlong strings)
33  37s 37s 37s (overlong strings are not first)

For output you should have:

• A consistent value indicating that the set is not doubly orderable
• A consistent value indicating that the set is can be doubly ordered using only 2-character strings
• A list of all overlong strings of which one is needed to make a valid list.

Full example:

1. 13 23 33 14 24 34 15 25 35 16 26 36 17 27 37
2. 33s 15e 16 17e
3. 34 25
4. 17e 37

In this example the 34 and 25 in set 3 force us to use either 33s or 15e from set 2 and therefore the 37 from set 4, with a number of options from set 1. Since all the valid lists begin with either 33s or 15e, these are the outputs.

Answer 17

Proving that a Russian cryptographic standard is too structured

Answer 18

Continue a progression code-golf math

The \$k\$th generalized mean \$M_k\$ of a set of numbers is defined as $$M_k(a_1,\dots,a_n)=\root^k\of{\frac{a_1^k+\dots+a_n^k}n}.$$ \$M_0\$, the geometric mean, is defined through a limit \$\lim_{k\to0} \root^k\of{\frac{a_1^k+\dots+a_n^k}{n}} = \root^n\of{a_1\cdot\dots\cdot a_n}\$. \$k\$ does not have to be integer.

An arithmetic progression is (according to Wikipedia) a sequence of numbers such that the difference between consecutive terms is constant. A geometric progression is a sequence of numbers such that the ratio between consecutive terms is constant.

There is a simple way to generalize these (that also explains why on earth is geometric progression named geometric): for a progression of order \$k\$ for any 3 consecutive elements \$a\$,\$b\$,\$c\$ \$M_k(a,c)=b\$. This way, the arithmetic progression is of order 1 and the geometric progression is of order 0. The order does not have to be integer.

The task is, given 3 real positive numbers \$a,b,c\$, to find the next term in the progression formed by them.

Notes

• If multiple valid outputs exist, you can output any of them.
• It is guaranteed that a valid output exists.
• An output is valid if \$|o_{correct}-o_{program}| \le10^{-5} \cdot \max(o_{correct}, 1)\$.

Sandbox stuff

• I still have to prepare some test cases, especially for non-integer orders.
• Has this been asked before?
• Do multiple correct outputs ever exist? I feel like very often there are infinitely many.
• Does Mathematica have a built-in?
• Should I add a time limit? I feel like brute-forcing all floating point numbers and checking if they are valid outputs might be shorter than actually calculating.
• Should I restrict the order to be integer, or even just 0 or 1 (leaving only arithmetic and geometric progressions)?
• Is there a simple and beautiful formula for the next term that I was unable to find and that all answers will have to copy from each other? I could neither get Mathematica nor myself to solve any related equations.
• Is the grammar correct enough?

Answer 19

Nearest match with limited values

code-golf

---

When writing my solution for this challenge, I found that I needed to generate a target value using nothing but multiplication and increments/decrements, using a restricted set of values to use in the multiplication. Given that my choice of values was restricted, I had to brute-force what the optimum solution was. gObviously, this seems like a programming challenge!

The challenge is this: Given a target value t and set of allowed multiplier/multiplicand values, find the solution t=x×y±c (x and y are from the set of allowed values), that has the smallest value of c. If c is zero, indicate the solution as an exact match.

As this is a code-golf challenge, smallest code size wins. The standard rules apply.

Example program (ungolfed): Try it online!

---

I don't think that I saw this particular challenge before, but I may have missed some. This is my first challenge, so please let me know how I can make it better!

Answer 20

Conversion

Assume that there is a number a. In every conversion of that number, the number can either convert itself to its value plus the value of one of its digits, or convert itself to its value minus the value of one of its digits.

In this situation, find the minimum number of conversions one has to make in order to get to the number b. If b cannot be reached, output -1.

Input

Input one line containing the integers a and b (where 1 <= a, and b <= 10^6).

Output

Output a line containing one integer, which represents the minimum amount that one has to convert the number.

Example input and output (s)

Input:  1 10
Output: 5

Why?

   1
-> 1+1=2
-> 2+2=4
-> 4+4=8
-> 8+8=16
-> 16-6=10
=> 10

Answer 21

Meta command-line flag parsing code-golf

The challenge

Write a program or function which determines whether or not a chosen command-line flag has been passed into the compiler or interpreter, but without accessing command-line parameters directly.

Details

• You must take in no input.
• You are free to choose the flag that is being detected, but it must:
  • be a flag, meaning a boolean command-line parameter that does not take any arguments (e.g. -O3 in gcc)
  • not print anything by virtue of being present (e.g. flags that print a version number or usage help are disallowed)
• The output must be 1 if the flag is present, and 0 otherwise.
• The program must successfully run without errors, whether or not the flag is present.
• You may not make use of the arguments passed to the compiler/interpreter, whether directly by value or by a property such as string length, array length.
• Separately from the chosen flag, other command line parameters can be used, so long as they remain the same when running the code with and without the flag in question.
• This is code-golf; shortest answer in bytes wins!

---

Sandbox Questions

• Are there any other edge cases or loopholes that should be accounted for here?
• Is this a decision-problem, despite the challenge not being related to input?

Feedback welcome!

Answer 22

GPA calculator

A GPA is sort of weighted average based on the grades obtained in certain courses. There are a number of different systems, but for this challenge we'll use the following grades and their numeric values:

A: 4
B: 3
C: 2
D: 1
F: 0
P: —

The grade is P is a special case. For some courses, students can sign up to take a course as Pass/Fail. In the case of a Pass (P), the course has no effect on their GPA whatsoever, but in the case of a Fail (F), the course does affect the GPA.

All courses are weighted by the number of hours/credits they are taken for. So give the following transcript:

Course            Hours   Grade
------            -----   -----
Next Gen Perl       6       A
Advanced C-minar    1       C
Starting with Java  3       B

We would calculate the total points as 35 (6*4 + 1*2 + 3*3), and then divide it by the number of hours, or 10 (6+1+3) for a final GPA of 3.5. If Starting with Java had been given an F, the total points would be 26 with 10 hours, for a GPA of 2.6. However, if it had been a P, the total points would still be 26, but with only 7 hours, the GPA would be 3.71428571429…

Input

An arbitrarily long list/array/sequence/etc of transcript entries. The entries are simply a two item list/array/sequence/etc with one item being an integer value (doesn't have to be an actual Int value, floats are fine) of hours, and the other being the string ('A','B'...). The above example would have been:

[
  [6, 'A'],
  [1, 'C'],
  [3, 'B']
]

You may assume that the list will have at least one computable grade (so no empty transcripts, nor transcripts consisting only of P). If your language does not have strings, then you may use numbers for A/B/C/D/F/P, but their values must be similarly spaced (e.g. 10,11,12,13,14,25)

Output

A number representing the GPA (float or other non-Int value)

Scoring and Restrictions

Codegolf, so shortest code in bytes wins. Standard rules apply.

Sandbox questions

I thought about allowing for either +/- grades (A+, A, A-, B+...) which would definitely prevent using ASCII values as easily, but then that led me to the thought of having a second input which is a list of possible grades with their equivalent value, but I think that would start over complicating it and way over benefit languages with built-in hashing. Thoughts?

Answer 23

Tag: code-golf

Arrays

I originally wrote it in Chinese and am still working on translating it. Sorry for the inconvenience.

Given an array containing n integers A1,A2,…,An, where all of their initial values are 0. Please implement the four operations to the array described below:

Operations

Given the positive integer x and y, let every number in the range Ax~Ay (including Ax and Ay) be added by the given positive integer c;
Given the positive integer x and y, let every number in the range Ax~Ay be (similarly to the previous spec; the rest of the spec also conforms that rule) multiplied by a given positive integer c;
Given the positive integer x and y, let every number in the range Ax~Ay be changed to a given positive integer c;
Given the positive integer x and y, with regard to a given positive integer p, evaluate the value of the following expression :```[pow(Ax, p) + pow(A(x + 1), p) + … + pow(Ay, p)]7```

Input

In the first line of the test case, there are two positive integers n(where 1<=n), which represents the length of the array.

Then, input operations sequentially, where each operation occupies one line, and the input will be 4 positive integers as in: type x y num, where type is either 1, 2, 3, or 4; these identifiers correspond to the corresponding operation as described above. The meaning of x and y corresponf to the description (where 1<=x<=y<=n). When type is not 4, num will be the positive integer given c(where 1<=c<=10000); when type is 4, num will be the given positive integer p(where 1<=p<=3)。

Output

For each test case, for every 4 operation for the array, output the value of the corresponding expression.

Example input

5
3 3 5 7
1 2 4 4
4 1 5 2
2 2 5 8
4 3 5 3

Example output

307
7489

Answer 24

Answer chain: decreasing character scores

Assign a non-negative integer value to each letter in the alphabet, and write a function or program which takes as input a character string and outputs the sum of of the values of the letters in the string. Characters outside of [a-z] and [A-Z] have value 0.

Now run your code, taking as input the code of each of the previous answers in the order they were posted (including your own). The resulting sequence of scores should be strictly decreasing.

For example, if you are 4th to answer and your code defines a function \$f\$, then the output should verify \$f(c_1)>f(c_2)>f(c_3)>f(c_4)\$ where \$c_1\$ is the code of the 1st answer, \$c_2\$ is the code of the 2nd answer, ..., \$c_4\$ is the code of your answer.

When there will have been one week with no new answer, the 2nd-to-last answer will be declared the winner.

Clarifications:

• The values you assign may be the same as or different from those used by previous answers.
• The value 0 is allowed.
• Different letters may be assigned the same value.
• Upper and lower case versions of the same letter may have different values.
• Letters with diacritics, such as é or Ä, have value 0.
• Your code need not handle letters which have not occurred in any of the previous answers (so if no answer so far has used the letter W, it's OK if your code fails on strings with a W).

Answer 25

Enable 2-char Jsfuck

Provide a shortest code that makes JavaScript able to do everything JavaScript is supposed to do, i.e. able to access(so no deleting [].prototype.toString unless you have a backup, even if you can simulate one [].prototype.toString) and exec anything, with only [ and ]. You can choose your environment(FF/node/etc). Answering in 6-char JsFuck or something similar is welcomed.

E.g. If you run

Array.prototype[''] = 'a';
Array.prototype['a'] = 'b';
Array.prototype['b'] = function() { console.log(this[0]); };

then [][[]] = [][''] = 'a', and [][[][[]]] = []['a'] = 'b', so [[][[]]][[][[][[]]]] = ['a']['b'] = function(){console.log('a')}.

Of course, this is an invalid answer, because it can't do prompt(web browser) or fs(node) or anything similar, or even calling the console.log.

Answer 26

Tips for golfing in H

As for H as described here, what general tips do you have for golfing in H? I'm looking for ideas which can be applied to code-golf problems. Tips have to be specific to H (e.g. "remove comments" is an answer).

Tips in Standard H are also on-topic, although its spec is in a bad condition. You can use the H description provided in the first link to solve anything you don't understand about.

Please post one tip per answer. Also, please specify which H implementation you are using if your code runs only under a specific H implementation, as different H implementations can have different behavior.

---

code-golftips

Answer 27

Find the closest hex colour shorthand

In CSS, colours can be specified by a "hex triplet" - a three byte (six digit) hexadecimal number where each byte represents the red, green, or blue components of the colour. For instance, #FF0000 is completely red, and is equivalent to rgb(255, 0, 0).

Colours can also be represented by the shorthand notation which uses three hexadecimal digits. The shorthand expands to the six digit form by duplicating each digit. For instance, #ABC becomes #AABBCC.

Since there are fewer digits in the hex shorthand, fewer colours can be represented.

The challenge

Write a program or function that takes a six digit hexadecimal color code and outputs the closest three-digit color code, where closeness is measured by adding together the difference between each component of the full color code and the corresponding component of the shorthand color code.

Here's an example:

• Input hex code: #28a086
• red component
  • 0x28 = 40 (decimal)
  • 0x22 = 30
  • 0x33 = 51
  • 0x22 is closer, so the first digit of the shortened color code is 2
• green component
  • 0xa0 = 160
  • 0x99 = 153
  • 0xaa = 170
  • 0x99 is closer, so the second digit is 9
• blue component
  • 0x86 = 134
  • 0x77 = 119
  • 0x88 = 136
  • 0x88 is closer, so the third digit is 8
• The shortened color code is #298

Your program or function must accept as input a six digit hexadecimal color code prepended with # and output a three digit color code prepended with #.

Examples

• #FF0000 → #F00
• #00FF00 → #0F0
• #D913C4 → #D1C
• #C0DD39 → #BD3
• #28A086 → #298
• #C0CF6F → #BC7

Answer 28

Golf an H quine [duplicate]

Your task is to write a quine program in H (described in my esolangs.org userpage). (It is unclear whether it is possible.) Referring to Computer Science stack exchange, which seems unappropriate.

---

code-golfcode-challengestringquine

Answer 29

Machine Learning Golf: Fashion MNIST

The first instance of Machine Learning Golf received a lot of intention but also revealed some problems (mostly caused by people in this community being too clever ;-)).

I intend to address those issues in this second installment:

Fashion MNIST is a dataset of 60,000 labelled 28x28 pixel grayscale images of fashion items (T-shirts/tops, Trousers, Pullovers, Dresses, Coats, Sandals, Shirts, Sneakers, Bags and Ankle boots).

Your task is to design and train a neural network that correctly identifies these images. Here are the rules:

Performance Goal

To qualify, your model must achieve at least 95% accuracy on the training set (i.e. you must identify at least 57,000 images correctly).

Rules

You may use any language and framework of your choice.

Your dataset must be taken as the current version of Fashion MNIST found here or in the references listed in that repo's README (for convenience).

You may reshape, permutate, rescale and offset entries in the dataset. However, modifications made to one entry must be performed on all entries.

You may transform the labels any way you like. (But you may, obviously, not change which labels correspond to which images.)

During training, you're allowed to use any dataset you want (in fact, you are allowed to come up with your weights however you like). Hence the above limitations are only relevant to assess whether your model meets the stated performance goal.

Your model

• must be a 'traditional' feed forward neural network, i.e.a node's value is calculated as a weighted linear combination of some of the nodes in previous layers (which may include a bias node with constant value 1) followed by an activation function. Note that this allows you to skip layers and use convolutional/residual layers,
• may only use the following standard activation functions:
  1. \$\mathrm{linear}(x) = x\$,
  2. \$\mathrm{softmax}(\vec{x})_i = \frac{e^{x_i}}{\sum_j e^{x_j}}\$,
  3. \$\mathrm{selu}_{\alpha, \beta}(x) = \begin{cases} \beta \cdot x & \text{, if } x > 0 \\ \alpha \cdot \beta (e^x -1 ) & \text{, otherwise} \end{cases}\$,
  4. \$\mathrm{softplus}(x) = \ln(e^x+1)\$,
  5. \$\mathrm{leaky-relu}_\alpha(x) = \begin{cases} x & \text{, if } x < 0 \\ \alpha \cdot x & \text{, otherwise} \end{cases}\$,
  6. \$\tanh(x)\$,
  7. \$\mathrm{sigmoid}(x) = \frac{e^x}{e^x+1}\$,
  8. \$\mathrm{hard-sigmoid}(x) = \begin{cases} 0 & \text{, if } x < -2.5 \\ 1 & \text{, if } x > 2.5 \\ 0.2 \cdot x + 0.5 & \text{, otherwise} \end{cases}\$,
  9. \$e^x\$
• must take a single entry of the (preprocessed) training set as its only input and
• return the predicted label, in the format you've specified, as its only output,
• if a given weight occurs multiple times in your model, you may reuse it to lower your overall score,

Your answer must include (or link to) all code necessary to check your results -- including the trained weights of your model. In particular, you must include all preprocessing steps of your dataset.

Scoring

The neural network with the smallest number of weights (including bias weights) wins.

Parameters used to preprocess your data don't count as weights.

Enjoy!

Baseline

There is a tutorial for the Fashion MNIST dataset available on Tensorflow which serves as an excellent starting point if you decide to use TF as your framework.

---

This challenge had already been posted on the main site and got closed there. The purpose of this post is threefold:

1. Is the community interested in this particular (and this kind of) challenge (in general)?
2. How can the user experience for the target audience be improved? Specifically:
   • What are likely causes of confusion?
   • Can we streamline the structure?
   • Are some of the rules too restrictive or not restrictive enough?
   • Are there any loopholes I've overlooked? (For instance, preprocessing the training data opens up the possibility of encoding labels into the feature set. Some of the rules are already designed to prohibit this but it's entirely possible that they don't suffice.)
3. Any other constructive feedback?

Answer 30

Calculate a constant from its characteristic function

You are given in some language-dependent way (e.g. a lambda parameter) a characteristic function which is basically another way of saying a decision-problem function. This function will take an integer input and return true or false, or 1 or 0, or any other two 1-byte values of your choice. You can decide whether you need the function to be 0-indexed or 1-indexed.

Your job is then to take this function and calculate the floating-point value obtained by interpreting the values of this function as a binary fraction. You must use as many significant digits as possible. I will assume IEEE double precision by default but you many use single precision if your language specifically supports it.

For example, if a function returns the sequence 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0 (this is OEIS A010051), then your program or function will output 0.41468250985111166 as any further terms will be less than the precision of a double-precision value.

You can decide whether you want to round the 54th significant bit up or not.

This is code-golf, so the shortest program or function that breaks no standard loopholes wins!