507
\$\begingroup\$

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

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]

\$\endgroup\$
0

3134 Answers 3134

1
6 7
8
9 10
105
4
\$\begingroup\$

Inscriptio Labyrinthica

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

SILO PRINCEPS FECIT

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

\$\endgroup\$
3
  • \$\begingroup\$ @trichoplax I've updated the challenge based on your feedback, let me know what you think. \$\endgroup\$ – user0721090601 Jun 30 '19 at 17:20
  • \$\begingroup\$ Looks good to me. +1 \$\endgroup\$ – trichoplax Jun 30 '19 at 18:24
  • \$\begingroup\$ you should now edit this to a link to the post and delete it. Thanks! \$\endgroup\$ – Giuseppe Jul 24 '19 at 19:11
4
\$\begingroup\$

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?

\$\endgroup\$
5
  • \$\begingroup\$ How about Opposite that behaves like the negation of the other operand? \$\endgroup\$ – Zgarb Dec 11 '16 at 19:10
  • \$\begingroup\$ @Zgarb Too similar to Other. For the "2 more to be added", I intended to make it possible to write expressions to 1) decide whether a variable is a specific value, and 2) return a specific value if a variable is true, or false otherwise. This may make the list more useful later. \$\endgroup\$ – jimmy23013 Dec 11 '16 at 19:42
  • \$\begingroup\$ @Zgarb I gave up and even removed one, to make hardcoding the tables less likely to be the optimal way. \$\endgroup\$ – jimmy23013 Dec 13 '16 at 17:56
  • \$\begingroup\$ if(whatever){/*???*/} \$\endgroup\$ – Pavel Dec 13 '16 at 20:23
  • \$\begingroup\$ @Zgarb I forgot this post for some reasons. Now I found your idea quite interesting. But I'll post the first version without it, and may add a stronger version if it worked well or is too easy, and may name it Degenerate to make most of the other results from operations make sense. \$\endgroup\$ – jimmy23013 Apr 30 '19 at 8:40
4
\$\begingroup\$

Knight's tour


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:

knight's moves

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:

5×5 knight's tour

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.

\$\endgroup\$
6
  • 5
    \$\begingroup\$ "Your code will be scored in bytes, usually in the encoding UTF-8, unless specified otherwise.": So a Jelly answer will need to specify "Jelly (Jelly codepage)" or else it needs to count bytes of a unicode encoded source? Why not leave it out and let the tag code-golf handle the rules. And instead of generating test-cases, you could just add a program that validates the result as there are a lot of possible answers . \$\endgroup\$ – ბიმო Sep 22 '18 at 14:19
  • 1
    \$\begingroup\$ @ბიმო Heh, I did this back with all my challenges when I was obsessed with creating "the perfect challenge template." I'll remove it. As for the test cases/validation program, I'll probably do both. \$\endgroup\$ – totallyhuman Jul 12 '19 at 1:55
  • \$\begingroup\$ @lirtosiast Oops, turns out I had mistaken the meaning of the Wikipedia section I just linked. I'll specify that a submission is not required to work on any \$n < 4\$. \$\endgroup\$ – totallyhuman Jul 12 '19 at 2:00
  • \$\begingroup\$ Another Mathematica built-in is coming~ \$\endgroup\$ – tsh Jul 12 '19 at 7:27
  • \$\begingroup\$ Can output be a list of coordinates? \$\endgroup\$ – tsh Jul 12 '19 at 7:29
  • \$\begingroup\$ Having both test cases and a validator sounds good to me too \$\endgroup\$ – trichoplax Jul 14 '19 at 7:59
4
\$\begingroup\$

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]

\$\endgroup\$
4
  • 2
    \$\begingroup\$ Hi and thanks for using the sandbox! I'll start right off by saying I don't know enough about babel to particularly talk about if this will be interesting. I think this kind of challenge is fine, just like regex-golf. This should probably be tagged code-challenge and shouldn't be tagged compiler. I am concerned that you tie everything to an external site. While I doubt the site will go down, what happens when they update babel? Will it break the challenge? Since this is a bit abnormal, you may want to ask on meta (specifically about the online scoring) or in chat for more feedback. \$\endgroup\$ – FryAmTheEggman Jul 1 '19 at 21:56
  • 2
    \$\begingroup\$ @FryAmTheEggman thanks for the tags and pointing me to meta for this, I think I'll wind up clarifying things over there. And also, about the foreign site - it's not required, but makes it far, far easier. That's why I edited in the clause about being able to do it locally. If the site is used, the settings are query parameters in the URL (but could be interpreted even if it went down). And contestants can do it locally, provided they post the settings they use, and use the same version. So I'm not too worried about tying it to a site, since it's just for convenience. \$\endgroup\$ – Nathaniel Pisarski Jul 2 '19 at 12:52
  • 1
    \$\begingroup\$ We discourage language specific challenges when there is no reason for it, but here it is clearly part of the challenge so I see no problem at all. \$\endgroup\$ – trichoplax Jul 16 '19 at 20:42
  • 1
    \$\begingroup\$ Having a fixed number of input bytes to work with can be awkward in language agnostic challenges as it's difficult to choose a suitable number that doesn't make it too difficult / too easy for some languages. Since everyone is using the same language here a fixed 128 bytes seems reasonable. Your examples already show it doesn't need to be higher. You could consider lower, depending on how you want the challenge to go. With 128 bytes there's a good chance some outputs will be too large to fit in the 65536 character answer length limit, but I don't see that as a problem either. Looks good to me \$\endgroup\$ – trichoplax Jul 16 '19 at 20:47
4
\$\begingroup\$

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, Qto, 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
\$\endgroup\$
4
\$\begingroup\$

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?

