571
\$\begingroup\$

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

\$\endgroup\$
1
  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    May 15 at 14:05

4688 Answers 4688

1
87 88
89
90 91
157
1
\$\begingroup\$

Possible moves in Othello/Reversi

\$\endgroup\$
1
  • \$\begingroup\$ This actually seems interesting, commenting since it's late and otherwise you wouldn't see \$\endgroup\$
    – mousetail
    Jan 25 at 14:30
1
\$\begingroup\$

Remove falsy rows and columns

\$\endgroup\$
1
\$\begingroup\$

Is it a coordinate-sum list?

In this challenge, we define a coordinate-sum list as a ragged list of positive integers where each value is the sum of its 0-indexed-coordinates in the array. For example, the following ragged list is a coordinate-sum list:

[[[0, 1],
  [1, 2, 3],
  [2]],
 [[1],
  [2, 3, 4],
  3]],
 2]]

In this array, the 4 is the third item of the second item of the second item of the list, or arr[1][1][2] (0-indexing), which gives it the coordinate [1, 1, 2], which sums to 4. Likewise, the 0 is arr[0][0][0] and has the coordinate [0, 0, 0] which sums to 0, and this is true for all items in the list.

This, however, is not a coordinate-sum list:

[[0, 1, 2],
 [1, 2, 3, 4],
 [2, 3, 6, 5],
 3]

Although all the other entries are the sums of their coordinates, the 6 at the third item of the third row has coordinate [2, 2], which sums to 4, but its value is 6, so this is not a coordinate-sum list.

Your challenge is to, given a nonempty ragged list of positive integers containing no empty lists at any level, determine whether it is a coordinate-sum list. You may instead validate the input via 1-indexing (i.e. [[2, 3], [3, 4, 5], 2] would be valid).

This is , shortest wins!

Testcases

All of these use 0-indexing. If your answer uses 1-indexing, add to each value its depth in the list.

Truthy

[0]
[0, 1, 2, 3]
[[0, 1, 2], [1, 2, 3, 4], 2]
[[[0, 1, 2, 3], [1, 2]], [[1, 2, 3], [2, 3, 4, 5, 6], [3, 4, 5]]]
[[0, 1, 2, 3, 4, 5, 6, 7], 1, [2, 3, 4, [5, 6, 7], 6], [3, 4, 5, 6]]
[[[[0, 1], [1, 2], 2], [[1, 2, 3], [2, 3]]], [[[1, 2], [2, 3, 4]], [[2, 3], [3, 4, 5, 6, 7]]], [2, 3]]
[[[[[0, 1, 2], [1, 2, 3], [2, 3, 4], [3, 4, 5]], [[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]], [[2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]]], [[[1, 2, 3], [2, 3, 4], [3, 4, 5], [4, 5, 6]], [[2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]], [[3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8]]], [[[2, 3, 4], [3, 4, 5], [4, 5, 6], [5, 6, 7]], [[3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8]], [[4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9]]], [[[3, 4, 5], [4, 5, 6], [5, 6, 7], [6, 7, 8]], [[4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9]], [[5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]]], [[[4, 5, 6], [5, 6, 7], [6, 7, 8], [7, 8, 9]], [[5, 6, 7], [6, 7, 8], [7, 8, 9], [8, 9, 10]], [[6, 7, 8], [7, 8, 9], [8, 9, 10], [9, 10, 11]]]]]

Falsy

[2]
[[1, 2], [2, 3, 4]]
[[0, 1], [2, 3]]
[[[1, 2, 3], 4, [3, 4, 5]], [[2, 3, 4], [3, 4, 5], [4, 5, 6]], [[3, 4, 5], [4, 5, 6], [5, 6, 7, 8], [6, [7, 8], 8]]]
[4, 3, 2, 1, 0]
[[4, 3, 2], [3, 2, 1], [2, 1, 0]]
\$\endgroup\$
3
  • \$\begingroup\$ Why does it matter that the array is othogonal? \$\endgroup\$
    – pajonk
    Feb 12 at 7:12
  • \$\begingroup\$ @pajonk It doesn't, it was mostly because I didn't want to make things unnecessarily hard for langs like C and haskell which don't (natively) have ragged lists. You're right that almost all approaches would work for ragged lists, and I'm just going to change it to that. (sorry for the late reply) \$\endgroup\$
    – emanresu A
    Feb 15 at 20:38
  • \$\begingroup\$ Ah, sorry for the confusion. We have different definitions of orthogonal and array - for me an array is simply a non-ragged list and orthogonal is a specific property related to arrangement of columns in the array. That said, I personally would prefer non-ragged lists (arrays) in this challenge, as this would be easier for languages supporting matrices (and higher dimension generalisations) like R or Octave. \$\endgroup\$
    – pajonk
    Feb 16 at 5:44
1
\$\begingroup\$

Search the deepest depths of an array

\$\endgroup\$
1
  • \$\begingroup\$ "multidimensional array" is a bit of a confusing term here, it's really a ragged list/array. \$\endgroup\$
    – Wheat Wizard Mod
    Feb 24 at 0:51
1
\$\begingroup\$

Print the largest hidden double

Given a sting of space delimited words, find the longest word such that, when that word is replaced with spaces, it is still a subsequence of the remaining string. Then, replace everything, except for one such subsequence, with spaces. Print the result

example:

input:

that was esoteric and awesome man dope

longest applicable word: awesome

output:

a w eso m e

Extra rules / Clarifications

  • You may always assume a solution
  • Input will only be ascii letters a-z and spaces
  • Input will be either all uppercase or all lowercase, whichever is most convenient for the solver
  • You must output leading spaces unless that is absolutely impossible for your language in general, but trailing spaces may be removed

meta:

i havent written a challenge in so long - how much of this is salvageable and how much can i clear up haha

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Will there always be a valid solution? Eg. a dog jumps has no answer \$\endgroup\$
    – ATaco
    Mar 6 at 2:39
  • \$\begingroup\$ @ATaco oh yea good question! I think these are better if you can always assume a solution so I'll add that, thank you \$\endgroup\$ Mar 7 at 6:04
1
\$\begingroup\$

Lattice points visible from the origin

\$\endgroup\$
1
\$\begingroup\$

Magical BF: BF code that works in two ways


Meta

  • This is basically a resurrection of this closed challenge but with different scoring. It was closed based on the policy about multipart challenges. I believe the most problematic part (copying parts of solutions) is solved by competing for each task separately. I also believe that this challenge is better served as one than five separate challenges, since there are some general techniques that transfer well across tasks (trust me, I solved all five tasks before posting this) and posting five of these would look spammy and unoriginal. Please leave comments if you think this version is off-topic.
\$\endgroup\$
4
  • \$\begingroup\$ Where does tape head start? \$\endgroup\$
    – l4m2
    Mar 7 at 8:34
  • \$\begingroup\$ Tape head (data pointer) starts at the leftmost cell. \$\endgroup\$
    – Bubbler
    Mar 7 at 8:37
  • \$\begingroup\$ Is "Author" you or the source? \$\endgroup\$
    – l4m2
    Mar 7 at 8:38
  • \$\begingroup\$ Those are my best scores. \$\endgroup\$
    – Bubbler
    Mar 7 at 8:40
1
\$\begingroup\$

Can I Clear The Grid?

\$\endgroup\$
4
  • \$\begingroup\$ Suggest case RGRG in case someone click on non-empty cell \$\endgroup\$
    – l4m2
    Mar 18 at 8:37
  • \$\begingroup\$ Provide link to english version instead? \$\endgroup\$ Mar 18 at 13:29
  • \$\begingroup\$ @Mukundan314 didn't realize there was one; thanks \$\endgroup\$
    – hyper-neutrino Mod
    Mar 18 at 13:57
  • \$\begingroup\$ @l4m2 good suggestion, added \$\endgroup\$
    – hyper-neutrino Mod
    Mar 18 at 13:59
1
\$\begingroup\$

Swingin' Four Operations!

Before, I found this song which has no meaning other than to combine all the consonants and vowels in the English alphabet. This challenge is similar, however, instead of outputting the song, your programs should output a modification which is basically addition, subtraction, multiplication and division tables of small integers up to 12, but presented in a format similar to the song.

Your challenge is to write a program that takes no input and outputs the four operation tables, where the operation inputs (first input from 1 to 10, second input from 1 to 12, both inclusive, 1 omitted for both inputs in the tables for multiplication and division) and output are seperated by spaces, the columns are seperated by commas followed by spaces and the rows are separated by dots followed by new lines. For division, non-integer outputs are rounded off to two decimal places. Each table is separated by two newlines.

The last two columns (11 and 12) don't contain the first parameter of the modification and are only separated by spaces. The required output is in this pastebin.

Rules:

  • You are not allowed to use external resources, such as the internet.
  • You cannot use compression algorithms, such as gzip or bzip2, unless you include the full algorithm in your code.
  • Use any language, shortest code in bytes wins.

\$\endgroup\$
4
  • \$\begingroup\$ Great challenge for writing reusable code and formatting numbers. I've got a few questions: 1) You say that it should output the tables for small integers up to 12. Why are the matrices in the pastebin link 10 by 12? 2) Does 'You are not allowed to use external resources, such as the internet' mean you may not do research (which would be a little weird for answering an online question) or you may not use an API (which is generally not allowed for codegolf)? \$\endgroup\$
    – Cactusroot
    Mar 29 at 18:41
  • \$\begingroup\$ @Cactusroot It does not specify that all of the small integer pairs are outputted. Also, 'You are not allowed to use external resources, such as the internet' means you may not use an API. \$\endgroup\$ Mar 29 at 18:49
  • \$\begingroup\$ Sorry, I added the question. Now I got it, but 'the text in this pastebin' may be a little ambiguous. I believe you can define it precisely as "Any of the four modification tables, where the modification inputs and output are separated by spaces, the columns are separated by commas followed by spaces and the rows are separated by dots followed by new lines, with a trailing separation. The last two columns (11 and 12) don't contain the first parameter of the modification and are only separated by spaces" \$\endgroup\$
    – Cactusroot
    Mar 29 at 18:51
  • \$\begingroup\$ @Cactusroot Edited. \$\endgroup\$ Mar 29 at 18:54
1
\$\begingroup\$

Rotation by triple skewing

You can rotate a two-dimensional array by an angle by sampling or some other mechanism to approximate the resulting value at a specific point. However this is not very effective for a small array, such as an ASCII-art picture. Instead, we can approximate the rotation by a triple skew.

The first skew shifts the rows of the array by an amount proportional to the distance above or below the centre of rotation. This value is an input which I shall call \$ t \$.

The second skew shifts the columns of the array by an amount \$ \frac{-2t}{1+t^2} \$ multiplied by the distance to the left or right of the centre of rotation.

The third skew is a copy of the first skew.

The shift amounts should be one of rounded, floored or ceilinged so that each row or column is shifted by an integer amount.

The array should be considered to be cyclic so that elements shifted will wrap around to the other side.

Given an input array, a centre of rotation, and \$ t \$, output the resulting rotated array.

The array may be any convenient data type such as bytes, characters or integers. If the array is of characters then you may also represent it as a list of strings.

Example of the three skews for \$t=0.475\$:

  012       012          27DE      27DE 
 34567     34567        16CJK     16CJK 
89ABCDE    89ABCDE     05BIQR     05BIQR
FGH IJK -> FGH IJK -> 34A PVW -> 34A PVW
LMNOPQR    LMNOPQR    89HOUZ     89HOUZ 
 STUVW       STUVW    FGNTY       FGNTY 
  XYZ         XYZ     LMSX        LMSX  

