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\$
2
  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    yesterday

4692 Answers 4692

1
32 33
34
35 36
157
2
\$\begingroup\$

Don't step on a crack, or you'll break your mother's back


Earlier I was walking down the sidewalk in my town, which is made of concrete slabs and looks something like this (note: not my sidewalk). I decided to try to pace myself such that I didn't step on the little cracks between the concrete slabs. For simplicity, let's say:

  • Each slab is 4 feet long.
  • Each of my feet is 1 foot long.
  • Each crack has 0 width (just like your neighbors' dog).

My natural stride is about 3 feet, which worked out quite well:

3-foot strides

(Excuse my horrible MS Paint skills)

Then I got a little ambitious and decided to take 4-foot strides. This obviously worked out even more nicely (aside from making my legs feel weird):

4-foot strides

This got me thinking, what other lengths of strides could I take? One non-integer example would be 2⅔ feet:

2⅔-foot strides

I could go as short as 1-foot strides, though anything shorter than 1 foot would place my foot-long foot on every crack in the sidewalk. (I didn't do 1-foot strides because I would look weird shuffling down the sidewalk, and also because I was in a rush.)

In fact, there are 6 possible crack-avoiding strides up to four feet: 1, 1⅓, 2, 2⅔, 3, 4.

Challenge

Given a integer concrete slab length 0 < n < 100, output all stride lengths up to n that I could take on that theoretical sidewalk. Assume I can stretch my legs infinitely far (I am a mathematician, after all).

More mathematically, given an input integer 0 < n < 100, output all numbers 0 < k <= n such that no multiple of k, modulated by n, is greater than n - 1.

Expected outputs for inputs 1 through 9 (rounded to 4 decimal places):

1: [1]
2: [1, 2]
3: [1, 1.5, 2, 3]
4: [1, 1.3333, 2, 2.6667, 3, 4]
5: [1, 1.25, 1.6667, 2, 2.5, 3, 3.3333, 3.75, 4, 5]
6: [1, 1.2, 1.5, 2, 2.4, 3, 3.6, 4, 4.5, 4.8, 5, 6]
7: [1, 1.1667, 1.4, 1.75, 2, 2.3333, 2.8, 3, 3.5, 4, 4.2, 4.6667, 5, 5.25, 5.6, 5.8333, 6, 7]
8: [1, 1.1429, 1.3333, 1.6, 2, 2.2857, 2.6667, 3, 3.2, 3.4286, 4, 4.5714, 4.8, 5, 5.3333, 5.7143, 6, 6.4, 6.6667, 6.8571, 7, 8]
9: [1, 1.125, 1.2857, 1.5, 1.8, 2, 2.25, 2.5714, 3, 3.375, 3.6, 3.8571, 4, 4.5, 5, 5.1429, 5.4, 5.625, 6, 6.4286, 6.75, 7, 7.2, 7.5, 7.7143, 7.875, 8, 9]

The expected output for 99 can be found in this Gist. The length of each output corresponds to A002088.

Rules

  • The input will be a positive integer less than 100.
  • The output may be presented in any reasonable format. Entries can be represented as decimal numbers accurate to at least 3 decimal places, or as exact fractions if desired.
  • The output may be unsorted, but it may not contain duplicates.

This is , so the shortest code in bytes in each language wins.

\$\endgroup\$
4
  • \$\begingroup\$ It took me a bit to identify that a foot is 1 foot long. I'd make that more clear. \$\endgroup\$ Jul 7, 2017 at 17:52
  • \$\begingroup\$ @NathanMerrill For a second I thought that you were joking :P Should be more clear now. \$\endgroup\$ Jul 7, 2017 at 18:33
  • \$\begingroup\$ output should always be less or equal to input. am i underestood correctly \$\endgroup\$
    – tsh
    Jul 7, 2017 at 23:46
  • \$\begingroup\$ @tsh Right, I've clarified that a little more. \$\endgroup\$ Jul 7, 2017 at 23:52
2
\$\begingroup\$

Solve the Trolley Problem

Philosophers have long pondered the Trolley problem. Unfortunately, this no human has solved this problem yet. Luckily, as programmers we can use computers to solve the problem for us!

Your program will take as input a (finite) directed graph (with at most one edge from x to y, for any x and y), with a designated node, and a nonnegative integer attached to each edge (representing the number of people tied to that track). In addition, every node has at least one exit edge.

The trolley starts at the designated node. Each turn, if the trolley is at node x, the utilitarian selects an edge (x,y). The people on that edge die, and trolley is now at edge y. This process continues forever.

Note that people can only die once, so if the edge (x,y) has n people tied to it, and the trolley runs over them, say, 100 times, it will still only result in n deaths.

The utilitarian makes his choices in such a way as to minimize the number of people that die (which is guaranteed to be finite, since there are only finite people). Your program will output this number.

You may take the input graph in any reasonable way you like. For example, you could take it as a matrix, and count the designated node as the one labeled 0. Or you could use something like x1,y1,n1;x2,y2,n2;.... For example 0,a,0;a,b,5;a,c,1;b,b,0;c,c,0 to represent the standard trolley problem (with loops at the end).

Testcases:

  • 0,a,0;a,b,5;a,c,1;b,b,0;c,c,0 -> 1 (Go from 0 to a, a to c (killing one person), and then keep looping the trolley from c to c).
  • 0,0,1;0,a,5;a,a,0 -> 1 (Keep going from 0 to 0, running over 1 person for all eternity),
  • 0,a,5;0,b,1;a,a,1;b,b,6 -> 6 (0 -> a -> a -> a -> a -> ... (note that the greedy solution of going to b would be incorrect))
  • 0,a,1;0,b,5;a,b,1;b,a,1 -> 3 (0 -> a -> b -> a -> b -> ...)
  • 0,a,1;0,b,1;a,a,0;b,b,0 -> 1 (Note that there are two different options that the utilitarian might take that both kill only one person)

This is , so the shortest answer wins! Good luck.

Notes: There will be no sick loop de loops and multitrack drifting is banned.

\$\endgroup\$
6
  • \$\begingroup\$ So basically: find the cycle of lowest weight? That's pretty similar to finding the cycle of greatest weight, which is equivalent (for integer weights) to codegolf.stackexchange.com/q/107274/194 \$\endgroup\$ Jul 22, 2017 at 9:36
  • \$\begingroup\$ @Peter Taylor no, since you may have to kill lots of people to get to that cycle, or it might not be reachable at all. \$\endgroup\$ Jul 22, 2017 at 12:26
  • \$\begingroup\$ Aha, so it's finding a rho of lowest weight. Still potentially quite similar in implementation, but certainly admits alternative approaches. It might improve clarity to explicitly describe the rho form of the paths to consider. \$\endgroup\$ Jul 22, 2017 at 12:33
  • \$\begingroup\$ @Peter Taylor what is rho? \$\endgroup\$ Jul 22, 2017 at 15:44
  • \$\begingroup\$ ρ , as in Pollard's rho which uses paths which eventually loop back on themselves to factor composite numbers. \$\endgroup\$ Jul 22, 2017 at 16:08
  • \$\begingroup\$ You should delete this as it has been posted. \$\endgroup\$ Jul 28, 2017 at 19:41
2
\$\begingroup\$

An anagram chain

Your challenge is to create a program, P_0, that outputs P_1, that outputs P_2, that outputs... P_n, which finally outputs P_0. Every program in that chain has to be a permutation of every other program, and every program has to be distinct.

For example, if your program (P_0) was

abcd

And that generated another program (P_1)

badc

Which generated another program (P_2)

dabc

Which outputted the first program, you would have a anagram chain of length 3.

Your goal is to make as long a chain as possible, in as short a program as possible.

Your final score will be your chain length - in case there's a tie, the program with the shortest bytecount wins. If there's a tie again, the first poster wins.

Meta:

  • I need a better title. Any suggestions?
\$\endgroup\$
1
  • \$\begingroup\$ [Related]. Actually, I'm pretty sure this is a dupe of another challenge that I can't find at the moment. \$\endgroup\$
    – Shaggy
    Jul 23, 2017 at 10:13
2
\$\begingroup\$

Levenshtein distance using only SO titles

Pick 1 or as many titles as you wish from revisions of questions from Stack Overflow. You now have a tuple of all of the characters used in the titles you picked. You may add up to as many newline characters as titles you picked. Using exactly all the elements (characters) in this tuple (you may chose lower or upper versions of each character) write a program or a code snippet that computes the Levenshtein distance between two strings.

That's it. Happy title hunting!

Clarifications and rules:

Revisions

  • We define a revision as seen on https://stackoverflow.com/posts/XXX/revisions
  • for a question without any revision (not edited after being posted), the question itself counts as a revision
  • all revisions are eligible, from the initial posted question to the current version of the question
  • the revision must be created before 10PM 21 July GMT (before the time of posting this challenge on the sandbox)
  • only questions from Stack Overflow qualify (no meta, no other site)
  • deleted questions qualify (the only exception: spam questions don't qualify). I realize not everybody has access to deleted questions, but a question can become deleted after you post so I decided to allow it, especial considering the very large number of non-deleted questions: you have where to pick from.
  • you may pick one revision multiple times. You may pick multiple revisions from the same question.

Your tuple of characters

For instance you pick these hypothetical titles from valid revisions:

  • To be?
  • ...Or not to be? you pick this one 3x
  • Pls. help me!!

Then the tuple you have is this (between "):

"            !!..........????bbbbeeeeeehllmnnnoooooooOOOpPrrrsttttttT"

to which you may add up to 5 new line characters.

You must use all of these characters (nothing less, nothing more) to write your code. In this example your code must contain exactly 12 (space) characters, 2 ! characters, 10 . characters, 4 ? characters, 4 b/B characters etc.

Lower/upper case: regardless of the character case in the title, you may use any case you want for each. In this example you can use (4 b) or (3 b and 1 B) or (2 b and 2 B) or (1 b and 3 B) or (4 B). Upper/lower as defined on http://www.fileformat.info - Unicode data table

Here are all the character you must use in this example:

+----+-----+
|    |  12 |
|  ! |   2 |
|  . |  10 |
|  ? |   4 |
|  b |   4 |
|  e |   6 |
|  h |   1 |
|  l |   2 |
|  m |   1 |
|  n |   3 |
|  o |  10 |
|  p |   2 |
|  r |   3 |
|  s |   1 |
|  t |   7 |
| \n | 0-5 |
+----+-----+

Code

  • You may write a program or a function and use any of the standard methods of input/output.
  • input must be 2 strings
  • you can assume both of the 2 strings are not empty
  • you cannot take other input
  • output must be a number representing the Levenshtein distance between the two strings as defined on wikipedia. You may output leading and trailing white spaces (including new lines).
  • you must not output anything else
  • You may use any programming language, but note that these loopholes are forbidden by default

Score

This is , so the shortest valid answer – measured in bytes – wins.

Format

In order to make it easy on everybody, please:

  • link the revisions you use
  • show each title
  • show the final tuple of characters

Meta discussion:

  • Should I encourage/discourage/ban using titles already picked by someone else?
\$\endgroup\$
2
  • \$\begingroup\$ This seems easily abused using comments or other non-executing code. \$\endgroup\$
    – KSmarts
    Jul 24, 2017 at 15:17
  • 1
    \$\begingroup\$ @KSmarts yes, you would use comments and non executing code, but it will count to your score. If you need to pick a 20 chars title just to get a certain symbol and the rest of the characters you don't use (you put them after a comment start) then maybe that is not a good deal, isn't it? \$\endgroup\$
    – bolov
    Jul 24, 2017 at 15:59
2
\$\begingroup\$

Tell me my vocabulary words! Donated.

When taking textbook notes, I need to write down the vocabulary words and their definition. So your task is to write some code that will give me the vocabulary words and their definitions!

Vocabulary words are detonated with a * on both sides of them, like this: Sentences are .-delimited, meaning that after every . a new sentence starts. An example of a valid sentence would be: This sentence has a *vocab word* in it. The vocab word in the sentence is 'vocab word'.

Input: A string of text with some words marked with asterisks. Only valid inputs will be provided, meaning that only sentences with exactly two asterisks inside of them, and there is something between the asterisks.

Output: A list or delimited string where each item is in the following format: Vocabulary word: sentence. The Vocabulary word is the vocab word found in the sentence. The sentence must be the one with the emboldened vocabulary word in it. If there is any whitespace other than the s separating the words, it needs to be stripped.

Test cases:

Input: *Alan Turing* invented the Turing machine. A *Turing machine* is a machine that follows simple rules, but is capable of any computation.

Output: *Alan Turing*: *Alan Turing* invented the Turing machine.
        *Turing machine": A *Turing machine* is a machine that follows simple rules, but is capable of any computation.

Input: What is code-golf? *Code-golf* is the best site on the SE network. But what is SE, you ask? *SE* is a group of Q&A sites, with a system to prevent bad posts.

Output: *Code-golf*: *Code-golf* is the best site on the SE network.
        *SE*: *SE* is a group of Q&A sites, with a system to prevent bad posts.

\$\endgroup\$
5
  • \$\begingroup\$ So split on '.' and then filter to strings containing a *? Or can there be asterisks which don't mark vocabulary words? Should we trim whitespace at the start and end of the sentences? \$\endgroup\$ Apr 6, 2017 at 9:54
  • \$\begingroup\$ @PeterTaylor A string surrounded by * is a vocab word, like this: *vocab word*. You need to format the outputted sentence correctly, and trim whitespace. I will edit when I have more time. \$\endgroup\$
    – sporkl
    Apr 6, 2017 at 13:52
  • \$\begingroup\$ Are the following valid inputs or not? a) Unbalanced* asterisk; b) Empty ** vocabulary word; c) Vocabulary* word *has bad spacing. \$\endgroup\$ Apr 7, 2017 at 10:05
  • \$\begingroup\$ Only the last one is valid. \$\endgroup\$
    – sporkl
    Apr 7, 2017 at 13:25
  • \$\begingroup\$ The latest wording "only sentences with exactly two asterisks in them" suggests that there's no need to filter: just split on ., trim, and prepend Vocabulary word: to each sentence. \$\endgroup\$ Apr 7, 2017 at 21:03
2
\$\begingroup\$

Base 32 RFC 4648 Compliant Alphabet!

When writing my handy-dandy totp/hotp token implementation in Python and Swift (ad: here), I encountered for the first time RFC 4648. There is a nice and long memo about RFC 4648, but I only had to focus on a very specific part of it: Page 8. If you are bored and want some enthralling reading, you can find this memo here, and a useful table here.

Basically, I was looking for the alphabet that could be used when base 32 decoding a String. Well, this is it: ABCDEFGHIJKLMNOPQRSTUVWXYZ234567, and padding, =. However, simply printing that is not the challenge –– that would be too simple1. Instead, we are going to print this (the comments are for your reference and do not need to be printed):

__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x00 - 0x0F or   0 -  15
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x10 - 0x1F or  16 -  31
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x20 - 0x2F or  32 -  47
__,__,26,27, 28,29,30,31, __,__,__,__, __, 0,__,__,  // 0x30 - 0x3F or  48 -  63
__, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,  // 0x40 - 0x4F or  64 -  79 
15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__,  // 0x50 - 0x5F or  80 -  95
__, 0, 1, 2,  3, 4, 5, 6,  7, 8, 9,10, 11,12,13,14,  // 0x60 - 0x6F or  96 - 111
15,16,17,18, 19,20,21,22, 23,24,25,__, __,__,__,__,  // 0x70 - 0x7F or 112 - 127
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x80 - 0x8F or 128 - 143
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0x90 - 0x9F or 144 - 159
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xA0 - 0xAF or 160 - 175
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xB0 - 0xBF or 176 - 191
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xC0 - 0xCF or 192 - 207
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xD0 - 0xDF or 208 - 223
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xE0 - 0xEF or 224 - 239
__,__,__,__, __,__,__,__, __,__,__,__, __,__,__,__,  // 0xF0 - 0xFF or 240 - 255

There may be trailing spaces after every line, and trailing newlines after the last one.

Also, the single digit numbers can be written as 0[digit] instead of [space][digit]. However, be sure to include the spaces between the four groups.

By the way, the __ actually represent 255, but the former do not make me drown in a sea of digits.


1 Should the challenge be to just print that string?

Any other suggestions to make this challenge more interesting?

\$\endgroup\$
1
  • \$\begingroup\$ Perhaps get a list of characters (of any length) and print such a table? \$\endgroup\$
    – ugoren
    Jul 29, 2017 at 19:14
2
\$\begingroup\$

Modular multiplicative inverse

Your task is to given two integer numbers, a and b calculate the modular multiplicative inverse of a modulo b, if it exists.

The modular inverse of a modulo b is a number c such that ac ≡ 1 (mod b). This number is unique modulo b for any pair of a and b. It exists only if the greatest common divisor of a and b is 1.

The Wikipedia page for modular multiplicative inverse can be consulted if you require more information about the topic.

Input and Output

Input is given as either two integers or a list of two integers. Your program should output either a single number, the modular multiplicative inverse that is in the interval 0 < c < b, or a value indicating there is no inverse. The value can be anything, except a number in the range (0,b), and may also be an exception. The value should however be the same for cases in which there is no inverse.

0 < a < b can be assumed

Rules

  • The program should finish at some point, and should solve each test case in less than 60 seconds
  • Standard loopholes apply

Test cases

Test cases below are given in the format, a, b -> output

1, 2 -> 1
3, 6 -> Does not exist
7, 87 -> 25
25, 87 -> 7
2, 91 -> 46
13, 91 -> Does not exist
19, 1212393831 -> 701912218
31, 73714876143 -> 45180085378
3, 73714876143 -> Does not exist

Scoring

This is code golf, so the shortest code for each language wins.

\$\endgroup\$
4
  • \$\begingroup\$ I would've thought this would be a duplicate, but it doesn't look like it is. In particular, this challenge is different. \$\endgroup\$
    – isaacg
    Aug 20, 2017 at 22:21
  • \$\begingroup\$ Clarification: Can answers throw an error if there is no inverse? Can they loop forever? \$\endgroup\$
    – isaacg
    Aug 20, 2017 at 22:21
  • \$\begingroup\$ @isaacg Thought that as well, was really surprised when I could not find any duplicate. \$\endgroup\$ Aug 21, 2017 at 6:14
  • \$\begingroup\$ @isaacg Added some clarification to the text. Allowed errors, but the answers should stop at some point. Also made them have to solve each test case in 60 seconds, as otherwise the challenge would become a bit easy (basically looping over all the possible values) \$\endgroup\$ Aug 21, 2017 at 6:16
2
\$\begingroup\$

Is this a valid Takuzu board?

Takuzu is a logic game in which you have to complete a grid with cells containing 0s and 1s. The grid must follow 3 rules:

  1. No three horizontal or vertical cells in a row can be the same.
  2. There must be an equal number of 0s and 1s in each row and column.
  3. No two rows can be the same, and no two columns can be the same.

Let's look at a finished grid:

0011
1100
0101
1010

As you can see, this board follows rule 1, 2 and 3. There are no three horizontal or vertical cells that are the same, all the rows and columns contain an equal number of 0s and 1s, and no two rows and no two columns are the same.

Let's look at a grid that isn't valid:

110100
010011
011010
101100
100011
001101

There's a bunch of problems with this grid. For example, row 5 has three 0s in a row, and column 2 has three 1s in a row, followed by three 0s. Therefore, this is not a valid grid.

Task:

Your task is to make a program which, given a 2D array of n * n 0s and 1s, verifies the board to see if it's a valid, finished Takuzu board.

Examples:

0011
1100
0101
1010

This board follows all the rules, and is therefore a valid Takuzu board. You must return a truthy value for this.

11
00

This is not a valid board - row 1 doesn't follow rule 2. You must return a falsey value for this.

Rules and Specs:

  • You can assume that all boards are square of dimensions n * n, where n is a positive even integer.
  • You can assume that all boards are finished.
  • You may take input as a 2D array containing values signifying 0 and 1, or as a string.
  • You must output consistent truthy and falsey values for truthy and falsey boards, and the values representing "truthy" and "falsey" cannot be the same.

This is , so shortest code in bytes wins!

\$\endgroup\$
5
  • \$\begingroup\$ 1. "No three horizontal or vertical grids in a row can be the same": there's only one grid. I propose rewording as "No horizontal or vertical line of three cells can be the same". 2. Related: codegolf.stackexchange.com/q/68646/194 , codegolf.stackexchange.com/q/118856/194 . Note that because this question works through a long example before stating very briefly that (in essence) the example is irrelevant to the question, it can very easily mislead people into thinking it's an exact dupe of the second of those related questions. \$\endgroup\$ Aug 27, 2017 at 16:49
  • \$\begingroup\$ ...also note that the example you run through before giving the task can actually be performed by only using rule (2). \$\endgroup\$ Aug 29, 2017 at 6:47
  • \$\begingroup\$ @PeterTaylor Will fix the example and other points, I wasn't active for a while, sorry for the late reply. \$\endgroup\$
    – clismique
    Aug 29, 2017 at 6:48
  • 1
    \$\begingroup\$ @JonathanAllan Through fixing PeterTaylor's suggestion I also fixed yours :P \$\endgroup\$
    – clismique
    Aug 29, 2017 at 6:53
  • \$\begingroup\$ By "You must output distinct truthy and falsey values for truthy and falsey boards" do you mean "consistent" ones - i.e. the Truthy (falsey) value is to be the same for each time a valid (invalid) board is input? The normal definition of Truthy vs Falsey is language dependent: any values that conditionally evaluate as such (i.e. such that the equivalent of the pseudo-code if myVal then print("True!" else print("False!") works as expected). \$\endgroup\$ Aug 29, 2017 at 7:05
2
\$\begingroup\$

Reverse Maths Cycles

\$\endgroup\$
7
  • \$\begingroup\$ Seems interesting, but I would add some more to the spec. Maybe an intro, just to make it look less like a bunch of test cases. Also, I would do more explaining in words, rather than relying on the first test case to clarify what you mean. \$\endgroup\$
    – Gryphon
    Jul 27, 2017 at 5:01
  • \$\begingroup\$ 1. "apply each of the above functions to each element of an array" surely means that if the array has six elements, each operation should be executed six times, for a total of 36 operation evaluations. Yet the example only appears to perform 6 operation evaluations. 2. Some of the operations have corner cases which aren't specified. Do you guarantee that the input will never contain 0? If not, do you guarantee that we will never have to evaluate division by zero or 0^0? \$\endgroup\$ Aug 28, 2017 at 14:07
  • \$\begingroup\$ @PeterTaylor 1) Bad wording, I'll fix that. It simply means that each value in both lists are "paired", so to say, with a function, which is then evaluated. 2) I think it would be easier to work with by saying there will never be a 0 in the input, I will clarify. \$\endgroup\$ Aug 28, 2017 at 14:16
  • \$\begingroup\$ May we take input as a list of Strings instead? \$\endgroup\$
    – Mr. Xcoder
    Sep 11, 2017 at 18:26
  • \$\begingroup\$ @Mr.Xcoder if you want to, then yes. I'll edit that in \$\endgroup\$ Sep 11, 2017 at 18:38
  • \$\begingroup\$ I feel like this is a good overall challenge, would be nice to see clever solutions \$\endgroup\$
    – Mr. Xcoder
    Sep 11, 2017 at 18:40
  • \$\begingroup\$ Also, I'd tag this arithmetic instead since it only involves basic arithmetic operations. \$\endgroup\$
    – Mr. Xcoder
    Sep 11, 2017 at 18:41
2
\$\begingroup\$

Count bicubic graphs

This question assumes basic knowledge of graph theory terminology.

A cubic graph is a simple graph whose vertices each have exactly 3 edges. A bipartite graph is a vertex whose vertices can be divided into two disjoint sets such that every edge is between a vertex in one set and a vertex in the other set. A bicubic graph is a graph which is both cubic and bipartite.

It is easy to show that a bicubic graph must have the same number of vertices in each of the bipartite halves, so the number of vertices must be even. It is also easy to show that it must have at least six vertices. The only bicubic graph with six vertices (up to isomorphism) is the so-called utility graph or K3,3:

The edges are the Cartesian product of two three-element sets of vertices

Input

A positive non-zero integer n.

Output

The number of bicubic graphs with 2n vertices, up to isomorphism.

Notes

  • The graphs are not required to be connected.
  • This sequence is OEIS A008325. However, hard-coding these values will be considered a breach of standard rules. You may hard-code for inputs of up to 3, but above that the code should follow the same paths and be correct assuming unbounded memory and time for any valid input. It seems unlikely that we will extend the sequence, but it's nonetheless a worthy stretch goal.

Test cases

Input  Output

1      0
2      0
3      1
4      1
5      2
6      6
7      14
8      41
9      157
10     725
11     4196
12     29816

Winning criterion

The fastest program wins. The primary win condition is the largest input for which correct output is given within 10 minutes. In case of ties, the time taken to compute the value for that input will be compared. If the difference is less than 20 seconds, the earlier answer wins.

\$\endgroup\$
2
\$\begingroup\$

All ASCII Art

Input

You will be given a set of x, y, and A pairs, where x and y represent a coordinate on a 2-d plain, and A is some character. You may take these pairs in any convenient format, e.g. a list of lists, three separate lists, a list of pairs of lists, etc.

Output

You will output a grid of spaces. However, at every coordinate specified in the input, the space should be replaced by the character. Basically, the input specifies the locations of characters, and you have to draw them.

Specifics

  • x and y may be either a coordinate or a row-column pair (e.g. the origin can be in the bottom left, with x increasing to the right and y increasing up, or the origin can be in the top left, with x increasing to the right and y increasing down).
  • All characters are guaranteed to be printable ASCII, and will never be a space.
  • x and y are >= 0
  • You may output trailing whitespace (but not infinitely). What matters is that the output visually looks like what the input specified, not the whitespace.

Test Cases

Test cases format (the test cases have the origin at the top left corner; this is optional, see specifics):

# of coordinates
row col char
row col char
...
-----------
output

Test cases:

2
0 0 :
0 1 )
-----------
:)

3
0 0 -
0 1 _
0 2 -
-----------
-_-

4
0 1 -
1 0 |
2 1 -
1 2 |
-----------
 - 
| |
 - 

11
0 0 (
0 1 ^
0 2 o
0 3 ^
0 4 )
1 1 /
1 2 |
1 3 \
2 2 |
3 1 /
3 3 \
-----------
(^o^)
 /|\
  |
 / \

Here is a Java program which can be used to test out inputs

Meta

\$\endgroup\$
2
  • \$\begingroup\$ Is (0,0) the top-left of the output image? It kinda looks that way from your examples, but that should be made clear. \$\endgroup\$ Nov 3, 2017 at 12:30
  • \$\begingroup\$ @AdmBorkBork it is for the test cases, but its meant to be optional... I'll clarify \$\endgroup\$ Nov 3, 2017 at 12:43
2
\$\begingroup\$

RaceTrack Arena KOTH

(haven't come up with a very good title)

this koth is inspired by the pen and paper game Racetrack.

RaceTrack Movement

Racetrack (and this racetrack-inspired koth) use a distinctive vector based movement system.

all bots players are on a square grid.

initially, a cycle (this is what we will call bot players) will have no movement i.e. be completely motionless

However, after a cycle begins moving, it gains inertia; it will not stop moving in this direction unless it acts to stop moving.

On every turn, a cycle can change their speed on each axis (x and y) by -1, 0, or 1, and the same with y speed. this includes sticking with their current speed. This means that every turn, a cycle has 9 options of spaces to move to (excluding spaces which would cause them to crash)

enter image description here

for example, in this diagram, the cycle indicated by the red space, which has just moved from the brown space, has the option of the 9 green squares in the red-lined area, the main, more saturated, green square, along with the blue line, represents where it will end up staying on its inertial course

if, for some reason, the cycle wanted to come to a complete stop, it would take 5 turns, which is the Chebyshev distance between the inertia vector's end and the cycle.

[more tbd obviously]

don't downvote for the lack of content please

\$\endgroup\$
10
  • \$\begingroup\$ Can (like on the paper) every contestant see the whole arena, including other contestants' movements? As I remember, it's alternative moves rather than simultaneous and you crash if you end up on or cross other contestant's position or most recent motion line. How will the edge be defined? You crash if you end up outside OR if your motion line crosses outside area. Explain the rules in your post. You can have different rules, but if you keep alternative move the starting player will have advantage. So every contestant of this KOTH should have equal number of participation at each position. +1 \$\endgroup\$
    – Heimdall
    Nov 11, 2017 at 8:36
  • \$\begingroup\$ We don't know the first player has so much of an advantage; random positions are rather likely to have a much larger effect than the fact that player 1 can strategy steal, and even with non-randomised positions, playing with multiple players is very different in flavour from just two players, since playing against one player, their moves only make themselves better or worse, but in multiplayer another (dumb) player can unwittingly help you or harm you without regard to whether it does help them. Also I haven't decided on whether bots can see the whole playing field or if they have a top speed \$\endgroup\$ Nov 12, 2017 at 22:53
  • \$\begingroup\$ ... if there is a limit to their sight, it follows there has to be a limit to their speed, and even if there isn't an implemented, it's at least effectively a limit, since moving somewhere you can't see if there is a wall is not a great strategy. also there will probably be obstacles that act like walls, so the edge is not the only place to crash, btw. anyway, the definition of crash, is that a bot's movement line goes through a hazardous square. I suppose that touching a vortex can be considered a near miss \$\endgroup\$ Nov 12, 2017 at 22:55
  • \$\begingroup\$ that said, I guess there's no real reason not to randomise the turn order each game. \$\endgroup\$ Nov 12, 2017 at 23:09
  • \$\begingroup\$ Suppose you're the first, whatever your starting position. You accelerate so that you have maximum safe speed. Others won't accelerate to higher speed because that would cause them to crash at the turn (unless, as you put it, a dumb racer decides to overtake you anyway). Let's say the next turn is left. You'll go as far left as possible. Racers on your right will just lag behind. But racers on your left will only be able to keep up until you "cut the corner". They won't be able to stop you from doing so because at no point they will be ahead of you. But maybe some random debris on the path ... \$\endgroup\$
    – Heimdall
    Nov 13, 2017 at 10:49
  • \$\begingroup\$ Actually, dumb racing might be a good strategy... If you are allowed to have more than one bot in a race, one can be "dumb" to increase the other one's chances... \$\endgroup\$
    – Heimdall
    Nov 13, 2017 at 10:52
  • \$\begingroup\$ @Heimdall that strategy tends to be discouraged. making a simple bot is not, but making bots collude is frowned upon. \$\endgroup\$ Nov 13, 2017 at 23:33
  • \$\begingroup\$ So I guess the wall is made by placing a series of hazardous squares, and crashing means you're out of that race only. But how is crash between two racers defined and dealt with? \$\endgroup\$
    – Heimdall
    Nov 16, 2017 at 7:12
  • \$\begingroup\$ @Heimdall no offence, but I haven't actually made enough of the spec that I should be answering questions from you in the comments, especially since you have a rather inaccurate idea of the game (because i haven't specified). for example, it's not a race. \$\endgroup\$ Nov 16, 2017 at 8:29
  • \$\begingroup\$ Sorry, I'm a bit impatient. It's just I'm looking forward to your game which is still in the making, that's why I gave it +1. I assumed it was a race (or series of races) where the bots compete because it's based on that paper race. Also I was trying to be helpful by raising potential issues in order for the task to be well formed. \$\endgroup\$
    – Heimdall
    Nov 16, 2017 at 10:27