\$\endgroup\$
6
  • 1
    \$\begingroup\$ What if, for example the bash script contains '''? Is that what rule 4 is talking about, since I don't really understand that rule. \$\endgroup\$ – Jo King Sep 2 '19 at 5:51
  • \$\begingroup\$ I'm indeed wondering the same as @JoKing. What if the content of the code we'd potentially insert into the wrapper contains something that could break the wrapper or other program itself? For example, let's say I submit 0W, where 0 is a wrapper for a 05AB1E program, and W for a Whitespace program. 05AB1E in general ignores all whitespaces between commands and Whitespace ignores all characters except for spaces/tabs/newlines. But what happens if the potential 05AB1E program contains a string with a space/tab/newline in it, which would interfere with the Whitespace program? \$\endgroup\$ – Kevin Cruijssen Sep 2 '19 at 9:25
  • \$\begingroup\$ Perhaps make it such that the inner programs are a turing complete subset of the parent language, such that the overall program will always run correctly. Answers would have to make a list of restrictions placed on the language subsets, as well as prove that they are still turing complete, and can't 'break out' of their wrappers, nor have effects on other sections of the program \$\endgroup\$ – Jo King Sep 2 '19 at 12:08
  • 1
    \$\begingroup\$ Would this work as a cops and robbers? Cops provide wrappers and robbers provide code that breaks the wrappers? \$\endgroup\$ – trichoplax Sep 3 '19 at 11:49
  • 1
    \$\begingroup\$ Good catch, everyone! I'll have to think about this some more. Cops and robbers sounds like a good way to make that problem into a feature, @trichoplax \$\endgroup\$ – BLuFeNiX Sep 3 '19 at 14:16
  • \$\begingroup\$ Your example can break in a different way too. An unterminated here-doc in bash will continue until the end of the script: B = cat << EOF \$\endgroup\$ – GammaFunction Sep 8 '19 at 6:29
4
\$\begingroup\$

Translate a simple sentence from Toki Pona

\$\endgroup\$
1
  • \$\begingroup\$ grammatical construct - this term seems too general. why not call these predicate marker and object marker, or simply "li" and "e" in quotes? \$\endgroup\$ – ngn Oct 25 '19 at 11:44
4
\$\begingroup\$

Hexagonify™ a String Block

\$\endgroup\$
4
\$\begingroup\$

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.
\$\endgroup\$
7
  • \$\begingroup\$ Shouldn't banner output be rotated 90 degrees? When I was testing banner, everything was sideways, not horizontal. \$\endgroup\$ – Lyxal Jan 13 '20 at 20:55
  • \$\begingroup\$ @Jono2906 The output in my post is copy/pasted straight from my Linux terminal. \$\endgroup\$ – Noodle9 Jan 13 '20 at 21:57
  • \$\begingroup\$ Huh, serves me right for using Unix. \$\endgroup\$ – Lyxal Jan 13 '20 at 21:59
  • 1
    \$\begingroup\$ @Jono2906 Found out there's a few different types of banner implementations out there thanks to your comments. I've picked the one I'm used to and noted that in the post. Thanks :-) \$\endgroup\$ – Noodle9 Jan 15 '20 at 10:59
  • \$\begingroup\$ No problem! I learnt something myself as well (the banner command and also that different OS's implement commands differently). \$\endgroup\$ – Lyxal Jan 15 '20 at 11:02
  • \$\begingroup\$ This is pretty similar, just a different big-character set. \$\endgroup\$ – AdmBorkBork Jan 17 '20 at 19:50
  • \$\begingroup\$ This one is also really close, with just slight modifications to the big-character set. \$\endgroup\$ – AdmBorkBork Jan 17 '20 at 19:52
4
\$\begingroup\$

Reversed Iota's

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.
\$\endgroup\$
4
  • \$\begingroup\$ How should output be formatted? \$\endgroup\$ – S.S. Anne Jan 26 '20 at 16:20
  • \$\begingroup\$ This old challenge is pretty similar. The regular challenge isn't really a dupe, but one of the more common ways to get the bonus was to do essentially this. I don't think I would close it because the old one has a bonus, but I can't speak for everyone. \$\endgroup\$ – FryAmTheEggman Jan 26 '20 at 19:01
  • \$\begingroup\$ A naming suggestion: Reveresed Iota's \$\endgroup\$ – Lyxal Jan 27 '20 at 9:05
  • \$\begingroup\$ May the initial 1 be a loose item instead of a list [1]? I.e. 3 bytes in Jelly. \$\endgroup\$ – Kevin Cruijssen Jan 28 '20 at 13:37
4
\$\begingroup\$

Is it a doubling sequence?

Posted here:

Is it a doubling sequence?

\$\endgroup\$
3
  • \$\begingroup\$ Can the input array be empty or of length 1? \$\endgroup\$ – Jo King Feb 12 '20 at 1:45
  • \$\begingroup\$ @JoKing In that case, the output must be vacuously True, I guess. \$\endgroup\$ – Dannyu NDos Feb 12 '20 at 4:47
  • \$\begingroup\$ @JoKing good question, I edited the input to only handle arrays with two or more numbers. \$\endgroup\$ – atlasologist Feb 12 '20 at 13:16
4
\$\begingroup\$

Posted to main.

\$\endgroup\$
12
  • \$\begingroup\$ The initial set of squares should have a guaranteed distance from each other set of squares. grid needs better specification. What does "nearby square" mean? Other than that, solid spec. \$\endgroup\$ – Nathan Merrill Oct 31 '18 at 13:12
  • 2
    \$\begingroup\$ 1) The wording is weird on the Game of Life rule explanation. Please take a look at the Wikipedia page and clarify them. Currently, I'm not sure if a cell can change color if it's surrounded by more opponents than allies. Also, it seems to be implied that a live cell surrounded by 3 neighbors dies (which I'm pretty sure wasn't your intention). 2) What happens when no colors remain on the board? 3) Nitpick: the "this" in "it has at this time" threw me off - "that" instead, perhaps? \$\endgroup\$ – Alion Oct 31 '18 at 13:18
  • 2
    \$\begingroup\$ 4a) Since there's no explicit ban on cooperation, it's allowed by default. Was this your intention? 4b) Can bots communicate with each other? 5) Can bots store data across games? 6) Can we get a more easy-to-use system of storing data within one game? Scopes are useful for this: function externalFunc() { /* Storage */ return function gameLoopFunc(args) { /* Code */ }; } 7) next is not very robust. Some people (including myself) will remake the game simulation to gain access to more advanced functionality. 8) What happens if the returned value isn't within 2 cells of one of my own cells? \$\endgroup\$ – Alion Oct 31 '18 at 13:30
  • 1
    \$\begingroup\$ 9a) Why is selecting a live cell that is not your own a legal move, despite not doing anything? 9b) Is it legal to pass a move always? If so, what should we return if we want to pass a turn? 9b2) If it's not legal to pass a turn... why? It sounds pretty useful and makes sense. Please consider it. \$\endgroup\$ – Alion Oct 31 '18 at 13:33
  • \$\begingroup\$ @NathanMerrill Thanks, I've clarified that now. \$\endgroup\$ – Spitemaster Oct 31 '18 at 13:46
  • \$\begingroup\$ @Alion I've fixed 1, 3. I've removed next - good point (7). I've changed access to localStorage to access to this, clears between games (5,6). I've changed the scoring to a percentage and clarified draws (2). I've clarified that passing values out of bounds is illegal (8) and what (9a) does. I've also made passing legal (9b/c). (4) I did intend for cooperation (but not communication) to be legal; I've clarified that. Thanks for all the help! \$\endgroup\$ – Spitemaster Oct 31 '18 at 14:02
  • 2
    \$\begingroup\$ Splendid work. That being said, I'm not done yet. 10) Typos: id > it (line 2 of rule explanation), bot's > bots' (last restriction). 11) Can bots modify the grid passed to them (in the non-malicious sense)? 12) Black doesn't immediately strike me as a living cell. I'd recommend specifying that there exist neutral living cells (I only realized this during my 4th reading). 13) What format should submissions be? Template and example submissions both work. 14) Controller: If you haven't already, you should check out Dave's JS KotH framework. \$\endgroup\$ – Alion Oct 31 '18 at 15:21
  • \$\begingroup\$ 15) You've opened Pandora's Box with cooperation restriction. I'll illustrate what I mean with several abstract examples. GrudgeBot and PassiveBot: GrudgeBot will not attack PassiveBot, because PassiveBot doesn't bother GrudgeBot. FriendlyBot: Attempts to make friends with bots that it comes into contact with by testing if they will attack it. 2 instances would quickly team up after meeting each other. AlgoBot: Runs simulations and tests how well other bots play according to its idea of "optimal". 2 instances quickly realize that the other is playing optimal or near-optimal moves and team up. \$\endgroup\$ – Alion Oct 31 '18 at 15:40
  • \$\begingroup\$ 15 cont.) So, where do you draw the line? 16) performance.now() for timing purposes. Introduces unpredictability, but lets bots police their own time instead of their creators having to wildly guess the right values. Allowed or not? 17) cellular-automata, game, grid (maybe). \$\endgroup\$ – Alion Oct 31 '18 at 15:44
  • \$\begingroup\$ Whew, what a rampage. Despite all of that, I'm impatiently looking forward to this hitting main. Expect to see me there immediately. Keep up the good work! \$\endgroup\$ – Alion Oct 31 '18 at 15:47
  • 1
    \$\begingroup\$ Thank you very much! I've fixed (10)-(12). I'll add an example submission when I'm finished the controller - and I will definitely check out that framework! (15) - Good point, but I don't want to give an advantage to people who build multiple bots. I've added a clarification that a test for "too much cooperation" is preset move sequences and the like - identifying a bot by its strategy is okay. There's room for interpretation, but I trust that non-malicious entries will be reasonable. All of your examples I'm okay with. :) I will add some tags. \$\endgroup\$ – Spitemaster Oct 31 '18 at 15:58
  • \$\begingroup\$ @Alion I know it's taken way too long for me to get around to this, but if you're still interested... \$\endgroup\$ – Spitemaster Feb 17 '20 at 17:32
4
\$\begingroup\$

Is it a Happy Number?

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
\$\endgroup\$
8
  • \$\begingroup\$ Is there an upper bound for inputs? I think one thing to consider is whether you want answers to implement the square-summing operation, or to try to compress or overfit some heuristic that works for say, 1 to 100. \$\endgroup\$ – xnor Mar 28 '20 at 10:46
  • \$\begingroup\$ Falsy numbers belong to A007770. \$\endgroup\$ – Arnauld Mar 29 '20 at 22:49
  • \$\begingroup\$ @Arnauld Nice catch + Title suggestion! \$\endgroup\$ – user92069 Mar 30 '20 at 0:25
  • 2
    \$\begingroup\$ With the term "happy number" in hand, I found a probable duplicate. \$\endgroup\$ – xnor Mar 30 '20 at 8:37
  • \$\begingroup\$ Ugh, why do I always have duplicate ideas recently... \$\endgroup\$ – user92069 Mar 30 '20 at 9:01
  • \$\begingroup\$ @xnor This is a dupe indeed, but the other challenge is very old and it seems like it requires a full program with a cumbersome output format. So maybe we should rather close the old challenge as a dupe of this one instead? (I'm not sure about the right policy here.) \$\endgroup\$ – Arnauld Mar 30 '20 at 10:38
  • 3
    \$\begingroup\$ We did once repost Kolakoski one and closed the old one as dupe (with relevant meta discussion). But this case is a bit different because the author of the old challenge is no longer active. \$\endgroup\$ – Bubbler Mar 30 '20 at 23:00
  • \$\begingroup\$ @Arnauld Good point, that old challenge is sure showing its rust. \$\endgroup\$ – xnor Mar 30 '20 at 23:14
4
\$\begingroup\$

Posted

Solve a Picross Row

\$\endgroup\$
2
  • 1
    \$\begingroup\$ I don't think it is a dupe of full nonogram solver. I recommend allowing flexible I/O formats though (e.g. values other than 0,1,2 to mark each cell state). \$\endgroup\$ – Bubbler May 6 '20 at 7:54
  • 1
    \$\begingroup\$ To make the challenge more self-contained, consider adding a brief introduction to picross/nonogram and its rules. \$\endgroup\$ – Bubbler May 6 '20 at 9:18
4
\$\begingroup\$

Implement an HTML renderer

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?

\$\endgroup\$
2
  • 1
    \$\begingroup\$ "I believe it is possible" -- Yes, rewriting a subset of the HTML Spec for ASCII is possible. However, successful challenges tend to keep it simple. I'd suggest using just span and div and using no attributes. In addition, parsing has probably been done before and is cumbersome, so I'd suggest allowing input as a pre-parsed AST to focus on the key challenge of ASCII-art generation \$\endgroup\$ – fireflame241 Jul 9 '20 at 6:16
  • \$\begingroup\$ Personally I would keep only body, div, span and img, altho img should follow a set pattern inside of it. I would also suggest making height and width attributes mandatory, in all tags. \$\endgroup\$ – Dion Jul 20 '20 at 6:08
4
\$\begingroup\$

Solve a 2xN Maze (posted)

\$\endgroup\$
1
  • \$\begingroup\$ Now that this has been posted to main, could you delete this proposal to create more space for new answers? \$\endgroup\$ – ChartZ Belatedly Sep 25 '20 at 1:04
4
\$\begingroup\$

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 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 , 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
\$\endgroup\$
11
  • 1
    \$\begingroup\$ What's the "naive fill" algorithm exactly? \$\endgroup\$ – user202729 Jul 12 '20 at 11:24
  • 1
    \$\begingroup\$ Comment: it's hard for me to figure out that each "column" (separated by space) represents a x*y board. Consider clarifying that. \$\endgroup\$ – user202729 Jul 12 '20 at 11:25
  • \$\begingroup\$ @user202729 The very first two sentences are supposed to describe it, just move in the first available preferred direction until you can't move any more and paint as you go. \$\endgroup\$ – Neil Jul 12 '20 at 14:11
  • \$\begingroup\$ Some comments: (1) You don't seem to define that "naïve fill" is. (2) It took me a while to undersdtand the meaning of the numbers 14, 21` etc mean the 2nd example, and similarly in others. After a while I realized that each "code section" contains several examples stacked horizontally. You should make thast more obvious (maybe increasing horizontal space, or explaining it in the text) \$\endgroup\$ – Luis Mendo Jul 12 '20 at 15:47
  • \$\begingroup\$ (3) "It normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise": what does "normally" mean here? How do we know/choose the direction the robot follows? Or maybe this is the definition of "naïve fill"? (4) Why can't the robot fill the 2×3 case when it starts in the middle right square? That is, why doesn't start by moving up instead of left? (5) In general, but I find it all quite confusing... maybe it's me, but consider explaining the challenge with more detail \$\endgroup\$ – Luis Mendo Jul 12 '20 at 15:47
  • \$\begingroup\$ @LuisMendo (1) The bot paints as it goes. It prefers to go west, but when it can't go west tries south, then east, then north. That's all there is to it. (2) I've added some more text and spacing. (3) "normally" means "most of the time it ends up doing this". (4) Because its first preferred direction is west so it ends up painting itself into a corner. \$\endgroup\$ – Neil Jul 12 '20 at 16:53
  • \$\begingroup\$ (1) It prefers to go west, but when it can't go west tries south, then east, then north. That phrasing makes it much totally clear. (Now I see that's probably what you meant with by preference) Include it in the text? (3) I still find the word normally confusing there, as if that were an additional degree of freedom. Also, I see now that except when it starts in the bottom right corner when it traverses clockwise is a consequence of (1). I suggest you explicitly state something like "As a consequence of the rule for direction choice, ..." \$\endgroup\$ – Luis Mendo Jul 12 '20 at 17:03
  • \$\begingroup\$ @LuisMendo Fair enough; I've tweaked the text again now. \$\endgroup\$ – Neil Jul 12 '20 at 17:35
  • \$\begingroup\$ I really like this challenge, but I wonder whether the title could be a little more descriptive/catchy - perhaps 'Can the bot fill the grid?' or similar? \$\endgroup\$ – Dingus Jul 14 '20 at 15:00
  • \$\begingroup\$ @Dingus "Can the naïve bot fill the grid?" counts as similar, right? \$\endgroup\$ – Neil Jul 14 '20 at 17:23
  • \$\begingroup\$ Ooh, that's even better. Immediately makes me curious to find out what the naïve bot is. \$\endgroup\$ – Dingus Jul 15 '20 at 0:35
4
\$\begingroup\$

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:

image of die

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.

\$\endgroup\$
17
  • \$\begingroup\$ Does anyone know the maths for this? Feel free to edit it in! \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 9:40
  • \$\begingroup\$ I'm not sure I understand: You want us to generate a random point on a sphere and output the face of the die it corresponds to? \$\endgroup\$ – flawr Nov 22 '19 at 9:57
  • \$\begingroup\$ yeah, so generate a random point on the sphere, then find the nearest "face" - i.e. the nearest of the 6 points (top, bottom, 4 points on opposite sides around middle) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 11:11
  • \$\begingroup\$ This will be exactly equivalent to a uniform distribution over 6 values, just based on the symmetry of the situation. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 12:33
  • \$\begingroup\$ @AlienAtSystem yes, all outcomes are equally likely; but the challenge is determining which number any given point on the face of the sphere is closest to \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:04
  • 4
    \$\begingroup\$ That's not the challenge as posted. Right now, it's "Takes no input, returns the number the (internally generated) random point is closest to" which is, under the consensus of no unobservable requirements simply equal to "Takes no input, returns uniform random value from 1-6". If you want the challenge to be "Input is point on sphere, output is number it's closest to", then write that. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:09
  • \$\begingroup\$ @AlienAtSystem I've edited to try and make it clearer what I'm looking for. Is it clearer now? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:15
  • \$\begingroup\$ It's clearer that my point still stands. Look, "Make Voronoi cells on sphere" and "Generate uniformly random points on sphere" are both good challenges. But when put together like that, they annihilate each other and give you an extremely quick shortcut right from Input (None) to output (a die roll) that doesn't require calculation of either part. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:21
  • 2
    \$\begingroup\$ @AlienAtSystem thanks for the feedback, I'd never heard of a Voronoi cell before. What I'm asking, then, is "generate a random point on a sphere and say which Voronoi cell that point is in". Can you explain why that doesn't work? Note that I'm asking for both the point and the cell to be output, not just the cell - otherwise I agree, given the "no unobservable requirements" rule it would be possible to just generate a random number and pretend you'd done it properly (although that would be against the spirit of it) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:24
  • \$\begingroup\$ Would it be better for the point on the sphere to be the input, then? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:27
  • \$\begingroup\$ If you want the challenge to be about finding the points it's closest to, yes. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:31
  • \$\begingroup\$ I want it to be a good challenge on this theme, whatever that would look like :) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:33
  • \$\begingroup\$ Although I don't think the current challenge is bad, it's usually best to not have multiple challenges into one nor multiple outputs (since some languages aren't able to output more than once very easily). The two challenges are: 1. Generate a random coordinate on a sphere (in whichever coordinate system you want); 2. Given a (random) coordinate on a sphere, output the dice-value closest to it. No. 1 already is a challenge, so I agree it might be better to rewrite it to challenge No. 2. I do like the general idea though, so +1 from me. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:36
  • \$\begingroup\$ It would also need some info about the size of the sphere, and what to do when the coordinate is exactly in the center between two or three poles. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:39
  • 1
    \$\begingroup\$ Note that the actual implementation is very simple, as explained in chat. \$\endgroup\$ – user202729 Jul 15 '20 at 2:43
4
\$\begingroup\$

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

\$\endgroup\$
18
  • \$\begingroup\$ Example answer \$\endgroup\$ – Daniel H. Aug 19 '20 at 12:38
  • \$\begingroup\$ Surely any cryptographic hash function (which are implemented in many languages) will make it easy to generate an impossible-to-crack answer? For instance, in R I can write test=scan(,'');if(digest::digest(test,"md5")=="b6778692586dc649267723ccc3356fad")TRUE else FALSE and I'll be pretty confident that nobody will crack my password... \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 15:10
  • 1
    \$\begingroup\$ That is a good point. It seems like this challenge is similar to just writing a hash function. You might want to add other ideas to make the challenge more interesting \$\endgroup\$ – thesilican Aug 19 '20 at 16:06
  • \$\begingroup\$ That's what I was about to write, any hash function with a hidden default salt depending on the language, or anything like that, could be hiding the password easily enough. \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:06
  • \$\begingroup\$ @DominicvanEssen is this an actual MD5 hash? I was unable to reverse it (note that a lot of MD5 hashes can be reversed with online tools like this). Note that for this challenge people would be allowed any and all tools at their disposal to crack passwords. This means people are very much allowed to reverse-engineer code in any ways they please \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:06
  • \$\begingroup\$ Answering in many esolangs could hide the password easily enough, too. If I answer in Lenguage, Unary, Mariolang,... \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:07
  • \$\begingroup\$ @V.Courtois this is true, but the point is not to read the password in the source code. The point of the challenge would be to reverse-engineer their code to crack a password (so documentation and online tools are all fair game). Also, Unary will likely be an invalid language because people must be able to actually run the program online (and Unary programs are usually way too big to run online) \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:08
  • \$\begingroup\$ Now that I think about it, any type of loop could hide the password easily enough, too. But even with what I said before and what I'm saying now, I think this challenge has to exist (if not existing already), because having many valid answers is not a problem (not to me, at least). \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:09
  • \$\begingroup\$ @DominicvanEssen also, even if nobody can reverse your password, that's still fine - the winner of this challenge is whoever has the shortest code out of all the uncracked passwords. In other words, this is still a codegolf challenge, but answers can be disqualified if anyone finds the password. So, if you want to win but you don't have the shortest code, you simply have to crack other people's passwords! \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:15
  • \$\begingroup\$ @DanielH. Yes, my example was an actual MD5 hash (the password was mypassword). You're right that some hash functions can be reversed, but there are many cryptographically-secure ones for which this is difficult. \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:17
  • \$\begingroup\$ @DominicvanEssen I'm unfamiliar with MD5 hashes, but when I converted mypassword to an MD5 hash using three different online tools I got 34819d7beeabb9260a5c854bc85b3e44 every time instead of the hash in your answer. Could you please provide a TIO link for the R code (when I copy-pasted it into TIO it didn't work for me and I'm unfamiliar with R)? I'd like to try experimenting with MD5 \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:22
  • \$\begingroup\$ I'm afraid that the R 'digest' library is not installed on TIO (making a link was the first thing I tried). \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:25
  • \$\begingroup\$ But, after some research, it turns-out that R adds some (consistent) extra characters to the string by default before applying MD5. This behaviour can be switched off, at which point mypassword indeed hashes to 34819d7beeabb9260a5c854bc85b3e44. \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:46
  • \$\begingroup\$ how many letters are the passowrds capped at? Are unprintables allowed? \$\endgroup\$ – Razetime Aug 20 '20 at 3:30
  • \$\begingroup\$ @Razetime I might add a restriction of 16 characters, ASCII printables only. I will have to try to balance this cap though - if it's too short, passwords can easily be brute-forced. If it's too long, everyone will just use one-way compression and passwords will never be cracked \$\endgroup\$ – Daniel H. Aug 20 '20 at 11:24
4
\$\begingroup\$

Stroke Count of a Chinese Numeral Posted

\$\endgroup\$
5
  • \$\begingroup\$ Related (not dupe). Stroke count is actually good idea because it avoids the need to hardcode Chinese characters. The description looks clear enough to me. \$\endgroup\$ – Bubbler Aug 5 '20 at 3:11
  • \$\begingroup\$ Might be useful: tio.run/… \$\endgroup\$ – user202729 Aug 5 '20 at 11:45
  • \$\begingroup\$ (to read the test cases) \$\endgroup\$ – user202729 Aug 5 '20 at 11:45
  • \$\begingroup\$ Has it been posted to main? I can't seem to find it. \$\endgroup\$ – V. Courtois Aug 21 '20 at 10:02
  • 1
    \$\begingroup\$ @V.Courtois posted. \$\endgroup\$ – att Aug 25 '20 at 4:54
4
\$\begingroup\$

All work and no play but it gets thinner every time

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.
\$\endgroup\$
6
  • \$\begingroup\$ So a sentences can span one or more lines? Was thinking the sentences got shorter until you said there's 103 full repetitions. No clear explanation on what exactly paragraphs, paragraph widths, sentences, lines, and line ends are. \$\endgroup\$ – Noodle9 Sep 28 '20 at 15:05
  • \$\begingroup\$ @Noodle9 I've added some of the reference output; would the reference suffice to explain those? \$\endgroup\$ – John Dvorak Sep 28 '20 at 15:30
  • \$\begingroup\$ Can you simply add the whole output? (I still don't understand it) \$\endgroup\$ – the default. Sep 28 '20 at 15:37
  • \$\begingroup\$ @thedefault. added. I didn't want to clutter the sandbox. \$\endgroup\$ – John Dvorak Sep 28 '20 at 15:39
  • \$\begingroup\$ Alternative name: Write a novel for Jack Torrance \$\endgroup\$ – Razetime Sep 28 '20 at 15:51
  • \$\begingroup\$ Better to say what you mean by these terms. Maybe a template of the output where lines are, say, seperared by newline characters. Sentences are substring of "..." containing only whole words and ended by a period. Paragraphs are seperated by two newlines. Or whatever it actually is. \$\endgroup\$ – Noodle9 Sep 28 '20 at 17:07
4
\$\begingroup\$

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

\$\endgroup\$
2
  • \$\begingroup\$ Perhaps it should be "larger than the program two before" rather than "larger than the original?" As stated, a 5-length program could output a 7-length, which outputs a 6-length, which then oscillates between 7 and 6, not growing in total size as it goes. \$\endgroup\$ – Ethan Chapman Oct 8 '20 at 18:51
  • \$\begingroup\$ Probably should be named something other than a quine because I find that term misleading for the challenge you described. \$\endgroup\$ – Beefster Oct 14 '20 at 21:12
4
\$\begingroup\$

The goal of this challenge is to fill a niche that is mostly lacking on this site. In my observations there most parsing verification challenges fall into two categories:

  1. Super easy parsing. This parsing can usually be done with a regex, and regex based answers usually do well.

  2. Super complex parsing. These are challenges with a lot of small parsing components that would on their own be type 1, but together make for long code with a lot of edge cases.

Neither of these categories are really bad, each can have fun challenges, but I want to shoot for something different. A challenge which is hard, hard enough that a regex will be unable to do the brunt of the work but with a easy to understand spec.


The goal of this challenge is to parse a lisp-like lambda function. Your code should accept a string as input and output of two possible consistent values. One which corresponds to an affirmative response (i.e. the input is a properly formatted lambda) and the other corresponds to a negative response (i.e. the input is not a properly formatted lambda).

I've put together 3 specifications of what constitutes a validly formatted lambda for this challenge. The first is a quick intuition base explanation. It explains the process and what things mean even if it is not perfectly rigorous. The second a formal grammar which expresses the idea succinctly and with no ambiguity. And the third is raw code, which is the hardest to read for humans but allows you to play around with the idea by trying different inputs. I recommend you read one of the first two and play around with the third.

Formatting

The challenge uses a lisp like format. This consists of "lists" which are just parentheses enclosing lowercase words, and other lists separated each by a single space. So

(foo (bar baz) foobar)

Would be a lisp-like "list". For our challenge each list will be identified by it's first element (which should by highlighted by the syntax highlighter), which must be either app, abs, or var, representing applications, abstractions and variables, respectively.

An application is the application of one lambda function to another. It is represented by a three element list starting with of course app followed by two other valid lambda expressions. So if S and K were valid lambdas then:

(app S K)

would be a valid lambda too.

The other two abstractions and variables work together, an abstraction introduces new names for variables and variables use those names. An abstraction encloses some lambda which must be valid with the introduced variable name, and a variable can only use names which are given by abstractions that surround it. So

(abs x (abs y (var x)))

Is valid because the x name was introduced and used in a nested context. But

(app (abs x (var x)) (var x))

Is not because even though there is an abstraction for x the second (var x) is not surrounded by any abstraction at all, let alone one that introduces x.

Additionally abstractions can only introduce new variables, so

(abs x (abs x (var x)))

is not valid because the name x is ambiguous, it could refer to either abstraction. Variable names must be a string of lowercase ascii letters (a-z).

Grammar

Now for the golfy definition. This parse cannot be defined in terms of a context free grammar, so this grammar uses context. The context is a set of strings of lowercase ascii letters as these are the valid variable names.

\$ \begin{array}[rr] \ S\left(x\in C\right) &:= \color{green}{\texttt{(var }}x\color{green}{\texttt{)}} \\ S\left(x\notin C\right) &:= \color{green}{\texttt{(abs }} x\texttt{ }S(C\cup\{x\})\color{green}{\texttt{)}} \\ S\left(C\right) &:= \color{green}{\texttt{(app }} S(C)\texttt{ }S(C)\color{green}{\texttt{)}} \end{array} \$

Any string spanned by the grammar is valid and any string not is invalid.

Code

I've exhausted myself with the above. I will write to code in a bit when I've eaten and stuff.

Scoring

This is so answers will be scored in bytes with the goal being a smaller score.

Test cases

Reject

(abs x (var x
uuuuuuuuu
)))(abs x (var x))
app (abs x (var x)) (abs x (var x))
(mmm hummus)
(abs x (var y))
(abs x (abs x (var x)))
(app (abs x (var x)) (var x))
(abs (var k) (var (vark k)))

Accept

(abs x (var x))
(abs x (abs y (var x)))
(abs xx (app (var xx) (var xx)))
(app (abs ab (app (var ab) (var ab))) (abs ab (app (var ab) (var ab))))
\$\endgroup\$
4
\$\begingroup\$

In need of title.

Note: In the final challenge \$N\$ will be a concrete number (I am thinking about 100), but while this is in the sandbox it is subject to change so I have left it as \$N\$.


This challenge is based off of a list of \$N\$ Castilian Spanish words and the words they originate from.

You are to write a program or function which takes the origin word as input and outputs as close as possible the Castilian derivative. Your program should be no longer than \$N\$ bytes.

Scoring

To calculate your score run your program on every origin word and calculate the distance between your output and the correct answer. Your score is the sum of all these distances.

The distance here is a modified version of Levenshtein distance. It is the same as Levenshtein distance except replacement steps that add or remove a diacritic cost only 1/2 of a step as opposed to their normal 1.

You can use this code to calculate the distance between two strings.

The goal is to have as low a score as possible.


About the list

All of the origin words, spare 1, are Latin words (Late or Classical depending on the word). The one exception is ezkerra (the origin for izquierda) which is of Basque origin. It has been added as an extra curve-ball in case you can get all the others with a little space to spare.

Verbs are always in the infinitive form and nouns in the nominative singular.

The words are not chosen randomly but rather I have focused on choosing words that follow a number of simple rules. The list is also organized so that words that undergo similar transformations are grouped together. This is for your ease of use, nothing more.


The list

faba, haba
facienda, hacienda
facere, hacer
fundus, hondo
profundus, profundo
fungus, hongo
fabulare, hablar
furnus, horno
ferrum, hierro
filus, hijo
filum, hilo
folia, hoja
fovea, hoyo
fagea, haya
fastidium, hastío
fastidiare, hastiar
afflare, hallar
formica, hormiga
fetere, heder
ficcare, hincar
factor, hechor
factum, hecho
octo, ocho
octavus, ochavo
noctu, noche
lacte, leche
iactare, echar
coctus, cocho
dictatum, dechado
capere, caber
sapere, saber
lupus, lobo
lacrima, lágrima
lacuna, laguna
eruca, oruga
pater, padre
mater, madre
liber, libro
thema, tema
theatrum, teatro
thesaurus, tesoro
thesis, tesis
thorax, tórax
aether, éter
anthropologia, antropología
orthographia, ortografía
sapphirus, zafiro
philosophia, filosofía
echo, eco
chalare, callar
chamaeleon, camaleón
chaos, caos
materia, materia
resistentia, resistencia
aurum, oro
taurus, toro
autumnus, otoño
annus, año
scribere, escribir
scutum, escudo
scutella, escudilla
scriptor, escritor
ezkerra, izquierda
\$\endgroup\$
12
  • \$\begingroup\$ I think it's interesting in that it should be near impossible to get a perfect score without built-ins. As a suggestion I'd remove the non-ASCII words, or at least normalise them, and perhaps not let \$N\$ be too high. Also, I wonder what the default cat program would be. \$\endgroup\$ – Jo King Mar 3 '20 at 12:31
  • 2
    \$\begingroup\$ @JoKing I am looking to somewhat twart perfect scores, I feel there should always be some room for improvement, It just is a little hard to balance this with golfing-languages ability for expressiveness. I am interested to hear what ranges for \$N\$ you think are too high. I started out by avoiding any non-ASCII characters, but it was really hard to build up a representative corpus of words. Plus the accents and eñe really are a feature of the language. I may adjust the scoring so that i and í for example are only half away from each other so that the penalty is small. \$\endgroup\$ – Wheat Wizard Mar 3 '20 at 13:05
  • \$\begingroup\$ Suggested title: Hispanize these words. Also mention that words should be in lowercase. Finally I think it makes more sense to restrict programs to \$N\$ characters rather than \$N\$ bytes. \$\endgroup\$ – SunnyMoon Nov 20 '20 at 15:24
  • 4
    \$\begingroup\$ I'm not a fan of "Your program should be no longer than N bytes". I think a scoring rule which incorporates both the Levenshtein distance and the byte count would be better, as in the Moby Dick challenge: it would allow more languages to compete, and would allow for more creativity. \$\endgroup\$ – Robin Ryder Nov 22 '20 at 23:43
  • 1
    \$\begingroup\$ @RobinRyder I think that metrics that combine two non-obviously related factors such as in the Moby Dick challenge or as you are suggested rarely work. In fact I can't even think of an example I feel is good. They simply require fine tuning that can only really be done in retrospect. I also don't know how this would allow more languages to compete and I certainly don't know how it would "allow for more creativity". If you have a specific metric in mind and a compelling reason why that metric would not be broken I would be happy to try it out and see. \$\endgroup\$ – Wheat Wizard Nov 23 '20 at 1:38
  • 1
    \$\begingroup\$ Sorry, I'll expand: with a low, hard limit on the number of characters, non-golfing languages don't stand a chance (hence the "more languages" part). If instead you set a high hard limit, it will be possible to reach a (near) perfect score, with no incentive to golf or search for trade-offs (hence the "creativity" part). There surely exists a sweet spot for the character limit where neither of these issues arise, but (a) it will be hard to find and (b) it will be highly language-dependent. \$\endgroup\$ – Robin Ryder Nov 23 '20 at 7:53
  • 1
    \$\begingroup\$ @RobinRyder I think that 100 characters is plenty of characters for nearly any language to implement something a bit more complex than cat (e.g. replace ^f with ^h). I also think that it would require quite a few characters any language to acheive a perfect score. More than half of the words have seemly random vowel mutations that are not covered by any general rule. The only way I can see a perfect score is a compression decompression method. It seems to me to write the de-compressor and make up for the loss would require a deal of room. \$\endgroup\$ – Wheat Wizard Nov 24 '20 at 15:56
  • \$\begingroup\$ What I'm saying is that I think that sweet spot is actually very large. And I think that adding more dimensions to the problem only increase the risk of missing the sweet spot. \$\endgroup\$ – Wheat Wizard Nov 24 '20 at 15:57
  • \$\begingroup\$ I'm not sure the modified version of the Levenshtein distance really adds something to the challenge, but it certainly makes it harder to score an answer. Would you consider updating your script so that it accepts the whole list of translations? \$\endgroup\$ – Arnauld Dec 2 '20 at 22:36
  • \$\begingroup\$ Some possible typos (I'm a native Castillian Spanish speaker and I'm familiar with Latin): afflare, hallar; factor, factor; chalare, callar \$\endgroup\$ – Luis Mendo Dec 20 '20 at 18:00
  • \$\begingroup\$ @LuisMendo hallar and chalare are definitely typos. But hechor was intentional. I suspect your hang up is that factor and hechor are doublets but factor is more similar to the Latin. There are plenty of words here for which the Latin is not a direct translation or the Spanish or vice versa (even factor is not). I chose to include hechor because it is a good example of some of the changes that I want to highlight, (f -> h and ct -> ch). \$\endgroup\$ – Wheat Wizard Dec 21 '20 at 23:26
  • \$\begingroup\$ The thing is, I never heard hechor. But I just checked in the dictionary and it is included, albeit as an old form, not in current use \$\endgroup\$ – Luis Mendo Dec 21 '20 at 23:46
4
\$\begingroup\$

Strobogrammatic Numbers


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,


strobogrammatic-number

(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 , 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?
\$\endgroup\$
1
4
\$\begingroup\$

Explain a Code Golf Answer

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 , 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?
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Related \$\endgroup\$ – Razetime Dec 24 '20 at 10:32
  • 1
    \$\begingroup\$ @Razetime I would say this is a dupe :-( \$\endgroup\$ – pxeger Dec 24 '20 at 13:35
  • \$\begingroup\$ I'd say this is simpler and more suited for code golf because it functions without the need for a complex priority system. You may want to request more opinions on the nineteenth byte. \$\endgroup\$ – Razetime Dec 24 '20 at 17:51
4
\$\begingroup\$

Interpret Interval Notation

\$\endgroup\$
13
  • \$\begingroup\$ @Adám yes to and -ish characters. I also broadened the scope to all meaningful intervals, so ranges may overlap and [5,5] (all integers x where 5<=x<=5)is [5] but not [5,5) (all integers x where 5<=x<5) and (5,5) (all integers x where5<x<5) are undefined. \$\endgroup\$ – Aiden4 Dec 22 '20 at 21:07
  • 2
    \$\begingroup\$ All integers x where 5<=x<5 would be [], no? \$\endgroup\$ – Adám Dec 22 '20 at 22:25
  • \$\begingroup\$ I'd put all the undefined cases separately, or at least at the end. \$\endgroup\$ – Adám Dec 23 '20 at 0:09
  • 2
    \$\begingroup\$ Typo: the [9,13] test case should either be [9,13) or 13 is missing from the output. \$\endgroup\$ – Dingus Dec 23 '20 at 2:35
  • \$\begingroup\$ undefined cases should be undefined behavior instead. Otherwise, one need to handle it separately which feels bad. Otherwise, it's a good challenge :) \$\endgroup\$ – vrintle Dec 23 '20 at 11:22
  • \$\begingroup\$ If you allow other symbols for the brackets, make sure to prohibit other phrases as that can be abused. \$\endgroup\$ – Adám Dec 23 '20 at 15:16
  • \$\begingroup\$ @Adám what do you mean by phrases? \$\endgroup\$ – pxeger Dec 23 '20 at 16:06
  • 3
    \$\begingroup\$ @pxeger Multi-character constructs. It'd allow solutions to require an input format that contained the necessary code such that the solution becomes an eval. \$\endgroup\$ – Adám Dec 23 '20 at 16:46
  • 1
    \$\begingroup\$ Related \$\endgroup\$ – Razetime Dec 24 '20 at 10:44
  • \$\begingroup\$ Is parsing a string necessary? Could you also allow other constructs (tuples with a marker to show if they're open or closed)? \$\endgroup\$ – user Dec 25 '20 at 21:56
  • \$\begingroup\$ Just asking frankly, did you forgot to post this, or is something yet missing? \$\endgroup\$ – vrintle Jan 4 at 2:59
  • \$\begingroup\$ @user I am going to say no to other constructs otherwise, it is basically a duplicate of the related challenge. \$\endgroup\$ – Aiden4 Jan 4 at 15:03
  • \$\begingroup\$ @vrintle Something like that. I haven't really been active since just before Christmas. I'll probably post it this afternoon. \$\endgroup\$ – Aiden4 Jan 4 at 15:04
4
\$\begingroup\$

Implement a zipwith function

\$\endgroup\$
14
  • \$\begingroup\$ APL or J will win this with 2 bytes (that's the shortest possible score, right?) \$\endgroup\$ – Adám Jan 14 at 21:23
  • \$\begingroup\$ Required tag: restricted-source \$\endgroup\$ – Adám Jan 14 at 21:24
  • \$\begingroup\$ Why the builtin restriction? \$\endgroup\$ – Redwolf Programs Jan 14 at 21:45
  • \$\begingroup\$ @RedwolfPrograms To avoid trivialising the challenge \$\endgroup\$ – ChartZ Belatedly Jan 14 at 21:52
  • \$\begingroup\$ @Adám 1) if those 2 bytes are a builtin, then no, otherwise, very possible. 2) Why [restricted-source]? \$\endgroup\$ – ChartZ Belatedly Jan 14 at 21:52
  • \$\begingroup\$ Any reason for banning that builtin in Haskell and Jelly? What's wrong with people submitting that as answer? They won't get upvoted much anyway. And it still lets people use builtins in other languages. \$\endgroup\$ – user Jan 14 at 22:14
  • \$\begingroup\$ @cairdcoinheringaahing No, that'd be prohibited by your source restrictions rule on an exact built-in. Rather, it'd be a more general built-in (so not "exact") plus a parameter that makes the general built-in choose the required behaviour. \$\endgroup\$ – Adám Jan 15 at 3:21
  • \$\begingroup\$ Allowing the built-in and seeing how many languages have it could be interesting in its own right. Or, generalize the problem to nzipwith, which takes an n-ary function and n sequences (and optionally the value n) and call the function for each n-tuple from the n sequences. \$\endgroup\$ – Bubbler Jan 15 at 6:10
  • \$\begingroup\$ I've softened the builtin ban to simply encourage people to post a non-builtin answer as well. @Bubbler Possibly, but I think it'd be a good challenge to simply have the basic zipwith given that it's a fairly common functional programming construct \$\endgroup\$ – ChartZ Belatedly Jan 15 at 14:39
  • \$\begingroup\$ I think it's better to not ban them, and simply let builtin users wallow in their downvotes/shame so they don't do it again \$\endgroup\$ – pxeger Jan 16 at 19:45
  • \$\begingroup\$ @pxeger I've removed the builtin ban, and changed it to encourage builtin-only answers to include a non-builtin version as well \$\endgroup\$ – ChartZ Belatedly Jan 16 at 19:47
  • \$\begingroup\$ Would taking input as two lazily evaluated iterators over the elements of the list or outputting an iterator over the results be acceptable \$\endgroup\$ – Aiden4 Jan 26 at 1:39
  • \$\begingroup\$ @Aiden4 I think that taking lists as lazy iterators is an accepted I/O method, so yes \$\endgroup\$ – ChartZ Belatedly Jan 26 at 9:11
  • \$\begingroup\$ I find the former ban on Jelly's " interesting considering that there's no way to really pass it a function. \$\endgroup\$ – Unrelated String Jan 26 at 9:36
4
\$\begingroup\$

Test if a Gray code is Beckett

An \$n\$-bit Gray code is an ordering of \$2^n\$ binary sequences so that adjacent sequences always differ by exactly one bit.

A Beckett-Gray code is a special kind of Gray code. In addition to being a Gray code, it has the following characteristics:

  • It is cyclic: the last bit pattern has one bit difference with the first pattern.
  • The first pattern is all zeros.
  • Whenever a bit turns from 1 to 0, that bit is the one which has been 1 for the longest time (consecutively).

It is known that a Beckett-Gray code exists for \$n=2, 5, 6, 7, 8\$, but does not exist for \$n=3\$ and \$4\$. It is not known if any such code exists for \$n \ge 9\$, and no constructive methods to build such a code are known.

One example for \$n=5\$ is as follows (copied from this paper, 1-0 transition marked):

00000, 00001, 00011, 00010, 00110, 00111, 00101, 01101,
                         ^                   ^
01001, 01000, 01010, 01011, 11011, 10011, 10111, 10101,
  ^        ^                        ^               ^
10100, 00100, 01100, 11100, 11000, 11010, 10010, 10110,
    ^  ^                      ^            ^
11110, 01110, 01111, 11111, 11101, 11001, 10001, 10000
       ^                       ^     ^     ^         ^

Task

Given a cyclic Gray code starting with an all-zero pattern, determine if it is a Beckett-Gray code.

You may take input as a sequence of boolean arrays (possibly transposed), a sequence of strings, or a sequence of equivalent integers. Also, you may optionally take the value of \$n\$ as the second input.

For output, you can choose to

  1. output truthy/falsy using your language's convention (swapping is allowed), or
  2. use two distinct values to represent true (affirmative) or false (negative) respectively.

Standard rules apply. Shortest code in bytes wins.

Test cases

Each test case is separated with an empty line.

Truthy (Beckett)

0, 1

00, 01, 11, 10

00, 10, 11, 01

00000, 00001, 00011, 00010, 00110, 00111, 00101, 01101,
01001, 01000, 01010, 01011, 11011, 10011, 10111, 10101,
10100, 00100, 01100, 11100, 11000, 11010, 10010, 10110,
11110, 01110, 01111, 11111, 11101, 11001, 10001, 10000

00000, 01000, 01001, 00001, 00011, 01011, 01010, 11010,
11000, 10000, 10001, 11001, 11101, 01101, 01111, 01110,
00110, 00010, 10010, 10110, 10100, 10101, 00101, 00111,
10111, 10011, 11011, 11111, 11110, 11100, 01100, 00100

Falsy (Not Beckett)

000, 001, 011, 010, 110, 111, 101, 100

0000, 1000, 1100, 1110, 1111, 1101, 0101, 0001,
1001, 1011, 1010, 0010, 0011, 0111, 0110, 0100

00000, 00001, 00011, 00010, 00110, 00111, 00101, 00100,
01100, 01101, 01111, 01110, 01010, 01011, 01001, 01000,
11000, 11001, 11011, 11010, 11110, 11111, 11101, 11100,
10100, 10101, 10111, 10110, 10010, 10011, 10001, 10000

Meta

  • Is it a good challenge idea as written? Am I simplifying the task too much?
  • Is the task clear?
\$\endgroup\$
1
  • 1
    \$\begingroup\$ Cool challenge and nice background information. +1. (also almost clear enough, except that I assume that "for the longest time" means "consecutively" / "since the last time it has been 0"? (not since the beginning of the sequence)) \$\endgroup\$ – user202729 Mar 5 at 12:47
3
\$\begingroup\$

Metagolf: Catlike Piet

The goal of this is to write a catlike program, which would be executed (in a Unix environment, though you needn't stick to that) by the following:

yourprogram < file > output
piet output

where piet output writes the contents of file to stdout. That is, you're to generate a Piet program which prints the input to yourprogram.

One-liners

Straight line programs can be written in Piet... in straight lines. If you're willing to take a hit to your score, your output can take the form of a string of commands:

=  none (continue color block)
|  push
^  pop
+  add
-  subtract
*  multiply
/  divide
%  mod
~  not
>  greater
.  pointer
\  switch
:  duplicate
@  roll
$  input number
?  input character
#  output number
!  output character

which is trivial to convert to a Piet program with the following (partially golfed) Python code:

def P(s):
 h=v=0;l=len(s)+1;R="P3 %i 2 255 192 0 0 "%(l+2)
 C=[1,3,2,6,4,5];V=[0,192,192,255,0,255]
 for x in map("=|^+-*/%~>.,:@$?#!".find,s):
  C=C[x//3:]+C[:x//3];V=V[x%3*2:]+V[:x%3*2]
  for i in [1,2,4]:R+="%i "%V[(C[0]//i)%2]
 return R+"255 "*4+"0 0 "+"255 "*l*3+"255 0 0 "*2

The dimension of said program is (n+3) x 2 if there are n characters in the string.

Scoring

Your code will be judged on the maximum dimension of the images that it outputs.

  • Part 1: Take the maximum score taken over all ascii codes (that is, single-character inputs), discounting EOF.

  • Part 2: Take the score for the input "Hello. My name is Inigo Montoya. You killed my father. Prepare to die."

Your score is the product of the scores in part 1 and part 2.

Punishment: Double your score if you write one-liners as above (that is, if you don't output an image).

Bonus: If your program is written in Piet, take the square root of your score above.

\$\endgroup\$
4
  • 1
    \$\begingroup\$ It took me a while to understand the task as "Write a program taking INPUT which produces as output a piet program that takes no input but produces INPUT." I think it is a interesting and challenging, but it's reception will depend entirely on how many people are willing to learn/futz-around-in/deal-with piet. And I have no feel for how many that is. \$\endgroup\$ – dmckee --- ex-moderator kitten Jul 7 '11 at 3:12
  • \$\begingroup\$ @dmckee; would it be better if I just used a reduced instruction set, and only ask for the instruction stream? I think this is still challenging with {push 1,duplicate,add,subtract,multiply,output}. Come to think of it, if I restrict to {push 1,duplicate,add,output}, there's a reduction to some awesome algorithms. \$\endgroup\$ – boothby Jul 7 '11 at 4:48
  • \$\begingroup\$ I did this in piet some time ago: craigoclock.blogspot.com/2011/05/metaprogramming-in-piet.html \$\endgroup\$ – captncraig May 21 '12 at 18:31
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) \$\endgroup\$ – programmer5000 Jun 9 '17 at 15:22
1
6 7
8
9 10
105

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .