Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

I came across this little web game Drench Its a fairly mindless game , I wrote a small JS snippet to play this game for me in the background of my browser, it cycles through and clicks on the 6 possible moves

let ind =0;
let games =0;
let wins =0;
let lastMoves = "";
setInterval(function(){
  if (jQuery('.moveNum').text() != lastMoves) {
    lastMoves = jQuery('.moveNum').text();
    ind++;
    ind = ind%6;
    jQuery('.pbutton:nth('+ind+')').click();
  } else {
    games++;
    if ((jQuery('.moveNum').text()*1)) {wins++;}
    jQuery('#myCanvas').click();
  }
},200);

This Strategy wins about 3% of the time My question is, is there a more optimal strategy that will allow me to win a greater % of the time (without looking at the board)?

Answer 2

Create a safe crossing.

---

Given a string/number/array of any two distinct characters make the "squarest" 2D array that allows "someone" to cross from left to right or top to bottom "stepping" only on whichever character you have chosen as your stepping stone

or

Make the "squarest" array possible that contains a complete row or column of stepping stone characters. (clearer but takes away the fun story-ness)

---

"squarest" meaning smallest difference between the dimensions of the 2D array.

Input

• A string/number/array of your choosing consisting only of your two chosen distinct characters. So no error checking needed. Allow true/false values if input is array?
• input will have at least 1 stepping stone character so that a valid solution is always possible 1 by x or x by 1
• a minimum length of x? needed? might make it easier if there's some weirdness with very short arrays in the algorithms people come up with
• the last row can be incomplete to allow for prime number length inputs and to more easily allow non trivial 1xX/Xx1 answers

Output

The output should be the dimensions of the array

• and specify the row or column to use?
• print your 2D array so that the path can be seen graphically?

Test Cases

100100100 -> 3x3 array

100
100
100

11111000 -> 4x2 or 3x3 - 3x3 is squarer so is correct

1111    111
1000    110
        00

11000011000101001001 -> 5x4

11000
01100
01010
01001

1000000000000 -> 12x1 - trivial as only 1 stepping stone

100000000000

010111 -> 3x2 or 2x3 - either acceptable as both are only "1" away from square

010    01
111    01
       11

This is code-golf so the shortest code in bytes wins.

code-golf array-manipulation

Issues

• allow diagonal crossings? does that make it a lot harder?
• need a lot more test cases I think?
• input spec
• output spec
• better/more tags?

Answer 3

ASCII Sum of your code

Encoding is nice, adding things is also nice. Let's do both !

Your task will be to create a program that read itself, convert every of its character into ASCII values and return the sum of those numbers.

Example

Let's say your program is Hello, world !. Convert every character into ascii values

H  e   l   l   o   ,  (space) w   o   r   l   d   (space) !
72 101 108 108 111 44 32      119 111 114 108 100 32      33

Now, sum everything into a meaningless very useful value

72 + 101 + 108 + 108 + 111 + 44 + 32 + 119 + 111 + 114 + 108 + 100 + 32 + 33
= 1193

Here it is, Hello, world! returns 1193 !

Rules

• The code have to read itself and calculate the result
• Standard loopholes are not allowed
• This is codegolf, so the fewer bytes wins.
• Non-standard languages with non-ASCII characters should use their own codepage's encodings (Thanks for @Veskah for this rule)

---

Feedback

• Is the challenge clear enouth ?
• Is there an already existing challenge like this one ?
• is this considered as a duplicate of this challenge ?

Answer 4

It's slashing time

code-golf date

(Inspired by Seven Slash Display)