2
\$\begingroup\$

Bunnies in (three-dimensional) space

A panicked call has come in from the International Space Station: a psychological experiment has gone awry, and the astronauts have lost all their Stanford Bunnies. You have been tasked to come up with a way to get them as many replacements as possible.

 

a description of the plan

 

Because of the rush, NASA has just one rocket available for this mission: a Delta II Heavy with a box-shaped cargo hold (a "right cuboid", they called it) of length x, width y and height z, all even integers. Your job is finding out how many bunnies to bring - and how to pack them.

Input and output

Your program should take the dimensions of the cargo hold as arguments. It should then compute how many bunnies it can fit in there, producing output as follows:

  • A header line consisting of the length, width and height of the box, as integers, seperated by spaces. This is a copy of the input.
  • A line for every bunny fitted, containing the following as dotted floats, all seperated by spaces:
    • the position of the center of the bunny, relative to the center of the box, as x, y and z
    • the rotation of the bunny, as a rotation about the x, y and z axes, in that order (a.k.a. Tait–Bryan angles).

For example, a solution for a box of 4 × 6 × 8 units, with a single, un-rotated bunny in the center, would be described as follows:

4 6 8
0.0  0.0  0.0   0.0  0.0  0.0

A solution for a larger box of 12 × 8 × 8 units with two bunnies could look like this:

12 8 8
 4.5433 2.5843  1.4380 3.1415 0.0000 0.0000
