Sandbox for Proposed Challenges

Question

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

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

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

Add Proposal

Search the Sandbox

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

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

@guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] — DJMcMayhem♦, Aug 29 at 15:19
Why no featured anymore? Can't we have it auto-added or something? — JL2210, Sep 26 at 15:57
@JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary — caird coinheringaahing, Sep 29 at 13:43
I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . — AZTECCO, Oct 5 at 19:39

RamenChef · Accepted Answer · 2018-11-21 16:39:57Z

2

Survival Game: Alien Hunters (working title)

king-of-the-hill java

Based on Create Your Wolf, but the combat is very different.

Somewhere, deep in the heart of the galaxy, lies the planet Oizys. A toroidal planet in the habitable zone of its star, its bountiful land and beautiful oceans make it the perfect planet for your race of aliens to start colonizing as an interstellar civilization.

Unfortunately, a few dozen other alien races are also trying to colonize it, and you can't stand them. So you're going to have to kill them.

Your Alien

Your task is to write an implementation of the net.ramenchef.oizys.Alien class:

package net.ramenchef.oizys;

public class Alien {
    public enum Move {
        // a whole bunch of values; these are described in "the board"
    }

    /**
     * Used by the runner to keep track of the alien's energy.
     */
    double energy = 1.0;

    /**
     * Moves the alien.
     *
     * @param surroundings The alien's surroundings. The first
     *  dimension is North–South, with index 0 being North. The second
     *  dimension is East–West, with index 0 being West.
     * @return A {@code Move} object representing the direction to
     *  move the alien
     */
    public abstract Move move(char[][] surroundings);

    /**
     * Called when the alien is in battle.
     *
     * @param opponents The other aliens on this tile that need to be
     *  fought
     * @return The amount of energy to use in this battle
     */
    public abstract double attack(char[] opponents);
}

100 instances of your class will be spawned in random locations on the board for each trial. Each alien class will be assigned a unique character to represent them on the board.

There are a number of stock alien races that already inhabit Oizys:

Rocks: they do absolutely nothing and don't pose any sort of threat (i.e., they attack with 0 energy), but for some reason your generals don't know what rocks are, so they appear just like any other alien.
Random Bears: they act randomly. They move in a random direction (including possibly not moving at all) and attack using a random portion of their energy.

The Board

Oizys is a toroidal planet, so the board will be side-looped on both edges. The width and height of the board will be equal to \$\left\lceil\sqrt s\right\rceil\$, where s is the number of alien species. Each round, your aliens will have the option to move one tile horizontally and/or vertically with the move method. This method takes a 3x3 char[][] representing the alien's surroundings, with a[0][0] being Northwest and a[0][2] being Northeast, and returns a Move enum. The possible Move values are NORTHWEST, NORTH, NORTHEAST, WEST, HOLD, EAST, SOUTHWEST, SOUTH, and SOUTHEAST.

Combat

If two or more aliens attempt to move into the same tile, they will fight. What better opportunity to kill those annoying other aliens! Or maybe get killed yourself, who knows? Each alien starts with 1 energy, and uses it to fight other aliens. When aliens fight, they use the attack method, which takes a char[] representing their opponents and returns a double, to determine how much energy they will use for that battle. The alien that uses the most energy wins, and the others die. In the case of a tie, the winner is determined by coin flip. An alien cannot use more energy than it has or it will die; neither can it use a negative amount of energy.

Scoring

Five trials will be held, with each trial being scored by the portion of the aliens remaining that are your alien. These trials will be held on [1 month after the challenge is posted].

Other Rules

Standard loopholes are forbidden.
Aliens attempting to alter field visibility/writability will be met with mysterious SecurityExceptions.
The order that aliens' methods are called is undefined, though there is a happens-before relationship between calls on successive rounds, as well as between aliens moving and those same aliens attacking each other.

edited Nov 21 '18 at 16:39

answered Apr 11 '18 at 18:48

RamenChef

8231 silver badge9 bronze badges

\$\begingroup\$ How do the aliens get energy? What is the energy limit mentioned in the description of the dragon? \$\endgroup\$ – Laikoni Apr 12 '18 at 8:54
\$\begingroup\$ @Laikoni the dragons have unlimited energy, and the rest of the aliens start with all the energy they'll get. \$\endgroup\$ – RamenChef Apr 12 '18 at 12:08
\$\begingroup\$ So the energy is a floating point number? Doesn't that cause potentially more trouble than just saying it's initially 100 and using ints? \$\endgroup\$ – Laikoni Apr 12 '18 at 12:35
\$\begingroup\$ @Laikoni how would using a floating point be a bad idea? \$\endgroup\$ – RamenChef Apr 12 '18 at 12:57
\$\begingroup\$ Testing for equality of floating point numbers can give imprecise results, see e.g. en.wikipedia.org/wiki/… \$\endgroup\$ – Laikoni Apr 12 '18 at 13:44
\$\begingroup\$ @Laikoni it's not testing for equality; it's comparing them. Whereas ints would not allow bots to divide their energy successively ad infinitum. \$\endgroup\$ – RamenChef Apr 16 '18 at 16:51
\$\begingroup\$ 1. You should disallow all reflection. 2. You need to run way more than 5 trials to get a good answer. 3. How are trial scores combined? What's the char for nothing? 4. You should add a helper method to get their own energy, as well as their own character. 5. I'd argue for int energy that is simply really high (like the maximum int or even maximum long). Then you don't deal with floating point imprecision, and will even improve calculation speed. 6. What happens when something attacks a rock? What does the rock return? \$\endgroup\$ – Nathan Merrill Apr 18 '18 at 14:52
\$\begingroup\$ 7. If I lose a battle, do I lose energy, or do I instantly die? 8. Re Dragons: I see two primary issues: The attack is so high to make fighting them pretty impractical. It's possible to identify them based off of their movement, but your field of vision is very small. If vision is bigger, then bots will learn to avoid them, but now many bots will start to imitate dragons. In essence, making dragons so strong changes the balance of the game drastically. Consider if that is really what you want. 9. Do you allow communication between instances of the same bot? What about different bots? \$\endgroup\$ – Nathan Merrill Apr 18 '18 at 14:57
\$\begingroup\$ @NathanMerrill 1) Why go beyond installing a SecurityManager? 2) The winner usually won't be determined by luck alone. 3) They're averaged. (will add this to the spec) 4) I had one for energy in the runner, but I forgot to document it. 5) ints can't go to 10^-300. 6) The rock returns 0. 7) You die instantly. The winner loses energy. 8) Noted. 9) Yes. Hiveminds are allowed. \$\endgroup\$ – RamenChef Apr 18 '18 at 23:46
\$\begingroup\$ 1) Because KotHs shouldn't be about the language, they should be about the core game rules. The instant you bring in reflection, you get in the world of one-upping: No matter how good my bot is, it can be one-upped. 2) Really? As of right now, I don't see any reason why not. Your starting position has a huge affect on how well you do. 3) Note that this means that winning by a large margin on a few games means more than consistently winning by a little. (This isn't bad, but its worth considering). 5)Ok? You don't need that much precision. 6,7,8) Please add to spec :) \$\endgroup\$ – Nathan Merrill Apr 19 '18 at 2:46
\$\begingroup\$ The aliens won't be given the classes of their opponents; only their character. If they want to keep pets of their opponents (like MultiWolf) I won't stop them \$\endgroup\$ – RamenChef Apr 19 '18 at 11:57
\$\begingroup\$ @RamenChef fair enough, but MultiWolf does't require reflection. He could simply have a function that builds the array by calling their constructors normally. \$\endgroup\$ – Nathan Merrill Apr 19 '18 at 15:03
\$\begingroup\$ @NathanMerrill Reflection is more streamlined though. \$\endgroup\$ – RamenChef Nov 21 '18 at 16:23
\$\begingroup\$ I'd love to see this make it to the main site. You can use something like this to open up the competition to other languages, but be warned, you may end up spending quite a few hair-pulling hours trying to get other people's code to work on your machine. I'll be the third to comment that using integers would be better. You commented that you won't be testing for equality but in the challenge spec you mention handling ties. How are multi-way ties handled? Maybe change "determined by coin flip" to "chosen at random". \$\endgroup\$ – Rainbolt May 22 at 23:27
\$\begingroup\$ Maybe I missed it, but what char represents an empty square? \$\endgroup\$ – Rainbolt May 22 at 23:27

add a comment |

japh · Accepted Answer · 2018-12-19 03:23:17Z

Count smooth numbers

fastest-code number-theory primes combinatorics

Define \$\Psi(x,B)\$ as the number of integers between \$1\$ and \$x\$, whose prime factors are all \$B\$ or less. (These are the \$B\$-smooth numbers.)

For example, there are 34 integers between 1 and 100 that have only 2, 3 and 5 as prime factors. These are:

 1  2  3  4  5  6  8  9 10 12
15 16 18 20 24 25 27 30 32 36
40 45 48 50 54 60 64 72 75 80
81 90 96 100

Therefore, \$\Psi(100,5)=34\$. The next prime is 7, so \$\Psi(100,6)\$ is also 34.

This is a challenge to calculate exact values of \$\Psi\$ as quickly as possible.

Methods

You may not use libraries or built-ins that calculate this function. That being said, I don't know any language that has a built-in for this (not even Mathematica?)

I also can't seem to find any fast algorithms for this problem, except for a basic meet-in-the-middle by Daniel J. Bernstein which might be a good starting point.

Bernstein also describes an approximation method that may or may not be useful.

Input range

You may assume that \$1<B\leq x\leq 10^{100}\$ and \$B<10^6\$.

Scoring

You will be scored on tiers of increasing difficulty.

Each tier has several inputs \$(x,B)\$ such that the \$\Psi(x,B)\$ have similar values, and the \$x\$ values are distributed exponentially. Tiers will start at around \$\Psi(x,B)\approx 10^9\$ and go up to \$\Psi(x,B)\approx 10^{20}\$ or more, depending on how fast the entries get.

The time limit for each tier is 60 CPU seconds per input on average. In other words, if a tier has \$n\$ inputs, you will essentially have \$n\$ CPU minutes to obtain the outputs. You are welcome to submit parallel code but each thread will count towards the time limit.

Your score is the highest tier that your program can solve. If there is a tie, the program that is fastest on the highest tier wins.

For practical reasons, your program will be limited to 15GiB of memory.

Sample tiers

Warm-ups:

3:
  Ψ(10^3, 997) = 1000
  Ψ(10^6, 7)   = 1273
  Ψ(10^9, 5)   = 1530
6:
  Ψ(10^6,  999983) = 1000000
  Ψ(10^9,  59)     = 1060717
  Ψ(10^12, 29)     = 1469549
  Ψ(10^15, 17)     =  919814
  Ψ(10^36, 7)      =  936046

Tiers:

9:
  Ψ(10^9,  999983) =  616220853
  Ψ(10^10, 4567)   =  954965955
  Ψ(10^12, 337)    = 1180049403
  Ψ(10^15, 97)     = 1016358704
  Ψ(10^18, 59)     = 1106651678
  Ψ(10^24, 31)     =  791377032
  Ψ(10^30, 23)     =  812060729
  Ψ(10^48, 17)     = 1435897064