You're lying in bed, awake. Sleepily, you turn your head to the alarm clock and read what time it is. Since you're lying down, the clock is facing diagonally, making it difficult to read. You decide to write a program to help you out (hey, you're awake anyway).

Given a "slashed" seven-segment display, output what time it is in 24-hour format.

      /\
       /\
    /\  /
    \ \
   . \/
 /\ .
  /
  \/

2:03

You can choose where to place the : between the numbers (for example, evenly spaced as above or left-aligned as below, etc.), but the : must be present.

Some further examples:

       \
        \
    /\
     /\
  / . /
  \/\.
 \  /
  \

15:31

       \
      \/\
     \
      \
   \.
    \.

1:14

Here are the precise digit shapes:

/\
\ \
 \/

 \
  \


/\
 /
 \/

/\
 /\
  /

 \
\/\

/
\/\
  /

/
\/\
 \/

/\
  \

/\
\/\
 \/

/\
\/\
  /

Rules & Standard I/O boilerplate

• The time will always be valid. For example, you'll never receive something like 30:25 or 7:99 or the like.
• You're allowed to pad the input with whitespace however necessary (e.g., padding it to always be a rectangle with trailing spaces).

Answer 5

Room volume as a function of paint on the walls/ceiling

Task: Write a function that will take in the size of a room (height, width, and length) and a number of paint layers (given that the layers are of a consistent thickness) and return the area of free space in the room after that many layers of paint are applied.

Requirements:

• Return the final area left in the room after the paint layers are added
• should be able to run on a room of any size
• The answer must account for the decreasing area in the room as each layer is applied.
• number of layers and paint layer thickness should both be inputs
• must account for walls and ceiling
• standard loopholes are disallowed

The winner is determined via byte count

Answer 6

List of integers to pairs ?? Any suggestions for the title ??

code-golfintegerarray-manipulationcombinatorics

Write a function or a full program taking a list of non negative integers numbers L that outputs a pair of numbers [X , Y] such that X %( Y + i ) == L [ i ] .

Output specifications

• You can output X Y in any order, just indicate it and be consistent.
• X Y are also unsigned integers, obviously Y must be greater than 0 to avoid modulo 0 errors.
• If your language doesn't support 0 indexed list you can consider X %( Y + i ) == L [ i + 1 ] ?? Any suggestions how to handle this ??

Example

[ 1, 2, 3 ] => [ 11, 2 ]

 11 %( 2 + 0 ) = 1
 11 %( 2 + 1 ) = 2
 11 %( 2 + 2 ) = 3

[ 10, 2 ] => [ 98, 11 ]

 98 %( 11 + 0 ) = 10
 98 %( 11 + 1 ) = 2

---

Test cases

[ input ] , [ output ] pairs

[ 0, 1, 2 ] ,  [ 5, 1 ]
[ 1, 2 ] ,  [ 5, 2 ]
[ 1, 2, 3 ] ,  [ 11, 2 ]
[ 1, 2, 3, 4, 5 ] ,  [ 59, 2 ]
[ 4, 3, 2, 1, 0 ] ,  [ 9, 5 ]
[ 6, 12, 18 ] ,  [ 3318, 18 ]
[ 27, 18, 9 ] ,  [ 279, 28 ]
[ 3, 9, 27 ] ,  [ 4059, 26 ]
[ 2, 4, 8, 16 ] ,  [ 8584, 14 ]
[ 0, 0, 0, 0, 0, 0 ] ,  [ 60, 1 ]
[ 1, 1, 1, 1 ] ,  [ 61, 2 ]
[ 120, 20 ] ,  [ 12220, 121 ]
[ 10, 2 ] ,  [ 98, 11 ]
[ 9, 8, 7, 0 ] ,  [ 1339, 10 ]
[ 0, 1, 4, 9, 2, 10, 4, 15, 10, 5, 0, 16, 12, 8, 4, 0, 22, 19, 16, 13 ] ,  [ 100, 10 ]
[ 9, 99, 90, 81, 72, 63, 54, 45, 36, 27 ] ,  [ 999, 99 ]

---

Rules

• Input/output can be given by any convenient method.
• You can print it to STDOUT or return it as a function result.
• Either a full program or a function are acceptable.
• Standard loopholes are forbidden.
• This is code-golf so all usual golfing rules apply, and the shortest code (in bytes) wins.

---

Answer 7

Create a block maze solver AI

A block maze is a maze in which goal is to complete a pathway by adding blocks.

It starts like this :

#..#.
#...#
..###
.#...
.#..#

# is a block (which can be crossed). . is empty space (which cannot be crossed).

The goal is to connect top-left corner S to the bottom-right corner E. Diagonals are not allowed.

S....
.....
.....
.....
....E

One possible solution for the example above is to add three blocks like this :

#..#.
#...#
#####
.#..#
.#..#

Think about a man who want to cross a river with crocodiles . using huge stone blocks #.

The task is to create a program that take a grid as input and return a solution as output.

Scoring

The sum of all blocks required to solve all solutions in a 1.000 test case file I will provide.

The winning program is the one that use the fewest blocks to solve all mazes.

Rules

• All grids are 25 x 25.
• Start / end points are always top-left / bottom-right corners. There is always a block on those points.
• There is always one guaranteed solution (which can be found by filling all empty spaces)
• Program must be entirely deterministic; pseudorandom solutions are allowed, but the program must generate the same output for the same test case every time. If two programs take the same number of steps (e.g. they both found the optimal solutions), the shorter program will win.

The program should return the solution as a sequence of blocks x-y coordinates (the coordinates of blocks to add to solve maze) in the format of your choosing :

11-3;15-6;19-12   

Meta

• I cannot think of a simple algorithm that returns an optimal (best possible) solution in a reasonable time. I expect programs to use some heuristics to get non-optimal/near-optimal solutions. I made the grids 25 x 25 to make it challenging enough and prevent simple solutions like brute force.
• Is this a duplicate? There is lot of maze related questions but I couldn't find anything related to block maze.
• The tags are code-challengemazepath-finding. Anything else?

---

EDIT : as AlienAtSystem pointed out in comments, there is an optimal algorithm for all cases. I made some tests: even a slightly modified Dijkstra's algorithm will work (it will find shortest path in a short time). I will not post this challenge as it is trivial. I leave it here in case someone else would have same idea.

Answer 8

OEIS A125959

https://oeis.org/A125959 is a sequence I submitted. It is the following array, which then repeats:

1 2 3 4 5 6 7 8 9    
2 4 6 8 1 3 5 7 9    
3 6 9 3 6 9 3 6 9    
4 8 3 7 2 6 1 5 9    
5 1 6 2 7 3 8 4 9    
6 3 9 6 3 9 6 3 9    
7 5 3 1 8 6 4 2 9    
8 7 6 5 4 3 2 1 9    
9 9 9 9 9 9 9 9 9

This is a rather useful array for quickly calculating the digital root of the product of any two numbers (i.e the iterative sum of the digits of the product). See the OEIS link if you're interested in the details.

The challenge is to print the array in the shortest number of bytes.

Input

None

Output

The above array. It can be output as strings with new lines, or as a nested array, or an array of strings; but not as a single-line sequence (i.e. the 2d-nature of the array must be reflected in your output).

kolmogorov-complexity code-golf

Answer 9

Times have changed!

(pun intended)

---

Preface

As mathematics progressed, mathematicians agreed upon the 'order of operations', to prevent mathematical expressions from becoming ambiguous.

Given the expression \$7 \times 6 + 5 \times 3\$ we know to first evalulate multiplication, giving \$ 42 + 15\$, which is equal to \$57\$.

But what if another group of mathematicians had agreed to evaluate addition before multiplication? This expression would become \$ 7 \times 11 \times 3\ = 231\$: which is different from our answer by an error of \$305\%\$!

---

The Challenge

Given a mathematical expression containing + (addition), * (multiplication), and the digits 0123456789, we can find:

• \$E_1\$ - the 'real' value of the expression, when multiplication takes precendence.
• \$E_2\$ - the 'alternate' value of the expression, when addition takes precedence.

Your task is to write a program or function which, given a string representing an expression, calculates and outputs the percentage error, \$\frac{|E_1 - E_2|}{E_1} \times 100\$.

---

Rules

• WIP.

Answer 10

Bake the cookie

Quick intro

So i was playing cookie clicker yesterday, and I thought about something. We keep producing cookies, without any loss. What if your cookies failed? This is where I thought about a clicker that would cook a cookie. Don't click too much, or the cookie will be overcooked!

Task

Your task will be to create a function that will "bake" a cookie :

• Your function will have to randomly select a number between 5 and 10 : it will establish the cooking duration of your cookie (and so, the number of time you'll have to call the function to cook your delicious cookie).
• Each time you call that function, it will iterate the baking process of your cookie.
• Your function should return "Undercooked" if your cookie is not fully cooked, "Overcooked" if you ... overcooked it, and "Cooked" when the cookie is baked just right.

Example

Since I'm bad at explaining things, an example will show you more clearly what needs to be done. Let's call my function bake() :

bake()    // The random number generated is 6, so i need to call my function 6 times
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()    // We hit the 6th function call, the cookie is baked.
Cooked

bake()    // The 7th call overcooked the cookie. Congratulation, you ruined it.
Overcooked

Rules

• The random number of iterations has to be set the first time you call the function. It has to be between 5 and 10 (inclusive).
• A cookie has to be undercooked before being cooked, and has to be cooked before being overcooked. The 3 steps have to be reachable. A cookie can't uncook itself, therefore you can't go from cooked to undercooked, or from overcooked to cooked (it's too late, you ruined the cookie anyway).
• The function can have as many parameters as you please.
• Classic rules apply, no standard loopholes
• This is codegolf, so the shortest code wins.

---

Meta

• Is the challenge clear enough ?
• Should I go with this method to iterate the "baking" process ?
• Are there some rules I could add to make it more exciting ?
• Does this challenge exist already ?
• Should we bake pies instead ?

Answer 11

Posted

Answer 12

Title: When is Hannukah?

Input

The input will be a year between 1583 and 2250.

Output

The Gregorian date of the first evening of Hannukah that year. That is the day before the first full day of Hannukah. Your code should output the month and day of the month in any easy to understand human readable form of your choice.

Examples

2013    November 27 
2014    December 16
2015    December 6  
2016    December 24 
2017    December 12 
2018    December 2  
2019    December 22
2020    December 10 
2021    November 28 
2022    December 18
2023    December 7  
2024    December 25 
2025    December 14 
2026    December 4  
2027    December 24
2028    December 12 
2029    December 1  
2030    December 20 
2031    December 9  
2032    November 27 
2033    December 16

How do you do this?

It could hardly be simpler. We start with a couple of definitions:

We define a new inline notation for the division remainder of \$x\$ when divided by \$y\$: $$(x|y)=x \bmod y$$

For any year Gregorian year \$y\$, the Golden Number, $$G(y) = (y|19) + 1$$ For example, \$G(1996)=2\$ because \$(1996|19)=1\$.

To find \$H(y)\$, the first evening of Hannukah in the year \$y\$, we need to find \$R(y)\$ and \$R(y+1)\$, the day of September where Rosh Hashanah falls in \$y\$ and in \$y+1\$. Note that September \$n\$ where \$n≥31\$ is actually October \$n-30\$.

$$R(y)=⌊N(y)⌋ + P(y)$$ where \$⌊x⌋\$ denotes \$x-(x|1)\$, the integer part of \$x\$, and

$$N(y)= \Bigl \lfloor \frac{y}{100} \Bigr \rfloor - \Bigl \lfloor \frac{y}{400} \Bigr \rfloor - 2 + \frac{765433}{492480}\big(12G(y)|19\big) + \frac{(y|4)}4 - \frac{313y+89081}{98496}$$

We define \$D_y(n)\$ as the day of the week (with Sunday being \$0\$) that September \$n\$ falls on in the year \$y\$. Further, Rosh Hashanah has to be postponed by a number of days which is

$$P(y)=\begin{cases} 1, & \text{if } D_y\big(\lfloor N(y)\rfloor \big)\in\{0,3,5\} & (1)\\ 1, & \text{if } D_y\big(\lfloor N(y)\rfloor\big)=1 \text{ and } (N(y)|1)≥\frac{23269}{25920} \text{ and } \big(12G(y)|19\big)>11 & (2)\\ 2, & \text{if } D_y\big(\lfloor N(y)\rfloor \big)=2 \text{ and } (N(y)|1)≥\frac{1367}{2160} \text{ and } (12G(y)|19)>6 & (3)\\ 0, & \text{otherwise} & (4) \end{cases}$$

For example, in \$y=1996\$, \$G(y)=2\$, so the \$N(y)\approx13.5239\$. However, since September 13 in 1996 was a Friday, by Rule \$(1)\$, we must postpone by \$P(y)=1\$ day, so Rosh Hashanah falls on Saturday, September 14.

Let \$L(y)\$ be the number of days between September \$R(y)\$ in the year \$y\$ and September \$R(y+1)\$ in year \$y+1\$.

The first evening of Hannukah is:

$$ H(y)=\begin{cases} 83\text{ days after }R(y) & \text{if } L(y)\in\{355,385\}\\ 82\text{ days after }R(y) & \text{otherwise} \end{cases} $$

Notes and thanks

Thank you to @Adám for pointing me to the rules. To keep things simple, this challenge assumes the location to be Jerusalem.

Answer 13

Decode the password

Given a printable ASCII string separated with spaces, output the specified index of every word. E.g.

"are turbas unsafe ?!", 1

will yield run!

• When the index is out of bounds, this index should yield the null string (which can be joined with other strings).

More test cases

"Is Pascal truly unloyal to users?",3 -> "sure"
"I'd pass kittens to anyone stopping by!!",4 -> "stop!"

Answer 14

Is this entire list likewise-modulus-aligned?

code-golf math

A pair of numbers are aligned in a modulus when they all share the same remainder when they can be put under the modulus function against an integer greater than or equal to 2 and less than or equal to the absolute value of both.

For example,

13 and 22 are aligned numbers under 3 because
13%3 = 1
22%3 = 1

3<=13, 3<=22, and 3>=2

All our requirements are met.

A list is likewise-modulus-aligned when all the elements are aligned under the same modulus base.

Challenge

Take in a list (not necessarily non-empty) of non-zero integers (not necessarily positive nor unique), and check if all the elements are likewise-modulus-aligned. Output is a truthy or falsy value.

Note; This is a "true-until-proven-otherwise" problem, meaning a single value in the list or an empty list will return TRUE.

Example I/O

      In      | Out | Why
--------------|-----|---------
         [5 7]|TRUE |1 mod 2
     [7 12 18]|FALSE|(7,18) are not mod-aligned
     [7 11 19]|TRUE |1 mod 2
  [5 13 28 44]|FALSE|(5,28) are not mod-aligned
[10 13 37 108]|FALSE|(37,108) aren't aligned in any base below 10
            []|TRUE |No disproven pairs
          [42]|TRUE |No disproven pairs
    [-5 13 16]|TRUE |1 mod 3
      [1 9 18]|FALSE|Arrays of size 2 or greater with 1 or -1 will always be false
    [14 17 19]|FALSE|Every pair is modulus-aligned, but not under the same base
[17,22,32,107]|TRUE |2 mod 5
      [4,8,12]|TRUE |0 mod 2
        [-1,1]|FALSE|No mod 1 allowed
           [1]|TRUE |No disproven pairs
       [7,7,7]|TRUE |Numbers >=2 are always mod-aligned with themselves
     [2,2,8,8]|TRUE |0 mod 2
   [3 9 22 22]|FALSE|Pairs don't suddenly make (9,22) mod-aligned.

Sandbox Questions

I'm gauging the interest to this question and seeing if this is an acceptable and unique challenge, just want to make sure I haven't missed another post doing a similar thing.

I changed the rules to be a lot more lenient on the comparisons, might do the pairwise comparison as a bonus or follow-up challenge later. But this is a compromise I can live with.

Extra Hints/Tips

For all non-1 derivations, a number will be aligned with its negative self.
1 is never aligned with any other number, nor will -1.
A number that is a multiple of another will be aligned with that number in all its factors.
Numbers that share factors will always align, but numbers that don't share factors also may.
All odd numbers are aligned with each other, as are all even numbers.

Answer 15

Square-Cube Digit Usage

Answer 16

graphical-output code-golf geometry

Draw an American flag for any amount of states

The flag of the United States of America goes by many names. The Stars and Stripes. Old Glory. The Last Known Non-Erotic Usage Of The Verb 'To Spangle'.

It is also one of the few flags semi-regularly updated. The red and white stripes represent the 13 original states, but one more star has been added to the blue canton for every state that joined the union later. This last happened in 1960, when Hawaii got in. Flag designs with 51 stars are already waiting for when Puerto Rico or Washington D.C. are made states, but this vexillologist is lazy. You are to make a program that can draw the flag with any number of stars desired!

Specification

Here's a neat image of the official, government-standardised design for the current U.S. flag:

Disregard the contents of the canton for now. Your program must draw a flag that adheres to only the ratios I give here:

• A (the height of the flag) = 1
• B (the width of the flag) = 19/10
• C (the height of the canton) = 7/13
• D (the width of the canton) = 19/25
• L (the height of any stripe) = 1/13

Because raster solutions are not exact and this flag is commonly misdrawn anyway, there's tolerance of 2% for every ratio, taking the flag height as the base.

Furthermore, the correct colours must be used.

• Every odd-numbered stripe must be this shade (hex): #B22234
• The blue canton must be in this shade: #3C3B6E
• Every even-numbered stripe, and every star, must be in this shade: #FFFFFF

Conversions to other colour coordinate systems can be found on the wiki page as well.

Stars

Your program must takes as input any integer between 0 and 200, and draw that number of stars within the canton. The following rules apply.

• Each star must have five outer points and be five-fold rotationally symmetrical.
• Each star must be the same size.
• The bounding circles of stars may overlap, but the surface of the stars itself may not overlap.
• The bounding circles of the stars may go outside the canton, but the surface of the stars itself may not go outside the canton.

• I don't want solutions that just place every star on the same line; that would leave a lot of blue canton untouched, which would be a waste. So, as a rule, the combined surface area of the bounding circles of every star in the canton must be at least 20% of the surface area of the canton.

  Since overlapping bounding circles still count, you get a formula for the minimum width w of the star, where a is the area of the canton and n the number of stars: . See here for how it's derived.

Other specifications

There's no minimum or maximum size for your output image, though I recommend something that will allow 200 stars to fit but still be demonstrably star-shaped. When they are only a few pixels high, it becomes hard to argue that they have the required amount of points. Obviously, for vector solutions any size is permissible.

This is code-golf, so the smallest program wins!

Test cases

Because I gave no specific arrangement of the stars (you may arrange them however you want), there is an infinite number of correct and incorrect solutions for each number of stars. These are just examples of valid and invalid solutions:

Valid:

Invalid (stars too small):

Valid:

Invalid (stars of unequal size, going out of the canton):

Invalid (stars have too many points, stripes have wrong colours, colours are the wrong hue, proportions are wrong):

Sandbox

Do I need more test cases? Any other feedback?

Answer 17

Excessively complicated Game of Life king-of-the-hill

In the excessively complicated version of the Game of Life, the world is a \$W \times H\$ square torus with a grid of squares. Each square has a rulestring attached to it - by default, B/S. Each square has a dead or alive cell in it. Each alive cell is controlled by a player. Every turn, if there is not an alive cell in a square, it is born iff the part between B and / contains the number of alive neighbours. Every turn, if there is an alive cell in a square, it survives iff the part after S contains the number of alive neighbours. Cells are considered adjacent if they have a common edge or a corner. A cell is not adjacent with itself. Cells controlled by other players also count as alive neighbours.

For example, normal Conway's Game of Life cells have the B3/S23 rulestring: cells are born if they have exactly 3 alive neighbours, and survive if they have 2 or 3.

Each player starts with a B/S012345678 cell, placed uniformly randomly.

Each cell knows a 3x3 array of numbers from \$-1\$ to \$1\$, representing adjacent cells (including self). \$1\$ in it means an ally cell, \$0\$ means a dead cell, and \$-1\$ means an enemy cell, and a 3x3 array of rulestrings for adjacent cells.

Every turn, every cell can alter one bit of the rulestring of any adjacent square (including its own) - that is, remove or add a number from it (or, alternatively, it can do nothing).

When cells are born, the player they belong to is chosen semi-randomly: the odds of the cell being assigned to a player are proportional to the number of cells they contributed to the cell's birth.

A player is eliminated when all their cells die. When \$N\$ turns passed, or when only one player remains, the game ends. A full point is distributed between all remaining players proportionally to the number of cells they control (dead cells don't count).

Clarifications

• Rulestrings are attached to squares, not to cells. When a cell dies, the rulestring on its square is not changed.
• No cell can be born with zero alive adjacent cells (that is, rulestrings cannot start with B0).
• When multiple cells attempt to alter the same bit in a rulestring, it is only affected once.

Challenge

Define a pure function \$(nearbyStates, nearbyRules)\to(\Delta x, \Delta y, index)\$ to be used as the algorithm for your cells. To do nothing, output an index of 0.

Otherwise, an index of 1 corresponds to toggling B1, 2 to B2 and so on until B8, the index 9 is skipped, then an index of 10 corresponds to toggling S0, 11 to S1 and so on until S8.

Winning criterion

\$X\$ games are run, and the leaderboard is formed by sorting participants by the total number of points.

This is king-of-the-hill, so whoever wins wins!

Sandbox stuff

• Is this a good idea?
• Is the description of the game clear?

I think I decided that the language for submissions will be Javascript. Now I have to write a controller.

Besides the obvious Javascript option, I am considering C++ with a Javascript engine (probably V8). This can multiply the performance by \$\%NUMBER\_OF\_PROCESSORS\% \cdot \frac{cppPerformance}{jsPerformance} \cdot \frac{myC++skill}{myJSskill}\$, which can be quite large. Unfortunately, that might also muptiply the challenge's popularity by \$\frac{webBrowserLoadingSpeed}{programInstallationSpeed}\$, which can be quite small! Would that be a good idea?

Answer 18

Symmetrical difference code-golf

Post'd.

Answer 19

Posted on the main site.

Answer 20

Help, I've mixed my week up!

My dog ate my calendar, and now my days are all mixed up. I tried putting it back together, but I keep mixing up the days of the week! I need some help putting my calendar back together, with the days in the correct order.

And since I need my calendar put together as fast as possible, don't waste my time by sending me superfluous bytes. The fewer bytes I have to read, the better!

Input

The days of the week, in any order. Input can be taken as a list of strings, or a space separated string, or any reasonable way of representing 7 strings (one for each day of the week).

The strings themselves are all capitalized, as weekdays should be, so the exact strings are:

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Output

The days of the week, in sorted order (Monday - Sunday). Output can be as a list of strings, or printed with some delimiter.

Disclaimer

Note that this is a kolmogorov-complexity challenge, with the added benefit of being able to use the input to shorten your code. You are not required to use the input if you don't want to.

Examples

To see example input and output, you can consult this python script.

For the sandbox

If there are any issues with the input/output specification, or if anything is unclear, please leave a comment.

Tags: code-golf kolmogorov-complexity sorting string random calendar

Answer 21

Fold my ACGT proteins code-golf string biology chemistry

Quoting Wikipedia, "Protein folding is the physical process by which a protein chain acquires its native 3-dimensional structure, a conformation that is usually biologically functional, in an expeditious and reproducible manner.". I don't know what that means but by means of a game called Foldit it seems we can use protein folding in some way to help and fight diseases.

Please bear in mind that the task described was inspired by the isolated meaning of the words in "protein folding" and doesn't necessarily translate into how protein folding really works! i.e. the title is just a pun.

Task

Your task is to take a string matching the regex /^[ACGT]+$/ and return the number of times the string can be "folded". A string can be folded if and only if:

• It's length is even;
• The first half of the string is the reverse of the second half of the string.

Input

Acceptable input formats include but are not limited to:

• strings
• character lists
• codepoint lists

Output

The output is an integer; I don't think there's much room to wiggle here, but let me know if you really wanted to return something else.

Test cases:

Python reference implementation

'A' -> 0
'AAA' -> 0
'AAAAA' -> 0
'TAAAAAAA' -> 0
'ATAAAAAA' -> 0
'AATAAAAA' -> 0
'AAATAAAA' -> 0
'AAAATAAA' -> 0
'AAAAATAA' -> 0
'AAAAAATA' -> 0
'AAAAAAAT' -> 0
'TGCAACGTTGCAACGT' -> 2
'ACGTTGCAACGTTGCAACGTTGCAACGTTGCA' -> 3
'TGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGT' -> 4
'TACCCCATTACCCCAT' -> 2
'TTTT' -> 2
'TATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTAT' -> 5
'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' -> 6
'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC' -> 6
'GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG' -> 6
'TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT' -> 6
'TAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAAT' -> 5
'GCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCG' -> 5
'CATTACCATTACCATTACCATTAC' -> 3
'CATTACCATTACCATTACCATTAC' -> 3
'CATACCATACCATACCATACCATACCATACCATACCATAC' -> 3

Answer 22

Integers in cosine

Posted

Answer 23

Bilibili AV/BV Code Conversion

Answer 24

Minimise my List of Error Codes

SANDBOX - One Option for a Challenge

Given a set of error codes, formed of letters (A-Z) and numbers (0-9), output a string that represents the set of error codes in a concise format, as follows:

• Where two or more error codes share some first characters, there is no need to repeat those characters in the output
• Individual errors in the output are comma-separated (or in separate array indices, if preferred)

e.g:

• E1,E2 -> E1,2
• E1,W1 -> E1,W1
• ERR001, ERR002, ERR101, WAR001 -> ERR001,2,101,WAR001 or WAR001,ERR001,2,101
• WARN001, ERR001 -> WARN001,ERR001
• EAR001, ERR001 -> EAR001,RR001
• E001, E001 -> E001,
• A, B, C01, D002 -> A,B,C01,D002
• D002, DC01, DC0A, DC0B -> D002,C01,A,B or DC01,A,B,002 or DC0A,B,1,002etc.

Basically, when decoding, each character after the comma replaces the characters at the end of the previous error code.

SANDBOX - Alternative Challenge?

Decode a string of error codes, as per the above format, to extract the individual list of error codes again

SANDBOX - Questions

I know the spec is incomplete above - this is a placeholder for when I have time to write a better spec.

Is this an interesting code-golf challenge? Which of the two options would work best? Or could it be the sum of the two (encoder and decoder)?

Answer 25

Inspired by Draw this planar graph.

Your input represents an ascending sequence, e.g. 1 2 3 4. You can require the sequence as input, or you can just input the length. The explanation assumes 1-indexing but you can use 0-indexed or even a-indexed input if you adjust the algorithm appropriately.

At each step, you can exchange any digit of value n with the digit n places to its right. So the valid second steps are 2 1 3 4 and 1 4 3 2. Eventually you want to end up at the reverse sequence 4 3 2 1, which is the only permutation that has no legal steps.

Please output all possible sequences of steps from the input sequence to its reverse.

You should support sequences of up to at least 10 elements.

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

Answer 26

Inspired by Wizard creating a jewelry.

Given an input list of positive integers, calculate the minimum cost of creating the list from the following operations:

1. Appending a positive integer costs the value of the integer.
2. Incrementing the entire list costs 2.
3. Exchanging two consecutive elements of the list costs 1.

Example: The list 1 4 9 16 25 could be constructed as follows:

• Append 1
• Append 8
• Append 17
• Increment
• Increment
• Increment
• Increment
• Increment
• Append 1
• Swap 22 with 1
• Swap 13 with 1
• Swap 6 with 1
• Increment
• Increment
• Increment
• Append 1
• Swap 25 with 1
• Swap 16 with 1
• Swap 9 with 1
• Swap 4 with 1

This costs 51, which is an improvement over simply appending the integers, as that is a cost of 54.

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

Answer 27

Reduce the entropy of the input...

Spec

Given two arguments:

• A list containing 2 or more positive integers (from 0 to artificial limit of 2^32)
• A positive number defining the 'entropy allowance'

Return a sublist containing elements up until the entropy allowance is used up.

For this challenge, we define 'entropy' as the difference in bits between numbers in the list; also known as the Hamming distance.

Note that no 'entropy' is used up when flipping the bits in the first number, only used when flipping subsequent bits.

Examples

Worked example (MSB...LSB), keeping the numbers low to keep things simple:

Example 1:

List: [1, 2, 3, 4, 5, 6] Allowance: 4

1 => 0000 0001 - ignore implicit change from 0, total used = 0
2 => 0000 0010 - change of 2 bits, total used = 2
3 => 0000 0011 - change of 1 bit, total used = 3 
4 => 0000 0100 - change of 3 bits, total used = 6 (would exceed allowance)
5 => 0000 0101 - change of 1 bit, total used = 7
6 => 0000 0110 - change of 2 bits, total used = 9

Output: [1, 2, 3]

Example 2:

List: [255, 0, 127, 64, 32, 100] Allowance: 23

255 => 1111 1111 - ignore implicit change from 0, total used = 0
0   => 0000 0000 - change of 8 bits, total used = 8
127 => 0111 1111 - change of 7 bit, total used = 15
64  => 0100 0100 - change of 6 bits, total used = 21
32  => 0010 0000 - change of 2 bit, total used = 23
100 => 0110 0100 - change of 2 bits, total used = 25

Output: [255, 0, 127, 64, 32]

Meta

Is this interesting enough a challenge? Is it just a chameleon (is it just the hamming distance with extra steps)? Thoughts?

If it's not shot down for being a plain, any ideas for a better title?

Answer 28

The smallest positive integer that cannot be printed in fewer than %NUMBER% bytes of %LANGUAGE% code-challenge

All numbers mentioned below are positive integers. All programs mentioned below output exactly 1 number (including functions that return it).

For every number, there must be at least one program in your language that outputs it. Besides, the problem of determining what number the program outputs must be undecidable without making the assumption that the program halts.

The challenge itself is to choose a number \$N\$ and find the smallest number \$M\$ that cannot be output by a program shorter than \$N\$ ordinary units of measurement used for your language (usually bytes). You have to prove your solution correct. A strong mathematical proof is not necessary, but it should be reasonably convincing for somebody knowledgeable in your programming language.

The answer with the largest \$M\$ wins.

Sandbox stuff

• In this challenge, non-golfing languages seem to have a serious advantage. I think scoring by \$M\$ instead of \$N\$ is better at reducing the advantage of Lenguage-like languages to manageable levels and preventing ties; is that correct?
• Is the code-challenge tag appropriate?
• Title suggestions?

Answer 29

Can this month tell the day-of-the-week? code-golf decision-problem date

June 2020 is a month in which June 1st corresponds to Monday, June 2nd corresponds to Tuesday, ... June 7th corresponds to Sunday. For reference, here's the cal of June 2020.

      June 2020     
Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30            

Given a year and a month in the format [year, month], output two distinct values that tell whether this month can tell the day-of-the week.

Test cases

[2020,6] -> True
[2021,2] -> True
[1929,4] -> True

[1969,1] -> False
[1997,5] -> False
[2060,1] -> False
```

Answer 30

Self-distances completion - Minimum k to get them all

Related minor code-golf challenge

Consider \$A = (a_1,\dots,a_k)\ k\ge2 \$ a sequence of positive integers, in which all elements are different.

The self-distances completion of a sequence like \$A\$ it's performed recursively as follow:

Starting from \$i=2\$, while \$a_i\in A:\$ _{(loop until the last element)}

• If \$d=|a_i-a_{i-1}|\$ is not already in \$A\$, append \$d\$ to \$A\$
• Increase \$i\$

The resulting sequence \$A^\circ\$ is presumably longer than \$A\$, nevertheless can't contain more than \$n\$ terms.

Examples

$$ A = (2,\ 9,\ 13,\ 15) \mapsto A^\circ = (2,\ 9,\ 13,\ 15,\ 7,\ 4,\ 8,\ 3,\ 5)\\ A = (2,\ 9,\ 13) \mapsto A^\circ = (2,\ 9,\ 13,\ 7,\ 4,\ 6,\ 3)\\ A = (2,\ 9) \mapsto A^\circ = (2,\ 9) $$

Task

If we pick a number \$n\ge 2\$, we can ask what's the minimum length \$k_n\$ of \$A\$ such that \$A^\circ\$ contains all the numbers up to \$n\$.

(Note that \$\max A = \max A^\circ\$ so \$n\$ has to be in \$A\$)

• Generate the sequence of \$k_n\$ starting from \$n=2\$.

This is fastest-code.

I'll run your code on my machine (Windows 10, i7-7500U) for 30 minutes.
Obviously longer sequence is better. In case of a tie, who gets to the last term faster wins.
Your submission must not use more than 8GB of memory.
Please include instructions for how to compile/run your code.

First values and more info

 n. k_n - first A* example found (how many A of lenght k_n that satisfy the condition)

 2.  2  - 1 2 (2)
 3.  2  - 1 3 2 (4)
 4.  2  - 4 1 3 2 (2)
 5.  2  - 5 4 1 3 2 (1)
 6.  3  - 1 6 2 5 4 3 (19)
 7.  3  - 3 1 7 2 6 5 4 (10)
 8.  3  - 6 1 8 5 7 3 2 4 (3)
 9.  4  - 6 1 9 2 5 8 7 3 4 (80)
10.  4  - 10 1 8 3 9 7 5 6 2 4 (39)
11.  4  - 6 8 1 11 2 7 10 9 5 3 4 (18)
12.  4  - 8 12 1 10 4 11 9 6 7 2 3 5 (7)
13.  4  - 5 3 12 13 2 9 1 11 7 8 10 4 6 (2)
14.  5  - 6 14 3 1 13 8 11 2 12 5 9 10 7 4 (68)
15.  5  - 9 13 3 1 15 4 10 2 14 11 6 8 12 5 7 (17)
16.  5  - 11 16 2 15 12 5 14 13 3 7 9 1 10 4 8 6 (9)
17.  5  - 14 15 9 13 17 1 6 4 16 5 2 12 11 3 10 8 7 (1)
18.  5  - 15 18 6 16 17 3 12 10 1 14 9 2 13 5 7 11 8 4 (1)
19.  6  - 16 10 18 1 4 19 6 8 17 3 15 13 2 9 14 12 11 7 5 (38)
20.  6  - 14 5 20 17 1 19 9 15 3 16 18 10 6 12 13 2 8 4 11 7 (8)
21.  6  - 12 19 3 21 20 6 7 16 18 1 14 9 2 17 13 5 15 4 8 10 11 (1)
22.  6  - 20 12 19 3 21 22 8 7 16 18 1 14 9 2 17 13 5 15 4 10 11 6 (1)
23.  7  - 22 4 23 14 16 1 21 18 19 9 2 15 20 3 10 7 13 5 17 6 8 12 11 (46)
24.  7  - 15 21 1 23 13 10 24 6 20 22 3 14 18 2 19 11 4 16 17 8 7 12 9 5 (14)
25.  8  - 19 23 2 22 9 1 25 7 4 21 20 13 8 24 18 3 17 5 16 6 15 14 12 11 10 (942)
26.  8  - 18 25 8 2 24 1 21 26 7 17 6 22 23 20 5 19 10 11 16 3 15 14 9 13 12 4 (254)
27.  8  - 27 1 25 20 6 22 18 3 26 24 5 14 16 4 15 23 2 19 9 12 11 8 21 17 10 13 7 (74)

The veeery elementary program I used. There aren't any optimizations, it's just for reference.

For the purpose of the challenge you don't have to output examples nor the count. k_n is sufficient

(It doesn't appear in OEIS).

Conjectures

• The sequence of \$k_n\$ is monotonically increasing
• \$k_{n+1}=k_{n}\lor k_{n+1}=k_{n}+1\$

Sandbox

• It's all clear and does it makes sense?
• Any suggestion for a "lighter" name of the process other than "self-distance completion"?