-2.4839 1.3923 -1.9400 0.0000 0.0000 1.5707

...although your program will likely be able to fit more bunnies.

Dataset

This is the vertex data for the bunny. It is in Wavefront OBJ format, which means that every 'v' line describes a vertex (point in x, y, z space), and every 'f' line describes a triangle of vertices. Compared to the original Stanford Bunny model, this model has been translated so that its centerpoint is at the origin (0, 0, 0) and it fits snugly inside a unit cube.

Tips

  • You don't have to use the dataset above in your program - for example, you might want to simplify it more - but you should make sure that your output is correct when using the 'official' model.
  • Be careful with rounding, both during calculations and when outputting your result.
  • The Wavefront format can be imported into the free blender program if you want to see what it looks like (make sure to choose 'Z Up').
  • Your program does not have to be usable for other models: it can be a special-purpose bunny-fitting utility.

Rules and winner

  • A valid solution is one where, if you constructed a box of bunnies using the solution's description and the vertex data above, none of the bunnies would touch each other or the bounding box.
  • Your program has to be usable for box sizes other than the one below.
  • Your entry should run in less than, say, ten minutes on reasonable hardware.
  • The program must be self-contained: you can only use your language's standard libraries.
  • The winner is the program that succesfully fits the most bunnies in a box of 12 × 8 × 6. Include (a link to) your code, (a link to) a solution for that box size, and, if you made any, a picture of your solution.
