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

Formulize the sum: Faulhaber's formula

code-golf math polynomials sequence

Sums of the form Σkⁿ over k in 1..x can be turned into a polynomial of x whenever n is a natural number.

Examples

Σ1 = x
Σk = (1/2)x²+(1/2)x
Σk²= (1/3)x³+(1/2)x²+(1/6)x

Criteria

You will take n as a non-negative integer input and output the coefficients in reduced fraction form of the resulting polynomial from leading coefficient down to the last non-zero coefficient.

This is code-golf, shortest code wins.

Test cases

0 #=> 1
1 #=> 1/2 1/2
2 #=> 1/3 1/2 1/6
3 #=> 1/4 1/2 1/4  0
4 #=> 1/5 1/2 1/3  0 -1/30
5 #=> 1/6 1/2 5/12 0 -1/12

(extra spacing here is just for clarity and is not necessary.)

Answer 2

The Hungry Moose

code-golf

Inspiration.

Moose face harsh conditions during the winter. According to one source:

Their winter foods are lower quality than what they eat in summer and provides less energy, consequently, they need to eat more of it. During harsh winters, having both extreme cold temperatures and deep snow, moose expend more energy than they take in and many can starve.

Challenge

At noon on day 1, a hungry moose starts at a food source (the top left corner). Each morning, the moose may either walk to any 8-adjacent square or stay in place. Each evening, the moose clears the food and snow from its location (adding its net nutritional value to its calorie store and setting that value in the array to 0), and before the end of the day loses 1 calorie to the extreme cold.

The moose dies when its calorie store falls to 0 or below at the end of a day. In particular, if the value at the upper-left corner is 1, 0, or negative, the moose dies on day 1.

Input

A 2D array of integers. Negative numbers represent calorie-negative deep snow.

Output

The maximum number of days the moose can survive (counting day 1 as a full day).

Test cases (add)

6 0 -2 3
0 0 -5 -5
0 0 -1 3
8

42 -100 1
-100 -100 2
3 4 5
42

5 -3 1
1 -9 9
12

Answer 3

Inscriptio Labyrinthica

In the burial place of King Silo of Asturias there is an inscription that reads SILO PRINCEPS FECIT (King Silo made this).

The first letter is found in the very middle, and from there one reads by going in any non-diagonal direction radiating outward. The final letter is found on all four corners. In this challenge, you'll generalize the process to make them.

Input

A string (or equivalent), and an integer. You may make the following assumptions about the input:

• The string will have an odd length.
• The integer will be an odd number between 1 and one less than twice the length of the string.

Output

An inscriptio labyrinthica for the string, using the integer for the height (see models). Output should be each letter with no spaces, line break as default to your system/language.

Test cases

Note that an input of 1 or (length * 2 - 1) will result in a horizontal or vertical palindrome.

 Input: FOO, 3    Input: BAR, 1    Input: BAR, 3    Input: BAR, 5

Output: OOO      Output: RABAR    Output: RAR       Output: R
        OFO                               ABA               A
        OOO                               RAR               B
                                                            A
                                                            R

 Input: ABCDE, 5   Input: ABCDE, 3   Input: *<>v^, 3

Output: EDCDE     Output: EDCBCDE           ^v>v^
        DCBCD             DCBABCD           v><>v
        CBABC             EDCBCDE           ><*<>
        DCBCD                               v><>v
        EDCDE                               ^v>v^

Scoring

This is code-golf so shortest answer in bytes wins. Standard loopholes forbidden.

(I feel like I've seen one similar, but searching around I couldn't find it, and I happened to be reading about this king when I got the idea).

Questions

In my original proposal, I had listed as a bonus to draw reading lines, but feedback was bonuses in code golf are discouraged. I still like that idea and am thinking about integrating it as a a main part of the challenge, but don't know if that would over complicate it or actually make it more interesting. The output for REI, 3 in such a case would be

I←E→I
↑ ↑ ↑
E←R→E
↓ ↓ ↓
I←E→I