10:
  Ψ(10^11, 11987) = 10016301575
  Ψ(10^12, 1499)  = 10753426440
  Ψ(10^15, 199)   = 12766644440
  Ψ(10^18, 89)    =  9052115006
  Ψ(10^24, 47)    = 11298682134
  Ψ(10^30, 37)    = 14838208717
  Ψ(10^48, 19)    =  7868307089
11:
  Ψ(10^13, 2297) =  84344528150
  Ψ(10^15, 443)  =  96272828440
  Ψ(10^18, 163)  = 107816435926
  Ψ(10^36, 37)   =  94053521936
  Ψ(10^24, 67)   =  81421195505
  Ψ(10^48, 29)   = 151266342065

etc.

I may choose to do the actual scoring on different inputs, including using \$x\$'s that are not powers of 10.

Mr. Xcoder · Accepted Answer · 2018-12-28 17:46:16Z

Squish these Numbers

META: I think my wording is not very clear, if you have a suggestion to make it easier to understand, feel free add a commment or edit it directly in to this post.

code-golf math array-manipulation arithmetic statistics

Given a finite sequence of real floating point numbers, map it into the Interval \$[-1,1]\$, such that the order of these numbers is preserved.

Details

You can choose any mapping you like, it doesn't have to be linear.
The mapping you choose doesn't have to stem from a function, that means some number \$x\in \mathbb R\$ doesn't have to get mapped to the same number in \$[-1,1]\$, the value it does get mapped to can change depending on the other values in the input list.
Two equal values in the input list, should remain equal in the output.
If some value in the input list is strictly smaller than some other value, then the corresponding values in the output should satisfy the same relation, in theory. In practice it might happend that two different numbers will get mapped to the same output due to floating point arithmetic issues, which is fine - as long as it would work with an arbitrary precision.
You can assume the input sequence contains at least two distinct entries.

Examples

Following example finds a linear map that maps the least entry to \$-1\$ and the greatest entry to \$1\$. Note how this map depends on the sequence.

$$ (x_1,x_2,\ldots,x_n) \mapsto \left( \frac{x_i - \min_k x_k}{\max_k x_k - \min_k x_k} \right)_{i=1}^n $$

Following example is a fixed function that always behave the same. Because it is monotonic and strictly increasing, it satisfies all conditions. $$ (x_i)_{i=1}^n \mapsto \left(\frac{\arctan(x_i)}{\pi} \right)_{i=1}^n$$

Thanks @PeterTaylor for following example. Here \$\operatorname{sort}(x)\$ sorts the input sequence in ascending order and \$\operatorname{indexof}(u,v)\$ returns the index of the first occurence of \$v\$ in the sequence \$u\$.

$$(x_i)_{i=1}^n \mapsto \left( \frac{1}{n} \operatorname{indexof}(\operatorname{sort}(x),x_i)\right)_{i=1}^n$$

How about a function which sorts the array and then maps \$x_i \to \frac1n \textrm{indexof}(\textrm{sorted}(x), x_i)\$? — Peter Taylor, Dec 18 '18 at 14:59
Yeah that looks fine (assuming for e.g. \$x_1 = x_2\$ we get the same index). - If you do not mind I'll add that as an example too. — flawr, Dec 18 '18 at 17:22
I think many languages have builtin tanh which trivializes this. Are you sure there are enough languages where this challenge is interesting? — lirtosiast, Dec 19 '18 at 0:40
I expect it will be hard for a list-aware function to beat a general mapping like x->1+1/(1+2**-x), or just tanh if that's available, but maybe Peter Taylor's method will be shorter in golfing languages. I think it's worth noting in the spec that it's OK if due to float inaccuracies two very close values are mapped to the same value in practice. — xnor, Dec 19 '18 at 0:42
@xnor I'll add the comment about the floating point problems, that is a good point. I'm convinced that there will be a lot of different approach that will be optimal in the different languages. — flawr, Dec 19 '18 at 9:16

l4m2 · Accepted Answer · 2019-01-09 14:07:32Z

Shortest JsFuck code for a number

JsFuck is a language using only []()!+ to run and express anything in JavaScript. Below is a simplified model of JavaScript to express numbers:

Types
1. Number
2. String
3. Boolean (true)
4. Array
Functions
- IEEEdouble(x):
  - Let \$u\$ is the number in \$\{a\cdot 2^{b}|-2^{53}<a<2^{53}, b>-1075, a,b\in \mathbb Z\}\$ nearest to x, maximizing \$b\$ on tie
  - If \$|u|<2^{1024}\$, return \$u\$