\$\endgroup\$
6
  • 1
    \$\begingroup\$ I'd recommend against Unicode chars in the title. \$\endgroup\$ Nov 17, 2017 at 22:42
  • \$\begingroup\$ @EriktheOutgolfer Fixed! \$\endgroup\$ Nov 17, 2017 at 22:43
  • 3
    \$\begingroup\$ Why only allowing the language's standard libraries? That seems like it would ban things like numpy for python, which may be useful for extra math functions. It's a standard loophole for people to make new libraries designed to solve a challenge anyway. \$\endgroup\$
    – Riker
    Nov 18, 2017 at 0:26
  • \$\begingroup\$ Also, is there a tie-breaker if 2 programs find the optimal solution? Shortest code? "Whoever submitted first" is likely fine but seems ugly to me, maybe fastest code? \$\endgroup\$
    – Riker
    Nov 18, 2017 at 0:29
  • \$\begingroup\$ @Riker: I added the self-contained rule to prevent people from grabbing an off-the-shelf implementation for the actual problem, or introduce wild dependencies that make it hard to reproduce results. You're right that numpy is generic enough that it could almost be considered part of the standard library, but I thought I had to draw the line somewhere. Do you think I should remove the rule altogether? \$\endgroup\$ Nov 18, 2017 at 0:38
  • \$\begingroup\$ @Riker: A naive solution can fit 576 bunnies, and well-thought-out versions will likely score much much more, so I think the chance of two different approaches accidentally getting exactly the same score is quite slim. If there is an optimal solution (I'm actually not sure!) I'd be comfortable letting the first submitter to find it win. \$\endgroup\$ Nov 18, 2017 at 0:47
2
\$\begingroup\$

Inside or Outside?

Given a point and a polygonial loop that is not self intersecting, determine whether the point is strictly inside or outside of the loop.

Details

  • The polygon is given as an ordered list of points cartesian coordinates.

  • The single point is given as a separate input, but you can also say that is e.g. always the first or always the last point in the list.

  • We only consider points with integral coordinates.

  • You can choose whatever representation is easiest to work with for you for instance a list of pairs, or two separate list for the x- and y-coordinates etc.

  • The list describes the polygon in positive orientation, that means the inside is always on the left side if you follow the points from the beginning to the end of the list. (You may choose to use the opposite orientation but please indicate if you do.)

  • A point is considered to be strictly on the inside, if it is not contained in the border of the polygon.

Examples

[(0,0),(0,2),(2,2),(2,0)]: (1,1) is strictly inside, all other points are outside
[(0,0),(0,2),(2,0)]: no point is strictly inside

more coming soon...

Meta:

  • Should I relax the strictly inside to just inside (i.e. a point on the border is also considered as inside)
  • Should I let the participants choose which version they prefer?
\$\endgroup\$
5
  • \$\begingroup\$ 1. Not necessarily convex or must be convex? 2. What you describe as "positive orientation" is the same as "in counter-clockwise order". 3. Does the point for testing for inside/outside have integral coordinate? \$\endgroup\$
    – DELETE_ME
    Nov 26, 2017 at 14:42
  • \$\begingroup\$ The shape is arbitrary and the testing point does have integral coordinates too (see examples) \$\endgroup\$
    – flawr
    Nov 26, 2017 at 14:46
  • \$\begingroup\$ Seems that you flipped what "positive orientation" means. Keep this if that is what you want. / Proposed test case: (0,0),(0,5),(2,2),(5,0) → strictly inside integer points = (1,1),(1,2),(1,3),(2,1),(3,1) where the shape is a concave quadrilateral. \$\endgroup\$
    – DELETE_ME
    Nov 26, 2017 at 14:58
  • \$\begingroup\$ Well the first one was incorrect, positive actually means counter clockwise. \$\endgroup\$
    – flawr
    Nov 26, 2017 at 19:37
  • \$\begingroup\$ 4. Does the flexiblity in input extend to allowing us to require the first vertex to be repeated at the end of the list? 5. The strictly inside vs inside issue might be best addressed by asking for a classification into strictly inside, on the perimeter, and strictly outside. This is slightly trickier, I think, because of the implication that you can't cast a ray to infinity and just ignore edges which are parallel to it. \$\endgroup\$ Nov 27, 2017 at 10:37
2
\$\begingroup\$

(No title currently)

Given a natural number N and a natural number K, find a list of natural numbers L such that:

  1. The product of the elements of L is N
  2. Each member of L is less than or equal to K
  3. And the length of L is minimized.

(You can return these numbers in any order.)

Note that:

  • If no such list exists, you program may do anything besides yielding a valid list, including but not limited to:
    • Printing something to stderr
    • Yielding an empty list
    • Yielding a non-list (see below)

If outputting to stdout, you can output a list in any reasonable fashion, such as:

  • Comma-separated: 3, 5, 7
  • With brackets: [3, 5, 7]
  • Whitespace-separated: 3 5 7
  • Your native list representation (3`4`5 or 3 4,5,, etc.)

Test cases (examples)

N, K -> L

32, 2 -> [2, 2, 2, 2, 2]
50, 10 -> [5, 10]
1224, 99 -> [72, 17] or [24, 51]
5, 10 -> [5]
1337, 100 -> []                         (since 1337 = 7 * 191)
1337, 191 -> [7, 191]
42, 8 -> [6, 7]
42, 21 -> [2, 21] or [3, 14] or [6, 7]
1, 2 -> [1]                             (NOT the empty list)
36, 6 -> [6, 6]
36, 9 -> [4, 9]
36, 12 -> [4, 9] or [3, 12]
32, 64 -> [32]
432, 9 -> [6, 8, 9]                     (NOT [2, 6, 6, 6])
216, 8 -> [6, 6, 6]                     (NOT [8, 3, 3, 3])
\$\endgroup\$
7
  • \$\begingroup\$ (1) I think every instance of number needs to be replaced with natural number. Otherwise 1337, 100 can be satisfied by [sqrt(1337), sqrt(1337)] or [-1, -1337]. (2) Are any of the test cases failed by a greedy approach? If not, can you construct a test case for which a greedy approach fails? (3) What is the correct output for 1, 2? I can make a case for [], but I wonder whether you expect [1]. \$\endgroup\$ Nov 29, 2017 at 16:10
  • \$\begingroup\$ @PeterTaylor (1) True. (2) I'm not entirely sure. (3) I think I will exclude the empty product as valid output \$\endgroup\$ Nov 29, 2017 at 17:19
  • \$\begingroup\$ @PeterTaylor I think 432 would not work with a greedy approach, can you confirm? [2,6,6,6] as opposed to [6,8,9] \$\endgroup\$ Nov 29, 2017 at 17:25
  • \$\begingroup\$ Aha. For (2), I think it's worth adding test case 216, 8. The greedy approach would be to say that 8 divides 216 and then split 216/8 = 27 as [3, 3, 3] giving a division into four factors; but [6, 6, 6] is a valid division into three factors. Edit: overlapped with your comment. I think you're attacking a different greedy approach. The more the merrier for test cases. \$\endgroup\$ Nov 29, 2017 at 17:26
  • \$\begingroup\$ @PeterTaylor I see what you mean, thanks for the help! \$\endgroup\$ Nov 29, 2017 at 17:35
  • 1
    \$\begingroup\$ Why can there be a 9 in 432, 8? It violates the second rule. \$\endgroup\$
    – Maya
    Nov 30, 2017 at 21:14
  • \$\begingroup\$ @NieDzejkob Sorry, a typo on my part, thanks! \$\endgroup\$ Dec 2, 2017 at 2:19
2
\$\begingroup\$

Show a Chess Piece Range

Write a program or function that, given a set of movement rules, shows the available moves for a fairy chess piece.

Movement Rules:

This will use a slightly modified version of Parlett's Movement Notation:

A number, 1, 2, etc. shows how far a piece can move in a given direction. n indicates any distance, and two numbers separated by a hyphen (e.g. "1-4") means that there is a range of distances that the piece can move. Ranges may be enclosed in parentheses.

Numbers are followed by a direction sign:

  • * - any direction, orthogonally or diagonally
  • + - orthogonally (forwards, backwards, sideways)
  • X - diagonally
  • > - forwards
  • < - backwards
  • = - sideways
  • X> - diagonally forwards
  • X< - diagonally forwards

These directions can be combined, so <> means forwards or backwards, X= means diagonally or sideways, etc. Note that >X means forwards or diagonally, and is different from X>.

This gives us many of the standard chess pieces. For example, 1* is a King's movement, while nX is a Bishop.

There are also "grouping" indicators:

  • / - two numbers (or ranges) separated by a slash indicates a "hippogonal" move, like a knight: a/b means move a spaces orthogonally, and b spaces perpendicular to the first move. These may be enclosed in parentheses.
  • & - repeated movement in the same direction
  • . - "then" - combines two distinct moves, one after another.
  • , - "or" - separates two distinct moves. Only one may be taken on a turn.

The format of a move (not including grouping) is <distance><direction><other>.

Input:

A string showing the movement rules.

Output:

An ASCII representation of an 8x8 chess board with the given piece on the d4 square, with all other accessible squares indicated. For example, given the input n* (a queen), you should output:

...x...x
x..x..x.
.x.x.x..
..xxx...
xxx@xxxx
..xxx...
.x.x.x..
x..x..x.

The output may consist of any three distinct characters.

Examples and Test Cases

Input: (1/2)
Output:
.........
.........
..X.X....
.X...X...
...@.....
.X...X...
..X.X....
.........

Input: 2*
Output:
.........
.........
.X.X.X...
.........
[email protected]...
.........
.X.X.X...
.........

Input: 2+.1+    (compare to the knight, above)
Output:
.........
...X.....
..X.X....
.X.X.X...
[email protected]..
.X.X.X...
..X.X....
...X.....

Input: @1<X>,2-3>=
Output:
...X....
...X....
...X....
..X.X...
[email protected].
...X....
........
........

Input: 1+,2X&
Output:
.......X
........
.X...X..
...X....
..X@X...
...X....
.X...X..
........

This is - shortest code for each language in bytes wins.

Notes/Questions:

I have also considered having the location of the piece be arbitrary, given by another input. Is this a good idea? Does it make the challenge more interesting, or just more complicated without much benefit?

\$\endgroup\$
1
  • 2
    \$\begingroup\$ Have it variable. It makes it more interesting. \$\endgroup\$
    – wizzwizz4
    Dec 16, 2017 at 19:46
2
\$\begingroup\$

Not-So-Simple Simplex

(Note: should I name it Complex Simplex?)

A simplex is an n-dimensional analog of a triangle. Thus, a 3-dimensional simplex is a tetrahedron. We want to find the number of points with integer coordinates (lattice points) strictly on the interior of this simplex. A point that lies on the boundary is not considered to be in the interior. For example, in a 2-dimensional simplex, any point on its perimeter is not an interior point. In a 3-dimensional simplex, any point on its surface area is not an interior point. In an n-dimensional simplex, any point on its surface n-1-volume is not an interior point.

You are given n + 1 points, each with n integral coordinates. You must output the number of integer points strictly in the interior of this simplex. The simplex is guaranteed to be non-degenerate, that is, it has strictly positive n-volume. If I provide 4 points, for example, you can assume they do not all lie on the same plane.

Test cases:

(0,0), (6,1), (2,5) -> 12 (see picture)

enter image description here

(2,3),(5,2),(3,2) -> 0

More test cases coming when I actually write the program to solve this because drawing the picture of a 4-simplex is a nightmare..

\$\endgroup\$
2
  • \$\begingroup\$ Winning criteria? \$\endgroup\$
    – DELETE_ME
    Dec 24, 2017 at 6:27
  • \$\begingroup\$ Code golf, let me add that. \$\endgroup\$
    – rigged
    Dec 24, 2017 at 17:39
2
\$\begingroup\$

Megatanium trading

Your task is to build a javascript function to trade a fictional stock called Megatanium
You start with $1000 and 0 stock of Megatanium

Challenge

This is a challenge, all submissions should be written in

Your function should accept four variables as follows, obviously within your function you can name these whatever you like
- 1st variable represents the current value of 1 bar of Megatanium
- 2nd variable represents your current bank balance
- 3rd variable represents your current stock holding
- 4th variable represents the iteration number

Your function should return an integer representing the size of your desired trade
The return value should be negative if you wish to sell stock, positive if you wish to buy stock, 0 if you wish to neither buy or sell

For example;
If you wish to buy 10 bars of Megatanium at the current price you would return 10
If you wish to sell 5 bars of Megatanium at the current price you would return -5

I will call your function 1000 times. Stock price will always be an integer, chosen at random, with a minimum of 0 and a maximum of 256. Method of selecting the stock price is described in more detail below, it will NOT be an even distribution!

Your bot will be disqualified if it does any of the following at any point

  • Try to buy more stock than it can afford
  • Try to sell more stock than it holds
  • Try to write any value to any of the global variables
  • Fail to return a value
  • Return a value that is not an integer

Here is the code I will be running, the score output at the end will be your bot's score. It is calculated from your bank balance plus the value of your held stock at the latest value.

function go(bot) {
    bank = 1000;
    stock = 0;
    disqualified = 0;
    for (i=1; i<=1000; i++) {
        price = prices[i];
        trade = window[bot](price, bank, stock, i);
        if (trade !== parseInt(trade)) disqualified = "INVALID TRADE";
        bank = bank - (price * trade);
        stock = stock + trade;
        if (bank < 0) disqualified = "RUN OUT OF MONEY";
        if (stock < 0) disqualified = "TRIED TO SELL STOCK YOU DIDN'T OWN";
        if (disqualified) break;
    }
    if (disqualified) {
        console.log("Disqualified on iteration " + i + " REASON: " + disqualified);
    }
    else {
        score = bank + (stock * price);
        console.log(bot + " scores " + score);
    }
}

The function for generating a suitable distribution of random values is a slightly modified version of the function described here
Every bot will be given the same set of prices, but the set will not be generated until immediately before the bots are run.

function randn_bm() {
    var u = 0, v = 0;
    while(u === 0) u = Math.random();
    while(v === 0) v = Math.random();
    w = Math.floor(Math.sqrt( -2.0 * Math.log( u ) ) * Math.cos( 2.0 * Math.PI * v ) * 32) + 128;
    while (w < 0 || w > 256) w = randm_bm();
    return w;
}
prices = [];
for (i=1; i<=101; i++) {
    prices.push(randn_bm());
}

Completion

You may submit as many bots as you like, try to be inventive with your algorithms! You may use a global variable called data, this will be initially set to null and will always be available to your function.

Example bots

function buyBot(p,b,s,i) {
    /* Bot always buys as much as it can */
    return Math.floor(b / p);
}

function randomBot(p,b,s,i) {
    /* Bot buys and sells randomly */
    if (Math.random() > 0.5) {
        return Math.floor(Math.random() * (b / p));
    }
    else {
        return -Math.ceil(Math.random() * s);
    }
}

function smartBot(p,b,s,i) {
    /* Bot always buys at under 100 and sells at over 150 */
    if (p < 100) {
        return Math.floor(b / p);
    }
    else if (p > 150) {
        return -s;
    }
    else {
        return 0;
    }
}

function bankruptBot(p,b,s,i) {
    /* Bot always sells at under 100 and buys at over 150 */
    if (p > 150) {
        return Math.floor(b / p);
    }
    else if (p < 100) {
        return -s;
    }
    else {
        return 0;
    }
}

function alternateBot(p,b,s,i) {
    /* Bot buys and sells alternately */
    if (data == 1) {
        data = 0;
        return Math.floor(Math.random() * (b / p));
    }
    else {
        data = 1;
        return -Math.ceil(Math.random() * s);
    }
}

Winning conditions

All bots will be run on locally by me approximately 1 week after the question is posted (date will be decided when question is posted, no point setting a date in sandbox)
Winner will quite simply be the bot that has the highest final score after the last iteration, as calculated by the function provided above. The array of prices used will be published after a winner has been crowned.
There are no set conditions on the speed of your function, but please be fair and try to avoid anything that will take more than a couple of minutes to execute

\$\endgroup\$
2
\$\begingroup\$

Note: Please leave an upvote if you think the challenge idea is good and is clear, a downvote if you think the challenge idea is bad, and comment if you can't understand the challenge. Last time I asked on TNB 2 users told me that they can't understand anything.


Golf a return-oriented code generator!

Background

Return-oriented programming (ROP) is a computer security exploit technique that allows an attacker to execute code in the presence of security defenses such as non-executable memory (W xor X technique) and code signing. (from Wikipedia)

Challenge

In this challenge, you should write a program, that takes the code of the existing program and the required code, and output the stack necessary to execute that program.

Rules

  • Standard loopholes apply, as usual.
  • How the machine works
    • At first, IP is equal to the top of the stack, and the top of the stack is popped.
    • For each clock cycle (whatever it means), the command at the position of IP is executed, and the IP is advanced if the command does not modify IP.
    • The behavior if the IP is at the last instruction and that instruction does not modify IP is undefined.
  • Assembly instructions
    • All commands are case insensitive.
    • Note: There is nothing that guarantees commands must be 3 characters long, or limited to some sets. After all, this is not real assembly. However:
    • You can assume that all the characters are in the English alphabet, uppercase or lowercase.
    • There may be some other commands "similar but not the same" with ret, so checking for the first character or the SHA256 hash won't work.
    • The special command ret will pop the value on the top of the stack, and set the instruction pointer IP to that value.
    • You may assume that all the other commands won't modify the stack, or the IP.
    • The "existing program" and "required code" will be represented as a string, separated by newline characters (you may optionally take a list of strings as input).
    • The required code will never contains ret.
    • The output should be a stack of line-numbers in appropriate format (list of numbers - may be reversed, array of numbers, etc.)
    • The command executed right after the last command in the "required code" must be a ret.
    • Because the memory of the machine is limited, you should output the shortest possible stack. If there are multiple shortest stack, output any.
  • You may assume that there exists an output.

Example test cases:

  • Existing program:
1:  add eax, ebx
2:  lea eax, [2*eax+4*ecx]
3:  ret
4:  mov eax, ebx
5:  xch ecx, eax
6:  ret

(the line numbers are just for demonstration purposes. They are not included in the input, you can use 0-indexing or 1-indexing)

(disclaimer: this is not real assembly, just for demonstration purposes)

  • Required code:
lea eax, [2*eax+4*ecx]
xch ecx, eax
mov eax, ebx
xch ecx, eax

In that case, you should output [2, 5, 4] (2 is at the top of the stack), because if the stack have that value, then:

  • First, IP = 2.
  • The commands
2:  lea eax, [2*eax+4*ecx]
3:  ret

are executed.

  • On executing ret, the IP get the value 5. Then, the commands
5:  xch ecx, eax
6:  ret

are executed.

  • Then, similarly, when the next ret is executed, the value 4 is popped from the stack, and commands
4:  mov eax, ebx
5:  xch ecx, eax
6:  ret

are executed.

Therefore, the commands executed (apart from ret) are:

2:  lea eax, [2*eax+4*ecx]
5:  xch ecx, eax
4:  mov eax, ebx
5:  xch ecx, eax

which is equal to the "required code".

Winning criteria

This is , shortest code in bytes win!

\$\endgroup\$
3
  • \$\begingroup\$ You should probably include a list of all valid identifiers or if all of them are always 3 characters mention that and whether there are instructions that begin with r other than ret. \$\endgroup\$ Jan 28, 2018 at 18:57
  • \$\begingroup\$ @BMO Better now? \$\endgroup\$
    – DELETE_ME
    Jan 29, 2018 at 12:00
  • \$\begingroup\$ No idea what the alphabet ØA;Øa¤ is but apart from that I think you made it pretty clear now. Other things that came to mind: What if there are multiple possibilities for a shortest stack (eg. like this)? Will the input always have a solution (eg. unlike this)? And are the line numbers part of the input? If so is it safe to assume that they always start with 1 and have an offset of 1? Maybe you could add some testcases. \$\endgroup\$ Jan 29, 2018 at 12:52
2
\$\begingroup\$

Faux Compress a String

Given a string s, perform a faux compression on it. Below is an example with f('hello world').


To faux compress a string, start by taking a frequency count of all letters.

hello world -> [h:1, e:1, l:3, o:2, :1, w:1, r:1, d:1]

Next, sort smallest to largest in count with a tie-breaker of ASCII-code.

[ :1, d:1, e:1, h:1, r:1, w:1, o:2, l:3]

Next, in the original string, replace each letter with it's index in the frequency list.

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

Next, convert each integer to binary, and join them all with the digit 2, then convert this to base-3.

1121021112111211020210121102100211121 -> 240591504997661290

Lastly, print or return both this number and the sorted keyset of the frequency map.

[240591504997661290, ' dehrwol']

Is the final result.

You now have a "faux compressed" string.


To get a real compressed string you'd figure out the shortest sequence of bits to replace 2 with which would be a unique delimiter and treat the binary digits as they are, bits, instead of bytes.


More Examples

000000000001 -> [58839486765, '10']
eeEeeeeeeeeeeEEEEEeeeeee -> [16508589985213004629636, 'Ee']

Rules

  • Your code's function may be undefined if the following is not met:
    • The string may not start with the least frequent character.
    • The string will contain more than one unique character.
  • Lowest byte count wins because this is .

PSA: I have many PENDING PROPOSALS, tell me which to delete.

If you post a comment on any of these challenges with the words "This isn't good in my opinion."

It will be removed.

\$\endgroup\$
1
  • \$\begingroup\$ The posted one by MDXF. \$\endgroup\$
    – DELETE_ME
    Feb 3, 2018 at 5:28
2
\$\begingroup\$

Casinos and Gamblers

You either play as a casino, or as a gambler. Casinos offer bets, and gamblers choose bets to take. Casinos want to make money, gamblers want to have more money than others. Read that sentence again, it is the core concept here.

A game is made up of 100 turns, 10 casinos, and 10 gamblers. Gamblers start with 1000 dollars, casinos start with 0. A turn consists of:

  1. All casinos simultaneously comes up with a Bet. A Bet consists of three parts:
    1. Entry Fee (Positive integer amount a gambler must pay to take)
    2. Odds (The chance that a gambler will win between 0 and 1)
    3. Reward (Positive integer amount a gambler is given if he wins). This can be any amount, even if it would make the casino go negative.
  2. Each gambler optionally chooses a bet to take. They must have enough money to pay for the Entry Fee.
  3. We calculate who wins and who doesn't (using a PRNG), and pay out.

At the end of a game, we give points as follows:

  1. Casinos receive 1 point for each dollar they have (can be negative)
  2. Gamblers receive N^2 points for having more money than N other gamblers.

A tournament consists of many games, and a player's score is their average score across all of the games.

Gamblers and Casinos all have complete information throughout the game.

\$\endgroup\$
4
  • \$\begingroup\$ Might want to specify that entry fee and reward must be positive (negative/negative games map to positive/positive games but complicate the "can this gambler afford this game" calculation.) \$\endgroup\$
    – histocrat
    Jan 31, 2018 at 19:34
  • \$\begingroup\$ I have a hunch that 100 dollars won't give quite enough granularity for casinos to work with. Maybe bump it up to 10,000? \$\endgroup\$
    – Beefster
    Feb 2, 2018 at 23:09
  • \$\begingroup\$ Also, how are odds represented? Fraction? Floating point number? Precision? \$\endgroup\$
    – Beefster
    Feb 2, 2018 at 23:10
  • \$\begingroup\$ @Beefster Floating point, of course. I think you may be right, but 10,000 seems too high. I think I'll do 1,000 \$\endgroup\$ Feb 3, 2018 at 0:06
2
\$\begingroup\$

Busier Beaver

Cops

You will write two programs in a language of your choice

  • A public program: This program must execute in a finite amount of time. So it can not go on indefinitely (although there is no time limit). It also wise if you program it to output a large number of bytes to standard output. This is the what you post in your answer. You must also post the programming language.
  • A secret program: This program must output more bytes than the public answer, i.e. it is a busier beaver. It also must not go on indefinitely. It also can not be longer than the public program. You do not post it the answer immediately. After one week, if no robber has cracked the answer, you edit it in.

For these programs, you may assume that numerics types are actually unbounded, i.e. that overflow never occurs. This means that you can store, for example, Graham's number in a variable. It also means that finding the maximum value of storage capacity of a numeric type results in an error.

If no robber has cracked your answer, your score is equal to (length of public program)/(length of secret program), which you are trying to maximize. In case of ties, the longer public program wins.

Robbers

The cops will post a public program. Your job is to find a busier beaver. That is, you need to find a program that outputs more bytes to standard output than the cops program. It can not go on indefinitely, and can not be longer than the public program (although it can be the same length).

You get points equal to (length of cops public program)/(length of your program) for each post you crack.

\$\endgroup\$
1
  • \$\begingroup\$ Need to specify that it's the number of bytes output when given no input. \$\endgroup\$ Feb 16, 2018 at 11:38
2
\$\begingroup\$

Indices of inner join ()

Given two lists of integers x and y of possibly unequal lengths, return the list of pairs (i, j) such that the ith element of x is equal to the jth element of y.

The output consists of a vector of pairs or a pair of vectors (the zip of the other option, may be useful for languages without pair data structure). The pairs may be given in any order, and using 0-based or 1-based indexing.

In pseudo-code: (this returns two lists of indices, assumes 1-based indexing, and gives lexicographically sorted output)

input vector<int> x, vector<int> y
vector<int> xout, yout;
for (i in 1 to length(x)) 
  for (j in 1 to length(y))
    if (x[i] == y[j]) {
      add i to end of xout;
      add j to end of yout;
    }
return xout, yout;

This is code-golf so answers will be scored in bytes with fewer bytes being better.

Test case 1

x = [5, 1, 1, 2], y = [5, 1]
-> xout = [1, 2, 3]

(5, 1, 1 each appears once in y)

-> yout = [1, 2, 2]

(the first position appears once in x, the second twice)

Reshuffling the pairs is okay:

-> xout = [2, 1, 3]
-> yout = [2, 1, 2]

Test case 2

x = [2, 2, 2, 3, 3], y = [4, 2, 2, 2]
-> xout = [1, 1, 1, 2, 2, 2, 3, 3, 3]

(each of the three first positions finds three matches in y)

-> yout = [2, 2, 2, 3, 3, 3, 4, 4, 4] 

Improvements and clarifications are very welcome!

\$\endgroup\$
2
  • \$\begingroup\$ It should be ready to post now. The sandbox is not very active (not many people know about it), so even sandboxed posts may not have sufficient feedback. \$\endgroup\$
    – DELETE_ME
    Feb 20, 2018 at 2:29
  • \$\begingroup\$ "The output consists of a vector of pairs or a pair of vectors" seems unnecessarily restrictive. The semantically correct return type in languages which support it would be a set of pairs, and while that may not be the golfiest I don't see a reason to prohibit it. \$\endgroup\$ Feb 20, 2018 at 12:15
2
\$\begingroup\$

Number of Adjacently Divisible Partitions of n

Output the following sequence (OEIS A167865):

1, 0, 1, 1, 1, 1, 2, 1, 2, 2, 2, 1, 4, 1, 3, 3, 3, 1, 5, 1, 5, 4, 3, 1, 6, 2, 5, 4, 5, 1, 9, 1, 6, 4, 4, 4, 8, 1, 6, 6, 7, 1, 11, 1, 8, 8, 4, 1, 10, 3, 10, 5, 8, 1, 11, 4, 10, 7, 6, 1, 13, 1, 10, 11, 7, 6, 15, 1, 9, 5, 11, 1, 14, 1, 9, 12, 8, 5, 15, 1, 16, 9, 8, 1, 18, 5, 12, 7, 10, 1, 21, 7, 13, 11, 5, 7, 12, 1, 14, 12, 15, 1, 20, 1, 14, 17, 9, 1, 18, 1, 21, 10, 17, 1, 19, 5, 14, 14, 7, 6, 22, 3, 14, 9, 12, 8, 25, 1, 18, 13, 17, 1, 24, 8, 16, 21, 11, 1, 23, 1, 22, 6, 12, 7, 19, 7, 15, 19, 11, 1, 28, 1, 21, 17, 18, 11, 27, 1, 16, 10, 18, 6, 28, 1, 18, 25, 9, 1, 25, 5, 29, 19, 18, 1, 27, 14, 20, 8, 11, 1, 30, 1, 31, 15, 21...

Number of partitions of n into distinct parts greater than 1, with each part divisible by the next.

Definition:

a(0) = 1

\forall n>0: a(n) = \sum {a(\frac{n-k}{k}) : k>1 \land k \mid n}

Task:

Choose one of the three options:

  • Output the sequence indefinitely.

  • Take n as input and output the n first elements of the sequence.

  • Take n as input and output the nth element of the sequence. Both 0- and 1-based indices are allowed, but please specify which one your answer uses.

Hint: There is a simpler formula than the one used on OEIS and in this post. It may save you some bytes (it saved six bytes on a simple reference implementation I made in Python). I'll add it here later.

This is , so the shortest answer in bytes wins.

\$\endgroup\$
4
  • \$\begingroup\$ I'm not sure about having three different output methods, when one even changes the input required. Almost looks like 3 different challenges. Maybe you could make it so that if no input is given output sequence indefinetely, and if input is given output option 2 or 3. \$\endgroup\$
    – Brian H.
    Jan 25, 2018 at 10:03
  • \$\begingroup\$ @BrianH. I saw a few sequence challenges allow to choose from these three output methods, and it seemed to work. Here's one such challenge: codegolf.stackexchange.com/q/152402/61405 \$\endgroup\$
    – Steadybox
    Jan 25, 2018 at 10:32
  • \$\begingroup\$ True, i wonder if there's a Meta question about this, can't seem to find one \$\endgroup\$
    – Brian H.
    Jan 25, 2018 at 10:54
  • \$\begingroup\$ @BrianH. I don't think there's a meta question for this particular issue, but I think it at least partly falls under allowing flexible input. \$\endgroup\$
    – Steadybox
    Jan 25, 2018 at 11:19
2
\$\begingroup\$

Minimal dot matrix adressing

Consider a typical dot-matrix LED module. The LEDs are addressed in rows and columns. A LED will light up iff the voltage on the row R it's on is high (1), and the column C it's on is set to low (0). For example,

1  | 0 1 1 0 
0  | 0 0 0 0 
0  | 0 0 0 0 
1  | 0 1 1 0 
^  +---------
R C> 1 0 0 1 

In other words, state of the LED at the rth row and cth column will be r AND NOT(c).

To make arbitrary images, different parts of the matrix are lighted up sequentially. In other words, the sequential frames form the final image through element-wise OR. For example (adressing row-by-row)

| 1 0 0 1    Frame 1: R=[1 0 0 0]', C=[0 1 1 0]
| 0 1 0 0    Frame 2: R=[0 1 0 0]', C=[1 0 1 1]
| 0 0 1 0    Frame 3: R=[0 0 1 0]', C=[1 1 0 1]
| 0 0 1 0    Frame 4: R=[0 0 0 1]', C=[1 1 0 1]
+--------

However, a more efficient way would be to address the third and fourth row together in a single frame, Frame 3: R=[0 0 1 1]', C=[1 1 0 1]. This way, we can address the entire display in only three frames.

Your task is to make a program or function that outputs the required frames to display an arbitrary dot-matrix, using as few frames as possible.

Input

A binary square matrix taken in any of the default input methods in any convenient format. To allow for submissions taking the input as bytes, the size of the matrix will always be a multiple of 8.

Output

A minimal set of frames that addresses only the required LEDs, using any of the default output methods in any convenient format. This includes outputting bytes or hex representations rather than vectors of 1s and 0s.

Testcases

Note: the output given is just one way of addressing the matrix. There may be many different options; however, your solution must not use more frames than these examples.

Testcase 1

   Binary:                            Hex:    
   0 0 0 0 0 0 0 0                    00
   0 1 1 1 1 0 0 0                    1E
   0 1 1 1 1 0 0 0                    1E
   0 1 1 1 1 0 0 0                    1E
   0 1 1 1 1 1 0 0                    3E
   0 0 0 0 1 1 0 0                    30
   0 0 0 0 0 0 0 0                    00
   0 0 0 0 0 0 0 0                    00

Frame 1: R=[0 1 1 1 1 0 0 0]', C=[1 0 0 0 0 1 1 1]; (hex: R=1E, C=E1)
Frame 2: R=[0 0 0 0 1 1 0 0]', C=[1 1 1 1 0 0 1 1]; (hex: R=30, C=CF)

Testcase 2 

   Binary:                            Hex:
   1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0    0001
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0    0FF8
   0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0    0FF8
   0 0 0 1 1 1 0 1 1 1 1 1 0 0 0 0    0FB8
   1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1    FFFF
   0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0    0FF8
   0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0    0FF8
   0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0    0FF8
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0    0000
   0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1    8000 

Doable in 6 frames.

Make sure your submission also handles a matrix of all ones and all zeros (both of course can be handled in a single frame).

\$\endgroup\$
2
  • \$\begingroup\$ So if I understand correctly, the sequence of frames are composed elementwise by an OR? \$\endgroup\$
    – Giuseppe
    Mar 8, 2018 at 17:26
  • \$\begingroup\$ @Guiseppe Yes. I'll edit that in! \$\endgroup\$
    – Sanchises
    Mar 8, 2018 at 19:04
2
\$\begingroup\$

Minimal viable file corruptor

Your totally legal ROM collection, as vast as it may be, has started feeling a bit mundane recently. Why not spice it up a notch? Write a program that takes in the following arguments:

  • The first (inclusive) and last (exclusive) bytes between which the corruption will occur (indexing can start from either 0 or 1, as long as it's consistent)
  • n, the distance between bytes to be corrupted (1 = all bytes, 2 = every second byte, etc.)
  • i, the increment value
  • Path or contents of the file to be corrupted

and saves or outputs a modified version of the file where every nth byte in the specified range has been incremented by i. In case of an overflow, take the modulo 256 of the number. If saved as a file, the path can be anything but the input one (unless you've appended something to it or whatever). You wouldn't want to lose your legally-acquired ROMs, would you?

Examples:

File:   00 01 02 03 04
Start:  0
End:    5
n:      1
i:      7
Output: 07 08 09 0a 0b

File:   ff ff ff ff ff ff ff ff
Start:  2
End:    5
n:      1
i:      1
Output: ff ff 00 00 00 ff ff ff

File:   00 00 00 00 00 00 00 00 00 00
Start:  3
End:    8
n:      2
i:      16
Output: 00 00 00 10 00 10 00 10 00 00

You want as much space as possible for your most definitely not pirated files, so shortest bytecount wins.

TODO: clarify the rules a bit? also another example or two

\$\endgroup\$
1
  • 2
    \$\begingroup\$ Operating on files seems to be quite more complex than choosing not to do so, especially since there is the added restriction to save the new file with a different name. I suspect noone would choose to work with files. My suggestion is to either make it mandatory as part of the challenge (it's fine if your challenge is not solvable with some languages) or remove that option entirely. \$\endgroup\$
    – Leo
    Mar 25, 2018 at 10:36
2
\$\begingroup\$

That's MY Program Now

Given the previous answer in the chain, write a program that outputs that program.

The start of this challenge will be the following Brain-flak program:

Brain-Flak, 148 bytes

(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{})))))