This is , so the shortest program that breaks no standard loopholes wins!

\$\endgroup\$
1
\$\begingroup\$
8-bit AVR integer division

Impatience got the better of me

\$\endgroup\$
1
\$\begingroup\$

Complement of a set of ranges

Consider a shop that exists for a given range of time. At certain times during the shop's existence items can go on sale. These items will be on sale for at least one unit of time.

Challenge

Given such a shop, and the times it has items for sale, find the mutually-exclusive ranges of time when the shop is not selling anything.

Your inputs will be: a two-length array that represents the range of time the shop exists for. An array, where each element is a two-length array that represents a range of time that an item was on sale for.

your output will be: An array, where each element is a two-length array that represents a range of time that no item was on sale for. Where no element's range should overlap another's range.

All values defining a time range will consist of positive integers (or zero).

Example

A shop exists for the time range [0, 10].

An item is put up for sale during the time range [5, 8]. Another item is put up for sale during the time range [2, 3]. Another item is put up for sale during the time range [4, 6].

Thus the shop is selling nothing from time 0 to 2, 3 to 4, and 8 to 10.

Inputs: [0, 10] and [[5, 8], [2, 3], [4, 6]]

Output: [[0, 2], [3, 4], [8, 10]]

Extra info

You may assume that the input time ranges overlap on a common boundary. i.e. items on sale for [1, 3] and [3, 4] is effectively a sale for [1, 4].

No time range (input or output) should span less than one unit of time: i.e. [1, 1] or [7, 7] is not permitted.

In case this seems ambiguous, the input time ranges can be thought of as closed intervals. Whilst the output time ranges can be thought of as open intervals. All the values used are whole numbers, however the ranges they represent are continuous. i.e. the open interval '[1, 2]' which does not contain any integers, still represents a continuous span of time between '1' and '2' (non inclusive on both sides).

Test cases (first array is the time for which the shop exists, second is the times for which items were on sale)


[0, 100] [[3, 7], [2, 5], [17, 54], [99, 100]] -> [[0, 2], [7, 17], [54, 99]]

[7, 20] [[8, 17], [12, 13], [14, 17], [9, 16], [18, 19]] -> [[7, 8], [17, 18], [19, 20]]

[1, 2] [[1, 2]] -> []

\$\endgroup\$
2
  • \$\begingroup\$ “You have written this well” is a compliment. The title should read complement. \$\endgroup\$ Apr 1 at 14:10
  • \$\begingroup\$ @KaiBurghardt Thanks. That explains why I'm always spelling implement incorrectly (impliment). \$\endgroup\$ Apr 2 at 13:45
1
\$\begingroup\$

Odds for second smallest prime factor

\$\endgroup\$
1
\$\begingroup\$
\$\endgroup\$
3
  • 1
    \$\begingroup\$ Maybe add test cases with the words title-cased? And even with mOrE eRrAtIc CaPs, unless it's more to the point to guarantee that the input will always be either all-lower, all-upper, or title. \$\endgroup\$ Mar 29 at 19:31
  • 1
    \$\begingroup\$ @UnrelatedString I am not going to do title case. I've considered it and I think it adds to much complexity, plus there are a bunch of cases where I don't even know what's proper, (m'Ubh, M'ubh, or M'Ubh?) And I definitely am not doing erratic caps. \$\endgroup\$
    – Wheat Wizard Mod
    Mar 31 at 19:01
  • \$\begingroup\$ I had assumed that title casing was expected to be handled from the verbiage about matching the case of the second character, but agree that the added complexity would be out of proportion. \$\endgroup\$ Apr 1 at 0:06
1
\$\begingroup\$

Emulate Jelly's tie-scan

\$\endgroup\$
1
\$\begingroup\$

Bitwise and on 2-adic number

TODO: Explain 2-adic number

E.g. 0b...001001001 * 0b111 = 0b...1111111 = -1, so 0b...001001001 = -1/7.

Given two 2-adic numbers in fraction form, output their bitand result.

Test cases:

1 & 2 => 0
1/3 & 2/3 => 2

  • Should I require decimal support (1/2 = 0b0.1)?
\$\endgroup\$
1
\$\begingroup\$

You're to create a file using a hex editor. Unluckily most of keys on your keyboard are broken. You can:

  • Add a byte you can press at the end of file
  • Add a byte such that, the upper 4 bits hex is a character you can press, and lower 4 bits hex is 0
  • Modify upper/lower 4 bits of a byte hex to a character you can press.

Here, character 0x30-0x39 map char 0-9, and 0x41-0x46, 0x61-0x66 map A-F for hex edit purpose.


Given the set of characters you can press, return all chars you can type in. IO can be integers or chars, and all in [0,255].

Test Cases

  • 3 (space and three) => #03
  • 8A => 8:AHJ\x81\x88\x8A\xA1\xA8\xAA
  • \xBA => \xBA
\$\endgroup\$
1
  • 1
    \$\begingroup\$ I think it would be helpful to have "Given the set of characters you can press, return all chars you can type in." closer to the top, with the "rules" below that. The rules are a bit confusing otherwise until I get further down. \$\endgroup\$
    – mbomb007
    Apr 10 at 18:30
1
\$\begingroup\$

Compose Two Polynomials

Objective

Given two polynomials \$p\$ and \$q\$ with integer coefficients (and with one indeterminate), output their composition \$p \circ q\$.

I/O format

Flexible.

It is assumed that the inputted polynomials have no leading zero coefficients, and the outputted polynomial shall have no leading zero coefficients, either.

Examples

Here, the polynomials are represented as lists of coefficients in descending degree of terms.

p(x), q(x), p(q(x))