The idea is that it would prevent simple flipping of data after calculating a quarter or half of the but still perhaps allow for some creative ways (I can think of some creative ways to do it shortly in some languages, but maybe it'll be overly complicated for others).

Answer 4

Golf the truth and null values

In many programming languages there is a null and/or other special values. Sometimes they don't follow the normal rules of boolean operations. They may not even agree with the values of the same name in other languages.

Here are some different kinds of the "extended" boolean values, either borrowed from some languages or invented myself:

• False.
• True.
• Absent. All operations between absent and another operand return the other operand.
• Whatever. All operations between whatever and another operand returns whatever (itself).
• Partial. If the result can be decided using the other operand, return that. Otherwise return partial (itself).
• Error. An error as the first operand works like whatever, and an error as the second operand works like partial, except that "itself" means error. It has higher precedence than whatever and partial.

Your task is to define all these values in your language, and the 2 operations and or.

To be clear, the 2 operations should work exactly as in the following tables. The left column represents the first operand, and the top row the second operand.

and F T A W P E       or F T A W P E
  F F F F W F F        F F T F W P E
  T F T T W P E        T T T T W T T
  A F T A W P E        A F T A W P E
  W W W W W W W        W W W W W W W
  P F P P W P E        P P T P W P E
  E E E E E E E        E E E E E E E

Rules

You could use anything distinct and consistent to represent these values. You don't have to use a truthy value to represent true, or a falsy value to represent false. You are allowed and encouraged to use values that contain useful code, i.e. this loophole is not forbidden.

You are allowed to use actual errors or exceptions to represent some of the values. In this case the definition of that value should throw the same error, instead of represent the caught error. But the caught errors or the output messages should be distinct and consistent. Alternatively, you may choose to include STDERR in the output of your code, and use the printed message string as a normal value.

You may choose to pass functions generating and returning the values but doing nothing else to your code as input, in place of the values themselves, without counting the extra code.

You may use different ways of input/output for different values, as long as it is consistent for each kind of value, and it is possible to tell apart the first and the second operand.

You are allowed to use builtin functions and operators without boilerplate, in any argument order, even if you cannot save them in something callable in your language.

There could be some common code shared by all the 8 definitions and appear only once as header/footer. Other than that, the 8 definitions of operations and values must work independently from each other. The only way you can call something defined in the values in the operations is through a valid input method (e.g. you cannot set a variable in a value and read it in an operation).

Your score is the length of common code * 12 + the total length of the 2 operations * 6 + the total length of the values. Smallest score wins. The length of a value is either the length of the code generating it, or the length of itself unquoted if all the values are strings and you choose this way.

---

Abandoned rules

You are allowed to use operators, or chains of operators and values to represent the 2 operations, even if you cannot save them in something callable in your language. You may require the operands to appear at specific positions, but each operand must appear exactly once and be grouped together. You may choose whether to save operands in variables previously, and don't count the assignment if it doesn't add new information in the assignment (e.g. by changing its type). This makes it possible to use the built-in operators with short-circuit evaluation in languages that don't allow redefining them and preserve this characteristic, and may also make it shorter in some other languages.

Previous scoring: total length of the 2 operations * 50 + the total length of the values.

Possible follow-up

Original title: All the weirdness about the nulls

Extended tables including Valid in a previous version, Reverse aka Opposite by Zgarb, and Possible.

and T F N O W E V R P     or T F N O W E V R P
  T T F T O W E ? F T      T T T T T W T T T T
  F F F F F W F F F F      F T F F O W E ? T F
  N T F N O W E ? ? ?      N T F N O W E ? ? ?
  O O F O O W E ? O O      O T O O O W E ? O T
  W W W W W W W ? W W      W W W W W W W ? W W
  E E E E E E E ? E E      E E E E E E E ? E E
  V T F ? O F F ? ? ?      V T T ? T F F ? T ?
  R F F ? O W ? ? ? ?      R T T ? O W ? ? ? ?
  P T F ? O W ? ? ? ?      P T F ? T W ? ? ? ?

Other potential additions:

• Default, that is opposite to Opposite.
• Merge Possible with Valid.

Sandbox questions

1. Will this be too easy in some languages that already have all of them?

   In languages that has True defined to be -1 and unifies bitwise and logical operations, most integers would works as Partial. GCD/LCM in APL is similar to this. SQL null is Whatever Partial. Most languages that has shortcut evaluation has errors as Error. Not sure about Absent, though.

   (Maybe the easiest way to find out is to post this question. It doesn't make the answer bad. But it's just some consideration in the sandbox for me to decide whether I'll post a stronger version.)

2. Allowing "operators and chains of operators" seems to open a can of worms. Should I just remove this rule?

Answer 5

Knight's tour

code-golf chess

---

A knight's tour is a sequence of moves of a knight on a chessboard such that the knight visits every square only once. For those who are not aware of how knights in chess work, knights are capable of moving in an L shape:

Tours generally apply to a regular chessboard of size \$8\$ however, it can be calculated for other sizes. For example, for a chessboard of size \$5\$, a possible knight's tour is:

Each grid size has quite a few combinations, for example, when \$n = 5\$, there are \$1728\$ possible tours and for a regular chessboard (where \$n = 8\$), there are \$19591828170979904\$. This is OEIS A165134.

Challenge

Write a program/function that takes a grid size \$n\$ and outputs a possible valid board of integers.

Specifications

• Standard I/O rules apply.
• Standard loopholes are forbidden.
• \$n > 4\$
• This challenge is not about finding the shortest approach in all languages, rather, it is about finding the shortest approach in each language.
• Built-in functions that compute this sequence are allowed but including a solution that doesn't rely on a built-in is encouraged.
• Explanations, even for "practical" languages, are encouraged.

Test cases

Yet to come.

Answer 6

Babel on and on (working title...)

Background

Babel is a cornerstone of modern web development. It takes Javascript using new or proposed ECMAscript features and "transpiles" it into an older language version, so that browsers can run it without updates. In order to do this it inserts its own shim methods, and own custom transforms.

The Challenge

Your objective is to write the Javascript code which produces the largest babel output in characters. Your code must be less than or equal to 128 bytes in length

Babel has an online, interactive compiler which you can access HERE. It's highly recommended that you use this to form your answer. If you work locally, you are restricted to modifying only the settings that the babel website allows you to modify.. There is a guide on installing babel at the end of the question.

Rules

• For consistency, you may use a Babel version between 7, but not above 8.* (when it eventually comes).
• You may change the interactive REPL's settings, source type, presets, options, and env-presets. You may change these settings locally if you are using a local installation of babel.
• You may only provide one input file.
• You may not exceed 128 bytes in your input file.
• You may not add your own plugins.
• You may not use the loophole listed below, or any of the standard loopholes.
• You may not use error output as a result. babel must transpile the code successfully under one of the allowed configurations.
• Neither your input or output need to run, or halt. The compilation just needs to output something.

Examples

41 in, 1075 out

{t: [...(function*(){let [a,b]=[1,2]})]}

32 in, 1101 out

export class b{d=function*(){}}

125 in, 7336 out

const b = function*(){return function*(){return function*(){return function*(){return function*(){return function*(){}}}}}};

Scoring

You must provide both the code and the settings you are using. For users of the online REPL, a link with the settings set in the URL suffices. The answer with the largest output with an input less than or equal to 128 bytes wins. Unlike many challenges of this nature, settings do not cost any bytes of input.

Setting up a local environment (OPTIONAL)

Most of the people doing this challenge will probably use babel's online transpiler to complete it. In the event that the website is taken down in the future or made inadequate for the challenge, it can be completed locally. Make a folder for the challenge, and in a shell in that folder, try something like the following:

Install Babel (globally - you could do it locally)
sudo npm install -g @babel/core @babel/cli
Set your .babelrc with a preset (in this case env)
echo '{"presets": ["@babel/preset-env"]}' > .babelrc
Install babel's dependencies
npm install --save-dev @babel/preset-env @babel/core

Then, given an input file test.js, you can figure out your output score with

babel test.js | wc -c

Happy Hunting!

Questions

This is my first time ever posting one of these. Does everything look on the up-and-up?

Also, should this incorporate "the less characters of input, the better?". I kept trying to think of ways to reward a large output for a small input, but every way I considered changed the tone of the challenge significantly.

Also also, I know that codegolf users don't like being constrained to one language. Is this bound to be an exception or will that stop the question in its tracks?

Proposed Tags: [BUSY BEAVER], [Javascript], [CODE CHALLENGE]

Answer 7

Castilian Numerals

A little known (but actually real) number system are the Castilian numerals. They were an odd mix of a digital and positional counting system used in Spain in the late middle ages. There are certain qualities about them, however, that make them not entirely straight forward to generate when you have lots of them in a group, in particular the fact they would be aligned by thousands places. Your challenge will be to print a vertical list of numbers, correctly spaced.

Description of the Numerals

A Castilian numeral is, in effect, a Roman numeral, but only uses 1-999, uses additives for 4 (IIIJ), 9 (VIIIJ), and 900 (DCCCC), and subtractives for 90 (XC) and 400 (CD). Both methods were commonly used for 40 (XL, XXXX). Additionally, final Is were written as Js, such that the sequence 1-6 goes J, IJ, IIJ, IIIJ, V, VJ. (This means standard Roman numeral generators will likely not be much help.) They were generally written lowercase, but for this challenge we'll use all uppercase.

For values under between 1-999, the fact that the letters indicated numerals was made clear by the presence of a symbol that looks like a U. Generally the numerals themselves were right aligned:

1          U           J
2          U          IJ
999        U DCCCXCVIIIJ

For values between 1000-999999, everything we would place to the left of the comma would be rendered as if it were its own independent 3-digit number and romanized, and the reminder placed to the right, such that

  1,000    J U
  1,001    J U          J
 21,030  XXJ U        XXX
500,444    D U CDXXXXIIIJ

For values 1,000,000-999,999,999, an additional separator was used, Q^to, but for our purposes, we'll just use Q. It would only be used if the number was over 1,000,000, unlike the U that always separated it.

  1,000,000       J Q       U
  1,000,001       J Q       U            J
  1,001,000       J Q     J U
  1,001,001       J Q     J U            J
123,456,789  CXXIIJ Q CDLVJ U DCCLXXXVIIIJ

As should be noticed, within each grouping of three (arabic) digits, everything is right aligned, with the thousands/million separators all in alignment. Because 0 didn't exist, it would just be left blank.

Input

A sequence of integers in whatever format you feel gives you the best advantage (a list, an array, a series, etc). You may assume that the integers are between 1 and 999,999,999.

Output

A printed list of Castilian numerals, properly aligned on different lines. Note the restrictions on 4/9: mandatory additives are 4,9,900; mandatory subtractives are 90 and 400; 40 is valid either way. The numerals for 1-999 should be right aligned, with a single space on either side of Q or U (there may be padding spaces, but the single longest numeral in each grouping will have the single space). Newlines may be whatever is native to your system/language.

Rules

This is code golf. Fewest bytes wins. Standard loopholes forbidden.

Test cases

Comments/observations are given after # and not part of the output.

Given: 1,2,3
U   J   
U  IJ
U IIJ   # one space between U and I

Given: 1,1000,10,100
  U J
J U     # trailing space not required
  U X
  U C

Given: 123,4,5678,111111111,90,12345,6789012
                U    CXXIIJ
                U        IV
              V U DCLXXVIIJ   # single space between U and the longest numeral
CXJ Q       CXJ U       CXJ   # Q only appears if >= 10^7
                U        XC
            XIJ U  CCCXXXXV   # also valid CCCXLV 
 VJ Q DCCLXXXIX U       XIJ   # single space between Q and the longest numeral

Answer 8

Polyglot wrappers

Many polyglots are a disastrous mess of unmaintainable code. Let's make this different.

Challenge

Make a polyglot "wrapper" such that code from two or more languages may be embedded in the file without modification.

Example

Consider the following polyglot wrapper for Bash and Python:

'''true'
B
exit 0
#'''
P

This wrapper can be used such that B can be replaced by an arbitrary bash script, and P can be replaced by an arbitrary python script.

After the scripts have been injected into the wrapper, running the resulting polyglot via either interpreter (bash or python) will result in functionally identical behavior as the original input scripts.

Rules

1. Your wrapper must support the injection of 2 or more languages
2. Your wrapper can use arbitrary markers for the string->script replacement
3. The markers must be at least 1 byte in size (no line number tricks)
4. Assume the replacement will be done by first replacing all markers with sufficiently long and random data, such that conflicts between the marker literals and contents of the input code cannot exist. However, your markers cannot conflict with the contents of the wrapper itself.
5. The behavior of the original input programs must not be altered by the wrapper. Ex: an input program that returns 0 must return 0 when run from your wrapper. An input program that crashes must still crash.
6. The winner is the polyglot wrapper that supports the most languages, with a tie breaker of smallest size (in bytes).
7. Allowances shall be made for a program that accesses itself on disk. Obviously no polyglot wrapper could correctly return identical output for a script that outputs its own file size.

Question for the sandbox

Is this sufficiently unique and understandable? Are there any loopholes I haven't covered?

Answer 9

Translate a simple sentence from Toki Pona

Answer 10

Is it a Snake Cube?

code-golfgeometrydecision-problem

A snake cube is a quite popular wooden puzzle. There are usually 27 cubes threaded on an elastic string. Each cube has a hole that either goes straight through from one face to the opposite face, or that makes a 90° bend, that means it exits through a face that is adjecent to the one it enters. (And the two end cubes into which this string enters. Two adjecent cubes on that string can rotate against eachother. The goal is rotating them all such that the whole "snake" forms a large 3x3x3 cube.

_{^{Images from Wikipedia (1)(2)}}

Obviously we cannot have any random sequence of the straight/90° pieces if we want to get a cube in the end. This leads us to the

Challenge

Given a sequence of the types of the inner 25 cubes of a "snake", determine whether it is possible to form a cube.

Example

I will here use the symbol T for a piece with a straight hole, and F for a piece with a 90° hole. The example in the image would be encoded (from the bottom left to the top right) as

TFFFTFFTFFFTFTFFFFTFTFTFT

Details

• You can take the input as a string or list/array or any other type of sequence.
• You can use different symbols for the two types, you could also take booleans or integers.
• The output is also flexible: You're can have two distinct output, one for each case, but they must be consistent. If it is not obvious (e.g. True/False) please specify which one means what.

Examples

No cube possible:

TFTFTFTFTFTFTFTFFTFFFTFFF (we have 8 consecutive (overlapping) straight runs of length 3)
TFTFTFTFFFFTFTFFFTFFTFFTT (we have a straight run of four pieces at the end)

Cube possible:

TFFFTFFTFFFTFTFFFFTFTFTFT
TFTFTFTFFFFTFTFFFTFFTFFFT

Answer 11

Hexagonify™ a String Block code-challengestringascii-art

Answer 12

Rennab

Reverse banneR

In the language of your own choosing write a program or function that takes as input the output of the super-handy-for-the-farsighted tool banner. And simply outputs the original text.

Example 1a of banner output on Linux:

> banner 'Code Golf'

   XXXX              XX                    XXXX            XX       XX
  X    X              X                   X    X            X      X
 X                    X                  X                  X      X
 X        XXXXX   XXXXX   XXXXX          X        XXXXX     X     XXXX
 X       X     X X    X  X     X         X       X     X    X      X
 X       X     X X    X  XXXXXXX         X   XXX X     X    X      X
 X       X     X X    X  X               X     X X     X    X      X
  X    X X     X X    X  X     X          X    X X     X    X      X
   XXXX   XXXXX   XXXXXX  XXXXX            XXXX   XXXXX   XXXXX   XXXX

Example 1b of rennab program that runs on Linux and takes input from stdin as lines of strings, and outputs to stdout, and supports the characters: [' ', 'C', 'G', 'd', 'e', 'f', 'l', 'o']:

> banner 'Code Golf' | rennab
Code Golf

Example 2a of banner output on Linux:

> banner ':-)'


                   X
                    X
                    X
    X                X
                     X
         XXXXXXX     X
                     X
                     X
    X               X
                    X
                   X

Example 2b of rennab program that runs on Linux and takes input from stdin as lines of strings, and outputs to stdout, and supports the characters: [':', '-', ')']:

> banner ':-)' | rennab
:-)

Choose what ever characters (minimum of 3) you want to support but that effects your score (see Rules below).

Rules

• Program or function - your choice.
• Input the output of banner in whatever format you'd like (eg 2d array of characters, list of strings, reading from stdin straight from the horse's mouth, &c).
• For this challenge we'll use Cedar Solutions' open-source GNU/GPL banner implementation common on Linux. Prints horizontally only with a fixed size.
• Output the original text in whatever format you'd like, return character at the end optional (eg as a string, a list of characters, as output to stdout, &c).
• You can assume only the characters supported are input.
• You must support a minimum of 3 characters.
• Score is calculated by this formula (where \$n\$ is the number of code bytes and \$c\$ is the number of characters supported): \$n - 8c\$.
• Scores can be negative.
• No standard loopholes.
• Lowest score wins.

Questions

• Has this been done before?
• Is the score formula any good? Any and all suggestions welcome.
• Is the question any good? Any and all feedback welcome.

Answer 13

Reversed Iota's code-golf

I didn't invent this challenge, but I find it very interesting to solve.

For every input number, e.g.:

4

Generate a range from 1 to that number:

[1 2 3 4]

And then, for every item in that list, generate a list from 1 to that number:

[[1] [1 2] [1 2 3] [1 2 3 4]]

Then, reverse every item of that list.

[[1] [2 1] [3 2 1] [4 3 2 1]]

Notes:

• 1 being a loose item is allowed, since flattening will not matter with this anyway.
• To preserve the spirit of the challenge, the range has to be 1-indexed.

Answer 14

Is it a doubling sequence?

Posted here:

Is it a doubling sequence?

Answer 15

Posted to main.

Answer 16

Is it a Happy Number? code-golf decision-problem

A repost of this challenge (if I got the policy right).

Given a single positive integer (which can also be taken as a list of digits or a string), output whether the number terminates at 1 . Truthy/falsy follows the language's convention, or you can choose exactly one value for truthy and another for falsy. (This sequence is A007770.)

Your program should theoretically support all non-negative integers; however, if your language doesn't support unbounded integers, you may only support integers up to 2147483647.

Procedure

Suppose you have the number 193.

• Square every individual digit in the number. Therefore the number's individual digits becomes:

[1] [81] [9]

• Sum all these individual digits:

92

• Repeat this procedure until it stabilizes at 1 or a 37-cycle like the following:

37-58-89-145-42-20-4-16-37

It has been shown that the procedure will always produce either one of these two outputs.

Test cases

Here is a sample program generating the test cases. Here is a step by step reduction of all input between 1 and 100.

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

Answer 17

Posted

Solve a Picross Row

Answer 18

Implement an HTML renderer code-golf ascii-art

Note: This challenge explaination is very much incomplete - it merely contains ideas that will require revising to form a proper challenge post.

The premise of the challenge is to write a program that take an HTML document as an input, and outputs an ASCII equivalent. Obviously, working with real HTML is not possible, so this challenge will use a very limited and modified subset of HTML.

Here is an example of a potential input:

<body>
    <h1>A Document</h1>
    <div>
        <span>Hello, this is some text</span>
        <img> 8 2 </img>
    </div>
</body>

Which would yield the following output:

+--------------------+
|A DOCUMENT          |
|                    |
|+------------------+|
||Hello, this is som||
||e text            ||
||+--------+        ||
|||@~@~@~@~|        ||
|||~@~@~@~@|        ||
||+--------+        ||
|+------------------+|
+--------------------+

HTML elements that will be implemented:

<span> - Renders text between the tags, wrapping when necessary.

Example:

<body>
<span>
    This is a span element.
    You can write text in here.
</span>
</body>

Output:

+--------------------+
|This is a span eleme|
|nt. You can write te|
|xt in here.         |
|                    |
|                    |
|                    |
|                    |
|                    |
|                    |
|                    |
+--------------------+

(Extra explanation needed to clarify whitespace and character set issues)

<p> (Explanations are omitted to save space)

<h1> - <h6>

<div>

<img>

Sandbox questions/remakrs

• I believe it is possible to write an unambiguous and specific set of rules for how an "HTML document" should be rendered
• It will require lots of careful explanation, wording, and ample examples
• However this challenge seems very long and complicated and it seems like it might not be in the spirit of a code golf challenge

What do you guys think?

Answer 19

Solve a 2xN Maze (posted)

Answer 20

Does the naïve fill suffice?

A bot is positioned in a rectangular grid. By preference it will paint in a west direction, but if it cannot it will paint in a south, east or if all else fails north direction. Sometimes this can lead it to fill the grid, but other times it gets stuck. The following examples show how the path (indicated by ascending digits) of the bot on a given grid varies depending on its starting position:

1

The bot is always able to fill a 1×1 grid, since simply by existing it has already painted the grid.

14    21    43    34
23    34    12    21

The bot is always able to fill a 2×2 grid. As a consequence of its painting direction preferences it normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise.

16    21    65    ..    56    65    165    216    321    654     345    456
25    36    14    21    43    34    234    345    456    123     216    321
34    45    23    34    12    21

The bot usually fills a 2×3 grid, except when it starts in the middle right square. On the other hand, it always fills a 3×2 grid; its painting direction preferences cause it to paint clockwise if it starts in the bottom middle or bottom right cell, otherwise anticlockwise.

189    21.    321    87.    987    ...    987    ...    987
276    387    498    165    216    321    236    345    456
345    456    567    234    345    456    145    216    321

The bot is able to fill a 3×3 grid when it starts in one of the even squares. It's mathematically impossible for the bot to fill it when it starts in an odd square, but I have included these positions for completeness.

Your task is to solve the decision-problem of whether the bot is able to fill a given grid from a given starting point. You can assume that the grid size is a positive integer and that the starting point lies within the grid. You can take the grid size and starting point in any consistent order, as separate inputs, a pair of pairs or a list of 4 elements, or any other reasonable input format. The starting point can be 0-indexed or 1-indexed. You can use any two consistent outputs, or you can output using any values that your language considers truthy or falsy, but not both. Please include your input and output format in your answer.

The directions west, south, east or north correspond to decrementing the x-coordinate, incrementing the y-coordinate, incrementing the x-coordinate and decrementing the y-coordinate respectively.

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

Test cases (0-indexed, width height x y):

4 4 0 0 -> True
4 4 1 1 -> False
4 4 2 2 -> True
4 4 3 3 -> True
4 7 1 3 -> False

Answer 21

A Spherical Die

Inspiration

I have a spherical die, but it's a cheap one so it doesn't work properly. When I roll it, it doesn't always land directly on a "face" marking, but instead can result in an ambiguous result ("is that a 6, a 4 or a 2?")

Assumptions

Assume the die is a perfect, evenly-weighted Unit Sphere (i.e. all points on the surface are radius 1cm from the center) , such that a "roll" can result in any point on the sphere being the uppermost point (the "roll value").

Assume that, if the die is placed or rolled such that 1 is at the "north pole", the conventions of a normal die will follow, i.e:

• 6 will be at the "south pole"
• 4, 5, 3, 2 will be on the "equator", clockwise in that order, equidistant around the sphere.

So, before it's rolled, the die looks like this:

The Challenge

Given a simulated roll of the die (i.e. coordinates representing the top of the die after it's rolled) with the conditions above, identify the closest value (1-6) to that point (i.e. what the roll value should resolve to).

Input

A co-ordinate on the sphere.

There are a few co-ordinate systems used for spheres, the two I'm familiar with (and so will provide examples in) are as follows:

• P(1, φ, Θ) where φ is the "azimuth angle" (0..360), Θ is the "polar angle" (0..180)

• P(x,y,z) where \$x^2+y^2+z^2=1\$

(note: the conversion between the two is: x = cos(φ)·sin(Θ); y = sin(φ)·sin(Θ); z = cos(Θ))

for clarity:

• roll "1" is at P(1,n,0)
• roll "2" is at P(1,270,90)
• roll "3" is at P(1,180,90)
• roll "4" is at P(1,0,90)
• roll "5" is at P(1,90,90)
• roll "6" is at P(1,n,180)

Output

The nearest value (1-6) to that point. If the point is equidistant to two or more points, output any one of them.

Usual exclusions etc. apply.

code-golf random mathematics

Answer 22

Note: this challenge is a work-in-progress, so suggestions would be appreciated

Questions for meta:

• How can I prevent people from just using SHA or MD5 one-way compression?
• are these language restrictions fair?
• is this scoring system fair?
• are there any obvious cheap answers?
• what other tags should be added?
• what should the challenge title be?
• will these restrictions adequately prevent people trying to cheat their way through?
• should a limit be put on a password length? Should I limit passwords to ASCII printable characters?

The challenge

Your challenge is to first choose a "password" (please do not use your actual password). Then, you will create a program which will output a truthy value if and only if this password is given as input, falsy otherwise. Your goal will be to make it so others are unable to reverse-engineer this password (and you will keep this password secret for now).

Scoring

The scoring for this challenge is somewhat different than regular code-golf. During the first two weeks from when an answer is posted, other users will have the opportunity to try to crack your password by reverse-engineering your code. If anyone gets your password correct during this two week period, your answer will be marked as cracked. If two weeks pass without users finding the password, your answer can be marked as safe once you share the password (again, please do not use your actual password, you should make up a new one that you don't use anywhere).

Note that you may use any tools at your disposal (online tools, brute-force attacks, modified code, etc) to extract someone else's password from their code.

Of all the safe answers, the one with the shortest source code (i.e. code-golf) wins!

Rules

To make things fair for everyone, you may only use languages that appear on TIO, or languages that have well-written documentation and are used somewhat widely. You must also provide a link to try your code online that anyone can access (as such, you may not use languages behind paywalls like MATLAB but Octave is still on the table because it's free).

Even if you don't want to post an answer, feel free to try to crack any of the existing answer's passwords! If you get a password, you can simply leave a comment on that answer and that answer will be cracked.

Note

If you edit the code in your answer, the two week period will reset! You may edit any explanations in your answer freely (I will verify that any answers marked safe did not cheat).

tags: code-golf

Answer 23

Stroke Count of a Chinese Numeral codegolf Posted

Answer 24

All work and no play but it gets thinner every time

code-golf kolmogorov-complexity

Your objective is to output the unique string with the following properties:

• Each paragraph consists entirely of repetitions of the sentence All work and no play makes Jack a dull boy.
• The first paragraph is a single line with exactly one repetition of the sentence.
• Each line of each subsequent paragraph is shorter than the longest line of the previous paragraph.
• Each line contains as many words of the sentence as possible without exceeding the length limit, and no trailing whitespace.
• Paragraph ends when its next line would be identical of some previous line of the same paragraph, possibly terminating the last sentence early.
• The last paragraph has the same width as the longest word in the sentence (5).
• There's a pair of line ends between each pair of paragraphs, a single line end after the last paragraph, and no line end before the first paragraph.

The string produced by these rules has: 5025 bytes when using Windows line ends (CR LF) or 4796 bytes using Linux line ends (LF); 229 line ends; 103 full repetitions of the sentence and 11 partial repetitions. It can be compressed into a 249-byte deflate stream (bubblegum code). The full string is included below for reference.

All work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes Jack
a dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes Jack
a dull boy. All work and no play

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a

All work and no play makes Jack
a dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play

All work and no play makes Jack
a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes

All work and no play
makes Jack a dull boy.

All work and no play
makes Jack a dull
boy. All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy. All
work and no play

All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy.

All work and no
play makes Jack a
dull boy. All
work and no play
makes Jack a dull
boy. All work and
no play makes
Jack a dull boy.

All work and no
play makes Jack
a dull boy. All
work and no play
makes Jack a
dull boy. All

All work and no
play makes Jack
a dull boy. All
work and no

All work and
no play makes
Jack a dull
boy. All work
and no play
makes Jack a
dull boy. All
work and no
play makes

All work and
no play
makes Jack a
dull boy.

All work
and no play
makes Jack
a dull boy.

All work
and no
play makes
Jack a
dull boy.

All work
and no
play
makes
Jack a
dull boy.

All work
and no
play
makes
Jack a
dull
boy. All
work and
no play

All
work
and no
play
makes
Jack a
dull
boy.

All
work
and
no
play
makes
Jack
a
dull
boy.

Answer 25

Make a quine that shrinks and grows

Write a program that outputs another program that is:

• Larger in bytes than the original
• Outputs a program that is smaller than itself that also obeys these rules and is larger than the original program

Basically the output should alternate between larger than the previous program and smaller than it, while increasing in total size as it goes.

Related

Answer 26

Strobogrammatic Numbers

number code-golf

---

Definition

A number which is rotationally symmetrical, i.e., it'll appear the same when rotated by 180 deg in the plane of your screen. The following figure illustrates it better,

(source: w3resource.com)

Task

Given a number as the input, determine if it's strobogrammatic or not.

Examples

• Truthy

1
8
0
69
96
69169
1001
666999
888888
101010101

• Falsey

2
3
4
5
7
666
969
1000
88881888
969696969

Rules

• The number is guaranteed to be less than a billion.
• We are considering 1 in it's roman numeral format for the sake of the challenge.
• Input can be taken as number, or an array of chars, or as string.
• Output would be a truthy/falsey value.
• This is a code-golf, so fewest bytes will win!

---

Meta

• Although I've tried a search, but is this a duplicate?
• Is the challenge's text clear enough?
• Any tricky/interesting test case?

Answer 27

Explain a Code Golf Answer code-golf string

Background

When writing Code Golf answers, it is often a good idea to add an explanation of the code so the reader understands what's going on. For example, this this answer by @Makonede (abridged):

        θ  # last element of
Σ          # the input, sorted in increasing order by
     1¢    # the number of ones of
   %       # modulo
 žJ        # 4294967296
    b      # in binary

The full program is written on the first line, then a blank line, then on each successive line, a little snippet of the program, aligned using spaces with its position in the full program, and then some comments on the right-hand side explaining each part.

I, for one, find writing and aligning these explanations tedious, so let's outsource it to a program.

Task

Given a program as a string, and a list of sets of pairs of start/end indices to form an inclusive range, output each sub-string defined by the indices on a new line, indented to its respective position in the whole string, with a # at the end of the line, padded so that there are two spaces before the # after the last sub-string, ready for the user to add their explanation.

Rules

• You may use 0-based or 1-based indexing
• You are guaranteed to receive valid, non-overlapping ranges, which together cover the whole string
• You may assume the program string contains no newlines, tabs or other unprintable characters, and no double-width characters
• Standard I/O rules and loopholes apply
• This is code-golf, so shortest code in bytes wins

Examples (1-based indexing)

Inputs: abcdwxyz, (1-8)
Output:

abcdwxyz  #

Inputs: abcdwxyz, (5-7), (1-2),(8-8), (3-4)
Output:

    wxy   #
ab     z  #
  cd      #

Inputs: <<<$[grep -c wx $0-grep -c y\z $0];:<<'Q', (6-20), (22-37), (4-5),(38-38),(21-21), (1-3), (39-39), (40-40), (41-45)]
Output:

     `grep -c wx $0`                           #
                     `grep -c y\z $0`          #
   $[               -                ]         #
<<<                                            #
                                      ;        #
                                       :       #
                                        <<'Q'  #

---

Meta

• Is this a duplicate?
• Is this clear enough?
• Any other feedback?

Answer 28

Interpret Interval Notation

Answer 29

Implement a zipwith function

Answer 30

Calculate the 'geothmetic meandian' of a set of numbers

Randall Munroe's March 10 xkcd comic "Geothmetic Meandian" defines the 'geothmetic meandian' of a set of positive real numbers as follows.

Define a function F, such that F accepts a set of n positive real numbers and returns the set (a, b, c), where a is the arithmetic mean of the set (the sum of the numbers in the set divided by n), b is the geometric mean of the set (the product of the numbers in the set to the power of 1/n), and c is the median of the set (the average of the middle two numbers in the sorted set when n is even, and the middle number in the set when n is odd). The function F can therefore be applied again to its own output. Iterating F an infinite number of times should cause its three outputs to converge to one value g. This value g is defined as the geothmetic meandian of the original set of positive reals. (For the purposes of this challenge, you may assume this value exists and does not diverge.)

Given a nonempty list of positive real numbers in any convenient and reasonable format and a positive integer q, compute its 'geothmetic meandian' to q significant figures. Standard code-golf rules apply, and the shortest code in bytes wins.

Test cases

[[1], 2] --> 1.0
[[2, 8], 4] --> 4.742
[[1, 1, 2, 3, 5], 6] --> 2.08906
[[1, 2, 4, 8], 6] --> 3.13227
[[1.1, 2.2, 4.4, 8.8], 9] --> 3.44550208