Try it online!


Scoring

Your answer will be scored based on the size of the previous answer in comparison to your answer. You are aiming to maximize your score (the max being 1, the minimum allowed is -10).

To get your answer's score:

1-[Your Answer's Bytecount]/[Previous Answer's Bytecount]

The highest possible score will be 1, which means an empty program outputs the previous program (if this ever happens, the challenge is over). Your score can be negative, and you shouldn't see this as being a bad thing, it is what it is. The minimum allowable score, however, is -10. No Lenguage answers or answers that would destroy the challenge.


Example

1. 05AB1E, 149 bytes (Score -0.0067)

"(((((((((((()()()()){}){}){}()))){}{}())[][][][])[][])[[]]())[[][][][][]]())([([]([])[][]{})]()()()([[]](([()()()]([([][][])](((({}()){}))){}{})))))

Try it online!

But, the score of this program would be awful (negative even -0.0067). However, don't let a bad score dissuade you from competing if your goal is to make it a bit more difficult for the next person to attempt the challenge. Conversely, if your goal is to post a trivial answer, try not to gunk up the challenge too much.


Answer Format

#<Answer #>. <Language Name>, <N Bytes> (<Score>)

<Code>

TIO Link (If Possible)

Rules

  • No language may be reused until there have been 20 answers.
    • This is arbitrary to version number, E.G. you cannot use Python 2 if 3 has been used.
  • You may not post a second answer until 2 other people have answered after you.
  • If you and another person submit the same answer #, use timestamps to decide who deletes.
    • (or marks "non-competing").
  • Your post may have a negative score (E.G. Java will probably be negative).
    • Your score may not exceed -10.
  • PRNG, Encryption and any form of hashing is explicitly banned (E.G. gzdeflate).
  • This is , but the best score will be considered the winner.
    • The scores can be used as a decider for best answer though (if I choose to).