[], [2,1], []
[1,2], [], []
[1], [1], [1]
[1], [2], [1]
[4,1], [1], [5]
[2,0], [1,2], [2,4]
[1,2], [2,0], [2,2]
[1,0], [3,3,3,-2], [3,3,3,-2]
[1,0,-1], [1,0,-1], [1,0,-2,0,0]
\$\endgroup\$
2
  • \$\begingroup\$ Duplicate? \$\endgroup\$
    – xnor
    Apr 19 at 22:32
  • \$\begingroup\$ @xnor Nevermind; though that question is poorly titled. \$\endgroup\$ Apr 20 at 0:12
1
\$\begingroup\$

Numbers with variable repeating digits

The number \${4...4}1\$ can be written as the expression \$\frac{4 \times 10^{a+1} - 13}{9}\$, where the variable \$a\$ represents the number of \$4\$s. Given such a number, output its corresponding expression.

Rules

  • The term doesn't have to be in the simplest form
  • The expression has to be in standard mathematical infix notation, you can replace the operators by a constant set of characters
  • You can take the variables via input or use lowercase/uppercase letters (you can assume the number of repeated groups is max. 26)
  • The number is strictly positive

Examples

[In]: [[4, "n"], 1]
[Out]: [[4, "*", [[10, "^", ["n", "+", 1]], "-", 13]], "/", 9]

[In]: [[6, "variable"], [2, "constant"], [53, "variable"]]
[Out]: "(10^(2*b)*(660*10^a-409)-53)/99"

...
\$\endgroup\$
5
  • \$\begingroup\$ Can each variable only be used once? \$\endgroup\$
    – l4m2
    Apr 29 at 0:45
  • \$\begingroup\$ @l4m2 Good question, I’d say no. (To confirm, the challenge wouldn’t be too trivial then, right?) \$\endgroup\$
    – math scat
    Apr 29 at 5:29
  • \$\begingroup\$ I'm not sure if I am missing something, but your formula seems to work for 4...43 rather than 4...41. I think if you change -13 to -31 it will be correct. I don't think you have enough of a requirement on the output as it is. I presume you want the answer to be divided by some multiple of 9 and 11, but without requiring it one could certainly come up with some other representation that would also work. \$\endgroup\$ Apr 30 at 22:13
  • \$\begingroup\$ @FryAmTheEggman Thanks. About the output requirement, you’re saying it’s better to restrict it to expression without any divisions / multiple of 9 and 11? \$\endgroup\$
    – math scat
    May 1 at 5:37
  • \$\begingroup\$ I was saying that was how I interpreted what you wanted the output to be. As is, a submission could produce some other valid expression, which may be very different from what you have here. If you don't actually care about that then you can leave it as it is. \$\endgroup\$ May 1 at 15:10
1
\$\begingroup\$

3-Dimensional Minesweeper

I've been on a minesweeper kick for a while, but all the questions are for 2 dimensions (or that one in 1D). But 2D is 2 easy!

Challenge

Write the shortest code possible to fill in the clues for a 3-dimensional minesweeper grid.

Input

The board dimensions, taken in any order and reasonable format, and the mines as a list of 3-dimensional coordinates in any reasonable format and order.

Output

A 3-D list resembling a 2-D list of columns (consistent order) or a list of 2-D slices (in order, any perspective) to form the final 3-D board. The number of adjacent mine can either be a number 1-26 or the corresponding letter a-z, unless it is empty and then it is 0. Mines can be any character/string that is not a number 0-26, and not a letter a-z if those are used instead.

test cases

Board: 3x3x3
Mines: [1,1,1]
Output:
[[[1,1,1],
[1,1,1],
[1,1,1]],
[[1,1,1],
[1,*,1],
[1,1,1]],
[[1,1,1],
[1,1,1],
[1,1,1]]]
\$\endgroup\$
4
  • \$\begingroup\$ Since the clues are going to be numbers, not just single digits, it would be convenient if the mines could be represented by numbers as well (optionally). I would suggest allowing answers to choose any number that can't be a clue to represent a mine. \$\endgroup\$
    – DLosc
    Apr 29 at 18:43
  • \$\begingroup\$ so the surrounding mines can be up to 26, if you want to take the mines as a number greater than that i guess you can? \$\endgroup\$
    – pacman256
    Apr 29 at 19:04
  • \$\begingroup\$ should i also allow a-z to represent adjacent mines \$\endgroup\$
    – pacman256
    Apr 29 at 19:05
  • 1
    \$\begingroup\$ Sure, why not? It's a fun coincidence that there are 26 letters, and maybe someone will find it helpful. (In the realm of numbers, I was thinking mines might be usefully represented by either 27 or -1.) \$\endgroup\$
    – DLosc
    Apr 29 at 19:10
1
\$\begingroup\$

Interpret Gray Snail

Gray Snail is a small Turing-complete string-based language that I've had fun using lately. Let's write an interpreter for it!

Note: there are several differences between the language spec on Esolangs, the behavior of the official implementation, and the spec for this challenge. These differences are noted in a section below.

Language overview

Gray Snail is an imperative language in which programs consist of a series of commands. Commands are executed one after another (unless the instruction pointer is changed by a GOTO statement). When the instruction pointer reaches the end of the program, execution halts.

Syntax

Each line of code represents one command. A command consists of one or more words (see below) separated by spaces. Examples of commands:

POP first rest hello
OUTPUT [first]
GOTO "exit string reversal loop" "" "[original string]"
1234567890!@#$%^&*()

You may assume the code will not contain any blank lines.

There are five types of commands: POP, GOTO, INPUT, OUTPUT, and labels. See the section on Commands for a full description.

Words