- toNumber(x):
  - If x is a Number, return x;
  - If x is a Boolean, return 1;
  - If x is an Array [y], return toNumber(y);
  - If x is an Array [], return 0;
  - Otherwise, x is a String. In this case,
  - If x matches /^([\+\-]?(?:\d*\.?\d+|\d+\.))(?:e([\+\-]?\d+)?$/, let \$v=\text{＄1}\times 10^\text{＄2}\$ ($2 is zero if not present)
  - Return IEEEdouble(\$v\$)
- toString(x):
  - If x is a String, return x;
  - If x is a Boolean, return 'true';
  - If x is an Array [y], return toString(y);
  - If x is an Array [], return '';
  - Otherwise, x is a Number. In this case,
  - Find \$p, q\in \mathbb Z\$ such that IEEEdouble(\$p\times 10^q\$)=x, maximizing \$q\$(there may be multiple \$p\$ satisfying the restriction, in which case choosing which one is unknown);
  - Let \$y=p\times 10^q\$;
  - If \$y=0\$ or \$10^{-6}\leq|y|<10^{21}\$, write it normally without scientific notation mapping the RegEx /^([1-9]\d*|0)(\.\d*[1-9])?$/;
  - Otherwise, write it in scientific notation mapping the RegEx /^[1-9](\.\d*[1-9])?e[\+\-][1-9]\d*$/
- x+y
  - If either x or y is a String or an Array, return toString(x) concatted with toString(y);
  - Otherwise, return IEEEdouble(the sum of toNumber(x) and toNumber(y))
- +x
  - Return toNumber(x)
- [] and [x]
  - Return an Array.
- x[y]
  - If x is a String, return the y^th character(0-index) in x
- !![] and !+[]
  - Return a Boolean

A valid JsFuck code is always parenthesis balanced without two symbols + together. Expression in parenthesis is calculated before the one out. On the same layer operations go from left to right.

You are required to output the shortest JsFuck code that generates a given IEEE double (A possible output of IEEEdouble). Shortest generator wins.

It's fine if your generator runs slow, but beware of potential infinite loop if you eval.

Samples

1     -> +!![]
2     -> !![]+!![]
10    -> +[+!+[]+[+[]]]
1e10  -> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))
0.1   -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+!![]))
1e-10 -> +((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))
5e-324-> +(!![]+!![]+!![]+(!![]+[])[!![]+!![]+!![]]+(+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(!![]+!![]+!![])+(!![]+!![])+(!![]+!![]+!![]+!![]))
9999999999
      -> +(+!![]+(!![]+[])[!![]+!![]+!![]]+(+!![])+(+[]))+(+((+((+(+!![]+[+!![]]+(!![]+[])[!![]+!![]+!![]]+(!![]+!![])+(+[]))+[])[+!![]]+(+[])+(+[])+(+[])+(+[])+(+[])+(+[])+(+!![]))+[])[!![]+!![]]+(+!![])))

SN: Another way to ask is requiring to be testable and shouldn't be longer than a chosen generator

Challenge seems a bit too long-- maybe restrict the domain to integers? Also I can't see any competitive solution actually finishing for nontrivial test cases because they'd just eval all valid JSFuck strings in parallel. — lirtosiast, Jan 6 at 3:41
@lirtosiast Do your "integer" mean safe integer? Also I don't see how it simplifies the problem much — l4m2, Jan 6 at 7:30

Sanchises · Accepted Answer · 2019-01-11 13:14:18Z

Is it shifted?

code-golf decision-problem keyboard

Consider a standard US-International QWERTY keyboard, without a numeric keypad, and Caps Lock mysteriously missing.

< insert image >

The goal is to write two programs or functions that take no input, and each give a distinct output through any default output method: Shift and No shift respectively. The program that outputs No shift has to be written without use of the ⇧ Shift key. The program that outputs Shift has to be written while holding the ⇧ Shift key throughout. Both programs have to be written using the exact same sequence of keypresses. A valid entry would be a1b2 + A!B@, if they output No shift and Shift respectively.

The symbols allowed for the "No-shift" program are as follows:

`1234567890-=
qwertyuiop[]\
asdfghjkl;'
zxcvbnm,./
<space> <newline> <tab>

The symbols allowed for the "Shift" program are as follows:

~!@#$%^&*()_+
QWERTYUIOP{}|
ASDFGHJKL:"
ZXCVBNM<>?
<space> <newline>

Note that Tab ↹ is missing, since Shift+Tab ↹ does not produce a \t tab symbol in most editors.

Sandbox note

I think using case-sensitive output makes the challenge more challenging, but it might become too challenging. What are your thoughts?

This already appears to be impossible in most productive languages, so I would allow output in any case. — Laikoni, Jan 13 at 8:53

ბიმო · Accepted Answer · 2019-01-14 20:19:38Z

Touch-typing distance

Tags: code-golf, string

Related: Levenshtein distance

There are many different string metrics, a simple one is the Levenshtein distance given by \$\texttt{ld}_{a,b}(|a|,|b|)\$:

$$ \texttt{ld}_{a,b}(i,j) = \begin{cases} \max(i,j), & \text{if $i = 0$ or $j = 0$} \\ \\ \min \begin{cases} \texttt{ld}_{a,b}(i-1,j) + c_\text{deletion} \\ \texttt{ld}_{a,b}(i,j-1) + c_\text{insertion} \\ \texttt{ld}_{a,b}(i-1,j-1) + w(a_i, b_j) \end{cases}, & \text{otherwise} \end{cases} $$

The avid reader may have noticed that there are missing pieces in the above definition, it makes use of a weight function \$w\$ which was never defined and the costs \$c_\text{deletion}\$ as well as \$c_\text{insertion}\$.

The Levenshtein distance uses an indicator function which evaluates to \$1\$ if the two characters are not equal and \$0\$ otherwise and costs \$1\$ for deletion and insertion. This does not take into account that a mistake of typing u instead of w should cost more than mistakenly typing an e. Let's try to fix this!

Challenge

For this challenge we'll assume a QWERTY keyboard and only take lower-case letters into account. We will use the usual letter-to-finger assignment (left-most finger to right-most) ["qaz","wsx","edc","rtfgvb","yuhjnm","ik","ol","p"]:

Left Hand

pinky: qaz
ring finger: wsx
middle finger: edc
index finger: rtfgvb

Right Hand

index finger: yuhjnm
middle finger: ik
ring finger: ol
pinky: p

Now, to define a new string metric we will use the following definitions in the above generalized Levenshtein distance: Set \$c_\text{deletion} = c_\text{insertion} = 8\$ and for \$w(a_i,b_j)\$ we will use the distance of the two characters plus \$1\$ according to the above assignments (unless they are equal, then we'll use \$0\$). Here are a few examples:

'q' 'q' -> 0
'q' 'a' -> 1
'q' 'w' -> 2
'l' 'g' -> 4
'p' 'a' -> 8

Rules

Input will be two strings \$a\$ and \$b\$ which

are non-empty
only contain lower-case letters (ie. match ^[a-z]+$)

Output will be the "touch-typing distance" as defined above.

Test cases

"todo" "todo" → 0

Deadcode · Accepted Answer · 2019-01-27 08:52:44Z

Shift right by half a bit code-golf math number arithmetic

The challenge is to implement a program or function ^{(subsequently referred to as "program")} that takes a nonnegative integer \$n\$ as input and returns \$n\over\sqrt{2}\$ (the input divided by the square root of two) as output, rounded to a nonnegative integer.

You may take your input and output in any reasonable format; for example stdin/stdout, files, or arguments/return values would all be acceptable.

You are required to use, at minimum, the largest fixed-size integer type offered by your language, and if an unsigned variant of this is available, you must use it. If your language has no built-in integer type (e.g. JavaScript) you are allowed to use its default numerical type (e.g. floating point); for languages with no concept of a number (e.g. regex), input and output can be e.g. the length of a string.

It is not required to reject negative integers; a submission that returns correct answers for negative inputs is allowed, but not required. Undefined behavior with negative inputs is allowed.

You are allowed and encouraged to use arbitrary-precision integer types if you so desire, but the type must either be a built-in, part of a standard library, or implemented from scratch in your program.

Despite what the title might imply, you may use any rounding algorithm you want (floor, ceiling, nearest half up, nearest half even, arbitrary, or even random), as long as the difference between the integer returned value and the theoretical exact (irrational) value is always less than \$1\$ for all inputs that fit in your chosen integer type. All inputs up to the maximum representable value must return a correct output.

In a way, the job of this program is to calculate the irrational number \$\sqrt{2}\$ to the requested precision, presenting it in the form of an integer. This is why solutions using arbitrary-precision types are encouraged, but not required.

This is a code-golf challenge. Standard loopholes are denied. The program with the least number of bytes wins. If there's a tie, the choice of accepted answer will be at my discretion. That said, this challenge is not only about which answer wins; it's also about seeing how concisely the challenge can be solved in each language, and seeing how each language "prefers" to handle rounding. And for those submissions that choose to use arbitrary precision, it's about seeing how concisely this can be done in the language.

Irregular English Verbs

text-processing string code-golf compression kolmogorov-complexity

Given the infinitive of an irregular English verb, output its simple past and its past participle.

Rules

The input and output can be given in any convenient format.
No need to handle verbs not in the given list.
Either a full program or a function are acceptable. If a function, you can return the output rather than printing it.
If possible, please include a link to an online testing environment so other people can try out your code!
Standard loopholes are forbidden.
This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

Example

fall    --> fell; fallen
beat    --> beat; beaten or beat
bereave --> bereaved or bereft; bereaved or bereft
shall   --> should;(no participle)

List of Irregular Verbs

Infinitive;Simple Past;Past Participle
alight;alighted or alit;alighted or alit
arise;arose;arisen
awake;awoke or awaked;awoken or awaked
be;was or were;been
bear;bore;borne or born
beat;beat;beaten or beat
become;became;become
beget;begot;begotten
begin;began;begun
bend;bent;bent
bereave;bereaved or bereft;bereaved or bereft
beseech;besought or beseeched;besought or beseeched
bet;bet or betted;bet or betted
bid;bade or bid;bidden or bid or bade
bide;bade or bided;bided
bind;bound;bound
bite;bit;bitten
bleed;bled;bled
bless;blessed or blest;blessed or blest
blow;blew;blown
break;broke;broken
breed;bred;bred
bring;brought;brought
broadcast;broadcast or broadcasted;broadcast or broadcasted
build;built;built
burn;burnt or burned;burnt or burned
burst;burst;burst
bust;bust or busted;bust or busted
buy;bought;bought
can;could;(no participle)
cast;cast;cast
catch;caught;caught
choose;chose;chosen
cleave;cleft or cleaved or clove;cleft or cleaved or cloven
cling;clung;clung
clothe;clothed or clad;clothed or clad
come;came;come
cost;cost;cost
creep;crept;crept
crow;crowed;crew or crowed
cut;cut;cut
deal;dealt;dealt
dig;dug;dug
do;did;done
draw;drew;drawn
dream;dreamt or dreamed;dreamt or dreamed
drink;drank;drunk
drive;drove;driven
dwell;dwelt or dwelled;dwelt or dwelled
eat;ate;eaten
fall;fell;fallen
feed;fed;fed
feel;felt;felt
fight;fought;fought
find;found;found
flee;fled;fled
fling;flung;flung
fly;flew;flown
forbid;forbad or forbade;forbid or forbidden
forecast;forecast or forecasted;forecast or forecasted
forget;forgot;forgotten
forsake;forsook;forsaken
freeze;froze;frozen
geld;gelded or gelt;gelded or gelt
get;got;got or gotten
gild;gilded or gilt;gilded or gilt
give;gave;given
gnaw;gnawed;gnawed or gnawn
go;went;gone
grind;ground;ground
grip;gripped or gript;gripped or gript
grow;grew;grown
hang;hung;hung
have;had;had
hear;heard;heard
heave;heaved or hove;heaved or hove
hew;hewed;hewed or hewn
hide;hid;hidden or hid
hit;hit;hit
hold;held;held
hurt;hurt;hurt
keep;kept;kept
kneel;knelt or kneeled;knelt or kneeled
knit;knitted or knit;knitted or knit
know;knew;known
lay;laid;laid
lead;led;led
lean;leant or leaned;leant or leaned
leap;leapt or leaped;leapt or leaped
learn;learnt or learned;learnt or learned
leave;left;left
lend;lent;lent
let;let;let
lie;lay;lain
light;lit or lighted;lit or lighted
lose;lost;lost
make;made;made
may;might;(no participle)
mean;meant;meant
meet;met;met
melt;melted;molten or melted
mow;mowed;mown or mowed
pay;paid;paid
pen;pent or penned;pent or penned
plead;pled or pleaded;pled or pleaded
prove;proved;proven or proved
put;put;put
quit;quit or quitted;quit or quitted
read;read;read
rid;rid or ridded;rid or ridded
ride;rode;ridden
ring;rang;rung
rise;rose;risen
run;ran;run
saw;sawed;sawn or sawed
say;said;said
see;saw;seen
seek;sought;sought
sell;sold;sold
send;sent;sent
set;set;set
sew;sewed;sewn or sewed
shake;shook;shaken
shall;should;(no participle)
shear;sheared;shorn or sheared
shed;shed;shed
shine;shone;shone
shit;shit or shitted or shat;shit or shitted or shat
shoe;shod or shoed;shod or shoed
shoot;shot;shot
show;showed;shown or showed
shred;shred or shredded;shred or shredded
shrink;shrank or shrunk;shrunk
shut;shut;shut
sing;sang;sung
sink;sank;sunk
sit;sat;sat
slay;slew;slain
sleep;slept;slept
slide;slid;slid
sling;slung;slung
slink;slunk;slunk
slit;slit;slit
smell;smelt or smelled;smelt or smelled
smite;smote;smitten
sow;sowed;sown or sowed
speak;spoke;spoken
speed;sped or speeded;sped or speeded
spell;spelt or spelled;spelt or spelled
spend;spent;spent
spill;spilt or spilled;spilt or spilled
spin;spun;spun
spit;spat;spat
split;split;split
spoil;spoilt or spoiled;spoilt or spoiled
spread;spread;spread
spring;sprang or sprung;sprung
stand;stood;stood
steal;stole;stolen
stick;stuck;stuck
sting;stung;stung
stink;stank or stunk;stunk
stride;strode;stridden
strike;struck;struck
string;strung;strung
strive;strove;striven
swear;swore;sworn
sweat;sweat or sweated;sweat or sweated
sweep;swept;swept
swell;swelled;swollen or swelled
swim;swam;swum
swing;swung;swung
take;took;taken
teach;taught;taught
tear;tore;torn
telecast;telecast or telecasted;telecast or telecasted
tell;told;told
think;thought;thought
throw;threw;thrown
thrust;thrust;thrust
tread;trod;trodden
understand;understood;understood
wake;woke or waked;woken or waked
wear;wore;worn
weave;wove;woven
wed;wed or wedded;wed or wedded
weep;wept;wept
wet;wet or wetted;wet or wetted
win;won;won
wind;wound;wound
wring;wrung;wrung
write;wrote;written

So this is a simple lookup, meaning that the bulk of the challenge is compressing the data? — Adám, Jan 24 at 12:48
Shouldn't the correct output from can be could;was able to rather than could;(kein Participle)? — Adám, Jan 24 at 12:49
Up to you. Using (kein Participle) makes the challenge more interesting, as it has the only uppercase character, and the only parentheses. — Adám, Jan 24 at 14:02
@Adám, no. It should be could or was able to or were able to;been able to. It certainly shouldn't be (kein Participle): the spec asks for output in English, not German. — Peter Taylor, Jan 24 at 15:04
@PeterTaylor OP hasn't answered, but to me it looks like lookup KC, so the actual content doesn't actually matter. — Adám, Jan 24 at 16:59
@Adám Yes, I think it's a simple lookup, it can be other than that? — mdahmoune, Jan 28 at 10:39
Imho, it would be much more interesting to take a regular verb as input, and output the past tense: Add "ed" or "d" if verb ends with "e", but change final consonant-"y" to "consonant-"i" and insert "k" if verb ends in "c" and double final consonant if verb ends with a single vowel followed by a single consonant. — Adám, Jan 28 at 13:04
@Adám Do u mean adding the rules, or extending the current list with some regular verbs? — mdahmoune, Jan 28 at 14:00
I meant replacing the list, so the challenge will only concern completely regular verbs. It is of course your choice. I can also post this related (but not really related, just inspired by) challenge myself. Let me know. — Adám, Jan 28 at 14:39
@Adám Using only regular verbs would make it a very different challenge. I think this one is interesting as-is. Even if these verbs are irregular, they do follow some rules of their own (such as i becomes u). You may want to identify and store the transformation rules that are common to several verbs rather than just do string compression. — Arnauld, Feb 5 at 23:21
@Arnauld can I use your comment to improve the text of the challenge? — mdahmoune, Feb 6 at 12:00
Sure. (But maybe you should use a better example than just 'i becomes u' and make it clear that this is not a general rule but just a rule that applies to several verbs.) — Arnauld, Feb 6 at 13:53

lirtosiast · Accepted Answer · 2019-01-31 01:13:26Z

2

Generate a 3D spiral

Inspired by this chat message

The spiral used in The Path Of The Wildebeest is a contiguous mapping of the positive integers to lattice points in 2D. Your task is to generalize this to 3D.

Specifically, create a function \$f\$ from \$\mathbb Z^+\$ to \$ \mathbb Z^3\$ with the following properties:

\$f\$ is a bijection (All points are eventually reached).
\$f(1) = (0,0,0)\$ (The spiral starts at the origin).
\$ |f(n+1) - f(n)| = 1\$ (The spiral is contiguous).
The Chebyshev distance from the origin \$ |f(n)|_\infty \$ is a nondecreasing function (\$f\$ fills all points in each concentric cubical shell \$k\$ before moving to shell \$k+1\$).

One possible \$f\$ is given by this Python implementation, but any \$f\$ that satisfies the above properties is allowed. Please describe the function your answer generates.

Because all your computer's memory is taken up by the wildebeest simulation you're running, typing is very slow, so your code must be as short as possible.

I/O

As is standard with sequence questions, either 1-indexing or 0-indexing is allowed. Any of these I/O formats are acceptable:

Receive \$n\$ as input and output the \$n\$th point in the sequence
Receive \$n\$ as input and output the first \$n\$ points
Take no input and output the sequence infinitely.

edited Jan 31 at 1:13

answered Jan 29 at 20:25

lirtosiast

19.2k19 silver badges26 bronze badges

\$\begingroup\$ Editing this from "is an increasing function" to "is a nondecreasing function" doesn't fix the problem... the function will sometimes have to decrease, because it has to hop over its own path and come back down. If you're already taking this into account, could you please be clearer about what you mean? \$\endgroup\$ – Deadcode Jan 30 at 1:40
\$\begingroup\$ @Deadcode I'm not sure what you mean by hopping over its own path. This challenge is just to generate the spiral, not the path of any chess piece. \$\endgroup\$ – lirtosiast Jan 30 at 1:45
\$\begingroup\$ Okay, imagine an actual ball of yarn. But to simplify things, let's imagine you start with a sphere. Start wrapping a string around it. After you make 1 revolution, you must adjust the angle of the string so that it crosses over its previous path. This will make a small bump in the path the string takes on its 2nd revolution. And on its 3rd revolution, there will be more bumps. Now imagine the analogy with a cube, quantizing the path to a cubical grid. The 2nd revolution will have to cross over the path the 1st revolution took, making a bump, 1 up, 1 down. \$\endgroup\$ – Deadcode Jan 30 at 1:56
\$\begingroup\$ I think in the cubical case, the path of the yarn can be arranged such that it never goes over bumps. \$\endgroup\$ – lirtosiast Jan 30 at 1:58
\$\begingroup\$ Okay, but then it will bear much less resemblance to a ball of yarn. \$\endgroup\$ – Deadcode Jan 30 at 2:04
\$\begingroup\$ @Deadcode the key point here is that it's the Chebyshev distance that's non-decreasing. So the 3d lattice is divided into cubic shells centered on the 0 point, and the function has to map to all of the points in shell n before moving on to shell n+1 \$\endgroup\$ – trichoplax Jan 30 at 21:37
\$\begingroup\$ (in that sense it's analogous to the 2d case) \$\endgroup\$ – trichoplax Jan 30 at 21:41

add a comment |

mdahmoune · Accepted Answer · 2019-02-01 17:11:59Z

2

Countries by Area

edited Feb 1 at 17:11

answered Apr 19 '18 at 13:24

mdahmoune

1,6802 silver badges5 bronze badges

\$\begingroup\$ You can remove the backticks before and after the list then select it and press Ctrl + K, it will show as a single block of code then \$\endgroup\$ – RedClover Apr 19 '18 at 13:59
\$\begingroup\$ @user202729 This isn't a KC because an answer to the challenge should accept inputs. \$\endgroup\$ – Shieru Asakoto Nov 19 '18 at 8:05

add a comment |

pizzapants184 · Accepted Answer · 2019-02-21 07:43:00Z

Least efficient field order

Background:

In C and other languages, a struct is a data type composed of fields of other data types. These fields may be different sizes (in bytes) and may have different alignment requirements (e.g. an int field may need to be on a 4-byte boundary).

Padding is added to a struct to keep all of its fields aligned, and to keep its size a multiple of each field's alignment.

For example:

struct test {
    char  a; // 1-byte, 1-byte aligned
    short b; // 2-byte, 2-byte aligned
    int   c; // 4-byte, 4-byte aligned
}

In this struct, there will be 1 byte of padding after a (to keep b on a 2-byte boundary), no padding after b (as c is already on a 4-byte boundary) and no padding after c (as the size is already a multiple of 2 and 4 bytes), so the total size of the struct is 8 bytes (1 + 2 + 4 + 2). However, if we rearrange the order of the fields, the struct size can be bigger.

struct test_2 {
    char  d; // 1-byte, 1-byte aligned
    int   e; // 4-byte, 4-byte aligned
    short f; // 2-byte, 2-byte aligned
}

In this struct, there will be 3 bytes of padding after d (to keep e on a 4-byte boundary) and there will be 2 bytes of padding after f (to keep the size a multiple of 2 and 4 bytes), so the total size of this struct is 12 bytes (1 + 4 + 2 + 3 + 2).

Challenge:

Given a list of pairs of positive integers (each pair representing the size and alignment of a field), return the same pairs in an order such that a struct with fields in that order would require the most padding, i.e. be the least space-efficient.

Givens:

A field's size will always be greater than or equal to its alignment. (e.g. (4, 8) is not a valid input pair)
A field's size will always be a multiple of its alignment. (i.e. (12, 5) is not a valid input pair)

Test cases: (other outputs that give the same total size are valid as well)

[(1, 1), (1, 1), (4, 4)] -> [(1, 1), (4, 4), (1, 1)] # size 12
[(12, 4), (1, 1), (2, 2), (8, 8)] -> [(12, 4), (8, 8), (1, 1), (2, 2)] # size 32
[(7, 7), (5, 1), (2, 2)] -> [(7, 7), (2, 2), (5, 1)] # size 28
[(6, 6), (6, 3), (4, 2), (2, 2)] -> [(6, 3), (4, 2), (6, 6), (2, 2)] # size 24
[(1, 1)] -> [(1, 1)] # size 1

Test case checker online!

I think in your explanation (1 + 2 + 4 + 2) should be (1 + 2 + 4 + 1). The only thing I see about this challenge that is questionable is whether having separate alignments is interesting or tedious. Would this lose much by assuming each field's alignment is equal to its size? — FryAmTheEggman, Feb 25 at 21:25

J. Sallé · Accepted Answer · 2019-03-14 19:32:57Z

The Minigame Challenge

cops-and-robbers code-golf

The idea of this CnR is fairly simple: The Cops must create a simple minigame (explained in more detail below), with a definite goal. That goal may or may not be achievable. The Robbers must then either complete the minigame, or prove its goal is not achievable.

Rules

The Minigame

The Cops will create a suitably simple minigame with a definite goal.

Acceptable minigame examples are functions that take some input and return some output, with the goal being to either achieve a specific output, or make the program terminate or error.

Minigames considered complex (and thus unnacceptable) would be programs/functions that will never terminate in up to 60s (using TIO as a benchmark here), or that simulate complex games (such as blackjack, chess, etc).

Note: I'll try to expand further on what kinds of minigames are acceptable or not. Suggestions are appreciated.

Cops:

The Cops must provide one of the following:

A solution for your minigame that achieves the goal, or
A proof that the goal for your minigame is not achievable.

at least 7 days (168h) after the answer was posted for their answer to be considered safe.

If your minigame's goal is achievable, it must always be achievable, and it must not contain "insider information", such as a fixed seed for a pRNG, or pregenerated primes as factors of a number to be factored.

Robbers:

To crack an (unsafe) answer, the robber must provide either a solution to the minigame that achieves the stated goal, or a proof that the goal is not achievable.

Scoring:

Cops will be scored based on standard code-golf rules, with the fewest number of bytes in an answer being better. Cracked answers will always have a score of \$\infty\$.

Robbers are scored according to the number of answers they've cracked.

Standard loopholes are, as usual, forbidden.

Challenge is still under construction

This is the first CnR I've ever come up with. Suggestions and observations are always appreciated.

\$\begingroup\$ This seems a lot like PCG inside PCG. \$\endgroup\$ – Beefster Mar 15 at 19:16 — Beefster, Mar 15 at 19:16

Hazard · Accepted Answer · 2019-03-24 22:39:22Z

Challenge

Create a function takes in two 2-dimensional arrays of Characters (or Strings if the programming language does not have characters as a datatype) as inputs: a and b.

Your task is to determine if b contains a. If this is so, return true. Otherwise, return false.

Sample Test Cases

a:

123
456
789

b:

123
456
789

should return true.

a:

code
golf

b:

thisis
code!!
golf!!
ohyeah

should return true.

a:

abcd
efgh
ijkl

b:

abcdef
ghijkl
mnopqr

should return false.

Least bytes wins.

does the block need to be as-is? No lines inbetween? No characters? i.e. does code\golf appear in `code!!\trucking!!\golf!!`? — Ven, Mar 25 at 11:04

attinat · Accepted Answer · 2019-03-27 19:39:43Z

(No title yet)

statistics

I'm traveling away from home, and while visiting a fair a dart-throwing game catches my eye.

To play, I can buy \$d\$ darts at a time. There are no other options for purchase.

There are \$t\$ identical targets, but since I'm not a great shot, I can't consistently aim at just one. Instead, I can hit one (at random) with nonzero probability \$p\$.

Of course, ~~just to make it harder for me~~ management also decided it would be too easy if players won a prize immediately upon hitting a target. Rather, I need to hit the same target \$n\$ times in order to get the prize. As long as I keep playing, darts that have already landed on targets will remain there, but if I leave, they will be reset.

I'd rather not be scammed though, so I would like to know how many times I should expect to purchase darts in order to win at least one prize.

Task

Given \$d\$, \$t\$, \$p\$, and \$n\$, find the expected cost for me to get at least one prize.

Test cases

(just some basic ones, for now)

  d,  t,  p,  n  -> E

 __, __, __,  1  -> 1/(1-(1-p)^d)
 __, __,  1, __  -> t*n

Comments

Any suggestions to improve wording or formatting? Is anything unclear or confusing?

Would it be more interesting to ask for the expected cost to get at least \$x\$ prizes, instead? In that case, a target would award a prize for every \$n\$ darts landed, i.e. at \$n,2n,3n,\ldots\$ darts.

What level of accuracy should be required?

Ideas for test cases?

Not entirely sure what other tag(s) I'd like to work with here. Golf should be interesting... I'd also like to see faster solutions though, and I would expect golfy solutions to be very inefficient.

Don Thousand · Accepted Answer · 2019-03-28 15:08:37Z

Finding Points in Convex Hulls

Convex hulls are notoriously hard to deal with, so today's challenge will deal with a relatively simple premise: given a convex hull defined by a set of points, and an additional point, find whether the additional point lies in the hull.

Now, for some definitions

The convex hull of a finite set X, a subset of R^n, is the set of convex combinations of points of $X$.
A convex combination of points x1,x2,...,xn is a point of the form a1x1+a2x2+...+anxn such that all ai>=0 and the sum of all of the ai is 1.

Input/Output

The input is rather flexible, as long as it contains the appropriate information to express the convex hull and additional point.

An example of a valid input format to express the convex hull represented by (0,1,2),(4,3,2),(8,8,8) and the point (5,5,5) is

([(0,1,2),(4,3,2),(8,8,8)],(5,5,5))

The output is a truthy/falsy value, depending on whether the point is contained in the hull.

Remarks

There are a lot of packages and libraries that deal with convex hulls, such as scipy.spatial. Such libraries/packages are explicitly banned. Libraries that facilitate matrix computations, such as numpy, are permitted.

The winning criterion is code-golf.

There is no limit on the number of dimensions the points can lie in, as long as they all lie in the same number of dimensions.

Test Cases

I will be using the following tio link for testing the validity of solutions.

Some smaller test cases:

([(1,1)],(1,1)) - True
([(1,1)],(1,2)) - False
([(1,1,1),(3,3,1)],(2,3,1)) - False
([(1,1,1),(3,3,1)],(2,2,1)) - True
([(0,0),(3,3),(0,6)],(2,4)) - True
([(0,0),(3,3),(0,6)],(1,1)) - True
([(0,0),(3,3),(0,5)],(2,4)) - False

Questions for Sandbox

Is code golf the best criteria for this? That might encourage brute force searches on every combination of points... any suggestions?

You mention R^n but all the examples use Z^n (which is much easier to work with computationally). Please clarify the expected input. Also, what about libraries for linear programming? — Peter Taylor, Apr 1 at 10:03
@PeterTaylor I was thinking of making it R^n only, since one can bash out the answer if it is in Z^n. And, linear programming libraries probably also should be banned. — Don Thousand, Apr 1 at 13:08
I'm not sure how easy it is to bash out the answer. The weights could be rational, and it's not obvious to me that the denominators can be bounded because the entire system can be translated. — Peter Taylor, Apr 1 at 20:35

Jonah · Accepted Answer · 2019-04-13 17:40:01Z

This is a post to pre-test for a duplicate question before I spend the time to finish the full post and add test cases.

So, have we ever had a question for a "snake rotation" of a matrix:

    +--------------+
      1  2  3  4  5|
    +------------  |
    |10  9  8  7  6|
    |  +-----------+
    |11 12 13 14 15
    +--------------+


    +--------------+
-->  13 14 15  1  2|
    +------------  |
    | 7  6  5  4  3|
    |  +-----------+
    | 8  9 10 11 12  -->
    +--------------+

The ascii walls are there only for clarity. Actual input/output would be normal matrices

l4m2 · Accepted Answer · 2019-05-11 14:17:01Z

2

Reverse RegEx

Take a regex a as input, output a regex b such that, for each string x, x matches a iff x.reverse matches b

Sample Input    Sample Output
/abcd/          /dcba/
/[^abc]/        /(?!a)[^bc]/
/[^abc]/        /[^abc]/
/(.)abc\1$/     /^(.)cba\1/
/$1/            /10% of $10/
/\123/          /S/

Shortest code win

TODO: List of allowed RegEx features, mainly if (?<=xxx) is allowed

edited May 11 at 14:17

answered May 10 at 8:45

l4m2

4,9302 silver badges11 bronze badges

2

\$\begingroup\$ What's the regex flavor/set of allowed features/inputs? Is it for a full or partial match? \$\endgroup\$ – feersum May 10 at 9:07
\$\begingroup\$ @feersum Allowed features need discuss. To be a full match ^ and $ can be added \$\endgroup\$ – l4m2 May 10 at 9:21
\$\begingroup\$ Why is test case /[^abc]/ there twice? Or is it to give two different example outputs? Since just outputting /[^abc]/ for input /[^abc]/ would be fine. Also, I'm not too familiar with this Regex syntax, but how does /$1/ work, since $ is the end of the match? And why is it /10% of $10/ reversed? \$\endgroup\$ – Kevin Cruijssen May 10 at 9:27
\$\begingroup\$ @KevinCruijssen twice to show that same input may lead to different output. /$1/ and /10% of $10/ both match nothing \$\endgroup\$ – l4m2 May 10 at 9:32
\$\begingroup\$ "both match nothing" Ah ok.. I falsely assumed the regex would match something. So incorrect (but still valid) regexes are also allowed as input. Maybe it's a good idea to add some comments to the sample outputs, like /10% of $10/ can be anything as long as it doesn't match anything (and maybe put the /(?!a)[^bc]/ or /[^abc]/ for the same input on one line. \$\endgroup\$ – Kevin Cruijssen May 10 at 9:37
2

\$\begingroup\$ You should more rigorously explain what x.reverse means, from the examples it looks like you mean the order of letters is reversed, but some people might be confused. \$\endgroup\$ – FryAmTheEggman May 11 at 21:28

add a comment |

Stewie Griffin · Accepted Answer · 2019-05-22 06:59:30Z

2

WordArt reader

I've decided to leave this very open ended, so that I can write it based on community input. There are a lot of questions in the bottom. All feedback is appreciated, even minor suggestions/comments. :)

image-processing,classification,code-challenge.

Did you know WordArt is still a thing in MS Word? Let's parse it!

^{(I'll remove the Swag format)}

The challenge will contain a test battery with X jpg.files each with a word or sentence shown in WordArt. Your task is to parse as many as you can. The winner will be the submission that correctly parses the most images, with date stamp being the tie breaker.

Sandboxing:

Good idea or not?
Should there be many different styles, or should I stick to one? Colors? Shade/mirroring?
How many test cases?
Is jpg the best format (it was used in the Upgoat/Downgoat challenge)
Should I have a more refined scoring mechanism? It's hard to mix two quantities into one score.
Should I stick to just letters / alphanumeric / all printable ASCII / multiple lines? Long sentences or single words?
Orientation? Waves? Circular?
Resolution?
Builtin functions?
Should I require a complete match of images, or character by character?

edited May 22 at 6:59

answered Nov 7 '17 at 16:37

Stewie Griffin

29.3k10 silver badges28 bronze badges

\$\begingroup\$ Nice challenge! 1 WordArt is a completely objective (good) definition. 2 Some of the questions was mainly for the problem of the challenge being "too hard", so if you want any answer at all you should simplify those. (somehow most PPCG users are lazy). 3 Format is not a very important problem (conversion is easy), but just to be sure, use a lossless format. \$\endgroup\$ – user202729 Nov 7 '17 at 16:48
\$\begingroup\$ There is another problem of the font used. \$\endgroup\$ – user202729 Nov 7 '17 at 16:49
\$\begingroup\$ The challenge is supposed to be hard. Scoring based on the success rate would be useless if not. But it's of course possible to change the scoring, and make the test cases easier. \$\endgroup\$ – Stewie Griffin Nov 7 '17 at 17:00
4

\$\begingroup\$ 1. optical-char-recognition. 2. Upgoat/Downgoat used JPG because it used photos. IMO it's preferable in general to allow any raster image format, because otherwise you pretty much force people to use languages with library support for image decoding. 3. The "Swag" example is ambiguous: is it "Swag Swag"? 4. If you want to refine the scoring mechanism, I would do it as the sum of Levenshtein distances from the correct results. But the big problem with scoring test-battery is the tension between keeping the tests secret (to prevent overfitting) and public (for objective scoring). \$\endgroup\$ – Peter Taylor Nov 8 '17 at 7:25
1

\$\begingroup\$ 3. I can avoid the Swag-type format. Are the other formats unambiguous? 4. I can either show all the possible formats, and say that I will use words that are say 4-15 characters, or maximum 15 characters per example. I can then pre-select the input list, and provide a hash that ensures I won't change the input list after answers are posted. People can then try their code on some random strings of their own choosing on various formats and approximate their results, while the final score is made public later...? \$\endgroup\$ – Stewie Griffin May 22 at 6:43
\$\begingroup\$ Thanks for the link to the other challenges, they are useful as references when writing this challenge. Do you think this is different enough by the way? \$\endgroup\$ – Stewie Griffin May 22 at 6:58

add a comment |

Pika the Wizard of the Whales · Accepted Answer · 2019-05-23 23:37:24Z

How many right triangles can you find?

code-golf math

Challenge

You will be given an input represented by x, which is a string containing at least 3 characters. It will consist only of the standard numeric characters, 0 through 9. Your job is to find and output how many right triangles can be formed with the given numbers.

Rules

Numbers must be kept in the order they were given in. No mixing them up!
The numbers for each right triangle must be consecutive.
The order of numbers has to be a first, b second, and c third, and must satisfy the formula a² + b² = c². a can be greater than or less than b, as long as it satisfies the formula.
Decimal points may be added between any numbers.
Decimals require one or more numbers to be placed before them, e.g. .5 cannot be used as a number but 0.5 and 12.5 can.
Decimals with at least 4 digits after the decimal point truncated to the third digit, e.g. 1.2345 would truncated to 1.234 and 1.9999 would be truncated to 1.999.
Numbers can be used more than once in 2 or more different triangles, but cannot be used multiple times in the same triangle.
Multiple representations of the same value can count multiple times.
Repeating zeros are allowed, e.g. 000.5 counts as a number.
All possible combinations must be taken into account for your program to be valid.

Example Inputs and Outputs

Input: 345
Output: 1
This can be split into 3, 4, and 5, which, of course, form a right triangle.

Input: 534
Output: 0
While this does include the necessary numbers to form a right triangle, they are not in the correct order. It has to follow the formula a² + b² = c², but in this case it follows c² = a² + b². The order of numbers cannot be changed from the original input, so in this case no right triangles can be formed.

Input: 3415
Output: 0
This does contain a 3, 4, and a 5, which can form a right triangle, but they are not consecutive; there is a 1 splitting the 5 from the 3 and 4.

Input: 5567507
Output: 1
Because decimals can be added anywhere, it can be changed to 55.67.507, which allows splitting it into 5, 5.6, and 7.507 to form a right triangle. Remember that decimals are truncated to the third digit after the decimal point, which is how we get 7.507.

Input: 345567507
Output: 2
The first right triangle is formed by 3, 4, and 5. The second one is formed by 5567507 (read the previous example for explanation). Numbers can be used more than once, so the first 5 was used in the first and second triangles.

Input: 51125
Output: 0
Because of rule 5, you cannot use .5, 1, and 1.25. An integer is required before .5 for it to work.

Input: 051125
Output: 0
Unlike the previous example, there is a number before the first 5, so it is now legal to use 0.5, 1, and 1.25.

Input: 121418439
Output: 2
The numbers 12 and 14 would form a right triangle where side c has a length of approximately 18.43908891458577462000. Because long decimals are truncated to the third digit after the decimal point, we would be left with 18.439. This fits in with the original input, 121418439. Additionally, 1.2, 1.4, and 1.843 counts as a separate combination, thus giving us our second right triangle.

Input: 10011005
Output: 8
Numbers count separately if they're represented in different ways, so this allows for (1, 00, 1), (1.0, 0, 1), (1, 0, 01), (1, 0.01, 1), (1, 0.01, 1.0), (1, 0.01, 1.00), (1.0, 0.1, 1.005), and (1, 00.1, 1.005).

This is code golf, so shortest answer in bytes wins. Good luck!

So if I understand correctly we do the following things: get all substrings of the input; get all 3-part partitions of each substring; insert a comma at each possible position in each possible partition; check any combination of three in order is approximately truthy for \$a^2+b^2=c^2\$ (approximately, because the decimals have been truncated, so aren't exactly a right triangle in some cases). Do I understand this correctly? — Kevin Cruijssen, May 8 at 7:07
@KevinCruijssen almost correct, except you must find all combinations both with and without decimals at any given location. So it's not necessarily just adding a decimal point at every possible place; it's checking the results that would occur both by adding and not adding a decimal. — Pika the Wizard of the Whales, May 8 at 14:19
"Numbers can be used more than once." - Could you provide some examples of this or otherwise clarify what you mean? — Beefster, May 10 at 19:52
@Beefster see the fifth example: one of the 5's is used to form two different right triangles. — Pika the Wizard of the Whales, May 10 at 19:57
Perhaps a better way to explain it would be something like "Right triangles that only use a subsequence of the digits can overlap with other triangles made from the same sequence of digits" or "You do not need to use all the digits for a single triangle and you may re-use digits that were used in previous triangles". What confused me about the way it's currently written is that it could be taken to mean that you can re-use a digit for the same triangle, so 125059 could be split into 12, 22, 25.059. — Beefster, May 13 at 22:45

Shieru Asakoto · Accepted Answer · 2019-05-29 08:33:29Z

\$n\$-Chess KotH king-of-the-hill grid chess board-game

Introduction

Inspired by the challenge N-movers: How much of the infinite board can I reach?, I came up with an idea of applying the \$n\$-mover rules in chess.

\$n\$-Chess™ is a board game played on a 8x8 grid like the original chess. However, the pieces are very different from chess - they are named \$n\$-movers (\$n\$ can be any natural number) and can only move by the rules set on them (see Rules: Pieces).

Rules

Pieces

In \$n\$-chess, a piece is called an \$n\$-mover, where \$n\$ denotes its possible movements. Specifically:

The \$n\$-mover can only move one step of Euclidean distance \$\sqrt n\$ each time, i.e. for a move with \$x\$ units horizontal and \$y\$ units vertical, \$x\$ and \$y\$ must fulfill the equation \$x^2+y^2=n\$ in order to be valid.
- For example, a 5-mover can only move 1 unit in one direction and 2 units in the another at the same time; while a 25-mover can move 5 units in either direction, or 3 units in one direction and 4 units in the another at the same time.
A piece can have at most 2 rules set at the same time. For a piece that can act as either an \$m\$-mover or an \$n\$-mover, we can call it an \$(m,n)\$-mover. An \$(m,n)\$-mover is allowed to move one step of Euclidean distance of either \$\sqrt m\$ or \$\sqrt n\$ or \$\sqrt{m+n}\$.
- It is allowed to have \$m=n\$.
- Only pieces that has captured other pieces can have multiple rules (See Rules: Capture).
If more than 2 rules are set on a piece, only 2 rules can be reserved. You can choose which 2 rules to reserve.

Board

The chess is played on a 8x8 board. The initial setup is as follows: Initial board setup

Capture

If a piece lands on a grid that an opponent piece has occupied (capture), that opponent piece shall be moved away from the board.
After that, the piece will be granted rules from the captured opponent piece. As stated in Piece, if there are more than 2 rules in total, only 2 shall be reserved.

Playing

In a turn, White and Black play a move in turn. White always moves first.
Only one piece can be move per turn.
You cannot move a piece in the way that is not allowed by the rules set on it, beyond the boundaries of the board, or onto a grid already occupied by your other pieces.
You cannot move your last piece in the way that after moving it it can be captured instantly.

Victory Condition

The game ends with either player winning if:

The last piece of the opponent is being checkmated, i.e. no possible moves that can save this last piece from being captured; or
The opponent resigns and loses. (In this challenge, no resignation will be allowed)

The game ends with a draw if :

No checkmate is possible for both sides;
Either player has no more possible moves, but is not in checkmate;
There is no capture in 50 moves; or
The identical board arrangement has appeared 3 times with the same player to move.

Implementation

A player bot is a class that implements a function nextMove(). This function receives 3 arguments and output an array of 6 integers:

function nextMove(
    color: int,                    // Your color: 0 = white, 1 = black
    board: int[8][8][3],           // Current board:
                                   //  First index: x-coordinate
                                   //  Second index: y-coordinate
                                   //  The third layer will be as follows - 
                                   //   [0]: the color of the grid
                                   //       (-1: Not occupied; 0: white; 1: black)
                                   //   [1]: rule 1 (0 if not exists)
                                   //   [2]: rule 2 (0 if not exists)
    moves: int[][10]               // Previous moves:
                                   //  First index: move number (0-indexed)
                                   //  The second layer will be as follows - 
                                   //   [0]: the color of the player
                                   //   [1]: is this a capture (0: no, 1: yes)
                                   //   [2]: source x-coordinate
                                   //   [3]: source y-coordinate
                                   //   [4]: source rule 1
                                   //   [5]: source rule 2 (0 if not exists)
                                   //   [6]: target x-coordinate
                                   //   [7]: target y-coordinate
                                   //   [8]: target rule 1
                                   //   [9]: target rule 2 (0 if not exists)
): int[6]                          // Return value: as follows:
                                   //  [0]: source x-coordinate
                                   //  [1]: source y-coordinate
                                   //  [2]: target x-coordinate
                                   //  [3]: target y-coordinate
                                   //  [4]: target rule 1
                                   //  [5]: target rule 2 (0 if not exists)

Rule 1 and Rule 2 denotes the 2 rules a piece has.
Source rule entries are used to denote which rules a piece has, while target rule entries are used to denote which rules are decide to keep.

You may use JavaScript, pseudo-codes, or any languages similar to JavaScript, but using JavaScript is strongly encouraged, because all submissions will be translated to JavaScript before using for competition, and the test drive only supports JavaScript.

Restriction

Standard loopholes are forbidden by default.
You cannot by any means read or modify other bots. You can only use data within the class and inputs passed to nextMove() function.
You may define other variables inside your class if needed.
You may use a random number generator.
Your bot, specifically the nextMove() function, must return value in 10 second per move. Timeout leads to disqualification.

Procedure

Round-robin will be used to determine the opponents, i.e. all bots will face each of the other bots twice, one as black and one as white. For each game, a win gets 2 points, a lose gets 0 points, and a draw gets 1 points.

The bot will the highest points wins, and if there are any ties, they will be broken by:

Number of victories;
Average time to checkmate opponent (shorter is better); and
Drawing lots. (Hopefully this step is not necessary)

TODO

Add a sample implementation.

KISS: since I assume that this is actually a game you've made up for the question, why not ditch checkmate and make the win condition that you capture all of the opposing pieces? I'm not sure about n-Chess™ for a name, either: it feels more like checkers than chess to me. — Peter Taylor, May 29 at 16:34
@PeterTaylor I'd say the question I had my inspiration from had its inspiration from chess, so I chose chess, and tbh I don't even know what checkers is until I've googled it right now. Well, it does look like checkers in the way capturing occurs, but I think I need to borrow some rules from chess, especially the ending rules, because I need to draw a line if the game never ends. Anyway thanks for your useful feedback! — Shieru Asakoto, May 30 at 2:41

5 revs · Accepted Answer · 2019-06-28 15:50:40Z

Proposed alternative to this

Golf an H interpreter

H is a text-based, weakly-typed string concatenation language. You task is to run an H script. You may do so by creating an interpreter, a compiler, a transpiler, or by any other reasonable means.

Definitions

Anything not defined herein is undefined behaviour and your implementation does neither have to support it nor does it need to throw an error. This includes unmatched quotes, invalid escapes, usage of variables before definition, etc. All given H scripts will abide by all the rules as stated.

General H syntax

Scripts: One or more lines, each containing zero or more statements, optionally followed by a comment.

White-space: you only have to support spaces in strings (tabs are escaped), plus tabs and/or spaces leading up to a comment.

Operators: There's only one, +, which is string concatenation.

Comments begin with # and continue until the end of the line. # may be prefixed by one or more spaces and/or tabs.

name: a sequence of exactly 4 single-case ASCII letters [A-Z] or [a-z] (you decide the scheme)

value: a +-delimited sequence of one or more strings (see below) and/or previously defined names. The combined value will never exceed 1000 characters.

Strings

Opened and closed by " and support ASCII 32–126 but with the following escape sequences:

\\: the literal backslash character; \

\n: a line break; CR, LF, CRLF, or LFCR (you decide)

\": a quotes symbol; "

\t: a tab character; (HT) or 2, 4, or 8 spaces (you decide)

A string matching the regex 0|-?[1-9]\d?\d? (i.e. look like an integer) may be left unquoted.

Statements

Terminated by ; but may not span multiple lines. There are only three types of H statements:

def name=value; sets the variable name to the given value.

print(value); prints value without trailing line break.

input(value;name); prints value without trailing line break, allows the user to enter a sequence of characters that extend that line, and assigns the characters to name. Any subsequent output begins on the next line.

Test script

The following assumes you have decided on the uppercase variable name scheme:

def HELO="Hello, ";
def HSMO=HELO+"strange"+-1;print("");
input(HSMO+"what is your name?";NAME);         #enter "User A" via stdin
#print(-123)   # nope
print(HELO+"\""+NAME+"\"\n\tthis isn't APL\\"+360+"!");

#done
print(-12+34)	# note the tab before #

Here is the equivalent using a lowercase variable name scheme:

def helo="Hello, ";
def hsmo=helo+"strange"+-1;print("");
input(hsmo+"what is your name?";name);         #enter "User A" via stdin
#print(-123)   # nope
print(helo+"\""+name+"\"\n\tthis isn't APL\\"+360+"!");

#done
print(-12+34)	# note the tab before #

Running the appropriate script, and entering User A should, according to the scheme where \t means ASCII 9 (HT), leave the console/screen/window showing:

Hello, strange-1what is your name?User A
Hello, "User A"
	this isn't APL\360!-1234

If instead you decided that \t means four spaces, it should show:

Hello, strange-1what is your name?User A
Hello, "User A"
    this isn't APL\360!-1234

code-golf interpreter compiler string interactive

You may want to explicitly state that User A is the STDIN-input in the Test script. I must admit I just can't read and read past the explanation of input(value;name); when going through the test script and was thinking: where is def name="User A";. And based on "Anything not defined herein is undefined behaviour and your implementation does neither have to support it nor does it need to throw an error." we can assume all scripts are valid, so no " that are unmatched, and no variable used before it is defined, and stuff like that? — Kevin Cruijssen, Jun 28 at 13:45
Perfect. :) I had already upvoted I see. Everything is clear to me now. — Kevin Cruijssen, Jun 28 at 16:40
@UserA No. There is an overwhelming consensus that one should avoid bonuses in code golf. — Adám, Jul 3 at 13:23
@UserA It is very probably that many of the solutions will allow all of those any way. — Adám, Jul 3 at 13:24

Erik the Outgolfer · Accepted Answer · 2019-07-10 17:49:16Z

Multi-Digit × Single-Digit Checker code-golf arithmetic

Introduction

The story below is fictional, don't worry.

Times table hard. More curriculum. Class advance. Son behind. Horror. Help.

ahem Pardon me.

So... I've got a big problem. The times table is huge, and all the mnemonic rules we've taught our son haven't make him fully memorize it yet. However, his class must advance to the next chapter, long multiplication. As a result, he is prone to making many mistakes while multiplying numbers.

See, they're already making the students multiply a multi-digit number by a single-digit number. My son often forgets to carry digits over and, of course, his times table. The good thing is that he never misses digits!

The situation is awful. Help me before they start with two multi-digit numbers!

Challenge

Your challenge is to write a program that takes a multiplier, a multiplicand and a product, and analyzes the product for any of the following mistakes. Here's how:

If a digit is the correct ones digit of the product of the multiplicand times the digit of the multiplier he's currently multiplying, but a non-zero carryover was supposed to be added to it, then this digit has a carryover error.
If a digit is otherwise wrong, there's a times table error around it (we can't be sure if the ones digit was wrong or a carryover digit was wrong), so it has a times table error.
There will never be another kind of mistake in the product, my son doesn't skip digits.

For each wrong digit, return an array of two or three elements:

Position of the digit from the left or right, 0- or 1-indexed (your choice must be consistent). Keep in mind that, if the leftmost digit is absent due to a carryover error, then it's still the leftmost digit and the place has the relevant index.
Correct carryover, if the mistake was a carryover error, or omitted otherwise. You may also put a 0 instead of omitting the element (you can't blame my son for forgetting to add a zero carryover!), but be consistent.
Correct digit.

Rules

The numbers will all be positive integers.
The multiplicand will be an integer from 1 to 9, inclusive.
You can get the three numbers via any reasonable way you want.
The output can be in any order, as can the elements of each array, as long as the latter is consistent.
You may not make use of any standard loophole.
This is a code-golf challenge, so the shortest answer, measured in bytes, wins.

Test cases

Multiplier, Multiplicand, Product -> Mistakes (0-indexed from the left, possibly absent carryover)

5, 3, 15 -> [] (15)
3, 5, 5 -> [[0, 1, 1]] (05 -> 15)
7, 3, 31 -> [[0, 2]] (31 -> 21)
1551, 9, 4959 -> [[0, 1, 1], [1, 4, 3]] (04959 -> 14959 -> 13959)
2121, 7, 14847 -> [] (14847)
2121, 7, 4727 -> [[0, 1, 1], [2, 1, 8], [3, 4]] (04727 -> 14727 -> 14827 -> 14847)
33333, 9, 11111 -> [[0, 2, 2], [1, 9], [2, 9], [3, 9], [4, 9], [5, 7]] (011111 -> 211111 -> 291111 -> 299111 -> 299911 -> 299991 -> 299997)

Sandbox

Is the challenge unclear?
Is the output format weird or too strict?

I think it's a pretty interesting challenge! My only nitpick is in the introduction, when you're bringing up 'My son makes these mistakes:': make this section a bit more formal/a bit less story-level detail. The rest of the introduction is funny and gives some good context, but while reading the challenge I was kind of thrown off by the unnecessary detail in that section, e.g 'Ah, the crux of my worries.' — Geza Kerecsenyi, Jul 9 at 21:25
@GezaKerecsenyi That might be because those were part of the challenge text before I decided to move it all to the Challenge section. I'll shorten them to one sentence. EDIT: I've removed that part. — Erik the Outgolfer, Jul 9 at 22:01
Also, I think that making the carryover optional is quite confusing, and it also means that you have to check if it was a carryover error just to know whether to output it or not. I would suggest to make them always give the correct carryover or 0, even if it wasn't a carryover error. — Geza Kerecsenyi, Jul 10 at 7:46
@GezaKerecsenyi I'm giving two options for times table errors, either exclude the carryover or make it 0. The answerer can choose one of the two consistently. Do you think there's an issue with the first one? — Erik the Outgolfer, Jul 10 at 17:48

Esolanging Fruit · Accepted Answer · 2019-07-11 22:13:16Z

2

Sandbox Notes

Any other/better tags?

Is my math right?

Knot Function

code-golf knot-theory function

TL;DR: Define a closed curve in 3D space that forms a knot.

A function \$f : [0,1] \to \mathbb R^3\$ is considered a loop function if the following conditions hold:

It is continuous.
\$f(0) = f(1)\$.
It is injective everywhere else.

Intuitively, this means that the function traces out a curve in 3D space that does not intersect itself.

Let the set of loop functions be denoted \$\text{Loop}\$. One such function is \$\text{circle}(t) = (0, \sin 2\pi t, \cos 2\pi t)\$, which traces out a circle in 3D space.

A function \$f : \text{Loop}\$ is considered a knot function if there exists no continuous function \$d : [0,1] \to \text {Loop}\$ such that \$d(0) = f\$ and \$d(1) = \text{circle}\$. Intuitively, this means that the loop that the function traces out cannot be continuously deformed into a circle without intersecting itself.

The Task

Write a program or function that implements a knot function, where real numbers are replaced with (to best approximation) floating point numbers.

This is code-golf, so the shortest valid answer (measured in bytes) wins.

edited Jul 11 at 22:13

answered Jul 5 at 2:52

Esolanging Fruit

9,10412 silver badges26 bronze badges

\$\begingroup\$ This is going to need a formal definition of continuity, in particular of \$d\$. E.g. if using epsilon-delta, what's the distance metric between loops? \$\endgroup\$ – Peter Taylor Jul 5 at 11:06
\$\begingroup\$ @PeterTaylor I think it's pointwise fixing each input value of t that's given to d. \$\endgroup\$ – xnor Jul 6 at 1:54
2

\$\begingroup\$ You need to be careful about input because it is not possible for a computable function to take an arbitrary real number between \$[0,1]\$ as input, so for this challenge \$[0,1]\$ is going to have to mean something else likely \$\mathbb{Q}\cap[0,1]\$. You might also want to replace \$\mathbb{R}^3\$ with \$\mathbb{Q}^3\$, but I don't think this is technically necessary. \$\endgroup\$ – Sriotchilism O'Zaic Jul 6 at 2:59
\$\begingroup\$ Also I am going to recommend the topological definition of continuity over \$\varepsilon-\delta\$ for this purpose because it meshes neatly with topology. (and IMO is easier to understand anyway) \$\endgroup\$ – Sriotchilism O'Zaic Jul 6 at 3:02
2

\$\begingroup\$ I think it would help to give a short informal statement of the challenge before going into the definition, so as not to needlessly scare away anyone intimidated by the math terms. \$\endgroup\$ – xnor Jul 10 at 4:23
\$\begingroup\$ The TL;DR needs "closed", because open polynomial curves which are knots are not valid answers. \$\endgroup\$ – Peter Taylor Jul 11 at 22:12
\$\begingroup\$ @PeterTaylor Fixed. \$\endgroup\$ – Esolanging Fruit Jul 11 at 22:13

add a comment |

EdgyNerd · Accepted Answer · 2019-07-13 15:40:55Z

Print the sum of the previous answer's ASCII values

answer-chaining

Challenge

Output the sum of the previous answer's characters. For example, if the previous answer was print(25), the next answer would have to output the next answer would have to output 741.

Initial Answer

The initial answer has to output the number 1000

Rules

Your code can only use ascii characters (sorry Jelly), no extended-ASCII or Unicode characters.
Your output can be in Decimal, Unary or Base 256 (represented by ASCII characters)
You cannot use a language that has been used before. (Note: Different versions of the same language are allowed, like Python 2 and Python 3)
To prevent overly long languages (such as Unary) ruining the chain, your answer cannot be longer then 1000000 bytes.
The same person cannot post twice in a row
If two users post "at the same time", the earlier one will stand
If a solution breaks one of these rules, it and all answers that chain off of it will be deleted
Don't edit your code after you've posted it, otherwise it could invalidate code that chains off of it

Winning

The winner of the challenge is whoever has posted the most recent answer, since it will get harder and harder the more languages that are used.

Can you clarify base 256? If extended ASCII is excluded, is there a specific way to represent 256 distinct digits using 127 codepoints? — trichoplax, Jul 13 at 20:12
IMO this is too trivial to make a good answer chaining question. Finding an unused language in which you can figure out how to write (essentially) Hello, World is not going to get difficult until a couple of thousand answers in. — Peter Taylor, Jul 14 at 8:24
Wouldn't every answer just be variants of print(n) where \$n\$ is the integer literal of the sum of the last answer? — Jo King, Jul 15 at 22:52
Yeah, I’m gonna scrap this challenge because I didn’t think it through properly — EdgyNerd, Jul 16 at 6:22

BDM · Accepted Answer · 2019-07-17 21:43:32Z

I'm sorry, Code Golf

code-golf ascii-art

This challenge is inspired by a series of Garfield-inspired artwork in which Garfield is depicted as a horror creature, stalking his owner, Jon. Commonly referred to as "Creepy Garfield", the line "I'm sorry, Jon" can be found in one of the earliest Creepy Garfield images, created by DubbleBaby.

William Burke's Depiction

After being used over and over again by the Code Golf community, our beloved Jimmy has transformed - no longer bound to his weak, mortal body. He has become the embodiment of spaghetti code, the ascii manifestation of hours-long debugging sessions.

Your Task:

Take 3 ordered numerical inputs and output Jimmy's body

Inputs

Input is received in the form x y z where:

x is the number of left limbs (integer between 1 & 10)
y is the number of right limbs (integer between 1 & 10)
z is the number of heads (integer between 1 & 10)

----Sample Input----
2 8 1

Meta Note: I don't think increasing the possible amount of body parts will influence the solutions but please let me know if you think they should be higher.

Body Parts

Head =          <o>
Left Limb =     /
Right Limb =    \
Filler Limb =   |
Body Piece =    0

Body Generation Rules

   1. Left limbs must be attached to the left side of a body piece
    (excl rule 3)
    - Correct:  /0
    - Incorrect: /<o>
    - Incorrect: 0/
    - Incorrect: /0\0\

2. Right limbs must be attached to the right side of a body piece
    (excl rule 3)
    - Correct: 0\
    - Incorrect: <o>\
    - Incorrect: \0

3. Limbs must not touch
    - Correct: /00\
    - Incorrect: /0\/0\

4. An external body piece without a limb must have a | in its place
    - Correct: /0|
    - Correct: |0|
    - Correct: /00\
    - Incorrect: /0
    - Incorrect: 0\

5. Heads must be between body pieces (horizontally not vertically)
    - Correct: 0<o>0
    - Incorrect: 0<o><o>0
    - Incorrect: 0<o>

6. All lines must be aligned centre
    - Correct:      /0\
                  /0<o>0|
                    /0\

    - Incorrect:    /0\
                    /0<o>0|
                    /0\

7. The bottom line of Jimmy's body must always contain a left and right limb
    - Correct:      /0\
                  /0<o>0|
                    /0\

    - Incorrect:    /0\
                  /0<o>0\
                    /0|

8. Jimmy's body must be whole and cannot be separated into sections
    - Correct:    /0\
                /0<o>0|

    - Incorrect:    /0\   /0\   |0<o>0|

    - Incorrect:      /0\

                    /0<o>0|

Examples

Input:
2 8 2

Sample Output:

/0<o>0<o>0\
    |0\
    |0\
    |0\
    |0\
    |0\
    |0\
    /0\

    OR

  /0\
  |0\
|0<o>0\
  |0\
  |0\
|0<o>0\
  |0\
  /0\

Rules & Win Conditions

You may receive the stated input via any method into a program or function.
You may display the output in any clear and discernible way.
Your output must obey all Body Generation Rules.
The previous 3 rules must be followed for all 1000 combinations of inputs.
Standard loophole rules apply.

As this is code-golf, least amount of code in bytes wins.

I don't like bonuses in code golf in general, and this one doesn't even affect the score so it's just an invitation to distract from the challenge — trichoplax, Jul 16 at 20:36
(1) Whenever you see a bandwagon, run the other way. It's better to ask an interesting question than the nth variant on a theme. (2) That aside, there's no clear explanation of what the input is. Where are the values of that enum? — Peter Taylor, Jul 17 at 10:53
@PeterTaylor (1) This challenge doesn't exist to hop on the bandwagon. I thought that generating an eldritch-like stick figure would be neat. If you don't think this is an interesting question, I'd love to hear your feedback on that. (2) I've amended the input section to be a bit clearer but I'm not sure what I was missing in the first place. — BDM, Jul 17 at 21:13
What's missing is an explanation of the interpretation of the numbers. The input section defines the range of legal inputs but not the meaning of the inputs. — Peter Taylor, Jul 17 at 21:33
@PeterTaylor Ah I understand now. Hopefully my recent edit solves this. — BDM, Jul 17 at 21:44

Zgarb · Accepted Answer · 2019-07-18 12:23:40Z

Minimum string attractors

code-golf string optimization

String attractors

Let \$S\$ be a string of length \$n\$. An attractor of \$S\$ is a subset of indices \$A \subset \{0, \ldots, n-1\}\$ such that every nonempty contiguous substring \$S[i \ldots j]\$ of \$S\$ has an occurrence \$S[i' \ldots j']\$ whose index set \$[i' \ldots j']\$ intersects \$A\$. A minimum attractor is one with minimal size. Minimum attractors can be used to implement very efficient string compression algorithms. In this challenge, your task is to find a minimum attractor for a given string.

Example

Consider the string acabaccabc. Using 0-based indexing, one of its attractors is \$A = \{2,3,5,8\}\$. This graphic shows the positions of \$A\$:

acabaccabc
  ^^ ^  ^

For example, the occurrence of the substring ac in the beginning doesn't intersect \$A\$, but there is another occurrence after the first b that does. It turns out that no attractor of size 3 exists for this string, so \$A\$ is a minimum attractor.

Specifications

Your input is a nonempty string of lowercase ASCII characters. Your output is a minimum attractor for this string, in any reasonable format. You can use either 0-based or 1-based indexing.

There may be several choices for the minimum attractor. In that case you may return any one of them, but only one.

The lowest byte count wins.

Test cases

These are 0-indexed and show one possible output.

a -> [0]
aaa -> [0]
ababab -> [0,1]
qgqqgq -> [1,2]
abcbacaa -> [1,3,5,6]
abcdefgh -> [0,1,2,3,4,5,6,7]
jejjeeje -> [2,3,5]
sttststt -> [1,5]
ykkkkvyk -> [0,2,5]
assassins -> [0,2,6,7]
acabaccabc -> [2,4,6,8]
ssssssjjjsjj -> [5,8]
hrhrhhrhhhrr -> [3,7,10]
fubuaabubuau -> [0,1,4,6,10]
jjaahajjhahaaahjjh -> [2,6,8,11,14]

It took me a few tries to understand the first paragraph. I think it is explained well, but I may just have been unfamiliar with the language. Adding an explanation of "occurrence" may help? — FryAmTheEggman, Jul 18 at 20:34
The formal definition in the first paragraph is clear if you are used to such an academic style, though it might unnecessarily hard to grasp for users with no such background. It might be worthwhile to start with an informal explanation before giving the concise formal specification. E.g. something like this: Consider the following game: You are given a string like acabaccabc and need to defend it against attacks by marking some of its characters. An attack is a continuous substring of the given string, e.g. ca, and it is defended if one of the occurrences of the substring has (1/2) — Laikoni, Jul 28 at 18:43
a character that was marked by you. In the given example, ca occurs two times and covers the characters at positions 1,2 and 6,7 (with positions starting with 0). Thus, at least one of the positions 1,2,6 or 7 would need to be marked to defend the attack. Your goal is to find a marking such that the string is defended against any attack. Furthermore, you want to mark as few characters as possible. (2/2) — Laikoni, Jul 28 at 18:43

Geza Kerecsenyi · Accepted Answer · 2019-07-18 19:10:01Z

2

Posted here

edited Jul 18 at 19:10

answered Jul 11 at 21:24

Geza Kerecsenyi

8627 bronze badges

add a comment |

T. Salim · Accepted Answer · 2019-08-07 14:37:15Z

2

Check If A Binary Search Tree Is Balanced

Now posted on CodeGolf.StackExchange.com:

Write The Shortest Program To Check If A Binary Tree Is Balanced

edited Aug 7 at 14:37

answered Aug 4 at 21:42

T. Salim

3801 silver badge3 bronze badges

1

\$\begingroup\$ Looks like a nice challenge! I think you should specify what representations of a binary tree are accepted. There is certainly the representation as a list (where the children of the entry at index r are at 2*r and 2*r+1), but there might also be other native representations. \$\endgroup\$ – flawr Aug 5 at 6:44
\$\begingroup\$ Now that you've posted this, please edit it to be only a link to the main challenge and then delete your post to help keep the Sandbox tidy. Thanks! \$\endgroup\$ – AdmBorkBork Aug 7 at 14:28

add a comment |

640KB · Accepted Answer · 2019-08-07 15:52:49Z

2

Posted to PPCG. Thx for the votes!

edited Aug 7 at 15:52

answered Aug 5 at 15:43

640KB

4,8594 bronze badges

add a comment |

Kevin Cruijssen · Accepted Answer · 2019-08-07 19:29:42Z

Nearest Primes Converted String

code-golf number string primes conversion

Inspired by this SO question.

Challenge:

Given a string input, convert each of its characters to its integer code-point, and then get the nearest prime \$p\leq c\leq P\$ (where \$c\$ is the code-point of the given characters, \$p\$ is the nearest prime below it, and \$P\$ the nearest prime above it), after which we convert that prime back to a character.

For example:

Input: test
It's code-points: [115, 101, 115, 116]
The primes \$[p, P]\$: [[113,127],[101,101],[113,127],[113,127]]
The nearest prime of the two: [113,101,113,113]
Output: qeqq

But wait

What happens when the nearest prime is an unprintable character, like 127 for character y? In that case we'll.. I have multiple things in mind. Will decide later how to deal with them. I might restrict it to printable ASCII only or printable unicode values only. Will edit this information later in after making some example implementations myself.

Challenge rules:

I/O can be in any reasonable format. Can be a string, list/array/stream of characters, input one by one through STDIN, etc. Taking the characters already as code-points is not allowed, unless your language has no other choice!
If the distance between the current code-point and its two nearest primes below and above are equal, we'll use the lowest prime of the two (i.e. f with a code-point of 102 and the prime above/below it being 101 and 103, both with a distance of 1, will become 101 (e).

General rules:

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

Test cases:

Input:          Output:

test            qeqq

TODO: More to come.

looks good. This challenge is closely related to this one, but I'm curious as to where else this will go; I've enjoyed many of your challenges. — Giuseppe, Aug 7 at 19:34
As it stands, I would VTC this as a dupe of the challenge @Giuseppe linked as it just requires wrapping those solutions in converting to codepoints, mapping and converting back to codepoints. That that would be trivial in some languages but less so in others is what might stay my dupe-hammer. If and how you decide to handle unprintables, though, could well change my opinion. — Shaggy, Aug 7 at 21:18
And, without having tried to come up with to restrict the characters in the output, I think the only feasible way to do so would be to restrict it to printable ASCII as, off the top of my head, the only way I can think of to restrict it to printable UTF would be through the use of some sort of lookup table, which, in my book, would make this a chameleon challenge. — Shaggy, Aug 7 at 21:21
@Shaggy Yeah, I indeed thought the same thing as your second comment, which is why I hadn't decided anything yet. And I agree with your VTC comment. I've looked at some of the implementations of that challenge, and putting a convert from/to string around it works as is. If you have any suggestions on how to change this challenge, feel free to let me know. I will see if I can come up with something myself as well to change it. If not, I'll just delete it. — Kevin Cruijssen, Aug 8 at 7:15

What is the Sandbox?

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

2558 Answers 2558

Survival Game: Alien Hunters (working title)

Your Alien

The Board

Combat

Scoring

Other Rules

Count smooth numbers

Methods

Input range

Scoring

Sample tiers

Squish these Numbers

Details

Examples

Shortest JsFuck code for a number

Samples

Is it shifted?

Sandbox note

Touch-typing distance

Challenge

Left Hand

Right Hand

Rules

Test cases

Shift right by half a bit code-golf math number arithmetic

Meta

Irregular English Verbs

Rules

Example

List of Irregular Verbs

Generate a 3D spiral

I/O

Least efficient field order

Background:

Challenge:

The Minigame Challenge

Rules

The Minigame

Note: I'll try to expand further on what kinds of minigames are acceptable or not. Suggestions are appreciated.

Cops:

Robbers:

Scoring:

Challenge is still under construction

Challenge

Sample Test Cases

Task

Test cases

Comments

Finding Points in Convex Hulls

Input/Output

Remarks

Test Cases

Questions for Sandbox

Reverse RegEx

WordArt reader

Sandboxing:

How many right triangles can you find?

Challenge

Rules

Example Inputs and Outputs

\$n\$-Chess KotH king-of-the-hillgridchessboard-game

Introduction

Rules

Pieces

Board

Capture

Playing

Victory Condition

Implementation

Restriction

Procedure

TODO

Golf an H interpreter

Definitions

General H syntax

Strings

Statements

\$n\$-Chess KotH king-of-the-hill grid chess board-game