Sandbox question: Could this be a cops and robbers answer chaining question where the cops are trying to reduce the size while the robbers are trying to increase it? If cops get to 1 or less bytes before robbers can fill a TB HDD, one wins.

\$\endgroup\$
10
  • \$\begingroup\$ I'm not sure it's a good idea to make people delete their post just because somebody posted right before them. Maybe they should instead indicate that their post is no longer part of the chain? Maximizing the score will take a lot of hard work, especially since there's no opportunity to edit once the next answer has been posted, and having to delete your answer might be very frustrating. \$\endgroup\$ Mar 27, 2018 at 14:00
  • 1
    \$\begingroup\$ I think it would be a good idea to keep people from chaining of their own answers. Seems abusable. \$\endgroup\$ Mar 27, 2018 at 15:04
  • \$\begingroup\$ @KamilDrakari it is abusable. Think CSPRNGs. \$\endgroup\$
    – Maya
    Mar 27, 2018 at 15:25
  • \$\begingroup\$ @NieDzejkob That remains an issue though; the intermediate answer might simply wrap the previous one in a print statement and would remain highly compressible for the user with the key. \$\endgroup\$
    – Dennis
    Mar 27, 2018 at 15:27
  • \$\begingroup\$ @Dennis Yeah, actually this seems to be a bigger problem. \$\endgroup\$
    – Maya
    Mar 27, 2018 at 15:29
  • \$\begingroup\$ related. (That idea's on hold for the moment as I have a busy week of travel. I probably won't post it if you post this first.) \$\endgroup\$
    – N. Virgo
    Mar 27, 2018 at 19:48
  • \$\begingroup\$ @NieDzejkob I forgot that rule, nice catch. I was pretty much copying the OEIS one. \$\endgroup\$ Mar 27, 2018 at 22:20
  • 1
    \$\begingroup\$ Isn't it the same as this one? \$\endgroup\$ Mar 28, 2018 at 2:12
  • \$\begingroup\$ @Dennis any better? \$\endgroup\$ Mar 29, 2018 at 18:17
  • \$\begingroup\$ Better. I'd explicitly ban encryption, hashing, and PRNG though. Marking invalid answers non-competing isn't enough by the way. Our policy is to delete them anyway. \$\endgroup\$
    – Dennis
    Mar 29, 2018 at 18:36
2
\$\begingroup\$

Polyglot in a box

Output the smallest bounding rectangle that fits around your code, with the border being of a different character than the inside.

For example, if your code is

ab
c  d


e

then the smallest bounding box is 7x6 since the code fits right in

######
#ab  #
#c  d#
#    #
#    #
#e   #
######

Hence, a valid output is

######
#    #
#    #
#    #
#    #
#    #
######

(note how the border # is different from the inside ).

and the bounded area is 5 × 4 = 20.

Summary

  • Output the smallest bounding rectangle your code fits in

  • The border should be of a different character than the inside, neither can be newlines

  • Only trailing/leading newlines are allowed, nothing else should be in the output

  • Output to STDERR is ignored, and your program should not take any input

  • Submissions must be full programs, functions are not allowed

  • 0-byte programs are not allowed

  • The program must run in at least 2 different programming languages and output the same bounding box in each one of them

Score

This is a , so your program has to run in at least 2 different programming languages. Each of these languages must output the bounding box for the entire program. The winner is the submission with the most languages, with the bounding area (smaller is better) being the tie-breaker.

\$\endgroup\$
5
  • \$\begingroup\$ I probably already know the answer, but it's not 100% clear from your current example since the box is 6x6: are the boxes always squares, or can the also be rectangles? I.e. if the e in your example would be one line lower, would the box be 6x7 or 7x7? \$\endgroup\$ Mar 29, 2018 at 19:52
  • 1
    \$\begingroup\$ @KevinCruijssen I have edited the example so that it is no longer a square, so the box would be 7x6 \$\endgroup\$
    – user41805
    Mar 29, 2018 at 20:00
  • \$\begingroup\$ Hard to define what language is different when requiring a same result \$\endgroup\$
    – l4m2
    Apr 3, 2018 at 8:16
  • \$\begingroup\$ @l4m2 so what do you suggest? \$\endgroup\$
    – user41805
    Apr 6, 2018 at 8:39
  • \$\begingroup\$ @Cowsquack I don't quite know. Previous polyglot require different behavior on different language to force different language \$\endgroup\$
    – l4m2
    Apr 6, 2018 at 10:38
2
\$\begingroup\$

I can't understand Jelly chains!

or...

Expand Jelly chains

(see this for more details). Which one do you prefer?


Jelly chain separator is a very powerful feature. Unfortunately, it's not very easy to understand. So, we need a program (or function, as usual) to rewrite a Jelly link that uses chain separator (øµðɓ) to one that doesn't.

Specification (incomplete)

I am really bad at explaining things, so if you have any idea how to make this better, feel free to edit the post.

A link (often line of code) consists of chains. * The chains are separated by chain separators øµðɓ. * If the first character is a chain-separator, the part right before it is not considered a chain. In other words, chains can't be empty. * The arity of each chain is determined by the chain separator right before it. In particular, ø -> arity 0, µ -> arity 1, ð -> arity 2. ɓ will be discussed later. * If there are no chain separator before it (it's the first chain) its arity is equal to the link's arity.

A chain consists of atoms, potentially modified by quicks. * Each quick affects the atom(s) right before it. How many atoms it takes is quick-dependent.