A word is composed of printable ASCII characters. It is either A) two double-quote characters surrounding a run of zero or more non-quote characters, or B) a run of one or more characters that do not include spaces or double quotes (in regex: ".*?"|[^\s"]+).

Examples of words:

POP
[xyz]123
"Hello, World!"
"  "
""

Quotes are only used for parsing and are not considered part of the word. For example, abc and "abc" are the same word, just written differently. There is no method of escaping quotes; words cannot include a literal " character. You do not have to handle unmatched quotes or quotes in the middle of a word.

The empty string is a valid word. You may assume that an empty word will always be wrapped in quotes ("").

No two words will occur next to each other; they will always be separated by spaces. The only way for spaces to be part of a word is if the word is wrapped in quotes. Outside of a word, you may assume there will never be multiple spaces in a row.

Strings

The only data type in Gray Snail is the unlimited-length string. Strings can be stored in variables, concatenated, and decomposed by the POP command (see below). Strings can be empty.

In contexts that expect a string, any word that does not contain square brackets is treated as a string literal. Anything wrapped in square brackets is a variable reference.

Variables

A variable has a name and a value, both of which are strings. Variables can be set by the POP or INPUT commands.

In contexts that expect a string, the value of a variable can be inserted by enclosing the variable's name in square brackets: for example, if the variable var is set to hello, OUTPUT var outputs the literal string var, but OUTPUT [var] outputs hello.

In contexts that expect a variable, the variable's name is not enclosed in square brackets: for example, INPUT var sets var to a string read from input.

Variable references can be concatenated to each other and to literal strings: if variable a contains code and variable b contains golf, [a]a[b] evaluates to codeagolf.

You may assume that variable names will be non-empty and will not contain square brackets.

Variable names may be wrapped in quotes and may contain spaces. Due to the syntax rules above, the quotes will always be on the outside of the word; thus, a variable named "some var" will be written as "[some var]" when retrieving its value.

Dereferencing a variable more than once (i.e. nesting square brackets) is undefined behavior: your interpreter will never need to handle something like [[a]]. You do not have to handle unmatched square brackets.

You may assume that variables will not be referenced before they are assigned.

Commands

There are five types of command in Gray Snail. Each consists of a fixed number of words, separated by single spaces. Four of them start with a specific word (POP, GOTO, INPUT, and OUTPUT).

Pop

POP var1 var2 string takes two variable names and a string. It separates the string's first character (in this example, s) from the rest (tring). It then stores the first character in the variable named var1 and the rest in the variable named var2.

  • If the third argument has only one character, that character is stored in var1 and the empty string is stored in var2.
  • If the third argument is empty, the empty string is stored in both var1 and var2.
  • The third argument is not modified by POP, even if it is a variable reference.

Label

A single word on a line by itself is a label. Labels do nothing; they serve as targets for GOTO instructions.

  • You may assume that the other commands' names (POP, GOTO, INPUT, or OUTPUT) will not be used as labels. Labels are case-sensitive, though, so pop or Pop could be used.
  • You may assume that labels will be non-empty and will not contain square brackets.
  • Labels may be wrapped in quotes and may contain spaces.

Goto

GOTO label string1 string2 takes three strings and compares string1 and string2. If they are equal, the program jumps to the label named label and execution continues from there. Otherwise, execution continues with the next statement as normal.

  • A goto target label may contain variable references: for example, GOTO L[a] x x will jump to label L1 if a is 1 and L2 if a is 2.
  • You may assume that the evaluated label name will be a valid label that occurs once and only once in the program. In particular, variables that are referenced in target labels will not contain quotes or square brackets.

Input

INPUT var takes a variable name. It reads a line of input and stores it in the variable named var.

  • Input may contain any printable ASCII character, including space, ", and [].
  • You may assume the program will not run out of input.

Output

OUTPUT string takes a string. It writes out string with a trailing newline.

Differences from the official language

The language specified here is materially the same as the official definition of Gray Snail, but it has been simplified a bit. Here are the ways in which the official implementation differs from this spec:

  • Words can contain any Unicode character. Words can also contain newlines if they are wrapped in quotes.
  • Quotes can wrap any part of the word; for example, ["some var"] is equivalent to "[some var]", and "string w"ith" "spac"e"s is equivalent to "string with spaces".
  • The empty string does not have to be wrapped in quotes. It can be used as a variable name and also as a label.
  • All variables are initialized to undefined.
  • The official spec has some input/output quirks because it's designed for a webpage rather than command-line.
  • The official implementation allows unconditional gotos without comparison strings, such as GOTO x. As far as I can tell, this is contrary to the official spec. One of the example programs on Esolangs uses GOTO x a a for an unconditional goto, which is also what we'll be doing for this challenge.

More details

TODO: stuff about full program vs function, limitations on size of strings, etc.

Example programs

TODO

This is ; the goal is to minimize the size of your code, measured in bytes.

\$\endgroup\$
6
  • \$\begingroup\$ Can the label argument of the GOTO command be a variable? The official interpreter supports this functionality. Also how should something like OUTPUT ][x][ be handled? \$\endgroup\$ Apr 30 at 0:59
  • \$\begingroup\$ Your regex for words doesn't seem to do what you describe in any flavour, as far as I can tell. You also say "even spaces" but it isn't clear if things like newlines should count as part of a word or if that is not supposed to appear in the input. \$\endgroup\$ Apr 30 at 21:59
  • \$\begingroup\$ @FryAmTheEggman Oops. I often get \s and \w mixed up by thinking that \w stands for Whitespace. :P Regex updated and verified working in Notepad++. Re: newlines in words, the answer is implied to be "no" by the statement that each line of code is a command and that each command is composed of words; it's also stated explicitly that "words will only contain printable ASCII characters." ...Although the official interpreter does allow newlines in words if they are quoted, and I allow answers to imitate that behavior. But the default is not to. \$\endgroup\$
    – DLosc
    Apr 30 at 22:13
  • \$\begingroup\$ Ah, I had missed the printable ASCII part. You may want to move it up to the explanation part, as it seems rather important. \$\endgroup\$ Apr 30 at 22:18
  • \$\begingroup\$ I'm starting to think that all the lines of "the official interpreter does this, but you don't have to, but you can if you want to" are cluttering things up. I will probably move them to their own section. \$\endgroup\$
    – DLosc
    Apr 30 at 22:30
  • \$\begingroup\$ @Mukundan314 1) Didn't think of it before, but yes; 2) undefined behavior. I clarified both points. \$\endgroup\$
    – DLosc
    Apr 30 at 22:31
1
\$\begingroup\$

Flip a coin in Lost

\$\endgroup\$
1
\$\begingroup\$

Anti Tic-Tac-Toe

The rule of Anti Tic-Tac-Toe is like Tic-Tac-Toe.

The rules are:

  • There is a 3*3 grid, the squares in the grid are labeled 1 to 9:
123
456
789
  • X goes first.
  • The most important rule: If there's a line, a column or a diagonal with all squares non-blank and the squares are not all the same, the player with more squares in the line, column or diagonal wins. For example, if the grid is like this (. stands for empty cells):
XOX
...
...

Then X wins.

If there are more than one lines like this and their winners are different, the game will stop and the state of the game will be bad.

For example:

OXO
X..
X.O

Is a bad game.

Your task is to input a list of integers from 1 to 9, each integer represents the cell the current player plays. The integers are guaranteed to be different from each other. You have to output the state of the game: X if X wins, O if O wins, . if the game hasn't stopped yet, ! if the game is bad.

Obviously, ties can't occur because if all the squares are taken, there will always be at least one row, column or diagonal that satisfies the winning condition.

You can use any forms of I/O, such as standard I/O, file I/O or function.

Examples

1 -> .
123 -> X
1539 -> O
214379 -> O
294371 -> !

This is , so code in the fewest bytes

\$\endgroup\$
1
\$\begingroup\$

Convert base-10 to base-0.1.

Test cases:

12.34 <=> 432.1 12 <=> 2.1 3.0 <=> 3.00

Hint: Actually 0 can behave same as other digits, as long as you map 3.0 to 3.0 rather than 3 or 3.00.


Anything more I should say?

\$\endgroup\$
1
\$\begingroup\$

Is this a solvable Numberlink?

\$\endgroup\$
7
  • \$\begingroup\$ Your solution example looks like it's required to fill each empty cell with a number s.t. every number connected, which seems not intended \$\endgroup\$
    – l4m2
    May 14 at 22:20
  • \$\begingroup\$ or if allowing to leave some empty cell, then both are equivalent \$\endgroup\$
    – l4m2
    May 14 at 22:22
  • \$\begingroup\$ @l4m2 well you can leave some blank space, just that it has a path \$\endgroup\$
    – badatgolf
    May 15 at 1:37
  • \$\begingroup\$ Many may also know this puzzle as Flow Free. See also But how hard is Flow? (YouTube) which talks about the computational complexity of solving Flow puzzles. Solving these puzzles is NP-complete, but I'm not sure if checking their solvability is. \$\endgroup\$
    – noodle man
    2 days ago
  • \$\begingroup\$ @noodleman yeah the video inspired me to make this challenge actually, I wonder if there is a way to check in polynomial time, and is it more golfed than the brute-force solution. \$\endgroup\$
    – badatgolf
    yesterday
  • \$\begingroup\$ I think you should allow input either as that coordinate-y structure or as a matrix. I have edited in the code to make the images smaller, please check the Markdown diff: for stack exchange image uploads, adding m before the file ending makes the size medium, s makes the size small, l probably makes them large though I haven’t tried that. \$\endgroup\$
    – noodle man
    yesterday
  • \$\begingroup\$ For true test cases I suppose you could borrow from Flow’s levels. If you have a solution to the problem already, you could use that to find unsolvable ones. \$\endgroup\$
    – noodle man
    yesterday
0
\$\begingroup\$

Test for Irreducible Complexity (Check for Redundant Characters)

I may need some additional help coming up with the full spec for this competition. As of right now, this is just a concept.

Many interesting questions, such as the "42" question in this sandbox, involve finding the longest program which is not reducible. This means that no set of characters can be removed and still allow the program to function as desired.

The basic idea is that your program will test a Base Program to make sure that it contains no redundant characters. The input will consist of:

  • Base Program (in the same language as your answer)
  • Expected Output

Your program will simply evaluate all possible subsequences of the Base Program and verify that none of them give the Expected Output.

This challenge actually has a utility value to several other challenges. For example, it verifies the results of a "longest non-reducible"-type challenge. In addition, it could make sure that a golfed solution cannot be golfed further.

I assume that the winning criteria will be fastest program, as cycling through all the possibilities takes a long time.

Problems

A sequence of length N has 2^N subsequences. Even if each evaluation is done very quickly, it might be unfeasible to test any program with more than 20 or so characters in a reasonable amount of time.

\$\endgroup\$
8
  • \$\begingroup\$ Problem: some subsequences of legitimate answers may be pretty dangerous to the environment. You don't want to eval just everything. \$\endgroup\$ Dec 23, 2013 at 16:59
  • \$\begingroup\$ @JanDvorak Yes that actually is a serious problem. To what extent is it possible to fix that? \$\endgroup\$
    – PhiNotPi
    Dec 23, 2013 at 17:04
  • 1
    \$\begingroup\$ Forbidding any program with dangerous subsequences? :-) \$\endgroup\$ Dec 23, 2013 at 17:05
  • 1
    \$\begingroup\$ A more reasonable (but very difficult) solution would be the requirement to implement a sandbox. \$\endgroup\$ Dec 23, 2013 at 17:07
  • 2
    \$\begingroup\$ Even without dangerous behavior, the halting problem will be an issue: it's hard to tell whether a shortened program will terminate at all, especially for every conceivable input. \$\endgroup\$
    – MvG
    Jan 7, 2014 at 23:49
  • \$\begingroup\$ Are you sure this is possible? The problem of testing if two functions/programs/turing-complete things are equivalent is undecidable - I'm fairly sure it's reasonable easy to constract a brainfuck program that you can't tell if you can remove even a single character. \$\endgroup\$ May 16, 2021 at 4:44
  • \$\begingroup\$ Extending on my previous comment - Let's assume you have a solution to this. Take a brainfuck program you want to test if halts. Let it reduce it, now you have an equivalent irreducible program. Add +. in the end of it, and then try to reduce it again. If the code never halts, that +. is reducible and when you'll run it again it will be removed. Otherwise it's important, so it will be kept. The halting problem is undecidable, therefor this is undecidable. \$\endgroup\$ May 16, 2021 at 4:54
  • \$\begingroup\$ You can also get its undecidablility from that in Unary it will tell you if a given program is minimal, which is known to be undecidable as well \$\endgroup\$ May 16, 2021 at 5:25
0
\$\begingroup\$

Wordlist detector

You are to write a program which, given a list of words, constructs a regular expression to match all these words but nothing else. Both your program and the constructed regular expressions are to be as short as possible.

Input and Output

Input comes on standard input and consists of one line giving n, the total number of words, followed by n lines with one word each. The number of words will be less than 1000, the length of each word less than 30. Words will consist only of lower case ASCII letters, i.e. a-z. You may choose to ignore the first line and use EOF instead to end the list.

Output shall be written to standard output. It consists of a single line, giving a POSIX extended regular expression to match these words and no others. Since input for this regex is not restricted to letters only, elements like . or [^…] won't make too much sense, which limits the language in a natural way. You may choose whether you want to terminate the line with a newline or not. Programs may choose to print multiple lines of output, in which case only the last one will be used for scoring. So you might print intermediate results and continue searching for improvements.

Test cases

Each submission may be accompanied by one regular expression. When scoring the submissions, I'll use this regular expression to reconstruct a word list from it. The code to do this reconstruction can be found at the end of this post. The reconstructed word list must fit the input specification above in terms of word count and length. It would be nice if your own program would be able to regenerate that regular expression from the word list, but that is not a strict requirement. But please don't paste bogus programs just to submit a challenging regular expression, though.

These test cases will be collected and fed to all programs for scoring.