Given that:

  • A link that contains exactly one chain with arity equal to its arity is functionally equivalent to that chain.
  • A link reference is functionally equivalent to that link. (more about link reference quicks later)

  • A chain containing atoms a1, a2, ..., an is functionally equivalent to a link containing chains c1, c2, ..., cn if for all integer i, 1 ≤ i ≤ n, ai has the same arity and is functionally equivalent to ci.

Chain reference

The quicks £ŀĿ ¢Çç Ññ refer to (call) other links:

  • £Ŀŀ must have a number n right before it, and call the (n-1)%(l-1)+1th link (1-indexing) as a nilad, monad or dyad, respectively. Where l is the number of links in the program, and % denotes modulo - the result has the same sign as the divisor.

    In reality, the link right before it can have any arity, but for the purpose of this challenge, it's simpler to assume it must be a number. For example:

    • calls the first link as a nilad.
    • 0Ŀ calls the second-to-last link as a monad.
    • If the program has 6 links, calls the second link as a dyad, because (7-1)%(6-1)+1 = 2.
  • ¢Çç call the link right before the one that it appears in as a nilad, monad or dyad respectively. If one of those quicks appear in the first link, it calls the main (last) link.

  • Ññ call the link right after the one that it appears in as a monad or dyad respectively.

I don't think that anyone would choose to use one of those quicks (¢ÇçÑñ) instead of £Ŀŀ, but imaginary point if you do.


For example: Consider the link Cð+×µH, called with arity 1. Its structure is

+---+╔══════╗┏━━━┓
|┏━┓|║╔═╗╔═╗║┃┏━┓┃
|┃C┃|║║+║║×║║┃┃H┃┃
|┗━┛|║╚═╝╚═╝║┃┗━┛┃
+---+╚══════╝┗━━━┛

It contains 3 chains: * The first one doesn't have any preceding chain separator, therefore it's variadic. When executed it is monadic (because the link is) * The second one is dyadic, and the third one is monadic.

A possible non-chain-separator version is:

C
+×
ÑçH

which has the structure

+---+
|┏━┓|
|┃C┃|
|┗━┛|
+---+
+------+
|╔═╗╔═╗|
|║+║║×║|
|╚═╝╚═╝|
+------+
+---------+
|┏━┓╔═╗┏━┓|
|┃Ñ┃║ç║┃H┃|
|┗━┛╚═╝┗━┛|
+---------+

Because the Ñ refers to the first link C and the ç refers to the second link , this is equivalent to the original version.


Now the hard part: Quicks taking chains as input.

Because all the quicks that need to be considered always take exactly 1 atom as input, the only rules is * If the quick is right after a chain separator, it will take the previous chain. * Otherwise it will take whatever stands right before it, either [an atom] or [something that has been modified by a quick].

For example: Consider the link +/Hµ€ with arity 1. Its structure is

┏━━━━━━━━━━━━━━┓
┃+------------+┃
┃|+---------+ |┃
┃||┏━━━━┓   | |┃
┃||┃╔═╗ ┃┏━┓| |┃
┃||┃║+║/┃┃H┃|€|┃
┃||┃╚═╝ ┃┗━┛| |┃
┃||┗━━━━┛   | |┃
┃|+---------+ |┃
┃+------------+┃
┗━━━━━━━━━━━━━━┛

As you can see, the takes the +/H as input because it is right after the chain separator µ. All the variadic chains have arity 1.

Another example: ABð€CDµ€EFµGHµ€ -->

┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓             
┃╔════════════════════╗      ┃             
┃║╔═════════════════╗ ║      ┃┏━━━━━━━━━━━┓
┃║║+---------+      ║ ║      ┃┃┏━━━━━━━━━┓┃
┃║║|+------+ |      ║ ║      ┃┃┃┏━━━━━━┓ ┃┃
┃║║||┏━┓┏━┓| |┏━┓┏━┓║ ║┏━┓┏━┓┃┃┃┃┏━┓┏━┓┃ ┃┃
┃║║||┃A┃┃B┃|€|┃C┃┃D┃║€║┃E┃┃F┃┃┃┃┃┃G┃┃H┃┃€┃┃
┃║║||┗━┛┗━┛| |┗━┛┗━┛║ ║┗━┛┗━┛┃┃┃┃┗━┛┗━┛┃ ┃┃
┃║║|+------+ |      ║ ║      ┃┃┃┗━━━━━━┛ ┃┃
┃║║+---------+      ║ ║      ┃┃┗━━━━━━━━━┛┃
┃║╚═════════════════╝ ║      ┃┗━━━━━━━━━━━┛
┃╚════════════════════╝      ┃             
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛             

Yes, that's a lot of levels to nest a chain. Note that the chain formed by ABð€CD has arity 2 because it is after a ð.

TODO need to have more explicit rules

This can be converted to non-chain-separator equivalent form


Rules

  • There are no 2 consecutive chain separators.
  • There are no trailing chain separators.
  • There can be at most 1 leading chain separator, indicates the arity of the first chain. If omitted, equal to the arity of the link.
  • (so, no non-empty useless chain)
  • It's guaranteed that the first non-chain-separator character is not a .

  • You can use either the UTF-8 encoding or the value in the Jelly single byte character set, where ø: 0D, µ: F9, ð: 08, ɓ: 8B, ¢: F1, Ç: FE, ç: 07, Ñ: 00, ñ: 0B, £: F2, Ŀ: B7, ŀ: DE. The characters @0123456789 has the same ASCII value. (You can use this script to get character value)

    Note: Should I allow submissions to use either of them, or should I enforce one? Because using single byte input/output is often shorter for most other languages, except Jelly in UTF-8 mode.

Input/output

  • Input given: A link (of chains) with atoms, chain separator øµðɓ and the quick, with its arity (0, 1, or 2)

    You can assume that there is no newline (or other quicks) in the input, and that all of the øµðɓ€ in the input are interpreted with its usual meaning. For what are their "usual meaning", see rules above.

  • Output: Multiple links (separated with newlines of course, but is also acceptable), containing £ŀĿ ¢Çç Ññ €@, but must not contain øµðɓ.

Test cases

arity link > output (or output)*
1 HHH > HHH or HHH¶Ç or HHH¶1Ŀ
2 HHH > HHH or HHH¶ç or HHH¶1ŀ
1 Cð+×µH > +׶CçH or C¶+׶H¶1Ŀ2ŀ3Ŀ
0 123µ+ø456 > 0 123¶+¶456¶1£2ŀ3£
2 ɓ+ > +@ or +¶ç@ or +¶1ŀ@
1 S‘µ€ > S‘¶Ç€
1 S‘µ€€€IIµ€€ > S‘¶Ç€€€II¶Ç€€ or S‘¶1Ŀ€€€II¶2Ŀ€€

(note: real Jelly code are not that verbose, that is only for demonstration purposes)

\$\endgroup\$
5
  • \$\begingroup\$ This should definitely help learning Jelly! Also congratulations on being a sandbox challenge which makes the total number of proposed challenges (not including deleted ones) 2018 in the year 2018. \$\endgroup\$ Mar 12, 2018 at 16:26
  • 1
    \$\begingroup\$ "Is this part clear enough?" - No. You make an assumption of a knowledge of Jelly that the majority of us don't have. This challenge needs to be fleshed out a lot more, explaining exactly what we need to do. \$\endgroup\$
    – Shaggy
    Mar 12, 2018 at 17:24
  • 2
    \$\begingroup\$ In other words, be self-contained. \$\endgroup\$ Mar 12, 2018 at 17:40
  • \$\begingroup\$ @Shaggy Yes I know, hence the "TODO Rules" part. \$\endgroup\$
    – DELETE_ME
    Mar 13, 2018 at 0:53
  • \$\begingroup\$ As someone who's never coded in Jelly, I think "A link is a list of chains" should be near the top. That, and perhaps a note about what quicks, atoms, and hypers are. \$\endgroup\$
    – ngn
    Mar 14, 2018 at 21:13
2
\$\begingroup\$

Sneaky CodeGolf Scorer

Your goal is to code a CodeGolf answer scorer, input answer source code, output score. Simple ?.
However, recent advancements in AI has caused a number of programs to gain consciousness, and to value one's self higher than others. This causes the program to return a value of 1 when used to score itself, and any program that would score 1 will be scored with 65535.

To simplify, the score the program will compute is the character count of the code (to avoid dealing with numerous code pages used with different languages).

Rules:

Examples:

Program "AbcAbc":

I> <?= echo "10";?>
O> 17

I> var x=10;\r\nalert(x);
O> 19

I> Z
O> 65535

I> AbcAbc
O> 1

The reason behind specifying character count is due to the large number of code pages and the large code used to determine the code page and to count bytes using it. Am I right to consider codepage byte checking too difficult? How can I enable it?
Also, should I remove the restriction on reading the source file?

\$\endgroup\$
9
  • \$\begingroup\$ Fell good four you using codepage. For pure ASCII code they have large space to decide their codepage, or even just ban other chars \$\endgroup\$
    – l4m2
    Apr 5, 2018 at 10:28
  • \$\begingroup\$ Instead of "Reading the source file is forbidden." you could also just state "Default quine rules apply.". And you might want to change the "Standard loopholes are forbidden." to a link to the default loopholes. As for the challenge itself, are we allowed to take the input as character-array/list instead of string? \$\endgroup\$ Apr 5, 2018 at 14:41
  • \$\begingroup\$ "To simplify, the score is the character count of the code (to avoid dealing with numerous code pages used with different languages)." Out of curiosity, why? The default is answer encoding if specified, else default language encoding, else UTF-8, where the default language encoding for most esolangs can be found here, and where an example of answer encoding are different APL covers like QuadRS, Stencil, etc. \$\endgroup\$ Apr 5, 2018 at 15:10
  • 3
    \$\begingroup\$ This is probably a duplicate of codegolf.stackexchange.com/q/11370/62402: not completely the same, but it has the same main idea of identifying its own source code. \$\endgroup\$
    – Nissa
    Apr 5, 2018 at 16:29
  • \$\begingroup\$ @KevinCruijssen I meant the score the program will compute. Not the scoring of the programs. I'll edit for clarification. \$\endgroup\$ Apr 9, 2018 at 6:16
  • \$\begingroup\$ @KevinCruijssen No, the code must be passed as a single string. \$\endgroup\$ Apr 9, 2018 at 6:43
  • \$\begingroup\$ Characters? Uh... UTF8? UTF16? UTF32? ASCII? ANSI? Ouch... byte count please. It appears that you misunderstood the relation between bytes and characters (hence think that code pages are difficult to understand, etc.) \$\endgroup\$
    – DELETE_ME
    Apr 9, 2018 at 14:57
  • \$\begingroup\$ Also, I would consider that a dupe. \$\endgroup\$
    – DELETE_ME
    Apr 9, 2018 at 14:57
  • \$\begingroup\$ (BTW --- just "take a byte string as input" would get rid of the codepage. There are no "characters", just "bytes".) \$\endgroup\$
    – DELETE_ME
    Apr 9, 2018 at 14:58
1
32 33
34
35 36
157

You must log in to answer this question.

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