Scoring

The final score of each program will be the program size plus the size of all its generated regular expressions for the inputs collected from submitted answers, including the example from this question. So short code which produces too long results might get beaten by longer code which generates shorter expressions.

Does this still qualify as ?

Submissions which generate an incorrect regular expression for one of the test cases will be disqualified, as will those which don't terminate in the allotted time. You can use the input reconstruction program below to check whether a produced regular expression does encode the correct word list.

Requirements

All submissions are welcome, but in order to include your submission in the tournament, it must be executable with reasonable effort on my Linux machine. It shouldn't depend on any exotic libraries, or any specialized ones which take too much work away from your own program. It must operate in reasonable time, say no more than five minutes per input. Your output must be reproducible, so if you use randomization at some point, please seed the randomizer, and please don't terminate an improove loop by a timer measuring execution time or some such.

Tournament times

I'll run the first major tournament two weeks after posting this question. I'll include a table of the results in this question. I'll try to run tournaments repeatedly as late submissions arrive, but I'll not promise any regular schedule.

Example

An very simple example application would be in Python 3 (53 chars):

print('|'.join(input() for i in range(int(input()))))

And here is a test case which could be posted along with the program, although this program obviously doesn't generate exactly this concise output:

bann?ana|ap(fel|ple)|s[ou]n|[hs](a|ou)nd

The expansion of that expression could be turned into the following example input, which need not be posted as part of an answer since it can be deduced from the regular expression:

10
banana
bannana
apfel
apple
son
sun
hand
hound
sand
sound

Regex expander program

And here is a program to turn regular expressions into word lists, again written in Python 3.

#!/bin/env python3
concat = set(('',))
altin = set(('',))
altout = set()
prev = None
stack = []
regex = iter(input())
for ch in regex:
    if ch == '(':
        stack.append((concat, altin, altout))
        altin = concat
        altout = set()
        prev = None
    elif ch == ')':
        concat.update(altout)
        prev, altin, altout = stack.pop()
    elif ch == '|':
        altout.update(concat)
        concat = altin
    elif ch == '[':
        ch = regex.__next__()
        cls = []
        while ch != ']':
            if ch == '-':
                crange = range(ord(cls[-1]), ord(regex.__next__()) + 1)
                cls.extend(map(chr, crange))
            else:
                cls.append(ch)
            ch = regex.__next__()
        prev = concat
        concat = set(w + c for w in prev for c in cls)
    elif ch == '?':
        concat.update(prev)
        prev = None
    elif ch >= 'a' and ch <= 'z':
        prev = concat
        concat = set(w + ch for w in prev)
    else:
        raise Exception("Illegal input")
if stack:
    raise Exception("Unclosed group")
concat.update(altout)
words = sorted(concat)
print(len(words))
print('\n'.join(words))

This is restricted to the part of regular expression syntax which I expect for this answer. If you have good reason to use something I did not consider, feel free to do so although I will likely have to update this code to cope with it. If you find a bug, please let me know.

\$\endgroup\$
1
  • 2
    \$\begingroup\$ This is just Meta regex golf under the constraint that the two lists between them cover all possible words. Given that some people are tackling that existing question on that basis, this would qualify for closing as a duplicate. \$\endgroup\$ Jan 8, 2014 at 8:45
0
\$\begingroup\$

Rhymalator

(at the point, it's just something that came to me before i wake up, so it may need some adjusting, and i'd like some feedback as to if this could be fun)


The code challenge is to write a program that takes as input a calculation in Reverse Polish Notation and outputs the result. It must at least implement + - * /. It So far so easy, but to make it fun and "artistic", the following restriction applies:

  • The source code must rhyme when read. Example in PHP

    $iterator = str_split($a);
    foreach ($iterator as $key=>$value){
        if ($key > 3){
            ++$virtue;
        }
    }
    

    (the rhyme is on value-virtue)

  • Lines whitout readable characters count as whitespace (the two lines with } in the example)

\$\endgroup\$
2
  • \$\begingroup\$ How does that example rhyme...? \$\endgroup\$
    – Doorknob
    Jan 25, 2014 at 12:54
  • \$\begingroup\$ @DoorknobofSnow well, i'm not really a poet, that's why i propose it as a challenge for others :p. if you have a better example i'll replace it \$\endgroup\$
    – Einacio
    Jan 27, 2014 at 15:58
0
\$\begingroup\$

Implement Kalah

The game of Kalah is a two-player board game in the Mancala family. Your implementation must:

  • Identify the active player ("Player 1" or "Player 2")
  • Display board state (in format specified below)
  • Accept input to allow that player to move (using index system below)
  • Announce a winner ("Player N wins")

Overview

Each player has a line of six spaces, called houses, and one additional space called a store. Each space holds seeds, which move from house to house in a counter-clockwise direction. The objective is to fill your store with seeds.

You must represent the board in the following two-row format with stores offset, where HH is a house and SS is a store:

SS HH HH HH HH HH HH
   HH HH HH HH HH HH SS

The top row represents the number of seeds in player #1's spaces, and the bottom row represents the seeds in player #2's spaces. The S in each row is the respective player's store (player #1's is top-left, #2's is bottom right). Single-digit values should include a leading space.

In this challenge, user-input will identify each house numerically. Use a left-to-right, indexed-from-one scheme for both sides:

S 1 2 3 4 5 6
  1 2 3 4 5 6 S

Note that the players' stores are not numbered, because seeds placed in the store never move out.

Rules

Wikipedia has a good summary of the game and its rules:

  1. At the beginning of the game, three seeds are placed in each house.

  2. Each player controls the six houses and their seeds on his/her side of the board. His/her score is the number of seeds in the store to his/her right. [Clarification: from our perspective, player 1's store is to the left, player 2's store is to the right.]

  3. Players take turns sowing their seeds. On a turn, the player removes all seeds from one of the houses under his/her control. Moving counter-clockwise, the player drops one seed in each house in turn, including the player's own store but not his/her opponent's.

  4. If the last sown seed lands in the player's store, the player gets an additional move. There is no limit on the number of moves a player can make in his/her turn.

  5. If the last sown seed lands in an empty house owned by the player, and the opposite house contains seeds, both the last seed and the opposite seeds are captured and placed into the player's store. [Clarification: moves that end on an opponent's empty house end normally without a capture.]

  6. When one player no longer has any seeds in any of his/her houses, the game ends. The other player moves all remaining seeds to his/her store, and the player with the most seeds in his/her store wins.

Example

(Parenthetical text should not appear in actual output.)

Player 1
 0  3  3  3  3  3  3
    3  3  3  3  3  3  0
> 2                      (prompt arrow and line break
                          are purely optional)
 Player 2
 1  1  0  3  3  3  3
    4  3  3  3  3  3  0
> 4

Player 2  (P2 gets a bonus turn from rule #4)
 1  0  3  3  3  3  3
    4  3  3  0  4  4  1
> 5

Player 1  
 1  0  3  3  3  4  4
    4  3  3  0  0  5  2
> 4

Player 1  (P1 captures P2's seeds in space 1)
 6  0  4  4  0  4  4
    0  3  3  0  0  5  2
...

Player 2
12  0  0 10  0  1  0
    0  0  0  0  0  1 13
 > 6

Player 1 wins            (because the non-finishing players gets
                          all remaining seeds on their side, it's 23-14)

Meta question: Would this be improved by removing some of the rules?

\$\endgroup\$
1
  • \$\begingroup\$ Do the players run the game once and then take it in turns to take moves, with the process ending only when the game ends? Or do they run the program once per move? \$\endgroup\$ Jan 30, 2014 at 10:06
0
\$\begingroup\$

[This is the first time I'm using the sandbox. I want to get feedback/suggestions before posting the question.]

Make a spider web (standard, orb type) that fills frame in the ratio of n:m, where n, m are input integers. You may use the example below as a model (but you don't need to use labels).

spider web

Your web should have multiple radii, at least 4 of which attach directly to the frame. The remaining radii should attach to the outer outline (perimeter) of the web. The web should have at least 15 radii. The mesh spacing should be more or less uniform spacing (although occasional weaving mistakes" or crossings are encouraged and will receive a bonus).

This is code-golf, so the shortest code (minus bonuses) wins.


Bonuses (to be removed from the number of characters in your code). Bonuses are awarded for the following features that reflect the architecture of an actual web (as opposed to a perfectly symmetric rendering). They are somewhat greater than usual as an incentive for attention to detail and realism.

-mesh spiral instead of concentric circles: 40 pts

-assymmetric web: 31 pts. (e.g. height of capture area greater than width)

-irregularly spaced radii: 42 pts

-distinct segments between radii (straight or crooked, but not the arc of a circle): 32 pts

-outer and inner outline clearly distinct from the spiral: 41 pts

-irregular outer outline: 20 pts

-2 or more easily observable reverses in spiral: 40

The accept will be awarded on Feb. 20, 2014.

\$\endgroup\$
2
  • \$\begingroup\$ If there are bonuses then it isn't code-golf, by definition. It's not clear what output formats are acceptable. I'm not sure what you mean by "distinct segments between radii". "2 or more easily observable reverses" seems problematic: the ease of observing reverses is subjective, and might in addition depend on input and/or on the random numbers obtained. The weighting for the bonuses seems very arbitrary: is there any justification for it? \$\endgroup\$ Feb 3, 2014 at 11:49
  • \$\begingroup\$ Re: bonuses, I should probably decide on the features I want included in the web, thereby eliminating bonuses altogether. Distinct segments means that there should be 2 straight mesh segments between radius n and radius n+2 (not sure whether this should be required in instructions to be updated.) Will give reverses more thought. \$\endgroup\$
    – DavidC
    Feb 3, 2014 at 12:02
1
87 88
89
90 91
157

You must log in to answer this question.

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